/*

* Copyright (c) 2002 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 <e32base.h>

#include <fbs.h>

#include <e32math.h>

#include <bitdev.h>

#include <mifconvdefs.h>

#include "AknIconUtils.h"

#include "AknIconManager.h"

#include "AknSourceBitmapIconManager.h"

#include "AknFileHandleIconManager.h"

#include "AknFileProviderIconManager.h"

#include "AknBitmap.h"

#include "AknIconSrvTlsData.h"

#include "AknIconPanic.h"

#include "AknIconTraces.h"

#include "AknInternalIconUtils.h"

// CONSTANTS

_LIT( KAvkonIconFileName, "Z:\\Resource\\Apps\\avkon2.mbm" );

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

EXPORT_C CAknIcon* CAknIcon::NewL()

    {

    return new( ELeave ) CAknIcon;

    }

CAknIcon::~CAknIcon()

    {

    delete iBitmap;

    delete iMask;

    }

EXPORT_C CFbsBitmap* CAknIcon::Bitmap() const

    {

    return iBitmap;

    }

EXPORT_C CFbsBitmap* CAknIcon::Mask() const

    {

    return iMask;

    }

EXPORT_C void CAknIcon::SetBitmap( CFbsBitmap* aBitmap )

    {

    iBitmap = aBitmap;

    }

EXPORT_C void CAknIcon::SetMask( CFbsBitmap* aMask )

    {

    iMask = aMask;

    }

// -----------------------------------------------------------------------------

// AknIconUtils::CreateIconL

// -----------------------------------------------------------------------------

//

EXPORT_C void AknIconUtils::CreateIconL(

    CFbsBitmap*& aBitmap,

    CFbsBitmap*& aMask,

    const TDesC& aFileName,

    TInt aBitmapId,

    TInt aMaskId )

    {

    CreateIconLC(

        aBitmap,

        aMask,

        aFileName,

        aBitmapId,

        aMaskId );

    CleanupStack::Pop( 2 );

    }

// -----------------------------------------------------------------------------

// AknIconUtils::CreateIconLC

// -----------------------------------------------------------------------------

//

EXPORT_C void AknIconUtils::CreateIconLC(

    CFbsBitmap*& aBitmap,

    CFbsBitmap*& aMask,

    const TDesC& aFileName,

    TInt aBitmapId,

    TInt aMaskId )

    {    

    CreateIconLC(

        aBitmap,

        aMask,

        aFileName,

        aBitmapId,

        aMaskId,

        NULL );

    }

// -----------------------------------------------------------------------------

// AknIconUtils::CreateIconL

// -----------------------------------------------------------------------------

//

EXPORT_C CFbsBitmap* AknIconUtils::CreateIconL(

    const TDesC& aFileName,

    TInt aBitmapId )

    {

    CFbsBitmap* bitmap;

    CFbsBitmap* mask;

    AknIconUtils::CreateIconL(

        bitmap,

        mask,

        aFileName,

        aBitmapId,

        -1 );

    return bitmap;

    }

// -----------------------------------------------------------------------------

// AknIconUtils::CreateIconL

// -----------------------------------------------------------------------------

//

EXPORT_C void AknIconUtils::CreateIconL(

    CFbsBitmap*& aBitmap,

    CFbsBitmap*& aMask,

    MAknIconFileProvider& aFileProvider,

    TInt aBitmapId,

    TInt aMaskId )

    {

    CreateIconLC(

        aBitmap,

        aMask,

        aFileProvider,

        aBitmapId,

        aMaskId );

    CleanupStack::Pop( 2 );

    }

// -----------------------------------------------------------------------------

// AknIconUtils::CreateIconL

// -----------------------------------------------------------------------------

//

EXPORT_C void AknIconUtils::CreateIconLC(

    CFbsBitmap*& aBitmap,

    CFbsBitmap*& aMask,

    MAknIconFileProvider& aFileProvider,

    TInt aBitmapId,

    TInt aMaskId )

    {

    __ASSERT_ALWAYS( &aFileProvider,

        User::Panic( KAknIconPanicCategory, EInvalidParameter ) );

    CreateIconLC(

        aBitmap,

        aMask,

        KNullDesC(), // filename comes from aFile,

        aBitmapId,

        aMaskId,

        &aFileProvider );

    }

// -----------------------------------------------------------------------------

// AknIconUtils::CreateIconL

// -----------------------------------------------------------------------------

//

EXPORT_C CFbsBitmap* AknIconUtils::CreateIconL(

    MAknIconFileProvider& aFileProvider,

    TInt aBitmapId )

    {

    CFbsBitmap* bitmap;

    CFbsBitmap* mask;

    CreateIconL(

        bitmap,

        mask,

        aFileProvider,

        aBitmapId,

        -1 );

    return bitmap;

    }

// -----------------------------------------------------------------------------

// AknIconUtils::PreserveIconData

// -----------------------------------------------------------------------------

//

EXPORT_C void AknIconUtils::PreserveIconData( CFbsBitmap* aBitmap )

    {

    if ( IsAknBitmap( aBitmap ) )

        {

        static_cast<CAknBitmap*>( aBitmap )->Manager()->PreserveIconData();

        }

    }

// -----------------------------------------------------------------------------

// AknIconUtils::DestroyIconData

// -----------------------------------------------------------------------------

//

EXPORT_C void AknIconUtils::DestroyIconData( CFbsBitmap* aBitmap )

    {

    if ( IsAknBitmap( aBitmap ) )

        {

        static_cast<CAknBitmap*>( aBitmap )->Manager()->DestroyIconData();

        }

    }

// -----------------------------------------------------------------------------

// AknIconUtils::SetSize

// -----------------------------------------------------------------------------

//

EXPORT_C TInt AknIconUtils::SetSize(

    CFbsBitmap* aBitmap,

    const TSize& aSize,

    TScaleMode aMode )

    {

    TInt ret = KErrNone;

#ifdef __AKNICON_TRACES

    RDebug::Print( _L("AknIcon: aBitmap=%x Calling AknIconUtils::SetSize - Icon size (%d,%d), Mode=%d"),

                   aBitmap, aSize.iWidth, aSize.iHeight, aMode);

#endif    

    if ( IsAknBitmap( aBitmap ) )

        {

        CAknBitmap* bmp = static_cast<CAknBitmap*>(aBitmap);

        CAknIconManager* man = bmp->Manager();

        ret = man->InitializeIcon(

                aSize, aMode );

        }

#ifdef __AKNICON_TRACES

    RDebug::Print( _L("AknIcon: aBitmap=%x AknIconUtils::SetSize called - return: %d"), aBitmap, ret);

#endif           

    return ret;

    }

// -----------------------------------------------------------------------------

// AknIconUtils::SetSizeAndRotation

// -----------------------------------------------------------------------------

//

EXPORT_C TInt AknIconUtils::SetSizeAndRotation(

    CFbsBitmap* aBitmap,

    const TSize& aSize,

    TScaleMode aMode,

    TInt aAngle )

    {

    TInt ret = KErrNone;

#ifdef __AKNICON_TRACES

    RDebug::Print( _L("AknIcon: aBitmap=%x Calling AknIconUtils::SetSizeAndRotation - Icon size (%d,%d), Mode=%d, Angle=%d"),

                   aBitmap, aSize.iWidth, aSize.iHeight, aMode, aAngle);

#endif 

    if ( IsAknBitmap( aBitmap ) )

        {

        ret = static_cast<CAknBitmap*>( aBitmap )->Manager()->InitializeIcon(

            aSize, aMode, aAngle );

        }

#ifdef __AKNICON_TRACES

    RDebug::Print( _L("AknIcon: aBitmap=%x AknIconUtils::SetSizeAndRotation called - return: %d"), aBitmap, ret);

#endif 

    return ret;

    }

// -----------------------------------------------------------------------------

// AknIconUtils::SetObserver

// -----------------------------------------------------------------------------

//

EXPORT_C void AknIconUtils::SetObserver(

    CFbsBitmap* aBitmap,

    MAknIconObserver* aObserver )

    {

    if ( IsAknBitmap( aBitmap ) )

        {

        static_cast<CAknBitmap*>( aBitmap )->Manager()->SetObserver( aObserver );

        }

    }

// -----------------------------------------------------------------------------

// AknIconUtils::AvkonIconFileName

// -----------------------------------------------------------------------------

//

EXPORT_C const TDesC& AknIconUtils::AvkonIconFileName()

    {

    return KAvkonIconFileName();

    }

// -----------------------------------------------------------------------------

// AknIconUtils::ValidateLogicalAppIconId

// -----------------------------------------------------------------------------

//

EXPORT_C void AknIconUtils::ValidateLogicalAppIconId( 

    const TDesC& aIconFileName,

    TInt& aBitmapId,

    TInt& aMaskId )

    {

    if ( IsMifFile( aIconFileName ) )

        {

        aBitmapId += KMifIdFirst;

        aMaskId += KMifIdFirst;

        }

    }

// -----------------------------------------------------------------------------

// AknIconUtils::IsMifFile

// -----------------------------------------------------------------------------

//

EXPORT_C TBool AknIconUtils::IsMifFile( const TDesC& aIconFileName )

    {

    return aIconFileName.Right( KExtensionLength ).CompareF( KMifExtension ) == 0;

    }

// -----------------------------------------------------------------------------

// AknIconUtils::IsMifIcon

// -----------------------------------------------------------------------------

//

EXPORT_C TBool AknIconUtils::IsMifIcon( const CFbsBitmap* aBitmap )

    {

    TBool ret = EFalse;

    if ( IsAknBitmap( aBitmap ) )

        {

        ret = !(static_cast<const CAknBitmap*>(aBitmap)->Manager()->IsMbmIcon());

        }

    return ret;

    }

// -----------------------------------------------------------------------------

// AknIconUtils::GetContentDimensions

// -----------------------------------------------------------------------------

//

EXPORT_C TInt AknIconUtils::GetContentDimensions(

    CFbsBitmap* aBitmap,

    TSize& aContentDimensions )

    {

    TAknContentDimensions contentDimensions;

   	TInt ret = GetContentDimensions(aBitmap,contentDimensions);

   	aContentDimensions.SetSize(contentDimensions.iWidth,contentDimensions.iHeight);

    return ret;

    }

// -----------------------------------------------------------------------------

// AknIconUtils::GetContentDimensions

// -----------------------------------------------------------------------------

//

EXPORT_C TInt AknIconUtils::GetContentDimensions(

    CFbsBitmap* aBitmap,

    TAknContentDimensions& aContentDimensions )

    {

    __ASSERT_DEBUG( aBitmap, 

        User::Panic( KAknIconPanicCategory, EInvalidParameter ) );

    TInt ret = KErrNone;

    if ( IsAknBitmap( aBitmap ) )

        {

        ret = static_cast<CAknBitmap*>( aBitmap )->Manager()->

            GetContentDimensions( aContentDimensions );

        }

    else

        {

        aContentDimensions.SetDimensions(aBitmap->SizeInPixels());

        }

    return ret;

    }

// -----------------------------------------------------------------------------

// AknIconUtils::CreateIconL

// -----------------------------------------------------------------------------

//

EXPORT_C CAknIcon* AknIconUtils::CreateIconL( CAknIcon* aSourceIcon )

    {

    // Take ownership of aSourceIcon

    CleanupStack::PushL( aSourceIcon );

    TBool masked = reinterpret_cast<TBool>( aSourceIcon->Mask() );

    CAknIconManager* manager =

        new( ELeave ) CAknSourceBitmapIconManager( aSourceIcon );

    CleanupStack::Pop(); // aSourceIcon

    CleanupStack::PushL( manager );

    CFbsBitmap* bitmap = CAknBitmap::NewL( *manager );

    CleanupStack::Pop(); // manager - deleted from bitmap destructor from now on.

    CleanupStack::PushL( bitmap );

    CFbsBitmap* mask = NULL;

    if ( masked )

        {

        mask = CAknBitmap::NewL( *manager );

        }

    // Push also mask in cleanup stack always, even if NULL.

    CleanupStack::PushL( mask );

    manager->SetBitmap( static_cast<CAknBitmap*>( bitmap ) );

    manager->SetMask( static_cast<CAknBitmap*>( mask ) );

    // Bitmap icons are loaded during this call.

    // Scalable icons are set to valid CFbsBitmap handles of empty bitmaps.

    manager->PreinitializeIconL();

    CAknIcon* resultIcon = CAknIcon::NewL();

    resultIcon->SetBitmap( bitmap );

    resultIcon->SetMask( mask );

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

    return resultIcon;

    }

// -----------------------------------------------------------------------------

// AknIconUtils::CreateIconL

// -----------------------------------------------------------------------------

//

EXPORT_C CFbsBitmap* AknIconUtils::CreateIconL( CFbsBitmap* aSourceBitmap )

    {

    CleanupStack::PushL( aSourceBitmap );

    CAknIcon* sourceIcon = CAknIcon::NewL();

    CleanupStack::Pop(); // aSourceBitmap

    sourceIcon->SetBitmap( aSourceBitmap );

    CAknIcon* resultIcon = CreateIconL( sourceIcon );

    CFbsBitmap* resultBitmap = resultIcon->Bitmap();

    resultIcon->SetBitmap( NULL );

    delete resultIcon;

    return resultBitmap;

    }

// -----------------------------------------------------------------------------

// AknIconUtils::SetIconColor

// -----------------------------------------------------------------------------

//

EXPORT_C void AknIconUtils::SetIconColor( CFbsBitmap* aBitmap, const TRgb aColor )

    {

    __ASSERT_DEBUG( aBitmap,

        User::Panic( KAknIconPanicCategory, EInvalidParameter ) );

    // If value 0xFF000000 is supplied, change it to 0x00000000 (same RGB value),

    // since 0xFF000000 is reserved to indicate that the color is not defined.

    if ( aColor == KColorNotDefined ) // 0xFF000000

        {

        *const_cast<TRgb*>( &aColor ) = TRgb( 0x00000000 );

        }

    if ( IsAknBitmap( aBitmap ) )

        {

        static_cast<CAknBitmap*>( aBitmap )->Manager()->SetIconColor( aColor );

        }

    }

// -----------------------------------------------------------------------------

// AknIconUtils::ExcludeFromCache

// -----------------------------------------------------------------------------

//

EXPORT_C void AknIconUtils::ExcludeFromCache( CFbsBitmap* aBitmap )

    {

    __ASSERT_DEBUG( aBitmap,

        User::Panic( KAknIconPanicCategory, EInvalidParameter ) );

    if ( IsAknBitmap( aBitmap ) )

        {

        static_cast<CAknBitmap*>( aBitmap )->Manager()->ExcludeFromCache();

        }

    }

// -----------------------------------------------------------------------------

// AknIconUtils::DisableCompression

// -----------------------------------------------------------------------------

//

EXPORT_C  void AknIconUtils::DisableCompression( CFbsBitmap* aBitmap )

    {

  __ASSERT_DEBUG( aBitmap,

        User::Panic( KAknIconPanicCategory, EInvalidParameter ) );

    if ( IsAknBitmap( aBitmap ) )

        {

        static_cast<CAknBitmap*>( aBitmap )->Manager()->DisableCompression();

        }  

    }

// -----------------------------------------------------------------------------

// AknIconUtils::IsAknBitmap

// -----------------------------------------------------------------------------

//

TBool AknIconUtils::IsAknBitmap( const CFbsBitmap* aBitmap )

    {

    return AknInternalIconUtils::IsAknBitmap(aBitmap);

    }

// -----------------------------------------------------------------------------

// AknIconUtils::RotateAndScaleBitmapL

// -----------------------------------------------------------------------------

//

void AknIconUtils::RotateAndScaleBitmapL(

    const TRect& aTrgRect,

    CFbsBitmap* aTrgBitmap, 

    CFbsBitmap* aSrcBitmap,

    TInt aAngle )

    {

    aAngle = aAngle % 360;

    if (aAngle < 0)

        {

        aAngle+=360;

        }

    if( !aSrcBitmap ) User::Leave( KErrArgument );

    if( !aTrgBitmap ) User::Leave( KErrArgument );