FCL/sf/mw/classicui: comparison uifw/EikStd/coctlsrc/EIKMENUP.CPP

equal deleted inserted replaced

-:aecbbf00d063
+:d48ab3b357f1
 /*
-* Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).
+* Copyright (c) 2002-2010 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".
 #include <aknconsts.h>
 #include <avkon.mbg>
 #include <AknsDrawUtils.h>
 #include <AknsFrameBackgroundControlContext.h>
 #include <AknBidiTextUtils.h>
-#include <AknMarqueeControl.h>
 #include <skinlayout.cdl.h>
 #include <aknlayoutscalable_avkon.cdl.h>
 #include <AknLayoutFont.h>
 #include <AknsUtils.h>
 #include <AknIconUtils.h>
 #include <aknappui.h>
-#include <AknsEffectAnim.h>
-#include <systemwarninglevels.hrh>
 #include <layoutmetadata.cdl.h>
 #include <AknStatuspaneUtils.h>
 #include <aknCharMap.h>
 #include <gfxtranseffect/gfxtranseffect.h> //For transition effects
 #include <akntranseffect.h> //For transition effects
 #include <akntransitionutils.h> // SetAllParents method
 #include <featmgr.h>
-#include <hal.h>
 #include <avkondomainpskeys.h>
 #include <e32property.h>
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-#include <aknlistboxtfxinternal.h> // LISTBOX EFFECTS IMPLEMENTATION
-#include <aknlistloadertfx.h>
-#include <aknlistboxtfx.h>
-#endif // RD_UI_TRANSITION_EFFECTS_LIST
 #include <touchfeedback.h>
 #include <AknTasHook.h>
 #include <aknphysics.h>
 #include <aknphysicsobserveriface.h>
 * CEikmenuPane is responsible for data members of this class.
 *
 * Extension now contains menu/submenu highlight animation functionality.
 */
 NONSHARABLE_CLASS( CEikMenuPaneExtension ):
-public CActive,
+public CBase,
-public MCoeForegroundObserver,
-public MAknsEffectAnimObserver,
 public MCoeControlObserver,
 public MAknPhysicsObserver
 {
 public:
-enum TFlag
-{
-/**
-* If set, animation creation is attempted. If not set, animation will
-* never be created.
-*/
-EFlagUseAnimation = 0
-};
-enum TScreen
-{
-EQhdHeight = 360,
-EQhdWidth = 640
-};
 CEikMenuPaneExtension();
 ~CEikMenuPaneExtension();
 void ConstructL( CEikMenuPane* aControl );
-void CreateAnimation();
-void NoAnimIfError( TInt aError );
-void UseNoAnimation();
-void FocusGained();
-void FocusLost();
-void HandleLayoutSwitch();
-void ChangeHighlightBackground();
 void MenuClosed();
 void ConstructMenuSctRowL( TDes& aSpecialChars, TInt aResourceId );
 void ConstructMenuSctRowFromDialogL( TDes& aSpecialChars, TInt aResourceId );
 TBool HighlightTimerActive() const;
 void ChangePosition( TPointerEvent& aPointerEvent );
 void CalculateParentEvent( const TPointerEvent& aPointerEvent,
 TPointerEvent& aParentEvent );
-TRect GetBackgroundRect( const TRect& aWindowRect ) const;
-static void AdjustPopupLayoutData( TAknWindowLineLayout& aListScrollPaneLayout );
-const TAknLayoutText GetMenuItemTextLayout(const TRect& aItemRect, TBool cascade);
-public: // Implementation of MCoeForegroundObserver
-void HandleGainingForeground();
-void HandleLosingForeground();
-public: // Implementation of MAknsEffectAnimObserver
-void AnimFrameReady( TInt aError, TInt );
 void HandleControlEventL(CCoeControl* aControl,TCoeEvent aEventType);
-protected: // CActive overloads
-void DoCancel();
-void RunL();
-private: // New internal methods
-void Play();
-TBool DrawHighlightBackground( CFbsBitGc& aGc );
-void PostDeleteAnimation();
-void CreateAnimationL( const TSize& aHighlightSize );
-void DoResizeL( const TSize& aHighlightSize, TBool aAboutToStart );
 public:
 void ImmediateFeedback( TTouchLogicalFeedback aType,
 TTouchFeedbackType aFbType );
 public:
 void StartCascadeMenuAppearTransition();
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-void CalcItemSize( MAknListBoxTfxInternal* transApi ) const;
-#endif
 /**
 * Prepares cascade menu for item specific commands.
 */
-void PrepareCascadeForItemCommands();
+void PrepareCascadeForItemCommandsL();
 /**
 * Returns ETrue if this menu pane belongs to a CS menu.
 *
 * @return ETrue if this menu pane belongs to a CS menu.
 /**
 * Is highlight enabled
 *
 * @return ETrue if highlight is enabled
 */
-TBool  HighlightEnabled();
+TBool HighlightEnabled();
 /**
 * Sets the default highlight to options menu
 *
 */
 void SetDefaultHighlight();
 public: // Data
-TBool iHasIcon;
-TBool iIsPenEnable;
 CFbsBitmap* iCascadeBitmap;
 CFbsBitmap* iCascadeBitmapMask;
 CAknsFrameBackgroundControlContext* iBgContext;
 TInt        iSubMenuWidthIndex;       // index for submenu layout which depends on the text length
 CFbsBitmap* iCheckMarkBitmap;         // bitmap to be drawn if the item has check box set on
 CFbsBitmap* iCheckMarkBitmapMask;     // mask for the above bitmap
 CFbsBitmap* iRadioButtonBitmap;       // bitmap to be drawn if the item has radio button set on
 CFbsBitmap* iRadioButtonBitmapMask;   // mask for the above bitmap
 TBool       iHasRadioGroup;           // is ETrue if submenu contains radio button group.
 TInt        iSelectedRadioButtonItem; // index of the radio button item which is currently selected (one must be selected)
-CCoeControl* iGrabbingCBAComponent;    // component control of CBA which is currently grabbing the pointer
 CEikMenuPane* iControl;
-CAknsEffectAnim* iAnimation;
-/**
-* Stored flags are explained in enumeration TFlags.
-*/
-TBitFlags32 iAnimFlags;
 CAknCharMap* iSct;      // Menu SCT row, created only when needed.
 TBool iSctHighlighted;  // No "normal" menu item can be highlighted if ETrue
 // Pen event related flag indicating whether the (sub)menu pane has
 // already consumed EButton1Down or not. If false,
 TBool iSpecialCharPointed;
 // transition demarcation rectangle for cascaded submenu
 // needs to be mutable since we need to get information from Draw methods
 // (that are declared const)
 mutable TRect iCascadeDRect;
-TBool iTransitionsOn;   // Transitions FtMgr flag on
 TBool iShowCascadeTransition;
 // For later deletion of cascade menu, this allows the transition system
 // to correctly handle the aborted transitions
 CEikMenuPane* iCascadeMenuObject;
 TBool iDraggedOutside;
 TPointerEvent iLastPointerEvent;
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-CWindowGc* iGc;
-#endif
 TInt iItemsThatFitInView;
 TRect iScrollBarRect;
 TRect iSctRect;
-TInt iTotalNumberOfItemsInView; // this value includes partial items
 CIdle* iTaskSwapIdle;
 CRedirectionListener* iRedirectionListener;
-TRect iSBRect;
 RWindow* iMenuPaneWindow; // Not own, used by SCT
 TBool iLaunchCascadeMenu;
 TBool isUpdateScrollDirectly;
 TBool iPressedDown;      // ETrue if pointer is down, otherwise.
 enum TCEikMenuPaneExtensionFlags
 {
 ESingleClickEnabled,
 EHideItemSpecificCommands,
 EContextSensitive,
-EHighlightEnabled
+ESkipScrollbarUpdate,
+EHighlightEnabled,
+EHideViewSpecificCommands,
+EHideMarkAndUnmark,
+EHideItemActionCommands
 };
 /**
 * Menu pane extension flags.
 */
 TBitFlags iFlags;
+/**
+* Cached rectangle occupied by menu items (excluding scrollbar's area).
+*/
+TRect iItemAreaRect;
+/**
+* Cached rectangle occupied by menu items and scrollbar.
+*/
+TRect iMenuAreaRect;
+/**
+* Index of the item were highlight was previously drawn to.
+* Can be KErrNotFound.
+*/
+TInt iHighlightedItem;
+/**
+* Scrollbar's desired visibility. This is calculated in conjunction with
+* menu pane's size and used later on when calculating scrollbar's layout.
+*/
+CEikScrollBarFrame::TScrollBarVisibility iScrollbarVisibility;
 private: // Data
 CPeriodic* iTimer; // timer to launch submenu, own
 CPeriodic* iHighlightTimer; // Timer to adjust pressed down highlight
 TInt iVerticalOffset; // Panning offset
 { return iTopItemIndex; }
 inline void CEikMenuPane::CMenuScroller::SetTopItemIndex(TInt aIndex)
 {
 iTopItemIndex=aIndex;
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-if ( iMenuPane.iExtension )
-{
-iTopItemIndex = aIndex;
-}
-#endif
 }
 inline CIdle* CEikMenuPane::CMenuScroller::Idle() const
 { return iIdle; }
 iVerticalOffset = 0;
 iListTopIndex = 0;
 iLastFeedbackTopItemIndex = 0;
 iPressedDown = EFalse;
 iFlickActive = EFalse;
-TRect rect;
+TRect rect( iMenuPaneRect );
-if ( !iControl->iOwner )
-{
-rect = iMenuPaneRect;
-}
-else
-{
-rect = iControl->Rect();
-}
 TInt itemHeight = iControl->iItemHeight;
 TInt itemsInRect = rect.Height() / itemHeight;
 TInt totalItemHeight = iControl->TotalItemHeight();
 // ---------------------------------------------------------------------------
 //
 void CEikMenuPaneExtension::ViewPositionChanged( const TPoint& aNewPosition,
 TBool aDrawNow,
 TUint /*aFlags*/ )
 {
 _AKNTRACE_FUNC_ENTER;
-if ( !iControl->iItemArray )
+TInt delta = iViewPosition.iY - aNewPosition.iY;
+if ( !iControl->iItemArray || delta == 0 )
 {
 return;
 }
 iListTopIndex = aNewPosition.iY - iViewHeight / 2;
 iListBottomIndex = aNewPosition.iY + iViewHeight - iViewHeight / 2;
-TInt delta = iViewPosition.iY - aNewPosition.iY;
 DoOffset( delta );
 iViewPosition = aNewPosition;
 _AKNTRACE( "iListTopIndex = %d",  iListTopIndex );
 _AKNTRACE( "iListBottomIndex = %d",  iListBottomIndex );
 _AKNTRACE( "delta = %d",  delta );
 _AKNTRACE( "iViewPosition(%d,%d)",  iViewPosition.iX, iViewPosition.iY );
+//here checking the delta whether it is changed.
+//if it is changed,the view must be drawn using the below code.
+if ( delta != 0 )
+{
+aDrawNow = ETrue;
+	}
 if ( aDrawNow )
 {
-TRAP_IGNORE( iControl->DoUpdateScrollBarL() );
+if ( iFlags.IsClear( ESkipScrollbarUpdate ) )
+{
-if ( iControl->iOwner ) // Submenu
+TRAP_IGNORE( iControl->DoUpdateScrollBarL() );
-{
+}
-iControl->DrawNow();
-}
+// Redraw only item area if scrollbar is invisible, otherwise include
-else
+// also scrollbar's area in order to avoid drawdeferred.
-{
+TRect drawRect( iItemAreaRect );
-iControl->DrawNow( TRect( iMenuPaneRect.Size() ) );
-}
+if ( iScrollbarVisibility == CEikScrollBarFrame::EOn )
+{
+drawRect = iMenuAreaRect;
+}
+iControl->DrawNow( drawRect );
 }
 _AKNTRACE_FUNC_EXIT;
 }
 // in case there's flicking or panning ongoing and not doing
 // bounce action
 if ( iFlickActive || iPanningActive )
 {
 if ( ( aOffset>0 && iListTopIndex <= listBottomLimit && iListTopIndex >= -iViewHeight ) ||
-	  ( aOffset<0 && iListBottomIndex >= 0 && iListBottomIndex <= listBottomLimit+iViewHeight ) )
+( aOffset<0 && iListBottomIndex >= 0 && iListBottomIndex <= listBottomLimit+iViewHeight ) )
-	{
+{
-	if ( iPhysics )
+if ( iPhysics )
 {
-TTouchFeedbackType feedbackType = ETouchFeedbackVibra;
+switch(iPhysics->OngoingPhysicsAction())
-switch( iPhysics->OngoingPhysicsAction() )
 {
+case CAknPhysics::EAknPhysicsActionBouncing:
 case CAknPhysics::EAknPhysicsActionDragging:
-{
-feedbackType = static_cast<TTouchFeedbackType> ( ETouchFeedbackVibra | ETouchFeedbackAudio );
-}
 case CAknPhysics::EAknPhysicsActionFlicking:
-case CAknPhysics::EAknPhysicsActionBouncing:
+ImmediateFeedback( ETouchFeedbackSensitiveList,
-{
+ETouchFeedbackVibra );
-ImmediateFeedback( ETouchFeedbackSensitiveItem,
-feedbackType );
 break;
-}
 default:
 break;
 }
 }
 	}
 void CEikMenuPaneExtension::PhysicEmulationEnded()
 {
 _AKNTRACE_FUNC_ENTER;
 iFlickActive = EFalse;
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-MAknListBoxTfx* tfxApi = CAknListLoader::TfxApi( iGc );
-if ( tfxApi )
-{
-tfxApi->EnableEffects( ETrue );
-}
-#endif // RD_UI_TRANSITION_EFFECTS_LIST
 _AKNTRACE_FUNC_EXIT;
 }
 TPoint CEikMenuPaneExtension::ViewPosition() const
 {
 // High CActive priority is well argumented because running the active object
 // will result in animation deletion -> results in freeing resources.
 // -----------------------------------------------------------------------------
 //
 CEikMenuPaneExtension::CEikMenuPaneExtension() :
-CActive( EPriorityHigh ),
 // Initialise data members to zero
 iCascadeBitmap( NULL ),
 iCascadeBitmapMask( NULL ),
 iBgContext( NULL ),
 iSubMenuWidthIndex( 1 ),
 iCheckMarkBitmapMask( NULL ),
 iRadioButtonBitmap( NULL ),
 iRadioButtonBitmapMask( NULL ),
 iHasRadioGroup( EFalse ),
 iSelectedRadioButtonItem( KNoSelectedRadioButtonItem ),
-iGrabbingCBAComponent( NULL ),
 iControl( NULL ),
-iAnimation( NULL ),
-iAnimFlags ( 0 ),
 iSct( NULL ),
 iSctHighlighted( EFalse ),
 iSpecialCharPointed( EFalse )
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-,iGc ( NULL )
-#endif // RD_UI_TRANSITION_EFFECTS_LIST
 ,iVerticalOffset( 0 )
 ,iPhysics( NULL )
 ,iListTopIndex( 0 )
 ,iViewHeight( 0 )
 ,iFlickActive( EFalse )
 ,iPanningActive( EFalse )
 ,iFeedback( MTouchFeedback::Instance() )
 ,iLastFeedbackTopItemIndex( 0 )
 {
-iIsPenEnable = AknLayoutUtils::PenEnabled();
+iItemsReadyForPenSelection = !AknLayoutUtils::PenEnabled();
-iItemsReadyForPenSelection = !iIsPenEnable;
 iNextHighlightItem = KErrNotFound;
+iHighlightedItem = KErrNotFound;
 }
 // -----------------------------------------------------------------------------
 // CEikMenuPaneExtension::~CEikMenuPaneExtension
 // Destructor for extension class
 // -----------------------------------------------------------------------------
 //
 CEikMenuPaneExtension::~CEikMenuPaneExtension()
 {
 _AKNTRACE_FUNC_ENTER;
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-if ( CAknListLoader::TfxApiInternal( iGc ) )
-{
-delete iGc;
-}
-#endif
-Cancel(); // Cancel possibly pending request
-// Stop receiving foreground events
-CCoeEnv* env = CCoeEnv::Static();
-env->RemoveForegroundObserver( *this );
 delete iCascadeBitmap;
 iCascadeBitmap = NULL;
 delete iCascadeBitmapMask;
 delete iRadioButtonBitmapMask;
 iRadioButtonBitmapMask = NULL;
 iControl = NULL;
-delete iAnimation;
-iAnimation = NULL;
 delete iSct;
 iSct = NULL;
 delete iCascadeMenuObject;
 //
 void CEikMenuPaneExtension::ConstructL( CEikMenuPane* aControl )
 {
 ASSERT( aControl );
 iControl = aControl;
-iAnimFlags.Set( EFlagUseAnimation ); // Animations are created by default
-CActiveScheduler::Add( this );
 iDraggedOutside = EFalse;
 iLaunchCascadeMenu = EFalse;
 iButtonDownItem = KErrNotFound;
 iTaskSwapIdle = CIdle::NewL( CActive::EPriorityHigh );
 if ( aControl->iOwner == NULL && GfxTransEffect::IsRegistered( aControl ) )
 {
 // Delays submenu opening during appear transitions
 iRedirectionListener = new ( ELeave ) CRedirectionListener( *this );
 }
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-iGc = CAknListLoader::CreateTfxGc( *aControl,
-iControl->iScroller->iTopItemIndex,
-iTotalNumberOfItemsInView );
-#endif // RD_UI_TRANSITION_EFFECTS_LIST
 if ( static_cast<CAknAppUi*>(
 iControl->ControlEnv()->AppUi() )->IsSingleClickCompatible() )
 {
 iFlags.Set( ESingleClickEnabled );
 }
 iBgContext = CAknsFrameBackgroundControlContext::NewL(
 KAknsIIDQsnFrPopup, TRect( 0, 0, 1, 1 ), TRect( 0, 0, 1, 1 ), EFalse );
 }
-// -----------------------------------------------------------------------------
-// CEikMenuPaneExtension::CreateAnimation
-// -----------------------------------------------------------------------------
-//
-void CEikMenuPaneExtension::CreateAnimation()
-{
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-return;
-#else
-if( !iAnimation && iAnimFlags.IsSet( EFlagUseAnimation ) )
-{
-TRect rect = iControl->HighlightRect();
-TRAPD( err, CreateAnimationL( rect.Size() ) );
-if( KErrNone != err )
-{
-// Animation has not been drawn -> no need for repaint
-UseNoAnimation();
-}
-}
-#endif //RD_UI_TRANSITION_EFFECTS_LIST
-}
-// -----------------------------------------------------------------------------
-// CEikMenuPaneExtension::NoAnimIfError
-// -----------------------------------------------------------------------------
-//
-void CEikMenuPaneExtension::NoAnimIfError( TInt aError )
-{
-if( KErrNone != aError )
-UseNoAnimation();
-}
-// -----------------------------------------------------------------------------
-// CEikMenuPaneExtension::UseNoAnimation
-// Falls back to normal highlight rendering.
-// -----------------------------------------------------------------------------
-//
-void CEikMenuPaneExtension::UseNoAnimation()
-{
-delete iAnimation;
-iAnimation = NULL;
-// Do not attempt to create animations in the future
-iAnimFlags.Clear( EFlagUseAnimation );
-// Stop receiving foreground events
-CCoeEnv* env = CCoeEnv::Static();
-env->RemoveForegroundObserver( *this );
-}
 // -----------------------------------------------------------------------------
 // CEikMenuPaneExtension::StartCascadeMenuTimerL
 // Starts the timer for the sub menu launch. Timer is constructed when used for
 // the first time
 iTimer->Start( KCascadeMenuOpenDelay,
 KCascadeMenuOpenDelay,
 TCallBack ( CascadeMenuTimerCallBack, this ) );
 _AKNTRACE_FUNC_EXIT;
 }
 // -----------------------------------------------------------------------------
 // CEikMenuPaneExtension::StopCascadeMenuTimer
 // Stops the timer for the sub menu launch
 // -----------------------------------------------------------------------------
 iControl->RepaintHighlight();
 }
 _AKNTRACE_FUNC_EXIT;
 }
 // -----------------------------------------------------------------------------
 // CEikMenuPaneExtension::HighlightTimerCallBack
 // Callback function of the timer for pressed down highlight
 // -----------------------------------------------------------------------------
 //
 //
 void CEikMenuPaneExtension::ChangePosition( TPointerEvent& aPointerEvent )
 {
 if ( !iControl->iSBFrame )
 {
-iControl->CreateScrollBarFrame();
+return;
 }
-TRect scrollBarRect = iControl->iSBFrame->VerticalScrollBar()->Rect();
-TPoint scrollerTl = scrollBarRect.iTl;
+TRect scrollBarRect( iControl->iSBFrame->VerticalScrollBar()->Rect() );
-TPoint scrollerBr = scrollBarRect.iBr;
+TPoint scrollerTl( scrollBarRect.iTl );
+TPoint scrollerBr( scrollBarRect.iBr );
 TRect gapRect;
 // For layout that left to right
 if ( !AknLayoutUtils::LayoutMirrored() )
 {
 TPoint rectTl( scrollerBr.iX, iControl->Rect().iTl.iY );
 //
 void CEikMenuPaneExtension::CalculateParentEvent( const TPointerEvent& aPointerEvent,
 TPointerEvent& aParentEvent )
 {
 aParentEvent.iModifiers = aPointerEvent.iModifiers;
-TPoint subPos = iControl->PositionRelativeToScreen();
+TPoint subPos = iControl->Position();
-TPoint ownerPos = iControl->iOwner->PositionRelativeToScreen();
+TPoint ownerPos = iControl->iOwner->Position();
 aParentEvent.iPosition.SetXY (
 aPointerEvent.iPosition.iX + subPos.iX - ownerPos.iX,
 aPointerEvent.iPosition.iY + subPos.iY - ownerPos.iY);
 aParentEvent.iType = aPointerEvent.iType;
 }
-// -----------------------------------------------------------------------------
-// CEikMenuPaneExtension::GetBackgroundRect
-// Get background rect for landscape mode of menu pane.
-// -----------------------------------------------------------------------------
-//
-TRect CEikMenuPaneExtension::GetBackgroundRect( const TRect& aWindowRect ) const
-{
-return aWindowRect;
-}
-// -----------------------------------------------------------------------------
-// CEikMenuPaneExtension::AdjustPopupLayoutData
-// Adjust popup layout data for main menu pane in landscape mode
-// -----------------------------------------------------------------------------
-//
-void CEikMenuPaneExtension::AdjustPopupLayoutData( TAknWindowLineLayout& aListScrollPaneLayout )
-{
-TRect screenRect;
-AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EScreen, screenRect );
-AknLayoutUtils::TAknCbaLocation cbaPosition = AknLayoutUtils::CbaLocation();
-if ( screenRect.Width() == EQhdWidth && screenRect.Height() == EQhdHeight
-&& cbaPosition == AknLayoutUtils::EAknCbaLocationBottom )
-{
-if ( !AknLayoutUtils::LayoutMirrored() )
-{
-aListScrollPaneLayout.ir -= 32;
-}
-else
-{
-aListScrollPaneLayout.il -= 32;
-}
-}
-}
-// -----------------------------------------------------------------------------
-// CEikMenuPaneExtension::GetMenuItemTextLayout
-// Get Layout of menu item text.
-// -----------------------------------------------------------------------------
-//
-const TAknLayoutText CEikMenuPaneExtension::GetMenuItemTextLayout(const TRect& aItemRect, TBool cascade)
-{
-TAknTextLineLayout menuTextLayout;
-if ( !iControl->iOwner )
-{
-menuTextLayout = AknLayoutScalable_Avkon::list_single_pane_t1_cp2( cascade ? 3 : 0 ).LayoutLine();
-}
-else
-{
-if ( iHasIcon )
-{
-menuTextLayout = TAknTextLineLayout( AknLayoutScalable_Avkon::list_single_popup_submenu_pane_t1( 1 ).LayoutLine() );
-}
-else
-{
-menuTextLayout = TAknTextLineLayout( AknLayoutScalable_Avkon::list_single_popup_submenu_pane_t1( 0 ).LayoutLine() );
-}
-}
-TAknLayoutText textRect;
-textRect.LayoutText( aItemRect, menuTextLayout );
-return textRect;
-}
-// -----------------------------------------------------------------------------
-// CEikMenuPaneExtension::FocusGained
-// The owning control has gained focus -> animation should be continued.
-// -----------------------------------------------------------------------------
-//
-void CEikMenuPaneExtension::FocusGained()
-{
-Play();
-}
-// -----------------------------------------------------------------------------
-// CEikMenuPaneExtension::FocusLost
-// The owning control has lost focus -> no running animation (even if the
-// control is partially visible).
-// -----------------------------------------------------------------------------
-//
-void CEikMenuPaneExtension::FocusLost()
-{
-if( iAnimation )
-{
-NoAnimIfError( iAnimation->Pause() );
-}
-}
-// -----------------------------------------------------------------------------
-// CEikMenuPaneExtension::HandleLayoutSwitch
-// -----------------------------------------------------------------------------
-//
-void CEikMenuPaneExtension::HandleLayoutSwitch()
-{
-if( iAnimation ) // Animation exists -> try to resize
-{
-TRect rect( iControl->HighlightRect() );
-// Resize animation
-TBool aboutToStart = ETrue;
-if( iAnimation->State() == EAknsAnimStateStopped )
-aboutToStart = EFalse;
-TRAPD( err, DoResizeL( rect.Size(), aboutToStart ) );
-NoAnimIfError( err );
-}
-}
-// -----------------------------------------------------------------------------
-// CEikMenuPaneExtension::ChangeHighlightBackground
-// -----------------------------------------------------------------------------
-//
-void CEikMenuPaneExtension::ChangeHighlightBackground()
-{
-// Every time the current list item is changed we need to change the
-// animation input layer (animated element is the highlight bacground that
-// can differ between highlight positions).
-if( iAnimation )
-{
-if( iAnimation->State() == EAknsAnimStateStopped  )
-{
-// Input layers don't exist when stopped or finished. We need to
-// resize to create the input layers and to update the output
-// layer.
-TRAPD( err, DoResizeL( iAnimation->Size(), EFalse ) );
-NoAnimIfError( err );
-}
-else // Either paused, running or finished
-{
-// Update the highlight background
-if( iAnimation->InputRgbGc() )
-DrawHighlightBackground( *iAnimation->InputRgbGc() );
-// We need to update the output frame (otherwise the highlight
-// would drawn with the old output before the next new animation
-// frame).
-NoAnimIfError( iAnimation->UpdateOutput() );
-}
-}
-}
 // -----------------------------------------------------------------------------
 // CEikMenuPaneExtension::MenuClosed
 // -----------------------------------------------------------------------------
 //
 void CEikMenuPaneExtension::MenuClosed()
 {
 _AKNTRACE_FUNC_ENTER;
-delete iAnimation;
-iAnimation = NULL;
-CCoeEnv* env = CCoeEnv::Static();
-env->RemoveForegroundObserver( *this );
-iAnimFlags.Set( EFlagUseAnimation );
 delete iSct;
 iSct = NULL;
 iSctHighlighted = EFalse;
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-iSctRect = TRect::EUninitialized;
-#endif
 if ( iCba )
 {
 iCba = NULL;
 }
 {
 iRedirectionListener->Closing();
 }
 iFlags.Clear( EHideItemSpecificCommands );
+iFlags.Clear( EHideItemActionCommands );
 iFlags.Clear( EContextSensitive );
 iFlags.Clear( EHighlightEnabled );
+iFlags.Clear( EHideViewSpecificCommands );
+iFlags.Clear( EHideMarkAndUnmark );
 _AKNTRACE_FUNC_EXIT;
 }
-// -----------------------------------------------------------------------------
-// CEikMenuPaneExtension::HandleGainingForeground
-// The application has gained foreground -> animation should be continued.
-// -----------------------------------------------------------------------------
-//
-void CEikMenuPaneExtension::HandleGainingForeground()
-{
-// It is safe to start animation in this method because animation is
-// deleted when the menu is closed -> it is not possible that menu receives
-// foreground event while it is not visible and the animation exists.
-// We need to check if the menu has focus (to prevent running nonfocused
-// animation because also the nonfocused menu (menu/submenu) receives
-// foreground events)
-Play();
-}
-// -----------------------------------------------------------------------------
-// CEikMenuPaneExtension::HandleLosingForeground
-// The application lost foreground -> no running animation (even if the
-// application is partially visible).
-// -----------------------------------------------------------------------------
-//
-void CEikMenuPaneExtension::HandleLosingForeground()
-{
-if( iAnimation )
-{
-NoAnimIfError( iAnimation->Stop() );
-}
-}
-// -----------------------------------------------------------------------------
-// CEikMenuPaneExtension::AnimFrameReady
-// -----------------------------------------------------------------------------
-//
-void CEikMenuPaneExtension::AnimFrameReady( TInt aError, TInt )
-{
-if( KErrNone != aError )
-{
-// Animation has failed to run -> schedule the animation for
-// deletion to fall back to normal rendering.
-PostDeleteAnimation();
-}
-else if( iControl ) // Frame ok
-{
-if ( iControl->IsVisible() )
-{
-iControl->RepaintHighlight();
-}
-}
-}
-// -----------------------------------------------------------------------------
-// CEikMenuPaneExtension::DoCancel
-// -----------------------------------------------------------------------------
-//
-void CEikMenuPaneExtension::DoCancel()
-{
-// Required method, but not needed
-}
-// -----------------------------------------------------------------------------
-// CEikMenuPaneExtension::RunL
-// Postponed animation deletion is done here
-// -----------------------------------------------------------------------------
-//
-void CEikMenuPaneExtension::RunL()
-{
-UseNoAnimation();
-}
-// -----------------------------------------------------------------------------
-// CEikMenuPaneExtension::Play
-// -----------------------------------------------------------------------------
-//
-void CEikMenuPaneExtension::Play()
-{
-if( !iAnimation || !iControl->IsFocused() )
-{
-return;
-}
-// No need to start running/finished animation
-if( EAknsAnimStateRunning == iAnimation->State() ||
-EAknsAnimStateFinished == iAnimation->State() )
-{
-return;
-}
-CAknAppUi* aui = static_cast<CAknAppUi*>(CEikonEnv::Static()->AppUi());
-if( !aui->IsForeground() )
-{
-return;
-}
-if( EAknsAnimStatePaused == iAnimation->State() )
-{
-NoAnimIfError( iAnimation->Continue() );
-}
-else if( EAknsAnimStateStopped == iAnimation->State() )
-{
-if( iAnimation->NeedsInputLayer() )
-{
-TRAPD( err, DoResizeL( iAnimation->Size(), ETrue ) );
-NoAnimIfError( err );
-if( KErrNone != err )
-return;
-}
-NoAnimIfError( iAnimation->Start() );
-}
-}
-// -----------------------------------------------------------------------------
-// CEikMenuPaneExtension::DrawHighlightBackground
-// Draws skinned highlight background to the provided graphics context.
-// -----------------------------------------------------------------------------
-//
-TBool CEikMenuPaneExtension::DrawHighlightBackground( CFbsBitGc& aGc )
-{
-// Draw the background under the current highlight. This simplified
-// drawing, we only grab a piece from the list background bitmap.
-MAknsSkinInstance* skin = AknsUtils::SkinInstance();
-return AknsDrawUtils::DrawBackground( skin, iBgContext, iControl, aGc, TPoint(0,0),
-iControl->HighlightRect(),
-KAknsDrawParamRGBOnly );
-}
-// -----------------------------------------------------------------------------
-// CEikMenuPaneExtension::PostDeleteAnimation
-// Schedules the animation for deletion by activating the extension itself.
-// Deletion is postponed because in many error/failure occasions the caller has
-// been animation and direct deletion is possibly not safe (because function
-// stack would return through the deleted object).
-// -----------------------------------------------------------------------------
-//
-void CEikMenuPaneExtension::PostDeleteAnimation()
-{
-TRequestStatus* status = &iStatus;
-User::RequestComplete( status, KErrNone );
-SetActive();
-}
-// -----------------------------------------------------------------------------
-// CEikMenuPaneExtension::CreateAnimationL
-// -----------------------------------------------------------------------------
-//
-void CEikMenuPaneExtension::CreateAnimationL( const TSize& aHighlightSize )
-{
-// Create animation
-CCoeEnv* env = CCoeEnv::Static();
-env->AddForegroundObserverL( *this );
-delete iAnimation;
-iAnimation = NULL;
-iAnimation = CAknsEffectAnim::NewL( this );
-TBool ok = iAnimation->ConstructFromSkinL( KAknsIIDQsnAnimList );
-if( !ok ) // Animation for the ID was not found from the skin
-{
-User::Leave( KErrNotFound );
-}
-DoResizeL( aHighlightSize, ETrue );
-Play();
-}
-// -----------------------------------------------------------------------------
-// CEikMenuPaneExtension::DoResizeL
-// -----------------------------------------------------------------------------
-//
-void CEikMenuPaneExtension::DoResizeL(
-const TSize& aHighlightSize, TBool aAboutToStart )
-{
-iAnimation->BeginConfigInputLayersL( aHighlightSize, aAboutToStart );
-if( iAnimation->InputRgbGc() )
-DrawHighlightBackground( *iAnimation->InputRgbGc() );
-iAnimation->EndConfigInputLayersL();
-}
 // -----------------------------------------------------------------------------
 // CEikMenuPaneExtension::ConstructMenuSctRowL
 // Creates a special characters row to be used in edit menu.
 // -----------------------------------------------------------------------------
 iSct->ConstructMenuSctRowL(aResourceId);
 iSct->SetBuffer( aSpecialChars );
 if ( renew && iMenuPaneWindow && iControl )
 {
 iSct->SetContainerWindowL( *iControl );
-if ( AknLayoutUtils::PenEnabled() )
+iSct->SetGloballyCapturing( ETrue );
-{
+iSct->SetPointerCapture( ETrue );
-iSct->SetGloballyCapturing( ETrue );
-iSct->SetPointerCapture( ETrue );
-}
 }
 _AKNTRACE_FUNC_EXIT;
 }
 // -----------------------------------------------------------------------------
 iSct->ConstructMenuSctRowFromDialogL(aResourceId);
 iSct->SetBuffer( aSpecialChars );
 if ( renew && iMenuPaneWindow && iControl)
 {
 iSct->SetContainerWindowL( *iControl );
-if ( AknLayoutUtils::PenEnabled() )
+iSct->SetGloballyCapturing( ETrue );
-{
+iSct->SetPointerCapture( ETrue );
-iSct->SetGloballyCapturing( ETrue );
-iSct->SetPointerCapture( ETrue );
-}
 }
 }
 // -----------------------------------------------------------------------------
 // CEikMenuPaneExtension::HandleControlEventL
 // -----------------------------------------------------------------------------
 //
 void CEikMenuPaneExtension::HandleControlEventL(CCoeControl* /*aControl*/,TCoeEvent aEventType)
 {
 _AKNTRACE_FUNC_ENTER;
-if ( AknLayoutUtils::PenEnabled() )
+if ( aEventType == EEventStateChanged )
 {
-if(aEventType == EEventStateChanged)
+// Something has been selected from CharMap
-{
+iSpecialCharPointed = ETrue;
-// Something has been selected from CharMap
-iSpecialCharPointed = ETrue;
-}
 }
 _AKNTRACE( "aEventType = %d", aEventType );
 _AKNTRACE_FUNC_EXIT;
 }
 //
 void CEikMenuPaneExtension::ImmediateFeedback(
 TTouchLogicalFeedback aType,
 TTouchFeedbackType aFbType  = TTouchFeedbackType( ETouchFeedbackAudio |
 ETouchFeedbackVibra ))
 {
-if ( iFeedback )
+if( iFeedback && AknLayoutUtils::PenEnabled() )
 {
 iFeedback->InstantFeedback( iControl, aType, aFbType, TPointerEvent() );
 }
 }
 // -----------------------------------------------------------------------------
-// CEikMenuPaneExtension::PrepareCascadeForItemCommands
+// CEikMenuPaneExtension::PrepareCascadeForItemCommandsL
 // -----------------------------------------------------------------------------
 //
-void CEikMenuPaneExtension::PrepareCascadeForItemCommands()
+void CEikMenuPaneExtension::PrepareCascadeForItemCommandsL()
 {
 if ( iFlags.IsSet( ESingleClickEnabled )
 && iControl->iOwner
 && iControl->iOwner->iExtension )
 {
 const TBitFlags& ownerFlags( iControl->iOwner->iExtension->iFlags );
 if ( ownerFlags.IsSet( EContextSensitive ) )
 {
 iFlags.Set( EContextSensitive );
 }
-else if ( ownerFlags.IsSet( EHideItemSpecificCommands ) )
+else
 {
-iControl->SetItemCommandsDimmed();
+if ( ownerFlags.IsSet( EHideItemSpecificCommands ) )
+{
+iControl->SetItemCommandsStateL( ETrue );
+}
+if ( ownerFlags.IsSet( EHideItemActionCommands ) )
+{
+iControl->SetItemActionsStateL( ETrue );
+}
 }
 }
 }
 //
 EXPORT_C CEikMenuPane::~CEikMenuPane()
 {
 _AKNTRACE_FUNC_ENTER;
 AKNTASHOOK_REMOVE();
+if ( iIsDeleted )
+{
+*iIsDeleted = ETrue;
+iIsDeleted = NULL;
+}
 CloseCascadeMenu();
 if ( !ItemArrayOwnedExternally() )
 {
 delete iItemArray;
 iItemArray  = NULL;
 iEditMenuObserver = aEditMenuObserver;
 CheckCreateScrollerL();
 CheckCreateExtensionL();
-iExtension->iTransitionsOn = FeatureManager::FeatureSupported( KFeatureIdUiTransitionEffects );
 CreateWindowL( iCoeEnv->RootWin() );
 EnableWindowTransparency();
 SetAllowStrayPointers();
 EnableDragEvents();
-TAknWindowLineLayout menuLineLayout;
+iItemHeight = CalculateItemHeight();
-if ( iOwner ) // submenu
-{
-menuLineLayout = AknLayoutScalable_Avkon::list_single_popup_submenu_pane( 0 ).LayoutLine();
-}
-else
-{
-menuLineLayout = AknLayoutScalable_Avkon::list_single_pane_cp2( 0 ).LayoutLine();
-}
-TRect windowRect = Rect();
-TAknLayoutRect menuLayoutRect;
-menuLayoutRect.LayoutRect( windowRect, menuLineLayout );
-iItemHeight = menuLayoutRect.Rect().Height();
 if ( iExtension->iSct )
 {
 RWindow* window = (RWindow*)this->DrawableWindow();
 iExtension->iMenuPaneWindow = window;
 iExtension->iSct->SetContainerWindowL( *this );
-if ( AknLayoutUtils::PenEnabled() )
+// This is effectively the same as CCoeControl::EnableDragEvents()
-{
+// which is protected.
-// This is effectively the same as CCoeControl::EnableDragEvents()
+window->PointerFilter( EPointerFilterDrag, 0 );
-// which is protected.
+iExtension->iSct->SetGloballyCapturing( ETrue );
-window->PointerFilter( EPointerFilterDrag, 0 );
+iExtension->iSct->SetPointerCapture( ETrue );
-iExtension->iSct->SetGloballyCapturing( ETrue );
+iExtension->iSct->SetObserver(iExtension);
-iExtension->iSct->SetPointerCapture( ETrue );
-iExtension->iSct->SetObserver(iExtension);
-}
 }
 if ( iOwner ) // submenu
 {
 SetPointerCapture( ETrue );
 RWindow* window = &Window();
 if( window == NULL )
 User::Leave( KErrNoMemory );
 Window().SetOrdinalPosition( 0 );
 Window().SetPointerGrab( ETrue );
 SetGloballyCapturing( ETrue );
 iExtension->iPhysics->UpdateViewWindowControl();
 _AKNTRACE_FUNC_EXIT;
 delete iItemArray;
 iItemArray = NULL;
 }
 CreateItemArrayL();
-TAknWindowLineLayout menuLineLayout;
+iItemHeight = CalculateItemHeight();
-if ( iOwner ) // submenu
-{
-menuLineLayout = AKN_LAYOUT_WINDOW_list_single_popup_submenu_pane( 0, 0 );
-}
-else
-{
-menuLineLayout = AKN_LAYOUT_WINDOW_list_single_popup_menu_pane( 0 );
-}
-TRect windowRect = Rect();
-TAknLayoutRect menuLayoutRect;
-menuLayoutRect.LayoutRect( windowRect, menuLineLayout );
-iItemHeight = menuLayoutRect.Rect().Height();
 CheckCreateScrollerL();
 CheckCreateExtensionL();
 const TInt count=aReader.ReadInt16();
 if (iEditMenuObserver)
 {
 iEditMenuObserver->DynInitMenuPaneL( aCascadeMenuId, iCascadeMenuPane );
 }
-iCascadeMenuPane->iExtension->PrepareCascadeForItemCommands();
+if ( iExtension->iFlags.IsSet( CEikMenuPaneExtension::EHideMarkAndUnmark ) )
+{
+TInt pos;
+if ( iCascadeMenuPane->MenuItemExists( EAknCmdMark, pos ) )
+{
+iCascadeMenuPane->SetItemDimmed( EAknCmdMark, ETrue );
+}
+if ( iCascadeMenuPane->MenuItemExists( EAknCmdUnmark, pos ) )
+{
+iCascadeMenuPane->SetItemDimmed( EAknCmdUnmark, ETrue );
+}
+}
+iCascadeMenuPane->iExtension->PrepareCascadeForItemCommandsL();
 iCascadeMenuPane->iExtension->EnableHighlight( EFalse );
 iCascadeMenuPane->FilterDimmedItems();
 // cascade menu launch animation
 if ( iExtension->iRedirectionListener )
 else
 {
 iExtension->StartCascadeMenuAppearTransition();
 }
-if( AknLayoutUtils::PenEnabled() )
+TTouchLogicalFeedback fbLogicalType = ETouchFeedbackPopUp;
-{
+if ( CAknTransitionUtils::TransitionsEnabled( AknTransEffect::EComponentTransitionsOff ) )
-TTouchLogicalFeedback fbLogicalType = ETouchFeedbackPopUp;
+{
-if ( CAknTransitionUtils::TransitionsEnabled( AknTransEffect::EComponentTransitionsOff ) )
+fbLogicalType = ETouchFeedbackSubMenuOpened;
-{
+}
-fbLogicalType = ETouchFeedbackPopupOpen;
+iExtension->ImmediateFeedback( fbLogicalType,
-}
-iExtension->ImmediateFeedback( fbLogicalType,
 ETouchFeedbackVibra );
-}
 _AKNTRACE_FUNC_EXIT;
 }
 // -----------------------------------------------------------------------------
 // CEikMenuPane::CalculateSizeAndPosition
 if ( iItemArray )
 {// Min size is for 1 item even if menu is empty
 numItemsInPane = iItemArray->Count();
 }
-if ( iExtension->iSct )
+if ( iExtension && iExtension->iSct )
 {
 numItemsInPane++;
 }
-TInt maxNumItemsInMenu = AknLayoutScalable_Avkon::
-list_single_pane_cp2_ParamLimits().LastRow() + 1;
-TInt maxNumItemsInSubMenu = AknLayoutScalable_Avkon::
-list_single_popup_submenu_pane_ParamLimits().LastRow() + 1;
 TInt maxItemsInView = NumberOfItemsThatFitInView();
 if (iExtension && iExtension->iSct)
 {
 CreateScrollBarFrame();
 iExtension->iPressedDown = EFalse;
 iExtension->SetOffset( 0 );
-iExtension->iHasIcon = MenuHasIcon();
-if ( iExtension->iTransitionsOn )
-{
-CAknTransitionUtils::SetAllParents( this );
-}
 const TSize screenSize( iEikonEnv->EikAppUi()->ApplicationRect().Size() );
 CEikCba *cba = 0;
 MopGetObject(cba);
 && iCoeEnv->LastEvent().Key()->iCode == EKeyCBA1 )
 {
 SetDefaultHighlight();
 }
-TRect rect( CalculateSizeAndPosition() );
+SetRect( CalculateSizeAndPosition() );
-TPoint newPos( rect.iTl );
-TSize menuSize( rect.Size() );
-SetExtent( newPos, menuSize );
 // We need to set the background context when calling create for the
 // first time. Otherwise iExtension->iBgContext would have tiny
 // rectangles and grabbing the highlight background would produce
 // white.
 UpdateBackgroundContext( Rect() );
-// The extent has been set. This is the first safe point in code to
-// construct animations (because before this highlight related layout code
-// will produce invalid results
-if( iExtension )
-{
-// Creates animation only if it does not exist
-iExtension->CreateAnimation();
-}
 // Initialize physics engine
 TRAP_IGNORE ( iExtension->InitPhysicsL() );
 MakeVisible(ETrue);
 SetFocus(ETrue);
 TAknLayoutRect topLeft;
 TAknLayoutRect bottomRight;
 TAknsItemID frameIID;
 TAknsItemID frameCenterIID;
-TRect backgroundRect( iExtension->GetBackgroundRect( aWindowRect ) );
 if( iOwner ) //for sub menu
 {
 topLeft.LayoutRect( aWindowRect, SkinLayout::Submenu_skin_placing_Line_2() );
 bottomRight.LayoutRect( aWindowRect, SkinLayout::Submenu_skin_placing_Line_5() );
 frameIID = KAknsIIDQsnFrPopupSub;
 frameCenterIID = KAknsIIDQsnFrPopupCenterSubmenu;
 }
 else
 {
-topLeft.LayoutRect( backgroundRect, SkinLayout::Popup_windows_skin_placing__frame_general__Line_2() );
+topLeft.LayoutRect( aWindowRect, SkinLayout::Popup_windows_skin_placing__frame_general__Line_2() );
-bottomRight.LayoutRect( backgroundRect, SkinLayout::Popup_windows_skin_placing__frame_general__Line_5() );
+bottomRight.LayoutRect( aWindowRect, SkinLayout::Popup_windows_skin_placing__frame_general__Line_5() );
 frameIID = KAknsIIDQsnFrPopup;
 frameCenterIID = KAknsIIDQsnFrPopupCenterMenu;
 }
 TRect outerRect( topLeft.Rect().iTl, bottomRight.Rect().iBr );
 TInt previousTopItem = iScroller->TopItemIndex();
 TInt previousSelectedItem = iSelectedItem;
 _AKNTRACE( "previousTopItem =  %d", previousTopItem );
 _AKNTRACE( "previousSelectedItem =  %d", previousSelectedItem );
+SetSelectedItem( aNewSelectedItem );
+if ( aNewSelectedItem >= 0 )
+{
+ScrollToMakeItemVisible( aNewSelectedItem );
+}
+else
+{
+ScrollToMakeItemVisible( 0 );
+}
 ActivateGc();
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-MAknListBoxTfxInternal *transApi = CAknListLoader::TfxApiInternal( iExtension->iGc );
-if ( transApi )
-{
-iExtension->iGc->Activate( *DrawableWindow() );
-}
-CWindowGc& gc = transApi ? *iExtension->iGc : SystemGc();
-#else
 CWindowGc& gc =  SystemGc();
-#endif // RD_UI_TRANSITION_EFFECTS_LIST
 PrepareGcForDrawingItems( gc );
-// Scrollers top item index must be updated first because setting selected
-// item results in animation redraw (which requires knowledge about the
-// current top item).
-if ( aNewSelectedItem >= 0 )
-{
-ScrollToMakeItemVisible( aNewSelectedItem );
-}
-else
-{
-ScrollToMakeItemVisible( 0 );
-}
 TInt topItem = iScroller->TopItemIndex();
 TInt bottomItem = topItem + NumberOfItemsThatFitInView();
 if( bottomItem > NumberOfItemsInPane() )
 {
 bottomItem = NumberOfItemsInPane();
 if (iExtension->iSctHighlighted)
 {
 DrawItem( gc, topItem, ERemoveHighlight );
 DrawItem( gc, (bottomItem-1), ERemoveHighlight );
 }
-SetSelectedItem( aNewSelectedItem );
 PrepareHighlightFrame();
 if ( previousTopItem == topItem  && aNewSelectedItem >= 0 )
 {
 // then only previuosly and currently selected items should be redrawn
-DrawItem( gc, previousSelectedItem, ERemoveHighlight );
+if ( iExtension->iHighlightedItem != KErrNotFound )
+{
+DrawItem( gc, previousSelectedItem, ERemoveHighlight );
+}
 if ( !iExtension->iSctHighlighted )
 {
 DrawItem( gc, aNewSelectedItem, EDrawHighlight );
 }
 }
-else
-{
-TBool skipHighlight = EFalse;
-if (iExtension && iExtension->iSct && aNewSelectedItem == 0 &&
-previousSelectedItem > 1)
-{
-skipHighlight = ETrue;
-}
-for( TInt i = topItem; i<bottomItem; i++ )
-{
-if( i == aNewSelectedItem && !skipHighlight)
-{
-DrawItem( gc, i, EDrawHighlight );
-}
-else
-{
-DrawItem( gc, i, ERemoveHighlight );
-}
-}
-}
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-if ( transApi )
-{
-iExtension->iGc->Deactivate();
-}
-#endif // RD_UI_TRANSITION_EFFECTS_LIST
 DeactivateGc();
-UpdateScrollBarThumbs();
-// Updating view position here prevents some flickering
-iExtension->ViewPositionChanged( iExtension->iViewPosition );
 _AKNTRACE_FUNC_EXIT;
 }
 // -----------------------------------------------------------------------------
 // CEikMenuPane::PrepareGcForDrawingItems
 // -----------------------------------------------------------------------------
 //
 void CEikMenuPane::PrepareGcForDrawingItems(CGraphicsContext& aGc) const
 {
 // BIDI
 /*
 * get the fonts from the LAF!
 * Do we need to get them here? - nope - moved to DrawItem()
 */
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
+aGc.SetPenColor( iEikonEnv->ControlColor( EColorMenuPaneText, *this) );
-MAknListBoxTfxInternal* transApi = CAknListLoader::TfxApiInternal( iExtension->iGc );
-if ( transApi )
-{
-transApi->StartDrawing( MAknListBoxTfxInternal::EListNotSpecified );
-}
-#endif
-aGc.SetPenColor(iEikonEnv->ControlColor( EColorMenuPaneText, *this) );
-#if defined(MENU_TEXTURED_BACKGROUND)
-iEikonEnv->SetTexturedBrush( aGc );
-#else
 aGc.SetBrushStyle( CGraphicsContext::ESolidBrush );
 aGc.SetBrushColor( iEikonEnv->ControlColor( EColorMenuPaneBackground,*this ) );
-#endif
+}
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-if ( transApi )
-{
-transApi->StopDrawing();
-}
-#endif
-}
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-/**
-* Iterate through the visible items in a menu and calculate minimum
-* item margins that dont need drawing.
-*/
-void CEikMenuPaneExtension::CalcItemSize( MAknListBoxTfxInternal* transApi ) const
-{
-if ( transApi && iControl->iItemArray && iControl->iItemArray->Count() )
-{
-TRect marginRect(TRect::EUninitialized);
-const TInt index = 0;
-// Specifies whether the text should be moved to give some space for icon.
-TInt hasIcon = iControl->MenuHasIcon() ? 1 : 0;
-TAknWindowLineLayout menuPane( AKN_LAYOUT_WINDOW_list_menu_pane( 0 , 0 ) );
-TAknWindowLineLayout singleMenuPane(
-AKN_LAYOUT_WINDOW_list_single_popup_menu_pane( index ) );
-TAknTextLineLayout menuTextLayout(
-AKN_LAYOUT_TEXT_List_pane_texts__menu_single__Line_1(0) );
-TAknLayoutRect menuPaneRect;
-TAknLayoutRect singleMenuPaneRect;
-TAknLayoutText textRect;
-TBool hasCascade = EFalse;
-TBool hasNonCascade = EFalse;
-// number of items in the whole menu
-for(TInt i = 0; i < iControl->iItemArray->Count(); i++)
-{
-CEikMenuPaneItem* item = (*iControl->iItemArray)[i];
-// true if a cascade symbol must be drawn (main menu only)
-TBool cascade = item->iData.iCascadeId != 0;
-if ( cascade )
-{
-if ( hasCascade )
-{
-if ( hasNonCascade )
-{
-break;
-}
-continue;
-}
-hasCascade = ETrue;
-}
-else
-{
-if ( hasNonCascade )
-{
-if ( hasCascade )
-{
-break;
-}
-continue;
-}
-hasNonCascade = ETrue;
-}
-if ( !iControl->iOwner )
-{
-TAknWindowLineLayout listScrollPaneLayout(
-AknLayoutScalable_Avkon::listscroll_menu_pane(0).LayoutLine() );
-AdjustPopupLayoutData( listScrollPaneLayout );
-TAknLayoutRect listScrollPaneRect;
-listScrollPaneRect.LayoutRect( iControl->Rect(), listScrollPaneLayout );
-menuPane = AknLayoutScalable_Avkon::list_menu_pane( 0 ).LayoutLine();
-menuPaneRect.LayoutRect( listScrollPaneRect.Rect(), menuPane );
-singleMenuPane = AknLayoutScalable_Avkon::list_single_pane_cp2( index ).LayoutLine();
-singleMenuPaneRect.LayoutRect( menuPaneRect.Rect(), singleMenuPane );
-menuTextLayout = AknLayoutScalable_Avkon::list_single_pane_t1_cp2( cascade ? 3 : 0 ).LayoutLine();
-}
-else // Submenu
-{
-TBool hasDoubleSpanScrollBar = EFalse;
-if ( iControl->iOwner && iControl->iSBFrame &&
-iControl->iSBFrame->VScrollBarVisibility() )
-{
-hasDoubleSpanScrollBar = ETrue;
-}
-TAknWindowLineLayout listScrollPaneLayout( AknLayoutScalable_Avkon::listscroll_popup_sub_pane().LayoutLine() );
-TAknLayoutRect listScrollPaneRect;
-listScrollPaneRect.LayoutRect( iControl->Rect(), listScrollPaneLayout );
-menuPane = AknLayoutScalable_Avkon::list_submenu_pane( !hasDoubleSpanScrollBar ).LayoutLine();
-menuPaneRect.LayoutRect( listScrollPaneRect.Rect(), menuPane );
-singleMenuPane = AknLayoutScalable_Avkon::list_single_popup_submenu_pane( index ).LayoutLine();
-singleMenuPaneRect.LayoutRect( menuPaneRect.Rect(), singleMenuPane );
-menuTextLayout = TAknTextLineLayout( AknLayoutScalable_Avkon::list_single_popup_submenu_pane_t1( hasIcon ).LayoutLine() );
-}
-textRect.LayoutText( singleMenuPaneRect.Rect(), menuTextLayout );
-if (marginRect == TRect::EUninitialized)
-{
-marginRect = textRect.TextRect();
-}
-else
-{
-marginRect.BoundingRect(textRect.TextRect());
-}
-if ( cascade )
-{
-TAknWindowLineLayout elementCascade( AknLayoutScalable_Avkon::list_single_pane_cp2_g3().LayoutLine());
-TAknLayoutRect cascadeRect;
-cascadeRect.LayoutRect( singleMenuPaneRect.Rect(), elementCascade );
-marginRect.BoundingRect(cascadeRect.Rect());
-}
-else
-{
-TAknLayoutRect activeApplicationsIconRect;
-activeApplicationsIconRect.LayoutRect( singleMenuPaneRect.Rect(),
-AknLayoutScalable_Avkon::list_single_pane_g1_cp2(0).LayoutLine() );
-marginRect.BoundingRect(activeApplicationsIconRect.Rect());
-}
-}
-if ( hasIcon )
-{
-TAknLayoutRect iconLayoutRect;
-iconLayoutRect.LayoutRect( singleMenuPaneRect.Rect(),
-AknLayoutScalable_Avkon::list_single_popup_submenu_pane_g1().LayoutLine() );
-marginRect.BoundingRect(iconLayoutRect.Rect());
-}
-//send margins to tfx
-TPoint tl ( marginRect.iTl - menuPaneRect.Rect().iTl );
-transApi->SetPosition( MAknListBoxTfxInternal::EListTLMargin, tl );
-TPoint br( singleMenuPaneRect.Rect().Size().AsPoint() - marginRect.iBr + menuPaneRect.Rect().iTl );
-transApi->SetPosition( MAknListBoxTfxInternal::EListBRMargin, br );
-}
-}
-#endif
 // ---------------------------------------------------------------------------
 // CEikMenuPane::DrawItem
 // ---------------------------------------------------------------------------
 //
 void CEikMenuPane::DrawItem( TInt aItem, THighlightType aHighlight ) const
 {
 ActivateGc();
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-MAknListBoxTfxInternal* transApi =
-CAknListLoader::TfxApiInternal( iExtension->iGc );
-if ( transApi )
-{
-iExtension->iGc->Activate( *DrawableWindow() );
-}
-CWindowGc& gc = transApi ? *iExtension->iGc : SystemGc();
-#else
 CWindowGc& gc = SystemGc();
-#endif // RD_UI_TRANSITION_EFFECTS_LIST
 PrepareGcForDrawingItems( gc );
 DrawItem( gc, aItem, aHighlight );
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-if ( transApi )
-{
-iExtension->iGc->Deactivate();
-}
-#endif // RD_UI_TRANSITION_EFFECTS_LIST
 DeactivateGc();
 }
 // ---------------------------------------------------------------------------
 if ( aItem >= numItemsInArray )
 {
 return;
 }
-// seem to have window owning control in correct place
-TRect windowRect = Rect();
-if ( !iOwner )
-{
-windowRect.iBr.iY -= ( iExtension->iCba->Rect().Height() );
-}
 CEikMenuPaneItem* item = (*iItemArray)[aItem];
 // Max visible number of items in menu / submenu
 TInt maxNumberOfItems = NumberOfItemsThatFitInView();
 TInt topIndex = iScroller->TopItemIndex();
 if ( (itemLeftInBottom > 0) && (topIndex > 0) )
 {
 index += itemLeftInBottom;
 }
-TBool drawPartialItem(EFalse);
+TBool drawSeparator = !( ( index + topIndex ) == numItemsInArray - 1 );
+TBool drawPartialItem = EFalse;
 if ( index == maxNumberOfItems )
 {
 // We have partial items to draw because of panning so there
 // is one more item to draw than normally.
 drawPartialItem = ETrue;
 // There is no layout data for the extra item, so we used the one
 // above it.
 --index;
 }
 if ( index < 0 || index >= maxNumberOfItems || (iExtension->iSct && index==0))
 {
 return;  // only interested in drawing visible items
 }
-// Collect all of the information from the Layout DLL. Initialise these
+TAknTextLineLayout menuTextLayout;
-// variables with DUMMY data. Then replace it with menu/submenu data.
-TAknWindowLineLayout menuPane( AKN_LAYOUT_WINDOW_list_menu_pane( 0 , 0 ) );
-TAknWindowLineLayout singleMenuPane(
-AKN_LAYOUT_WINDOW_list_single_popup_menu_pane( index ) );
-TAknTextLineLayout menuTextLayout(
-AKN_LAYOUT_TEXT_List_pane_texts__menu_single__Line_1(0) );
-TAknLayoutRect menuPaneRect;
 TAknLayoutRect singleMenuPaneRect;
-if ( !iOwner )
+if ( !iOwner ) // main menu
 {
-TAknWindowLineLayout listScrollPaneLayout(
+singleMenuPaneRect.LayoutRect( iExtension->iItemAreaRect,
-AknLayoutScalable_Avkon::listscroll_menu_pane(0).LayoutLine() );
+AknLayoutScalable_Avkon::list_single_pane_cp2( index ).LayoutLine() );
-if ( iExtension )
+menuTextLayout =
-{
+AknLayoutScalable_Avkon::list_single_pane_t1_cp2( cascade ? 1 : 0 ).LayoutLine();
-iExtension->AdjustPopupLayoutData( listScrollPaneLayout );
+}
-}
+else // submenu
-TAknLayoutRect listScrollPaneRect;
+{
-listScrollPaneRect.LayoutRect( windowRect, listScrollPaneLayout );
+singleMenuPaneRect.LayoutRect( iExtension->iItemAreaRect,
+AknLayoutScalable_Avkon::list_single_popup_submenu_pane( index ).LayoutLine() );
-menuPane = AknLayoutScalable_Avkon::list_menu_pane( 0 ).LayoutLine();
-menuPaneRect.LayoutRect( listScrollPaneRect.Rect(), menuPane );
-singleMenuPane = AknLayoutScalable_Avkon::list_single_pane_cp2( index ).LayoutLine();
-singleMenuPaneRect.LayoutRect( menuPaneRect.Rect(), singleMenuPane );
-menuTextLayout = AknLayoutScalable_Avkon::list_single_pane_t1_cp2( cascade ? 3 : 0 ).LayoutLine();
-}
-else // Submenu
-{
-TBool hasDoubleSpanScrollBar = EFalse;
-if ( iSBFrame && iSBFrame->VScrollBarVisibility() )
-{
-hasDoubleSpanScrollBar = ETrue;
-}
-TAknWindowLineLayout listScrollPaneLayout( AknLayoutScalable_Avkon::listscroll_popup_sub_pane().LayoutLine() );
-TAknLayoutRect listScrollPaneRect;
-listScrollPaneRect.LayoutRect( windowRect, listScrollPaneLayout );
-menuPane = AknLayoutScalable_Avkon::list_submenu_pane( !hasDoubleSpanScrollBar ).LayoutLine();
-menuPaneRect.LayoutRect( listScrollPaneRect.Rect(), menuPane );
-singleMenuPane = AknLayoutScalable_Avkon::list_single_popup_submenu_pane( index ).LayoutLine();
-singleMenuPaneRect.LayoutRect( menuPaneRect.Rect(), singleMenuPane );
-menuTextLayout = TAknTextLineLayout( AknLayoutScalable_Avkon::list_single_popup_submenu_pane_t1( 0 ).LayoutLine() );
 if ( hasIcon )
 {
-menuTextLayout = TAknTextLineLayout( AknLayoutScalable_Avkon::list_single_popup_submenu_pane_t1( 1 ).LayoutLine() );
+menuTextLayout =
+TAknTextLineLayout(
+AknLayoutScalable_Avkon::list_single_popup_submenu_pane_t1( 1 ).LayoutLine() );
+}
+else
+{
+menuTextLayout =
+TAknTextLineLayout(
+AknLayoutScalable_Avkon::list_single_popup_submenu_pane_t1( 0 ).LayoutLine() );
 }
 }
 TRect itemRect( singleMenuPaneRect.Rect() );
 TBool drawingInitiated = ETrue;
 RWindow& window = Window();
 if ( &window && window.GetDrawRect() == TRect::EUninitialized )
 {
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-MAknListBoxTfxInternal* transApi =
-CAknListLoader::TfxApiInternal( &aGc );
-drawingInitiated = transApi && !transApi->EffectsDisabled();
-#else
 drawingInitiated = EFalse;
-#endif
+}
-}
+if ( !drawingInitiated && !iExtension->iFullRedraw )
-if ( !drawingInitiated )
+{
-{
+TRect drawRect( itemRect );
-window.Invalidate( itemRect );
+drawRect.Intersection( iExtension->iItemAreaRect );
-window.BeginRedraw( itemRect );
+window.Invalidate( drawRect );
+window.BeginRedraw( drawRect );
 }
 MAknsSkinInstance* skin = AknsUtils::SkinInstance();
 MAknsControlContext* cc = NULL;
 if( iExtension )
 {
 cc = iExtension->iBgContext;
 }
 TBool background( ETrue );
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-MAknListBoxTfxInternal *transApi = CAknListLoader::TfxApiInternal( &aGc );
+aGc.SetBrushStyle( CGraphicsContext::ESolidBrush );
-if ( transApi && !transApi->EffectsDisabled() )
+aGc.SetBrushColor( singleMenuPaneRect.Color() );
-{
-iExtension->iGc->Activate( *DrawableWindow() );
+// there can be partial items, so clip drawing on menu pane's item area
-}
+aGc.SetClippingRect( iExtension->iItemAreaRect );
-#endif
+if (!iExtension->iFullRedraw)
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
+{
-if ( !transApi || transApi->EffectsDisabled() )
+background = AknsDrawUtils::Background(
-{
+skin, cc, this, aGc, itemRect,
-#endif
+KAknsDrawParamNoClearUnderImage );
+}
+if ( !background )
+{
 aGc.SetBrushStyle( CGraphicsContext::ESolidBrush );
-aGc.SetBrushColor( singleMenuPaneRect.Color() );
+aGc.SetPenStyle( CGraphicsContext::ENullPen );
+aGc.SetPenColor( singleMenuPaneRect.Color() );
-if(!iExtension->iFullRedraw)
+aGc.SetBrushColor( singleMenuPaneRect.Color() );
-{
+aGc.DrawRect( itemRect );
-background = AknsDrawUtils::Background(
+}
-skin, cc, this, aGc, itemRect,
-KAknsDrawParamNoClearUnderImage );
-}
-if( !background )
-{
-aGc.SetBrushStyle( CGraphicsContext::ESolidBrush );
-aGc.SetPenStyle( CGraphicsContext::ENullPen );
-aGc.SetPenColor( singleMenuPaneRect.Color() );
-aGc.SetBrushColor( singleMenuPaneRect.Color() );
-aGc.DrawRect( itemRect );
-}
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-}
-#endif
 if ( !iExtension->HighlightEnabled() )
 {
 aHighlight = ENoHighlight;
 }
 switch ( aHighlight )
 {
 case EDrawHighlight :
 {
 if ( !iExtension->iSctHighlighted )
 {
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
+iExtension->iHighlightedItem = aItem;
-if ( transApi )
-{
+// Because of transparency, background must be drawn here as well
-// This will remove the old bitmap
+// (as frame may be see-through)
-transApi->Invalidate( MAknListBoxTfxInternal::EListHighlight );
+aGc.SetBrushStyle( CGraphicsContext::ESolidBrush );
+aGc.SetBrushColor( singleMenuPaneRect.Color() );
-transApi->BeginRedraw( MAknListBoxTfxInternal::EListHighlight,
-itemRect );
+AknsDrawUtils::Background(
-transApi->StartDrawing( MAknListBoxTfxInternal::EListHighlight );
+skin, cc, this, aGc, itemRect,
-}
+KAknsDrawParamNoClearUnderImage );
-#endif
+TAknLayoutRect highlightTopLeft;
-// Partial items, so prevent drawing over the edge of menu pane
+TAknLayoutRect highlightBottomRight;
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-if ( !transApi || ( transApi && transApi->EffectsDisabled() ) )
+highlightTopLeft.LayoutRect(itemRect,
-{
+SkinLayout::List_highlight_skin_placing__popup_windows__Line_2() );
-aGc.SetClippingRect(menuPaneRect.Rect());
+highlightBottomRight.LayoutRect(itemRect,
-}
+SkinLayout::List_highlight_skin_placing__popup_windows__Line_5() );
-#else
+TRect outerRect( highlightTopLeft.Rect().iTl, highlightBottomRight.Rect().iBr );
-aGc.SetClippingRect(menuPaneRect.Rect());
+TRect innerRect( highlightTopLeft.Rect().iBr, highlightBottomRight.Rect().iTl );
-#endif // RD_UI_TRANSITION_EFFECTS_LIST
+TBool drawOk = AknsDrawUtils::DrawFrame( skin,
-TBool drawOk = EFalse;
+aGc,
-if( iExtension->iAnimation ) // Draw animated highlight
+outerRect,
-{
+innerRect,
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
+KAknsIIDQsnFrList,
-if ( transApi && transApi->VerifyKml() == KErrNone )
+KAknsIIDDefault );
-{
-Extension()->UseNoAnimation();
+// skinned highlight drawing has failed
-}
+if ( !drawOk )
-else
-{
-#endif
-TAknLayoutRect highlightTopLeft;
-TAknLayoutRect highlightBottomRight;
-highlightTopLeft.LayoutRect( itemRect,
-SkinLayout::List_highlight_skin_placing__popup_windows__Line_2() );
-highlightBottomRight.LayoutRect( itemRect,
-SkinLayout::List_highlight_skin_placing__popup_windows__Line_5() );
-TRect outerRect( highlightTopLeft.Rect().iTl, highlightBottomRight.Rect().iBr );
-drawOk = iExtension->iAnimation->Render( aGc, outerRect );
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-}
-#endif
-}
-if( !drawOk )
-{
-// Animated highlight was not available, use normal skinned
-// rendering.
-// Because of transparency, background must be drawn here as well
-// (as frame may be see-through)
-aGc.SetBrushStyle( CGraphicsContext::ESolidBrush );
-aGc.SetBrushColor( singleMenuPaneRect.Color() );
-AknsDrawUtils::Background(
-skin, cc, this, aGc, itemRect,
-KAknsDrawParamNoClearUnderImage );
-TAknLayoutRect highlightTopLeft;
-TAknLayoutRect highlightBottomRight;
-highlightTopLeft.LayoutRect(itemRect,
-SkinLayout::List_highlight_skin_placing__popup_windows__Line_2() );
-highlightBottomRight.LayoutRect(itemRect,
-SkinLayout::List_highlight_skin_placing__popup_windows__Line_5() );
-TRect outerRect( highlightTopLeft.Rect().iTl, highlightBottomRight.Rect().iBr );
-TRect innerRect( highlightTopLeft.Rect().iBr, highlightBottomRight.Rect().iTl );
-drawOk = AknsDrawUtils::DrawFrame( skin,
-aGc,
-outerRect,
-innerRect,
-KAknsIIDQsnFrList,
-KAknsIIDDefault );
-}
-// Both animated highlight and normal highlight drawing have
-// failed.
-if( !drawOk )
 {
 TAknLayoutRect shadowRect;
 TAknLayoutRect highlightRect;
 shadowRect.LayoutRect( itemRect,
 AKN_LAYOUT_WINDOW_Highlight_graphics__various__Line_1( itemRect ) );
 AKN_LAYOUT_WINDOW_Highlight_graphics__various__Line_2( itemRect ) );
 aGc.SetBrushStyle( CGraphicsContext::ESolidBrush );
 shadowRect.DrawRect( aGc );
 highlightRect.DrawRect( aGc );
 }
-aGc.CancelClippingRect();
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-if ( transApi )
-{
-transApi->StopDrawing();
-transApi->EndRedraw( MAknListBoxTfxInternal::EListHighlight );
-}
-#endif
 }
 break;
 }
 case ERemoveHighlight:
 case ENoHighlight:
+if ( iExtension->iHighlightedItem == aItem )
+{
+iExtension->iHighlightedItem = KErrNotFound;
+}
 default:
 break;
 }
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-if ( transApi )
-{
-transApi->BeginRedraw( MAknListBoxTfxInternal::EListItem, itemRect, aItem );
-transApi->StartDrawing( MAknListBoxTfxInternal::EListItem );
-}
-#endif // RD_UI_TRANSITION_EFFECTS_LIST
-// Partial items, so prevent drawing over the edge of menu pane
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-if ( !transApi || ( transApi && transApi->EffectsDisabled() ) )
-{
-aGc.SetClippingRect(menuPaneRect.Rect());
-}
-#else
-aGc.SetClippingRect(menuPaneRect.Rect());
-#endif // RD_UI_TRANSITION_EFFECTS_LIST
 // Cascade
 if ( cascade )
 {
 TAknWindowLineLayout elementCascade( AknLayoutScalable_Avkon::list_single_pane_cp2_g3().LayoutLine());
 aGc.SetBrushStyle( CGraphicsContext::ENullBrush );
 CAknsMaskedBitmapItemData* itemData = static_cast<CAknsMaskedBitmapItemData*>(
 skin->GetCachedItemData( KAknsIIDQgnIndiSubmenu, EAknsITMaskedBitmap ) );
 if( itemData )
 {
+AknIconUtils::SetSize( itemData->Bitmap(),cascadeRect.Rect().Size() );
 aGc.BitBltMasked( cascadeRect.Rect().iTl, itemData->Bitmap(),
 cascadeRect.Rect().Size(), itemData->Mask(), ETrue );
 }
 else
 {
-aGc.BitBltMasked( cascadeRect.Rect().iTl, iExtension->iCascadeBitmap,
+if ( iExtension->iCascadeBitmap && iExtension->iCascadeBitmapMask )
-cascadeRect.Rect().Size(), iExtension->iCascadeBitmapMask, ETrue );
+{
+AknIconUtils::SetSize( iExtension->iCascadeBitmap,cascadeRect.Rect().Size() );
+aGc.BitBltMasked( cascadeRect.Rect().iTl, iExtension->iCascadeBitmap,
+cascadeRect.Rect().Size(), iExtension->iCascadeBitmapMask, ETrue );
+}
 }
 }
 else
 {
 TAknLayoutRect activeApplicationsIconRect;
 }
 }
 }
 // Text
-TAknLayoutText textRect( iExtension->GetMenuItemTextLayout( itemRect, cascade ) );
+TAknLayoutText textRect;
+textRect.LayoutText( itemRect, menuTextLayout );
 TRgb textColor = textRect.Color();
 if ( aHighlight == EDrawHighlight ) // highlighted text
 {
 AknsUtils::GetCachedColor( skin, textColor, KAknsIIDQsnTextColors, EAknsCIQsnTextColorsCG10 );
 }
 else if ( !iOwner ) // menu
 textColor = KRgbBlack;
 }
 }
 aGc.SetBrushStyle( CGraphicsContext::ENullBrush );
 aGc.SetPenColor( textColor );
-aGc.UseFont( textRect.Font() );
 const CFont* font = textRect.Font();
 //TBuf<CEikMenuPaneItem::SData::ENominalTextLength + KAknBidiExtraSpacePerLine> visualText; // buffer for visually ordered text
 TBuf<255 + KAknBidiExtraSpacePerLine> visualText; // buffer for visually ordered text
 TRect cascRect( textRect.TextRect() );
 cascRect.Move( position );
 iExtension->iCascadeDRect.SetRect( cascRect.iTl, cascRect.iBr );
 }
-if(iExtension->iIsPenEnable)
+TAknLayoutRect highlightRect;
-{
+highlightRect.LayoutRect( itemRect,
-TAknLayoutRect highlightRect;
+AKN_LAYOUT_WINDOW_Highlight_graphics__various__Line_2( itemRect ) );
-highlightRect.LayoutRect( itemRect,
-AKN_LAYOUT_WINDOW_Highlight_graphics__various__Line_2( itemRect ) );
+// store the calculated y-position to the menu item,
+// so that it can be used in HandlePointerEventL()
-// store the calculated y-position to the menu item,
+item->iPos = highlightRect.Rect().iTl.iY;
-// so that it can be used in HandlePointerEventL()
-item->iPos = highlightRect.Rect().iTl.iY;
+// don't draw separator line for the last item
-aGc.DiscardFont();
+if ( drawSeparator )
-}
+{
+AknListUtils::DrawSeparator( aGc, itemRect, textColor, skin );
-if ( !drawingInitiated )
+}
+if ( !drawingInitiated && !iExtension->iFullRedraw )
 {
 Window().EndRedraw();
 }
 aGc.CancelClippingRect();
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-if ( transApi && !transApi->EffectsDisabled() )
-{
-transApi->StopDrawing();
-transApi->EndRedraw( MAknListBoxTfxInternal::EListItem, aItem );
-iExtension->iGc->Deactivate();
-}
-#endif // RD_UI_TRANSITION_EFFECTS_LIST
 }
 // -----------------------------------------------------------------------------
 // CEikMenuPane::Draw
 // -----------------------------------------------------------------------------
 //
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
 EXPORT_C void CEikMenuPane::Draw( const TRect& aRect ) const
 {
-CWindowGc& gc = ( iExtension && iExtension->iGc ) ?
-*iExtension->iGc : SystemGc();
-MAknListBoxTfxInternal *transApi = CAknListLoader::TfxApiInternal( &gc );
-if ( transApi )
-{
-iExtension->iGc->Activate( *DrawableWindow() );
-if ( !transApi->EffectsDisabled() )
-{
-if ( iExtension->iScrollBarRect.iTl.iX <= aRect.iTl.iX &&
-iExtension->iScrollBarRect.iBr.iX >= aRect.iBr.iX )
-{
-transApi->BeginRedraw( MAknListBoxTfxInternal::EListUpdateRect, aRect );
-iExtension->iGc->Deactivate();
-return;
-}
-iExtension->CalcItemSize( transApi );
-}
-}
-#else
-EXPORT_C void CEikMenuPane::Draw(const TRect& /*aRect*/) const
-{
-#endif // RD_UI_TRANSITION_EFFECTS_LIST
-TRect windowRect( Rect() );
 MAknsSkinInstance* skin = AknsUtils::SkinInstance();
 MAknsControlContext* cc = NULL;
 if( iExtension )
 {
 cc = iExtension->iBgContext;
 }
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-if ( transApi )
-{
-transApi->SetListType( MAknListBoxTfxInternal::EListBoxTypeMenuPane );
-transApi->BeginRedraw( MAknListBoxTfxInternal::EListView, windowRect );
-}
-#else
 CWindowGc& gc = SystemGc();
-#endif // RD_UI_TRANSITION_EFFECTS_LIST
 PrepareGcForDrawingItems( gc );
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-if ( transApi )
-{
-transApi->StartDrawing( MAknListBoxTfxInternal::EListView );
-}
-#endif
-if ( !IsCascadeMenuPane() )
-{
-CFbsBitmap* cbaExtension = AknsUtils::GetCachedBitmap( skin, KAknsIIDQsnBgSlicePopup );
-if ( cbaExtension )
-{
-TAknLayoutRect sliceRect;
-sliceRect.LayoutRect( windowRect, SkinLayout::Popup_windows_skin_placing__background_slice__Line_2() );
-AknIconUtils::SetSize( cbaExtension, sliceRect.Rect().Size() );
-gc.BitBlt( TPoint( windowRect.iTl.iX, windowRect.iBr.iY-cbaExtension->SizeInPixels().iHeight ), cbaExtension );
-windowRect.iBr.iY -=2; // two used as margin when rect layouts were done
-}
-}
 TInt count=0;
 if( iItemArray )
 {
 count=iItemArray->Count();
 }
 // Give the topmost menu item's rect to SCT if needed.
 if ( iExtension->iSct )
 {
-TAknLayoutRect listScrollPaneRect;
+iExtension->iSct->SetMenuSctRect( ItemRect( 0 ) );
-TAknLayoutRect menuPaneRect;
-TAknLayoutRect singleMenuPaneRect;
-TAknWindowLineLayout listScrollPaneLayout(
-AknLayoutScalable_Avkon::listscroll_menu_pane(0).LayoutLine() );
-if ( iExtension )
-{
-iExtension->AdjustPopupLayoutData( listScrollPaneLayout );
-}
-listScrollPaneRect.LayoutRect( windowRect, listScrollPaneLayout );
-menuPaneRect.LayoutRect( listScrollPaneRect.Rect(),
-AknLayoutScalable_Avkon::list_menu_pane( 0 ).LayoutLine() );
-singleMenuPaneRect.LayoutRect( menuPaneRect.Rect(),
-AknLayoutScalable_Avkon::list_single_pane_cp2( 0 ).LayoutLine() );
-// Give the rect of the first menu item to SCT.
-iExtension->iSct->SetMenuSctRect( singleMenuPaneRect.Rect() );
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-if( transApi )
-{
-iExtension->iSctRect = singleMenuPaneRect.Rect();
-TAknLayoutRect cellLayRect;
-cellLayRect.LayoutRect( iExtension->iSctRect,
-AknLayoutScalable_Avkon::cell_graphic_popup_pane( 0, 0, 0 ) );
-iExtension->iSctRect.iTl.iX -= 1;
-iExtension->iSctRect.iTl.iY -= 1;
-iExtension->iSctRect.iBr.iX += 3;
-transApi->ResetNonDrawingRects();
-transApi->AddNonDrawingRect( iExtension->iScrollBarRect );
-transApi->AddNonDrawingRect( iExtension->iSctRect );
-}
-#endif // RD_UI_TRANSITION_EFFECTS_LIST
-}
-if ( iExtension->iSct )
-{
 TRegionFix<4> region;
-region.AddRect( Rect() );
+region.AddRect( aRect );
 region.SubRect( iExtension->iSct->Rect() );
 gc.SetClippingRegion( region );
 }
-TRect backgroundRect( iOwner ? windowRect : iExtension->GetBackgroundRect( windowRect ) );
 // The added flag removes the white bg for transparency
 TBool frameDrawn = AknsDrawUtils::Background(
-skin, cc, this, gc, backgroundRect, KAknsDrawParamNoClearUnderImage );
+skin, cc, this, gc, aRect, KAknsDrawParamNoClearUnderImage );
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
+if ( aRect.Intersects( iExtension->iItemAreaRect ) )
-if ( transApi )
+{
-{
+iExtension->iFullRedraw = ETrue;
-transApi->StopDrawing();
-}
+for ( TInt ii=0;ii<count;++ii )
-#endif // RD_UI_TRANSITION_EFFECTS_LIST
+{
+if(!iExtension->iSctHighlighted && ii == iSelectedItem  )
-iExtension->iFullRedraw = ETrue;
+DrawItem( gc, ii, EDrawHighlight);
+else
-for ( TInt ii=0;ii<count;++ii )
+DrawItem( gc, ii, ENoHighlight);
-{
+}
-if(!iExtension->iSctHighlighted && ii == iSelectedItem  )
-DrawItem( gc, ii, EDrawHighlight);
+iExtension->iFullRedraw = EFalse;
-else
+}
-DrawItem( gc, ii, ENoHighlight);
-}
-iExtension->iFullRedraw = EFalse;
 if ( iExtension->iSct )
 {
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-if ( transApi )
-{
-transApi->StartDrawing( MAknListBoxTfxInternal::EListNotSpecified );
-}
-#endif
 gc.CancelClippingRegion();
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
+}
-if ( transApi )
-{
-transApi->StopDrawing();
-}
-#endif
-}
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-if ( transApi )
-{
-transApi->EndViewRedraw( aRect );
-iExtension->iGc->Deactivate();
-}
-#endif // RD_UI_TRANSITION_EFFECTS_LIST
 }
 // -----------------------------------------------------------------------------
 // CEikMenuPane::ReportSelectionMadeL
 // 'this' might be destroyed by calling iMenuObserver->ProcessCommandL(
 // commandId ), so need to avoid crash
 CEikMenuPane* menu = iOwner ? iOwner : this;
 MCoeControlObserver* observer = menu->Observer();
+if ( commandId >= EAknCmdMarkingModeEnter
-if ( commandId != EAknCmdTaskSwapper )
+&& commandId <= EAknCmdMarkingModeUnmarkAll )
+{
+CEikMenuBar* menuBar = static_cast<CEikMenuBar*>( Parent() );
+if ( menuBar && menuBar->MenuPane() == this )
+{
+static_cast<MEikCommandObserver*>(
+menuBar)->ProcessCommandL( commandId );
+}
+ReportCanceled();
+}
+else if ( commandId != EAknCmdTaskSwapper )
 {
 _AKNTRACE( "commandId = %d",  commandId );
+TBool isDeleted = EFalse;
+iIsDeleted = &isDeleted;
+CleanupStack::PushL( TCleanupItem( CleanLocalRef, this ) );
 iMenuObserver->ProcessCommandL( commandId );
+CleanupStack::Pop();
+if ( !isDeleted )
+{
+CEikMenuBar* menuBar = static_cast<CEikMenuBar*>( Parent() );
+if ( menuBar && menuBar->MenuPane() == this )
+{
+static_cast<MEikCommandObserver*>(
+menuBar)->ProcessCommandL( commandId );
+}
+}
+iIsDeleted = NULL;
 }
 else
 {
 ReportCanceled();
 return;
 //
 EXPORT_C void CEikMenuPane::FocusChanged( TDrawNow aDrawNow )
 {
 _AKNTRACE_FUNC_ENTER;
 _AKNTRACE( "aDrawNow =  %d", aDrawNow );
-if( iExtension )
-{
-if ( IsFocused() )
-{
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-// Focus must be handled here, otherwise it will come to late
-MAknListBoxTfxInternal *transApi = CAknListLoader::TfxApiInternal( iExtension->iGc );
-if ( transApi )
-{
-transApi->HandleFocusChange( ETrue );
-}
-#endif // RD_UI_TRANSITION_EFFECTS_LIST
-iExtension->FocusGained();
-}
-else // Not focused
-{
-iExtension->FocusLost();
-}
-}
 if ( !iItemArray || iItemArray->Count() == 0 )
 {
 return;
 }
 TInt newHighlight = iSelectedItem;
 TBool loopScrolling = ETrue;
 TInt itemAfterLastItem = loopScrolling ? 0 : max;
 TInt itemAfterFirstItem = loopScrolling ? max : 0;
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
+// Scroll highlighted item so that it becomes visible,
-CWindowGc& gc = iExtension->iGc ? *iExtension->iGc : SystemGc();
+// if it is not visible before (scrolling with scroll bar
-MAknListBoxTfxInternal* transApi = CAknListLoader::TfxApiInternal( &gc );
+// can cause highlighted item to go out of screen)
-#endif //RD_UI_TRANSITION_EFFECTS_LIST
+TInt topItem = iScroller->TopItemIndex();
+TInt bottomItem = topItem + NumberOfItemsThatFitInView();
-if(iExtension->iIsPenEnable)
-{
+if ( iExtension->Offset() < 0 )
-_AKNTRACE( "[%s]", "iExtension->iIsPenEnable = TRUE" );
+{
-// Scroll highlighted item so that it becomes visible,
+// Extra bottom item when panning
-// if it is not visible before (scrolling with scroll bar
+bottomItem++;
-// can cause highlighted item to go out of screen)
+}
-TInt topItem = iScroller->TopItemIndex();
-TInt bottomItem = topItem + NumberOfItemsThatFitInView();
+if( bottomItem > NumberOfItemsInPane() )
+{
-if ( iExtension->Offset() < 0 )
+bottomItem = NumberOfItemsInPane();
-{
+}
-// Extra bottom item when panning
+_AKNTRACE( "topItem = %d,bottomItem = %d", topItem,bottomItem );
-bottomItem++;
-}
+if ( aType != EEventKeyDown && iSelectedItem != ENothingSelected &&
+!(iExtension->iSctHighlighted && topItem == 0) &&
-if( bottomItem > NumberOfItemsInPane() )
+(iSelectedItem < topItem || iSelectedItem > bottomItem - 1) )
 {
-bottomItem = NumberOfItemsInPane();
+_AKNTRACE( "[%s]", "ScrollToMakeItemVisible(iSelectedItem);" );
-}
+ScrollToMakeItemVisible(iSelectedItem);
-_AKNTRACE( "topItem = %d,bottomItem = %d", topItem,bottomItem );
+ActivateGc();
-if ( aType != EEventKeyDown && iSelectedItem != ENothingSelected &&
+CWindowGc& gc = SystemGc();
-!(iExtension->iSctHighlighted && topItem == 0) &&
+PrepareGcForDrawingItems( gc );
-(iSelectedItem < topItem || iSelectedItem > bottomItem - 1) )
-{
+// draw all items that are needed.
-_AKNTRACE( "[%s]", "ScrollToMakeItemVisible(iSelectedItem);" );
+for( TInt i = 0; i < count; i++ )
-ScrollToMakeItemVisible(iSelectedItem);
+{
+if( i == iSelectedItem && !iExtension->iSctHighlighted)
-ActivateGc();
+{
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
+DrawItem( gc, i, EDrawHighlight );
-if ( transApi )
+}
-{
+else
-iExtension->iGc->Activate( *DrawableWindow() );
+{
-}
+DrawItem( gc, i, ERemoveHighlight );
-#else
+}
-CWindowGc& gc = SystemGc();
+}
-#endif // RD_UI_TRANSITION_EFFECTS_LIST
-PrepareGcForDrawingItems( gc );
+DeactivateGc();
+_AKNTRACE( "[%s]", "OfferKeyEventL return 9" );
-// draw all items that are needed.
+_AKNTRACE_FUNC_EXIT;
-for( TInt i = 0; i < count; i++ )
+return EKeyWasConsumed;
-{
-if( i == iSelectedItem && !iExtension->iSctHighlighted)
-{
-DrawItem( gc, i, EDrawHighlight );
-}
-else
-{
-DrawItem( gc, i, ERemoveHighlight );
-}
-}
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-if ( transApi )
-{
-iExtension->iGc->Deactivate();
-}
-#endif // RD_UI_TRANSITION_EFFECTS_LIST
-DeactivateGc();
-_AKNTRACE( "[%s]", "OfferKeyEventL return 9" );
-_AKNTRACE_FUNC_EXIT;
-return EKeyWasConsumed;
-}
 }
 if ( iSelectedItem != ENothingSelected || iExtension->iSctHighlighted )
 {
 switch ( code )
 return EKeyWasConsumed;
 // AKNLAF start
 // loop scrolling always used in options menus
 case EKeyDownArrow:
 	_AKNTRACE( "[%s]", "OfferKeyEventL(EKeyDownArrow)" );
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-if ( transApi )
-{
-transApi->SetMoveType(
-MAknListBoxTfxInternal::EListMoveDown );
-}
-#endif //RD_UI_TRANSITION_EFFECTS_LIST
 if ( iExtension->iSctHighlighted && iExtension->iSct )
 {
 iExtension->iSctHighlighted = EFalse;
 MoveHighlightTo( ++newHighlight );
 iExtension->iSct->HighlightSctRow( iExtension->iSctHighlighted );
 }
 keyResponse = EKeyWasConsumed;
 break;
 case EKeyUpArrow:
 	_AKNTRACE( "[%s]", "OfferKeyEventL(EKeyUpArrow)" );
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-if ( transApi )
-{
-transApi->SetMoveType(
-MAknListBoxTfxInternal::EListMoveUp );
-}
-#endif //RD_UI_TRANSITION_EFFECTS_LIST
 if ( iExtension->iSct &&
 iSelectedItem == 0 && !iExtension->iSctHighlighted )
 {
 iExtension->iSctHighlighted = ETrue;
 MoveHighlightTo( ENothingSelected );
 return;
 }
 TInt count( NumberOfItemsInPane() );
-if ( iExtension->iIsPenEnable )
+// Scroll highlighted item so that it becomes visible
-{
+// if it is not visible before (scrolling with scroll bar
-// Scroll highlighted item so that it becomes visible
+// can cause highlighted item to go out of screen).
-// if it is not visible before (scrolling with scroll bar
+TInt topItem( iScroller->TopItemIndex() );
-// can cause highlighted item to go out of screen).
+TInt bottomItem( topItem + NumberOfItemsThatFitInView() );
-TInt topItem( iScroller->TopItemIndex() );
+if ( bottomItem > count )
-TInt bottomItem( topItem + NumberOfItemsThatFitInView() );
+{
-if ( bottomItem > count )
+bottomItem = count;
-{
+}
-bottomItem = count;
-}
+if ( iExtension->Offset() < 0 &&
+( iSelectedItem == topItem || iSelectedItem == bottomItem ) )
-if ( iExtension->Offset() < 0 &&
+{
-( iSelectedItem == topItem || iSelectedItem == bottomItem ) )
+// Restoring offset with "simulated" ok key event.
-{
+iExtension->RestoreOffset( EKeyOK );
-// Restoring offset with "simulated" ok key event.
+}
-iExtension->RestoreOffset( EKeyOK );
+else if ( iSelectedItem < topItem ||
-}
+iSelectedItem > bottomItem - 1 )
-else if ( iSelectedItem < topItem ||
+{
-iSelectedItem > bottomItem - 1 )
+if ( count > iSelectedItem )
 {
-if ( count > iSelectedItem )
+if ( iExtension->iSctHighlighted && iExtension->iSct )
 {
-if ( iExtension->iSctHighlighted && iExtension->iSct )
+TKeyEvent key;
+key.iCode = EKeyOK;
+key.iModifiers = 0;
+TKeyResponse keyResponse( EKeyWasNotConsumed );
+TEventCode type( EEventNull );
+keyResponse = iExtension->iSct->OfferKeyEventL( key,
+type );
+if ( keyResponse == EKeyWasConsumed )
 {
-TKeyEvent key;
+ReportSelectionMadeL();
-key.iCode = EKeyOK;
-key.iModifiers = 0;
-TKeyResponse keyResponse( EKeyWasNotConsumed );
-TEventCode type( EEventNull );
-keyResponse = iExtension->iSct->OfferKeyEventL( key,
-type );
-if ( keyResponse == EKeyWasConsumed )
-{
-ReportSelectionMadeL();
-}
-_AKNTRACE( "[%s]" "ActivateCurrentItemL return 2" );
-_AKNTRACE_FUNC_EXIT;
-return;
 }
-}
+_AKNTRACE( "[%s]" "ActivateCurrentItemL return 2" );
+_AKNTRACE_FUNC_EXIT;
-iExtension->isUpdateScrollDirectly = ETrue;
+return;
-ScrollToMakeItemVisible( iSelectedItem );
+}
-iExtension->isUpdateScrollDirectly = EFalse;
+}
-ActivateGc();
+iExtension->isUpdateScrollDirectly = ETrue;
+ScrollToMakeItemVisible( iSelectedItem );
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
+iExtension->isUpdateScrollDirectly = EFalse;
-MAknListBoxTfxInternal *transApi =
+ActivateGc();
-CAknListLoader::TfxApiInternal( iExtension->iGc );
+CWindowGc& gc = SystemGc();
-if ( transApi )
+PrepareGcForDrawingItems( gc );
-{
-iExtension->iGc->Activate( *DrawableWindow() );
+// Draw all items that are needed.
-}
+for ( TInt i = 0; i < count; i++ )
-CWindowGc& gc = transApi ? *iExtension->iGc : SystemGc();
+{
+if ( i == iSelectedItem && !iExtension->iSctHighlighted )
-#else
+{
+DrawItem( gc, i, EDrawHighlight );
-CWindowGc& gc = SystemGc();
+}
+else
-#endif // RD_UI_TRANSITION_EFFECTS_LIST
+{
+DrawItem( gc, i, ERemoveHighlight );
-PrepareGcForDrawingItems( gc );
+}
+}
-// Draw all items that are needed.
-for ( TInt i = 0; i < count; i++ )
+DeactivateGc();
-{
+_AKNTRACE( "[%s]" "ActivateCurrentItemL return 3" );
-if ( i == iSelectedItem && !iExtension->iSctHighlighted )
+_AKNTRACE_FUNC_EXIT;
-{
+return;
-DrawItem( gc, i, EDrawHighlight );
-}
-else
-{
-DrawItem( gc, i, ERemoveHighlight );
-}
-}
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-if ( transApi )
-{
-iExtension->iGc->Deactivate();
-}
-#endif // RD_UI_TRANSITION_EFFECTS_LIST
-DeactivateGc();
-_AKNTRACE( "[%s]" "ActivateCurrentItemL return 3" );
-_AKNTRACE_FUNC_EXIT;
-return;
-}
 }
 if ( iCascadeMenuPane )
 {
 iCascadeMenuPane->ActivateCurrentItemL();
 CEikMenuBar* menubar = static_cast<CEikMenuBar*>( Parent() );
 if( menubar->MenuPane() == this )
 {
 TPointerEvent ptrEvent;
 ptrEvent.iType = TPointerEvent::EButton1Up;
-menubar->HandlePointerEventL( ptrEvent );
+TRAP_IGNORE( menubar->HandlePointerEventL( ptrEvent ) );
 }
 else
 {
 MCoeControlObserver* observer = iOwner ? iOwner->Observer() : Observer();
 if ( observer )
 // Handles pointer events.
 // ----------------------------------------------------------------------------
 //
 EXPORT_C void CEikMenuPane::HandlePointerEventL( const TPointerEvent& aPointerEvent )
 {
-if( !AknLayoutUtils::PenEnabled() )
-{
-return;
-}
 _AKNTRACE_FUNC_ENTER;
 if ( iOwner && !IsVisible() )
 {
 _AKNTRACE( "[%s]", "HandlePointerEventL return 1" );
 }
 else
 {
 if ( aPointerEvent.iType == TPointerEvent::EButton1Down )
 {
-if( AknLayoutUtils::PenEnabled() )
+if ( CAknTransitionUtils::TransitionsEnabled( AknTransEffect::EComponentTransitionsOff ) )
 {
-if ( CAknTransitionUtils::TransitionsEnabled( AknTransEffect::EComponentTransitionsOff ) )
+iExtension->ImmediateFeedback( ETouchFeedbackSubMenuClosed );
-{
+}
-iExtension->ImmediateFeedback( ETouchFeedbackPopupClose );
+else
-}
+{
-else
+iExtension->ImmediateFeedback( ETouchFeedbackPopUp );
-{
-iExtension->ImmediateFeedback( ETouchFeedbackPopUp );
-}
 }
 iExtension->iShowCascadeTransition = ETrue;
 CloseCascadeMenu();
+// Submenu of submenu was closed
+if ( iCascadeMenuPane  )
+{
+iCascadeMenuPane->iExtension->EnableHighlight( EFalse );
+iCascadeMenuPane->RepaintHighlight();
+iExtension->iDownOnMenuArea = EFalse;
+}
+else
+{
+iExtension->EnableHighlight( EFalse );
+RepaintHighlight();
+}
 IgnoreEventsUntilNextPointerUp();
 _AKNTRACE( "[%s]", "HandlePointerEventL return 2" );
 _AKNTRACE_FUNC_EXIT;
 return;
 }
 const TRect innerRect = iBorder.InnerRect( Rect() );
 TRect menuSctRect;
 // Get the option item's rect in Menu SCT
 if ( iExtension->iSct )
 {
-TAknLayoutRect menuPaneRect;
+menuSctRect = iExtension->iItemAreaRect;
-TAknWindowLineLayout menuPane;
-TAknWindowLineLayout listScrollPaneLayout(
-AknLayoutScalable_Avkon::listscroll_menu_pane(0).LayoutLine() );
-if ( iExtension )
-{
-iExtension->AdjustPopupLayoutData( listScrollPaneLayout );
-}
-TAknLayoutRect listScrollPaneRect;
-listScrollPaneRect.LayoutRect( Rect(), listScrollPaneLayout );
-menuPane = AknLayoutScalable_Avkon::list_menu_pane( 0 ).LayoutLine();
-menuPaneRect.LayoutRect( listScrollPaneRect.Rect(), menuPane );
-menuSctRect = menuPaneRect.Rect();
 }
 TRect cascadeMenuRect(0,0,0,0);
 // Y coordinate for pointer event
 const TInt yPos = aPointerEvent.iPosition.iY;
 // if submenu, then move it's rect coordinates to relative to parent.
 if ( iCascadeMenuPane  )
 {
-TPoint subPos = iCascadeMenuPane->PositionRelativeToScreen();
+TPoint subPos = iCascadeMenuPane->Position();
-cascadeMenuRect = TRect(subPos-PositionRelativeToScreen(), iCascadeMenuPane->Size());
+cascadeMenuRect = TRect(subPos-Position(), iCascadeMenuPane->Size());
 }
 // Pointerevent in case we need to pass event from submenu to parent
 TPointerEvent parentEvent;
 {
 iExtension->StopCascadeMenuTimer();
 iExtension->ResetPressedHighlight();
 }
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-MAknListBoxTfxInternal *transApi = CAknListLoader::TfxApiInternal(
-iExtension->iGc );
-TBool effects = transApi && !transApi->EffectsDisabled();
-#endif
 switch (aPointerEvent.iType )
 {
 case TPointerEvent::EButton1Up:
 {
 _AKNTRACE( "[%s]", "TPointerEvent::EButton1Up" );
 if ( !innerRect.Contains( aPointerEvent.iPosition ) )
 {
+TBool highlightWasEnabled = iExtension->HighlightEnabled();
 // remove highlight in case highlight is outside of menu pane
 iExtension->EnableHighlight( EFalse );
 if ( iOwner )
 {
 RepaintHighlight();
 }
+else if ( highlightWasEnabled && !iCascadeMenuPane )
+{
+DrawItem( SelectedItem(), ENoHighlight );
+}
 }
 if ( iOwner &&
 !innerRect.Contains( aPointerEvent.iPosition ) &&
 !iExtension->iDownOnMenuArea )
 {
 iExtension->CalculateParentEvent( aPointerEvent, parentEvent);
 _AKNTRACE( "[%s]", "HandlePointerEventL return 6" );
 _AKNTRACE_FUNC_EXIT;
 return iOwner->HandlePointerEventL( parentEvent );
 }
-iExtension->iDownOnMenuArea = EFalse;
 iExtension->iPanningActive = EFalse;
-if ( !(iExtension->iSct &&  iExtension->iSct->Rect().Contains( iExtension->iStartPoint ) ) )
+if ( !(iExtension->iSct &&  iExtension->iSct->Rect().Contains( iExtension->iStartPoint ) )
+&& iExtension->iDownOnMenuArea )
 {
 TPoint drag = iExtension->iStartPoint - aPointerEvent.iPosition;
 if ( iExtension->iPhysics->StartPhysics(
 drag, iExtension->iStartTime ) )
 {
 iExtension->iFlickActive = ETrue;
 iExtension->ResetPressedHighlight();
 }
 }
+iExtension->iDownOnMenuArea = EFalse;
 if ( iExtension->HighlightTimerActive() &&
 !iExtension->iPressedDown )
 {
 // Complete the timer here if it's still running
 // when up event is received.
 TryLaunchCascadeMenuL( *item );
 }
 else if ( iExtension->iButtonDownItem == iSelectedItem )
 {
-iExtension->ImmediateFeedback( ETouchFeedbackBasicItem,
+iExtension->ImmediateFeedback( ETouchFeedbackList,
 ETouchFeedbackVibra );
 if( !IsCascadeMenuPane() )
 {
 // EFalse = don't stop transition if opening the cascade menu
 // just report selection
 {
 if ( iExtension->iFlickActive )
 {
 noSelection = ETrue;
 					//when touch down during the flicking, play a basic list feedback
-iExtension->ImmediateFeedback( ETouchFeedbackBasicItem );
+iExtension->ImmediateFeedback( ETouchFeedbackList );
 }
 // stop physics for drag
 iExtension->iPhysics->StopPhysics();
 iExtension->iPhysics->ResetFriction();
 if ( iCascadeMenuPane )
 {
 // if submenu, and clicked outside of it
 if ( !cascadeMenuRect.Contains( aPointerEvent.iPosition ) )
 {
-if( AknLayoutUtils::PenEnabled() )
+if ( CAknTransitionUtils::TransitionsEnabled( AknTransEffect::EComponentTransitionsOff ) )
 {
-if ( CAknTransitionUtils::TransitionsEnabled( AknTransEffect::EComponentTransitionsOff ) )
+iExtension->ImmediateFeedback( ETouchFeedbackSubMenuClosed );
-{
+}
-iExtension->ImmediateFeedback( ETouchFeedbackPopupClose );
+else
-}
+{
-else
+iExtension->ImmediateFeedback( ETouchFeedbackPopUp );
-{
-iExtension->ImmediateFeedback( ETouchFeedbackPopUp );
-}
 }
 //Just close sub menu
 iExtension->iShowCascadeTransition = ETrue;
 CloseCascadeMenu();
-iExtension->EnableHighlight( EFalse );
+// Submenu of submenu was closed
-RepaintHighlight();
+if ( iCascadeMenuPane  )
+{
+iCascadeMenuPane->iExtension->EnableHighlight( EFalse );
+iCascadeMenuPane->RepaintHighlight();
+iExtension->iDownOnMenuArea = EFalse;
+}
+else
+{
+iExtension->EnableHighlight( EFalse );
+RepaintHighlight();
+}
 IgnoreEventsUntilNextPointerUp();
 break;
 }
 }
 else
 // from sct to normal menu item
 iExtension->iSctHighlighted = EFalse;
 iExtension->iSct->HighlightSctRow( iExtension->iSctHighlighted );
 }
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-if ( effects )
-{
-transApi->SetMoveType( MAknListBoxTfxInternal::EListTap );
-}
-#endif
 iExtension->iPressedDown = ETrue;
 // Start timer for pressed highlight
 if ( !noSelection )
 {
-iExtension->ImmediateFeedback( ETouchFeedbackBasicItem );
+iExtension->ImmediateFeedback( ETouchFeedbackList );
 iExtension->StartHighlightTimerL();
 }
 iExtension->iNextHighlightItem = ii;
 iExtension->iButtonDownItem = ii;
 // down even on already highlighted item => list feedback
 if ( iExtension->iButtonDownItem == iSelectedItem )
 {
-iExtension->ImmediateFeedback( ETouchFeedbackBasicItem );
+iExtension->ImmediateFeedback( ETouchFeedbackList );
 }
 if ( noSelection )
 {
 iExtension->iButtonDownItem = KErrNotFound;
 }
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-if ( effects )
-{
-transApi->Draw( Rect() );
-}
-#endif
 // if new item has submenu, show it
 if ( item->iData.iCascadeId )
 {
 if ( !iExtension->IsCascadeMenuTimerActive() )
 {
 }
 }
 else
 {
 // Clicked out side submenu, parent handles this
+iExtension->iDownOnMenuArea = EFalse;
 if ( iOwner )
 {
 iExtension->CalculateParentEvent(aPointerEvent, parentEvent);
 _AKNTRACE( "[%s]", "HandlePointerEventL return 12" );
 _AKNTRACE_FUNC_EXIT;
 return iOwner->HandlePointerEventL( parentEvent );
 }
 else
 {
-if ( iExtension->iIsPenEnable )
+// For finger usability, extend to the right.
+TRect innerToRightRect;
+if ( AknLayoutUtils::LayoutMirrored() )
 {
-// For finger usability, extend to the right.
+innerToRightRect = TRect( Rect().iTl, innerRect.iBr );
-TRect innerToRightRect;
+}
-if ( AknLayoutUtils::LayoutMirrored() )
+else
+{
+innerToRightRect = TRect( innerRect.iTl, Rect().iBr );
+}
+// Keep opened
+if ( innerToRightRect.Contains( aPointerEvent.iPosition ) )
+{
+break;
+}
+// clicked outside, then close menu case by case
+if ( iCascadeMenuPane )
+{
+if ( CAknTransitionUtils::TransitionsEnabled( AknTransEffect::EComponentTransitionsOff ) )
 {
-innerToRightRect = TRect( Rect().iTl, innerRect.iBr );
+iExtension->ImmediateFeedback( ETouchFeedbackSubMenuClosed );
 }
 else
 {
-innerToRightRect = TRect( innerRect.iTl, Rect().iBr );
+iExtension->ImmediateFeedback( ETouchFeedbackPopUp );
-}
-// Keep opened
-if ( innerToRightRect.Contains( aPointerEvent.iPosition ) )
-{
-break;
-}
-}
-// clicked outside, then close menu case by case
-if ( iCascadeMenuPane )
-{
-if( AknLayoutUtils::PenEnabled() )
-{
-if ( CAknTransitionUtils::TransitionsEnabled( AknTransEffect::EComponentTransitionsOff ) )
-{
-iExtension->ImmediateFeedback( ETouchFeedbackPopupClose );
-}
-else
-{
-iExtension->ImmediateFeedback( ETouchFeedbackPopUp );
-}
 }
 iExtension->iShowCascadeTransition = ETrue;
 CloseCascadeMenu(); //Just close sub menu.
-iExtension->EnableHighlight( EFalse );
+// Submenu of submenu was closed
-RepaintHighlight();
+if ( iCascadeMenuPane  )
+{
+iCascadeMenuPane->iExtension->EnableHighlight( EFalse );
+iCascadeMenuPane->RepaintHighlight();
+}
+else
+{
+iExtension->EnableHighlight( EFalse );
+RepaintHighlight();
+}
 IgnoreEventsUntilNextPointerUp();
 }
 else
 {
-ReportCanceled();   //Close main menu.
+_AKNTRACE( "[%s]", "HandlePointerEventL return 12.5" );
+_AKNTRACE_FUNC_EXIT;
+return;
 }
 }
 }
 }
 	}
 TPoint drag = iExtension->iStartPoint -
 aPointerEvent.iPosition;
 TInt threshold = drag.iY;
-if( Abs( threshold ) > iExtension->iPhysics->DragThreshold() )
+if( Abs( threshold ) > iExtension->iPhysics->DragThreshold()
-{
+&& iExtension->iDownOnMenuArea )
+{
+iExtension->EnableHighlight( EFalse );
 iExtension->iButtonDownItem = KErrNotFound;
 iExtension->ResetPressedHighlight();
 iExtension->iNextHighlightItem = KErrNotFound;
 iExtension->iPanningActive = ETrue;
-iExtension->EnableHighlight( EFalse );
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-MAknListBoxTfx* tfxApi = CAknListLoader::TfxApi( iExtension->iGc );
-if ( tfxApi )
-{
-tfxApi->EnableEffects( EFalse );
-}
-#endif // RD_UI_TRANSITION_EFFECTS_LIST
 }
-if ( iExtension->iPanningActive )
+if ( iExtension->iPanningActive && iExtension->iDownOnMenuArea )
 {
 TPoint delta(
 0, iExtension->iPrevPoint.iY - aPointerEvent.iPosition.iY );
 iExtension->iPhysics->RegisterPanningPosition( delta );
 }
 iExtension->ResetPressedHighlight();
 }
 // act in Menu Sct or Option Menu repectively
 if (( iExtension->iSct && menuSctRect.Contains(aPointerEvent.iPosition)) ||
-( !iExtension->iSct && innerRect.Contains(aPointerEvent.iPosition)))
+( !iExtension->iSct && innerRect.Contains(aPointerEvent.iPosition)) &&
+iExtension->iDownOnMenuArea )
 {
 iExtension->iDraggedOutside = EFalse;
 // Scroll only through visible items
 for ( TInt ii = topItem; ii < bottomItem; ++ii )
 {
 // if submenu open and touched item is not the one which opened submenu, then close submenu
 if ( (ii != iSelectedItem)
 && !cascadeMenuRect.Contains(
 aPointerEvent.iPosition ) )
 {
-if ( AknLayoutUtils::PenEnabled() )
+if ( CAknTransitionUtils::TransitionsEnabled(
+AknTransEffect::EComponentTransitionsOff ) )
 {
-if ( CAknTransitionUtils::TransitionsEnabled(
+iExtension->ImmediateFeedback(
-AknTransEffect::EComponentTransitionsOff ) )
+ETouchFeedbackSubMenuClosed );
-{
+}
-iExtension->ImmediateFeedback(
+else
-ETouchFeedbackPopupClose );
+{
-}
+iExtension->ImmediateFeedback(
-else
+ETouchFeedbackPopUp );
-{
-iExtension->ImmediateFeedback(
-ETouchFeedbackPopUp );
-}
 }
 iExtension->iShowCascadeTransition = ETrue;
 CloseCascadeMenu();
 }
-}
-else
-{
-TInt oldSelected = iSelectedItem;
-// update highlight to new item
-if ( oldSelected != ii )
-{
-iExtension->iPressedDown = EFalse;
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-if ( effects
-&& !iExtension->iShowCascadeTransition )
-{
-transApi->SetMoveType(
-MAknListBoxTfxInternal::EListDrag );
-}
-#endif
-}
-TRect screenRect( TPoint( KMinTInt, KMinTInt ),
-TPoint( KMaxTInt, KMaxTInt ) );
-TRect repeatRect( screenRect.iTl.iX, item->iPos,
-screenRect.iBr.iX, item->iPos
-+ iItemHeight );
 }
 // item found, break
 break;
 }
 }
 // -----------------------------------------------------------------------------
 //
 EXPORT_C void CEikMenuPane::SetSelectedItem( TInt aSelectedItem )
 {
 iSelectedItem = (aSelectedItem >= NumberOfItemsInPane() ) ? 0 : aSelectedItem;
-if( iExtension )
-iExtension->ChangeHighlightBackground();
 }
 // -----------------------------------------------------------------------------
 // CEikMenuPane::SelectedItem
 // -----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 //
 void CEikMenuPane::HandleScrollEventL( CEikScrollBar* aScrollBar, TEikScrollEvent aEventType )
 {
 _AKNTRACE_FUNC_ENTER;
-if( !AknLayoutUtils::PenEnabled())
-{
-return;
-}
 _AKNTRACE( "[%s]", "Stop physics engine");
 iExtension->iPhysics->StopPhysics();
 iExtension->iPhysics->ResetFriction();
 }
 // Items that becomes topmost and downmost items
 TInt newTopItem = 0;
 // if update is not wanted, do nothing.
 if ( update )
 {
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-MAknListBoxTfxInternal* transApi = CAknListLoader::TfxApiInternal(
-iExtension->iGc );
-TBool effects = transApi && !transApi->EffectsDisabled();
-#endif
 switch (aEventType)
 {
 case EEikScrollUp:
 {
 _AKNTRACE( "[%s]", "EEikScrollUp");
 case EEikScrollPageDown:
 {
 _AKNTRACE( "[%s]", "EEikScrollPageDown");
 _AKNTRACE( "bottomItem = %d", bottomItem);
-// if last item is not visible
+update = ETrue;
-if ( bottomItem < countOfItems)
-{
-// move menu to show one site down or then downmost items.
-newTopItem = (bottomItem <=  (countOfItems - itemsThatFitToView)) ? (topItem + itemsThatFitToView) : (countOfItems - itemsThatFitToView);
-}
-else
-{
-update = EFalse;
-}
-_AKNTRACE( "newTopItem = %d", newTopItem);
 _AKNTRACE( "update = %d", update);
 }
 break;
 case EEikScrollThumbDragVert:
 {
 _AKNTRACE( "[%s]", "EEikScrollThumbDragVert");
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-if ( effects )
-{
-MAknListBoxTfx* tfxApi = CAknListLoader::TfxApi( iExtension->iGc );
-if ( tfxApi )
-{
-tfxApi->EnableEffects( EFalse );
-effects = EFalse;
-}
-}
-#endif
 // new thumb position
 TInt thumb = aScrollBar->ThumbPosition();
 _AKNTRACE( "thumb = %d", thumb);
+update = ETrue;
-// did dragging cause scrolling
-if ( thumb != topItem )
-{
-newTopItem = thumb;
-}
-else
-{
-update = EFalse;
-}
-_AKNTRACE( "newTopItem = %d", newTopItem);
 _AKNTRACE( "update = %d", update);
 }
 break;
-case EEikScrollThumbReleaseVert:
-{
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-MAknListBoxTfx* tfxApi = CAknListLoader::TfxApi( iExtension->iGc );
-if ( tfxApi )
-{
-tfxApi->EnableEffects( ETrue );
-}
-#endif
-}
-return;
 default:
 update = EFalse;
 break;
 }
 // if topItem changed, then draw menu again.
-if ( newTopItem != topItem )
+if ( newTopItem != topItem || update )
 {
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
+iExtension->iListTopIndex = aScrollBar->ThumbPosition();
-if ( effects )
+TPoint newPosition( iExtension->iViewPosition.iX,
-{
+iExtension->iListTopIndex + iExtension->iViewHeight / 2 );
-transApi->SetMoveType( newTopItem > topItem ?
-MAknListBoxTfxInternal::EListScrollDown :
-MAknListBoxTfxInternal::EListScrollUp );
-}
-#endif
-iExtension->iListTopIndex = aScrollBar->ThumbPosition();
+iExtension->iFlags.Set( CEikMenuPaneExtension::ESkipScrollbarUpdate );
+iExtension->ViewPositionChanged( newPosition );
-iExtension->iViewPosition.iY =
+iExtension->iFlags.Clear( CEikMenuPaneExtension::ESkipScrollbarUpdate );
-iExtension->iListTopIndex + iExtension->iViewHeight / 2;
-iExtension->ViewPositionChanged( iExtension->iViewPosition );
 }
 }
 _AKNTRACE_FUNC_EXIT;
 }
 // -----------------------------------------------------------------------------
 // CEikMenuPane::CreateScrollBarFrame
 // -----------------------------------------------------------------------------
 //
 TRAPD( err,( iSBFrame = new(ELeave) CEikScrollBarFrame( this, iScroller, ETrue, ETrue ) ) );
 if ( !err )
 {
 CEikScrollBarFrame::TScrollBarVisibility visibility = CEikScrollBarFrame::EOn;
-if ( iOwner && ( iItemArray->Count() <= NumberOfItemsThatFitInView() ) )
+if ( iItemArray->Count() <= NumberOfItemsThatFitInView() )
 {
-// submenu with less than 6 items
+// all items fit, no need to show the scrollbar
 visibility = CEikScrollBarFrame::EOff;
 }
-TRAP_IGNORE( iSBFrame->SetScrollBarVisibilityL( CEikScrollBarFrame::EOff, visibility /*CEikScrollBarFrame::EAuto*/ ) );
+TRAP_IGNORE( iSBFrame->SetScrollBarVisibilityL( CEikScrollBarFrame::EOff, visibility ) );
 TRAP_IGNORE( iSBFrame->CreateDoubleSpanScrollBarsL( EFalse, EFalse, ETrue, EFalse ) );
 iSBFrame->DrawBackground( EFalse, EFalse );
 UpdateScrollBar();
 }
 }
 // CEikMenuPane::UpdateScrollBar
 // -----------------------------------------------------------------------------
 //
 void CEikMenuPane::UpdateScrollBar()
 {
-if ( !CheckCreateScroller() )
+if ( !CheckCreateScroller() || !IsVisible() )
 return;
 CIdle* idle = iScroller->Idle();
 if ( idle && !idle->IsActive() )
 idle->Start( TCallBack( CEikMenuPane::UpdateScrollBarCallBackL, this ) );
 }
 // -----------------------------------------------------------------------------
 // CEikMenuPane::UpdateScrollBarCallBackL
 // -----------------------------------------------------------------------------
 //
 TInt CEikMenuPane::UpdateScrollBarCallBackL( TAny* aObj )
 { // static
 REINTERPRET_CAST(CEikMenuPane*,aObj)->DoUpdateScrollBarL();
 return 0;
 }
 // -----------------------------------------------------------------------------
 // CEikMenuPane::DoUpdateScrollBarL
 // -----------------------------------------------------------------------------
 //
 return;
 _AKNTRACE_FUNC_ENTER;
 TEikScrollBarModel hSbarModel;
 TEikScrollBarModel vSbarModel;
-TRect menuPaneRect;
+TRect clientRect( iExtension->iMenuPaneRect.Size() );
-if ( !iOwner )
-{
-menuPaneRect = iExtension->iMenuPaneRect;
-}
-else
-{
-menuPaneRect = Rect();
-}
-TRect clientRect( menuPaneRect.Size() );
 // Panning uses pixel resolution scrollbar
 vSbarModel.iThumbPosition = iExtension->iListTopIndex;
 vSbarModel.iScrollSpan = TotalItemHeight();
 vSbarModel.iThumbSpan = iExtension->iViewHeight;
 TEikScrollBarFrameLayout layout;
 layout.SetClientMargin( 0 );
 layout.SetInclusiveMargin( 0 );
 layout.iTilingMode = TEikScrollBarFrameLayout::EClientRectConstant;
-// For main menupane scrollbar is always shown, for submenu only when needed
+CEikScrollBarFrame::TScrollBarVisibility visibility =
-if ( !iOwner )
+iSBFrame->ScrollBarVisibility( CEikScrollBar::EVertical );
-{
-iSBFrame->SetScrollBarVisibilityL( CEikScrollBarFrame::EOff, CEikScrollBarFrame::EOn );
+// scrollbar is shown only if needed
-}
+if ( iExtension->iScrollbarVisibility == CEikScrollBarFrame::EOn
-else
+&& visibility == CEikScrollBarFrame::EOff )
 {
-TInt maxItems = NumberOfItemsThatFitInView();
+iSBFrame->SetScrollBarVisibilityL( CEikScrollBarFrame::EOff,
-TInt count = iItemArray->Count();
+CEikScrollBarFrame::EOn );
-iSBFrame->SetScrollBarVisibilityL( CEikScrollBarFrame::EOff,
+iExtension->iScrollBarRect = iSBFrame->VerticalScrollBar()->Rect();
-(count > maxItems) ? CEikScrollBarFrame::EOn : CEikScrollBarFrame::EOff );
+}
-}
+else if ( iExtension->iScrollbarVisibility == CEikScrollBarFrame::EOff
+&& visibility == CEikScrollBarFrame::EOn )
+{
+iSBFrame->SetScrollBarVisibilityL( CEikScrollBarFrame::EOff,
+CEikScrollBarFrame::EOff );
+iExtension->iScrollBarRect = TRect::EUninitialized;
+}
 TAknLayoutRect scrollLayoutRect;
-if ( !iOwner )
+scrollLayoutRect.LayoutRect( clientRect,
-{
+AknLayoutScalable_Avkon::listscroll_popup_sub_pane().LayoutLine() );
-TAknWindowLineLayout listScrollPaneLayout(
+scrollBarInclusiveRect = scrollLayoutRect.Rect();
-AknLayoutScalable_Avkon::listscroll_menu_pane(0).LayoutLine() );
+scrollBarClientRect = scrollBarInclusiveRect;
-if ( iExtension )
-{
+AknLayoutUtils::LayoutVerticalScrollBar( iSBFrame, scrollBarClientRect,
-iExtension->AdjustPopupLayoutData( listScrollPaneLayout );
+AknLayoutScalable_Avkon::scroll_pane_cp4().LayoutLine());
-}
-scrollLayoutRect.LayoutRect( clientRect, listScrollPaneLayout );
-scrollBarInclusiveRect =  scrollLayoutRect.Rect();
-scrollBarClientRect = scrollBarInclusiveRect;
-AknLayoutUtils::LayoutVerticalScrollBar( iSBFrame, scrollBarClientRect,
-AknLayoutScalable_Avkon::scroll_pane_cp25(0).LayoutLine() );
-}
-else
-{
-scrollLayoutRect.LayoutRect( clientRect,
-AknLayoutScalable_Avkon::listscroll_popup_sub_pane().LayoutLine() );
-scrollBarInclusiveRect = scrollLayoutRect.Rect();
-scrollBarClientRect = scrollBarInclusiveRect;
-AknLayoutUtils::LayoutVerticalScrollBar( iSBFrame, scrollBarClientRect,
-AknLayoutScalable_Avkon::scroll_pane_cp4().LayoutLine());
-}
 iSBFrame->TileL( &hDsSbarModel, &vDsSbarModel, scrollBarClientRect, scrollBarInclusiveRect, layout );
 iSBFrame->SetVFocusPosToThumbPos( vDsSbarModel.FocusPosition() );
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-MAknListBoxTfxInternal* transApi = CAknListLoader::TfxApiInternal( iExtension->iGc );
-if ( iSBFrame->VerticalScrollBar() &&
-iSBFrame->VScrollBarVisibility() == CEikScrollBarFrame::EOn )
-{
-iExtension->iScrollBarRect = iSBFrame->VerticalScrollBar()->Rect();
-}
-else
-{
-iExtension->iScrollBarRect = TRect::EUninitialized;
-}
-if ( transApi )
-{
-transApi->ResetNonDrawingRects();
-transApi->AddNonDrawingRect( iExtension->iScrollBarRect );
-transApi->AddNonDrawingRect( iExtension->iSctRect );
-}
-#endif // RD_UI_TRANSITION_EFFECTS_LIST
-if ( iSBFrame->VerticalScrollBar() &&
-iSBFrame->VScrollBarVisibility() == CEikScrollBarFrame::EOn )
-{
-iExtension->iSBRect = iSBFrame->VerticalScrollBar()->Rect();
-}
-else
-{
-iExtension->iSBRect = TRect::EUninitialized;
-}
 _AKNTRACE_FUNC_EXIT;
 }
 // -----------------------------------------------------------------------------
 // CEikMenuPane::UpdateScrollBarThumbs
 // -----------------------------------------------------------------------------
 //
 void CEikMenuPane::UpdateScrollBarThumbs()
 if ( iSBFrame )
 {
 iSBFrame->SetVFocusPosToThumbPos( iExtension->iListTopIndex );
 }
 }
 // -----------------------------------------------------------------------------
 // CEikMenuPane::ScrollToMakeItemVisible
 // -----------------------------------------------------------------------------
 //
 {
 UpdateScrollBar();
 }
 else
 {
-DoUpdateScrollBarL();
+TRAP_IGNORE( DoUpdateScrollBarL() );
 }
 }
 _AKNTRACE_FUNC_EXIT;
 return;
 }
 // -----------------------------------------------------------------------------
 // CEikMenuPane::Scroll
 // -----------------------------------------------------------------------------
 //
 newTop = Max( 0, newTop );
 newTop = Min( newTop, count - NumberOfItemsThatFitInView() );
 iScroller->SetTopItemIndex( newTop );
 _AKNTRACE( "newTop =  %d", newTop );
-// Menu moved with keys, update panning/flicking data
 iExtension->iListTopIndex = iScroller->TopItemIndex() * iItemHeight;
-iExtension->iViewPosition.iY =
+TPoint newPosition( iExtension->iViewPosition );
-iExtension->iListTopIndex + iExtension->iViewHeight / 2;
+newPosition.iY = iExtension->iListTopIndex + iExtension->iViewHeight / 2;
 iExtension->SetOffset( 0 );
+iExtension->ViewPositionChanged( newPosition );
 _AKNTRACE( "iExtension->iListTopIndex =  %d", iExtension->iListTopIndex );
 _AKNTRACE( "iExtension->iViewPosition.iY =  %d", iExtension->iViewPosition.iY );
 _AKNTRACE( "[%s]", "iExtension->SetOffset( 0 )" );
 _AKNTRACE_FUNC_EXIT;
 return;
 }
 // -----------------------------------------------------------------------------
 // CEikMenuPane::ViewRect
 // -----------------------------------------------------------------------------
 //
 TRect CEikMenuPane::ViewRect() const
 {
 return Rect();
 }
 // -----------------------------------------------------------------------------
 // CEikMenuPane::NumberOfItemsThatFitInView
 // -----------------------------------------------------------------------------
 //
 TInt subst = 0;
 if ( iExtension->iSct )
 {
 subst = 1;
 }
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
 iExtension->iItemsThatFitInView = iOwner ? AknLayoutScalable_Avkon::
 list_single_popup_submenu_pane_ParamLimits().LastRow() + 1 :
 AknLayoutScalable_Avkon::
 list_single_pane_cp2_ParamLimits().LastRow() + 1 - subst;
 if ( Layout_Meta_Data::IsLandscapeOrientation()
 && iExtension->iItemsThatFitInView == 6 )
 {
 iExtension->iItemsThatFitInView --;
 }
-if ( iExtension->iPhysics && iExtension->Offset() != 0 )
-{
-// with kinetic scrolling there can be partial items on the screen
-iExtension->iTotalNumberOfItemsInView = iExtension->iItemsThatFitInView + 1;
-}
 return iExtension->iItemsThatFitInView;
-#else
+}
-return iOwner ? AknLayoutScalable_Avkon::
-list_single_popup_submenu_pane_ParamLimits().LastRow() + 1 :
-AknLayoutScalable_Avkon::
-list_single_pane_cp2_ParamLimits().LastRow() + 1 - subst;
-#endif
-}
 // -----------------------------------------------------------------------------
 // CEikMenuPane::TotalItemHeight
 // -----------------------------------------------------------------------------
 //
 {
 TRAP( err,( iScroller = CMenuScroller::NewL( *this ) ) );
 }
 return err == KErrNone;
 }
 // -----------------------------------------------------------------------------
 // CEikMenuPane::CheckCreateScrollerL
 // -----------------------------------------------------------------------------
 //
 }
 TRect rect( CalculateSizeAndPosition() );
 SetExtent( rect.iTl, rect.Size() );
-TRAP_IGNORE( DoUpdateScrollBarL() );
-UpdateBackgroundContext( Rect() );
-PrepareHighlightFrame();
-SetCascadedIconSize();
-// Background under highlight may have changed -> we need to update
-// highlight background to animation
-if( iExtension )
-{
-iExtension->HandleLayoutSwitch();
-}
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-MAknListBoxTfxInternal *transApi = CAknListLoader::TfxApiInternal( iExtension->iGc );
-if ( transApi )
-{
-transApi->Remove( MAknListBoxTfxInternal:: EListEverything );
-}
-#endif
 //Initialize physics engine
 if ( iExtension->iPhysics )
 {
 TRAP_IGNORE ( iExtension->InitPhysicsL() );
 iExtension->iListTopIndex = iScroller->TopItemIndex() * iItemHeight;
 iExtension->iViewPosition.iY =
 iExtension->iListTopIndex + iExtension->iViewHeight / 2;
-iExtension->ViewPositionChanged( iExtension->iViewPosition );
+}
-}
+TRAP_IGNORE( DoUpdateScrollBarL() );
+UpdateBackgroundContext( Rect() );
+PrepareHighlightFrame();
+SetCascadedIconSize();
+DrawDeferred();
 if ( iCascadeMenuPane )
 {
 iCascadeMenuPane->HandleResourceChange( aType );
 }
 {
 TPointerEvent pointerEvent = iExtension->iLastPointerEvent;
 pointerEvent.iType = TPointerEvent::EButton1Up;
 // Sending a up event to scroll bar for dehighlighting
 // the scroll bar.
-verScrollBar->HandlePointerEventL(pointerEvent);
+TRAP_IGNORE ( verScrollBar->HandlePointerEventL(pointerEvent) );
 iSBFrame->DrawScrollBarsDeferred();
 ClaimPointerGrab( EFalse );
 }
 }
 // Fixed for TSW error ELLI-7UG89S
 }
 }
 }
 else if ( aType == KAknMessageFocusLost )
 {
-if ( iExtension && iExtension->HighlightEnabled() )
+if ( iCascadeMenuPane )
+{
+iCascadeMenuPane->HandleResourceChange( aType );
+}
+else if ( iExtension && iExtension->HighlightEnabled() )
 {
 iExtension->EnableHighlight( EFalse, EFalse );
 DrawItem( iSelectedItem, ENoHighlight );
 }
 }
 _AKNTRACE_FUNC_ENTER;
 TRect retVal;
 // it can be only in submenu in case when scalable layout is available
 TBool hasIcon = MenuHasIcon();
-TBool hasDoubleSpanScrollBar = EFalse;
+// scrollbar is shown only if needed
-if ( iSBFrame && iSBFrame->VScrollBarVisibility() )
+if ( iItemArray->Count() > NumberOfItemsThatFitInView() )
 {
-_AKNTRACE( "[%s]", "hasDoubleSpanScrollBar = ETrue;" );
+iExtension->iScrollbarVisibility = CEikScrollBarFrame::EOn;
-hasDoubleSpanScrollBar = ETrue;
+}
-}
+else
+{
+iExtension->iScrollbarVisibility = CEikScrollBarFrame::EOff;
+}
 TRect parentMenuRect;
 AknLayoutUtils::TAknCbaLocation cbaPosition = AknLayoutUtils::CbaLocation();
 if ( !iOwner )
 {
 _AKNTRACE( "parentMenuRect.iTl.iX = %d", parentMenuRect.iTl.iX );
 _AKNTRACE( "parentMenuRect.iTl.iY = %d", parentMenuRect.iTl.iY );
 _AKNTRACE( "parentMenuRect.Width() = %d", parentMenuRect.Width() );
 _AKNTRACE( "parentMenuRect.Height( = %d", parentMenuRect.Height() );
-// if we have landscape layout then main menu should be positioned vertically centered
-TRect appRect( iEikonEnv->EikAppUi()->ApplicationRect() );
 if ( !iOwner ) // main menu
 {
 // Embedded cba
 TRect screen;
 // CEikMenuPane rect contains empty space. We want the popup content
 // to be in correct place - so we calculate correct position for
 // background and move control rect to match new background top left
 // position.
-TRect backgroundRect( iExtension->GetBackgroundRect( parentMenuRect ) );
 TPoint backgroundRectPos(
-AknPopupUtils::Position( backgroundRect.Size(), ETrue ) );
+AknPopupUtils::Position( parentMenuRect.Size(), ETrue ) );
 retVal = parentMenuRect;
-retVal.Move( backgroundRectPos - backgroundRect.iTl );
+retVal.Move( backgroundRectPos - parentMenuRect.iTl );
 // Set embedded cba rect
 if ( iExtension->iCba )
 {
 // There is hidden extra touch space for scroll bar in landscape
-TInt xOffset = backgroundRect.iTl.iX - parentMenuRect.iTl.iX ;
+TInt xOffset = parentMenuRect.iTl.iX - parentMenuRect.iTl.iX ;
 iExtension->iCba->SetRect( TRect(
 xOffset,
 menuRect.Height(),
-backgroundRect.Width() + xOffset,
+parentMenuRect.Width() + xOffset,
 menuRect.Height() + cbaRect.Rect().Height() ) );
 }
 iExtension->iMenuPaneRect = TRect( retVal.iTl,
 TSize ( menuRect.Size() ) );
+TInt variety = 4;
+// reserve area for scrollbar only if it's shown
+if ( iExtension->iScrollbarVisibility == CEikScrollBarFrame::EOn )
+{
+variety = 0;
+}
+TAknLayoutRect layoutRect;
+layoutRect.LayoutRect( TRect( iExtension->iMenuPaneRect.Size() ),
+AknLayoutScalable_Avkon::listscroll_popup_sub_pane( 0 ) );
+iExtension->iMenuAreaRect = layoutRect.Rect();
+layoutRect.LayoutRect( iExtension->iMenuAreaRect,
+AknLayoutScalable_Avkon::list_menu_pane( variety ) );
+iExtension->iItemAreaRect = layoutRect.Rect();
 _AKNTRACE( "[%s]", "the layout of main menu return" );
 _AKNTRACE_FUNC_EXIT;
 return retVal;
 }
 TInt parentCount = iOwner->iItemArray->Count(); // There must be at least one parent item for a submenu to have popped up.
 iExtension->iSubMenuWidthIndex = KAlternativeSubmenuWidths - 1;
 TAknLayoutRect parentListScrollLayoutRect;     // listscroll_menu_pane
-TAknLayoutRect parentPaneLayoutRect;           // list_menu_pane
 TAknTextLineLayout subMenuText;                // layout for the text when item is not indicated
 TAknTextLineLayout subMenuIconText;            // layout for the text when item is indicated
 TAknWindowLineLayout parentListScrollPaneLayout(
 AknLayoutScalable_Avkon::listscroll_menu_pane(0).LayoutLine() );
-if ( iExtension )
-{
-iExtension->AdjustPopupLayoutData( parentListScrollPaneLayout );
-}
 parentListScrollLayoutRect.LayoutRect( parentMenuRect, parentListScrollPaneLayout );
-parentPaneLayoutRect.LayoutRect( parentListScrollLayoutRect.Rect(),
-AknLayoutScalable_Avkon::list_menu_pane(0).LayoutLine() );
 subMenuText = AknLayoutScalable_Avkon::list_single_popup_submenu_pane_t1(0).LayoutLine();
 subMenuIconText = AknLayoutScalable_Avkon::list_single_popup_submenu_pane_t1(1).LayoutLine();
 // Choose correct submenu width
 // Find the narrowest layout that will accommodate the text
 textWidth = font->TextWidthInPixels( item->iData.iText );
 maxTextWidth = Max( maxTextWidth, textWidth );
 }
 // find the suitable item width, so that the text would be visible
+TInt submenuVariety = 1;
+if ( iExtension->iScrollbarVisibility == CEikScrollBarFrame::EOn )
+{
+submenuVariety = 0;
+}
 for ( ii = 6; ii < KAlternativeSubmenuWidths + 6; ++ii )
 {
 TAknWindowLineLayout submenuLayout( AknLayoutScalable_Avkon::popup_submenu_window( ii ).LayoutLine() );
 TAknLayoutRect submenuRect;
 submenuRect.LayoutRect( parentListScrollLayoutRect.Rect(), submenuLayout );
 TAknWindowLineLayout listScrollPaneLayout( AknLayoutScalable_Avkon::listscroll_popup_sub_pane().LayoutLine() );
 TAknLayoutRect listScrollPaneRect;
 listScrollPaneRect.LayoutRect( submenuRect.Rect(), listScrollPaneLayout );
-TAknWindowLineLayout listSubmenuPaneLayout( AknLayoutScalable_Avkon::list_submenu_pane( !hasDoubleSpanScrollBar ).LayoutLine() );
+TAknWindowLineLayout listSubmenuPaneLayout( AknLayoutScalable_Avkon::list_submenu_pane( submenuVariety ).LayoutLine() );
 TAknLayoutRect listSubmenuPaneRect;
 listSubmenuPaneRect.LayoutRect( listScrollPaneRect.Rect(), listSubmenuPaneLayout );
 TAknLayoutText textIconLayout;
 textIconLayout.LayoutText( listSubmenuPaneRect.Rect(), subMenuIconText);
 // Position of submenu depends upon parent size and position of selected item. Position is 1 at bottom up to six at top
 TInt parentPos = iOwner->iScroller->TopItemIndex() - iOwner->SelectedItem() +
 Min( parentCount, iOwner->NumberOfItemsThatFitInView() );
-TInt index =  iOwner->SelectedItem() - iOwner->iScroller->TopItemIndex();
+TRect parentSelectedItemRect( iOwner->HighlightRect() );
-TInt rows = AknLayoutScalable_Avkon::list_single_pane_cp2_ParamLimits().LastRow();
+parentSelectedItemRect.Move( iOwner->Position() );
-// This condition may be true if less items fits to menu view than sub-menu view
-// and sub-menu under sub-menu is launched.
-if (index > rows)
-{
-// Change the out-of-boundary index to last legal one.
-index = rows;
-}
-TAknLayoutRect parentSelectedItemRect;
-parentSelectedItemRect.LayoutRect( parentPaneLayoutRect.Rect(),
-AknLayoutScalable_Avkon::list_single_pane_cp2( index ).LayoutLine() );
 TAknLayoutRect submenuWindowRect;
 // To prevent a panic in layout code, count has to be at least 1 even if
 // submenu is empty. Otherwise the index is out of bounds.
 if ( count == 0 )
 enum { EFloating, EBottom } subMenuPos;
 if ( ( Layout_Meta_Data::IsLandscapeOrientation()
 && cbaPosition != AknLayoutUtils::EAknCbaLocationBottom ) )
 {
-if ( ( parentSelectedItemRect.Rect().iTl.iY + submenuWindowRect.Rect().Height() ) >
+if ( ( parentSelectedItemRect.iTl.iY + submenuWindowRect.Rect().Height() ) >
 aWindowRect.iBr.iY )
 {
 subMenuPos = EBottom;
 }
 else
 TSize( submenuWindowRect.Rect().Width() + widthOffset, submenuWindowRect.Rect().Height() ) );
 }
 }
 else  // floating
 {
-TInt yPos = parentSelectedItemRect.Rect().iTl.iY -
+TInt yPos = parentSelectedItemRect.iTl.iY -
 ( listScrollPaneRect.Rect().iTl.iY - submenuWindowRect.Rect().iTl.iY );
 // When a submenu is floating, make sure that the possible panning offset of the
 // parent menu is taken into account.
 yPos += iOwner->iExtension->Offset();
 TInt offset = retVal.iBr.iY -
 iOwner->iExtension->iMenuPaneRect.iBr.iY;
 retVal.Move( 0, -offset );
 }
 }
+if ( retVal.iTl.iY < 0 )
+{
+retVal.Move( 0, -retVal.iTl.iY );
+}
+iExtension->iMenuPaneRect = retVal;
+TAknLayoutRect layoutRect;
+layoutRect.LayoutRect( TRect( iExtension->iMenuPaneRect.Size() ),
+AknLayoutScalable_Avkon::listscroll_popup_sub_pane( 0 ) );
+iExtension->iMenuAreaRect = layoutRect.Rect();
+layoutRect.LayoutRect( iExtension->iMenuAreaRect,
+AknLayoutScalable_Avkon::list_submenu_pane( submenuVariety ) );
+iExtension->iItemAreaRect = layoutRect.Rect();
 _AKNTRACE( "[%s]", "the layout of sub menu return" );
 _AKNTRACE_FUNC_EXIT;
 return retVal;
 }
 // TopItemIndex. Which results in negative index. This "fix" prevents from
 // crashing the menu.
 if( index < 0 )
 index = 0;
-// It is possible that this method is called when iItemArray is NULL.  In
-// that case we fake numItems as 1 to make layout code work.
-TInt maxItems = NumberOfItemsThatFitInView();
-TInt numItems = Min( Max( 1, iItemArray->Count() ), maxItems );
-if( !iItemArray )
-numItems = 1;
 // When physics is enabled highlight can be moved to partially visible
 // item which is at the bottom of menu. This causes layout panic and to
 // avoid that we reduce index by one.
-if ( index == maxItems )
+if ( index == NumberOfItemsThatFitInView() )
 {
 index--;
 }
-TRect windowRect = Rect();
+return ItemRect( index );
-TAknWindowLineLayout menuPane( AKN_LAYOUT_WINDOW_list_menu_pane( 0 , 0 ) );
-TAknWindowLineLayout singleMenuPane( AKN_LAYOUT_WINDOW_list_single_popup_menu_pane( index ) );
-TAknLayoutRect menuPaneRect;
-TAknLayoutRect singleMenuPaneRect;
-TBool hasDoubleSpanScrollBar = EFalse;
-if ( iSBFrame && iSBFrame->VScrollBarVisibility() )
-{
-hasDoubleSpanScrollBar = ETrue;
-}
-if ( !iOwner )
-{
-TAknWindowLineLayout listScrollPaneLayout(
-AknLayoutScalable_Avkon::listscroll_menu_pane(0).LayoutLine() );
-if ( iExtension )
-{
-iExtension->AdjustPopupLayoutData( listScrollPaneLayout );
-}
-TAknLayoutRect listScrollPaneRect;
-listScrollPaneRect.LayoutRect( windowRect, listScrollPaneLayout );
-menuPane = AknLayoutScalable_Avkon::list_menu_pane( 0 ).LayoutLine();
-menuPaneRect.LayoutRect( listScrollPaneRect.Rect(), menuPane );
-singleMenuPane = AknLayoutScalable_Avkon::list_single_pane_cp2( index ).LayoutLine();
-singleMenuPaneRect.LayoutRect( menuPaneRect.Rect(), singleMenuPane );
-}
-else // Submenu
-{
-TAknWindowLineLayout listScrollPaneLayout( AknLayoutScalable_Avkon::listscroll_popup_sub_pane().LayoutLine() );
-TAknLayoutRect listScrollPaneRect;
-listScrollPaneRect.LayoutRect( windowRect, listScrollPaneLayout );
-menuPane = AknLayoutScalable_Avkon::list_submenu_pane( !hasDoubleSpanScrollBar ).LayoutLine();
-menuPaneRect.LayoutRect( listScrollPaneRect.Rect(), menuPane );
-singleMenuPane = AknLayoutScalable_Avkon::list_single_popup_submenu_pane( index ).LayoutLine();
-singleMenuPaneRect.LayoutRect( menuPaneRect.Rect(), singleMenuPane );
-}
-// Compared to normal DrawItem the highlight rect step is omitted because
-// it would shift the highlight towards left.
-return singleMenuPaneRect.Rect();
 }
 // -----------------------------------------------------------------------------
 // CEikMenuPane::PrepareHighlightFrame
 if( itemData )
 {
 AknIconUtils::SetSize( itemData->Bitmap(),  cascadeRect.Rect().Size() );
 }
 else
 {
 if (iExtension->iCascadeBitmap)
 {
 AknIconUtils::SetSize( iExtension->iCascadeBitmap,  cascadeRect.Rect().Size() );
 // -----------------------------------------------------------------------------
 //
 EXPORT_C TInt CEikMenuPane::CountComponentControls() const
 {
 TInt count = 0;
-if ( iSBFrame && iSBFrame->VerticalScrollBar() &&
+if ( iSBFrame && iSBFrame->VerticalScrollBar() )
-!( iSBFrame->VerticalScrollBar()->OwnsWindow() ) )
 {
 count = 1;
 }
 if ( iExtension->iSct )
 {
 {
 switch ( aIndex)
 {
 case 0:
 {
-if ( iSBFrame && iSBFrame->VerticalScrollBar() &&
+if ( iSBFrame && iSBFrame->VerticalScrollBar() )
-!( iSBFrame->VerticalScrollBar()->OwnsWindow() ) )
 {
 return iSBFrame->VerticalScrollBar();
 }
 }
 case 1:
 __ASSERT_ALWAYS( iExtension, Panic( EEikPanicNullPointer ) );
 return iExtension;
 }
+// -----------------------------------------------------------------------------
+// CEikMenuPane::CheckCreateExtensionL
+// -----------------------------------------------------------------------------
+//
 void CEikMenuPane::CheckCreateExtensionL()
 {
 if ( !iExtension )
 {
 iExtension = new (ELeave) CEikMenuPaneExtension;
 iExtension->ConstructL( this );
 }
+}
+// -----------------------------------------------------------------------------
+// CEikMenuPane::ItemRect
+// -----------------------------------------------------------------------------
+//
+TRect CEikMenuPane::ItemRect( TInt aItemIndex ) const
+{
+// this method is valid for the main menu only
+TInt lastRow = AknLayoutScalable_Avkon::list_single_pane_cp2_ParamLimits().LastRow();
+aItemIndex = Min( aItemIndex, lastRow );
+TAknLayoutRect layoutRect;
+layoutRect.LayoutRect( iExtension->iItemAreaRect,
+AknLayoutScalable_Avkon::list_single_pane_cp2( aItemIndex ) );
+return layoutRect.Rect();
+}
+// -----------------------------------------------------------------------------
+// CEikMenuPane::CalculateItemHeight
+// -----------------------------------------------------------------------------
+//
+TInt CEikMenuPane::CalculateItemHeight() const
+{
+TAknWindowLineLayout menuLineLayout;
+if ( iOwner ) // submenu
+{
+menuLineLayout =
+AknLayoutScalable_Avkon::list_single_popup_submenu_pane( 0 ).LayoutLine();
+}
+else
+{
+menuLineLayout =
+AknLayoutScalable_Avkon::list_single_pane_cp2( 0 ).LayoutLine();
+}
+TAknLayoutRect menuLayoutRect;
+menuLayoutRect.LayoutRect( Rect(), menuLineLayout );
+return menuLayoutRect.Rect().Height();
 }
 // -----------------------------------------------------------------------------
 // CEikMenuPane::ConstructMenuSctRowL
 TInt resourceId = R_AVKON_MENU_SCT_ROW_DEFAULT_CONTENTS;
 if (FeatureManager::FeatureSupported(KFeatureIdChinese))
 {
 resourceId = R_AVKON_MENU_SCT_ROW_DEFAULT_CONTENTS_CHINESE;
 }
+if (FeatureManager::FeatureSupported(KFeatureIdKorean))
+{
+resourceId = R_AVKON_MENU_SCT_ROW_DEFAULT_CONTENTS_KOREAN;
+}
 iExtension->ConstructMenuSctRowL( aSpecialChars, resourceId );
 }
 // -----------------------------------------------------------------------------
 // CEikMenuPane::ConstructMenuSctRowL
 // -----------------------------------------------------------------------------
 //
 EXPORT_C void CEikMenuPane::SetItemSpecific(
 TInt aCommandId, TBool aItemSpecific )
 {
+if ( !iExtension )
+{
+TRAPD( err, CheckCreateExtensionL() );
+if ( err )
+{
+return;
+}
+}
 if ( iExtension->iFlags.IsSet(
 CEikMenuPaneExtension::ESingleClickEnabled ) )
 {
 CEikMenuPaneItem::SData& itemData = ItemData( aCommandId );
 if ( aItemSpecific )
 //iExtension->StartCascadeMenuDisappearTransition();
 if ( iCascadeMenuPane->IsVisible() )
 {
 okToDraw = AknsUtils::SkinInstance() != NULL;
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
-MAknListBoxTfxInternal *transApi = CAknListLoader::TfxApiInternal( iExtension->iGc );
-if ( transApi && okToDraw )
-{
-iCascadeMenuPane->SetFocus( EFalse, EDrawNow );
-}
-#endif
 // Stop ongoing comp. transitions, this is mostly for fast clicking
 // cases to make sure that no "scrap" is left behind.
 GfxTransEffect::NotifyExternalState( ENotifyGlobalAbort );
 // cascade menu "cancel" animation. This does not apply
 // when something is chosen from the menu
+if ( iExtension->iShowCascadeTransition && okToDraw )
-if( iExtension->iShowCascadeTransition && okToDraw )
+{
-{
+iCascadeMenuPane->SetParent( this );
-iCascadeMenuPane->SetParent( this );
+GfxTransEffect::Begin( iCascadeMenuPane, KGfxControlDisappearAction );
-GfxTransEffect::Begin( iCascadeMenuPane, KGfxControlDisappearAction );
+GfxTransEffect::SetDemarcation( iCascadeMenuPane, iExtension->iCascadeDRect );
-GfxTransEffect::SetDemarcation( iCascadeMenuPane, iExtension->iCascadeDRect );
+iCascadeMenuPane->MakeVisible( EFalse );
+GfxTransEffect::End( iCascadeMenuPane );
-iCascadeMenuPane->MakeVisible( EFalse );
-GfxTransEffect::End( iCascadeMenuPane );
 }
 }
 // deregister right away since cascade menu is deleted
 GfxTransEffect::Deregister( iCascadeMenuPane );
 return menuPane;
 }
 // -----------------------------------------------------------------------------
-// CEikMenuPane::SetItemCommandsDimmed
+// CEikMenuPane::SetItemCommandsStateL
 // -----------------------------------------------------------------------------
 //
-void CEikMenuPane::SetItemCommandsDimmed()
+void CEikMenuPane::SetItemCommandsStateL( TBool aDimmed )
 {
 if ( iExtension && iExtension->iFlags.IsSet(
 CEikMenuPaneExtension::ESingleClickEnabled ) )
 {
-iExtension->iFlags.Set(
+if ( aDimmed )
-CEikMenuPaneExtension::EHideItemSpecificCommands );
+{
+iExtension->iFlags.Set(
+CEikMenuPaneExtension::EHideItemSpecificCommands );
+}
+else
+{
+iExtension->iFlags.Set(
+CEikMenuPaneExtension::EHideViewSpecificCommands );
+}
 for ( TInt i = 0; i < iItemArray->Count(); ++i )
 {
 CEikMenuPaneItem* item = iItemArray->At( i );
-if ( item->iData.iFlags & EEikMenuItemAction
+TBool itemSpecificItem(
+item->iData.iFlags & EEikMenuItemAction
 || item->iData.iFlags & EEikMenuItemSpecific
-|| item->iData.iFlags & EEikMenuItemSpecificListQuery )
+|| item->iData.iFlags & EEikMenuItemSpecificListQuery );
+// Dim item specific items
+if ( aDimmed && itemSpecificItem )
 {
 item->iData.iFlags |= EEikMenuItemDimmed;
 }
-}
+// Dim items not item specific
-}
+else if ( !aDimmed
-}
+&& ( !itemSpecificItem
+|| item->iData.iFlags & EEikMenuItemAction ) )
+{
+item->iData.iFlags |= EEikMenuItemDimmed;
+if ( item->iData.iCascadeId )
+{
+// i is not updated in AddCascadeMenuItemsToMenuL so going
+// through added items again here. Then it goes through
+// also submenus of submenus.
+AddCascadeMenuItemsToMenuL(
+item->iData.iCascadeId, ETrue, EFalse, NULL, i );
+}
+}
+}
+}
+}
+// -----------------------------------------------------------------------------
+// CEikMenuPane::SetItemActionsStateL
+// -----------------------------------------------------------------------------
+//
+void CEikMenuPane::SetItemActionsStateL( TBool aDimmed )
+{
+if ( iExtension && iExtension->iFlags.IsSet(
+CEikMenuPaneExtension::ESingleClickEnabled ) )
+{
+if ( aDimmed )
+{
+iExtension->iFlags.Set(
+CEikMenuPaneExtension::EHideItemActionCommands );
+}
+for ( TInt i = 0; i < iItemArray->Count(); ++i )
+{
+CEikMenuPaneItem* item = iItemArray->At( i );
+TBool itemActionItem(
+item->iData.iFlags & EEikMenuItemAction );
+// Dim item specific items
+if ( aDimmed && itemActionItem )
+{
+item->iData.iFlags |= EEikMenuItemDimmed;
+}
+}
+}
+}
 // -----------------------------------------------------------------------------
 // CEikMenuPane::AddMenuItemsToItemActionMenuL
 // -----------------------------------------------------------------------------
 //
 // If menu item is not list query and it has cascade menu
 // add cascade menu items to menu data directly
 if ( !( item->iData.iFlags & EEikMenuItemSpecificListQuery )
 && item->iData.iCascadeId )
 {
-AddCascadeMenuItemsToActionMenuL(
+AddCascadeMenuItemsToMenuL(
-item->iData.iCascadeId, EFalse, aMenuData );
+item->iData.iCascadeId, EFalse, ETrue, &aMenuData );
 }
 // If menu item is list query or it does not have cascade menu
 else
 {
 aMenuData.AddMenuItemToDataArrayL(
 // If item is not item specific, add its item specific cascade menu
 // items if the item itself isn't dimmed.
 else if ( item->iData.iCascadeId &&
 !( item->iData.iFlags & EEikMenuItemDimmed ) )
 {
-AddCascadeMenuItemsToActionMenuL(
+AddCascadeMenuItemsToMenuL(
-item->iData.iCascadeId, ETrue, aMenuData );
+item->iData.iCascadeId, ETrue, ETrue, &aMenuData );
 }
 }
 }
 // -----------------------------------------------------------------------------
-// CEikMenuPane::AddCascadeMenuItemsToActionMenuL
+// CEikMenuPane::AddCascadeMenuItemsToMenuL
 // -----------------------------------------------------------------------------
 //
-void CEikMenuPane::AddCascadeMenuItemsToActionMenuL(
+void CEikMenuPane::AddCascadeMenuItemsToMenuL(
 TInt aCascadeId,
 TBool aItemSpecific,
-CAknItemActionMenuData& aMenuData )
+TBool aAddToItemActionMenu,
+CAknItemActionMenuData* aMenuData,
+TInt aItemIndex )
 {
 if ( aCascadeId && iCoeEnv->IsResourceAvailableL( aCascadeId ) )
 {
 CEikMenuPane* cascadeMenu =
 CEikMenuPane::NewItemCommandMenuL( iMenuObserver );
 if ( ( aItemSpecific
 && CEikMenuPaneExtension::ItemSpecificCommand( *item ) )
 || ( !aItemSpecific
 && !( item->iData.iFlags & EEikMenuItemDimmed ) ) )
 {
-aMenuData.AddMenuItemToDataArrayL(
+if ( aAddToItemActionMenu )
-item->iData.iCommandId,
+{
-item->iData.iCascadeId,
+aMenuData->AddMenuItemToDataArrayL(
-item->iData.iText );
+item->iData.iCommandId,
+item->iData.iCascadeId,
+item->iData.iText );
+}
+else
+{
+InsertMenuItemL( item->iData, ++aItemIndex );
+}
 }
 }
 CleanupStack::PopAndDestroy( cascadeMenu );
 }
 }
 {
 iExtension->SetDefaultHighlight();
 }
 }
+// -----------------------------------------------------------------------------
+// CEikMenuPane::HideMarkAndUnmark
+// -----------------------------------------------------------------------------
+//
+void CEikMenuPane::HideMarkAndUnmark( TBool aHide )
+{
+if ( aHide )
+{
+iExtension->iFlags.Set( CEikMenuPaneExtension::EHideMarkAndUnmark );
+}
+else
+{
+iExtension->iFlags.Clear( CEikMenuPaneExtension::EHideMarkAndUnmark );
+}
+}
+// -----------------------------------------------------------------------------
+// CEikMenuPane::CleanLocalRef
+// -----------------------------------------------------------------------------
+//
+void CEikMenuPane::CleanLocalRef( TAny* aParam )
+{
+static_cast<CEikMenuPane*>( aParam )->iIsDeleted = NULL;
+}
 // end of file

branch	RCL_3
changeset 56	d48ab3b357f1
parent 55	aecbbf00d063
child 72	a5e7a4f63858