--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/idlehomescreen/xmluicontroller/src/aixuikoneventhandler.cpp Thu Dec 17 08:40:49 2009 +0200
@@ -0,0 +1,552 @@
+/*
+* Copyright (c) 2005-2007 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: Used for handling XUIKON events
+*
+*/
+
+
+#include "aixuikoneventhandler.h"
+#include "aifweventhandler.h"
+#include "aiuieventhandler.h"
+#include "aiapplicationeventhandler.h"
+#include "aiconsts.h"
+#include "xmluicontroller.h"
+#include "aixmluiconstants.h"
+#include "aixmluiutils.h"
+#include "contentrenderer.h"
+#include <activeidle2domainpskeys.h>
+#include <activeidle2domaincrkeys.h>
+#include <csxhelp/hmsc.hlp.hrh>
+#include <aisystemuids.hrh>
+
+#include "xnnodeappif.h"
+#include "xnuiengineappif.h"
+#include "xnproperty.h"
+#include "xndomnode.h"
+#include "xntype.h"
+#include "xndomlist.h" // for cxndomlist
+#include "xndomattribute.h" // for cxndomattribute
+#include <e32svr.h>
+#include <aiutility.h>
+#include <aistrparser.h>
+#include <layoutmetadata.cdl.h>
+#include <e32property.h>
+#include <centralrepository.h>
+#include <AknUtils.h>
+#include <akntoolbar.h>
+#include <aknappui.h>
+#include <hlplch.h>
+#include <aknlistquerydialog.h>
+#include <ai3xmlui.rsg>
+#include <aknnotewrappers.h>
+#include <StringLoader.h>
+#include "xndompropertyvalue.h"
+#include "xnnodeappif.h"
+#include "appui.h"
+#include "xndomproperty.h"
+#include "xnplugindefs.h"
+#include "aieventhandler.h"
+
+const TInt KAiMaxNumberCharacters = 5;
+
+namespace AiXmlUiController
+ {
+ class CAIXuikonEventHandler::CNullEventHandler :
+ public CBase,
+ public MAiFwEventHandler,
+ public MAiUiEventHandler,
+ public MAiApplicationEventHandler
+ {
+
+ private: // from MAiFwEventHandler
+ void AppEnvReadyL();
+ void HandleUiReadyEventL( CAiUiController& aUiController );
+ void HandleActivateUI();
+ void HandleUiShutdown( CAiUiController& aUiController );
+ void CriticalStartupPhaseOver( TInt aStageInteger );
+ void HandleLoadPluginL( const TAiPublisherInfo& aPublisherInfo );
+ void HandleDestroyPluginL( const TAiPublisherInfo& aPublisherInfo );
+ void HandlePluginEvent( const TDesC& aParam );
+ void HandlePluginEventL( const TAiPublisherInfo& aPublisherInfo, const TDesC& aParam );
+ TBool HasMenuItemL( const TAiPublisherInfo& aPublisherInfo, const TDesC& aMenuItem );
+ TBool RefreshContent( const TDesC& aContentCid );
+ TBool QueryIsMenuOpen();
+ void ProcessStateChange( TAifwStates aSate );
+
+ private: // from MAiUiEventHandler
+ TBool HandleUiEvent( TAny* aEvent, const TDesC8& aParam );
+
+ private: // from MAiApplicationEventHandler
+ TBool HandleApplicationEvent( TInt aEvent, const TDesC8& aParam );
+ };
+ }
+
+using namespace AiXmlUiController;
+using namespace AiUiDef::xml::event;
+
+// ======== MEMBER FUNCTIONS ========
+// ----------------------------------------------------------------------------
+// CAIXuikonEventHandler::CAIXuikonEventHandler()
+// ----------------------------------------------------------------------------
+//
+CAIXuikonEventHandler::CAIXuikonEventHandler( CXmlUiController& aUiController,
+ CContentRenderer& aRenderer )
+ : iUiController(aUiController),
+ iContentRenderer(aRenderer)
+ {
+ }
+
+// ----------------------------------------------------------------------------
+// CAIXuikonEventHandler::ConstructL()
+// ----------------------------------------------------------------------------
+//
+void CAIXuikonEventHandler::ConstructL()
+ {
+ iStrParser = AiUtility::CreateStrParserL();
+ iNullEventHandler = new ( ELeave ) CNullEventHandler;
+ iFwEventHandler = iNullEventHandler;
+ iUiEventHandler = iNullEventHandler;
+ iApplicationEventHandler = iNullEventHandler;
+ }
+
+// ----------------------------------------------------------------------------
+// CAIXuikonEventHandler::NewL()
+// ----------------------------------------------------------------------------
+//
+CAIXuikonEventHandler* CAIXuikonEventHandler::NewL(
+ CXmlUiController& aUiController,
+ CContentRenderer& aRenderer )
+ {
+ CAIXuikonEventHandler* self =
+ new ( ELeave ) CAIXuikonEventHandler( aUiController, aRenderer );
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self );
+ return self;
+ }
+
+// ----------------------------------------------------------------------------
+// CAIXuikonEventHandler::~CAIXuikonEventHandler()
+// ----------------------------------------------------------------------------
+//
+CAIXuikonEventHandler::~CAIXuikonEventHandler()
+ {
+ delete iNullEventHandler;
+ delete iVolumeEvent;
+
+ Release( iStrParser );
+ }
+
+// ----------------------------------------------------------------------------
+// CAIXuikonEventHandler::SetFwEventHandler()
+// ----------------------------------------------------------------------------
+//
+void CAIXuikonEventHandler::SetFwEventHandler(
+ MAiFwEventHandler* aFwEventHandler )
+ {
+ if ( aFwEventHandler )
+ {
+ iFwEventHandler = aFwEventHandler;
+ }
+ else
+ {
+ iFwEventHandler = iNullEventHandler;
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CAIXuikonEventHandler::SetUiEventHandler()
+// ----------------------------------------------------------------------------
+//
+void CAIXuikonEventHandler::SetUiEventHandler(
+ MAiUiEventHandler* aUiEventHandler )
+ {
+ if ( aUiEventHandler )
+ {
+ iUiEventHandler = aUiEventHandler;
+ }
+ else
+ {
+ iUiEventHandler = iNullEventHandler;
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CAIXuikonEventHandler::SetApplicationEventHandler()
+// ----------------------------------------------------------------------------
+//
+void CAIXuikonEventHandler::SetApplicationEventHandler(
+ MAiApplicationEventHandler* aApplicationEventHandler )
+ {
+ if ( aApplicationEventHandler )
+ {
+ iApplicationEventHandler = aApplicationEventHandler;
+ }
+ else
+ {
+ iApplicationEventHandler = iNullEventHandler;
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CAIXuikonEventHandler::HandleXuikonEventL()
+// ----------------------------------------------------------------------------
+//
+void CAIXuikonEventHandler::HandleXuikonEventL( CXnNodeAppIf& aOrigin,
+ CXnNodeAppIf& /*aTrigger*/, CXnDomNode& aTriggerDefinition,
+ CXnDomNode& aEvent )
+ {
+ DispatchEventL( aEvent, aOrigin, aTriggerDefinition );
+ }
+
+// ----------------------------------------------------------------------------
+// CAIXuikonEventHandler::HandleXuikonActionL()
+// ----------------------------------------------------------------------------
+//
+inline TBool CAIXuikonEventHandler::HandleSystemEventL(
+ const TDesC8& aEventText, CXnDomNode& aEvent )
+ {
+ const TDesC8& prefix( AiUiDef::xml::event::KEventHandlerPrefix );
+ TInt pos( aEventText.Find( prefix ) );
+ if ( pos != 0 )
+ {
+ // Event is not targeted here
+ return EFalse;
+ }
+ CAIEventHandler* handler = CAIEventHandler::NewL( iUiController );
+ CleanupStack::PushL( handler );
+ handler->HandleEventL( aEventText, aEvent );
+ CleanupStack::PopAndDestroy( handler );
+ return ETrue;
+ }
+
+
+// ----------------------------------------------------------------------------
+// CAIXuikonEventHandler::ParseParameterStringL()
+// ----------------------------------------------------------------------------
+//
+void CAIXuikonEventHandler::ParseParameterStringL( const TDesC8& aSourcePtr,
+ TPtrC8& aTargetPtr )
+ {
+ // Parses parameter string between the first '(' and last ')'
+ // Trailing and heading white spaces ARE NOT handled!
+
+ const TInt separatorPos = aSourcePtr.Locate( KEventParameterSeparator );
+ User::LeaveIfError( separatorPos );
+
+ const TInt eventSeparatorPos = aSourcePtr.LocateReverse(
+ KEventParameterSeparatorEnd );
+ User::LeaveIfError( eventSeparatorPos );
+
+ // separatorPos + 1 must be smaller than eventSeparatorPos - 1
+ User::LeaveIfError( ( eventSeparatorPos ) - ( separatorPos + 1 ) );
+
+ // Extract event and parameter string
+ TPtrC8 menuName( aSourcePtr.Mid( separatorPos + 1,
+ ( eventSeparatorPos ) - ( separatorPos + 1 ) ) );
+
+ aTargetPtr.Set( menuName );
+ }
+
+// ----------------------------------------------------------------------------
+// CAIXuikonEventHandler::HandleUiEventL()
+// ----------------------------------------------------------------------------
+//
+inline TBool CAIXuikonEventHandler::HandleUiEventL( const TDesC8& aEventText,
+ CXnNodeAppIf& aOrigin )
+ {
+ if ( aEventText.Left( KUiEventPrefix().Length() ) == KUiEventPrefix )
+ {
+ iUiEventHandler->HandleUiEvent( (TAny*)&aOrigin, aEventText );
+
+ return ETrue;
+ }
+
+ return EFalse;
+ }
+
+// ----------------------------------------------------------------------------
+// CAIXuikonEventHandler::HandleApplicationEventL()
+// ----------------------------------------------------------------------------
+//
+inline TBool CAIXuikonEventHandler::HandleApplicationEventL(
+ const TDesC8& aEventText )
+ {
+ return iApplicationEventHandler->HandleApplicationEvent( 0, aEventText );
+ }
+
+// ----------------------------------------------------------------------------
+// CAIXuikonEventHandler::VolumeChanged()
+// ----------------------------------------------------------------------------
+//
+void CAIXuikonEventHandler::VolumeChanged( TInt aValue )
+ {
+ TRAP_IGNORE(
+ // Ignore errors, missing one event is not fatal enough to panic
+ HBufC* volumeString( HBufC::NewLC( KAiMaxNumberCharacters ) );
+
+ volumeString->Des().Num( aValue );
+
+ HBufC* eventString( iVolumeEvent->AllocLC() );
+
+ TInt foundAt( eventString->Des().Find( KTargetSliderVolumeValue ) );
+
+ if( foundAt >= 0 )
+ {
+ eventString->Des().Replace( foundAt,
+ KTargetSliderVolumeValue().Length(), *volumeString );
+ }
+
+ // TODO: implement namespace properly
+ iFwEventHandler->HandlePluginEvent( *eventString );
+
+ CleanupStack::PopAndDestroy( 2, volumeString );
+ ); // TRAP_IGNORE
+ }
+
+// ----------------------------------------------------------------------------
+// CAIXuikonEventHandler::HandlePluginEventL()
+// ----------------------------------------------------------------------------
+//
+inline
+void CAIXuikonEventHandler::HandlePluginEventL( CXnDomNode& aEvent )
+ {
+ const TDesC8& event8(
+ aEvent.AttributeValue( XnPropertyNames::action::event::KName ) );
+
+ HBufC16* event( NULL );
+
+ event = iStrParser->CopyToBufferL( event, event8 );
+
+ if ( !event || *event == KNullDesC )
+ {
+ // No event defined
+ return;
+ }
+
+ CleanupStack::PushL( event );
+
+ TXnUiEngineAppIf* engine( iUiController.UiEngineL() );
+
+ const TDesC8& broadcast(
+ aEvent.AttributeValue( XnPropertyNames::action::event::KBroadcast ) );
+
+ if ( broadcast == XnPropertyNames::KTrue )
+ {
+ // Broadcast events are allowed only from view's namespace
+ if ( engine->ActiveView()->Namespace() == aEvent.Namespace() )
+ {
+ _LIT8( KGlobal, "global" );
+
+ // Get all plugins
+ RPointerArray< CXnNodeAppIf >
+ list( engine->FindContentSourceNodesL( KGlobal ) );
+
+ CleanupClosePushL( list );
+
+ // Broadcast event to all plugins
+ for ( TInt i = 0; i < list.Count(); i++ )
+ {
+ TAiPublisherInfo info;
+
+ iUiController.PublisherInfoL( *list[i], info );
+
+ // Forward event to AiFw
+ iFwEventHandler->HandlePluginEventL( info, *event );
+ }
+
+ CleanupStack::PopAndDestroy( &list );
+ }
+ }
+ else
+ {
+ const TDesC8& ns( aEvent.Namespace() );
+
+ // Get plugins from the event's namespace
+ RPointerArray< CXnNodeAppIf >
+ list( engine->FindContentSourceNodesL( ns ) );
+
+ CleanupClosePushL( list );
+
+ if ( list.Count() == 1 )
+ {
+ // Only one data plugin in this namespace,
+ // it must handle this event.
+ TAiPublisherInfo info;
+
+ iUiController.PublisherInfoL( *list[0], info );
+
+ // Forward event to AiFw
+ iFwEventHandler->HandlePluginEventL( info, *event );
+ }
+ else if ( list.Count() > 1 )
+ {
+ const TDesC8& destination(
+ aEvent.AttributeValue(
+ XnPropertyNames::action::event::KDestination ) );
+
+ // Multiple data plugins in this namespace,
+ // resolve destination
+ CXnNodeAppIf* eventHandler(
+ engine->FindNodeByIdL( destination, ns ) );
+
+ if ( eventHandler )
+ {
+ TAiPublisherInfo info;
+
+ iUiController.PublisherInfoL( *eventHandler, info );
+
+ // Forward event to AiFw
+ iFwEventHandler->HandlePluginEventL( info, *event );
+ }
+ else
+ {
+ // No exact destination defined,
+ // try to find a correct plugin based on event
+ const TInt pos( event->Locate( KPluginEventSeparator ) );
+
+ if ( pos != KErrNotFound )
+ {
+ // Extract plugin name
+ TPtrC pluginName( event->Left( pos ) );
+
+ for ( TInt i = 0; i < list.Count(); i++ )
+ {
+ TAiPublisherInfo info;
+
+ iUiController.PublisherInfoL( *list[i], info );
+
+ if( info.iName == pluginName )
+ {
+ // Forward Plug-in events to AI FW for further
+ // dispatching to the target Plug-in
+ iFwEventHandler->HandlePluginEventL( info,*event );
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ CleanupStack::PopAndDestroy( &list );
+ }
+
+ CleanupStack::PopAndDestroy( event );
+ }
+
+// ----------------------------------------------------------------------------
+// CAIXuikonEventHandler::DispatchEventL()
+// ----------------------------------------------------------------------------
+//
+void CAIXuikonEventHandler::DispatchEventL( CXnDomNode& aEvent,
+ CXnNodeAppIf& aOrigin, CXnDomNode& /*aTriggerDefinition*/ )
+ {
+ const TDesC8& aEventString8(
+ aEvent.AttributeValue( XnPropertyNames::action::event::KName ) );
+
+ // First check if the event is a XUIKON-specific event
+ if( !HandleSystemEventL( aEventString8, aEvent ) )
+ {
+ // Next check if it is a UI event
+ if( !HandleUiEventL( aEventString8, aOrigin ) )
+ {
+ // Next check if it is an application event
+ if( !HandleApplicationEventL( aEventString8 ) )
+ {
+ // Assume that it is a Plug-in event
+ HandlePluginEventL( aEvent );
+ }
+ }
+ }
+ }
+
+// CAIXuikonEventHandler::CNullEventHandler
+void CAIXuikonEventHandler::CNullEventHandler::AppEnvReadyL()
+ {
+ }
+
+void CAIXuikonEventHandler::CNullEventHandler::HandleUiReadyEventL
+ ( CAiUiController& /*aUiController*/ )
+ {
+ }
+
+void CAIXuikonEventHandler::CNullEventHandler::HandleActivateUI()
+ {
+ }
+
+void CAIXuikonEventHandler::CNullEventHandler::HandlePluginEvent
+ ( const TDesC& /*aParam*/ )
+ {
+ }
+
+void CAIXuikonEventHandler::CNullEventHandler::HandlePluginEventL
+ (const TAiPublisherInfo& /*aPublisherInfo*/, const TDesC& /*aParam*/ )
+ {
+ }
+
+TBool CAIXuikonEventHandler::CNullEventHandler::HasMenuItemL(
+ const TAiPublisherInfo& /*aPublisherInfo*/, const TDesC& /*aMenuItem*/ )
+ {
+ return EFalse;
+ }
+
+void CAIXuikonEventHandler::CNullEventHandler::HandleUiShutdown
+ ( CAiUiController& /*aUiController*/ )
+ {
+ }
+
+TBool CAIXuikonEventHandler::CNullEventHandler::RefreshContent(
+ const TDesC& /*aContentCid*/ )
+ {
+ return EFalse;
+ }
+
+void CAIXuikonEventHandler::CNullEventHandler::CriticalStartupPhaseOver(
+ TInt /*aStageInteger*/ )
+ {
+ }
+
+TBool CAIXuikonEventHandler::CNullEventHandler::QueryIsMenuOpen()
+ {
+ return EFalse;
+ }
+
+void CAIXuikonEventHandler::CNullEventHandler::ProcessStateChange(
+ TAifwStates /*aSate*/)
+ {
+ }
+
+void CAIXuikonEventHandler::CNullEventHandler::HandleLoadPluginL(
+ const TAiPublisherInfo& /*aPluginToLoad*/ )
+ {
+ }
+
+void CAIXuikonEventHandler::CNullEventHandler::HandleDestroyPluginL(
+ const TAiPublisherInfo& /*aPluginToDestroy*/ )
+ {
+ }
+
+TBool CAIXuikonEventHandler::CNullEventHandler::HandleUiEvent
+ (TAny* /*aEvent*/, const TDesC8& /*aParam*/)
+ {
+ return EFalse;
+ }
+
+TBool CAIXuikonEventHandler::CNullEventHandler::HandleApplicationEvent
+ (TInt /*aEvent*/, const TDesC8& /*aParam*/)
+ {
+ return EFalse;
+ }
+
+// End of file