/*
* 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