/*

* 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:   Utility for loading skin graphics.

*

*/

#include "alf/alfimageloaderutil.h"

#include "alf/alfbitmapprovider.h"

#include "alf/alfstatic.h"

#include "alf/alfenv.h"

#include <SVGEngineInterfaceImpl.h>

#include <SVGRequestObserver.h>

#include <AknsItemData.h>

#include <AknsUtils.h>

#include <uiacceltk/HuiUtil.h>

// Set this flag to ETrue if autosize textures need to be exluded from Avkon

// icon cache, e.g. because it get filled with different size variants of same icon.

// Excluding is likely to decrease texture upload performance.

const TBool KExcludeAutosizeTextureIconsFromAvkonIconCache = EFalse;

const TInt KSkinFrameBorderWidthDefaultValue = 8;

const TInt KSkinFrameBorderWidthSmallValue = 4;

const TInt KSkinFrameBorderWidthSmallestValue = 1;

const TInt KSkinFrameWidthMinValue = 1;

const TInt KAlfImageLoaderDefaultWidth = 4;

const TInt KAlfImageLoaderDefaultHeight = 4;

const TScaleMode KAlfImageLoaderDefaultScaleMode = EAspectRatioPreserved;

struct TAlfProvidedBitmap

    {

    TInt iId;

    TSize iPreferredSize;        

    };

/**

 * Base class of the image loader classes

 */

class CAlfImageLoader: public CBase, public MAlfBitmapProvider, public MAlfTextureAutoSizeObserver

	{

public:

	CAlfImageLoader();

    ~CAlfImageLoader();

    /**

     * Set size of the icon. This must be called before creating texture.

     * This call only sets information and dees *NOT* cause any scalable icon rasterization.

     *

     * @param aSize     Size in pixel.

     */

	void SetSize(TSize aSize) {iSize = aSize;}

	void SetScaleMode(TScaleMode aScaleMode) {iScaleMode = aScaleMode;}

    /**

     * Set skin instance, which is acquired from AknsUtils::SkinInstance().

     *

     * @param aSkinInstance     An Avkon skin instamce.

     */

	void SetSkinInstance(MAknsSkinInstance *aSkinInstance) {iSkinInstance = aSkinInstance;}

public:

    // From MHuiBitmapProvider

	virtual void ProvideBitmapL (TInt aId, CFbsBitmap *& aBitmap, CFbsBitmap *& aMaskBitmap) ;

    // From MHuiTextureAutoSizeObserver

    virtual TBool PreferredSizeChanged(const CAlfTexture& aChangedTexture, TSize aPreferredSize);

protected:

	MAknsSkinInstance* GetValidSkinInstance();

    TSize PreferredSize(TInt aId) const;

protected:

	// common source info data

	MAknsSkinInstance *iSkinInstance;

	TSize iSize;

	TScaleMode iScaleMode;

	RArray<TAlfProvidedBitmap> iProvidedBitmaps;

	TBool iExcludeFromAvkonIconCache;

	};

/**

 * Image loader utility for skin item image loading.

 *

 */

NONSHARABLE_CLASS(CAlfSkinItemImageLoader): public CAlfImageLoader

{

public:

    /**

     * Default constructor      

     */

    CAlfSkinItemImageLoader();

    /**

     * Construct an icon source information with Avkon skin item ID. AknsUtils::CreateIconL()

     * will be called in RAlfImageLoaderUtil::CreateIconL().

     *

     * @param aInstance     Skin instance.

     * @param aID  An ID of the graphical item (e.g. an icon).

     * @param aBitmapId  ID of the bitmap when fallback is used.

     * @param aMaskId  ID of the mask bitmap when fallback is used.

     */

    CAlfSkinItemImageLoader( const TAknsItemID &aID, TInt aBitmapId, TInt aMaskId );

    /**

     * Construct an icon source information with Avkon skin item ID. AknsUtils::CreateIconL()

     * will be called in RAlfImageLoaderUtil::CreateIconL().

     *

     * @param aFileName  File name of graphics file e.g. mif file) when sepcified item is not found in the current skin.

     */

	void ConstructL( const TDesC &aFileName );

	/**

     * Destructor

     */		

	~CAlfSkinItemImageLoader();

    /**

     * Implementation of MAlfBitmapProvider interface.

     *

     * @param aId     A unique ID of the texture needed to provide bitmaps.

     * @param aBitmap     A bitmap.

     * @param aMaskBitmap     A mask bitmap.

     */

	virtual void ProvideBitmapL (TInt aId, CFbsBitmap *& aBitmap, CFbsBitmap *& aMaskBitmap) ;

protected:

	TAknsItemID iId;

	HBufC* iFileName;

	TInt iBitmapId;

	TInt iMaskId;

};

/**

 * Image loader utility for skin frame item image loading.

 *

 */

NONSHARABLE_CLASS(CAlfSkinFrameItemImageLoader): public CAlfSkinItemImageLoader

{

public:

    enum TFrameParts

            {

            EFramePartCornerTl = 0,

            EFramePartCornerTr,

            EFramePartCornerBl, 

            EFramePartCornerBr,

            EFramePartSideT,

            EFramePartSideB,

            EFramePartSideL,

            EFramePartSideR,

            EFramePartCenter

            };

    /**

     * Create MAlfBitmapProvider instance to load frame image with Avkon skin item ID.

     * @param aFrameID  An Akvon skin item ID of the graphical frame item to load.

     * @param aInnerRect Inner rect of the frame

     * @param aOuterRect Outer rect of the frame

     */

    CAlfSkinFrameItemImageLoader( const TAknsItemID &aFrameID, const TRect& aInnerRect, const TRect& aOuterRect );

    /**

     * Construct an icon source information with Avkon skin item ID. AknsUtils::CreateIconL()

     * will be called in RAlfImageLoaderUtil::CreateIconL().

     *

     * @param aFileName  File name of graphics file e.g. mif file) when sepcified item is not found in the current skin.

     * @param aBitmapId  ID of the bitmap when fallback is used.

     * @param aMaskId  ID of the mask bitmap when fallback is used.

     */

	void ConstructL( const TDesC &aFileName, TInt aBitmapId, TInt aMaskId );

	/**

     * Destructor

     */		

	~CAlfSkinFrameItemImageLoader();

    /**

     * Implementation of MAlfBitmapProvider interface.

     *

     * @param aId     A unique ID of the texture needed to provide bitmaps.

     * @param aBitmap     A bitmap.

     * @param aMaskBitmap     A mask bitmap.

     */

	virtual void ProvideBitmapL (TInt aId, CFbsBitmap *& aBitmap, CFbsBitmap *& aMaskBitmap) ;

private:

    TSize GetFramePartSize(const TFrameParts aFramePart, const TSize& aFullFrameSize) const;

    TPoint GetFramePartPos(const TFrameParts aFramePart, const TSize& aFullFrameSize) const;

    TRect AdjustedOuterRect(const TSize& aFullFrameSize) const;

    TRect AdjustedInnerRect(const TSize& aFullFrameSize) const;

    TInt FrameBorderWidth() const;

private:

    TRect iInnerRect; 

    TRect iOuterRect;

};

/**

 * Image loader utility for loading Svg Images

 *

 */

NONSHARABLE_CLASS(CAlfSvgImageLoader): public CAlfImageLoader, public MSvgRequestObserver

{

public:

    /**

     * Construct an SVG loader

     *

     * @param aSVGFile     Svg File name.     

     */

    static CAlfSvgImageLoader* NewLC(const TDesC& aSVGFile); 

    /**

     * Destructor

     */		

	~CAlfSvgImageLoader();

    /**

     * Implementation of MAlfBitmapProvider interface.

     *

     * @param aId     A unique ID of the texture needed to provide bitmaps.

     * @param aBitmap     A bitmap.

     * @param aMaskBitmap     A mask bitmap.

     */

	virtual void ProvideBitmapL (TInt aId, CFbsBitmap *& aBitmap, CFbsBitmap *& aMaskBitmap) ;

    /**

     * Implementation of MSvgRequestObserver interface. - UpdateScreen

     */

	void UpdateScreen();

    /**

     * Implementation of MSvgRequestObserver interface. - ScriptCall

     */	

	TBool ScriptCall( const TDesC& aScript,CSvgElementImpl* aCallerElement );

    /**

     * Implementation of MSvgRequestObserver interface.- FetchImage

     */	

    TInt FetchImage( const TDesC& aUri, RFs& aSession, RFile& aFileHandle );

    /**

     * Implementation of MSvgRequestObserver interface.-UpdatePresentation

     */    

    void UpdatePresentation(const TInt32&  aNoOfAnimation);

    /**

     * Implementation of MSvgRequestObserver interface.-FetchFont

     */    

    TInt FetchFont( const TDesC& aUri, RFs& aSession, RFile& aFileHandle );	

private:	

	CAlfSvgImageLoader();

	void ConstructL(const TDesC& aSVGFile);

	void LoadSVGFileL(TInt aId);

private:

    CSvgEngineInterfaceImpl* iSvgEngine;//owned

    CFbsBitmap* iBitmap;//not owned

    CFbsBitmap* iMask; //not owned

    CFbsBitmap* iDummyBitmap;//owned

    HBufC* iFileName;

};

CAlfSvgImageLoader::~CAlfSvgImageLoader()

{

	delete iSvgEngine;

    delete iDummyBitmap;

    delete iBitmap;

    delete iMask; 	

    delete iFileName;

}

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

// CSVGPerfTestAppView::UpdateScreen

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

//

void CAlfSvgImageLoader::UpdateScreen()

    {

    }

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

// CSVGPerfTestAppView::ScriptCall

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

//

TBool CAlfSvgImageLoader::ScriptCall(

    const TDesC& /*aScript*/,

    CSvgElementImpl* /*aCallerElement*/ )

    {

    return EFalse;

    }

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

// CAlfSvgImageLoader::FetchImage

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

//

TInt CAlfSvgImageLoader:: FetchImage(

    const TDesC& /*aUri*/, RFs& /*aSession*/, RFile& /*aFileHandle*/ )

    {

    return KErrNotSupported;

    }

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

// CSVGPerfTestAppView::UpdatePresentation

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

//

void CAlfSvgImageLoader::UpdatePresentation(

    const TInt32& /*aNoOfAnimation*/ )

    {

    }

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

// CAlfSvgImageLoader::UpdatePresentation

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

//    

TInt CAlfSvgImageLoader::FetchFont( const TDesC& /*aUri*/, RFs& /*aSession*/, RFile& /*aFileHandle*/ )

    {

    return KErrNotSupported;

    }   

void CAlfSvgImageLoader::LoadSVGFileL(TInt aId)

{

  	// delete previous content

	delete iBitmap;

	iBitmap = NULL;

	delete iMask;

	iMask = NULL;

	// create frame and frame mask buffers		

	iBitmap = new( ELeave ) CFbsBitmap;

	User::LeaveIfError( iBitmap->Create( PreferredSize(aId), EColor64K ) );

	iMask = new( ELeave ) CFbsBitmap;

	User::LeaveIfError( iMask->Create( PreferredSize(aId), EGray256 ) );

    // If filename does not contain full path, then prepend the path from 

    // primary envs default texture manager.

    TFileName filename;

    TParsePtrC parse(*iFileName);

    if (!parse.DrivePresent())

        {

        filename.Append(CAlfStatic::Env().TextureManager().ImagePath());        

        }    

    filename.Append(*iFileName);

	// Load and render SVG file

	TInt handle = 0;

	iSvgEngine->PrepareDom( filename, handle ) ;

	iSvgEngine->UseDom( handle, iBitmap, iMask );

	// check the aspect ratio (taken from AknSvgFormatHandler.cpp)

	TSvgPreserveAspectAlignType alignTypeValue = ESvgPreserveAspectRatio_XmidYmid;

    TSvgMeetOrSliceType meetOrSliceTypeValue = ESvgMeetOrSlice_Meet;

    switch ( iScaleMode )

        {

        case EAspectRatioPreserved: // fall through

            {

            // use default

            break;

            }

        // Ensures SVG content fully covers            

        // the area of the icon whilst preserving aspect ratio.

        case EAspectRatioPreservedSlice:

            {

            // alignTypeValue use default

            meetOrSliceTypeValue = ESvgMeetOrSlice_Slice;

            break;

            } 

        // EAspectRatioPreservedAndUnusedSpaceRemoved is mapped to

        // the same values as EAspectRatioNotPreserved

        // because we already have a frame buffer

        // with the dimensions that preserves the aspect ratio.

        // This mapping ensures that SVG engine does not calculate aspect

        // ratio twice and potentially resulting in precision loss.

        case EAspectRatioPreservedAndUnusedSpaceRemoved:                        

        case EAspectRatioNotPreserved:

           {            

            alignTypeValue = ESvgPreserveAspectRatio_None;

           // meetOrSliceTypeValue use default

            break;

            }

        default:

            {

            __ASSERT_DEBUG( 0, USER_INVARIANT() );

           }

        }    

    iSvgEngine->SetPreserveAspectRatio( NULL, alignTypeValue, meetOrSliceTypeValue, ETrue);      

	// render frame and frame mask

	iSvgEngine->Start();	

	iSvgEngine->UseDom( handle, NULL, NULL );

	iSvgEngine->DeleteDom( handle );  

}

CAlfSvgImageLoader* CAlfSvgImageLoader::NewLC(const TDesC& aSVGFile)

    {

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

    CleanupStack::PushL( self );

    self->ConstructL(aSVGFile);

    return self;

    }

CAlfSvgImageLoader::CAlfSvgImageLoader()

    {

    }

void CAlfSvgImageLoader::ConstructL(const TDesC& aSVGFile)

    {

    iFileName = aSVGFile.AllocL();

    // Initialize SVG engine

    TFontSpec spec;

	if ( !iDummyBitmap )

	    {

	    // Have to give some bitmap to the engine in the constructor.

	    iDummyBitmap = new( ELeave ) CFbsBitmap;

	    TInt error = iDummyBitmap->Create( TSize( 0, 0 ), EGray2 );

	    if ( error != KErrNone )

	        {

	        delete iDummyBitmap;

	        iDummyBitmap = NULL;

	        User::Leave( error );

	        }

	    }

	iSvgEngine = CSvgEngineInterfaceImpl::NewL( iDummyBitmap, this, spec );

	iSvgEngine->SetBackgroundColor( 0 );

	// No DRM check needed.

	iSvgEngine->SetDRMMode( EFalse );

    }

void CAlfSvgImageLoader::ProvideBitmapL (TInt aId, CFbsBitmap *& aBitmap, CFbsBitmap *& aMaskBitmap)

{

	CAlfImageLoader::ProvideBitmapL (aId, aBitmap, aMaskBitmap);

	LoadSVGFileL(aId);

	aBitmap = iBitmap; //ownership transfered

	aMaskBitmap = iMask; // ownership transfered

    iBitmap = NULL;

    iMask = NULL;

}

/**

 * Image loader utility for application icon loading.

 *

 */

NONSHARABLE_CLASS(CAlfAppIconImageLoader): public CAlfImageLoader

{

public:

    /**

     * Construct an icon source information to create application icon. AknsUtils::CreateAppIconLC()

     * will be called in RAlfImageLoaderUtil::CreateIconL().

     *

     * @param aInstance     Skin instance.

     * @param aAppUid  Application UID of the icon to be created.

     * @param aType  Type of the application icon. Likely EAknsAppIconTypeContext is used...

     */

	CAlfAppIconImageLoader(TUid aAppUid, TAknsAppIconType aType);

    /**

     * Implementation of MAlfBitmapProvider interface.

     *

     * @param aId     A unique ID of the texture needed to provide bitmaps.

     * @param aBitmap     A bitmap.

     * @param aMaskBitmap     A mask bitmap.

     */

	virtual void ProvideBitmapL (TInt aId, CFbsBitmap *& aBitmap, CFbsBitmap *& aMaskBitmap) ;

private:

	TUid iAppUid;

	TAknsAppIconType iType;

};

// Image loader util

EXPORT_C CAlfImageLoaderUtil::CAlfImageLoaderUtil()

		:iSize(KAlfImageLoaderDefaultWidth,

		       KAlfImageLoaderDefaultHeight), 

		 iScaleMode(KAlfImageLoaderDefaultScaleMode)

	{

	}

EXPORT_C CAlfImageLoaderUtil::~CAlfImageLoaderUtil()

	{

	for (TInt i=0; i<iImageLoaderList.Count(); i++)

		delete iImageLoaderList[i];

	iImageLoaderList.Close();

	}

EXPORT_C MAlfBitmapProvider* CAlfImageLoaderUtil::CreateImageLoaderL(

				const TAknsItemID &aID, 

				const TDesC &aFileName, 

				TInt aBitmapId, 

				TInt aMaskId)

	{

	// Create frame item loader, it can also handle normal items.

	CAlfSkinFrameItemImageLoader* imgLoader = new (ELeave) CAlfSkinFrameItemImageLoader(

			aID, TRect(0,0,0,0), TRect(0,0,0,0));

    CleanupStack::PushL( imgLoader );

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

	imgLoader->SetSize(iSize);