--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/widgetmodel/alfwidgetmodel/src/alfcommonvisualattributesetter.cpp Wed Sep 01 12:23:18 2010 +0100
@@ -0,0 +1,843 @@
+/*
+* 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: attributesetter for common visual attributes
+*
+*/
+
+
+#include "alf/alfattribute.h"
+#include "alf/alfcommonvisualattributesetter.h"
+#include "alf/alfattributevaluetype.h"
+#include <alf/alfvisual.h>
+#include <alf/alfattributeexception.h>
+#include <alf/alfdataexception.h>
+#include <alf/alfvisualexception.h>
+#include "alf/alfattributecontainer.h"
+#include <libc/string.h>
+#include <osn/ustring.h>
+#include "alf/attrproperty.h"
+#include <alf/alfenv.h>
+
+using namespace osncore;
+
+using namespace duiuimodel::commonattributes;
+using namespace duiuimodel::commonattributevalues;
+using namespace duiuimodel::commonvisualattributes;
+using namespace duiuimodel::layoutattributes;
+using namespace duiuimodel::rect;
+using namespace duiuimodel::padding;
+using namespace duiuimodel::tactileattributes;
+
+namespace Alf
+ {
+
+// ---------------------------------------------------------------------------
+// gets the data from map pointed by attribute's field name.
+// ---------------------------------------------------------------------------
+//
+IAlfVariantType* getData(const AlfAttribute& aAttr, IAlfMap* aData)
+ {
+ IAlfVariantType* data = 0;
+ const char* dataField = aAttr.getDataField();
+ if (dataField)
+ {
+ data = aData->item(UString(dataField));
+ }
+ return data;
+ }
+
+// ---------------------------------------------------------------------------
+// gets the time from attribute safely.
+// ---------------------------------------------------------------------------
+//
+int getTime(const AlfAttribute& aAttr, bool aImmediate = false)
+ {
+ int time = 0;
+ if (!aImmediate)
+ {
+ time = aAttr.getTime();
+ }
+
+ return time;
+ }
+
+// ---------------------------------------------------------------------------
+// sets source values from aAttr to aPoint.
+// ---------------------------------------------------------------------------
+//
+void setSourceValue(TAlfTimedValue& aValue, const AlfAttribute& aAttr)
+ {
+ if (aAttr.getSourceValueCount() > 0)
+ {
+ aValue.SetValueNow(aAttr.getSourceValue()->realValue());
+ }
+ }
+// ---------------------------------------------------------------------------
+// sets source values to aPoint.
+// ---------------------------------------------------------------------------
+//
+void SetSourceValues(TAlfTimedPoint& aPoint, const AlfAttribute& aAttrX,
+ const AlfAttribute& aAttrY)
+ {
+ if (aAttrX.getSourceValueCount() > 0)
+ {
+ aPoint.iX.SetValueNow(aAttrX.getSourceValue()->realValue());
+ }
+ if (aAttrY.getSourceValueCount() > 0)
+ {
+ aPoint.iY.SetValueNow(aAttrY.getSourceValue()->realValue());
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// sets source values to aRect.
+// ---------------------------------------------------------------------------
+//
+void SetSourceRect(TAlfRealRect& aRect, const AlfAttribute& aAttrTopX,
+ const AlfAttribute& aAttrTopY,
+ const AlfAttribute& aAttrBottomRightX,
+ const AlfAttribute& aAttrBottomRightY)
+ {
+ if (aAttrTopX.getSourceValueCount() > 0)
+ {
+ aRect.iTl.iX = aAttrTopX.getSourceValue()->realValue();
+ }
+ if (aAttrTopY.getSourceValueCount() > 0)
+ {
+ aRect.iTl.iY = aAttrTopY.getSourceValue()->realValue();
+ }
+ if (aAttrBottomRightX.getSourceValueCount() > 0)
+ {
+ aRect.iBr.iX = aAttrBottomRightX.getSourceValue()->realValue();
+ }
+ if (aAttrBottomRightY.getSourceValueCount() > 0)
+ {
+ aRect.iBr.iY = aAttrBottomRightY.getSourceValue()->realValue();
+ }
+ }
+
+// ======== MEMBER FUNCTIONS ========
+
+// ---------------------------------------------------------------------------
+// Constructor.
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT AlfCommonVisualAttributeSetter::AlfCommonVisualAttributeSetter()
+ {
+ }
+
+// ---------------------------------------------------------------------------
+// Destructor.
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT AlfCommonVisualAttributeSetter::~AlfCommonVisualAttributeSetter()
+ {
+ }
+
+// ---------------------------------------------------------------------------
+// creates one command.
+// deprecated
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT TAlfCommand* AlfCommonVisualAttributeSetter::createCommand(
+ CAlfVisual& /*aVisual*/, AlfAttributeContainer* /*aContainer*/,
+ IAlfMap* /*aData*/, int /*aTransitionTime*/, CAlfVisual* /*aRefVisual*/ )
+ {
+ return 0;
+ }
+
+// ---------------------------------------------------------------------------
+// creates and sends one or more commands.
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT void AlfCommonVisualAttributeSetter::createAndSendCommands(
+ CAlfVisual& aVisual,
+ AlfAttributeContainer* aContainer,
+ CAlfVisual* aRefVisual )
+ {
+ unsigned int attrCount = aContainer->attributeCount();
+
+ for ( int i = 0; i < attrCount; ++i )
+ {
+ AlfAttribute& attr = aContainer->getAttribute(i);
+ sendCommandsForAttribute(aVisual, *aContainer, attr, aRefVisual);
+ }
+
+ // Call the base class implementation also.
+ // It goes through the same loop again and checks if there are attributes
+ // that it handles.
+ AlfCommonAttributeSetter::createAndSendCommands(
+ aVisual,
+ aContainer,
+ aRefVisual );
+ }
+
+// ---------------------------------------------------------------------------
+// Sets an value of a static attribute to target visual immediately
+// without a transition.
+// ---------------------------------------------------------------------------
+//
+void AlfCommonVisualAttributeSetter::handleStaticAttribute(
+ CAlfVisual &aVisual, AlfAttribute& aAttr,
+ AlfAttributeContainer& aContainer)
+ {
+ const char* attrName = aAttr.name();
+ if ( !strcmp(attrName, KParentVisual))
+ {
+ }
+ else if (!strcmp(attrName, KMaxHeight)||!strcmp(attrName, KMaxWidth))
+ {
+ setMaxSize(aVisual,aContainer,NULL);
+ }
+ else if (!strcmp(attrName, KMinHeight)||!strcmp(attrName, KMinWidth))
+ {
+ setMinSize(aVisual,aContainer,NULL);
+ }
+ else if (!strcmp(attrName, KPaddingTop)||!strcmp(attrName, KPaddingBottom)
+ ||!strcmp(attrName, KPaddingLeft)||!strcmp(attrName, KPaddingRight))
+ {
+ setPadding(aVisual,aContainer,NULL);
+
+ }
+ else if (!strcmp(attrName, KSetFlags))
+ {
+ int val = aAttr.intValue();
+ aVisual.SetFlags(val);
+ }
+ else if (!strcmp(attrName, KClearFlags))
+ {
+ int val = aAttr.intValue();
+ aVisual.ClearFlags(val);
+ }
+ else if (!strcmp(attrName, KEventInput) || !strcmp(attrName, KFeedbackType))
+ {
+ setTactileFeedback(aVisual,aContainer,NULL);
+ }
+ // turnangle and secondaryalpha are implemented by derived attributesetters
+ else
+ {
+ //check, if dynamic attribute, if so, set attributes immediately.
+ if (!doHandleDynamicAttribute(aVisual, aAttr, aContainer, true))
+ {
+ //not handled here, try base class.
+ AlfCommonAttributeSetter::handleStaticAttribute(aVisual,
+ aAttr, aContainer);
+ }
+ }
+ }
+
+void AlfCommonVisualAttributeSetter::setTactileFeedback(CAlfVisual &aVisual,AlfAttributeContainer& aContainer,IAlfMap* /*aData*/)
+ {
+ TRAPD( error, aVisual.SetTactileFeedbackL(
+ aContainer.getAttributeByName( KEventInput ).intValue(),
+ aContainer.getAttributeByName( KFeedbackType ).intValue() ) );
+
+ if(error != KErrNone)
+ {
+ ALF_THROW(AlfVisualException,EInvalidAttribute,"AlfCommonVisualAttributeSetter")
+ }
+ try
+ {
+ aContainer.getAttributeByName( duiuimodel::tactileattributes::KEventInput ).setDirty( false );
+ aContainer.getAttributeByName( duiuimodel::tactileattributes::KFeedbackType ).setDirty( false );
+ }
+
+ catch( AlfDataException& exception )
+ {
+ //exception needed here?
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// Sets an dynamic attribute value in the target visual
+// using transitions defined in attributes
+// ---------------------------------------------------------------------------
+//
+void AlfCommonVisualAttributeSetter::handleDynamicAttribute(
+ CAlfVisual& aVisual, AlfAttribute& aAttr,
+ AlfAttributeContainer& aContainer)
+ {
+ if (!doHandleDynamicAttribute(aVisual, aAttr, aContainer))
+ {
+ //not handled here, try base class.
+ AlfCommonAttributeSetter::handleDynamicAttribute(aVisual, aAttr,
+ aContainer);
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// Sets an value for static attribute in the target visual immediately
+// without a transition using data in map.
+// ---------------------------------------------------------------------------
+//
+void AlfCommonVisualAttributeSetter::handleStaticDataAttribute(
+ CAlfVisual &aVisual, AlfAttribute& aAttr,
+ AlfAttributeContainer& aContainer, IAlfMap* aData)
+ {
+
+ if (aData)
+ {
+ const char* attrName = aAttr.name();
+
+ if (!strcmp(attrName, KMaxHeight))
+ {
+ // If maxheight exists, maxwidth must exists also.
+ const IAlfVariantType* maxHeight = getData(aAttr, aData);
+ const IAlfVariantType* maxWidth = getData(
+ aContainer.getAttributeByName(KMaxWidth), aData);
+
+ if (maxHeight && maxHeight->type() == IAlfVariantType::EReal &&
+ maxWidth && maxWidth->type() == IAlfVariantType::EReal)
+ {
+ TAlfRealSize size( maxWidth->real(), maxHeight->real() );
+ aVisual.SetMaxSize(size);
+ }
+ }
+ else if (!strcmp(attrName, KMinHeight))
+ {
+ //If minheight exists, minwidth must exists also.
+ const IAlfVariantType* minHeight = getData(aAttr, aData);
+ const IAlfVariantType* minWidth = getData(
+ aContainer.getAttributeByName(KMinWidth), aData);
+
+ if (minHeight && minHeight->type() == IAlfVariantType::EReal &&
+ minWidth && minWidth->type() == IAlfVariantType::EReal)
+ {
+ TAlfRealSize size( minWidth->real(), minHeight->real() );
+ aVisual.SetMinSize(size);
+ }
+ }
+ else if (!strcmp(attrName, KPaddingTop))
+ {
+ const IAlfVariantType* top = getData(aAttr, aData);
+ const IAlfVariantType* right = getData(
+ aContainer.getAttributeByName(KPaddingRight), aData);
+ const IAlfVariantType* bottom = getData(
+ aContainer.getAttributeByName(KPaddingBottom), aData);
+ const IAlfVariantType* left = getData(
+ aContainer.getAttributeByName(KPaddingLeft), aData);
+
+ if (top && top->type() == IAlfVariantType::EReal &&
+ right && right->type() == IAlfVariantType::EReal &&
+ bottom && bottom->type() == IAlfVariantType::EReal &&
+ left && left->type() == IAlfVariantType::EReal)
+ {
+ float l = left->real();
+ float r = right->real();
+ float t = top->real();
+ float b = bottom->real();
+ TAlfBoxMetric metric(l, r, t, b);
+ aVisual.SetPadding(metric);
+ }
+ }
+ else if (!strcmp(attrName, KSetFlags))
+ {
+ const IAlfVariantType* flag = getData(aAttr, aData);
+ if (flag && flag->type() == IAlfVariantType::EInt)
+ {
+ int flagValue = flag->integer();
+ aVisual.SetFlags(flagValue);
+ }
+ }
+ else if (!strcmp(attrName, KClearFlags))
+ {
+ const IAlfVariantType* flag = getData(aAttr, aData);
+ if (flag && flag->type() == IAlfVariantType::EInt)
+ {
+ int flagValue = flag->integer();
+ aVisual.ClearFlags(flagValue);
+ }
+ }
+ // turnangle and secondaryalpha are implemented by derived attributesetters
+ else if (strcmp(attrName, KMaxWidth) && //these are already
+ strcmp(attrName, KMinWidth) && //handled above
+ strcmp(attrName, KPaddingRight) &&
+ strcmp(attrName, KPaddingBottom) &&
+ strcmp(attrName, KPaddingLeft))
+ {
+ //check, if dynamic attribute, if so, set attributes immediately.
+ //If not, the function will call baseclass SetAttributeValue.
+ if (!doHandleDynamicDataAttribute(aVisual, aAttr,
+ aContainer, aData, true))
+ {
+ //not handled here, try base class.
+ AlfCommonAttributeSetter::handleStaticDataAttribute(
+ aVisual, aAttr, aContainer, aData);
+ }
+ }
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// From AlfCommonAttributeSetter
+//
+// Sets a value for dynamic data attribute value in the target visual
+// using transitions and data in map.
+// ---------------------------------------------------------------------------
+//
+void AlfCommonVisualAttributeSetter::handleDynamicDataAttribute(
+ CAlfVisual& aVisual, AlfAttribute& aAttr,
+ AlfAttributeContainer& aContainer, IAlfMap* aData)
+ {
+ if (!doHandleDynamicDataAttribute(aVisual, aAttr, aContainer, aData))
+ {
+ //not handled here, try base class.
+ AlfCommonAttributeSetter::handleDynamicDataAttribute(aVisual, aAttr,
+ aContainer, aData);
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// Sets an dynamic attribute value in the target visual
+// using transitions defined in attributes
+// Handles only attributes, belonging to this attributesetter, not bases.
+// ---------------------------------------------------------------------------
+//
+bool AlfCommonVisualAttributeSetter::doHandleDynamicAttribute(
+ CAlfVisual& aVisual, AlfAttribute& aAttr,
+ AlfAttributeContainer& aContainer, bool aImmediate)
+ {
+ const char* attrName = aAttr.name();
+ bool handled = true;
+
+ if ( !strcmp( attrName, KOpacity ) )
+ {
+ TAlfTimedValue v;
+ setSourceValue(v, aAttr);
+
+ float targetValue(aAttr.realValue());
+ int time = getTime(aAttr, aImmediate);
+ v.SetTarget(targetValue, time);
+ v.SetStyle(aAttr.getInterpolationStyle());
+ aVisual.SetOpacity(v);
+ }
+
+ else if (!strcmp( attrName, KPositionX)||!strcmp( attrName, KPositionY)) ////also handles: KPositionY
+ {
+ setPos(aVisual,aContainer,NULL,aImmediate);
+ }
+
+ else if (!strcmp( attrName, KWidth)||!strcmp( attrName, KHeight)) //also handles: KHeight
+ {
+ setSize(aVisual,aContainer,NULL,aImmediate);
+ }
+ else if (!strcmp(attrName, KTopLeftX)||!strcmp(attrName, KTopLeftY)
+ ||!strcmp(attrName, KBottomRightX)||!strcmp(attrName, KBottomRightY))
+ {
+ setRect(aVisual,aContainer,NULL,aImmediate);
+ }
+ else
+ {
+ handled = false;
+ }
+
+ return handled;
+ }
+
+// ---------------------------------------------------------------------------
+// Sets an value for dynamic attribute value in the target visual
+// using transitions and data in map.
+// ---------------------------------------------------------------------------
+//
+bool AlfCommonVisualAttributeSetter::doHandleDynamicDataAttribute(
+ CAlfVisual& aVisual, AlfAttribute& aAttr,
+ AlfAttributeContainer& aContainer, IAlfMap* aData, bool aImmediate )
+ {
+ bool handled = true;
+ if (aData)
+ {
+ const char* attrName = aAttr.name();
+
+ if ( !strcmp( attrName, KOpacity ) )
+ {
+ const IAlfVariantType* data = getData(aAttr, aData);
+ if (data && data->type() == IAlfVariantType::EReal)
+ {
+ TAlfTimedValue v;
+ setSourceValue(v, aAttr);
+
+ float targetValue(data->real());
+ int time = getTime(aAttr, aImmediate);
+ v.SetTarget(targetValue, time);
+ v.SetStyle(aAttr.getInterpolationStyle());
+ aVisual.SetOpacity(v);
+ }
+ }
+ else if (!strcmp( attrName, KPositionX)) //also handles: KPositionY
+ {
+ //If positionx exists, positiony must exists also
+ const AlfAttribute& attrX = aAttr;
+ const AlfAttribute& attrY = aContainer.getAttributeByName(KPositionY);
+
+ const IAlfVariantType* posX = getData(attrX, aData);
+ const IAlfVariantType* posY = getData(attrY, aData);
+
+ if (posX && posX->type() == IAlfVariantType::EReal &&
+ posY && posY->type() == IAlfVariantType::EReal)
+ {
+ TAlfTimedPoint pos;
+ SetSourceValues(pos, attrX, attrY);
+
+ pos.iX.SetStyle(attrX.getInterpolationStyle());
+ pos.iX.SetTarget(posX->real(), getTime(attrX, aImmediate));
+ pos.iY.SetStyle(attrY.getInterpolationStyle());
+ pos.iY.SetTarget(posY->real(), getTime(attrY, aImmediate));
+ aVisual.SetPos(pos);
+ }
+ }
+ else if (!strcmp( attrName, KWidth)) //also handles: KHeight
+ {
+ const AlfAttribute& attrWidth = aAttr;
+ const AlfAttribute& attrHeight =
+ aContainer.getAttributeByName(KHeight);
+
+ const IAlfVariantType* width = getData(attrWidth, aData);
+ const IAlfVariantType* height = getData(attrHeight, aData);
+
+ if (width && width->type() == IAlfVariantType::EReal &&
+ height && height->type() == IAlfVariantType::EReal)
+ {
+ TAlfTimedPoint size;
+ SetSourceValues(size, attrWidth, attrHeight);
+
+ size.iX.SetStyle(attrWidth.getInterpolationStyle());
+ size.iX.SetTarget(width->real(),
+ getTime(attrWidth, aImmediate));
+ size.iY.SetStyle(attrHeight.getInterpolationStyle());
+ size.iY.SetTarget(height->real(),
+ getTime(attrHeight, aImmediate));
+
+ aVisual.SetSize(size);
+ }
+ }
+ else if (!strcmp(attrName, KTopLeftX))
+ {
+ //If topleftx exists, topy, bottomx and bottomy must exists also
+ const AlfAttribute& attrTopX = aAttr;
+ const AlfAttribute& attrTopY =
+ aContainer.getAttributeByName(KTopLeftY);
+ const AlfAttribute& attrBottomRightX =
+ aContainer.getAttributeByName(KBottomRightX);
+ const AlfAttribute& attrBottomRightY =
+ aContainer.getAttributeByName(KBottomRightY);
+
+ const IAlfVariantType* topX = getData(attrTopX, aData);
+ const IAlfVariantType* topY = getData(attrTopY, aData);
+ const IAlfVariantType* bottomX = getData(attrBottomRightX, aData);
+ const IAlfVariantType* bottomY = getData(attrBottomRightY, aData);
+
+ if (topX && topX->type() == IAlfVariantType::EReal &&
+ topY && topY->type() == IAlfVariantType::EReal &&
+ bottomX && bottomX->type() == IAlfVariantType::EReal &&
+ bottomY && bottomY->type() == IAlfVariantType::EReal)
+ {
+ const TAlfRealPoint sTopLeft(aVisual.Pos().ValueNow());
+ TAlfRealPoint size(aVisual.Size().ValueNow());
+ TAlfRealRect sRect(sTopLeft, TAlfRealPoint(
+ sTopLeft.iX + size.iX, sTopLeft.iY + size.iY));
+
+ SetSourceRect(sRect, attrTopX, attrTopY, attrBottomRightX,
+ attrBottomRightY);
+
+ aVisual.SetRect(sRect, 0);
+
+ TAlfRealPoint topLeft(topX->real(), topY->real());
+ TAlfRealPoint bottomRight(bottomX->real(), bottomY->real());
+ TAlfRealRect realRect(topLeft, bottomRight);
+ aVisual.SetRect(realRect, getTime(aAttr, aImmediate));
+ }
+ }
+ else if (strcmp(attrName, KPositionY) && //these are already
+ strcmp(attrName, KHeight) && //handled above
+ strcmp(attrName, KTopLeftY) &&
+ strcmp(attrName, KBottomRightX) &&
+ strcmp(attrName, KBottomRightY))
+ {
+ handled = false;
+ }
+ }
+
+ return handled;
+ }
+
+// ---------------------------------------------------------------------------
+// Creates and returns one command
+// ---------------------------------------------------------------------------
+//
+void AlfCommonVisualAttributeSetter::sendCommandsForAttribute(
+ CAlfVisual& aVisual, AlfAttributeContainer& aContainer,
+ AlfAttribute& aAttr, CAlfVisual* aRefVisual)
+ {
+ const char* attrName = aAttr.name();
+
+ if ( !strcmp( attrName, KOpacity ) )
+ {
+ float value(aAttr.realValue());
+
+ if (aRefVisual)
+ {
+ // Add the opacity of the reference visual to the value
+ // of the opacity provided in the attribute
+ value += aRefVisual->Opacity().ValueNow();
+ }
+
+ int time = getTime(aAttr);
+
+ //setting interpolation style
+ TAlfInterpolationStyle style = aAttr.getInterpolationStyle();
+ TAlfTimedValue v;
+ v.SetStyle(style);
+ aVisual.SetOpacity(v);
+
+ //create command
+ TAlfValueCommand cmd(&aVisual, EAlfValueCommandVisualSetOpacity,
+ EAlfOpSet, value, time);
+
+ //send with delay.
+ CAlfEnv::Static()->Send(cmd, aAttr.getDelay());
+ }
+
+ else if (!strcmp( attrName, KPositionX)) ////also handles: KPositionY
+ {
+ // Must contain both KPositionX and KPositionY
+ const AlfAttribute& posXattrib = aAttr;
+ const AlfAttribute& posYattrib =
+ aContainer.getAttributeByName(KPositionY);
+
+ TAlfRealPoint value(posXattrib.realValue(),
+ posYattrib.realValue());
+
+ if ( aRefVisual )
+ {
+ value += aRefVisual->Pos().ValueNow(); // Add the reference point
+ }
+
+ int time = getTime(aAttr);
+
+ //create command
+ TAlfPointCommand cmd(&aVisual, EAlfPointCommandVisualSetPos,
+ value, time);
+
+ //send with delay.
+ CAlfEnv::Static()->Send(cmd, aAttr.getDelay());
+ }
+
+ else if (!strcmp( attrName, KWidth)) //also handles: KHeight
+ {
+ // Must contain both KWidth and KHeight
+ const AlfAttribute& widthAttrib = aAttr;
+ const AlfAttribute& heightAttrib =
+ aContainer.getAttributeByName(KHeight);
+
+ TAlfRealPoint value(widthAttrib.realValue(),
+ heightAttrib.realValue());
+
+ if (aRefVisual)
+ {
+ value += aRefVisual->Size().ValueNow(); // Add the reference point
+ }
+ int time = getTime(aAttr);
+
+ //create command
+ TAlfPointCommand cmd(&aVisual,
+ EAlfPointCommandVisualSetSize, value, time);
+
+ //send with delay.
+ CAlfEnv::Static()->Send(cmd, aAttr.getDelay());
+ }
+ else if (!strcmp(attrName, KTopLeftX))
+ {
+ //If topleftx exists, topy, bottomx and bottomy must exists also
+ float topX = aAttr.realValue();
+ const AlfAttribute& attrTopY =
+ aContainer.getAttributeByName(KTopLeftY);
+ const AlfAttribute& attrBottomX =
+ aContainer.getAttributeByName(KBottomRightX);
+ const AlfAttribute& attrBottomY =
+ aContainer.getAttributeByName(KBottomRightY);
+ TAlfRealPoint topLeft(topX, attrTopY.realValue());
+ TAlfRealPoint size(attrBottomX.realValue() - topLeft.iX,
+ attrBottomY.realValue() - topLeft.iY);
+ if (aRefVisual)
+ {
+ // Add the reference point
+ topLeft += aRefVisual->Pos().ValueNow();
+ size += aRefVisual->Size().ValueNow();
+ }
+
+ int posTime = getTime(aAttr);
+ int sizeTime = getTime(attrBottomX);
+
+ //create position command
+ TAlfPointCommand posCmd(&aVisual, EAlfPointCommandVisualSetPos,
+ topLeft, posTime);
+ TAlfPointCommand sizeCmd(&aVisual, EAlfPointCommandVisualSetPos,
+ size, sizeTime);
+
+ //send with delay.
+ CAlfEnv::Static()->Send(posCmd, aAttr.getDelay());
+ CAlfEnv::Static()->Send(sizeCmd, attrBottomX.getDelay());
+ }
+ }
+
+
+void AlfCommonVisualAttributeSetter::setPadding(CAlfVisual &aVisual,AlfAttributeContainer& aContainer,IAlfMap* /*aData*/)
+ {
+ //If padding-top exists, right, bottom and left must exists also
+
+ AlfAttribute& attrTop =
+ aContainer.getAttributeByName(KPaddingTop);
+ AlfAttribute& attrRight =
+ aContainer.getAttributeByName(KPaddingRight);
+ AlfAttribute& attrBottom =
+ aContainer.getAttributeByName(KPaddingBottom);
+ AlfAttribute& attrLeft =
+ aContainer.getAttributeByName(KPaddingLeft);
+
+ TAlfBoxMetric metric(
+ TAlfMetric(attrLeft.realValue(), attrLeft.unit()),
+ TAlfMetric(attrRight.realValue(), attrRight.unit()),
+ TAlfMetric(attrTop.realValue(), attrTop.unit()),
+ TAlfMetric(attrBottom.realValue(), attrBottom.unit()));
+
+ aVisual.SetPadding(metric);
+
+ attrTop.setDirty(false);
+ attrRight.setDirty(false);
+ attrBottom.setDirty(false);
+ attrLeft.setDirty(false);
+
+ }
+
+void AlfCommonVisualAttributeSetter::setMinSize(CAlfVisual &aVisual,AlfAttributeContainer& aContainer,IAlfMap* /*aData*/)
+ {
+ //If minheight exists, minwidth must exists also.
+ AlfAttribute& attrHt =
+ aContainer.getAttributeByName(KMinHeight);
+ AlfAttribute& attrWidth =
+ aContainer.getAttributeByName(KMinWidth);
+ float height = attrHt.realValue();
+ float width = attrWidth.realValue();
+ TAlfRealSize size( width, height );
+
+ aVisual.SetMinSize(size);
+
+ attrHt.setDirty(false);
+ attrWidth.setDirty(false);
+ }
+
+void AlfCommonVisualAttributeSetter::setMaxSize(CAlfVisual &aVisual,AlfAttributeContainer& aContainer,IAlfMap* /*aData*/)
+ {
+ AlfAttribute& attrHt =
+ aContainer.getAttributeByName(KMaxHeight);
+ AlfAttribute& attrWidth =
+ aContainer.getAttributeByName(KMaxWidth);
+ float height = attrHt.realValue();
+ float width = attrWidth.realValue();
+ TAlfRealSize size( width, height );
+
+ aVisual.SetMaxSize(size);
+
+
+ attrHt.setDirty(false);
+ attrWidth.setDirty(false);
+
+
+ }
+
+void AlfCommonVisualAttributeSetter::setSize(CAlfVisual &aVisual,AlfAttributeContainer& aContainer,IAlfMap* /*aData*/,bool aImmediate)
+ {
+ // Must contain both KWidth and KHeight
+ AlfAttribute& attrWidth =
+ aContainer.getAttributeByName(KWidth);;
+ AlfAttribute& attrHeight =
+ aContainer.getAttributeByName(KHeight);
+
+ TAlfTimedPoint size(aVisual.Size());
+ SetSourceValues(size, attrWidth, attrHeight);
+
+ size.iX.SetStyle(attrWidth.getInterpolationStyle());
+ size.iX.SetTarget(attrWidth.realValue(),
+ getTime(attrWidth, aImmediate));
+ size.iY.SetStyle(attrHeight.getInterpolationStyle());
+ size.iY.SetTarget(attrHeight.realValue(),
+ getTime(attrHeight, aImmediate));
+
+
+ aVisual.SetSize(size);
+
+
+ attrWidth.setDirty(false);
+ attrHeight.setDirty(false);
+ }
+
+void AlfCommonVisualAttributeSetter::setPos(CAlfVisual &aVisual,AlfAttributeContainer& aContainer,IAlfMap* /*aData*/,bool aImmediate)
+ {
+ // Must contain both KPositionX and KPositionY
+ AlfAttribute& attrX = aContainer.getAttributeByName(KPositionX);
+ AlfAttribute& attrY = aContainer.getAttributeByName(KPositionY);
+
+ TAlfTimedPoint pos(aVisual.Pos());
+ SetSourceValues(pos, attrX, attrY);
+
+ pos.iX.SetStyle(attrX.getInterpolationStyle());
+ pos.iX.SetTarget(attrX.realValue(), getTime(attrX, aImmediate));
+ pos.iY.SetStyle(attrY.getInterpolationStyle());
+ pos.iY.SetTarget(attrY.realValue(), getTime(attrY, aImmediate));
+
+ aVisual.SetPos(pos);
+
+
+ attrX.setDirty(false);
+ attrY.setDirty(false);
+ }
+
+void AlfCommonVisualAttributeSetter::setRect(CAlfVisual &aVisual,AlfAttributeContainer& aContainer,IAlfMap* /*aData*/,bool aImmediate)
+ {
+ //If topleftx exists, topy, bottomx and bottomy must exists also
+ AlfAttribute& attrTopX =
+ aContainer.getAttributeByName(KTopLeftX);
+ AlfAttribute& attrTopY =
+ aContainer.getAttributeByName(KTopLeftY);
+ AlfAttribute& attrBottomRightX =
+ aContainer.getAttributeByName(KBottomRightX);
+ AlfAttribute& attrBottomRightY =
+ aContainer.getAttributeByName(KBottomRightY);
+
+ const TAlfRealPoint sTopLeft(aVisual.Pos().ValueNow());
+ TAlfRealPoint size(aVisual.Size().ValueNow());
+ TAlfRealRect sRect(sTopLeft, TAlfRealPoint(sTopLeft.iX + size.iX,
+ sTopLeft.iY + size.iY));
+
+ SetSourceRect(sRect, attrTopX, attrTopY, attrBottomRightX,
+ attrBottomRightY);
+
+ aVisual.SetRect(sRect, 0);
+
+ TAlfRealPoint tTopLeft(attrTopX.realValue(), attrTopY.realValue());
+ TAlfRealPoint tBottomRight(attrBottomRightX.realValue(),
+ attrBottomRightY.realValue());
+ TAlfRealRect tRealRect(tTopLeft, tBottomRight);
+
+ int time = getTime(attrTopX, aImmediate);
+ aVisual.SetRect(tRealRect, time);
+
+
+ attrTopX.setDirty(false);
+ attrTopY.setDirty(false);
+ attrBottomRightX.setDirty(false);
+ attrBottomRightY.setDirty(false);
+
+ }
+} // Alf