--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uiacceltk/hitchcock/Client/src/alfcommand.cpp Tue Feb 02 07:56:43 2010 +0200
@@ -0,0 +1,882 @@
+/*
+* 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: Implementation of the commands
+*
+*/
+
+
+
+#include "alf/alfcommand.h"
+#include "alf/alfevent.h"
+#include "alf/alfcontrol.h"
+#include "alf/alfenv.h"
+#include "alf/alftextvisual.h"
+#include "alf/alfeventhandler.h"
+#include "alf/alfdisplay.h"
+#include "alf/alfroster.h"
+#include "alf/alfcontrolgroup.h"
+#include "alf/alfimagevisual.h"
+#include "alf/alftransformation.h"
+#include "alflogger.h"
+
+// ======== MEMBER FUNCTIONS ========
+
+
+EXPORT_C TAlfCommand::TAlfCommand(TAlfCommandType aType)
+ : iType(aType)
+ {
+ }
+
+
+EXPORT_C TAlfCommand::~TAlfCommand()
+ {
+ }
+
+
+EXPORT_C TAlfCommandType TAlfCommand::Type() const
+ {
+ return iType;
+ }
+
+EXPORT_C void TAlfCommand::CommandExtension(const TUid& /*aExtensionUid*/, TAny** /*aExtensionParams*/)
+ {
+ }
+
+
+EXPORT_C const TAlfObjectCommand* TAlfCommand::ObjectCommand() const
+ {
+ return NULL;
+ }
+
+// GROUP COMMAND
+
+EXPORT_C TAlfGroupCommand::TAlfGroupCommand(CAlfControlGroup& aGroup, TAlfOp aOperation,
+ CAlfDisplay* aDisplay)
+ : TAlfObjectCommand(EAlfCommandTypeGroup, &aGroup, aOperation),
+ iDisplay(aDisplay)
+ {
+ }
+
+
+EXPORT_C void TAlfGroupCommand::ExecuteL(CAlfEnv& /*aEnv*/) const
+ {
+ __ALFLOGSTRING1( "TAlfGroupCommand::ExecuteL operation %d", Operation() )
+ switch(Operation())
+ {
+ case EAlfOpShow:
+ if(iDisplay)
+ {
+ iDisplay->Roster().ShowL(ControlGroup());
+ }
+ break;
+
+ case EAlfOpHide:
+ if(iDisplay)
+ {
+ iDisplay->Roster().Hide(ControlGroup());
+ }
+ break;
+
+ case EAlfOpEnableInput:
+ ControlGroup().SetAcceptInput(ETrue);
+ break;
+
+ case EAlfOpDisableInput:
+ ControlGroup().SetAcceptInput(EFalse);
+ break;
+
+ default:
+ __ALFLOGSTRING1( "TAlfGroupCommand::ExecuteL Unknown operation %d", Operation() )
+ break;
+ }
+ }
+
+
+EXPORT_C TInt TAlfGroupCommand::Size() const
+ {
+ return sizeof(*this);
+ }
+
+
+EXPORT_C CAlfControlGroup& TAlfGroupCommand::ControlGroup() const
+ {
+ return *(CAlfControlGroup*) Object();
+ }
+
+
+EXPORT_C CAlfDisplay* TAlfGroupCommand::Display() const
+ {
+ return iDisplay;
+ }
+
+EXPORT_C void TAlfGroupCommand::CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams)
+ {
+ TAlfObjectCommand::CommandExtension( aExtensionUid, aExtensionParams );
+ }
+
+// CONTROL COMMAND
+
+EXPORT_C TAlfControlCommand::TAlfControlCommand(CAlfControl& aControl, TAlfOp aOperation)
+ : TAlfObjectCommand(EAlfCommandTypeControl, &aControl, aOperation)
+ {
+ }
+
+
+EXPORT_C void TAlfControlCommand::ExecuteL(CAlfEnv& /*aEnv*/) const
+ {
+ __ALFLOGSTRING1( "TAlfControlCommand::ExecuteL Unknown operation %d", Operation() )
+ }
+
+
+EXPORT_C TInt TAlfControlCommand::Size() const
+ {
+ return sizeof(*this);
+ }
+
+
+EXPORT_C CAlfControl& TAlfControlCommand::Control() const
+ {
+ return *(CAlfControl*) Object();
+ }
+
+EXPORT_C void TAlfControlCommand::CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams)
+ {
+ TAlfObjectCommand::CommandExtension( aExtensionUid, aExtensionParams );
+ }
+
+// VISUAL COMMAND
+
+
+EXPORT_C TAlfVisualCommand::TAlfVisualCommand(CAlfVisual& aVisual, TAlfOp aOperation,
+ TInt aSetFlags, TInt aClearFlags)
+ : TAlfObjectCommand(EAlfCommandTypeVisual, &aVisual, aOperation),
+ iSetFlags(aSetFlags), iClearFlags(aClearFlags)
+ {
+ }
+
+
+EXPORT_C void TAlfVisualCommand::ExecuteL(CAlfEnv& /*aEnv*/) const
+ {
+ switch(Operation())
+ {
+ case EAlfOpRemoveAndDestroyAll:
+ Visual().RemoveAndDestroyAllD();
+ // The object is no longer valid after this.
+ break;
+ case EAlfOpEnableTransformation:
+ Visual().EnableTransformationL(ETrue);
+ break;
+
+ case EAlfOpDisableTransformation:
+ Visual().EnableTransformationL(EFalse);
+ break;
+
+ case EAlfOpModifyFlags:
+ if(iSetFlags)
+ {
+ Visual().SetFlags(iSetFlags);
+ }
+ if(iClearFlags)
+ {
+ Visual().ClearFlags(iClearFlags);
+ }
+ break;
+
+ default:
+ __ALFLOGSTRING1( "TAlfVisualCommand::ExecuteL Unknown operation %d", Operation() )
+ break;
+ }
+ }
+
+
+EXPORT_C TInt TAlfVisualCommand::Size() const
+ {
+ return sizeof(*this);
+ }
+
+
+EXPORT_C CAlfVisual& TAlfVisualCommand::Visual() const
+ {
+ return *(CAlfVisual*) Object();
+ }
+
+
+EXPORT_C TInt TAlfVisualCommand::FlagsToSet() const
+ {
+ return iSetFlags;
+ }
+
+
+EXPORT_C TInt TAlfVisualCommand::FlagsToClear() const
+ {
+ return iClearFlags;
+ }
+
+EXPORT_C void TAlfVisualCommand::CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams)
+ {
+ TAlfObjectCommand::CommandExtension( aExtensionUid, aExtensionParams );
+ }
+
+// IMAGE COMMAND
+
+EXPORT_C TAlfImageCommand::TAlfImageCommand(CAlfImageVisual& aImageVisual,
+ const TAlfImage& aImage,
+ TAlfOp aOperation)
+ : TAlfObjectCommand(EAlfCommandTypeImage, &aImageVisual, aOperation),
+ iImage(aImage)
+ {
+ }
+
+
+EXPORT_C void TAlfImageCommand::ExecuteL(CAlfEnv& /*aEnv*/) const
+ {
+ switch(Operation())
+ {
+ case EAlfOpSetPrimaryImage:
+ ImageVisual().SetImage(iImage);
+ break;
+
+ case EAlfOpSetSecondaryImage:
+ ImageVisual().SetSecondaryImage(iImage);
+ break;
+
+ default:
+ __ALFLOGSTRING1( "TAlfImageCommand::ExecuteL Unknown operation %d", Operation() )
+ break;
+ }
+ }
+
+
+EXPORT_C TInt TAlfImageCommand::Size() const
+ {
+ return sizeof(*this);
+ }
+
+
+EXPORT_C CAlfImageVisual& TAlfImageCommand::ImageVisual() const
+ {
+ return *(CAlfImageVisual*) Object();
+ }
+
+
+EXPORT_C const TAlfImage& TAlfImageCommand::Image() const
+ {
+ return iImage;
+ }
+
+EXPORT_C void TAlfImageCommand::CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams)
+ {
+ TAlfObjectCommand::CommandExtension( aExtensionUid, aExtensionParams );
+ }
+
+
+// ACTION COMMAND
+
+EXPORT_C TAlfActionCommand::TAlfActionCommand(TInt aId)
+ : TAlfCommand(EAlfCommandTypeAction), iId(aId)
+ {
+ }
+
+EXPORT_C void TAlfActionCommand::ExecuteL(CAlfEnv& aEnv) const
+ {
+ TInt error = aEnv.ReportAction(*this);
+ if(error != KErrNone)
+ {
+ // Leave with the error code if one of the observers failed.
+ User::Leave(error);
+ }
+ }
+
+EXPORT_C TInt TAlfActionCommand::Size() const
+ {
+ return sizeof(*this);
+ }
+
+
+EXPORT_C TInt TAlfActionCommand::Id() const
+ {
+ return iId;
+ }
+
+EXPORT_C void TAlfActionCommand::CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams)
+ {
+ TAlfCommand::CommandExtension( aExtensionUid, aExtensionParams );
+ }
+
+// OBJECT COMMAND
+
+
+EXPORT_C TAlfObjectCommand::TAlfObjectCommand(TAlfCommandType aType, TAny* aDataOwnerObject, TAlfOp aOperation)
+ : TAlfCommand(aType), iObject(aDataOwnerObject), iOperation(aOperation)
+ {
+ }
+
+EXPORT_C TInt TAlfObjectCommand::Size() const
+ {
+ return sizeof(*this);
+ }
+
+EXPORT_C void TAlfObjectCommand::ExecuteL(CAlfEnv& /*aEnv*/) const
+ {
+ __ALFLOGSTRING1( "TAlfObjectCommand::ExecuteL Unknown operation %d", Operation() )
+ }
+
+EXPORT_C TAny* TAlfObjectCommand::Object() const
+ {
+ return iObject;
+ }
+
+
+EXPORT_C TAlfOp TAlfObjectCommand::Operation() const
+ {
+ return iOperation;
+ }
+
+
+EXPORT_C const TAlfObjectCommand* TAlfObjectCommand::ObjectCommand() const
+ {
+ // All object commands can be casted to TAlfObjectCommand.
+ return this;
+ }
+
+EXPORT_C void TAlfObjectCommand::CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams)
+ {
+ TAlfCommand::CommandExtension( aExtensionUid, aExtensionParams );
+ }
+
+
+// TEXT COMMAND
+
+EXPORT_C TAlfTextCommand::TAlfTextCommand(CAlfTextVisual& aTextVisual, const TDesC& aText,
+ TAlfOp aOperation)
+ : TAlfObjectCommand(EAlfCommandTypeText, &aTextVisual, aOperation),
+ iText(aText)
+ {
+ }
+
+EXPORT_C void TAlfTextCommand::ExecuteL(CAlfEnv& /*aEnv*/) const
+ {
+ switch(Operation())
+ {
+ case EAlfOpSetText:
+ TextVisual().SetTextL(iText);
+ break;
+
+ default:
+ __ALFLOGSTRING1( "TAlfTextCommand::ExecuteL Unknown operation %d", Operation() )
+ break;
+ }
+ }
+
+
+EXPORT_C TInt TAlfTextCommand::Size() const
+ {
+ return sizeof(*this);
+ }
+
+
+EXPORT_C CAlfTextVisual& TAlfTextCommand::TextVisual() const
+ {
+ return *(CAlfTextVisual*) Object();
+ }
+
+
+EXPORT_C const TDesC& TAlfTextCommand::Text() const
+ {
+ return iText;
+ }
+
+EXPORT_C void TAlfTextCommand::CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams)
+ {
+ TAlfObjectCommand::CommandExtension( aExtensionUid, aExtensionParams );
+ }
+
+// VALUE COMMAND
+
+EXPORT_C TAlfValueCommand::TAlfValueCommand(TAny* aObject, TAlfValueCommandTarget aObjectType,
+ TReal32 aTarget, TInt aTransitionTime) __SOFTFP
+ : TAlfObjectCommand(EAlfCommandTypeValue, aObject, EAlfOpSet),
+ iTimedValue(aObjectType), iTarget(aTarget), iTransitionTime(aTransitionTime),
+ iSpeed(0.0)
+ {
+ }
+
+
+EXPORT_C TAlfValueCommand::TAlfValueCommand(TAny* aObject, TAlfValueCommandTarget aObjectType,
+ TAlfOp aOperation,
+ TReal32 aTarget, TReal32 aTiming) __SOFTFP
+ : TAlfObjectCommand(EAlfCommandTypeValue, aObject, aOperation),
+ iTimedValue(aObjectType), iTarget(aTarget), iTransitionTime(0),
+ iSpeed(0.0)
+ {
+ if(aOperation == EAlfOpSetWithSpeed)
+ {
+ iSpeed = aTiming;
+ }
+ else
+ {
+ iTransitionTime = TInt(aTiming);
+ }
+ }
+
+EXPORT_C void TAlfValueCommand::ExecuteL(CAlfEnv& /*aEnv*/) const
+ {
+ TAlfTimedValue value;
+
+ TInt op = Operation();
+ if(op >= EAlfOpSetStyle && op < EAlfOpSetStyle + EAlfTimedValueStyleLast)
+ {
+ value.SetStyle(TAlfInterpolationStyle(op - EAlfOpSetStyle));
+ }
+
+ switch(Operation())
+ {
+ case EAlfOpSet:
+ {
+ value.SetTarget( iTarget, iTransitionTime );
+ break;
+ }
+ case EAlfOpSetWithSpeed:
+ {
+ value.SetTargetWithSpeed(iTarget, iSpeed);
+ break;
+ }
+ default:
+ __ALFLOGSTRING1( "TAlfValueCommand::ExecuteL Unknown operation %d", Operation() )
+ break;
+ }
+
+ switch( TimedValue() )
+ {
+ case EAlfValueCommandVisualSetOpacity:
+ {
+ CAlfVisual*visual = (CAlfVisual*) Object();
+ visual->SetOpacity( value );
+ break;
+ }
+ default:
+ __ALFLOGSTRING1( "TAlfValueCommand::ExecuteL Unknown target %d", TimedValue() )
+ break;
+ }
+ }
+
+
+EXPORT_C TInt TAlfValueCommand::Size() const
+ {
+ return sizeof(*this);
+ }
+
+
+EXPORT_C TAlfValueCommandTarget TAlfValueCommand::TimedValue() const
+ {
+ return iTimedValue;
+ }
+
+
+EXPORT_C TReal32 TAlfValueCommand::Target() const __SOFTFP
+ {
+ return iTarget;
+ }
+
+
+EXPORT_C TInt TAlfValueCommand::TransitionTime() const
+ {
+ return iTransitionTime;
+ }
+
+
+EXPORT_C TReal32 TAlfValueCommand::Speed() const __SOFTFP
+ {
+ return iSpeed;
+ }
+
+EXPORT_C void TAlfValueCommand::CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams)
+ {
+ TAlfObjectCommand::CommandExtension( aExtensionUid, aExtensionParams );
+ }
+
+// POINT COMMAND
+
+EXPORT_C TAlfPointCommand::TAlfPointCommand(TAny* aObject, TAlfPointCommandTarget aObjectType,
+ TAlfOp aOperation)
+ : TAlfObjectCommand(EAlfCommandTypePoint, aObject, aOperation),
+ iTimedPoint(aObjectType), iTransitionTime(0), iSpeed(0.0)
+ {
+ }
+
+
+EXPORT_C TAlfPointCommand::TAlfPointCommand(TAny* aObject, TAlfPointCommandTarget aObjectType,
+ TAlfRealPoint aTarget, TInt aTransitionTime,
+ TParameterTarget aParameterTarget)
+ : TAlfObjectCommand(EAlfCommandTypePoint, aObject, EAlfOpSet),
+ iTimedPoint(aObjectType), iTarget(aTarget),
+ iTransitionTime(aTransitionTime), iSpeed(0.0), iParameterTarget(aParameterTarget)
+ {
+ }
+
+
+EXPORT_C TAlfPointCommand::TAlfPointCommand(TAny* aObject, TAlfPointCommandTarget aObjectType,
+ TAlfOp aOperation,
+ TAlfRealPoint aTarget, TReal32 aTiming,
+ TParameterTarget aParameterTarget) __SOFTFP
+ : TAlfObjectCommand(EAlfCommandTypePoint, aObject, aOperation),
+ iTimedPoint(aObjectType), iTarget(aTarget),
+ iTransitionTime(0), iSpeed(0.0), iParameterTarget(aParameterTarget)
+ {
+ if(aOperation == EAlfOpSetWithSpeed)
+ {
+ iSpeed = aTiming;
+ }
+ else
+ {
+ iTransitionTime = TInt(aTiming);
+ }
+ }
+
+
+EXPORT_C void TAlfPointCommand::ExecuteL(CAlfEnv& /*aEnv*/) const
+ {
+ TAlfTimedPoint point;
+
+ // Check for interpolation style change ops.
+ TInt op = Operation();
+ if(op >= EAlfOpSetStyle && op < EAlfOpSetStyle + EAlfTimedValueStyleLast)
+ {
+ point.SetStyle(TAlfInterpolationStyle(op - EAlfOpSetStyle));
+ }
+
+ switch( Operation() )
+ {
+ case EAlfOpSet:
+ point.SetTarget(iTarget, iTransitionTime);
+ break;
+
+ case EAlfOpSetWithSpeed:
+ point.SetTargetWithSpeed(iTarget, iSpeed);
+ break;
+
+ default:
+ __ALFLOGSTRING1( "TAlfPointCommand::ExecuteL() - Unknown op %d.", Operation())
+ break;
+ }
+
+ if ( iParameterTarget == EBoth || iParameterTarget == EXOnly )
+ {
+ point.iX.SetTarget( iTarget.iX, iTransitionTime );
+ }
+
+ if ( iParameterTarget == EBoth || iParameterTarget == EYOnly )
+ {
+ point.iY.SetTarget( iTarget.iY, iTransitionTime );
+ }
+
+ switch( TimedPoint() )
+ {
+ case EAlfPointCommandVisualSetPos:
+ {
+ CAlfVisual* visual = (CAlfVisual*) Object();
+ visual->SetPos( point );
+ break;
+ }
+ case EAlfPointCommandVisualSetSize:
+ {
+ CAlfVisual*visual = (CAlfVisual*) Object();
+ visual->SetSize( point );
+ break;
+ }
+
+ default:
+ __ALFLOGSTRING1( "TAlfPointCommand::ExecuteL Unknown target %d", TimedPoint() )
+ break;
+ }
+ }
+
+
+EXPORT_C TInt TAlfPointCommand::Size() const
+ {
+ return sizeof(*this);
+ }
+
+
+EXPORT_C TAlfPointCommandTarget TAlfPointCommand::TimedPoint() const
+ {
+ return iTimedPoint;
+ }
+
+
+EXPORT_C TAlfRealPoint TAlfPointCommand::Target() const
+ {
+ return iTarget;
+ }
+
+
+EXPORT_C TInt TAlfPointCommand::TransitionTime() const
+ {
+ return iTransitionTime;
+ }
+
+
+EXPORT_C TReal32 TAlfPointCommand::Speed() const __SOFTFP
+ {
+ return iSpeed;
+ }
+
+EXPORT_C void TAlfPointCommand::CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams)
+ {
+ TAlfObjectCommand::CommandExtension( aExtensionUid, aExtensionParams );
+ }
+
+// TRANSFORMATION COMMAND
+
+EXPORT_C TAlfTransformationCommand::TAlfTransformationCommand(
+ TAny* aOwner, CAlfTransformation& aTransformation, TAlfOp aOperation, TInt aStep)
+ : TAlfObjectCommand(EAlfCommandTypeTransformation, aOwner, aOperation),
+ iTransformation(aTransformation), iStep(aStep)
+ {
+ // Set default values for transformation
+ switch(aOperation)
+ {
+ case EAlfOpRotate:
+ iX = TAlfTimedValue(0.0f);
+ iY = TAlfTimedValue(0.0f);
+ iZ = TAlfTimedValue(1.0f);
+ break;
+ case EAlfOpScale:
+ iX = TAlfTimedValue(1.0f);
+ iY = TAlfTimedValue(1.0f);
+ iZ = TAlfTimedValue(1.0f);
+ break;
+ default:
+ break;
+ }
+ }
+
+
+EXPORT_C void TAlfTransformationCommand::ExecuteL(CAlfEnv& /*aEnv*/) const
+ {
+ switch(Operation())
+ {
+ case EAlfOpLoadIdentity:
+ iTransformation.LoadIdentity();
+ break;
+
+ case EAlfOpTranslate:
+ if(iStep != EStepNone)
+ {
+ CAlfTransformation::TTransform xs = iTransformation.Step(iStep);
+ xs.iType = CAlfTransformation::ETypeTranslate;
+ xs.iParams[EAlfTransformParamTranslateX] = iX;
+ xs.iParams[EAlfTransformParamTranslateY] = iY;
+ xs.iParams[EAlfTransformParamTranslateZ] = iZ;
+ iTransformation.ReplaceStep(iStep,xs);
+ }
+ else
+ {
+ iTransformation.Translate(iX, iY);
+ }
+ break;
+
+ case EAlfOpScale:
+ if(iStep != EStepNone)
+ {
+ CAlfTransformation::TTransform xs = iTransformation.Step(iStep);
+ xs.iType = CAlfTransformation::ETypeScale;
+ xs.iParams[EAlfTransformParamScaleX] = iX;
+ xs.iParams[EAlfTransformParamScaleY] = iY;
+ xs.iParams[EAlfTransformParamScaleZ] = iZ;
+ iTransformation.ReplaceStep(iStep,xs);
+ }
+ else
+ {
+ iTransformation.Scale(iX, iY, iZ);
+ }
+ break;
+
+ case EAlfOpRotate:
+ if(iStep != EStepNone)
+ {
+ CAlfTransformation::TTransform xs = iTransformation.Step(iStep);
+ xs.iType = CAlfTransformation::ETypeRotate;
+ xs.iParams[EAlfTransformParamRotateAngle] = iAngle;
+ xs.iParams[EAlfTransformParamRotateAxisX] = iX;
+ xs.iParams[EAlfTransformParamRotateAxisY] = iY;
+ xs.iParams[EAlfTransformParamRotateAxisZ] = iZ;
+ iTransformation.ReplaceStep(iStep,xs);
+ }
+ else
+ {
+ TAlfTimedValue unsuspended;
+ unsuspended = iX;
+ TReal32 x = unsuspended.ValueNow();
+ unsuspended = iY;
+ TReal32 y = unsuspended.ValueNow();
+ unsuspended = iZ;
+ TReal32 z = unsuspended.ValueNow();
+ iTransformation.Rotate(iAngle, x, y, z);
+ }
+ break;
+
+ case EAlfOpReplaceStep:
+ {
+ if(iStep != EStepNone)
+ {
+ CAlfTransformation::TTransform xs = iTransformation.Step(iStep);
+ xs.iParams[EAlfTransformParamRotateAngle] = iAngle;
+ xs.iParams[EAlfTransformParamRotateAxisX] = iX;
+ xs.iParams[EAlfTransformParamRotateAxisY] = iY;
+ xs.iParams[EAlfTransformParamRotateAxisZ] = iZ;
+ iTransformation.ReplaceStep(iStep,xs);
+ }
+ break;
+ }
+
+ default:
+ __ALFLOGSTRING1( "TAlfTransformationCommand::ExecuteL Unknown operation %d", Operation() )
+ break;
+ }
+ }
+
+
+EXPORT_C TInt TAlfTransformationCommand::Size() const
+ {
+ return sizeof(*this);
+ }
+
+
+EXPORT_C CAlfTransformation& TAlfTransformationCommand::Transformation() const
+ {
+ return iTransformation;
+ }
+
+
+EXPORT_C TInt TAlfTransformationCommand::Step() const
+ {
+ return iStep;
+ }
+
+
+EXPORT_C void TAlfTransformationCommand::SetX(const TAlfTimedValue& aValue)
+ {
+ iX = aValue;
+ //iX.Suspend();
+ }
+
+
+EXPORT_C void TAlfTransformationCommand::SetY(const TAlfTimedValue& aValue)
+ {
+ iY = aValue;
+ //iY.Suspend();
+ }
+
+
+EXPORT_C void TAlfTransformationCommand::SetZ(const TAlfTimedValue& aValue)
+ {
+ iZ = aValue;
+ //iZ.Suspend();
+ }
+
+
+EXPORT_C void TAlfTransformationCommand::SetAngle(const TAlfTimedValue& aValue)
+ {
+ iAngle = aValue;
+ //iAngle.Suspend();
+ }
+
+EXPORT_C void TAlfTransformationCommand::CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams)
+ {
+ TAlfObjectCommand::CommandExtension( aExtensionUid, aExtensionParams );
+ }
+
+// MARKER COMMAND
+
+EXPORT_C TAlfMarkerCommand::TAlfMarkerCommand(TInt aId)
+ : TAlfCommand(TAlfCommandType(EAlfCommandTypeMarkerFirst + aId))
+ {
+ }
+
+
+EXPORT_C void TAlfMarkerCommand::ExecuteL(CAlfEnv& /*aEnv*/) const
+ {
+ __ALFLOGSTRING1( "TAlfMarkerCommand::ExecuteL - Marker %d reached.", Id() )
+ }
+
+
+EXPORT_C TInt TAlfMarkerCommand::Size() const
+ {
+ return sizeof(*this);
+ }
+
+
+EXPORT_C TInt TAlfMarkerCommand::Id() const
+ {
+ return Type() - EAlfCommandTypeMarkerFirst;
+ }
+
+EXPORT_C void TAlfMarkerCommand::CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams)
+ {
+ TAlfCommand::CommandExtension( aExtensionUid, aExtensionParams );
+ }
+
+// CUSTOM EVENT
+
+EXPORT_C TAlfCustomEventCommand::TAlfCustomEventCommand(
+ TInt aEventParam, MAlfEventHandler* aRecipient, TInt aEventData)
+ : TAlfObjectCommand(EAlfCommandTypeCustomEvent, aRecipient, EAlfOpNone),
+ iEventParam(aEventParam),
+ iEventData(aEventData)
+ {
+ }
+
+
+EXPORT_C void TAlfCustomEventCommand::ExecuteL(CAlfEnv& aEnv) const
+ {
+ TAlfEvent customEvent(iEventParam, iEventData);
+
+ if(Recipient())
+ {
+ Recipient()->OfferEventL(customEvent);
+ }
+ else
+ {
+ aEnv.BroadcastEventL(customEvent);
+ }
+ }
+
+
+EXPORT_C TInt TAlfCustomEventCommand::Size() const
+ {
+ return sizeof(*this);
+ }
+
+
+EXPORT_C MAlfEventHandler* TAlfCustomEventCommand::Recipient() const
+ {
+ return (MAlfEventHandler*) Object();
+ }
+
+EXPORT_C TInt TAlfCustomEventCommand::Param() const
+ {
+ return iEventParam;
+ }
+
+EXPORT_C TInt TAlfCustomEventCommand::EventData() const
+ {
+ return iEventData;
+ }
+
+EXPORT_C void TAlfCustomEventCommand::CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams)
+ {
+ TAlfObjectCommand::CommandExtension( aExtensionUid, aExtensionParams );
+ }
+