/*

* 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 <alf/alfimage.h>

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.

     */