diff -r 000000000000 -r 2f259fa3e83a uifw/AvKon/src/aknnavi.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uifw/AvKon/src/aknnavi.cpp Tue Feb 02 01:00:49 2010 +0200 @@ -0,0 +1,2560 @@ +/* +* Copyright (c) 2002-2008 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: Implementation of the navi pane container control. +* +*/ + + +// SYSTEM INCLUDE FILES +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +// USER INCLUDE FILES +#include "aknenv.h" +#include "AknDef.h" +#include "aknappui.h" +#include "aknconsts.h" +#include "akntabgrp.h" +#include "aknnavide.h" +#include "AknIndicatorContainer.h" +#include "AknVolumePopup.h" +#include "AknUtils.h" +#include "AknBitmapMirrorUtils.h" +#include "avkon.hrh" +#include "aknnavi.h" +#include "aknnavilabel.h" +#include "akncontext.h" +#include "AknSignalNotify.h" +#include "AknNaviForegroundObserver.h" +#include "AknNaviConstants.h" +#include "aknEditStateIndicator.h" +#include "AknStatuspaneUtils.h" +#include "akntitle.h" +#include "AknTitlePaneLabel.h" +#include "AknDebug.h" + +const TInt KAknNaviPaneStackGranularity = 2; +/** +* Extension class for CAknNavigationControlContainer. +*/ +class CAknNavigationControlContainerExtension : public CBase + { +public: + CAknNavigationControlContainerExtension(){}; + ~CAknNavigationControlContainerExtension(){}; + +public: + TInt iCurrentColorScheme; + CAknNaviForegroundObserver* iForegroundObserver; + TBool iDestructionOngoing; + CFbsBitmap* iNaviColorBitmap; + TInt iPreferredNaviDecoratorLayoutStyle; + TBool iIsActiveIdle; + }; + + + +// ---------------------------------------------------------------------------- +// CAknNavigationControlContainer::CAknNavigationControlContainer +// Default constructor. +// ---------------------------------------------------------------------------- +// +EXPORT_C CAknNavigationControlContainer::CAknNavigationControlContainer() : + iStatusPane( CEikStatusPaneBase::Current() ) + { + AKNTASHOOK_ADD( this, "CAknNavigationControlContainer" ); + } + + +// ---------------------------------------------------------------------------- +// CAknNavigationControlContainer::~CAknNavigationControlContainer +// Destructor. +// ---------------------------------------------------------------------------- +// +EXPORT_C CAknNavigationControlContainer::~CAknNavigationControlContainer() + { + AKNTASHOOK_REMOVE(); + if ( iExtension ) + { + iExtension->iDestructionOngoing = ETrue; + } + + AknsUtils::DeregisterControlPosition( this ); + + delete iNaviDecoratorFromResource; + + if ( iNaviPaneControls ) + { + const TInt last = iNaviPaneControls->Count() - 1; + TInt ii = 0; + for ( ii = last; ii >= 0; ii-- ) + { + Pop( iNaviPaneControls->At( ii ) ); + } + delete iNaviPaneControls; + } + + for ( TInt jj = 0; jj < 4; jj++ ) + { + delete iNaviArrowBitmap[ jj ]; + } + + if ( iExtension ) + { + delete iExtension->iForegroundObserver; + delete iExtension->iNaviColorBitmap; + delete iExtension; + } + } + + +// ---------------------------------------------------------------------------- +// CAknNavigationControlContainer::ConstructL +// Second-phase constructor. +// ---------------------------------------------------------------------------- +// +EXPORT_C void CAknNavigationControlContainer::ConstructL() + { + if ( !iExtension ) + { + iExtension = + new (ELeave) CAknNavigationControlContainerExtension(); + iExtension->iCurrentColorScheme = ColorScheme(); + iExtension->iForegroundObserver = + CAknNaviForegroundObserver::NewL( this ); + iExtension->iIsActiveIdle = AknStatuspaneUtils::IsActiveIdle(); + } + + if ( !iNaviPaneControls ) + { + iNaviPaneControls = + new (ELeave) CAknNaviPaneStack( KAknNaviPaneStackGranularity ); + } + + // creating color bitmap + LoadNaviColorBitmapL(); + + MAknsSkinInstance* skin = AknsUtils::SkinInstance(); + + AknsUtils::CreateIconL( skin, + KAknsIIDQgnIndiNaviArrowLeft, + iNaviArrowBitmap[ 0 ], + iNaviArrowBitmap[ 1 ], + KAvkonBitmapFile, + EMbmAvkonQgn_indi_navi_arrow_left, + EMbmAvkonQgn_indi_navi_arrow_left_mask ); + + AknsUtils::CreateIconL( skin, + KAknsIIDQgnIndiNaviArrowRight, + iNaviArrowBitmap[ 2 ], + iNaviArrowBitmap[ 3 ], + KAvkonBitmapFile, + EMbmAvkonQgn_indi_navi_arrow_right, + EMbmAvkonQgn_indi_navi_arrow_right_mask ); + + } + + +// ---------------------------------------------------------------------------- +// CAknNavigationControlContainer::ConstructFromResourceL +// Resource constructor. +// ---------------------------------------------------------------------------- +// +EXPORT_C void CAknNavigationControlContainer::ConstructFromResourceL( + TResourceReader& aReader ) + { + ConstructL(); + iNaviDecoratorFromResource = + ConstructNavigationDecoratorFromResourceL( aReader ); + if ( iNaviDecoratorFromResource ) + { + PushL( *iNaviDecoratorFromResource ); + } + } + + +// ---------------------------------------------------------------------------- +// CAknNavigationControlContainer::ConstructNavigationDecoratorFromResourceL +// Creates a decorated navi pane control from resource. +// ---------------------------------------------------------------------------- +// +EXPORT_C CAknNavigationDecorator* CAknNavigationControlContainer::ConstructNavigationDecoratorFromResourceL( + TResourceReader& aReader ) + { + TInt controlType = aReader.ReadInt16(); // type + CAknNavigationDecorator* decoratedNaviObject = NULL; + + switch ( controlType ) + { + case ENaviDecoratorControlNone: + { + PushDefaultL(); + break; + } + + case ENaviDecoratorControlTabGroup: + { + decoratedNaviObject = CreateTabGroupL( aReader ); + break; + } + + case ENaviDecoratorLabel: + { + decoratedNaviObject = CreateNavigationLabelL( aReader ); + break; + } + + case ENaviDecoratorImage: + { + decoratedNaviObject = CreateNavigationImageL( aReader ); + break; + } + + case ENaviDecoratorToolTip: + { + decoratedNaviObject = CreateMessageLabelL( aReader ); + break; + } + + default: + { + break; + } + } + + return decoratedNaviObject; + } + + +// ---------------------------------------------------------------------------- +// CAknNavigationControlContainer::CreateTabGroupL +// Creates a decorated tab group control to use in navi pane. +// ---------------------------------------------------------------------------- +// +EXPORT_C CAknNavigationDecorator* CAknNavigationControlContainer::CreateTabGroupL() + { + TBool penEnabled( AknLayoutUtils::PenEnabled() ); + + CAknTabGroup* tabGroup = CAknTabGroup::NewL( *this ); + + // Tab group to the clean up stack in first line of NewL function. + CAknNavigationDecorator* decoratedTabGroup = + CAknNavigationDecorator::NewL( this, + tabGroup, + CAknNavigationDecorator::ETabGroup ); + + if ( penEnabled ) + { + // Set tab group as an observer of the decorator for right/left + // arrows tapping. + decoratedTabGroup->SetNaviDecoratorObserver( tabGroup ); + } + + CleanupStack::PushL( decoratedTabGroup ); + + decoratedTabGroup->SetContainerWindowL( *this ); + + // Navi arrows are not used for tab group in touch layouts. + decoratedTabGroup->MakeScrollButtonVisible( !penEnabled ); + + tabGroup->SetRect( + CAknNavigationDecorator::DecoratedTabControlRect( + !AknStatuspaneUtils::UsualLayoutActive(), + !penEnabled ) ); + + CleanupStack::Pop( decoratedTabGroup ); + + decoratedTabGroup->SetObserver( this ); + + return decoratedTabGroup; + } + + +// ---------------------------------------------------------------------------- +// CAknNavigationControlContainer::CreateTabGroupL +// Creates a decorated tab group control to use in navi pane. +// ---------------------------------------------------------------------------- +// +EXPORT_C CAknNavigationDecorator* CAknNavigationControlContainer::CreateTabGroupL( + MAknTabObserver *aObserver ) + { + CAknNavigationDecorator* navDec = CreateTabGroupL(); + CAknTabGroup* tabGroup = + static_cast( navDec->DecoratedControl() ); + tabGroup->SetObserver( aObserver ); + + return navDec; + } + + +// ---------------------------------------------------------------------------- +// CAknNavigationControlContainer::CreateTabGroupL +// Creates a decorated tab group control to use in navi pane. +// ---------------------------------------------------------------------------- +// +EXPORT_C CAknNavigationDecorator* CAknNavigationControlContainer::CreateTabGroupL( + TResourceReader& aReader, MAknTabObserver* aObserver ) + { + CAknNavigationDecorator *navDec = CreateTabGroupL( aReader ); + + CAknTabGroup* tabGroup = + static_cast( navDec->DecoratedControl() ); + tabGroup->SetObserver( aObserver ); + + return navDec; + } + + +// ---------------------------------------------------------------------------- +// CAknNavigationControlContainer::CreateTabGroupL +// Creates a decorated tab group control to use in navi pane. +// ---------------------------------------------------------------------------- +// +EXPORT_C CAknNavigationDecorator* CAknNavigationControlContainer::CreateTabGroupL( + TResourceReader& aReader) + { + CAknNavigationDecorator* decoratedTabGroup; + decoratedTabGroup = CreateTabGroupL(); + CleanupStack::PushL( decoratedTabGroup ); + + CAknTabGroup* tabGroup = + static_cast( decoratedTabGroup->DecoratedControl() ); + + TInt width = aReader.ReadInt16(); + tabGroup->SetTabFixedWidthL( width ); + TInt activeIndex = aReader.ReadInt16(); + + TInt count = aReader.ReadInt16(); // Tab count + for ( TInt ii = 0; ii < count; ii++ ) + { + tabGroup->AddTabL( aReader ); + } + tabGroup->SetActiveTabByIndex( activeIndex ); + + CleanupStack::Pop( decoratedTabGroup ); + return decoratedTabGroup; + } + + +// ---------------------------------------------------------------------------- +// CAknNavigationControlContainer::CreateNavigationLabelL +// Creates a decorated navigation label control to use in navi pane. +// ---------------------------------------------------------------------------- +// +EXPORT_C CAknNavigationDecorator* CAknNavigationControlContainer::CreateNavigationLabelL( + const TDesC& aText ) + { + CAknNaviLabel* label = new (ELeave) CAknNaviLabel; + CleanupStack::PushL( label ); + + label->SetContainerWindowL( *this ); + label->SetTextL( aText ); + label->SetNaviLabelType( CAknNaviLabel::EAdditionalInfoLabel ); + + CleanupStack::Pop( label ); + CAknNavigationDecorator* decoratedLabel = + CAknNavigationDecorator::NewL( this, + label, + CAknNavigationDecorator::ENaviLabel ); + CleanupStack::PushL( decoratedLabel ); + + decoratedLabel->SetContainerWindowL( *this ); + decoratedLabel->SetControlContext( this ); + decoratedLabel->MakeScrollButtonVisible( EFalse ); + + CleanupStack::Pop( decoratedLabel ); + + return decoratedLabel; + } + + +// ---------------------------------------------------------------------------- +// CAknNavigationControlContainer::CreateNavigationLabelL +// Creates a decorated navigation label control to use in navi pane. +// ---------------------------------------------------------------------------- +// +EXPORT_C CAknNavigationDecorator* CAknNavigationControlContainer::CreateNavigationLabelL( + TResourceReader& aReader ) + { + HBufC* txt = aReader.ReadHBufCL(); // Label text + CAknNavigationDecorator* decoratedLabel = NULL; + + if ( txt ) + { + CleanupStack::PushL( txt ); + decoratedLabel = CreateNavigationLabelL( *txt ); + CleanupStack::PopAndDestroy( txt ); + } + else + { + decoratedLabel = CreateNavigationLabelL( KNullDesC ); + } + + return decoratedLabel; + } + + +// ---------------------------------------------------------------------------- +// CAknNavigationControlContainer::CreateNavigationImageL +// Creates a decorated navigation image control to use in navi pane. +// ---------------------------------------------------------------------------- +// +EXPORT_C CAknNavigationDecorator* CAknNavigationControlContainer::CreateNavigationImageL( + const CFbsBitmap* aBitmap, const CFbsBitmap* aMaskBitmap ) + { + CEikImage* image = new (ELeave) CEikImage; + CleanupStack::PushL( image ); + + image->SetContainerWindowL( *this ); + + TAknWindowComponentLayout layout; + if ( AknStatuspaneUtils::StaconPaneActive() ) + { + layout = TAknWindowComponentLayout::Compose( + AknLayoutScalable_Avkon::navi_navi_pane_stacon( 1 ), + AknLayoutScalable_Avkon::navi_navi_icon_text_pane() ); + } + else + { + layout = TAknWindowComponentLayout::Compose( + AknLayoutScalable_Avkon::navi_navi_pane(), + AknLayoutScalable_Avkon::navi_navi_icon_text_pane() ); + } + + TRect parent( Rect() ); + TAknLayoutRect imageLayoutRect; + imageLayoutRect.LayoutRect( parent, layout ); + TRect imageRect( imageLayoutRect.Rect() ); + + image->SetRect( imageRect ); + + image->SetPictureOwnedExternally( ETrue ); + image->SetPicture( aBitmap, aMaskBitmap ); + CleanupStack::Pop( image ); + + CAknNavigationDecorator* decoratedImage = + CAknNavigationDecorator::NewL( this, + image, + CAknNavigationDecorator::ENaviImage ); + + CleanupStack::PushL( decoratedImage ); + decoratedImage->SetContainerWindowL( *this ); + CleanupStack::Pop( decoratedImage ); + + decoratedImage->MakeScrollButtonVisible( EFalse ); + + // Ownership of aBitmap and aMaskBitmap is moved to decoratedImage object + // after all leaving methods. + image->SetPictureOwnedExternally( EFalse ); + return decoratedImage; + } + + +// ---------------------------------------------------------------------------- +// CAknNavigationControlContainer::CreateNavigationImageL +// Creates a decorated navigation image control to use in navi pane. +// ---------------------------------------------------------------------------- +// +EXPORT_C CAknNavigationDecorator* CAknNavigationControlContainer::CreateNavigationImageL( + TResourceReader& aReader ) + { + CAknNavigationDecorator* decoratedLabel = NULL; + + HBufC* bitmapFile = aReader.ReadHBufCL(); // bmp filename + TInt bitmapId = aReader.ReadInt16(); // bmp id + TInt maskId = aReader.ReadInt16(); // bmp mask id + + if ( bitmapFile ) + { + CleanupStack::PushL( bitmapFile ); + + TFileName fileName( *bitmapFile ); + CompleteWithAppPath( fileName ); + + if ( bitmapId != KErrNotFound ) + { + CFbsBitmap* bitmap; + + if ( maskId != KErrNotFound ) + { + CFbsBitmap* mask; + AknIconUtils::CreateIconL( bitmap, + mask, + fileName, + bitmapId, + maskId ); + + TAknLayoutRect rect; + + TAknWindowComponentLayout layout; + if ( AknStatuspaneUtils::StaconPaneActive() ) + { + layout = TAknWindowComponentLayout::Compose( + AknLayoutScalable_Avkon::navi_navi_pane(), + AknLayoutScalable_Avkon::navi_navi_tabs_pane() ); + } + else + { + layout = AknLayoutScalable_Avkon::navi_navi_tabs_pane(); + } + + rect.LayoutRect( Rect(), layout ); + + AknIconUtils::SetSize( bitmap, rect.Rect().Size() ); + + decoratedLabel = CreateNavigationImageL( bitmap, mask ); + } + else + { + bitmap = AknIconUtils::CreateIconL( fileName, bitmapId ); + TAknLayoutRect rect; + + TAknWindowComponentLayout layout; + if ( AknStatuspaneUtils::StaconPaneActive() ) + { + layout = TAknWindowComponentLayout::Compose( + AknLayoutScalable_Avkon::navi_navi_pane(), + AknLayoutScalable_Avkon::navi_navi_tabs_pane() ); + } + else + { + layout = AknLayoutScalable_Avkon::navi_navi_tabs_pane(); + } + + rect.LayoutRect( Rect(), layout ); + AknIconUtils::SetSize( bitmap, rect.Rect().Size() ); + + decoratedLabel = CreateNavigationImageL( bitmap ); + } + } + CleanupStack::PopAndDestroy( bitmapFile ); + } + + return decoratedLabel; + } + + +// ---------------------------------------------------------------------------- +// CAknNavigationControlContainer::CreateMessageLabelL +// Creates a decorated message label control to use in navi pane. +// ---------------------------------------------------------------------------- +// +EXPORT_C CAknNavigationDecorator* CAknNavigationControlContainer::CreateMessageLabelL( + const TDesC& aText ) + { + CAknNavigationDecorator* decoratedLabel = CreateNavigationLabelL( aText ); + + CAknNaviLabel* label = STATIC_CAST( CAknNaviLabel*, + decoratedLabel->DecoratedControl() ); + + label->SetNaviLabelType( CAknNaviLabel::EHintText ); + + decoratedLabel->SetControlType( CAknNavigationDecorator::EHintText ); + + return decoratedLabel; + } + + +// ---------------------------------------------------------------------------- +// CAknNavigationControlContainer::CreateMessageLabelL +// Creates a decorated message label control to use in navi pane. +// ---------------------------------------------------------------------------- +// +EXPORT_C CAknNavigationDecorator* CAknNavigationControlContainer::CreateMessageLabelL( + TResourceReader& aReader ) + { + HBufC* txt = aReader.ReadHBufCL(); // message text + CAknNavigationDecorator* decoratedLabel = NULL; + if ( txt ) + { + CleanupStack::PushL( txt ); + decoratedLabel = CreateMessageLabelL( *txt ); + CleanupStack::PopAndDestroy( txt ); + } + else + { + decoratedLabel = CreateMessageLabelL( KNullDesC ); + } + return decoratedLabel; + } + + +// ---------------------------------------------------------------------------- +// CAknNavigationControlContainer::CreateVolumeIndicatorL +// Deprecated, creates a volume popup control. +// ---------------------------------------------------------------------------- +// +EXPORT_C CAknNavigationDecorator* CAknNavigationControlContainer::CreateVolumeIndicatorL( + TInt aResourceId ) + { + // Navi pane volume control is no longer supported from release 5.0 on, + // but to maintain BC a volume popup control is launched instead. + CAknVolumePopup* volumeIndicator = + CAknVolumePopup::ConstructFromResourceL( aResourceId ); + + CleanupStack::PushL( volumeIndicator ); + + CAknNavigationDecorator* decoratedVolumeIndicator = + CAknNavigationDecorator::NewL( this, + volumeIndicator, + CAknNavigationDecorator::ENaviVolume ); + + // Set the volume popup's position. + volumeIndicator->SetRect( VolumePopupRect() ); + + CleanupStack::Pop( volumeIndicator ); + + return decoratedVolumeIndicator; + } + + +// ---------------------------------------------------------------------------- +// CAknNavigationControlContainer::CreateEditorIndicatorContainerL +// Creates a decorated editor indicator container control to use in navi pane. +// ---------------------------------------------------------------------------- +// +EXPORT_C CAknNavigationDecorator* CAknNavigationControlContainer::CreateEditorIndicatorContainerL() + { + CAknIndicatorContainer* editorIndicatorContainer = + new (ELeave) CAknIndicatorContainer( + CAknIndicatorContainer::ENaviPaneEditorIndicators ); + + CleanupStack::PushL( editorIndicatorContainer ); + + editorIndicatorContainer->SetContainerWindowL( *this ); + + TResourceReader reader; + iCoeEnv->CreateResourceReaderLC( reader, + R_AVKON_NAVI_PANE_EDITOR_INDICATORS ); + editorIndicatorContainer->ConstructFromResourceL( reader ); + + // Update the signal icon state from status pane layout in small status pane + // to keep those two in sync. + if ( iStatusPane && + ( iStatusPane->CurrentLayoutResId() == + R_AVKON_STATUS_PANE_LAYOUT_SMALL_WITH_SIGNAL_PANE || + iStatusPane->CurrentLayoutResId() == + R_AVKON_STATUS_PANE_LAYOUT_SMALL_WITH_SIGNAL_PANE_MIRRORED ) ) + { + editorIndicatorContainer->SetIndicatorState( + TUid::Uid( EAknNaviPaneEditorIndicatorGprs ), + EAknIndicatorStateOn, + EFalse ); + } + + CleanupStack::PopAndDestroy(); // resource reader + + CleanupStack::Pop( editorIndicatorContainer ); // editorIndicatorContainer + + CAknNavigationDecorator* decoratedEditorIndicatorContainer = + CAknNavigationDecorator::NewL( this, + editorIndicatorContainer, + CAknNavigationDecorator::EEditorIndicator ); + + CleanupStack::PushL( decoratedEditorIndicatorContainer ); + + decoratedEditorIndicatorContainer->SetContainerWindowL( *this ); + CleanupStack::Pop( decoratedEditorIndicatorContainer ); + + decoratedEditorIndicatorContainer->MakeScrollButtonVisible( EFalse ); + + return decoratedEditorIndicatorContainer; + } + + +// ---------------------------------------------------------------------------- +// CAknNavigationControlContainer::PushDefaultL +// Pushes the default (empty) navi pane control to the navi pane control stack. +// ---------------------------------------------------------------------------- +// +EXPORT_C void CAknNavigationControlContainer::PushDefaultL( + TBool aAllowDuplicates ) + { + if ( !aAllowDuplicates ) + { + const TInt last = iNaviPaneControls->Count() - 1; + for ( TInt ii = last; ii >= 0; ii-- ) + { + if ( !( iNaviPaneControls->At( ii ) ) ) + { + iNaviPaneControls->Delete( ii ); + break; // Same reference only once in the stack + } + } + } + const TInt lastAfterDelete = iNaviPaneControls->Count() - 1; + + // This is required in case the empty navi pane is pushed to the stack, and + // the previous navi pane has a direction indication animation ongoing, + // in which case the arrow indicator would remain visible on the + // empty navi pane. + // + // Also, if the previous navi pane control is volume control, which + // now launches a volume popup, and the popup is visible, then it's closed. + // + CAknNavigationDecorator* naviControl = NULL; + for ( TInt jj = lastAfterDelete; jj >= 0; jj-- ) + { + naviControl = iNaviPaneControls->At( jj ); + if ( naviControl ) + { + naviControl->CancelTimer(); + + if ( naviControl->ControlType() == + CAknNavigationDecorator::ENaviVolume ) + { + CAknVolumePopup* volumePopup = + static_cast ( + naviControl->iDecoratedControl ); + if ( volumePopup ) + { + volumePopup->CloseVolumePopup(); + } + } + } + } + + if (lastAfterDelete >= 0 && + IsFepOwnedEditorIndicatorControl( iNaviPaneControls->At(lastAfterDelete) )) + { + // Insert after FEP owned editor indicator object. + iNaviPaneControls->InsertL(lastAfterDelete, NULL); + } + else + { + iNaviPaneControls->AppendL( NULL ); + DrawDeferred(); + } + + // Notify contextpane and signalpane that possibly the naviwipe drawing has + // been changed. + TRAP_IGNORE( NotifyNaviWipeStatusL() ); + } + + +// --------------------------------------------------------------------------- +// CAknNavigationControlContainer::PushL +// Pushes a decorated navi pane control to the navi pane control stack. +// --------------------------------------------------------------------------- +// +EXPORT_C void CAknNavigationControlContainer::PushL( + CAknNavigationDecorator& aNaviPaneControl ) + { + TBool isLandscape( Layout_Meta_Data::IsLandscapeOrientation() ); + + if ( AknStatuspaneUtils::FlatLayoutActive() && + iExtension->iPreferredNaviDecoratorLayoutStyle ) + { + // In flat status pane layout it's possible to use the narrow + // navi pane variant. + CAknNavigationDecorator::TAknNaviControlLayoutStyle layoutStyle; + if ( iExtension->iPreferredNaviDecoratorLayoutStyle == + CAknNavigationDecorator::ENaviControlLayoutNarrow ) + { + // Narrow layout set as preferred, use it. + layoutStyle = CAknNavigationDecorator::ENaviControlLayoutNarrow; + } + else + { + // Otherwise use the normal layout. + layoutStyle = CAknNavigationDecorator::ENaviControlLayoutNormal; + } + + // Check if the layout style is supported in the current layout. + if ( aNaviPaneControl.NaviControlLayoutStyleSupported( layoutStyle ) ) + { + aNaviPaneControl.SetNaviControlLayoutStyle( layoutStyle ); + + if ( isLandscape ) + { + // In landscape flat status pane layout use the automatic + // navi pane layout mode, so that the navi pane gives + // space to the title pane when necessary. + aNaviPaneControl.SetNaviControlLayoutMode( + CAknNavigationDecorator::ENaviControlLayoutModeAutomatic ); + } + else + { + // In portrait use the forced mode. + aNaviPaneControl.SetNaviControlLayoutMode( + CAknNavigationDecorator::ENaviControlLayoutModeForced ); + } + } + } + else if ( iExtension->iPreferredNaviDecoratorLayoutStyle == + CAknNavigationDecorator::ENaviControlLayoutWide || + ( AknStatuspaneUtils::UsualLayoutActive() && + !isLandscape && + ( aNaviPaneControl.ControlType() != + CAknNavigationDecorator::ETabGroup || + AknLayoutUtils::PenEnabled() ) ) ) + { + // In usual portrait status pane layout use the wide navi pane + // layout. Exception is tab group control in non-touch devices, + // for which the normal layout is used. + if ( aNaviPaneControl.NaviControlLayoutStyleSupported( + CAknNavigationDecorator::ENaviControlLayoutWide ) ) + { + aNaviPaneControl.SetNaviControlLayoutStyle( + CAknNavigationDecorator::ENaviControlLayoutWide ); + aNaviPaneControl.SetNaviControlLayoutMode( + CAknNavigationDecorator::ENaviControlLayoutModeForced ); + } + } + else + { + // Otherwise use the normal layout. + aNaviPaneControl.SetNaviControlLayoutStyle( + CAknNavigationDecorator::ENaviControlLayoutNormal ); + aNaviPaneControl.SetNaviControlLayoutMode( + CAknNavigationDecorator::ENaviControlLayoutModeAutomatic ); + } + + TRect rect( Rect() ); + aNaviPaneControl.SetRect( rect ); + + // If the object already exists in the stack, delete it first. + const TInt last = iNaviPaneControls->Count() - 1; + for ( TInt ii = last; ii >= 0; ii-- ) + { + if ( iNaviPaneControls->At(ii) == &aNaviPaneControl ) + { + iNaviPaneControls->Delete(ii); + break; // Same reference only once in the stack + } + } + + // If the top most object is an editor indicator control, insert + // new object after it. New object is put to the top otherwise. + const TInt lastAfterDelete = iNaviPaneControls->Count() - 1; + + // This is required in case the empty navi pane is pushed to the stack, and + // the previous navi pane has a direction indication animation ongoing, + // in which case the arrow indicator would remain visible on the + // empty navi pane. + // + // Also, if the previous navi pane control is volume control, which + // now launches a volume popup, and the popup is visible, then it's closed. + // + CAknNavigationDecorator* naviControl = NULL; + for ( TInt jj = lastAfterDelete; jj >= 0; jj-- ) + { + naviControl = iNaviPaneControls->At( jj ); + if ( naviControl ) + { + naviControl->CancelTimer(); + + if ( naviControl->ControlType() == + CAknNavigationDecorator::ENaviVolume ) + { + CAknVolumePopup* volumePopup = + static_cast ( + naviControl->iDecoratedControl ); + if ( volumePopup ) + { + volumePopup->CloseVolumePopup(); + // Tell the volume control that it's no longer the topmost + // control on the navi stack. + static_cast( + naviControl->DecoratedControl() )->HandleNaviStackChange( EFalse ); + } + } + } + } + + if ( lastAfterDelete >= 0 && + IsFepOwnedEditorIndicatorControl( + iNaviPaneControls->At(lastAfterDelete) ) ) + { + HandleVisibilityOfNonFepOwnedIndicatorControl( &aNaviPaneControl, + EFalse ); + // Insert new object after after FEP owned editor indicator object + iNaviPaneControls->InsertL( lastAfterDelete, &aNaviPaneControl ); + + // Tell the navi pane control that it is in this status pane + aNaviPaneControl.SetNaviStack( this ); + aNaviPaneControl.ActivateL(); + + if ( rect != Rect() ) + { + aNaviPaneControl.SetRect( Rect() ); + } + } + else + { + if ( lastAfterDelete >= 0 && + IsFepOwnedEditorIndicatorControl( &aNaviPaneControl ) ) + { + HandleVisibilityOfNonFepOwnedIndicatorControl( + iNaviPaneControls->At( lastAfterDelete ), EFalse ); + } + // Put new object to the top + iNaviPaneControls->AppendL( &aNaviPaneControl ); + + // Tell the navi pane control that it is in this status pane + aNaviPaneControl.SetNaviStack( this ); + + if ( aNaviPaneControl.ControlType() != CAknNavigationDecorator::ENaviVolume ) + { + aNaviPaneControl.ActivateL(); + + if ( rect != Rect() ) + { + aNaviPaneControl.SetRect( Rect() ); + } + + DrawDeferred(); + } + else + { + // If the navi pane control is of the ENaviVolume type, a volume popup + // is shown instead. + CAknVolumeControl* volumeControl = + static_cast ( aNaviPaneControl.DecoratedControl() ); + + // Check also that we are on the foreground. + if ( volumeControl && + iExtension && + iExtension->iForegroundObserver && + iExtension->iForegroundObserver->HasForegroundGained() ) + { + // Tell the volume control that it's the topmost + // control on the navi stack. + volumeControl->HandleNaviStackChange( ETrue ); + } + } + } + + // Notify contextpane and signalpane that possibly the naviwipe drawing has + // been changed. + TRAP_IGNORE( NotifyNaviWipeStatusL() ); + } + + +// --------------------------------------------------------------------------- +// CAknNavigationControlContainer::Pop +// Pops the topmost control from the navi stack. +// --------------------------------------------------------------------------- +// +EXPORT_C void CAknNavigationControlContainer::Pop() + { + const TInt last = iNaviPaneControls->Count() - 1; + if ( last >= 0 ) + { + if ( IsFepOwnedEditorIndicatorControl( iNaviPaneControls->At(last) ) ) + { + if ( last > 0) + { + // Tell the control that it is removed from this status pane + CAknNavigationDecorator* controlToDelete = + iNaviPaneControls->At( last - 1 ); + if ( controlToDelete ) + { + controlToDelete->SetNaviStack( NULL ); + } + + iNaviPaneControls->Delete( last - 1 ); + DrawDeferred(); + } + } + else + { + // Tell the control that it is removed from this status pane + CAknNavigationDecorator* controlToDelete = + iNaviPaneControls->At( last ); + + if ( controlToDelete ) + { + if ( controlToDelete->ControlType() == + CAknNavigationDecorator::ENaviVolume ) + { + CAknVolumePopup* volumePopup = + static_cast ( controlToDelete->iDecoratedControl ); + + if ( volumePopup ) + { + // Tell the volume control that it's no longer the topmost + // control on the navi stack. + static_cast( + controlToDelete->DecoratedControl() )->HandleNaviStackChange( EFalse ); + volumePopup->CloseVolumePopup(); + } + } + + controlToDelete->SetNaviStack( NULL ); + } + + iNaviPaneControls->Delete( last ); + DrawDeferred(); + } + } + + // Volume control must be informed if it's the topmost control in the navi + // pane stack after popping and we have the foreground. + TInt lastAfterDelete = iNaviPaneControls->Count() - 1; + if ( lastAfterDelete >= 0 ) + { + CAknNavigationDecorator* naviControl = NULL; + + naviControl = iNaviPaneControls->At( lastAfterDelete ); + if ( naviControl && + iExtension && + iExtension->iForegroundObserver && + iExtension->iForegroundObserver->HasForegroundGained() ) + { + if ( naviControl->ControlType() == + CAknNavigationDecorator::ENaviVolume ) + { + CAknVolumePopup* volumePopup = + static_cast ( + naviControl->iDecoratedControl ); + + if ( volumePopup ) + { + // Tell the volume control that it's the topmost + // control on the navi stack. + static_cast( + naviControl->DecoratedControl() )->HandleNaviStackChange( ETrue ); + } + } + else + { + // Initialize the layout timer if necessary. + naviControl->SetNaviControlLayoutMode( + naviControl->NaviControlLayoutMode() ); + } + } + } + + // Notify contextpane and signalpane that possibly the naviwipe drawing has + // been changed. + TRAP_IGNORE( NotifyNaviWipeStatusL() ); + } + + +// --------------------------------------------------------------------------- +// CAknNavigationControlContainer::Pop +// Pops a navi pane control from the navi stack. +// --------------------------------------------------------------------------- +// +EXPORT_C void CAknNavigationControlContainer::Pop( + CAknNavigationDecorator* aControl ) + { + const TInt last = iNaviPaneControls->Count() - 1; + TInt ii = 0; + for ( ii = last; ii >= 0; ii-- ) + { + if ( iNaviPaneControls->At(ii) == aControl ) + { + // Tell the control that it is not in this navi pane now. + if ( aControl ) + { + if ( aControl->ControlType() == CAknNavigationDecorator::ENaviVolume ) + { + CAknVolumePopup* volumePopup = + static_cast ( aControl->iDecoratedControl ); + + if ( volumePopup ) + { + static_cast( + aControl->DecoratedControl() )->HandleNaviStackChange( EFalse ); + volumePopup->CloseVolumePopup(); + } + } + + aControl->SetNaviStack( NULL ); + } + + iNaviPaneControls->Delete(ii); + break; // Same reference only once in the stack + } + } + + if ( ii == last ) // Drawn only if topmost control was popped + { + const TInt lastAfterDelete = iNaviPaneControls->Count() - 1; + if ( lastAfterDelete >= 0 ) + { + HandleVisibilityOfNonFepOwnedIndicatorControl( + iNaviPaneControls->At( lastAfterDelete ), ETrue ); + + CAknNavigationDecorator* naviControl = NULL; + + naviControl = iNaviPaneControls->At( lastAfterDelete ); + if ( naviControl && + iExtension && + iExtension->iForegroundObserver && + iExtension->iForegroundObserver->HasForegroundGained() ) + { + // Volume control must be informed if it's the topmost control + // in the navi pane stack after popping + // and we have the foreground. + if ( naviControl->ControlType() == + CAknNavigationDecorator::ENaviVolume ) + { + CAknVolumePopup* volumePopup = + static_cast ( + naviControl->iDecoratedControl ); + + if ( volumePopup ) + { + static_cast( + naviControl->DecoratedControl() )->HandleNaviStackChange( ETrue ); + } + } + else + { + // Initialize the layout timer if necessary. + naviControl->SetNaviControlLayoutMode( + naviControl->NaviControlLayoutMode() ); + } + } + } + DrawDeferred(); + } + + // Notify contextpane and signalpane that possibly the naviwipe drawing has + // been changed. + TRAP_IGNORE( NotifyNaviWipeStatusL() ); + } + + +// --------------------------------------------------------------------------- +// CAknNavigationControlContainer::Top +// Returns the topmost control on the navi stack. +// --------------------------------------------------------------------------- +// +EXPORT_C CAknNavigationDecorator* CAknNavigationControlContainer::Top() + { + return Top( ETrue ); + } + + +// --------------------------------------------------------------------------- +// CAknNavigationControlContainer::Top +// Returns the topmost control on the navi stack. +// --------------------------------------------------------------------------- +// +EXPORT_C CAknNavigationDecorator* CAknNavigationControlContainer::Top( + TBool aIgnoreFepEditorIndicator ) const + { + CAknNavigationDecorator* topMostControl = NULL; + + const TInt last = iNaviPaneControls->Count() - 1; + if ( last >= 0 ) + { + topMostControl = iNaviPaneControls->At( last ); + if ( IsFepOwnedEditorIndicatorControl( topMostControl ) && + aIgnoreFepEditorIndicator ) + { + if ( last > 0) + { + topMostControl = iNaviPaneControls->At( last - 1 ); + } + } + } + + return topMostControl; + } + + +// --------------------------------------------------------------------------- +// CAknNavigationControlContainer::ReplaceL +// Replaces an existing navi pane control with another one. +// --------------------------------------------------------------------------- +// +EXPORT_C TInt CAknNavigationControlContainer::ReplaceL( + CAknNavigationDecorator& aToBeReplaced, + CAknNavigationDecorator& aReplacement ) + { + const TInt last = iNaviPaneControls->Count() - 1; + for ( TInt ii = last; ii >= 0; ii-- ) + { + if ( iNaviPaneControls->At( ii ) == &aToBeReplaced ) + { + TBool redrawNeeded = EFalse; + aReplacement.SetRect( Rect() ); + + // If the replaced control is volume control, then + // ensure that the parent control is not set and the + // volume control must be informed about the + // navi stack change. + if ( aToBeReplaced.ControlType() == + CAknNavigationDecorator::ENaviVolume ) + { + CAknVolumePopup* volumePopup = + static_cast ( + aToBeReplaced.iDecoratedControl ); + + if ( volumePopup ) + { + volumePopup->CloseVolumePopup(); + } + + static_cast( + aToBeReplaced.DecoratedControl() )->HandleNaviStackChange( EFalse ); + } + + aToBeReplaced.SetNaviStack( NULL ); + iNaviPaneControls->Delete(ii); + iNaviPaneControls->InsertL( ii, &aReplacement); + aReplacement.SetNaviStack( this ); + + // If the replacing control is volume control, then + // ensure that the parent control is not set and the + // volume control must be informed about the + // navi stack change. + if ( aReplacement.ControlType() == + CAknNavigationDecorator::ENaviVolume ) + { + CAknVolumePopup* volumePopup = + static_cast ( + aReplacement.iDecoratedControl ); + + if ( volumePopup ) + { + volumePopup->CloseVolumePopup(); + } + + static_cast( + aReplacement.DecoratedControl() )->HandleNaviStackChange( ETrue ); + } + else + { + // Must not to do this for volume popup. + aReplacement.ActivateL(); + } + + if ( ii == last ) + { + redrawNeeded = ETrue; // Top item replaced, redraw is needed. + } + + // Delete second copy of aReplacement if it existed on the + // stack before ReplaceL call. + for (TInt jj = last; jj >= 0; jj--) + { + if ( jj != ii && iNaviPaneControls->At(jj) == &aReplacement ) + { + iNaviPaneControls->Delete(jj); + if ( jj == last ) + { + redrawNeeded = ETrue; // Top item deleted, redraw is needed. + } + break; // Same reference only once in the stack + } + } + + if ( redrawNeeded ) + { + // Initialize the layout timer if necessary. + aReplacement.SetNaviControlLayoutMode( + aReplacement.NaviControlLayoutMode() ); + + // Redraw if top most item was replaced. + DrawDeferred(); + } + return KErrNone; + } + } + return KErrNotFound; + } + + +// --------------------------------------------------------------------------- +// CAknNavigationControlContainer::ResourceDecorator +// --------------------------------------------------------------------------- +// +EXPORT_C CAknNavigationDecorator* CAknNavigationControlContainer::ResourceDecorator() + { + CAknNavigationDecorator* naviDecorator = iNaviDecoratorFromResource; + + // The ownership of the object is moved to the application. + iNaviDecoratorFromResource = NULL; + return naviDecorator; + } + + +// --------------------------------------------------------------------------- +// CAknNavigationControlContainer::NaviArrowBitmap +// Gets the bitmap for the left or right navigation arrow. +// --------------------------------------------------------------------------- +// +CFbsBitmap& CAknNavigationControlContainer::NaviArrowBitmap( TInt aId ) + { + MAknsSkinInstance* skin = AknsUtils::SkinInstance(); + + TAknsItemID iid = KAknsIIDNone; + if ( aId < 2 ) + { + iid = KAknsIIDQgnIndiNaviArrowLeft; + } + else + { + iid = KAknsIIDQgnIndiNaviArrowRight; + } + + CFbsBitmap* skinBitmap = NULL; + CFbsBitmap* skinMask = NULL; + AknsUtils::GetCachedMaskedBitmap( skin, iid, skinBitmap, skinMask ); + + TBool narrowLayoutInUse( EFalse ); + CAknNavigationDecorator* topControl = Top( ETrue ); + if ( topControl && + topControl->NaviControlLayoutStyle() == + CAknNavigationDecorator::ENaviControlLayoutNarrow ) + { + narrowLayoutInUse = ETrue; + } + + TSize arrowSize( CAknNavigationDecorator::NaviArrowRect( + CAknNavigationDecorator::ELeftButton, narrowLayoutInUse ).Size() ); + + if ( skinBitmap ) + { + AknIconUtils::SetSize( skinBitmap, arrowSize ); + } + if ( skinMask ) + { + AknIconUtils::SetSize( skinMask, arrowSize ); + } + + // Set also the default navi arrow bitmap to correct size here. + AknIconUtils::SetSize( iNaviArrowBitmap[aId], arrowSize ); + + if( ( aId & 1 ) && skinMask ) // If aId is odd and mask exists + { + return *skinMask; + } + else if( skinBitmap ) + { + return *skinBitmap; + } + + return *iNaviArrowBitmap[aId]; + } + + +// --------------------------------------------------------------------------- +// CAknNavigationControlContainer::SizeChanged +// Handles size change events. +// --------------------------------------------------------------------------- +// +EXPORT_C void CAknNavigationControlContainer::SizeChanged() + { + TRect rect( Rect() ); + + // No fading if staconpane is active. + SetContainerWindowNonFading( AknStatuspaneUtils::StaconPaneActive() ); + + TBool narrowLayoutInUse( EFalse ); + CAknNavigationDecorator* topControl = Top( ETrue ); + if ( topControl && + topControl->NaviControlLayoutStyle() == + CAknNavigationDecorator::ENaviControlLayoutNarrow ) + { + narrowLayoutInUse = ETrue; + } + + TSize naviArrowSize( + CAknNavigationDecorator::NaviArrowRect( + CAknNavigationDecorator::ELeftButton, narrowLayoutInUse ).Size() ); + + AknIconUtils::SetSize( iNaviArrowBitmap[ 0 ], naviArrowSize ); + AknIconUtils::SetSize( iNaviArrowBitmap[ 2 ], naviArrowSize ); + + const TInt last = iNaviPaneControls->Count() - 1; + + if ( last >= 0 && iNaviPaneControls->At( last ) ) + { + if ( iNaviPaneControls->At( last )->ControlType() == + CAknNavigationDecorator::ENaviVolume ) + { + // Volume popup's position must be set here. + iNaviPaneControls->At( last )->iDecoratedControl->SetRect( + VolumePopupRect() ); + if( last - 1 >= 0 ) + { + iNaviPaneControls->At( last - 1 )->SetRect( rect ); + } + } + else + { + iNaviPaneControls->At( last )->SetRect( rect ); + } + } + + AknsUtils::RegisterControlPosition( this ); + + // Notify contextpane and signalpane that possibly the naviwipe drawing has + // been changed. + TRAP_IGNORE( NotifyNaviWipeStatusL() ); + } + + +// --------------------------------------------------------------------------- +// CAknNavigationControlContainer::HandleResourceChange +// Handles resource change events. +// --------------------------------------------------------------------------- +// +EXPORT_C void CAknNavigationControlContainer::HandleResourceChange( TInt aType ) + { + // CCoeControl::HandleResourceChange forwards events only to topmost items. + // We try this to forward the event and hope that it does not + // break too much things. + if ( aType == KEikDynamicLayoutVariantSwitch || + aType == KEikColorResourceChange || + aType == KAknsMessageSkinChange ) + { + const TInt last = iNaviPaneControls->Count() - 1; + TInt ii = 0; + CAknNavigationDecorator* control; + for ( ii = last; ii >= 0; ii-- ) + { + control = iNaviPaneControls->At( ii ); + if ( control ) + { + if ( control->ControlType() == + CAknNavigationDecorator::ENaviVolume ) + { + // Volume popup's position must be set here. + control->iDecoratedControl->SetPosition( + VolumePopupRect().iTl ); + } + + control->HandleResourceChange( aType ); + } + } + } + else + { + CCoeControl::HandleResourceChange( aType ) ; + } + + if ( aType == KEikColorResourceChange || + aType == KEikDynamicLayoutVariantSwitch || + aType == KAknsMessageSkinChange ) + { + TInt colorScheme = ColorScheme(); + if ( colorScheme != iExtension->iCurrentColorScheme || + aType == KEikDynamicLayoutVariantSwitch || + aType == KAknsMessageSkinChange ) + { + iExtension->iCurrentColorScheme = colorScheme; + + // updating color bitmap + TRAP_IGNORE( LoadNaviColorBitmapL() ); + } + DrawDeferred(); + } + else if ( aType == KEikMessageFadeAllWindows ) + { + // Close the volume popup if navi pane is faded. + CAknNavigationDecorator* topControl = Top(); + + if ( topControl && + topControl->ControlType() == CAknNavigationDecorator::ENaviVolume ) + { + CAknVolumePopup* volumePopup = + static_cast ( topControl->iDecoratedControl ); + + if ( volumePopup ) + { + volumePopup->CloseVolumePopup(); + } + } + } + } + + +// --------------------------------------------------------------------------- +// CAknNavigationControlContainer::CountComponentControls +// Report number of component controls. +// --------------------------------------------------------------------------- +// +EXPORT_C TInt CAknNavigationControlContainer::CountComponentControls() const + { + const TInt last = iNaviPaneControls->Count() - 1; + if ( last < 0 || !iNaviPaneControls->At( last ) ) + { + return 1; + } + + return 2; + } + + +// --------------------------------------------------------------------------- +// CAknNavigationControlContainer::ComponentControl +// Return a contained control. +// --------------------------------------------------------------------------- +// +EXPORT_C CCoeControl* CAknNavigationControlContainer::ComponentControl( + TInt aIndex ) const + { + CCoeControl* control = NULL; + + if ( aIndex == 0 ) + { + control = iExtension->iForegroundObserver; + } + else if ( aIndex == 1 ) + { + // Return top item from the navi stack. + // If the top is Volume Control, Return the one next to the top + CAknNavigationDecorator *naviDecorator = iNaviPaneControls->At( iNaviPaneControls->Count() - 1 ); + if ( naviDecorator->ControlType() == CAknNavigationDecorator::ENaviVolume ) + { + if ( iNaviPaneControls->Count() - 2 >= 0 )\ + { + control = iNaviPaneControls->At( iNaviPaneControls->Count() - 2 ); + } + } + + if ( control == NULL) + { + control = naviDecorator; + } + } + + return control; + } + + +// --------------------------------------------------------------------------- +// CAknNavigationControlContainer::HandleControlEventL +// --------------------------------------------------------------------------- +// +EXPORT_C void CAknNavigationControlContainer::HandleControlEventL( + CCoeControl* aControl, + TCoeEvent aEventType ) + { + switch ( aEventType ) + { + case EEventStateChanged: + { + const TInt last = iNaviPaneControls->Count() - 1; + // Drawn only if the object that sent the event is + // topmost at the stack + if ( last > KErrNotFound && + aControl == iNaviPaneControls->At( last ) ) + { + DrawDeferred(); + } + } + break; + default: + break; + } + } + + +// --------------------------------------------------------------------------- +// CAknNavigationControlContainer::Draw +// --------------------------------------------------------------------------- +// +EXPORT_C void CAknNavigationControlContainer::Draw( + const TRect& /*aRect*/ ) const + { + if ( iExtension->iIsActiveIdle ) + { + return; + } + + CWindowGc& gc = SystemGc(); + + MAknsSkinInstance* skin = AknsUtils::SkinInstance(); + + if( !skin ) + { + // We are in the middle of AppUi destructor, abort to reduce flicker. + return; + } + + MAknsControlContext* cc = AknsDrawUtils::ControlContext( this ); + + TRect rect( Rect() ); + + // + // Navi pane is located in COMBINED CONTROL/STATUSPANE + // + if ( AknStatuspaneUtils::StaconPaneActive() ) + { + // + // - Navi wipe is never used + // - No offset in right, left or top + // + if( !AknsDrawUtils::Background( skin, cc, this, gc, rect ) ) + { + gc.SetPenStyle( CGraphicsContext::ENullPen ); + gc.SetBrushStyle( CGraphicsContext::ESolidBrush ); + gc.SetBrushColor( + AKN_LAF_COLOR( KStatusPaneBackgroundGraphicsColorUsual ) ); + + gc.DrawRect( rect ); + } + return; + } + // + // Navi pane is located in SMALL STATUSPANE + // + else if ( AknStatuspaneUtils::SmallLayoutActive() ) + { + // This component is drawn differently in small statuspane. + // + // - Navi wipe is never used + // - No offset in right, left or top + // + gc.SetPenStyle( CGraphicsContext::ENullPen ); + gc.SetBrushStyle( CGraphicsContext::ESolidBrush ); + gc.SetBrushColor( + AKN_LAF_COLOR( KStatusPaneBackgroundGraphicsColorUsual ) ); + + if( !AknsDrawUtils::Background( skin, cc, this, gc, rect ) ) + { + gc.DrawRect( rect ); + } + return; + } + // + // Navi pane is located in FLAT STATUSPANE + // + else if ( AknStatuspaneUtils::FlatLayoutActive() ) + { + // + // - Navi wipe is never used + // - No offset in right, left or top + // + if( !AknsDrawUtils::Background( skin, cc, this, gc, rect ) ) + { + gc.SetPenStyle( CGraphicsContext::ENullPen ); + gc.SetBrushStyle( CGraphicsContext::ESolidBrush ); + gc.SetBrushColor( + AKN_LAF_COLOR( KStatusPaneBackgroundGraphicsColorUsual ) ); + gc.DrawRect( rect ); + } + + if ( iStatusPane && !AknLayoutUtils::PenEnabled() ) + { + // Draw title text or image that overlaps to navipane area. + CCoeControl* navicontrol = NULL; + CCoeControl* titlecontrol = NULL; + CCoeControl* titlepaneControl = NULL; + + TRAP_IGNORE( navicontrol = + iStatusPane->ContainerControlL( + TUid::Uid( EEikStatusPaneUidNavi ) ) ); + TRAP_IGNORE( titlecontrol = + iStatusPane->ContainerControlL( + TUid::Uid( EEikStatusPaneUidTitle ) ) ); + TRAP_IGNORE( titlepaneControl = + iStatusPane->ControlL( + TUid::Uid( EEikStatusPaneUidTitle ) ) ); + + if ( navicontrol && titlecontrol && titlepaneControl ) + { + TRect naviRect( + navicontrol->Position().iX, + navicontrol->Position().iY, + navicontrol->Position().iX + navicontrol->Size().iWidth, + navicontrol->Position().iY + navicontrol->Size().iHeight ); + + TRect titleRect( + titlecontrol->Position().iX, + titlecontrol->Position().iY, + titlecontrol->Position().iX + titlecontrol->Size().iWidth, + titlecontrol->Position().iY + titlecontrol->Size().iHeight ); + + TInt offset = titleRect.iTl.iX; + + titleRect.Intersection( naviRect ); + TRect intersection = titleRect; + intersection.iTl.iX -= offset; + intersection.iBr.iX -= offset; + + CAknTitlePane* titlePane = + dynamic_cast ( titlepaneControl ); + + CAknNavigationDecorator* topControl = Top( ETrue ); + + if ( titlePane && topControl && + topControl->NaviControlLayoutStyle() == + CAknNavigationDecorator::ENaviControlLayoutNarrow ) + { + CEikImage* titleImage = titlePane->TitleImage(); + + CAknTitlePaneLabel* titleLabel = + static_cast( + titlePane->TextLabel() ); + + if ( titleImage ) + { + if ( titleImage->Mask() ) + { + gc.BitBltMasked( TPoint( 0, 0 ), + titleImage->Bitmap(), + intersection, + titleImage->Mask(), + ETrue ); + } + else + { + gc.BitBlt( TPoint( 0, 0 ), + titleImage->Bitmap(), + intersection ); + } + } + else if ( titleLabel && + titleLabel->TextAsBitmap() && + titleLabel->TextAsMask() ) + { + gc.BitBltMasked( TPoint( 0, 0 ), + titleLabel->TextAsBitmap(), + intersection, + titleLabel->TextAsMask(), + ETrue ); + } + } + } + } + + return; + } + // + // Navi pane is located in NORMAL STATUSPANE + // + else + { + TBool naviWipeUsed = NaviWipeUsed(); + + TBool skinnedNaviWipeDrawn = EFalse; + TBool skinnedNaviSolidDrawn = EFalse; + TBool defaultNaviWipeDrawn = EFalse; + TBool defaultNaviSolidDrawn = EFalse; + + // If naviwipe is to be used, try first skinned draw... + if ( naviWipeUsed ) + { + skinnedNaviWipeDrawn = DrawSkinnedNaviWipe( gc, rect, skin, cc ); + } + + // If naviwipe is to be used and skinned draw failed, + // draw default wipe draw... + if ( naviWipeUsed && !skinnedNaviWipeDrawn ) + { + defaultNaviWipeDrawn = DrawDefaultNaviWipe( gc, rect ); + } + + // If naviwipe is not to be drawn or the nawiwipe draws has failed for + // some reason then draw solid. Try skinned solid draw first... + if ( !skinnedNaviWipeDrawn && !defaultNaviWipeDrawn ) + { + skinnedNaviSolidDrawn = DrawSkinnedNaviSolid( gc, rect, skin, cc ); + } + + // If not any above is the case, then draw the default solid here. + if ( !skinnedNaviWipeDrawn && + !defaultNaviWipeDrawn && + !skinnedNaviSolidDrawn && + !defaultNaviSolidDrawn ) + { + defaultNaviSolidDrawn = DrawDefaultNaviSolid( gc, rect ); + } + } + } + + +// --------------------------------------------------------------------------- +// CAknNavigationControlContainer::HandlePointerEventL +// --------------------------------------------------------------------------- +// +EXPORT_C void CAknNavigationControlContainer::HandlePointerEventL( + const TPointerEvent& aPointerEvent ) + { + CAknControl::HandlePointerEventL( aPointerEvent ); + } + + +// --------------------------------------------------------------------------- +// CAknNavigationControlContainer::ExtensionInterface +// --------------------------------------------------------------------------- +// +EXPORT_C void* CAknNavigationControlContainer::ExtensionInterface( + TUid /*aInterface*/ ) + { + return NULL; + } + + +// --------------------------------------------------------------------------- +// CAknNavigationControlContainer::ColorScheme +// --------------------------------------------------------------------------- +// +EXPORT_C TInt CAknNavigationControlContainer::ColorScheme() + { + TInt colorScheme = 0; + + CRepository* repository = NULL; + TRAPD( ret, repository = CRepository::NewL( KCRUidPersonalisation ) ); + if ( ret == KErrNone ) + { + ret = repository->Get( KPslnColorPalette, colorScheme ); + } + delete repository; + +#ifdef AVKON_RDEBUG_INFO + _LIT( KDMsg, "Cenrep CAknNavigationControlContainer::ColorScheme %d" ); + RDebug::Print( KDMsg, colorScheme ); +#endif + + if ( colorScheme < 0 || + colorScheme >= TInt( sizeof( KNaviWipeBitmaps ) / sizeof( TInt ) ) ) + { + // If shared data returned illegal color scheme + // value default blue scheme is returned. + colorScheme = 0; + } + + return colorScheme; + } + + +// --------------------------------------------------------------------------- +// CAknNavigationControlContainer::NotifyNaviWipeStatusL +// --------------------------------------------------------------------------- +// +void CAknNavigationControlContainer::NotifyNaviWipeStatusL() + { + if ( iExtension && iExtension->iDestructionOngoing ) + { + return; + } + + // If flat statuspane is active, then we don't have navi wipe on/off, + // but instead we bring title pane to the foreground or let navipane + // partially cover titlepane. But also in this we had to update naviwipe + // statuses, because layout might need to be switched. + if ( AknStatuspaneUtils::FlatLayoutActive() ) + { + RWindow* naviwindow = NULL; + CCoeControl* navicontrol = NULL; + + RWindow* titlewindow = NULL; + CCoeControl* titlecontrol = NULL; + + RWindow* emptywindow = NULL; + CCoeControl *emptycontrol = NULL; + + if ( iStatusPane ) + { + TRAP_IGNORE( navicontrol = + iStatusPane->ContainerControlL( + TUid::Uid( EEikStatusPaneUidNavi ) ) ); + if ( navicontrol ) + { + RDrawableWindow* drawableWindow = navicontrol->DrawableWindow(); + if ( drawableWindow ) + { + // trust that container is always RWindow + naviwindow = static_cast ( drawableWindow ); + } + } + + TRAP_IGNORE( titlecontrol = + iStatusPane->ContainerControlL( + TUid::Uid( EEikStatusPaneUidTitle ) ) ); + if ( titlecontrol ) + { + RDrawableWindow* drawableWindow = titlecontrol->DrawableWindow(); + if ( drawableWindow ) + { + // trust that container is always RWindow + titlewindow = static_cast ( drawableWindow ); + } + } + + TRAP_IGNORE( emptycontrol = + iStatusPane->ContainerControlL( + TUid::Uid( EEikStatusPaneUidEmpty) ) ); + if ( emptycontrol ) + { + RDrawableWindow *drawableWindow = emptycontrol->DrawableWindow(); + if ( drawableWindow ) + { + emptywindow = static_cast ( drawableWindow ); + } + } + } + + const TInt last = iNaviPaneControls->Count() - 1; + if ( ( last < 0 || !( iNaviPaneControls->At( last ) ) ) || + ( last >= 0 && + iNaviPaneControls->At( last ) && + iNaviPaneControls->At( last )->ControlType() == + CAknNavigationDecorator::ENaviVolume ) ) + { + // If not controls in navi stack, send navipane behind of titlepane + // Minus ordinal ordinal position number always means set + // the window to be the last one of the windows with the same + // ordinal priority + if ( iExtension->iIsActiveIdle )//Added for active idle's transparent + { + if ( titlewindow ) + { + titlewindow->SetOrdinalPosition( 4 ); + } + if ( naviwindow ) + { + naviwindow->SetOrdinalPosition( 5 ); + } + if ( emptywindow ) + { + emptywindow->SetOrdinalPosition( 6 ); + } + } + else + { + if ( titlewindow ) + { + titlewindow->SetOrdinalPosition( -1 ); + } + if ( naviwindow ) + { + naviwindow->SetOrdinalPosition( -1 ); + } + if ( emptywindow ) + { + emptywindow->SetOrdinalPosition( -1 ); + } + } + } + else + { + // If controls in navi stack, send titlepane behind the navipane. + // Minus ordinal ordinal position number always means set + // the window to be the last one of the windows with the same + // ordinal priority + if ( iExtension->iIsActiveIdle )//Added for active idle's transparent + { + if ( naviwindow ) + { + naviwindow->SetOrdinalPosition( 4 ); + } + if ( titlewindow ) + { + titlewindow->SetOrdinalPosition( 5 ); + } + if ( emptywindow ) + { + emptywindow->SetOrdinalPosition( 6 ); + } + } + else + { + if ( naviwindow ) + { + naviwindow->SetOrdinalPosition( -1 ); + } + if ( titlewindow ) + { + titlewindow->SetOrdinalPosition( -1 ); + } + if ( emptywindow ) + { + emptywindow->SetOrdinalPosition( -1 ); + } + } + } + + // Finally request titlepane to refresh itself. + if( titlecontrol ) + { + titlecontrol->SetSize( titlecontrol->Size() ); + titlecontrol->DrawDeferred(); + DrawDeferred(); + } + } + } + + +// --------------------------------------------------------------------------- +// CAknNavigationControlContainer::HandleLosingForeground +// --------------------------------------------------------------------------- +// +void CAknNavigationControlContainer::HandleLosingForeground() + { + // If volume popup is shown when the navi pane loses foreground, + // then the popup needs to be closed if shown, and the volume control + // told that it's not the topmost control. + CAknNavigationDecorator* topControl = Top(); + + if ( topControl ) + { + if ( topControl && + topControl->ControlType() == CAknNavigationDecorator::ENaviVolume ) + { + CAknVolumePopup* volumePopup = + static_cast ( + topControl->iDecoratedControl ); + + if ( volumePopup ) + { + volumePopup->CloseVolumePopup(); + static_cast( + topControl->DecoratedControl() )->HandleNaviStackChange( EFalse ); + } + } + } + } + + +// --------------------------------------------------------------------------- +// CAknNavigationControlContainer::HandleGainingForegroundL +// --------------------------------------------------------------------------- +// +void CAknNavigationControlContainer::HandleGainingForegroundL() + { + if ( iExtension && iExtension->iDestructionOngoing ) + { + return; + } + + // Inform the volume popup about the foreground gain if it's the + // topmost control on the navi stack. + CAknNavigationDecorator* topControl = Top(); + if ( topControl ) + { + if ( topControl && + topControl->ControlType() == CAknNavigationDecorator::ENaviVolume ) + { + CAknVolumePopup* volumePopup = + static_cast ( topControl->iDecoratedControl ); + + if ( volumePopup ) + { + static_cast( + topControl->DecoratedControl() )->HandleNaviStackChange( ETrue ); + } + } + } + + NotifyNaviWipeStatusL(); + } + + +// --------------------------------------------------------------------------- +// CAknNavigationControlContainer::NaviWipeUsed +// Naviwipe graphics is no more used (since 3.0). +// --------------------------------------------------------------------------- +// +TBool CAknNavigationControlContainer::NaviWipeUsed() const + { + return EFalse; + } + + +// --------------------------------------------------------------------------- +// CAknNavigationControlContainer::IsFepOwnedEditorIndicatorControl +// Checks whether a navi decorator is an editor indicator control owned +// by a FEP. +// --------------------------------------------------------------------------- +// +TBool CAknNavigationControlContainer::IsFepOwnedEditorIndicatorControl( + CAknNavigationDecorator* aDecorator ) const + { + TBool fepOwnedIndicator = EFalse; + MAknEditingStateIndicator* fepIndicator = + CAknEnv::Static()->EditingStateIndicator(); + if ( aDecorator && + aDecorator->ControlType() == CAknNavigationDecorator::EEditorIndicator && + fepIndicator && + fepIndicator->IndicatorContainer() == aDecorator->DecoratedControl() ) + { + fepOwnedIndicator = ETrue; + } + + return fepOwnedIndicator; + } + + +// ----------------------------------------------------------------------------- +// CAknNavigationControlContainer::HandleVisibilityOfNonFepOwnedIndicatorControl +// ----------------------------------------------------------------------------- +// +void CAknNavigationControlContainer::HandleVisibilityOfNonFepOwnedIndicatorControl( + CAknNavigationDecorator* aDecorator, + TBool aVisible ) + { + if ( aDecorator && + aDecorator->ControlType() == CAknNavigationDecorator::EEditorIndicator && + !IsFepOwnedEditorIndicatorControl( aDecorator ) ) + { + aDecorator->DecoratedControl()->MakeVisible( aVisible ); + } + } + + +// --------------------------------------------------------------------------- +// CAknNavigationControlContainer::DrawDefaultNaviWipe +// Naviwipe graphics is no more used (since 3.0). +// --------------------------------------------------------------------------- +// +TBool CAknNavigationControlContainer::DrawDefaultNaviWipe( + CWindowGc& /*aGc*/, + const TRect& /*aRect*/ ) const + { + return EFalse; + } + + +// --------------------------------------------------------------------------- +// CAknNavigationControlContainer::DrawDefaultNaviSolid +// --------------------------------------------------------------------------- +// +TBool CAknNavigationControlContainer::DrawDefaultNaviSolid( + CWindowGc& aGc, + const TRect& aRect ) const + { + TRect rect( aRect ); + + // screen + TRect screenRect; + AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EScreen, screenRect ); + + // application window + TAknLayoutRect applicationWindowLayoutRect; + applicationWindowLayoutRect.LayoutRect( + screenRect, + AknLayoutScalable_Avkon::application_window( 0 ) ); + TRect applicationWindowRect( applicationWindowLayoutRect.Rect() ); + + // status pane + TAknLayoutRect statusPaneLayoutRect; + statusPaneLayoutRect.LayoutRect( + applicationWindowRect, + AknLayoutScalable_Avkon::status_pane( 0 ) ); + TRect statusPaneRect( statusPaneLayoutRect.Rect() ); + + // navi pane + TAknLayoutRect naviPaneLayoutRect; + if ( !Layout_Meta_Data::IsLandscapeOrientation() ) + { + naviPaneLayoutRect.LayoutRect( + statusPaneRect, + AknLayoutScalable_Avkon::navi_pane( 5 ) ); + } + else + { + if ( AknStatuspaneUtils::StaconPaneActive() ) + { + TInt skVariety = AknStatuspaneUtils::StaconSoftKeysRight() ? 2 : 3; + naviPaneLayoutRect.LayoutRect( + statusPaneRect, + AknLayoutScalable_Avkon::navi_pane_stacon( skVariety ) ); + } + else + { + naviPaneLayoutRect.LayoutRect( + statusPaneRect, + AknLayoutScalable_Avkon::navi_pane( 0 ) ); + } + } + TRect naviPaneRect( naviPaneLayoutRect.Rect() ); + + // navi wipe graphics + TAknLayoutRect naviWipeGraphicsLayoutRect; + naviWipeGraphicsLayoutRect.LayoutRect( + statusPaneRect, + AknLayoutScalable_Avkon::status_pane_g1( 0 ) ); + TRect naviWipeGraphicsRect( naviWipeGraphicsLayoutRect.Rect() ); + + TRect naviWipeNaviPanePart( naviWipeGraphicsRect ); + + if ( naviWipeNaviPanePart.Intersects( naviPaneRect ) ) + { + naviWipeNaviPanePart.Intersection( naviPaneRect ); + // calculate new origo, relative to navipane rect. + naviWipeNaviPanePart.iTl.iX -= naviPaneRect.iTl.iX; + naviWipeNaviPanePart.iTl.iY -= naviPaneRect.iTl.iY; + naviWipeNaviPanePart.iBr.iX -= naviPaneRect.iTl.iX; + naviWipeNaviPanePart.iBr.iY -= naviPaneRect.iTl.iY; + } + + // Finally check where naviwipe intersects this rect + if ( naviWipeNaviPanePart.Intersects( rect ) ) + { + naviWipeNaviPanePart.Intersection( rect ); + } + + // Clear first to enable 1 pixel borders + aGc.SetPenStyle( CGraphicsContext::ENullPen ); + aGc.SetBrushStyle( CGraphicsContext::ESolidBrush ); + aGc.SetBrushColor( AKN_LAF_COLOR( KStatusPaneBackgroundColor ) ); + aGc.DrawRect( rect ); + + // Draw the rect + aGc.SetPenStyle( CGraphicsContext::ENullPen ); + aGc.SetBrushStyle( CGraphicsContext::ESolidBrush ); + aGc.SetBrushColor( + AKN_LAF_COLOR( KStatusPaneBackgroundGraphicsColorUsual ) ); + aGc.DrawRect( naviWipeNaviPanePart ); + + return ETrue; + } + + +// --------------------------------------------------------------------------- +// CAknNavigationControlContainer::DrawSkinnedNaviSolid +// Naviwipe graphics is no more used (since 3.0). +// --------------------------------------------------------------------------- +// +TBool CAknNavigationControlContainer::DrawSkinnedNaviWipe( + CWindowGc& /*aGc*/, + const TRect& /*aRect*/, + MAknsSkinInstance* /*skin*/, + MAknsControlContext* /*aCc*/) const + { + return EFalse; + } + + +// --------------------------------------------------------------------------- +// CAknNavigationControlContainer::DrawSkinnedNaviSolid +// --------------------------------------------------------------------------- +// +TBool CAknNavigationControlContainer::DrawSkinnedNaviSolid( + CWindowGc& aGc, + const TRect& aRect, + MAknsSkinInstance* aSkin, + MAknsControlContext* aCc ) const + { + TRect rect( aRect ); + + aGc.SetPenStyle( CGraphicsContext::ENullPen ); + aGc.SetBrushStyle( CGraphicsContext::ESolidBrush ); + aGc.SetBrushColor( AKN_LAF_COLOR( KStatusPaneBackgroundColor ) ); + + return AknsDrawUtils::Background( aSkin, aCc, this, aGc, rect ); + } + + +// --------------------------------------------------------------------------- +// CAknNavigationControlContainer::MopSupplyObject +// --------------------------------------------------------------------------- +// +TTypeUid::Ptr CAknNavigationControlContainer::MopSupplyObject( TTypeUid aId ) + { + if ( aId.iUid == CAknNavigationControlContainer::ETypeId ) + { + // Return self, this code makes it possible to workaround the fact + // that statuspane controls cannot be safely casted after + // retrieving them using CEikStatusPaneBase::ControlL(). + // + // So now the caller could do something like this rather safely: + // + // CEikStatusPaneBase* statusPane = CEikStatusPaneBase::Current(); + // CAknNavigationControlContainer* naviPane = NULL; + // + //if (statusPane && + // statusPane->PaneCapabilities(TUid::Uid(EEikStatusPaneUidNavi)).IsInCurrentLayout()) + // { + // CCoeControl* control = statusPane->ControlL(TUid::Uid( EEikStatusPaneUidNavi )); + // control->MopGetObject(naviPane); + // } + // + //if (naviPane) + // { + // // The retrieved control was type of CAknNavigationControlContainer + // } + //else + // { + // // The retrieved control was NOT type of CAknNavigationControlContainer. + // // Someone has perhaps swap the control in the statuspane. + // } + return aId.MakePtr( this ); + } + + return CCoeControl::MopSupplyObject( aId ); + } + + +// --------------------------------------------------------------------------- +// CAknNavigationControlContainer::LoadNaviColorBitmapL +// --------------------------------------------------------------------------- +// +void CAknNavigationControlContainer::LoadNaviColorBitmapL() + { + if ( !iExtension ) + { + return; + } + + if ( iExtension->iNaviColorBitmap ) + { + delete iExtension->iNaviColorBitmap; + iExtension->iNaviColorBitmap = NULL; + } + + MAknsSkinInstance* skin = AknsUtils::SkinInstance(); + TRgb color( KRgbGray ); + + if ( AknStatuspaneUtils::StaconPaneActive() ) + { + AknsUtils::GetCachedColor( skin, + color, + KAknsIIDQsnIconColors, + EAknsCIQsnIconColorsCG25 ); + } + else + { + AknsUtils::GetCachedColor( skin, + color, + KAknsIIDQsnIconColors, + EAknsCIQsnIconColorsCG7 ); + } + + // Parent rect is searched from laf data because it can be zero sized when + // this method gets called from constructor. + + // screen + TRect screenRect; + AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EScreen, screenRect ); + + // app window + TAknLayoutRect applicationWindowLayoutRect; + applicationWindowLayoutRect.LayoutRect( + screenRect, + AknLayoutScalable_Avkon::application_window( 0 ) ); + TRect applicationWindowRect( applicationWindowLayoutRect.Rect() ); + + // statuspane + TAknLayoutRect statusPaneLayoutRect; + statusPaneLayoutRect.LayoutRect( applicationWindowRect, + AknLayoutScalable_Avkon::status_pane( 0 ) ); + TRect statusPaneRect( statusPaneLayoutRect.Rect() ); + + // navi pane + TAknLayoutRect naviPaneLayoutRect; + if ( !Layout_Meta_Data::IsLandscapeOrientation() ) + { + naviPaneLayoutRect.LayoutRect( statusPaneRect, + AknLayoutScalable_Avkon::navi_pane( 5 ) ); + } + else + { + if ( AknStatuspaneUtils::StaconPaneActive() ) + { + TInt skVariety = AknStatuspaneUtils::StaconSoftKeysRight() ? 2 : 3; + naviPaneLayoutRect.LayoutRect( statusPaneRect, + AknLayoutScalable_Avkon::navi_pane_stacon( skVariety ) ); + } + else + { + naviPaneLayoutRect.LayoutRect( statusPaneRect, + AknLayoutScalable_Avkon::navi_pane( 0 ) ); + } + } + TRect naviPaneRect( naviPaneLayoutRect.Rect() ); + + TRect parentRect( 0, 0, naviPaneRect.Width(), naviPaneRect.Height() ); + + TAknLayoutRect rect; + rect.LayoutRect( parentRect, + TAknWindowComponentLayout::Compose( + AknLayoutScalable_Avkon::navi_navi_pane(), + AknLayoutScalable_Avkon::navi_navi_pane_g1( 0 ) ) ); + + iExtension->iNaviColorBitmap = new (ELeave) CFbsBitmap(); + + AknIconConfig::TPreferredDisplayMode mode; + AknIconConfig::PreferredDisplayMode( mode, AknIconConfig::EImageTypeOffscreen ); + + //To fix TSW Error:ELLI-7UU67E, we have to adjust color bitmap size so as to be + //different from arrow bitmap mask size, since it is weird that the arrow icon can't + //be shown correctly when they were the same size. + //This may be removed when NGA is stable enough. + TSize arrowSize( rect.Rect().Size().iWidth, rect.Rect().Size().iHeight-1 ); + + TInt err = iExtension->iNaviColorBitmap->Create( arrowSize, + mode.iBitmapMode ); + if ( err != KErrNone ) + { + delete iExtension->iNaviColorBitmap; + iExtension->iNaviColorBitmap = NULL; + return; + } + + CFbsBitmapDevice* destinationDevice = + CFbsBitmapDevice::NewL( iExtension->iNaviColorBitmap ); + CleanupStack::PushL( destinationDevice ); + + CFbsBitGc* destinationGc; + User::LeaveIfError( destinationDevice->CreateContext( destinationGc ) ); + + destinationGc->SetPenColor( color ); + destinationGc->SetPenStyle( CGraphicsContext::ESolidPen ); + destinationGc->SetBrushColor( color ); + destinationGc->SetBrushStyle( CGraphicsContext::ESolidBrush ); + destinationGc->DrawRect( TRect( rect.Rect().Size() ) ); + + delete destinationGc; + CleanupStack::PopAndDestroy( destinationDevice ); + } + + +// --------------------------------------------------------------------------- +// CAknNavigationControlContainer::NaviColorBitmap +// --------------------------------------------------------------------------- +// +CFbsBitmap* CAknNavigationControlContainer::NaviColorBitmap() const + { + CFbsBitmap* bitmap = NULL; + + if ( iExtension ) + { + bitmap = iExtension->iNaviColorBitmap; + } + + return bitmap; + } + + +// --------------------------------------------------------------------------- +// CAknNavigationControlContainer::CurrentNaviWipeBitmap +// Returns the index of the navi wipe graphics to be used. +// --------------------------------------------------------------------------- +// +TInt CAknNavigationControlContainer::CurrentNaviWipeBitmap() + { + TInt bitmapId = + KNaviWipeBitmaps[CAknNavigationControlContainer::ColorScheme()]; + + // Do some safety checkings for the bitmap & mask values as AknIconUtils + // cannot cope with situation where one of them is in the mbm range and + // other in mif range. Default to blue if necessary. + if ( EMbmAvkonQgn_graf_navi_wipe_blue_mask > KMifIdFirst ) + { + if ( bitmapId < KMifIdFirst && bitmapId != KNaviDrawWithSolidColor ) + { + bitmapId = EMbmAvkonQgn_graf_navi_wipe_blue; + } + } + else + { + if ( bitmapId > KMifIdFirst && bitmapId != KNaviDrawWithSolidColor ) + { + bitmapId = EMbmAvkonQgn_graf_navi_wipe_blue; + } + } + + return bitmapId; + } + + +// --------------------------------------------------------------------------- +// CAknNavigationControlContainer::SetBackgroundContextAttributes +// Naviwipe graphics is no more used (since 3.0) +// --------------------------------------------------------------------------- +// +void CAknNavigationControlContainer::SetBackgroundContextAttributes( + CCoeControl* /*aControl*/, TBool /*aNaviWipeUsed*/ ) + { + return; + } + + +// --------------------------------------------------------------------------- +// CAknNavigationControlContainer::SetContainerWindowNonFading +// Allows/disallows fading of the navi pane. +// --------------------------------------------------------------------------- +// +void CAknNavigationControlContainer::SetContainerWindowNonFading( + TBool aNonFading ) + { + if ( iStatusPane ) + { + CCoeControl* control = NULL; + TRAPD( err, + control = iStatusPane->ContainerControlL( + TUid::Uid( EEikStatusPaneUidNavi ) ) ); + + if ( !err && control ) + { + control->DrawableWindow()->SetNonFading( aNonFading ); + } + } + } + + +// --------------------------------------------------------------------------- +// CAknNavigationControlContainer::VolumePopupRect +// Gets the area for volume popup control from the layout data. +// --------------------------------------------------------------------------- +// +TRect CAknNavigationControlContainer::VolumePopupRect() + { + TAknLayoutRect layoutRect; + + TRect appRect; + AknLayoutUtils::LayoutMetricsRect( + AknLayoutUtils::EApplicationWindow, + appRect ); + + if ( AknStatuspaneUtils::HDLayoutActive() || + Layout_Meta_Data::IsLandscapeOrientation() ) + { + layoutRect.LayoutRect( + appRect, + AknLayoutScalable_Avkon::main_pane( 13 ) ); + } + else + { + layoutRect.LayoutRect( + appRect, + AknLayoutScalable_Avkon::main_pane( 3 ) ); + } + + layoutRect.LayoutRect( + layoutRect.Rect(), + AknLayoutScalable_Avkon::popup_slider_window( + Layout_Meta_Data::IsLandscapeOrientation() ) ); + + return layoutRect.Rect(); + } + + +// --------------------------------------------------------------------------- +// CAknNavigationControlContainer::SetPreferredNaviDecoratorLayoutStyle +// Sets the preferred navi decorator layout. +// --------------------------------------------------------------------------- +// +EXPORT_C void CAknNavigationControlContainer::SetPreferredNaviDecoratorLayoutStyle( + TInt aLayoutStyle ) + { + iExtension->iPreferredNaviDecoratorLayoutStyle = aLayoutStyle; + } + +// End of File