diff -r 000000000000 -r 15bf7259bb7c uiacceltk/hitchcock/ServerCore/Src/alfmappingfunctionhandlers.cpp --- /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 + +// 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 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(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 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 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 returnValuePckg(returnValue); + aResponse = returnValuePckg; + break; + } + + case EAlfCurvePathOffset: + { + TAlfTimedPoint returnValue; + AlfTimedPointUtility::CopyTimedPoint(iCurvePath->iOffset, returnValue); + + TPckg 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 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 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 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; + } +