/*

* Copyright (c) 2002-2008 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:  Control for status pane's signal pane.

*

*/

// INCLUDE FILES

#include <AknSignal.h>

#include <barsread.h>

#include <eikspane.h>

#include <avkon.mbg>

#include <AknsDrawUtils.h>

#include <AknsUtils.h>

#include <AknIconUtils.h>

#include <AknUtils.h>

#include <aknconsts.h>

#include <aknenv.h>

#include <AknStatuspaneUtils.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <AknDef.h>

#include <AknTasHook.h>

#include "AknSignalIcon.h"

#include "AknSignalStrength.h"

#include "aknsignaldataobserver.h"

/** Frame delay for signal state animations. */

const TInt KAknIndicatorAnimationDelay    = 500000; // microseconds

/** Frame interval for signal state animations. */

const TInt KAknIndicatorAnimationInterval = 500000; // microseconds

/** Number of bitmap frames for CDMA animations. */

const TInt KAknCdmaAnimationFrames = 14;

// Flags for Signal Pane

enum TSignalPaneControlFlags

    {

    EAknSignalPaneButton1DownInSignalRect = 0x00000001

    };

class CAknSignalPaneExtension: public CBase

    {

public:

    CAknSignalPaneExtension();

    ~CAknSignalPaneExtension();

public: // new methods

    TBool CdmaSignalIconInUse();

    CFbsBitmap* CdmaSignalIcon();

    void CdmaSignalAnimate();

public:

    // General signal indicators

    TAny* iSpare1; // was iSignalIcon

    TAny* iSpare2; // was iSignalIconMask

    // CDMA Signal indicators

    TInt        iCdmaAnimationIndex;

    TInt        iCdmaSignalState;

    CFbsBitmap* iCdmaReceiveIcons[KAknCdmaAnimationFrames];  // animation frames

    CFbsBitmap* iCdmaReceiveMasks[KAknCdmaAnimationFrames];  // animation frame masks (needed because of AknIconUtils)

    CFbsBitmap* iCdmaSendIcons[KAknCdmaAnimationFrames];     // animation frames

    CFbsBitmap* iCdmaSendMasks[KAknCdmaAnimationFrames];     // animation frame masks (needed because of AknIconUtils)

    CFbsBitmap* iCdmaStaticIcons[5];    // non-animated icons

    CFbsBitmap* iCdmaStaticMasks[5];    // non-animated masks (needed because of AknIconUtils)

    CEikStatusPaneBase*      iStatusPane;

    };

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

// CAknSignalPaneExtension::CAknSignalPaneExtension

// Default constructor.

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

//

CAknSignalPaneExtension::CAknSignalPaneExtension()

    {

    }

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

// CAknSignalPaneExtension::~CAknSignalPaneExtension

// Destructor

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

//

CAknSignalPaneExtension::~CAknSignalPaneExtension()

    {

    }

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

// CAknSignalPaneExtension::CdmaSignalIconInUse

// Determine if any CDMA indicator is being used.

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

//

TBool CAknSignalPaneExtension::CdmaSignalIconInUse()

    {

    if ( iCdmaSignalState != EAknSignalCdmaIndicatorOff )

        {

        return ETrue;

        }

    return EFalse;

    }

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

// CAknSignalPaneExtension::CdmaSignalIcon

// Get the current CDMA icon to be displayed.

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

//

CFbsBitmap* CAknSignalPaneExtension::CdmaSignalIcon()

    {

    if ( iCdmaSignalState == EAknSignalCdmaIndicatorReceiving )

        {

        return iCdmaReceiveMasks[iCdmaAnimationIndex];

        }

    else if ( iCdmaSignalState == EAknSignalCdmaIndicatorSending )

        {

        return iCdmaSendMasks[iCdmaAnimationIndex];

        }

    else

        {

        return iCdmaStaticMasks[iCdmaSignalState - EAknSignalCdmaIndicatorNoService];

        }

    }

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

// CAknSignalPaneExtension::CdmaSignalAnimate

// Adjusts the animation of the CDMA signal icon.

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

//

void CAknSignalPaneExtension::CdmaSignalAnimate()

    {

    iCdmaAnimationIndex++;

    if ( iCdmaAnimationIndex >= KAknCdmaAnimationFrames )

        {

        iCdmaAnimationIndex = 0;

        }

    }

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

// CAknSignalPane::CAknSignalPane

// Default contructor.

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

//

EXPORT_C CAknSignalPane::CAknSignalPane()

    {

    AKNTASHOOK_ADD( this, "CAknSignalPane" );

    }

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

// CAknSignalPane::~CAknSignalPane

// Destructor

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

//

EXPORT_C CAknSignalPane::~CAknSignalPane()

    {

    AKNTASHOOK_REMOVE();

    AknsUtils::DeregisterControlPosition( this );

    delete iDataObserver;

    delete iTicker;

    for ( TInt ll = 0; ll < KAknCdmaAnimationFrames; ll++ )

        {

        delete iExtension->iCdmaReceiveIcons[ll];

        delete iExtension->iCdmaReceiveMasks[ll];

        }

    for ( TInt mm = 0; mm < KAknCdmaAnimationFrames; mm++ )

        {

        delete iExtension->iCdmaSendIcons[mm];

        delete iExtension->iCdmaSendMasks[mm];

        }

    for ( TInt nn = 0; nn < 5; nn++ )

        {

        delete iExtension->iCdmaStaticIcons[nn];

        delete iExtension->iCdmaStaticMasks[nn];

        }

    delete iSignalIconControl;

    delete iSignalStrengthControl;

    delete iExtension;

    }

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

// CAknSignalPane::ConstructL

// Second-phase constructor.

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

//

EXPORT_C void CAknSignalPane::ConstructL()

    {

    iExtension = new (ELeave) CAknSignalPaneExtension();

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

#ifdef __PROTOCOL_CDMA

    // Create CDMA indicator icons

    for ( TInt mm = 0; mm < KAknCdmaAnimationFrames; mm++ )

        {

        AknIconUtils::CreateIconL(

            iExtension->iCdmaReceiveIcons[mm],

            iExtension->iCdmaReceiveMasks[mm],

            AknIconUtils::AvkonIconFileName(),

            EMbmAvkonQgn_indi_signal_receiving_cdma_01 + mm,

            EMbmAvkonQgn_indi_signal_receiving_cdma_01 + mm );

        AknIconUtils::CreateIconL(

            iExtension->iCdmaSendIcons[mm],

            iExtension->iCdmaSendMasks[mm],

            AknIconUtils::AvkonIconFileName(),

            EMbmAvkonQgn_indi_signal_sending_cdma_01 + mm,

            EMbmAvkonQgn_indi_signal_sending_cdma_01 + mm );

        }

    // No service

    AknsUtils::CreateColorIconL(

        skin,

        KAknsIIDQgnIndiSignalNoService,

        iExtension->iCdmaStaticIcons[0],

        iExtension->iCdmaStaticMasks[0],

        AknIconUtils::AvkonIconFileName(),

        EMbmAvkonQgn_indi_signal_no_service,

        EMbmAvkonQgn_indi_signal_no_service );

     // Packet data available, uses standard signal icon

    AknsUtils::CreateColorIconL(

        skin,

        KAknsIIDQgnPropSignalIcon,

        iExtension->iCdmaStaticIcons[1],

        iExtension->iCdmaStaticMasks[1],

        AknIconUtils::AvkonIconFileName(),

        EMbmAvkonQgn_prop_signal_icon,

        EMbmAvkonQgn_prop_signal_icon );

    // Packet data unavailable

    AknsUtils::CreateColorIconL(

        skin,

        KAknsIIDQgnIndiSignalNotAvailCdma,

        iExtension->iCdmaStaticIcons[2],

        iExtension->iCdmaStaticMasks[2],

        AknIconUtils::AvkonIconFileName(),

        EMbmAvkonQgn_indi_signal_not_avail_cdma,

        EMbmAvkonQgn_indi_signal_not_avail_cdma );

    // Packet data active

    AknsUtils::CreateColorIconL(

        skin,

        KAknsIIDQgnIndiSignalActiveCdma,

        iExtension->iCdmaStaticIcons[3],

        iExtension->iCdmaStaticMasks[3],

        AknIconUtils::AvkonIconFileName(),

        EMbmAvkonQgn_indi_signal_active_cdma,

        EMbmAvkonQgn_indi_signal_active_cdma );

    // Packet data dormant

    AknsUtils::CreateColorIconL(

        skin,

        KAknsIIDQgnIndiSignalDormantCdma,

        iExtension->iCdmaStaticIcons[4],

        iExtension->iCdmaStaticMasks[4],

        AknIconUtils::AvkonIconFileName(),

        EMbmAvkonQgn_indi_signal_dormant_cdma,

        EMbmAvkonQgn_indi_signal_dormant_cdma );

#endif // __PROTOCOL_CDMA

    // off by default

    iExtension->iCdmaSignalState    = EAknSignalCdmaIndicatorOff;

    iExtension->iCdmaAnimationIndex = 0;

		iExtension->iStatusPane = CEikStatusPaneBase::Current();

    iSignalIconControl = CAknSignalIcon::NewL();

    iSignalIconControl->SetDrawBlank( EFalse );

    // Load default icon

    LoadSignalIconL( 0, 0 );

    iSignalStrengthControl = CAknSignalStrength::NewL();

    iSignalIconControl->SetContainerWindowL( *this );

    iSignalStrengthControl->SetContainerWindowL( *this );

    iTicker = CPeriodic::NewL( CActive::EPriorityLow );

    // Set flags to default values

    iPrivateFlags = 0;

    iDataObserver = new (ELeave) CAknSignalDataObserver( this );

    }

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

// CAknSignalPane::ConstructFromResourceL

// Resource constructor.

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

//

EXPORT_C void CAknSignalPane::ConstructFromResourceL(

    TResourceReader& aReader )

    {

    ConstructL();

    SetSignalLevel( aReader.ReadInt16() ); // Initial signal level.

    }

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

// CAknSignalPane::SetSignalLevel

// Sets the signal level.

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

//

EXPORT_C void CAknSignalPane::SetSignalLevel( TInt aLevel )

    {

    if ( aLevel == KAknSignalOffLineMode )

        {

        iSignalIconControl->SetOffLine( ETrue );

        }

    else

        {

        iSignalIconControl->SetOffLine( EFalse );

        }

    iSignalStrengthControl->SetSignalLevel( aLevel );

    }

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

// CAknSignalPane::SignalLevel

// Returns the current signal level.

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

//

TInt CAknSignalPane::SignalLevel()

    {

    if ( iSignalStrengthControl )

        {

        return iSignalStrengthControl->SignalLevel();

        }

    else

        {

        return 0;

        }

    }

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

// CAknSignalPane::SignalState

// Returns the current signal state.

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

//

TInt CAknSignalPane::SignalState()

    {

    return iSignalState;

    }

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

// CAknSignalPane::DisableAnimation

// Stops ongoing signal state animation.

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

//

void CAknSignalPane::DisableAnimation()

    {

    if ( iTicker && iTicker->IsActive() )

        {

        iTicker->Cancel();

        }

    }

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

// CAknSignalPane::ShowGprsIcon

// Displays a GRPS state icon.

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

//

EXPORT_C void CAknSignalPane::ShowGprsIcon( TInt aGprsIconState )

    {

    // Gprs state is not changed if illegal value was given.

    if (  aGprsIconState >= EAknSignalGprsIndicatorOff &&

          aGprsIconState <= EAknSignalGprsIndicatorMultipdp )

        {

        TRAP_IGNORE( LoadSignalIconL( aGprsIconState,

                                      iSignalIconControl->ColorIndex() ) );

        iSignalIconControl->SetDrawBlank( EFalse );

        if ( aGprsIconState != EAknSignalGprsIndicatorEstablishingContext &&

             iTicker )

            {

            iTicker->Cancel();

            }

        else if ( aGprsIconState == EAknSignalGprsIndicatorEstablishingContext )

            {

            if ( iTicker && !iTicker->IsActive() )

                {

                iTicker->Start( KAknIndicatorAnimationDelay,

                                KAknIndicatorAnimationInterval,

                                TCallBack( TickerCallback, this ) );

                }

            }

        }

    }

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

// From class CCoeControl.

// CAknSignalPane::SizeChanged

// Handles size change events.

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

//

EXPORT_C void CAknSignalPane::SizeChanged()

    {

    // No fading if staconpane is active.

    SetContainerWindowNonFading( AknStatuspaneUtils::StaconPaneActive() );

    TAknWindowComponentLayout signalIconLayout;

    TAknWindowComponentLayout signalStrenghtLayout;

    TRect parent( Rect() );

    TAknLayoutRect rect;

    if ( AknStatuspaneUtils::StaconPaneActive() )

        {

        //  Signal pane in STACON PANE.

        TInt varietyIndex = AknStatuspaneUtils::StaconSoftKeysLeft() ? 1 : 0;

        signalIconLayout =

            AknLayoutScalable_Avkon::signal_pane_stacon_g2( varietyIndex );

        signalStrenghtLayout =

            AknLayoutScalable_Avkon::signal_pane_stacon_g1( varietyIndex );

        AknLayoutUtils::LayoutControl( iSignalIconControl,

                                       parent,

                                       signalIconLayout );

        AknLayoutUtils::LayoutControl( iSignalStrengthControl,

                                       parent,

                                       signalStrenghtLayout );

        }

    else if ( AknStatuspaneUtils::FlatLayoutActive() )

        {

        //  Signal pane in FLAT STATUSPANE.

        signalIconLayout     = AknLayoutScalable_Avkon::signal_pane_g2( 1 );

        signalStrenghtLayout = AknLayoutScalable_Avkon::signal_pane_g1( 1 );

        AknLayoutUtils::LayoutControl( iSignalIconControl,

                                       parent,

                                       signalIconLayout);

        AknLayoutUtils::LayoutControl( iSignalStrengthControl,

                                       parent,

                                       signalStrenghtLayout );

        }

    else if ( AknStatuspaneUtils::SmallLayoutActive() )

        {

        //  Signal pane in SMALL STATUSPANE, only icon shown.

        signalIconLayout = AknLayoutScalable_Avkon::status_small_pane_g2( 0 );

        AknLayoutUtils::LayoutControl( iSignalIconControl,

                                       parent,

                                       signalIconLayout );

        iSignalStrengthControl->SetRect( TRect( 0, 0, 0, 0 ) );

        }

    else

        {

        // Signal pane in NORMAL or WIDESCREEN STATUS PANE.

        TBool hdLayout( AknStatuspaneUtils::HDLayoutActive() );

        signalIconLayout =

            AknLayoutScalable_Avkon::signal_pane_g2( hdLayout ? 2 : 0 );

        signalStrenghtLayout =

            AknLayoutScalable_Avkon::signal_pane_g1( hdLayout ? 2 : 0 );

        AknLayoutUtils::LayoutControl( iSignalIconControl,

                                       parent,

                                       signalIconLayout );

        AknLayoutUtils::LayoutControl( iSignalStrengthControl,

                                       parent,

                                       signalStrenghtLayout );

        }

    TInt iconColorIndex = 0;

    if ( AknStatuspaneUtils::StaconPaneActive() ||

         AknStatuspaneUtils::FlatLayoutActive() )

        {

        iconColorIndex = EAknsCIQsnIconColorsCG23;

        }

    else

        {

        iconColorIndex = EAknsCIQsnIconColorsCG5;

        }

    TRAP_IGNORE( LoadSignalIconL( iSignalState, iconColorIndex ) );

    AknsUtils::RegisterControlPosition( this );

    }

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

// From class CCoeControl.

// CAknSignalPane::PositionChanged

// Handles position change events.

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

//

EXPORT_C void CAknSignalPane::PositionChanged()

    {

    AknsUtils::RegisterControlPosition( this );

    }

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