--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/widgetmodel/alfwidgetmodel/src/alfeventoutput.cpp Wed Sep 01 12:23:18 2010 +0100
@@ -0,0 +1,473 @@
+/*
+* 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.