/*

* Copyright (c) 2009 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 FILES

#include <xcfwtree.h>

#include <xcfwengine.h>

#include <pathinfo.h>

#include <f32file.h>

#include <sysutil.h>

#include "menueng.h"

#include "menuengobjectfactoryproxy.h"

#include "menuengobject.h"

#include "menuengobserver.h"

#include "menuengoperation.h"

#include "menuengfilter.h"

#include "menuengvisitor.h"

#include "menuengitemlister.h"

#include "menuengdeletionchecker.h"

#include "menuengidmanagerinit.h"

#include "menuengidsetter.h"

#include "menuengidmanager.h"

#include "menuengidcollector.h"

#include "menuengflags.h"

#include "mcsmenuitem.h" // for flags

// CONSTANTS

LOCAL_D const TInt KDriveAndColon = 2; //drive letter and colon, e.g. "c:"

_LIT( KMenuTypeIdSeed, "menu:id_seed" );

_LIT( KMenuAttrIdSeed, "seed" );

_LIT( KMenuContentDirName, "content\\" );

_LIT( KMenuContentExtension, ".xml" );

_LIT( KMenuTempExtension, ".$$$" );

// ================= LOCAL FUNCTIONS =======================

/**

* Insert string into other string, checking vaailable space.

* Leaves with KErrOverflow if aSoure cannot be inserted to aTarget.

* @param aTarget Target descriptor.

* @param aPos Insertion point.

* @param aSource Source descriptor.

*/

LOCAL_C void InsertL( TDes& aTarget, TInt aPos, const TDesC& aSource )

    {

    if ( aTarget.MaxLength() < aTarget.Length() + aSource.Length() )

        {

        User::Leave( KErrOverflow );

        }

    aTarget.Insert( aPos, aSource );

    }

/**

* Append string to the end of other string, checking available space.

* Leaves with KErrOverflow if aSource cannot be appended to aTarget.

* @param aTarget Target descriptor.

* @param aSource Source descriptor.

*/

LOCAL_C void AppendL( TDes& aTarget, const TDesC& aSource )

    {

    if ( aTarget.MaxLength() < aTarget.Length() + aSource.Length() )

        {

        User::Leave( KErrOverflow );

        }

    aTarget.Append( aSource );

    }

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

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

// CMenuEng::Object

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

//

CMenuEngObject& CMenuEng::Object( MXCFWNode& aNode ) const

    {

    return (CMenuEngObject&)(*aNode.Data());

    }

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

// CMenuEng::~CMenuEng

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

//

EXPORT_C CMenuEng::~CMenuEng()

    {

    Cancel();

    CancelAllOperations();

    iOperations.Close();

    iNotifyQueue.Close();

    delete iEngine;

    delete iTree;

    delete iObjectFactory;

    delete iIdManager;

    iFs.Close();

    iName.Close();

    iTempFileName.Close();

    iRamFileName.Close();

    delete iActiveWait;

    }

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

// CMenuEng::NewL

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

//

EXPORT_C CMenuEng* CMenuEng::NewL

( const TDesC& aName, MMenuEngObserver& aObserver )

    {

    CMenuEng* eng = new (ELeave) CMenuEng( aObserver );

    CleanupStack::PushL( eng );

    eng->ConstructL( aName );

    CleanupStack::Pop( eng );

    return eng;

    }

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

// CMenuEng::CMenuEng

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

//

CMenuEng::CMenuEng( MMenuEngObserver& aObserver )

: CActive( CActive::EPriorityStandard ), iObserver( aObserver )

    {

    CActiveScheduler::Add( this );

    iLegacyFormat = EFalse;

    }

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

// CMenuEng::ConstructL

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

//

void CMenuEng::ConstructL( const TDesC& aName )

    {

    ValidateNameL( aName );

    iName.CreateL( aName );

    User::LeaveIfError( iFs.Connect() );

    // Keep temp file and the RAM file name as members -

    // we use these all the time.

    TFileName fname;

    GetFileNameL( fname, ETempFile );

    iTempFileName.CreateL( fname );

    GetFileNameL( fname, ERamFile );

    iRamFileName.CreateL( fname );

    iObjectFactory = CMenuEngObjectFactoryProxy::NewL( *this );

    iEngine = CXCFWEngine::NewL( this );

    iEngine->RegisterObjectFactoryL( iObjectFactory );

    SelfComplete( KErrNone ); 	// Start processing asynchronously.

    ActiveWaitForFileLoadL();	//we need to wait until parsing is complete

    }

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

// CMenuEng::QueueOperationL

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

//

EXPORT_C void CMenuEng::QueueOperationL( MMenuEngOperation& aOperation )

    {

    __ASSERT_DEBUG( KErrNotFound == iOperations.Find( &aOperation ), \

                    User::Invariant() );

    iOperations.AppendL( &aOperation );

    // If idle, kick back into life.

    if ( EReady == iState )

        {

        iState = EExecuteOp;

        SelfComplete( KErrNone );

        }

    }

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

// CMenuEng::DequeueOperation

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

//

EXPORT_C void CMenuEng::DequeueOperation( MMenuEngOperation& aOperation )

    {

    if ( iCurrentOperation == &aOperation )

        {

        iCurrentOperation = NULL;

        }

    TInt i = iOperations.Find( &aOperation );

    if ( KErrNotFound != i )

        {

        iOperations.Remove( i );

        }

    }

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

// CMenuEng::TraverseFolderL

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

//

EXPORT_C void CMenuEng::TraverseFolderL

( TInt aFolder, MMenuEngVisitor& aVisitor ) const

    {

    if ( !iTree )

        {

        User::Leave( KErrNotReady );

        }

    TraverseNodeL( FolderNodeL( aFolder ), aVisitor );

    }

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

// CMenuEng::NewObjectL

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

//

EXPORT_C CMenuEngObject* CMenuEng::NewObjectL( const TDesC& aType )

    {

    if ( !iIdManager )

        {

        User::Leave( KErrNotReady );

        }

    CMenuEngObject* object = CMenuEngObject::NewL( *this, aType );

    CleanupStack::PushL( object );

    TInt id;

    iIdManager->AllocL( id );

    object->SetId( id );

    CleanupStack::Pop( object );

    return object;

    }

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

// CMenuEng::RootFolderL

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

//

EXPORT_C void CMenuEng::RootFolderL( TInt& aId ) const

    {

    if ( !iTree )

        {

        User::Leave( KErrNotReady );

        }

    aId = iRoot;

    }

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

// CMenuEng::ParentFolderL

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

//

EXPORT_C void CMenuEng::ParentFolderL( TInt aId, TInt& aParentId ) const

    {

    if ( !iTree )

        {

        User::Leave( KErrNotReady );

        }

    TInt parentId = 0;

    if ( aId != iRoot )

        {

        // We may have nodes above the root, but do not allow access to those.

        // Say 0 to the root's parent.

        MXCFWNode* parentNode = NodeL( aId ).Parent();

        if ( parentNode )

            {

            parentId = Object( *parentNode ).Id();

            }

        }

    aParentId = parentId;

    }

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

// CMenuEng::GetItemL

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

//

EXPORT_C void CMenuEng::GetItemL( TInt aId, TMenuItem& aItem ) const

    {

    if ( !iTree )

        {

        User::Leave( KErrNotReady );

        }

    const CMenuEngObject& object = ObjectL( aId );

    aItem.SetId( object.Id() );

    aItem.SetFlags( object.Flags() );

    aItem.SetType( object.Type() );

    TInt parent;

    ParentFolderL( aId, parent );

    aItem.SetParent( parent );

    }

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

// CMenuEng::GetItemsL

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

//

EXPORT_C void CMenuEng::GetItemsL(

        RArray<TMenuItem>& aItemArray,

        TInt aFolder,

        const MMenuEngFilter* aFilter,

        TBool aRecursive ) const

    {

    if ( !iTree )

        {

        User::Leave( KErrNotReady );

        }

    TMenuEngItemLister lister

        ( *this, aItemArray, aFolder, aFilter, aRecursive );

    TraverseFolderL( aFolder, lister );

    }

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

// CMenuEng::ObjectL

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

//

EXPORT_C const CMenuEngObject& CMenuEng::ObjectL( TInt aId ) const

    {

    if ( !iTree )

        {

        User::Leave( KErrNotReady );

        }

    return Object( NodeL( aId ) );

    }

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

// CMenuEng::GetLegacyFormat

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

//

EXPORT_C TBool CMenuEng::GetOnceLegacyFormat()

    {

    TBool format = iLegacyFormat;

    iLegacyFormat = EFalse;

    return format;

    }

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

// CMenuEng::RemoveL

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

//

EXPORT_C void CMenuEng::RemoveL( TInt aId )

    {

	if ( SysUtil::DiskSpaceBelowCriticalLevelL( &iFs, 0, EDriveC) )

		{

		User::Leave( KErrDiskFull );

		}

    if ( iState != EExecuteOp )

        {

        User::Leave( KErrLocked );

        }

    // Check if aId exists.

    MXCFWNode& node = NodeL( aId );

    // Can't delete the root.

    if ( aId == iRoot )

        {

        User::Leave( KErrAccessDenied );

        }

    // Can't delete read-only items, or folders containing any read-only items.

    TMenuEngDeletionChecker checker;

    TraverseNodeL( node, checker );

    // Get the IDs of items to be deleted.

    RArray<TInt> deletedIds;

    CleanupClosePushL( deletedIds );

    TMenuEngIdCollector idCollector( deletedIds );

    TraverseNodeL( node, idCollector );

    // Add notification event.

    MXCFWNode* parent = node.Parent();

    __ASSERT_DEBUG( parent, User::Invariant() );

    AppendNotifyL( Object( *parent ).Id(),

                   RMenuNotifier::EItemsAddedRemoved );

    // Delete node.

    iTree->RemoveNodeL( &node );

    iChanged = ETrue;

    // Deletion successful, remove the IDs.

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

        {

        iIdManager->Remove( deletedIds[i] );

        }

    CleanupStack::PopAndDestroy( &deletedIds );

    }

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

// CMenuEng::MoveToFolderL

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

//

EXPORT_C void CMenuEng::MoveToFolderL

( RArray<TInt>& aItems, TInt aFolder, TInt aMoveBefore )

    {

	if ( SysUtil::DiskSpaceBelowCriticalLevelL( &iFs, 0, EDriveC) )

		{

		User::Leave( KErrDiskFull );

		}

    if ( iState != EExecuteOp )

        {

        User::Leave( KErrLocked );

        }

    TInt i;

    TInt id;

    MXCFWNode* fromFolder = NULL;

    // Check that toFolder exists.

    MXCFWNode& toFolder = FolderNodeL( aFolder );

    CMenuEngObject& toFolderObj = Object( toFolder );

    // Check that we can move items into target toFolder.

    if ( toFolderObj.Flags() & TMenuItem::ELockMoveInto )

        {

        User::Leave( KErrAccessDenied );

        }

    // Check that all items exist and they are not locked against moving.

    // Also check that and they are in the same toFolder.

    if ( aItems.Count() )

        {

        fromFolder = NodeL( aItems[0] ).Parent();

        for ( i = 0; i< aItems.Count(); i++ )

            {

            id = aItems[i];

            if ( id == iRoot )

                {

                User::Leave( KErrAccessDenied ); // Can't move the root.

                }

            MXCFWNode& node = NodeL( id );

            if ( Object( node ).Flags() & TMenuItem::ELockItem )

                {

                User::Leave( KErrAccessDenied ); // lock_item

                }

            if ( node.Parent() != fromFolder )

                {

                User::Leave( KErrArgument ); // Items from different folders.

                }

            }

        // Add notification events. Presume that there will be no recursion.

        // If there is recursion, then we make an unnecessary notify, that is

        // better than missing one.

        __ASSERT_DEBUG( fromFolder, User::Invariant() );

        AppendNotifyL( Object( *fromFolder ).Id(),

                       RMenuNotifier::EItemsAddedRemoved );

        AppendNotifyL( toFolderObj.Id(),

                       RMenuNotifier::EItemsAddedRemoved );

        // Do move the items.

        // Recursion check is done by the XML tree (->KErrArgument).

        MXCFWNode* moveBefore = Child( toFolder, aMoveBefore );

        for ( i = 0; i < aItems.Count(); i++ )

            {

            iTree->MoveNodeL( &NodeL( aItems[i] ), &toFolder, moveBefore );

            }

        iChanged = ETrue;

        }

    }

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

// CMenuEng::ReorderL

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

//

EXPORT_C void CMenuEng::ReorderL( TInt aId, TInt aMoveBefore )

    {

	if ( SysUtil::DiskSpaceBelowCriticalLevelL( &iFs, 0, EDriveC) )

		{

		User::Leave( KErrDiskFull );

		}

    if ( iState != EExecuteOp )

        {

        User::Leave( KErrLocked );

        }

    // Can't reorder the root.

    if ( aId == iRoot )

        {

        User::Leave( KErrArgument );

        }

    // Check if aId exists.

    MXCFWNode& node = NodeL( aId );

    // Check if item can be reordered.

    if ( Object( node ).Flags() & TMenuItem::ELockItem )

        {

        User::Leave( KErrAccessDenied ); // lock_item

        }

    MXCFWNode* parent = node.Parent();

    __ASSERT_DEBUG( parent, User::Invariant() );

    if ( parent )

        {

        // Add notification event.

        AppendNotifyL( Object( *parent ).Id(),

                       RMenuNotifier::EItemsReordered );

        // Move it.

        MXCFWNode* moveBefore = Child( *parent, aMoveBefore );

        iTree->MoveNodeL( &node, parent, moveBefore );

        iChanged = ETrue;

        }

    }

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

// CMenuEng::AddL

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

//

EXPORT_C void CMenuEng::AddL

( CMenuEngObject& aObject, TInt aFolder, TInt aInsertBefore )

    {

	if ( SysUtil::DiskSpaceBelowCriticalLevelL( &iFs, 0, EDriveC) )

		{

		User::Leave( KErrDiskFull );

		}

    if ( &aObject.Engine() != this )

        {

        // ID integrity requires that objects are bound to engines.

        User::Leave( KErrArgument );

        }

    if ( iState != EExecuteOp )

        {

        User::Leave( KErrLocked );

        }

    if ( KMenuTypeData() == aObject.Type() )

        {

        // Internal type, disallow.

        User::Leave( KErrArgument );

        }

    // Check if aFolder exists.

    MXCFWNode& folder = FolderNodeL( aFolder );

    // Check if folder is locked.

    if ( Object( folder ).Flags() & TMenuItem::ELockMoveInto )

        {

        User::Leave( KErrAccessDenied ); // lock_moveinto

        }

    // Add notification event.

    AppendNotifyL( aFolder, RMenuNotifier::EItemsAddedRemoved );

    // Add the node.

    MXCFWNode* insertBefore = Child( folder, aInsertBefore );

    if ( insertBefore )

        {

        iTree->AddNodeL( &aObject, &folder, insertBefore );

        // No leaving after this point - ownership of aObject taken by the

        // tree. (Well, almost -- CXCFWTree is buggy, but hopefully it will

        // be fixed.)

        }

    else

        {

        // CXCFWTree API design flaw:

        // AddNodeL( &aObject, &folder, NULL ) leaves with KErrArgument!

        iTree->AddNodeL( &aObject, &folder );