diff -r 000000000000 -r f72a12da539e idlehomescreen/xmluicontroller/src/aixuikoneventhandler.cpp
--- /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