/*

* 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 CVCommandUi class

*

*/

#include <vcommandapi.h>

#include <AknsSkinInstance.h>

#include <AknsUtils.h>

#include <gulicon.h>

#include "rubydebug.h"

/**

* The version of the streamed data protocol

* It is rather likely, that the format of the data streamed changes in the future.

* Using the protocol version, the code can check if it knows how to parse the 

* input stream

*/

const TInt32 KVCCommandUiProtocolVersion = 5;

/**

* This object does not take an ownership of the passed descriptors, 

* but makes own copies. 

* 

* @param aWrittenText Text to display

* @param aTooltip Second line of the text if ant

* @param aFolderInfo Folder-related details

* @param aModifiable If user can modify the command

* @leave KErrOverflow if descriptors are too big

*/

EXPORT_C CVCCommandUi* CVCCommandUi::NewL( const TDesC& aWrittenText, 

                                  const CVCFolderInfo& aFolderInfo, 

                                  TBool aModifiable, const TDesC& aTooltip,

                                  const TUid& aIconUid, const TDesC& aUserText, 

                                  TBool aConfirmationNeeded ) 

    {

    RUBY_DEBUG_BLOCKL( "CVCCommandUi::NewL" );

    CVCCommandUi* self = new (ELeave) CVCCommandUi;

    CleanupStack::PushL( self );

    self->ConstructL( aWrittenText, aFolderInfo, aModifiable, aTooltip, aIconUid, 

                      aUserText, aConfirmationNeeded );

    CleanupStack::Pop( self );

    return self;

    }

/**

* Copy the existing CVCCommandUi

*/

EXPORT_C CVCCommandUi* CVCCommandUi::NewL( const CVCCommandUi& aOriginal )

    {

    CVCCommandUi* self = new (ELeave) CVCCommandUi;

    CleanupStack::PushL( self );

    self->ConstructL( aOriginal.WrittenText(), aOriginal.FolderInfo(), 

                      aOriginal.Modifiable(), aOriginal.Tooltip(), 

                      aOriginal.IconUid(), aOriginal.UserText(),

                      aOriginal.ConfirmationNeeded() );

    CleanupStack::Pop( self );

    return self;

    }

/** 

* Internalizes the command from stream 

* values are read in the same order as ExternalizeL wrote them

*/

EXPORT_C CVCCommandUi* CVCCommandUi::NewL( RReadStream &aStream )

    {

    CVCCommandUi* self = new (ELeave) CVCCommandUi;

    CleanupStack::PushL( self );

    self->ConstructL( aStream );

    CleanupStack::Pop( self );

    return self;

    }

void CVCCommandUi::ConstructL( RReadStream &aStream )

	{

	/**

	* @todo extract the repeated descriptor internalization code into

	*       a separate method

	*/

	TInt32 ver;

    aStream >> ver;

    __ASSERT_ALWAYS( ver == KVCCommandUiProtocolVersion, User::Leave( KErrNotSupported  ) );

    iWrittenText = HBufC::NewL( aStream.ReadInt32L() );

    TPtr pWrittenText = iWrittenText->Des();

    aStream >> pWrittenText;

    iFolderInfo = CVCFolderInfo::NewL( aStream );

    TInt32 intModifiable;

    aStream >> intModifiable;

    iUserCanModify = static_cast<TBool>( intModifiable );

    iTooltip = HBufC::NewL( aStream.ReadInt32L() );

    TPtr pTooltip = iTooltip->Des();

    aStream >> pTooltip;

    iIconUid = TUid::Uid( aStream.ReadInt32L() );

    iUserText = HBufC::NewL( aStream.ReadInt32L() );

    TPtr pUserText = iUserText->Des();

    aStream >> pUserText;

    TInt32 intConfirmationNeeded;

    aStream >> intConfirmationNeeded;

    iConfirmationNeeded = static_cast<TBool>( intConfirmationNeeded );

	}

/** 

* Second-phase constructor 

* @see NewL for guarding conditions

*/    

void CVCCommandUi::ConstructL( const TDesC& aWrittenText, const CVCFolderInfo& aFolderInfo,

                               TBool aModifiable, const TDesC& aTooltip, const TUid& aIconUid,

                               const TDesC& aUserText, TBool aConfirmationNeeded ) 

    {

    RUBY_DEBUG_BLOCKL( "CVCCommandUi::ConstructL" );

    iWrittenText = HBufC::NewL( aWrittenText.Length() );

    *iWrittenText = aWrittenText;

    iFolderInfo = CVCFolderInfo::NewL( aFolderInfo );

    iTooltip = HBufC::NewL( aTooltip.Length() );

    *iTooltip = aTooltip;

    iUserCanModify = aModifiable;

    iIconUid = TUid::Uid( aIconUid.iUid );

    iUserText = HBufC::NewL( aUserText.Length() );

    *iUserText = aUserText;

    iConfirmationNeeded = aConfirmationNeeded;

    }

EXPORT_C CVCCommandUi::~CVCCommandUi() 

    {

    delete iUserText;

    delete iWrittenText;

    delete iFolderInfo;

    delete iTooltip;

    }

/** 

 * Saves the command to stream.

 * Descriptor components are saved as <length><descriptor> pairs, where 

 * <length> is TInt32 and <descriptor> is the default descriptor represetation

 * TBools are saved as TInt32 either

 */

EXPORT_C void CVCCommandUi::ExternalizeL( RWriteStream &aStream ) const

    {

    aStream << KVCCommandUiProtocolVersion;

    aStream << static_cast<TInt32>( iWrittenText->Length() );

    aStream << *iWrittenText;

    aStream << *iFolderInfo;

    aStream << static_cast<TInt32> ( iUserCanModify );

    aStream << static_cast<TInt32>( iTooltip->Length() );

    aStream << *iTooltip;

    aStream << iIconUid.iUid;

    aStream << static_cast<TInt32>( iUserText->Length() );

    aStream << *iUserText;

    aStream << static_cast<TInt32> ( iConfirmationNeeded );

    }

EXPORT_C const TDesC& CVCCommandUi::WrittenText() const 

    {

    return *iWrittenText;

    }

EXPORT_C const TDesC& CVCCommandUi::UserText() const 

    {

    return *iUserText;

    }

EXPORT_C const CVCFolderInfo& CVCCommandUi::FolderInfo() const 

    {

    return *iFolderInfo;

    }

EXPORT_C const TDesC& CVCCommandUi::Tooltip() const 

    {

    return *iTooltip;

    }

EXPORT_C TBool CVCCommandUi::Modifiable() const

    {

    return iUserCanModify;

    }

EXPORT_C TBool CVCCommandUi::ConfirmationNeeded() const

    {

    return iConfirmationNeeded;

    }

EXPORT_C const TUid& CVCCommandUi::IconUid() const 

    {

    return iIconUid;

    }

EXPORT_C TBool CVCCommandUi::operator==( const CVCCommandUi& aCommandUi ) const

    {

    return (

            ( *iWrittenText == aCommandUi.WrittenText() ) &&

            ( *iFolderInfo == aCommandUi.FolderInfo() ) &&

            ( *iTooltip == aCommandUi.Tooltip() ) &&

            ( iUserCanModify == aCommandUi.Modifiable() ) &&

            ( iIconUid == aCommandUi.IconUid() ) &&

            ( *iUserText == aCommandUi.UserText() ) &&

            ( iConfirmationNeeded == aCommandUi.ConfirmationNeeded() )

           );

    }

EXPORT_C CGulIcon* CVCCommandUi::IconLC() const

	{

	MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    CFbsBitmap* bitmap = NULL;

    CFbsBitmap* mask = NULL;

	AknsUtils::CreateAppIconLC( skin, IconUid(), EAknsAppIconTypeList, bitmap, mask );

    CGulIcon* icon = CGulIcon::NewL( bitmap, mask );

    icon->SetBitmapsOwnedExternally( EFalse );

    // icon now owns the bitmaps, no need to keep on cleanup stack.

    CleanupStack::Pop( 2 ); // mask, bitmap

    CleanupStack::PushL( icon );

    return icon;

	}

/**

 * Tells if all non user-changeable parts of aCommandUi are equal to this object's

 * @return ETrue if equal, EFalse otherwise

 */

EXPORT_C TBool CVCCommandUi::EqualNonUserChangeableData( const CVCCommandUi& aCommandUi ) const

    {

    if( WrittenText() != aCommandUi.WrittenText() ) return EFalse;

    if( !(FolderInfo() == aCommandUi.FolderInfo()) ) return EFalse;    

    if( Modifiable() != aCommandUi.Modifiable() ) return EFalse;    

    if( ConfirmationNeeded() != aCommandUi.ConfirmationNeeded() ) return EFalse;    

    if( Tooltip() != aCommandUi.Tooltip() ) return EFalse;    

    if( IconUid() != aCommandUi.IconUid() ) return EFalse;    

    return ETrue;    

    }

//End of file