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

equal deleted inserted replaced

-:0aa5fbdfbc30
+:3d340a0166ff
 /*
-* 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.
 * 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;
 private:
 CMatchBuffer* iBuffer;
 CEikListBox& iListBox;
 CEikListBox::TReasonForFocusLost iReasonForFocusLost;
 iLastItemIndex(-1),
 iItemActionMenu( NULL ),
 iLongTapDetector( NULL ),
 iSingleClickEnabled( iAvkonAppUi->IsSingleClickCompatible() ),
 iLongTappedItem( KErrNotFound ),
-iListBox(aListBox)
+iOldWinPos( KErrNotFound ),
+iListBox(aListBox)
 {
 }
 CListBoxExt::~CListBoxExt()
 {
 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*/ )
 {
+if ( aExtensionId == MAknMarkingCollection::TYPE )
+{
+a0 = static_cast<MAknMarkingCollection*>( this );
+}
 return KErrNone;
+}
+// -----------------------------------------------------------------------------
+// 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( iListBox.CurrentItemIndex() );
+}
+}
+_AKNTRACE_FUNC_EXIT;
+}
+// -----------------------------------------------------------------------------
+// CListBoxExt::MarkAllL
+// -----------------------------------------------------------------------------
+//
+void CListBoxExt::MarkAllL()
+{
+_AKNTRACE_FUNC_ENTER;
+if ( iListBox.MarkingMode() )
+{
+for ( TInt i = 0; i < iListBox.Model()->NumberOfItems(); ++i )
+{
+if ( !iListBox.iItemDrawer->Properties( i ).IsSelectionHidden() )
+{
+iListBox.View()->SelectItemL( i );
+}
+}
+}
+_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 );
+IgnorePointerEventsUntilUp();
+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 )
 {
 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 item specific items were found and current
+// Send event on down only if item specific items were found.
-// item is marked if there are marked items
+// Long tap is also disabled if current item is not marked while
-if ( !( MarkedItems() &&
+// there are some marked items or marking mode is active.
-!iListBox.View()->ItemIsSelected( iListBox.CurrentItemIndex() ) )
+if ( !( ( iListBox.MarkingMode() || MarkedItems() )
-&& ( aPointerEvent.iType != TPointerEvent::EButton1Down
+&& !iListBox.View()->ItemIsSelected( iListBox.CurrentItemIndex() ) )
-|| iItemActionMenu->InitMenuL() ) )
+&& ( aPointerEvent.iType != TPointerEvent::EButton1Down
+|| iItemActionMenu->InitMenuL() ) )
 {
 iLongTapDetector->PointerEventL ( aPointerEvent );
 }
 }
 }
 && 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 ETrue;
+}
+_AKNTRACE_FUNC_EXIT;
+return EFalse;
+}
+// -----------------------------------------------------------------------------
 // CListBoxExt::StartLongPressTimerL
 // -----------------------------------------------------------------------------
 //
 void CListBoxExt::StartLongPressTimerL()
 {
 }
 _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 );
+// 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 ) && !iFlickStopped )
+|| ( iSingleClickEnabled && iLastDownTappedItem != KErrNotFound ) ) &&
+!iFlickStopped )
 {
 enabled = ETrue;
 }
 _AKNTRACE_FUNC_EXIT;
 return enabled;
 }
 // ---------------------------------------------------------------------------
 	|| iListBoxExt && iListBoxExt->iPhysics
 	&& currentItemIndex == ( topItemIndex + numberOfItems - 1 ) )
 {
 if ( iListBoxExt && iListBoxExt->iSingleClickEnabled )
 {
-// If single click is enabled, highlight must also be visible
+TInt offset = (iListBoxExt->iWorldSize.iHeight / 2)
-if ( iListBoxExt->CollectionState()
+- iListBoxExt->iViewPosition.iY;
+TInt totalItems = iModel->NumberOfItems();
+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 );
 }
 }
 if ( newTopItemIndex != KEikListBoxInvalidIndex )
 	{
 	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;
 }
 // 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;
 if ( iListBoxExt && iListBoxExt->iPhysics
 && aEvent != MEikListBoxObserver::EEventFlickStopped )
 {
 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);
 // 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() )
 {
 iView->DrawItem( iView->CurrentItemIndex() );
 }
 iListBoxExt->iFeedbackType = ETouchFeedbackList;
-if ( iListBoxFlags & ES60StyleMultiselection ||
+if ( !iListBoxExt->iSingleClickEnabled &&
-( !iListBoxExt->iSingleClickEnabled &&
+itemIndex != iView->CurrentItemIndex() )
-itemIndex != iView->CurrentItemIndex() ) )
 {
 iListBoxExt->iFeedbackType = ETouchFeedbackSensitiveList;
 }
 if ( iListBoxExt->iPhysics &&
 iListBoxExt->EnableHighlight( ETrue, ETrue );
 UpdateHighlightL( itemIndex );
 CCoeEnv::Static()->WsSession().Finish();
 }
-iListBoxExt->ImmediateFeedback(
+if ( !( ( iListBoxFlags & EViewerFlag ) &&
-iListBoxExt->iFeedbackType,
+( iListBoxFlags & EDisableItemSpecificMenu ) ) )
-TTouchFeedbackType( ETouchFeedbackVibra |
+{
-ETouchFeedbackAudio ),
+iListBoxExt->ImmediateFeedback(
-aPointerEvent );
+iListBoxExt->iFeedbackType,
+TTouchFeedbackType( ETouchFeedbackVibra |
+ETouchFeedbackAudio ),
+aPointerEvent );
+}
 if ( !wasFlicking )
 {
 ReportListBoxEventL(
 MEikListBoxObserver::EEventPenDownOnItem );
 {
 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 );
 }
 break;
 case TPointerEvent::EButton1Up:
 _AKNTRACE("TPointerEvent::EButton1Up");
-if ( iListBoxExt->FeedbackEnabledOnUpEvent() && iListBoxExt->iClickEventsAllowed )
+if ( iListBoxExt->FeedbackEnabledOnUpEvent() && iListBoxExt->iClickEventsAllowed
+	                    && ( !( ( iListBoxFlags & EViewerFlag ) &&
+( iListBoxFlags & EDisableItemSpecificMenu ) ) ) )
 {
 TTouchLogicalFeedback fbType = ETouchFeedbackList;
-if ( iListBoxFlags & ES60StyleMultiselection )
+if ( iListBoxFlags & ES60StyleMultiselection
+|| iListBoxFlags & EMultipleSelection )
 {
 fbType = ETouchFeedbackCheckbox;
 }
 iListBoxExt->ImmediateFeedback( fbType,
 ETouchFeedbackVibra,
 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, the
+// item index may change unwanted, so we make a threshold
+// for this situation.
+else if ( s60StyleMultiselection
+&& ( iListBoxExt->iLastDownTappedItem == itemIndex
+|| Abs( iListBoxExt->iLastPointerPos.iY
+- aPointerEvent.iPosition.iY ) < KPointerDownAndUpThreshold )
+&& !Buffer()->iDragToAnotherItem )
 {
 iListBoxFlags |= EStateChanged;
 Buffer()->iPressedIndex = itemIndex;
 iView->SetAnchor(itemIndex-1); // zero indexed
 iView->UpdateSelectionL(selectionMode);
 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;
 }
 }
 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 )
 {
 DrawDeferred();
 break;
 case KAknMessageFocusLost:
 {
-if ( iListBoxExt && iListBoxExt->iSingleClickEnabled )
+TInt oldWinPos = iListBoxExt->iOldWinPos;
+TInt winPos = DrawableWindow()->OrdinalPosition();
+// Do not remove higlight if window ordinal position has changed
+// during the time when stylus menu is open
+if ( iListBoxExt && iListBoxExt->iSingleClickEnabled
+&& ( oldWinPos == KErrNotFound || oldWinPos == winPos ) )
 {
 TBool enabled( iItemDrawer && !( iItemDrawer->Flags()
 & CListItemDrawer::ESingleClickDisabledHighlight ) );
 if ( enabled )
 }
 }
 _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
 TTouchFeedbackType( ETouchFeedbackVibra ),
 TPointerEvent() );
 }
 else if ( CAknPhysics::EAknPhysicsActionDragging == iListBoxExt->iPhysics->OngoingPhysicsAction() )
 {
-iListBoxExt->ImmediateFeedback( iListBoxExt->iFeedbackType,
+iListBoxExt->ImmediateFeedback( ETouchFeedbackSensitiveList,
 TTouchFeedbackType( ETouchFeedbackVibra | ETouchFeedbackAudio ),
 TPointerEvent() );
 }
 }
 }
 #ifdef _DEBUG
 RDebug::Print( _L( "CEikListBox::ScrollView, newTopItemIndex = %d" ), newTopItemIndex );
 #endif // _DEBUG
 iView->SetTopItemIndex( newTopItemIndex );
 }
 if ( aDrawNow )
 {
 TRect rect(Rect());
 // list position changed
-if ( iListBoxExt )
+if ( iListBoxExt && iListBoxExt->FlickOrPanningOngoing() )
 {
-iListBoxExt->iBackgroundDrawingSuppressed = ETrue;
+iItemDrawer->SetFlags( CListItemDrawer::EDrawWholeBackground );
 }
 UpdateScrollBarThumbs();
 DrawNow();
 if (iSBFrame && iSBFrame->VerticalScrollBar() && !iSBFrame->VerticalScrollBar()->OwnsWindow())
 {
 TRect srect( iSBFrame->VerticalScrollBar()->Rect() );
 if ( !srect.Intersects( rect ))
 {
 iSBFrame->DrawScrollBarsNow();
 }
 }
 if ( iListBoxExt )
 {
-iListBoxExt->iBackgroundDrawingSuppressed = EFalse;
+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;
 }
 }
 {
 iListBoxExt->iLastDownTappedItem = tappedItemIndex;
 iListBoxExt->iMarkingDisabled = ETrue;
 iListBoxFlags|=ELeftDownInViewRect;
 blockEvent = ETrue;
+iListBoxExt->ImmediateFeedback(
+ETouchFeedbackList,
+TTouchFeedbackType( ETouchFeedbackVibra |
+ETouchFeedbackAudio ),
+aPointerEvent );
 }
 }
 }
 else
 {
 _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.
 // ---------------------------------------------------------------------------
 //
 EXPORT_C void CEikListBox::MakeVisible( TBool aVisible )
 {

branch	RCL_3
changeset 23	3d340a0166ff
parent 18	0aa5fbdfbc30
child 25	941195f2d488