1 /*

     2 * Copyright (c) 2005-2007 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 */

    18 

    19 

    20 #include "CPbk2ThumbnailScaler.h"

    21 

    22 #include <bitmaptransforms.h>

    23 #include <applayout.cdl.h>

    24 #include <AknUtils.h>

    25 

    26 // Sizes for different original images from LAF

    27 #define KVgaSize        TSize(640, 480)

    28 #define KVgaTurnedSize  TSize(480, 640)

    29 #define KCifSize        TSize(352, 288)

    30 #define KCifTurnedSize  TSize(288, 352)

    31 #define KCommSize       TSize(80,  96)

    32 const TReal KTallThumbnailRatio = 0.625;

    33 const TReal KWideThumbnailRatio = 1.467;

    34 

    35 CPbk2ThumbnailScaler* CPbk2ThumbnailScaler::NewL

    36         (MPbk2ThumbnailScalerObserver& aObserver)

    37     {

    38     return new(ELeave) CPbk2ThumbnailScaler(aObserver);

    39     }

    40 

    41 CPbk2ThumbnailScaler::CPbk2ThumbnailScaler

    42         (MPbk2ThumbnailScalerObserver& aObserver) :

    43     CActive(CActive::EPriorityStandard),

    44     iObserver(aObserver)

    45     {

    46     CActiveScheduler::Add(this);

    47     }

    48 

    49 CPbk2ThumbnailScaler::~CPbk2ThumbnailScaler()

    50     {

    51     Cancel();

    52     delete iScaler;

    53     delete iBitmap;

    54     }

    55 

    56 void CPbk2ThumbnailScaler::DoCropL(CFbsBitmap* aBitmap)

    57     {

    58     TSize size = aBitmap->SizeInPixels();

    59     TReal ratio = TReal(size.iWidth) / TReal(size.iHeight);

    60 

    61     TSize targetSize;

    62 

    63     if (ratio < KTallThumbnailRatio)

    64         {

    65         targetSize.SetSize

    66             (size.iWidth, TInt(size.iWidth / KTallThumbnailRatio));

    67         }

    68     else if (ratio > KWideThumbnailRatio)

    69         {

    70         targetSize.SetSize

    71             (TInt(size.iHeight * KWideThumbnailRatio), size.iHeight);

    72         }

    73     else

    74         {

    75         // no cropping needed

    76         return;

    77         }

    78 

    79     TRect targetRect(TPoint((size.iWidth - targetSize.iWidth) / 2,

    80                             (size.iHeight - targetSize.iHeight) / 2),

    81                      targetSize);

    82 

    83     CFbsBitmap* target = new(ELeave) CFbsBitmap;

    84     CleanupStack::PushL(target);

    85     User::LeaveIfError(target->Create(targetSize, aBitmap->DisplayMode()));

    86     

    87     HBufC8* scanLine = HBufC8::NewLC(aBitmap->ScanLineLength

    88         (targetSize.iWidth, aBitmap->DisplayMode()));

    89     TPtr8 scanLinePtr = scanLine->Des();

    90     

    91     TPoint startPoint(targetRect.iTl.iX, targetRect.iTl.iY);

    92     TInt targetY = 0;

    93     for (; startPoint.iY < targetRect.iBr.iY; ++startPoint.iY)

    94         {

    95         aBitmap->GetScanLine(scanLinePtr, startPoint, targetSize.iWidth, aBitmap->DisplayMode());

    96         target->SetScanLine(scanLinePtr, targetY++);

    97         }

    98 

    99     aBitmap->Reset();

   100     User::LeaveIfError(aBitmap->Duplicate(target->Handle()));

   101     CleanupStack::PopAndDestroy(2, target); // scanLine, target

   102     }

   103 

   104 void CPbk2ThumbnailScaler::StartScaleL(CFbsBitmap* aBitmap, const TSize& aSize)

   105     {

   106     // Crops the image if needed

   107     DoCropL(aBitmap);

   108 

   109     if (!iScaler)

   110         {

   111         iScaler = CBitmapScaler::NewL();

   112         }

   113 

   114     iBitmap = aBitmap;

   115 

   116     iScaler->Scale(&iStatus, *iBitmap, aSize);

   117     SetActive();

   118     }

   119 

   120 void CPbk2ThumbnailScaler::CreateThumbnail(CFbsBitmap* aBitmap)

   121     {

   122     Cancel();

   123     

   124     TSize size = aBitmap->SizeInPixels();

   125     TReal ratio = TReal(size.iWidth) / TReal(size.iHeight);

   126 

   127     TSize targetSize;

   128     TRect zeroRect(0, 0, 0, 0);

   129     if (size == KVgaSize)

   130         {

   131         TAknLayoutRect layoutRect;

   132         layoutRect.LayoutRect(zeroRect, AppLayout::VGA());

   133         targetSize = TSize(layoutRect.Rect().Width(), layoutRect.Rect().Height());

   134         }

   135     else if (size == KVgaTurnedSize)

   136         {

   137         TAknLayoutRect layoutRect;

   138         layoutRect.LayoutRect(zeroRect, AppLayout::VGA_turned_90());

   139         targetSize = TSize(layoutRect.Rect().Width(), layoutRect.Rect().Height());

   140         }

   141     else if (size == KCifSize)

   142         {

   143         TAknLayoutRect layoutRect;

   144         layoutRect.LayoutRect(zeroRect, AppLayout::CIF());

   145         targetSize = TSize(layoutRect.Rect().Width(), layoutRect.Rect().Height());

   146         }

   147     else if (size == KCifTurnedSize)

   148         {

   149         TAknLayoutRect layoutRect;

   150         layoutRect.LayoutRect(zeroRect, AppLayout::CIF_turned_90());

   151         targetSize = TSize(layoutRect.Rect().Width(), layoutRect.Rect().Height());

   152         }

   153     else if (size == KCommSize)

   154         {

   155         TAknLayoutRect layoutRect;

   156         layoutRect.LayoutRect(zeroRect, AppLayout::Communicator_personal_image());

   157         targetSize = TSize(layoutRect.Rect().Width(), layoutRect.Rect().Height());

   158         }

   159     else if (ratio < KTallThumbnailRatio)

   160         {

   161         TAknLayoutRect layoutRect;

   162         layoutRect.LayoutRect(zeroRect, AppLayout::Image_aspect_ratio___0_625());

   163         targetSize = TSize(layoutRect.Rect().Width(), layoutRect.Rect().Height());

   164         }

   165     else if (ratio > KWideThumbnailRatio)

   166         {

   167         TAknLayoutRect layoutRect;

   168         layoutRect.LayoutRect(zeroRect, AppLayout::Image_aspect_ratio___1_467());

   169         targetSize = TSize(layoutRect.Rect().Width(), layoutRect.Rect().Height());

   170         }

   171     else // KTallThumbnailRatio < ratio < KWideThumbnailRatio

   172         {

   173         TAknLayoutRect layoutRect;

   174         layoutRect.LayoutRect(zeroRect, AppLayout::_0_625___image_aspect_ratio___1_467());

   175         targetSize = TSize(layoutRect.Rect().Width(), layoutRect.Rect().Height());

   176         }

   177 

   178     TRAPD(err, StartScaleL(aBitmap, targetSize));

   179     if (err != KErrNone)

   180         {

   181         iObserver.ThumbnailScalingComplete(err, aBitmap);

   182         }

   183     }

   184 

   185 void CPbk2ThumbnailScaler::RunL()

   186     {

   187     TInt status = iStatus.Int();

   188     iObserver.ThumbnailScalingComplete(status, iBitmap);

   189     iBitmap = NULL;

   190     }

   191 

   192 void CPbk2ThumbnailScaler::DoCancel()

   193     {

   194     iScaler->Cancel();

   195     iObserver.ThumbnailScalingComplete(KErrCancel, iBitmap);

   196     iBitmap = NULL;

   197     }

   198 

   199 TInt CPbk2ThumbnailScaler::RunError(TInt aError)

   200     {

   201     iObserver.ThumbnailScalingComplete(aError, iBitmap);

   202     iBitmap = NULL;

   203     return KErrNone;

   204     }

   205 

   206 // End of File