--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uiacceltk/hitchcock/Client/src/alfmappingfunctions.cpp Tue Feb 02 07:56:43 2010 +0200
@@ -0,0 +1,733 @@
+/*
+* 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;
+ TPckgC<TInt> functionPckg( function );
+
+ TInt err = iData->iComms->DoCmdNoReply(
+ EAlfAverageMappingFunctionSetFunction1,
+ functionPckg );
+
+ if ( err )
+ {
+ __ALFLOGSTRING1( "CAlfAverageMappingFunction::SetMappingFunction1 panic error %d", err )
+ USER_INVARIANT();
+ }
+ }
+
+EXPORT_C void CAlfAverageMappingFunction::SetMappingFunction2( MAlfMappingFunction* aFunction2 )
+ {
+ TInt function = aFunction2 ? aFunction2->MappingFunctionIdentifier() : 0;
+ TPckgC<TInt> functionPckg( function );
+ TBuf8<1> outDum;
+
+ TInt err = iData->iComms->DoCmdNoReply(
+ EAlfAverageMappingFunctionSetFunction2,
+ functionPckg );
+
+ if ( err )
+ {
+ __ALFLOGSTRING1( "CAlfAverageMappingFunction::SetMappingFunction2 panic error %d", err )
+ USER_INVARIANT();
+ }
+ }
+
+EXPORT_C void CAlfAverageMappingFunction::SetMappingFunctions(
+ MAlfMappingFunction* aFunction1,
+ MAlfMappingFunction* aFunction2 )
+ {
+ TInt2 functions(
+ aFunction1 ? aFunction1->MappingFunctionIdentifier() : 0,
+ aFunction2 ? aFunction2->MappingFunctionIdentifier() : 0 );
+ TPckgC<TInt2> functionsPckg( functions );
+ TBuf8<1> outDum;
+
+ TInt err = iData->iComms->DoCmdNoReply(
+ EAlfAverageMappingFunctionSetFunctions,
+ functionsPckg );
+
+ if ( err )
+ {
+ __ALFLOGSTRING1( "CAlfAverageMappingFunction::SetMappingFunctions panic error %d", err )
+ USER_INVARIANT();
+ }
+ }
+
+EXPORT_C void CAlfAverageMappingFunction::SetWeight(
+ const TAlfTimedValue& aWeight )
+ {
+ TPckgC<TAlfTimedValue> buf(aWeight);
+
+ TInt err = iData->iComms->DoCmdNoReply(
+ EAlfAverageMappingFunctionSetWeight,
+ buf);
+
+ if ( err )
+ {
+ __ALFLOGSTRING1( "CAlfAverageMappingFunction::SetWeight panic error %d", err )
+ USER_INVARIANT();
+ }
+ }
+struct CAlfTableMappingFunction::TPrivateData
+ {
+ CAlfGenComponent* iComms;
+ TAlfTableMappingFunctionParams iParams;
+ MAlfTableMappingFunctionDataProvider* iLastFunction;
+ TReal32 iLastStart;
+ TReal32 iLastEnd;
+ };
+
+
+
+EXPORT_C CAlfTableMappingFunction* CAlfTableMappingFunction::NewL(
+ CAlfEnv& aEnv)
+ {
+ CAlfTableMappingFunction* self = new (ELeave)CAlfTableMappingFunction();
+ CleanupStack::PushL( self );
+ self->ConstructL( aEnv );
+ CleanupStack::Pop( self );
+ return self;
+ }
+
+CAlfTableMappingFunction::CAlfTableMappingFunction()
+ {
+ }
+
+void CAlfTableMappingFunction::ConstructL(CAlfEnv& aEnv)
+ {
+ iData = new (ELeave) TPrivateData;
+
+ iData->iComms = NULL;
+ Mem::FillZ(&iData->iParams, sizeof(iData->iParams));
+ iData->iLastStart = 0;
+ iData->iLastEnd = 0;
+ iData->iLastFunction = NULL;
+
+ TReal2 param(0.f, 0.f);
+ TPckgC<TReal2> paramPckg( param );
+ iData->iComms = CAlfGenComponent::NewL(aEnv,
+ EAlfMappingFunctionTableCreate,
+ 0,
+ paramPckg);
+ }
+
+EXPORT_C CAlfTableMappingFunction::~CAlfTableMappingFunction()
+ {
+ if ( iData )
+ {
+ delete iData->iComms;
+ iData->iComms = NULL;
+ }
+ delete iData;
+ iData = NULL;
+ }
+
+TReal32 CAlfTableMappingFunction::MapValue(TReal32 aValue, TInt /*aComponent*/) const __SOFTFP
+ {
+ // For performance resons, this same function exist both client and serverside
+ TReal32 retVal = aValue;
+
+ TBool inverted = EFalse;
+
+ if (iData->iParams.iValues[KAlfTableMappingNumberOfMappedValues - 1] < iData->iParams.iValues[0])
+ {
+ inverted = ETrue;
+ }
+
+ TInt i = 0;
+
+ if (!inverted)
+ {
+ // Find closest pre-calculated value...
+ for (i=0; i<KAlfTableMappingNumberOfMappedValues;i++)
+ {
+ if ((!inverted && aValue < iData->iParams.iValues[i]) ||
+ inverted && (aValue > iData->iParams.iValues[i]))
+ {
+ retVal = iData->iParams.iMappedValues[i];
+ break;
+ }
+ retVal = iData->iParams.iMappedValues[i];
+ }
+
+ // ...do approximation, real value is between pre-calculated values
+ if (i != 0)
+ {
+ TReal32 valueDelta = iData->iParams.iValues[i] - aValue;
+ if (inverted)
+ {
+ valueDelta = -valueDelta;
+ }
+
+ TReal32 valueStep = iData->iParams.iValues[i] - iData->iParams.iValues[i-1];
+ TReal32 mappedValueStep = iData->iParams.iMappedValues[i] - iData->iParams.iMappedValues[i-1];
+ TReal32 fix = (valueDelta/valueStep) * mappedValueStep;
+ retVal -= fix;
+ }
+ }
+
+ return retVal;
+ }
+
+TInt CAlfTableMappingFunction::MappingFunctionIdentifier() const
+ {
+ return iData->iComms->Identifier();
+ }
+
+EXPORT_C void CAlfTableMappingFunction::SetMappingTableValues(TReal32 aStart, TReal32 aEnd, MAlfTableMappingFunctionDataProvider* aFunction) __SOFTFP
+ {
+ TBool valuesChanged = (iData->iLastStart != aStart || iData->iLastEnd != aEnd);
+ TBool functionChanged = (aFunction != iData->iLastFunction);
+
+ if (aFunction && (valuesChanged || functionChanged))
+ {
+ TReal32 step = (aEnd - aStart)/(KAlfTableMappingNumberOfMappedValues - 1);
+ TReal32 value = aStart;
+ for (TInt i=0; i<KAlfTableMappingNumberOfMappedValues;i++)
+ {
+ iData->iParams.iValues[i] = value;
+ iData->iParams.iMappedValues[i] = aFunction->MapValue(value, 0);
+ value += step;
+ }
+
+ iData->iParams.iValues[KAlfTableMappingNumberOfMappedValues -1] = aEnd;
+ iData->iParams.iMappedValues[KAlfTableMappingNumberOfMappedValues -1] =
+ aFunction->MapValue(aEnd, 0);
+
+ TPckgC<TAlfTableMappingFunctionParams> mapValuesPckg( iData->iParams );
+
+ TInt err = iData->iComms->DoCmdNoReply(
+ EAlfMappingFunctionTableSetValues,
+ mapValuesPckg );
+ __ASSERT_ALWAYS( err == KErrNone, USER_INVARIANT() );
+
+ iData->iLastStart = aStart;
+ iData->iLastEnd = aEnd;
+ iData->iLastFunction = aFunction;
+ }
+ }
+