diff -r 000000000000 -r 2f259fa3e83a uifw/EikStd/coctlsrc/AknToolbar.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uifw/EikStd/coctlsrc/AknToolbar.cpp Tue Feb 02 01:00:49 2010 +0200 @@ -0,0 +1,4360 @@ +/* +* Copyright (c) 2005-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: Popup toolbar component +* +*/ + + +// INCLUDE FILES +#include +#include +#include // CAknButton +#include // CAknTouchPane +#include "akntoolbaritem.h" +#include + +#include // TResourceReader +#include // SEikControlInfo +#include // CEikAppUi +#include +#include +#include // toolbar flags +#include +#include // KRAMGOODTHRESHOLD +#include // CEikButtonGroupContainer +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include // for testability hooks +#include +#include + +#include +#include +#include +#include "touchtoolbardata.h" + +// CONSTANTS +const TInt KLineArrayGranularity = 5; + +const TInt KFocusedNone = -1; +const TInt KSelectedNone = -2; + +const TInt KToolbarButtonBeforeTimeout = 300; +const TInt KToolbarButtonInViewTimeout = 5000; + +const TInt KFixedtoolbarButtons = 3; // Number of buttons fixed toolbar has to have +//const TUint32 KToolbarColorKey = 0x00000000; // ARGB + +const TUint32 KToolbarBgColor = 0x00000000; +const TInt KToolBarBgAlpha = 0x7F; + +#ifdef RD_SCALABLE_UI_V2 +const TInt KDisableToolbar = 0xfff1; +const TInt KEnableToolbar = 0xfff2; +#endif + +// toolbar's internal flags +enum TInternalFlags + { + EInIdle, // toolbar is shown in idle view + ESlidingSupported, // whether toolbar can be show up with sliding effect if it is needed + EWithSliding, // defines whether toolbar should be shown with sliding effect + ENoItemsVisible, // used to check if no items are visible, this is needed to know if CBA needs to be created again + EShown, // whether toolbar is shown right now( IsVisible() is not safe enough because can be changed from outside with MakeVisible() + EShowingAgain, // used to check if toolbar is shown again when allready shown, this is needed for not sliding when toolbar is allready shown + ESliding, // set if toolbar is currently sliding + EFixedShown, // tells to fixed toolbar if it needs to be shown when the layout is good + ECalledFromFW, // indicates to SetToolbarVisibility that it was called by the framework + EAppOverrideVisibility, // indicates whether fixed toolbar visibility has been overriden by the application + EDisabled, // whether toolbar is disabled or not + EDrawBackground, // whether only toolbar background should be drawn + EItemsHidden, // whether application has called HideItemsAndDrawOnlyBackground + EItemsHiddenWithPriority, // whether application has called HideItemsAndDrawOnlyBackground with priority + ESwitchForItemsHidden, // switch for clearing EItemsHidden when the toolbar is to be shown + EDefaultToolbar //used for hideitemsanddrawonlybackground + }; + +// Control stack priority for toolbar to enable view deactivation +const TInt KCoeStackToolbarPriority = ECoeStackPriorityCba; + + +// ============================ MEMBER FUNCTIONS =============================== + +// ----------------------------------------------------------------------------- +// CAknToolbar::NewL +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +EXPORT_C CAknToolbar* CAknToolbar::NewL( const TInt aResourceId ) + { + CAknToolbar* self = NewLC( aResourceId ); + CleanupStack::Pop( self ); + return self; + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::NewLC +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +EXPORT_C CAknToolbar* CAknToolbar::NewLC( const TInt aResourceId ) + { + CAknToolbar* self = new ( ELeave ) CAknToolbar(); + CleanupStack::PushL( self ); + self->ConstructL(); + self->ConstructFromResourceL( aResourceId ); + AKNTASHOOK_ADDL( self, "CAknToolbar" ); + return self; + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::CAknToolbar +// C++ default constructor. +// ----------------------------------------------------------------------------- +// +CAknToolbar::CAknToolbar() + : iItems( KLineArrayGranularity ), + iVisibleItems( KLineArrayGranularity ), + iFocusedItem( KFocusedNone ), + iSelectedItem( KSelectedNone ), + iInitialFocusedItem ( KFocusedNone ), + iLastFocusedItem( KFocusedNone ), + iOrientation( EAknOrientationHorizontal ), + iSoftkeyResource( R_AVKON_SOFTKEYS_SELECT_CLOSE__SELECT ), + iPreviousItem( KSelectedNone ), + iDrawingPriority( ECoeWinPriorityLow ) + { + CEikApplication* application = iAvkonAppUi->Application(); + + if ( application ) + { + TVwsViewId idleView; + TInt err = AknDef::GetPhoneIdleViewId( idleView ); + + if ( application->AppDllUid() == idleView.iAppUid ) + { + iInternalFlags.Set( EInIdle ); + } + } + } + +// ----------------------------------------------------------------------------- +// Destructor +// ----------------------------------------------------------------------------- +// +EXPORT_C CAknToolbar::~CAknToolbar() + { + AKNTASHOOK_REMOVE(); + SetFocus( EFalse ); + CEikonEnv::Static()->EikAppUi()->RemoveFromStack( this ); + + iVisibleItems.Reset(); + iItems.ResetAndDestroy(); + + delete iToolbarCba; + delete iFrameContext; + delete iBgContext; + if ( iIdle && iIdle->IsActive() ) + { + iIdle->Cancel(); + } + delete iIdle; + + iToolbarObserver = NULL; // not owned + + GfxTransEffect::Deregister( this ); + + CTouchToolbarData* d = CTouchToolbarData::GetData( this ); + if ( d ) + { + CAknTransitionUtils::RemoveObserver( d, + CAknTransitionUtils::EEventControlTransitionFinished ); + CAknTransitionUtils::RemoveData( reinterpret_cast( this ) ); + delete d; + } + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::ConstructL +// Symbian 2nd phase constructor. +// ----------------------------------------------------------------------------- +// +void CAknToolbar::ConstructL() + { + // create control's window + CreateWindowL(); + SetFocusing( EFalse ); + + DrawableWindow()->SetPointerGrab( ETrue ); + DrawableWindow()->SetShadowDisabled( ETrue ); + DrawableWindow()->SetOrdinalPosition( 0, ECoeWinPriorityNeverAtFront ); + + CEikonEnv::Static()->EikAppUi()->AddToStackL( this, KCoeStackToolbarPriority, + ECoeStackFlagRefusesFocus | ECoeStackFlagRefusesAllKeys ); + + SetComponentsToInheritVisibility( ETrue ); + SetShown( EFalse ); + iBgIID = KAknsIIDNone; + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::CountComponentControls +// Gets the number of controls contained in a compound control. +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt CAknToolbar::CountComponentControls() const + { + return iVisibleItems.Count(); + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::ConstructFromResourceL +// Constructs controls from a resource file. +// ----------------------------------------------------------------------------- +// +void CAknToolbar::ConstructFromResourceL( TResourceReader& aReader ) + { + aReader.ReadInt8(); //version, not used currently + aReader.ReadInt8(); //lines, not used currently + iFlags = aReader.ReadInt32(); + + TBool enableTransparency = CAknEnv::Static()->TransparencyEnabled() && + ( ( !( iFlags & KAknToolbarFixed ) && + !( iFlags & KAknToolbarFloatingUnTransparent ) ) || + ( iFlags & KAknToolbarTransparent && iFlags & KAknToolbarFixed ) ); + + + if( enableTransparency ) + { + Window().SetRequiredDisplayMode( EColor16MA ); // Without this, ACT does not work in all cases in HW + TInt err = Window().SetTransparencyAlphaChannel(); + + if ( err == KErrNone ) // it should all ways be true in NGA + { + // Set the window initially completely transparent. This needs to be called only once. + Window().SetBackgroundColor(~0); + } + } + + + + iFrameContext = CAknsFrameBackgroundControlContext::NewL( KAknsIIDQsnFrPopupSub, + TRect(), TRect(), ( iFlags & KAknToolbarFixed )? ETrue : EFalse ); + + iBgContext = CAknsBasicBackgroundControlContext::NewL( + KAknsIIDQsnBgScreen, TRect(), ETrue ); + + SetWithSliding( ETrue ); + + TInt softkeyResource = aReader.ReadUint32(); //softkeys + + if ( softkeyResource > 0 ) + { + iSoftkeyResource = softkeyResource; + } + + const TInt controlCount = aReader.ReadInt16(); + + for ( TInt ii = 0; ii < controlCount; ii++ ) + { + CAknToolbarItem* item = ConstructControlLC( aReader ); + if ( item ) + { + if ( IsSupportedItemType( item->ControlType() ) ) + { + iItems.AppendL( item ); + CleanupStack::Pop( item ); + } + else + { + // we don't support this type + CleanupStack::PopAndDestroy( item ); + } + } + } + aReader.ReadInt32(); // extension link, not used currently + + + SetOrientation( iOrientation ); + + // If toolbar is fixed need to set size for toolbar so that it can reduce + // the rects correctly. + if ( iFlags & KAknToolbarFixed ) + { + if ( iFlags & KAknToolbarDefault ) + { + SetDimmed( ETrue ); + } + SetFocusing( EFalse ); + SetRect( CalculateSizeAndPosition() ); + } + + AdjustAllButtons(); + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::ConstructFromResourceL +// Constructs controls from a resource file. +// ----------------------------------------------------------------------------- +// +void CAknToolbar::ConstructFromResourceL( const TInt aResourceId ) + { + TResourceReader reader; + iCoeEnv->CreateResourceReaderLC( reader, aResourceId ); + ConstructFromResourceL( reader ); + CleanupStack::PopAndDestroy(); + iToolbarResourceId = aResourceId; + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::ControlOrNull +// Gets a pointer to the specified control. +// ----------------------------------------------------------------------------- +// +EXPORT_C CCoeControl* CAknToolbar::ControlOrNull( const TInt aControlId ) const + { + for ( TInt ii = 0; ii < iItems.Count(); ii++ ) + { + CAknToolbarItem* item = iItems[ii]; + if ( item->CommandId() == aControlId ) + { + return item->Control(); + } + } + return NULL; + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::SetToolbarVisibility +// Shows or hides toolbar. +// The position of the top left corner should be set in advance. +// ----------------------------------------------------------------------------- +// +EXPORT_C void CAknToolbar::SetToolbarVisibility( const TBool aVisible ) + { + SetToolbarVisibility( aVisible, ETrue ); + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::SetToolbarVisibility +// If flag RD_SCALABLE_UI_V2 is not defined, toolbar is always focusing. +// ----------------------------------------------------------------------------- +// +EXPORT_C void CAknToolbar::SetToolbarVisibility( const TBool aVisible, + const TBool aFocusing ) + { + if ( iInternalFlags.IsSet( EDisabled ) ) + { + return; + } + + TBool visible = aVisible; + + if ( iInternalFlags.IsSet( ECalledFromFW ) ) + { + if ( iInternalFlags.IsSet( EAppOverrideVisibility ) ) + { + visible = EFalse; + } + } + else + { + if ( aVisible ) + { + iInternalFlags.Clear( EAppOverrideVisibility ); + } + else + { + iInternalFlags.Set( EAppOverrideVisibility ); + } + } + + if ( iFlags & KAknToolbarFixed ) + { + if ( visible ) + { + iInternalFlags.Set( EFixedShown ); + } + else + { + iInternalFlags.Clear( EFixedShown ); + } + + if ( visible && ( !AknLayoutUtils::PenEnabled() || + ( !Layout_Meta_Data::IsLandscapeOrientation() && iFlags & KAknToolbarDefault ) ) ) + { + return; + } + + } + if ( iFlags & KAknToolbarAlwaysFocusing ) + { + SetFocusing( ETrue ); + } + else + { +#ifdef RD_SCALABLE_UI_V2 + if ( iFlags & KAknToolbarFixed ) + { + SetFocusing( EFalse ); + } + else + { + SetFocusing( aFocusing ); + } +#else + SetFocusing( ETrue ); +#endif + } + + if ( iInternalFlags.IsSet( EShown ) && visible ) + { + if ( iFlags & KAknToolbarFixed ) + { + return; + } + if ( iInternalFlags.IsSet( EShown ) ) + { + //using IsVisible() to avoide setting flag when toolbar is invisible. + if ( IsVisible() ) + { + iInternalFlags.Set( EShowingAgain ); + } + ShowViaIdle(); + } + + return; + } + + if ( visible ) + { + if ( !(iFlags & KAknToolbarFixed ) ) + { + ShowViaIdle(); + } + else + { + TRAPD( err, ShowToolbarL() ); + if ( err != KErrNone ) + { + // if we failed then softkeys should be deleted just in case if they + // were created before leave + delete iToolbarCba; + iToolbarCba = NULL; + + SetFocus( EFalse ); + CEikonEnv::Static()->EikAppUi()->UpdateStackedControlFlags( this, + ~0, ECoeStackFlagRefusesFocus | ECoeStackFlagRefusesAllKeys ); + + } + + } + + } + else + { + TRAP_IGNORE( HideToolbarL() ); + } + } + +// ----------------------------------------------------------------------------- +// ----------------------------------------------------------------------------- +// +static CTouchToolbarData* CheckRegistration( CCoeControl* aControl ) + { + TInt key = reinterpret_cast( aControl ); + TBool selectPressed = EFalse; + + CTouchToolbarData* data = reinterpret_cast( + CAknTransitionUtils::GetData( key ) ); + + if ( data && data->SelectPressed() ) + { + selectPressed = ETrue; + } + + // If we're not already registered from the touchpane, register here for + // a toolbar transition without the touchpane. + if ( !data || !data->BetweenRegisterAndBegin() ) + { + // We need to reset the data here, to make sure that + // DemarcationRectSet() is false below. + TRect rect; + if ( CTouchToolbarData::SetData( aControl, rect, EFalse ) != + KErrNone ) + { + return NULL; + } + + // if already registered, then the toolbar client may have chosen a different + // effect for the toolbar + if( !GfxTransEffect::IsRegistered( aControl ) ) + { + GfxTransEffect::Register( aControl, KGfxToolbarControlUid, EFalse ); + } + GfxTransEffect::Enable(); + + data = reinterpret_cast( + CAknTransitionUtils::GetData( key ) ); + + if ( selectPressed ) + { + data->SetSelectPressed( selectPressed ); + } + } + + return data; + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::ShowToolbarL +// Makes toolbar visible and activates it +// The position of the top left corner should be set in advance. +// ----------------------------------------------------------------------------- +// +void CAknToolbar::ShowToolbarL() + { + if ( iFlags & KAknToolbarFixed && + ( !AknLayoutUtils::PenEnabled() || + iFlags & KAknToolbarDefault ) ) + { + if ( IsVisible() ) + { + MakeVisible( EFalse ); + } + return; + } + iInternalFlags.Clear( EDrawBackground ); + // get specific settings from observer + if ( iToolbarObserver ) + { + iToolbarObserver->DynInitToolbarL( iToolbarResourceId, this ); + } + + // Check buttons if fixed toolbar + if ( iFlags & KAknToolbarFixed && ! ( iFlags & KAknToolbarDefault ) ) + { + CheckFixedToolbarButtonsL(); + } + + TRect rect( CalculateSizeAndPosition() ); + + if ( iVisibleItems.Count() > 0 || ( iFlags & KAknToolbarFixed ) ) + { + TBool tmpDisplayed = CEikonEnv::Static()->EikAppUi()->IsDisplayingMenuOrDialog(); + TBool tmpCondition = IsNonFocusing() ||( !IsNonFocusing() && tmpDisplayed ) ; + CEikonEnv::Static()->EikAppUi()->UpdateStackedControlFlags( this, + tmpCondition ? ECoeStackFlagRefusesFocus : ECoeStackFlagStandard, + ECoeStackFlagRefusesFocus | ECoeStackFlagRefusesAllKeys ); + + // This is called so toolbar can get focus if needed + CEikonEnv::Static()->EikAppUi()->HandleStackChanged(); + + TPoint startPos = rect.iTl; + if ( iInternalFlags.IsSet( ESlidingSupported ) && iInternalFlags.IsSet( EWithSliding ) && + iOrientation == EAknOrientationHorizontal ) + { + startPos.iX = -rect.Size().iWidth; + } + SetExtent( startPos, rect.Size() ); + UpdateControlPositions(); + + TBool redrawStoreEnabled(EFalse); + if( !CAknEnv::Static()->TransparencyEnabled() ) + { + redrawStoreEnabled = Window().IsRedrawStoreEnabled(); + } + + CTouchToolbarData* data = CheckRegistration( this ); + if ( data && !(iFlags & KAknToolbarFixed) && iAvkonAppUi->IsForeground() ) + { + data->SetBetweenRegisterAndBegin( EFalse ); + + CAknTransitionUtils::SetAllParents( this ); + + Window().ClearRedrawStore( ); + + GfxTransEffect::NotifyExternalState( ENotifyGlobalAbort ); + GfxTransEffect::Begin( this, KGfxControlAppearAction ); + } + + SetShown( ETrue ); + + if ( data ) + { + if ( data->DemarcationRectSet() ) + { + GfxTransEffect::SetBeginDemarcation( this, data->DemarcationRect() ); + } + else + { + GfxTransEffect::SetBeginDemarcation( this, rect ); + } + + if ( CAknTransitionUtils::AddObserver( data, + CAknTransitionUtils::EEventControlTransitionFinished, + reinterpret_cast( this ) ) == KErrNone ) + { + GfxTransEffect::End( this ); + } + else + { + CAknTransitionUtils::RemoveData( reinterpret_cast( this ) ); + delete data; + GfxTransEffect::Deregister( this ); + } + + if ( !CAknEnv::Static()->TransparencyEnabled() && redrawStoreEnabled ) + { + Window().EnableRedrawStore( ETrue ); + } + } + + // notify observer, for example touch pane, that toolbar was shown + if ( Observer() ) + { + Observer()->HandleControlEventL( this, + MCoeControlObserver::EEventStateChanged ); + } + + + // Default toolbar window priority to low to prevent toolbar + // to be drawn on top of a full-screen application + if ( iFlags & KAknToolbarDefault && !iInternalFlags.IsSet( EItemsHidden ) ) + { + DrawableWindow()->SetOrdinalPosition( 0, ECoeWinPriorityLow ); + } + else + { + DrawableWindow()->SetOrdinalPosition( 0, ECoeWinPriorityNormal ); + } + + if ( iFlags & KAknToolbarFixed ) + { + SetOrdinalPositions(); + } + + ActivateL(); + + //Also activating the items that are currently not in iVisibleItems + for ( TInt ii = 0; ii < iItems.Count(); ++ii ) + { + iItems[ii]->Control()->ActivateL(); + } + + + // softkeys for focused toolbar only + if ( !IsNonFocusing() && IsFocused() ) + { + TBool withoutCba( iFlags & KAknToolbarWithoutCba ); + + if ( !withoutCba ) + { + if ( !iToolbarCba ) + { + iToolbarCba = + CEikButtonGroupContainer::NewL( CEikButtonGroupContainer::ECba, + CEikButtonGroupContainer::EHorizontal, + this, iSoftkeyResource ); + } + + if ( iToolbarCba->ButtonGroup() ) + { + static_cast( iToolbarCba->ButtonGroup() )-> + SetSkinBackgroundId( KAknsIIDQsnBgAreaControlPopup ); + } + } + } + else if ( iToolbarCba ) + { + delete iToolbarCba; + iToolbarCba = NULL; + } + + + if ( iInternalFlags.IsSet( ESlidingSupported ) && iInternalFlags.IsSet( EWithSliding ) ) + { + SlideToolbar( rect.iTl ); + } + else + { + if ( !( iFlags & KAknToolbarFixed ) ) + { + InitFocusedItemL( ETrue ); + } + DrawNow(); + } + } + else + { + SetShown( EFalse ); + + // notify observer, for example touch pane, that toolbar was closed + if ( Observer() ) + { + Observer()->HandleControlEventL( this, + MCoeControlObserver::EEventStateChanged ); + } + } + + if ( !IsNonFocusing() ) + { + SetFocus( ETrue ); + } + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::HideToolbar +// Disactivate toolbar and hides it. +// ----------------------------------------------------------------------------- +// +void CAknToolbar::HideToolbarL() + { + if ( !iInternalFlags.IsSet( EShown ) ) // nothing to hide + { + if ( iFlags & KAknToolbarDefault && !AknLayoutUtils::PenEnabled() + && IsVisible() ) + { + MakeVisible( EFalse ); + } + return; + } + + if ( iIdle && iIdle->IsActive() ) + { + iIdle->Cancel(); + } + + if ( !IsNonFocusing() & IsFocused() ) + { + SetFocus( EFalse ); + } + + iLastFocusedItem = iFocusedItem; + + SelectItemL( iSelectedItem, EFalse ); + if ( !IsNonFocusing() && iFocusedItem < iVisibleItems.Count() && + iFocusedItem >= 0 ) + { + // Take focus away from control so that it shows tooltip next time + iVisibleItems[iFocusedItem]->SetFocusL( EFalse, ETrue, ENoDrawNow, this ); + } + + if ( iToolbarCba ) + { + // we don't want toolbar to be focused again after softkeys are deleted + // so it shouldn't get focus as the top item + CEikonEnv::Static()->EikAppUi()->UpdateStackedControlFlags( this, + ~0, ECoeStackFlagRefusesFocus | ECoeStackFlagRefusesAllKeys ); + + delete iToolbarCba; + iToolbarCba = NULL; + + CEikonEnv::Static()->EikAppUi()->UpdateStackedControlFlags( this, + 0, ECoeStackFlagRefusesFocus | ECoeStackFlagRefusesAllKeys); + + } + + + // Drawing toolbar background, when application hides toolbar + if ( ( !iInternalFlags.IsSet( ECalledFromFW ) && !iInternalFlags.IsSet( EItemsHidden ) || + iInternalFlags.IsSet( EDrawBackground ) ) && iFlags & KAknToolbarFixed && + !( iFlags & KAknToolbarDsaMode ) && !( iFlags & KAknToolbarNoBackground ) || + iInternalFlags.IsSet( EItemsHidden ) && iFlags & KAknToolbarFixed && + !( iFlags & KAknToolbarDsaMode) && !( iFlags & KAknToolbarNoBackground ) ) + { + + if ( iInternalFlags.IsSet( EItemsHiddenWithPriority ) ) + { + DrawableWindow()->SetOrdinalPosition( 0, iDrawingPriority ); + iInternalFlags.Clear( EItemsHiddenWithPriority ); + } + else + { + DrawableWindow()->SetOrdinalPosition( 0, ECoeWinPriorityLow ); + } + + iInternalFlags.Set( EDrawBackground ); + + for ( TInt i = 0; i < iVisibleItems.Count(); i++ ) + { + iVisibleItems[i]->Control()->MakeVisible( EFalse ); + } + + TRect rect = Rect(); + Window().Invalidate( rect ); + ActivateGc(); + Window().BeginRedraw( rect ); + + CWindowGc& gc = SystemGc(); + MAknsSkinInstance* skin = AknsUtils::SkinInstance(); + + AknsDrawUtils::Background( skin, iBgContext, this, gc, rect, + KAknsDrawParamNoClearUnderImage ); + + + Window().EndRedraw(); + DeactivateGc(); + iInternalFlags.Clear( EShown ); + } + CTouchToolbarData* data = CheckRegistration( this ); + + TBool foreground = iAvkonAppUi->IsForeground(); + // The window is created asynchronously (in CreateDelayedWindow(), so if + // you click the toolbar button quickly enough, you can get here before + // the window has actually been created, and in that case the app would + // crash, hence the check. + if ( &Window() && data && !data->SelectPressed() && !(iFlags & KAknToolbarFixed) + && foreground ) + { + data->SetBetweenRegisterAndBegin( EFalse ); + + GfxTransEffect::NotifyExternalState( ENotifyGlobalAbort ); + GfxTransEffect::Begin( this, KGfxControlDisappearAction ); + } + + if ( !iInternalFlags.IsSet( EDrawBackground ) ) + { + SetShown( EFalse ); + } + + if ( &Window() && data && !data->SelectPressed() && !(iFlags & KAknToolbarFixed) + && foreground ) + { + if ( data->DemarcationRectSet() ) + { + GfxTransEffect::SetEndDemarcation( this, data->DemarcationRect() ); + } + else + { + GfxTransEffect::SetEndDemarcation( this, Rect() ); + } + + if ( CAknTransitionUtils::AddObserver( data, + CAknTransitionUtils::EEventControlTransitionFinished, + reinterpret_cast( this ) ) == KErrNone ) + { + GfxTransEffect::End( this ); + } + else + { + CAknTransitionUtils::RemoveData( reinterpret_cast( this ) ); + delete data; + GfxTransEffect::Deregister( this ); + } + } + else if ( data ) + { + CAknTransitionUtils::RemoveData( reinterpret_cast( this ) ); + delete data; + } + if ( !iInternalFlags.IsSet( EDrawBackground ) ) + { + DrawableWindow()->SetOrdinalPosition( 0, ECoeWinPriorityNeverAtFront ); + } + + CEikonEnv::Static()->EikAppUi()->UpdateStackedControlFlags( this, + ~0, ECoeStackFlagRefusesFocus | ECoeStackFlagRefusesAllKeys ); + + // notify observer, for example touch pane, that toolbar was closed + if ( Observer() ) + { + Observer()->HandleControlEventL( this, + MCoeControlObserver::EEventStateChanged ); + } + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::SetItemDimmed +// Dims (greys out) or undims a toolbar item. +// ----------------------------------------------------------------------------- +// +EXPORT_C void CAknToolbar::SetItemDimmed( const TInt aCommandId, + const TBool aDimmed, + const TBool aDrawNow ) + { + if( IsDimmed() ) + return; + CAknToolbarItem* item = ToolbarItemById( aCommandId ); + if ( item && item->Control() ) + { + item->Control()->SetDimmed( aDimmed ); + if ( aDimmed && IsFocused() && item->Control()->IsFocused() ) + { + // move selection to the next non-dimmed item + if ( iFocusedItem == iVisibleItems.Count() - 1 ) + { + TRAP_IGNORE( MoveHighlightL( 0, aDrawNow ) ); + } + else + { + TRAP_IGNORE( MoveHighlightL( ToolbarVisibleIndexById( aCommandId ) + 1, + aDrawNow ) ); + } + if ( iFocusedItem == KFocusedNone && item->Control()->IsFocused() ) + { + item->Control()->SetFocus( EFalse ); + } + } + if ( aDrawNow ) + { + item->Control()->DrawDeferred(); + } + } + } + + + +// ----------------------------------------------------------------------------- +// CAknToolbar::HideItem +// Hides or unhides a toolbar item. +// ----------------------------------------------------------------------------- +// +EXPORT_C void CAknToolbar::HideItem( const TInt aCommandId, + const TBool aHide, + const TBool aDrawNow ) + { + CAknToolbarItem* item = ToolbarItemById( aCommandId ); + + if ( !aHide && item && item->ControlType() == EAknCtButton && item->Control() ) + { + CAknButton* button = static_cast( item->Control() ); + button->ResetState(); + } + + if ( item && item->Control() && item->IsHidden() != aHide ) + { + item->SetHidden( aHide ); + + TInt itemIndex; + TRect rect; + if ( aHide ) + { + itemIndex = ToolbarVisibleIndexByControl( item->Control() ); + TRAP_IGNORE( SelectItemL ( itemIndex, EFalse ) ); + rect = CalculateSizeAndPosition(); + } + else + { + rect = CalculateSizeAndPosition(); + itemIndex = ToolbarVisibleIndexByControl( item->Control() ); + } + UpdateControlVisibility(); + UpdateControlPositions(); + + if ( itemIndex >=0 && itemIndex <= iFocusedItem && !IsNonFocusing() ) + { + if ( aHide ) + { + // Check if the hidden item was the last + if ( iFocusedItem >= iVisibleItems.Count() ) + { + iFocusedItem = iVisibleItems.Count() - 1; + } + else if ( iVisibleItems.Count() > 0 && + !( itemIndex == 0 && iFocusedItem == 0 ) && + ( itemIndex != iFocusedItem ) ) + { + TRAP_IGNORE( MoveHighlightL( iFocusedItem - 1, EFalse ) ); + } + } + else + { + TRAP_IGNORE( MoveHighlightL( iFocusedItem + 1, EFalse ) ); + } + } + if ( iInternalFlags.IsSet( EShown ) && aDrawNow ) + { + if ( !( iFlags & KAknToolbarFlexiblePosition ) ) + { + SetPosition( rect.iTl ); + } + SetSize( rect.Size() ); + DrawDeferred(); + } + } + else + { + if ( aDrawNow ) + { + DrawDeferred(); + } + } + } + + +// ----------------------------------------------------------------------------- +// CAknToolbar::SetToolbarObserver +// Sets the observer for the toolbar +// ----------------------------------------------------------------------------- +// +EXPORT_C void CAknToolbar::SetToolbarObserver( MAknToolbarObserver* aObserver ) + { + iToolbarObserver = aObserver; + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::ToolbarObserver +// Returns a pointer to the toolbar observer. +// ----------------------------------------------------------------------------- +// +EXPORT_C MAknToolbarObserver* CAknToolbar::ToolbarObserver() + { + return iToolbarObserver; + } +// ----------------------------------------------------------------------------- +// CAknToolbar::HandlePointerEventL +// ----------------------------------------------------------------------------- +// +EXPORT_C void CAknToolbar::HandlePointerEventL( + const TPointerEvent& aPointerEvent ) + { + if ( !DrawableWindow()->IsNonFading() && ( DrawableWindow()->IsFaded() + || iInternalFlags.IsSet( EDrawBackground ) ) ) + { + return; + } + + TPointerEvent event( aPointerEvent ); + TBool override ( EFalse ); + + if ( aPointerEvent.iType == TPointerEvent::EButton1Up ) + { + iPreviousItem = KSelectedNone; + } + + // Cancel previous button + if ( iPreviousItem >=0 && ( aPointerEvent.iType == TPointerEvent::EDrag || + aPointerEvent.iType == TPointerEvent::EButtonRepeat ) ) + { + CAknToolbarItem* prevItem = iVisibleItems[iPreviousItem]; + + if ( prevItem->Control() + && ( prevItem->ControlType() == EAknCtButton + || prevItem->ControlType() == EAknCtToolbarExtension ) ) + { + CAknButton* button = static_cast( prevItem->Control() ); + if ( !button->TouchArea().Contains( aPointerEvent.iPosition ) ) + { + event.iType = TPointerEvent::EButton1Up; + button->HandlePointerEventL ( event ); + override = ETrue; + iPreviousItem = KSelectedNone; + } + } + } + + CAknToolbarItem* item = NULL; + for ( TInt ii = 0; ii < iVisibleItems.Count(); ++ii ) + { + item = iVisibleItems[ii]; + if ( item->Control() && + item->Control()->Rect().Contains( aPointerEvent.iPosition ) ) + { + if ( item->ControlType() == EAknCtButton || + item->ControlType() == EAknCtToolbarExtension ) + { + CAknButton* button = static_cast( item->Control() ); + + if ( button->TouchArea().Contains( aPointerEvent.iPosition ) ) + { + if ( ii != iPreviousItem ) + { + if ( !button->IsDimmed() ) + { + MoveHighlightL( ii, ETrue ); + // focus has moved from one button to another due to dragging, + // give sensitive feedback + if ( iPreviousItem != iFocusedItem && + ( aPointerEvent.iType == TPointerEvent::EDrag || + aPointerEvent.iType == TPointerEvent::EButtonRepeat ) ) + { + MTouchFeedback* feedback = MTouchFeedback::Instance(); + if ( feedback ) + { + feedback->InstantFeedback( ETouchFeedbackSensitiveButton ); + } + } + } + + if ( aPointerEvent.iType == TPointerEvent::EDrag || + aPointerEvent.iType == TPointerEvent::EButtonRepeat ) + { + button->SetHelpNoteTimeouts( KToolbarButtonBeforeTimeout, 0 ); + event.iType = TPointerEvent::EButton1Down; + button->HandlePointerEventL( event ); + override = ETrue; + } + iPreviousItem = ii; + } + + if ( aPointerEvent.iType == TPointerEvent::EButton1Down ) + { + iDownItem = ii; + button->SetHelpNoteTimeouts( KToolbarButtonBeforeTimeout, 0 ); + } + + if ( aPointerEvent.iType == TPointerEvent::EButton1Up ) + { + // Up and down events are in different items, give basic + // feedback to the released item. + if ( ii != iDownItem && !button->IsDimmed() ) + { + MTouchFeedback* feedback = MTouchFeedback::Instance(); + if ( feedback ) + { + feedback->InstantFeedback( ETouchFeedbackBasicButton ); + } + } + + button->HandlePointerEventL( aPointerEvent ); + override = ETrue; + } + } + else + { + // Button touchArea did not contain pointerevent + break; + } + + } + SelectItemL( ii, ETrue ); + } + } + + if ( !override ) + { + CAknControl::HandlePointerEventL( aPointerEvent ); + } + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::HandleResourceChange +// Handles a change to the control's resources. +// ----------------------------------------------------------------------------- +// +EXPORT_C void CAknToolbar::HandleResourceChange( TInt aType ) + { + // Base class method is not called because only visible components are + // returned by ComponentControl -> all icons wouldn't be updated. + + if ( aType == KAknToolbarSetHiddenAndDrawBackground ) + { + if ( Layout_Meta_Data::IsLandscapeOrientation() ) + { + aType = KAknToolbarSetHidden; + } + else + { + if ( IsShown() ) + { + iInternalFlags.Set( ECalledFromFW ); + if ( !( iFlags & KAknToolbarNoBackground ) ) + { + iInternalFlags.Set( EDrawBackground ); + } + + SetToolbarVisibility(EFalse, EFalse); + iInternalFlags.Clear( ECalledFromFW ); + } + else if ( iFlags & KAknToolbarDefault ) + { + iInternalFlags.Clear( EFixedShown ); + } + return; + } + } + + if ( aType == KAknToolbarSetVisible && iFlags & KAknToolbarDefault + && !AknLayoutUtils::PenEnabled() ) + { + return; + } + else if ( aType == KAknToolbarSetVisible && !IsShown() ) + { + iInternalFlags.Set( ECalledFromFW ); + iInternalFlags.Clear( EDrawBackground ); + SetToolbarVisibility(ETrue, EFalse); + iInternalFlags.Clear( ECalledFromFW ); + } + else if ( aType == KAknToolbarSetHidden && IsShown() ) + { + iInternalFlags.Set( ECalledFromFW ); + iInternalFlags.Clear( EDrawBackground ); + SetToolbarVisibility(EFalse, EFalse); + iInternalFlags.Clear( ECalledFromFW ); + } + else if ( aType == KAknToolbarSetHidden && + iInternalFlags.IsSet( EFixedShown ) ) + { + iInternalFlags.Clear( EFixedShown ); + } + + if ( aType == KEikDynamicLayoutVariantSwitch ) + { + iPreviousItem = KSelectedNone; + for(TInt i = 0; i < iVisibleItems.Count(); i++) + { + CAknToolbarItem* item = iVisibleItems[ i ]; + CAknButton* button = static_cast( item->Control() ); + button->ResetState(); + } + if ( iFlags & KAknToolbarDefault && !AknLayoutUtils::PenEnabled() && IsVisible() ) + { + TRAP_IGNORE( HideToolbarL() ); + return; + } + else if ( iFlags & KAknToolbarFixed ) + { + if ( Layout_Meta_Data::IsLandscapeOrientation() && AknLayoutUtils::PenEnabled() ) + { + iOrientation = EAknOrientationVertical; + if ( ( iInternalFlags.IsSet( EFixedShown ) + || ( iInternalFlags.IsSet( EItemsHidden ) + && iInternalFlags.IsSet( EAppOverrideVisibility ) ) ) + && !iInternalFlags.IsSet( EShown ) ) + { + // When the window is faded (e.g. while showing + // some note, ShowViaIdle is too slow + if ( DrawableWindow()->IsFaded() ) + { + TRAP_IGNORE( ShowToolbarL() ); + } + else + { + ShowViaIdle(); + } + } + } + else if ( !( iFlags & KAknToolbarDefault ) && AknLayoutUtils::PenEnabled() ) + { + iOrientation = EAknOrientationHorizontal; + if ( iInternalFlags.IsSet( EFixedShown ) && !iInternalFlags.IsSet( EShown ) ) + { + // If showing toolbar because HideItemsAndDrawOnlyBackground( EFalse ) + // called, show toolbar immediately (ShowViaIdle is too slow) + if ( iInternalFlags.IsSet( EItemsHidden ) ) + { + iInternalFlags.Clear( EItemsHidden ); + TRAP_IGNORE( ShowToolbarL() ); + } + else + { + ShowViaIdle(); + } + } + } + else if ( ( !AknLayoutUtils::PenEnabled() || iFlags & KAknToolbarDefault ) && iInternalFlags.IsSet( EShown ) ) + { + TRAP_IGNORE( HideToolbarL() ); + return; + } + else + { + iOrientation = EAknOrientationHorizontal; + } + + // Ordinal positions must be set in both landscape & portrait. In + // portrait that is needed in order to bring dialogs on top of the + // fixed toolbar whereas in landscape that is needed to disable + // toolbar's buttons when there is a dialog on the screen. + if ( iInternalFlags.IsSet( EShown ) ) + { + SetOrdinalPositions(); + } + } + + //Recalculate size no matter whether toolbar is visible. + { + TRect rect( CalculateSizeAndPosition() ); + + if ( !( iFlags & KAknToolbarFlexiblePosition ) ) + { + SetPosition( rect.iTl ); + } + else + { + UpdateControlPositions(); + } + + SetSize( rect.Size() ); + } + + if ( iInternalFlags.IsSet( EShown ) ) + { + if ( IsFocused() ) + { + TRAP_IGNORE( MoveHighlightL( iFocusedItem, EFalse ) ); + } + + } + } + + for ( TInt ii = 0; ii < iItems.Count(); ++ii ) + { + iItems[ii]->Control()->HandleResourceChange( aType ); + } + + if ( iInternalFlags.IsSet( EShown ) && ( aType == KAknsMessageSkinChange || + aType == KEikDynamicLayoutVariantSwitch ) ) + { + if ( aType == KAknsMessageSkinChange ) + { + DrawDeferred(); + } + } + + if ( aType == KEikMessageFadeAllWindows ) + { + // non-fixed toolbar should not be focusable when its window is faded + if ( !( iFlags & KAknToolbarFixed ) && IsVisible() && !IsNonFocusing() ) + { + // Cope with a situation where a focusing toolbar was visible when + // the application lost foreground when e.g. a task swapper was shown. + // In that case TopFocusedControl == NULL since it has not been set + // yet in CCoeAppUi. KEikMessageFadeAllWindows is sent via AknPopupFader + // which is a window server message observer i.e. it gets all ws + // events before any other processing is done. + CAknAppUi* appUi = iAvkonAppUi; + + CCoeControl* topControl = appUi->TopFocusedControl(); + + if ( topControl ) + { + appUi->UpdateStackedControlFlags( this, ~0, + ECoeStackFlagRefusesFocus | ECoeStackFlagRefusesAllKeys ); + + appUi->HandleStackChanged(); + } + } + } + else if ( aType == KEikMessageUnfadeWindows ) + { + if ( !( iFlags & KAknToolbarFixed ) && IsVisible() && !IsNonFocusing() ) + { + // window is unfaded, toolbar can be focused again + CAknAppUi* appUi = iAvkonAppUi; + + appUi->UpdateStackedControlFlags( this, ECoeStackFlagStandard, + ECoeStackFlagRefusesFocus | ECoeStackFlagRefusesAllKeys ); + + appUi->HandleStackChanged(); + } + } + } + + +// ----------------------------------------------------------------------------- +// CAknToolbar::HandleControlEventL +// Handles an event from an observed toolbar item. +// ----------------------------------------------------------------------------- +// +EXPORT_C void CAknToolbar::HandleControlEventL( CCoeControl* aControl, + TCoeEvent aEventType ) + { + switch ( aEventType ) + { + + case MCoeControlObserver::EEventRequestCancel: + { + CAknToolbarItem* item = ToolbarItemByControl( aControl ); + if ( item ) + { + if ( item->ControlType() == EAknCtButton || + item->ControlType() == EAknCtToolbarExtension ) + { + CAknButton* button = static_cast( aControl ); + button->SetHelpNoteTimeouts( KToolbarButtonBeforeTimeout, + KToolbarButtonInViewTimeout ); + } + } + break; + } + case MCoeControlObserver::EEventRequestExit: + { + HideToolbarL(); + break; + } + case MCoeControlObserver::EEventStateChanged: + { + iEventModifiers &= ~(ELongPress | ELongPressEnded); + + if ( ( iFlags & KAknToolbarLastUsedItemFocused ) && + !IsNonFocusing() && IsFocused() ) + { + iInitialFocusedItem = iFocusedItem; + } + CAknToolbarItem* item = ToolbarItemByControl( aControl ); + if ( item ) + { + if ( item->ControlType() == EAknCtButton || + item->ControlType() == EAknCtToolbarExtension) + { + CAknButton* button = static_cast( aControl ); + button->SetHelpNoteTimeouts( KToolbarButtonBeforeTimeout, + KToolbarButtonInViewTimeout ); + } + + if ( iToolbarObserver ) + { + // We don't want to start a transition if the toolbar + // is closed because select/ok was pressed. + CTouchToolbarData* d = CTouchToolbarData::GetData( this ); + if ( !d ) + { + TRect rect; + if ( CTouchToolbarData::SetData( this, rect, EFalse ) != + KErrNone ) + { + return; + } + + d = CTouchToolbarData::GetData( this ); + } + + if (NULL != d) + { + d->SetSelectPressed( ETrue ); + } + + if ( iAvkonAppUi && iAvkonAppUi->IsForeground() ) + { + iToolbarObserver->OfferToolbarEventL( item->CommandId() ); + } + d = CTouchToolbarData::GetData( this ); + if ( d ) + { + d->SetSelectPressed( EFalse ); + } + } + } + break; + } + case MCoeControlObserver::EEventRequestFocus: + { + if ( !IsNonFocusing() && !aControl->IsDimmed() ) + { + CAknToolbarItem* item = ToolbarItemByControl( aControl ); + if ( item->ControlType() == EAknCtButton || + item->ControlType() == EAknCtToolbarExtension ) + { + CAknButton* button = static_cast(aControl); + if ( button->IsDimmed() ) + { + break; + } + } + // focus should be moved to this control + TInt index = ToolbarVisibleIndexByControl( aControl ); + if ( index == KErrNotFound ) + { + return; + } + if ( !IsFocused() ) + { + iLastFocusedItem = index; + SetFocus( ETrue, EDrawNow ); + } + else + { + MoveHighlightL( index, ETrue ); + } + } + break; + } + case CAknButton::ELongPressEvent: + case CAknButton::ELongPressEndedEvent: + { + iEventModifiers &= ~( ELongPressEnded | ELongPress); + iEventModifiers |= ( aEventType == CAknButton::ELongPressEvent ) ? + ELongPress : ELongPressEnded; + CAknToolbarItem* item = ToolbarItemByControl( aControl ); + + if ( item && iToolbarObserver && iAvkonAppUi && iAvkonAppUi->IsForeground() ) + { + iToolbarObserver->OfferToolbarEventL( item->CommandId() ); + } + break; + } + default: + { + break; + } + } + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::PositionChanged +// ----------------------------------------------------------------------------- +// +EXPORT_C void CAknToolbar::PositionChanged() + { + if ( iFlags & KAknToolbarFlexiblePosition && !iInternalFlags.IsSet( ESliding ) ) + { + SetSize( CalculateSizeAndPosition().Size() ); + + if ( IsFocused() ) + { + TRAP_IGNORE( MoveHighlightL( iFocusedItem, EFalse ) ); + } + } + + UpdateControlPositions(); + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::ProcessCommandL +// From MEikCommandObserver. +// Processes user commands. +// ----------------------------------------------------------------------------- +// +EXPORT_C void CAknToolbar::ProcessCommandL( TInt aCommandId ) + { + switch ( aCommandId ) + { + case EAknSoftkeySelect: + { + // shouldn't be KFocusedNone either + __ASSERT_ALWAYS( ( iFocusedItem >= 0 && iFocusedItem < iVisibleItems.Count() ), + Panic( EEikPanicInvalidIndex )); + + if ( iFlags & KAknToolbarLastUsedItemFocused ) + { + iInitialFocusedItem = iFocusedItem; + } + + CAknToolbarItem* item = iVisibleItems[iFocusedItem]; + if ( item && item->Control() ) + { + if ( !( item->ControlType() == EAknCtButton || + item->ControlType() == EAknCtToolbarExtension ) ) + { + SelectItemL( iFocusedItem, EFalse ); + if ( iToolbarObserver ) + { + iToolbarObserver->OfferToolbarEventL( item->CommandId() ); + } + } + } + break; + } + + case EAknSoftkeyClose: + case EAknSoftkeyDone: + { + HideToolbarL(); + break; + } + + default: + { + break; + } + } + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::SetDimmed +// Sets toolbar dimmed. Doesn't redraw. +// ----------------------------------------------------------------------------- +// +EXPORT_C void CAknToolbar::SetDimmed( TBool aDimmed ) + { + for ( TInt ii = 0; ii < iItems.Count(); ii++ ) + { + CAknToolbarItem* item = iItems[ii]; + if ( item && item->Control() ) + { + item->Control()->SetDimmed( aDimmed ); + } + } + if ( aDimmed && !IsNonFocusing() ) + { + iFocusedItem = KFocusedNone; + if ( !iToolbarCba ) + { + return; + } + iToolbarCba->MakeCommandVisibleByPosition( + CEikButtonGroupContainer::ELeftSoftkeyPosition, EFalse ); + iToolbarCba->MakeCommandVisibleByPosition( + CEikButtonGroupContainer::EMiddleSoftkeyPosition, EFalse ); + iToolbarCba->DrawDeferred(); + } + CCoeControl::SetDimmed( aDimmed ); + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::OfferKeyEventL +// Handles key events. +// ----------------------------------------------------------------------------- +// +EXPORT_C TKeyResponse CAknToolbar::OfferKeyEventL( const TKeyEvent& aKeyEvent, + TEventCode aType ) + { + if ( aKeyEvent.iCode == EKeyEscape ) + { + return EKeyWasNotConsumed; + } + + if ( IsNonFocusing() || !IsFocused() ) + { + if ( iSelectedItem != KSelectedNone ) + { + CAknToolbarItem* item = iVisibleItems[iSelectedItem]; + if ( item->Control() && !item->RefusesKeys() ) + { + return item->Control()->OfferKeyEventL( aKeyEvent, aType ); + } + } + return EKeyWasNotConsumed; + } + + if ( ( iFlags & KAknToolbarWithoutCba ) && + !IsNonFocusing() && IsFocused() ) + { + if ( aKeyEvent.iCode == EKeyCBA1 || aKeyEvent.iCode == EKeyCBA2 || + aKeyEvent.iScanCode == EStdKeyDevice0 ) + { + return EKeyWasNotConsumed; + } + + CEikMenuPane* menuPane = NULL; + TBool useFactoryMenu = ETrue; + + // if this is a view app then ask menu from the currently active view + TVwsViewId uid; + + if ( iAvkonAppUi->GetActiveViewId( uid ) == KErrNone ) + { + if ( uid.iAppUid != uid.iViewUid ) + { + CEikMenuBar* menuBar = iAvkonViewAppUi->View( uid.iViewUid )->MenuBar(); + + if ( menuBar ) + { + menuPane = menuBar->MenuPane(); + useFactoryMenu = EFalse; + } + } + } + + // use factory menu if available + if ( useFactoryMenu ) + { + CEikMenuBar* menuBar = iEikonEnv->AppUiFactory( *iAvkonAppUi )->MenuBar(); + + if ( menuBar ) + { + menuPane = menuBar->MenuPane(); + } + } + // if menu is displayed then toolbar should not use key events. + if ( menuPane ) + { + if ( menuPane->IsVisible() ) + { + return EKeyWasNotConsumed; + } + } + } + + TInt count = iItems.Count(); + if ( count == 0 || iFocusedItem == KFocusedNone ) + { + return EKeyWasNotConsumed; + } + + CAknToolbarItem* item = iVisibleItems[iFocusedItem]; + + if ( ( !item || !item->IsSelected() ) && aType == EEventKey ) + { + switch ( aKeyEvent.iCode ) + { + case EKeyRightArrow: + case EKeyDownArrow: + case EKeyTab: + if ( ( aKeyEvent.iCode == EKeyDownArrow && + iOrientation != EAknOrientationVertical ) || + ( aKeyEvent.iCode == EKeyRightArrow && + iOrientation != EAknOrientationHorizontal ) ) + { + return EKeyWasNotConsumed; + } + + if ( count == 1 ) + { + return EKeyWasConsumed; + } + + if ( iFocusedItem + 1 < iVisibleItems.Count() ) + { + MoveHighlightL( iFocusedItem + 1, ETrue ); + } + else + { + MoveHighlightL( 0, ETrue ); + } + return EKeyWasConsumed; + + case EKeyLeftArrow: + case EKeyUpArrow: + if ( ( aKeyEvent.iCode == EKeyUpArrow && + iOrientation != EAknOrientationVertical ) || + ( aKeyEvent.iCode == EKeyLeftArrow && + iOrientation != EAknOrientationHorizontal ) ) + { + return EKeyWasNotConsumed; + } + + if ( count == 1 ) + { + return EKeyWasConsumed; + } + + if ( iFocusedItem - 1 >= 0 ) + { + MoveHighlightL( iFocusedItem - 1, ETrue, EFalse, ETrue ); + } + else + { + MoveHighlightL( iVisibleItems.Count() - 1, ETrue, EFalse, + ETrue ); + } + return EKeyWasConsumed; + + default: + break; + } + } + + // All key events can be given to buttons, other toolbar items must + // be seleceted to get events + if ( item && item->Control() ) + { + if ( ( item->ControlType() == EAknCtButton ) || + ( item->ControlType() == EAknCtToolbarExtension ) || item->IsSelected() ) + { + if ( aKeyEvent.iScanCode == EStdKeyDevice0 ) + { + TKeyEvent keyEvent = aKeyEvent; + // Button does not accept key events if the code is EStdKeyDevice0 + // so changing the key event to EStdKeyDevice3 + keyEvent.iScanCode = EStdKeyDevice3; + item->Control()->OfferKeyEventL( keyEvent, aType ); + } + else + { + item->Control()->OfferKeyEventL( aKeyEvent, aType ); + } + } + } + + return EKeyWasConsumed; // To avoid loss of focus + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::InputCapabilities +// Gets the control's input capabilities. +// ----------------------------------------------------------------------------- +// +EXPORT_C TCoeInputCapabilities CAknToolbar::InputCapabilities() const + { + return TCoeInputCapabilities::EAllText; + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::MopSupplyObject +// Retrieves an object of the same type as that encapsulated in aId. +// ----------------------------------------------------------------------------- +// +EXPORT_C TTypeUid::Ptr CAknToolbar::MopSupplyObject( TTypeUid aId ) + { + if ( aId.iUid == CEikCba::ETypeId ) + { + if ( iToolbarCba && iToolbarCba->ButtonGroupType() == + CEikButtonGroupContainer::ECba ) + { + return aId.MakePtr( static_cast( iToolbarCba->ButtonGroup() ) ); + } + else + { + return TTypeUid::Null(); + } + } + else if ( iToolbarCba && aId.iUid == CEikButtonGroupContainer::ETypeId ) + { + return aId.MakePtr( iToolbarCba ); + } + return CCoeControl::MopSupplyObject(aId); + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::Draw +// From MCoeControlBackground +// Draw the background for a given control. +// The text drawer that shall be used to draw text on the specific background +// can be fetched through the GetTextDrawer() method. +// ----------------------------------------------------------------------------- +// +EXPORT_C void CAknToolbar::Draw( CWindowGc& aGc, const CCoeControl& aControl, + const TRect& aRect ) const + { + if ( !( iFlags & KAknToolbarFixed ) ) + { + SetOrdinalPositions(); + } + + if ( iFlags & KAknToolbarNoBackground ) + { + return; + } + + MAknsSkinInstance* skin = AknsUtils::SkinInstance(); + + aGc.SetClippingRect( aRect ); + + CAknToolbarItem* item = ToolbarItemByControl( &aControl ); + + if ( iFlags & KAknToolbarFixed ) + { + TRAP_IGNORE( DrawFixedBackgroundL( aGc, aControl, aRect) ); + return; + } + + if ( item && ( item->ControlType() == EAknCtButton || + item->ControlType() == EAknCtToolbarExtension ) ) + { + CAknButton* button = static_cast( item->Control() ); + if ( !( button && ( button->ButtonFlags() & KAknButtonNoFrame ) ) ) + { + AknsDrawUtils::Background( skin, iFrameContext, aGc, aRect ); + } + } + else + { + AknsDrawUtils::Background( skin, iFrameContext, aGc, aRect ); + } + + if ( iFocusedItem == KFocusedNone ) + { + return; + } + if ( !IsNonFocusing() && ( iFlags & KAknToolbarSmall ) && + &aControl == iVisibleItems[iFocusedItem]->Control() ) + { + CAknToolbarItem* item = iVisibleItems[iFocusedItem]; + if ( item && item->HighlightRect().Intersects( aRect ) ) + { + TAknLayoutRect topLeft; + topLeft.LayoutRect( item->HighlightRect(), + SkinLayout::Highlight_skin_placing__grid__Line_2() ); + + TAknLayoutRect bottomRight; + bottomRight.LayoutRect( item->HighlightRect(), + SkinLayout::Highlight_skin_placing__grid__Line_5() ); + + TRect outerRect( topLeft.Rect().iTl, bottomRight.Rect().iBr ); + TRect innerRect( topLeft.Rect().iBr, bottomRight.Rect().iTl ); + + if ( iFlags & KAknToolbarTransparent ) + { + outerRect.Move(TPoint(-(topLeft.Rect().iTl.iX),-(topLeft.Rect().iTl.iY))); + AknsDrawUtils::DrawFrame( AknsUtils::SkinInstance(), + aGc, outerRect, innerRect, + KAknsIIDQsnFrGrid, KAknsIIDDefault ); // to another skin id ( Alpha ) + } + else + { + if ( !AknsDrawUtils::DrawFrame( AknsUtils::SkinInstance(), + aGc, outerRect, innerRect, + KAknsIIDQsnFrGrid, KAknsIIDDefault ) ) + { + aGc.SetBrushColor( KRgbRed ); + aGc.SetBrushStyle( CGraphicsContext::ESolidBrush ); + aGc.DrawRect( item->HighlightRect() ); + } + } + } + } + + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::ComponentControl +// Gets the specified component of a compound control. +// ----------------------------------------------------------------------------- +// +EXPORT_C CCoeControl* CAknToolbar::ComponentControl( TInt aIndex ) const + { + if ( aIndex < iVisibleItems.Count() && aIndex >= 0 ) + { + return iVisibleItems[aIndex]->Control(); + } + return NULL; + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::SizeChanged +// Responds to size changes to sets the size and position of the contents +// of this control. +// ----------------------------------------------------------------------------- +// +EXPORT_C void CAknToolbar::SizeChanged() + { + // Setup skin + const TRect popupRect( Rect() ); + if( popupRect.IsEmpty() || !iFrameContext ) + { + return ; + } + TAknLayoutRect topLeft; + topLeft.LayoutRect( popupRect, SkinLayout::Submenu_skin_placing_Line_2() ); + TAknLayoutRect bottomRight; + bottomRight.LayoutRect( popupRect, SkinLayout::Submenu_skin_placing_Line_5() ); + TRect outerRect = TRect( topLeft.Rect().iTl, bottomRight.Rect().iBr ); + TRect innerRect = TRect( topLeft.Rect().iBr, bottomRight.Rect().iTl ); + + if ( ( !( iFlags & KAknToolbarFixed ) && + !( iFlags & KAknToolbarFloatingUnTransparent ) ) ) + { + TRegionFix<4> transparentRegion; + // left side + transparentRegion.AddRect( TRect( outerRect.iTl, TPoint( innerRect.iTl.iX, outerRect.iBr.iY ) ) ); + // right side + transparentRegion.AddRect( TRect( TPoint( innerRect.iBr.iX, outerRect.iTl.iY ), outerRect.iBr ) ); + // top center + transparentRegion.AddRect( TRect( innerRect.iTl.iX, outerRect.iTl.iY, innerRect.iBr.iX, innerRect.iTl.iY ) ); + // bottom center + transparentRegion.AddRect( TRect( innerRect.iTl.iX, innerRect.iBr.iY, innerRect.iBr.iX, outerRect.iBr.iY ) ); + + Window().SetTransparentRegion( transparentRegion ); + } + + iFrameContext->SetFrameRects( outerRect, innerRect ); + + iFrameContext->SetParentPos( Position() ); + + iBgContext->SetParentPos( iAvkonAppUi->ApplicationRect().iTl ); + iBgContext->SetRect( iAvkonAppUi->ApplicationRect() ); + + //reset button tooltip position + UpdateItemTooltipPosition(); + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::FocusChanged +// This function is called whenever a control gains or loses focus. +// ----------------------------------------------------------------------------- +// +EXPORT_C void CAknToolbar::FocusChanged( TDrawNow aDrawNow ) + { + if ( !iInternalFlags.IsSet( EShown ) || IsNonFocusing() ) + { + return; // nothing should be done in this case + } + + TBool withoutCba( iFlags & KAknToolbarWithoutCba ); + if ( IsFocused() ) + { + if ( !withoutCba ) + { + if ( !iToolbarCba ) + { + TRAP_IGNORE( iToolbarCba = + CEikButtonGroupContainer::NewL( CEikButtonGroupContainer::ECba, + CEikButtonGroupContainer::EHorizontal, + this, iSoftkeyResource ) ); //lint !e665 + } + } + if ( iToolbarCba && iToolbarCba->ButtonGroup() ) + { + static_cast( iToolbarCba->ButtonGroup() )->SetSkinBackgroundId( + KAknsIIDQsnBgAreaControlPopup ); + } + + if ( iLastFocusedItem == KFocusedNone ) + { + TRAP_IGNORE( InitFocusedItemL( aDrawNow ) ); + } + else + { + TRAP_IGNORE( MoveHighlightL( iLastFocusedItem, aDrawNow ) ); + } + } + else + { + iLastFocusedItem = iFocusedItem; + } + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::ExtensionInterface +// For future extensions +// ----------------------------------------------------------------------------- +// +EXPORT_C void* CAknToolbar::ExtensionInterface( TUid /*aInterface*/ ) + { + return NULL; + } +// ----------------------------------------------------------------------------- +// CAknToolbar::Draw +// Draw a control called by window server. +// ----------------------------------------------------------------------------- +// +EXPORT_C void CAknToolbar::Draw( const TRect& aRect ) const + { + if ( !( iFlags & KAknToolbarFixed ) ) + { + SetOrdinalPositions(); + } + + CWindowGc& gc = SystemGc(); + MAknsSkinInstance* skin = AknsUtils::SkinInstance(); + // Draw background + if ( iFlags & KAknToolbarFixed && + iBgRect.Height() > 0 && + iBgRect.Width() > 0 ) + { + if ( aRect.Intersects( iBgRect ) ) + { + TBool idleLayout( AknStatuspaneUtils::IdleLayoutActive() ); + TBool wallpaperInUse( EFalse ); + + if ( iInternalFlags.IsSet( EInIdle ) || idleLayout ) + { + CRepository* repository = 0; + TRAP_IGNORE( repository = CRepository::NewL(KCRUidPersonalisation) ); + if( repository ) + { + repository->Get( KPslnWallpaperType, wallpaperInUse ); + delete repository; + } + } + + if ( wallpaperInUse != 0 && Layout_Meta_Data::IsLandscapeOrientation() && iInternalFlags.IsSet( EItemsHidden ) ) + { + iBgContext->SetBitmap( KAknsIIDWallpaper ); + } + AknsDrawUtils::Background( skin, iBgContext, this, gc, iBgRect, + KAknsDrawParamNoClearUnderImage ); + } + } + + if ( ( iFlags & KAknToolbarFixed ) || + ( iFlags & KAknToolbarNoBackground ) ) + { + // fixed toolbar doesn't draw anything itself - all drawing is done + // through background drawer implementation + return; + } + + gc.SetClippingRect( aRect ); + + if ( iFlags & KAknToolbarFixed ) + { + AknsDrawUtils::Background( skin, iFrameContext, this, gc, aRect, KAknsDrawParamNoClearUnderImage ); + } + else + { + AknsDrawUtils::Background( skin, iFrameContext, gc, aRect ); + } + + // draw toolbar item highlight if toolbar is not small + if ( !IsNonFocusing() && iFocusedItem != KFocusedNone && !( iFlags & KAknToolbarSmall ) ) + { + CAknToolbarItem* item = iVisibleItems[iFocusedItem]; + if ( item && item->HighlightRect().Intersects( aRect ) ) + { + TAknLayoutRect topLeft; + topLeft.LayoutRect( item->HighlightRect(), + SkinLayout::Highlight_skin_placing__grid__Line_2() ); + + TAknLayoutRect bottomRight; + bottomRight.LayoutRect( item->HighlightRect(), + SkinLayout::Highlight_skin_placing__grid__Line_5() ); + + TRect outerRect( topLeft.Rect().iTl, bottomRight.Rect().iBr ); + TRect innerRect( topLeft.Rect().iBr, bottomRight.Rect().iTl ); + + if ( !AknsDrawUtils::DrawFrame( AknsUtils::SkinInstance(), + gc, outerRect, innerRect, + KAknsIIDQsnFrGrid, KAknsIIDDefault ) ) + { + gc.SetBrushColor( KRgbRed ); + gc.SetBrushStyle( CGraphicsContext::ESolidBrush ); + gc.DrawRect( item->HighlightRect() ); + } + } + } + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::AddItemL +// Adds one new item to the toolbar. +// ----------------------------------------------------------------------------- +// +EXPORT_C void CAknToolbar::AddItemL( CCoeControl* aItem, + const TInt aType, + const TInt aCommandId, + const TInt aFlags ) + { + AddItemL( aItem, aType, aCommandId, aFlags, iItems.Count() ); + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::AddItemL +// Adds one new item to the toolbar. +// ----------------------------------------------------------------------------- +// +EXPORT_C void CAknToolbar::AddItemL( CCoeControl* aItem, + const TInt aType, + const TInt aCommandId, + const TInt aFlags, + const TInt aIndex ) + { + if ( aItem && IsSupportedItemType( aType ) ) + { + aItem->SetContainerWindowL( *this ); + aItem->SetBackground( this ); + + if ( aType != EAknCtToolbarExtension ) + { + aItem->SetObserver( this ); + } + + CAknToolbarItem* tbItem = new ( ELeave ) CAknToolbarItem( aItem, aType, + aCommandId, aFlags ); + CleanupStack::PushL( tbItem ); + iItems.InsertL( tbItem, aIndex ); + CleanupStack::Pop( tbItem ); + + TRect rect = CalculateSizeAndPosition(); + UpdateControlVisibility(); + TInt itemIndex = ToolbarVisibleIndexById( aCommandId ); + + if ( itemIndex <= iFocusedItem && IsFocused() && itemIndex >= 0 ) + { + MoveHighlightL( iFocusedItem + 1, EFalse ); + } + if ( aType == EAknCtButton || aType == EAknCtToolbarExtension ) + { + AdjustButton( *static_cast( aItem ) ); + } + + if ( iInternalFlags.IsSet( EShown ) ) + { + aItem->ActivateL(); + + if ( !( iFlags & KAknToolbarFlexiblePosition ) ) + { + SetPosition( rect.iTl ); + } + else + { + UpdateControlPositions(); + } + SetSize( rect.Size() ); + DrawDeferred(); + } + } + else + { + User::Leave( KErrNotSupported ); + } + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::RemoveItem +// Removes the item according to the specified ID +// ----------------------------------------------------------------------------- +// +EXPORT_C void CAknToolbar::RemoveItem( const TInt aCommandId ) + { + TInt itemIndex = ToolbarItemIndexById( aCommandId ); + if ( itemIndex >= 0 && itemIndex < iItems.Count() ) + { + TInt visibleIndex = ToolbarVisibleIndexById( aCommandId ); + + delete iItems[itemIndex]; + iItems.Remove( itemIndex ); + + TRect rect = CalculateSizeAndPosition(); + UpdateControlVisibility(); + + if ( visibleIndex >= 0 && visibleIndex < iFocusedItem && IsFocused() ) + { + TRAP_IGNORE( MoveHighlightL( iFocusedItem - 1, EFalse ) ); + } + if ( iInternalFlags.IsSet( EShown ) ) + { + if ( !( iFlags & KAknToolbarFlexiblePosition ) ) + { + SetPosition( rect.iTl ); + } + else + { + UpdateControlPositions(); + } + SetSize( rect.Size() ); + DrawDeferred(); + } + } + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::IsSupportedItemType +// Returns ETrue if item is supported. +// ----------------------------------------------------------------------------- +// +EXPORT_C TBool CAknToolbar::IsSupportedItemType( const TInt aType ) const + { + switch ( aType ) + { + case EAknCtButton: + case EAknCtToolbarExtension : + { + return ETrue; + } + default: + { +#ifdef RD_SCALABLE_UI_V2 + if ( iFlags & KAknToolbarSmall || iFlags & KAknToolbarFixed ) + { + return EFalse; + } + else + { + return ETrue; + } +#else + return EFalse; +#endif + + } + } + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::SetInitialFocusedItem +// Changes the command ID for the initially focused item when toolbar +// is shown or gain focus. +// ----------------------------------------------------------------------------- +// +EXPORT_C void CAknToolbar::SetInitialFocusedItem( const TInt aCommandId ) + { + iInitialFocusedItem = ToolbarVisibleIndexById( aCommandId ); + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::SetEmphasis +// Called by the framework to handle the emphasising or +// de-emphasising of a toolbar window when it is needed. +// ----------------------------------------------------------------------------- +// +EXPORT_C void CAknToolbar::SetEmphasis( const TBool aEmphasis ) + { + if ( iInternalFlags.IsSet( EShown ) ) + { + CEikonEnv::Static()->EikAppUi()->UpdateStackedControlFlags( this, + aEmphasis ? 0 : ECoeStackFlagRefusesFocus, ECoeStackFlagRefusesFocus ); + } + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::IsShown +// Returns toolbar visibility at this moment +// ----------------------------------------------------------------------------- +// +EXPORT_C TBool CAknToolbar::IsShown() const + { + return ( iInternalFlags.IsSet( EShown ) || ( iIdle && iIdle->IsActive() ) ); + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::SetWithSliding +// Specifies whether toolbar should be shown with sliding effect or not. +// By default toolbar is shown with sliding. +// ----------------------------------------------------------------------------- +// +EXPORT_C void CAknToolbar::SetWithSliding( const TBool /* aSlide */ ) + { + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::SetCloseOnCommand +// ----------------------------------------------------------------------------- +// +EXPORT_C void CAknToolbar::SetCloseOnCommand( const TInt aCommandId, + const TBool aClose ) + { + CAknToolbarItem* item = ToolbarItemById( aCommandId ); + if ( item ) + { + item->SetCloseOnCommand( aClose ); + } + } //lint !e1762 function cannot be made const + +// ----------------------------------------------------------------------------- +// CAknToolbar::SetCloseOnAllCommands +// ----------------------------------------------------------------------------- +// +EXPORT_C void CAknToolbar::SetCloseOnAllCommands( const TBool aClose ) + { + for ( TInt ii = 0; ii < iItems.Count(); ++ii ) + { + iItems[ii]->SetCloseOnCommand( aClose ); + } + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::SetOrientation +// ----------------------------------------------------------------------------- +// +EXPORT_C void CAknToolbar::SetOrientation( const TAknOrientation aOrientation ) + { + iOrientation = aOrientation; + if ( iFlags & KAknToolbarFixed ) + { + if ( Layout_Meta_Data::IsLandscapeOrientation() ) + { + iOrientation = EAknOrientationVertical; + } + else + { + iOrientation = EAknOrientationHorizontal; + } + } + if ( iFlags & KAknToolbarTransparent ) + { + TAknsItemID bgContextId; + if ( iFlags & KAknToolbarSmall ) + { + bgContextId = KAknsIIDQgnGrafPopupTrans; + } + else + { + bgContextId = ( iOrientation == EAknOrientationHorizontal ? + KAknsIIDQgnGrafBgTouchHorizontal : KAknsIIDQgnGrafBgTouchVertical ); + } + iFrameContext->SetFrame( bgContextId ); + if ( iFlags & KAknToolbarSmall ) + { + iFrameContext->SetCenter( KAknsIIDQgnGrafPopupTransCenter ); + } + } + + TRect rect = CalculateSizeAndPosition(); + // Set focused item again to avoid panic in a case when toolbar has more + // items in previous orientation and some of the items that do not + // fit to toolbar in this orientation was focused. + if ( IsFocused() ) + { + TRAP_IGNORE( MoveHighlightL( iFocusedItem, EFalse ) ); + } + + if ( iInternalFlags.IsSet( EShown ) ) + { + if ( !( iFlags & KAknToolbarFlexiblePosition ) ) + { + SetPosition( rect.iTl ); + } + else + { + UpdateControlPositions(); + } + SetSize( rect.Size() ); + DrawDeferred(); + } + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::NotifyBackgroundChange +// ----------------------------------------------------------------------------- +// +EXPORT_C void CAknToolbar::UpdateBackground() + { + return ; + } + + +// ----------------------------------------------------------------------------- +// CAknToolbar::ShowToolbarForBackgroundUpdate +// Shows toolbar after it has been hidden with HideToolbarForBackgroundUpdate +// this function is deserted for NGA's removing BitmapDevice +// ----------------------------------------------------------------------------- +// +void CAknToolbar::ShowToolbarForBackgroundUpdate() + { + return; + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::DisableToolbarL +// This disables toolbar so that it cannot be enabled. This is needed especially +// if a dialog is shown on the screen and toolbar should not be enabled by the +// user from touch pane. +// ----------------------------------------------------------------------------- +// +EXPORT_C void CAknToolbar::DisableToolbarL( TBool aDisable ) + { + if ( iInternalFlags.IsSet( EShown ) ) + { + User::Leave( KErrToolbarShown ); + } + + // notify observer (touch pane) that toolbar is disabled + if ( aDisable ) + { + iInternalFlags.Set( EDisabled ); + + if ( Observer() ) + { + Observer()->HandleControlEventL( this, + static_cast( KDisableToolbar ) ); + } + } + else + { + iInternalFlags.Clear( EDisabled ); + + if ( Observer() ) + { + Observer()->HandleControlEventL( this, + static_cast( KEnableToolbar ) ); + } + } + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::IsToolbarDisabled +// Returns ETrue if toolbar is disabled +// ----------------------------------------------------------------------------- +// +EXPORT_C TBool CAknToolbar::IsToolbarDisabled() const + { + return iInternalFlags.IsSet( EDisabled ); + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::SetFocusedItemL +// Sets toolbar item focused if found. +// ----------------------------------------------------------------------------- +// +EXPORT_C void CAknToolbar::SetFocusedItemL( const TInt aCommandId ) + { + TInt visibleIndex = ToolbarVisibleIndexById( aCommandId ); + if ( visibleIndex == KErrNotFound || IsNonFocusing() ) + { + User::Leave( KErrNotFound ); + } + + if ( visibleIndex == iFocusedItem ) + { + return; + } + + // There are only buttons in a focusable toolbar + CAknToolbarItem* item = iVisibleItems[visibleIndex]; + CAknButton* button = static_cast( item->Control() ); + + if ( button && button->IsDimmed() ) + { + return; + } + + TInt oldFocused = iFocusedItem; + + iFocusedItem = visibleIndex; + + // set this item focused + item->SetFocusL( ETrue, EFalse, ENoDrawNow, this ); + DrawNow( item->HighlightRect() ); + + if ( oldFocused != KFocusedNone ) + { + item = iVisibleItems[oldFocused]; + if ( item && item->Control() ) + { + SelectItemL( oldFocused, EFalse ); + + // take the focus away + item->SetFocusL( EFalse, EFalse, ENoDrawNow, this ); + DrawNow( item->HighlightRect() ); + } + } + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::FocusedItem +// Returns focused toolbar item command id +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt CAknToolbar::FocusedItem() const + { + if ( iFocusedItem < 0 || iFocusedItem >= iVisibleItems.Count() ) + { + return KErrNotFound; + } + CAknToolbarItem* item = iVisibleItems[iFocusedItem]; + return item->CommandId(); + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::PrepareForFocusLossL +// Takes focus away from editor/other controls if needed +// ----------------------------------------------------------------------------- +// +void CAknToolbar::PrepareForFocusLossL() + { + if ( iSelectedItem != KSelectedNone ) + { + SelectItemL( iSelectedItem, EFalse ); + } + } + + +// ----------------------------------------------------------------------------- +// CAknToolbar::EventModifiers +// Returns event modifiers +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt CAknToolbar::EventModifiers() const + { + return iEventModifiers; + } + + +// ----------------------------------------------------------------------------- +// CAknToolbar::ToolbarFlags +// Returns toolbar flags +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt CAknToolbar::ToolbarFlags() const + { + return iFlags; + } + + +// ----------------------------------------------------------------------------- +// CAknToolbar::FadeBehindPopup +// Fades behind popup +// ----------------------------------------------------------------------------- +// +void CAknToolbar::FadeBehindPopup( TBool aFade ) + { + iFader.FadeBehindPopup( this, this, aFade ); + } + + +// ----------------------------------------------------------------------------- +// CAknToolbar::CountFadedComponents +// Counts faded components +// ----------------------------------------------------------------------------- +// +TInt CAknToolbar::CountFadedComponents() + { + TInt count = 1; //this + if ( iToolbarCba ) + { + count++; + } + if ( ToolbarExtension() && ToolbarExtension()->ExtensionView() ) + { + count++; + } + return count; + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::FadedComponent +// Returns faded components +// ----------------------------------------------------------------------------- +// +CCoeControl* CAknToolbar::FadedComponent(TInt aIndex) + { + switch ( aIndex ) + { + case 0: + return this; + case 1: + if ( iToolbarCba ) + { + return iToolbarCba; + } + return ToolbarExtension()->ExtensionView(); + case 2: + return ToolbarExtension()->ExtensionView(); + default: + return NULL; + } + } + + +// ----------------------------------------------------------------------------- +// CAknToolbar::ReduceRect +// Reduces main pane rect +// ----------------------------------------------------------------------------- +// +void CAknToolbar::ReduceRect( TRect& aBoundingRect ) const + { + TBool toolbarNotVisible( !IsShown() && !( iFlags & KAknToolbarDefault ) ); + TBool fixedToolbar( iFlags & KAknToolbarFixed ); + TBool landscapeOrientation( Layout_Meta_Data::IsLandscapeOrientation() ); + TBool touchEnabled( AknLayoutUtils::PenEnabled() ); + TBool defaultContent( iFlags & KAknToolbarDefault ); + + if ( toolbarNotVisible || + !fixedToolbar || + ( defaultContent && !landscapeOrientation ) || + !touchEnabled || + ( fixedToolbar && defaultContent ) ) + { + return; + } + TRect appRect, toolbarRect; + AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EApplicationWindow, + appRect); + if ( !Layout_Meta_Data::IsLandscapeOrientation() ) + { + toolbarRect = RectFromLayout( appRect, + AknLayoutScalable_Avkon::area_side_right_pane( 6 ) ); + } + else + { + toolbarRect = RectFromLayout( appRect, + AknLayoutScalable_Avkon::area_side_right_pane( 0 ) ); + } + + + if ( toolbarRect.Intersects( aBoundingRect ) ) + { + toolbarRect.Intersection( aBoundingRect ); + + if ( Layout_Meta_Data::IsLandscapeOrientation() ) + { + aBoundingRect.iBr.iX = toolbarRect.iTl.iX; + } + else + { + aBoundingRect.iBr.iY = toolbarRect.iTl.iY; + } + } + } + + +// ----------------------------------------------------------------------------- +// CAknToolbar::SetSoftkeyResourceIdL +// Sets softkey resource id for toolbar +// ----------------------------------------------------------------------------- +// +EXPORT_C void CAknToolbar::SetSoftkeyResourceIdL( TInt aSoftkeyResourceId ) + { + iSoftkeyResource = aSoftkeyResourceId; + if ( iToolbarCba ) + { + iToolbarCba->SetCommandSetL( iSoftkeyResource ); + iToolbarCba->DrawDeferred(); + } + } + + +// ----------------------------------------------------------------------------- +// CAknToolbar::ExtensionEventL +// Extension notifies of its events using this method +// ----------------------------------------------------------------------------- +// +void CAknToolbar::ExtensionEventL( TInt aCommandId ) + { + if ( iToolbarObserver ) + { + iToolbarObserver->OfferToolbarEventL( aCommandId ); + } + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::ConstructControlLC +// Constructs one of the toolbar items +// ----------------------------------------------------------------------------- +// +CAknToolbarItem* CAknToolbar::ConstructControlLC( TResourceReader& aReader ) + { + CAknToolbarItem* item = new(ELeave) CAknToolbarItem; + CleanupStack::PushL( item ); + + item->ConstructFromResourceL( aReader ); + if ( item->Control() ) + { + item->Control()->SetContainerWindowL( *this ); + item->Control()->SetBackground( this ); + + if ( item->ControlType() != EAknCtToolbarExtension ) + { + item->Control()->SetObserver( this ); + } + } + else + { + CleanupStack::PopAndDestroy( item ); + item = NULL; + } + + return item; + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::CalculateSizeAndPosition +// Calculates size and position of the toolbar. +// ----------------------------------------------------------------------------- +// +TRect CAknToolbar::CalculateSizeAndPosition() + { + iVisibleItems.Reset(); + iPreviousItem = KSelectedNone; + if ( iItems.Count() <= 0 ) + { + return TRect(); + } + + TRect mainPaneRect; + if ( !( iFlags & KAknToolbarFixed ) ) + { + AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, + mainPaneRect ); + if ( iAvkonAppUi->TouchPane() ) + { + iAvkonAppUi->TouchPane()->ReduceRect( mainPaneRect ); + } + } + else + { + TRect appRect; + AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EApplicationWindow, + appRect); + if ( !Layout_Meta_Data::IsLandscapeOrientation() ) + { + iOrientation = EAknOrientationHorizontal; + mainPaneRect = RectFromLayout( appRect, + AknLayoutScalable_Avkon::area_side_right_pane( 6 ) ); + } + else + { + iOrientation = EAknOrientationVertical; + mainPaneRect = RectFromLayout( appRect, + AknLayoutScalable_Avkon::area_side_right_pane( 0 ) ); + } + } + + TRect toolbarRect; + TRect gridPaneRect; + TRect cellPaneRect; + + TBool smallToolbar = iFlags & KAknToolbarSmall; + + CalculateRects( mainPaneRect, toolbarRect, gridPaneRect, cellPaneRect ); + + // The position of the toolbar is by default fixed, but it can be changed + TPoint position; + TBool flexiblePosition = iFlags & KAknToolbarFlexiblePosition; + if ( flexiblePosition ) + { + position = Position(); + } + else + { + position = toolbarRect.iTl; + } + + TInt minToolbarWidthOrHeight; + // Maximum possible width of the toolbar with the specified position + TInt maxToolbarWidthOrHeight; + + if ( iOrientation == EAknOrientationHorizontal ) + { + // Width of empty toolbar + minToolbarWidthOrHeight = toolbarRect.Width() - gridPaneRect.Width(); + // Maximum width for toolbar + maxToolbarWidthOrHeight = mainPaneRect.Width() - + ( position.iX - mainPaneRect.iTl.iX ); + } + else + { + if ( iFlags & KAknToolbarFixed ) + { + minToolbarWidthOrHeight = 0; + maxToolbarWidthOrHeight = gridPaneRect.Height(); + } + else + { + // Height of empty toolbar + minToolbarWidthOrHeight = toolbarRect.Height() - gridPaneRect.Height(); + // Maximum height for toolbar + maxToolbarWidthOrHeight = mainPaneRect.Height() - + ( position.iY - mainPaneRect.iTl.iY ); + } + } + + + TInt gridPaneWidth= 0; + TInt gridPaneHeight = 0; + + TInt maxGridPaneWidthOrHeight = maxToolbarWidthOrHeight - minToolbarWidthOrHeight; + + + // Layout the component controls in grid pane. Note: Code does not use the + // actual cells from the layout, because toolbar must be able to contain any + // kind of control. It assumes that the cells are side by side in grid pane + // and that grid pane is filled from left to right. Code takes the height of + // the controls from button pane, but uses the control's own width. + TRect currentCellPaneRect = cellPaneRect; + iBgRect = TRect( TPoint( 0,0 ), toolbarRect.Size() ); + if ( iInternalFlags.IsSet( ESwitchForItemsHidden ) + && iInternalFlags.IsSet( EItemsHidden )) + { + iInternalFlags.Clear( EItemsHidden ); + } + for ( TInt ii = 0; + ii < iItems.Count() && + ( iOrientation == EAknOrientationHorizontal ? + currentCellPaneRect.iBr.iX - gridPaneRect.iTl.iX: + currentCellPaneRect.iBr.iY - gridPaneRect.iTl.iY ) + <= maxGridPaneWidthOrHeight; ++ii ) + { + CAknToolbarItem* item = iItems[ii]; + if ( item && item->Control() && !item->IsHidden() && !iInternalFlags.IsSet( EItemsHidden ) ) + { + switch ( item->ControlType() ) + { + case EAknCtButton: + case EAknCtToolbarExtension : + + { + TRect controlRect; + + if ( iFlags & KAknToolbarSmall ) + { + controlRect = currentCellPaneRect; + } + else if ( iFlags & KAknToolbarFixed ) + { + controlRect = currentCellPaneRect; + TAknLayoutRect centerLayout; + centerLayout.LayoutRect( currentCellPaneRect, + AknLayoutScalable_Avkon::cell_sctrl_middle_pane_g2( iOrientation == EAknOrientationHorizontal ).LayoutLine() ); + TRect graphicsRect = centerLayout.Rect(); + + CAknButton* button = static_cast( item->Control() ); + button->SetIconSize( graphicsRect.Size() ); + + TMargins8 margins; + margins.iTop = currentCellPaneRect.iTl.iY - graphicsRect.iTl.iY; + margins.iBottom = graphicsRect.iBr.iY - currentCellPaneRect.iBr.iY; + margins.iLeft = currentCellPaneRect.iTl.iX - graphicsRect.iTl.iX; + margins.iRight = graphicsRect.iBr.iX - currentCellPaneRect.iBr.iX; + button->SetMargins( margins ); + } + else + { + controlRect = CalculateControlRect( currentCellPaneRect ); + } + item->Control()->SetRect( controlRect ); + + if ( iOrientation == EAknOrientationHorizontal ) + { + iBgRect.iTl.iX += controlRect.Width(); + } + else + { + iBgRect.iTl.iY += controlRect.Height(); + } + break; + } + default: + { + CCoeControl* control = item->Control(); + + TRect controlRect = RectFromLayout( currentCellPaneRect, + AknLayoutScalable_Avkon::toolbar_button_pane() ); + + if ( iOrientation == EAknOrientationHorizontal ) + { + control->SetExtent( controlRect.iTl, + TSize( control->Rect().Width(), + controlRect.Height() ) ); + + currentCellPaneRect.Resize( control->Rect().Width() - + controlRect.Width(), 0); + } + else + { + control->SetExtent( controlRect.iTl, + TSize( controlRect.Width(), + control->Rect().Height() ) ); + + currentCellPaneRect.Resize( 0, control->Rect().Height() - + controlRect.Height() ); + } + break; + } + } + TRect highlightRect; + if ( smallToolbar ) + { + highlightRect = currentCellPaneRect; + } + else if ( iOrientation == EAknOrientationHorizontal ) + { + highlightRect = RectFromLayout( currentCellPaneRect, + AknLayoutScalable_Avkon::grid_highlight_pane_cp2(0) ); + } + else + { + highlightRect = RectFromLayout( currentCellPaneRect, + AknLayoutScalable_Avkon::grid_highlight_pane_cp2(3) ); + } + + item->SetHighlightRect( highlightRect ); + + +#ifdef RD_SCALABLE_UI_V2 + // Only buttons are shown with focusable toolbar or small toolbar. + if ( ( IsNonFocusing() && !smallToolbar ) || + item->ControlType() == EAknCtButton || item->ControlType() == EAknCtToolbarExtension ) +#else + if ( item->ControlType() == EAknCtButton || item->ControlType() == EAknCtToolbarExtension ) +#endif + { + if ( iOrientation == EAknOrientationHorizontal && + gridPaneWidth + currentCellPaneRect.Width() <= + maxGridPaneWidthOrHeight ) + { + iVisibleItems.Append( item ); + gridPaneWidth += currentCellPaneRect.Width(); + } + + else if ( iOrientation == EAknOrientationVertical && + gridPaneHeight + currentCellPaneRect.Height() <= + maxGridPaneWidthOrHeight ) + { + iVisibleItems.Append( item ); + gridPaneHeight += currentCellPaneRect.Height(); + gridPaneWidth = item->Control()->Rect().Width(); + } + + // Set up next cell pane rect + if ( iOrientation == EAknOrientationVertical ) + { + currentCellPaneRect.SetRect( TPoint( currentCellPaneRect.iTl.iX, + currentCellPaneRect.iBr.iY ), + cellPaneRect.Size() ); + } + else + { + currentCellPaneRect.SetRect( TPoint( currentCellPaneRect.iBr.iX, + currentCellPaneRect.iTl.iY ), + cellPaneRect.Size() ); + } + } + else + { + if ( item->IsSelected() ) + { + TRAP_IGNORE( item->SetIsSelectedL( EFalse ) ); + } + + currentCellPaneRect.SetRect( TPoint( currentCellPaneRect.iTl.iX, + currentCellPaneRect.iTl.iY ), + cellPaneRect.Size() ); + } + } + } + + if ( TooFewItemsVisible() ) + { + return TRect( position, TSize(0,0) ); + } + + + TRect rect; + + if ( iFlags & KAknToolbarFixed ) + { + rect = toolbarRect; + return rect; + } + + if ( iOrientation == EAknOrientationHorizontal ) + { + TInt mid = mainPaneRect.Width() / 2; + if ( !flexiblePosition ) + { + position.iX = mainPaneRect.iTl.iX + + ( mid - ( minToolbarWidthOrHeight + gridPaneWidth ) / 2 ); + if ( position.iX < toolbarRect.iTl.iX ) + { + position.iX = toolbarRect.iTl.iX; + } + } + rect = TRect( position, TSize( minToolbarWidthOrHeight + gridPaneWidth, + toolbarRect.Height() ) ); + } + else + { + TInt mid = mainPaneRect.Height() / 2; + if ( !flexiblePosition ) + { + position.iY = mainPaneRect.iTl.iY + + ( mid - ( minToolbarWidthOrHeight + gridPaneHeight ) / 2 ); + if ( position.iY < toolbarRect.iTl.iY ) + { + position.iY = toolbarRect.iTl.iY; + } + } + rect = TRect( position, TSize( toolbarRect.Width(), + minToolbarWidthOrHeight + gridPaneHeight ) ); + } + + return rect; + } + + + +// ----------------------------------------------------------------------------- +// CAknToolbar::CalculateRects +// Calculates rects for toolbar. +// ----------------------------------------------------------------------------- +// +void CAknToolbar::CalculateRects( TRect& aMainPaneRect, TRect& aToolbarRect, + TRect& aGridPaneRect, TRect& aCellPaneRect ) + { + TBool smallToolbar = iFlags & KAknToolbarSmall; + + TInt variety; + + if ( smallToolbar ) + { + if ( iOrientation == EAknOrientationHorizontal ) + { + variety = 1; + aToolbarRect = RectFromLayout( aMainPaneRect, + AknLayoutScalable_Avkon::popup_toolbar_trans_pane( variety ) ); + + aGridPaneRect = RectFromLayout( TRect( TPoint(), aToolbarRect.Size() ), + AknLayoutScalable_Avkon::grid_tb_trans_pane( variety ) ); + + aCellPaneRect = RectFromLayout( aGridPaneRect, + AknLayoutScalable_Avkon::cell_toolbar_trans_pane( 0, variety ) ); + } + else + { + aToolbarRect = RectFromLayout( aMainPaneRect, + AknLayoutScalable_Avkon::popup_toolbar_trans_pane() ); + + aGridPaneRect = RectFromLayout( TRect( TPoint(), aToolbarRect.Size() ), + AknLayoutScalable_Avkon::grid_tb_trans_pane() ); + + aCellPaneRect = RectFromLayout( aGridPaneRect, + AknLayoutScalable_Avkon::cell_toolbar_trans_pane( 0 ) ); + + } + } + else if ( iFlags & KAknToolbarFixed ) + { + if ( iOrientation == EAknOrientationHorizontal ) + { + variety = 4; + aToolbarRect = RectFromLayout( aMainPaneRect, + AknLayoutScalable_Avkon::grid_sctrl_middle_pane( 1 ) ); + + aGridPaneRect = TRect( TPoint(), aToolbarRect.Size() ); + + aCellPaneRect = RectFromLayout( aGridPaneRect, + AknLayoutScalable_Avkon::cell_sctrl_middle_pane( 1, 0, 0 ) ); + } + else + { + aToolbarRect = RectFromLayout( aMainPaneRect, + AknLayoutScalable_Avkon::grid_sctrl_middle_pane( 0 ) ); + + aGridPaneRect = TRect( TPoint(), aToolbarRect.Size() ); + + + aCellPaneRect = RectFromLayout( aGridPaneRect, + AknLayoutScalable_Avkon::cell_sctrl_middle_pane( 0, 0, 0 ) ); + } + } + else + { + if ( iOrientation == EAknOrientationHorizontal ) + { + variety = 4; + aToolbarRect = RectFromLayout( aMainPaneRect, + AknLayoutScalable_Avkon::popup_toolbar_window( variety ) ); + + aGridPaneRect = RectFromLayout( TRect( TPoint(), aToolbarRect.Size() ), + AknLayoutScalable_Avkon::grid_toobar_pane() ); + + aCellPaneRect = RectFromLayout( aGridPaneRect, + AknLayoutScalable_Avkon::cell_toolbar_pane( 0 ) ); + } + else + { + aToolbarRect = RectFromLayout( aMainPaneRect, + AknLayoutScalable_Avkon::popup_toolbar_window( 6 ) ); + + aGridPaneRect = RectFromLayout( TRect( TPoint(), aToolbarRect.Size() ), + AknLayoutScalable_Avkon::grid_toobar_pane( 6 ) ); + + aCellPaneRect = RectFromLayout( aGridPaneRect, + AknLayoutScalable_Avkon::cell_toolbar_pane( 0, 1, 0 ) ); + + } + } + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::CalculateControlRect +// Calculates control rect for toolbar item. +// ----------------------------------------------------------------------------- +// +TRect CAknToolbar::CalculateControlRect( TRect& aCurrentCellPaneRect ) + { + TRect controlRect; + if ( iOrientation == EAknOrientationHorizontal ) + { + controlRect = RectFromLayout( aCurrentCellPaneRect, + AknLayoutScalable_Avkon::toolbar_button_pane() ); + } + else + { + controlRect = RectFromLayout( aCurrentCellPaneRect, + AknLayoutScalable_Avkon::toolbar_button_pane( 2 ) ); + } + return controlRect; + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::CheckNumberOfVisibleItems +// Checks number of visible items and deletes or created CBA if needed +// ----------------------------------------------------------------------------- +// +TBool CAknToolbar::TooFewItemsVisible() + { + if( !iVisibleItems.Count() ) + { + if ( iFlags & KAknToolbarFixed ) + { + return EFalse; + } + else + { + //if the number of toolbar items is 0 then toolbar CBA is deleted + if ( iToolbarCba ) + { + delete iToolbarCba; + iToolbarCba = NULL; + } + + DrawableWindow()->SetOrdinalPosition( 0, ECoeWinPriorityNeverAtFront ); + + iInternalFlags.Set( ENoItemsVisible ); + return ETrue; + } + } + else if ( iInternalFlags.IsSet( ENoItemsVisible ) ) + { + iInternalFlags.Clear( ENoItemsVisible ); + + TBool withoutCba( iFlags & KAknToolbarWithoutCba ); + + DrawableWindow()->SetOrdinalPosition( 0, ECoeWinPriorityNormal ); + + // toolbar CBA is created here because it had been deleted due to + // too few items in toolbar + if ( !withoutCba && !IsNonFocusing() ) + { + TRAP_IGNORE( iToolbarCba = CEikButtonGroupContainer::NewL( + CEikButtonGroupContainer::ECba, + CEikButtonGroupContainer::EHorizontal, + this, iSoftkeyResource ) ); + + if ( iToolbarCba->ButtonGroup() ) + { + static_cast( iToolbarCba->ButtonGroup() )-> + SetSkinBackgroundId( KAknsIIDQsnBgAreaControlPopup ); + } + TRAP_IGNORE( InitFocusedItemL( ETrue ) ); + + } + } + return EFalse; + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::ToolbarItemByControl +// Returns toolbar item object for the specified control. +// ----------------------------------------------------------------------------- +// +CAknToolbarItem* CAknToolbar::ToolbarItemByControl( const CCoeControl* aControl ) const + { + if ( aControl ) + { + for ( TInt ii = 0; ii < iItems.Count(); ii++ ) + { + CAknToolbarItem* item = iItems[ii]; + if ( item && item->Control() && item->Control() == aControl ) + { + return item; + } + } + } + return NULL; + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::ToolbarItemById +// Returns toolbar item object for the specified command ID +// ----------------------------------------------------------------------------- +// +CAknToolbarItem* CAknToolbar::ToolbarItemById( const TInt aId ) const + { + for ( TInt ii = 0; ii < iItems.Count(); ii++ ) + { + CAknToolbarItem* item = iItems[ii]; + if ( item && item->CommandId() == aId ) + { + return item; + } + } + return NULL; + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::ToolbarItemIndexById +// Returns the index of the toolbar item inside of the iItems array. +// ----------------------------------------------------------------------------- +// +TInt CAknToolbar::ToolbarItemIndexById( const TInt aId ) const + { + for ( TInt ii = 0; ii < iItems.Count(); ii++ ) + { + CAknToolbarItem* item = iItems[ii]; + if ( item && item->CommandId() == aId ) + { + return ii; + } + } + return KErrNotFound; + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::ToolbarItemIndexByControl +// Returns toolbar item index for the specified control or KErrNotFound. +// ----------------------------------------------------------------------------- +// +TInt CAknToolbar::ToolbarItemIndexByControl( const CCoeControl* aControl ) const + { + if ( aControl ) + { + for ( TInt ii = 0; ii < iItems.Count(); ii++ ) + { + CAknToolbarItem* item = iItems[ii]; + if ( item && item->Control() == aControl ) + { + return ii; + } + } + } + return KErrNotFound; + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::ToolbarVisibleIndexById +// Returns the index of the toolbar item inside of the iVisibleItems array. +// ----------------------------------------------------------------------------- +// +TInt CAknToolbar::ToolbarVisibleIndexById( const TInt aId ) const + { + for ( TInt ii = 0; ii < iVisibleItems.Count(); ii++ ) + { + CAknToolbarItem* item = iVisibleItems[ii]; + if ( item && item->CommandId() == aId ) + { + return ii; + } + } + return KErrNotFound; + } + + + +// ----------------------------------------------------------------------------- +// CAknToolbar::ToolbarVisibleIndexByControl +// Returns visible toolbar item index for the specified control or KErrNotFound. +// ----------------------------------------------------------------------------- +// +TInt CAknToolbar::ToolbarVisibleIndexByControl( const CCoeControl* aControl ) const + { + if ( aControl ) + { + for ( TInt ii = 0; ii < iVisibleItems.Count(); ii++ ) + { + CAknToolbarItem* item = iVisibleItems[ii]; + if ( item && item->Control() == aControl ) + { + return ii; + } + } + } + return KErrNotFound; + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::SlideToolbar +// Draws the toolbar with sliding effect. +// ----------------------------------------------------------------------------- +// +void CAknToolbar::SlideToolbar( const TPoint& aEndPos ) + { + // Currently supports sliding only from left to right. + // If some other cases are needed implementation should be changed then. + + if ( iOrientation == EAknOrientationVertical ) + { + return; + } + + TPoint start = Position(); + iStep = ( aEndPos.iX - start.iX ) / 10; + + iEndPos = aEndPos.iX; + + SlideWithIdle(); + + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::SetRightCbaText +// Changes CBA if no item is focused. +// ----------------------------------------------------------------------------- +// +void CAknToolbar::SetRightCbaTextL() + { + if ( !iToolbarCba ) + { + return; + } + + if ( IsFocused() && iFocusedItem == KFocusedNone ) + { + iToolbarCba->MakeCommandVisibleByPosition( + CEikButtonGroupContainer::ELeftSoftkeyPosition, EFalse ); + iToolbarCba->MakeCommandVisibleByPosition( + CEikButtonGroupContainer::EMiddleSoftkeyPosition, EFalse ); + iToolbarCba->DrawDeferred(); + } + } +// ----------------------------------------------------------------------------- +// CAknToolbar::GetNextSelectableItemIndex +// Returns next not dimmed and not hidden control index. +// ----------------------------------------------------------------------------- +// +TInt CAknToolbar::GetNextSelectableItemIndex( TInt aStartIndex, TBool aMoveForward ) + { + TInt index( aStartIndex ); + + if ( IsNonFocusing() ) + { + return KFocusedNone; + } + + __ASSERT_ALWAYS( iVisibleItems.Count(), Panic( EEikPanicInvalidLength ) ); + + CAknButton* button = NULL; + // we will do it till we don't get valid non-dimmed item or till we don't + // make the whole round ( all items are dimmed ) + do + { + button = NULL; + if ( aMoveForward && index >= iVisibleItems.Count() - 1 ) + { + index = 0; + } + else if ( !aMoveForward && index == 0 ) + { + index = iVisibleItems.Count() - 1; + } + else + { + if ( aMoveForward ) + { + ++index; + } + else + { + --index; + } + } + button = static_cast( iVisibleItems[index]->Control() ); + + } while ( ( !button || button->IsDimmed() ) && aStartIndex != index ); + + // no non-dimmed items + if ( aStartIndex == index ) + { + return KFocusedNone; + } + + return index; + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::MoveHighlightL +// Moves highlight from one item to another +// ----------------------------------------------------------------------------- +// +void CAknToolbar::MoveHighlightL( TInt aItemIndex, + const TBool aDrawNow, + const TBool aMoveForward, + const TBool aPrepareControl ) + { + if ( IsNonFocusing() || !iVisibleItems.Count() ) + { + // Item cannot get focus, when toolbar is non-focusing + aItemIndex = KFocusedNone; + } + + if ( aItemIndex >= iVisibleItems.Count() ) + { + aItemIndex = iVisibleItems.Count() - 1; + } + else if ( aItemIndex < 0 && aItemIndex != KFocusedNone ) + { + aItemIndex = 0; + } + + if ( aItemIndex == iFocusedItem ) + { + if ( iFocusedItem >= 0 && iFocusedItem < iVisibleItems.Count() ) + { + // Set item focused again so that tooltip is shown again. + iVisibleItems[iFocusedItem]->SetFocusL( ETrue, aPrepareControl, + aDrawNow ? EDrawNow : ENoDrawNow, this ); + } + return; + } + + TInt oldFocused = iFocusedItem; + if ( oldFocused < 0 || oldFocused >= iVisibleItems.Count() ) + { + oldFocused = KFocusedNone; + } + iFocusedItem = aItemIndex; + CAknToolbarItem* item = NULL; + CAknButton* button = NULL; + + if ( iFocusedItem != KFocusedNone ) + { + // There are only buttons in a focusable toolbar + item = iVisibleItems[iFocusedItem]; + button = static_cast( item->Control() ); + + if ( button && button->IsDimmed() ) + { + // we should skip dimmed controls + TInt index = GetNextSelectableItemIndex( iFocusedItem, + aMoveForward ); + if ( index == KFocusedNone ) + { + // all items are dimmed + iFocusedItem = KFocusedNone; + SetRightCbaTextL(); + // Draw last hightlighted item again to remove highlight + if ( oldFocused >= 0 && oldFocused < iVisibleItems.Count() ) + { + CAknToolbarItem* oldItem = iVisibleItems[oldFocused]; + DrawNow( oldItem->HighlightRect() ); + } + return; + } + // there is only one non dimmed item + else if ( index == oldFocused ) + { + iFocusedItem = oldFocused; + return; + } + else + { + iFocusedItem = index; + } + + __ASSERT_DEBUG( ( index >= 0 && index < iVisibleItems.Count() ), + Panic( EEikPanicInvalidIndex ) ); + item = iVisibleItems[index]; + } + + // set this item focused + item->SetFocusL( ETrue, aPrepareControl, + aDrawNow ? EDrawNow : ENoDrawNow, this ); + item->Control()->DrawNow( item->HighlightRect() ); + } + + if ( oldFocused != KFocusedNone ) + { + item = iVisibleItems[oldFocused]; + if ( item && item->Control() ) + { + SelectItemL( oldFocused, EFalse ); + + // take the focus away + item->SetFocusL( EFalse, aPrepareControl, + aDrawNow ? EDrawNow : ENoDrawNow, this ); + item->Control()->DrawNow( item->HighlightRect() ); + } + } + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::InitFocusedItemL +// Set the focus to the middle or first item. Size and position should be +// calculated already, to avoid iVisibleItems.Count() to be 0. +// ----------------------------------------------------------------------------- +// +void CAknToolbar::InitFocusedItemL( const TBool aDrawNow ) + { + __ASSERT_ALWAYS( iVisibleItems.Count(), Panic( EEikPanicInvalidLength ) ); + + if ( iInitialFocusedItem >= 0 && + iInitialFocusedItem < iVisibleItems.Count() ) + { + MoveHighlightL( iInitialFocusedItem, aDrawNow ); + return; + } + + if ( iFlags & KAknToolbarMiddleItemFocused && iVisibleItems.Count() != 1 ) + { + // focus is in the middle + if ( iVisibleItems.Count() % 2 ) + { + // if the number of visible items is odd number + MoveHighlightL( iVisibleItems.Count() / 2, aDrawNow ); + } + else + { + // if the number of visible items is even number + MoveHighlightL( iVisibleItems.Count() / 2 - 1, aDrawNow ); + } + } + else // default behaviour + { + MoveHighlightL( 0, aDrawNow ); + } + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::SetShown +// Sets the flag on or off. +// ----------------------------------------------------------------------------- +// +void CAknToolbar::SetShown( const TBool aShown ) + { + if ( aShown ) + { + iInternalFlags.Set( EShown ); + } + else + { + iInternalFlags.Clear( EShown ); + } + + if ( !( iFlags & KAknToolbarWithoutCba ) && !IsNonFocusing() && + !( iFlags & KAknToolbarSmall ) ) + { + FadeBehindPopup( aShown ); + } + CCoeControl::MakeVisible( aShown ); + // Need to call here, because ComponentControl only returns + // visible items + UpdateControlVisibility(); + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::SelectItemL +// ----------------------------------------------------------------------------- +// +void CAknToolbar::SelectItemL( const TInt aIndex, const TBool aSelect ) + { + if ( aSelect ) + { + if ( aIndex != iSelectedItem ) + { + if ( iSelectedItem != KSelectedNone && + iSelectedItem < iVisibleItems.Count() ) + { + iVisibleItems[iSelectedItem]->SetIsSelectedL( EFalse ); + } + + if ( aIndex != KSelectedNone && aIndex < iVisibleItems.Count() ) + { + if ( iVisibleItems[aIndex]->SetIsSelectedL( ETrue ) ) + { + iSelectedItem = aIndex; + } + else + { + iSelectedItem = KSelectedNone; + } + } + else + { + iSelectedItem = KSelectedNone; + } + } + } + else + { + if ( aIndex == iSelectedItem ) + { + if ( aIndex != KSelectedNone && aIndex < iVisibleItems.Count() ) + { + iVisibleItems[aIndex]->SetIsSelectedL( EFalse ); + } + iSelectedItem = KSelectedNone; + } + } + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::RectFromLayout +// ----------------------------------------------------------------------------- +// +TRect CAknToolbar::RectFromLayout( const TRect& aParent, + const TAknWindowComponentLayout& aComponentLayout ) const + { + TAknWindowLineLayout lineLayout = aComponentLayout.LayoutLine(); + TAknLayoutRect layoutRect; + layoutRect.LayoutRect( aParent, lineLayout ); + return layoutRect.Rect(); + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::WaitForScreenSwitch. This is called by CIdle when it returns. +// Toolbar is shown again with new screen capture. +// this function is deserted for NGA's removing BitmapDevice +// ----------------------------------------------------------------------------- +// +TInt CAknToolbar::WaitForScreenSwitch(TAny* /*aThis*/) + { + return KErrNone; + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::HideToolbarForBackgroundUpdate +// This hides toolbar so that it is possible to get a screen capture. +// ----------------------------------------------------------------------------- +// +void CAknToolbar::HideToolbarForBackgroundUpdate() + { + return; + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::UpdateTooltipPositions +// Updates tooltips positions +// ----------------------------------------------------------------------------- +// +void CAknToolbar::UpdateControlPositions() + { + for ( TInt ii = 0; ii < iVisibleItems.Count(); ++ii ) + { + iVisibleItems[ii]->RegisterPosition( Position() ); + } + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::ShowViaIdle +// Shows toolbar via CIdle. +// ----------------------------------------------------------------------------- +// +void CAknToolbar::ShowViaIdle() + { + if ( !iIdle ) + { + TRAPD( err, iIdle = CIdle::NewL( CActive::EPriorityStandard ) ); + + if ( err != KErrNone) + { + return; + } + } + + if ( iIdle->IsActive() ) + { + iIdle->Cancel(); + } + + if ( iFlags & KAknToolbarFixed ) + { + iIdle->SetPriority ( CActive::EPriorityStandard ); + } + else + { + iIdle->SetPriority( CActive::EPriorityIdle ); + } + + iInternalFlags.Set( EShown ); + iIdle->Start( TCallBack ( ShowDelayedToolbar, this ) ); + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::ShowDelayedToolbar +// Callback for delayed window creation. +// ----------------------------------------------------------------------------- +// +TInt CAknToolbar::ShowDelayedToolbar( TAny* aThis ) + { + CAknToolbar* toolbar = static_cast(aThis); + if ( !toolbar->iInternalFlags.IsSet( EShowingAgain ) && + toolbar->iInternalFlags.IsSet( EShown ) ) + { + TRAPD(err,toolbar->ShowToolbarL()); + if ( err != KErrNone ) + { + // if we failed then softkeys should be deleted just in case if they + // were created before leave + delete toolbar->iToolbarCba; + toolbar->iToolbarCba = NULL; + + toolbar->SetFocus( EFalse ); + CEikonEnv::Static()->EikAppUi()->UpdateStackedControlFlags( toolbar, + ~0, ECoeStackFlagRefusesFocus | ECoeStackFlagRefusesAllKeys ); + + } + } + else + { + toolbar->DrawableWindow()->SetOrdinalPosition( 0, ECoeWinPriorityNormal ); + toolbar->iInternalFlags.Clear( EShowingAgain ); + } + return KErrNone; + } + + +// ----------------------------------------------------------------------------- +// CAknToolbar::CheckHitAreas +// Registers buttons to check hit areas in the case of fixed toolbar +// ----------------------------------------------------------------------------- +// +void CAknToolbar::CheckHitAreas() + { + CAknButton* button = NULL; + + for ( TInt ii = 0; ii < iItems.Count(); ++ii ) + { + if ( iItems[ii]->ControlType() == EAknCtButton || + iItems[ii]->ControlType() == EAknCtToolbarExtension ) + { + button = static_cast(iItems[ii]->Control()); + button->CheckHitArea(); + } + } + + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::Toolbar Extension +// Return pointer to toolbar extension if available +// ----------------------------------------------------------------------------- +// +EXPORT_C CAknToolbarExtension* CAknToolbar::ToolbarExtension() const + { + for ( TInt i = 0; i < iItems.Count(); ++i ) + { + if ( iItems[i]->ControlType() == EAknCtToolbarExtension ) + { + return static_cast( iItems[i]->Control() ); + } + } + return NULL; + } + +// ----------------------------------------------------------------------------- +// Calls dyninittoolbarL about extension opening. +// ----------------------------------------------------------------------------- +// +void CAknToolbar::DynInitExtensionL( CCoeControl* aControl ) + { + TInt commandId = ToolbarItemByControl( aControl )->CommandId(); + if ( iToolbarObserver ) + { + iToolbarObserver->DynInitToolbarL( commandId, this ); + } + } + + +// ----------------------------------------------------------------------------- +// CAknToolbar::CheckFixedToolbarButtonsL +// Counts button components of fixed toolbar and adds button(s) if needed +// ----------------------------------------------------------------------------- +// +void CAknToolbar::CheckFixedToolbarButtonsL() + { + if ( iFlags & KAknToolbarFixed ) + { + // Count button components + TInt count ( 0 ); + for ( TInt ii = 0; ii < iItems.Count(); ++ii ) + { + if ( iItems[ii]->ControlType() == EAknCtButton || + iItems[ii]->ControlType() == EAknCtToolbarExtension ) + { + ++count; + } + } + + // Add missing button components + for ( TInt kk = count; kk < KFixedtoolbarButtons; ++kk ) + { + CAknButton* button = CAknButton::NewLC( NULL, NULL, NULL, NULL, + KNullDesC, KNullDesC, 0, 0 ); + button->SetDimmed( ETrue ); + AddItemL( button, EAknCtButton, -1, 0 ); + CleanupStack::Pop( button ); + AdjustButton( *button ); + } + } + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::DrawFixedBackgroundL +// Draws background of fixed toolbar +// ----------------------------------------------------------------------------- +// +void CAknToolbar::DrawFixedBackgroundL( CWindowGc& aGc, + const CCoeControl& aControl, + const TRect& aRect ) const + { + // What happens here is: + // 1. Check if we are in the idle state and a wallpaper is in use. + // 2. If wallpaper is not used then just blit a correct piece of the skin + // background to the screen and return. + // 3. If we're in idle and wallpaper is used then draw wallpaper to a + // temporary bitmap. + // 4. Skin background with additional mask (either qgn_graf_bg_lsc_bottom_mask_icon + // or qgn_graf_bg_prt_bottom_mask_icon) is blitted on top of the wallpaper. + // Skin background's original mask is ignored. Note that these additional + // masks are larger than the actual fixed toolbar so only a portion of them + // should be used. + // Blit the generated background bitmap to the screen. + TBool wallpaperInUse = EFalse; + TInt itemsInCleanupStack = 0; + + if ( iInternalFlags.IsSet( EInIdle ) ) + { + CRepository* repository = CRepository::NewL( KCRUidPersonalisation ); + repository->Get( KPslnWallpaperType, wallpaperInUse ); + delete repository; + } + + MAknsSkinInstance* skin = AknsUtils::SkinInstance(); + + // background context shared by both wallpaper and skin background + TAknsItemID itemID = iInternalFlags.IsSet( EInIdle ) ? KAknsIIDQsnBgScreenIdle : KAknsIIDQsnBgScreen; + if ( iBgIID != KAknsIIDNone ) + { + itemID = iBgIID; + } + CAknsBasicBackgroundControlContext* context = + CAknsBasicBackgroundControlContext::NewL( + itemID, + iAvkonAppUi->ApplicationRect(), + EFalse ); + + CleanupStack::PushL( context ); + ++itemsInCleanupStack; + + const TDisplayMode displayMode( + CCoeEnv::Static()->ScreenDevice()->DisplayMode() ); + + TBool useDithering = EFalse; + TPoint skinOrigin( aRect.iTl ); + + // check if dithering is to be used + if ( ( displayMode == EColor16MA || displayMode == EColor16MU ) && + ( iFlags & KAknToolbarDsaMode ) /*&& + !bgBmp->IsCompressedInRAM() */) + { + useDithering = ETrue; + } + + // draw skin background to whatever context was chosen (window or bitmap) + AknsDrawUtils::DrawBackground( skin, + context, + this, + aGc, + skinOrigin, + TRect( iPosition + aRect.iTl, aControl.Size() ), + KAknsDrawParamDefault ); + + if ( wallpaperInUse ) + { + // Blit wallpaper to the background bitmap. + context->SetBitmap( KAknsIIDWallpaper ); + AknsDrawUtils::DrawBackground( skin, + context, + this, + aGc, + TPoint( 0, 0 ), + TRect( iPosition + aRect.iTl, aControl.Size() ), + KAknsDrawParamDefault ); + } + if ( useDithering ) + { + aGc.SetDrawMode( CGraphicsContext::EDrawModeWriteAlpha ); + aGc.SetBrushColor( TRgb( KToolbarBgColor, KToolBarBgAlpha ) ); + aGc.SetBrushStyle( CGraphicsContext::ESolidBrush ); + aGc.DrawRect( Rect() ); + } + + CleanupStack::PopAndDestroy( itemsInCleanupStack ); + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::SlideWithIdle. This is called by CIdle when it returns. +// Toolbar is drawn again with different coordinates. +// ----------------------------------------------------------------------------- +// +void CAknToolbar::SlideWithIdle() + { + TPoint start(iPosition); + + if ( start.iX < iEndPos ) + { + start.iX += iStep; + if ( start.iX >= iEndPos ) + { + start.iX = iEndPos; // needed if start.iX is greater than iEndPos + TRAP_IGNORE( InitFocusedItemL( ETrue ) ); + } + SetPosition( start ); + DrawNow(); + + if ( !iIdle ) + { + TRAPD( err, iIdle = CIdle::NewL( CActive::EPriorityIdle ) ); + if ( err != KErrNone) + { + return; + } + } + + if ( iIdle->IsActive() ) + { + iIdle->Cancel(); + } + + iIdle->Start( TCallBack ( ReadyToSlide, this ) ); + } + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::ReadyToSlide. This is called by CIdle when it returns. +// Toolbar is drawn again with different coordinates. +// ----------------------------------------------------------------------------- +// +TInt CAknToolbar::ReadyToSlide( TAny* aThis ) + { + CAknToolbar* toolbar = static_cast(aThis); + toolbar->SlideWithIdle(); + return KErrNone; + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::AdjustButton +// Adjusts button's properties depending on the toolbar's features. +// ----------------------------------------------------------------------------- +// +void CAknToolbar::AdjustButton( CAknButton& aButton ) + { + // tooltip properties + aButton.SetHelpNoteTimeouts( KToolbarButtonBeforeTimeout, + KToolbarButtonInViewTimeout ); + + aButton.HideTooltipWhenAppFaded( EFalse ); + + // toolbar buttons don't have margins + if ( aButton.UsesDefaultMargins() ) + { + TMargins8 margins; + margins.SetAllValuesTo( 0 ); + aButton.SetMargins( margins ); + } + + // remove frame graphics if the current toolbar mode doesn't support them + if ( ( iFlags & KAknToolbarSmall ) || + ( iFlags & KAknToolbarNoBackground ) ) + { + aButton.SetButtonFlags( aButton.ButtonFlags() | KAknButtonNoFrame ); + } + + // force frame graphics for fixed toolbar button + if ( iFlags & KAknToolbarFixed ) + { + aButton.UseMaskedDraw( ETrue ); + aButton.SetFrameAndCenterIds( KAknsIIDQgnFrSctrlButton, + KAknsIIDQgnFrSctrlButtonCenter, + KAknsIIDQgnFrSctrlButtonPressed, + KAknsIIDQgnFrSctrlButtonCenterPressed, + KAknsIIDQgnFrSctrlButton, + KAknsIIDQgnFrSctrlButtonCenter, + KAknsIIDQgnFrSctrlButtonPressed, + KAknsIIDQgnFrSctrlButtonCenterPressed, + KAknsIIDQgnFrSctrlButton, + KAknsIIDQgnFrSctrlButtonCenter ); + + // Touch area tuning - in fixed toolbar only such events + // that hit to touch rect + aButton.CheckHitArea(); + } + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::AdjustAllButtons +// Adjusts all buttons' properties depending on the toolbar's features. +// ----------------------------------------------------------------------------- +// +void CAknToolbar::AdjustAllButtons() + { + for ( TInt i = 0; i < iItems.Count(); ++i ) + { + if ( iItems[i]->ControlType() == EAknCtButton || + iItems[i]->ControlType() == EAknCtToolbarExtension ) + { + AdjustButton( *static_cast(iItems[i]->Control() ) ); + } + } + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::SetOrdinalPositions +// Adjusts toolbar's and overlying dialog's window positions so that dialog is +// displayed on top of the toolbar. +// ----------------------------------------------------------------------------- +// +void CAknToolbar::SetOrdinalPositions() const + { + TBool isDisplayed = CEikonEnv::Static()->EikAppUi()->IsDisplayingMenuOrDialog(); + CCoeControl* ctrl = NULL; + RDrawableWindow* ctrlWindow = NULL; + RDrawableWindow* childWindow = NULL; + + if ( !isDisplayed ) + { + CEikMenuBar* menuBar = NULL; + TVwsViewId viewId; + TInt err = iAvkonViewAppUi->GetActiveViewId( viewId ); + if ( err == KErrNone && viewId.iAppUid != viewId.iViewUid ) + { + // Application has active view + CAknView* view = iAvkonViewAppUi->View( viewId.iViewUid ); + if ( view ) + { + ctrl = menuBar = view->CAknView::MenuBar(); + } + } + else + { + ctrl = menuBar = iEikonEnv->AppUiFactory()->MenuBar(); + } + + if ( menuBar ) + { + isDisplayed = menuBar->IsDisplayed(); + } + if ( isDisplayed ) + { + // if menuBar returns ETrue from IsDisplayed, it means it has a menu + // pane + ctrlWindow = menuBar->MenuPane()->DrawableWindow(); + + if ( menuBar->MenuPane()->CascadeMenuPane() ) + { + // submenu has a submenu + if ( menuBar->MenuPane()->CascadeMenuPane()->CascadeMenuPane() ) + { + ctrlWindow = menuBar->MenuPane()->CascadeMenuPane()->DrawableWindow(); + childWindow = + menuBar->MenuPane()->CascadeMenuPane()->CascadeMenuPane()->DrawableWindow(); + } + else + { + childWindow = + menuBar->MenuPane()->CascadeMenuPane()->DrawableWindow(); + } + } + } + } + else + { + ctrl = CCoeEnv::Static()->AppUi()->TopFocusedControl(); + + if ( ctrl ) + { + CEikDialog* dialog = ctrl->MopGetObject( dialog ); + + if ( dialog ) + { + if ( dialog->DrawableWindow() ) + { + TInt flag = dialog->DialogFlags(); + + if( !( flag & EEikDialogFlagFillScreen ) && + !( flag & EEikDialogFlagFillAppClientRect ) ) + { + ctrlWindow = dialog->DrawableWindow(); + } + } + } + else + { + CEikMenuBar* ctrlMenu = ctrl->MopGetObject( ctrlMenu ); + + if ( ctrlMenu && ctrlMenu->IsDisplayed() ) + { + ctrlWindow = ctrlMenu->MenuPane()->DrawableWindow(); + ctrl = ctrlMenu; + if ( ctrlMenu->MenuPane()->CascadeMenuPane() ) + { + childWindow = ctrlMenu->MenuPane()->CascadeMenuPane()->DrawableWindow(); + } + } + } + } + } + // Menupane or dialog most probably has softkeys so we need to push + // the control first and then softkeys so that a possible pointer + // capture still works. + if ( ctrlWindow ) + { + CEikCba* cba = ctrl->MopGetObject( cba ); + + TBool ctrlFaded = ctrlWindow->IsFaded(); + TBool childFaded = EFalse; + TBool cbaFaded = EFalse; + + if ( childWindow ) + { + childFaded = childWindow->IsFaded(); + } + if ( cba && cba->DrawableWindow() ) + { + cbaFaded = cba->DrawableWindow()->IsFaded(); + } + + if ( !ctrlFaded ) + { + ctrlWindow->SetOrdinalPosition( 0 ); + } + + // Set possible child in front of parent + if ( childWindow && !childFaded ) + { + childWindow->SetOrdinalPosition( 0 ); + } + + if ( cba && cba->DrawableWindow()&& !cbaFaded ) + { + cba->DrawableWindow()->SetOrdinalPosition( 0 ); + } + } + } + + +// ----------------------------------------------------------------------------- +// CAknToolbar::HideItemsAndDrawOnlyBackground +// Hides/Unhides toolbar items temporarily. When called with ETrue toolbar draws +// just background in landscape and is hidden in portrait. Calling with EFalse +// returns the situation to normal. +// ----------------------------------------------------------------------------- +// +EXPORT_C void CAknToolbar::HideItemsAndDrawOnlyBackground( TBool aHide ) + { + __ASSERT_DEBUG( ( iFlags & KAknToolbarFixed ), User::Invariant() ); + + if ( aHide ) + { + if ( iFlags & KAknToolbarDefault && !( iInternalFlags.IsSet( EItemsHidden ) ) ) + { + iInternalFlags.Set( EDefaultToolbar ); + } + iInternalFlags.Set( EItemsHidden ); + iFlags |= KAknToolbarDefault; + HandleResourceChange( KEikDynamicLayoutVariantSwitch ); + UpdateControlVisibility(); + } + else + { + if ( !( iInternalFlags.IsSet( EItemsHidden ) ) && CountComponentControls() > 0 ) + { + return; + } + TInt messageType( KEikDynamicLayoutVariantSwitch ); + //defualt property should not be given up + if ( !iInternalFlags.IsSet( EDefaultToolbar ) ) + { + iFlags &= ~KAknToolbarDefault; + } + + if ( !Layout_Meta_Data::IsLandscapeOrientation() && iInternalFlags.IsSet( EDefaultToolbar ) ) + { + messageType = KAknToolbarSetHiddenAndDrawBackground; + } + else + { + // Clearing this temporarily, it gets setted again from HandleResourceChange + iInternalFlags.Clear( EShown ); + } + iInternalFlags.Set( ESwitchForItemsHidden ); + HandleResourceChange( messageType ); + // Clear this after HandleResourceChange so that correct method + // for toolbar showing is chosen + if ( iInternalFlags.IsSet( EItemsHidden ) ) + { + iInternalFlags.Clear( EItemsHidden ); + } + iInternalFlags.Clear( EItemsHiddenWithPriority ); + UpdateControlVisibility(); + iInternalFlags.Clear( ESwitchForItemsHidden ); + iInternalFlags.Clear( EDefaultToolbar ); + } + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::HideItemsAndDrawOnlyBackground +// Hides/Unhides toolbar items temporarily. When called with ETrue toolbar draws +// just background with the window priority defined in aPriority. +// ----------------------------------------------------------------------------- +// +EXPORT_C void CAknToolbar::HideItemsAndDrawOnlyBackground( TBool aHide, TInt aPriority ) + { + if ( aHide ) + { + if ( iInternalFlags.IsSet( EShown ) ) + { + iInternalFlags.Set( EItemsHiddenWithPriority ); + iDrawingPriority = aPriority; + } + else if ( aPriority != DrawableWindow()->OrdinalPriority() ) + { + DrawableWindow()->SetOrdinalPosition( 0, aPriority ); + } + } + HideItemsAndDrawOnlyBackground( aHide ); + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::SetSkinBackgroundId +// Define new fixed toolbar background theme ID. +// ----------------------------------------------------------------------------- +// +EXPORT_C void CAknToolbar::SetSkinBackgroundId( const TAknsItemID& aIID ) + { + iBgIID = aIID; + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::UpdateControlVisibility +// Other details are commented in header +// ----------------------------------------------------------------------------- +// +void CAknToolbar::UpdateControlVisibility() + { + for ( TInt ii = 0; ii < iItems.Count(); ii++ ) + { + CAknToolbarItem* item = iItems[ii]; + TBool makeVisible = iInternalFlags.IsSet( EShown ) + && ( ToolbarVisibleIndexByControl( item->Control() ) >= 0 ); + item->Control()->MakeVisible( makeVisible ); + } + } + +// ----------------------------------------------------------------------------- +// CAknToolbar::UpdateItemTooltipPosition() +// Update items tooltip position +// ----------------------------------------------------------------------------- +// +void CAknToolbar::UpdateItemTooltipPosition() + { + //reset position of button tooltip + TPoint centerPos = static_cast + ( iEikonEnv->AppUiFactory() )->ClientRect().Center(); + CAknButton::TTooltipPosition tooltipPosition; + if ( iOrientation == EAknOrientationHorizontal ) + { + if ( Position().iY > centerPos.iY ) + { + tooltipPosition = CAknButton::EPositionTop; + } + else + { + tooltipPosition = CAknButton::EPositionBottom; + } + } + else + { + if ( Position().iX > centerPos.iX ) + { + tooltipPosition = CAknButton::EPositionLeft; + } + else + { + tooltipPosition = CAknButton::EPositionRight; + } + } + for ( TInt ii = 0; ii < iItems.Count(); ++ii ) + { + // This assumes that every control in touch pane is button + CAknToolbarItem* item = iItems[ii]; + if ( item->ControlType() == EAknCtButton || + item->ControlType() == EAknCtToolbarExtension ) + { + CAknButton* button = static_cast( item->Control() ); + button->SetTooltipPosition( tooltipPosition ); + } + } + + } +// End of file