/*
* Copyright (c) 2006, 2007 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 for CAknTreeListIcon class.
*
*/


#include <AknsUtils.h>
#include <AknIconUtils.h>

#include "akntreelisticon.h"

// Flag definitions.
enum TAknTreeListIconFlags
    {
    EFlagColored, // Icon is color skinned.
    EFlagReloadable, // Parameters for reloading the icon are stored in class.
    EFlagBitmapsOwnedExternally
    };


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

// ---------------------------------------------------------------------------
// Two-phased constructor.
// ---------------------------------------------------------------------------
//
CAknTreeListIcon* CAknTreeListIcon::NewLC( TInt aIconId, const TAknsItemID& aId,
    const TDesC& aFilename, TInt aBitmapId, TInt aMaskId,
    TScaleMode aScaleMode )
    {
    CAknTreeListIcon* self = new ( ELeave ) CAknTreeListIcon( aIconId, aId,
        aBitmapId, aMaskId, aScaleMode );
    CleanupStack::PushL( self );
    self->ConstructL( aFilename );
    return self;
    }


// ---------------------------------------------------------------------------
// Two-phased constructor.
// ---------------------------------------------------------------------------
//
CAknTreeListIcon* CAknTreeListIcon::NewLC( TInt aIconId, CFbsBitmap* aIcon,
    CFbsBitmap* aMask, TBool aTransferOwnership, TScaleMode aScaleMode )
    {
    CAknTreeListIcon* self = new ( ELeave ) CAknTreeListIcon( aIconId,
        aIcon, aMask, aTransferOwnership, aScaleMode );
    CleanupStack::PushL( self );
    return self;
    }


// ---------------------------------------------------------------------------
// Two-phased constructor.
// ---------------------------------------------------------------------------
//
CAknTreeListIcon* CAknTreeListIcon::NewLC( TInt aIconId, const TAknsItemID& aId,
    const TAknsItemID& aColorId, TInt aColorIndex, const TDesC& aFilename,
    TInt aBitmapId, TInt aMaskId, TRgb aDefaultColor, TScaleMode aScaleMode )
    {
    CAknTreeListIcon* self = new ( ELeave ) CAknTreeListIcon( aIconId, aId,
        aColorId, aColorIndex, aBitmapId, aMaskId, aDefaultColor, aScaleMode );
    CleanupStack::PushL( self );
    self->ConstructL( aFilename );
    return self;
    }


// ---------------------------------------------------------------------------
// Destructor.
// ---------------------------------------------------------------------------
//
CAknTreeListIcon::~CAknTreeListIcon()
    {
    delete iFilename;

    if ( iFlags.IsClear( EFlagBitmapsOwnedExternally ) )
        {
        delete iBitmap;
        delete iMask;
        }

    iBitmap = NULL;
    iMask = NULL;
    }


// ---------------------------------------------------------------------------
// Compares given two tree list icons.
// ---------------------------------------------------------------------------
//
TInt CAknTreeListIcon::Compare( const CAknTreeListIcon& aFirst,
    const CAknTreeListIcon& aSecond )
    {
    TInt id = aFirst.Id();
    return CompareId( &id, aSecond );
    }


// ---------------------------------------------------------------------------
// Compares icon ID with the one in given tree list icons.
// ---------------------------------------------------------------------------
//
TInt CAknTreeListIcon::CompareId( const TInt* aIconId,
    const CAknTreeListIcon& aIcon )
    {
    TInt value = NULL;
    TInt id1 = *aIconId;
    TInt id2 = aIcon.Id();

    if ( id1 < id2 )
        {
        value = -1;
        }
    else if ( id1 > id2 )
        {
        value = 1;
        }

    return value;
    }


// ---------------------------------------------------------------------------
// Reconstructs the bitmap and mask for the icon.
// ---------------------------------------------------------------------------
//
void CAknTreeListIcon::ReconstructL()
    {
    if ( iFlags.IsSet( EFlagReloadable ) )
        {
        CFbsBitmap* bitmap = NULL;
        CFbsBitmap* mask = NULL;

        MAknsSkinInstance* skin = AknsUtils::SkinInstance();
        if ( iFlags.IsSet( EFlagColored ) )
            {
            AknsUtils::CreateColorIconL( skin, iId, iColorId, iColorIndex,
                bitmap, mask, *iFilename, iBitmapId, iMaskId, iDefaultColor,
                iSize, iScaleMode );
            }
        else
            {
            AknsUtils::CreateIconL( skin, iId, bitmap, mask, *iFilename,
                iBitmapId, iMaskId );
            AknIconUtils::SetSize( bitmap, iSize, iScaleMode );
            }

        delete iBitmap;
        iBitmap = bitmap;

        delete iMask;
        iMask = mask;
        }
    }


// ---------------------------------------------------------------------------
// Returns the ID assigned for the tree list icon.
// ---------------------------------------------------------------------------
//
TInt CAknTreeListIcon::Id() const
    {
    return iIconId;
    }


// ---------------------------------------------------------------------------
// Returns the icon's skin item ID.
// ---------------------------------------------------------------------------
//
const TAknsItemID& CAknTreeListIcon::SkinItemID() const
    {
    return iId;
    }


// ---------------------------------------------------------------------------
// Returns pointer to the bitmap.
// ---------------------------------------------------------------------------
//
CFbsBitmap* CAknTreeListIcon::Bitmap()
    {
    return iBitmap;
    }


// ---------------------------------------------------------------------------
// Returns pointer to the mask.
// ---------------------------------------------------------------------------
//
CFbsBitmap* CAknTreeListIcon::Mask()
    {
    return iMask;
    }


// ---------------------------------------------------------------------------
// Returns the icon's size.
// ---------------------------------------------------------------------------
//
TSize CAknTreeListIcon::Size() const
    {
    return iSize;
    }


// ---------------------------------------------------------------------------
// Returns the icon's scale mode.
// ---------------------------------------------------------------------------
//
TScaleMode CAknTreeListIcon::ScaleMode() const
    {
    return iScaleMode;
    }


// ---------------------------------------------------------------------------
// Sets new icon size and scale mode.
// ---------------------------------------------------------------------------
//
TInt CAknTreeListIcon::SetSize( const TSize& aSize )
    {
    TInt error = KErrNone;
    if ( iSize != aSize )
        {
        iSize = aSize;
        error = AknIconUtils::SetSize( iBitmap, iSize, iScaleMode );
        }
    return error;
    }


// ---------------------------------------------------------------------------
// C++ constructor.
// ---------------------------------------------------------------------------
//
CAknTreeListIcon::CAknTreeListIcon( TInt aIconId, const TAknsItemID& aId,
    TInt aBitmapId, TInt aMaskId, TScaleMode aScaleMode )
    : iIconId( aIconId ),
      iId( aId ),
      iBitmapId( aBitmapId ),
      iMaskId( aMaskId ),
      iScaleMode( aScaleMode )
    {
    iFlags.Set( EFlagReloadable );
    }


// ---------------------------------------------------------------------------
// C++ constructor.
// ---------------------------------------------------------------------------
//
CAknTreeListIcon::CAknTreeListIcon( TInt aIconId, CFbsBitmap* aIcon,
    CFbsBitmap* aMask, TBool aTransferOwnership, TScaleMode aScaleMode )
    : iIconId( aIconId ),
      iId( KAknsIIDNone ),
      iBitmap( aIcon ),
      iMask( aMask ),
      iScaleMode( aScaleMode )
    {
    iFlags.Assign( EFlagBitmapsOwnedExternally, !aTransferOwnership );
    }


// ---------------------------------------------------------------------------
// C++ constructor.
// ---------------------------------------------------------------------------
//
CAknTreeListIcon::CAknTreeListIcon( TInt aIconId, const TAknsItemID& aId,
    const TAknsItemID& aColorId, TInt aColorIndex, TInt aBitmapId,
    TInt aMaskId, TRgb aDefaultColor, TScaleMode aScaleMode )
    : iIconId( aIconId ),
      iId( aId ),
      iColorId( aColorId ),
      iColorIndex( aColorIndex ),
      iBitmapId( aBitmapId ),
      iMaskId( aMaskId ),
      iDefaultColor( aDefaultColor ),
      iScaleMode( aScaleMode )
    {
    iFlags.Set( EFlagReloadable );
    iFlags.Set( EFlagColored );
    }


// ---------------------------------------------------------------------------
// Second phase constructor.
// ---------------------------------------------------------------------------
//
void CAknTreeListIcon::ConstructL( const TDesC& aFilename )
    {
    iFilename = aFilename.AllocL();
    MAknsSkinInstance* skin = AknsUtils::SkinInstance();
    if ( iFlags.IsSet( EFlagColored ) )
        {
        AknsUtils::CreateColorIconL( skin, iId, iColorId, iColorIndex,
            iBitmap, iMask, *iFilename, iBitmapId, iMaskId, iDefaultColor );
        }
    else
        {
        AknsUtils::CreateIconL( skin, iId, iBitmap, iMask, *iFilename,
            iBitmapId, iMaskId );
        }
    }