/*
* Copyright (c) 2007-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:  
*
*/


#include "hnmdmenuitem.h"
#include "hnglobals.h"
#include "hnconvutils.h"
#include "hnstringhandler.h"
#include "hnconditioninterface.h"
#include "hnmdeventmappingelement.h"
#include "hnmdevent.h"
#include "hnmenuitemmodel.h"
#include "hnconditionfactory.h"

// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
TBool CHnMdMenuItem::IsMenuItemElementName( const TDesC8& aNameToCompare )    
    {
    return !aNameToCompare.Compare( KMenuItemElementName8 )
        || !aNameToCompare.Compare( KMenuItemSpecificElementName8 )
        || !aNameToCompare.Compare( KMenuItemActionElementName8 );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CHnMdMenuItem::AppendChildItemL( CHnMdMenuItem* aMenuItem )
    {
    iChildren.AppendL( aMenuItem );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CHnMdMenuItem::EvaluateL( CHnMenuItemModel* aMenuModel,
        const CLiwGenericParamList& aQueriesResultsList, TInt aPos )
    {
    for ( TInt i( 0 ); i < iChildren.Count(); i++ )
      {
      CHnMdMenuItem* mdMenu = iChildren[ i ];
      if ( mdMenu->IsValidL( aQueriesResultsList, aPos ) )
          {
          CHnMenuItemModel* menu = CHnMenuItemModel::NewL( mdMenu->NameL() );
          mdMenu->EvaluateL( menu, aQueriesResultsList, aPos );
          aMenuModel->AppendChildMenuL( menu );
          }
      }
    aMenuModel->SetCommand( iEvent );
    aMenuModel->SetPosition( iPosition );
    aMenuModel->SetMenuItemType( iType );
    }

// ---------------------------------------------------------------------------
// ConstructL takes as an argument an item xml element. It iterates through 
// item elements in order to find menuitems.
// ---------------------------------------------------------------------------
//
void CHnMdMenuItem::CreatePropertiesL( TXmlEngElement aElement,
                                 THnMdCommonPointers* /* aCmnPtrs */ )
    {
    iType = CHnMenuItemModel::EItemApplication;
    if ( !aElement.Name().Compare( KMenuItemSpecificElementName8 ) )
    	{
    	iType = CHnMenuItemModel::EItemSpecific;
    	}
    else if ( !aElement.Name().Compare( KMenuItemActionElementName8 ) )
    	{
    	iType = CHnMenuItemModel::EItemAction;
    	}
    
    // name
    HBufC* name = HnConvUtils::Str8ToStrLC(
            aElement.AttributeValueL( KName8 ) );
    iName.Assign(name);
    CleanupStack::Pop( name );

    // position
    TPtrC8 pos = aElement.AttributeValueL( KPositionAttrName8 );
    TLex8 lexPosition ( pos );
    User::LeaveIfError( lexPosition.Val( iPosition ) );

    // event
    if( aElement.AttributeValueL( KEventAttrName8 ).Length() && 
                                            !aElement.HasChildNodes() )
        { // there might not be the event attribute - submenues
        TPtrC8 event = aElement.AttributeValueL( KEventAttrName8 );
        TLex8 lex( event );
        User::LeaveIfError( lex.Val( iEvent ) );
        }
    
    // condition
    if( aElement.AttributeValueL( KMenuConditionAttrName8 ).Length() )
        {
        iCondition = HnConditionFactory::NewL(  
          aElement.AttributeNodeL( KMenuConditionAttrName8 ) );
        }
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CHnMdMenuItem::CreateChildrenL( TXmlEngElement aElement,
                                        THnMdCommonPointers* aCmnPtrs )
    { 
    RXmlEngNodeList< TXmlEngElement > children;
    CleanupClosePushL( children );
    aElement.GetChildElements( children );
    TInt count = children.Count();

    for ( TInt i = 0; i < count; i++ )
        {
        TXmlEngElement child = children.Next();
        if ( IsMenuItemElementName( child.Name() ) )
            {
            AppendChildItemL( CHnMdMenuItem::NewL( child, aCmnPtrs ) );
            }
        }
    CleanupStack::PopAndDestroy( &children );
    }

// ---------------------------------------------------------------------------
// ConstructL takes as an argument an item xml element. It iterates through 
// item elements in order to find menuitems.
// ---------------------------------------------------------------------------
//
void CHnMdMenuItem::ConstructL( TXmlEngElement aElement,
                                THnMdCommonPointers* aCmnPtrs )
    {
    if ( IsMenuItemElementName( aElement.Name() ) )
        { // this is an ordinary menu item
        CreatePropertiesL( aElement, aCmnPtrs );
        CreateChildrenL( aElement, aCmnPtrs ); // in case there are subitems
        }
    else
        { // this is the root level
        CreateChildrenL( aElement, aCmnPtrs );
        }
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
CHnMdMenuItem* CHnMdMenuItem::NewL( TXmlEngElement aElement,
        THnMdCommonPointers* aCmnPtrs )
    {
    CHnMdMenuItem* self = CHnMdMenuItem::NewLC( aElement, aCmnPtrs );
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
CHnMdMenuItem* CHnMdMenuItem::NewLC( TXmlEngElement aElement, 
        THnMdCommonPointers* aCmnPtrs )
    {
    CHnMdMenuItem* self = new( ELeave ) CHnMdMenuItem;
    CleanupStack::PushL( self );
    self->ConstructL( aElement, aCmnPtrs );
    return self;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
CHnMdMenuItem::CHnMdMenuItem()
    {
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
CHnMdMenuItem::~CHnMdMenuItem()
    {
    iName.Close();
    iChildren.ResetAndDestroy();
    iNameValueCache.Close();
    delete iCondition;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
const TDesC& CHnMdMenuItem::NameL() 
    {
    iNameValueCache.Close();
    HnStringHandler::LocaliseL( iNameValueCache, iName, NULL /*common params*/);
    return iNameValueCache;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
TBool CHnMdMenuItem::IsValidL( const CLiwGenericParamList& aQueryResults, 
        TInt aPos )    
    {
    TBool ret( EFalse );
    if( !iCondition || iCondition->ResultL( aQueryResults, aPos ) )
        {
        ret = ETrue;
        }
    return ret;
    }