/*

* 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 AknIconSrvUtils.

*

*/

// INCLUDE FILES

#include <fbs.h>

#include <gdi.h>

#include <bitdev.h>

#include <mifconvdefs.h>

#include "AknIconSrvUtils.h"

#include "AknIconFormatHandler.h"

#include "AknIconLoader.h"

#include "AknIconSrv.h"

#include "AknIconFormatHandlerFactory.h"

#include "AknIconSrvDef.h"

#include "AknBitmap.h"

// CONSTANTS

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

TPtrC8 AknIconSrvUtils::InitIconDataAndHandlerLC(

    CAknIconLoader* aLoader,

    RPointerArray<MAknIconFormatHandler>& aHandlerList,

    MAknIconFormatHandler*& aHandler,

    const TAknIconParams& aParams,

    TBool aAnimated )

    {

    CleanupStack::PushL( TCleanupItem( CleanupFreeIcon, aLoader ) );

    if ( aLoader->IconAnimatedL( aParams.iBitmapId ) && !aAnimated )

        {

        User::Leave( KAknIconSrvCodeAnimated );

        }

    TInt type = aLoader->IconTypeL( aParams.iBitmapId );

#ifdef _NGATESTING        

    type = aLoader->GetDerivedIconTypeL(type, aParams.iFileName);

#endif

    // Check if handler is already present, if so then return with same pointer

    for ( TInt lIndex = 0; lIndex < aHandlerList.Count(); lIndex++ )

        {

        if ( aHandlerList[ lIndex ]->IconFormatType() == type )

            {

            aHandler = aHandlerList[ lIndex ]; 

            break;

            }

        }

    // No Handler found, create one and add to list

    if ( !aHandler )

        {

        aHandler = AknIconFormatHandlerFactory::NewIconFormatHandlerL( type );

        aHandlerList.Append( aHandler );

        aHandler->SetAnimated( aAnimated );

        }

    return aLoader->IconL( aParams.iBitmapId );

    }

TPtrC8 AknIconSrvUtils::InitIconDataAndHandlerLC(

    CAknIconLoader* aLoader,

    MAknIconFormatHandler*& aHandler,

    TInt aIconId,

    TBool aAnimated )

    {

    CleanupStack::PushL( TCleanupItem( CleanupFreeIcon, aLoader ) );

    if ( aLoader->IconAnimatedL( aIconId ) && !aAnimated )

        {

        User::Leave( KAknIconSrvCodeAnimated );

        }

    TInt type = aLoader->IconTypeL( aIconId );

    if ( !aHandler )

        {

        aHandler = AknIconFormatHandlerFactory::NewIconFormatHandlerL( type );

        aHandler->SetAnimated( aAnimated );

        }

    return aLoader->IconL( aIconId );

    }

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

// AknIconSrvUtils::RenderPreparedIconL

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

//

TAknContentDimensions AknIconSrvUtils::RenderPreparedIconL(

    MAknIconFormatHandler& aHandler,

    CFbsBitmap* aBitmap,

    CFbsBitmap* aMask, // may be NULL

    TDisplayMode aBitmapDepth,

    TDisplayMode aPreferredDepth,

    const TSize& aSize,

    TScaleMode aMode,

    TInt aRotationAngle,

    TRgb aColor,

    TInt /*aBitmapId*/,

    TInt /*aMaskId*/,

    TBool isAppIcon)

    {

    TSize resultSize( aSize );

    CAknBitmap* aknIcon = CAknBitmap::DynamicCast(aBitmap);

    TAknContentDimensions dimensions;

    TBool dimensionsRetrieved = EFalse;

    if ( aMode == EAspectRatioPreservedAndUnusedSpaceRemoved )

        {

        if ( !resultSize.iWidth || !resultSize.iHeight )

            {

            resultSize.iWidth = 0;

            resultSize.iHeight = 0;

            }

        else

            {

            aHandler.GetContentDimensionsL( dimensions );

            dimensionsRetrieved = ETrue;

            GetAspectRatioPreservedSize( dimensions, resultSize );

            }

        }

    TDisplayMode definedDepth = aBitmapDepth;

    // Change display mode to the closest one supported by the engine.

    aHandler.SupportedDisplayMode( aBitmapDepth, aPreferredDepth );    

    CFbsBitmap* renderBitmap = aBitmap;

    // If EGray256 mode was defined, and the engine did not support it,

    // render the icon first in a temporary bitmap.

    if ( definedDepth == EGray256 && definedDepth != aBitmapDepth )

        {

        renderBitmap = new( ELeave ) CFbsBitmap;

        CleanupStack::PushL( renderBitmap );

        }

    User::LeaveIfError( renderBitmap->Create( resultSize, aBitmapDepth ) );

    if ( aMask )

        {

        // Always use soft masks with SVGs.

        User::LeaveIfError( aMask->Create( resultSize, EGray256 ) );

        }

    aHandler.SetScaleMode( aMode );

    aHandler.SetRotation( aRotationAngle );

    aknIcon = CAknBitmap::DynamicCast(aBitmap);

    aHandler.RenderPreparedIconL(renderBitmap, aMask ,resultSize, aBitmapDepth, EGray256,aColor, isAppIcon);

    // Copy from temp. render bitmap to real bitmap,

    // and convert display depth to EGray256.

    if ( renderBitmap != aBitmap )

        {

        User::LeaveIfError( aBitmap->Create( resultSize, EGray256 ) );

        CFbsBitmapDevice* dev = CFbsBitmapDevice::NewL( aBitmap );

        CleanupStack::PushL( dev );

        CFbsBitGc* gc = NULL;

        User::LeaveIfError( dev->CreateContext( gc ) );

        CleanupStack::PushL( gc );

        gc->BitBlt( TPoint( 0, 0 ), renderBitmap );

        CleanupStack::PopAndDestroy( 3 ); // renderBitmap, dev, gc

        }

    if ( !dimensionsRetrieved )

        {

        aHandler.GetContentDimensionsL( dimensions );

        }

    return dimensions;

    }

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

// AknIconSrvUtils::GetAspectRatioPreservedSize

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

//

void AknIconSrvUtils::GetAspectRatioPreservedSize(

    const TAknContentDimensions& aDimensions,

    TSize& aSize )

    {

    if ( !aDimensions.iWidth || !aDimensions.iHeight )

        {

        aSize.iWidth = 0;

        aSize.iHeight = 0;

        }

    else

        {

        if ( aSize.iWidth > KMaxTInt16 )

            {

            aSize.iWidth = KMaxTInt16;

            }

        if ( aSize.iHeight > KMaxTInt16 )

            {

            aSize.iHeight = KMaxTInt16;

            }

        TReal32 xScaleFactor = (TReal32)(aSize.iWidth) / aDimensions.iWidth;

        TReal32 yScaleFactor = (TReal32)(aSize.iHeight) / aDimensions.iHeight;

        if ( xScaleFactor > yScaleFactor )

            {

            TReal32 width = aDimensions.iWidth * yScaleFactor; 

            aSize.iWidth = width;

            if ( width - aSize.iWidth > 0 ) //rounding

                {

                aSize.iWidth++;

                }

            }

        else

            {

            TReal32 height = aDimensions.iHeight * xScaleFactor;

            aSize.iHeight = height;

            if ( height - aSize.iHeight > 0 ) //rounding

                {

                aSize.iHeight++;

                }

            }

        }

    }

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

// AknIconSrvUtils::GetAspectRatioPreservedSize

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

//

void AknIconSrvUtils::GetAspectRatioPreservedSize(

    const TSize& aDimensions,

    TSize& aSize,

    TBool aFitToOriginalSize )

    {

    if ( !aDimensions.iWidth || !aDimensions.iHeight )

        {

        aSize.iWidth = 0;

        aSize.iHeight = 0;

        }

    else

        {

        if ( aSize.iWidth > KMaxTInt16 )

            {

            aSize.iWidth = KMaxTInt16;

            }

        if ( aSize.iHeight > KMaxTInt16 )

            {

            aSize.iHeight = KMaxTInt16;

            }

        TInt xScaleFactor = (aSize.iWidth << 16) / aDimensions.iWidth;

        TInt yScaleFactor = (aSize.iHeight << 16) / aDimensions.iHeight;

        TBool chooseWidthScaling = (xScaleFactor > yScaleFactor);

        if (!aFitToOriginalSize)

            {

            chooseWidthScaling = !chooseWidthScaling;

            }

        if ( chooseWidthScaling )

            {

            aSize.iWidth = aDimensions.iWidth * yScaleFactor;

            TBool rounding = aSize.iWidth & 0x8000;

            aSize.iWidth >>= 16;

            if ( rounding )

                {

                aSize.iWidth++;

                }

            }

        else

            {

            aSize.iHeight = aDimensions.iHeight * xScaleFactor;

            TBool rounding = aSize.iHeight & 0x8000;

            aSize.iHeight >>= 16;

            if ( rounding )

                {

                aSize.iHeight++;

                }

            }

        }

    }    

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

// AknIconSrvUtils::ScaleBitmapIconL

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

//

TBool AknIconSrvUtils::ScaleBitmapIconL(

    const TSize& aSize,

    const TScaleMode aMode,

    const TInt aAngle,

    const TRgb aColor,

    CFbsBitmap* aSourceBitmap,

    CFbsBitmap* aSourceMask,

    CFbsBitmap* aTargetBitmap,

    CFbsBitmap* aTargetMask )

    {

    TSize scaledSize( aSize );

    TSize originalSize(aSourceBitmap->SizeInPixels());

    TBool colorIcon = aColor != KColorNotDefined;

    // Find out the scaled size according to the given scale mode.

    // Note:In scaling mode EAspectRatioPreservedSlice no need to calculate scaledSize for color icons.

    if ( aMode != EAspectRatioNotPreserved && (aMode != EAspectRatioPreservedSlice || !colorIcon))

        {

        AknIconSrvUtils::GetAspectRatioPreservedSize( originalSize, scaledSize, aMode != EAspectRatioPreservedSlice );

        }

    const TSize& bitmapSize =

        aMode == EAspectRatioPreservedAndUnusedSpaceRemoved ?

        scaledSize : aSize;    

    TDisplayMode colorDepth = colorIcon ?

        EColor64K : aSourceBitmap->DisplayMode();

    User::LeaveIfError( aTargetBitmap->Create( bitmapSize, colorDepth ) );

    // Icon should be centered, so calculate x and y margins.

    TInt xMargin = ( bitmapSize.iWidth - scaledSize.iWidth ) / 2;

    TInt yMargin = ( bitmapSize.iHeight - scaledSize.iHeight ) / 2;

    // Target rect inside the target bitmap.

    TRect targetRect( xMargin, yMargin,

        xMargin + scaledSize.iWidth, yMargin + scaledSize.iHeight );

    // Decide if fallback should be forced in ScaleBitmapExtL calls

    TBool forceFallBack = EFalse;

    if ( !colorIcon && aSourceBitmap && !aAngle )

        {

        forceFallBack = AknIconUtils::DoesScaleBitmapUseFallBack( aSourceBitmap );

        }

    if ( aSourceMask && aTargetMask && !aAngle )

        {

        forceFallBack = forceFallBack || AknIconUtils::DoesScaleBitmapUseFallBack( aSourceMask );

        }

    // If color icon, just fill the bitmap with the defined color.

    if ( colorIcon )

        {

        CFbsBitmapDevice* dev = CFbsBitmapDevice::NewL( aTargetBitmap );

        CleanupStack::PushL( dev );

        CFbsBitGc* gc = NULL;

        User::LeaveIfError( dev->CreateContext( gc ) );

        CleanupStack::PushL( gc );

        gc->SetBrushColor( aColor );

        gc->SetPenStyle( CGraphicsContext::ENullPen );

        gc->SetBrushStyle( CGraphicsContext::ESolidBrush );

        // Fill icon with the given color, mask defines the icon shape.

        gc->DrawRect( TRect( TPoint( 0, 0 ), bitmapSize ) );

        CleanupStack::PopAndDestroy( 2 ); // dev, gc

        }

    // Otherwise, perform bitmap scaling and rotation as required.

    else

        {

        if ( !aAngle )

            {

            AknIconUtils::ScaleBitmapExtL( targetRect, aTargetBitmap, aSourceBitmap, forceFallBack );

            }

        else

            {

            AknIconUtils::RotateAndScaleBitmapL( 

                targetRect,

                aTargetBitmap,

                aSourceBitmap,

                aAngle );

            }

        }

    // Optional mask is always scaled and rotated as required.

    if ( aSourceMask && aTargetMask)

        {

        User::LeaveIfError(aTargetMask->Create( bitmapSize, aSourceMask->DisplayMode() ) );

        // If target mode is EAspectRatioPreserved, there may be unused parts

        // in the bitmap, so need to initialize soft masks black before scaling.

        if ( aMode == EAspectRatioPreserved && aTargetMask->DisplayMode() == EGray256 )

            {

            CFbsBitmapDevice* dev = CFbsBitmapDevice::NewL( aTargetMask );

            CleanupStack::PushL( dev );

            CFbsBitGc* gc = NULL;

            User::LeaveIfError( dev->CreateContext( gc ) );

            CleanupStack::PushL( gc );

            gc->SetBrushColor( KRgbBlack );

            gc->SetBrushStyle( CGraphicsContext::ESolidBrush );

            gc->Clear();

            CleanupStack::PopAndDestroy(2); // dev, gc

            }

        if ( !aAngle )

            {

            AknIconUtils::ScaleBitmapExtL( targetRect, aTargetMask, aSourceMask, forceFallBack );

            }

        else

            {

            AknIconUtils::RotateAndScaleBitmapL( 

                targetRect,

                aTargetMask,

                aSourceMask,

                aAngle );

            }

        }

    return colorIcon;    

    }

LOCAL_C TInt CheckTransparency(const CFbsBitmap* aBmp, TDes8& aBuffer, TInt aMask, TDisplayMode aMode)

    {

    // Note: The following calculations use the below notation.

    //

    //     Ha = Actual height of the bitmap

    //     hTa = Height of the transparent region at the bottom of the bitmap

    //     hNT = Height of the non-transparent region in the bitmap

    //     Therefore, Ha = hNT + 2 * hTa

    // 

    //     hNTN = New height of the non-transparent region after accomodating 

    //            for the 12% transparent margins(bottom)

    //       HaN = New needed height of the bitmap to adjust the transparent area 

    //           at the bottom to 12%

    //     R = Ratio of hNTN / hNT 

    //     C = 2 * hTa

    //     HaN = Ha * R - C * R + C

    //

    //     This means that if the transparent margins are already 12% then 

    //     R becomes 1 in the above equation and it reduces to 

    //         HaN = Ha

    //     If R becomes > 1 i.e. hNTN > hNT, then it would be clipped to 1.

    const TSize& sz = aBmp->SizeInPixels();	

	const TInt lValidMargin = sz.iHeight * 12 / 100; 

    const TInt Ha = sz.iHeight;

    TInt hTa = 0;

    TInt hNT = 0;

    TInt C = 0;

    TInt hNTN = Ha - 2.0 * 0.12 * Ha;

    TReal R = 1.0;

    TInt HaN = Ha;

	switch(aMode)

	   {

	   case EGray256: // for mask 

	      {

	      const TInt lastColumn = sz.iWidth - 1;

	   	  const TUint8* ptr8 = reinterpret_cast<const TUint8*> (aBuffer.Ptr());

	      for ( TInt curRow = 0; curRow < lValidMargin; curRow++ )

		     {

		     const TInt y = (sz.iHeight - 1) - curRow; // h - 1 is the last line

		     aBmp->GetScanLine(aBuffer, TPoint(0, y), sz.iWidth, aMode);

		     for ( TInt s = lastColumn; s >= 0; --s )

			   {

			   TUint8 lPixel = aBuffer[s];

			   if ( aBuffer[s] & (TUint8)aMask ) //note that mask is inverted

			      {

				  hTa = curRow;

				  hNT = Ha - 2 * hTa;

				  C = 2 * hTa;

				  R = ( ( (TReal)hNTN / (TReal)hNT ) > 1.0 ) ? 1 : (TReal)hNTN / (TReal)hNT;

				  HaN = Ha * R - C * R + C;

			//	  HaN =( 0.88 * Ha) + hTa;

			      return( HaN );

				  }

			   }

		     }	

	   	  }

	   break;

	   case EColor16MA:

	   	  {

	   	  const TInt lastColumn = aBuffer.MaxLength() / sizeof(TUint32) - 1;

	   	  const TUint32* ptr = reinterpret_cast<const TUint32*> (aBuffer.Ptr());

	      for ( TInt curRow = 0; curRow < lValidMargin; curRow++ )

		     {

		     const TInt y = (sz.iHeight - 1) - curRow; // h - 1 is the last line

		     aBmp->GetScanLine(aBuffer, TPoint(0, y), sz.iWidth, aMode);

		     for ( TInt s = lastColumn; s >= 0; --s )

			    {

			    if ( ptr[s] & aMask ) //note that mask is inverted

				   {

				   hTa = curRow;

				   hNT = Ha - 2 * hTa;

				   C = 2 * hTa;

				   R = ( ( (TReal)hNTN / (TReal)hNT ) > 1.0 ) ? 1 : (TReal)hNTN / (TReal)hNT;

				   HaN = Ha * R - C * R + C;

			//	   HaN =( 0.88 * Ha) + hTa;

			       return( HaN );

                   }

			    }

		     }

	   	   }

	   break;

	   default:

	   break;

	   }

    return HaN;

    }

TInt AknIconSrvUtils::CheckMaskTransparencyL(const CFbsBitmap* aBmp)

	{

	const TSize& sz = aBmp->SizeInPixels();

	HBufC8* buffer = HBufC8::NewLC(sz.iWidth);