--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uifw/AvKon/src/AknBatteryStrength.cpp Tue Feb 02 01:00:49 2010 +0200
@@ -0,0 +1,735 @@
+/*
+* 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 )
+ {
+ SetBatteryLevel( iBatteryLevel ); // refreshes battery level offsets
+ }
+
+ DrawDeferred();
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// CAknBatteryStrength::DrawInNormalStatusPane
+// ---------------------------------------------------------------------------
+//
+void CAknBatteryStrength::DrawInNormalStatusPane( const TRect& /*aRect*/ ) const
+ {
+ CWindowGc& gc = SystemGc();
+
+ TRect rect( Rect() );
+ MAknsSkinInstance* skin = AknsUtils::SkinInstance();
+
+ // Draws battery strength bar
+ CAknsMaskedBitmapItemData* bitmap = NULL;
+
+ if ( skin )
+ {
+ bitmap = static_cast<CAknsMaskedBitmapItemData*>(
+ skin->GetCachedItemData(
+ KAknsIIDQgnIndiBatteryStrength, EAknsITMaskedBitmap ) );
+ if ( bitmap )
+ {
+ if ( bitmap->Bitmap() )
+ {
+ AknIconUtils::SetSize( bitmap->Bitmap(),
+ Size() );
+ }
+ if ( bitmap->Mask() )
+ {
+ AknIconUtils::SetSize( bitmap->Mask(),
+ Size() );
+ }
+
+ gc.BitBltMasked(
+ TPoint( rect.iTl.iX, iDefaultBatteryBitmapOffset ),
+ bitmap->Bitmap(),
+ TRect( 0,
+ iDefaultBatteryBitmapOffset,
+ rect.Width(),
+ rect.Height() ),
+ bitmap->Mask(),
+ ETrue );
+ }
+ }
+
+ if ( !bitmap )
+ {
+ if ( iDefaultBatteryIndicatorBitmap &&
+ iDefaultBatteryIndicatorBitmapMask )
+ {
+ gc.BitBltMasked(
+ TPoint( rect.iTl.iX, iDefaultBatteryBitmapOffset ),
+ iDefaultBatteryIndicatorBitmap,
+ TRect( 0,
+ iDefaultBatteryBitmapOffset,
+ rect.Width(),
+ rect.Height() ),
+ iDefaultBatteryIndicatorBitmapMask,
+ ETrue );
+ }
+ }
+
+ }
+
+
+// ---------------------------------------------------------------------------
+// CAknBatteryStrength::DrawInStaconPane
+// ---------------------------------------------------------------------------
+//
+void CAknBatteryStrength::DrawInStaconPane( const TRect& /*aRect*/ ) const
+ {
+ CWindowGc& gc = SystemGc();
+
+ CFbsBitmap* bitmap = NULL;
+ CFbsBitmap* mask = NULL;
+
+ TRect rect( Rect() );
+
+ if ( AknStatuspaneUtils::StaconSoftKeysLeft() )
+ {
+ bitmap = iStaconRightSideBatteryIndicatorBitmap;
+ mask = iStaconRightSideBatteryIndicatorBitmapMask;
+ }
+ else
+ {
+ bitmap = iStaconLeftSideBatteryIndicatorBitmap;
+ mask = iStaconLeftSideBatteryIndicatorBitmapMask;
+ }
+
+ TPoint point( rect.iTl );
+ if ( AknStatuspaneUtils::StaconSoftKeysLeft() && bitmap )
+ {
+ point = TPoint( rect.iBr.iX - bitmap->SizeInPixels().iWidth,
+ rect.iTl.iY );
+ }
+
+ if ( bitmap && mask )
+ {
+ gc.BitBltMasked(
+ point,
+ bitmap,
+ TRect( 0, 0, rect.Width(), iStaconBatteryBitmapOffset ),
+ mask,
+ ETrue );
+ }
+
+ }
+
+
+// ---------------------------------------------------------------------------
+// CAknBatteryStrength::DrawInFlatStatusPane
+// ---------------------------------------------------------------------------
+//
+void CAknBatteryStrength::DrawInFlatStatusPane( const TRect& /*aRect*/ ) const
+ {
+ CWindowGc& gc = SystemGc();
+
+ TRect rect( Rect() );
+ MAknsSkinInstance* skin = AknsUtils::SkinInstance();
+
+ // Draws battery strength bar
+ CAknsMaskedBitmapItemData* bitmapData = NULL;
+
+ if ( skin )
+ {
+ bitmapData = static_cast<CAknsMaskedBitmapItemData*>(
+ skin->GetCachedItemData(
+ KAknsIIDQgnIndiBatteryStrength, EAknsITMaskedBitmap ) );
+ if ( bitmapData )
+ {
+ CFbsBitmap* bitmap = bitmapData->Bitmap();
+
+ if ( bitmap )
+ AknIconUtils::SetSize( bitmap,
+ TSize( rect.Width(),
+ rect.Height() ),
+ EAspectRatioNotPreserved );
+
+ TPoint point( 0, iFlatBatteryBitmapOffset );
+ if ( bitmap && !AknLayoutUtils::LayoutMirrored() )
+ {
+ point = TPoint( rect.iBr.iX - bitmap->SizeInPixels().iWidth,
+ iFlatBatteryBitmapOffset);
+ }
+
+ gc.BitBltMasked(
+ point,
+ bitmap, TRect(0,iFlatBatteryBitmapOffset,
+ rect.Width(),
+ rect.Height()),
+ bitmapData->Mask(), ETrue );
+ }
+ }
+
+ if ( !bitmapData )
+ {
+ if ( iFlatBatteryIndicatorBitmap && iFlatBatteryIndicatorBitmapMask )
+ {
+ TPoint point( 0, iFlatBatteryBitmapOffset );
+ if ( !AknLayoutUtils::LayoutMirrored() )
+ {
+ point = TPoint(
+ rect.iBr.iX - iFlatBatteryIndicatorBitmap->SizeInPixels().iWidth,
+ iFlatBatteryBitmapOffset );
+ }
+ gc.BitBltMasked(
+ point,
+ iFlatBatteryIndicatorBitmap,
+ TRect( 0,
+ iFlatBatteryBitmapOffset,
+ rect.Width(),
+ rect.Height() ),
+ iFlatBatteryIndicatorBitmapMask,
+ ETrue );
+ }
+ }
+
+ }
+
+
+// ---------------------------------------------------------------------------
+// CAknBatteryStrength::SetRecharging
+// ---------------------------------------------------------------------------
+//
+void CAknBatteryStrength::SetRecharging( TBool aRecharging )
+ {
+ iRecharging = aRecharging;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CAknBatteryStrength::Recharging
+// ---------------------------------------------------------------------------
+//
+TBool CAknBatteryStrength::Recharging()
+ {
+ return iRecharging;
+ }
+
+// End of File