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

equal deleted inserted replaced

-:aecbbf00d063
+:d48ab3b357f1
 /*
-* Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).
+* Copyright (c) 1997-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 <touchfeedback.h>
 #include <akncollection.h>
 #include <aknitemactionmenu.h>
 #include <aknlongtapdetector.h>
 #include <AknPriv.hrh>
+#include <aknmarkingmodeobserver.h>
 #include "akntrace.h"
 // timeout for long keypress used in markable lists
 const TInt KLongPressInterval = 600000; // 0,6 seconds
 const TInt KEikListBoxPointerRepeatInterval = 100000;  // in micro conds (= 0.1 secod)
 // Maximum scroll speed ( max amount of items moved one time )
 const TInt KDefaultMaxSpeed = 30;
 const TInt KDefaultStepSpeed = 5;
 const TInt KEikListBoxInvalidIndex=-1;
 //interval time for disable second point event
 const TInt KTwoPointerUpEventInterval = 120;    //  120 millisecond ( = 0.12 second )
+const TInt KPointerDownAndUpThreshold = 5;
 // -----------------------------------------------------------------------------
 // If a parent to the supplied control has its Gc set, this function will find
 // it and return it.
 // -----------------------------------------------------------------------------
 //
 NONSHARABLE_CLASS(CListBoxExt) : public CBase, public MListVisibilityObserver,
 public MCenRepNotifyHandlerCallback,
 public MAknPhysicsObserver,
 public MAknCollection,
+public MAknMarkingCollection,
 public MAknLongTapDetectorCallBack
 {
 public:
 static CListBoxExt* NewL(CEikListBox& aListBox);
 ~CListBoxExt();
 * @param  a0            First extension method parameter.
 * @param  a1            Second extension method parameter.
 */
 TInt CollectionExtension( TUint aExtensionId, TAny*& a0, TAny* a1 );
+// From MAknMarkingCollection
+/**
+* Sets multiple marking state.
+*
+* @param aActive ETrue if multiple marking should be active.
+*/
+void SetMultipleMarkingState( TBool aActive );
+/**
+* Returns whether the observer accepts ending of marking mode
+*
+* @return ETrue if observer accepts exiting marking mode
+*/
+TBool ExitMarkingMode();
+/**
+* Returns the collection marking state. The state is combination of
+* flags defined in @c TStateFlag.
+*
+* @return  Collection state.
+*/
+TUint MarkingState() const;
+/**
+* Marks the currently selected item.
+*/
+void MarkCurrentItemL();
+/**
+* Marks all items in the collection.
+*/
+void MarkAllL();
+/**
+* Unmarks all items in the collection.
+*/
+void UnmarkAll();
+/*
+* Can current item be marked
+*
+* @return ETrue if item can be marked
+*/
+TBool CurrentItemMarkable();
 // From MAknLongTapDetectorCallBack
 /**
 * Long tap detector callback
 *
 * @param aPenEventLocation Long tap event location relative to parent control.
 * Sets the highlight for the first item visible after single click
 * is disabled
 */
 void DisableSingleClick();
+/**
+* Enables single click
+*/
+void EnableSingleClickL();
 /**
 * Disables item specific menu.
 */
 void DisableItemSpecificMenu();
 * Returns ETrue if list has currently marked items.
 *
 * @return ETrue if list has marked items.
 */
 TBool MarkedItems() const;
+/**
+* Ignores pointer events until next up event.
+*
+* @return ETrue if the pointer event ignore was enabled.
+*/
+TBool IgnorePointerEventsUntilUp();
 public:
 void InitPhysicsL();
 /**
 TInt iInterval;
 CPeriodic* iHighlightTimer;
 CAknPhysics *iPhysics;
 TPoint iDragStartPosition;
 TPoint iLastPointerPos;
-TBool iBackgroundDrawingSuppressed;
 TBool iClickEventsAllowed;
 TBool iScrolling;
 TSize iViewSize;
 TSize iWorldSize;
 TBool iItemDraggingReported;
 /**
 * Item that opened the item action menu
 */
 TInt iLongTappedItem;
+/**
+* Marking mode on / off.
+*/
+TBool iMarkingModeInUse;
+/**
+* Marking mode observer.
+*/
+MAknMarkingModeObserver* iMarkingModeObserver;
 /**
 * Pointer event to be forwarded to the long tap detector upon
 * highlight timer completion.
 */
 TPointerEvent iDelayedPointerDownEvent;
+/**
+* Ordinal position of listbox window, before stylus menu is opened.
+*/
+TInt iOldWinPos;
+/**
+* If double click modifier is set on PointerEvent, the event may be ignored
+* in some situation(To prevent extra dialog launched by AO).
+*/
+TBool iDoubleClickEventIgnored;
 private:
 CMatchBuffer* iBuffer;
 CEikListBox& iListBox;
 CEikListBox::TReasonForFocusLost iReasonForFocusLost;
 TBool iPanningOngoing;
 /**
 * Height of the list in pixels.
 */
 TInt iListBottomLimit;
 };
 // CEikListBoxExt
 CListBoxExt* CListBoxExt::NewL( CEikListBox& aListBox )
 iLastItemIndex(-1),
 iItemActionMenu( NULL ),
 iLongTapDetector( NULL ),
 iSingleClickEnabled( iAvkonAppUi->IsSingleClickCompatible() ),
 iLongTappedItem( KErrNotFound ),
-iListBox(aListBox)
+iOldWinPos( KErrNotFound ),
+iListBox(aListBox)
 {
 }
 CListBoxExt::~CListBoxExt()
 {
 iHighlightTimer = CPeriodic::NewL( CActive::EPriorityStandard );
 }
 iItemsInSingleLine = 1;
 iFeedback = MTouchFeedback::Instance();
-iItemActionMenu = CAknItemActionMenu::RegisterCollectionL( *this );
+iItemActionMenu = CAknItemActionMenu::RegisterCollectionL( *this, &iListBox );
 if ( !( iListBox.iListBoxFlags & CEikListBox::EDisableItemSpecificMenu )
 && iItemActionMenu )
 {
 iLongTapDetector = CAknLongTapDetector::NewL( this );
 }
 if ( iListBox.iListBoxFlags & CEikListBox::EMultipleSelection )
 {
 state |= MAknCollection::EStateMultipleSelection;
 }
+if ( MarkedItems() )
+{
+state |= MAknCollection::EStateMarkedItems;
+}
 _AKNTRACE_FUNC_EXIT;
 return state;
 }
 if ( iLongTappedItem != KErrNotFound )
 {
 EnableHighlight( EFalse );
 iListBox.iView->DrawItem( iLongTappedItem );
 iLongTappedItem = KErrNotFound;
+iOldWinPos = KErrNotFound;
 }
 }
 // -----------------------------------------------------------------------------
 // CListBoxExt::CollectionExtension
 // -----------------------------------------------------------------------------
 //
 TInt CListBoxExt::CollectionExtension(
-TUint /*aExtensionId*/, TAny*& /*a0*/, TAny* /*a1*/ )
+TUint aExtensionId, TAny*& a0, TAny* /*a1*/ )
 {
-return KErrNone;
+if ( aExtensionId == MAknMarkingCollection::TYPE )
+{
+a0 = static_cast<MAknMarkingCollection*>( this );
+return KErrNone;
+}
+return KErrNotFound;
+}
+// -----------------------------------------------------------------------------
+// CListBoxExt::SetMultipleMarkingState
+// -----------------------------------------------------------------------------
+//
+void CListBoxExt::SetMultipleMarkingState( TBool aActive )
+{
+_AKNTRACE_FUNC_ENTER;
+iListBox.SetMarkingMode( aActive );
+_AKNTRACE_FUNC_EXIT;
+}
+// -----------------------------------------------------------------------------
+// CListBoxExt::ExitMarkingMode
+// -----------------------------------------------------------------------------
+//
+TBool CListBoxExt::ExitMarkingMode()
+{
+if ( iListBox.MarkingModeObserver() )
+{
+return iListBox.MarkingModeObserver()->ExitMarkingMode();
+}
+return ETrue;
+}
+// -----------------------------------------------------------------------------
+// CListBoxExt::MarkingState
+// -----------------------------------------------------------------------------
+//
+TUint CListBoxExt::MarkingState() const
+{
+_AKNTRACE_FUNC_ENTER;
+TUint state( 0 );
+if ( iListBox.MarkingMode() )
+{
+state |= MAknMarkingCollection::EStateMarkingMode;
+if ( MarkedItems() )
+{
+state |= MAknMarkingCollection::EStateMarkedItems;
+}
+if ( iListBox.Model()->NumberOfItems() == 0 )
+{
+state |= MAknMarkingCollection::EStateCollectionEmpty;
+}
+}
+_AKNTRACE_FUNC_EXIT;
+return state;
+}
+// -----------------------------------------------------------------------------
+// CListBoxExt::MarkCurrentItemL
+// -----------------------------------------------------------------------------
+//
+void CListBoxExt::MarkCurrentItemL()
+{
+_AKNTRACE_FUNC_ENTER;
+if ( iListBox.MarkingMode() )
+{
+TInt index = iListBox.CurrentItemIndex();
+if ( index >= 0 &&
+!iListBox.iItemDrawer->Properties( index ).IsSelectionHidden() )
+{
+iListBox.View()->SelectItemL( index );
+}
+}
+_AKNTRACE_FUNC_EXIT;
+}
+// -----------------------------------------------------------------------------
+// CListBoxExt::MarkAllL
+// -----------------------------------------------------------------------------
+//
+void CListBoxExt::MarkAllL()
+{
+_AKNTRACE_FUNC_ENTER;
+if ( iListBox.MarkingMode() &&
+iListBox.Model()->NumberOfItems() > 0 )
+{
+iListBox.View()->SelectAllL( ETrue );
+}
+_AKNTRACE_FUNC_EXIT;
+}
+// -----------------------------------------------------------------------------
+// CListBoxExt::UnmarkAll
+// -----------------------------------------------------------------------------
+//
+void CListBoxExt::UnmarkAll()
+{
+_AKNTRACE_FUNC_ENTER;
+if ( iListBox.MarkingMode() )
+{
+iListBox.View()->ClearSelection();
+}
+_AKNTRACE_FUNC_EXIT;
+}
+// -----------------------------------------------------------------------------
+// CListBoxExt::CurrentItemMarkable
+// -----------------------------------------------------------------------------
+//
+TBool CListBoxExt::CurrentItemMarkable()
+{
+_AKNTRACE_FUNC_ENTER;
+TBool itemCanBeMarked = ETrue;
+TInt index = iListBox.CurrentItemIndex();
+if ( index >= 0 &&
+iListBox.iItemDrawer->Properties( index ).IsSelectionHidden() )
+{
+itemCanBeMarked = EFalse;
+}
+_AKNTRACE_FUNC_EXIT;
+return itemCanBeMarked;
 }
 // ---------------------------------------------------------------------------
 // CListBoxExt::HandleLongTapEventL
 {
 _AKNTRACE_FUNC_ENTER;
 iLongTappedItem = iLastDownTappedItem;
 iLastDownTappedItem = KErrNotFound;
 iItemActionMenu->ShowMenuL( aPenEventScreenLocation, 0 );
+iOldWinPos = iListBox.DrawableWindow()->OrdinalPosition();
 _AKNTRACE_FUNC_EXIT;
 }
 // -----------------------------------------------------------------------------
 _AKNTRACE_FUNC_ENTER;
 EnableHighlight( ETrue );
 if ( iListBox.iView->ViewRect() != TRect() )
 {
-TInt topItemIndex = iListBox.iView->TopItemIndex();
+// Set current item index highlighted if it is visible, otherwise
-if ( iListBox.iView->ItemIsPartiallyVisible( topItemIndex) )
+// the first visible index
-{
+TInt index = iListBox.iView->CurrentItemIndex();
-topItemIndex++;
+if ( !iListBox.iView->ItemIsVisible( index ) )
-}
+{
-TRAP_IGNORE( iListBox.UpdateHighlightL( topItemIndex ) );
+index = iListBox.iView->TopItemIndex();
+if ( iListBox.iView->ItemIsPartiallyVisible( index ) )
+{
+index++;
+}
+}
+TRAP_IGNORE( iListBox.UpdateHighlightL( index ) );
 }
 DisableItemSpecificMenu();
 if ( iItemActionMenu )
 {
 iSingleClickEnabled = EFalse;
 _AKNTRACE_FUNC_EXIT;
 }
+// -----------------------------------------------------------------------------
+// CListBoxExt::EnableSingleClickL
+// -----------------------------------------------------------------------------
+//
+void CListBoxExt::EnableSingleClickL()
+{
+_AKNTRACE_FUNC_ENTER;
+if ( !iLongTapDetector )
+{
+iLongTapDetector = CAknLongTapDetector::NewL( this );
+}
+if ( !iItemActionMenu )
+{
+iItemActionMenu = CAknItemActionMenu::RegisterCollectionL(
+*this, &iListBox );
+iListBox.iListBoxFlags &= ( ~CEikListBox::EDisableItemSpecificMenu );
+}
+iSingleClickEnabled = ETrue;
+EnableHighlight( EFalse );
+// iListBox.UpdateHighlightL( iListBox.iView->CurrentItemIndex() );
+_AKNTRACE_FUNC_EXIT;
+}
 // -----------------------------------------------------------------------------
 // CListBoxExt::DisableItemSpecificMenu
 // -----------------------------------------------------------------------------
 //
 iListBox.iListBoxFlags |= CEikListBox::EDisableItemSpecificMenu;
 _AKNTRACE_FUNC_EXIT;
 }
 // -----------------------------------------------------------------------------
 // CListBoxExt::LongTapPointerEventL
 // -----------------------------------------------------------------------------
 //
 void CListBoxExt::LongTapPointerEventL( const TPointerEvent& aPointerEvent )
 {
 if ( iSingleClickEnabled && iLongTapDetector && iItemActionMenu  )
 {
-// Send event on down only if no marked items and item specific items
+// Send event on down only if item specific items were found.
-// were found
+// Long tap is also disabled if current item is not marked while
-if ( aPointerEvent.iType != TPointerEvent::EButton1Down
+// there are some marked items or marking mode is active.
-|| ( !MarkedItems() && iItemActionMenu->InitMenuL() ) )
+if ( ( !( ( iListBox.MarkingMode() || MarkedItems() )
+&& !iListBox.View()->ItemIsSelected( iListBox.CurrentItemIndex() ) )
+|| ( iListBox.iListBoxFlags & CEikListBox::EItemSpecificMenuAlwaysShown ) )
+&& ( aPointerEvent.iType != TPointerEvent::EButton1Down
+|| iItemActionMenu->InitMenuL() ) )
 {
 iLongTapDetector->PointerEventL ( aPointerEvent );
 }
 }
 }
 //
 TBool CListBoxExt::MarkedItems() const
 {
 return ( iListBox.iListBoxFlags & CEikListBox::ES60StyleMarkable
 || iListBox.iListBoxFlags & CEikListBox::EMultipleSelection )
-&& iListBox.SelectionIndexes()->Count() > 0;
+&& iListBox.iView && iListBox.SelectionIndexes()->Count() > 0;
+}
+// -----------------------------------------------------------------------------
+// CListBoxExt::IgnorePointerEventsUntilUp
+// -----------------------------------------------------------------------------
+//
+TBool CListBoxExt::IgnorePointerEventsUntilUp()
+{
+_AKNTRACE_FUNC_ENTER;
+// Pointer event ignore must be done for the window-owning
+// control or it doesn't have any effect!
+CCoeControl* windowOwningControl = &iListBox;
+while ( windowOwningControl && !windowOwningControl->OwnsWindow() )
+{
+windowOwningControl = windowOwningControl->Parent();
+}
+if ( windowOwningControl )
+{
+windowOwningControl->IgnoreEventsUntilNextPointerUp();
+}
+_AKNTRACE_FUNC_EXIT;
+return ( windowOwningControl != NULL );
 }
 // -----------------------------------------------------------------------------
 // CListBoxExt::StartLongPressTimerL
 void CListBoxExt::PhysicEmulationEnded()
 {
 _AKNTRACE_FUNC_ENTER;
 if ( iScrolling )
 {
+// currently, this is the only way to fix ou1cimx1#375869
+// iViewPosision is changed but we can't provent that
+if ( iListBox.iView->TopItemIndex() == 0
+&& iListBox.iView->ItemOffsetInPixels() > 0 )
+{
+iListBox.ScrollView( -iListBox.iView->ItemOffsetInPixels(), ETrue );
+}
 #ifdef RD_UI_TRANSITION_EFFECTS_LIST
 iListBox.SuspendEffects( EFalse );
 #endif // RD_UI_TRANSITION_EFFECTS_LIST
 TRAP_IGNORE( iListBox.ReportListBoxEventL(
 MEikListBoxObserver::EEventFlickStopped ) );
 {
 // calculate view center based on CEikListBoxView::iTopItemIndex
 TInt topItemIndex = iListBox.iView->TopItemIndex();
 TInt itemHeight = iListBox.iView->ItemHeight();
 TInt numberOfItems = iListBox.iModel->NumberOfItems();
+TInt emptySpaceOffset ( 0 );
 TSize viewSize( iListBox.iView->ViewRect().Size() );
 TSize worldSize( viewSize.iWidth, itemHeight * numberOfItems );
 // grid has several items in one line
 if ( iItemsInSingleLine > 1 )
 // handle non-full grid row
 if ( numberOfItems % iItemsInSingleLine )
 {
 worldSize.iHeight += itemHeight;
 }
+// Check empty space below the grid
+if ( topItemIndex != 0 )
+{
+TInt lastItemBottomY =
+iListBox.iView->ItemPos(
+numberOfItems - 1 ).iY + itemHeight +1;
+emptySpaceOffset = Min( 0, lastItemBottomY - viewSize.iHeight );
+}
 }
 // Reset offset if view's size has changed - this is needed if e.g.
 // HandleResourceChange is overridden by a derived implementation.
 if ( viewSize != iViewSize && iViewSize != TSize( 0, 0 ) )
 {
 iListBox.iView->SetItemOffsetInPixels( 0 );
 }
 TPoint viewCenter( viewSize.iWidth / 2, ( topItemIndex / iItemsInSingleLine ) * itemHeight - iListBox.iView->ItemOffsetInPixels() + ( viewSize.iHeight / 2 ) );
+viewCenter.iY += emptySpaceOffset;
 // Make sure that world's size is always at least view size.
 worldSize.iHeight = Max( worldSize.iHeight, viewSize.iHeight );
 iPhysics->InitPhysicsL( worldSize, viewSize, EFalse );
 }
 _AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
-// CListBoxExt::FeedbackEnabledOnUpEvent
+// Checks whether or not tactile feedback should be given on a pointer
+// up event.
 // ---------------------------------------------------------------------------
 //
 TBool CListBoxExt::FeedbackEnabledOnUpEvent()
 {
 _AKNTRACE_FUNC_ENTER;
 TBool enabled( EFalse );
-if ( ( iListBox.iItemDrawer->Flags() & CListItemDrawer::EPressedDownState ) &&
-!iFlickStopped )
+// As there's no pressed down highlight in single click enabled lists,
+// the iLastDownTappedItem is used to track whether or not the pointer
+// up event happened inside the same list item as the pointer down event.
+// Feedback should not be given if the pointer up is received outside of
+// the item that received the pointer down event, or in cases when the
+// list has been dragged or flicked between the pointer down and pointer
+// up events.
+if ( ( iListBox.iItemDrawer->Flags() & CListItemDrawer::EPressedDownState
+|| ( iSingleClickEnabled && iLastDownTappedItem != KErrNotFound ) ) &&
+!iFlickStopped )
 {
 enabled = ETrue;
 }
 _AKNTRACE_FUNC_EXIT;
 return enabled;
 }
 // ---------------------------------------------------------------------------
 {
 iListBoxExt->iItemsInSingleLine = aItems;
 }
 }
+// -----------------------------------------------------------------------------
+// CEikListBox::ItemsInSingleLine
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TInt CEikListBox::ItemsInSingleLine() const
+{
+if ( iListBoxExt )
+{
+return iListBoxExt->iItemsInSingleLine;
+}
+return 1;
+}
 EXPORT_C void CEikListBox::UpdateViewColors()
 {
 _AKNTRACE_FUNC_ENTER;
 if(!iView)
 {
 {
 _AKNTRACE_FUNC_ENTER;
 iView->CalcBottomItemIndex();
 iView->CalcDataWidth();
 TInt currentItemIndex = iView->CurrentItemIndex();
+TInt totalItems = iModel->NumberOfItems();
 if ( ItemExists(currentItemIndex) )
 {
 TInt topItemIndex( iView->TopItemIndex() );
 TInt numberOfItems = iView->NumberOfItemsThatFitInRect( iView->ViewRect() );
 TInt newTopItemIndex( KEikListBoxInvalidIndex );
 // Current item not visible or current item is the last item (not fully visible)
 if ( !iView->ItemIsVisible(currentItemIndex)
 	|| iListBoxExt && iListBoxExt->iPhysics
 	&& currentItemIndex == ( topItemIndex + numberOfItems - 1 ) )
 {
-newTopItemIndex = iView->CalcNewTopItemIndexSoItemIsVisible( currentItemIndex );
+if ( iListBoxExt && iListBoxExt->iSingleClickEnabled )
+{
+TInt offset = (iListBoxExt->iWorldSize.iHeight / 2)
+- iListBoxExt->iViewPosition.iY;
+TInt itemsInRect =
+iView->NumberOfItemsThatFitInRect( iView->ViewRect() );
+if ( ( iListBoxExt->CollectionState()
+& MAknCollection::EStateHighlightVisible )
+|| ( ItemsInSingleLine()
+&& ( totalItems <= itemsInRect )
+&& ( offset != 0 ) ) )
+{
+newTopItemIndex = iView->CalcNewTopItemIndexSoItemIsVisible( currentItemIndex );
+}
+else
+{
+newTopItemIndex = iView->CalcNewTopItemIndexSoItemIsVisible( topItemIndex );
+}
+}
+else
+{
+newTopItemIndex = iView->CalcNewTopItemIndexSoItemIsVisible( currentItemIndex );
+}
 }
 else
 {
 // recalculates top index of list when mode be changed
-TInt totalItems = iModel->NumberOfItems();
 if ( (totalItems - topItemIndex) < numberOfItems )
 {
 newTopItemIndex = Max( 0, totalItems - numberOfItems );
 }
 }
-if ( newTopItemIndex != KEikListBoxInvalidIndex )
+if ( newTopItemIndex > KEikListBoxInvalidIndex
+&& newTopItemIndex < totalItems )
 	{
 	iView->SetTopItemIndex( newTopItemIndex );
-	if ( iListBoxExt && iListBoxExt->iPhysics )
+}
-		{
+if ( iListBoxExt && iListBoxExt->iPhysics )
-		iListBoxExt->InitPhysicsL();
+{
-		}
+iListBoxExt->InitPhysicsL();
 }
 }
 UpdateScrollBarsL();
 _AKNTRACE_FUNC_EXIT;
 }
 TBool redrawDisabled = iView->RedrawDisabled();
 iView->SetDisableRedraw(ETrue);
 UpdateCurrentItem(aItemIndex);
 iView->SetDisableRedraw(redrawDisabled);
-if ( iListBoxExt && iListBoxExt->iPhysics && aItemIndex == 0 )
+if ( iListBoxExt && iListBoxExt->iPhysics && aItemIndex == 0
-{
+&& !iListBoxExt->iScrolling )
+{
 iView->SetItemOffsetInPixels( 0 );
 }
 _AKNTRACE_FUNC_EXIT;
 }
 CreateViewL();
 if(iItemDrawer && (iItemDrawer->MinimumCellSize().iHeight != 0))
 iItemHeight = iItemDrawer->MinimumCellSize().iHeight;
+CheckCreateExtensionL();
 if ( iListBoxExt->iLongTapDetector
 && iListBoxFlags & EDisableItemSpecificMenu )
 {
 delete iListBoxExt->iLongTapDetector;
 iListBoxExt->iLongTapDetector = NULL;
 RestoreClientRectFromViewRect(clientRect);
 TRect inclusiveRect=Rect();
 TEikScrollBarFrameLayout layout;
 CreateScrollBarFrameLayout(layout);
 TBool sizeChanged=iSBFrame->TileL(&hSbarModel, &vSbarModel, clientRect, inclusiveRect, layout);
-if (iListBoxExt->UpdateScrollBarsColors())
+if ( iListBoxExt && iListBoxExt->UpdateScrollBarsColors() )
 UpdateScrollBarsColors();
 if (!sizeChanged)
 return;
 // else size of client/inclusive rect has changed
 if (layout.iTilingMode==TEikScrollBarFrameLayout::EClientRectConstant)
 && iItemDrawer->Properties(index).IsSelectionHidden() )
 {
 _AKNTRACE_FUNC_EXIT;
 return;
 }
-if( !iListBoxExt )
-{
-_AKNTRACE_FUNC_EXIT;
-return;
-}
 CEikButtonGroupContainer *bgc;
 CCoeControl* MSK( NULL );
 CEikCba* cba( NULL );
 CONST_CAST( CEikListBox*,this )->MopGetObject( bgc );
 if ( !bgc )
 TRAPD( err, bgc->AddCommandToStackL( 3, newResourceId ) );
 // in case of error, don't inform observers
 // marking still works even MSK isn't changed
 if ( err )
 {
-iListBoxExt->iSelectionModeEnabled = EFalse;
+if ( iListBoxExt )
+{
+iListBoxExt->iSelectionModeEnabled = EFalse;
+}
 _AKNTRACE_FUNC_EXIT;
 return;
 }
 cba->DrawNow();
-iListBoxExt->iSelectionModeEnabled = ETrue;
+if ( iListBoxExt )
+{
+iListBoxExt->iSelectionModeEnabled = ETrue;
+}
 }
 // remove stacked MSK
-if( !aEnable && iListBoxExt->iSelectionModeEnabled )
+if( !aEnable && iListBoxExt && iListBoxExt->iSelectionModeEnabled )
 {
 if( ( MSK && cba->ControlId( MSK ) == EAknSoftkeyMark ) ||
 ( MSK && cba->ControlId( MSK ) == EAknSoftkeyUnmark ) )
 {
 bgc->RemoveCommandFromStack( 3, cba->ControlId( MSK ) );
 }
 iListBoxExt->iSelectionModeEnabled = EFalse; // just in case
 }
+if ( iListBoxExt )
-TInt count = iListBoxExt->iSelectionObservers.Count();
+{
-for ( int i=0; i < count; i++ )
+TInt count = iListBoxExt->iSelectionObservers.Count();
-{
+for ( int i=0; i < count; i++ )
-iListBoxExt->iSelectionObservers[i]->SelectionModeChanged( this, aEnable );
+{
+iListBoxExt->iSelectionObservers[i]->SelectionModeChanged( this, aEnable );
+}
 }
 _AKNTRACE_FUNC_EXIT;
 }
 iView->CalcBottomItemIndex();
 UpdateScrollBarsL();
 UpdateScrollBarThumbs();
 iView->ClearFlags(CListBoxView::EItemCountModified);
+if ( iListBoxExt->iItemActionMenu &&
+iListBoxExt->iLongTappedItem != KErrNotFound )
+{
+// Item action menu is being shown and it needs to be closed when
+// items are added or removed to the list array, otherwise the
+// item specific commands may be targeted to the wrong item.
+iListBoxExt->iItemActionMenu->HideMenu();
+}
 FireItemChange();
 if ( iListBoxExt && iListBoxExt->iPhysics )
 {
 iListBoxExt->InitPhysicsL();
 }
 EXPORT_C void CEikListBox::HandleItemAdditionL()
 {
 _AKNTRACE_FUNC_ENTER;
-//fix the bug EGGO-7SQA4S and EVSG-7TD9WZ
+__ASSERT_DEBUG( iView, Panic( EEikPanicListBoxNoView ) );
 TInt curItemIndex = iView->CurrentItemIndex();
 if(curItemIndex >= 0 && curItemIndex < iModel->NumberOfItems() )
 {
 TInt newTopItemIndex = iView->CalcNewTopItemIndexSoItemIsVisible( curItemIndex );
 iView->SetTopItemIndex( newTopItemIndex );
 }
 iView->SetFlags(CListBoxView::EItemCountModified);
-// following breaks lists in square layout, not needed in SERIES60?
-//iView->CalcDataWidth();
 iView->CalcBottomItemIndex();
 UpdateScrollBarsL();
 UpdateScrollBarThumbs();
 if (IsReadyToDraw()) DrawDeferred();
 iView->ClearFlags(CListBoxView::EItemCountModified);
 FireItemChange();
 if ( iListBoxExt )
 {
 iListBoxExt->CheckScrollBarVisibility();
 // Physics engine world size needs to be updated here, otherwise aknphysics
 // cone observer may block pointer events on new items. this can happen
 // when item addition inserts new row to taskswapper's grid and reuses list in Common Dialog
 if ( iListBoxExt->iPhysics )
 {
 iListBoxExt->InitPhysicsL();
 }
-}
+if ( iListBoxExt->iItemActionMenu &&
+iListBoxExt->iLongTappedItem != KErrNotFound )
+{
+// Item action menu is being shown and it needs to be closed when
+// items are added or removed to the list array, otherwise the
+// item specific commands may be targeted to the wrong item.
+iListBoxExt->iItemActionMenu->HideMenu();
+}
+}
 _AKNTRACE_FUNC_EXIT;
 }
 EXPORT_C void CEikListBox::HandleItemRemovalL()
 {
 }
 else
 {
 selectionMode = CListBoxView::ENoSelection;
 UpdateMarkUnmarkMSKL();
-if (IsSelectionMarkKeys(code, aKeyEvent.iScanCode, iListBoxExt->iWesternVariant))
+if ( iListBoxExt
+&& IsSelectionMarkKeys( code, aKeyEvent.iScanCode, iListBoxExt->iWesternVariant ) )
 {
 __KeyDebug(ETrue, "SelectionMarkKey")
 View()->ClearSelectionAnchorAndActiveIndex();
 }
 }
 }
 // CAknGrid marking is implemeted in avkon.dll. But we still need to disable short
 // hash mark in here.
-if ( iListBoxFlags & EMultipleSelection &&
+if ( iListBoxExt && iListBoxFlags & EMultipleSelection &&
 iListBoxFlags & EShiftEnterMarks && aType == EEventKeyUp )
 {
 if ( aKeyEvent.iScanCode == EStdKeyLeftArrow ||
 aKeyEvent.iScanCode == EStdKeyUpArrow ||
 aKeyEvent.iScanCode == EStdKeyRightArrow ||
 _AKNTRACE_FUNC_EXIT;
 return( EKeyWasConsumed );
 }
 }
-if ( ScrollingDisabled() || ( !iListBoxExt->MovePhysicsCursorL( moveto, selectionMode ) ) )
+if ( ScrollingDisabled()
+|| ( iListBoxExt && !iListBoxExt->MovePhysicsCursorL( moveto, selectionMode ) ) )
 {
 iView->MoveCursorL(moveto, selectionMode);
 }
 ClearMatchBuffer();
 if( iListBoxFlags & EMultipleSelection )
 _AKNTRACE_FUNC_EXIT;
 return(EKeyWasConsumed);
 }
 }
-if ( ScrollingDisabled() || ( !iListBoxExt->MovePhysicsCursorL( moveto, selectionMode ) ) )
+if ( ScrollingDisabled()
+|| ( iListBoxExt && !iListBoxExt->MovePhysicsCursorL( moveto, selectionMode ) ) )
 {
 iView->MoveCursorL(moveto, selectionMode);
 }
 ClearMatchBuffer();
 if (iListBoxFlags & EMultipleSelection)
 // Markable list CR JLEO-4VQJ75
 if (!shiftKeyPressed && iListBoxFlags & EShiftEnterMarks)
 {
 // enter key pressed on markable list without shift
-if (SelectionIndexes()->Count() > 0)
+if ( SelectionIndexes()->Count() > 0 && !MarkingMode() )
 {
 // when there's marked items, should open options menu.
 __KeyDebug(ETrue, "ok without shift => ok options menu");
 CEikMenuBar *bar;
 //
 // Switch/case ends here
 //
 if(switchMSK)
 {
-if( selectionMode == CListBoxView::EDisjointMarkSelection )
+if( iListBoxExt && selectionMode == CListBoxView::EDisjointMarkSelection )
 {
 // if hash and either up or down pressed -> no short marking
 iListBoxExt->iShortHashMark = EFalse;
 }
 UpdateMarkUnmarkMSKL();
 // This code block watches for hash key presses, and simulates shift + ok
 // if short hash key presses are used for selections. The events are simulated
 // only if a markable list is active, otherwise the simulated event might open
 // the selected item, which we don't want.
 if((iListBoxFlags & EMultipleSelection) && (iListBoxFlags & EShiftEnterMarks) &&
-iListBoxExt->iWesternVariant &&
+iListBoxExt && iListBoxExt->iWesternVariant &&
 iListBoxExt->iAknFepHashKeySelection &&
 iListBoxExt->iQwertyMode == EFalse &&
 aType == EEventKeyUp && aKeyEvent.iScanCode == EStdKeyHash &&
 IsFocused() )
 {
 switch ( aEvent )
 {
 case MEikListBoxObserver::EEventFlickStarted:
 case MEikListBoxObserver::EEventPanningStarted:
 {
+if ( iListBoxExt && ( iListBoxExt->iWorldSize.iHeight
+<= iListBoxExt->iViewSize.iHeight ) )
+{
+return;
+}
 iItemDrawer->SetFlags( CListItemDrawer::EDisableMarquee );
-if ( aEvent == MEikListBoxObserver::EEventFlickStarted )
+if ( iListBoxExt )
-iListBoxExt->SetFlickOngoing( ETrue );
+{
-else
+if ( aEvent == MEikListBoxObserver::EEventFlickStarted )
-iListBoxExt->SetPanningOngoing( ETrue );
+{
+iListBoxExt->SetFlickOngoing( ETrue );
+}
+else
+{
+iListBoxExt->SetPanningOngoing( ETrue );
+}
+}
 break;
 }
 case MEikListBoxObserver::EEventFlickStopped:
 case MEikListBoxObserver::EEventPanningStopped:
 {
+if ( iListBoxExt && ( iListBoxExt->iWorldSize.iHeight
+<= iListBoxExt->iViewSize.iHeight ) )
+{
+return;
+}
 iItemDrawer->ClearFlags( CListItemDrawer::EDisableMarquee );
-if ( aEvent == MEikListBoxObserver::EEventFlickStopped )
+if ( iListBoxExt )
 {
-iListBoxExt->SetFlickOngoing( EFalse );
+if ( aEvent == MEikListBoxObserver::EEventFlickStopped )
-}
+{
-else
+iListBoxExt->SetFlickOngoing( EFalse );
-{
+}
-iListBoxExt->SetPanningOngoing( EFalse );
+else
-}
+{
+iListBoxExt->SetPanningOngoing( EFalse );
+}
+}
 break;
 }
 }
 if ( iListBoxObserver )
 {
 TBool allowed = ETrue;
 if ( iListBoxExt && iListBoxExt->iPhysics
-&& aEvent != MEikListBoxObserver::EEventFlickStopped )
+&& aEvent != MEikListBoxObserver::EEventFlickStopped
+&& aEvent != MEikListBoxObserver::EEventFlickStarted )
 {
 allowed = iListBoxExt->iClickEventsAllowed;
+}
+if ( MarkingMode() && allowed )
+{
+switch ( aEvent )
+{
+case MEikListBoxObserver::EEventItemSingleClicked:
+case MEikListBoxObserver::EEventEnterKeyPressed:
+{
+TInt index = CurrentItemIndex();
+if ( index >= 0 &&
+!iItemDrawer->Properties(index).IsSelectionHidden() )
+{
+iView->ToggleItemL( iView->CurrentItemIndex() );
+}
+allowed = EFalse;
+}
+break;
+default:
+break;
+}
 }
 if ( allowed )
 {
 iListBoxObserver->HandleListBoxEventL(this, aEvent);
 // ---------------------------------------------------------------------------
 //
 EXPORT_C void CEikListBox::HandlePhysicsScrollEventL( TInt aDeltaPixels )
 {
 _AKNTRACE_FUNC_ENTER;
-if ( iListBoxExt->iPhysics )
+if ( iListBoxExt && iListBoxExt->iPhysics )
 {
 iListBoxExt->InitPhysicsL();
 TPoint newPosition( iListBoxExt->iViewPosition.iX,
 aDeltaPixels + iListBoxExt->iViewPosition.iY );
 EXPORT_C void CEikListBox::HandleScrollEventL(CEikScrollBar* aScrollBar,TEikScrollEvent aEventType)
 {
 _AKNTRACE_FUNC_ENTER;
-if ( iListBoxExt->iSingleClickEnabled )
+if ( iListBoxExt && iListBoxExt->iSingleClickEnabled )
 {
 iListBoxExt->EnableHighlight( EFalse );
 iView->DrawItem( iView->CurrentItemIndex() );
 }
 MAknListBoxTfxInternal::EListScrollUp :
 MAknListBoxTfxInternal::EListScrollDown );
 }
 #endif
-if ( iListBoxExt->iPhysics )
+if ( iListBoxExt && iListBoxExt->iPhysics )
 {
 iListBoxExt->InitPhysicsL();
 TInt deltaPixels = newThumbPos;
 #ifdef _DEBUG
 RDebug::Print( _L( "CListBox::HandleScrollEventL, deltaPixels = %d" ), deltaPixels );
 #endif // _DEBUG
 TPoint newPosition( iListBoxExt->iViewPosition.iX, deltaPixels + iView->ViewRect().Height() / 2 );
 iListBoxExt->ViewPositionChanged( newPosition );
 }
 else
 {
 iView->VScrollTo(newThumbPos/iView->ItemHeight());
 }
 }
 // If the event has changed thumb position, then update scroll bar
 // unless physics is used. In that case thumb is updated via
 // CEikListBox::ScrollView.
-if ( AknLayoutUtils::PenEnabled() && newThumbPos != newThumbPosBeforeCorrecting && !iListBoxExt->iPhysics )
+if ( AknLayoutUtils::PenEnabled()
+&& newThumbPos != newThumbPosBeforeCorrecting
+&& iListBoxExt && !iListBoxExt->iPhysics )
 {
 UpdateScrollBarThumbs();
 }
 }
 iItemDrawer->ClearFlags(CListItemDrawer::EDisableMarquee);
 {
 _AKNTRACE_FUNC_EXIT;
 return;
 }
-CheckCreateExtensionL();
 if (!(iListBoxFlags & ELeftDownInViewRect))
 {
 _AKNTRACE_FUNC_EXIT;
 return;
 }
 TInt oldCurrentItemIndex;
 TBool listEmpty = !ItemExists( iView->TopItemIndex() );
 // Handle empty list area events
 if ( aPointerEvent.iType == TPointerEvent::EButton1Up &&
-!iListBoxExt->iScrolling )
+!iListBoxExt->iScrolling && !iListBoxExt->iIsDownOnItem )
 {
 if ( listEmpty )
 {
 // No items, empty list was clicked
 ReportListBoxEventL( MEikListBoxObserver::EEventEmptyListClicked );
 // Return always if list empty to avoid tactile feedback
 _AKNTRACE_FUNC_EXIT;
 return;
 }
-// When in marking mode, pointer events should not be forwarded to
-// long tap detector, this boolean indicates if marking mode is active
-TBool markingMode( iListBoxExt->MarkedItems() );
 if ( aPointerEvent.iType == TPointerEvent::EButton1Down )
 {
 if ( iListBoxExt->iSingleClickEnabled &&
 itemIndex != iView->CurrentItemIndex() )
 {
 iListBoxExt->EnableHighlight( EFalse );
 iView->DrawItem( iView->CurrentItemIndex() );
 }
-iListBoxExt->iFeedbackType = ETouchFeedbackBasicItem;
+iListBoxExt->iFeedbackType = ETouchFeedbackList;
+iListBoxExt->iDoubleClickEventIgnored = EFalse;
-if ( itemIndex != iView->CurrentItemIndex() ||
-iListBoxFlags & ES60StyleMultiselection )
+if ( !iListBoxExt->iSingleClickEnabled &&
-{
+itemIndex != iView->CurrentItemIndex() )
-iListBoxExt->iFeedbackType = ETouchFeedbackSensitiveItem;
+{
+iListBoxExt->iFeedbackType = ETouchFeedbackSensitiveList;
 }
 if ( iListBoxExt->iPhysics &&
 iListBoxExt->iPhysics->OngoingPhysicsAction() == CAknPhysics::EAknPhysicsActionFlicking )
 {
-iListBoxExt->iFeedbackType = ETouchFeedbackBasicItem;
+iListBoxExt->iFeedbackType = ETouchFeedbackList;
-}
-if ( !iListBoxExt->iPhysics || itemIndex == iView->CurrentItemIndex() )
-{
-iListBoxExt->ImmediateFeedback( iListBoxExt->iFeedbackType,
-TTouchFeedbackType(ETouchFeedbackVibra | ETouchFeedbackAudio),
-aPointerEvent );
 }
 }
 iListBoxExt->iEventModifiers = aPointerEvent.iModifiers;
 CListBoxView::TSelectionMode selectionMode = CListBoxView::ENoSelection;
 TBool shiftKeyPressed = EFalse;
 }
 if(Buffer()->iPressedIndex == itemIndex)
 {
 Buffer()->iPressedIndex = KEikListBoxInvalidIndex;
+iListBoxExt->iDoubleClickEventIgnored = ETrue;
 _AKNTRACE_FUNC_EXIT;
 return;
 }
 }
 {
 case TPointerEvent::EButton1Down:
 _AKNTRACE("TPointerEvent::EButton1Down");
 // For drag outside listbox
 iListBoxExt->iIsDownOnItem = pointerIsOverAnItem;
 iListBoxExt->iLastPoint = pointerPos;
+			iListBoxExt->iLongTappedItem = KErrNotFound;
 // update index of the last down tapped item
 iListBoxExt->iLastDownTappedItem = itemIndex;
+iListBoxExt->iMarkableListShiftKeyPressed = EFalse;
 if ((! (Rect().Contains(aPointerEvent.iPosition))) && (iListBoxFlags & EPopout))
 {
 ReportEventL(MCoeControlObserver::EEventRequestCancel);
 iListBoxExt->iEventModifiers = 0;
 {
 iListBoxExt->EnableHighlight( ETrue, ETrue );
 UpdateHighlightL( itemIndex );
 CCoeEnv::Static()->WsSession().Finish();
 }
-if ( itemIndex != oldCurrentItemIndex )
+if ( !( ( iListBoxFlags & EViewerFlag ) &&
+( iListBoxFlags & EDisableItemSpecificMenu ) ) )
 {
-	iListBoxExt->ImmediateFeedback(
+iListBoxExt->ImmediateFeedback(
 iListBoxExt->iFeedbackType,
 TTouchFeedbackType( ETouchFeedbackVibra |
 ETouchFeedbackAudio ),
 aPointerEvent );
-	}
+}
 if ( !wasFlicking )
 {
 ReportListBoxEventL(
 MEikListBoxObserver::EEventPenDownOnItem );
 iListBoxExt->LongTapPointerEventL( aPointerEvent );
 }
 }
 else
 {
+if( itemIndex == oldCurrentItemIndex )
+{
+if( !( ( iListBoxFlags & EViewerFlag ) &&
+( iListBoxFlags & EDisableItemSpecificMenu ) ) )
+{
+iListBoxExt->ImmediateFeedback(
+							                                   iListBoxExt->iFeedbackType,
+														       TTouchFeedbackType( ETouchFeedbackVibra |
+														       ETouchFeedbackAudio ),
+														       aPointerEvent );
+}
+							}
 ReportListBoxEventL(
 MEikListBoxObserver::EEventPenDownOnItem );
 }
 }
 else
 {
 transApi->SetMoveType( MAknListBoxTfxInternal::EListTap );
 }
 }
 #endif
-if (!(iListBoxFlags & EMultipleSelection))      // i.e. this is a single selection listbox
+if ( !( iListBoxFlags & EMultipleSelection )
+|| MarkingMode() )
 {
 if (itemIndex == oldCurrentItemIndex)
 {
 iItemDrawer->SetFlags( CListItemDrawer::EPressedDownState );
 iView->DrawItem( itemIndex );
 {
 iListBoxExt->iMarkableListShiftKeyPressed = EFalse;
 }
 }
-if ( itemIndex == oldCurrentItemIndex )
+if ( itemIndex == oldCurrentItemIndex && !iListBoxExt->iSingleClickEnabled )
 {
 if ( shiftKeyPressed )
 {
 #ifdef RD_UI_TRANSITION_EFFECTS_LIST
 iListBoxExt->iAnchor = oldCurrentItemIndex;
 }
 break;
 case TPointerEvent::EButton1Up:
 _AKNTRACE("TPointerEvent::EButton1Up");
-if ( iListBoxExt->FeedbackEnabledOnUpEvent() && iListBoxExt->iClickEventsAllowed )
+if ( iListBoxExt->FeedbackEnabledOnUpEvent() &&
-{
+			     iListBoxExt->iClickEventsAllowed &&
-TTouchLogicalFeedback fbType = ETouchFeedbackBasicItem;
+				 ( !( ( iListBoxFlags & EViewerFlag ) &&
-if ( iListBoxFlags & ES60StyleMultiselection )
+				 ( iListBoxFlags & EDisableItemSpecificMenu ) ) )&&
+				 ( iListBoxExt->iLastDownTappedItem == itemIndex ) &&
+				 ( !iListBoxExt->iDoubleClickEventIgnored ) &&
+				 itemIndex == iView->CurrentItemIndex() )
+{
+TTouchLogicalFeedback fbType = ETouchFeedbackList;
+if ( iListBoxFlags & ES60StyleMultiselection
+|| iListBoxFlags & EMultipleSelection )
 {
 fbType = ETouchFeedbackCheckbox;
 }
 iListBoxExt->ImmediateFeedback( fbType,
 ETouchFeedbackVibra,
 {
 iListBoxExt->LongTapPointerEventL( aPointerEvent );
 }
 if ( !s60StyleMultiselection )
 {
-if ( !iListBoxExt->iSingleClickEnabled )
+if ( !iListBoxExt->iSingleClickEnabled &&
+itemIndex == iListBoxExt->iLastDownTappedItem )
 {
 ReportListBoxEventL(MEikListBoxObserver::EEventItemClicked);
 }
 else if ( itemIndex == iListBoxExt->iLastDownTappedItem )
 {
 MEikListBoxObserver::EEventItemSingleClicked );
 _AKNTRACE_FUNC_EXIT;
 return;
 }
 }
-else if ( s60StyleMultiselection &&
+// Due to the feature of capactior panel, the pointer position
-iListBoxExt->iLastDownTappedItem == itemIndex &&
+// may change between pointer down and up during user click
-!Buffer()->iDragToAnotherItem )
+// action. When the click position is between two items
+// and flick or drag event is not performed, the item index may
+// change unwanted, so we make a threshold for this situation.
+else if ( s60StyleMultiselection && !Buffer()->iDragToAnotherItem
+&& ( iListBoxExt->iLastDownTappedItem == itemIndex
+|| ( iListBoxExt->iLastDownTappedItem != KErrNotFound
+&& Abs( iListBoxExt->iLastPointerPos.iY - aPointerEvent.iPosition.iY ) < KPointerDownAndUpThreshold ) ) )
 {
 iListBoxFlags |= EStateChanged;
 Buffer()->iPressedIndex = itemIndex;
 iView->SetAnchor(itemIndex-1); // zero indexed
 iView->UpdateSelectionL(selectionMode);
 else
 {
 // switch off selection (marking) mode when we lose focus
 // this also corrects situation, where FEP-menu is launched
 // and thus listbox doesn't receive shift up event
-if (NULL != iListBoxExt)
+if ( iListBoxExt )
 {
 if ((iListBoxFlags & EMultipleSelection) && (iListBoxFlags & EShiftEnterMarks))
 {
 iListBoxExt->iShiftKeyPressed = EFalse;
 if (iListBoxExt->iLongPressTimer && iListBoxExt->iLongPressTimer->IsActive())
 }
 iView->SetEmphasized(EFalse);
 iView->HideMatcherCursor();
-if (iItemEditor &&
+if ( iItemEditor &&
-(iListBoxFlags & EPaintedSelection) &&
+( iListBoxFlags & EPaintedSelection ) &&
-(NULL != iListBoxExt && iListBoxExt->ReasonForFocusLost() == EFocusLostToExternalControl))
+( iListBoxExt && iListBoxExt->ReasonForFocusLost() == EFocusLostToExternalControl ) )
 {
 iView->DeselectItem(CurrentItemIndex());
 }
 }
 #ifdef RD_UI_TRANSITION_EFFECTS_LIST
 return rect;
 }
 EXPORT_C TBool CEikListBox::BackgroundDrawingSuppressed() const
 {
-if ( iListBoxExt )
+if ( iItemDrawer )
 {
-return iListBoxExt->iBackgroundDrawingSuppressed;
+TInt flags = iItemDrawer->Flags();
+return ( flags & CListItemDrawer::EDrawWholeBackground )
+&& ( flags & CListItemDrawer::EBackgroundDrawn );
 }
 return EFalse;
 }
 iListBoxFlags &= ( ~ELeftDownInViewRect );
 }
 if ( iView )
 {
 iView->SetItemOffsetInPixels( 0 );
 }
 // make sure that highlight is removed and long tap is canceled
 // on layout switch, if single click is enabled and there is
 // pointer down on any item
 }
 iBackColor=iEikonEnv->ControlColor(IsDimmed() ?
 EColorControlDimmedBackground : EColorControlBackground,*this);
 UpdateViewColors();
 UpdateItemDrawerColors();
+// store the value of virtical offset as it will be 0 in SizeChange,
+// that will affect view position in skin changed, which is a bug.
+TInt oldOffset = 0;
+if ( iView )
+{
+oldOffset = iView->ItemOffsetInPixels();
+}
+// TODO: check if this call is real need here.
 SizeChanged();
+if ( oldOffset !=0 && iView )
+{
+iView->SetItemOffsetInPixels( oldOffset );
+UpdateScrollBarThumbs();
+}
+// this methord is empty.
 UpdateScrollBarsColors();
 #ifdef RD_UI_TRANSITION_EFFECTS_LIST
 if ( transApi )
 {
 case KEikMessageFadeAllWindows:
 {
 // Some client does not let list get button1up, so we do it there...
 iItemDrawer->ClearFlags( CListItemDrawer::EPressedDownState );
 TInt index = View()->CurrentItemIndex();
-if ( index != KErrNotFound )
+TBool enabled( !( iItemDrawer->Flags()
+& CListItemDrawer::ESingleClickDisabledHighlight ) );
+if ( index != KErrNotFound && enabled )
 	{
 Window().Invalidate( TRect( View()->ItemPos(index),
-		                 View()->ItemSize() ) );
+iItemDrawer->ItemCellSize() ) );
 	}
 break;
 }
 case KEikDynamicLayoutVariantSwitch:
 case KEikMessageColorSchemeChange:
 DrawDeferred();
 break;
 case KAknMessageFocusLost:
 {
-if ( iListBoxExt && iListBoxExt->iSingleClickEnabled )
+// Do not remove highlight if window ordinal position has changed
+// during the time when stylus menu is open
+if ( iListBoxExt && iListBoxExt->iSingleClickEnabled &&
+( iListBoxExt->iOldWinPos == KErrNotFound ||
+iListBoxExt->iOldWinPos ==
+DrawableWindow()->OrdinalPosition() ) )
 {
 TBool enabled( iItemDrawer && !( iItemDrawer->Flags()
 & CListItemDrawer::ESingleClickDisabledHighlight ) );
 if ( enabled )
 rect.iTl.iX += LafListBox::InnerGutter();
 if (iItemDrawer->Flags()&CListItemDrawer::EDrawMarkSelection)
 {
 rect.iTl.iX += iItemDrawer->MarkColumn() + iItemDrawer->MarkGutter();
 }
-iListBoxExt->SetReasonForFocusLost(EFocusLostToInternalEditor);
+if ( iListBoxExt )
+{
+iListBoxExt->SetReasonForFocusLost(EFocusLostToInternalEditor);
+}
 itemEditor->StartEditingL(*this,rect,index,aMaxLength);
-iListBoxExt->SetReasonForFocusLost(EFocusLostToExternalControl);
+if ( iListBoxExt )
+{
+iListBoxExt->SetReasonForFocusLost(EFocusLostToExternalControl);
+}
 ReportListBoxEventL( MEikListBoxObserver::EEventEditingStarted );
 }
 _AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 //
 EXPORT_C void CEikListBox::DisableScrolling( TBool aDisabled )
 {
 _AKNTRACE_FUNC_ENTER;
-iListBoxExt->iScrollingDisabled = aDisabled;
+if ( iListBoxExt )
-iView->iExtension->iScrollingDisabled = aDisabled;
+{
+iListBoxExt->iScrollingDisabled = aDisabled;
-if ( aDisabled && iListBoxExt->iPhysics )
+iView->iExtension->iScrollingDisabled = aDisabled;
-{
-delete iListBoxExt->iPhysics;
+if ( aDisabled && iListBoxExt->iPhysics )
-iListBoxExt->iPhysics = NULL;
+{
-iView->SetItemOffsetInPixels( 0 );
+delete iListBoxExt->iPhysics;
-}
+iListBoxExt->iPhysics = NULL;
-else if ( !aDisabled && !iListBoxExt->iPhysics && CAknPhysics::FeatureEnabled() )
+iView->SetItemOffsetInPixels( 0 );
-{
+}
-iListBoxExt->iPhysics = CAknPhysics::NewL( *iListBoxExt, this);
+else if ( !aDisabled && !iListBoxExt->iPhysics && CAknPhysics::FeatureEnabled() )
+{
+iListBoxExt->iPhysics = CAknPhysics::NewL( *iListBoxExt, this);
+}
 }
 _AKNTRACE_FUNC_EXIT;
 }
 // Checks if the kinetic scrolling functionality is disabled in the list.
 // ---------------------------------------------------------------------------
 //
 EXPORT_C TBool CEikListBox::ScrollingDisabled()
 {
-return !iListBoxExt->iPhysics || iListBoxExt->iScrollingDisabled;
+if ( iListBoxExt )
+{
+return !iListBoxExt->iPhysics || iListBoxExt->iScrollingDisabled;
+}
+else
+{
+return ETrue;
+}
 }
 EXPORT_C void CEikListBox::SetPointerEventFilterDisabledL( const CArrayFix<TInt>& aItemIndexes )
 {
 _AKNTRACE_FUNC_ENTER;
-iListBoxExt->iMutiTappingItems.Reset();
+if ( iListBoxExt )
+{
-for(TInt i=0; i<aItemIndexes.Count(); i++ )
+iListBoxExt->iMutiTappingItems.Reset();
-{
-iListBoxExt->iMutiTappingItems.InsertInOrderL( aItemIndexes.At(i) );
+for(TInt i=0; i<aItemIndexes.Count(); i++ )
-}
+{
+iListBoxExt->iMutiTappingItems.InsertInOrderL( aItemIndexes.At(i) );
+}
+}
 _AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // Disables the single click functionality in the list.
 // ---------------------------------------------------------------------------
 //
 EXPORT_C void CEikListBox::DisableSingleClick( TBool aDisabled )
 {
 _AKNTRACE_FUNC_ENTER;
-if ( aDisabled && iListBoxExt->iSingleClickEnabled )
+if ( aDisabled &&
+iListBoxExt &&
+	 iListBoxExt->iSingleClickEnabled &&
+	 iItemDrawer )
 {
 iListBoxExt->DisableSingleClick();
+iItemDrawer->ClearFlags( CListItemDrawer::ESingleClickEnabled);
+}
+else if ( !aDisabled &&
+iListBoxExt &&
+!iListBoxExt->iSingleClickEnabled &&
+iItemDrawer )
+{
+TRAP_IGNORE( iListBoxExt->EnableSingleClickL() );
+iItemDrawer->SetFlags( CListItemDrawer::ESingleClickEnabled );
 }
 _AKNTRACE_FUNC_EXIT;
 }
 // CEikListBox::DisableItemSpecificMenu
 // ---------------------------------------------------------------------------
 //
 EXPORT_C void CEikListBox::DisableItemSpecificMenu()
 {
+_AKNTRACE_FUNC_ENTER;
 if ( iListBoxExt )
 {
 iListBoxExt->DisableItemSpecificMenu();
+}
+_AKNTRACE_FUNC_EXIT;
+}
+// ---------------------------------------------------------------------------
+// CEikListBox::IsHighlightEnabled
+// ---------------------------------------------------------------------------
+//
+EXPORT_C TBool CEikListBox::IsHighlightEnabled()
+{
+_AKNTRACE_FUNC_ENTER;
+TBool enabled( EFalse );
+if ( !( iItemDrawer->Flags() & CListItemDrawer::EDisableHighlight ) )
+{
+if ( iListBoxExt && iListBoxExt->iSingleClickEnabled )
+{
+enabled = !( iItemDrawer->Flags()
+& CListItemDrawer::ESingleClickDisabledHighlight );
+}
+else
+{
+enabled = ETrue;
+}
+}
+_AKNTRACE_FUNC_EXIT;
+return enabled;
+}
+// ---------------------------------------------------------------------------
+// CEikListBox::SetMarkingMode
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CEikListBox::SetMarkingMode( TBool aEnable )
+{
+if ( iListBoxExt && iListBoxExt->iSingleClickEnabled &&
+( iListBoxFlags & CEikListBox::ES60StyleMarkable ) )
+{
+if ( iListBoxExt->iMarkingModeInUse != aEnable )
+{
+if ( aEnable )
+{
+iView->ItemDrawer()->SetFlags(
+CListItemDrawer::EMarkingModeEnabled );
+}
+else
+{
+iView->ItemDrawer()->ClearFlags(
+CListItemDrawer::EMarkingModeEnabled );
+if ( iView->SelectionIndexes()->Count() > 0 )
+{
+iView->ClearSelection( EFalse );
+}
+}
+iListBoxExt->iMarkingModeInUse = aEnable;
+DrawDeferred();
+}
+if ( MarkingModeObserver() )
+{
+MarkingModeObserver()->MarkingModeStatusChanged( aEnable );
+}
+}
+}
+// ---------------------------------------------------------------------------
+// CEikListBox::SetMarkingModeObserver
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CEikListBox::SetMarkingModeObserver(
+MAknMarkingModeObserver* aObserver )
+{
+if ( iListBoxExt )
+{
+iListBoxExt->iMarkingModeObserver = aObserver;
 }
 }
 void CEikListBox::ScrollView( const TInt aOffset, TBool aDrawNow )
 	{
 	_AKNTRACE_FUNC_ENTER;
 #ifdef _DEBUG
 	RDebug::Print( _L( "CEikListBox::ScrollView, aOffset = %d, aDrawNow = %d" ), aOffset, aDrawNow );
 #endif // _DEBUG
-	if ( aOffset != 0 )
+	if ( iListBoxExt && aOffset != 0 )
 	    {
 TInt itemHeight = iView->ItemHeight();
 TInt viewHeight = iView->ViewRect().Size().iHeight;
 TInt itemsInSingleLine = iListBoxExt->iItemsInSingleLine;
 TInt oldListTopPos = ( iView->TopItemIndex() / itemsInSingleLine ) * itemHeight
 {
 if( ( newListBottomPos < iListBoxExt->ListBottomLimit() && newListTopPos > 0 ) ||
 ( newListBottomPos >= iListBoxExt->ListBottomLimit() ) ||
 ( newListTopPos <= 0 && newListTopPos + viewHeight >= 0 && newListLastItemPos > viewHeight ) )
 {
-if ( CAknPhysics::EAknPhysicsActionFlicking == iListBoxExt->iPhysics->OngoingPhysicsAction() ||
+switch(iListBoxExt->iPhysics->OngoingPhysicsAction())
-CAknPhysics::EAknPhysicsActionBouncing == iListBoxExt->iPhysics->OngoingPhysicsAction() )
 {
-iListBoxExt->ImmediateFeedback( ETouchFeedbackSensitiveItem,
+case CAknPhysics::EAknPhysicsActionBouncing:
-TTouchFeedbackType( ETouchFeedbackVibra ),
+case CAknPhysics::EAknPhysicsActionDragging:
-TPointerEvent() );
+case CAknPhysics::EAknPhysicsActionFlicking:
-}
+iListBoxExt->ImmediateFeedback(
-else if ( CAknPhysics::EAknPhysicsActionDragging == iListBoxExt->iPhysics->OngoingPhysicsAction() )
+ETouchFeedbackSensitiveList,
-{
+TTouchFeedbackType( ETouchFeedbackVibra ),
-iListBoxExt->ImmediateFeedback( iListBoxExt->iFeedbackType,
+TPointerEvent() );
-TTouchFeedbackType( ETouchFeedbackVibra | ETouchFeedbackAudio ),
+break;
-TPointerEvent() );
+default:
+break;
 }
 }
 }
 }
 newTopItemIndex = newTopItemIndexBck;
 #ifdef _DEBUG
 RDebug::Print( _L( "CEikListBox::ScrollView, newTopItemIndex = %d" ), newTopItemIndex );
 #endif // _DEBUG
 iView->SetTopItemIndex( newTopItemIndex );
 }
 if ( aDrawNow )
 {
 TRect rect(Rect());
 // list position changed
-iListBoxExt->iBackgroundDrawingSuppressed = ETrue;
+if ( iListBoxExt && iListBoxExt->FlickOrPanningOngoing() )
+{
+iItemDrawer->SetFlags( CListItemDrawer::EDrawWholeBackground );
+}
 UpdateScrollBarThumbs();
 DrawNow();
 if (iSBFrame && iSBFrame->VerticalScrollBar() && !iSBFrame->VerticalScrollBar()->OwnsWindow())
 {
 TRect srect( iSBFrame->VerticalScrollBar()->Rect() );
 if ( !srect.Intersects( rect ))
 {
 iSBFrame->DrawScrollBarsNow();
 }
 }
-iListBoxExt->iBackgroundDrawingSuppressed = EFalse;
+if ( iListBoxExt )
+{
+iItemDrawer->ClearFlags( CListItemDrawer::EDrawWholeBackground
+| CListItemDrawer::EBackgroundDrawn );
+}
 }
 _AKNTRACE_FUNC_EXIT;
 	}
 TBool CEikListBox::HandlePhysicsPointerEventL( const TPointerEvent& aPointerEvent )
 {
 _AKNTRACE_FUNC_ENTER;
 _AKNTRACE( "aPointerEvent.iType = %d", aPointerEvent.iType );
 if ( iListBoxExt->iPhysics->OngoingPhysicsAction() == CAknPhysics::EAknPhysicsActionBouncing )
 {
-// Block scrolling events outside listbox area. Note that pointer
+// Block scrolling events outside listbox area.
-// event ignore must be done for the window-owning control or it
+if ( iListBoxExt->IgnorePointerEventsUntilUp() )
-// doesn't have any effect!
+{
-CCoeControl* windowOwningControl = this;
-while ( windowOwningControl && !windowOwningControl->OwnsWindow() )
-{
-windowOwningControl = windowOwningControl->Parent();
-}
-if ( windowOwningControl )
-{
-windowOwningControl->IgnoreEventsUntilNextPointerUp();
 _AKNTRACE_FUNC_EXIT;
 return ETrue;
 }
 }
 TBool blockEvent = EFalse;
-TBool allowDragEvent( ( iListBoxFlags & ELeftDownInViewRect ) && iSBFrame && !iListBoxExt->iScrollingDisabled );
+// If tap down in listbox area, kinetic scrolling is enabled and style popup menu is not shown,
+// drag event is sent to listbox.
+TBool allowDragEvent( ( iListBoxFlags & ELeftDownInViewRect )
+&& !iListBoxExt->iScrollingDisabled
+&& ( iListBoxExt->iSingleClickEnabled
+&& iListBoxExt->iLongTappedItem == KErrNotFound ) );
 switch ( aPointerEvent.iType )
 {
 case TPointerEvent::EButton1Down:
 {
 tappedItemIndex );
 if ( iListBoxExt->iIsDownOnItem )
 {
 iListBoxExt->iLastDownTappedItem = tappedItemIndex;
 iListBoxExt->iMarkingDisabled = ETrue;
+iListBoxFlags|=ELeftDownInViewRect;
 blockEvent = ETrue;
+iListBoxExt->ImmediateFeedback(
+ETouchFeedbackList,
+TTouchFeedbackType( ETouchFeedbackVibra |
+ETouchFeedbackAudio ),
+aPointerEvent );
 }
 }
 }
 else
 {
 void CEikListBox::UpdateHighlightL( TInt aItemIndex )
 {
 _AKNTRACE_FUNC_ENTER;
 TInt oldCurrentItemIndex = iView->CurrentItemIndex();
-if ( iListBoxExt->iReportDelayedPenDown && !iListBoxExt->iScrolling )
+if ( iListBoxExt && iListBoxExt->iReportDelayedPenDown
+&& !iListBoxExt->iScrolling )
 {
 #ifdef RD_UI_TRANSITION_EFFECTS_LIST
 if ( aItemIndex != oldCurrentItemIndex )
 {
 MAknListBoxTfxInternal* transApi =
 // been made visible.
 iListBoxExt->LongTapPointerEventL(
 iListBoxExt->iDelayedPointerDownEvent );
 }
-if ( iListBoxExt->iDelayedMultiselection )
+if ( iListBoxExt && iListBoxExt->iDelayedMultiselection )
 {
 iItemDrawer->SetFlags( CListItemDrawer::EPressedDownState );
 }
 iView->SetItemIndex( aItemIndex );
-if ( iListBoxExt->iMarkableListMarking )
+if ( iListBoxExt && iListBoxExt->iMarkableListMarking )
 {
-if ( iListBoxExt->iMarkableListShiftKeyPressed )
+if ( iListBoxExt->iSingleClickEnabled )
+{
+if ( iListBoxExt->iMarkableListShiftKeyPressed )
+{
+iView->ToggleItemL( iView->CurrentItemIndex() );
+iListBoxExt->iClickEventsAllowed = EFalse;
+}
+}
+else if ( iListBoxExt->iMarkableListShiftKeyPressed )
 {
 #ifdef RD_UI_TRANSITION_EFFECTS_LIST
 iListBoxExt->iAnchor = oldCurrentItemIndex;
 iListBoxExt->iSelect =
 !iView->ItemIsSelected( iView->CurrentItemIndex() );
 }
 iView->DrawItem( oldCurrentItemIndex );
 iView->DrawItem( aItemIndex );
-if ( iListBoxExt->iDelayedMultiselection )
+if ( iListBoxExt && iListBoxExt->iDelayedMultiselection )
 {
 iListBoxFlags |= EStateChanged;
 Buffer()->iPressedIndex = aItemIndex;
 }
 ReportEventL( MCoeControlObserver::EEventStateChanged );
 _AKNTRACE_FUNC_EXIT;
+}
+// ---------------------------------------------------------------------------
+// CEikListBox::MarkingMode
+// ---------------------------------------------------------------------------
+//
+TBool CEikListBox::MarkingMode() const
+{
+TBool markingModeInUse = EFalse;
+if ( iListBoxExt )
+{
+markingModeInUse = iListBoxExt->iMarkingModeInUse;
+}
+return markingModeInUse;
+}
+// ---------------------------------------------------------------------------
+// CEikListBox::MarkingModeObserver
+// ---------------------------------------------------------------------------
+//
+MAknMarkingModeObserver* CEikListBox::MarkingModeObserver()
+{
+MAknMarkingModeObserver* observer = NULL;
+if ( iListBoxExt )
+{
+observer = iListBoxExt->iMarkingModeObserver;
+}
+return observer;
 }
 // ---------------------------------------------------------------------------
 // Sets this control as visible or invisible.

branch	RCL_3
changeset 56	d48ab3b357f1
parent 55	aecbbf00d063
child 59	978afdc0236f