/*

* Copyright (c) 2003-2006 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Implementation of CMIDGaugeItem

*

*/

#include <coemain.h>

#include <e32std.h>

#include <eikcapc.h>

// CAknSlider - needed for iSlider member

#include <aknslider.h>

// macros for resources

#include <lcdui.rsg>

// using TMifAvkon enumeration

#include <avkon.mbg>

// Api for skin instance

// and creating icons

#include <AknsUtils.h>

// needed CEikProgressInfo API for iProgressInfo member

// control used to indicate the progress of an operation

#include <eikprogi.h>

#include <eikon.hrh>

#include <eikpanic.h>

// using TResourceReader class in ConstructSliderL (interactive gauge)

// interprets resource data read from a resource file

#include <barsread.h>

#include <gulbordr.h>

#include <eikenv.h>

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

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

#include <gulcolor.h>

// using AknsDrawUtils for drawing background

#include <AknsDrawUtils.h>

#include <applayout.cdl.h>

// for MAknsControlContext::SupplyMopObject method

#include <AknsFrameBackgroundControlContext.h>

// LAF

#include <aknlayoutscalable_avkon.cdl.h>

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

#ifdef RD_JAVA_ADVANCED_TACTILE_FEEDBACK

#include <touchfeedback.h>

#endif //RD_JAVA_ADVANCED_TACTILE_FEEDBACK

#include <j2me/jdebug.h>

#include "CMIDGaugeItem.h"

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

#include "CMIDCommandList.h"

// API for iLabelControl (inherited from CMIDControlItem)

#include "CMIDItemLabel.h"

// using TlsStruct for creating bitmap storage

#include "CMIDMenuHandler.h"

#include "CMIDUtils.h"

#include "CMIDUIManager.h"

// Using of CAknBitmapAnimation for iBitmapAnimation

#include <AknBitmapAnimation.h>

//

// Constants

//

const TInt KDelayInMicroSeconds = 50000;

const TInt KContRunningAnimFramesCount = 7;

const TInt KIncUpdatingAnimFramesCount = 19;

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

const TInt KSliderHeightDivider = 3;

// class CGaugeTimer

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

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

{

    CActiveScheduler::Add(this);

}

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

{

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

}

void CMIDGaugeItem::CGaugeTimer::RunL()

{

    if (!iGauge.iGaugeFrameData)

    {

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

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

        //Return without restarting the timer

        return;

    }

    iGauge.iValue++;

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

    {

        iGauge.iValue = 0;

    }

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

    nig->DoSafeDraw();

    After(TTimeIntervalMicroSeconds32(KDelayInMicroSeconds));

}

// class CMIDGaugeItem

TInt CMIDGaugeItem::GetValue()

{

    return iValue;

}

// ---------------------------------------------------------------------------

//

// ---------------------------------------------------------------------------

//

CMIDGaugeItem::CMIDGaugeItem(CMIDUIManager* aUIManager)

        : CMIDControlItem(EDefault, aUIManager),

        iIndefiniteState(EIncrementalIdle),

        iGaugeFrameData(NULL)

{

    iMMidItem = this;

}

CMIDGaugeItem::~CMIDGaugeItem()

{

    if (iGaugeFrameData)

    {

        iGaugeFrameData->iNumInstances--;

        if (!(iGaugeFrameData->iNumInstances))

        {

            // delete bitmaps from thread-local bitmap storage

            DeleteBitmapsInTls();

            iGaugeFrameData->Close();

            delete iGaugeFrameData;

            iUIManager->SetGaugeItemData(NULL);

        }

    }

}

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

{

    DEBUG("CMIDGaugeItem::BaseConstructL <");

    CMIDControlItem::ConstructL();

    SetLabelL(aLabel);

    iLabelControl->SetWidthL(FormClientAreaWidth());

    if (aMaxValue == 0)

    {

        aMaxValue = 1;

    }

    iMaxValue = aMaxValue;

    iValue = aInitialValue;

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

    if (iIndefinite)

    {

        iIndefiniteState = aInitialValue;

        iValue = 0;

    }

    DEBUG("CMIDGaugeItem::BaseConstructL >");

}

void CMIDGaugeItem::CreateBitmapsIfNeededL()

{

    if (iGaugeFrameData)

    {

        return;

    }

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

    if (iGaugeFrameData)

    {

        iGaugeFrameData->iNumInstances++;

    }

    else

    {

        // Create shared data

        iGaugeFrameData = new(ELeave) TGaugeFrameData;

        iGaugeFrameData->Clean();

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

        // Initialize data

        CreateBitmapsInTlsL();

        // Resize data

        ResizeBitmapsInTlsL();

    }

}

void CMIDGaugeItem::CreateBitmapsInTlsL()

{

    // check if thread-local bitmap storage is created

    if (!iGaugeFrameData)

    {

        return;

    }

    // eventually delete existing bitmaps

    DeleteBitmapsInTls();

    // skin instance and default bitmaps file

    MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance();

    TFileName avkonbmpFilename = AknIconUtils::AvkonIconFileName();

    // for bitmap loading

    const TAknsItemID* aknsItemId;

    TInt bitmapId;

    TInt bitmapMaskId;

    CFbsBitmap* bitmap;

    CFbsBitmap* bitmapMask;

    TInt i;

    // continuous running bitmaps

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

    {

        switch (i)

        {

        case 0:

            aknsItemId = &KAknsIIDQgnGrafBarWait1;

            bitmapId = EMbmAvkonQgn_graf_bar_wait_1;

            bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_1_mask;

            break;

        case 1:

            aknsItemId = &KAknsIIDQgnGrafBarWait2;

            bitmapId = EMbmAvkonQgn_graf_bar_wait_2;

            bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_2_mask;

            break;

        case 2:

            aknsItemId = &KAknsIIDQgnGrafBarWait3;

            bitmapId = EMbmAvkonQgn_graf_bar_wait_3;

            bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_3_mask;

            break;

        case 3:

            aknsItemId = &KAknsIIDQgnGrafBarWait4;

            bitmapId = EMbmAvkonQgn_graf_bar_wait_4;

            bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_4_mask;

            break;

        case 4:

            aknsItemId = &KAknsIIDQgnGrafBarWait5;

            bitmapId = EMbmAvkonQgn_graf_bar_wait_5;

            bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_5_mask;

            break;

        case 5:

            aknsItemId = &KAknsIIDQgnGrafBarWait6;

            bitmapId = EMbmAvkonQgn_graf_bar_wait_6;

            bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_6_mask;

            break;

        default:

            aknsItemId = &KAknsIIDQgnGrafBarWait7;

            bitmapId = EMbmAvkonQgn_graf_bar_wait_7;

            bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_7_mask;

            break;

        }

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

                               bitmapMask, avkonbmpFilename, bitmapId, bitmapMaskId);

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

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

        if (appendErr1 != KErrNone)

        {

            delete bitmap;

        }

        if (appendErr2 != KErrNone)

        {

            delete bitmapMask;

        }

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

        {

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

        }

    }

    // incremental updating bitmaps

    // (bitmaps masks ids "EMbmAvkonQgn_graf_bar_wait_increm_mask" -

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

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

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

    {

        switch (i)

        {

        case 0:

            aknsItemId = &KAknsIIDQgnGrafBarWaitIncrem;

            bitmapId = EMbmAvkonQgn_graf_bar_wait_increm;

            bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_1_mask;

            break;

        case 1:

            aknsItemId = &KAknsIIDQgnGrafBarWaitIncrem02;

            bitmapId = EMbmAvkonQgn_graf_bar_wait_increm_02;

            bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_2_mask;

            break;

        case 2:

            aknsItemId = &KAknsIIDQgnGrafBarWaitIncrem03;

            bitmapId = EMbmAvkonQgn_graf_bar_wait_increm_03;

            bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_3_mask;

            break;

        case 3:

            aknsItemId = &KAknsIIDQgnGrafBarWaitIncrem04;

            bitmapId = EMbmAvkonQgn_graf_bar_wait_increm_04;

            bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_4_mask;

            break;

        case 4:

            aknsItemId = &KAknsIIDQgnGrafBarWaitIncrem05;

            bitmapId = EMbmAvkonQgn_graf_bar_wait_increm_05;

            bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_5_mask;

            break;

        case 5:

            aknsItemId = &KAknsIIDQgnGrafBarWaitIncrem06;

            bitmapId = EMbmAvkonQgn_graf_bar_wait_increm_06;

            bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_6_mask;

            break;

        case 6:

            aknsItemId = &KAknsIIDQgnGrafBarWaitIncrem07;

            bitmapId = EMbmAvkonQgn_graf_bar_wait_increm_07;

            bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_7_mask;

            break;

        case 7:

            aknsItemId = &KAknsIIDQgnGrafBarWaitIncrem08;

            bitmapId = EMbmAvkonQgn_graf_bar_wait_increm_08;

            bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_7_mask;

            break;

        case 8:

            aknsItemId = &KAknsIIDQgnGrafBarWaitIncrem09;

            bitmapId = EMbmAvkonQgn_graf_bar_wait_increm_09;

            bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_7_mask;

            break;

        case 9:

            aknsItemId = &KAknsIIDQgnGrafBarWaitIncrem10;

            bitmapId = EMbmAvkonQgn_graf_bar_wait_increm_10;

            bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_7_mask;

            break;

        case 10:

            aknsItemId = &KAknsIIDQgnGrafBarWaitIncrem11;

            bitmapId = EMbmAvkonQgn_graf_bar_wait_increm_11;

            bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_7_mask;

            break;

        case 11:

            aknsItemId = &KAknsIIDQgnGrafBarWaitIncrem12;

            bitmapId = EMbmAvkonQgn_graf_bar_wait_increm_12;

            bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_7_mask;

            break;

        case 12:

            aknsItemId = &KAknsIIDQgnGrafBarWaitIncrem13;

            bitmapId = EMbmAvkonQgn_graf_bar_wait_increm_13;

            bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_7_mask;

            break;

        case 13:

            aknsItemId = &KAknsIIDQgnGrafBarWaitIncrem14;

            bitmapId = EMbmAvkonQgn_graf_bar_wait_increm_14;

            bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_7_mask;

            break;

        case 14:

            aknsItemId = &KAknsIIDQgnGrafBarWaitIncrem15;

            bitmapId = EMbmAvkonQgn_graf_bar_wait_increm_15;

            bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_7_mask;

            break;

        case 15:

            aknsItemId = &KAknsIIDQgnGrafBarWaitIncrem16;

            bitmapId = EMbmAvkonQgn_graf_bar_wait_increm_16;

            bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_7_mask;

            break;

        case 16:

            aknsItemId = &KAknsIIDQgnGrafBarWaitIncrem17;

            bitmapId = EMbmAvkonQgn_graf_bar_wait_increm_17;

            bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_7_mask;

            break;

        case 17:

            aknsItemId = &KAknsIIDQgnGrafBarWaitIncrem18;

            bitmapId = EMbmAvkonQgn_graf_bar_wait_increm_18;

            bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_7_mask;

            break;

        default:

            aknsItemId = &KAknsIIDQgnGrafBarWaitIncrem19;

            bitmapId = EMbmAvkonQgn_graf_bar_wait_increm_19;

            bitmapMaskId = EMbmAvkonQgn_graf_bar_wait_7_mask;

            break;

        }

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

                               bitmapMask, avkonbmpFilename, bitmapId, bitmapMaskId);

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

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

        if (appendErr1 != KErrNone)

        {

            delete bitmap;

        }

        if (appendErr2 != KErrNone)

        {

            delete bitmapMask;

        }

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

        {

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

        }

    }

    // continuous idle bitmap

    // (bitmap mask id "EMbmAvkonQgn_graf_bar_wait_idle_mask" is not

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

    AknsUtils::CreateIconL(skinInstance, KAknsIIDQgnGrafBarWaitIdle,

                           iGaugeFrameData->iContIdleBitmap,

                           iGaugeFrameData->iContIdleBitmapMask,

                           avkonbmpFilename,

                           EMbmAvkonQgn_graf_bar_wait_idle, EMbmAvkonQgn_graf_bar_wait_1_mask);

    // incremental idle bitmap

    // (bitmap mask id "EMbmAvkonQgn_graf_bar_wait_increm_idle_mask" is not

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

    AknsUtils::CreateIconL(skinInstance, KAknsIIDQgnGrafBarWaitIncremIdle,

                           iGaugeFrameData->iIncIdleBitmap,

                           iGaugeFrameData->iIncIdleBitmapMask,

                           avkonbmpFilename,

                           EMbmAvkonQgn_graf_bar_wait_increm_idle,

                           EMbmAvkonQgn_graf_bar_wait_1_mask);

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

    AknsUtils::CreateIconL(skinInstance, KAknsIIDQgnGrafBarFrameSideL,

                           iGaugeFrameData->iFrameL, iGaugeFrameData->iFrameLMask,

                           avkonbmpFilename, EMbmAvkonQgn_graf_bar_frame_side_l,

                           EMbmAvkonQgn_graf_bar_frame_side_l_mask);

    AknsUtils::CreateIconL(skinInstance, KAknsIIDQgnGrafBarFrameCenter,

                           iGaugeFrameData->iFrameCenter, iGaugeFrameData->iFrameCenterMask,

                           avkonbmpFilename, EMbmAvkonQgn_graf_bar_frame_center,

                           EMbmAvkonQgn_graf_bar_frame_center_mask);

    AknsUtils::CreateIconL(skinInstance, KAknsIIDQgnGrafBarFrameSideR,

                           iGaugeFrameData->iFrameR, iGaugeFrameData->iFrameRMask,

                           avkonbmpFilename, EMbmAvkonQgn_graf_bar_frame_side_r,

                           EMbmAvkonQgn_graf_bar_frame_side_r_mask);

}

void CMIDGaugeItem::DeleteBitmapsInTls()

{

    // check if thread-local bitmap storage is created

    if (!iGaugeFrameData)

    {

        return;

    }

    // continuous running bitmaps

    TInt i;

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

    {

        delete iGaugeFrameData->iContRunBitmap[i];

    }

    iGaugeFrameData->iContRunBitmap.Reset();

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

    {

        delete iGaugeFrameData->iContRunBitmapMask[i];

    }

    iGaugeFrameData->iContRunBitmapMask.Reset();

    // incremental updating bitmaps

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

    {

        delete iGaugeFrameData->iIncUpdBitmap[i];

    }

    iGaugeFrameData->iIncUpdBitmap.Reset();

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

    {

        delete iGaugeFrameData->iIncUpdBitmapMask[i];

    }

    iGaugeFrameData->iIncUpdBitmapMask.Reset();

    // continuous idle bitmap

    delete iGaugeFrameData->iContIdleBitmap;

    iGaugeFrameData->iContIdleBitmap = NULL;

    delete iGaugeFrameData->iContIdleBitmapMask;

    iGaugeFrameData->iContIdleBitmapMask = NULL;

    // incremental idle bitmap

    delete iGaugeFrameData->iIncIdleBitmap;

    iGaugeFrameData->iIncIdleBitmap = NULL;

    delete iGaugeFrameData->iIncIdleBitmapMask;

    iGaugeFrameData->iIncIdleBitmapMask = NULL;

    // frame bitmaps

    delete iGaugeFrameData->iFrameL;

    iGaugeFrameData->iFrameL = NULL;

    delete iGaugeFrameData->iFrameLMask;

    iGaugeFrameData->iFrameLMask = NULL;

    delete iGaugeFrameData->iFrameCenter;

    iGaugeFrameData->iFrameCenter = NULL;

    delete iGaugeFrameData->iFrameCenterMask;

    iGaugeFrameData->iFrameCenterMask = NULL;

    delete iGaugeFrameData->iFrameR;

    iGaugeFrameData->iFrameR = NULL;