diff -r 4ea6f81c838a -r 0e9bb658ef58 widgetmodel/alfwidgetmodel/src/alfwidgeteventhandler.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/widgetmodel/alfwidgetmodel/src/alfwidgeteventhandler.cpp Wed Sep 01 12:23:18 2010 +0100 @@ -0,0 +1,632 @@ +/* +* 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 +#include + +#include "alf/alfwidgeteventhandler.h" +#include +#include +#include +#include "alf/alfattribute.h" +#include +#include +#include +#include + +#ifdef RD_TACTILE_FEEDBACK +#include +#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 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 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 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 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 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 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( 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.