--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/idlehomescreen/xmluicontroller/src/xmluicontroller.cpp Thu Dec 17 08:40:49 2009 +0200
@@ -0,0 +1,1023 @@
+/*
+* Copyright (c) 2005-2008 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: XML UI Controller main class
+*
+*/
+
+// System includes
+#include <ecom/implementationproxy.h>
+#include <AknQueryDialog.h>
+#include <eikstart.h>
+#include <apgtask.h>
+#include <centralrepository.h>
+#include <e32property.h>
+
+// User includes
+#include <activeidle2domainpskeys.h>
+#include <activeidle2domaincrkeys.h>
+#include <aiscutplugindomaincrkeys.h>
+#include <aisystemuids.hrh>
+#include <ai3xmlui.rsg>
+
+#include "xmluicontroller.h"
+
+#include "xnuiengineappif.h"
+#include "xnnodeappif.h"
+#include "xnproperty.h"
+#include "xntype.h"
+#include "aistrcnv.h"
+
+#include "application.h"
+#include "appui.h"
+#include "xmlnodeidgenerator.h"
+#include "aixuikoneventhandler.h"
+#include "aixmluiutils.h"
+#include "aiutility.h"
+#include "aipluginsettings.h"
+#include "aixmluiconstants.h"
+#include "aifweventhandler.h"
+#include "debug.h"
+#include "aiconsts.h"
+#include "contentrenderer.h"
+#include "xmluicontrollerpanic.h"
+#include "pmodtiterator.h"
+#include "contentpublisher.h"
+#include "xnplugindefs.h"
+#include "ainativeuiplugins.h"
+
+
+using namespace AiXmlUiController;
+
+const TInt KOneSecondInMicroS = 1000*1000;
+const TInt KAI2CrKeyIncrementBy2 = 2;
+
+typedef TBuf<32> TNamespace;
+
+_LIT( KSettingsDummyData, "" );
+
+// ======== LOCAL FUNCTIONS ========
+// ----------------------------------------------------------------------------
+// ResolveEventParameters()
+// ----------------------------------------------------------------------------
+//
+static void ResolveEventParameters( const TDesC8& aEventString,
+ TPtrC8& aParam1, TPtrC8& aParam2 )
+ {
+ TInt paramPos( aEventString.Locate( KEventParameterSeparator ) );
+
+ TLex8 lex( aEventString.Mid( ++paramPos ) );
+
+ aParam1.Set( lex.NextToken() ); // first ui element id
+
+ TInt commaPos( aParam1.LocateReverse( KComma ) );
+
+ if( commaPos != KErrNotFound )
+ {
+ // Strip comma
+ aParam1.Set( aParam1.Left( commaPos ) );
+
+ aParam2.Set( lex.NextToken() ); // second ui element id
+
+ TInt rightParenthesis( aParam2.LocateReverse( KRightParenthesis ) );
+
+ if( rightParenthesis != KErrNotFound )
+ {
+ aParam2.Set( aParam2.Left( rightParenthesis ) );
+ }
+ }
+ else
+ {
+ // Strip right parenthesis
+ aParam1.Set( aParam1.Left( aParam1.Length() -1 ) );
+ }
+ }
+
+// ======== MEMBER FUNCTIONS ========
+// ----------------------------------------------------------------------------
+// CXmlUiController::CXmlUiController()
+// ----------------------------------------------------------------------------
+//
+CXmlUiController::CXmlUiController()
+ {
+ }
+
+// ----------------------------------------------------------------------------
+// CXmlUiController::ConstructL()
+// ----------------------------------------------------------------------------
+//
+void CXmlUiController::ConstructL()
+ {
+ iNodeIdGenerator = CXmlNodeIdGenerator::NewL();
+
+ iAISettingsRepository =
+ CRepository::NewL( TUid::Uid( KCRUidActiveIdleLV ) );
+
+ // Indicate to wserv plugin if it launches logs on send key or not
+ RProperty::Set( KPSUidAiInformation, KActiveIdleActOnSendKey, ETrue );
+ }
+
+// ----------------------------------------------------------------------------
+// CXmlUiController::NewL()
+// ----------------------------------------------------------------------------
+//
+CXmlUiController* CXmlUiController::NewL()
+ {
+ CXmlUiController* self = new ( ELeave ) CXmlUiController;
+
+ CleanupStack::PushL( self );
+ self->ConstructL();
+
+ // Set XML UI Controller object to TLS for access in static
+ // CXmlUiController::NewApplication
+ User::LeaveIfError( Dll::SetTls( self ) );
+
+ CleanupStack::Pop( self );
+
+ return self;
+ }
+
+// ----------------------------------------------------------------------------
+// CXmlUiController::~CXmlUiController()
+// ----------------------------------------------------------------------------
+//
+CXmlUiController::~CXmlUiController()
+ {
+ delete iNodeIdGenerator;
+ delete iExitTimer;
+ delete iAISettingsRepository;
+ delete iCPSpublisher;
+
+ // Reset TLS pointer to this set in NewL
+ Dll::SetTls( NULL );
+ }
+
+// ----------------------------------------------------------------------------
+// CXmlUiController::Exit()
+// ----------------------------------------------------------------------------
+//
+void CXmlUiController::Exit()
+ {
+ if( iExitTimer )
+ {
+ iExitTimer->Cancel();
+
+ iExitTimer->Start( 0, KOneSecondInMicroS,
+ TCallBack( ExitTimerCallBack, this ) );
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CXmlUiController::ExitTimerCallBack()
+// ----------------------------------------------------------------------------
+//
+TInt CXmlUiController::ExitTimerCallBack(TAny *aSelf)
+ {
+ CXmlUiController* self =
+ static_cast< CXmlUiController* >( aSelf );
+
+ if( self )
+ {
+ self->iExitTimer->Cancel();
+
+ self->iAppUi->Exit();
+ }
+
+ return KErrNone;
+ }
+
+// ----------------------------------------------------------------------------
+// CXmlUiController::SetObserver()
+// ----------------------------------------------------------------------------
+//
+void CXmlUiController::SetObserver( MAiContentObserver& aObserver )
+ {
+ iObserver = &aObserver;
+ }
+
+// ----------------------------------------------------------------------------
+// CXmlUiController::SetAppUi()
+// ----------------------------------------------------------------------------
+//
+void CXmlUiController::SetAppUi( CAppUi& aAppUi )
+ {
+ iAppUi = &aAppUi;
+ }
+
+// ----------------------------------------------------------------------------
+// CXmlUiController::AppUi()
+// ----------------------------------------------------------------------------
+//
+CAppUi* CXmlUiController::AppUi() const
+ {
+ return iAppUi;
+ }
+
+// ----------------------------------------------------------------------------
+// CXmlUiController::UiEngineL()
+// ----------------------------------------------------------------------------
+//
+TXnUiEngineAppIf* CXmlUiController::UiEngineL() const
+ {
+ return iAppUi ? iAppUi->UiEngineL() : NULL;
+ }
+
+// ----------------------------------------------------------------------------
+// CXmlUiController::SettingsRepository()
+// ----------------------------------------------------------------------------
+//
+CRepository& CXmlUiController::SettingsRepository() const
+ {
+ return *iAISettingsRepository;
+ }
+
+// ----------------------------------------------------------------------------
+// CXmlUiController::CreateXuikonEventHandlerL()
+// ----------------------------------------------------------------------------
+//
+CAIXuikonEventHandler* CXmlUiController::CreateXuikonEventHandlerL(
+ CContentRenderer& aRenderer )
+ {
+ CAIXuikonEventHandler* eventHandler =
+ CAIXuikonEventHandler::NewL( *this, aRenderer );
+
+ eventHandler->SetFwEventHandler( iFwEventHandler );
+ eventHandler->SetUiEventHandler( this );
+
+ return eventHandler;
+ }
+
+// ----------------------------------------------------------------------------
+// CXmlUiController::NotifyAppEnvReadyL()
+// ----------------------------------------------------------------------------
+//
+void CXmlUiController::NotifyAppEnvReadyL()
+ {
+ if( iFwEventHandler )
+ {
+ iFwEventHandler->AppEnvReadyL();
+ iFwEventHandler->HandleUiReadyEventL( *this );
+ }
+
+ if( !iCPSpublisher )
+ {
+ iCPSpublisher = CContentPublisher::NewL( *this );
+ }
+
+ if( !iExitTimer )
+ {
+ iExitTimer = CPeriodic::NewL( CActive::EPriorityStandard );
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CXmlUiController::LoadUIDefinition()
+// ----------------------------------------------------------------------------
+//
+void CXmlUiController::LoadUIDefinitionL()
+ {
+ // No implementation required
+ }
+
+// ----------------------------------------------------------------------------
+// CXmlUiController::GetPluginsL()
+// ----------------------------------------------------------------------------
+//
+void CXmlUiController::GetPluginsL( RAiPublisherInfoArray& /*aPlugins*/ )
+ {
+ // No implementation required
+ }
+
+// ----------------------------------------------------------------------------
+// CXmlUiController::PublisherInfo()
+// ----------------------------------------------------------------------------
+//
+void CXmlUiController::PublisherInfoL( RAiPublisherInfoArray& aPlugins )
+ {
+ // This method returns plugins with namespace KNativeUiNamespace
+ if ( iRunningAsMain )
+ {
+ // This plugin is used to publish data on secondary ui controller side
+ TAiPublisherInfo deviceStatus;
+ deviceStatus.iUid = KDeviceStatusPluginUid;
+ deviceStatus.iName.Copy( KDeviceStatusPluginName );
+ deviceStatus.iNamespace.Copy( KNativeUiNamespace );
+
+ aPlugins.AppendL( deviceStatus );
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CXmlUiController::PublisherInfoL()
+// ----------------------------------------------------------------------------
+//
+void CXmlUiController::PublisherInfoL( CXnNodeAppIf& aSource,
+ TAiPublisherInfo& aInfo )
+ {
+ // Fetch uid from XML and convert it to TUid
+ const TDesC8* uid( PropertyValue( aSource,
+ AiUiDef::xml::property::KValue ) );
+
+ if ( !uid )
+ {
+ return;
+ }
+
+ _LIT8( KPrefix, "0x" );
+
+ const TInt pos( uid->FindF( KPrefix ) );
+
+ if( pos != KErrNotFound )
+ {
+ TLex8 lex( uid->Mid( pos + KPrefix().Length() ) );
+
+ // Hex parsing needs unsigned int
+ TUint32 value = 0;
+ const TInt parseResult = lex.Val( value, EHex );
+
+ if ( parseResult == KErrNone )
+ {
+ TInt32 value32( value );
+
+ aInfo.iUid = TUid::Uid( value32 );
+ }
+ }
+
+ // Fetch plug-in name from XML
+ HBufC* pluginName( PropertyValueL( aSource,
+ AiUiDef::xml::property::KName ) );
+
+ CleanupStack::PushL( pluginName );
+
+ if ( pluginName )
+ {
+ aInfo.iName.Copy( *pluginName );
+ }
+
+ CleanupStack::PopAndDestroy( pluginName );
+
+ aInfo.iNamespace.Copy( aSource.Namespace() );
+ }
+
+// ----------------------------------------------------------------------------
+// CXmlUiController::GetSettingsL()
+// ----------------------------------------------------------------------------
+//
+void CXmlUiController::GetSettingsL( const TAiPublisherInfo& aPubInfo,
+ RAiSettingsItemArray& aSettings )
+ {
+ if ( aPubInfo.iNamespace == KNativeUiNamespace )
+ {
+ // This controller doesn't provide settings for native ui namespace
+ return;
+ }
+
+ const TDesC& classId( iNodeIdGenerator->SettingsNodeIdL( aPubInfo ) );
+
+ TNamespace ns;
+
+ ns.Copy( aPubInfo.iNamespace );
+
+ // Find settings nodes
+ RPointerArray< CXnNodeAppIf > nodes(
+ UiEngineL()->FindNodeByClassL( classId, ns ) );
+
+ CleanupClosePushL( nodes );
+
+ // Reserve space for settings
+ aSettings.ReserveL( aSettings.Count() + nodes.Count() );
+
+ // Collect settings
+ TInt count( nodes.Count() );
+
+ for( TInt i = 0; i < count; ++i )
+ {
+ CXnNodeAppIf* node( nodes[i] );
+
+ const TDesC8* name(
+ PropertyValue( *node, AiUiDef::xml::property::KName ) );
+
+ HBufC* value(
+ PropertyValueL( *node, AiUiDef::xml::property::KValue ) );
+
+ CleanupStack::PushL( value );
+
+ if( name && value )
+ {
+ MAiPluginSettings* settings( AiUtility::CreatePluginSettingsL() );
+ CleanupDeletePushL( settings );
+
+ MAiPluginSettingsItem& item( settings->AiPluginSettingsItem() );
+ item.SetPublisherId( aPubInfo.iUid );
+
+ TInt32 key( 0 );
+
+ User::LeaveIfError( AiUtility::ParseInt( key, *name ) );
+
+ item.SetKey( key );
+ item.SetValueL( *value, EFalse );
+
+ // Append settings into array.
+ // This can not fail because space has been reserved.
+ aSettings.Append( settings );
+ CleanupStack::Pop( settings );
+ }
+
+ CleanupStack::PopAndDestroy( value );
+ }
+
+ CleanupStack::PopAndDestroy( &nodes );
+
+ GetSettingsFromCRL( aPubInfo, aSettings );
+ GetContentModelL( aPubInfo, aSettings );
+ }
+
+// ----------------------------------------------------------------------------
+// CXmlUiController::GetSettingsFromCRL()
+// ----------------------------------------------------------------------------
+//
+void CXmlUiController::GetSettingsFromCRL( const TAiPublisherInfo& aPubInfo,
+ RAiSettingsItemArray &aPluginSettings )
+ {
+ if ( aPubInfo.iNamespace == KNativeUiNamespace )
+ {
+ // This controller doesn't provide settings for native ui namespace
+ return;
+ }
+
+ /*
+ * The settings are stored in the cenrep starting from 0x1000.
+ * 0x1000 is the name of the plugin which this setting belongs to (for example Settings/Shortcut)
+ * 0x1001 is the id of the setting (for example 1)
+ * 0x1002 is the value of the setting (for example localapp:0x012345678)
+ *
+ * So three keys per setting.
+ *
+ * Settings from cenrep override those from XML
+ */
+
+ TUint32 crKey( KAIPluginSettingsKeyRangeStart );
+
+ TBool moreSettings( ETrue );
+
+ HBufC* pluginId = HBufC::NewLC(
+ NCentralRepositoryConstants::KMaxUnicodeStringLength );
+
+ HBufC* settingValue = HBufC::NewLC(
+ NCentralRepositoryConstants::KMaxUnicodeStringLength );
+
+ HBufC* settingKey = HBufC::NewLC(
+ NCentralRepositoryConstants::KMaxUnicodeStringLength );
+
+ TPtr pluginIdPtr( pluginId->Des() );
+ TPtr settingValuePtr( settingValue->Des() );
+ TPtr settingKeyPtr( settingKey->Des() );
+
+ TInt32 settingId( 0 );
+
+ TInt err( KErrNone );
+ TBool settingFound( EFalse );
+
+ while( moreSettings )
+ {
+ settingFound = EFalse;
+
+ pluginIdPtr.Zero();
+ settingValuePtr.Zero();
+ settingKeyPtr.Zero();
+
+ //Get the name of plugin with the Settings/ prefix
+ err = iAISettingsRepository->Get( crKey++, pluginIdPtr );
+
+ // remove the Settings/ prefix if it is located at the start of the string
+ if( pluginIdPtr.FindC( AiUiDef::xml::propertyClass::KSettings ) == 0 )
+ {
+ pluginIdPtr.Delete( 0,
+ AiUiDef::xml::id::KSettingsIdSeparator().Length() +
+ AiUiDef::xml::propertyClass::KSettings().Length() );
+ }
+
+ // does the setting belong to this plugin
+ if( err == KErrNone && pluginIdPtr == aPubInfo.iName )
+ {
+ // Get the settings id
+ err = iAISettingsRepository->Get( crKey++, settingKeyPtr );
+
+ if( err == KErrNone )
+ {
+ err = AiUtility::ParseInt( settingId,settingKeyPtr );
+ }
+
+ if( err == KErrNone )
+ {
+ // Get the actual value of the setting
+ err = iAISettingsRepository->Get( crKey++, settingValuePtr );
+
+ // Ignore possible placeholder data in cenrep
+ if( err == KErrNone && settingValuePtr.Compare( KSettingsDummyData ) != 0 )
+ {
+ // Try to find an existing setting for this
+ for( TInt j = 0; j < aPluginSettings.Count(); j++ )
+ {
+ MAiPluginSettings* setting( aPluginSettings[j] );
+ MAiPluginSettingsItem& item( setting->AiPluginSettingsItem() );
+
+ // Existing setting found => replace it
+ if( item.Key() == settingId && item.PublisherId() == aPubInfo.iUid )
+ {
+ item.SetValueL( settingValuePtr, EFalse );
+ settingFound = ETrue;
+ break;
+ }
+ }
+
+ // Existing setting not found => append new one ONLY if we
+ // are dealing with the icon overrides or toolbar shortcuts
+ if( !settingFound &&
+ ( ( settingId & KScutFlagBitToolbarShortcut ) ||
+ ( settingId & KScutFlagBitIconOverride ) ) )
+ {
+ MAiPluginSettings* settings( AiUtility::CreatePluginSettingsL() );
+ CleanupDeletePushL( settings );
+
+ MAiPluginSettingsItem& item( settings->AiPluginSettingsItem() );
+
+ item.SetPublisherId( aPubInfo.iUid );
+ item.SetKey( settingId );
+ item.SetValueL( settingValuePtr, EFalse );
+
+ aPluginSettings.Append( settings );
+ CleanupStack::Pop( settings );
+ }
+ }
+ }
+ else
+ {
+ // no settings id found => invalid settings in cenrep
+ __PRINT8( __DBG_FORMAT8("CXmlUiController::GetSettingsFromCRL: ERROR: invalid settings. key: %d pluginname: %S id: %d value: %S"), crKey, pluginId, settingId, settingValue );
+ }
+ }
+ else if( err != KErrNone )
+ {
+ // name of the plugin not found => no more settings
+ moreSettings = EFalse;
+ }
+ else
+ {
+ // not the correct setting for this plugin
+ crKey += KAI2CrKeyIncrementBy2;
+ }
+ }
+
+ CleanupStack::PopAndDestroy( 3, pluginId ); // settingValue, settingKey
+ }
+
+// ----------------------------------------------------------------------------
+// CXmlUiController::GetContentModelL()
+// ----------------------------------------------------------------------------
+//
+// ContentModelL()
+void CXmlUiController::GetContentModelL( const TAiPublisherInfo& aPubInfo,
+ RAiSettingsItemArray& aSettings )
+ {
+ if ( aPubInfo.iNamespace == KNativeUiNamespace )
+ {
+ // This controller doesn't provide content model for native ui namespace
+ return;
+ }
+
+ // Find the node for the publisher
+ // TODO Does not work if widget is in view
+ RPointerArray<CXnNodeAppIf> list(
+ UiEngineL()->FindContentSourceNodesL( aPubInfo.iNamespace ) );
+ CleanupClosePushL( list );
+
+ CXnNodeAppIf* publisherNode( NULL );
+
+ if ( list.Count() > 0 )
+ {
+ publisherNode = list[0];
+ }
+
+ CleanupStack::PopAndDestroy( &list );
+
+ if( !publisherNode )
+ {
+ return;
+ }
+
+ // Find ui plugin node for the data plugin
+ CXnNodeAppIf* parentNode( publisherNode->ParentL() );
+
+ // parent must be correct type
+ if( parentNode->InternalDomNodeType() == _L8("widget") )
+ {
+ // Get plugin configurations
+ GetConfigurationsL( *parentNode, aSettings, AiUiDef::xml::element::K16Plugin());
+ CPmODTIterator* iter = CPmODTIterator::NewL( *parentNode );
+ CleanupStack::PushL( iter );
+ CXnNodeAppIf* node = iter->First();
+ while( node )
+ {
+ const TDesC8& nodeType = node->Type()->Type();
+ if( nodeType == XnPropertyNames::action::KActions)
+ {
+ node = iter->SkipBranchL();
+ }
+ // Get the content model and configuration for the supported elements
+ else if( nodeType == AiUiDef::xml::element::KImage ||
+ nodeType == AiUiDef::xml::element::KText ||
+ nodeType == AiUiDef::xml::element::KNewsTicker )
+ {
+ // Is created in GetContenItem and used in GetConfigurationsL
+ HBufC* confOwner( NULL );
+ // get content item for the element, confOwner is filled
+ GetContentItemL( *node, aSettings, confOwner );
+ if( confOwner )
+ {
+ CleanupStack::PushL( confOwner );
+ // get configurations for the element
+ GetConfigurationsL( *node, aSettings, *confOwner );
+ CleanupStack::PopAndDestroy( confOwner );
+ }
+ node = iter->SkipBranchL();
+ }
+ else
+ {
+ node = iter->NextL();
+ }
+ }
+ CleanupStack::PopAndDestroy( iter );
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CXmlUiController::GetContentItemL()
+// ----------------------------------------------------------------------------
+//
+// ContentItemL()
+void CXmlUiController::GetContentItemL( CXnNodeAppIf& aNode,
+ RAiSettingsItemArray& aSettings, HBufC*& aItemName )
+ {
+ // Find property node
+ RPointerArray<CXnNodeAppIf> childNodes( aNode.ChildrenL() );
+ CleanupClosePushL( childNodes );
+
+ TInt count( childNodes.Count() );
+
+ for ( TInt i = 0; i < count; i++ )
+ {
+ CXnNodeAppIf* node( childNodes[i] );
+
+ if( node->Type()->Type() == XnPropertyNames::action::KProperty )
+ {
+ HBufC* name = PropertyValueL( *node, AiUiDef::xml::property::KClass );
+ CleanupStack::PushL( name );
+
+ if( name )
+ {
+ // Content model found for the element, create content item
+ MAiPluginSettings* settings = AiUtility::CreatePluginSettingsL();
+ CleanupDeletePushL( settings );
+
+ MAiPluginContentItem& item = settings->AiPluginContentItem();
+
+ // Type of the element is needed in content model
+ HBufC* type( NULL );
+ type = AiUtility::CopyToBufferL( type, aNode.Type()->Type());
+ CleanupStack::PushL( type );
+ item.SetTypeL( *type );
+ CleanupStack::PopAndDestroy( type );
+
+ item.SetNameL( *name );
+
+ aItemName = name;
+ aSettings.AppendL( settings );
+ CleanupStack::Pop( settings );
+ }
+
+ // Ownership is given to aItemName
+ CleanupStack::Pop( name );
+
+ // First property element, which has class attribute is selected
+ break;
+ }
+ }
+
+ CleanupStack::PopAndDestroy( &childNodes );
+ }
+
+// ----------------------------------------------------------------------------
+// CXmlUiController::GetConfigurationsL()
+// ----------------------------------------------------------------------------
+//
+// ConfigurationItemsL()
+void CXmlUiController::GetConfigurationsL( CXnNodeAppIf& aNode,
+ RAiSettingsItemArray& aSettings, const TDesC& aConfOwner )
+ {
+ // Find configuration nodes
+ RPointerArray< CXnNodeAppIf > nodes( aNode.ChildrenL() );
+ CleanupClosePushL( nodes );
+
+ // Collect settings
+ TInt count( nodes.Count() );
+
+ for( TInt j = 0; j < count; j++ )
+ {
+ CXnNodeAppIf* node( nodes[j] );
+
+ if( node->Type()->Type() == AiUiDef::xml::element::KConfiguration )
+ {
+ HBufC* name( PropertyValueL( *node, AiUiDef::xml::property::KName ) );
+ CleanupStack::PushL( name );
+
+ HBufC* value( PropertyValueL( *node, AiUiDef::xml::property::KValue ) );
+ CleanupStack::PushL( value );
+
+ MAiPluginSettings* settings = AiUtility::CreatePluginSettingsL();
+ CleanupDeletePushL( settings );
+
+ MAiPluginConfigurationItem& item( settings->AiPluginConfigurationItem() );
+
+ item.SetOwnerL( aConfOwner );
+ item.SetNameL( *name );
+ item.SetValueL( *value );
+
+ // Append settings into array.
+ aSettings.AppendL( settings );
+
+ CleanupStack::Pop( settings );
+ CleanupStack::PopAndDestroy( value );
+ CleanupStack::PopAndDestroy( name );
+ }
+ }
+
+ CleanupStack::PopAndDestroy( &nodes );
+ }
+
+// ----------------------------------------------------------------------------
+// CXmlUiController::ActivateUI()
+// ----------------------------------------------------------------------------
+//
+void CXmlUiController::ActivateUI()
+ {
+ }
+
+// ----------------------------------------------------------------------------
+// CXmlUiController::GetContentObserver()
+// ----------------------------------------------------------------------------
+//
+MAiContentObserver& CXmlUiController::GetContentObserver()
+ {
+ return *iObserver;
+ }
+
+// ----------------------------------------------------------------------------
+// CXmlUiController::SetEventHandler()
+// ----------------------------------------------------------------------------
+//
+void CXmlUiController::SetEventHandler( MAiFwEventHandler& aFwEventHandler )
+ {
+ iFwEventHandler = &aFwEventHandler;
+ }
+
+// ----------------------------------------------------------------------------
+// CXmlUiController::RemovePluginFromUI()
+// ----------------------------------------------------------------------------
+//
+void CXmlUiController::RemovePluginFromUI( MAiPropertyExtension& aPlugin )
+ {
+ CContentRenderer* contentRenderer =
+ static_cast< CContentRenderer* >( iObserver );
+
+ if ( contentRenderer )
+ {
+ contentRenderer->CleanPluginFromUi( aPlugin );
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CXmlUiController::FwEventHandler()
+// ----------------------------------------------------------------------------
+//
+MAiFwEventHandler* CXmlUiController::FwEventHandler() const
+ {
+ return iFwEventHandler;
+ }
+
+// ----------------------------------------------------------------------------
+// CXmlUiController::MainInterface()
+// ----------------------------------------------------------------------------
+//
+MAiMainUiController* CXmlUiController::MainInterface()
+ {
+ return this;
+ }
+
+// ----------------------------------------------------------------------------
+// CXmlUiController::SecondaryInterface()
+// ----------------------------------------------------------------------------
+//
+MAiSecondaryUiController* CXmlUiController::SecondaryInterface()
+ {
+ return NULL;
+ }
+
+// ----------------------------------------------------------------------------
+// CXmlUiController::RunApplicationL()
+// ----------------------------------------------------------------------------
+//
+void CXmlUiController::RunApplicationL()
+ {
+ iRunningAsMain = ETrue;
+
+ User::LeaveIfError(
+ EikStart::RunApplication( &CXmlUiController::NewApplication ) );
+ }
+
+// ----------------------------------------------------------------------------
+// CXmlUiController::CoeEnv()
+// ----------------------------------------------------------------------------
+//
+CCoeEnv& CXmlUiController::CoeEnv()
+ {
+ __ASSERT_ALWAYS( iAppUi, Panic(ECriticalPointerNull) );
+ return *iAppUi->CoeEnv();
+ }
+
+// ----------------------------------------------------------------------------
+// CXmlUiController::SetUiFrameworkObserver()
+// ----------------------------------------------------------------------------
+//
+void CXmlUiController::SetUiFrameworkObserver(
+ MAiUiFrameworkObserver& aObserver )
+ {
+ iUiFrameworkObserver = &aObserver;
+ }
+
+// ----------------------------------------------------------------------------
+// CXmlUiController::IsMenuOpen()
+// ----------------------------------------------------------------------------
+//
+TBool CXmlUiController::IsMenuOpen()
+ {
+ TBool menuOpen( EFalse );
+ TRAP_IGNORE( menuOpen = UiEngineL()->IsMenuDisplaying() );
+ return menuOpen;
+ }
+
+// ----------------------------------------------------------------------------
+// CXmlUiController::UiFrameworkObserver()
+// ----------------------------------------------------------------------------
+//
+MAiUiFrameworkObserver* CXmlUiController::UiFrameworkObserver() const
+ {
+ return iUiFrameworkObserver;
+ }
+
+// ----------------------------------------------------------------------------
+// CXmlUiController::HandleUiEvent()
+// ----------------------------------------------------------------------------
+//
+TBool CXmlUiController::HandleUiEvent( TAny* aEvent, const TDesC8& aParam )
+ {
+ CXnNodeAppIf* event( static_cast<CXnNodeAppIf*>( aEvent ) );
+
+ TBool retval( EFalse );
+
+ if( event )
+ {
+ TPtrC8 param1;
+ TPtrC8 param2;
+ const TDesC8& eventString(
+ aParam.Mid( AiUiDef::xml::event::KUiEventPrefix().Length() ) );
+
+ // Extract event name
+ TInt paramPos( eventString.Locate( KEventParameterSeparator ) );
+
+ const TDesC8& eventName( eventString.Left( Max( 0, paramPos ) ) );
+
+ if( eventName == AiUiDef::xml::event::KFocusGained )
+ {
+ // Resolve event parameters
+ ResolveEventParameters( eventString, param1, param2 );
+
+ TRAP_IGNORE( HandleFocusGainedL( param1, param2, *event ) );
+
+ retval = ETrue;
+ }
+ else if( eventName == AiUiDef::xml::event::KSetElementSizeToCPS )
+ {
+ // Resolve event parameters
+ ResolveEventParameters( eventString, param1, param2 );
+
+ TRAP_IGNORE( HandleSetElementSizeL( param1, *event ));
+
+ retval = ETrue;
+ }
+ }
+
+ return retval;
+ }
+
+// ----------------------------------------------------------------------------
+// CXmlUiController::HandleSetElementSizeL()
+// ----------------------------------------------------------------------------
+//
+void CXmlUiController::HandleSetElementSizeL( const TDesC8& aElementName,
+ CXnNodeAppIf& aOrigin )
+ {
+ __UHEAP_MARK;
+ // Resolve ui elements
+ CXnNodeAppIf* element(
+ UiEngineL()->FindNodeByIdL( aElementName, aOrigin.Namespace() ) );
+
+ LeaveIfNull( element, KErrNotFound );
+
+ TRect rect( element->Rect() );
+
+ HBufC* elementName( NULL );
+ elementName = AiUtility::CopyToBufferL( elementName, aElementName );
+ CleanupStack::PushL( elementName );
+
+ iCPSpublisher->PublishSizeL( *elementName, rect.Width(), rect.Height() );
+
+ CleanupStack::PopAndDestroy( elementName );
+
+ __UHEAP_MARKEND;
+ }
+
+// ----------------------------------------------------------------------------
+// CXmlUiController::HandleFocusGainedL()
+// ----------------------------------------------------------------------------
+//
+void CXmlUiController::HandleFocusGainedL( const TDesC8& aUiElement1,
+ const TDesC8& aUiElement2, CXnNodeAppIf& aOrigin )
+ {
+ // Resolve ui elements
+ CXnNodeAppIf* element1(
+ UiEngineL()->FindNodeByIdL( aUiElement1, aOrigin.Namespace() ) );
+
+ LeaveIfNull( element1, KErrNotFound );
+
+ CXnNodeAppIf* element2(
+ UiEngineL()->FindNodeByIdL( aUiElement2, aOrigin.Namespace() ) );
+
+ LeaveIfNull( element2, KErrNotFound );
+
+ // swap display properties between ui elements
+ CXnProperty* display1(
+ element1->GetPropertyL( XnPropertyNames::style::common::KDisplay ) );
+
+ LeaveIfNull( display1, KErrNotFound );
+
+ CXnProperty* display2(
+ element2->GetPropertyL( XnPropertyNames::style::common::KDisplay ) );
+
+ LeaveIfNull( display2, KErrNotFound );
+
+ display1 = display1->CloneL();
+ CleanupStack::PushL( display1 );
+
+ display2 = display2->CloneL();
+ CleanupStack::PushL( display2 );
+
+ element1->SetPropertyL( display2 );
+ CleanupStack::Pop( display2 );
+
+ element2->SetPropertyL( display1 );
+ CleanupStack::Pop( display1 );
+ }
+
+// ----------------------------------------------------------------------------
+// CXmlUiController::NewApplication()
+// ----------------------------------------------------------------------------
+//
+CApaApplication* CXmlUiController::NewApplication()
+ {
+ CXmlUiController* self = static_cast<CXmlUiController*>(Dll::Tls());
+ __ASSERT_ALWAYS( self, Panic(ECriticalPointerNull) );
+ return CApplication::New(*self);
+ }
+
+const TImplementationProxy KImplementationTable[] =
+ {
+ IMPLEMENTATION_PROXY_ENTRY(KImplementationUidXmlUiController, CXmlUiController::NewL)
+ };
+
+EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)
+ {
+ aTableCount = sizeof(KImplementationTable) / sizeof(TImplementationProxy);
+ return KImplementationTable;
+ }
+