1 /*

     2  * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3  * All rights reserved.

     4  * This component and the accompanying materials are made available

     5  * under the terms of "Eclipse Public License v1.0"

     6  * which accompanies this distribution, and is available

     7  * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8  *

     9  * Initial Contributors:

    10  * Nokia Corporation - initial contribution.

    11  *

    12  * Contributors:

    13  *

    14  * Description :

    15  *

    16  */

    17 #include "activitygraphicfilescaling.h"

    18 #include <imageconversion.h>

    19 

    20 

    21 // -----------------------------------------------------------------------------

    22 // -----------------------------------------------------------------------------

    23 //

    24 CGraphicsSalingHandler::CGraphicsSalingHandler(MImageReadyCallBack &aNotify,

    25                             const TSize &aNewSize,

    26                             TKindOfScaling aKindOfScaling

    27                             /* = CGraphicsSalingHandler::EIgnoreAspectRatio*/) :

    28     CActive(EPriorityNormal),

    29     mNotify(aNotify),

    30     mNewSize(aNewSize),

    31     mKindOfScaling(aKindOfScaling),

    32     mCurrentOperation(ENone)

    33 {

    34 }

    35 

    36 // -----------------------------------------------------------------------------

    37 // -----------------------------------------------------------------------------

    38 //

    39 CGraphicsSalingHandler::~CGraphicsSalingHandler()

    40 {

    41     Cancel();

    42     delete mBitmapFromFile;

    43     delete mBitmapOutput;

    44     delete mImageDecoder;

    45     delete mBitmapScaler;

    46 }

    47 

    48 // -----------------------------------------------------------------------------

    49 // -----------------------------------------------------------------------------

    50 //

    51 CGraphicsSalingHandler* CGraphicsSalingHandler::NewL(MImageReadyCallBack &aNotify,

    52                                 RFs &aFs,

    53                                 const TDesC &aFileName,

    54                                 const TDesC8& aMimeType,

    55                                 const TSize &aNewSize,

    56                                 TKindOfScaling aKindOfScaling

    57                                 /* = CGraphicsSalingHandler::EIgnoreAspectRatio*/)

    58 {

    59     CGraphicsSalingHandler *self = CGraphicsSalingHandler::NewLC(aNotify,

    60                                                                  aFs,

    61                                                                  aFileName,

    62                                                                  aMimeType,

    63                                                                  aNewSize,

    64                                                                  aKindOfScaling);

    65     CleanupStack::Pop();

    66     return self;

    67 }

    68 

    69 // -----------------------------------------------------------------------------

    70 // -----------------------------------------------------------------------------

    71 //

    72 CGraphicsSalingHandler* CGraphicsSalingHandler::NewLC(MImageReadyCallBack &aNotify,

    73                                 RFs &aFs,

    74                                 const TDesC &aFileName,

    75                                 const TDesC8& aMimeType,

    76                                 const TSize &aNewSize,

    77                                 TKindOfScaling aKindOfScaling

    78                                 /* = CGraphicsSalingHandler::EIgnoreAspectRatio*/)

    79 {

    80     CGraphicsSalingHandler *self = new (ELeave) CGraphicsSalingHandler(aNotify,

    81                                                                        aNewSize,

    82                                                                        aKindOfScaling);

    83 

    84     

    85 

    86     CleanupStack::PushL(self);

    87     self->ConstructL(aFs, aFileName, aMimeType);

    88     return self;

    89 }

    90 

    91 // -----------------------------------------------------------------------------

    92 // -----------------------------------------------------------------------------

    93 //

    94 void CGraphicsSalingHandler::ConstructL(RFs &aFs, const TDesC &aFileName, const TDesC8& aMimeType)

    95 {

    96     if (aFileName.Length() == 0

    97         || aFs.IsValidName(aFileName) == EFalse) {

    98         User::Leave(KErrPathNotFound);

    99     }

   100 

   101     if (aMimeType.Length() == 0) {

   102         User::Leave(KErrBadName);

   103     }

   104 

   105     if(0>=mNewSize.iWidth || 0>=mNewSize.iHeight) {

   106        User::Leave(KErrCorrupt);

   107     }

   108 

   109     CActiveScheduler::Add(this);

   110 

   111     mBitmapScaler = CBitmapScaler::NewL();

   112     mBitmapScaler->SetQualityAlgorithm(CBitmapScaler::EMaximumQuality);

   113 

   114     // convert *.png to bitmap

   115     mImageDecoder = CImageDecoder::FileNewL(aFs, aFileName, aMimeType);

   116     mBitmapFromFile = new(ELeave)CFbsBitmap();

   117     const TFrameInfo frameInfo(mImageDecoder->FrameInfo(0));

   118     User::LeaveIfError(mBitmapFromFile->Create(frameInfo.iOverallSizeInPixels, 

   119                                                frameInfo.iFrameDisplayMode));

   120 

   121     mImageDecoder->Convert(&iStatus, *mBitmapFromFile, 0);

   122     mCurrentOperation = EConvertBitmapFromFile;

   123     SetActive();

   124 }

   125 

   126 // -----------------------------------------------------------------------------

   127 // -----------------------------------------------------------------------------

   128 //

   129 void CGraphicsSalingHandler::DoCancel()

   130 {

   131     switch (mCurrentOperation) {

   132     case EConvertBitmapFromFile:

   133         mImageDecoder->Cancel();

   134         break;

   135     case EScale:

   136         mBitmapScaler->Cancel();

   137         break;

   138     }

   139     mNotify.ImageReadyCallBack(KErrCancel, 0);

   140 }

   141 

   142 // -----------------------------------------------------------------------------

   143 // -----------------------------------------------------------------------------

   144 //

   145 void CGraphicsSalingHandler::RunL()

   146 {

   147     if(iStatus.Int()){

   148         mNotify.ImageReadyCallBack(iStatus.Int(), 0);

   149         return;

   150     }

   151 

   152     switch (mCurrentOperation) {

   153     case EConvertBitmapFromFile: {

   154             delete mImageDecoder;

   155             mImageDecoder = 0;

   156             

   157             mBitmapOutput = new (ELeave)CFbsBitmap();

   158             User::LeaveIfError(mBitmapOutput->Create(Scaling(), mBitmapFromFile->DisplayMode()));

   159             mBitmapScaler->Scale(&iStatus, *mBitmapFromFile, *mBitmapOutput, EFalse);

   160             mCurrentOperation = EScale;

   161             SetActive();

   162             break;

   163         }

   164     case EScale: {

   165             mCurrentOperation = ENone;

   166 

   167             delete mBitmapScaler;

   168             mBitmapScaler = 0;

   169             

   170             delete mBitmapFromFile;

   171             mBitmapFromFile = 0;

   172 

   173             if (mKindOfScaling == CGraphicsSalingHandler::EKeepAspectRatioByExpanding) {

   174                 User::LeaveIfError(mBitmapOutput->Resize(mNewSize));

   175             }

   176 

   177             mNotify.ImageReadyCallBack(iStatus.Int(), mBitmapOutput);

   178             break;

   179         }

   180     }

   181 }

   182 

   183 // -----------------------------------------------------------------------------

   184 // -----------------------------------------------------------------------------

   185 //

   186 TSize CGraphicsSalingHandler::Scaling()

   187 {

   188    TSize originalSize = mBitmapFromFile->SizeInPixels();

   189    float widthFactor = mNewSize.iWidth / (float)originalSize.iWidth;

   190    float heightFactor = mNewSize.iHeight / (float)originalSize.iHeight;

   191 

   192    TSize retSize(mNewSize);

   193 

   194    if (mKindOfScaling == CGraphicsSalingHandler::EKeepAspectRatio) {

   195        retSize = (widthFactor < heightFactor) ?

   196                  TSize(mNewSize.iWidth, widthFactor * originalSize.iHeight) :

   197                  TSize(heightFactor * originalSize.iWidth, mNewSize.iHeight);

   198    } else if (mKindOfScaling == CGraphicsSalingHandler::EKeepAspectRatioByExpanding) {

   199       retSize = (widthFactor < heightFactor) ?

   200                 TSize(heightFactor * originalSize.iWidth, mNewSize.iHeight) :

   201                 TSize(mNewSize.iWidth, widthFactor * originalSize.iHeight);

   202    }

   203    return retSize;

   204 }

   205 // -----------------------------------------------------------------------------

   206 // -----------------------------------------------------------------------------

   207 //

   208 TInt CGraphicsSalingHandler::RunError(TInt aError)

   209 {

   210     mNotify.ImageReadyCallBack(aError, 0);

   211     return KErrNone;

   212 }