1 /*

     2 * Copyright (c) 2003-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 "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:  Implementation of CMIDGaugeItem

    15 *

    16 */

    17 

    18 

    19 #include <coemain.h>

    20 #include <e32std.h>

    21 #include <eikcapc.h>

    22 // CAknSlider - needed for iSlider member

    23 #include <aknslider.h>

    24 // macros for resources

    25 #include <lcdui.rsg>

    26 // using TMifAvkon enumeration

    27 #include <avkon.mbg>

    28 // Api for skin instance

    29 // and creating icons

    30 #include <AknsUtils.h>

    31 

    32 // needed CEikProgressInfo API for iProgressInfo member

    33 // control used to indicate the progress of an operation

    34 #include <eikprogi.h>

    35 #include <eikon.hrh>

    36 #include <eikpanic.h>

    37 // using TResourceReader class in ConstructSliderL (interactive gauge)

    38 // interprets resource data read from a resource file

    39 #include <barsread.h>

    40 #include <gulbordr.h>

    41 #include <eikenv.h>

    42 // API use to retrieve info if pen is enabled (PenEnabled) in HandlePointerEventL function

    43 #include <AknUtils.h> // for arabic texts support

    44 #include <gulcolor.h>

    45 

    46 // using AknsDrawUtils for drawing background

    47 #include <AknsDrawUtils.h>

    48 #include <applayout.cdl.h>

    49 // LAF

    50 #include <aknlayoutscalable_avkon.cdl.h>

    51 

    52 #include <AknDef.h> // For layout change event definitions

    53 

    54 #ifdef RD_JAVA_ADVANCED_TACTILE_FEEDBACK

    55 #include <touchfeedback.h>

    56 #endif //RD_JAVA_ADVANCED_TACTILE_FEEDBACK

    57 

    58 #include <j2me/jdebug.h>

    59 #include "CMIDGaugeItem.h"

    60 // API used for obtain info about command count for IsSelectable function

    61 #include "CMIDCommandList.h"

    62 // API for iLabelControl (inherited from CMIDControlItem)

    63 #include "CMIDItemLabel.h"

    64 // using TlsStruct for creating bitmap storage

    65 #include "CMIDMenuHandler.h"

    66 #include "CMIDUtils.h"

    67 #include "CMIDUIManager.h"

    68 // Using of CAknBitmapAnimation for iBitmapAnimation

    69 #include <AknBitmapAnimation.h>

    70 

    71 //

    72 // Constants

    73 //

    74 const TInt KDelayInMicroSeconds = 50000;

    75 const TInt KContRunningAnimFramesCount = 7;

    76 const TInt KIncUpdatingAnimFramesCount = 19;

    77 // Divider to correct pointerEvent y-coordinate close to graphics center

    78 const TInt KSliderHeightDivider = 3;

    79 

    80 

    81 // class CGaugeTimer

    82 

    83 inline CMIDGaugeItem::CGaugeTimer::CGaugeTimer(CMIDGaugeItem& aGauge)

    84         :CTimer(CActive::EPriorityStandard),iGauge(aGauge)

    85 {

    86     CActiveScheduler::Add(this);

    87 }

    88 

    89 CMIDGaugeItem::CGaugeTimer* CMIDGaugeItem::CGaugeTimer::NewL(CMIDGaugeItem& aGauge)

    90 {

    91     CGaugeTimer* self = new(ELeave) CGaugeTimer(aGauge);

    92     CleanupStack::PushL(self);

    93     self->ConstructL();

    94     CleanupStack::Pop(self);

    95     return self;

    96 }

    97 

    98 void CMIDGaugeItem::CGaugeTimer::RunL()

    99 {

   100     if (!iGauge.iGaugeFrameData)

   101     {//if the bitmaps haven't been created it means we are inside an alert,

   102         //which is using its own bitmaps for the gauge animation.

   103         //Return without restarting the timer

   104         return;

   105     }

   106 

   107     iGauge.iValue++;

   108 

   109     if (iGauge.iValue >= iGauge.iGaugeFrameData->iContRunBitmap.Count())

   110     {

   111         iGauge.iValue = 0;

   112     }

   113 

   114     CMIDNonInteractiveGauge* nig = static_cast<CMIDNonInteractiveGauge*>(&iGauge);

   115     nig->DoSafeDraw();

   116 

   117     After(TTimeIntervalMicroSeconds32(KDelayInMicroSeconds));

   118 }

   119 

   120 

   121 // class CMIDGaugeItem

   122 

   123 

   124 TInt CMIDGaugeItem::GetValue()

   125 {

   126     return iValue;

   127 }

   128 

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

   130 //

   131 // ---------------------------------------------------------------------------

   132 //

   133 CMIDGaugeItem::CMIDGaugeItem(CMIDUIManager* aUIManager)

   134         : CMIDControlItem(EDefault, aUIManager),

   135         iIndefiniteState(EIncrementalIdle),

   136         iGaugeFrameData(NULL),

   137         iTimer(NULL)

   138 {

   139     iMMidItem = this;

   140     iIsInForeground = ETrue;

   141 }

   142 

   143 CMIDGaugeItem::~CMIDGaugeItem()

   144 {

   145     if (iGaugeFrameData)

   146     {

   147         iGaugeFrameData->iNumInstances--;

   148 

   149         if (!(iGaugeFrameData->iNumInstances))

   150         {

   151             // delete bitmaps from thread-local bitmap storage

   152             DeleteBitmapsInTls();

   153             iGaugeFrameData->Close();

   154             delete iGaugeFrameData;

   155             iUIManager->SetGaugeItemData(NULL);

   156         }

   157     }

   158 }

   159 

   160 

   161 void CMIDGaugeItem::BaseConstructL(const TDesC& aLabel,TInt aMaxValue,TInt aInitialValue)

   162 {

   163     DEBUG("CMIDGaugeItem::BaseConstructL <");

   164 

   165     CMIDControlItem::ConstructL();

   166     SetLabelL(aLabel);

   167 

   168     iLabelControl->SetWidthL(FormClientAreaWidth());

   169 

   170     if (aMaxValue == 0)

   171     {

   172         aMaxValue = 1;

   173     }

   174 

   175     iMaxValue = aMaxValue;

   176     iValue = aInitialValue;

   177 

   178     SetStateL(aMaxValue,aInitialValue);

   179 

   180     DEBUG("CMIDGaugeItem::BaseConstructL >");

   181 }

   182 

   183 void CMIDGaugeItem::CreateBitmapsIfNeededL()

   184 {

   185     if (iGaugeFrameData)

   186     {

   187         return;

   188     }

   189     iGaugeFrameData = reinterpret_cast< TGaugeFrameData* >(iUIManager->GetGaugeItemData());

   190     if (iGaugeFrameData)

   191     {

   192         iGaugeFrameData->iNumInstances++;

   193     }

   194     else

   195     {

   196         // Create shared data

   197         iGaugeFrameData = new(ELeave) TGaugeFrameData;

   198         iGaugeFrameData->Clean();

   199         iUIManager->SetGaugeItemData(reinterpret_cast< void* >(iGaugeFrameData));

   200         // Initialize data

   201         CreateBitmapsInTlsL();

   202         // Resize data

   203         ResizeBitmapsInTlsL();

   204     }

   205 }

   206 

   207 

   208 void CMIDGaugeItem::CreateBitmapsInTlsL()

   209 {

   210     // check if thread-local bitmap storage is created

   211     if (!iGaugeFrameData)

   212     {

   213         return;

   214     }

   215 

   216     // eventually delete existing bitmaps

   217     DeleteBitmapsInTls();

   218 

   219     // skin instance and default bitmaps file

   220     MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance();

   221     TFileName avkonbmpFilename = AknIconUtils::AvkonIconFileName();

   222 

   223     // for bitmap loading

   224     const TAknsItemID* aknsItemId;

   225     TInt bitmapId;

   226     TInt bitmapMaskId;

   227     CFbsBitmap* bitmap;

   228     CFbsBitmap* bitmapMask;

   229     TInt i;

   230 

   231     // continuous running bitmaps

   232     for (i=0; i<KContRunningAnimFramesCount; i++)

   233     {

   234         switch (i)

   235         {

   236         case 0:

   237             aknsItemId = &KAknsIIDQgnGrafBarWait1;

   238             bitmapId = EMbmAvkonQgn_graf_bar_wait_1;

   239             bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_1_mask;

   240             break;

   241         case 1:

   242             aknsItemId = &KAknsIIDQgnGrafBarWait2;

   243             bitmapId = EMbmAvkonQgn_graf_bar_wait_2;

   244             bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_2_mask;

   245             break;

   246         case 2:

   247             aknsItemId = &KAknsIIDQgnGrafBarWait3;

   248             bitmapId = EMbmAvkonQgn_graf_bar_wait_3;

   249             bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_3_mask;

   250             break;

   251         case 3:

   252             aknsItemId = &KAknsIIDQgnGrafBarWait4;

   253             bitmapId = EMbmAvkonQgn_graf_bar_wait_4;

   254             bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_4_mask;

   255             break;

   256         case 4:

   257             aknsItemId = &KAknsIIDQgnGrafBarWait5;

   258             bitmapId = EMbmAvkonQgn_graf_bar_wait_5;

   259             bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_5_mask;

   260             break;

   261         case 5:

   262             aknsItemId = &KAknsIIDQgnGrafBarWait6;

   263             bitmapId = EMbmAvkonQgn_graf_bar_wait_6;

   264             bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_6_mask;

   265             break;

   266         default:

   267             aknsItemId = &KAknsIIDQgnGrafBarWait7;

   268             bitmapId = EMbmAvkonQgn_graf_bar_wait_7;

   269             bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_7_mask;

   270             break;

   271         }

   272 

   273         AknsUtils::CreateIconL(skinInstance, *aknsItemId, bitmap,

   274                                bitmapMask, avkonbmpFilename, bitmapId, bitmapMaskId);

   275 

   276         TInt appendErr1 = iGaugeFrameData->iContRunBitmap.Append(bitmap);

   277         TInt appendErr2 = iGaugeFrameData->iContRunBitmapMask.Append(bitmapMask);

   278 

   279         if (appendErr1 != KErrNone)

   280         {

   281             delete bitmap;

   282         }

   283         if (appendErr2 != KErrNone)

   284         {

   285             delete bitmapMask;

   286         }

   287         if ((appendErr1 != KErrNone) || (appendErr2 != KErrNone))

   288         {

   289             User::LeaveIfError((appendErr1 != KErrNone) ? appendErr1 : appendErr2);

   290         }

   291     }

   292 

   293     // incremental updating bitmaps

   294     // (bitmaps masks ids "EMbmAvkonQgn_graf_bar_wait_increm_mask" -

   295     // "EMbmAvkonQgn_graf_bar_wait_increm_19_mask" are not defined and that's

   296     // why masks for continuous running animation are used instead)

   297     for (i=0; i<KIncUpdatingAnimFramesCount; i++)

   298     {

   299         switch (i)

   300         {

   301         case 0:

   302             aknsItemId = &KAknsIIDQgnGrafBarWaitIncrem;

   303             bitmapId = EMbmAvkonQgn_graf_bar_wait_increm;

   304             bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_1_mask;

   305             break;

   306         case 1:

   307             aknsItemId = &KAknsIIDQgnGrafBarWaitIncrem02;

   308             bitmapId = EMbmAvkonQgn_graf_bar_wait_increm_02;

   309             bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_2_mask;

   310             break;

   311         case 2:

   312             aknsItemId = &KAknsIIDQgnGrafBarWaitIncrem03;

   313             bitmapId = EMbmAvkonQgn_graf_bar_wait_increm_03;

   314             bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_3_mask;

   315             break;

   316         case 3:

   317             aknsItemId = &KAknsIIDQgnGrafBarWaitIncrem04;

   318             bitmapId = EMbmAvkonQgn_graf_bar_wait_increm_04;

   319             bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_4_mask;

   320             break;

   321         case 4:

   322             aknsItemId = &KAknsIIDQgnGrafBarWaitIncrem05;

   323             bitmapId = EMbmAvkonQgn_graf_bar_wait_increm_05;

   324             bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_5_mask;

   325             break;

   326         case 5:

   327             aknsItemId = &KAknsIIDQgnGrafBarWaitIncrem06;

   328             bitmapId = EMbmAvkonQgn_graf_bar_wait_increm_06;

   329             bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_6_mask;

   330             break;

   331         case 6:

   332             aknsItemId = &KAknsIIDQgnGrafBarWaitIncrem07;

   333             bitmapId = EMbmAvkonQgn_graf_bar_wait_increm_07;

   334             bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_7_mask;

   335             break;

   336         case 7:

   337             aknsItemId = &KAknsIIDQgnGrafBarWaitIncrem08;

   338             bitmapId = EMbmAvkonQgn_graf_bar_wait_increm_08;

   339             bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_7_mask;

   340             break;

   341         case 8:

   342             aknsItemId = &KAknsIIDQgnGrafBarWaitIncrem09;

   343             bitmapId = EMbmAvkonQgn_graf_bar_wait_increm_09;

   344             bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_7_mask;

   345             break;

   346         case 9:

   347             aknsItemId = &KAknsIIDQgnGrafBarWaitIncrem10;

   348             bitmapId = EMbmAvkonQgn_graf_bar_wait_increm_10;

   349             bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_7_mask;

   350             break;

   351         case 10:

   352             aknsItemId = &KAknsIIDQgnGrafBarWaitIncrem11;

   353             bitmapId = EMbmAvkonQgn_graf_bar_wait_increm_11;

   354             bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_7_mask;

   355             break;

   356         case 11:

   357             aknsItemId = &KAknsIIDQgnGrafBarWaitIncrem12;

   358             bitmapId = EMbmAvkonQgn_graf_bar_wait_increm_12;

   359             bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_7_mask;

   360             break;

   361         case 12:

   362             aknsItemId = &KAknsIIDQgnGrafBarWaitIncrem13;

   363             bitmapId = EMbmAvkonQgn_graf_bar_wait_increm_13;

   364             bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_7_mask;

   365             break;

   366         case 13:

   367             aknsItemId = &KAknsIIDQgnGrafBarWaitIncrem14;

   368             bitmapId = EMbmAvkonQgn_graf_bar_wait_increm_14;

   369             bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_7_mask;

   370             break;

   371         case 14:

   372             aknsItemId = &KAknsIIDQgnGrafBarWaitIncrem15;

   373             bitmapId = EMbmAvkonQgn_graf_bar_wait_increm_15;

   374             bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_7_mask;

   375             break;

   376         case 15:

   377             aknsItemId = &KAknsIIDQgnGrafBarWaitIncrem16;

   378             bitmapId = EMbmAvkonQgn_graf_bar_wait_increm_16;

   379             bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_7_mask;

   380             break;

   381         case 16:

   382             aknsItemId = &KAknsIIDQgnGrafBarWaitIncrem17;

   383             bitmapId = EMbmAvkonQgn_graf_bar_wait_increm_17;

   384             bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_7_mask;

   385             break;

   386         case 17:

   387             aknsItemId = &KAknsIIDQgnGrafBarWaitIncrem18;

   388             bitmapId = EMbmAvkonQgn_graf_bar_wait_increm_18;

   389             bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_7_mask;

   390             break;

   391         default:

   392             aknsItemId = &KAknsIIDQgnGrafBarWaitIncrem19;

   393             bitmapId = EMbmAvkonQgn_graf_bar_wait_increm_19;

   394             bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_7_mask;

   395             break;

   396         }

   397 

   398         AknsUtils::CreateIconL(skinInstance, *aknsItemId, bitmap,

   399                                bitmapMask, avkonbmpFilename, bitmapId, bitmapMaskId);

   400 

   401         TInt appendErr1 = iGaugeFrameData->iIncUpdBitmap.Append(bitmap);

   402         TInt appendErr2 = iGaugeFrameData->iIncUpdBitmapMask.Append(bitmapMask);

   403 

   404         if (appendErr1 != KErrNone)

   405         {

   406             delete bitmap;

   407         }

   408         if (appendErr2 != KErrNone)

   409         {

   410             delete bitmapMask;

   411         }

   412         if ((appendErr1 != KErrNone) || (appendErr2 != KErrNone))

   413         {

   414             User::LeaveIfError((appendErr1 != KErrNone) ? appendErr1 : appendErr2);

   415         }

   416     }

   417 

   418     // continuous idle bitmap

   419     // (bitmap mask id "EMbmAvkonQgn_graf_bar_wait_idle_mask" is not

   420     // defined and that's why mask for continuous running animation is used instead)

   421     AknsUtils::CreateIconL(skinInstance, KAknsIIDQgnGrafBarWaitIdle,

   422                            iGaugeFrameData->iContIdleBitmap,

   423                            iGaugeFrameData->iContIdleBitmapMask,

   424                            avkonbmpFilename,

   425                            EMbmAvkonQgn_graf_bar_wait_idle, EMbmAvkonQgn_graf_bar_wait_1_mask);

   426 

   427     // incremental idle bitmap

   428     // (bitmap mask id "EMbmAvkonQgn_graf_bar_wait_increm_idle_mask" is not

   429     // defined and that's why mask for continuous running animation is used instead)

   430     AknsUtils::CreateIconL(skinInstance, KAknsIIDQgnGrafBarWaitIncremIdle,

   431                            iGaugeFrameData->iIncIdleBitmap,

   432                            iGaugeFrameData->iIncIdleBitmapMask,

   433                            avkonbmpFilename,

   434                            EMbmAvkonQgn_graf_bar_wait_increm_idle,

   435                            EMbmAvkonQgn_graf_bar_wait_1_mask);

   436 

   437     // bar frame bitmaps (left, center and right part of frame)

   438     AknsUtils::CreateIconL(skinInstance, KAknsIIDQgnGrafBarFrameSideL,

   439                            iGaugeFrameData->iFrameL, iGaugeFrameData->iFrameLMask,

   440                            avkonbmpFilename, EMbmAvkonQgn_graf_bar_frame_side_l,

   441                            EMbmAvkonQgn_graf_bar_frame_side_l_mask);

   442 

   443     AknsUtils::CreateIconL(skinInstance, KAknsIIDQgnGrafBarFrameCenter,

   444                            iGaugeFrameData->iFrameCenter, iGaugeFrameData->iFrameCenterMask,

   445                            avkonbmpFilename, EMbmAvkonQgn_graf_bar_frame_center,

   446                            EMbmAvkonQgn_graf_bar_frame_center_mask);

   447 

   448     AknsUtils::CreateIconL(skinInstance, KAknsIIDQgnGrafBarFrameSideR,

   449                            iGaugeFrameData->iFrameR, iGaugeFrameData->iFrameRMask,

   450                            avkonbmpFilename, EMbmAvkonQgn_graf_bar_frame_side_r,

   451                            EMbmAvkonQgn_graf_bar_frame_side_r_mask);

   452 }

   453 

   454 

   455 void CMIDGaugeItem::DeleteBitmapsInTls()

   456 {

   457     // check if thread-local bitmap storage is created

   458     if (!iGaugeFrameData)

   459     {

   460         return;

   461     }

   462 

   463     // continuous running bitmaps

   464     TInt i;

   465 

   466     for (i=0; i < iGaugeFrameData->iContRunBitmap.Count(); i++)

   467     {

   468         delete iGaugeFrameData->iContRunBitmap[i];

   469     }

   470     iGaugeFrameData->iContRunBitmap.Reset();

   471 

   472     for (i=0; i < iGaugeFrameData->iContRunBitmapMask.Count(); i++)

   473     {

   474         delete iGaugeFrameData->iContRunBitmapMask[i];

   475     }

   476     iGaugeFrameData->iContRunBitmapMask.Reset();

   477 

   478     // incremental updating bitmaps

   479     for (i=0; i < iGaugeFrameData->iIncUpdBitmap.Count(); i++)

   480     {

   481         delete iGaugeFrameData->iIncUpdBitmap[i];

   482     }

   483     iGaugeFrameData->iIncUpdBitmap.Reset();

   484 

   485     for (i=0; i < iGaugeFrameData->iIncUpdBitmapMask.Count(); i++)

   486     {

   487         delete iGaugeFrameData->iIncUpdBitmapMask[i];

   488     }

   489     iGaugeFrameData->iIncUpdBitmapMask.Reset();

   490 

   491     // continuous idle bitmap

   492     delete iGaugeFrameData->iContIdleBitmap;

   493     iGaugeFrameData->iContIdleBitmap = NULL;

   494 

   495     delete iGaugeFrameData->iContIdleBitmapMask;

   496     iGaugeFrameData->iContIdleBitmapMask = NULL;

   497 

   498     // incremental idle bitmap

   499     delete iGaugeFrameData->iIncIdleBitmap;

   500     iGaugeFrameData->iIncIdleBitmap = NULL;

   501 

   502     delete iGaugeFrameData->iIncIdleBitmapMask;

   503     iGaugeFrameData->iIncIdleBitmapMask = NULL;

   504 

   505     // frame bitmaps

   506     delete iGaugeFrameData->iFrameL;

   507     iGaugeFrameData->iFrameL = NULL;

   508 

   509     delete iGaugeFrameData->iFrameLMask;

   510     iGaugeFrameData->iFrameLMask = NULL;

   511 

   512     delete iGaugeFrameData->iFrameCenter;

   513     iGaugeFrameData->iFrameCenter = NULL;

   514 

   515     delete iGaugeFrameData->iFrameCenterMask;

   516     iGaugeFrameData->iFrameCenterMask = NULL;

   517 

   518     delete iGaugeFrameData->iFrameR;

   519     iGaugeFrameData->iFrameR = NULL;

   520 

   521     delete iGaugeFrameData->iFrameRMask;

   522     iGaugeFrameData->iFrameRMask = NULL;

   523 }

   524 

   525 

   526 void CMIDGaugeItem::ResizeBitmapsInTlsL()

   527 {

   528     // check if thread-local bitmap storage is created

   529     if (!iGaugeFrameData)

   530     {

   531         return;

   532     }

   533 

   534     // get layout info

   535     TRect formRect;

   536     TRect waitGaugeRect;

   537     TRect waitGaugeBarRect;

   538     TRect waitGaugeBarFrameLRect;

   539     TRect waitGaugeBarFrameCRect;

   540     TRect waitGaugeBarFrameRRect;

   541     TAknLayoutRect layoutRect;

   542     TSize waitGaugeBarRectSize;

   543 

   544     formRect = FormClientAreaRect();

   545 

   546     layoutRect.LayoutRect(formRect,

   547                           AknLayoutScalable_Avkon::form2_midp_gauge_wait_pane().LayoutLine());

   548     waitGaugeRect = layoutRect.Rect();

   549 

   550     layoutRect.LayoutRect(waitGaugeRect,

   551                           AknLayoutScalable_Avkon::form2_midp_wait_pane(1).LayoutLine());

   552     waitGaugeBarRect = layoutRect.Rect();

   553 

   554     layoutRect.LayoutRect(waitGaugeBarRect,

   555                           AknLayoutScalable_Avkon::form2_midp_wait_pane_g1().LayoutLine());

   556     waitGaugeBarFrameLRect = layoutRect.Rect();

   557 

   558     layoutRect.LayoutRect(waitGaugeBarRect,

   559                           AknLayoutScalable_Avkon::form2_midp_wait_pane_g2().LayoutLine());

   560     waitGaugeBarFrameCRect = layoutRect.Rect();

   561 

   562     layoutRect.LayoutRect(waitGaugeBarRect,

   563                           AknLayoutScalable_Avkon::form2_midp_wait_pane_g3().LayoutLine());

   564     waitGaugeBarFrameRRect = layoutRect.Rect();

   565 

   566     waitGaugeBarRectSize = waitGaugeBarRect.Size();

   567 

   568     // resize bitmaps

   569     TInt i;

   570 

   571     // continuous running bitmaps

   572     for (i=0; i < iGaugeFrameData->iContRunBitmap.Count(); i++)

   573     {

   574         CFbsBitmap* bitmap = iGaugeFrameData->iContRunBitmap[i];

   575 

   576         if (bitmap->SizeInPixels() != waitGaugeBarRectSize)

   577         {

   578             User::LeaveIfError(AknIconUtils::SetSize(bitmap,

   579                                waitGaugeBarRectSize, EAspectRatioNotPreserved));

   580         }

   581     }

   582 

   583     for (i=0; i < iGaugeFrameData->iContRunBitmapMask.Count(); i++)

   584     {

   585         CFbsBitmap* bitmap = iGaugeFrameData->iContRunBitmapMask[i];

   586 

   587         if (bitmap->SizeInPixels() != waitGaugeBarRectSize)

   588         {

   589             User::LeaveIfError(AknIconUtils::SetSize(bitmap,

   590                                waitGaugeBarRectSize, EAspectRatioNotPreserved));

   591         }

   592     }

   593 

   594     // incremental updating bitmaps

   595     for (i=0; i < iGaugeFrameData->iIncUpdBitmap.Count(); i++)

   596     {

   597         CFbsBitmap* bitmap = iGaugeFrameData->iIncUpdBitmap[i];

   598 

   599         if (bitmap->SizeInPixels() != waitGaugeBarRectSize)

   600         {

   601             User::LeaveIfError(AknIconUtils::SetSize(bitmap,

   602                                waitGaugeBarRectSize, EAspectRatioNotPreserved));

   603         }

   604     }

   605 

   606     for (i=0; i < iGaugeFrameData->iIncUpdBitmapMask.Count(); i++)

   607     {

   608         CFbsBitmap* bitmap = iGaugeFrameData->iIncUpdBitmapMask[i];

   609 

   610         if (bitmap->SizeInPixels() != waitGaugeBarRectSize)

   611         {

   612             User::LeaveIfError(AknIconUtils::SetSize(bitmap,

   613                                waitGaugeBarRectSize, EAspectRatioNotPreserved));

   614         }

   615     }

   616 

   617     // continuous idle bitmap

   618     if (iGaugeFrameData->iContIdleBitmap && (iGaugeFrameData->

   619             iContIdleBitmap->SizeInPixels() != waitGaugeBarRectSize))

   620     {

   621         User::LeaveIfError(AknIconUtils::SetSize(

   622                                iGaugeFrameData->iContIdleBitmap, waitGaugeBarRectSize,

   623                                EAspectRatioNotPreserved));

   624     }

   625 

   626     if (iGaugeFrameData->iContIdleBitmapMask && (iGaugeFrameData->

   627             iContIdleBitmapMask->SizeInPixels() != waitGaugeBarRectSize))

   628     {

   629         User::LeaveIfError(AknIconUtils::SetSize(

   630                                iGaugeFrameData->iContIdleBitmapMask, waitGaugeBarRectSize,

   631                                EAspectRatioNotPreserved));

   632     }

   633 

   634     // incremental idle bitmap

   635     if (iGaugeFrameData->iIncIdleBitmap && (iGaugeFrameData->

   636                                             iIncIdleBitmap->SizeInPixels() != waitGaugeBarRectSize))

   637     {

   638         User::LeaveIfError(AknIconUtils::SetSize(

   639                                iGaugeFrameData->iIncIdleBitmap, waitGaugeBarRectSize,

   640                                EAspectRatioNotPreserved));

   641     }

   642 

   643     if (iGaugeFrameData->iIncIdleBitmapMask && (iGaugeFrameData->

   644             iIncIdleBitmapMask->SizeInPixels() != waitGaugeBarRectSize))

   645     {

   646         User::LeaveIfError(AknIconUtils::SetSize(

   647                                iGaugeFrameData->iIncIdleBitmapMask, waitGaugeBarRectSize,

   648                                EAspectRatioNotPreserved));

   649     }

   650 

   651     // frame bitmaps

   652     if (iGaugeFrameData->iFrameL && (iGaugeFrameData->

   653                                      iFrameL->SizeInPixels() != waitGaugeBarFrameLRect.Size()))

   654     {

   655         User::LeaveIfError(AknIconUtils::SetSize(

   656                                iGaugeFrameData->iFrameL, waitGaugeBarFrameLRect.Size(),

   657                                EAspectRatioNotPreserved));

   658     }

   659 

   660     if (iGaugeFrameData->iFrameLMask && (iGaugeFrameData->

   661                                          iFrameLMask->SizeInPixels() != waitGaugeBarFrameLRect.Size()))

   662     {

   663         User::LeaveIfError(AknIconUtils::SetSize(

   664                                iGaugeFrameData->iFrameLMask, waitGaugeBarFrameLRect.Size(),

   665                                EAspectRatioNotPreserved));

   666     }

   667 

   668     if (iGaugeFrameData->iFrameCenter && (iGaugeFrameData->

   669                                           iFrameCenter->SizeInPixels() != waitGaugeBarFrameCRect.Size()))

   670     {

   671         User::LeaveIfError(AknIconUtils::SetSize(

   672                                iGaugeFrameData->iFrameCenter, waitGaugeBarFrameCRect.Size(),

   673                                EAspectRatioNotPreserved));

   674     }

   675 

   676     if (iGaugeFrameData->iFrameCenterMask && (iGaugeFrameData->

   677             iFrameCenterMask->SizeInPixels() != waitGaugeBarFrameCRect.Size()))

   678     {

   679         User::LeaveIfError(AknIconUtils::SetSize(

   680                                iGaugeFrameData->iFrameCenterMask, waitGaugeBarFrameCRect.Size(),

   681                                EAspectRatioNotPreserved));

   682     }

   683 

   684     if (iGaugeFrameData->iFrameR && (iGaugeFrameData->

   685                                      iFrameR->SizeInPixels() != waitGaugeBarFrameRRect.Size()))

   686     {

   687         User::LeaveIfError(AknIconUtils::SetSize(

   688                                iGaugeFrameData->iFrameR, waitGaugeBarFrameRRect.Size(),

   689                                EAspectRatioNotPreserved));

   690     }

   691 

   692     if (iGaugeFrameData->iFrameRMask && (iGaugeFrameData->

   693                                          iFrameRMask->SizeInPixels() != waitGaugeBarFrameRRect.Size()))

   694     {

   695         User::LeaveIfError(AknIconUtils::SetSize(

   696                                iGaugeFrameData->iFrameRMask, waitGaugeBarFrameRRect.Size(),

   697                                EAspectRatioNotPreserved));

   698     }

   699 }

   700 

   701 

   702 void CMIDGaugeItem::ColorChange(TInt aType)

   703 {

   704     // call default implementation

   705     CMIDControlItem::ColorChange(aType);

   706 

   707     // recreate bitmaps (current bitmaps are deleted in CreateBitmapsInTlsBitmapsL())

   708     TRAPD(createErr, CreateBitmapsInTlsL());

   709 

   710     if (createErr != KErrNone)

   711     {

   712         DEBUG_INT("CMIDGaugeItem::ColorChange() - Exception from CreateBitmapsInTlsL. Error = %d ", createErr);

   713     }

   714 

   715     TRAPD(resizeErr, ResizeBitmapsInTlsL());

   716 

   717     if (resizeErr != KErrNone)

   718     {

   719         DEBUG_INT("CMIDGaugeItem::ColorChange() - Exception from ResizeBitmapsInTlsL. Error = %d ", resizeErr);

   720     }

   721 }

   722 

   723 void CMIDGaugeItem::HandleForegroundL(TBool aForeground)

   724 {

   725     // synchronize foreground flag

   726     iIsInForeground = aForeground;

   727 

   728     // if continuous-running ni-gauge is in foreground and it's timer

   729     // is not created then create it else if gauge is in background

   730     // and if it is inserted in form then dispose it's timer

   731     if (iIsInForeground)

   732     {

   733         if ((iIndefiniteState == EContinuousRunning) && (!iTimer))

   734         {

   735             iTimer = CGaugeTimer::NewL(*this);

   736             iTimer->After(TTimeIntervalMicroSeconds32(KDelayInMicroSeconds));

   737         }

   738     }

   739     else if (iForm)

   740     {

   741         DisposeTimer();

   742     }

   743 }

   744 

   745 void CMIDGaugeItem::SetStateL(TInt aMaxValue,TInt aValue)

   746 {

   747     iIndefinite = (aMaxValue == EIndefinite) ? ETrue : EFalse;

   748 

   749     if (iIndefinite)

   750     {

   751         iIndefiniteState = aValue;

   752         iValue = 0;

   753         switch (aValue)

   754         {

   755         case EContinuousIdle:

   756         case EIncrementalIdle:

   757             DisposeTimer();

   758             break;

   759         case EContinuousRunning:

   760             if (!iTimer)

   761             {

   762                 iTimer = CGaugeTimer::NewL(*this);

   763                 iTimer->After(TTimeIntervalMicroSeconds32(KDelayInMicroSeconds));

   764             }

   765             break;

   766         case EIncrementalUpdating:

   767             DisposeTimer();

   768             break;

   769         default:

   770             ASSERT(EFalse);

   771         }

   772     }

   773     else

   774     {

   775     }

   776     //

   777     // We're now back in normal mode

   778     //

   779 }

   780 

   781 #ifdef RD_SCALABLE_UI_V2

   782 void CMIDGaugeItem::HandlePointerEventL(const TPointerEvent& aPointerEvent)

   783 {

   784     if (AknLayoutUtils::PenEnabled())

   785     {

   786         if (IsSelectable())

   787         {

   788             CMIDControlItem::HandlePointerEventL(aPointerEvent);

   789         }

   790     }

   791 }

   792 #endif // RD_SCALABLE_UI_V2

   793 

   794 

   795 /**

   796  * An interactive Gauge will always be selectable. A non-interactive

   797  * Gauge will only be selectable if it has at least one Command.

   798  */

   799 TBool CMIDGaugeItem::IsSelectable() const

   800 {

   801     return (iCommandList->Count() > 0 || !IsNonFocusing());

   802 }

   803 

   804 void CMIDGaugeItem::DisposeTimer()

   805 {

   806     if (iTimer)

   807         iTimer->Cancel();

   808     delete iTimer;

   809     iTimer = NULL;

   810 }

   811 

   812 void CMIDGaugeItem::FocusChanged(TDrawNow aDrawNow)

   813 {

   814     CMIDControlItem::FocusChanged(aDrawNow);

   815 }

   816 

   817 void CMIDGaugeItem::SetLabelL(const TDesC& aLabel)

   818 {

   819     CMIDControlItem::SetLabelL(aLabel);

   820 }

   821 

   822 void CMIDGaugeItem::SetLayoutL(TLayout aLayout)

   823 {

   824     CMIDItem::SetLayoutL(aLayout);

   825 }

   826 

   827 void CMIDGaugeItem::Dispose()

   828 {

   829     delete this;

   830 }

   831 

   832 void CMIDGaugeItem::AddCommandL(MMIDCommand* aCommand)

   833 {

   834     CMIDItem::AddCommandL(aCommand);

   835 }

   836 

   837 void CMIDGaugeItem::RemoveCommand(MMIDCommand* aCommand)

   838 {

   839     CMIDItem::RemoveCommand(aCommand);

   840 }

   841 

   842 void CMIDGaugeItem::SetDefaultCommand(MMIDCommand* aCommand)

   843 {

   844     CMIDItem::SetDefaultCommand(aCommand);

   845 }

   846 

   847 void CMIDGaugeItem::SetPreferredSizeL(const TSize& aSize)

   848 {

   849     CMIDItem::SetPreferredSize(aSize,MinimumSize());

   850 }

   851 

   852 TSize CMIDGaugeItem::PreferredSize() const

   853 {

   854     return ResetPreferredSize();

   855 }

   856 

   857 TSize CMIDGaugeItem::MinimumSize() const

   858 {

   859     CCoeControl* control = const_cast<CMIDGaugeItem*>(this);

   860     return control->MinimumSize();

   861 }

   862 

   863 TInt CMIDGaugeItem::GetIndefiniteState() const

   864 {

   865     return iIndefiniteState;

   866 }

   867 //////////////////////////////////////////////////////////////////////////////

   868 

   869 // ---------------------------------------------------------------------------

   870 //

   871 // ---------------------------------------------------------------------------

   872 //

   873 MMIDGauge* CMIDNonInteractiveGauge::NewL(

   874     const TDesC& aLabel,TInt aMaxValue,TInt aInitialValue, CMIDUIManager* aUIManager)

   875 {

   876     CMIDNonInteractiveGauge* self = new(ELeave) CMIDNonInteractiveGauge(aUIManager);

   877     CleanupStack::PushL(self);

   878     self->BaseConstructL(aLabel, aMaxValue, aInitialValue);

   879     self->ConstructL();

   880     CleanupStack::Pop(self);

   881     return self;

   882 }

   883 

   884 CMIDNonInteractiveGauge::~CMIDNonInteractiveGauge()

   885 {

   886     DisposeTimer();

   887     delete iProgressInfo;

   888     delete iBitmapAnimation;

   889 }

   890 

   891 // ---------------------------------------------------------------------------

   892 //

   893 // ---------------------------------------------------------------------------

   894 //

   895 CMIDNonInteractiveGauge::CMIDNonInteractiveGauge(CMIDUIManager* aUIManager)

   896         : CMIDGaugeItem(aUIManager),

   897         iBitmapAnimation(NULL)

   898 {

   899     SetFocusing(EFalse);

   900 }

   901 

   902 void CMIDNonInteractiveGauge::ConstructL()

   903 {

   904     UpdateMemberVariables();

   905     ConstructProgressInfoL();

   906     ActivateL();

   907 }

   908 

   909 void CMIDNonInteractiveGauge::UpdateMemberVariables()

   910 {

   911     TRect formRect = FormClientAreaRect();

   912 

   913     iWaitGaugeRect.LayoutRect(formRect,

   914                               AknLayoutScalable_Avkon::form2_midp_gauge_wait_pane().LayoutLine());

   915 

   916     iWaitBarRect.LayoutRect(iWaitGaugeRect.Rect(),

   917                             AknLayoutScalable_Avkon::form2_midp_wait_pane(1).LayoutLine());

   918 

   919     iWaitBarSize = iWaitBarRect.Rect().Size();

   920 

   921     // WaitBar position in relation to CCoeControl (CMIDControlItem Rect) area

   922     // Note that label height has to be added to the y coordinate

   923     iProgressInfoWithLabelHeightTl = iWaitBarRect.Rect().iTl - formRect.iTl;

   924 

   925     iItemheightWithoutLabel = iWaitGaugeRect.Rect().Height() +

   926                               iWaitGaugeRect.Rect().iTl.iY - formRect.iTl.iY + ItemContentBottomMargin();

   927 }

   928 

   929 void CMIDNonInteractiveGauge::ConstructProgressInfoL()

   930 {

   931     ASSERT(!iProgressInfo);

   932 

   933     CEikProgressInfo::SInfo info;

   934     info.iFinalValue = iIndefinite ? 100 : iMaxValue;

   935     info.iSplitsInBlock = 0;

   936     info.iTextType = EEikProgressTextPercentage;

   937 

   938     info.iWidth = iWaitBarSize.iWidth;

   939     info.iHeight = iWaitBarSize.iHeight;

   940 

   941     iProgressInfo = new(ELeave) CEikProgressInfo(info);

   942     iProgressInfo->ConstructL();

   943     iProgressInfo->SetContainerWindowL(*this);

   944     iProgressInfo->SetAndDraw(iValue);

   945 

   946     if (IsActivated())

   947     {

   948         iProgressInfo->ActivateL();

   949     }

   950 }

   951 

   952 void CMIDNonInteractiveGauge::SetValueL(TInt aValue)

   953 {

   954     if (iIndefinite)

   955     {

   956         // indefinite gauge will not be updated when it is inserted in form

   957         // and the form is sent to background

   958         TBool updateGauge = (iForm) ? iIsInForeground : ETrue;

   959 

   960         // update gauge state

   961         TInt oldIndefiniteState = iIndefiniteState;

   962         iIndefiniteState = aValue;

   963 

   964         switch (iIndefiniteState)

   965         {

   966         case EContinuousIdle:

   967             iValue = 0;

   968             DisposeTimer();

   969             break;

   970         case EIncrementalIdle:

   971             iValue = 0;

   972             DisposeTimer();

   973             break;

   974         case EContinuousRunning:

   975             if (!iTimer && updateGauge)

   976             {

   977                 iTimer = CGaugeTimer::NewL(*this);

   978                 iTimer->After(TTimeIntervalMicroSeconds32(KDelayInMicroSeconds));

   979             }

   980             break;

   981         case EIncrementalUpdating:

   982             DisposeTimer();

   983 

   984             // update gauge's state

   985             if (updateGauge)

   986             {

   987                 if (iIndefiniteState != oldIndefiniteState)

   988                 {

   989                     iValue = -1;

   990                 }

   991                 iValue++;

   992                 if (iGaugeFrameData && iValue >= iGaugeFrameData->iIncUpdBitmap.Count())

   993                 {

   994                     iValue = 0;

   995                 }

   996             }

   997             break;

   998         default:

   999             ASSERT(EFalse);

  1000         }

  1001 

  1002         // update gauge in alert

  1003         if (iGaugeToAlertListner)

  1004         {

  1005             iGaugeToAlertListner->UpdateGaugeInAlertL(iValue);

  1006         }

  1007 

  1008         // eventually notify alert dialog that indefinite state changed

  1009         if (iGaugeToAlertListner && (iIndefiniteState != oldIndefiniteState))

  1010         {

  1011             iGaugeToAlertListner->GaugeTypeInAlertChangedL();

  1012         }

  1013 

  1014         // redraw gauge if it should be updated or if it's type changed

  1015         if (updateGauge || (iIndefiniteState != oldIndefiniteState))

  1016         {

  1017             DoSafeDraw();

  1018         }

  1019     }

  1020     else

  1021     {

  1022         iValue = aValue;

  1023 

  1024         if (iGaugeToAlertListner)

  1025         {

  1026             iGaugeToAlertListner->UpdateGaugeInAlertL(iValue);

  1027         }

  1028 

  1029         DoSafeDraw();

  1030     }

  1031 }

  1032 

  1033 void CMIDNonInteractiveGauge::SetGaugeListenerFromAlert(

  1034     MMIDGaugeToAlertListner* aGaugeToAlertListner)

  1035 {

  1036     iGaugeToAlertListner = aGaugeToAlertListner;

  1037 }

  1038 

  1039 void CMIDNonInteractiveGauge::SetMaxValueL(TInt aMaxValue)

  1040 {

  1041     // is new max value indefinite?

  1042     if (aMaxValue == EIndefinite)

  1043     {

  1044         if (!iIndefinite)

  1045         {

  1046             // set gauge state to indefinite

  1047             iIndefinite = ETrue;

  1048             iMaxValue = EIndefinite;

  1049 

  1050             // set indefinite state to other type than with which

  1051             //  SetValueL function will be called in order to detect change

  1052             //  of gauge type in this function

  1053             iIndefiniteState = EContinuousIdle+1;

  1054             SetValueL(EContinuousIdle);

  1055         }

  1056     }

  1057     else

  1058     {

  1059         // no timer needed for definite gauge

  1060         DisposeTimer();

  1061 

  1062         // set gauge state to definite

  1063         iIndefinite = EFalse;

  1064         iMaxValue = aMaxValue;

  1065 

  1066         // check gauge's value

  1067         if (iValue > iMaxValue)

  1068         {

  1069             iValue = iMaxValue;

  1070         }

  1071         else if (iValue < 0)

  1072         {

  1073             iValue = 0;

  1074         }

  1075 

  1076         // eventually update gauge in alert

  1077         if (iGaugeToAlertListner)

  1078         {

  1079             iGaugeToAlertListner->GaugeTypeInAlertChangedL();

  1080         }

  1081 

  1082         // redraw

  1083         DoSafeDraw();

  1084     }

  1085 }

  1086 

  1087 TSize CMIDNonInteractiveGauge::MinimumSize()

  1088 {

  1089     if (!iLabelControl || (iLabelControl->Text()->Length() == 0))

  1090     { // item doesn't have label

  1091         return TSize(FormClientAreaWidth(), iItemheightWithoutLabel);

  1092     }

  1093     else // item has label

  1094     {

  1095         return TSize(FormClientAreaWidth(),

  1096                      iItemheightWithoutLabel + OneLineLabelHeight());

  1097     }

  1098 }

  1099 

  1100 TInt CMIDNonInteractiveGauge::CountComponentControls() const

  1101 {

  1102     if (iIndefinite)

  1103     {

  1104         return 1; // we will draw the gauge in our Draw() method

  1105     }

  1106     else

  1107     {

  1108         return 2;

  1109     }

  1110 }

  1111 

  1112 CCoeControl* CMIDNonInteractiveGauge::ComponentControl(TInt aIndex) const

  1113 {

  1114     switch (aIndex)

  1115     {

  1116     case 0:

  1117         return iLabelControl;

  1118     case 1:

  1119         return iProgressInfo;

  1120     default:

  1121         return NULL;

  1122     }

  1123 }

  1124 

  1125 /** Unlike other items, this one here draw the backgorund as well because its draw

  1126     method is called without drawing the form first. Other items only draw the control.

  1127 */

  1128 void CMIDNonInteractiveGauge::Draw(const TRect& /*aRect*/) const

  1129 {

  1130     CWindowGc& gc=SystemGc();

  1131 

  1132     // get drawing position

  1133     TRect rect(Rect());

  1134