/*

* Copyright (c) 2009 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:   File Implements the various output events, including custom events.

*

*/

#include <alf/alfevent.h>

#include <alf/alfcommand.h>

#include <alf/alfenv.h>

#include <osn/ustring.h>

#include <alf/alfwidgetcontrol.h>

#include "alf/alfreferencetovisual.h"

#include <alf/alfvarianttype.h>

#include "alf/alfwidget.h"

#include <alf/alfexceptions.h>

#include "alf/alfattribute.h"

#include "alf/alfattributevaluetype.h"

#include "alf/ialfattributeowner.h"

#include <alf/alfeventoutputsignalsubscriber.h>

#include <alf/ialfappeventlistener.h>

#include <alf/alfwidgetcommand.h>

#include <alf/alfwidgetenvextension.h>

#include <alf/ialfwidgetfactory.h>

#include "alfeventoutput.h"

namespace Alf

    {

// ======== LOCAL FUNCTIONS ========

void DeleteIAlfVariantType( TAny* aParam )

    {

    IAlfVariantType* ptr = static_cast<IAlfVariantType*>( aParam );

    delete ptr;

    }

// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------

// Class AlfEventOutput

// ---------------------------------------------------------------------------

//

AlfEventOutput::AlfEventOutput(

    int aEventType, int aEventID, const char* aTargetWidget, unsigned int aDelay )

    {

    if ( aEventType != TAlfEvent::ETypeCustom &&

            aEventType != TAlfEvent::ETypeKey )

        {

        ALF_THROW(AlfVisualException,EInvalidAttribute,"AlfEventOutput")

        }

    // Key event outputs must have a target widget.

    if ( aEventType == TAlfEvent::ETypeKey &&

            !UString(aTargetWidget).compare(UString("")) )

        {

        ALF_THROW(AlfVisualException,EInvalidAttribute,"AlfEventOutput")

        }

    mEventType = aEventType;

    mEventID = aEventID;

    mTargetWidget = UString(aTargetWidget);

    mDelay = aDelay;

    }

AlfEventOutput::AlfEventOutput()

    {

    }

AlfEventOutput::~AlfEventOutput()

    {

    }

// ---------------------------------------------------------------------------

// ?implementation_description

// ---------------------------------------------------------------------------

//

void AlfEventOutput::execute( const CAlfWidgetControl& aControl, const TAlfEvent& aEvent )

    {

    CAlfEnv& env = aControl.Env();

    CAlfWidgetControl* controller = NULL;

    if ( mTargetWidget.compare( UString("") ) )

        {

        IAlfWidget* widget = AlfWidgetEnvExtension::widgetFactory(env).findWidget( mTargetWidget.getUtf8() );

        if ( !widget )

            {

            ALF_THROW(AlfWidgetException,EInvalidWidget,"AlfEventOutput")

            }

        controller = widget->control();

        }

    if ( mEventType == TAlfEvent::ETypeCustom )

        {

        // control is NULL if the event is to be broadcast

        TAlfCustomEventCommand command( mEventID, controller, aEvent.CustomEventData() );

        env.Send( command, mDelay );

        }

    else if ( mEventType == TAlfEvent::ETypeKey && controller )

        {

        // Simulate a key event with a given event ID as scan code.

        TKeyEvent key =

            {

            0,          // iCode

            mEventID,   // iScanCode

            0,          // iModifiers

            0           // iRepeats

            };

        TAlfEvent event( *controller->Display(), key, EEventKey );

        controller->processEvent( event );

        }

    }

// ---------------------------------------------------------------------------

// Class AlfEventCancelOutput

// ---------------------------------------------------------------------------

//

AlfEventCancelOutput::AlfEventCancelOutput(

    const char* aTargetWidget, int aEventID, bool aCancelAll )

    {

    mTargetWidget = UString(aTargetWidget);

    mEventID = aEventID;

    mCancelAll = aCancelAll;

    }

AlfEventCancelOutput::AlfEventCancelOutput()

    {

    }

AlfEventCancelOutput::~AlfEventCancelOutput()

    {

    }

// ---------------------------------------------------------------------------

// ?implementation_description

// ---------------------------------------------------------------------------

//

void AlfEventCancelOutput::execute( const CAlfWidgetControl& aControl )

    {

    // This cancels either all or specified command in the given

    // target control.

    CAlfEnv& env = aControl.Env();

    IAlfWidget* widget = AlfWidgetEnvExtension::widgetFactory(env).findWidget( mTargetWidget.getUtf8() );

    if ( !widget )

        {

        ALF_THROW(AlfWidgetException,EInvalidWidget,"AlfEventCancelOutput")

        }

    CAlfControl* controller = widget->control();

    if ( mCancelAll )

        {

        env.CancelCustomCommands( controller );

        }

    else

        {

        env.CancelCustomCommands( controller, mEventID );

        }

    }

// ---------------------------------------------------------------------------

// Class AlfAnimationCancelOutput

// ---------------------------------------------------------------------------

//

AlfAnimationCancelOutput::AlfAnimationCancelOutput(

    const char* aElementName,

    const char* aVisualName,

    TAlfOp aOperation,

    bool aCancelAll )

    {

    mVisualRef.reset(AlfReferenceToVisual::create( aElementName, aVisualName, true ));

    mOperation = aOperation;

    mCancelAll = aCancelAll;

    }

AlfAnimationCancelOutput::AlfAnimationCancelOutput()

    {

    }

AlfAnimationCancelOutput::~AlfAnimationCancelOutput()

    {

    }

// ---------------------------------------------------------------------------

// ?implementation_description

// ---------------------------------------------------------------------------

//

void AlfAnimationCancelOutput::execute(

    CAlfWidgetControl& aControl, int aDataID )

    {

    CAlfEnv& env = aControl.Env();

    CAlfVisual* visual=NULL;

    visual = mVisualRef->resolve( aControl, aDataID );

    if ( visual )

        {

        if ( mCancelAll )

            {

            env.CancelCommands( visual );

            }

        else

            {

            env.CancelCommands( visual, mOperation );

            }

        }

    }

// ---------------------------------------------------------------------------

// Class AlfWidgetAttributeOuptut

// ---------------------------------------------------------------------------

//

AlfWidgetAttributeOutput::AlfWidgetAttributeOutput( AlfAttribute& aAttribute,

    const char* aWidgetId )

    {

    mAttr = &aAttribute;

    mWidgetId = "";

    if (aWidgetId)   

        {

        mWidgetId = aWidgetId;

        }

    }

AlfWidgetAttributeOutput::AlfWidgetAttributeOutput()

    {

    }

AlfWidgetAttributeOutput::~AlfWidgetAttributeOutput()

    {

    delete mAttr;

    }

void AlfWidgetAttributeOutput::execute( CAlfWidgetControl& aControl )

    {

    AlfWidget* widget = aControl.widget();

    IAlfAttributeOwner* owner = 0;

    if (mWidgetId.isEmpty())

        {

        owner = IAlfInterfaceBase::makeInterface<IAlfAttributeOwner>(widget);

        }

    else

        {

        IAlfWidget* widget1 = AlfWidgetEnvExtension::widgetFactory(aControl.Env()).findWidget(mWidgetId.getUtf8());

        owner = IAlfInterfaceBase::makeInterface<IAlfAttributeOwner>(widget1);

        }

    if ( owner )

        {        

        owner->setAttribute( *mAttr );

        UString target;

        TAlfWidgetAttributeCommand command( mAttr, target, widget );

        CAlfEnv& env = aControl.Env();

        env.Send( command, 0);

        command.mOwnedAttribute = NULL;

        }

    }

#ifdef RD_TACTILE_FEEDBACK

// ---------------------------------------------------------------------------

// Class AlfWidgetTactileOutput

// ---------------------------------------------------------------------------

//

AlfTactileOutput::AlfTactileOutput( TTouchLogicalFeedback aFeedbackType )

    {

    mFeedbackType = aFeedbackType;

    }

AlfTactileOutput::AlfTactileOutput()

    {

    }

AlfTactileOutput::~AlfTactileOutput()

    {

    }

void AlfTactileOutput::execute()

    {

    MTouchFeedback* feedback = MTouchFeedback::Instance();

    if ( feedback )

        {

        feedback->InstantFeedback( mFeedbackType );

        }

    }

#endif // RD_TACTILE_FEEDBACK

// ---------------------------------------------------------------------------

// Class AlfEventOutputSignal

// ---------------------------------------------------------------------------

//

AlfEventOutputSignal::AlfEventOutputSignal( 

	IAlfEventOutputSignalSubscriber& aSubscriber )

	: mSubscriber(&aSubscriber)

    {}

AlfEventOutputSignal::~AlfEventOutputSignal()

    {

    delete mSubscriber;

    }

void AlfEventOutputSignal::execute()

    {

    mSubscriber->receiveSignal();

    }

// ---------------------------------------------------------------------------

// Class AlfStateChangeOutput

// ---------------------------------------------------------------------------

//

AlfStateChangeOutput::AlfStateChangeOutput(

    const char* aTargetWidget, uint aEnableStates, uint aDisableStates ):

    mTargetWidget(aTargetWidget),

    mEnableStates(aEnableStates),

    mDisableStates(aDisableStates)

    {

    // State change events output must have a target widget.

    if ( !aTargetWidget || aTargetWidget[0] == 0 )

        {

        ALF_THROW(AlfWidgetException,EInvalidWidget,"AlfStateChangeOutput")

        }

    // State change events must not have ambiguous overlapping bits

    if ( mEnableStates & mDisableStates  )

        {

        ALF_THROW(AlfWidgetException,EInvalidArgument,"AlfStateChangeOutput")

        }

    }

AlfStateChangeOutput::~AlfStateChangeOutput()

    {

    }

// ---------------------------------------------------------------------------

// ?implementation_description

// ---------------------------------------------------------------------------

//

void AlfStateChangeOutput::execute( const CAlfWidgetControl& aControl)

    {

    CAlfEnv& env = aControl.Env();

    if ( mTargetWidget.compare( UString("") ) )

        {

        IAlfWidget* widget = AlfWidgetEnvExtension::widgetFactory(env).findWidget( mTargetWidget.getUtf8() );

        if ( !widget )

            {

            ALF_THROW(AlfWidgetException,EInvalidWidget,"AlfStateChangeOutput")

            }

        CAlfWidgetControl* target = widget->control();

        target->enableState( mEnableStates);

        target->disableState(mDisableStates);

        }

    }

// ---------------------------------------------------------------------------

// Class AlfEventPasserOutput

// ---------------------------------------------------------------------------

//

AlfEventPasserOutput::AlfEventPasserOutput( const char* aSourceWidget, const char* aTargetWidget ):

    mSourceWidget(aSourceWidget),

    mTargetWidget(aTargetWidget)                     

    {

    mEventMappingData = false;

    // Event passer events output must have a target widget.

    if ( !mTargetWidget )

        {

        ALF_THROW(AlfWidgetException,EInvalidWidget,"AlfEventPasserOutput")

        }

    }

// ---------------------------------------------------------------------------

// Class AlfEventPasserOutput

// ---------------------------------------------------------------------------

//

AlfEventPasserOutput::AlfEventPasserOutput( const char* aSourceWidget , const char* aTargetWidget, 

                                            int aNewEventId , int aNewEventCustomData ):

    mSourceWidget(aSourceWidget),

    mTargetWidget(aTargetWidget),

    mNewEventId(aNewEventId),

    mNewEventCustomData(aNewEventCustomData)                     

    {

    mEventMappingData = true;

    // Event passer events output must have a target widget.

    if ( !mTargetWidget )

        {

        ALF_THROW(AlfWidgetException,EInvalidWidget,"AlfEventPasserOutput")

        }

    }

AlfEventPasserOutput::AlfEventPasserOutput()

    {

    }

AlfEventPasserOutput::~AlfEventPasserOutput()

    {

    }

void AlfEventPasserOutput::execute( const CAlfWidgetControl* aControl , const TAlfEvent& aEvent )

    {

    if(mTargetWidget)

        {

        IAlfWidget* wdgt = AlfWidgetEnvExtension::widgetFactory(aControl->Env()).findWidget(mTargetWidget);

        //const char* wname = wdgt->widgetName(); //for debugging purposes

        // if widget is not found, ignore...

        if( wdgt  )

            {

            if(!mEventMappingData)

                {

                //pass to widgets control. The event handler that handles the event

                //is found from the target widgets controls event handler list.

                wdgt->control()->processEvent(aEvent);     

                }

            else

                {

                //map event to other type of event. Use user set event ids and custom data.

                wdgt->control()->processEvent(TAlfEvent(mNewEventId , mNewEventCustomData));      

                }

            }

        }

    }

// ---------------------------------------------------------------------------

// Class AlfAppEventOutput

// ---------------------------------------------------------------------------

//

AlfAppEventOutput::AlfAppEventOutput( const UString& aCmd, IAlfAppEventListener& aAppEvent ):

    mAppEvent(&aAppEvent),

    mCmd(aCmd)

    {

    }

AlfAppEventOutput::~AlfAppEventOutput()

    {

    }

void AlfAppEventOutput::execute(const TAlfEvent& aEvent)

    {

    mAppEvent->handleApplicationEvent(mCmd, aEvent);

    }

    } // namespace Alf

// End of File.