activityfw/tsutils/tsrc/t_tsgraphicfilescalinghandler/src/t_tsgraphicfilescalinghandler.cpp
changeset 117 c63ee96dbe5f
equal deleted inserted replaced
115:3ab5c078b490 117:c63ee96dbe5f
       
     1 //Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
       
     2 //All rights reserved.
       
     3 //This component and the accompanying materials are made available
       
     4 //under the terms of "Eclipse Public License v1.0"
       
     5 //which accompanies this distribution, and is available
       
     6 //at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     7 
       
     8 //Initial Contributors:
       
     9 //Nokia Corporation - initial contribution.
       
    10 
       
    11 //Contributors:
       
    12 
       
    13 //Description:
       
    14 
       
    15 /////////////////////////////////////////////////////////////////////
       
    16 
       
    17 // INCLUDED FILES
       
    18 #include <QtTest/QtTest>
       
    19 #include "t_tsgraphicfilescalinghandler.h"
       
    20 
       
    21 _LIT(KFileName, "c:\\data\\Images\\Pictures\\image_file.png");
       
    22 _LIT8(KMimeType, "image/png");
       
    23 QString KFileName2("c:\\data\\Images\\Pictures\\image_file.png");
       
    24 
       
    25 const TSize KOriginalSize(480, 236);
       
    26 const TSize KWanted_TheSameRatio(KOriginalSize.iWidth/2, KOriginalSize.iHeight/2);
       
    27 const TSize KWanted_LessWidth(KOriginalSize.iWidth/2, KOriginalSize.iHeight);
       
    28 const TSize KWanted_LessHeight(KOriginalSize.iWidth, KOriginalSize.iHeight/2);
       
    29 
       
    30 // -----------------------------------------------------------------------------
       
    31 // -----------------------------------------------------------------------------
       
    32 //
       
    33 QTEST_MAIN(T_CTsGraphicFileScalingHandler)
       
    34 
       
    35 // -----------------------------------------------------------------------------
       
    36 // -----------------------------------------------------------------------------
       
    37 //
       
    38 T_CTsGraphicFileScalingHandler::T_CTsGraphicFileScalingHandler(QObject *parent) :
       
    39     QObject(parent),
       
    40     mErrorCallBack(KErrNone)
       
    41 {
       
    42     User::LeaveIfError(mFs.Connect());
       
    43     User::LeaveIfError(RFbsSession::Connect(mFs));
       
    44 }
       
    45 
       
    46 // -----------------------------------------------------------------------------
       
    47 // -----------------------------------------------------------------------------
       
    48 //
       
    49 T_CTsGraphicFileScalingHandler::~T_CTsGraphicFileScalingHandler()
       
    50 {
       
    51     mFs.Close();
       
    52     RFbsSession::Disconnect();
       
    53 }
       
    54 
       
    55 // -----------------------------------------------------------------------------
       
    56 // -----------------------------------------------------------------------------
       
    57 //
       
    58 void T_CTsGraphicFileScalingHandler::WaitActive(TInt aTime)
       
    59 {
       
    60     CActiveSchedulerWait *wait = new (ELeave)CActiveSchedulerWait();
       
    61     CPeriodic *periodic = CPeriodic::NewL(CActive::EPriorityIdle);
       
    62     periodic->Start(aTime, aTime, TCallBack(CallStop, wait));
       
    63     wait->Start();
       
    64     delete periodic;
       
    65     delete wait;
       
    66 }
       
    67 
       
    68 // -----------------------------------------------------------------------------
       
    69 // -----------------------------------------------------------------------------
       
    70 //
       
    71 TInt T_CTsGraphicFileScalingHandler::CallStop(TAny *aWait)
       
    72 {
       
    73     (static_cast<CActiveSchedulerWait*>(aWait))->AsyncStop();
       
    74     return 1;
       
    75 }
       
    76 
       
    77 // -----------------------------------------------------------------------------
       
    78 // -----------------------------------------------------------------------------
       
    79 //
       
    80 void T_CTsGraphicFileScalingHandler::testGraphicFileScalingIgnoreAspectRatio_LessWidth()
       
    81 {
       
    82     CTsGraphicFileScalingHandler *screenShotHadnler = 0;
       
    83 
       
    84     TRAPD(errNo, screenShotHadnler =
       
    85         CTsGraphicFileScalingHandler::NewL(*this,
       
    86                                     mFs,
       
    87                                     KFileName,
       
    88                                     KMimeType,
       
    89                                     KWanted_LessWidth
       
    90                                     /*CTsGraphicFileScalingHandler::EIgnoreAspectRatio*/));
       
    91 
       
    92     QCOMPARE(errNo, KErrNone);
       
    93     WaitActive(5000000);
       
    94 
       
    95     QVERIFY(!mErrorCallBack);
       
    96     QVERIFY(!mPixMapCallBack.isNull());
       
    97     QCOMPARE(mPixMapCallBack.width(), KWanted_LessWidth.iWidth);
       
    98     QCOMPARE(mPixMapCallBack.height(), KWanted_LessWidth.iHeight);
       
    99     delete screenShotHadnler;
       
   100 }
       
   101 
       
   102 // -----------------------------------------------------------------------------
       
   103 // -----------------------------------------------------------------------------
       
   104 //
       
   105 void T_CTsGraphicFileScalingHandler::testGraphicFileScalingIgnoreAspectRatio_LessHeight()
       
   106 {
       
   107     CTsGraphicFileScalingHandler *screenShotHadnler = 0;
       
   108 
       
   109     TRAPD(errNo, screenShotHadnler =
       
   110         CTsGraphicFileScalingHandler::NewL(*this,
       
   111                                     mFs,
       
   112                                     KFileName,
       
   113                                     KMimeType,
       
   114                                     KWanted_LessHeight
       
   115                                     /*CTsGraphicFileScalingHandler::EIgnoreAspectRatio*/));
       
   116 
       
   117     QCOMPARE(errNo, KErrNone);
       
   118     WaitActive(5000000);
       
   119 
       
   120     QVERIFY(!mErrorCallBack);
       
   121     QVERIFY(!mPixMapCallBack.isNull());
       
   122     QCOMPARE(mPixMapCallBack.width(), KWanted_LessHeight.iWidth);
       
   123     QCOMPARE(mPixMapCallBack.height(), KWanted_LessHeight.iHeight);
       
   124     delete screenShotHadnler;
       
   125 }
       
   126 
       
   127 // -----------------------------------------------------------------------------
       
   128 // -----------------------------------------------------------------------------
       
   129 //
       
   130 void T_CTsGraphicFileScalingHandler::testGraphicFileScalingIgnoreAspectRatio_TheSameRatio()
       
   131 {
       
   132     CTsGraphicFileScalingHandler *screenShotHadnler = 0;
       
   133 
       
   134     TRAPD(errNo, screenShotHadnler =
       
   135         CTsGraphicFileScalingHandler::NewL(*this,
       
   136                                     mFs,
       
   137                                     KFileName,
       
   138                                     KMimeType,
       
   139                                     KWanted_TheSameRatio
       
   140                                     /*CTsGraphicFileScalingHandler::EIgnoreAspectRatio*/));
       
   141 
       
   142     QCOMPARE(errNo, KErrNone);
       
   143     WaitActive(5000000);
       
   144 
       
   145     QVERIFY(!mErrorCallBack);
       
   146     QVERIFY(!mPixMapCallBack.isNull());
       
   147     QCOMPARE(mPixMapCallBack.width(), KWanted_TheSameRatio.iWidth);
       
   148     QCOMPARE(mPixMapCallBack.height(), KWanted_TheSameRatio.iHeight);
       
   149     delete screenShotHadnler;
       
   150 }
       
   151 
       
   152 // -----------------------------------------------------------------------------
       
   153 // -----------------------------------------------------------------------------
       
   154 //
       
   155 void T_CTsGraphicFileScalingHandler::testGraphicFileScalingKeepAspectRatio_LessWidth()
       
   156 {
       
   157     CTsGraphicFileScalingHandler *screenShotHadnler = 0;
       
   158 
       
   159     TRAPD(errNo, screenShotHadnler =
       
   160         CTsGraphicFileScalingHandler::NewL(*this,
       
   161                                     mFs,
       
   162                                     KFileName,
       
   163                                     KMimeType,
       
   164                                     KWanted_LessWidth,
       
   165                                     CTsGraphicFileScalingHandler::EKeepAspectRatio));
       
   166 
       
   167     QCOMPARE(errNo, KErrNone);
       
   168     WaitActive(5000000);
       
   169 
       
   170     QVERIFY(!mErrorCallBack);
       
   171     QVERIFY(!mPixMapCallBack.isNull());
       
   172     QVERIFY(mPixMapCallBack.width() <= KWanted_LessWidth.iWidth);
       
   173     QVERIFY(mPixMapCallBack.height() <= KWanted_LessWidth.iHeight);
       
   174     delete screenShotHadnler;
       
   175 }
       
   176 
       
   177 // -----------------------------------------------------------------------------
       
   178 // -----------------------------------------------------------------------------
       
   179 //
       
   180 void T_CTsGraphicFileScalingHandler::testGraphicFileScalingKeepAspectRatio_LessHeight()
       
   181 {
       
   182     CTsGraphicFileScalingHandler *screenShotHadnler = 0;
       
   183 
       
   184     TRAPD(errNo, screenShotHadnler =
       
   185         CTsGraphicFileScalingHandler::NewL(*this,
       
   186                                     mFs,
       
   187                                     KFileName,
       
   188                                     KMimeType,
       
   189                                     KWanted_LessHeight,
       
   190                                     CTsGraphicFileScalingHandler::EKeepAspectRatio));
       
   191 
       
   192     QCOMPARE(errNo, KErrNone);
       
   193     WaitActive(5000000);
       
   194 
       
   195     QVERIFY(!mErrorCallBack);
       
   196     QVERIFY(!mPixMapCallBack.isNull());
       
   197     QVERIFY(mPixMapCallBack.width() <= KWanted_LessHeight.iWidth);
       
   198     QVERIFY(mPixMapCallBack.height() <= KWanted_LessHeight.iHeight);
       
   199     delete screenShotHadnler;
       
   200 }
       
   201 
       
   202 // -----------------------------------------------------------------------------
       
   203 // -----------------------------------------------------------------------------
       
   204 //
       
   205 void T_CTsGraphicFileScalingHandler::testGraphicFileScalingKeepAspectRatio_TheSameRatio()
       
   206 {
       
   207     CTsGraphicFileScalingHandler *screenShotHadnler = 0;
       
   208 
       
   209     TRAPD(errNo, screenShotHadnler =
       
   210         CTsGraphicFileScalingHandler::NewL(*this,
       
   211                                     mFs,
       
   212                                     KFileName,
       
   213                                     KMimeType,
       
   214                                     KWanted_TheSameRatio,
       
   215                                     CTsGraphicFileScalingHandler::EKeepAspectRatio));
       
   216 
       
   217     QCOMPARE(errNo, KErrNone);
       
   218     WaitActive(5000000);
       
   219 
       
   220     QVERIFY(!mErrorCallBack);
       
   221     QVERIFY(!mPixMapCallBack.isNull());
       
   222     QVERIFY(mPixMapCallBack.width() <= KWanted_TheSameRatio.iWidth);
       
   223     QVERIFY(mPixMapCallBack.height() <= KWanted_TheSameRatio.iHeight);
       
   224     delete screenShotHadnler;
       
   225 }
       
   226 
       
   227 // -----------------------------------------------------------------------------
       
   228 // -----------------------------------------------------------------------------
       
   229 //
       
   230 void T_CTsGraphicFileScalingHandler::testGraphicFileScalingKeepAspectRatioByExpanding_LessWidth()
       
   231 {
       
   232     CTsGraphicFileScalingHandler *screenShotHadnler = 0;
       
   233 
       
   234     TRAPD(errNo, screenShotHadnler =
       
   235         CTsGraphicFileScalingHandler::NewL(*this,
       
   236                                     mFs,
       
   237                                     KFileName,
       
   238                                     KMimeType,
       
   239                                     KWanted_LessWidth,
       
   240                                     CTsGraphicFileScalingHandler::EKeepAspectRatioByExpanding));
       
   241 
       
   242     QCOMPARE(errNo, KErrNone);
       
   243     WaitActive(5000000);
       
   244 
       
   245     QVERIFY(!mErrorCallBack);
       
   246     QVERIFY(!mPixMapCallBack.isNull());
       
   247     QCOMPARE(mPixMapCallBack.width(), KWanted_LessWidth.iWidth);
       
   248     QCOMPARE(mPixMapCallBack.height(), KWanted_LessWidth.iHeight);
       
   249     delete screenShotHadnler;
       
   250 }
       
   251 
       
   252 // -----------------------------------------------------------------------------
       
   253 // -----------------------------------------------------------------------------
       
   254 //
       
   255 void T_CTsGraphicFileScalingHandler::testGraphicFileScalingKeepAspectRatioByExpanding_LessHeight()
       
   256 {
       
   257     CTsGraphicFileScalingHandler *screenShotHadnler = 0;
       
   258 
       
   259     TRAPD(errNo, screenShotHadnler =
       
   260         CTsGraphicFileScalingHandler::NewL(*this,
       
   261                                     mFs,
       
   262                                     KFileName,
       
   263                                     KMimeType,
       
   264                                     KWanted_LessHeight,
       
   265                                     CTsGraphicFileScalingHandler::EKeepAspectRatioByExpanding));
       
   266 
       
   267     QCOMPARE(errNo, KErrNone);
       
   268     WaitActive(5000000);
       
   269 
       
   270     QVERIFY(!mErrorCallBack);
       
   271     QVERIFY(!mPixMapCallBack.isNull());
       
   272     QCOMPARE(mPixMapCallBack.width(), KWanted_LessHeight.iWidth);
       
   273     QCOMPARE(mPixMapCallBack.height(), KWanted_LessHeight.iHeight);
       
   274     delete screenShotHadnler;
       
   275 }
       
   276 
       
   277 // -----------------------------------------------------------------------------
       
   278 // -----------------------------------------------------------------------------
       
   279 //
       
   280 void T_CTsGraphicFileScalingHandler::testGraphicFileScalingKeepAspectRatioByExpanding_TheSameRatio()
       
   281 {
       
   282     CTsGraphicFileScalingHandler *screenShotHadnler = 0;
       
   283 
       
   284     TRAPD(errNo, screenShotHadnler =
       
   285         CTsGraphicFileScalingHandler::NewL(*this,
       
   286                                     mFs,
       
   287                                     KFileName,
       
   288                                     KMimeType,
       
   289                                     KWanted_TheSameRatio,
       
   290                                     CTsGraphicFileScalingHandler::EKeepAspectRatioByExpanding));
       
   291 
       
   292     QCOMPARE(errNo, KErrNone);
       
   293     WaitActive(5000000);
       
   294 
       
   295     QVERIFY(!mErrorCallBack);
       
   296     QVERIFY(!mPixMapCallBack.isNull());
       
   297     QCOMPARE(mPixMapCallBack.width(), KWanted_TheSameRatio.iWidth);
       
   298     QCOMPARE(mPixMapCallBack.height(), KWanted_TheSameRatio.iHeight);
       
   299     delete screenShotHadnler;
       
   300 }
       
   301 
       
   302 // ---------------------------------------------------------------------------
       
   303 // ---------------------------------------------------------------------------
       
   304 //
       
   305 void T_CTsGraphicFileScalingHandler::testGraphicFileScalingInvalidImagePath()
       
   306 {
       
   307     CTsGraphicFileScalingHandler *screenShotHadnler = 0;
       
   308     TSize newSize(240, 118);
       
   309     _LIT(wrongImagePath, "c:\\data\\Images\\Pictures\\<image_file.png");
       
   310 
       
   311     TRAPD(errNo, screenShotHadnler =
       
   312             CTsGraphicFileScalingHandler::NewL(*this,
       
   313                                         mFs,
       
   314                                         wrongImagePath,
       
   315                                         KMimeType,
       
   316                                         newSize);
       
   317     );
       
   318 
       
   319     QCOMPARE(errNo, KErrPathNotFound);
       
   320     WaitActive(5000000);
       
   321     delete screenShotHadnler;
       
   322 }
       
   323 
       
   324 // ---------------------------------------------------------------------------
       
   325 // ---------------------------------------------------------------------------
       
   326 //
       
   327 void T_CTsGraphicFileScalingHandler::testGraphicFileScalingEmptyImagePath()
       
   328 {
       
   329     CTsGraphicFileScalingHandler *screenShotHadnler = 0;
       
   330     TSize newSize(240, 118);
       
   331     _LIT(wrongImagePath, "");
       
   332 
       
   333     TRAPD(errNo, screenShotHadnler =
       
   334             CTsGraphicFileScalingHandler::NewL(*this,
       
   335                                         mFs,
       
   336                                         wrongImagePath,
       
   337                                         KMimeType,
       
   338                                         newSize);
       
   339     );
       
   340 
       
   341     QCOMPARE(errNo, KErrPathNotFound);
       
   342     WaitActive(5000000);
       
   343     delete screenShotHadnler;
       
   344 }
       
   345 
       
   346 // ---------------------------------------------------------------------------
       
   347 // ---------------------------------------------------------------------------
       
   348 //
       
   349 void T_CTsGraphicFileScalingHandler::testGraphicFileScalingEmptyMimeType()
       
   350 {
       
   351     CTsGraphicFileScalingHandler *screenShotHadnler = 0;
       
   352     TSize newSize(240, 118);
       
   353     _LIT8(wrongMimeType, "");
       
   354 
       
   355     TRAPD(errNo,
       
   356         screenShotHadnler = CTsGraphicFileScalingHandler::NewL(*this,
       
   357                                         mFs,
       
   358                                         KFileName,
       
   359                                         wrongMimeType,
       
   360                                         newSize);
       
   361     );
       
   362 
       
   363     QCOMPARE(errNo, KErrBadName);
       
   364     WaitActive(5000000);
       
   365     delete screenShotHadnler;
       
   366 }
       
   367 
       
   368 // ---------------------------------------------------------------------------
       
   369 // ---------------------------------------------------------------------------
       
   370 //
       
   371 void T_CTsGraphicFileScalingHandler::testGraphicFileScalingScalingToIncorrectWidthSize()
       
   372 {
       
   373     CTsGraphicFileScalingHandler *screenShotHadnler = 0;
       
   374     TSize newSize(-20, 118);
       
   375 
       
   376     TRAPD(errNo, screenShotHadnler =
       
   377             CTsGraphicFileScalingHandler::NewL(*this,
       
   378                                         mFs,
       
   379                                         KFileName,
       
   380                                         KMimeType,
       
   381                                         newSize);
       
   382     );
       
   383 
       
   384     QCOMPARE(errNo, KErrCorrupt);
       
   385     WaitActive(5000000);
       
   386     delete screenShotHadnler;
       
   387 }
       
   388 
       
   389 // ---------------------------------------------------------------------------
       
   390 // ---------------------------------------------------------------------------
       
   391 //
       
   392 void T_CTsGraphicFileScalingHandler::testGraphicFileScalingScalingToIncorrectHeightSize()
       
   393 {
       
   394     CTsGraphicFileScalingHandler *screenShotHadnler = 0;
       
   395     TSize newSize(240, -20);
       
   396 
       
   397     TRAPD(errNo, screenShotHadnler =
       
   398             CTsGraphicFileScalingHandler::NewL(*this,
       
   399                                         mFs,
       
   400                                         KFileName,
       
   401                                         KMimeType,
       
   402                                         newSize);
       
   403     );
       
   404 
       
   405     QCOMPARE(errNo, KErrCorrupt);
       
   406     WaitActive(5000000);
       
   407     delete screenShotHadnler;
       
   408 }
       
   409 
       
   410 // ---------------------------------------------------------------------------
       
   411 // ---------------------------------------------------------------------------
       
   412 //
       
   413 void T_CTsGraphicFileScalingHandler::testGraphicFileScalingScalingToZeroSize()
       
   414 {
       
   415     CTsGraphicFileScalingHandler *screenShotHadnler = 0;
       
   416     TSize newSize(0, 0);
       
   417 
       
   418     TRAPD(errNo, screenShotHadnler =
       
   419             CTsGraphicFileScalingHandler::NewL(*this,
       
   420                                         mFs,
       
   421                                         KFileName,
       
   422                                         KMimeType,
       
   423                                         newSize);
       
   424     );
       
   425 
       
   426     QCOMPARE(errNo, KErrCorrupt);
       
   427     WaitActive(5000000);
       
   428     delete screenShotHadnler;
       
   429 }
       
   430 
       
   431 // ---------------------------------------------------------------------------
       
   432 // ---------------------------------------------------------------------------
       
   433 //
       
   434 void T_CTsGraphicFileScalingHandler::testDoCancel()
       
   435 {
       
   436     CTsGraphicFileScalingHandler *screenShotHadnler = 0;
       
   437 
       
   438     TRAPD(errNo, screenShotHadnler =
       
   439         CTsGraphicFileScalingHandler::NewL(*this,
       
   440                                     mFs,
       
   441                                     KFileName,
       
   442                                     KMimeType,
       
   443                                     KWanted_LessWidth));
       
   444 
       
   445     QCOMPARE(errNo, KErrNone);
       
   446 
       
   447     screenShotHadnler->Cancel();
       
   448 
       
   449     WaitActive(5000000);
       
   450     QCOMPARE(mErrorCallBack, KErrCancel);
       
   451     QVERIFY(mPixMapCallBack.isNull());
       
   452     delete screenShotHadnler;
       
   453 }
       
   454 
       
   455 // ---------------------------------------------------------------------------
       
   456 // ---------------------------------------------------------------------------
       
   457 //
       
   458 void T_CTsGraphicFileScalingHandler::testCFbsBitmapScalingToCorrectSize()
       
   459 {
       
   460     QPixmap imputPixMap(KFileName2);
       
   461 
       
   462     CFbsBitmap *cFbsBitmap = new(ELeave)CFbsBitmap();
       
   463     QVERIFY(cFbsBitmap = imputPixMap.toSymbianCFbsBitmap());
       
   464 
       
   465     CTsGraphicFileScalingHandler *screenShotHadnler = 0;
       
   466 
       
   467     TRAPD(errNoo, screenShotHadnler =
       
   468         CTsGraphicFileScalingHandler::NewL(*this,
       
   469                                     *cFbsBitmap,
       
   470                                     KWanted_LessHeight));
       
   471 
       
   472     QCOMPARE(errNoo, KErrNone);
       
   473     WaitActive(5000000);
       
   474 
       
   475     QVERIFY(!mErrorCallBack);
       
   476     QVERIFY(!mPixMapCallBack.isNull());
       
   477     QCOMPARE(mPixMapCallBack.width(), KWanted_LessHeight.iWidth);
       
   478     QCOMPARE(mPixMapCallBack.height(), KWanted_LessHeight.iHeight);
       
   479 
       
   480     delete screenShotHadnler;
       
   481     delete cFbsBitmap;
       
   482 }
       
   483 
       
   484 // ---------------------------------------------------------------------------
       
   485 // ---------------------------------------------------------------------------
       
   486 //
       
   487 void T_CTsGraphicFileScalingHandler::testCFbsBitmapScalinToIncorrectWidthSize()
       
   488 {
       
   489     QPixmap imputPixMap(KFileName2);
       
   490 
       
   491     CFbsBitmap *cFbsBitmap = new(ELeave)CFbsBitmap();
       
   492     QVERIFY(cFbsBitmap = imputPixMap.toSymbianCFbsBitmap());
       
   493 
       
   494     CTsGraphicFileScalingHandler *screenShotHadnler = 0;
       
   495     TSize newSize(-20, 118);
       
   496 
       
   497     TRAPD(errNoo, screenShotHadnler =
       
   498         CTsGraphicFileScalingHandler::NewL(*this,
       
   499                                     *cFbsBitmap,
       
   500                                     newSize));
       
   501 
       
   502     QCOMPARE(errNoo, KErrCorrupt);
       
   503     WaitActive(5000000);
       
   504 
       
   505     delete screenShotHadnler;
       
   506     delete cFbsBitmap;
       
   507 }
       
   508 
       
   509 // ---------------------------------------------------------------------------
       
   510 // ---------------------------------------------------------------------------
       
   511 //
       
   512 void T_CTsGraphicFileScalingHandler::testCFbsBitmapScalinToIncorrectHeightSize()
       
   513 {
       
   514     QPixmap imputPixMap(KFileName2);
       
   515 
       
   516     CFbsBitmap *cFbsBitmap = new(ELeave)CFbsBitmap();
       
   517     QVERIFY(cFbsBitmap = imputPixMap.toSymbianCFbsBitmap());
       
   518 
       
   519     CTsGraphicFileScalingHandler *screenShotHadnler = 0;
       
   520     TSize newSize(240, -20);
       
   521 
       
   522     TRAPD(errNoo, screenShotHadnler =
       
   523         CTsGraphicFileScalingHandler::NewL(*this,
       
   524                                     *cFbsBitmap,
       
   525                                     newSize));
       
   526 
       
   527     QCOMPARE(errNoo, KErrCorrupt);
       
   528     WaitActive(5000000);
       
   529 
       
   530     delete screenShotHadnler;
       
   531     delete cFbsBitmap;
       
   532 }
       
   533 
       
   534 // -----------------------------------------------------------------------------
       
   535 // -----------------------------------------------------------------------------
       
   536 //
       
   537 void T_CTsGraphicFileScalingHandler::ImageReadyCallBack(TInt error,
       
   538                                                    const CFbsBitmap *bitmap)
       
   539 {
       
   540     CFbsBitmap *retBitmap = const_cast<CFbsBitmap *>(bitmap);
       
   541 
       
   542     mErrorCallBack = error;
       
   543     mPixMapCallBack = QPixmap();
       
   544 
       
   545     if (retBitmap && !error) {
       
   546         mPixMapCallBack = QPixmap::fromSymbianCFbsBitmap(retBitmap);
       
   547     }
       
   548 }
       
   549 
       
   550 //  End of KFileName