/*

* Copyright (c) 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 <e32cmn.h>

#include <liwcommon.h>

#include <liwgenericparam.h>

#include "mcsgetlistcreatorinterface.h"

#include "menusrveng.h"

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

// CMcsGetListCreatorInterface::~CMcsGetListCreatorInterface

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

//

CMcsGetListCreatorInterface::~CMcsGetListCreatorInterface()

    {

    }

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

// CMcsGetListCreatorInterface::CMcsGetListCreatorInterface

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

//

CMcsGetListCreatorInterface::CMcsGetListCreatorInterface( CMenuSrvEng& aEng ):

	iEng( aEng )

    {

    }

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

// CMcsGetListCreatorInterface::ConstructL

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

//

void CMcsGetListCreatorInterface::ConstructL()

    {

    }

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

// CMcsGetListCreatorInterface::BuildMapL

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

//

void CMcsGetListCreatorInterface::BuildMapL(

		const TMenuItem& aMenuItem, CDesC16Array* aRequiredAttributes,

		CDesC16Array* aIgnoredAttributes, CLiwDefaultMap* aMap )

	{

	SetItemIdL( aMenuItem.Id() );

	AddFundamentalAttributesL( aMenuItem, aMap );

	if( aRequiredAttributes->MdcaCount() &&

			aIgnoredAttributes->MdcaCount() == KErrNone )

	    {

	    AddRequiredAttributesL( aMenuItem, aRequiredAttributes, aMap );

	    }

	else if( aIgnoredAttributes->MdcaCount() &&

			aRequiredAttributes->MdcaCount() == KErrNone )

	    {

	    AddAttributesWithoutIgnoredL( aMenuItem, aIgnoredAttributes, aMap );

	    }

	else if( aRequiredAttributes->MdcaCount() )

	    {

	    AddRequiredAttributesWithoutIgnoredL( aMenuItem, aRequiredAttributes,

	    		aIgnoredAttributes, aMap );

	    }

	else

	    {

	    AddAllAttributesL( aMenuItem, aMap );

	    }

	}

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

// CMcsGetListCreatorInterface::AddFundamentalAttributesL

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

//

void CMcsGetListCreatorInterface::AddFundamentalAttributesL(

		const TMenuItem& aMenuItem, CLiwDefaultMap* aMap )

	{

    aMap->InsertL( KMenuAttrId8, TLiwVariant( (TInt32)aMenuItem.Id() ) );

    aMap->InsertL( KType, TLiwVariant( aMenuItem.Type() ) );

    aMap->InsertL( KMenuParentId, TLiwVariant( (TInt32)aMenuItem.Parent() ) );

    // Flags

    TInt flag = aMenuItem.Flags();

    TInt flagvalue = ( flag & TMenuItem::ELockDelete )? 1 : 0;

    aMap->InsertL( KDeleteLocked, TLiwVariant( (TBool)flagvalue) );

    flagvalue = ( flag & TMenuItem::ELockName )? 1 : 0;

    aMap->InsertL( KNameLocked, TLiwVariant( (TBool)flagvalue) );

    flagvalue = ( flag & TMenuItem::ELockIcon )? 1 : 0;

    aMap->InsertL( KIconLocked, TLiwVariant( (TBool)flagvalue) );

    flagvalue = ( flag & TMenuItem::ELockMoveInto )? 1 : 0;

    aMap->InsertL( KAddingLocked, TLiwVariant( (TBool)flagvalue) );

    flagvalue = ( flag & TMenuItem::ELockItem )? 1 : 0;

    aMap->InsertL( KMoveLocked, TLiwVariant( (TBool)flagvalue) );

    flagvalue = ( flag & TMenuItem::EHidden )? 1 : 0;

    aMap->InsertL( KHidden, TLiwVariant( (TBool)flagvalue) );

    flagvalue = ( flag & TMenuItem::EMissing )? 1 : 0;

    aMap->InsertL( KMissing, TLiwVariant( (TBool)flagvalue) );

	}

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

// CMcsGetListCreatorInterface::AddRequiredAttributesL

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

//

void CMcsGetListCreatorInterface::AddRequiredAttributesL( const TMenuItem& aMenuItem,

		CDesC16Array* aRequiredAttributes, CLiwDefaultMap* aMap )

	{

	TBool exists = EFalse;

	TBuf<KMenuMaxAttrNameLen> running;

	running.Copy( KRunning );

	TBuf<KMenuMaxAttrNameLen> bitmap;

	bitmap.Copy( KBitmapBuffer );

	TBuf<KMenuMaxAttrNameLen> mask;

	mask.Copy( KMaskBuffer );

	TBool findBitmap( EFalse );

	TBool findMask( EFalse );

	RBuf attrvalue;

	attrvalue.CreateL( KMenuMaxAttrValueLen );

	CleanupClosePushL( attrvalue );

	for( TInt i= 0; i < aRequiredAttributes->MdcaCount(); i++ )

	    {

	    if( aRequiredAttributes->MdcaPoint(i).Compare( running ) == KErrNone )

	        {

	        if ( aMenuItem.Type() == KMenuTypeApp() ||

	        		aMenuItem.Type() == KMenuTypeFolder() )

	            {

	            iEng.GetAttributeL( iId, KRunningStatus, exists, attrvalue );

	            aMap->InsertL( KRunning, TLiwVariant( exists ) );

	            }

	        }

	    else if( aRequiredAttributes->MdcaPoint(i).Compare( bitmap ) == KErrNone )

	        {

	        findBitmap = ETrue;

	        }

	    else if( aRequiredAttributes->MdcaPoint(i).Compare( mask ) == KErrNone  )

	        {

	        findMask = ETrue;

	        }

	    else

	        {

            iEng.GetAttributeL(

                    iId, aRequiredAttributes->MdcaPoint(i), exists, attrvalue );

	        if( exists )

	            {

	            TBuf8<KMenuMaxAttrNameLen> attrname;

	            attrname.Copy( aRequiredAttributes->MdcaPoint(i) );

	            aMap->InsertL( attrname, TLiwVariant( attrvalue ) );

	            }

	        }

	    }

	if( findBitmap && findMask )

	    {

	    CLiwDefaultMap* iconAttrMap = CLiwDefaultMap::NewLC();

	    FillIconAttributesMapL( aMenuItem, iconAttrMap );

		aMap->InsertL( KIconAttributes, TLiwVariant( iconAttrMap ) );

    	CleanupStack::PopAndDestroy( iconAttrMap );

	   	}

	CleanupStack::PopAndDestroy( &attrvalue );

	}

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

// CMcsGetListCreatorInterface::AddAttributesWithoutIgnoredL

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

//

void CMcsGetListCreatorInterface::AddAttributesWithoutIgnoredL(	const TMenuItem& aMenuItem,

		CDesC16Array* aIgnoredAttributes, CLiwDefaultMap* aMap )

	{

    TBool exists = EFalse;

    TInt pos( KErrNotFound );

	RBuf attrvalue;

	attrvalue.CreateL( KMenuMaxAttrValueLen );

	CleanupClosePushL( attrvalue );

    if ( aMenuItem.Type() == KMenuTypeApp()

    		|| aMenuItem.Type() == KMenuTypeFolder() )

        {

        TBuf<KMenuMaxAttrNameLen> running;

        running.Copy( KRunning );

        if( aIgnoredAttributes->Find( running, pos ) != KErrNone )

            {

            iEng.GetAttributeL( iId, KRunningStatus, exists, attrvalue );

            aMap->InsertL( KRunning, TLiwVariant( exists ) );

            }

        }

    RArray<TPtrC> attrNameList;

    CleanupClosePushL(attrNameList);

    iEng.GetAttributeListL( aMenuItem.Id(), attrNameList );

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

        {

        if( aIgnoredAttributes->Find( attrNameList[i], pos ) != KErrNone )

            {

            iEng.GetAttributeL( iId, attrNameList[i], exists, attrvalue );

            if( exists )

                {

                TBuf8<KMenuMaxAttrNameLen> attrname;

                attrname.Copy( attrNameList[i] );

                aMap->InsertL( attrname, TLiwVariant( attrvalue ) );

                }

            }

        }

    TBuf<KMenuMaxAttrNameLen> bitmap;

    bitmap.Copy( KBitmapBuffer );

    TBuf<KMenuMaxAttrNameLen> mask;

    mask.Copy( KMaskBuffer );

    if( aIgnoredAttributes->Find( bitmap, pos ) != KErrNone

        && aIgnoredAttributes->Find( mask, pos ) != KErrNone )

        {

        CLiwDefaultMap* iconAttrMap = CLiwDefaultMap::NewLC();

    	FillIconAttributesMapL( aMenuItem, iconAttrMap );

    	aMap->InsertL( KIconAttributes, TLiwVariant( iconAttrMap ) );

    	CleanupStack::PopAndDestroy( iconAttrMap );

    	}

    CleanupStack::PopAndDestroy(&attrNameList);

	CleanupStack::PopAndDestroy( &attrvalue );

	}

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

// CMcsGetListCreatorInterface::AddRequiredAttributesWithoutIgnoredL

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

//

void CMcsGetListCreatorInterface::AddRequiredAttributesWithoutIgnoredL(

		const TMenuItem& aMenuItem, CDesC16Array* aRequiredAttributes,

		CDesC16Array* aIgnoredAttributes, CLiwDefaultMap* aMap )

	{

    TInt pos( KErrNotFound );

    TBool exists = EFalse;

    TBuf<KMenuMaxAttrNameLen> running;

    running.Copy( KRunning );

    TBuf<KMenuMaxAttrNameLen> bitmap;

    bitmap.Copy( KBitmapBuffer );

    TBuf<KMenuMaxAttrNameLen> mask;

    mask.Copy( KMaskBuffer );

    TBool findBitmap( EFalse );

    TBool findMask( EFalse );

	RBuf attrvalue;

	attrvalue.CreateL( KMenuMaxAttrValueLen );

	CleanupClosePushL( attrvalue );

    for( TInt i= 0; i < aRequiredAttributes->MdcaCount(); i++ )

        {

        if( aRequiredAttributes->MdcaPoint(i).Compare( running ) == KErrNone

            && aIgnoredAttributes->Find( running, pos ) != KErrNone )

            {

            if ( aMenuItem.Type() == KMenuTypeApp() || aMenuItem.Type() == KMenuTypeFolder() )

                {

                iEng.GetAttributeL( iId, KRunningStatus, exists, attrvalue );

                aMap->InsertL( KRunning, TLiwVariant( exists ) );

                }

            }

        else if( aRequiredAttributes->MdcaPoint(i).Compare( bitmap ) == KErrNone

                && aIgnoredAttributes->Find( bitmap, pos ) != KErrNone )

            {

            findBitmap = ETrue;

            }

        else if( aRequiredAttributes->MdcaPoint(i).Compare( mask ) == KErrNone

                && aIgnoredAttributes->Find( mask, pos ) != KErrNone )

            {

            findMask = ETrue;

            }

        else if( aIgnoredAttributes->Find( aRequiredAttributes->MdcaPoint(i), pos ) != KErrNone )

            {

            iEng.GetAttributeL(

                    iId, aRequiredAttributes->MdcaPoint(i), exists, attrvalue );

            if( exists )

                {

                TBuf8<KMenuMaxAttrNameLen> attrname;

                attrname.Copy( aRequiredAttributes->MdcaPoint(i) );

                aMap->InsertL( attrname, TLiwVariant( attrvalue ) );

                }

            }

        }

    if( findBitmap && findMask )

        {

        CLiwDefaultMap* iconAttrMap = CLiwDefaultMap::NewLC();

       	FillIconAttributesMapL( aMenuItem, iconAttrMap );

       	aMap->InsertL( KIconAttributes, TLiwVariant( iconAttrMap ) );

       	CleanupStack::PopAndDestroy( iconAttrMap );

        }

	CleanupStack::PopAndDestroy( &attrvalue );

	}

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

// CMcsGetListCreatorInterface::AddAllAttributesL

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

//

void CMcsGetListCreatorInterface::AddAllAttributesL(

		const TMenuItem& aMenuItem, CLiwDefaultMap* aMap )

	{

	TBool exists = EFalse;

    RBuf attrvalue;

	attrvalue.CreateL( KMenuMaxAttrValueLen );

	CleanupClosePushL( attrvalue );

	if ( aMenuItem.Type() == KMenuTypeApp() ||

			aMenuItem.Type() == KMenuTypeFolder() )

	    {

        iEng.GetAttributeL( iId, KRunningStatus, exists, attrvalue );

        aMap->InsertL( KRunning, TLiwVariant( exists ) );

	    }

	RArray<TPtrC> attrNameList;

	CleanupClosePushL(attrNameList);

    iEng.GetAttributeListL( aMenuItem.Id(), attrNameList );

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

	    {

	    TBuf8<KMenuMaxAttrNameLen> attrname;

	    attrname.Copy( attrNameList[i] );

        iEng.GetAttributeL( iId, attrNameList[i], exists, attrvalue );

	    if(exists)

	        {

	        attrname.Copy(attrNameList[i]);

	        aMap->InsertL( attrname, TLiwVariant( attrvalue ) );

	        }

	    }

    CLiwDefaultMap* iconAttrMap = CLiwDefaultMap::NewLC();

   	FillIconAttributesMapL( aMenuItem, iconAttrMap );

   	aMap->InsertL( KIconAttributes, TLiwVariant( iconAttrMap ) );

   	CleanupStack::PopAndDestroy( iconAttrMap );

	CleanupStack::PopAndDestroy(&attrNameList);

	CleanupStack::PopAndDestroy( &attrvalue );

	}

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

// CMcsGetListCreatorInterface::FillIconAttributesMapL

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

//

void CMcsGetListCreatorInterface::FillIconAttributesMapL(

		const TMenuItem& aMenuItem, CLiwDefaultMap* aMap )

	{

    if ( aMenuItem.Type() == KMenuTypeApp())

    	{

    	AppendAttrL( KMenuAttrUid, aMap );

    	AppendAttrL( KMenuAttrNative, aMap );

    	}

    else if ( aMenuItem.Type() == KMenuTypeFolder() )

    	{

    	AppendAttrL( KChildrenCount, aMap );

    	}

	AppendAttrL( KMenuAttrIconSkinMajorId, aMap );

	AppendAttrL( KMenuAttrIconSkinMinorId, aMap );

	AppendAttrL( KMenuAttrIconFile, aMap );

	AppendAttrL( KMenuAttrIconId, aMap );

	AppendAttrL( KMenuAttrMaskId, aMap );

	}

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

// CMcsGetListCreatorInterface::AppendAttrL

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

//

void CMcsGetListCreatorInterface::AppendAttrL(

        const TDesC& aAttrName, CLiwDefaultMap* aMap )

	{

	TBool exists;

	TBuf8<KMenuMaxAttrNameLen> attrName;

	RBuf attrvalue;

    attrvalue.CreateL( KMenuMaxAttrValueLen );

	CleanupClosePushL( attrvalue );

    iEng.GetAttributeL( iId, aAttrName, exists, attrvalue );

	if ( exists )

		{

		attrName.Copy( aAttrName );

		aMap->InsertL(attrName, TLiwVariant( attrvalue ) );

		}

	CleanupStack::PopAndDestroy( &attrvalue );

	}

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

// CMcsGetListCreatorInterface::SetGetterStrategyL

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

//

void CMcsGetListCreatorInterface::SetItemIdL( TInt aId )

	{

	iId = aId;

	}

//  End of File