/*

* Copyright (c) 2006 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:   Transformation sub session

*

*/

#include "alfsrvtransformationsubsession.h"

#include "alf/alfconstants.h"

#include "alf/alfappsrvsessionbase.h"

#include "alfappsrvsession.h"

#include "alf/alfserverutils.h"

#include <uiacceltk/HuiEnv.h>

#include <uiacceltk/HuiTransformation.h>

#include <uiacceltk/HuiUtil.h>

#include <alf/alftransformation.h>

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

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

// Constructor

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

//

CAlfSrvTransformationSubSession::CAlfSrvTransformationSubSession( 

    CAlfAppSrvSessionBase& aSession )

    : CAlfSrvSubSessionBase( aSession )

    {

    }

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

// 2nd phasse constructor

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

//

void CAlfSrvTransformationSubSession::ConstructL()

    {

    CAlfSrvSubSessionBase::ConstructL();

    }

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

// NewL

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

//

CAlfSrvTransformationSubSession* CAlfSrvTransformationSubSession::NewL( 

    CAlfAppSrvSessionBase& aSession )

    {

    CAlfSrvTransformationSubSession* self = 

        CAlfSrvTransformationSubSession::NewLC( aSession );

    CleanupStack::Pop( self );

    return self;

    }

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

// NewLC

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

//

CAlfSrvTransformationSubSession* CAlfSrvTransformationSubSession::NewLC( 

    CAlfAppSrvSessionBase& aSession )

    {

    CAlfSrvTransformationSubSession* self = 

        new( ELeave ) CAlfSrvTransformationSubSession( aSession );

    CleanupClosePushL( *self );

    self->ConstructL();

    return self;

    }

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

// Destructor

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

//

CAlfSrvTransformationSubSession::~CAlfSrvTransformationSubSession()

    {

    iTransformation= NULL;

    }

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

// Gets transformation

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

//

CHuiTransformation& CAlfSrvTransformationSubSession::Transformation()

    {

    __ASSERT_ALWAYS( iTransformation, USER_INVARIANT() );

    return *iTransformation;

    }

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

// Sets transformation

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

//

void CAlfSrvTransformationSubSession::SetTransformation( 

    CHuiTransformation* aTransformation )

    {

    iTransformation = aTransformation;

    }

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

// Reset matrix

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

// 

void CAlfSrvTransformationSubSession::LoadIdentityL(const RMessage2& aMessage)

    {

    // Load identity

    Transformation().LoadIdentity();

    // Complete

    aMessage.Complete( KErrNone );

    }

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

// Translate

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

//

void CAlfSrvTransformationSubSession::TranslateL(const RMessage2& aMessage)

    {

    // Parser parameters

    // 1: x (in)

    TReal32 x(0.0);

    TPckg<TReal32> xRealPckg(x);

    aMessage.Read(1,xRealPckg);

    // 2: y (in)

    TReal32 y(0.0);

    TPckg<TReal32> yRealPckg(y);

    aMessage.Read(2,yRealPckg);

    // Translate

    Transformation().Translate( x, y );

    // Complete

    aMessage.Complete( KErrNone );

    }

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

// Rotate

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

//  

void CAlfSrvTransformationSubSession::RotateL(const RMessage2& aMessage)

    {

    // Parser parameters

    // 1: angle (in)

    TAlfTimedValue alf_angle;

    TPckg<TAlfTimedValue> anglePckg(alf_angle);

    aMessage.Read(1,anglePckg);

    THuiTimedValue angle;

    AlfTimedValueUtility::CopyTimedValue(alf_angle, angle, Session());    

    // Rotate

    Transformation().Rotate( angle );

    // Complete

    aMessage.Complete( KErrNone );

    }

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

// Count

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

//  

void CAlfSrvTransformationSubSession::CountL(const RMessage2& aMessage)

    {

    TInt count = 0;

    TPckg<TInt> outputPckg(count);    

    // Count

    count = Transformation().Count();

    // Write output params

    aMessage.Write(1,outputPckg);    

    // Complete

    aMessage.Complete( KErrNone );

    }

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

// NonIdentityCount

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

//  

void CAlfSrvTransformationSubSession::NonIdentityCountL(const RMessage2& aMessage)

    {

    TInt count = 0;

    TPckg<TInt> outputPckg(count);    

    // Count

    count = Transformation().NonIdentityCount();

    // Write output params

    aMessage.Write(1,outputPckg);    

    // Complete

    aMessage.Complete( KErrNone );

    }

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

// Step

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

//  

void CAlfSrvTransformationSubSession::StepL(const RMessage2& aMessage)

    {

    // 1: Index (in) 

    TInt index = aMessage.Int1();

    // 2: Transform step (out)

    CAlfTransformation::TTransform step;

    TPckg<CAlfTransformation::TTransform> outputPckg(step);    

    // Step

    CHuiTransformation::TTransform huiStep = Transformation().Step(index);

    step.iType = (CAlfTransformation::TType)huiStep.iType;

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

        {

        AlfTimedValueUtility::CopyTimedValue(huiStep.iParams[i], step.iParams[i]);    

        step.iParams[i].Flags() = EAlfValueFlagsNone; // clear flags so client will send only changed values back         

        }

    // Write output params

    aMessage.Write(2,outputPckg);    

    // Complete

    aMessage.Complete( KErrNone );

    }

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

// ReplaceStep

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

//  

void CAlfSrvTransformationSubSession::ReplaceStepL(const RMessage2& aMessage)

    {

    // 1: Index (in) 

    TInt index = aMessage.Int1();

    // 2: Transform step (in)

    CAlfTransformation::TTransform step;

    TPckg<CAlfTransformation::TTransform> stepPckg(step);    

    aMessage.Read(2,stepPckg);               

    // ReplaceStep

    CHuiTransformation::TTransform& huiStep = Transformation().Step(index); 

    huiStep.iType = (CHuiTransformation::TType)step.iType;

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

        {

        AlfTimedValueUtility::CopyTimedValue(step.iParams[i], huiStep.iParams[i], Session());    

        }    

    // Complete

    aMessage.Complete( KErrNone );

    }

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

// Rotate (3D version of the function)

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

//  

void CAlfSrvTransformationSubSession::Rotate3DL(const RMessage2& aMessage)

    {

    // Parse parameters

    // 1: params (in)

    TAlfTransformationRotateParams params;

    TPckg<TAlfTransformationRotateParams> paramPckg(params);

    aMessage.Read(1,paramPckg);

    THuiTimedValue angle;

    AlfTimedValueUtility::CopyTimedValue(params.iAngle, angle, Session());    

    // Rotate

    Transformation().Rotate( angle, params.iAxisX, params.iAxisY, params.iAxisZ );

    // Complete

    aMessage.Complete( KErrNone );

    }

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

// Scale (3D version of the function)

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

//  

void CAlfSrvTransformationSubSession::Scale3DL(const RMessage2& aMessage)

    {

    // Parse parameters

    // 1: params (in)

    TAlfTransformationTimedParams params;

    TPckg<TAlfTransformationTimedParams> paramPckg(params);

    aMessage.Read(1,paramPckg);

    THuiTimedValue x;

    AlfTimedValueUtility::CopyTimedValue(params.iX, x, Session());    

    THuiTimedValue y;

    AlfTimedValueUtility::CopyTimedValue(params.iY, y, Session());    

    THuiTimedValue z;

    AlfTimedValueUtility::CopyTimedValue(params.iZ, z, Session());    

    // Rotate

    Transformation().Scale( x,y,z );

    // Complete

    aMessage.Complete( KErrNone );

    }

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

// Translate  (2D version of the function with timedvalues)

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

//  

void CAlfSrvTransformationSubSession::Translate2DL(const RMessage2& aMessage)

    {

    // Parse parameters

    // 1: params (in)

    TAlfTransformationTimedParams params;

    TPckg<TAlfTransformationTimedParams> paramPckg(params);

    aMessage.Read(1,paramPckg);

    THuiTimedValue x;

    AlfTimedValueUtility::CopyTimedValue(params.iX, x, Session());    

    THuiTimedValue y;

    AlfTimedValueUtility::CopyTimedValue(params.iY, y, Session());    

    // Rotate

    Transformation().Translate( x,y );

    // Complete

    aMessage.Complete( KErrNone );

    }

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

// From CAlfSrvSubSessionBase

// Process the message.

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

// 

void CAlfSrvTransformationSubSession::DoProcessMessageL(const RMessage2& aMessage)

    {

    switch( aMessage.Int0() )

        {

        case EAlfTransformationLoadIdentity:

            {

            LoadIdentityL( aMessage );

            break;

            }

        case EAlfTransformationTranslate:

            {

            TranslateL( aMessage );

            break;

            }

        case EAlfTransformationRotate:

            {

            RotateL( aMessage );

            break;

            }

        case EAlfTransformationCount:

            {

            CountL( aMessage );                

            break;

            }

        case EAlfTransformationNonIdentityCount:

            {

            NonIdentityCountL( aMessage );     

            break;

            }

        case EAlfTransformationStep:

            {

            StepL( aMessage );                

            break;

            }

        case EAlfTransformationReplaceStep:

            {

            ReplaceStepL( aMessage );                                

            break;

            }

        case EAlfTransformationRotate3D:

            {

            Rotate3DL( aMessage );                                                

            break;

            }

        case EAlfTransformationTranslate2D:

            {

            Translate2DL( aMessage );                                                                

            break;

            }

        case EAlfTransformationScale:

            {

            Scale3DL( aMessage );                                                                                

            break;

            }

        case EAlfTransformationSubSessionClose: // obsolete

            {

            Session().CloseSubSession( aMessage );

            break;

            }            

        default:

            CAlfSrvSubSessionBase::DoProcessMessageL( aMessage );

            break;

        }

    }