/*

* Copyright (c) 2005-2007 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 "gsasyncimagehandling.h"

#include <aknappui.h>

#include <AknUtils.h>

#include <applayout.cdl.h>

#include <aknlayoutscalable_apps.cdl.h>

#include <startupdomaincrkeys.h>

#include "mgsasyncimagehandlingobserver.h"

#include "GsLogger.h"

#include <CPhCltImageHandler.h>

#include <CPhCltImageParams.h>

#include <CPhCltBaseImageParams.h>

//_LIT( KGSWelcomeNoteImgPath, "c:\\private\\100058ec\\welcomeimage.mbm");

const   TInt    KGSVTStillImageWidth = 176;

const   TInt    KGSVTStillImageHeight = 144;

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

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

// CGSAsyncImageHandling::CGSAsyncImageHandling

// C++ constructor.

//

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

//

CGSAsyncImageHandling::CGSAsyncImageHandling( RFs& aFs,

                                  MGSAsyncImageHandlingObserver* aObserver,

                                  const TDesC& aDestinationPath )

        : CActive( EPriorityNormal ),

          iObserver( aObserver ),

          iFs( aFs ),

          iDestinationPath( aDestinationPath )

    {

    CActiveScheduler::Add( this );

    }

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

// CGSAsyncImageHandling::NewL()

// C++ constructor.

//

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

//

EXPORT_C CGSAsyncImageHandling* CGSAsyncImageHandling::NewL( RFs& aFs,

                                   MGSAsyncImageHandlingObserver* aObserver,

                                   const TDesC& aDestinationPath )

    {

    CGSAsyncImageHandling* self =

        new( ELeave ) CGSAsyncImageHandling( aFs, aObserver,

                                                  aDestinationPath );

    CleanupStack::PushL( self );                                              

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CGSAsyncImageHandling::ConstructL

// Symbian 2nd phase constructor can leave.

//

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

//

void CGSAsyncImageHandling::ConstructL()

    {

    iStartupRepository = CRepository::NewL( KCRUidStartupConf );

    iBitmapScaler = CBitmapScaler::NewL();

    }

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

// CGSAsyncImageHandling::~CGSAsyncImageHandling

// destructor.

//

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

//

CGSAsyncImageHandling::~CGSAsyncImageHandling()

    {

    Cancel();

    if ( iStartupRepository )

        {

        delete iStartupRepository;

        }

    if( iDecoder )

        {

        delete iDecoder;

        }

    if ( iBitmapScaler )

        {

        delete iBitmapScaler;

        }

    if ( iBitmap )

        {

        delete iBitmap;

        }

    }

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

// CGSAsyncImageHandling::ProcessImageL

//

// Processing the image asynchronously

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

//

void CGSAsyncImageHandling::ProcessImageL( const TDesC& aFileName,

                                           TInt aScreenWidth,

                                           TInt aScreenHeight,

                                           TGSBgImageType aBgImageType )

    {

__GSLOGSTRING1( "[CGSAsyncImageHandling] process image %S", &aFileName );

    TInt frameNumber = 0; //for JPEG & bmp images

    iBgImageType = aBgImageType;

    // make sure there is no memory leaks because of iBitmap and iDimmedBmp

    if (iBitmap)

        {

        delete iBitmap;

        iBitmap = NULL;

        }

    iBitmap = new(ELeave) CFbsBitmap;

    // Loading image from file into CFbsBitmap

    CImageDecoder::GetMimeTypeFileL( iFs, aFileName, iMimeString );

    iDecoder = CImageDecoder::FileNewL( iFs, aFileName,

                                        CImageDecoder::EOptionNone );

    TFrameInfo frameInfo = iDecoder->FrameInfo();

    TSize imgSize = frameInfo.iOverallSizeInPixels;

    TDisplayMode displayMode = GetDisplayMode( frameInfo );

    TSize screenSize( aScreenWidth, aScreenHeight );

    TSize loadSize( CalculateLoadSize( frameInfo, screenSize ) );

    iScaleSize = loadSize;

    iBitmap->Reset();

    User::LeaveIfError( iBitmap->Create( imgSize, displayMode ) );

    iDecoder->Convert( &iStatus, *iBitmap, frameNumber );

    if ( aBgImageType == EGSWelcomeNoteImage )

      {

      iState = EGSWelcomeConversion;

      }

    else if ( aBgImageType == EGSVtStillImage )

      {

      iState = EGSVTConversion;

      }

    SetActive();

    }

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

// CGSAsyncImageHandling::GetDisplayMode

//

// Dithers the image to attain the required dithering according to the display

// mode settings

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

//

TDisplayMode CGSAsyncImageHandling::GetDisplayMode( const TFrameInfo& aFrameInfo )

    {

    if( aFrameInfo.iFlags & TFrameInfo::ECanDither )

        {

        if( aFrameInfo.iFrameDisplayMode < EColor64K )

            {

            return aFrameInfo.iFrameDisplayMode;

            }

        else

            {

            return EColor64K;

            }

        }

    else

        {

        return aFrameInfo.iFrameDisplayMode;

        }

    }

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

// CGSAsyncImageHandling::RunL

//

//

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

//

void CGSAsyncImageHandling::RunL()

    {

    if( iStatus.Int() == KErrNone )

      {

      switch( iState )

        {

        case EGSWelcomeConversion:

          iBitmapScaler->Scale(&iStatus, *iBitmap, iScaleSize, ETrue );

          iState = EGSWelcomeScaling;

          SetActive();

          break;

        case EGSWelcomeScaling:

            {

            TInt err = iBitmap->Save( iDestinationPath );

            iStartupRepository->Set( KStartupWelcomeNoteImage,

                                     iDestinationPath );

            //raising completion event

            iObserver->ImageHandlingCompleteL( iStatus.Int() );

            Cancel();

            }

          break;

        case EGSVTConversion:

          iBitmapScaler->Scale(&iStatus, *iBitmap, iScaleSize, ETrue );

          iState = EGSVTScaling;

          SetActive();

          break;

        case EGSVTScaling:

          SaveVTStillImageL();

          iObserver->ImageHandlingCompleteL( iStatus.Int() );

          Cancel();

          break;

        default:

          break;

        }

      }

    else

      {

      iObserver->ImageHandlingCompleteL( iStatus.Int() );

      Cancel();

      }

    }

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

// CGSAsyncImageHandling::DoCancel

//

//

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

//

void CGSAsyncImageHandling::DoCancel()

    {

    if ( iDecoder )

        {

        iDecoder->Cancel();

        }

    if ( iBitmapScaler )

        {

        iBitmapScaler->Cancel();

        }

    delete iDecoder;

    iDecoder = NULL;

    }

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

// CGSAsyncImageHandling::RunError

//

//

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

//

TInt CGSAsyncImageHandling::RunError( TInt aError )

    {

    TRAP_IGNORE( iObserver->ImageHandlingCompleteL( aError ) );

    DoCancel();

    return aError;

    }

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

// TSize CGSAsyncImageHandling::CalculateLoadSize

//

// Calculates the load size

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

//

TSize CGSAsyncImageHandling::CalculateLoadSize( TFrameInfo& aFrameInfo,

                                               const TSize aScreenSize )

    {

    TReal perfectAspect = ( TReal )(

    		( TReal )aScreenSize.iWidth/

    		( TReal )aScreenSize.iHeight );

    TReal aspect = ( TReal )(

        ( TReal )aFrameInfo.iFrameCoordsInPixels.Width()/

        ( TReal )aFrameInfo.iFrameCoordsInPixels.Height() );

    TSize size( aScreenSize.iWidth, aScreenSize.iHeight );

    TSize cropsize( aScreenSize.iWidth, aScreenSize.iHeight );

    TAknWindowLineLayout layout = AknLayout::wallpaper_pane();

    if( aFrameInfo.iFrameCoordsInPixels.Width() > aScreenSize.iWidth ||

        aFrameInfo.iFrameCoordsInPixels.Height() > aScreenSize.iHeight )

        {

        //calculating dynamically range for image aspect ratio close to screen

        TReal maxAspect = ((TReal)aScreenSize.iWidth/(TReal)aScreenSize.iHeight) + 0.12;

        TReal minAspect = ((TReal)aScreenSize.iWidth/(TReal)aScreenSize.iHeight) - 0.12;

        if (aspect >= minAspect && aspect <= maxAspect )

            {

            if( aspect < perfectAspect )

                {

                size.iWidth = aScreenSize.iWidth;

                size.iHeight = (TInt)((TReal)aScreenSize.iWidth/

                    (TReal)aFrameInfo.iFrameCoordsInPixels.Width()*

                    (TReal)aFrameInfo.iFrameCoordsInPixels.Height());

                }

            else

                {

                size.iWidth = (TInt)((TReal)aScreenSize.iHeight/

                    (TReal)aFrameInfo.iFrameCoordsInPixels.Height()*

                    (TReal)aFrameInfo.iFrameCoordsInPixels.Width());

                size.iHeight = aScreenSize.iHeight;

                }

            if (size.iWidth > aScreenSize.iWidth)

                {

                cropsize.iWidth = aScreenSize.iWidth;

                }

            else

                {

                cropsize.iWidth = size.iWidth;

                }

            if (size.iHeight > aScreenSize.iHeight)

                {

                cropsize.iHeight = aScreenSize.iHeight;

                }

            else

                {

                cropsize.iHeight = size.iHeight;

                }

            }

        else

            {

            // Scale and maintain aspect ratio

            if( aspect < perfectAspect )

                {

                if (aFrameInfo.iFrameCoordsInPixels.Height() > aScreenSize.iHeight)

                    {

                    size.iWidth = (TInt)((TReal)aScreenSize.iHeight/

                        (TReal)aFrameInfo.iFrameCoordsInPixels.Height()*

                        (TReal)aFrameInfo.iFrameCoordsInPixels.Width());

                    size.iHeight = aScreenSize.iHeight;

                    }

                }

            else

                {

                if (aFrameInfo.iFrameCoordsInPixels.Width() > aScreenSize.iWidth)

                    {

                    size.iWidth = aScreenSize.iWidth;

                    size.iHeight = (TInt)((TReal)aScreenSize.iWidth/

                        (TReal)aFrameInfo.iFrameCoordsInPixels.Width()*

                        (TReal)aFrameInfo.iFrameCoordsInPixels.Height());

                    }

                }

            }

        }

    return size;

    }

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

// CGSAsyncImageHandling::SaveVTStillImageL

//

//

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

//

void CGSAsyncImageHandling::SaveVTStillImageL()

    {

    //creating new and merging

    const TSize KStillImageSize( KGSVTStillImageWidth, KGSVTStillImageHeight );

    CFbsBitmap* newBitmap = new ( ELeave ) CFbsBitmap;

    CleanupStack::PushL( newBitmap );

    User::LeaveIfError(

        newBitmap->Create( KStillImageSize, iBitmap->DisplayMode() ) );

    CFbsBitmapDevice* device = CFbsBitmapDevice::NewL( newBitmap );

    CleanupStack::PushL( device );

    CFbsBitGc* context = NULL;

    User::LeaveIfError( device->CreateContext( context ) );

    User::LeaveIfNull( context );

    context->SetPenStyle( CGraphicsContext::ENullPen );

    context->SetBrushColor( TRgb( 0, 0, 0 ) ); // black color

    context->SetBrushStyle( CGraphicsContext::ESolidBrush );

    context->Clear();

    const TSize scaledImageSize( iBitmap->SizeInPixels() );

    TInt xPos = ( KStillImageSize.iWidth - scaledImageSize.iWidth ) / 2;

    TInt yPos = ( KStillImageSize.iHeight - scaledImageSize.iHeight ) / 2;

    context->BitBlt( TPoint( xPos, yPos ), iBitmap );

    delete context;

    CleanupStack::PopAndDestroy( device );

    //saving bitmap

    CPhCltImageHandler* phCltImageHandler = CPhCltImageHandler::NewL();

    CleanupStack::PushL( phCltImageHandler );

    // Acquires ownership of *imageParams

    // Bad naming for create-function CPhCltBaseImageParamsL().

    CPhCltImageParams* imageParams = phCltImageHandler->

                       CPhCltBaseImageParamsL( EPhCltTypeVTStill );

    CleanupStack::PushL( imageParams );

    TInt ret = newBitmap->Handle();

    imageParams->AddImageL( ret );

    phCltImageHandler->SaveImages( *imageParams );

    CleanupStack::PopAndDestroy( imageParams );

    CleanupStack::PopAndDestroy( phCltImageHandler );

    delete iBitmap;

    iBitmap = NULL;

    CleanupStack::PopAndDestroy( newBitmap );

    }

// End of File