/*

* 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 eventhandler in widgetmodel.

*

*/

#include <alf/alftypes.h>

#include <osn/ustring.h>

#include "alf/alfwidgeteventhandler.h"

#include <alf/alfwidgetcontrol.h>

#include <alf/alfvarianttype.h>

#include <alf/alfexceptions.h>

#include "alf/alfattribute.h"

#include <alf/alfeventoutputsignalsubscriber.h>

#include <alf/ialfappeventlistener.h>

#include <stdexcept>

#include <osn/osnnew.h>

#ifdef RD_TACTILE_FEEDBACK

#include <touchfeedback.h>

#endif // RD_TACTILE_FEEDBACK

#include "alfwidgeteventhandlerimpl.h"

#include "alfanimationoutput.h"

#include "alfeventinput.h"

#include "alfeventoutput.h"

namespace Alf

    {

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

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

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

// ?description_if_needed

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

//

OSN_EXPORT AlfWidgetEventHandler::AlfWidgetEventHandler(

    IAlfWidgetEventHandler::AlfEventHandlerType aEventHandlerType,

    IAlfWidgetEventHandler::AlfEventHandlerExecutionPhase aEventHandlerExecutionPhase )

    {

    mImpl.reset( new (EMM) AlfWidgetEventHandlerImpl(

        aEventHandlerType, aEventHandlerExecutionPhase ) );

    }

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

// ?description_if_needed

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

//

AlfWidgetEventHandler::~AlfWidgetEventHandler()

    {

    }

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

// ?implementation_description

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

//

OSN_EXPORT void AlfWidgetEventHandler::addKeyInput(

    int aEventID,

    EventTypeFlags aEventTypeFlags,

    uint aModifiers )

    {

    if ( aEventTypeFlags != keyDown && aEventTypeFlags != keyUp )

        {

        ALF_THROW(

            AlfException,

            EInvalidArgument,

            "AlfWidgetEventHandler - invalid event type given in addKeyInput()" );

        }

    mImpl->mInputs.resize(mImpl->mInputs.count()+1);

    AlfEventInput* input = new( EMM ) AlfEventInput( aEventTypeFlags, aEventID, 0, aModifiers );

    mImpl->mInputs.insert(mImpl->mInputs.count(),input);

    }

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

// ?implementation_description

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

//

OSN_EXPORT void AlfWidgetEventHandler::addCustomInput(

    int aEventID, bool aUseEventData, int aEventData )

    {

    mImpl->mInputs.resize(mImpl->mInputs.count()+1);

    AlfEventInput* input = new( EMM ) AlfEventInput(custom, aEventID, aEventData, 0 );

    if ( aUseEventData )

        {

        input->mEventTypeFlags |= useEventData;

        }

    mImpl->mInputs.insert(mImpl->mInputs.count(), input);

    }

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

// ?implementation_description

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

//

OSN_EXPORT void AlfWidgetEventHandler::addPointerInput(

    const char* aElementName, const char* aVisualName, 

    WidgetPointerEvent aEvent )

    {

    mImpl->mPointerInputs.resize(mImpl->mPointerInputs.count()+1);

    AlfPointerEventInput* input = new( EMM ) AlfPointerEventInput( aElementName, aVisualName, aEvent );

    mImpl->mPointerInputs.insert(mImpl->mPointerInputs.count(), input);

    }

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

// ?implementation_description

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

OSN_EXPORT void AlfWidgetEventHandler::addOutput(

    int aEventType,

    int aEventID,

    const char* aTargetControl,

    unsigned int aDelay )

    {

    mImpl->mOutputs.resize(mImpl->mOutputs.count()+1);

    AlfEventOutput* output = new( EMM ) AlfEventOutput( aEventType, aEventID, aTargetControl, aDelay );

    mImpl->mOutputs.insert(mImpl->mOutputs.count(), output);

    }

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

// ?implementation_description

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

//

OSN_EXPORT void AlfWidgetEventHandler::addAnimationOutput(

    AlfReferenceToVisual* aTargetVisual,

    AlfReferenceToVisual* aReferenceVisual,

    IAlfAttributeSetter* aAttributeSetter,

    AlfAttributeContainer* aAttributeContainer,

    unsigned int aAnimationTime,

    unsigned int aDelay )

    {

    mImpl->mAnimationOutputs.resize(mImpl->mAnimationOutputs.count()+1);

    AlfAnimationOutput* output = new( EMM ) AlfAnimationOutput(

        aTargetVisual,

        aReferenceVisual,

        aAttributeSetter,

        aAttributeContainer,

        aAnimationTime,

        aDelay );

    // This should always succeed, because the array has already been resized.

    mImpl->mAnimationOutputs.insert(mImpl->mAnimationOutputs.count(), output );

    }

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

// ?implementation_description

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

//

OSN_EXPORT void AlfWidgetEventHandler::addCancelOutput(

    const char* aTargetWidget, int aEventID, bool aCancelAll )

    {

    mImpl->mCancelOutputs.resize(mImpl->mCancelOutputs.count()+1);

    AlfEventCancelOutput* output = new( EMM ) AlfEventCancelOutput( aTargetWidget, aEventID, aCancelAll );

    mImpl->mCancelOutputs.insert(mImpl->mCancelOutputs.count(), output);

    }

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

// ?implementation_description

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

//

OSN_EXPORT void AlfWidgetEventHandler::addAnimationCancelOutput(

    const char* aElementName,

    const char* aVisualName,

    TAlfOp aOperation,

    bool aCancelAll )

    {

    mImpl->mAnimationCancelOutputs.resize(mImpl->mAnimationCancelOutputs.count()+1);

    AlfAnimationCancelOutput* output = new( EMM ) AlfAnimationCancelOutput(aElementName, aVisualName, aOperation, aCancelAll );

    mImpl->mAnimationCancelOutputs.insert(mImpl->mAnimationCancelOutputs.count(), output);

    }

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

// AddWidgetAttributeOutput

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

//

OSN_EXPORT void AlfWidgetEventHandler::addWidgetAttributeOutput(

    AlfAttribute& aAttribute, const char* aWidgetId )

    {

    mImpl->mWidgetAttributeOutputs.resize( mImpl->mWidgetAttributeOutputs.count() + 1 );

    AlfWidgetAttributeOutput* output = new (EMM) AlfWidgetAttributeOutput( aAttribute, aWidgetId );

    mImpl->mWidgetAttributeOutputs.insert( mImpl->mWidgetAttributeOutputs.count(), output );

    }

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

// addWidgetAttributeOutput

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

//

OSN_EXPORT void AlfWidgetEventHandler::addWidgetAttributeOutput(

    UString& aName, AlfAttributeValueType* aValue, const char* aWidgetId )

    {

    auto_ptr<AlfAttribute> attr(

        new( EMM ) AlfAttribute(aName.getUtf8(), AlfAttribute::EStatic ) );

    attr->addTargetValue( aValue );

    mImpl->mWidgetAttributeOutputs.resize( mImpl->mWidgetAttributeOutputs.count() + 1 );

    // Add attribute to attribute output. Onwership is transferred.

    AlfWidgetAttributeOutput* output = new (EMM) AlfWidgetAttributeOutput( *attr.get(), aWidgetId );

    attr.release();

    mImpl->mWidgetAttributeOutputs.insert( mImpl->mWidgetAttributeOutputs.count(), output );

    }

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

// addWidgetAttributeInput

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

//

OSN_EXPORT void AlfWidgetEventHandler::addWidgetAttributeInput(

	UString& aName, AlfAttributeValueType* aValue, const char* aElementId )

    {

    auto_ptr<AlfAttribute> attr(

        new( EMM ) AlfAttribute(aName.getUtf8(), AlfAttribute::EStatic ) );

    attr->addTargetValue( aValue );

    mImpl->mWidgetAttributeInputs.resize( mImpl->mWidgetAttributeInputs.count() + 1 );

    // Add attribute to attribute input. Onwership is transferred.

    AlfWidgetAttributeInput* input = new (EMM) AlfWidgetAttributeInput( *attr.get(), aElementId );

    attr.release();

    mImpl->mWidgetAttributeInputs.insert( mImpl->mWidgetAttributeInputs.count(), input );

    }

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

// addTactileOutput

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

//

OSN_EXPORT void AlfWidgetEventHandler::addTactileOutput( 

    WidgetTactileFeedbackType aFeedbackType )

    {

#ifdef RD_TACTILE_FEEDBACK

	// map the feedback type to official tactile feedback type

    TTouchLogicalFeedback feedback = ETouchFeedbackNone;

    switch ( aFeedbackType )

        {

        case tactileFeedbackBasic:

            feedback = ETouchFeedbackBasic;

            break;

        case tactileFeedbackSensitive:

            feedback = ETouchFeedbackSensitive;

            break;

        case tactileFeedbackNone:

        default:

            break;

        }

    // create tactile output

    mImpl->mTactileOutputs.resize( mImpl->mTactileOutputs.count() + 1 );

    AlfTactileOutput* output = new (EMM) AlfTactileOutput( feedback );

    mImpl->mTactileOutputs.insert( mImpl->mTactileOutputs.count(), output );

#endif // RD_TACTILE_FEEDBACK

    }

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

// addEventPasserInput

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

//

OSN_EXPORT void AlfWidgetEventHandler::addEventPasserInput (

    int aEventId, int aCustomData )

    {

    mImpl->mEventPasserInputs.resize( mImpl->mEventPasserInputs.count() + 1 );                                                                      

    AlfEventPasserInput* input = new( EMM ) AlfEventPasserInput(

        aEventId, aCustomData );

    mImpl->mEventPasserInputs.insert( mImpl->mEventPasserInputs.count(), input ); 

    }

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

// addEventPasserOutput

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

//

OSN_EXPORT void AlfWidgetEventHandler::addEventPasserOutput( 

    const char* aSourceWidget , const char* aTargetWidget )

    {

    mImpl->mEventPasserOutputs.resize( mImpl->mEventPasserOutputs.count() + 1 );

    //create new output here

    AlfEventPasserOutput* output = new( EMM ) AlfEventPasserOutput(

        aSourceWidget, aTargetWidget );

    mImpl->mEventPasserOutputs.insert( mImpl->mEventPasserOutputs.count(), output );

    }

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

// addEventPasserOutput

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

//

OSN_EXPORT void AlfWidgetEventHandler::addEventPasserOutput( 

    const char* aSourceWidget , const char* aTargetWidget, int aNewEventId, int aNewEventCustomData )

    {

    //create new output here

    auto_ptr<AlfEventPasserOutput> output(new (EMM) AlfEventPasserOutput( aSourceWidget,

                                                                          aTargetWidget,

                                                                          aNewEventId,

                                                                          aNewEventCustomData ));

    mImpl->mEventPasserOutputs.resize( mImpl->mEventPasserOutputs.count() + 1 );                                                                      

    mImpl->mEventPasserOutputs.insert( mImpl->mEventPasserOutputs.count(), output.get() ); 

    output.release();        

    }

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

// addWidgetEventOutputSignalSubscriber

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

//

OSN_EXPORT void AlfWidgetEventHandler::addWidgetEventOutputSignalSubscriber(

	IAlfEventOutputSignalSubscriber& aSubscriber )

	{

	auto_ptr<AlfEventOutputSignal> signal(new (EMM) AlfEventOutputSignal( aSubscriber ));

	mImpl->mWidgetEventOutputSignals.resize( mImpl->mWidgetEventOutputSignals.count() + 1 );

	mImpl->mWidgetEventOutputSignals.insert( mImpl->mWidgetEventOutputSignals.count(), signal.get() );

	signal.release();

	}

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

// addWidgetStateOutput

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

//

OSN_EXPORT void AlfWidgetEventHandler::addWidgetStateOutput( 

    const UString& aName, uint aEnableStates, uint aDisableStates )

    {

    auto_ptr<AlfStateChangeOutput> output(new (EMM) AlfStateChangeOutput( aName.getUtf8(), aEnableStates, aDisableStates ));

    mImpl->mStateChangeOutputs.resize( mImpl->mStateChangeOutputs.count() + 1 );

    mImpl->mStateChangeOutputs.insert( mImpl->mStateChangeOutputs.count(), output.get() ); 

    output.release();

    }

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

// addAppEventOutput

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

//

OSN_EXPORT void AlfWidgetEventHandler::addAppEventOutput(const UString& aCmd , IAlfAppEventListener& aAppEvent )

    {

    auto_ptr<AlfAppEventOutput> appOutput(new (EMM) AlfAppEventOutput( aCmd, aAppEvent ));

    mImpl->mAppEventOutputs.resize( mImpl->mAppEventOutputs.count() + 1 );

    mImpl->mAppEventOutputs.insert( mImpl->mAppEventOutputs.count(), appOutput.get() );

    appOutput.release();

    }

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

// From class IAlfWidgetEventHandler.

// ?implementation_description

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

//

bool AlfWidgetEventHandler::accept(

    CAlfWidgetControl& aControl, const TAlfEvent& aEvent ) const

    {

    bool ret = false;

    // Custom and key events

    if ( !aEvent.IsPointerEvent() )

        {

        int count = mImpl->mInputs.count();

        for ( int i = 0 ; i < count ; i++ )

            {

            if ( mImpl->mInputs[i]->accept( aEvent ) )

                {

                ret = true;

                break;

                }

            }

        }

    // Pointer events

    else

        {

        int count = mImpl->mPointerInputs.count();

        for ( int i = 0 ; i < count ; i++ )

            {

            if ( mImpl->mPointerInputs[i]->accept( aControl, aEvent ) )

                {

                ret = true;

                break;

                }

            }

        }

    // All the inputs below handle only custom events.

    if (!ret) 

        {

        int count = mImpl->mWidgetAttributeInputs.count();

        for ( int i = 0 ; i < count ; i++ )

            {

            if ( mImpl->mWidgetAttributeInputs[i]->accept( aEvent ) )

                {

                ret = true;

                break;

                }

            }

        }

    if (!ret) 

        {

        int count = mImpl->mEventPasserInputs.count();

        for ( int i = 0 ; i < count ; i++ )

            {

            if ( mImpl->mEventPasserInputs[i]->accept( aEvent ) )

                {

                ret = true;

                break;

                }

            }

        }        

    return ret;

    }

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

// From class IAlfWidgetEventHandler.

// ?implementation_description

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

//

AlfEventStatus AlfWidgetEventHandler::offerEvent( 

    CAlfWidgetControl& aControl,

    const TAlfEvent& aEvent )

    {

    AlfEventStatus ret(EEventNotHandled);

    // If the event handler is active in the control's current state and

    // any of the inputs accept the event, execute all outputs.

    if ( ( (mImpl->mActiveStates == ~0) ||

            (aControl.state() & mImpl->mActiveStates) ) &&

            accept( aControl, aEvent ) )

        {

        ret = EEventHandled;

        // Normal event outputs, property outputs and cancel outputs

        // are executed with all types of events (custom, key, pointer).

        int i;

        int count = mImpl->mCancelOutputs.count();

        for ( i = 0 ; i < count ; i++ )

            {

            mImpl->mCancelOutputs[i]->execute( aControl );

            }

        count = mImpl->mOutputs.count();

        for ( i = 0 ; i < count ; i++ )

            {

            mImpl->mOutputs[i]->execute( aControl, aEvent );

            }

        // Tactile outputs

#ifdef RD_TACTILE_FEEDBACK

        count = mImpl->mTactileOutputs.count();

        for ( i = 0 ; i < count ; i++ )

            {

            mImpl->mTactileOutputs[i]->execute();

            }

#endif // RD_TACTILE_FEEDBACK

        // widget attribute outputs

        count = mImpl->mWidgetAttributeOutputs.count();

        for ( i = 0 ; i < count ; i++ )

            {

            mImpl->mWidgetAttributeOutputs[i]->execute(

                aControl );

            }

        // Event output signal subscribers

        count = mImpl->mWidgetEventOutputSignals.count();

        for ( i = 0 ; i < count ; i++ )

            {

            mImpl->mWidgetEventOutputSignals[i]->execute();

            }

        // Animation event outputs, animation cancel outputs and property outputs

        // are executed only with custom events.

        if ( aEvent.IsCustomEvent() )

            {

            // Custom events have the associated data ID for finding the target

            // visual in the event data parameter.

            int dataID = aEvent.CustomEventData();

            count = mImpl->mAnimationCancelOutputs.count();

            for ( i = 0 ; i < count ; i++ )

                {

                mImpl->mAnimationCancelOutputs[i]->execute( aControl, dataID );

                }

            count = mImpl->mAnimationOutputs.count();

            for ( i = 0 ; i < count ; i++ )

                {

                mImpl->mAnimationOutputs[i]->sendCommand( aControl, dataID );

                }

            }

        // State change outputs

        count = mImpl->mStateChangeOutputs.count();

        for( i = 0; i < count; i++)

            {

            mImpl->mStateChangeOutputs[i]->execute( aControl );

            }

        // Event passer outputs

        count = mImpl->mEventPasserOutputs.count();

        for( i = 0; i < count; i++)

            {

            mImpl->mEventPasserOutputs[i]->execute( &aControl , aEvent );

            }      

        // AlfAppEvent outputs

        count = mImpl->mAppEventOutputs.count();