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     CActive(EPriorityNormal),

    28     mNotify(aNotify),

    29     mNewSize(aNewSize),

    30     mKindOfScaling(aKindOfScaling),

    31     mCurrentOperation(ENone)

    32 {

    33 }

    34 

    35 // -----------------------------------------------------------------------------

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

    37 //

    38 CGraphicsSalingHandler::~CGraphicsSalingHandler()

    39 {

    40     Cancel();

    41     delete mBitmapFromFile;

    42     delete mBitmapOutput;

    43     delete mImageDecoder;

    44     delete mBitmapScaler;

    45 }

    46 

    47 // -----------------------------------------------------------------------------

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

    49 //

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

    51                                                      RFs &aFs,

    52                                                      const TDesC &aFileName,

    53                                                      const TDesC8& aMimeType,

    54                                                      const TSize &aNewSize,

    55                                                      TKindOfScaling aKindOfScaling)

    56 {

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

    58                                                                  aFs, 

    59                                                                  aFileName, 

    60                                                                  aMimeType, 

    61                                                                  aNewSize, 

    62                                                                  aKindOfScaling);

    63     CleanupStack::Pop();

    64     return self;

    65 }

    66 

    67 // -----------------------------------------------------------------------------

    68 // -----------------------------------------------------------------------------

    69 //

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

    71                                               RFs &aFs,

    72                                               const TDesC &aFileName,

    73                                               const TDesC8& aMimeType,

    74                                               const TSize &aNewSize,

    75                                               TKindOfScaling aKindOfScaling)

    76 {

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

    78                                                                        aNewSize, 

    79                                                                        aKindOfScaling);

    80     CleanupStack::PushL(self);

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

    82     return self;

    83 }

    84 

    85 // -----------------------------------------------------------------------------

    86 // -----------------------------------------------------------------------------

    87 //

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

    89 {

    90     CActiveScheduler::Add(this);

    91 

    92     if (aFileName.Length() == 0

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

    94         User::Leave(KErrPathNotFound);

    95     }

    96 

    97     mBitmapScaler = CBitmapScaler::NewL();

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

    99 

   100     // convert *.png to bitmap

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

   102     mBitmapFromFile = new(ELeave)CFbsBitmap();

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

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

   105                                                frameInfo.iFrameDisplayMode));

   106     

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

   108     mCurrentOperation = EConvertBitmapFromFile;

   109     SetActive();

   110 }

   111 

   112 // -----------------------------------------------------------------------------

   113 // -----------------------------------------------------------------------------

   114 //

   115 void CGraphicsSalingHandler::DoCancel()

   116 {

   117     switch (mCurrentOperation) {

   118     case EConvertBitmapFromFile:

   119         mImageDecoder->Cancel();

   120         break;

   121     case EScale:

   122         mBitmapScaler->Cancel();

   123         break;

   124     }

   125     mNotify.ImageReadyCallBack(KErrCancel, 0);

   126 }

   127 

   128 // -----------------------------------------------------------------------------

   129 // -----------------------------------------------------------------------------

   130 //

   131 void CGraphicsSalingHandler::RunL()

   132 {

   133     if(iStatus.Int()){

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

   135         return;

   136     }

   137 

   138     switch (mCurrentOperation) {

   139     case EConvertBitmapFromFile: {

   140             delete mImageDecoder;

   141             mImageDecoder = 0;

   142             

   143             mBitmapOutput = new (ELeave)CFbsBitmap();

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

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

   146             mCurrentOperation = EScale;

   147             SetActive();

   148             break;

   149         }

   150     case EScale: {

   151             mCurrentOperation = ENone;

   152             

   153             delete mBitmapScaler;

   154             mBitmapScaler = 0;

   155             

   156             delete mBitmapFromFile;

   157             mBitmapFromFile = 0;

   158             

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

   160             break;

   161         }

   162     }

   163 }

   164 

   165 // -----------------------------------------------------------------------------

   166 // -----------------------------------------------------------------------------

   167 //

   168 TSize CGraphicsSalingHandler::Scaling()

   169 {

   170    TSize originalSize = mBitmapFromFile->SizeInPixels();

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

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

   173    TSize retSize(mNewSize);

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

   175        retSize = (widthFactor < heightFactor) ?

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

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

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

   179       retSize = (widthFactor < heightFactor) ?

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

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

   182    }

   183    return retSize;

   184 }

   185 // -----------------------------------------------------------------------------

   186 // -----------------------------------------------------------------------------

   187 //

   188 TInt CGraphicsSalingHandler::RunError(TInt aError)

   189 {

   190     mNotify.ImageReadyCallBack(aError, 0);

   191     return KErrNone;

   192 }