--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uiacceltk/hitchcock/ServerCore/Src/alfmappingfunctionhandlers.cpp Tue Feb 02 07:56:43 2010 +0200
@@ -0,0 +1,639 @@
+/*
+* 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 );
+ }
+ }
+
+
+
+// TABLE MAPPING FUNCTION
+
+TAlfTableMappingFunctionHandler::TAlfTableMappingFunctionHandler(
+ MAlfInterfaceProvider& aResolver)
+ : iResolver(aResolver)
+ {
+ }
+
+void TAlfTableMappingFunctionHandler::Release()
+ {
+ delete this;
+ }
+
+TAny* TAlfTableMappingFunctionHandler::GetInterface(
+ const THuiInterfaceSupport& aInterface)
+ {
+ switch ( aInterface )
+ {
+ case EHuiInterfaceMappingFunction:
+ return &iMappingFunction;
+ default:
+ return NULL;
+ }
+ }
+
+void TAlfTableMappingFunctionHandler::HandleCmdL(
+ TInt aCommandId,
+ const TDesC8& aInputBuffer,
+ TDes8& aResponse )
+ {
+ switch ( aCommandId )
+ {
+ case EAlfMappingFunctionMapValue:
+ {
+ TIntTReal* mapValues = (TIntTReal*) aInputBuffer.Ptr();
+
+ const TReal32 returnValue = iMappingFunction.MapValue( mapValues->iReal, mapValues->iInt );
+
+ TPckg<TReal32> returnValuePckg(returnValue);
+ aResponse = returnValuePckg;
+ break;
+ }
+ case EAlfMappingFunctionTableSetValues:
+ {
+ TAlfTableMappingFunctionParams* mapValues = (TAlfTableMappingFunctionParams*) aInputBuffer.Ptr();
+ iMappingFunction.iParams = *mapValues;
+ break;
+ }
+ default:
+ User::Leave( KErrNotSupported );
+ }
+ }
+
+TAlfTableMappingFunction::TAlfTableMappingFunction()
+ {
+
+ }
+
+TReal32 TAlfTableMappingFunction::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 (iParams.iValues[KAlfTableMappingNumberOfMappedValues - 1] < iParams.iValues[0])
+ {
+ inverted = ETrue;
+ }
+
+ TInt i = 0;
+
+ if (!inverted)
+ {
+ // Find closest pre-calculated value...
+ for (i=0; i<KAlfTableMappingNumberOfMappedValues-1;i++)
+ {
+ if ((!inverted && aValue < iParams.iValues[i]) ||
+ inverted && (aValue > iParams.iValues[i]))
+ {
+ retVal = iParams.iMappedValues[i];
+ break;
+ }
+ retVal = iParams.iMappedValues[i];
+ }
+
+ // ...do approximation, real value is between pre-calculated values
+ if (i != 0)
+ {
+ TReal32 valueDelta = iParams.iValues[i] - aValue;
+ if (inverted)
+ {
+ valueDelta = -valueDelta;
+ }
+
+ TReal32 valueStep = iParams.iValues[i] - iParams.iValues[i-1];
+ TReal32 mappedValueStep = iParams.iMappedValues[i] - iParams.iMappedValues[i-1];
+ TReal32 fix = (valueDelta/valueStep) * mappedValueStep;
+ retVal -= fix;
+ }
+ }
+
+ return retVal;
+ }
+