/*
* 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 <s32strm.h>
#include "menusrvoperation.h"
#include "menuitemattr.h"
#include "menuutil.h"
#include "menueng.h"
#include "menuengobject.h"

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

// ---------------------------------------------------------
// CMenuSrvOperation::CMenuSrvOperation()
// ---------------------------------------------------------
//
CMenuSrvOperation::CMenuSrvOperation( CMenuEng& aEng )
: iEng( aEng )
    {
    }

// ---------------------------------------------------------
// CMenuSrvOperation::StartL()
// ---------------------------------------------------------
//
void CMenuSrvOperation::StartL( const RMessage2& aMessage )
    {
    PanicIfPendingL( aMessage );
    iEng.QueueOperationL( *this );
    SetPending( aMessage ); // No leaving after this point!
    }

// ---------------------------------------------------------
// CMenuSrvOperation::Cancel()
// ---------------------------------------------------------
//
void CMenuSrvOperation::Cancel()
    {
    iEng.DequeueOperation( *this );
    Complete( KErrCancel );
    }

// ---------------------------------------------------------
// CMenuSrvOperation::CompletedMenuEngOperation()
// ---------------------------------------------------------
//
void CMenuSrvOperation::CompletedMenuEngOperation( TInt aErr )
    {
    iEng.DequeueOperation( *this );
    Complete( aErr );
    }

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

// ---------------------------------------------------------
// CMenuSrvRemoveOperation::CMenuSrvRemoveOperation
// ---------------------------------------------------------
//
CMenuSrvRemoveOperation::CMenuSrvRemoveOperation( CMenuEng& aEng, TInt aId )
: CMenuSrvOperation( aEng ), iId( aId )
    {
    }

// ---------------------------------------------------------
// CMenuSrvRemoveOperation::RunMenuEngOperationL
// ---------------------------------------------------------
//
void CMenuSrvRemoveOperation::RunMenuEngOperationL()
    {
    iEng.RemoveL( iId );
    }

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

// ---------------------------------------------------------
// CMenuSrvMoveToFolderOperation::~CMenuSrvMoveToFolderOperation
// ---------------------------------------------------------
//
CMenuSrvMoveToFolderOperation::~CMenuSrvMoveToFolderOperation()
    {
    iItems.Close();
    }

// ---------------------------------------------------------
// CMenuSrvMoveToFolderOperation::NewL()
// ---------------------------------------------------------
//
CMenuSrvMoveToFolderOperation* CMenuSrvMoveToFolderOperation::NewL(
        CMenuEng& aEng,
        RReadStream& aItems,
        TInt aFolder,
        TInt aMoveBefore )
    {
    CMenuSrvMoveToFolderOperation* op =
        new (ELeave) CMenuSrvMoveToFolderOperation
        ( aEng, aFolder, aMoveBefore );
    CleanupStack::PushL( op );
    op->ConstructL( aItems );
    CleanupStack::Pop( op );
    return op;
    }

// ---------------------------------------------------------
// CMenuSrvMoveToFolderOperation::CMenuSrvMoveToFolderOperation
// ---------------------------------------------------------
//
CMenuSrvMoveToFolderOperation::CMenuSrvMoveToFolderOperation
( CMenuEng& aEng, TInt aFolder, TInt aMoveBefore )
: CMenuSrvOperation( aEng ), iFolder( aFolder ), iMoveBefore( aMoveBefore )
    {
    }

// ---------------------------------------------------------
// CMenuSrvMoveToFolderOperation::ConstructL()
// ---------------------------------------------------------
//
void CMenuSrvMoveToFolderOperation::ConstructL( RReadStream& aItems )
    {
    MenuUtil::InternalizeL( iItems, aItems );
    }

// ---------------------------------------------------------
// CMenuSrvMoveToFolderOperation::RunMenuEngOperationL
// ---------------------------------------------------------
//
void CMenuSrvMoveToFolderOperation::RunMenuEngOperationL()
    {
    iEng.MoveToFolderL( iItems, iFolder, iMoveBefore );
    }

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

// ---------------------------------------------------------
// CMenuSrvReorderOperation::CMenuSrvReorderOperation
// ---------------------------------------------------------
//
CMenuSrvReorderOperation::CMenuSrvReorderOperation
( CMenuEng& aEng, TInt aId, TInt aMoveBefore )
: CMenuSrvOperation( aEng ), iId( aId ), iMoveBefore( aMoveBefore )
    {
    }

// ---------------------------------------------------------
// CMenuSrvReorderOperation::RunMenuEngOperationL
// ---------------------------------------------------------
//
void CMenuSrvReorderOperation::RunMenuEngOperationL()
    {
    iEng.ReorderL( iId, iMoveBefore );
    }

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

// ---------------------------------------------------------
// CMenuSrvAddOperation::~CMenuSrvAddOperation
// ---------------------------------------------------------
//
CMenuSrvAddOperation::~CMenuSrvAddOperation()
    {
    delete iObject;
    }

// ---------------------------------------------------------
// CMenuSrvAddOperation::NewL()
// ---------------------------------------------------------
//
CMenuSrvAddOperation* CMenuSrvAddOperation::NewL
( CMenuEng& aEng, const TDesC& aType, RReadStream& aChanges )
    {
    CMenuSrvAddOperation* op = new (ELeave) CMenuSrvAddOperation( aEng );
    CleanupStack::PushL( op );
    op->ConstructL( aType, aChanges );
    CleanupStack::Pop( op );
    return op;
    }

// ---------------------------------------------------------
// CMenuSrvAddOperation::CMenuSrvAddOperation
// ---------------------------------------------------------
//
CMenuSrvAddOperation::CMenuSrvAddOperation( CMenuEng& aEng )
: CMenuSrvOperation( aEng )
    {
    }

// ---------------------------------------------------------
// CMenuSrvAddOperation::ConstructL()
// ---------------------------------------------------------
//
void CMenuSrvAddOperation::ConstructL( const TDesC& aType, RReadStream& aChanges )
    {
    iObject = iEng.NewObjectL( aType );
    // Flags.
    const TUint32 flags = aChanges.ReadUint32L();
    // Attributes.
    RMenuItemAttrArray attrChanges;
    CleanupResetAndDestroyPushL( attrChanges );
    attrChanges.InternalizeL( aChanges );
    // Parent folder and insertion point.
    iParent = aChanges.ReadInt32L();
    iInsertBefore = aChanges.ReadInt32L();
    // Flag and attribute data is stored inside the object.
    iObject->SetFlags( flags, ETrue );
    for ( TInt i = 0; i < attrChanges.Count(); i++ )
        {
        const CMenuItemAttr* attr = attrChanges[i];
        if ( attr->Value() )
            {
            iObject->SetAttributeL( attr->Name(), *attr->Value(), EFalse );
            }
        else
            {
            ; // No use trying to remove attribute: this is a new object.
            }
        }
    CleanupStack::PopAndDestroy( &attrChanges ); // Ownership NOT passed.        
    }

// ---------------------------------------------------------
// CMenuSrvAddOperation::ObjectId
// ---------------------------------------------------------
//
TInt CMenuSrvAddOperation::ObjectId()
    {
    __ASSERT_DEBUG( iObject, User::Invariant() );
    return iObject->Id();
    }

// ---------------------------------------------------------
// CMenuSrvAddOperation::RunMenuEngOperationL
// ---------------------------------------------------------
//
void CMenuSrvAddOperation::RunMenuEngOperationL()
    {
    __ASSERT_DEBUG( iObject, User::Invariant() );
    iEng.AddL( *iObject, iParent, iInsertBefore );
    iObject = NULL; // Ownership passed to engine.
    }

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

// ---------------------------------------------------------
// CMenuSrvUpdateOperation::~CMenuSrvUpdateOperation
// ---------------------------------------------------------
//
CMenuSrvUpdateOperation::~CMenuSrvUpdateOperation()
    {
    iAttrChanges.ResetAndDestroy();
    }

// ---------------------------------------------------------
// CMenuSrvUpdateOperation::NewL()
// ---------------------------------------------------------
//
CMenuSrvUpdateOperation* CMenuSrvUpdateOperation::NewL
( CMenuEng& aEng, TInt aId, RReadStream& aChanges )
    {
    CMenuSrvUpdateOperation* op =
        new (ELeave) CMenuSrvUpdateOperation( aEng, aId );
    CleanupStack::PushL( op );
    op->ConstructL( aChanges );
    CleanupStack::Pop( op );
    return op;
    }

// ---------------------------------------------------------
// CMenuSrvUpdateOperation::CMenuSrvUpdateOperation
// ---------------------------------------------------------
//
CMenuSrvUpdateOperation::CMenuSrvUpdateOperation( CMenuEng& aEng, TInt aId )
: CMenuSrvOperation( aEng ), iId( aId )
    {
    }

// ---------------------------------------------------------
// CMenuSrvUpdateOperation::ConstructL()
// ---------------------------------------------------------
//
void CMenuSrvUpdateOperation::ConstructL( RReadStream& aChanges )
    {
    iFlags = aChanges.ReadUint32L();
    iChangedFlags = aChanges.ReadUint32L();
    iAttrChanges.InternalizeL( aChanges );
    }

// ---------------------------------------------------------
// CMenuSrvUpdateOperation::RunMenuEngOperationL
// ---------------------------------------------------------
//
void CMenuSrvUpdateOperation::RunMenuEngOperationL()
    {
    CMenuEngObject& object = iEng.ModifiableObjectL( iId );
    object.SetFlags( iFlags & iChangedFlags, ETrue );
    object.SetFlags( ~iFlags & iChangedFlags, EFalse );
    for ( TInt i = 0; i < iAttrChanges.Count(); i++ )
        {
        const CMenuItemAttr* attr = iAttrChanges[i];
        if ( attr->Value() )
            {
            object.SetAttributeL( attr->Name(), *attr->Value(), EFalse );
            }
        else
            {
            object.RemoveAttribute( attr->Name() );
            }
        }
    }

//  End of File