/*

* Copyright (c) 2006-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:   Definition of THuiCommand and derived command classes. 

*

*/

#ifndef __HUICOMMAND_H__

#define __HUICOMMAND_H__

#include <e32base.h>

#include <uiacceltk/HuiImage.h>

#include <uiacceltk/HuiTimedValue.h>

#include <uiacceltk/HuiTimedPoint.h>

/* Forward declarations. */

class CHuiEnv;

class CHuiControlGroup;

class CHuiControl;

class CHuiDisplay;

class CHuiVisual;

class CHuiImageVisual;

class CHuiTextVisual;

class CHuiTransformation;

class THuiObjectCommand;

class THuiEvent;

class MHuiEventHandler;

/**

 * Command types.

 * All the commands that can be executed by the toolkit are enumerated here.

 */

enum THuiCommandType

    {

    /** None corresponds the base class (THuiCommand). */

    EHuiCommandTypeNone = 0,

    EHuiCommandTypeObject,

    EHuiCommandTypeAction,

    EHuiCommandTypeGroup,

    EHuiCommandTypeControl,

    EHuiCommandTypeVisual,

    EHuiCommandTypeImage,

    EHuiCommandTypeText,

    EHuiCommandTypeValue,

    EHuiCommandTypePoint,

    EHuiCommandTypeTransformation,

    EHuiCommandTypeCustomEvent,

    /** Marker command type. Types up from here will be used for markers only. */    

    EHuiCommandTypeMarkerFirst = 10000,

    EHuiCommandTypeMarker0 = EHuiCommandTypeMarkerFirst,

    EHuiCommandTypeMarker1,

    EHuiCommandTypeMarker2,

    EHuiCommandTypeMarker3,

    EHuiCommandTypeMarker4,

    EHuiCommandTypeMarker5,

    EHuiCommandTypeMarker6,

    EHuiCommandTypeMarker7,

    EHuiCommandTypeMarker8,

    EHuiCommandTypeMarker9,

    EHuiCommandTypeMarker10

    };

/** 

 * Command operations. 

 */

enum THuiOp

    {

    EHuiOpNone = 0,

    /* Control Group operations. */

    EHuiOpHide = 1000,

    EHuiOpShow,

    EHuiOpEnableInput,

    EHuiOpDisableInput,

    /* Control operations. */

    /* (start from 2000) */  // None defined yet.

    /* Visual operations. */

    EHuiOpRemoveAndDestroyAll = 3000,

    EHuiOpModifyFlags,

    EHuiOpSetPrimaryImage,

    EHuiOpSetSecondaryImage,

    EHuiOpSetText,

    EHuiOpEnableTransformation,

    EHuiOpDisableTransformation,

    /* Timed value operations. */

    EHuiOpSet = 4000,

    EHuiOpSetWithSpeed,

    /* Timed value style operations. The actual is:

       THuiInterpolationStyle(iOperation - EHuiOpSetStyle) */

    EHuiOpSetStyle = 5000,

    /* Transformation operations. */

    EHuiOpLoadIdentity = 6000,

    EHuiOpTranslate,

    EHuiOpScale,

    EHuiOpRotate

    };

/**

 * Object types.

 * These are the different types of objects which can issue and receive commands.

 */

enum THuiCommandObjectType

    {

    EHuiCommandObjectTypeNone,

    /** This object is a visual. */

    EHuiCommandObjectTypeVisual,

    /** This object is a control. */

    EHuiCommandObjectTypeControl,

    /** This object is a control group. */

    EHuiCommandObjectTypeControlGroup

    };

/**

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

    {

public:

    /* Destructor. */

    IMPORT_C virtual ~THuiCommand();

    /* Methods. */

    /**

     * Returns a pointer to the command casted to THuiObjectCommand.

     * If this is not possible (the command is not derived from 

     * THuiObjectCommand), returns NULL instead.

     */

    IMPORT_C virtual const THuiObjectCommand* ObjectCommand() const;

    /**

     * Executes the command.

     *

     * @param aEnv  The environment in which the command is being executed.

     */

    virtual void ExecuteL(CHuiEnv& aEnv) const = 0;

    /**

     * Returns the size of the command.

     */

    virtual TInt Size() const = 0;

    /**

     * Sets the sender object of the command.

     * The sender must not be deleted while the command is pending execution in a scheduler.

     *

     * @param aType    Sender type.

     * @param aSender  Pointer to sender.     

     */

    IMPORT_C void SetSender(THuiCommandObjectType aType, TAny* aSender);

    /**

     * Determines the type of the command.

     *

     * @return  Command type.

     */

    IMPORT_C THuiCommandType Type() const;

    /**

     * Determines the type of the object that sent the command.

     *

     * @return  Sender object type.

     */

    IMPORT_C THuiCommandObjectType SenderType() const;

    /**

     * Returns the sender object. This is the object which issued

     * the command originally.

     *

     * @return the object which sent the command.

     */

    IMPORT_C TAny* Sender() const;

    /**

     * Returns the sender visual. Returns NULL if the sender is not a visual.

     *

     * @return  Visual, or NULL.

     * @see Sender()

     */     

    IMPORT_C CHuiVisual* SenderVisual() const;

    /**

     * Returns the sender control. Returns NULL if the sender is not a control.

     *

     * @return  Control, or NULL.

     * @see Sender()

     */     

    IMPORT_C CHuiControl* SenderControl() const;

    /**

     * Returns the sender control group. Returns NULL if the sender is not a control group.

     *

     * @return  Control group, or NULL.

     * @see Sender()

     */     

    IMPORT_C CHuiControlGroup* SenderControlGroup() const;

protected:

    /* Constructor. */

    /**

     * Protected constructor.

     *

     * @param aType  Type of the command.

     */

    IMPORT_C THuiCommand(THuiCommandType 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. */

    THuiCommandType iType;

    /** Type of the object that sent the command. */

    THuiCommandObjectType iSenderType;

    /** Object that sent this command. Must exist. */

    TAny* iSender;

private:

    TInt iSpare1;

    TInt iSpare2;

    };

/**

 * THuiActionCommand is a simple action that triggers an action notification.

 */

class THuiActionCommand : public THuiCommand

    {

public:

    /* Constructor. */

    /**

     * Constructs a new action command.

     *

     * @param aId  Identifier of the action.

     */

    IMPORT_C THuiActionCommand(TInt aId);    

    /* Methods. */

    /* Implementation of THuiCommand::ExecuteL(). */

    IMPORT_C void ExecuteL(CHuiEnv& aEnv) const;

    /* Implementation of THuiCommand::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;

    };

/** 

 * THuiObjectCommand 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.

 */

class THuiObjectCommand : public THuiCommand

    {

public:

    /* Methods. */

    IMPORT_C const THuiObjectCommand* ObjectCommand() const;

    IMPORT_C void ExecuteL(CHuiEnv& aEnv) const;

    IMPORT_C TInt Size() const;

    /**

     * Returns the data owner object of the command.

     */

    IMPORT_C TAny* Object() const;

    /**

     * Returns the operation of the command.

     */

    IMPORT_C THuiOp Operation() 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 THuiObjectCommand(THuiCommandType aType, TAny* aDataOwnerObject, THuiOp 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. */

    THuiOp iOperation;

    };

/**

 * THuiGroupCommand is an object command that operates on a control group.

 */    

class THuiGroupCommand : public THuiObjectCommand

    {

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 THuiGroupCommand(CHuiControlGroup& aGroup, THuiOp aOperation, 

                              CHuiDisplay* aDisplay = NULL);    

    /* Implementation of THuiCommand::ExecuteL(). */

    IMPORT_C void ExecuteL(CHuiEnv& aEnv) const;

    /* Implementation of THuiCommand::Size(). */

    IMPORT_C TInt Size() const;

    /* Methods. */

    /**

     * Returns the control group that the command operates on.

     */

    IMPORT_C CHuiControlGroup& ControlGroup() const;

    /**

     * Returns the display associated with the command.

     */

    IMPORT_C CHuiDisplay* Display() const;

protected:

    IMPORT_C void CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams);

private:

    /** Display associated with the command. */

    CHuiDisplay* iDisplay;

private:

    TInt iSpare1;

    TInt iSpare2;

    };

/**

 * THuiControlCommand is an object command that operates on a control.

 */    

class THuiControlCommand : public THuiObjectCommand

    {

public:

    /* Constructor. */

    /**

     * Constructs a new control command.

     *

     * @param aControl    Control.

     * @param aOperation  Operation to do on the control.

     */

    IMPORT_C THuiControlCommand(CHuiControl& aControl, THuiOp aOperation);    

    /* Implementation of THuiCommand::ExecuteL(). */

    IMPORT_C void ExecuteL(CHuiEnv& aEnv) const;

    /* Implementation of THuiCommand::Size(). */

    IMPORT_C TInt Size() const;   

    /* Methods. */

    /**

     * Returns the control that the command operates on.

     */

    IMPORT_C CHuiControl& Control() const;

protected:

    IMPORT_C void CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams);

private:

    TInt iSpare1;

    TInt iSpare2;

    };

/**

 * THuiVisualCommand is an object command that operates on a visual.

 */    

class THuiVisualCommand : public THuiObjectCommand

    {

public:

    /* Constructor. */

    /**

     * Constructs a new visual command.

     *

     * @param aVisual     Visual.

     * @param aOperation  Operation to do on the visual.

     */

    IMPORT_C THuiVisualCommand(CHuiVisual& aVisual, THuiOp aOperation,

                               TInt aSetFlags = 0, TInt aClearFlags = 0);    

    /* Implementation of THuiCommand::ExecuteL(). */

    IMPORT_C void ExecuteL(CHuiEnv& aEnv) const;

    /* Implementation of THuiCommand::Size(). */

    IMPORT_C TInt Size() const;

    /* Methods. */

    /**

     * Returns the visual that the command operates on.

     */

    IMPORT_C CHuiVisual& 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;