/*

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

*

*/

#include <vcommandapi.h>

#include <AknsSkinInstance.h>

#include <AknsUtils.h>

#include <AknsConstants.h>

#include <gulicon.h>

#include <mifconvdefs.h>

#include "rubydebug.h"

/**

 * File name to read icons from if icon file name is not specified

 */

_LIT( KDefaultIconFile, "Z:\\resource\\apps\\vcommand.mif" );

const TInt KDefaultIconIndex = KMifIdFirst;  // first image in the file

/**

* 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 KVCFolderInfoProtocolVersion = 2;

static const TAknsItemID* const KIconId[] = 

    {

    &KAknsIIDQgnPropFolderVcGeneral,

    &KAknsIIDQgnPropFolderVcTools,

    &KAknsIIDQgnPropFolderVcOrganiser,

    &KAknsIIDQgnPropFolderVcMessage,

    &KAknsIIDQgnPropFolderVcMedia,

    &KAknsIIDQgnPropFolderVcProfiles

    };

/**

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

 * but makes own copies. 

 * 

 * @param aTitle Folder title. It is shown at the top of the screen,

 *        when the folder is opened in the VCommand application

 * @param aListedName Version of a title shown when the folder is

 *        is displayed in the list of VCommands in the VCommand app

 * @param aHelpTopicId Topic to open when help is requested for the 

 *        given folder

 * @param aIconIndex Index of the folder icon in the folder icons mbm file

 *        each index correspods to two images - the actual icon and its mask

 * @param aIconFile Mbm file where the icons are obtained from. If KNullDesC, 

 * 		  the default icon file is used

 */

EXPORT_C CVCFolderInfo* CVCFolderInfo::NewL( const TDesC& aTitle,

        const TDesC& aListedName, TUint32 aHelpTopicId, TUint aIconIndex,

                const TDesC& aIconFile )

    {

    CVCFolderInfo* self = new (ELeave) CVCFolderInfo( aHelpTopicId, aIconIndex );

    CleanupStack::PushL( self );

    self->ConstructL( aTitle, aListedName, aIconFile );

    CleanupStack::Pop( self );

    return self;

    }

/**

* Copy the existing CVCFolderInfo

*/

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

    {

    CVCFolderInfo* self = new (ELeave) CVCFolderInfo( aOriginal.HelpTopicId(), 

                                                      aOriginal.IconIndex() );

    CleanupStack::PushL( self );

    self->ConstructL( aOriginal.Title(), aOriginal.ListedName(), aOriginal.IconFile() );

    CleanupStack::Pop( self );

    return self;

    }

/**

 * Constructs the folder information from stream

 * @leave KErrNotSupported if the stream data format is unsupported

 */

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

    {

    CVCFolderInfo* self = new (ELeave) CVCFolderInfo;

    CleanupStack::PushL( self );

    self->ConstructL( aStream );

    CleanupStack::Pop( self );

    return self;

    }

CVCFolderInfo::CVCFolderInfo( TUint32 aHelpTopicId, TUint aIconIndex ) :

    iHelpTopicId( aHelpTopicId ), iIconIndex (aIconIndex )

    {

    // empty

    }

void CVCFolderInfo::ConstructL( RReadStream &aStream )

	{

	/**

	* @todo extract the repeated descriptor internalization code into

	*       a separate method

	*/

	TInt32 ver;

    aStream >> ver;

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

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

    TPtr pTitle = iTitle->Des();

    aStream >> pTitle;

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

    TPtr pListedName = iListedName->Des();

    aStream >> pListedName;

    iHelpTopicId = aStream.ReadUint32L();

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

    TPtr pIconFile = iIconFile->Des();

    aStream >> pIconFile;

    iIconIndex = aStream.ReadUint32L();

	}

/** 

* Second-phase constructor 

*/

void CVCFolderInfo::ConstructL( const TDesC& aTitle, const TDesC& aListedName,

                                const TDesC& aIconFile )

    {

    RUBY_DEBUG_BLOCKL( "" );

    iTitle = HBufC::NewL( aTitle.Length() );

    *iTitle = aTitle;

    iListedName = HBufC::NewL( aListedName.Length() );

    *iListedName = aListedName;    

    iIconFile = HBufC::NewL( aIconFile.Length() );

    *iIconFile = aIconFile;

    }

EXPORT_C CVCFolderInfo::~CVCFolderInfo() 

    {

    delete iListedName;

    delete iTitle;

    delete iIconFile;

    }

/** 

 * 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 CVCFolderInfo::ExternalizeL( RWriteStream &aStream ) const

    {

    aStream << KVCFolderInfoProtocolVersion;

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

    aStream << *iTitle;

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

    aStream << *iListedName;

    aStream << iHelpTopicId;

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

    aStream << *iIconFile;

    // Mandate saving index as Uint32 to preserve the string format

    aStream << static_cast<TUint32> ( iIconIndex );

    }

EXPORT_C const TDesC& CVCFolderInfo::Title() const 

    {

    return *iTitle;

    }

EXPORT_C const TDesC& CVCFolderInfo::ListedName() const 

    {

    return *iListedName;

    }

EXPORT_C TUint32 CVCFolderInfo::HelpTopicId() const 

    {

    return iHelpTopicId;

    }

EXPORT_C TBool CVCFolderInfo::operator==( const CVCFolderInfo& aFolderInfo ) const

    {

    return (

            ( iHelpTopicId == aFolderInfo.HelpTopicId() ) &&

            ( *iTitle == aFolderInfo.Title()            ) &&

            ( *iListedName == aFolderInfo.ListedName()  ) &&

            ( *iIconFile == aFolderInfo.IconFile()      ) &&

            ( iIconIndex == aFolderInfo.IconIndex()     ) 

           );

    }

EXPORT_C TDesC& CVCFolderInfo::IconFile() const

	{

	return *iIconFile;

	}    

EXPORT_C TUint CVCFolderInfo::IconIndex() const

	{

	return iIconIndex;

	}

/**

* Creates an icon to represent this folder. Works only if CEikonEnv is available

* @return Icon for the folder

*/

EXPORT_C CGulIcon* CVCFolderInfo::IconLC() const

	{

 	MAknsSkinInstance* skin = AknsUtils::SkinInstance();

	CFbsBitmap* bitmap = NULL;

    CFbsBitmap* mask = NULL;

    const TInt KBitmapsPerIcon = 2;

    // Every "index" corrsponds to two bitmaps - actual icon and its mask

    TInt iconIndex = KMifIdFirst + IconIndex()*KBitmapsPerIcon;

    TInt maskIndex = iconIndex + 1;

    TDesC& iconFile = IconFile();

    if ( iconFile == KNullDesC )

        {

        iconFile = KDefaultIconFile;

        }

    TRAPD( err,    

	    AknsUtils::CreateIconLC( skin, *KIconId[ IconIndex() ],

       	                     bitmap, mask, iconFile, iconIndex, 

       	                     maskIndex );

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

         )

    if( err != KErrNone )

        {

        RUBY_DEBUG1( "CreateIconLC failed with %d. Loading default icon", err );

        AknsUtils::CreateIconLC( skin, *KIconId[ IconIndex() ],

                             bitmap, mask, KDefaultIconFile, KDefaultIconIndex, 

                             KDefaultIconIndex + 1 );

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

        }

    CleanupStack::PushL( mask );

    CleanupStack::PushL( bitmap );

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

    icon->SetBitmapsOwnedExternally( EFalse );

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

    CleanupStack::Pop( bitmap );  

    CleanupStack::Pop( mask );  

    CleanupStack::PushL( icon );

    return icon;

	}

//End of file