/*

* Copyright (c) 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:   Alf mapping functions

*

*/

#include "alf/alfmappingfunctions.h"

#include "alf/alfgencomponent.h"

#include "alf/alfconstants.h"

#include "alflogger.h"

#include <uiacceltk/HuiUtil.h>

#include <e32math.h>

#include <e32std.h>

// CONSTANT MAPPING FUNCTION

struct CAlfConstantMappingFunction::TPrivateData

    {

    CAlfGenComponent* iComms;

    TReal32 iValue;

    };

EXPORT_C CAlfConstantMappingFunction* CAlfConstantMappingFunction::NewL( 

        CAlfEnv& aEnv, 

        TReal32 aValue  ) __SOFTFP

    {

    CAlfConstantMappingFunction* self = new (ELeave) CAlfConstantMappingFunction;

    CleanupStack::PushL( self );

    self->ConstructL( aEnv, aValue );

    CleanupStack::Pop( self );

    return self;

    }

CAlfConstantMappingFunction::CAlfConstantMappingFunction()

    {

    }

void CAlfConstantMappingFunction::ConstructL( CAlfEnv& aEnv, TReal32 aValue )

    {

    iData = new (ELeave) TPrivateData;

    iData->iComms = NULL;

    TPckgC<TReal32> paramsPckg( aValue );    

    iData->iComms = CAlfGenComponent::NewL(aEnv,

            EAlfMappingFunctionConstantCreate, 

            0, 

            paramsPckg);

    iData->iValue = aValue;

    }

EXPORT_C CAlfConstantMappingFunction::~CAlfConstantMappingFunction()

    {

    if ( iData )

        {

        delete iData->iComms;

        iData->iComms = NULL;

        }

    delete iData;

    iData = NULL;

    }

TReal32 CAlfConstantMappingFunction::MapValue(TReal32 /*aValue*/, TInt /*aComponent*/) const __SOFTFP

    {

    return iData->iValue;

    }

TInt CAlfConstantMappingFunction::MappingFunctionIdentifier() const

    {

    return iData->iComms->Identifier();

    }

EXPORT_C void CAlfConstantMappingFunction::SetValue( TReal32 aValue ) __SOFTFP

    {

    TPckgC<TReal32> paramsPckg( aValue );

    TInt err = iData->iComms->DoCmdNoReply(

        EAlfConstantMappingFunctionSetValue, 

        paramsPckg );

    if ( err )

        {

        __ALFLOGSTRING1( "CAlfConstantMappingFunction::SetValue panic error %d", err )

        USER_INVARIANT();

        }

    iData->iValue = aValue;

    }

EXPORT_C TReal32 CAlfConstantMappingFunction::Value() const __SOFTFP

    {

    return iData->iValue;

    }

// LINEAR MAPPING FUNCTION

struct CAlfLinearMappingFunction::TPrivateData

    {

    CAlfGenComponent* iComms;

    TReal32 iFactor; 

    TReal32 iOffset;

    };

EXPORT_C CAlfLinearMappingFunction* CAlfLinearMappingFunction::NewL( 

        CAlfEnv& aEnv, 

        TReal32 aFactor,

        TReal32 aOffset) __SOFTFP

    {

    CAlfLinearMappingFunction* self = new (ELeave) CAlfLinearMappingFunction;

    CleanupStack::PushL( self );

    self->ConstructL( aEnv, aFactor, aOffset );

    CleanupStack::Pop( self );

    return self;

    }

CAlfLinearMappingFunction::CAlfLinearMappingFunction()

    {

    }

void CAlfLinearMappingFunction::ConstructL( CAlfEnv& aEnv, TReal32 aFactor, TReal32 aOffset )

    {

    iData = new (ELeave) TPrivateData;

    iData->iComms = NULL;

    TReal2 params( aFactor, aOffset );

    TPckgC<TReal2> paramsPckg( params );    

    iData->iComms = CAlfGenComponent::NewL(aEnv,

            EAlfMappingFunctionLinearCreate, 

            0, 

            paramsPckg);

    iData->iFactor = aFactor;

    iData->iOffset = aOffset;

    }

EXPORT_C CAlfLinearMappingFunction::~CAlfLinearMappingFunction()

    {

    if ( iData )

        {

        delete iData->iComms;

        iData->iComms = NULL;

        }

    delete iData;

    iData = NULL;

    }

TReal32 CAlfLinearMappingFunction::MapValue(TReal32 aValue, TInt /*aComponent*/) const __SOFTFP

    {

    return aValue * iData->iFactor + iData->iOffset;

    }

TInt CAlfLinearMappingFunction::MappingFunctionIdentifier() const

    {

    return iData->iComms->Identifier();

    }

EXPORT_C void CAlfLinearMappingFunction::SetFactor( TReal32 aFactor ) __SOFTFP

    {

    TPckgC<TReal32> paramsPckg( aFactor );

    TInt err = iData->iComms->DoCmdNoReply(

        EAlfLinearMappingFunctionSetFactor, 

        paramsPckg );

    if ( err )

        {

        __ALFLOGSTRING1( "CAlfLinearMappingFunction::SetFactor panic error %d", err )

        USER_INVARIANT();

        }

    iData->iFactor = aFactor;

    }

EXPORT_C TReal32 CAlfLinearMappingFunction::Factor() const __SOFTFP

    {

    return iData->iFactor;

    }

EXPORT_C void CAlfLinearMappingFunction::SetOffset( TReal32 aOffset ) __SOFTFP

    {

    TPckgC<TReal32> paramsPckg( aOffset );

    TInt err = iData->iComms->DoCmdNoReply(

        EAlfLinearMappingFunctionSetOffset, 

        paramsPckg );

    if ( err )

        {

        __ALFLOGSTRING1( "CAlfLinearMappingFunction::SetOffset panic error %d", err )

        USER_INVARIANT();

        }

    iData->iOffset = aOffset;

    }

EXPORT_C TReal32 CAlfLinearMappingFunction::Offset() const __SOFTFP

    {

    return iData->iOffset;

    }

// SINE MAPPING FUNCTION

struct CAlfSineMappingFunction::TPrivateData

    {

    CAlfGenComponent* iComms;

    TReal32 iFactor; 

    TReal32 iOffset;

    };

EXPORT_C CAlfSineMappingFunction* CAlfSineMappingFunction::NewL( 

        CAlfEnv& aEnv, 

        TReal32 aFactor,

        TReal32 aOffset) __SOFTFP

    {

    CAlfSineMappingFunction* self = new (ELeave) CAlfSineMappingFunction;

    CleanupStack::PushL( self );

    self->ConstructL( aEnv, aFactor,aOffset );

    CleanupStack::Pop( self );

    return self;

    }

CAlfSineMappingFunction::CAlfSineMappingFunction()

    {

    }

void CAlfSineMappingFunction::ConstructL( CAlfEnv& aEnv, TReal32 aFactor, TReal32 aOffset )

    {

    iData = new (ELeave) TPrivateData;

    iData->iComms = NULL;

    TReal2 params( aFactor, aOffset );

    TPckgC<TReal2> paramsPckg( params );    

    iData->iComms = CAlfGenComponent::NewL(aEnv,

            EAlfMappingFunctionSineCreate, 

            0, 

            paramsPckg);

    iData->iFactor = aFactor;

    iData->iOffset = aOffset;

    }

EXPORT_C CAlfSineMappingFunction::~CAlfSineMappingFunction()

    {

    if ( iData )

        {

        delete iData->iComms;

        iData->iComms = NULL;

        }

    delete iData;

    iData = NULL;

    }

TReal32 CAlfSineMappingFunction::MapValue(TReal32 aValue, TInt /*aComponent*/) const __SOFTFP

    {

    TReal mapped = 0;

    Math::Sin(mapped, aValue);

    return mapped * iData->iFactor + iData->iOffset;

    }

TInt CAlfSineMappingFunction::MappingFunctionIdentifier() const

    {

    return iData->iComms->Identifier();

    }

EXPORT_C void CAlfSineMappingFunction::SetFactor( TReal32 aFactor ) __SOFTFP

    {

    TPckgC<TReal32> paramsPckg( aFactor );

    TInt err = iData->iComms->DoCmdNoReply(

        EAlfSineMappingFunctionSetFactor, 

        paramsPckg );

    if ( err )

        {

        __ALFLOGSTRING1( "CAlfSineMappingFunction::SetFactor panic error %d", err )

        USER_INVARIANT();

        }

    iData->iFactor = aFactor;

    }

EXPORT_C TReal32 CAlfSineMappingFunction::Factor() const __SOFTFP

    {

    return iData->iFactor;

    }

EXPORT_C void CAlfSineMappingFunction::SetOffset( TReal32 aOffset ) __SOFTFP

    {

    TPckgC<TReal32> paramsPckg( aOffset );

    TInt err = iData->iComms->DoCmdNoReply(

        EAlfSineMappingFunctionSetOffset, 

        paramsPckg );

    if ( err )

        {

        __ALFLOGSTRING1( "CAlfSineMappingFunction::SetOffset panic error %d", err )

        USER_INVARIANT();

        }

    iData->iOffset = aOffset;

    }

EXPORT_C TReal32 CAlfSineMappingFunction::Offset() const __SOFTFP

    {

    return iData->iOffset;

    }

// COSINE MAPPING FUNCTION

struct CAlfCosineMappingFunction::TPrivateData

    {

    CAlfGenComponent* iComms;

    TReal32 iFactor; 

    TReal32 iOffset;

    };

EXPORT_C CAlfCosineMappingFunction* CAlfCosineMappingFunction::NewL( 

        CAlfEnv& aEnv, 

        TReal32 aFactor,

        TReal32 aOffset) __SOFTFP

    {

    CAlfCosineMappingFunction* self = new (ELeave) CAlfCosineMappingFunction;

    CleanupStack::PushL( self );

    self->ConstructL( aEnv, aFactor,aOffset );

    CleanupStack::Pop( self );

    return self;

    }

CAlfCosineMappingFunction::CAlfCosineMappingFunction()

    {

    }

void CAlfCosineMappingFunction::ConstructL( CAlfEnv& aEnv, TReal32 aFactor, TReal32 aOffset )

    {

    iData = new (ELeave) TPrivateData;

    iData->iComms = NULL;

    TReal2 params( aFactor, aOffset );

    TPckgC<TReal2> paramsPckg( params );    

    iData->iComms = CAlfGenComponent::NewL(aEnv,

            EAlfMappingFunctionCosineCreate, 

            0, 

            paramsPckg);

    iData->iFactor = aFactor;

    iData->iOffset = aOffset;

    }

EXPORT_C CAlfCosineMappingFunction::~CAlfCosineMappingFunction()

    {

    if ( iData )

        {

        delete iData->iComms;

        iData->iComms = NULL;

        }

    delete iData;

    iData = NULL;

    }

TReal32 CAlfCosineMappingFunction::MapValue(TReal32 aValue, TInt /*aComponent*/) const __SOFTFP

    {

    TReal mapped = 0;

    Math::Cos(mapped, aValue);

    return mapped * iData->iFactor + iData->iOffset;

    }

TInt CAlfCosineMappingFunction::MappingFunctionIdentifier() const

    {

    return iData->iComms->Identifier();

    }

EXPORT_C void CAlfCosineMappingFunction::SetFactor( TReal32 aFactor ) __SOFTFP

    {

    TPckgC<TReal32> paramsPckg( aFactor );

    TInt err = iData->iComms->DoCmdNoReply(

        EAlfCosineMappingFunctionSetFactor, 

        paramsPckg );

    if ( err )

        {

        __ALFLOGSTRING1( "CAlfCosineMappingFunction::SetFactor panic error %d", err )

        USER_INVARIANT();

        }

    iData->iFactor = aFactor;

    }

EXPORT_C TReal32 CAlfCosineMappingFunction::Factor() const __SOFTFP

    {

    return iData->iFactor;

    }

EXPORT_C void CAlfCosineMappingFunction::SetOffset( TReal32 aOffset ) __SOFTFP

    {

    TPckgC<TReal32> paramsPckg( aOffset );

    TInt err = iData->iComms->DoCmdNoReply(

        EAlfCosineMappingFunctionSetOffset, 

        paramsPckg );

    if ( err )

        {

        __ALFLOGSTRING1( "CAlfCosineMappingFunction::SetOffset panic error %d", err )

        USER_INVARIANT();

        }

    iData->iOffset = aOffset;

    }

EXPORT_C TReal32 CAlfCosineMappingFunction::Offset() const __SOFTFP

    {

    return iData->iOffset;

    }

// AVERAGE MAPPING FUNCTION

struct CAlfAverageMappingFunction::TPrivateData

    {

    CAlfGenComponent* iComms;

    };

EXPORT_C CAlfAverageMappingFunction* CAlfAverageMappingFunction::NewL( 

        CAlfEnv& aEnv,

        MAlfMappingFunction* aFunc1, 

        MAlfMappingFunction* aFunc2 )

    {

    CAlfAverageMappingFunction* self = new (ELeave)CAlfAverageMappingFunction();

    CleanupStack::PushL( self );

    self->ConstructL( aEnv, aFunc1, aFunc2 );

    CleanupStack::Pop( self );

    return self;

    }

CAlfAverageMappingFunction::CAlfAverageMappingFunction()

    {

    }

void CAlfAverageMappingFunction::ConstructL( 

        CAlfEnv& aEnv,

        MAlfMappingFunction* aFunc1, 

        MAlfMappingFunction* aFunc2

        )

    {

    iData = new (ELeave) TPrivateData;

    iData->iComms = NULL;

    TInt2 functions( 

        aFunc1 ? aFunc1->MappingFunctionIdentifier() : 0,

        aFunc2 ? aFunc2->MappingFunctionIdentifier() : 0 );

    TPckgC<TInt2> functionsPckg( functions );    

    iData->iComms = CAlfGenComponent::NewL(aEnv,

            EAlfMappingFunctionAverageCreate, 

            0, 

            functionsPckg);

    }

EXPORT_C CAlfAverageMappingFunction::~CAlfAverageMappingFunction()

    {

    if ( iData )

        {

        delete iData->iComms;

        iData->iComms = NULL;

        }

    delete iData;

    iData = NULL;

    }

TReal32 CAlfAverageMappingFunction::MapValue(TReal32 aValue, TInt aComponent) const __SOFTFP

    {

    TIntTReal mapValues( aComponent, aValue );

    TPckgC<TIntTReal> mapValuesPckg( mapValues );

    TReal32 returnValue = aValue;

    TPckg<TReal32> returnBuf(returnValue);

    TInt err = iData->iComms->DoSynchronousCmd(

        EAlfMappingFunctionMapValue, 

        mapValuesPckg, 

        returnBuf );

    if ( err )

        {

        __ALFLOGSTRING1( "CAlfAverageMappingFunction::MapValue panic error %d", err )

        USER_INVARIANT();

        }

    return returnValue;

    }

TInt CAlfAverageMappingFunction::MappingFunctionIdentifier() const

    {

    return iData->iComms->Identifier();

    }

EXPORT_C void CAlfAverageMappingFunction::SetMappingFunction1( MAlfMappingFunction* aFunction1 )

    {

    TInt function = aFunction1 ? aFunction1->MappingFunctionIdentifier() : 0;