diff -r 4ea6f81c838a -r 0e9bb658ef58 widgetmodel/alfwidgetmodel/src/alflinevisualattributesetter.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/widgetmodel/alfwidgetmodel/src/alflinevisualattributesetter.cpp Wed Sep 01 12:23:18 2010 +0100 @@ -0,0 +1,1409 @@ +/* +* 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: Implements attributesetters for linevisual. +* +*/ + + +//includes + +//widget model includes +#include "alf/alfattributecontainer.h" +#include "alf/alfattributevaluetype.h" +#include "alf/alfattribute.h" +#include "alf/alflinevisualattributesetter.h" +#include +#include +#include + +//osn includes +#include +#include + +//alf includes +#include +#include +#include +#include + +//dui includes +#include "alf/attrproperty.h" + +//other includes +#include +#include + + + +//namespaces + +using namespace osncore; + +using namespace duiuimodel::commonvisualattributes; +using namespace duiuimodel::linevisualattributes; +using namespace duiuimodel::curvepathattributes; + +namespace Alf + { + +static void throwIfErr ( int aErr ) + { + if (aErr!=KErrNone) + { + ALF_THROW ( AlfAttributeException, aErr, + "AlfLineVisualAttributeSetter") + } + } + + +class AlfLineVisualAttributeSetterImpl + { +public: + AlfLineVisualAttributeSetterImpl(); + ~AlfLineVisualAttributeSetterImpl(); +public: + + // Texture manager doesn't unload the texture from memory untill Env + // is deleted. Hence need to unload them once attribute setter is deleted. + AlfPtrVector mLoadedTextures; + // Env needed to access TextureManager while unloading textures. + CAlfEnv* mEnv; + }; + +AlfLineVisualAttributeSetterImpl::AlfLineVisualAttributeSetterImpl() + { + // Do not delete textures here as they may be in use by the visuals + // that have not been deleted. + mLoadedTextures.setAutoDelete(false); + } + +AlfLineVisualAttributeSetterImpl::~AlfLineVisualAttributeSetterImpl() + { + // Unload all loaded textures created by this attributesetter to free + // up the memory. + for (int i =0;iTextureManager().UnloadTexture(Texture->Id()); + } + mLoadedTextures.clear(); + } + + +// ======== MEMBER FUNCTIONS ======== + +// --------------------------------------------------------------------------- +// Constructor. +// --------------------------------------------------------------------------- +// +OSN_EXPORT AlfLineVisualAttributeSetter::AlfLineVisualAttributeSetter() + { + mImpl.reset(new (EMM) AlfLineVisualAttributeSetterImpl()); + } + +// --------------------------------------------------------------------------- +// Destructor. +// --------------------------------------------------------------------------- +// +OSN_EXPORT AlfLineVisualAttributeSetter::~AlfLineVisualAttributeSetter() + { + } + + +// --------------------------------------------------------------------------- +// Sets Attribute Value. Delegates based on attribute Category. +// --------------------------------------------------------------------------- +// +OSN_EXPORT void AlfLineVisualAttributeSetter::setAttributeValue ( + CAlfVisual &aVisual, + AlfAttributeContainer* aContainer, + IAlfMap* aData ) + { + CAlfLineVisual* lineVisual = dynamic_cast( &aVisual); + + if ( !lineVisual ) + { + ALF_THROW ( AlfVisualException, EInvalidVisual, "AlfLineVisualAttributeSetter" ) + } + + CAlfCurvePath* curve = lineVisual->Path(); + if (curve) + { + curve->Reset(); + } + + AlfCommonVisualAttributeSetter::setAttributeValue(aVisual, + aContainer, aData); + } + +// --------------------------------------------------------------------------- +// Deprecated +// --------------------------------------------------------------------------- +// +OSN_EXPORT TAlfCommand* AlfLineVisualAttributeSetter::createCommand ( + CAlfVisual& /*aVisual*/, + AlfAttributeContainer* /*aContainer*/, + IAlfMap* /*aData*/, + int /*aTransitionTime*/, + CAlfVisual* /*aRefVisual*/ ) + { + //deprecated + TAlfCommand* cmd = 0; + return cmd; + } + +// --------------------------------------------------------------------------- +// Sends a command to Env +// --------------------------------------------------------------------------- +// +OSN_EXPORT void AlfLineVisualAttributeSetter::createAndSendCommands ( + CAlfVisual& aVisual, + AlfAttributeContainer* aContainer, + CAlfVisual* aRefVisual ) + { + // SetOffset in CAlfCurvePath, + // SetThickness,SetShadowThickness SetStartPos & SetEndPos + // in Line Visual can be sent as a TAlfCustomEventCommand + AlfCommonVisualAttributeSetter::createAndSendCommands ( + aVisual, aContainer, aRefVisual ); + + } + + +// --------------------------------------------------------------------------- +// Sets dynamic attributes to visual +// --------------------------------------------------------------------------- +// +void AlfLineVisualAttributeSetter::handleDynamicAttribute ( + CAlfVisual &aVisual, + AlfAttribute& aAttr, + AlfAttributeContainer& aContainer) + { + + CAlfLineVisual* lineVisual = dynamic_cast( &aVisual); + if ( !lineVisual ) + { + return; + } + const char* attrName = aAttr.name(); + + if ( !strcmp ( attrName, KThickness ) ) + { + TAlfTimedValue tVal((TReal32)aAttr.getSourceValue()->realValue()); + tVal.SetTarget ((TReal32)aAttr.getTargetValue()->realValue(), + (TInt) aAttr.getTime()); + tVal.SetStyle ( aAttr.getInterpolationStyle() ); + tVal.SetMappingFunctionIdentifier (aAttr.getMappingFunctionId()); + + lineVisual->SetThickness(tVal); + } + + else if ( !strcmp ( attrName, KShadowThickness ) ) + { + TAlfTimedValue tVal((TReal32)aAttr.getSourceValue()->realValue()); + tVal.SetTarget ((TReal32)aAttr.getTargetValue()->realValue(), + (TInt) aAttr.getTime()); + tVal.SetStyle ( aAttr.getInterpolationStyle() ); + tVal.SetMappingFunctionIdentifier (aAttr.getMappingFunctionId()); + + lineVisual->SetShadowThickness(tVal); + } + + else if ( !strcmp ( attrName, KStartPos ) ) + { + TAlfTimedValue tVal((TReal32)aAttr.getSourceValue()->realValue()); + tVal.SetTarget ((TReal32)aAttr.getTargetValue()->realValue(), + (TInt) aAttr.getTime()); + tVal.SetStyle ( aAttr.getInterpolationStyle() ); + tVal.SetMappingFunctionIdentifier (aAttr.getMappingFunctionId()); + + lineVisual->SetStartPos(tVal); + } + + else if ( !strcmp ( attrName, KEndPos ) ) + { + TAlfTimedValue tVal((TReal32)aAttr.getSourceValue()->realValue()); + tVal.SetTarget ((TReal32)aAttr.getTargetValue()->realValue(), + (TInt) aAttr.getTime()); + tVal.SetStyle ( aAttr.getInterpolationStyle() ); + tVal.SetMappingFunctionIdentifier (aAttr.getMappingFunctionId()); + + lineVisual->SetEndPos(tVal); + } + + else if ( !strcmp ( attrName, KOffsetX )||!strcmp ( attrName, KOffsetY ) ) + { + AlfAttribute& offsety = aContainer.getAttributeByName ( + KOffsetY ); + AlfAttribute& offsetx = aContainer.getAttributeByName ( + KOffsetX ); + //will throw if attribute is not found + + TAlfTimedPoint offset((TReal32)offsetx.getSourceValue()->realValue(), + (TReal32)offsety.getSourceValue()->realValue()); + + offset.iX.SetTarget((TReal32)offsetx.getTargetValue()->realValue(), + offsetx.getTime()); + + offset.iY.SetTarget((TReal32)offsety.getTargetValue()->realValue(), + offsety.getTime()); + + offset.iX.SetStyle ( offsetx.getInterpolationStyle() ); + offset.iY.SetStyle ( offsety.getInterpolationStyle() ); + + offset.iX.SetMappingFunctionIdentifier ( + offsetx.getMappingFunctionId()); + offset.iY.SetMappingFunctionIdentifier ( + offsety.getMappingFunctionId()); + + CAlfCurvePath* curve = this->getCurvePath(lineVisual); + curve->SetOffset ( offset ); + offsetx.setDirty(false); + offsety.setDirty(false); + } + + else + { + AlfCommonVisualAttributeSetter::handleDynamicAttribute( + aVisual, aAttr, aContainer); + } + } + +// --------------------------------------------------------------------------- +// Sets static attributes to visual +// --------------------------------------------------------------------------- +// +void AlfLineVisualAttributeSetter::handleStaticAttribute ( + CAlfVisual& aVisual, + AlfAttribute& aAttr, + AlfAttributeContainer& aContainer) + { + + CAlfLineVisual* lineVisual = dynamic_cast( &aVisual); + if ( !lineVisual ) + { + return; + } + + const char* attrName = aAttr.name(); + + if ( !strcmp ( attrName, KImagePath ) ) + { + TPtrC8 src; + src.Set((TUint8*)aAttr.stringValue().getUtf8()); + auto_ptr DesC; + TRAPD(err1, + DesC.reset(CnvUtfConverter::ConvertToUnicodeFromUtf8L(src))); + throwIfErr(err1); + + if (DesC.get()) + { + CAlfTexture* texture = NULL; + TRAPD(err2,texture = &(aVisual.Env().TextureManager(). + LoadTextureL( *(DesC.get()), + EAlfTextureFlagDefault, + KAlfAutoGeneratedTextureId))); + throwIfErr(err2); + lineVisual->SetImage(TAlfImage(*texture)); + mImpl->mEnv = &aVisual.Env(); + mImpl->mLoadedTextures.resize(mImpl->mLoadedTextures.count()+1); + mImpl->mLoadedTextures.insert(mImpl->mLoadedTextures.count(), + texture); + } + } + + else if ( !strcmp ( attrName, KThickness ) ) + { + TAlfTimedValue val(aAttr.realValue(),0); + //static attribute,apply with immidiate effect + + lineVisual->SetThickness(val); + } + + else if ( !strcmp ( attrName, KShadowThickness ) ) + { + TAlfTimedValue val(aAttr.realValue(),0); + //static attribute,apply with immidiate effect + + lineVisual->SetShadowThickness(val); + } + + else if ( !strcmp ( attrName, KStartPos ) ) + { + TAlfTimedValue val(aAttr.realValue(),0); + //static attribute,apply with immidiate effect + + lineVisual->SetStartPos(val); + } + + else if ( !strcmp ( attrName, KEndPos ) ) + { + TAlfTimedValue val(aAttr.realValue(),0); + //static attribute,apply with immidiate effect + + lineVisual->SetEndPos(val); + } + + else if ( !strcmp ( attrName, KAlphaMappingFunction ) ) + { + // assumption: + // The int value-mapping function mapping is the following: + // 0 - KConstMappingFunction + // 1 - duiuimodel::nodetypes::KLinearMappingFunction + // 2 - KSineMappingFunction + // 3 - KCosineMappingFunction + + MAlfMappingFunction* func = this->getMappingFunction(aAttr, + lineVisual->Env()); + if (!func) + { + ALF_THROW ( AlfAttributeException, + EInvalidAttribute, "AlfLineVisualAttributeSetter") + } + + lineVisual->SetAlphaFunction(func); + } + + else if ( !strcmp ( attrName, KWidthMappingFunction ) ) + { + //assumption: + //The int value-mapping function mapping is the following: + //0 - KConstMappingFunction + //1 - duiuimodel::nodetypes::KLinearMappingFunction + //2 - KSineMappingFunction + //3 - KCosineMappingFunction + + MAlfMappingFunction* func = this->getMappingFunction(aAttr, + lineVisual->Env()); + if (!func) + { + ALF_THROW ( AlfAttributeException, + EInvalidAttribute, "AlfLineVisualAttributeSetter") + } + lineVisual->SetWidthFunction(func); + } + + else if ( !strcmp ( attrName, KColor ) ) + { + if ( 4 == aAttr.getTargetValueCount() && + AlfAttributeValueType::EFloat == aAttr.type(0) && + AlfAttributeValueType::EFloat == aAttr.type(1) && + AlfAttributeValueType::EFloat == aAttr.type(2) && + AlfAttributeValueType::EFloat == aAttr.type(3)) + { + TRgb color ( aAttr.realValue(0), + aAttr.realValue(1), + aAttr.realValue(2), + aAttr.realValue(3) ); + lineVisual->SetColor ( color ); + } + else + { + ALF_THROW ( AlfAttributeException, EInvalidAttribute, + "AlfLineVisualAttributeSetter") + } + } + + else if ( !strcmp ( attrName, KEnableLoop ) ) + { + + CAlfCurvePath* curve = this->getCurvePath(lineVisual); + + // if value is not int, then use default parameter of EnableLoop + if ( AlfAttributeValueType::EInt != aAttr.type() ) + { + curve->EnableLoop (); + } + else + { + int enableLoop = aAttr.intValue(); + + TBool flag = ETrue; + //Assume true for any non-zero value. + + if ( 0 == enableLoop ) + { + flag = EFalse; + } + curve->EnableLoop ( flag ); + } + } + + else if ( !strcmp ( attrName, KOrigin ) ) + { + CAlfCurvePath* curve = this->getCurvePath(lineVisual); + curve->SetOrigin ( aAttr.realValue() ); + } + + else if ( !strcmp ( attrName, KOffsetX )||!strcmp ( attrName, KOffsetY ) ) + { + CAlfCurvePath* curve = this->getCurvePath(lineVisual); + AlfAttribute& offsety = aContainer.getAttributeByName ( + KOffsetY ); + AlfAttribute& offsetx = aContainer.getAttributeByName ( + KOffsetX ); + //will throw if attribute is not found + + TAlfTimedPoint offset( offsetx.realValue(), offsety.realValue()); + curve->SetOffset ( offset ); + offsetx.setDirty(false); + offsety.setDirty(false); + } + + else if ( !strcmp ( attrName, KLine ) ) + { + CAlfCurvePath* curve = this->getCurvePath(lineVisual); + + // This multi-value attribute has to be filled in this order: + // startx,starty,endx,endy,linelength + + if ( 5 != aAttr.getTargetValueCount()) + { + ALF_THROW ( AlfAttributeException, EInvalidAttribute, + "CAlfLineVisualLayoutAttributeSetter" ); + } + float startx = this->floatOrInt( aAttr, 0 ); + float starty = this->floatOrInt( aAttr, 1 ); + float endx = this->floatOrInt( aAttr, 2 ); + float endy = this->floatOrInt( aAttr, 3 ); + float len = aAttr.realValue(4); + + TRAPD(err1, + curve->AppendLineL ( TAlfRealPoint(startx,starty), + TAlfRealPoint(endx,endy),len )) + throwIfErr(err1); + } + + else if ( !strcmp ( attrName, KArc ) ) + { + CAlfCurvePath* curve = this->getCurvePath(lineVisual); + + // This multi-value attribute has to be filled in this order: + // arcoriginx,arcoriginy,archorzradius,arcvertradius, + // arcstartangle,arcendangle,arclength + + if ( 7 != aAttr.getTargetValueCount()) + { + ALF_THROW ( AlfAttributeException, EInvalidAttribute, + "CAlfLineVisualLayoutAttributeSetter" ); + } + + float originx = this->floatOrInt( aAttr, 0 ); + float originy = this->floatOrInt( aAttr, 1 ); + float horzradius = this->floatOrInt( aAttr, 2 ); + float vertradius = this->floatOrInt( aAttr, 3 ); + float startangle = aAttr.realValue(4); + float endangle = aAttr.realValue(5); + float len = aAttr.realValue(6); + TRAPD(err1, + curve->AppendArcL(TAlfRealPoint(originx,originy), + TAlfRealSize(horzradius,vertradius), + startangle, endangle, len)) + throwIfErr(err1); + } + + else + { + AlfCommonVisualAttributeSetter::handleStaticAttribute ( + aVisual, aAttr, aContainer); + } + } + + + +// --------------------------------------------------------------------------- +// Sets dynamic attributes to visual from data +// --------------------------------------------------------------------------- +// +void AlfLineVisualAttributeSetter::handleDynamicDataAttribute ( + CAlfVisual& aVisual, + AlfAttribute& aAttr, + AlfAttributeContainer& aContainer, + IAlfMap* aData ) + { + CAlfLineVisual* lineVisual = dynamic_cast( &aVisual); + if ( !lineVisual ) + { + ALF_THROW ( AlfDataException, ECommonError, + "AlfLineVisualAttributeSetter" ) + } + + const char* attrName = aAttr.name(); + + const char* dataField = aAttr.getDataField(); + + if ( !dataField ) + { + ALF_THROW ( AlfDataException, ECommonError, + "AlfLineVisualAttributeSetter") + } + + if (!aData) + { + ALF_THROW ( AlfDataException, ECommonError, + "AlfLineVisualAttributeSetter" ) + } + + IAlfVariantType* data = aData->item ( UString(dataField) ); + + if (data) + { + const char* attrName = aAttr.name(); + + if ( !strcmp ( attrName, KOffsetX ) ) + { + AlfAttribute& offsety = aContainer.getAttributeByName ( + KOffsetY ); + //will throw if attribute is not found + + const char* offsetyDataField = offsety.getDataField(); + if ( !offsetyDataField ) + { + ALF_THROW ( AlfDataException, ECommonError, + "AlfLineVisualAttributeSetter" ) + } + IAlfVariantType* offsetyData = + aData->item ( UString(offsetyDataField) ); + + if ( data->type() == IAlfVariantType::EReal && + offsetyData && + offsetyData->type() == IAlfVariantType::EReal) + { + // The time value is in the attribute? + //Is it not part of data as well? + TAlfTimedPoint offset; + offset.iX.SetTarget(data->real(), aAttr.getTime()); + offset.iX.SetStyle ( aAttr.getInterpolationStyle() ); + offset.iX.SetMappingFunctionIdentifier ( + aAttr.getMappingFunctionId()); + offset.iY.SetTarget(offsetyData->real(), offsety.getTime()); + offset.iY.SetStyle ( offsety.getInterpolationStyle() ); + offset.iY.SetMappingFunctionIdentifier ( + offsety.getMappingFunctionId()); + CAlfCurvePath* curve = this->getCurvePath(lineVisual); + curve->SetOffset ( offset ); + } + else + { + ALF_THROW ( AlfDataException, EInvalidVariantDataType, "AlfLineVisualtAttributeSetter"); + } + } + + else if ( !strcmp ( attrName, KOffsetY ) ) + { + //Make sure X Attribute also exists, but do nothing. Actual values + //will be set in the iteration that checks for KOffsetX + aContainer.getAttributeByName ( KOffsetX ); + //will throw if attribute is not found + } + + else if ( !strcmp ( attrName, KThickness ) ) + { + if ( data->type() == IAlfVariantType::EReal) + { + // The time value is in the attribute? + // Is it not part of data as well? + // how is the source value stored in data? policy not clear + TAlfTimedValue tVal; + tVal.SetTarget(data->real(),(TInt) aAttr.getTime()); + tVal.SetStyle ( aAttr.getInterpolationStyle() ); + tVal.SetMappingFunctionIdentifier ( + aAttr.getMappingFunctionId()); + lineVisual->SetThickness(tVal); + } + else + { + ALF_THROW ( AlfDataException, EInvalidVariantDataType, "AlfLineVisualtAttributeSetter"); + } + } + + else if ( !strcmp ( attrName, KShadowThickness ) ) + { + if ( data->type() == IAlfVariantType::EReal) + { + // The time value is in the attribute? + // Is it not part of data as well? + // how is the source value stored in data? policy not clear + TAlfTimedValue tVal; + tVal.SetTarget(data->real(),(TInt) aAttr.getTime()); + tVal.SetStyle ( aAttr.getInterpolationStyle() ); + tVal.SetMappingFunctionIdentifier ( + aAttr.getMappingFunctionId()); + lineVisual->SetShadowThickness(tVal); + } + else + { + ALF_THROW ( AlfDataException, EInvalidVariantDataType, "AlfLineVisualtAttributeSetter"); + } + } + + else if ( !strcmp ( attrName, KStartPos ) ) + { + if ( data->type() == IAlfVariantType::EReal) + { + // The time value is in the attribute? + // Is it not part of data as well? + // how is the source value stored in data? policy not clear + TAlfTimedValue tVal; + tVal.SetTarget(data->real(),(TInt) aAttr.getTime()); + tVal.SetStyle ( aAttr.getInterpolationStyle() ); + tVal.SetMappingFunctionIdentifier ( + aAttr.getMappingFunctionId()); + lineVisual->SetStartPos(tVal); + } + else + { + ALF_THROW ( AlfDataException, EInvalidVariantDataType, "AlfLineVisualtAttributeSetter"); + } + } + + else if ( !strcmp ( attrName, KEndPos ) ) + { + if ( data->type() == IAlfVariantType::EReal) + { + // The time value is in the attribute? + // Is it not part of data as well? + // how is the source value stored in data? policy not clear + TAlfTimedValue tVal; + tVal.SetTarget(data->real(),(TInt) aAttr.getTime()); + tVal.SetStyle ( aAttr.getInterpolationStyle() ); + tVal.SetMappingFunctionIdentifier ( + aAttr.getMappingFunctionId()); + lineVisual->SetEndPos(tVal); + } + else + { + ALF_THROW ( AlfDataException, EInvalidVariantDataType, "AlfLineVisualtAttributeSetter"); + } + } + + else + { + AlfCommonVisualAttributeSetter::handleDynamicDataAttribute( + aVisual, aAttr, aContainer, aData); + } + } + } + +// --------------------------------------------------------------------------- +// Sets static attributes to visual from data +// --------------------------------------------------------------------------- +// +void AlfLineVisualAttributeSetter::handleStaticDataAttribute ( + CAlfVisual &aVisual, + AlfAttribute& aAttr, + AlfAttributeContainer& aContainer, + IAlfMap* aData ) + { + + CAlfLineVisual* lineVisual = dynamic_cast( &aVisual); + if ( !lineVisual ) + { + ALF_THROW ( AlfDataException, ECommonError, + "AlfLineVisualAttributeSetter" ) + } + + const char* dataField = aAttr.getDataField(); + + if ( !dataField ) + { + ALF_THROW ( AlfDataException, ECommonError, + "AlfLineVisualAttributeSetter" ); + } + + if (!aData) + { + ALF_THROW ( AlfDataException, ECommonError, + "AlfLineVisualAttributeSetter" ); + } + + IAlfVariantType* data = aData->item (UString( dataField) ); + + const char* attrName = aAttr.name(); + + if ( data ) + { + if ( !strcmp ( attrName, KImagePath ) ) + { + if (data->type() == IAlfVariantType::EString) + { + + TPtrC8 src; + src.Set((TUint8*)data->string().getUtf8()); + auto_ptr DesC; + TRAPD(err1, + DesC.reset(CnvUtfConverter::ConvertToUnicodeFromUtf8L(src))); + throwIfErr(err1); + + if (DesC.get()) + { + CAlfTexture* texture = NULL; + TRAPD(err2,texture = &(aVisual.Env().TextureManager(). + LoadTextureL(*(DesC.get()), + EAlfTextureFlagDefault, + KAlfAutoGeneratedTextureId))); + throwIfErr(err2); + lineVisual->SetImage(TAlfImage(*texture)); + mImpl->mEnv = &aVisual.Env(); + mImpl->mLoadedTextures.resize( + mImpl->mLoadedTextures.count()+1); + mImpl->mLoadedTextures.insert( + mImpl->mLoadedTextures.count(), texture); + } + } + else + { + ALF_THROW ( AlfDataException, EInvalidVariantDataType, "AlfLineVisualtAttributeSetter"); + } + } + + else if ( !strcmp ( attrName, KThickness ) ) + { + if (data->type() == IAlfVariantType::EReal) + { + TAlfTimedValue val(data->real(),0); + //static attribute,apply with immidiate effect + + lineVisual->SetThickness(val); + } + else + { + ALF_THROW ( AlfDataException, EInvalidVariantDataType, "AlfLineVisualtAttributeSetter"); + } + } + + else if ( !strcmp ( attrName, KShadowThickness ) ) + { + if (data->type() == IAlfVariantType::EReal) + { + TAlfTimedValue val(data->real(),0); + //static attribute,apply with immidiate effect + + lineVisual->SetShadowThickness(val); + } + else + { + ALF_THROW ( AlfDataException, EInvalidVariantDataType, "AlfLineVisualtAttributeSetter"); + } + } + + else if ( !strcmp ( attrName, KStartPos ) ) + { + if (data->type() == IAlfVariantType::EReal) + { + TAlfTimedValue val(data->real(),0); + //static attribute,apply with immidiate effect + + lineVisual->SetStartPos(val); + } + } + + else if ( !strcmp ( attrName, KEndPos ) ) + { + if (data->type() == IAlfVariantType::EReal) + { + TAlfTimedValue val(data->real(),0); + //static attribute,apply with immidiate effect + + lineVisual->SetEndPos(val); + } + else + { + ALF_THROW ( AlfDataException, EInvalidVariantDataType, "AlfLineVisualtAttributeSetter"); + } + } + + else if ( !strcmp ( attrName, KAlphaMappingFunction ) ) + { + //assumption: + //The int value-mapping function mapping is the following: + //0 - KConstMappingFunction + //1 - duiuimodel::nodetypes::KLinearMappingFunction + //2 - KSineMappingFunction + //3 - KCosineMappingFunction + if (data->type() == IAlfVariantType::EContainer ) + { + IAlfContainer* dataContainer = data->container(); + MAlfMappingFunction* func = + this->getMappingFunctionFromContainer(dataContainer, + lineVisual->Env()); + + if (!func) + { + ALF_THROW ( AlfAttributeException, + EInvalidAttribute, "AlfLineVisualAttributeSetter") + } + + lineVisual->SetAlphaFunction(func); + } + else + { + ALF_THROW ( AlfDataException, EInvalidVariantDataType, "AlfLineVisualtAttributeSetter"); + } + } + + else if ( !strcmp ( attrName, KWidthMappingFunction ) ) + { + //assumption: + //The int value-mapping function mapping is the following: + //0 - KConstMappingFunction + //1 - duiuimodel::nodetypes::KLinearMappingFunction + //2 - KSineMappingFunction + //3 - KCosineMappingFunction + + if (data->type() == IAlfVariantType::EContainer ) + { + IAlfContainer* dataContainer = data->container(); + MAlfMappingFunction* func = + this->getMappingFunctionFromContainer(dataContainer, + lineVisual->Env()); + + if (!func) + { + ALF_THROW ( AlfAttributeException, + EInvalidAttribute, "AlfLineVisualAttributeSetter") + } + + lineVisual->SetWidthFunction(func); + } + else + { + ALF_THROW ( AlfDataException, EInvalidVariantDataType, "AlfLineVisualtAttributeSetter"); + } + } + + else if ( !strcmp ( attrName, KColor ) ) + { + if (data->type() == IAlfVariantType::EContainer ) + { + IAlfContainer* dataContainer = data->container(); + + if ( 4 != dataContainer -> count() ) + { + ALF_THROW ( AlfAttributeException,EIncompleteAttributeValues, "AlfLineVisualAttributeSetter") + } + + IAlfVariantType* red = dataContainer->item ( 0 );//red + + IAlfVariantType* green = dataContainer->item ( 1 );//green + + IAlfVariantType* blue = dataContainer->item ( 2 );//blue + + IAlfVariantType* alpha = dataContainer->item ( 3 );//alpha + + if ( red && IAlfVariantType::EReal == red->type() && + green && IAlfVariantType::EReal == green->type() && + blue && IAlfVariantType::EReal == blue->type() && + alpha && IAlfVariantType::EReal == alpha->type() ) + { + TRgb color ( red->real(), + green->real(), + blue->real(), + alpha->real() ); + + lineVisual->SetColor ( color ); + } + else + { + ALF_THROW ( AlfAttributeException, EInvalidAttribute, + "AlfLineVisualAttributeSetter" ) + } + } + else + { + ALF_THROW ( AlfDataException, EInvalidVariantDataType, "AlfLineVisualtAttributeSetter"); + } + } + + else if ( !strcmp ( attrName, KEnableLoop ) ) + { + CAlfCurvePath* curve = this->getCurvePath(lineVisual); + + // if value is not bool, then use default parameter of EnableLoop + if ( data->type() != IAlfVariantType::EBool ) + { + curve->EnableLoop (); + } + + else + { + curve->EnableLoop ( data->boolean() ); + } + } + + else if ( !strcmp ( attrName, KOrigin ) ) + { + CAlfCurvePath* curve = this->getCurvePath(lineVisual); + + if ( data->type() == IAlfVariantType::EReal ) + { + float origin = data->real() ; + curve->SetOrigin ( origin ); + } + else + { + ALF_THROW ( AlfDataException, EInvalidVariantDataType, "AlfLineVisualtAttributeSetter"); + } + } + + else if ( !strcmp ( attrName, KOffsetX ) ) + { + CAlfCurvePath* curve = this->getCurvePath(lineVisual); + + AlfAttribute& offsety = aContainer.getAttributeByName ( + KOffsetY ); + + //will throw if attribute is not found + const char* offsetyDataField = offsety.getDataField(); + if ( !offsetyDataField ) + { + ALF_THROW ( AlfDataException, + ECommonError, "AlfLineVisualAttributeSetter" ) + } + + IAlfVariantType* offsetyData = + aData->item (UString( offsetyDataField ) ); + + if ( data->type() == IAlfVariantType::EReal && + offsetyData && + offsetyData->type() == IAlfVariantType::EReal) + { + TAlfTimedPoint offset( data->real(), offsetyData->real()); + curve->SetOffset ( offset ); + } + else + { + ALF_THROW ( AlfDataException, EInvalidVariantDataType, "AlfLineVisualtAttributeSetter"); + } + } + + else if ( !strcmp ( attrName, KOffsetY ) ) + { + //Make sure X Attribute also exists, but do nothing. + //Actual values will be set in the iteration that checks for + //KOffsetX + + aContainer.getAttributeByName ( KOffsetX ); + //will throw if attribute is not found + } + + else if ( !strcmp ( attrName, KLine ) ) + { + CAlfCurvePath* curve = this->getCurvePath(lineVisual); + + //if not a container, dont proceed + if (!(data->type() == IAlfVariantType::EContainer)) + { + return; + } + + IAlfContainer* container = data->container(); + //if all item are not present, throw + if (container->count() != 5) + { + ALF_THROW ( AlfAttributeException, EInvalidAttribute, + "AlfLineVisualAttributeSetter" ); + } + + IAlfVariantType* lineStartXvalue = container->item(0); + IAlfVariantType* lineStartYvalue = container->item(1); + IAlfVariantType* lineEndXvalue = container->item(2); + IAlfVariantType* lineEndYvalue = container->item(3); + IAlfVariantType* lineLengthvalue = container->item(4); + + float startx = this->floatOrIntFromData( lineStartXvalue); + float starty = this->floatOrIntFromData( lineStartYvalue); + float endx = this->floatOrIntFromData( lineEndXvalue ); + float endy = this->floatOrIntFromData( lineEndYvalue ); + float len = float(lineLengthvalue->real()); + TRAPD(err1, + curve->AppendLineL ( TAlfRealPoint(startx,starty), + TAlfRealPoint(endx,endy),len )) + throwIfErr(err1); + } + + else if ( !strcmp ( attrName, KArc ) ) + { + CAlfCurvePath* curve = this->getCurvePath(lineVisual); + + //if not a container, dont proceed + if (!(data->type() == IAlfVariantType::EContainer)) + { + return; + } + + IAlfContainer* container = data->container(); + + //if all item are not present, throw + if (container->count() != 7) + { + ALF_THROW ( AlfAttributeException, EInvalidAttribute, + "AlfLineVisualAttributeSetter" ); + } + + IAlfVariantType* arcOriginXValue = container->item(0); + IAlfVariantType* arcOriginYValue = container->item(1); + IAlfVariantType* archorzradiusValue = container->item(2); + IAlfVariantType* arcvertradiusValue = container->item(3); + IAlfVariantType* arcstartangleValue = container->item(4); + IAlfVariantType* arcendangleValue = container->item(5); + IAlfVariantType* arclengthValue = container->item(6); + + float originx = this->floatOrIntFromData( arcOriginXValue); + float originy = this->floatOrIntFromData( arcOriginYValue); + float horzradius = this->floatOrIntFromData( archorzradiusValue); + float vertradius = this->floatOrIntFromData( arcvertradiusValue); + float startangle = float(arcstartangleValue->real()); + float endangle = float(arcendangleValue->real()); + float len = float(arclengthValue->real()); + TRAPD(err1, + curve->AppendArcL(TAlfRealPoint(originx,originy), + TAlfRealSize(horzradius,vertradius), + startangle,endangle,len)) + + throwIfErr(err1); + } + + else + { + AlfCommonVisualAttributeSetter::handleStaticDataAttribute( + aVisual, aAttr, aContainer, aData ); + } + } + + } + + +// --------------------------------------------------------------------------- +// Creates and returns a toolkit defined mappping function based on the +// attribute contents +// assumption: +// The int value-mapping function mapping is the following: +// 0 - KConstMappingFunction +// 1 - duiuimodel::nodetypes::KLinearMappingFunction +// 2 - KSineMappingFunction +// 3 - KCosineMappingFunction +// --------------------------------------------------------------------------- +// +MAlfMappingFunction* AlfLineVisualAttributeSetter::getMappingFunction( + AlfAttribute& aAttribute, + CAlfEnv& aEnv) + { + MAlfMappingFunction* func=0; + int intValue = aAttribute.realValue(0); + + switch (intValue) + { + case 0: + { + if (aAttribute.getTargetValueCount() == 2) + { + TRAPD(err1,func = CAlfConstantMappingFunction::NewL(aEnv, + aAttribute.realValue(1))) + throwIfErr(err1); + } + + else + { + TRAPD(err1,func = CAlfConstantMappingFunction::NewL(aEnv)) + throwIfErr(err1); + } + } + break; + + case 1: + { + if (aAttribute.getTargetValueCount() == 3) + { + TRAPD(err1,func = CAlfLinearMappingFunction::NewL(aEnv, + aAttribute.realValue(1), + aAttribute.realValue(2))) + throwIfErr(err1); + } + + else if (aAttribute.getTargetValueCount() == 2) + { + TRAPD(err1,func = CAlfLinearMappingFunction::NewL(aEnv, + aAttribute.realValue(1))) + throwIfErr(err1); + } + + else + { + TRAPD(err1,func = CAlfLinearMappingFunction::NewL(aEnv)) + throwIfErr(err1); + } + } + break; + + case 2: + { + if (aAttribute.getTargetValueCount() == 3) + { + TRAPD(err1,func = CAlfSineMappingFunction::NewL(aEnv, + aAttribute.realValue(1), + aAttribute.realValue(2))) + throwIfErr(err1); + } + + else if (aAttribute.getTargetValueCount() == 2) + { + TRAPD(err1,func = CAlfSineMappingFunction::NewL(aEnv, + aAttribute.realValue(1))) + throwIfErr(err1); + } + + else + { + TRAPD(err1,func = CAlfSineMappingFunction::NewL(aEnv)) + throwIfErr(err1); + } + } + break; + + case 3: + { + if (aAttribute.getTargetValueCount() == 3) + { + TRAPD(err1,func = CAlfCosineMappingFunction::NewL(aEnv, + aAttribute.realValue(1), + aAttribute.realValue(2))) + throwIfErr(err1); + } + + else if (aAttribute.getTargetValueCount() == 2) + { + TRAPD(err1,func = CAlfCosineMappingFunction::NewL(aEnv, + aAttribute.realValue(1))) + throwIfErr(err1); + } + + else + { + TRAPD(err1,func = CAlfCosineMappingFunction::NewL(aEnv)) + throwIfErr(err1); + } + } + break; + + default: + break; + + } + + return func; + } + + +// --------------------------------------------------------------------------- +// Creates and returns a toolkit defined mappping function based on the +// container contents +// assumption: +// The int value-mapping function mapping is the following: +// 0 - KConstMappingFunction +// 1 - duiuimodel::nodetypes::KLinearMappingFunction +// 2 - KSineMappingFunction +// 3 - KCosineMappingFunction +// --------------------------------------------------------------------------- +// +MAlfMappingFunction* AlfLineVisualAttributeSetter:: + getMappingFunctionFromContainer(IAlfContainer* aContainer, CAlfEnv& aEnv) + { + MAlfMappingFunction* func=0; + + if (IAlfVariantType::EInt != aContainer->item(0)->type()) + { + return func; + } + + switch (aContainer->item(0)->integer()) + { + case 0: + { + if (aContainer -> count() == 2) + { + TRAPD(err1,func = CAlfConstantMappingFunction::NewL(aEnv, + aContainer->item(1)->real())) + throwIfErr(err1); + } + + else + { + TRAPD(err1,func = CAlfConstantMappingFunction::NewL(aEnv)) + throwIfErr(err1); + } + } + break; + + case 1: + { + if (aContainer -> count() == 3) + { + TRAPD(err1,func = CAlfLinearMappingFunction::NewL(aEnv, + aContainer->item(1)->real(), + aContainer->item(2)->real())) + throwIfErr(err1); + } + + else if (aContainer -> count() == 2) + { + TRAPD(err1,func = CAlfLinearMappingFunction::NewL(aEnv, + aContainer->item(1)->real())) + throwIfErr(err1); + } + + else + { + TRAPD(err1,func = CAlfLinearMappingFunction::NewL(aEnv)) + throwIfErr(err1); + } + } + break; + + case 2: + { + if (aContainer -> count() == 3) + { + TRAPD(err1,func = CAlfSineMappingFunction::NewL(aEnv, + aContainer->item(1)->real(), + aContainer->item(2)->real())) + throwIfErr(err1); + } + + else if (aContainer -> count() == 2) + { + TRAPD(err1,func = CAlfSineMappingFunction::NewL(aEnv, + aContainer->item(1)->real())) + throwIfErr(err1); + } + + else + { + TRAPD(err1,func = CAlfSineMappingFunction::NewL(aEnv)) + throwIfErr(err1); + } + } + break; + + case 3: + { + if (aContainer -> count() == 3) + { + TRAPD(err1,func = CAlfCosineMappingFunction::NewL(aEnv, + aContainer->item(1)->real(), + aContainer->item(2)->real())) + throwIfErr(err1); + } + + else if (aContainer -> count() == 2) + { + TRAPD(err1,func = CAlfCosineMappingFunction::NewL(aEnv, + aContainer->item(1)->real())) + throwIfErr(err1); + } + + else + { + TRAPD(err1,func = CAlfCosineMappingFunction::NewL(aEnv)) + throwIfErr(err1); + } + } + break; + + default: + break; + + } + + return func; + } + + +// --------------------------------------------------------------------------- +// If the line visual already has a path set to it, it is retrived. +// Else a new instance is created +// --------------------------------------------------------------------------- +// +CAlfCurvePath* AlfLineVisualAttributeSetter::getCurvePath( + CAlfLineVisual* aLineVisual) + { + CAlfCurvePath* curve = 0; + if(aLineVisual) + { + curve = aLineVisual->Path(); + + if (!curve) + { + TRAPD(err1,curve = CAlfCurvePath::NewL(aLineVisual->Env())) + throwIfErr(err1); + + aLineVisual->SetPath( curve, EAlfHasOwnership); + } + } + return curve; + } + +// --------------------------------------------------------------------------- +// Check if data in the attribute is int or float. +// Return the value as a float value +// --------------------------------------------------------------------------- +// +float AlfLineVisualAttributeSetter::floatOrInt( + const AlfAttribute& aAttr, + int aIndex) + { + if (aAttr.type(aIndex) == AlfAttributeValueType::EInt) + { + return float(aAttr.intValue(aIndex)); + } + else if (aAttr.type(aIndex) == AlfAttributeValueType::EFloat) + { + return aAttr.realValue(aIndex); //will throw an exception i + } + else + { + ALF_THROW ( AlfAttributeException, ECommonError, + "AlfLineVisualAttributeSetter" ); + } + } + +// --------------------------------------------------------------------------- +// Check if data in the variant type is int or float. +// Return the value as a float value +// --------------------------------------------------------------------------- +// +float AlfLineVisualAttributeSetter::floatOrIntFromData(IAlfVariantType* aData) + { + if (IAlfVariantType::EInt == aData->type()) + { + return float(aData->integer()); + } + else if (IAlfVariantType::EReal == aData->type()) + { + return aData->real();; //will throw an exception i + } + else + { + ALF_THROW ( AlfAttributeException, ECommonError, + "AlfLineVisualAttributeSetter" ); + } + } + + }// namespace Alf +// End of file + + + + +