/*

* Copyright (c) 2004-2007 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:  Signal strength indicator control.

*

*/

// INCLUDE FILES

#include "AknSignalStrength.h"

#include "aknconsts.h"

#include "AknUtils.h"

#include "AknIconUtils.h"

#include "AknBitmapMirrorUtils.h"

#include "AknStatuspaneUtils.h"

#include "aknappui.h"

#include <avkon.mbg>

#include <AknsDrawUtils.h>

#include <eikenv.h>

#include <eikspane.h>

#include "AknDef.h"

#include <layoutmetadata.cdl.h>

#include <akniconconfig.h>

#include <AknTasHook.h> // for testability hooks

const TInt KSignalStrengthLevels = 7;

const TInt KScaleFactor          = 10000;

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

// CAknSignalStrength::CAknSignalStrength

// Default contructor.

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

//

CAknSignalStrength::CAknSignalStrength()

    {

    }

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

// CAknSignalStrength::~CAknSignalStrength

// Destructor.

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

//

CAknSignalStrength::~CAknSignalStrength()

    {

    AKNTASHOOK_REMOVE();

    AknsUtils::DeregisterControlPosition( this );

    delete iDefaultSignalIndicatorBitmap;

    delete iDefaultSignalIndicatorBitmapMask;

    delete iDefaultNoSignalIndicatorBitmap;

    delete iDefaultNoSignalIndicatorBitmapMask;

    delete iFlatSignalIndicatorBitmap;

    delete iFlatSignalIndicatorBitmapMask;

    delete iFlatNoSignalIndicatorBitmap;

    delete iFlatNoSignalIndicatorBitmapMask;

    delete iStaconLeftSideSignalIndicatorBitmap;

    delete iStaconLeftSideSignalIndicatorBitmapMask;

    delete iStaconRightSideSignalIndicatorBitmap;

    delete iStaconRightSideSignalIndicatorBitmapMask;

    delete iStaconNoSignalIndicatorBitmap;

    delete iStaconNoSignalIndicatorBitmapMask;

    }

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

// CAknSignalStrength::NewL

// Two-phased constructor.

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

//

CAknSignalStrength* CAknSignalStrength::NewL()

    {

    CAknSignalStrength* self = CAknSignalStrength::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// CAknSignalStrength::NewLC

// Two-phased constructor.

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

//

CAknSignalStrength* CAknSignalStrength::NewLC()

    {

    CAknSignalStrength* self = new (ELeave) CAknSignalStrength;

    CleanupStack::PushL( self );

    AKNTASHOOK_ADDL( self, "CAknSignalStrength" );

    return self;

    }

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

// CAknSignalStrength::SizeChanged

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

//

void CAknSignalStrength::SizeChanged()

    {

    TSize size( Size() );

    if ( AknStatuspaneUtils::StaconPaneActive() )

        {

        TRAP_IGNORE( LoadStaconBitmapsL() );

        if ( iStaconRightSideSignalIndicatorBitmap )

            {

            AknIconUtils::SetSize( iStaconRightSideSignalIndicatorBitmap,

                                   size,

                                   EAspectRatioPreservedAndUnusedSpaceRemoved );

            }

        if ( iStaconLeftSideSignalIndicatorBitmap )

            {

            AknIconUtils::SetSize( iStaconLeftSideSignalIndicatorBitmap,

                                   size,

                                   EAspectRatioPreservedAndUnusedSpaceRemoved );

            }

        if ( iStaconNoSignalIndicatorBitmap )

            {

            AknIconUtils::SetSize( iStaconNoSignalIndicatorBitmap,

                                   size );

            }

        iLastStaconSize = size;

        }

    else if ( AknStatuspaneUtils::FlatLayoutActive() )

        {

        TRAP_IGNORE( LoadFlatBitmapsL() );

        if ( iFlatSignalIndicatorBitmap && iFlatNoSignalIndicatorBitmap )

            {

            AknIconUtils::SetSize( iFlatSignalIndicatorBitmap,

                                   size,

                                   EAspectRatioNotPreserved );

            AknIconUtils::SetSize( iFlatNoSignalIndicatorBitmap, size );

            }

        iLastFlatSize = size;

        }

    else if ( AknStatuspaneUtils::ExtendedLayoutActive() )

        {

        TRAP_IGNORE( LoadDefaultBitmapsL() );

        if ( iDefaultSignalIndicatorBitmap && iDefaultNoSignalIndicatorBitmap )

            {

            AknIconUtils::SetSize( iDefaultSignalIndicatorBitmap,

                                   size,

                                   EAspectRatioNotPreserved );

            AknIconUtils::SetSize( iDefaultNoSignalIndicatorBitmap, size );

            }

        iLastDefaultSize = size;

        }

    else

        {

        TRAP_IGNORE( LoadDefaultBitmapsL() );

        if ( iDefaultSignalIndicatorBitmap && iDefaultNoSignalIndicatorBitmap )

            {

            AknIconUtils::SetSize( iDefaultSignalIndicatorBitmap, size );

            AknIconUtils::SetSize( iDefaultNoSignalIndicatorBitmap, size );

            }

        iLastDefaultSize = size;

        }

    SetSignalLevel( iSignalLevel ); // refreshes level offsets

    AknsUtils::RegisterControlPosition( this );

    }

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

// CAknSignalStrength::PositionChanged

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

//

void CAknSignalStrength::PositionChanged()

    {

    AknsUtils::RegisterControlPosition( this );

    if ( AknStatuspaneUtils::StaconPaneActive() )

        {

        TRAP_IGNORE( LoadStaconBitmapsL() );

        }

    }

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

// CAknSignalStrength::Draw

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

//

void CAknSignalStrength::Draw( const TRect& /*aRect*/ ) const

    {

    if ( AknStatuspaneUtils::StaconPaneActive() )

        {

        DrawInStaconPane( Rect() );

        }

    else if ( AknStatuspaneUtils::FlatLayoutActive() )

        {

        DrawInFlatStatusPane( Rect() );

        }

    else

        {

        DrawInNormalStatusPane( Rect() );

        }

    }

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

// CAknSignalStrength::SetSignalLevel

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

//

void CAknSignalStrength::SetSignalLevel( TInt aLevel )

    {

    if ( aLevel == KAknSignalOffLineMode )

        {

        // Off-line mode indicator is shown.

        iSignalLevel = aLevel;

        return;

        }

    TBool legalValue  =

        ( ( aLevel <= KSignalLevelMax ) &&

          ( aLevel >= KSignalLevelMin ) );

    if ( !legalValue )

        {

        // Signal value is not changed if wrong value was given.

        return;

        }

    iSignalLevel = aLevel;

    TSize size( Size() );

    if ( aLevel == KSignalLevelMin )

        {

        iDefaultSignalBitmapOffset = size.iHeight;

        iStaconSignalBitmapOffset  = size.iHeight;

        iFlatSignalBitmapOffset    = size.iHeight;

        }

    // Offsets are calculated from the signal strength area

    // because the signal strength level layouts return

    // wrong values in some cases.

    else if ( AknStatuspaneUtils::FlatLayoutActive() )

        {

        TInt stepSize =

            size.iHeight * KScaleFactor / KSignalStrengthLevels;

        iFlatSignalBitmapOffset = size.iHeight - stepSize * iSignalLevel / KScaleFactor;

        }

    else if ( AknStatuspaneUtils::StaconPaneActive() )

        {

        TInt stepSize = size.iHeight * KScaleFactor / KSignalStrengthLevels;

        iStaconSignalBitmapOffset =

            size.iHeight - stepSize * iSignalLevel / KScaleFactor;

        }

    else // normal statuspane

        {

        TInt stepSize =

            size.iHeight * KScaleFactor / KSignalStrengthLevels;

        iDefaultSignalBitmapOffset =

            size.iHeight - stepSize * iSignalLevel / KScaleFactor;

        }

    }

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

// CAknSignalStrength::LoadDefaultBitmapsL

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

//

void CAknSignalStrength::LoadDefaultBitmapsL()

    {

    if ( iDefaultSignalIndicatorBitmap &&

         iDefaultSignalIndicatorBitmapMask &&

         iDefaultNoSignalIndicatorBitmap &&

         iDefaultNoSignalIndicatorBitmapMask &&

         iLastDefaultSize == Size() )

        {

        return;

        }

    else

        {

        delete iDefaultSignalIndicatorBitmap;

        iDefaultSignalIndicatorBitmap = NULL;

        delete iDefaultSignalIndicatorBitmapMask;

        iDefaultSignalIndicatorBitmapMask = NULL;

        delete iDefaultNoSignalIndicatorBitmap;

        iDefaultNoSignalIndicatorBitmap = NULL;

        delete iDefaultNoSignalIndicatorBitmapMask;

        iDefaultNoSignalIndicatorBitmapMask = NULL;

        }

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    AknsUtils::CreateIconL( skin,

                            KAknsIIDQgnIndiSignalStrength,

                            iDefaultSignalIndicatorBitmap,

                            iDefaultSignalIndicatorBitmapMask,

                            KAvkonBitmapFile,

                            EMbmAvkonQgn_indi_signal_strength,

                            EMbmAvkonQgn_indi_signal_strength_mask );

    AknsUtils::CreateColorIconL( skin,

                                 KAknsIIDQgnIndiNoSignal,

                                 KAknsIIDQsnIconColors,

                                 EAknsCIQsnIconColorsCG3,

                                 iDefaultNoSignalIndicatorBitmap,

                                 iDefaultNoSignalIndicatorBitmapMask,

                                 KAvkonBitmapFile,

                                 EMbmAvkonQgn_indi_no_signal,

                                 EMbmAvkonQgn_indi_no_signal_mask,

                                 KRgbGray );

    if ( AknStatuspaneUtils::ExtendedLayoutActive() )

        {

        AknIconUtils::SetSize( iDefaultSignalIndicatorBitmap,

                               Size(),

                               EAspectRatioNotPreserved );

        AknIconUtils::SetSize( iDefaultNoSignalIndicatorBitmap,

                               Size(),

                               EAspectRatioNotPreserved );

        }

    else

        {

        AknIconUtils::SetSize( iDefaultSignalIndicatorBitmap, Size() );

        AknIconUtils::SetSize( iDefaultNoSignalIndicatorBitmap, Size() );

        }

    CFbsBitmap* itemIsSkinned = AknsUtils::GetCachedBitmap(

            skin, KAknsIIDQgnIndiSignalStrength );

    if ( AknLayoutUtils::LayoutMirrored() && !itemIsSkinned )

        {

        CFbsBitmap* tmpBitmap =

            AknBitmapMirrorUtils::HorizontallyMirrorBitmapL(

                iDefaultSignalIndicatorBitmap );

        CFbsBitmap* tmpBitmapMask =

            AknBitmapMirrorUtils::HorizontallyMirrorBitmapL(

                iDefaultSignalIndicatorBitmapMask );

        delete iDefaultSignalIndicatorBitmap;

        iDefaultSignalIndicatorBitmap = tmpBitmap;

        delete iDefaultSignalIndicatorBitmapMask;

        iDefaultSignalIndicatorBitmapMask = tmpBitmapMask;

        }

    CFbsBitmap* itemIsSkinned2 = AknsUtils::GetCachedBitmap(

            skin, KAknsIIDQgnIndiNoSignal );

    if ( AknLayoutUtils::LayoutMirrored() && !itemIsSkinned2 )

        {

        CFbsBitmap* tmpBitmapNoSignal =

            AknBitmapMirrorUtils::HorizontallyMirrorBitmapL(

                iDefaultNoSignalIndicatorBitmap );

        CFbsBitmap* tmpBitmapNoSignalMask =

            AknBitmapMirrorUtils::HorizontallyMirrorBitmapL(

                iDefaultNoSignalIndicatorBitmapMask );

        delete iDefaultNoSignalIndicatorBitmap;

        iDefaultNoSignalIndicatorBitmap = tmpBitmapNoSignal;

        delete iDefaultNoSignalIndicatorBitmapMask;

        iDefaultNoSignalIndicatorBitmapMask = tmpBitmapNoSignalMask;

        }

    }

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

// CAknSignalStrength::LoadStaconBitmapsL

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

//

void CAknSignalStrength::LoadStaconBitmapsL()

    {

    TBool iconsExistForActiveStaconLayout = EFalse;

    if ( AknStatuspaneUtils::StaconSoftKeysLeft() )

        {

        if ( iStaconRightSideSignalIndicatorBitmap &&

             iStaconRightSideSignalIndicatorBitmapMask &&

             iStaconNoSignalIndicatorBitmap &&

             iStaconNoSignalIndicatorBitmapMask )

            {

            iconsExistForActiveStaconLayout = ETrue;

            }

        }

    else if ( AknStatuspaneUtils::StaconSoftKeysRight() )

        {

        if ( iStaconLeftSideSignalIndicatorBitmap &&

             iStaconLeftSideSignalIndicatorBitmapMask &&

             iStaconNoSignalIndicatorBitmap &&

             iStaconNoSignalIndicatorBitmapMask )

            {

            iconsExistForActiveStaconLayout = ETrue;

            }

        }

    if ( iconsExistForActiveStaconLayout &&

         iLastStaconSize == Size() )

        {

        // Bitmaps exist and size hasn't changed.

        return;

        }

    else

        {

        delete iStaconRightSideSignalIndicatorBitmap;

        iStaconRightSideSignalIndicatorBitmap = NULL;

        delete iStaconRightSideSignalIndicatorBitmapMask;

        iStaconRightSideSignalIndicatorBitmapMask = NULL;

        delete iStaconLeftSideSignalIndicatorBitmap;

        iStaconLeftSideSignalIndicatorBitmap = NULL;

        delete iStaconLeftSideSignalIndicatorBitmapMask;

        iStaconLeftSideSignalIndicatorBitmapMask = NULL;

        delete iStaconNoSignalIndicatorBitmap;

        iStaconNoSignalIndicatorBitmap = NULL;

        delete iStaconNoSignalIndicatorBitmapMask;

        iStaconNoSignalIndicatorBitmapMask = NULL;

        }

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    AknsUtils::CreateColorIconL( skin,

                                 KAknsIIDQgnIndiNoSignal,

                                 KAknsIIDQsnIconColors,

                                 EAknsCIQsnIconColorsCG21,

                                 iStaconNoSignalIndicatorBitmap,

                                 iStaconNoSignalIndicatorBitmapMask,

                                 KAvkonBitmapFile,

                                 EMbmAvkonQgn_indi_no_signal,

                                 EMbmAvkonQgn_indi_no_signal_mask,

                                 KRgbGray );

    AknIconUtils::SetSize( iStaconNoSignalIndicatorBitmap, Size() );

    TRAPD( err, AknsUtils::CreateIconL( skin,

                                        KAknsIIDQgnIndiSignalStrengthLsc,

                                        iStaconLeftSideSignalIndicatorBitmap,

                                        iStaconLeftSideSignalIndicatorBitmapMask,

                                        KAvkonBitmapFile,

                                        EMbmAvkonQgn_indi_signal_strength_lsc,

                                        EMbmAvkonQgn_indi_signal_strength_lsc_mask ) );

    if ( AknStatuspaneUtils::StaconSoftKeysLeft() )

        {

        if ( err == KErrNone )

            {

            TSize size = Size();

            AknIconUtils::SetSize( iStaconLeftSideSignalIndicatorBitmap,

                                   size,

                                   EAspectRatioPreservedAndUnusedSpaceRemoved );

            CFbsBitmap* tmpBitmap =

                AknBitmapMirrorUtils::HorizontallyMirrorBitmapL(

                    iStaconLeftSideSignalIndicatorBitmap );

            CFbsBitmap* tmpBitmapMask =

                AknBitmapMirrorUtils::HorizontallyMirrorBitmapL(

                    iStaconLeftSideSignalIndicatorBitmapMask );

            delete iStaconRightSideSignalIndicatorBitmap;

            iStaconRightSideSignalIndicatorBitmap = tmpBitmap;

            delete iStaconRightSideSignalIndicatorBitmapMask;

            iStaconRightSideSignalIndicatorBitmapMask = tmpBitmapMask;

            }

        }

    // Delete unnecessary bitmaps to save RAM

    if ( AknStatuspaneUtils::StaconSoftKeysLeft() )

        {

        delete iStaconLeftSideSignalIndicatorBitmap;

        iStaconLeftSideSignalIndicatorBitmap = NULL;

        delete iStaconLeftSideSignalIndicatorBitmapMask;

        iStaconLeftSideSignalIndicatorBitmapMask = NULL;

        }

    else if ( AknStatuspaneUtils::StaconSoftKeysRight() )

        {

        delete iStaconRightSideSignalIndicatorBitmap;

        iStaconRightSideSignalIndicatorBitmap = NULL;

        delete iStaconRightSideSignalIndicatorBitmapMask;

        iStaconRightSideSignalIndicatorBitmapMask = NULL;

        }

    }

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

// CAknSignalStrength::LoadFlatBitmapsL

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

//

void CAknSignalStrength::LoadFlatBitmapsL()

    {

    if ( iFlatSignalIndicatorBitmap &&

         iFlatSignalIndicatorBitmapMask &&

         iFlatNoSignalIndicatorBitmap &&

         iFlatNoSignalIndicatorBitmapMask &&

         iLastFlatSize == Size() )

        {

        return;

        }

    else

        {

        delete iFlatSignalIndicatorBitmap;

        iFlatSignalIndicatorBitmap = NULL;

        delete iFlatSignalIndicatorBitmapMask;

        iFlatSignalIndicatorBitmapMask = NULL;

        delete iFlatNoSignalIndicatorBitmap;

        iFlatNoSignalIndicatorBitmap = NULL;

        delete iFlatNoSignalIndicatorBitmapMask;

        iFlatNoSignalIndicatorBitmapMask = NULL;

        }

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    AknsUtils::CreateIconL( skin,

                            KAknsIIDQgnIndiSignalStrength,

                            iFlatSignalIndicatorBitmap,

                            iFlatSignalIndicatorBitmapMask,

                            KAvkonBitmapFile,