--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uifw/AvKon/src/AknSignalStrength.cpp Tue Feb 02 01:00:49 2010 +0200
@@ -0,0 +1,916 @@
+/*
+* 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,
+ EMbmAvkonQgn_indi_signal_strength,
+ EMbmAvkonQgn_indi_signal_strength_mask );
+
+ AknsUtils::CreateColorIconL( skin,
+ KAknsIIDQgnIndiNoSignal,
+ KAknsIIDQsnIconColors,
+ EAknsCIQsnIconColorsCG3,
+ iFlatNoSignalIndicatorBitmap,
+ iFlatNoSignalIndicatorBitmapMask,
+ KAvkonBitmapFile,
+ EMbmAvkonQgn_indi_no_signal,
+ EMbmAvkonQgn_indi_no_signal_mask,
+ KRgbGray );
+
+ AknIconUtils::SetSize( iFlatSignalIndicatorBitmap,
+ Size(),
+ EAspectRatioNotPreserved);
+ AknIconUtils::SetSize( iFlatNoSignalIndicatorBitmap,
+ Size(),
+ EAspectRatioNotPreserved );
+
+ CFbsBitmap* itemIsSkinned = AknsUtils::GetCachedBitmap(
+ skin, KAknsIIDQgnIndiSignalStrength );
+ if ( AknLayoutUtils::LayoutMirrored() && !itemIsSkinned )
+ {
+ CFbsBitmap* tmpBitmap =
+ AknBitmapMirrorUtils::HorizontallyMirrorBitmapL(
+ iFlatSignalIndicatorBitmap );
+
+ CFbsBitmap* tmpBitmapMask =
+ AknBitmapMirrorUtils::HorizontallyMirrorBitmapL(
+ iFlatSignalIndicatorBitmapMask );
+
+ delete iFlatSignalIndicatorBitmap;
+ iFlatSignalIndicatorBitmap = tmpBitmap;
+ delete iFlatSignalIndicatorBitmapMask;
+ iFlatSignalIndicatorBitmapMask = tmpBitmapMask;
+ }
+
+ CFbsBitmap* itemIsSkinned2 = AknsUtils::GetCachedBitmap(
+ skin, KAknsIIDQgnIndiNoSignal );
+ if ( AknLayoutUtils::LayoutMirrored() && !itemIsSkinned2 )
+ {
+ CFbsBitmap* tmpBitmapNoSignal =
+ AknBitmapMirrorUtils::HorizontallyMirrorBitmapL(
+ iFlatNoSignalIndicatorBitmap );
+
+ CFbsBitmap* tmpBitmapNoSignalMask =
+ AknBitmapMirrorUtils::HorizontallyMirrorBitmapL(
+ iFlatNoSignalIndicatorBitmapMask );
+
+ delete iFlatNoSignalIndicatorBitmap;
+ iFlatNoSignalIndicatorBitmap = tmpBitmapNoSignal;
+ delete iFlatNoSignalIndicatorBitmapMask;
+ iFlatNoSignalIndicatorBitmapMask = tmpBitmapNoSignalMask;
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// CAknSignalStrength::DeleteBitmaps
+// ---------------------------------------------------------------------------
+//
+void CAknSignalStrength::DeleteBitmaps()
+ {
+ // default bitmaps
+ delete iDefaultSignalIndicatorBitmap;
+ iDefaultSignalIndicatorBitmap = NULL;
+ delete iDefaultSignalIndicatorBitmapMask;
+ iDefaultSignalIndicatorBitmapMask = NULL;
+ delete iDefaultNoSignalIndicatorBitmap;
+ iDefaultNoSignalIndicatorBitmap = NULL;
+ delete iDefaultNoSignalIndicatorBitmapMask;
+ iDefaultNoSignalIndicatorBitmapMask = NULL;
+
+ // flat bitmaps
+ delete iFlatSignalIndicatorBitmap;
+ iFlatSignalIndicatorBitmap = NULL;
+ delete iFlatSignalIndicatorBitmapMask;
+ iFlatSignalIndicatorBitmapMask = NULL;
+ delete iFlatNoSignalIndicatorBitmap;
+ iFlatNoSignalIndicatorBitmap = NULL;
+ delete iFlatNoSignalIndicatorBitmapMask;
+ iFlatNoSignalIndicatorBitmapMask = NULL;
+
+ // stacon bitmaps
+ delete iStaconLeftSideSignalIndicatorBitmap;
+ iStaconLeftSideSignalIndicatorBitmap = NULL;
+ delete iStaconLeftSideSignalIndicatorBitmapMask;
+ iStaconLeftSideSignalIndicatorBitmapMask = NULL;
+
+ delete iStaconRightSideSignalIndicatorBitmap;
+ iStaconRightSideSignalIndicatorBitmap = NULL;
+ delete iStaconRightSideSignalIndicatorBitmapMask;
+ iStaconRightSideSignalIndicatorBitmapMask = NULL;
+
+ delete iStaconNoSignalIndicatorBitmap;
+ iStaconNoSignalIndicatorBitmap = NULL;
+ delete iStaconNoSignalIndicatorBitmapMask;
+ iStaconNoSignalIndicatorBitmapMask = NULL;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CAknSignalStrength::HandleResourceChange
+// ---------------------------------------------------------------------------
+//
+void CAknSignalStrength::HandleResourceChange( TInt aType )
+ {
+ CCoeControl::HandleResourceChange( aType );
+
+ if ( aType == KEikDynamicLayoutVariantSwitch ||
+ aType == KEikColorResourceChange ||
+ aType == KAknsMessageSkinChange )
+ {
+ DeleteBitmaps(); // SizeChanged loads bitmaps again
+ SizeChanged();
+ SetSignalLevel( iSignalLevel ); // Refreshes signal level offsets
+ DrawDeferred();
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// CAknSignalStrength::DrawInNormalStatusPane
+// ---------------------------------------------------------------------------
+//
+void CAknSignalStrength::DrawInNormalStatusPane( const TRect& /*aRect*/ ) const
+ {
+ CWindowGc& gc = SystemGc();
+
+ MAknsSkinInstance* skin = AknsUtils::SkinInstance();
+ TRect rect( Rect() );
+
+ // Signal strength bar.
+ CAknsMaskedBitmapItemData* bitmap;
+
+ if( iSignalLevel == KAknSignalOffLineMode )
+ {
+ // Off-line indicator.
+ if ( iDefaultNoSignalIndicatorBitmap &&
+ iDefaultNoSignalIndicatorBitmapMask )
+ {
+ gc.BitBltMasked(
+ rect.iTl,
+ iDefaultNoSignalIndicatorBitmap,
+ TRect( 0, 0, rect.Width(), rect.Height() ),
+ iDefaultNoSignalIndicatorBitmapMask,
+ ETrue );
+ }
+ }
+ else
+ {
+ TBool legacydraw = EFalse;
+
+ if ( skin )
+ {
+ bitmap = static_cast<CAknsMaskedBitmapItemData*>(
+ skin->GetCachedItemData( KAknsIIDQgnIndiSignalStrength,
+ 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, iDefaultSignalBitmapOffset ),
+ bitmap->Bitmap(),
+ TRect( 0,
+ iDefaultSignalBitmapOffset,
+ rect.Width(),
+ rect.Height() ),
+ bitmap->Mask(),
+ ETrue );
+ }
+ else
+ {
+ legacydraw = ETrue;
+ }
+ }
+
+ if ( legacydraw )
+ {
+ if ( iDefaultSignalIndicatorBitmap &&
+ iDefaultSignalIndicatorBitmapMask )
+ {
+ gc.BitBltMasked(
+ TPoint( rect.iTl.iX, iDefaultSignalBitmapOffset ),
+ iDefaultSignalIndicatorBitmap,
+ TRect( 0,
+ iDefaultSignalBitmapOffset,
+ rect.Width(),
+ rect.Height() ),
+ iDefaultSignalIndicatorBitmapMask,
+ ETrue );
+ }
+ }
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// CAknSignalStrength::DrawInStaconPane
+// ---------------------------------------------------------------------------
+//
+void CAknSignalStrength::DrawInStaconPane( const TRect& /*aRect*/ ) const
+ {
+ CWindowGc& gc = SystemGc();
+ TRect rect( Rect() );
+
+ CFbsBitmap* bitmap = NULL;
+ CFbsBitmap* mask = NULL;
+
+ if ( iSignalLevel == KAknSignalOffLineMode )
+ {
+ // Off-line indicator.
+ if ( iStaconNoSignalIndicatorBitmap &&
+ iStaconNoSignalIndicatorBitmapMask )
+ {
+ gc.BitBltMasked(
+ rect.iTl,
+ iStaconNoSignalIndicatorBitmap,
+ TRect( 0, 0, rect.Width(), rect.Height() ),
+ iStaconNoSignalIndicatorBitmapMask,
+ ETrue );
+ }
+ }
+ else
+ {
+ TPoint point( rect.iTl.iX,
+ rect.iTl.iY + iStaconSignalBitmapOffset );
+
+ if ( AknStatuspaneUtils::StaconSoftKeysLeft() )
+ {
+ bitmap = iStaconRightSideSignalIndicatorBitmap;
+ mask = iStaconRightSideSignalIndicatorBitmapMask;
+
+ if ( bitmap )
+ {
+ point = TPoint( rect.iBr.iX - bitmap->SizeInPixels().iWidth,
+ rect.iTl.iY + iStaconSignalBitmapOffset );
+ }
+
+ }
+ else
+ {
+ bitmap = iStaconLeftSideSignalIndicatorBitmap;
+ mask = iStaconLeftSideSignalIndicatorBitmapMask;
+ }
+
+ if ( bitmap && mask )
+ {
+ gc.BitBltMasked(
+ point,
+ bitmap,
+ TRect( 0,
+ iStaconSignalBitmapOffset,
+ rect.Width(),
+ rect.Height() ),
+ mask,
+ ETrue );
+ }
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// CAknSignalStrength::DrawInFlatStatusPane
+// ---------------------------------------------------------------------------
+//
+void CAknSignalStrength::DrawInFlatStatusPane( const TRect& /*aRect*/ ) const
+ {
+ CWindowGc& gc = SystemGc();
+
+ MAknsSkinInstance* skin = AknsUtils::SkinInstance();
+ TRect rect( Rect() );
+
+ // Signal strength bar.
+ CAknsMaskedBitmapItemData* bitmapData;
+
+ if ( iSignalLevel == KAknSignalOffLineMode )
+ {
+ // Off-line indicator.
+ if ( iFlatNoSignalIndicatorBitmap && iFlatNoSignalIndicatorBitmapMask )
+ {
+ gc.BitBltMasked(
+ rect.iTl,
+ iFlatNoSignalIndicatorBitmap,
+ TRect( 0, 0, rect.Width(), rect.Height() ),
+ iFlatNoSignalIndicatorBitmapMask,
+ ETrue );
+ }
+ }
+ else
+ {
+ TBool legacydraw = EFalse;
+
+ if ( skin )
+ {
+ bitmapData = static_cast<CAknsMaskedBitmapItemData*>(
+ skin->GetCachedItemData(
+ KAknsIIDQgnIndiSignalStrength, EAknsITMaskedBitmap ) );
+ if ( bitmapData )
+ {
+ TPoint point( rect.iTl.iX, iFlatSignalBitmapOffset );
+
+ CFbsBitmap* bitmap = bitmapData->Bitmap();
+
+ if ( bitmap )
+ {
+ AknIconUtils::SetSize(
+ bitmap,
+ TSize( rect.Width(),
+ rect.Height() ),
+ EAspectRatioNotPreserved );
+
+ if ( AknLayoutUtils::LayoutMirrored() )
+ {
+ point = TPoint(
+ rect.iBr.iX - bitmap->SizeInPixels().iWidth,
+ iFlatSignalBitmapOffset );
+ }
+ }
+
+ gc.BitBltMasked(
+ point,
+ bitmap,
+ TRect( 0,
+ iFlatSignalBitmapOffset,
+ rect.Width(),
+ rect.Height() ),
+ bitmapData->Mask(),
+ ETrue );
+ }
+ else
+ {
+ legacydraw = ETrue;
+ }
+ }
+
+ if ( legacydraw )
+ {
+ if ( iFlatSignalIndicatorBitmap && iFlatSignalIndicatorBitmapMask )
+ {
+ TPoint point( rect.iTl.iX, iFlatSignalBitmapOffset );
+
+ if ( AknLayoutUtils::LayoutMirrored() )
+ {
+ point = TPoint(
+ rect.iBr.iX - iFlatSignalIndicatorBitmap->SizeInPixels().iWidth,
+ iFlatSignalBitmapOffset );
+ }
+
+ gc.BitBltMasked(
+ point,
+ iFlatSignalIndicatorBitmap,
+ TRect( 0,
+ iFlatSignalBitmapOffset,
+ rect.Width(),
+ rect.Height() ),
+ iFlatSignalIndicatorBitmapMask,
+ ETrue );
+ }
+ }
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// CAknSignalStrength::SignalLevel
+// ---------------------------------------------------------------------------
+//
+TInt CAknSignalStrength::SignalLevel()
+ {
+ return iSignalLevel;
+ }
+
+// End of File