/*
 * Copyright (c) 2009 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 "tsgraphicfilescalinghandler.h"
#include <imageconversion.h>

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
CTsGraphicFileScalingHandler::CTsGraphicFileScalingHandler(MImageReadyCallBack &aNotify,
                                const TSize &aNewSize,
                                TKindOfScaling aKindOfScaling
                                /* = CTsGraphicFileScalingHandler::EIgnoreAspectRatio*/) :
    CActive(EPriorityNormal),
    mNotify(aNotify),
    mNewSize(aNewSize),
    mKindOfScaling(aKindOfScaling),
    mCurrentOperation(ENone)
{
    CActiveScheduler::Add(this);
}

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
EXPORT_C CTsGraphicFileScalingHandler::~CTsGraphicFileScalingHandler()
{
    Cancel();
    delete mInputBitmap;
    delete mOutputBitmap;
    delete mImageDecoder;
    delete mBitmapScaler;
}

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
EXPORT_C CTsGraphicFileScalingHandler* CTsGraphicFileScalingHandler::NewL(MImageReadyCallBack &aNotify,
                                                RFs &aFs,
                                                const TDesC &aFileName,
                                                const TDesC8& aMimeType,
                                                const TSize &aNewSize,
                                                TKindOfScaling aKindOfScaling
                                                /* = CTsGraphicFileScalingHandler::EIgnoreAspectRatio*/)
{
    CTsGraphicFileScalingHandler *self = CTsGraphicFileScalingHandler::NewLC(aNotify,
                                                                        aFs,
                                                                        aFileName,
                                                                        aMimeType,
                                                                        aNewSize,
                                                                        aKindOfScaling);
    CleanupStack::Pop();
    return self;
}

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
EXPORT_C CTsGraphicFileScalingHandler* CTsGraphicFileScalingHandler::NewLC(MImageReadyCallBack &aNotify,
                                                RFs &aFs,
                                                const TDesC &aFileName,
                                                const TDesC8& aMimeType,
                                                const TSize &aNewSize,
                                                TKindOfScaling aKindOfScaling
                                                /* = CTsGraphicFileScalingHandler::EIgnoreAspectRatio*/)
{
    CTsGraphicFileScalingHandler *self = new (ELeave) CTsGraphicFileScalingHandler(aNotify,
                                                                                aNewSize,
                                                                                aKindOfScaling);

    CleanupStack::PushL(self);
    self->ConstructL(aFs, aFileName, aMimeType);
    return self;
}

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CTsGraphicFileScalingHandler::ConstructL(RFs &aFs, const TDesC &aFileName, const TDesC8& aMimeType)
{
    if (aFileName.Length() == 0
        || aFs.IsValidName(aFileName) == EFalse) {
        User::Leave(KErrPathNotFound);
    }

    if (aMimeType.Length() == 0) {
        User::Leave(KErrBadName);
    }

    if (0>=mNewSize.iWidth || 0>=mNewSize.iHeight) {
       User::Leave(KErrCorrupt);
    }

    mInputBitmap = new(ELeave)CFbsBitmap();
    DecodingOperationL(aFs, aFileName, aMimeType);
    SetActive();
}

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
EXPORT_C CTsGraphicFileScalingHandler* CTsGraphicFileScalingHandler::NewL(MImageReadyCallBack &aNotify,
                                        const CFbsBitmap &aImputFbsBitmap,
                                        const TSize &aNewSize,
                                        TKindOfScaling aKindOfScaling
                                        /* = CTsGraphicFileScalingHandler::EIgnoreAspectRatio*/)
{
    CTsGraphicFileScalingHandler *self = CTsGraphicFileScalingHandler::NewLC(aNotify,
                                                                        aImputFbsBitmap,
                                                                        aNewSize,
                                                                        aKindOfScaling);
    CleanupStack::Pop();
    return self;
}

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
EXPORT_C CTsGraphicFileScalingHandler* CTsGraphicFileScalingHandler::NewLC(MImageReadyCallBack &aNotify,
                                                const CFbsBitmap &aImputFbsBitmap,
                                                const TSize &aNewSize,
                                                TKindOfScaling aKindOfScaling
                                                /* = CTsGraphicFileScalingHandler::EIgnoreAspectRatio*/)
{
    CTsGraphicFileScalingHandler *self = new (ELeave) CTsGraphicFileScalingHandler(aNotify,
                                                                                aNewSize,
                                                                                aKindOfScaling);

    CleanupStack::PushL(self);
    self->ConstructL(aImputFbsBitmap);
    return self;
}

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CTsGraphicFileScalingHandler::ConstructL(const CFbsBitmap &aImputFbsBitmap)
{
    if (0>=mNewSize.iWidth || 0>=mNewSize.iHeight) {
       User::Leave(KErrCorrupt);
    }

    mInputBitmap = new(ELeave)CFbsBitmap();
    User::LeaveIfError(mInputBitmap->Duplicate(aImputFbsBitmap.Handle()));

    ScalingOperationL();
    SetActive();
}

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CTsGraphicFileScalingHandler::DoCancel()
{
    switch (mCurrentOperation) {
    case EConvertBitmapFromFile:
        mImageDecoder->Cancel();
        break;
    case EScale:
        mBitmapScaler->Cancel();
        break;
    }
    mNotify.ImageReadyCallBack(KErrCancel, 0);
}

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CTsGraphicFileScalingHandler::RunL()
{
    User::LeaveIfError(iStatus.Int());

    switch (mCurrentOperation) {
    case EConvertBitmapFromFile: {
            delete mImageDecoder;
            mImageDecoder = 0;

            ScalingOperationL();
            SetActive();
            break;
        }
    case EScale: {
            mCurrentOperation = ENone;

            delete mBitmapScaler;
            mBitmapScaler = 0;
            
            delete mInputBitmap;
            mInputBitmap = 0;

            if (mKindOfScaling == CTsGraphicFileScalingHandler::EKeepAspectRatioByExpanding) {
                User::LeaveIfError(mOutputBitmap->Resize(mNewSize));
            }

            mNotify.ImageReadyCallBack(iStatus.Int(), mOutputBitmap);
            break;
        }
    }
}

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CTsGraphicFileScalingHandler::DecodingOperationL(RFs &aFs, const TDesC &aFileName, const TDesC8& aMimeType)
{
    // convert *.png to bitmap
    mImageDecoder = CImageDecoder::FileNewL(aFs, aFileName, aMimeType);
    const TFrameInfo frameInfo(mImageDecoder->FrameInfo(0));
    mInputBitmap->Reset();
    User::LeaveIfError(mInputBitmap->Create(frameInfo.iOverallSizeInPixels, 
                                               frameInfo.iFrameDisplayMode));

    mImageDecoder->Convert(&iStatus, *mInputBitmap, 0);
    mCurrentOperation = EConvertBitmapFromFile;
}

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CTsGraphicFileScalingHandler::ScalingOperationL()
{
    mBitmapScaler = CBitmapScaler::NewL();
    mBitmapScaler->SetQualityAlgorithm(CBitmapScaler::EMaximumQuality);

    FixForDisplayModeNotSupportedByScalingOperation();

    mOutputBitmap = new (ELeave)CFbsBitmap();
    User::LeaveIfError(mOutputBitmap->Create(NewSizeToScalingOperation(), mInputBitmap->DisplayMode()));
    mBitmapScaler->Scale(&iStatus, *mInputBitmap, *mOutputBitmap, EFalse);
    mCurrentOperation = EScale;
}

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CTsGraphicFileScalingHandler::FixForDisplayModeNotSupportedByScalingOperation()
{
    if (EColor16MAP == mInputBitmap->DisplayMode()) {
        mInputBitmap->SetDisplayMode(EColor16MA);
    }
}

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
TSize CTsGraphicFileScalingHandler::NewSizeToScalingOperation()
{
   TSize originalSize = mInputBitmap->SizeInPixels();
   float widthFactor = mNewSize.iWidth / (float)originalSize.iWidth;
   float heightFactor = mNewSize.iHeight / (float)originalSize.iHeight;

   TSize retSize(mNewSize);

   if (mKindOfScaling == CTsGraphicFileScalingHandler::EKeepAspectRatio) {
       retSize = (widthFactor < heightFactor) ?
                 TSize(mNewSize.iWidth, widthFactor * originalSize.iHeight) :
                 TSize(heightFactor * originalSize.iWidth, mNewSize.iHeight);
   } else if (mKindOfScaling == CTsGraphicFileScalingHandler::EKeepAspectRatioByExpanding) {
      retSize = (widthFactor < heightFactor) ?
                TSize(heightFactor * originalSize.iWidth, mNewSize.iHeight) :
                TSize(mNewSize.iWidth, widthFactor * originalSize.iHeight);
   }
   return retSize;
}
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
TInt CTsGraphicFileScalingHandler::RunError(TInt aError)
{
    mNotify.ImageReadyCallBack(aError, 0);
    return KErrNone;
}