/*

* 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:   Loads a slide from file

*

*/

//  INCLUDES

#include "SlideshowPluginUtils.h"

#include "SlideshowSlideLoader.h"

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

// DivAndRoundUp

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

//

TInt DivAndRoundUp(const TInt aNumber, const TInt aDivider)

    {

    TInt result = aNumber / aDivider;

    if (aNumber % aDivider)

        {

        result += 1;

        }

    return result;

    }

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

// CSlideshowSlideLoader::NewL

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

//

CSlideshowSlideLoader* CSlideshowSlideLoader::NewL(CSlideshowSlide *aSlide)

	{

	CSlideshowSlideLoader * self = new (ELeave)CSlideshowSlideLoader(aSlide);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

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

// CSlideshowSlideLoader::ConstructL

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

//

void CSlideshowSlideLoader::ConstructL()

	{

	// Add this object to active scheduler

	CActiveScheduler::Add(this);

	}

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

// CSlideshowSlideLoader::CSlideshowSlideLoader

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

//

CSlideshowSlideLoader::CSlideshowSlideLoader(CSlideshowSlide *aSlide)

	: CActive(CActive::EPriorityStandard),iSlide(aSlide)

	{

	// Empty

	}

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

// CSlideshowSlideLoader::~CSlideshowSlideLoader

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

//

CSlideshowSlideLoader::~CSlideshowSlideLoader()

	{

	if(IsActive())

		{

		Cancel();

		}

	}

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

// CSlideshowSlideLoader::DeleteDecoder

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

//

void CSlideshowSlideLoader::DeleteDecoder()

	{

	if(iDecoder)

		{

		delete iDecoder;

		iDecoder = NULL;

		}

	}

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

// CSlideshowSlideLoader::DoCancel

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

//

void CSlideshowSlideLoader::DoCancel()

	{

	iDecoder->Cancel();

	DeleteDecoder();

	// delete the image

	if(iSlide->iImage)

		{

		delete iSlide->iImage;

		iSlide->iImage = NULL;

		}

	}

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

// CSlideshowSlideLoader::RunL

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

//

void CSlideshowSlideLoader::RunL()

	{

	// delete the decoder to save some memory.

	DeleteDecoder();

	if(iStatus != KErrNone)

		{

		iSlide->ReleaseImage();

		// SSS_DECODEFAILED says that Image could not be decoded. Corrupted image.

		(iSlide->iFlags) |= SSS_DECODEFAILED;

		return;

		}

	// Image loaded, size scaled down while loading. Find out, if the

    // image still needs to be scaled smaller to fit the screen

    TReal aspectRatio = (TReal) iBitmapsize.iWidth / (TReal) iBitmapsize.iHeight;

    if ((iBitmapsize.iWidth <= iTargetSize.iWidth) &&

        (iBitmapsize.iHeight <= iTargetSize.iHeight))

        {

        // Fits completely - finish

        SSPLOGGER_WRITE("No resize needed");

        // Compress the heap after imageconversion as

        // imagedecoder seems to leave heap uncompressed

        User::Heap().Compress();

        (iSlide->iFlags) |= SSS_IMAGELOADED;

    	return;

        }

    // Figure out which dimension needs most scaling

    TReal xFactor = (TReal) iTargetSize.iWidth / (TReal) iBitmapsize.iWidth;

    TReal yFactor = (TReal) iTargetSize.iHeight / (TReal) iBitmapsize.iHeight;

    // Start with target (screen) size

    TSize finalSize = iTargetSize;

    if (xFactor <= yFactor)

        {

        // X-dimension needs most scaling - fit to x, re-calc y

        finalSize.iHeight = (TInt) ((TReal) finalSize.iWidth / aspectRatio);

        }

    else

        {

        // Y-dimension needs most scaling - fit to y, re-calc x

        finalSize.iWidth = (TInt) ((TReal) finalSize.iHeight * aspectRatio);

        }

    SSPLOGGER_WRITEF(_L("SSP: Final size (%d, %d)"),

                     finalSize.iWidth, finalSize.iHeight);

    // Create a final bitmap with the final size, and draw to it

    CFbsBitmap* finalBmp = new (ELeave) CFbsBitmap;

    CleanupStack::PushL(finalBmp);

    User::LeaveIfError(finalBmp->Create(finalSize, (iSlide->iImage)->DisplayMode()));

    CFbsBitmapDevice* bmpDev = CFbsBitmapDevice::NewL(finalBmp);

    CleanupStack::PushL(bmpDev);

    CFbsBitGc* bmpCxt;

    User::LeaveIfError(bmpDev->CreateContext(bmpCxt));

    CleanupStack::PushL(bmpCxt);

    bmpCxt->DrawBitmap(TRect(0, 0, finalSize.iWidth, finalSize.iHeight),

    					(iSlide->iImage),

    					TRect(0, 0, iBitmapsize.iWidth, iBitmapsize.iHeight));

    CleanupStack::PopAndDestroy(2); // bmpDev, bmpCxt

    // Return the result in the original bitmap parameter

    (iSlide->iImage)->Reset();

    User::LeaveIfError((iSlide->iImage)->Duplicate(finalBmp->Handle()));

    CleanupStack::PopAndDestroy(finalBmp);

    // Compress the heap after imageconversion as

    // imagedecoder seems to leave heap uncompressed

    User::Heap().Compress();

    (iSlide->iFlags) |= SSS_IMAGELOADED;

	return;

	}

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

// CSlideshowSlideLoader::LoadSlideL

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

//

void CSlideshowSlideLoader::LoadSlideL(

    const TDesC& aFilename, const TSize& aTargetSize)

    {

    iTargetSize = aTargetSize;

    RFs filesys;

    User::LeaveIfError(filesys.Connect());

    CleanupClosePushL(filesys);

    // this line can leave if decoder is not found..need to cacth this.

    iDecoder = CImageDecoder::FileNewL(filesys, aFilename, ContentAccess::EView,CImageDecoder::EOptionAlwaysThread);

    if (aTargetSize == TSize(-1,-1))

        {

        CleanupStack::PopAndDestroy(&filesys); 

        iDecoder = NULL;

        return;

        }

    // Get image information

    TFrameInfo frameinfo = iDecoder->FrameInfo();

    TDisplayMode mode;

    // Tone down colors if possible (saves memory)

    if (frameinfo.iFlags & TFrameInfo::ECanDither)

        {

        mode = EColor64K;

        }

    else

        {

        mode = frameinfo.iFrameDisplayMode;

        }

    // Find out if the image can be downscaled during loading

    iBitmapsize = frameinfo.iOverallSizeInPixels;

    if ((iBitmapsize.iWidth  >= aTargetSize.iWidth * 2) &&

        (iBitmapsize.iHeight >= aTargetSize.iHeight * 2))

        {

        // 1/2 size

        iBitmapsize.iWidth = DivAndRoundUp(frameinfo.iOverallSizeInPixels.iWidth, 2);

        iBitmapsize.iHeight = DivAndRoundUp(frameinfo.iOverallSizeInPixels.iHeight, 2);

        if ((iBitmapsize.iWidth  >= aTargetSize.iWidth * 2) &&

            (iBitmapsize.iHeight >= aTargetSize.iHeight * 2))

            {

            // 1/4 size

            iBitmapsize.iWidth = DivAndRoundUp(frameinfo.iOverallSizeInPixels.iWidth, 4);

            iBitmapsize.iHeight = DivAndRoundUp(frameinfo.iOverallSizeInPixels.iHeight, 4);

            if ((iBitmapsize.iWidth  >= aTargetSize.iWidth * 2) &&

                (iBitmapsize.iHeight >= aTargetSize.iHeight * 2))

                {

                // 1/8 size

                iBitmapsize.iWidth = DivAndRoundUp(frameinfo.iOverallSizeInPixels.iWidth, 8);

                iBitmapsize.iHeight = DivAndRoundUp(frameinfo.iOverallSizeInPixels.iHeight, 8);

                }

            }

        }

    // Create a target bitmap

    iSlide->iImage = new (ELeave) CFbsBitmap;

    User::LeaveIfError((iSlide->iImage)->Create(iBitmapsize, mode));

    // for filesys

    CleanupStack::PopAndDestroy(&filesys);

    //Start decoding the image ...

    // RunL method is called when decoding is done.

    iDecoder->Convert(&iStatus, *(iSlide->iImage),0);  

    SetActive();

 }

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

// CSlideshowSlideLoader::RunError

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

//

TInt CSlideshowSlideLoader::RunError(TInt aError)

	{

	if (NULL != iSlide->iImage)

		{

		delete iSlide->iImage;

		iSlide->iImage = NULL;

		}

	return aError;

	}