/*
* 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();
        for( i = 0; i < count; i++)
            {
            mImpl->mAppEventOutputs[i]->execute( aEvent );
            } 
        }

    return ret;
    }

// ---------------------------------------------------------------------------
// From class IAlfWidgetEventHandler.
// ---------------------------------------------------------------------------
//
void AlfWidgetEventHandler::setActiveStates( unsigned int aStates )
    {
    mImpl->mActiveStates = aStates;
    }

// ---------------------------------------------------------------------------
// From class IAlfWidgetEventHandler.
// ?implementation_description
// ---------------------------------------------------------------------------
//
void AlfWidgetEventHandler::setCapturing( bool aCapturing )
    {
    mImpl->mCapturing = aCapturing;
    }

// ---------------------------------------------------------------------------
// From class IAlfWidgetEventHandler.
// ?implementation_description
// ---------------------------------------------------------------------------
//
bool AlfWidgetEventHandler::capturing() const
    {
    return mImpl->mCapturing;
    }

// ---------------------------------------------------------------------------
// From class MAlfInterfaceBase.
// ?implementation_description
// ---------------------------------------------------------------------------
//
IAlfInterfaceBase* AlfWidgetEventHandler::makeInterface( const IfId& aType )
    {
    UString param( aType.mImplementationId );
    if ( param == IAlfWidgetEventHandler::type().mImplementationId )
        {
        return static_cast<IAlfWidgetEventHandler*>( this );
        }

    return NULL;
    }
    
// ---------------------------------------------------------------------------
// setEventHandlerData
// ---------------------------------------------------------------------------
//    
void AlfWidgetEventHandler::setEventHandlerData(const AlfWidgetEventHandlerInitData& aData)
	{
	// Set event handler id
	if (aData.mWidgetEventHandlerId)
	    {
	    int len = strlen(aData.mWidgetEventHandlerId);
	    char* tmp = new( EMM ) char[len + 1];
	    
        delete[] mImpl->mEhData.mWidgetEventHandlerId;
	        
        strcpy(tmp, aData.mWidgetEventHandlerId);
	    tmp[len] = 0;
	    mImpl->mEhData.mWidgetEventHandlerId = tmp;
	    }
	// we don't need to set node at the moment
	mImpl->mEhData.mNode = 0;
	}

// ---------------------------------------------------------------------------
// eventHandlerData
// ---------------------------------------------------------------------------
//
AlfWidgetEventHandlerInitData* AlfWidgetEventHandler::eventHandlerData()
	{
	return &mImpl->mEhData;
	}

// ---------------------------------------------------------------------------
// eventHandlerType
// ---------------------------------------------------------------------------
//
IAlfWidgetEventHandler::AlfEventHandlerType AlfWidgetEventHandler::eventHandlerType()
    {
    return mImpl->mEventHandlerType;
    }

// ---------------------------------------------------------------------------
// eventExecutionPhase
// ---------------------------------------------------------------------------
//
IAlfWidgetEventHandler::AlfEventHandlerExecutionPhase AlfWidgetEventHandler::eventExecutionPhase()
    {
    return mImpl->mEventHandlerExecutionPhase;
    }
}
// End of File.