/*

* 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:  Battery strength indicator control.

*

*/

// INCLUDE FILES

#include "AknBatteryStrength.h"

#include "aknconsts.h"

#include "AknUtils.h"

#include "AknBitmapMirrorUtils.h"

#include "aknenv.h"

#include "AknIconUtils.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 <AknTasHook.h>

const TInt KBatteryStrengthLevels = 7;

const TInt KScaleFactor           = 10000;

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

// CAknBatteryStrength::CAknBatteryStrength

// Default constructor.

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

//

CAknBatteryStrength::CAknBatteryStrength()

    {

    }

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

// CAknBatteryStrength::~CAknBatteryStrength

// Destructor.

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

//

CAknBatteryStrength::~CAknBatteryStrength()

    {

    AKNTASHOOK_REMOVE();

    AknsUtils::DeregisterControlPosition( this );

    delete iDefaultBatteryIndicatorBitmap;

    delete iDefaultBatteryIndicatorBitmapMask;

    delete iFlatBatteryIndicatorBitmap;

    delete iFlatBatteryIndicatorBitmapMask;

    delete iStaconLeftSideBatteryIndicatorBitmap;

    delete iStaconLeftSideBatteryIndicatorBitmapMask;

    delete iStaconRightSideBatteryIndicatorBitmap;

    delete iStaconRightSideBatteryIndicatorBitmapMask;

    }

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

// CAknBatteryStrength::NewL

// Two-phased constructor.

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

//

CAknBatteryStrength* CAknBatteryStrength::NewL()

    {

    CAknBatteryStrength* self = CAknBatteryStrength::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// CAknBatteryStrength::NewLC

// Two-phased constructor.

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

//

CAknBatteryStrength* CAknBatteryStrength::NewLC()

    {

    CAknBatteryStrength* self = new (ELeave) CAknBatteryStrength;

    CleanupStack::PushL( self );

    AKNTASHOOK_ADDL( self, "CAknBatteryStrength" );

    return self;

    }

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

// CAknBatteryStrength::SizeChanged

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

//

void CAknBatteryStrength::SizeChanged()

    {

    TSize size( Size() );

    if ( AknStatuspaneUtils::StaconPaneActive() )

        {

        TRAP_IGNORE( LoadStaconBitmapsL() );

        if ( iStaconLeftSideBatteryIndicatorBitmap )

            {

            AknIconUtils::SetSize(

                iStaconLeftSideBatteryIndicatorBitmap,

                size,

                EAspectRatioPreservedAndUnusedSpaceRemoved );

            }

        if ( iStaconRightSideBatteryIndicatorBitmap )

            {

            AknIconUtils::SetSize(

                iStaconRightSideBatteryIndicatorBitmap,

                size,

                EAspectRatioPreservedAndUnusedSpaceRemoved );

            }

        iLastStaconSize = size;

        }

    else if ( AknStatuspaneUtils::FlatLayoutActive() )

        {

        TRAP_IGNORE( LoadFlatBitmapsL() );

        if ( iFlatBatteryIndicatorBitmap )

            {

            AknIconUtils::SetSize( iFlatBatteryIndicatorBitmap,

                                   size,

                                   EAspectRatioNotPreserved );

            }

        iLastFlatSize = size;

        }

    else if ( AknStatuspaneUtils::ExtendedLayoutActive() )

        {

        TRAP_IGNORE( LoadDefaultBitmapsL() );

        if ( iDefaultBatteryIndicatorBitmap )

            {

            AknIconUtils::SetSize( iDefaultBatteryIndicatorBitmap,

                                   size,

                                   EAspectRatioNotPreserved );

            }

        iLastDefaultSize = size;

        }

    else

        {

        TRAP_IGNORE( LoadDefaultBitmapsL() );

        if ( iDefaultBatteryIndicatorBitmap )

            {

            AknIconUtils::SetSize( iDefaultBatteryIndicatorBitmap, size );

            }

        iLastDefaultSize = size;

        }

    SetBatteryLevel( iBatteryLevel ); // refreshes battery level offsets

    AknsUtils::RegisterControlPosition( this );

    }

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

// CAknBatteryStrength::PositionChanged

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

//

void CAknBatteryStrength::PositionChanged()

    {

    AknsUtils::RegisterControlPosition( this );

    if ( AknStatuspaneUtils::StaconPaneActive() )

        {

        TRAP_IGNORE( LoadStaconBitmapsL() );

        }

    }

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

// CAknBatteryStrength::Draw

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

//

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

    {

    if ( AknStatuspaneUtils::StaconPaneActive() )

        {

        DrawInStaconPane( Rect() );

        }

    else if ( AknStatuspaneUtils::FlatLayoutActive() )

        {

        DrawInFlatStatusPane( Rect() );

        }

    else

        {

        DrawInNormalStatusPane( Rect() );

        }

    }

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

// CAknBatteryStrength::BatteryLevel

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

//

TInt CAknBatteryStrength::BatteryLevel()

    {

    return iBatteryLevel;

    }

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

// CAknBatteryStrength::SetBatteryLevel

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

//

void CAknBatteryStrength::SetBatteryLevel( TInt aLevel )

    {

    TBool legalValue  =

        ( ( aLevel <= KBatteryLevelMax ) &&

          ( aLevel >= KBatteryLevelMin ) );

    if ( !legalValue )

        {

        // Battery level value is not changed if wrong value was given.

        return;

        }

    TSize size( Size() );

    iBatteryLevel = aLevel;

    if ( iBatteryLevel == KBatteryLevelMin )

        {

        iDefaultBatteryBitmapOffset = size.iHeight;

        iFlatBatteryBitmapOffset    = size.iHeight;

        iStaconBatteryBitmapOffset  = 0;

        }

    // Offsets are calculated from the battery strength area

    // because the battery strength level layouts return

    // wrong values in some cases.

    else if ( AknStatuspaneUtils::FlatLayoutActive() )

        {

        TInt stepSize =

            size.iHeight * KScaleFactor / KBatteryStrengthLevels;

        iFlatBatteryBitmapOffset =

            size.iHeight - ( stepSize * iBatteryLevel / KScaleFactor );

        }

    else if ( AknStatuspaneUtils::StaconPaneActive() )

        {

        TInt stepSize = size.iHeight * KScaleFactor / KBatteryStrengthLevels;

        iStaconBatteryBitmapOffset = stepSize * iBatteryLevel / KScaleFactor;

        }

    else // normal statuspane

        {

        TInt stepSize =

            size.iHeight * KScaleFactor / KBatteryStrengthLevels;

        iDefaultBatteryBitmapOffset =

            size.iHeight - ( stepSize * iBatteryLevel / KScaleFactor );

        }

    }

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

// CAknBatteryStrength::LoadDefaultBitmapsL

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

//

void CAknBatteryStrength::LoadDefaultBitmapsL()

    {

    if ( iDefaultBatteryIndicatorBitmap &&

         iDefaultBatteryIndicatorBitmapMask &&

         iLastDefaultSize == Size() )

        {

        return;

        }

    else

        {

        delete iDefaultBatteryIndicatorBitmap;

        iDefaultBatteryIndicatorBitmap = NULL;

        delete iDefaultBatteryIndicatorBitmapMask;

        iDefaultBatteryIndicatorBitmapMask = NULL;

        }

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    AknsUtils::CreateIconL( skin,

                            KAknsIIDQgnIndiBatteryStrength,

                            iDefaultBatteryIndicatorBitmap,

                            iDefaultBatteryIndicatorBitmapMask,

                            KAvkonBitmapFile,

                            EMbmAvkonQgn_indi_battery_strength,

                            EMbmAvkonQgn_indi_battery_strength_mask );

    if ( AknStatuspaneUtils::ExtendedLayoutActive() )

        {

        AknIconUtils::SetSize( iDefaultBatteryIndicatorBitmap,

                               Size(),

                               EAspectRatioNotPreserved );

        }

    else

        {

        AknIconUtils::SetSize( iDefaultBatteryIndicatorBitmap,

                               Size() );

        }

    CFbsBitmap* itemIsSkinned = AknsUtils::GetCachedBitmap(

            skin, KAknsIIDQgnIndiBatteryStrength );

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

        {

        CFbsBitmap* tmpBitmap =

            AknBitmapMirrorUtils::HorizontallyMirrorBitmapL(

                iDefaultBatteryIndicatorBitmap );

        CFbsBitmap* tmpBitmapMask =

            AknBitmapMirrorUtils::HorizontallyMirrorBitmapL(

                iDefaultBatteryIndicatorBitmapMask );

        delete iDefaultBatteryIndicatorBitmap;

        iDefaultBatteryIndicatorBitmap = tmpBitmap;

        delete iDefaultBatteryIndicatorBitmapMask;

        iDefaultBatteryIndicatorBitmapMask = tmpBitmapMask;

        }

    }

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

// CAknBatteryStrength::LoadStaconBitmapsL

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

//

void CAknBatteryStrength::LoadStaconBitmapsL()

    {

    // stacon bitmaps

    TBool iconsExistForActiveStaconLayout = EFalse;

    if ( AknStatuspaneUtils::StaconSoftKeysLeft() )

        {

        if ( iStaconRightSideBatteryIndicatorBitmap &&

             iStaconRightSideBatteryIndicatorBitmapMask )

            {

            iconsExistForActiveStaconLayout = ETrue;

            }

        }

    else if ( AknStatuspaneUtils::StaconSoftKeysRight() )

        {

        if ( iStaconLeftSideBatteryIndicatorBitmap &&

             iStaconLeftSideBatteryIndicatorBitmapMask )

            {

            iconsExistForActiveStaconLayout = ETrue;

            }

        }

    if ( iconsExistForActiveStaconLayout &&

         iLastStaconSize == Size() )

        {

        // Bitmaps exist and size hasn't changed.

        return;

        }

    else

        {

        delete iStaconRightSideBatteryIndicatorBitmap;

        iStaconRightSideBatteryIndicatorBitmap = NULL;

        delete iStaconRightSideBatteryIndicatorBitmapMask;

        iStaconRightSideBatteryIndicatorBitmapMask = NULL;

        delete iStaconLeftSideBatteryIndicatorBitmap;

        iStaconLeftSideBatteryIndicatorBitmap = NULL;

        delete iStaconLeftSideBatteryIndicatorBitmapMask;

        iStaconLeftSideBatteryIndicatorBitmapMask = NULL;

        }

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    TRAPD( err, AknsUtils::CreateIconL( skin,

                                        KAknsIIDQgnIndiBatteryStrengthLsc,

                                        iStaconLeftSideBatteryIndicatorBitmap,

                                        iStaconLeftSideBatteryIndicatorBitmapMask,

                                        KAvkonBitmapFile,

                                        EMbmAvkonQgn_indi_battery_strength_lsc,

                                        EMbmAvkonQgn_indi_battery_strength_lsc_mask ) );

    // Only icon for right sk situation exists, we mirror graphics here if needed.

    if ( AknStatuspaneUtils::StaconSoftKeysLeft() )

        {

        if ( err == KErrNone )

            {

            AknIconUtils::SetSize( iStaconLeftSideBatteryIndicatorBitmap,

                                   Size(),

                                   EAspectRatioPreservedAndUnusedSpaceRemoved );

            CFbsBitmap* tmpBitmap =

                AknBitmapMirrorUtils::HorizontallyMirrorBitmapL(

                    iStaconLeftSideBatteryIndicatorBitmap );

            CFbsBitmap* tmpBitmapMask =

                AknBitmapMirrorUtils::HorizontallyMirrorBitmapL(

                    iStaconLeftSideBatteryIndicatorBitmapMask );

            delete iStaconRightSideBatteryIndicatorBitmap;

            iStaconRightSideBatteryIndicatorBitmap = tmpBitmap;

            delete iStaconRightSideBatteryIndicatorBitmapMask;

            iStaconRightSideBatteryIndicatorBitmapMask = tmpBitmapMask;

            }

        }

    // Delete unnecessary bitmaps to save RAM

    if ( AknStatuspaneUtils::StaconSoftKeysLeft() )

        {

        delete iStaconLeftSideBatteryIndicatorBitmap;

        iStaconLeftSideBatteryIndicatorBitmap = NULL;

        delete iStaconLeftSideBatteryIndicatorBitmapMask;

        iStaconLeftSideBatteryIndicatorBitmapMask = NULL;

        }

    else if ( AknStatuspaneUtils::StaconSoftKeysRight() )

        {

        delete iStaconRightSideBatteryIndicatorBitmap;

        iStaconRightSideBatteryIndicatorBitmap = NULL;

        delete iStaconRightSideBatteryIndicatorBitmapMask;

        iStaconRightSideBatteryIndicatorBitmapMask = NULL;

        }

    }

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

// CAknBatteryStrength::LoadFlatBitmapsL

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

//

void CAknBatteryStrength::LoadFlatBitmapsL()

    {

    if ( iFlatBatteryIndicatorBitmap &&

         iFlatBatteryIndicatorBitmapMask &&

         iLastFlatSize == Size() )

        {

        return;

        }

    else

        {

        delete iFlatBatteryIndicatorBitmap;

        iFlatBatteryIndicatorBitmap = NULL;

        delete iFlatBatteryIndicatorBitmapMask;

        iFlatBatteryIndicatorBitmapMask = NULL;

        }

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    // Flat bitmaps

    AknsUtils::CreateIconL( skin,

                            KAknsIIDQgnIndiBatteryStrength,

                            iFlatBatteryIndicatorBitmap,

                            iFlatBatteryIndicatorBitmapMask,

                            KAvkonBitmapFile,

                            EMbmAvkonQgn_indi_battery_strength,

                            EMbmAvkonQgn_indi_battery_strength_mask );

    AknIconUtils::SetSize( iFlatBatteryIndicatorBitmap,

                           Size(),

                           EAspectRatioNotPreserved );

    CFbsBitmap*  itemIsSkinned = AknsUtils::GetCachedBitmap(

            skin, KAknsIIDQgnIndiBatteryStrength );

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

        {

        CFbsBitmap* tmpBitmap =

            AknBitmapMirrorUtils::HorizontallyMirrorBitmapL(

                iFlatBatteryIndicatorBitmap );

        CFbsBitmap* tmpBitmapMask =

            AknBitmapMirrorUtils::HorizontallyMirrorBitmapL(

                iFlatBatteryIndicatorBitmapMask );

        delete iFlatBatteryIndicatorBitmap;

        iFlatBatteryIndicatorBitmap = tmpBitmap;

        delete iFlatBatteryIndicatorBitmapMask;

        iFlatBatteryIndicatorBitmapMask = tmpBitmapMask;

        }

    }

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

// CAknBatteryStrength::DeleteBitmaps

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

//

void CAknBatteryStrength::DeleteBitmaps()

    {

    delete iDefaultBatteryIndicatorBitmap;

    iDefaultBatteryIndicatorBitmap = NULL;

    delete iDefaultBatteryIndicatorBitmapMask;

    iDefaultBatteryIndicatorBitmapMask = NULL;

    delete iFlatBatteryIndicatorBitmap;

    iFlatBatteryIndicatorBitmap = NULL;

    delete iFlatBatteryIndicatorBitmapMask;

    iFlatBatteryIndicatorBitmapMask = NULL;

    delete iStaconLeftSideBatteryIndicatorBitmap;

    iStaconLeftSideBatteryIndicatorBitmap = NULL;

    delete iStaconLeftSideBatteryIndicatorBitmapMask;

    iStaconLeftSideBatteryIndicatorBitmapMask = NULL;

    delete iStaconRightSideBatteryIndicatorBitmap;

    iStaconRightSideBatteryIndicatorBitmap = NULL;

    delete iStaconRightSideBatteryIndicatorBitmapMask;

    iStaconRightSideBatteryIndicatorBitmapMask = NULL;

    }

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

// CAknBatteryStrength::HandleResourceChange

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

//

void CAknBatteryStrength::HandleResourceChange( TInt aType )

    {

    if ( aType==KEikDynamicLayoutVariantSwitch ||

         aType == KEikColorResourceChange ||

         aType == KAknsMessageSkinChange)

        {

        DeleteBitmaps(); // SizeChanged reloads needed bitmaps

        SizeChanged();

        if ( aType == KEikDynamicLayoutVariantSwitch )

            {