diff -r 000000000000 -r 15bf7259bb7c uiaccelerator_plat/alf_visual_api/inc/alf/alfcommand.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uiaccelerator_plat/alf_visual_api/inc/alf/alfcommand.h Tue Feb 02 07:56:43 2010 +0200 @@ -0,0 +1,1174 @@ +/* +* Copyright (c) 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: ?Description +* +*/ + + + +#ifndef T_ALFCOMMAND_H +#define T_ALFCOMMAND_H + +#include + +class CAlfControl; +class TAlfObjectCommand; +class CAlfEnv; +class CAlfVisual; +class CAlfControlGroup; +class CAlfTextVisual; +class MAlfEventHandler; +class CAlfDisplay; +class CAlfImageVisual; +class CAlfTransformation; + +/** + * Command types. + * All the commands that can be executed by the toolkit are enumerated here. + */ +enum TAlfCommandType + { + + /** None corresponds the base class (TAlfCommand). */ + EAlfCommandTypeNone = 0, + + EAlfCommandTypeObject, + + EAlfCommandTypeAction, + + EAlfCommandTypeGroup, + + EAlfCommandTypeControl, + + EAlfCommandTypeVisual, + + EAlfCommandTypeImage, + + EAlfCommandTypeText, + + EAlfCommandTypeValue, + + EAlfCommandTypePoint, + + EAlfCommandTypeTransformation, + + EAlfCommandTypeCustomEvent, + + /** Marker command type. Types up from here will be used for markers only. */ + EAlfCommandTypeMarkerFirst = 10000, + EAlfCommandTypeMarker0 = EAlfCommandTypeMarkerFirst, + EAlfCommandTypeMarker1, + EAlfCommandTypeMarker2, + EAlfCommandTypeMarker3, + EAlfCommandTypeMarker4, + EAlfCommandTypeMarker5, + EAlfCommandTypeMarker6, + EAlfCommandTypeMarker7, + EAlfCommandTypeMarker8, + EAlfCommandTypeMarker9, + EAlfCommandTypeMarker10 + }; + + +/** + * Command operations. + */ +enum TAlfOp + { + EAlfOpNone = 0, + + /* Control Group operations. */ + EAlfOpHide = 1000, + EAlfOpShow, + EAlfOpEnableInput, + EAlfOpDisableInput, + + /* Control operations. */ + /* (start from 2000) */ // None defined yet. + + /* Visual operations. */ + EAlfOpRemoveAndDestroyAll = 3000, + EAlfOpModifyFlags, + EAlfOpSetPrimaryImage, + EAlfOpSetSecondaryImage, + EAlfOpSetText, + EAlfOpEnableTransformation, + EAlfOpDisableTransformation, + + /* Timed value operations. */ + EAlfOpSet = 4000, + EAlfOpSetWithSpeed, + + /* Timed value style operations. The actual is: + TAlfInterpolationStyle(iOperation - EAlfOpSetStyle) */ + EAlfOpSetStyle = 5000, + + /* Transformation operations. */ + EAlfOpLoadIdentity = 6000, + EAlfOpTranslate, + EAlfOpScale, + EAlfOpRotate, + EAlfOpReplaceStep + }; + +/** + * Object types. + * These are the different types of objects which can issue and receive commands. + */ +enum TAlfCommandObjectType + { + EAlfCommandObjectTypeNone, + + /** This object is a visual. */ + EAlfCommandObjectTypeVisual, + + /** This object is a control. */ + EAlfCommandObjectTypeControl, + + /** This object is a control group. */ + EAlfCommandObjectTypeControlGroup + }; + +/** + * Value command target + * + */ +enum TAlfValueCommandTarget + { + EAlfValueCommandVisualSetOpacity + }; + +/** + * Point command target + * + */ +enum TAlfPointCommandTarget + { + EAlfPointCommandVisualSetPos, + EAlfPointCommandVisualSetSize + }; + +/** + * TAlfCommand is the base class of all commands. A command is an + * instruction to some class that can be set to occur some time in the future. + * Each command stores information about an operation. Each command is also responsible for + * the execution of the command. + * Commands are processed by the class's OfferEventL() method. + */ +class TAlfCommand + { +public: + + /* Destructor. */ + + IMPORT_C virtual ~TAlfCommand(); + + + /* Methods. */ + + IMPORT_C TAlfCommandType Type() const; + + /** + * Returns a pointer to the command casted to TAlfObjectCommand. + * If this is not possible (the command is not derived from + * TAlfObjectCommand), returns NULL instead. + */ + IMPORT_C virtual const TAlfObjectCommand* ObjectCommand() const; + + /** + * Executes the command. + * + * @param aEnv The environment in which the command is being executed. + */ + virtual void ExecuteL(CAlfEnv& aEnv) const = 0; + + /** + * Returns the size of the command. + */ + virtual TInt Size() const = 0; + +protected: + + /* Constructor. */ + + /** + * Protected constructor. + * + * @param aType Type of the command. + */ + IMPORT_C TAlfCommand(TAlfCommandType aType); + + IMPORT_C virtual void CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams); + +private: + + /* These member variables are shared by all commands. */ + + /** Type of the command. Depends on the command class. */ + TAlfCommandType iType; + +private: + TInt iSpare1; + TInt iSpare2; + }; + +/** + * TAlfActionCommand is a simple action that triggers an action notification. + * + * They are reserved for notifying observers of user-initiated actions in the user + * interface. + * For example, a button control might send an action command when the user clicks on + * the button. + * + * Usage: + * @code + * + * //Candidate, interested in action notification, should implement + * // MAlfActionObserver interface + * class ActionCommandTest : public MAlfActionObserver + * { + * public: + * ..... + * ..... + * ..... + * void HandleAction( const TAlfActionCommand& aActionCommand ); + * }; + * + * // From MAlfActionObserver + * void ActionCommandTest::HandleAction( const TAlfActionCommand& aActionCommand ) + * { + * //Perform required action on notification + * } + * ------------------------------------------------------------------------------- + * //Observer registrartion + * ActionCommandTest* testClass = new ActionCommandTest(); + * + * //Create command + * TAlfActionCommand command( 1 ); + * + * //Register test command as observer to environment + * iEnv->AddActionObserverL( testClass ); + * + * //Send command + * iEnv->Send( command, 1 ); + * + * //Cleanup + * iEnv->RemoveActionObserver( testClass ); + * delete testClass; + * + * @endcode + * + * @see MAlfActionObserver + * @see CAlfEnv::AddActionObserverL() + * @see CAlfEnv::RemoveActionObserver() + */ + class TAlfActionCommand : public TAlfCommand + { +public: + + /* Constructor. */ + + /** + * Constructs a new action command. + * + * @param aId Identifier of the action. + */ + IMPORT_C TAlfActionCommand(TInt aId); + + /* Methods. */ + + /* Implementation of TAlfCommand::ExecuteL(). */ + IMPORT_C void ExecuteL(CAlfEnv& aEnv) const; + + /* Implementation of TAlfCommand::Size(). */ + IMPORT_C TInt Size() const; + + /** + * Determines the action identifier of the command. + * + * @param Action identifier. + */ + IMPORT_C TInt Id() const; + + +protected: + + IMPORT_C void CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams); + +private: + + /** Action identifier. */ + TInt iId; + +private: + TInt iSpare1; + TInt iSpare2; + }; + +/** + * TAlfObjectCommand is the base class for commands that modify data owned by + * an object. If the object gets deleted and the scheduler is notified of this, + * the command will be automatically canceled. + * + * Deriving class needs to override Clone() and Execute() functions from the Command + * base class and NOT to call the base class implementation. + */ +class TAlfObjectCommand : public TAlfCommand + { +public: + + /* Methods. */ + + IMPORT_C const TAlfObjectCommand* ObjectCommand() const; + + /** + * Returns the data owner object of the command. + */ + IMPORT_C TAny* Object() const; + + /** + * Returns the operation of the command. + */ + IMPORT_C TAlfOp Operation() const; + + + IMPORT_C void ExecuteL(CAlfEnv& aEnv) const; + + + IMPORT_C TInt Size() const; + +protected: + + /* Constructor. */ + + /** + * Protected constructor. + * + * @param aType Type of the command. + * @param aDataOwnerObject Object that owns the data this command handles. + * @param aOperation Operation being done on the object. + */ + IMPORT_C TAlfObjectCommand(TAlfCommandType aType, TAny* aDataOwnerObject, TAlfOp aOperation); + + IMPORT_C void CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams); + +private: + + /** Object that owns the data this command handles. */ + TAny* iObject; + + /** Operation being done on the object. */ + TAlfOp iOperation; + +private: + TInt iSpare1; + TInt iSpare2; + }; + +/** + * TAlfGroupCommand is an object command that operates on a control group. + * Usage: + * + * @code + * //Create control group command to show contro group on display + * TAlfGroupCommand command( *iControlGroup, EAlfOpShow, &display ); + * + * //Send command , control group will be shown + * iEnv->Send( command, 1 ); + * + * //Create control group command to hide control group on display + * TAlfGroupCommand command1( *iControlGroup, EAlfOpHide, &display ); + * + * //Send command , control group will be hidden + * iEnv->Send( command, 1 ); + * @endcode +*/ +class TAlfGroupCommand : public TAlfObjectCommand + { +public: + + /* Constructor. */ + + /** + * Constructs a new control group command. + * + * @param aGroup Control group. + * @param aDisplay Display associated with the command. + * @param aOperation Operation to do on the group. + */ + IMPORT_C TAlfGroupCommand(CAlfControlGroup& aGroup, TAlfOp aOperation, + CAlfDisplay* aDisplay = NULL); + + /* Implementation of TAlfCommand::ExecuteL(). */ + IMPORT_C void ExecuteL(CAlfEnv& aEnv) const; + + /* Implementation of TAlfCommand::Size(). */ + IMPORT_C TInt Size() const; + + + /* Methods. */ + + /** + * Returns the control group that the command operates on. + */ + IMPORT_C CAlfControlGroup& ControlGroup() const; + + /** + * Returns the display associated with the command. + */ + IMPORT_C CAlfDisplay* Display() const; + +protected: + + IMPORT_C void CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams); + +private: + + /** Display associated with the command. */ + CAlfDisplay* iDisplay; + +private: + TInt iSpare1; + TInt iSpare2; + }; + +/** + * TAlfControlCommand is an object command that operates on a control. + */ +class TAlfControlCommand : public TAlfObjectCommand + { +public: + + /* Constructor. */ + + /** + * Constructs a new control command. + * + * @param aControl Control. + * @param aOperation Operation to do on the control. + */ + IMPORT_C TAlfControlCommand(CAlfControl& aControl, TAlfOp aOperation); + + /* Implementation of TAlfCommand::ExecuteL(). */ + IMPORT_C void ExecuteL(CAlfEnv& aEnv) const; + + /* Implementation of TAlfCommand::Size(). */ + IMPORT_C TInt Size() const; + + /* Methods. */ + + /** + * Returns the control that the command operates on. + */ + IMPORT_C CAlfControl& Control() const; + +protected: + + IMPORT_C void CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams); + +private: + TInt iSpare1; + TInt iSpare2; + }; + +/** + * TAlfVisualCommand is an object command that operates on a visual. + * Usage: + * + * @code + * //Create Visual command to move visual to front + * TAlfVisualCommand command( *iVisual, EAlfOpEnableTransformation ); + * + * //Send command , visual will be moved to front + * iEnv->Send( command, 1 ); + * + * @endcode + * + */ +class TAlfVisualCommand : public TAlfObjectCommand + { +public: + + /* Constructor. */ + + /** + * Constructs a new visual command. + * + * @param aVisual Visual. + * @param aOperation Operation to do on the visual. + */ + IMPORT_C TAlfVisualCommand(CAlfVisual& aVisual, TAlfOp aOperation, + TInt aSetFlags = 0, TInt aClearFlags = 0); + + /* Implementation of TAlfCommand::ExecuteL(). */ + IMPORT_C void ExecuteL(CAlfEnv& aEnv) const; + + /* Implementation of TAlfCommand::Size(). */ + IMPORT_C TInt Size() const; + + /* Methods. */ + + /** + * Returns the visual that the command operates on. + */ + IMPORT_C CAlfVisual& Visual() const; + + /** + * Returns the flags that will be set by the command. + */ + IMPORT_C TInt FlagsToSet() const; + + /** + * Returns the flags that will be cleared by the command. + */ + IMPORT_C TInt FlagsToClear() const; + +protected: + + IMPORT_C void CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams); + +private: + + /** Flags to set. */ + TInt iSetFlags; + + /** Flags to clear. */ + TInt iClearFlags; + +private: + TInt iSpare1; + TInt iSpare2; + + }; + +/** + * TAlfImageCommand is a command that operaters on an image visual. + * Usage: + * + * @code + * + * //Create Image command to set primary image for imagevisual + * TAlfImageCommand command( *imageVisual, *image, EAlfOpSetPrimaryImage ); + * + * //Send command , Primary image will be set + * iEnv->Send( command, 1 ); + * + * @endcode + */ +class TAlfImageCommand : public TAlfObjectCommand + { +public: + + /* Constructor. */ + + /** + * Constructs a new image command. + * + * @param aImageVisual Image visual. + * @param aImage Image. + * @param aOperation Operation to do on the visual. + */ + IMPORT_C TAlfImageCommand(CAlfImageVisual& aImageVisual, const TAlfImage& aImage, + TAlfOp aOperation = EAlfOpSetPrimaryImage); + + /* Implementation of TAlfCommand::ExecuteL(). */ + IMPORT_C void ExecuteL(CAlfEnv& aEnv) const; + + /* Implementation of TAlfCommand::Size(). */ + IMPORT_C TInt Size() const; + + + /* Methods. */ + + /** + * Returns the visual that the command operates on. + */ + IMPORT_C CAlfImageVisual& ImageVisual() const; + + /** + * Returns a reference to the image of the visual. + */ + IMPORT_C const TAlfImage& Image() const; + +protected: + + IMPORT_C void CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams); + +private: + + /** Image of the command. */ + TAlfImage iImage; + +private: + TInt iSpare1; + TInt iSpare2; + }; + +/** + * TAlfTextCommand is a command that operaters on a text visual. + * + * Usage: + * + * @code + * + * //Create text command to set text in textvisual + * TAlfTextCommand command( *textVisual, _L( "Text" ) ); + * + * //Send command , text will be set to textvisual + * iEnv->Send( command, 1 ); + * @endcode + */ +class TAlfTextCommand : public TAlfObjectCommand + { +public: + + /* Constructor. */ + + /** + * Constructs a new text command. + * + * @param aTextVisual Text visual. + * @param aText Text. + * @param aOperation Operation to perform. + */ + IMPORT_C TAlfTextCommand(CAlfTextVisual& aTextVisual, const TDesC& aText, + TAlfOp aOperation = EAlfOpSetText); + + /* Implementation of TAlfCommand::ExecuteL(). */ + IMPORT_C void ExecuteL(CAlfEnv& aEnv) const; + + /* Implementation of TAlfCommand::Size(). */ + IMPORT_C TInt Size() const; + + + /* Methods. */ + + /** + * Returns the visual that the command operates on. + */ + IMPORT_C CAlfTextVisual& TextVisual() const; + + /** + * Returns a reference to the text of the visual. + */ + IMPORT_C const TDesC& Text() const; + +protected: + + IMPORT_C void CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams); + +private: + + /** Text of the command. */ + const TDesC& iText; + +private: + TInt iSpare1; + TInt iSpare2; + }; + + +/** + * TAlfValueCommand is a command that operates on a single timed value. + * + * @code + * + * //Create timed value command to set visualopacity of a visual + * TAlfValueCommand command( visual, EAlfValueCommandVisualSetOpacity, 0.2, 15 ); + * + * //Send command , visualopacity will be set + * iEnv->Send( command, 1 ); + * + * @endcode + */ +class TAlfValueCommand : public TAlfObjectCommand + { +public: + + /* Constructor. */ + + /** + * Constructs a new value command. + * + * @param aObject Object. Needs to match with aObjectType + * @param aObjectType Timed value to modify. + * @param aTarget Target value + * @param aTransitionTime Time (in milliseconds) for the transition to occur. + */ + IMPORT_C TAlfValueCommand( + TAny* aObject, + TAlfValueCommandTarget aObjectType, + TReal32 aTarget, + TInt aTransitionTime = 0 ) __SOFTFP; + + /** + * Constructs a new value command. This constructor takes an operation + * parameter in addition to the target and timing values. + * + * @param aObject Object. Needs to match with aObjectType + * @param aObjectType Timed value to modify. + * @param aOperation Operation to perform. + * @param aTarget Target value + * @param aTiming Time (in milliseconds) for the transition to occur. + */ + IMPORT_C TAlfValueCommand(TAny* aObject, TAlfValueCommandTarget aObjectType, + TAlfOp aOperation = EAlfOpSet, + TReal32 aTarget = 0.0, TReal32 aTiming = 0.0) __SOFTFP; + + /* Implementation of TAlfCommand::ExecuteL(). */ + IMPORT_C void ExecuteL(CAlfEnv& aEnv) const; + + /* Implementation of TAlfCommand::Size(). */ + IMPORT_C TInt Size() const; + + + /* Methods. */ + + /** + * Returns the visual that the command operates on. + */ + IMPORT_C TAlfValueCommandTarget TimedValue() const; + + /** + * Returns the target value. + */ + IMPORT_C TReal32 Target() const __SOFTFP; + + /** + * Returns the transition time. + */ + IMPORT_C TInt TransitionTime() const; + + /** + * Returns the transition speed. Zero, if not set. + */ + IMPORT_C TReal32 Speed() const __SOFTFP; + +protected: + + IMPORT_C void CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams); + +private: + + /** Timed value being operated on. */ + TAlfValueCommandTarget iTimedValue; + + /** Target value. */ + TReal32 iTarget; + + /** Transition time in milliseconds. */ + TInt iTransitionTime; + + /** Optionally, transition speed in units/second. */ + TReal32 iSpeed; + +private: + TInt iSpare1; + TInt iSpare2; + }; + +/** + * TAlfPointCommand is a command that operates on a timed point. + * Usage: + * @code + * + * //Create timed point command to set visual size + * TAlfRealPoint p1( 0.1, 0.1 ); + * TAlfPointCommand command1( iVisual, EAlfValueCommandVisualSize, p1, 1 ); + * + * //Send command , Primary image will be set + * iEnv->Send( command, 1 ); + * + * @endcode + */ +class TAlfPointCommand : public TAlfObjectCommand + { +public: + + enum TParameterTarget + { + EBoth = 0, // default + EXOnly, + EYOnly + }; + + /* Constructor. */ + + /** + * Constructs a new timed point command. + * + * @param aObject Object. Needs to match with aObjectType + * @param aObjectType Timed value to modify. + * @param aOperation Operation to perform. + */ + IMPORT_C TAlfPointCommand(TAny* aObject, TAlfPointCommandTarget aObjectType, + TAlfOp aOperation); + + /** + * Constructs a new timed point command. + * + * @param aObject Object. Needs to match with aObjectType + * @param aObjectType Timed value to modify. + * @param aTarget Target value + * @param aTransitionTime Time (in milliseconds) for the transition to occur. + */ + IMPORT_C TAlfPointCommand(TAny* aObject, TAlfPointCommandTarget aObjectType, + TAlfRealPoint aTarget, TInt aTransitionTime = 0, + TParameterTarget aParameterTarget = EBoth ); + + /** + * Constructs a new timed point command. This constructor takes an operation + * parameter in addition to the target and timing values. + * + * @param aObject Object. Needs to match with aObjectType + * @param aObjectType Timed value to modify. + * @param aOperation Operation to perform. + * @param aTarget Target value. + * @param aTiming Time (in milliseconds) for the transition to occur. + */ + IMPORT_C TAlfPointCommand(TAny* aObject, TAlfPointCommandTarget aObjectType, + TAlfOp aOperation, + TAlfRealPoint aTarget, TReal32 aTiming = 0.0, + TParameterTarget aParameterTarget = EBoth) __SOFTFP; + + /* Implementation of TAlfCommand::ExecuteL(). */ + IMPORT_C void ExecuteL(CAlfEnv& aEnv) const; + + /* Implementation of TAlfCommand::Size(). */ + IMPORT_C TInt Size() const; + + + /* Methods. */ + + /** + * Returns the object type that the command operates on. + */ + IMPORT_C TAlfPointCommandTarget TimedPoint() const; + + /** + * Returns the target value. + */ + IMPORT_C TAlfRealPoint Target() const; + + /** + * Returns the transition time. + */ + IMPORT_C TInt TransitionTime() const; + + /** + * Returns the transition speed. Zero, if not set. + */ + IMPORT_C TReal32 Speed() const __SOFTFP; + +protected: + + IMPORT_C void CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams); + +private: + + /** Timed point being operated on. */ + TAlfPointCommandTarget iTimedPoint; + + /** Target value. */ + TAlfRealPoint iTarget; + + /** Transition time in milliseconds. */ + TInt iTransitionTime; + + /** Optionally, transition speed in units/second. */ + TReal32 iSpeed; + + TParameterTarget iParameterTarget; + +private: + TInt iSpare1; + TInt iSpare2; + }; + +/** + * TAlfTransformationCommand is a command that operates on a transformation. + * + * Transformation command can generate one of the following operations: + * @li EAlfOpLoadIdentity - Loads an identity matrix to the transformation. + * @li EAlfOpTranslate - Applies a translation to the object affected by the transformation. + * @li EAlfOpScale - Applies scaling to the object affected by the transformation. + * @li EAlfOpRotate - Applies a rotation to the object that is affected by the transformation. + * @li EAlfOpReplaceStep - Replaces the whole transformation step values with the + * ones given as command parameters + * + * If the transformation operation is rotation the default rotation is around z-axis. + * If the transformation operation is scaling the default scale factors are 1.0 on all axis. + * On any other transformation the x,y and z components are zero by default. + * + * Usage: + * @code + * + * //Enable transformation + * iVisual->EnableTransformationL( ); + * + * //Get transformation object + * CAlfTransformation* transformation = &iVisual->Transformation(); + * + * //Set transformation properties + * const TInt rotateAngle = 23.67; + * transformation->Rotate( rotateAngle ); + * + * //Create transformation command + * TAlfTransformationCommand command( iVisual,transformation, EAlfOpRotate, 0 ); + * + * //Properties can also be set through command + * command.SetAngle( TAlfTimedValue( 56 ) ); + * + * //Send command + * iEnv->Send( command, 1 ); + * + * @endcode + */ +class TAlfTransformationCommand : public TAlfObjectCommand + { +public: + + enum + { + /** Used in the aStep parameter to specify that no step index is + specified. */ + EStepNone = -1 + }; + + + /* Constructor. */ + + /** + * Constructs a new transformation command. + * + * @param aOwner Owner of the transformation. Allowed be NULL. + * @param aTransformation Transformation to operate on. + * @param aOperation Operation to perform. + * @param aStep Step index in the transformation. + */ + IMPORT_C TAlfTransformationCommand(TAny* aOwner, CAlfTransformation& aTransformation, + TAlfOp aOperation = EAlfOpLoadIdentity, + TInt aStep = EStepNone); + + /* Implementation of TAlfCommand::ExecuteL(). */ + IMPORT_C void ExecuteL(CAlfEnv& aEnv) const; + + /* Implementation of TAlfCommand::Size(). */ + IMPORT_C TInt Size() const; + + + /* Methods. */ + + /** + * Returns the transformation that the command operates on. + */ + IMPORT_C CAlfTransformation& Transformation() const; + + /** + * Returns the transformation step index. + */ + IMPORT_C TInt Step() const; + + /** + * Sets the X component. + * - If transformation is translation this sets the amount of translation on X axis. + * - If transformation is rotation this sets the X component of rotation axis vector. + * - If transformation is scaling this sets the scaling factor for the X axis. + * + * @param aValue Timed value to set to the X component. + */ + IMPORT_C void SetX(const TAlfTimedValue& aValue); + + /** + * Sets the Y component. + * - If transformation is translation this sets the amount of translation on Y axis. + * - If transformation is rotation this sets the Y component of rotation axis vector. + * - If transformation is scaling this sets the scaling factor for the Y axis. + * + * @param aValue Timed value to set to the Y component. + */ + IMPORT_C void SetY(const TAlfTimedValue& aValue); + + /** + * Sets the Z component. + * - If transformation is translation this sets the amount of translation on Z axis. + * - If transformation is rotation this sets the Z component of rotation axis vector. + * - If transformation is scaling this sets the scaling factor for the Z axis. + * + * @param aValue Timed value to set to the Z component. + */ + IMPORT_C void SetZ(const TAlfTimedValue& aValue); + + /** + * Set the angle of rotation if the transformation is rotation. + */ + IMPORT_C void SetAngle(const TAlfTimedValue& aValue); + +protected: + + IMPORT_C void CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams); + +private: + + /** Image of the command. */ + CAlfTransformation& iTransformation; + + /** Step index. */ + TInt iStep; + + /** X component. Suspended. */ + TAlfTimedValue iX; + + /** Y component. Suspended. */ + TAlfTimedValue iY; + + /** Z component. Suspended. */ + TAlfTimedValue iZ; + + /** Angle component. Suspended. */ + TAlfTimedValue iAngle; + +private: + TInt iSpare1; + TInt iSpare2; + }; + + +/** + * TAlfMarkerCommand is a special marker command that has no functionality, + * but can be entered into the scheduler to mark a specific point in time. + */ +class TAlfMarkerCommand : public TAlfCommand + { +public: + + /* Constructor. */ + + /** + * Constructs a new marker command. + * + * @param aId Identifier of the marker. + */ + IMPORT_C TAlfMarkerCommand(TInt aId); + + + /* Methods. */ + + /* Implementation of TAlfCommand::ExecuteL(). */ + IMPORT_C void ExecuteL(CAlfEnv& aEnv) const; + + /* Implementation of TAlfCommand::Size(). */ + IMPORT_C TInt Size() const; + + /** + * Determines the identifier of the marker. + * + * @param Marker identifier. + */ + IMPORT_C TInt Id() const; + +protected: + + IMPORT_C void CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams); + +private: + TInt iSpare1; + TInt iSpare2; + }; + + + +/** + * TAlfCustomEventCommand is a command that sends a custom event. The command + * can be sent to any individual MAlfEventHandler derived object or broadcasted to + * all Control derived objects. + * + * Usage + * + * @code + * //Create custom Event command, as iControl implements, MAlfEventHandler, + * // it will recieve custom event + * TAlfCustomEventCommand command( KCustomCommandIdDefault, iControl ); + * + * //Send command + * iEnv->Send( command, 1 ); + * + * @endcode + */ +class TAlfCustomEventCommand : public TAlfObjectCommand + { +public: + + /* Constructor. */ + + /** + * Constructs a new custom event command. + * + * @param aEventParam Parameter of the custom event. + * @param aRecipient Optional recipient of the event. + * @param aEventData Optional event data identifier. + * + * @todo It would be good to be able to specify more information to + * be sent with the custom event, e.g., a pointer. Also check + * out TAlfEvent. + */ + IMPORT_C TAlfCustomEventCommand( + TInt aEventParam, MAlfEventHandler* aRecipient = NULL, TInt aEventData = 0 ); + + /* Methods. */ + + /* Implementation of TAlfCommand::ExecuteL(). */ + IMPORT_C void ExecuteL(CAlfEnv& aEnv) const; + + /* Implementation of TAlfCommand::Size(). */ + IMPORT_C TInt Size() const; + + /** + * Returns the recipient of the event, or NULL if none defined. + */ + IMPORT_C MAlfEventHandler* Recipient() const; + + /** + * Determines the custom event parameter of the command. + * + * @return Parameter. + */ + IMPORT_C TInt Param() const; + + /** + * Returns the event data of the command. + * + * @return Event data. + */ + IMPORT_C TInt EventData() const; + +protected: + + IMPORT_C void CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams); + +private: + + /** Custom event parameter. @todo Could be a pointer as well? */ + TInt iEventParam; + + /** Event data. */ + TInt iEventData; + +private: + TInt iSpare1; + TInt iSpare2; + }; + + +#endif // T_ALFCOMMAND_H