/*

* Copyright (c) 2006 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:  Implementation of the CVCommandRunnable class

*

*/

#include <vcommandapi.h>

#include "rubydebug.h"

/** 

* Constructs the non-modifiable CVCommandArray

* @param aSource Commands to store. CVCommandArray makes

*        copies of them

*/

EXPORT_C CVCommandArray* CVCommandArray::NewL( const RVCommandArray& aSource )

	{

	RUBY_DEBUG_BLOCK( "CVCommandArray::NewL" );

	CVCommandArray* self = new (ELeave) CVCommandArray;

	CleanupStack::PushL( self );

	self->ConstructL( aSource );

	CleanupStack::Pop( self );

	return self;

	}

void CVCommandArray::ConstructL( const RVCommandArray& aSource )

	{

	RUBY_DEBUG_BLOCKL( "CVCommandArray::ConstructL" );

	iCommands.ResetAndDestroy();

	for( TInt j = 0; j < aSource.Count(); j++ ) 

		{

		CVCommand* addition = CVCommand::NewL( *aSource[j] );

		CleanupStack::PushL( addition );

		iCommands.AppendL( addition );

		CleanupStack::Pop( addition );

		}

	}	

/**

* Destructor

*/

EXPORT_C CVCommandArray::~CVCommandArray()

	{

	RUBY_DEBUG0( "CVCommandArray::~CVCommandArray start" );

	iCommands.ResetAndDestroy();

	RUBY_DEBUG0( "CVCommandArray::~CVCommandArray end" );

	}

/**

* Returns the reference to the command stored in this

* CVCommandArray

* @param aIndex Zero-based index of the command. If aIndex is out of

*               bounds, this method will panic with USER 130

* @return Unmodifiable reference to CVCommand

*/

EXPORT_C const CVCommand& CVCommandArray::At( TInt aIndex ) const

	{

	return *iCommands[ aIndex ];

	}

/**

* Equivalent to the operator At

* @see At()

*/

EXPORT_C const CVCommand& CVCommandArray::operator[]( TInt aIndex ) const

	{

	return At( aIndex );

	}

/** 

* Returns the number of commands

*/

EXPORT_C TInt CVCommandArray::Count() const

	{

	return iCommands.Count();

	}

/**

* For the compatibility with routines, requiring RVCommandArray

* @return Unmodifiable array of pointers to VCommands

*/

EXPORT_C const RVCommandArray& CVCommandArray::PointerArray() const

    {

    return iCommands;

    }

/**

 * Figures out which commands have to untrained (removed from VCommandHandler)

 * if this command set is merged with aUpdates.

 * Merging is performed on the basis of comapring the commands' Runnable component

 * If runnables are equal, the commands are considered being equal.

 * It is useful e.g. when figuring out what to (un)train after the language change

 * 

 * @param aUpdates Set of commands to merge in. 

 * @return Set of commands to be removed from the system if the merging takes place

 */

EXPORT_C CVCommandArray* CVCommandArray::ProduceUntrainSetByRunnablesLC( 

                            const RVCommandArray& aUpdates ) const

    {

    RVCommandArray deduction;

    CleanupClosePushL( deduction );

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

        {

        for( TInt j = 0; j < aUpdates.Count(); j++ )

            {

            if( ( At(i).Runnable() == aUpdates[j]->Runnable() ) &&

                !( At(i).EqualNonUserChangeableData( *aUpdates[j] ) ) 

               )

                { 

                deduction.AppendL( &At(i) );

                break;

                }

            }

        }

    CVCommandArray* result = CVCommandArray::NewL( deduction );

    CleanupStack::PopAndDestroy( &deduction );

    CleanupStack::PushL( result );

    return result;

    }

/**

 * Figures out which commands have to trained (removed added to the system)

 * if this command set is merged with aUpdates.

 * Merging is performed on the basis of comapring the commands' Runnable component

 * If runnables are equal, the commands are considered being equal.

 * It is useful e.g. when figuring out what to (un)train after the language change

 * 

 * @param aUpdates Set of commands to merge in. 

 * @return Set of commands to be added to the system if the merging takes place

 * @see ProduceUntrainSetByRunnables

 */

EXPORT_C CVCommandArray* CVCommandArray::ProduceTrainSetByRunnablesLC( 

                            const RVCommandArray& aUpdates ) const

    {

    RVCommandArray addition;

    CleanupClosePushL( addition );

    for( TInt j = 0; j < aUpdates.Count(); j++ )

        {

        TBool injectedMatchesSomeTarget = EFalse;

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

            {

            if( At(i).EqualNonUserChangeableData( *aUpdates[j] ) )

                { 

                injectedMatchesSomeTarget = ETrue;

                break;

                }

            else if( At(i).Runnable() == aUpdates[j]->Runnable() &&

                     At(i).CommandUi().UserText() != KNullDesC )

                {

                CVCCommandUi* updatedCommandUi( NULL );

                updatedCommandUi = CVCCommandUi::NewL( aUpdates[j]->CommandUi().WrittenText(), 

                                                       aUpdates[j]->CommandUi().FolderInfo(),

                                                       aUpdates[j]->CommandUi().Modifiable(),

                                                       aUpdates[j]->CommandUi().Tooltip(), 

                                                       aUpdates[j]->CommandUi().IconUid(),

                                                       At(i).CommandUi().UserText(),

                                                       aUpdates[j]->CommandUi().ConfirmationNeeded() );

                CleanupStack::PushL( updatedCommandUi );

                CVCommand* updatedCommand( NULL );

                updatedCommand = CVCommand::NewL( aUpdates[j]->SpokenText(),

                                                  aUpdates[j]->Runnable(),

                                                  *updatedCommandUi );

                CleanupStack::PushL( updatedCommand );

                addition.AppendL( updatedCommand );

                CleanupStack::Pop( updatedCommand );

                CleanupStack::PopAndDestroy( updatedCommandUi );

                injectedMatchesSomeTarget = ETrue;

                break;

                }

            }  // for i

        if( !injectedMatchesSomeTarget )

            {

            addition.AppendL( aUpdates[j] );

            }  // if

        }  // for j

    CVCommandArray* result = CVCommandArray::NewL( addition );

    CleanupStack::PopAndDestroy( &addition );

    CleanupStack::PushL( result );

    return result;

    }

//End of file