/*

* 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:   Mapping function handlers

*

*/

#include "alfmappingfunctionhandlers.h"

#include "alf/alfconstants.h"

#include "alf/alfserverutils.h"

#include <uiacceltk/HuiCurvePath.h>

// CONSTANT MAPPING FUNCTION

TAlfConstantMappingFunctionHandler::TAlfConstantMappingFunctionHandler( 

        MAlfInterfaceProvider& aResolver,

        TReal32 aValue )

        : iConstantMappingFunction( aValue ) , iResolver(aResolver)

    {

    }

void TAlfConstantMappingFunctionHandler::Release()

    {

    delete this;

    }

TAny* TAlfConstantMappingFunctionHandler::GetInterface(

    const THuiInterfaceSupport& aInterface)

    {

    switch ( aInterface )

        {

        case EHuiInterfaceMappingFunction:

            return &iConstantMappingFunction;

        default:

            return NULL;

        }

    }

void TAlfConstantMappingFunctionHandler::HandleCmdL(

    TInt aCommandId, 

    const TDesC8& aInputBuffer, 

    TDes8& /*aResponse*/ )

    {

    switch ( aCommandId )

        {

        case EAlfConstantMappingFunctionSetValue:

            {

            TReal32* mapValues = (TReal32*) aInputBuffer.Ptr();

            iConstantMappingFunction.iValue = *mapValues;

            break;

            }

        default:

            User::Leave( KErrNotSupported );

        }

    }

// LINEAR MAPPING FUNCTION

TAlfLinearMappingFunctionHandler::TAlfLinearMappingFunctionHandler( 

        MAlfInterfaceProvider& aResolver,

        TReal32 aFactor,

        TReal32 aOffset )

        : iLinearMappingFunction( aFactor,aOffset ) , iResolver(aResolver)

    {

    }

void TAlfLinearMappingFunctionHandler::Release()

    {

    delete this;

    }

TAny* TAlfLinearMappingFunctionHandler::GetInterface(

    const THuiInterfaceSupport& aInterface)

    {

    switch ( aInterface )

        {

        case EHuiInterfaceMappingFunction:

            return &iLinearMappingFunction;

        default:

            return NULL;

        }

    }

void TAlfLinearMappingFunctionHandler::HandleCmdL(

    TInt aCommandId, 

    const TDesC8& aInputBuffer, 

    TDes8& /*aResponse*/ )

    {

    switch ( aCommandId )

        {

        case EAlfLinearMappingFunctionSetFactor:

            {

            TReal32* mapValues = (TReal32*) aInputBuffer.Ptr();

            iLinearMappingFunction.iFactor = *mapValues;

            break;

            }

        case EAlfLinearMappingFunctionSetOffset:

            {

            TReal32* mapValues = (TReal32*) aInputBuffer.Ptr();

            iLinearMappingFunction.iOffset = *mapValues;

            break;

            }

        default:

            User::Leave( KErrNotSupported );

        }

    }

// SINE MAPPING FUNCTION

TAlfSineMappingFunctionHandler::TAlfSineMappingFunctionHandler( 

        MAlfInterfaceProvider& aResolver,

        TReal32 aFactor,

        TReal32 aOffset )

        : iSineMappingFunction( aFactor,aOffset ) , iResolver(aResolver)

    {

    }

void TAlfSineMappingFunctionHandler::Release()

    {

    delete this;

    }

TAny* TAlfSineMappingFunctionHandler::GetInterface(

    const THuiInterfaceSupport& aInterface)

    {

    switch ( aInterface )

        {

        case EHuiInterfaceMappingFunction:

            return &iSineMappingFunction;

        default:

            return NULL;

        }

    }

void TAlfSineMappingFunctionHandler::HandleCmdL(

    TInt aCommandId, 

    const TDesC8& aInputBuffer, 

    TDes8& /*aResponse*/ )

    {

    switch ( aCommandId )

        {

        case EAlfSineMappingFunctionSetFactor:

            {

            TReal32* mapValues = (TReal32*) aInputBuffer.Ptr();

            iSineMappingFunction.iFactor = *mapValues;

            break;

            }

        case EAlfSineMappingFunctionSetOffset:

            {

            TReal32* mapValues = (TReal32*) aInputBuffer.Ptr();

            iSineMappingFunction.iOffset = *mapValues;

            break;

            }

        default:

            User::Leave( KErrNotSupported );

        }

    }

// COSINE MAPPING FUNCTION

TAlfCosineMappingFunctionHandler::TAlfCosineMappingFunctionHandler( 

        MAlfInterfaceProvider& aResolver,

        TReal32 aFactor,

        TReal32 aOffset )

        : iCosineMappingFunction( aFactor,aOffset ) , iResolver(aResolver)

    {

    }

void TAlfCosineMappingFunctionHandler::Release()

    {

    delete this;

    }

TAny* TAlfCosineMappingFunctionHandler::GetInterface(

    const THuiInterfaceSupport& aInterface)

    {

    switch ( aInterface )

        {

        case EHuiInterfaceMappingFunction:

            return &iCosineMappingFunction;

        default:

            return NULL;

        }

    }

void TAlfCosineMappingFunctionHandler::HandleCmdL(

    TInt aCommandId, 

    const TDesC8& aInputBuffer, 

    TDes8& /*aResponse*/ )

    {

    switch ( aCommandId )

        {

        case EAlfCosineMappingFunctionSetFactor:

            {

            TReal32* mapValues = (TReal32*) aInputBuffer.Ptr();

            iCosineMappingFunction.iFactor = *mapValues;

            break;

            }

        case EAlfCosineMappingFunctionSetOffset:

            {

            TReal32* mapValues = (TReal32*) aInputBuffer.Ptr();

            iCosineMappingFunction.iOffset = *mapValues;

            break;

            }

        default:

            User::Leave( KErrNotSupported );

        }

    }

// AVERAGE MAPPING FUNCTION

TAlfAverageMappingFunctionHandler::TAlfAverageMappingFunctionHandler( 

        MAlfInterfaceProvider& aResolver,

        MHuiMappingFunction* aFunc1, 

        MHuiMappingFunction* aFunc2 )

        : iAverageMappingFunction( aFunc1, aFunc2 ) , iResolver(aResolver)

    {

    }

void TAlfAverageMappingFunctionHandler::Release()

    {

    delete this;

    }

TAny* TAlfAverageMappingFunctionHandler::GetInterface(

    const THuiInterfaceSupport& aInterface)

    {

    switch ( aInterface )

        {

        case EHuiInterfaceMappingFunction:

            return &iAverageMappingFunction;

        default:

            return NULL;

        }

    }

void TAlfAverageMappingFunctionHandler::HandleCmdL(

    TInt aCommandId, 

    const TDesC8& aInputBuffer, 

    TDes8& aResponse )

    {

    switch ( aCommandId )

        {

        case EAlfMappingFunctionMapValue:

            {

            TIntTReal* mapValues = (TIntTReal*) aInputBuffer.Ptr();

            const TReal32 returnValue = iAverageMappingFunction.MapValue( mapValues->iReal, mapValues->iInt );

            TPckg<TReal32> returnValuePckg(returnValue);

            aResponse = returnValuePckg; 

            break;

            }

        case EAlfAverageMappingFunctionSetFunction1:

            {

            TInt* params = (TInt*)aInputBuffer.Ptr();

            MHuiMappingFunction* func1 = NULL;

            if ( *params )

                {

                func1 = (MHuiMappingFunction*) iResolver.GetInterfaceL(EHuiInterfaceMappingFunction, *params );

                }

            iAverageMappingFunction.iFunc1 = func1;

            break;

            }

        case EAlfAverageMappingFunctionSetFunction2:

            {

            TInt* params = (TInt*)aInputBuffer.Ptr();

            MHuiMappingFunction* func2 = NULL;

            if ( *params )

                {

                func2 = (MHuiMappingFunction*) iResolver.GetInterfaceL(EHuiInterfaceMappingFunction, *params );

                }

            iAverageMappingFunction.iFunc2 = func2;

            break;

            }

        case EAlfAverageMappingFunctionSetFunctions:

            {

            TInt2* params = (TInt2*) aInputBuffer.Ptr();

            MHuiMappingFunction* func1 = NULL;

            MHuiMappingFunction* func2 = NULL;

            if ( params->iInt1 )

                {

                func1 = (MHuiMappingFunction*) iResolver.GetInterfaceL(EHuiInterfaceMappingFunction, params->iInt1 );

                }

            if ( params->iInt2 )

                {

                func2 = (MHuiMappingFunction*) iResolver.GetInterfaceL(EHuiInterfaceMappingFunction, params->iInt2 );

                }

            iAverageMappingFunction.iFunc1 = func1;

            iAverageMappingFunction.iFunc2 = func2; 

            break;

            }

        case EAlfAverageMappingFunctionSetWeight:

            {

            TAlfTimedValue* opacity = (TAlfTimedValue*) aInputBuffer.Ptr() ;

            AlfTimedValueUtility::CopyTimedValue(*opacity, iAverageMappingFunction.iWeight, iResolver);    

            break;

            }

        default:

            User::Leave( KErrNotSupported );

        }

    }

// CURVE PATH

CAlfCurvePathHandler* CAlfCurvePathHandler::NewL( 

    MAlfInterfaceProvider& aResolver,

    CHuiCurvePath* aCurvePath )

    {

    CAlfCurvePathHandler* self = new (ELeave) CAlfCurvePathHandler( aResolver );

    CleanupStack::PushL( self );

    self->ConstructL( aCurvePath );

    CleanupStack::Pop( self );

    return self;

    }

CAlfCurvePathHandler::CAlfCurvePathHandler( MAlfInterfaceProvider& aResolver )

 : iResolver( aResolver )

    {

    }

void CAlfCurvePathHandler::ConstructL(CHuiCurvePath* aCurvePath)

    {

    if ( aCurvePath )

        {

        iCurvePath = aCurvePath;

        iOwnCurvePath = EFalse;

        }

    else

        {

        iCurvePath = CHuiCurvePath::NewL();

        iOwnCurvePath = ETrue;

        }

    }

CAlfCurvePathHandler::~CAlfCurvePathHandler()

    {

    if ( iOwnCurvePath )

        {

        delete iCurvePath;

        }

    iCurvePath = NULL;

    }

void CAlfCurvePathHandler::Release()

    {

    delete this;

    }

TAny* CAlfCurvePathHandler::GetInterface(const THuiInterfaceSupport& aInterface)

    {

    switch ( aInterface )

        {

        case EHuiInterfaceMappingFunction:

            return static_cast<MHuiMappingFunction*>(iCurvePath);

        default:

            return NULL;

        }

    }

void CAlfCurvePathHandler::HandleCmdL(TInt aCommandId, const TDesC8& aInputBuffer, TDes8& aResponse)

    {

    switch( aCommandId )

        {

        case EAlfCurvePathReset:

            {

            iCurvePath->Reset();

            break;

            }

        case EAlfCurvePathEnableLoop:

            {

            TBool* params = (TBool*) aInputBuffer.Ptr();

            iCurvePath->EnableLoop( *params );

            break;

            }

        case EAlfCurvePathLoop:

            {

            const TBool returnValue = iCurvePath->Loop();

            TPckg<TBool> returnValuePckg(returnValue);

            aResponse = returnValuePckg; 

            break;

            }

        case EAlfCurvePathSetOrigin:

            {

            TReal32* params = (TReal32*) aInputBuffer.Ptr();

            iCurvePath->SetOrigin( *params );

            break;

            }

        case EAlfCurvePathAppendLine:

            {

            TAlfCurvePathLineParams* params = (TAlfCurvePathLineParams*) aInputBuffer.Ptr();

            iCurvePath->AppendLineL( 

                params->iStart,

                params->iEnd,

                params->iLength );

            break;

            }

        case EAlfCurvePathAppendLine2:

            {

            TAlfCurvePathLineRealParams* params = (TAlfCurvePathLineRealParams*) aInputBuffer.Ptr();

            THuiRealPoint start(params->iStart.iX, params->iStart.iY);

            THuiRealPoint end(params->iEnd.iX, params->iEnd.iY);

            iCurvePath->AppendLineL( 

                start,

                end,

                params->iLength );

            break;

            }

        case EAlfCurvePathAppendArc:

            {

            TAlfCurvePathArcParams* params = (TAlfCurvePathArcParams*) aInputBuffer.Ptr();

            iCurvePath->AppendArcL( 

                params->iOrigin,

                params->iSize,

                params->iStartAngle,

                params->iEndAngle,

                params->iLength );

            break;

            }

        case EAlfCurvePathAppendArc2:

            {

            TAlfCurvePathArcRealParams* params = (TAlfCurvePathArcRealParams*) aInputBuffer.Ptr();

            THuiRealPoint origin(params->iOrigin.iX, params->iOrigin.iY);

            THuiRealSize size2(params->iSize.iWidth, params->iSize.iHeight);

            iCurvePath->AppendArcL( 

                origin,

                size2,

                params->iStartAngle,

                params->iEndAngle,

                params->iLength );

            break;

            }

        case EAlfCurvePathLength:

            {

            const TReal32 returnValue = iCurvePath->Length();

            TPckg<TReal32> returnValuePckg(returnValue);

            aResponse = returnValuePckg; 

            break;

            }

        case EAlfCurvePathEvaluate:

            {

            TReal32* params = (TReal32*) aInputBuffer.Ptr();

            THuiRealPoint result;

            iCurvePath->Evaluate( *params, result );

            TAlfRealPoint returnValue(result.iX, result.iY);

            TPckg<TAlfRealPoint> returnValuePckg(returnValue);

            aResponse = returnValuePckg; 

            break;

            }

        case EAlfCurvePathOffset:

            {

            TAlfTimedPoint returnValue;

            AlfTimedPointUtility::CopyTimedPoint(iCurvePath->iOffset, returnValue);

            TPckg<TAlfTimedPoint> returnValuePckg(returnValue);

            aResponse = returnValuePckg;

            break;

            }

        case EAlfCurvePathSetOffset:

            {

            TAlfTimedPoint* params = (TAlfTimedPoint*) aInputBuffer.Ptr();

            AlfTimedPointUtility::CopyTimedPoint(*params, iCurvePath->iOffset, iResolver);    

            break;

            }

        case EAlfCurvePathMapValue:

            {

            TIntTReal* mapValues = (TIntTReal*) aInputBuffer.Ptr();

            const TReal32 returnValue = iCurvePath->MapValue( mapValues->iReal, mapValues->iInt );

            TPckg<TReal32> returnValuePckg(returnValue);

            aResponse = returnValuePckg; 

            break;

            }

        default:

            User::Leave( KErrNotSupported );