/*

* Copyright (c) 2007-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 menu events

*

*/

#include "aixuikonmenueventhandler.h"

#include "aiconsts.h"

#include "aixmluiconstants.h"

#include "aixmluiutils.h"

#include "mxncomponentinterface.h"

#include "xnmenuadapter.h"

#include "xnappuiadapter.h"

#include "xntext.h"

#include "xnnodeappif.h"

#include "xndomnode.h"

#include "xndomlist.h"

#include "xntype.h"

#include <gulicon.h>

#include <aiutility.h>

#include <aistrparser.h>

#include "aifweventhandler.h"

#include "xnproperty.h"

#include "xnuiengineappif.h"

#include "xndompropertyvalue.h"

#include <aipspropertyobserver.h>

#include <avkondomainpskeys.h> 

#include <aknviewappui.h>		//CaknViewAppui

#include "xnplugindefs.h"

_LIT8( KMenubar, "menubar" );

_LIT8( KClass, "class" );

_LIT8( KId, "id" );

_LIT8( KEditWidget, "edit_widget" );

_LIT8( KRemoveItem, "removeitem" );

_LIT8( KWidget, "widget" );

_LIT8( KRemovable, "removable" );

_LIT ( KMenuItem, "menuitem");

using namespace AiXmlUiController;

// ---------------------------------------------------------------------------

// FindFromContentModelL

// ---------------------------------------------------------------------------

// 

static CXnNodeAppIf* FindFromContentModelL( CXnNodeAppIf* aNode )

    {

    if ( !aNode )

        {

        return NULL;

        }

    CXnProperty* node = aNode->GetPropertyL( KClass ); 

    if ( node && node->StringValue() == KContentSource )

        {

        return aNode;

        }

    // Recurse children        

    RPointerArray< CXnNodeAppIf > children( aNode->ChildrenL() );

    CleanupClosePushL( children );

    CXnNodeAppIf* retval( NULL );

    for ( TInt i = 0; i < children.Count(); i++ )

        {

        CXnNodeAppIf* node( FindFromContentModelL( children[i] ) );

        if ( node )

            {

            retval = node;

            break;

            }

        }

    CleanupStack::PopAndDestroy( &children );

    return retval;

    }

// ---------------------------------------------------------------------------

// FindFromConfigurationL

// ---------------------------------------------------------------------------

// 

static CXnNodeAppIf* FindFromConfigurationL( CXnNodeAppIf* aNode )

    {

    if ( !aNode )

        {

        return NULL;

        }

    // Is this node type of settingsconfiguration

    if ( aNode->Type()->Type() == KSettingsConfiguration )

        {

        return aNode;

        }

    // Recurse children        

    RPointerArray< CXnNodeAppIf > children( aNode->ChildrenL() );

    CleanupClosePushL( children );

    CXnNodeAppIf* retval( NULL );

    for ( TInt i = 0; i < children.Count(); i++ )

        {               

        CXnNodeAppIf* node( FindFromConfigurationL( children[i] ) );

        if ( node )

            {

            retval = node;

            break;

            }

        }

    CleanupStack::PopAndDestroy( &children );

    return retval;

    }

// ---------------------------------------------------------------------------

// DeletePluginNames

// ---------------------------------------------------------------------------

// 

static void DeletePluginNames( TAny* aObject )

    {

    reinterpret_cast<

        RPointerArray<HBufC16>*>( aObject )->ResetAndDestroy();

    }

CAIXuikonMenuEventHandler::CAIXuikonMenuEventHandler( TXnUiEngineAppIf& aUiEngine,

                                                      MAiFwEventHandler* aFwEventHandler,

                                                      CXnAppUiAdapter* aAppUi )

  : iCurrentCBA( EAIMenuOff ),

    iUiEngine( &aUiEngine ),

    iFwEventHandler( aFwEventHandler ),

    iAppUi( aAppUi )

    {

    }

void CAIXuikonMenuEventHandler::ConstructL()

    {

    iStrParser = AiUtility::CreateStrParserL();

    iKeylockObserver = AiUtility::CreatePSPropertyObserverL

        ( TCallBack( HandleKeylockEvent, this ),

            KPSUidAvkonDomain, KAknKeyguardStatus );  

    }

void CAIXuikonMenuEventHandler::SetObserverL( const TDesC8& aParam, CXnDomNode* aEvent )

    {

    if ( aEvent )

        {

        CXnNodeAppIf* node( iUiEngine->FindNodeByIdL( aParam, aEvent->Namespace() ) );

        if ( node && node->Type()->Type() == KMenubar )

            {

            XnMenuInterface::MXnMenuInterface* menuIf( NULL );

            XnComponentInterface::MakeInterfaceL( menuIf, *node );

            if ( menuIf )

                {

                menuIf->SetObserver( *this );

                }

            }

        }

    }

TInt CAIXuikonMenuEventHandler::HandleKeylockEvent( TAny* aSelf )

    {

    // Stop displaying menu when keylock is activated.

    CAIXuikonMenuEventHandler* self = 

        static_cast<CAIXuikonMenuEventHandler*>( aSelf );

    TInt err = KErrNone;

    TInt value = EKeyguardNotActive;

    if ( self )

        {

        TInt err = self->iKeylockObserver->Get( value );

        if ( err == KErrNone )

            {

			if ( value > EKeyguardNotActive )

				{

		        if ( self->iAppUi && self->iCurrentCBA == EAIMenuOn )

		        	{

		        	self->iAppUi->StopDisplayingMenuBar();

		        	TRAP_IGNORE( self->iUiEngine->RefreshMenuL() );

		        	}			

				}        				

            }

        }

    return err;

    }

CAIXuikonMenuEventHandler* CAIXuikonMenuEventHandler::NewL( TXnUiEngineAppIf& aUiEngine,

                                                            MAiFwEventHandler* aFwEventHandler,

                                                            CXnAppUiAdapter* aAppUi )

    {

    CAIXuikonMenuEventHandler* self = 

        new( ELeave ) CAIXuikonMenuEventHandler( aUiEngine, aFwEventHandler, aAppUi );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

CAIXuikonMenuEventHandler::~CAIXuikonMenuEventHandler()

    {

    Release ( iKeylockObserver );

    Release( iStrParser );

    delete iActivationEvent;

    delete iSettingsEvent;

    // Delete stored label id's

    delete iMenuModeLskLabel;

    delete iMenuModeRskLabel;

    delete iNormalModeLskLabel;

    delete iNormalModeRskLabel;  

    }

TBool CAIXuikonMenuEventHandler::HandleEventL( const TDesC8& aEventString8, CXnNodeAppIf* aOrigin, CXnDomNode* aEvent )

    {

    if ( aEventString8 == AiUiDef::xml::event::KScreenDeviceChange )

        {

        iUiEngine = iAppUi->UiEngineL();

        return ETrue;

        }

    else if ( aEventString8.Left(KAIDynamicMenuPrefixLen).Compare( KAIDynamicMenuPrefix ) != 0 )

        {

        // For optimization when dynamic menu prefix is not found from event string start

        // return immediate from here.

        return EFalse;

        }

    if ( (iCurrentCBA == EAIMenuOff && aEventString8.Find(KAIMenuEventIfMenuOff) >= 0 ) ||

        (iCurrentCBA == EAIMenuOn && aEventString8.Find(KAIMenuEventIfMenuOn) >= 0) )

        {

        TPtrC8 eventString;

        ParseParameterStringL(aEventString8, eventString);

        if ( !HandleEventL(eventString, aOrigin, aEvent ) )

            {

            // Default action from the event string

            HBufC16* eventString16 = NULL;

            eventString16 = iStrParser->CopyToBufferL( eventString16, eventString );

            CleanupStack::PushL( eventString16 );

            if ( iFwEventHandler && eventString16 )

                {

                iFwEventHandler->HandlePluginEvent( *eventString16 );

                }

            CleanupStack::PopAndDestroy( eventString16 );

            }

        return ETrue;

        }

    else if ( aEventString8 == KAIMenuEventInitPluginItems )

        {

        if ( !aEvent )

            {

            return ETrue;

            }

        CXnDomList& children( aEvent->ChildNodes() );

        TInt count( children.Length() );

        for ( TInt i = 0; i < count; i++ )

            {

            CXnDomNode* node = static_cast< CXnDomNode* >( children.Item( i ) );

            const TDesC8& type( node->Name() );

            if ( type == XnPropertyNames::action::KProperty )

                {

                const TDesC8& id( node->AttributeValue( 

                                    XnPropertyNames::action::KValue ) );

                if ( id != KNullDesC8 )

                    {

                    CXnNodeAppIf* nodeById( iUiEngine->FindNodeByIdL( id, aEvent->Namespace() ) );

                    if ( nodeById )

                        {                            

                        TBool showItem( DynInitItemL( *nodeById, aOrigin ) ); 

                        const TDesC8 *value( NULL );

                        if ( showItem )

                            {

                            value = &XnPropertyNames::style::common::display::KBlock;

                            }

                        else

                            {

                            value = &XnPropertyNames::style::common::display::KNone;

                            }            

                        CXnDomStringPool& sp( aEvent->StringPool() );

                        // create property

                        CXnProperty* prop = CXnProperty::NewL( XnPropertyNames::style::common::KDisplay, 

                                                               *value, 

                                                               CXnDomPropertyValue::EString, 

                                                               sp );

                        CleanupStack::PushL( prop );

                        // and set it

                        nodeById->SetPropertyL( prop );

                        CleanupStack::Pop( prop );

                        }

                    }

                }

            }

        return ETrue;

        }

    else if ( aEventString8 == KAIMenuEventInitEmptyItems  ||

              aEventString8 == KAIMenuEventInitWidgetItems )

        {

        if ( !aEvent )

            {

            return ETrue;

            }

        CXnProperty* pluginId( aOrigin->GetPropertyL( KPluginId ) );

        CXnProperty* pluginName( aOrigin->GetPropertyL( KPluginName ) );

        TBool showItem( EFalse );

        if ( aEventString8 == KAIMenuEventInitWidgetItems )

            {

            if( pluginId && pluginName && pluginName->StringValue() != KDummy8 )                        

                {

                // check if plugin can be removed

                CXnProperty* removable = GetWidgetPropertyL(*aOrigin, KRemovable);

                if ( removable && removable->StringValue() == XnPropertyNames::KFalse )

                    {

                    showItem = EFalse;

                    }

                else

                    {

                    showItem = ETrue;

                    }

                }                                

            }

        else

            {

            if ( pluginId && pluginName && pluginName->StringValue() == KDummy8 )

                {

                showItem = ETrue;

                }

            }

        CXnDomList& children( aEvent->ChildNodes() );

        TInt count( children.Length() );

        for ( TInt i = 0; i < count; i++ )

            {

            CXnDomNode* node = static_cast< CXnDomNode* >( children.Item( i ) );

            const TDesC8& type( node->Name() );

            if ( type == XnPropertyNames::action::KProperty )

                {

                const TDesC8& id( node->AttributeValue( 

                                    XnPropertyNames::action::KValue ) );

                if ( id != KNullDesC8 )

                    {

                    CXnNodeAppIf* nodeById( iUiEngine->FindNodeByIdL( id, aEvent->Namespace() ) );

                    if ( nodeById )

                        {

                        const TDesC8 *value( NULL );

                        if ( showItem )

                            {

                            value = &XnPropertyNames::style::common::display::KBlock;

                            }

                        else

                            {

                            value = &XnPropertyNames::style::common::display::KNone;

                            }

                        CXnDomStringPool& sp( aEvent->StringPool() );

                        // create property

                        CXnProperty* prop = CXnProperty::NewL( XnPropertyNames::style::common::KDisplay, 

                                                               *value, 

                                                               CXnDomPropertyValue::EString, 

                                                               sp );

                        CleanupStack::PushL( prop );

                        // and set it

                        nodeById->SetPropertyL( prop );

                        CleanupStack::Pop( prop );

                        }

                    }

                }

            }

        return ETrue;

        }

    else if ( aEventString8.Find( KAIMenuEventIfMenuOff ) >= 0 )

        {

        return ETrue;

        }

    else if ( aEventString8.Find( KAIMenuEventIfMenuOn ) >= 0 )

        {

        return ETrue;

        }

    else if ( aEventString8.Compare( KAIMenuEventGenerateSetActivationEvent ) == 0 )

        {

        // Generate set plugin event

        if ( iFwEventHandler && iActivationEvent )

            {

            iFwEventHandler->HandlePluginEvent( *iActivationEvent );

            }

        return ETrue;

        }

    else if ( aEventString8.Find( KAIMenuEventSetActivationEvent ) >= 0 )

        {

        // find event string

        TPtrC8 eventString;

        ParseParameterStringL( aEventString8, eventString );

        delete iActivationEvent;

        iActivationEvent = NULL;

        // store activation event (plugin event string)

        iActivationEvent = iStrParser->CopyToBufferL( iActivationEvent, eventString );

        return ETrue;

        }

    else if (aEventString8.Compare( KAIMenuEventGenerateOpenSettingsEvent ) == 0)

        {

        // Generate set plugin event

        if ( iFwEventHandler && iSettingsEvent )

            {

            iFwEventHandler->HandlePluginEvent( *iSettingsEvent );

            }

        return ETrue;

        }

    else if ( aEventString8.Find( KAIMenuEventSetOpenSettingsnEvent ) >= 0 )

        {

        // find event string

        TPtrC8 eventString;

        ParseParameterStringL( aEventString8, eventString );

        delete iSettingsEvent;

        iSettingsEvent = NULL;

        // store activation event (plugin event string)

        iSettingsEvent = iStrParser->CopyToBufferL( iSettingsEvent, eventString );

        return ETrue;

        }

    else if ( aEventString8.Find( KAIMenuEventShowMenuItem ) >= 0 )

        {

        if (iCurrentCBA == EAIMenuOn)

            {

            // find node by id

            TPtrC8 menuItem;

            ParseParameterStringL( aEventString8, menuItem );

            // set visibility property to visible

            ShowMenuItemL( menuItem, ETrue, aEvent );

            }

        return ETrue;

        }

    else if ( aEventString8.Find( KAIMenuEventHideMenuItem ) >= 0 )

        {

        if ( iCurrentCBA == EAIMenuOn )

            {

            // find node by id

            TPtrC8 menuItem;

            ParseParameterStringL( aEventString8, menuItem );

            // set visibility property to visible

            ShowMenuItemL( menuItem, EFalse, aEvent );

            }

        return ETrue;

        }

    else if ( aEventString8.Find( KAIMenuEventShowHideMenuItem ) >= 0 )

            {

            if ( iCurrentCBA == EAIMenuOn )

                {

                // find node by id

                TPtrC8 menuItem;

                ParseParameterStringL( aEventString8, menuItem );

                // set visibility property

                if ( IsMenuItemVisibleL( menuItem, aEvent ) )

                    {

                    ShowMenuItemL( menuItem, EFalse, aEvent );

                    }

                else

                    {

                    ShowMenuItemL( menuItem, ETrue, aEvent );

                    }

                }

            return ETrue;

            }

    else if ( aEventString8.Compare( KAIMenuEventMenuOn ) == 0 )

        {

        if ( iCurrentCBA != EAIMenuOn )

            {

            // also updates current state

            SetCBALabelsL( EAIMenuOn, aEvent );

            }

        return ETrue;

        }

    else if ( aEventString8.Compare( KAIMenuEventMenuOff ) == 0 )

        {

        if ( iCurrentCBA != EAIMenuOff )

            {

            // also updates current state

            SetCBALabelsL( EAIMenuOff, aEvent );

            }

        return ETrue;

        }

    else if ( ( aEventString8.Find( KAIMenuEventShowAll ) ) >= 0 )

        {

        if ( iCurrentCBA == EAIMenuOn )

            {

            // Show all menu items. Xuikon actually open the menu it self..