/*

* 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:  Implementation of class CAknIconManager.

*

*/

// INCLUDE FILES

#include <mifconvdefs.h>

#include "AknIconManager.h"

#include "AknIconSrvDef.h"

#include "AknIconFormatHandler.h"

#include "AknIconFormatHandlerFactory.h"

#include "AknIconSrvClient.h"

#include "AknBitmap.h"

#include "AknIconSrv.h"

#include "AknIconSrvTlsData.h"

#include "AknIconLoader.h"

#include "AknIconSrvUtils.h"

#include "AknIconLocationInfo.h"

#include "AknIconTraces.h"

#include "AknIconFileNameCache.h"

#include <bitdev.h>

#include <e32math.h> // for Math::Frac()

// CONSTANTS

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

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

// CAknIconManager::CAknIconManager

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CAknIconManager::CAknIconManager() : 

    iInitializedSize( -1, -1 ),

    iInitializedMode( -1 ),

    iInitializedColor(KColorNotDefined),

    iColor( KColorNotDefined ),

    iContentDimensions( -1, -1 ),

    iAppIcon(EFalse)

	{

	}

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

// CAknIconManager::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CAknIconManager::ConstructL(

    const TDesC& aFileName, const TInt16 aBitmapId, const TInt16 aMaskId )

    {

    iBitmapId = aBitmapId;

    iMaskId = aMaskId;

#ifdef __AKNICON_TRACES

    RDebug::Print( _L("AknIcon: %x CAknIconManager::ConstructL - iBitmapId=%d, iMaskId=%d"), this, iBitmapId, iMaskId);

#endif    

    TFileName fileName;

    const TDesC* usedFileName = &aFileName;

    // This check is to support compatibility with CEikonEnv::CreateBitmapL

    if ( !aFileName.Length() )

        {

        usedFileName = &AknIconUtils::AvkonIconFileName();

        }

    // Drive not defined? If so, check in all drives, Z: first.

    else if ( aFileName.Length() < 2 || aFileName[1] != KDriveDelimiter )

        {

        fileName = aFileName;

        ChangeFileExtension( fileName );

        CAknIconSrvTlsData* data = static_cast<CAknIconSrvTlsData*>( Dll::Tls() );

        TFindFile* find = new( ELeave ) TFindFile( data->FsSessionL() );

        CleanupStack::PushL( find );

        User::LeaveIfError( find->FindByDir( fileName, KDriveZ ) );

        fileName = find->File();

        CleanupStack::PopAndDestroy(); // find

        usedFileName = &fileName;

        }

    InitIconFileNameL(*usedFileName);

    }

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

// CAknIconManager::InitIconFileNameL

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

//

void CAknIconManager::InitIconFileNameL( const TDesC& aFileName )

    {

    CAknIconSrvTlsData* data = static_cast<CAknIconSrvTlsData*>( Dll::Tls() );

    TPtrC usedFileName = aFileName;

    // Check for the default icon dir. It is indicated with a flag, to save RAM.

    if ( usedFileName.Length() >= KAknIconDefaultDirLength &&

         usedFileName.Left( KAknIconDefaultDirLength ).CompareF( 

            KAknIconDefaultDir ) == 0 )

        {

        SetDefaultIconDirUsed();

        usedFileName.Set(usedFileName.Mid( KAknIconDefaultDirLength ));

        }

    // remove file extension to save RAM by eliminating storing redundant file names

    // in TLS data

    if (HasValidFileExtension(usedFileName))    

        {

        usedFileName.Set(usedFileName.Left( usedFileName.Length() - KExtensionLength ));

        SetFileExtRemoved();

        }

    // cache icon file name        

    iFileName = data->IconFileNameCache().CacheIconFileNameL(usedFileName);

    }

CAknIconManager* CAknIconManager::NewL(

    const TDesC& aFileName, const TInt16 aBitmapId, const TInt16 aMaskId )

    {

    CAknIconManager* self = new( ELeave ) CAknIconManager();

    CleanupStack::PushL( self );

    self->ConstructL( aFileName, aBitmapId, aMaskId );

    CleanupStack::Pop();

    return self;

    }

// Destructor

CAknIconManager::~CAknIconManager()

    {

    DestroyIconData();

    delete iHandler;

    }

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

// CAknIconManager::PreinitializeIconL

// Does the initializations that are done during AknIconUtils::CreateIconL(C)

// calls, i.e. before AknIconUtils::SetSize has been called.

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

//

void CAknIconManager::PreinitializeIconL()

    {

    // Releases the icon file handle, if opened.

    CleanupStack::PushL( TCleanupItem( CleanupReleaseFileHandle, this ) );    

    RetrieveIconLocationInfoL();

    LoadIfBitmapIconL();

    CleanupStack::PopAndDestroy(); // CleanupReleaseFileHandle

    }

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

// CAknIconManager::LoadIfBitmapIconL

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

//

void CAknIconManager::LoadIfBitmapIconL()

    {

    if ( IsMbmIcon() )

        {

        /**

        * CAknBitmap::Reset needs to be called always before calling

        * CFbsBitmap::Load or CFbsBitmap::Duplicate.

        */

        iBitmap->Reset();

        if ( iMask )

            {

            iMask->Reset();

            }

        LoadBitmapIconL(); // virtual function call

        // None of the scale modes was used - just plain load.

        iInitializedMode = -1; 

        iLoadedSize = iBitmap->SizeInPixels();

        }

    }

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

// CAknIconManager::InitializeIcon

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

//

TInt CAknIconManager::InitializeIcon( const TSize& aSize, TScaleMode aMode )

    {

    return InitializeIcon( aSize, aMode, 0 );

    }

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

// CAknIconManager::InitializeIcon

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

//

// This method resizes both scalable and bitmap icons.

//

TInt CAknIconManager::InitializeIcon( 

    const TSize& aSize,

    TScaleMode aMode,

    TInt aAngle )

    {

#ifdef __AKNICON_TRACES

    RDebug::Print( _L("AknIcon: %x Calling CAknIconManager::InitializeIcon - Icon size (%d,%d), Mode=%d, Angle=%d"),

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

#endif    

    // If already initialized with the same parameters, do nothing.

    if ( iBitmap->Handle() )

        {

        // MBM icon

        if ( IsMbmIcon() )

            {

            if ( (iInitializedMode < 0 && iBitmap->SizeInPixels() == aSize && !iBitmap->IsAppIcon() && !aAngle && iColor == KColorNotDefined ) ||

                 (iInitializedMode == aMode &&

                  iInitializedSize == aSize && 

                  iInitializedAngle == aAngle &&

                  iInitializedColor == iColor) )

                {

                return KErrNone;

                }

            }

        // MIF icon

        else

            {

            if ( iInitializedMode == aMode && 

                 iInitializedSize == aSize &&

                 iInitializedAngle == aAngle &&

                 iInitializedColor == iColor)

                {

                return KErrNone;

                }

            }

        }

    // TRAP all leaving code and handle error in the end.

    TRAPD( err,

        {

        InitializeIconL(

            aSize,

            aMode,

            aAngle );

        } );

    HandleError( err );

#ifdef __AKNICON_TRACES

    RDebug::Print( _L("AknIcon: %x CAknIconManager::InitializeIcon called - return: %d"), this, err);

#endif    

    return err;

    }

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

// CAknIconManager::InitializeIconL

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

//

void CAknIconManager::InitializeIconL(

    const TSize& aSize,

    TScaleMode aMode,

    TInt aAngle )

    {

#ifdef __AKNICON_TRACES

    TSize oldSize = iBitmap->SizeInPixels();

    if ( oldSize != TSize( 0, 0 ) &&

         oldSize != iLoadedSize )

        {

        HBufC* buf = HBufC::New( 1024 );

        if ( buf )

            {

            TPtr ptr = buf->Des();

            ptr.Copy( _L("AknIcon WARNING: icon size changed (") );            

            ptr.AppendNum( oldSize.iWidth );

            ptr.Append( _L(", ") );

            ptr.AppendNum( oldSize.iHeight );

            ptr.Append( _L(") -> (") );

            ptr.AppendNum( aSize.iWidth );

            ptr.Append( _L(", ") );

            ptr.AppendNum( aSize.iHeight );

            ptr.Append( _L(")") );

            RDebug::Print( ptr );

            ptr.Zero();

            if (iFileName)

            	{

            	GetFullFileName( ptr );

            	}

            ptr.Append( _L(", bitmap ID = ") );

            ptr.AppendNum( iBitmapId );

            ptr.Append( _L(", mask ID = ") );

            ptr.AppendNum( iMaskId );

            RDebug::Print( ptr );

            delete buf;

            }

        }

#endif

    DoInitializeIconL( aSize, aMode, aAngle ); // virtual function call

    }

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

// CAknIconManager::GetContentDimensions

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

//

TInt CAknIconManager::GetContentDimensions( TAknContentDimensions& aContentDimensions )

    {

    TRAPD( ret, GetContentDimensionsL( aContentDimensions ) );

    return ret;

    }

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

// CAknIconManager::GetContentDimensionsL

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

//

void CAknIconManager::GetContentDimensionsL( TAknContentDimensions& aContentDimensions )

    {

    // Releases the icon file handle, if opened.

    CleanupStack::PushL( TCleanupItem( CleanupReleaseFileHandle, this ) );

    // MBM icon

    if ( IsMbmIcon() )

        {

        // If not loaded at all yet, do it now.

        if ( !iBitmap->Handle() )

            {

            LoadIfBitmapIconL();

            }

        aContentDimensions.SetDimensions(iLoadedSize);

        }

    else if ( iContentDimensions.iWidth < 0 )

        {

	    // Server-shared MIF icon (not animated)

		if ( !IsAnimated() )

			{

		    // Never returns NULL.

		    RAknIconSrvClient* client = RAknIconSrvClient::GetSession();

		    TInt ret = client->GetContentDimensions( *iBitmap, aContentDimensions );

		    if ( ret == KAknIconSrvCodeAnimated )

		        {

#ifdef __AKNICON_TRACES

		    RDebug::Print( _L("AknIcon: %x In DoInitializeIconL animated icon"), this);

#endif    	        

		        SetAnimated();

		        }

		    else

		        {

		        User::LeaveIfError( ret );

		        }

	        }

		// Animated MIF icon

		if ( IsAnimated())

		    {

		        // Prepare icon if not done yet.

		        if ( !iHandler )

		            {

					PrepareAnimatedIconL();

		            }

		        iHandler->GetContentDimensionsL( aContentDimensions );

		        // free resources

		        DeleteIconFormatHandler();

		    }

		// Store content dimensions in this class.

		iContentDimensions = aContentDimensions;

		}

    // Content dimensions already retrieved.

    else

        {

        aContentDimensions = iContentDimensions;

        }

    CleanupStack::PopAndDestroy(); // CleanupReleaseFileHandle

    }

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

// CAknIconManager::HandleError

// Handles errors occurred in icon initialization (SetSize).

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

//

void CAknIconManager::HandleError( TInt aError )

    {

    if ( aError != KErrNone )

        {

        iBitmap->Reset();

        if ( iMask )

            {

            iMask->Reset();

            }

        // Clear the information of the

        // initialisation status parameters.    

        iInitializedMode = -1;

        iInitializedSize = ( TSize( -1, -1 ) );

        iInitializedAngle = 0;

        }

    }

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

// CAknIconManager::PreserveIconData

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

//

void CAknIconManager::PreserveIconData()

    {

    if ( !IsMbmIcon() && !IsIconDataPreserved() )

        {

        // Never returns NULL.

        RAknIconSrvClient* client = RAknIconSrvClient::GetSession();

        TInt ret = client->PreserveIconData( *iBitmap->Manager() );

        // Release the icon file handle, if opened.

        ReleaseFileHandle();

        if ( ret == KErrNone )

            {

            SetIconDataPreserved();

            }

        else if ( ret == KAknIconSrvCodeAnimated )

            {

            SetAnimated();

            }

        }

    }

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

// CAknIconManager::DestroyIconData

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

//

void CAknIconManager::DestroyIconData()

    {

    if ( IsIconDataPreserved() )

        {

        ClearIconDataPreserved();

        // Never returns NULL.

        RAknIconSrvClient* client = RAknIconSrvClient::GetSession();

        client->DestroyIconData( *this );

        }

    }

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

// CAknIconManager::SetIconColor

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

//

void CAknIconManager::SetIconColor( const TRgb aColor )

    {

    iColor = aColor;

    }

TRgb CAknIconManager::GetIconColor() const

    {

    return iColor;

    }

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

// CAknIconManager::GetFileName

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

//

void CAknIconManager::GetFileName( TDes& aFileName ) const

    {

    aFileName = *iFileName;

    AppendFileExtension( aFileName );

    }

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

// CAknIconManager::GetFullFileName

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

//

void CAknIconManager::GetFullFileName( TDes& aFileName ) const

    {

    if ( IsDefaultIconDirUsed() )

        {

        aFileName = KAknIconDefaultDir;

        }

    aFileName.Append( *iFileName );

    AppendFileExtension( aFileName );

    }

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

// CAknIconManager::GetFullMifFileName

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

//

void CAknIconManager::GetFullMifFileName( TDes& aFileName ) const

    {

    if ( IsDefaultIconDirUsed() )

        {

        aFileName = KAknIconDefaultDir;

        }

    aFileName.Append( *iFileName );

    if ( IsFileExtRemoved())

        {                

        aFileName.Append( KMifExtension );

        }    

    }

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

// CAknIconManager::Ref

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

//

void CAknIconManager::Ref()

    {

    iRefCount++;

    }

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

// CAknIconManager::Unref

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

//

void CAknIconManager::Unref(const CAknBitmap& aBitmap)

    {

    if ( --iRefCount == 0 )

        {