/*

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