diff -r 000000000000 -r 15bf7259bb7c uiacceltk/hitchcock/Client/src/alfcommand.cpp
--- /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 );
+    }
+