diff -r 000000000000 -r 2f259fa3e83a uifw/AvKon/src/AknBatteryStrength.cpp --- /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 +#include +#include +#include +#include "AknDef.h" +#include + +#include +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( + 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( + 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