1 /*

     2 * Copyright (c) 2006 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 the License "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:  This class represents the Widget Extension object

    15 *

    16 */

    17 

    18 // INCLUDE FILES

    19 #include "config.h"

    20 #include <eikmenub.h>

    21 #include <eikenv.h>

    22 #include <gdi.h>

    23 #include <bitdev.h>

    24 #include "Renderer.h"

    25 #include "WebView.h"

    26 

    27 //#include "WebSurface.h"

    28 //#include "StaticObjectsContainer.h"

    29 

    30 // EXTERNAL DATA STRUCTURES

    31 

    32 // EXTERNAL FUNCTION PROTOTYPES

    33 

    34 // CONSTANTS

    35 const TUint8 KMaxTransitionCount = 30;

    36 const TInt KMediumResolutionDpi = 200;

    37 //NOTE: 5 transitions is plenty for Tube, but mileage may vary 

    38 //      on future high-res devices. 

    39 const TUint8 KMinTransitionCount = 5;

    40 // LOCAL FUNCTION PROTOTYPES

    41 

    42 

    43 // ----------------------------------------------------------------------------

    44 // TransitionCb

    45 //

    46 //

    47 //

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

    49 TInt transitionCb( TAny* aPtr )

    50 {

    51     static_cast<WidgetRenderer*>(aPtr)->transitionCb();

    52     return ETrue;

    53 }

    54 

    55 

    56 // ----------------------------------------------------------------------------

    57 // WidgetRenderer::WidgetRenderer

    58 //

    59 //

    60 //

    61 // ----------------------------------------------------------------------------

    62 WidgetRenderer::WidgetRenderer(MWidgetEngineCallbacks& aWidgetEngineCallback) : 

    63 m_transitionbitmap(0),

    64 m_fademask(0),

    65 m_transitiontimer(0),

    66 m_transitioncount(0), 

    67 m_maxtransitions(KMaxTransitionCount),

    68 m_widgetenginecallback( &aWidgetEngineCallback )

    69 {

    70    // If a high-res device, use fewer transitions

    71    CEikonEnv* eikEnv = CEikonEnv::Static();

    72    if ( eikEnv )   {

    73        CWsScreenDevice& screenDev = *eikEnv->ScreenDevice();

    74        TUint dpi = screenDev.VerticalTwipsToPixels( KTwipsPerInch );

    75        if ( dpi > KMediumResolutionDpi ) {  //high resolution

    76            m_maxtransitions = KMinTransitionCount;

    77        }

    78    }

    79 }

    80 

    81 // ----------------------------------------------------------------------------

    82 // WidgetRenderer::~WidgetRenderer

    83 //

    84 //

    85 //

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

    87 WidgetRenderer::~WidgetRenderer()

    88 {

    89     if (m_transitiontimer) {

    90         m_transitiontimer->Cancel();        

    91         delete m_transitiontimer;

    92     }

    93     

    94     if (m_fademask) {

    95         delete m_fademask;

    96     }

    97 

    98     if (m_transitionbitmap) {

    99         delete m_transitionbitmap;

   100     }

   101 

   102 }

   103 

   104 // ----------------------------------------------------------------------------

   105 // WidgetRenderer::prepareForTransition

   106 //

   107 //

   108 //

   109 // ----------------------------------------------------------------------------

   110 void WidgetRenderer::prepareForTransitionL(const TDesC& /*aTransition*/)

   111 {

   112     m_transitioncount = 0;   

   113     destroyTransitionBitmap();

   114     createTransitionBitmapL();

   115     destroyFadeMask();

   116     createFadeMaskL();

   117     drawFadeMaskL();

   118 }

   119 

   120 // ----------------------------------------------------------------------------

   121 // WidgetRenderer::PerformTransitionL

   122 //

   123 //

   124 //

   125 // ----------------------------------------------------------------------------

   126 void WidgetRenderer::performTransitionL()

   127 {

   128     delete m_transitiontimer;

   129     m_transitiontimer = 0;

   130     TRAP_IGNORE(m_transitiontimer = CPeriodic::NewL( CActive::EPriorityLow ));

   131     m_transitioncount = 0;

   132     m_transitiontimer->Start( 20, 20, TCallBack( &::transitionCb, this ) );

   133 }

   134 

   135 // ----------------------------------------------------------------------------

   136 // WidgetRenderer::transitionCb

   137 //

   138 //

   139 //

   140 // ----------------------------------------------------------------------------

   141 void WidgetRenderer::transitionCb()

   142 {

   143     m_transitioncount++;

   144 

   145     if (m_transitioncount==m_maxtransitions) {

   146         destroyTransitionBitmap();

   147         m_transitiontimer->Cancel();

   148         destroyFadeMask();

   149     }

   150 

   151     TRAP_IGNORE(drawFadeMaskL());

   152     

   153     m_widgetenginecallback->drawWidgetTransition();

   154     

   155 }

   156 

   157 // ----------------------------------------------------------------------------

   158 // WidgetRenderer::createTransitionBitmapL

   159 //

   160 //

   161 //

   162 // ----------------------------------------------------------------------------

   163 void WidgetRenderer::createTransitionBitmapL()

   164 {

   165 

   166     if (m_widgetenginecallback->offscreenBitmap()) {

   167         m_transitionbitmap = new (ELeave) CFbsBitmap();

   168         User::LeaveIfError(m_transitionbitmap->Create( m_widgetenginecallback->offscreenBitmap()->SizeInPixels(), EColor16MU));

   169         CFbsBitmapDevice* dev = CFbsBitmapDevice::NewL(m_transitionbitmap);

   170         CleanupStack::PushL(dev);

   171         CFbsBitGc* gc;

   172         User::LeaveIfError(dev->CreateContext(gc));

   173         gc->BitBlt(TPoint(0,0),m_widgetenginecallback->offscreenBitmap());

   174         delete gc;

   175         CleanupStack::PopAndDestroy();        

   176     }

   177     

   178 }

   179 

   180 // ----------------------------------------------------------------------------

   181 // WidgetRenderer::destroyTransitionBitmap

   182 //

   183 //

   184 //

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

   186 void WidgetRenderer::destroyTransitionBitmap()

   187 {

   188     delete m_transitionbitmap;

   189     m_transitionbitmap = 0;

   190 }

   191 

   192 // ----------------------------------------------------------------------------

   193 // WidgetRenderer::createFadeMaskL

   194 //

   195 //

   196 //

   197 // ----------------------------------------------------------------------------

   198 void WidgetRenderer::createFadeMaskL()

   199 {

   200     m_fademask = new (ELeave) CFbsBitmap();

   201     m_fademask->Create(m_transitionbitmap->SizeInPixels(),EGray256);

   202 }

   203 

   204 // ----------------------------------------------------------------------------

   205 // WidgetRenderer::destroyFadeMask

   206 //

   207 //

   208 //

   209 // ----------------------------------------------------------------------------

   210 void WidgetRenderer::destroyFadeMask()

   211 {

   212     delete m_fademask;

   213     m_fademask = 0;

   214 }

   215 

   216 

   217 // ----------------------------------------------------------------------------

   218 // WidgetRenderer::drawFadeMaskL

   219 //

   220 //

   221 //

   222 // ----------------------------------------------------------------------------

   223 void WidgetRenderer::drawFadeMaskL()

   224 {

   225     if (m_fademask) {

   226         

   227         CFbsBitmapDevice* dev = CFbsBitmapDevice::NewL(m_fademask);

   228         CleanupStack::PushL(dev);

   229         

   230         CFbsBitGc* gc;

   231         User::LeaveIfError(dev->CreateContext(gc));

   232         m_fademask->LockHeap();

   233         

   234         TSize s = m_fademask->SizeInPixels();

   235         TUint8* data = (TUint8*)m_fademask->DataAddress();

   236         TUint8* end = data + s.iWidth*s.iHeight;

   237 

   238         while ( data<end ) {

   239             *(data++) = (255*m_transitioncount/m_maxtransitions);

   240         }

   241         

   242         m_fademask->UnlockHeap();

   243         delete gc;

   244         CleanupStack::PopAndDestroy();

   245     }

   246     

   247 }

   248 

   249 

   250 // ----------------------------------------------------------------------------

   251 // WidgetRenderer::drawTransition

   252 //

   253 //

   254 //

   255 // ----------------------------------------------------------------------------

   256 void WidgetRenderer::drawTransition(CWindowGc& gc, CFbsBitmap* aCurrentBitmap)

   257 {

   258 

   259     if (transitionInProgress()) {

   260         

   261         if (!m_transitionbitmap || !aCurrentBitmap || !m_fademask)

   262             return;

   263 

   264         TSize s = m_transitionbitmap->SizeInPixels();

   265         gc.BitBlt(TPoint(0,0),m_transitionbitmap);

   266         gc.BitBltMasked(TPoint(0,0),aCurrentBitmap, TRect(s), m_fademask, EFalse);

   267     }

   268 }

   269 

   270 

   271 

   272