/*
* 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 "mcsmenuitem.h"
#include "menuitemattr.h"
#include "menubuf.h"
#include "mcsmenu.h"
#include "menuclientoperation.h"
#include "menucompletedoperation.h"


NONSHARABLE_CLASS( CMenuItem::TData )
    {

public:     // construction

    TData( RMenu& aMenu ): iMenu( aMenu ) {}

public:     // data

    RMenu& iMenu;
    TMenuItem iHdr;
    TUint32 iOrigFlags;
    RMenuItemAttrArray iAttrCache;
    TInt iInsertBefore;

    };

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

/**
* Check if this is a valid attribute name. Leave with KErrArgument if not.
* We don't accept whitespace or exotic characters anywhere, and also
* forbid setting reserved attribute "flags".
* The Engine also checks this, but it's more friendly to leave on client
* side too - no point in attempting something that we know will fail.
*/
LOCAL_C void CheckAttrNameL( const TDesC& aAttrName )
    {
    if ( !aAttrName.Length() )
        {
        User::Leave( KErrArgument );
        }
    if ( KMenuAttrFlags() == aAttrName || KMenuAttrId() == aAttrName )
        {
        // Internal attributes, disallow.
        User::Leave( KErrArgument );
        }
    for ( TInt i = 0; i < aAttrName.Length(); i++ )
        {
        const TChar c = aAttrName[i];
        // Allowed set of characters
        if ( !c.IsAlphaDigit() &&
             '_' != c &&
             '-' != c &&
             ':' != c )
            {
            User::Leave( KErrArgument );
            }
        }
    }


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

// ---------------------------------------------------------
// TMenuItem::ExternalizeL
// ---------------------------------------------------------
//
void TMenuItem::ExternalizeL( RWriteStream& aStream ) const
    {
    aStream.WriteInt32L( iId );
    aStream.WriteInt32L( iParent );
    aStream.WriteUint32L( iFlags );
    aStream.WriteInt32L( iType.Length() );
    aStream.WriteL( iType );
    }

// ---------------------------------------------------------
// TMenuItem::InternalizeL
// ---------------------------------------------------------
//
void TMenuItem::InternalizeL( RReadStream& aStream )
    {
    iId = aStream.ReadInt32L();
    iParent = aStream.ReadInt32L();
    iFlags = aStream.ReadUint32L();
    TInt len = aStream.ReadInt32L();
    aStream.ReadL( iType, len );
    }

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

// ---------------------------------------------------------
// CMenuItem::~CMenuItem
// ---------------------------------------------------------
//
EXPORT_C CMenuItem::~CMenuItem()
    {
    if ( iData )
        {
        iData->iAttrCache.ResetAndDestroy();
        delete iData;
        }
    }

// ---------------------------------------------------------
// CMenuItem::CreateL
// ---------------------------------------------------------
//
EXPORT_C CMenuItem* CMenuItem::CreateL
( RMenu& aMenu, const TDesC& aType, TInt aFolder, TInt aInsertBefore )
    {
    if ( KMenuTypeData() == aType )
        {
        // Internal type, disallow.
        User::Leave( KErrArgument );
        }
    // Item created locally, no IPC.
    CMenuItem* item = NewLC( aMenu );
    item->iData->iHdr.SetType( aType );
    item->iData->iHdr.SetParent( aFolder );
    item->iData->iOrigFlags = item->iData->iHdr.Flags();
    item->iData->iInsertBefore = aInsertBefore;
    CleanupStack::Pop( item );
    return item;
    }

// ---------------------------------------------------------
// CMenuItem::OpenL
// ---------------------------------------------------------
//
EXPORT_C CMenuItem* CMenuItem::OpenL( RMenu& aMenu, TInt aId )
    {
    // Get header from server, IPC needed.
    return OpenL( aMenu, aMenu.GetHdrL( aId ) );
    }

// ---------------------------------------------------------
// CMenuItem::OpenL
// ---------------------------------------------------------
//
EXPORT_C CMenuItem* CMenuItem::OpenL( RMenu& aMenu, const TMenuItem& aHdr )
    {
    // We accept the existing header, no IPC needed.
    CMenuItem* item = NewLC( aMenu );
    item->iData->iHdr = aHdr;
    item->iData->iOrigFlags = item->iData->iHdr.Flags();
    CleanupStack::Pop( item );
    return item;
    }

// ---------------------------------------------------------
// CMenuItem::CMenuItem
// ---------------------------------------------------------
//
CMenuItem::CMenuItem()
    {
    }

// ---------------------------------------------------------
// CMenuItem::NewLC
// ---------------------------------------------------------
//
CMenuItem* CMenuItem::NewLC( RMenu& aMenu )
    {
    CMenuItem* item = new (ELeave) CMenuItem();
    CleanupStack::PushL( item );
    item->iData = new (ELeave) CMenuItem::TData( aMenu );
    return item;
    }

// ---------------------------------------------------------
// CMenuItem::Id
// ---------------------------------------------------------
//
EXPORT_C TInt CMenuItem::Id() const
    {
    return iData->iHdr.Id();
    }

// ---------------------------------------------------------
// CMenuItem::Parent
// ---------------------------------------------------------
//
EXPORT_C TInt CMenuItem::Parent() const
    {
    return iData->iHdr.Parent();
    }

// ---------------------------------------------------------
// CMenuItem::Flags
// ---------------------------------------------------------
//
EXPORT_C TUint32 CMenuItem::Flags() const
    {
    return iData->iHdr.Flags();
    }

// ---------------------------------------------------------
// CMenuItem::SetFlags
// ---------------------------------------------------------
//
EXPORT_C void CMenuItem::SetFlags( TUint32 aMask, TBool aOn )
    {
    if ( aOn )
        {
        iData->iHdr.SetFlags( iData->iHdr.Flags() | aMask );
        }
    else
        {
        iData->iHdr.SetFlags( iData->iHdr.Flags() & ~aMask );
        }
    }

// ---------------------------------------------------------
// CMenuItem::Type
// ---------------------------------------------------------
//
EXPORT_C TPtrC CMenuItem::Type() const
    {
    return iData->iHdr.Type();
    }

// ---------------------------------------------------------
// CMenuItem::GetAttributeL
// ---------------------------------------------------------
//
EXPORT_C TPtrC CMenuItem::GetAttributeL
( const TDesC& aAttrName, TBool& aAttrExists )
    {
    CheckAttrNameL( aAttrName );
    CMenuItemAttr* attr = NULL;
    TInt i = iData->iAttrCache.Find( aAttrName );
    if ( KErrNotFound == i )
        {
        attr = CMenuItemAttr::NewLC( aAttrName );
        HBufC* value;
        if( iData->iHdr.Id() )
            {
            value = iData->iMenu.GetAttributeL( Id(), aAttrName );
            }
           else
            {
            value = NULL;
            }

        attr->SetValue( value ); // Takes ownership.
        attr->SetChanged( EFalse ); // New in cache -> not changed.
        iData->iAttrCache.AppendL( attr );
        CleanupStack::Pop( attr ); // Now owned by the cache.
        }
    else
        {
        attr = iData->iAttrCache[i];
        }
    __ASSERT_DEBUG( attr, User::Invariant() ); // Should be cached by now.
    if ( attr->Value() )
        {
        aAttrExists = ETrue;
        return *attr->Value();
        }
    aAttrExists = EFalse;
    return KNullDesC();
    }

// ---------------------------------------------------------
// CMenuItem::GetAttributeL
// ---------------------------------------------------------
//
EXPORT_C void CMenuItem::GetAttributeListL( RArray<TAttributeName>& aList )
    {
    iData->iMenu.GetAttributeListL( Id(), aList );
    }

// ---------------------------------------------------------
// CMenuItem::SetAttributeL
// ---------------------------------------------------------
//
EXPORT_C void CMenuItem::SetAttributeL
( const TDesC& aAttrName, const TDesC& aAttrValue )
    {
    CheckAttrNameL( aAttrName );
    CMenuItemAttr* attr = NULL;
    TInt i = iData->iAttrCache.Find( aAttrName );
    if ( KErrNotFound == i )
        {
        attr = CMenuItemAttr::NewLC( aAttrName );
        attr->SetChanged( ETrue ); // Changed.
        iData->iAttrCache.AppendL( attr );
        CleanupStack::Pop( attr ); // Now owned by the cache.
        }
    else
        {
        attr = iData->iAttrCache[i];
        }
    __ASSERT_DEBUG( attr, User::Invariant() ); // Should be cached by now.
    attr->SetValue( aAttrValue.AllocL() ); // Sets changed bit as needed.
    }

// ---------------------------------------------------------
// CMenuItem::RemoveAttributeL
// ---------------------------------------------------------
//
EXPORT_C void CMenuItem::RemoveAttributeL( const TDesC& aAttrName )
    {
    CheckAttrNameL( aAttrName );
    CMenuItemAttr* attr = NULL;
    TInt i = iData->iAttrCache.Find( aAttrName );
    if ( KErrNotFound == i )
        {
        attr = CMenuItemAttr::NewLC( aAttrName );
        attr->SetChanged( ETrue ); // Changed.
        iData->iAttrCache.AppendL( attr );
        CleanupStack::Pop( attr ); // Now owned by the cache.
        }
    else
        {
        attr = iData->iAttrCache[i];
        }
    __ASSERT_DEBUG( attr, User::Invariant() ); // Should be cached by now.
    attr->SetValue( NULL ); // Sets changed bit as needed.
    }

// ---------------------------------------------------------
// CMenuItem::SaveL
// ---------------------------------------------------------
//
EXPORT_C CMenuOperation* CMenuItem::SaveL( TRequestStatus& aStatus )
    {
    if ( !Changed() )
        {
        return CMenuCompletedOperation::NewL
            ( iData->iMenu, CActive::EPriorityStandard, aStatus, KErrNone );
        }
    if ( Id() )
        {
        return UpdateL( aStatus );
        }
    return AddL( aStatus );
    }

// ---------------------------------------------------------
// CMenuItem::HandleCommandL
// ---------------------------------------------------------
//
EXPORT_C CMenuOperation* CMenuItem::HandleCommandL(
        const TDesC8& aCommand,
        const TDesC8& aParams,
        TRequestStatus& aStatus )
    {
    return iData->iMenu.HandleCommandL( *this, aCommand, aParams, aStatus );
    }

// ---------------------------------------------------------
// CMenuItem::AddL
// ---------------------------------------------------------
//
CMenuOperation* CMenuItem::AddL( TRequestStatus& aStatus )
    {
    __ASSERT_DEBUG( Changed(), User::Invariant() );
    __ASSERT_DEBUG( !Id(), User::Invariant() );
    RMenuBuf buf;
    User::LeaveIfError( buf.Open( iData->iMenu ) );
    CleanupClosePushL( buf );
    RWriteStream stream( &buf );
    // Flags.
    stream.WriteUint32L( iData->iHdr.Flags() );
    __ASSERT_DEBUG( 0 == iData->iOrigFlags, User::Invariant() ); // New item!
    // Attributes.
    __ASSERT_DEBUG( iData->iAttrCache.Count() == \
        iData->iAttrCache.CountChanged(), User::Invariant() ); // New item!
    iData->iAttrCache.ExternalizeL( stream );
    // Parent folder and insertion point.
    stream.WriteInt32L( Parent() );
    stream.WriteInt32L( iData->iInsertBefore );
    stream.CommitL();
    CMenuClientOperation* op = new (ELeave) CMenuClientOperation
        ( iData->iMenu, CActive::EPriorityStandard, aStatus );
    CleanupStack::PushL( op );
    TInt id = op->AddL( Type(), buf );
    __ASSERT_DEBUG( id, User::Invariant() );
    iData->iHdr.SetId( id ); // Write ID back.
    CleanupStack::Pop( op );
    CleanupStack::PopAndDestroy( &buf );
    ClearChanged();
    return op;
    }

// ---------------------------------------------------------
// CMenuItem::UpdateL
// ---------------------------------------------------------
//
CMenuOperation* CMenuItem::UpdateL( TRequestStatus& aStatus )
    {
    __ASSERT_DEBUG( Changed(), User::Invariant() );
    __ASSERT_DEBUG( Id(), User::Invariant() );
    RMenuBuf buf;
    User::LeaveIfError( buf.Open( iData->iMenu ) );
    CleanupClosePushL( buf );
    RWriteStream stream( &buf );
    // Flags and flag changes (small -> always sent).
    stream.WriteUint32L( iData->iHdr.Flags() );
    stream.WriteUint32L( iData->iOrigFlags ^ iData->iHdr.Flags() );
    // Changed attributes.
    iData->iAttrCache.ExternalizeChangesL( stream );
    stream.CommitL();
    CMenuClientOperation* op = new (ELeave) CMenuClientOperation
        ( iData->iMenu, CActive::EPriorityStandard, aStatus );
    CleanupStack::PushL( op );
    op->UpdateL( Id(), buf );
    CleanupStack::Pop( op );
    CleanupStack::PopAndDestroy( &buf );
    ClearChanged();
    return op;
    }

// ---------------------------------------------------------
// CMenuItem::Changed
// ---------------------------------------------------------
//
TBool CMenuItem::Changed() const
    {
    return !iData->iHdr.Id() || // New item
           iData->iHdr.Flags() != iData->iOrigFlags || // Changed flags
           iData->iAttrCache.CountChanged(); // Changed attributes
    }

// ---------------------------------------------------------
// CMenuItem::ClearChanged
// ---------------------------------------------------------
//
void CMenuItem::ClearChanged()
    {
    iData->iAttrCache.ClearChanged();
    iData->iOrigFlags = iData->iHdr.Flags();
    }


// ---------------------------------------------------------
// CMenuItem::RunningStatus
// ---------------------------------------------------------
//
EXPORT_C TBool CMenuItem::RunningStatusL()
    {
    TBool ret(EFalse);
    HBufC* value;
    value = iData->iMenu.GetAttributeL( Id(), KRunningStatus );
    if( value )
    	{
    	ret = ETrue;
    	}
    delete value;
    return ret;
    }