MCL/sf/mw/classicui: comparison uifw/AvKon/aknhlist/src/akntreelistview.cpp

equal deleted inserted replaced

-:aecbbf00d063
+:d48ab3b357f1
 /*
-* Copyright (c) 2006, 2007 Nokia Corporation and/or its subsidiary(-ies).
+* Copyright (c) 2006-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 <barsread.h>
 #include <aknappui.h>
 #include <aknitemactionmenu.h>
 #include <AknTasHook.h> // for testability hooks
 #include <AknPriv.hrh>
+#include <AknIconArray.h>
+#include <avkon.mbg>
+#include <gulicon.h>
+#include <aknmarkingmodeobserver.h>
 #include "akntreelistview.h"
 #include "akntree.h"
 #include "akntreelist.h"
 #include "akntreeiterator.h"
 #include "akntreelistphysicshandler.h"
+#include "akntrace.h"
 #ifdef RD_UI_TRANSITION_EFFECTS_LIST
 #include <aknlistboxtfxinternal.h> // LISTBOX EFFECTS IMPLEMENTATION
 #include <aknlistloadertfx.h>
 const TInt KLongPressInterval = 600000; // 0.6 seconds
 // Number of additional items to draw
 const TInt KAdditionalItems = 2;
+// Number of icons in marking mode icon array
+const TInt KMarkingModeIconArraySize = 2;
 // Tree list view flag definitions.
 enum TAknTreeListViewFlags
 {
 EFlagStructureLines,
 EFlagIndention,
 EFlagLooping,
 EFlagUpdateBackground,
 EFlagMarkingEnabled, // Marking of list items is enabled.
-EFlagMarkingMode, // List in marking mode (MSK controlled by list).
+EFlagMarkingState, // List in marking state (MSK controlled by list).
 EFlagMark, // List items are being marked.
 EFlagUnmark, // List items are being unmarked.
 EFlagSimultaneousMarking, // Simultaneous marking ongoing.
 EFlagHashKeyPressed,
 EFlagCtrlKeyPressed,
 EFlagShiftKeyPressed,
 EFlagSaveFocusAfterSorting,
 EFlagSingleClickEnabled,
 EFlagHighlightEnabled, // Is highlight drawing enabled
-EFlagIgnoreButtonUpEvent // Up event ignored (when styluspopup menu open)
+EFlagIsPressedDownState,
+EFlagIsDragged,
+EFlagScrollPhysicsTop, // Physics view adjusted according to top item
+EFlagMirroredLayoutInUse, // Mirrored layout in use
+EFlagMarkingMode // Marking mode activated
 };
 // ======== MEMBER FUNCTIONS ========
 {
 iItemActionMenu->RemoveCollection( *this );
 }
 delete iLongTapDetector;
+if ( iMarkingIconArray )
+{
+iMarkingIconArray->ResetAndDestroy();
+}
+delete iMarkingIconArray;
 #ifdef RD_UI_TRANSITION_EFFECTS_LIST
 if ( CAknListLoader::TfxApiInternal( iGc ) )
 {
 delete iGc;
 }
 if ( aDrawNow )
 {
 Window().Invalidate( Rect() );
 }
-UpdateScrollbars();
+UpdateScrollbars( ETrue );
 }
 // ---------------------------------------------------------------------------
 // Sets the focused item and its position in the view.
 UpdateAnimation();
 // Draw always
 Window().Invalidate( Rect() );
-UpdateScrollbars();
+UpdateScrollbars( ETrue );
 }
 // ---------------------------------------------------------------------------
 void CAknTreeListView::SetEmptyTextL(const TDesC& aText)
 {
 delete iEmptyListText;
 iEmptyListText = NULL;
 iEmptyListText = aText.AllocL();
+UpdateScrollbars( ETrue );
 }
 // ---------------------------------------------------------------------------
 // InitPhysicsL
 // SelectItem
 // ---------------------------------------------------------------------------
 //
 void CAknTreeListView::SelectItem( CAknTreeItem* aSelectedItem )
 {
-SelectItem( aSelectedItem, EFalse );
+if ( iFlags.IsSet( EFlagMarkingMode ) )
+{
+if ( aSelectedItem->IsMarkable() )
+{
+MarkItem( aSelectedItem, !aSelectedItem->IsMarked(), ETrue );
+}
+else if ( aSelectedItem->IsNode() )
+{
+SelectItem( aSelectedItem, EFalse );
+}
+}
+else
+{
+SelectItem( aSelectedItem, EFalse );
+}
 }
 // ---------------------------------------------------------------------------
 // VisibleItemCount
 // SetPressedDownState
 // ---------------------------------------------------------------------------
 //
 void CAknTreeListView::SetPressedDownState( const TBool& aPressedDown )
 {
-iIsPressedDownState = aPressedDown;
+if ( aPressedDown )
+{
+iFlags.Set( EFlagIsPressedDownState );
+}
+else
+{
+iFlags.Clear( EFlagIsPressedDownState );
+}
 }
 // ---------------------------------------------------------------------------
 // UpdateTreeListView
 void CAknTreeListView::UpdateTreeListView( const TInt& aFirstItem,
 const TBool& aDrawNow )
 {
 CAknTreeItem* first = iTree.VisibleItem( aFirstItem );
 UpdateVisibleItems( 0, first );
-UpdateScrollbars();
+UpdateScrollbars( ETrue );
 UpdateAnimation();
 if ( aDrawNow )
 {
 DrawNow();
 // ---------------------------------------------------------------------------
 //
 void CAknTreeListView::MakeVisible( TBool aVisible )
 {
 CAknControl::MakeVisible( aVisible );
+UpdateScrollbars( aVisible );
-if ( aVisible )
-{
-UpdateScrollbars();
-}
 }
 // ---------------------------------------------------------------------------
 // From class CCoeControl.
 Window().SetPointerGrab( ETrue );
 iScrollbarFrame = new ( ELeave ) CEikScrollBarFrame( this, this );
 iScrollbarFrame->CreateDoubleSpanScrollBarsL( EFalse, EFalse );
+if ( CAknEnv::Static()->TransparencyEnabled() && iPhysicsHandler )
+{
+// disable background drawing of scrollbar
+iScrollbarFrame->DrawBackground( EFalse, EFalse );
+}
 }
 // ---------------------------------------------------------------------------
 // From class CCoeControl.
 // ---------------------------------------------------------------------------
 //
 void CAknTreeListView::HandleResourceChange( TInt aType )
 {
 CAknControl::HandleResourceChange( aType );
-if ( aType == KAknsMessageSkinChange )
-{
+switch ( aType )
-TRAPD( error, CreateAnimationL() )
+{
-if ( error )
+case KEikMessageWindowsFadeChange:
 {
-delete iAnimation;
+ReportCollectionChangedEvent();
-iAnimation = NULL;
+}
-}
-}
+case KAknsMessageSkinChange:
-else if ( aType == KEikDynamicLayoutVariantSwitch && FocusedItem() )
+{
-{
+TRAPD( error, CreateAnimationL() )
-if ( !FocusedItemVisible() )
+if ( error )
 {
-TInt firstItemIndex = 0;
+delete iAnimation;
-if ( iItems.Count() && iItems[0].Item() )
+iAnimation = NULL;
-{
+}
-firstItemIndex = iTree.VisibleItemIndex( iItems[0].Item() );
-}
+TRAP_IGNORE( LoadMarkingIconsL() );
+break;
-TInt index = 0;
+}
-if ( firstItemIndex < iTree.VisibleItemIndex( FocusedItem() ) )
-{
+case KEikDynamicLayoutVariantSwitch:
-index = iItems.Count() - 1;
+{
-}
+if ( AknLayoutUtils::LayoutMirrored() )
+{
-SetFocusedItem( FocusedItem(), index, ETrue );
+iFlags.Set( EFlagMirroredLayoutInUse );
 }
 else
 {
-SetFocusedItem( FocusedItem(), FocusIndex(), ETrue );
+iFlags.Clear( EFlagMirroredLayoutInUse );
+}
+CAknTreeItem* focusedItem( FocusedItem() );
+if ( focusedItem )
+{
+if ( !FocusedItemVisible() )
+{
+TInt firstItemIndex = 0;
+if ( iItems.Count() && iItems[0].Item() )
+{
+firstItemIndex =
+iTree.VisibleItemIndex( iItems[0].Item() );
+}
+TInt index = 0;
+if ( firstItemIndex < iTree.VisibleItemIndex( focusedItem ) )
+{
+index = iItems.Count() - 1;
+}
+if( HighlightEnabled() )
+{
+SetFocusedItem( focusedItem, index, ETrue );
+}
+else
+{
+// This block moves visible view after layout switch
+// if there are not enough items to fill whole screen
+TInt visibleItemIndex = iTree.VisibleItemIndex( focusedItem );
+if ( visibleItemIndex != KErrNotFound )
+{
+TInt visibleItemCount( iTree.VisibleItemCount() );
+TInt itemCountLimit = iItems.Count();
+if ( visibleItemCount <= itemCountLimit - KAdditionalItems )
+{
+UpdateVisibleItems( visibleItemIndex, focusedItem );
+}
+}
+}
+}
+else
+{
+SetFocusedItem( focusedItem, FocusIndex(), ETrue );
+// This block moves visible view after layout switch
+// if there are not enough items to fill whole screen
+TInt visibleItemIndex =
+iTree.VisibleItemIndex( focusedItem );
+if ( visibleItemIndex != KErrNotFound )
+{
+TInt focusedItemIndex = FocusedItemIndex();
+if ( focusedItemIndex != -1 )
+{
+TInt visibleItemCount( iTree.VisibleItemCount() );
+TInt height =
+visibleItemCount - visibleItemIndex + focusedItemIndex;
+TInt itemCountLimit = iItems.Count();
+if ( height < itemCountLimit &&
+height < visibleItemCount )
+{
+TInt move = itemCountLimit - height;
+UpdateVisibleItems( focusedItemIndex + move, focusedItem );
+}
+}
+}
+// end of block
+}
+}
+break;
+}
+case KAknMessageFocusLost:
+{
+if ( SingleClickEnabled() && HighlightEnabled() &&
+( iOldWinPos == KErrNotFound ||
+iOldWinPos == DrawableWindow()->OrdinalPosition() ) )
+{
+EnableHighlight( EFalse );
+// Redraw item
+SetFocusedItem( FocusedItem(), FocusIndex(), ETrue );
+}
+break;
+}
-// This block moves visible view after layout switch
+default:
-// if there are not enough items to fill whole screen
+{
-TInt visibleItemIndex = iTree.VisibleItemIndex( FocusedItem() );
+break;
-if ( visibleItemIndex != KErrNotFound)
+}
-{
-TInt focusedItemIndex = FocusedItemIndex();
-if (focusedItemIndex != -1)
-{
-TInt height =  iTree.VisibleItemCount() - visibleItemIndex + focusedItemIndex;
-TInt itemCountLimit = iItems.Count();
-if ( height < itemCountLimit && height < iTree.VisibleItemCount() )
-{
-TInt move = itemCountLimit - height;
-UpdateVisibleItems( focusedItemIndex + move, FocusedItem() );
-}
-}
-}
-// end of block
-}
-}
-else if ( aType == KAknMessageFocusLost && HighlightEnabled() )
-{
-EnableHighlight( EFalse );
 }
 }
 // ---------------------------------------------------------------------------
 // focused.
 // ---------------------------------------------------------------------------
 //
 void CAknTreeListView::HandlePointerEventL( const TPointerEvent& aPointerEvent )
 {
-if ( iFlags.IsSet( EFlagIgnoreButtonUpEvent )
+if ( GrabbingComponent() )
-&& aPointerEvent.iType == TPointerEvent::EButton1Up )
-{
-return;
-}
-if ( GrabbingComponent() != NULL )
 {
 iPhysicsHandler->ResetEventBlockingStatus();
 }
 else
 {
 {
 EnableHighlight( EFalse );
 }
 TInt thumbPosition = aScrollBar->ThumbPosition();
-if ( AknLayoutUtils::LayoutMirrored() &&
+if ( iFlags.IsSet( EFlagMirroredLayoutInUse ) &&
 aScrollBar != iScrollbarFrame->VerticalScrollBar() )
 {
 const TEikScrollBarModel* model = aScrollBar->Model();
 thumbPosition = ( model->iScrollSpan - model->iThumbSpan )
 - thumbPosition;
 case EEikScrollLeft:
 case EEikScrollRight:
 case EEikScrollPageLeft:
 case EEikScrollPageRight:
 iViewLevel = thumbPosition;
-UpdateScrollbars();
+UpdateScrollbars( ETrue );
 UpdateAnimation();
 Window().Invalidate( Rect() );
 break;
 case EEikScrollThumbDragHoriz:
 UpdateAnimation();
 Window().Invalidate( Rect() );
 break;
 case EEikScrollThumbReleaseHoriz:
-UpdateScrollbars();
+UpdateScrollbars( ETrue );
 break;
 case EEikScrollHome:
-// Not in use!
+// Not in use
 break;
 case EEikScrollEnd:
-// Not in use!
+// Not in use
 break;
 default:
 break;
 }
 break;
 }
 if ( aDrawNow )
 {
-Window().Invalidate( Rect() );
+		// DrawNow must be used here.
+DrawNow();
 }
 }
 // ---------------------------------------------------------------------------
 {
 Window().Invalidate( Rect() );
 }
 else if ( IsFocused() && FocusedItemVisible() )
 {
-TRect rect = iItems[FocusIndex()].HighlightRect( iViewLevel, Indention(), IndentionWidth() );
+TRect rect = iItems[FocusIndex()].HighlightRect( iViewLevel,
+Indention(),
+IndentionWidth() );
 Window().Invalidate( rect );
 }
 ReportTreeListEvent( MAknTreeListObserver::EItemFocused,
 iTree.Id( FocusedItem() ) );
 {
 // Get layout for the view.
 LayoutView();
 // Update scrollbars.
-UpdateScrollbars();
+UpdateScrollbars( ETrue );
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
 UpdateIndexes();
-#endif
 AknsUtils::RegisterControlPosition( this, PositionRelativeToScreen() );
 TRAP_IGNORE( InitPhysicsL() );
 }
 iViewLevel( 0 ),
 iMaxViewLevel( 0 ),
 iStylusDownItemIndex( -1 ),
 iAnimationIID( KAknsIIDQsnAnimList ),
 iIndentionWidth( -1 ),
-iPhysicsHandler( NULL ),
+iPhysicsHandler( NULL )
-iScrollPhysicsTop( ETrue )
 #ifdef RD_UI_TRANSITION_EFFECTS_LIST
 ,iGc(NULL)
 #endif //RD_UI_TRANSITION_EFFECTS_LIST
 ,iItemActionMenu( NULL ),
-iLongTapDetector( NULL )
+iLongTapDetector( NULL ),
+iOldWinPos( KErrNotFound )
 {
 if ( static_cast<CAknAppUi*>(
 iCoeEnv->AppUi() )->IsSingleClickCompatible() )
 {
 iFlags.Set( EFlagSingleClickEnabled );
 }
 iFlags.Set( EFlagStructureLines );
 iFlags.Set( EFlagIndention );
+iFlags.Set( EFlagScrollPhysicsTop );
 }
 // ---------------------------------------------------------------------------
 // Second phase constructor.
 iPhysicsHandler = CAknTreeListPhysicsHandler::NewL( this,
 &iTree,
 &iItems );
 }
-iIsPressedDownState = EFalse;
+iFlags.Clear( EFlagIsPressedDownState );
-iIsDragged = EFalse;
+iFlags.Clear( EFlagIsDragged );
-iItemActionMenu = CAknItemActionMenu::RegisterCollectionL( *this );
+iItemActionMenu = CAknItemActionMenu::RegisterCollectionL( *this, this );
 if ( iItemActionMenu )
 {
 iLongTapDetector = CAknLongTapDetector::NewL( this );
 }
 }
 else
 {
 EnableHighlight( ETrue );
 }
+if ( AknLayoutUtils::LayoutMirrored() )
+{
+iFlags.Set( EFlagMirroredLayoutInUse );
+}
+else
+{
+iFlags.Clear( EFlagMirroredLayoutInUse );
+}
+LoadMarkingIconsL();
 }
 // ---------------------------------------------------------------------------
 // Handles an addition of new item into tree list. The focused item is kept
 // ---------------------------------------------------------------------------
 //
 void CAknTreeListView::HandleItemAddedEvent( CAknTreeItem* /*aItem*/, TBool aDrawNow )
 {
 UpdateVisibleItems();
-if (aDrawNow)
+UpdateScrollbars( aDrawNow );
-{
-UpdateScrollbars();
-}
 }
 // ---------------------------------------------------------------------------
 // Handles the movement of a tree item. Movement of focused item has to be
 {
 // Note: This method cannot deduce, which items in the view have actually
 // been changed, unless the it receives information from where the
 // specified item was moved.
 UpdateVisibleItems();
-UpdateScrollbars();
+UpdateScrollbars( ETrue );
 }
 // ---------------------------------------------------------------------------
 // Prepares view for the item removal by moving the focus from the removed
 // ---------------------------------------------------------------------------
 //
 void CAknTreeListView::HandleItemRemovedEvent( CAknTreeItem* /*aItem*/, TBool aDrawNow )
 {
 UpdateVisibleItems();
-if (aDrawNow)
+UpdateScrollbars( aDrawNow );
-{
-UpdateScrollbars();
-}
 }
 // ---------------------------------------------------------------------------
 // Handles an expansion of a tree node. If the expanded node is focused, it is
 }
 else
 {
 UpdateVisibleItems();
 }
-UpdateScrollbars();
+UpdateScrollbars( ETrue );
 }
 // ---------------------------------------------------------------------------
 // Handles a collapse of a tree node. If one of the items in collapsed node
 // visible
 UpdateViewItemAsVisible( aNode );
 }
 UpdateVisibleItems();
-UpdateScrollbars();
+UpdateScrollbars( ETrue );
 }
 // ---------------------------------------------------------------------------
 // Handles a change in tree item.
 {
 iItems[ii].SetItem( iterator.Next() );
 }
 }
 }
-if ( aDrawNow )
-{
+UpdateScrollbars( aDrawNow );
-UpdateScrollbars();
-}
 }
 // ---------------------------------------------------------------------------
 // Updates the view items so that the specified item is located at the
 void CAknTreeListView::UpdateVisibleItems( TInt aIndex, CAknTreeItem* aItem )
 {
 SetFocusIndex( KMinTInt );
 if ( !iItems.Count() )
 {
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
 UpdateIndexes();
-#endif
 return;
 }
 TInt index = Min( aIndex, iTree.VisibleItemIndex( aItem ) );
 if ( iItems[ii].Item() == FocusedItem() )
 {
 SetFocusIndex( ii );
 }
 }
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
 UpdateIndexes();
-#endif
 }
 // ---------------------------------------------------------------------------
 // Updates the view items so that the focused item remains in the same
 SetFocusIndex( ii );
 }
 item = iterator.Next();
 }
 }
-#ifdef RD_UI_TRANSITION_EFFECTS_LIST
 UpdateIndexes();
-#endif
 }
 else if ( itemCount && iItems.Count() )
 {
 if ( FocusedItemVisible() )
 {
 void CAknTreeListView::HandleSelectionKeyEvent()
 {
 CAknTreeItem* item = FocusedItem();
 if ( item )
 {
-if ( MarkingOngoing() )
+if ( iFlags.IsSet( EFlagMarkingMode ) )
 {
-MarkItem( item, !item->IsMarked(), ETrue );
+if ( item->IsMarkable() )
+{
+MarkItem( item, !item->IsMarked(), ETrue );
+}
 }
 else
 {
-SelectItem( item, true );
+SelectItem( item, EFalse );
 }
 }
 }
 // Handles right arrow key event.
 // ---------------------------------------------------------------------------
 //
 void CAknTreeListView::HandleRightArrowKeyEvent()
 {
-if ( AknLayoutUtils::LayoutMirrored() )
+if ( iFlags.IsSet( EFlagMirroredLayoutInUse ) )
 {
 AscendFocus();
 }
 else
 {
 // Handles left arrow key event.
 // ---------------------------------------------------------------------------
 //
 void CAknTreeListView::HandleLeftArrowKeyEvent()
 {
-if ( AknLayoutUtils::LayoutMirrored() )
+if ( iFlags.IsSet( EFlagMirroredLayoutInUse ) )
 {
 DescendFocus();
 }
 else
 {
 for ( TInt ii = iItems.Count(); ii < itemCountLimit; ++ii )
 {
 // This should not fail, if enough space was reserved for the
 // array, and if it fails, it results only fewer items being
 // shown in the list.
-iItems.Append( TAknTreeListViewItem() );
+			if ( KErrNone != iItems.Append( TAknTreeListViewItem() ) )
+				{
+				return;
+				}
 }
 }
 // Get iterator and set it to point at the first item in the view, or at
 // the first item in the list, if the view does not contain any items.
 if ( first )
 {
 iterator.SetCurrent( first );
 iterator.Previous();
 }
+if ( iFlags.IsSet( EFlagMarkingMode ) )
+{
+if ( iFlags.IsSet( EFlagMirroredLayoutInUse ))
+{
+itemRect.iBr.iX -=
+AknLayoutScalable_Avkon::list_double_graphic_pane_t1(
+0 ).LayoutLine().ir;
+}
+else
+{
+itemRect.iBr.iX -=
+AknLayoutScalable_Avkon::list_double_graphic_pane_t1(
+0 ).LayoutLine().il;
+}
+}
 // Update items and their rectangles.
 for ( TInt ii = 0; ii < iItems.Count(); ++ii )
 {
 CAknTreeItem* item = iterator.Next();
 TRect viewRect( listRect );
 // Fill whole control area with list items when physics enabled
 // and threre is no horizontal scrollbar.
 if ( iScrollbarFrame &&
-iScrollbarFrame->ScrollBarVisibility( CEikScrollBar::EHorizontal ) != CEikScrollBarFrame::EOn &&
+iScrollbarFrame->ScrollBarVisibility(
+CEikScrollBar::EHorizontal ) != CEikScrollBarFrame::EOn &&
 viewRect.Height() < Rect().Height() )
 {
 viewRect.iTl.iY = Rect().iTl.iY;
 viewRect.iBr.iY = Rect().iBr.iY;
 }
 // Updates the span, thumb size and position for both of the scrollbars. New
 // layout for the view is applied, if the visibility of either of the
 // scrollbars changes.
 // ---------------------------------------------------------------------------
 //
-void CAknTreeListView::UpdateScrollbars()
+void CAknTreeListView::UpdateScrollbars( TBool aDrawNow )
 {
 if ( iScrollbarFrame )
 {
-iPhysicsHandler->UpdateScrollIndex( iScrollPhysicsTop );
+TBool drawHorizontal;
-iScrollPhysicsTop = ETrue;
+TBool drawVertical;
+if ( !aDrawNow )
+{
+// Backup the old values.
+iScrollbarFrame->DrawBackgroundState( drawHorizontal,
+drawVertical );
+// Disable the scrollbar background drawing for the duration
+// of this call.
+iScrollbarFrame->DrawBackground( EFalse, EFalse );
+}
+iPhysicsHandler->UpdateScrollIndex(
+iFlags.IsSet( EFlagScrollPhysicsTop ) );
+iFlags.Set( EFlagScrollPhysicsTop );
 // Get values for horizontal scrollbar.
 TInt hThumbPos = iViewLevel;
 TInt hThumbSpan = iHorizontalViewSpan;
 TInt hScrollSpan = Max( hThumbPos + hThumbSpan, iMaxViewLevel );
 TInt c = iItems[0].ItemRect( iViewLevel, Indention(),
 IndentionWidth() ).Width();
 hThumbSpan = a/b;
 hScrollSpan = Max( hThumbPos + hThumbSpan, c/b );
 }
+if ( iFlags.IsSet( EFlagMirroredLayoutInUse ) )
-if ( AknLayoutUtils::LayoutMirrored() )
 {
 hThumbPos = hScrollSpan - ( hThumbPos + hThumbSpan );
 }
 TEikScrollBarModel hModel( hScrollSpan, hThumbSpan, hThumbPos );
 // Set new model for scrollbars.
 iScrollbarFrame->Tile( &hModel, &vModel );
 LayoutView();
-UpdateScrollbars(); // Recursion
+UpdateScrollbars( aDrawNow ); // Recursion
 // Update animation in case that scrollbar visibility change
 // has affected the highlight size of focused item.
 UpdateAnimation();
 }
 else
 {
 // Set new model for scrollbars.
 iScrollbarFrame->Tile( &hModel, &vModel );
 }
+if ( !aDrawNow )
+{
+// Restore the previous draw background state values.
+iScrollbarFrame->DrawBackground( drawHorizontal, drawVertical );
+}
 }
 }
 {
 iLongPressTimer->Cancel();
 }
 // Exits marking mode.
-if ( iFlags.IsSet( EFlagMarkingMode ) )
+if ( iFlags.IsSet( EFlagMarkingState ) )
 {
-ExitMarkingMode();
+ExitMarking();
 }
 // Remove MSK observer.
 CEikButtonGroupContainer* cba;
 MopGetObject( cba );
 // Handles long press.
 // ---------------------------------------------------------------------------
 //
 void CAknTreeListView::DoHandleLongPressL()
 {
-if ( iFlags.IsClear( EFlagMarkingMode ) )
+if ( iFlags.IsClear( EFlagMarkingState ) )
 {
-EnterMarkingMode();
+EnterMarking();
 }
 }
 // ---------------------------------------------------------------------------
-// Enters marking mode.
+// Enters marking state.
 // ---------------------------------------------------------------------------
 //
-void CAknTreeListView::EnterMarkingMode()
+void CAknTreeListView::EnterMarking()
 {
 CEikButtonGroupContainer* bgc;
 CCoeControl* MSK = NULL;
 MopGetObject( bgc );
 if ( bgc )
 TRAPD( err, bgc->AddCommandToStackL( 3, newResourceId ) );
 if ( !err )
 {
 ReportTreeListEvent( MAknTreeListObserver::EMarkingModeEnabled,
 iTree.Id( FocusedItem() ) );
-iFlags.Set( EFlagMarkingMode );
+iFlags.Set( EFlagMarkingState );
 bgc->DrawNow();
 }
 }
 }
 // ---------------------------------------------------------------------------
-// Exits marking mode.
+// Exits marking state.
 // ---------------------------------------------------------------------------
 //
-void CAknTreeListView::ExitMarkingMode()
+void CAknTreeListView::ExitMarking()
 {
-if ( iFlags.IsSet( EFlagMarkingMode ) )
+if ( iFlags.IsSet( EFlagMarkingState ) )
 {
 CEikButtonGroupContainer* bgc = NULL;
 CCoeControl* MSK = NULL;
 MopGetObject( bgc );
 if ( bgc )
 }
 }
 }
 ReportTreeListEvent( MAknTreeListObserver::EMarkingModeDisabled,
 iTree.Id( FocusedItem() ) );
-iFlags.Clear( EFlagMarkingMode );
+iFlags.Clear( EFlagMarkingState );
 }
 }
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 //
 void CAknTreeListView::DrawItemsWithPhysics( const TRect& aRect ) const
 {
 TBool empty = IsEmpty();
+TInt offset = Offset();
 #ifdef RD_UI_TRANSITION_EFFECTS_LIST
 CWindowGc& gc = iGc && !empty ? *iGc : SystemGc();
-TInt offset = Offset();
 #else
 CWindowGc& gc = SystemGc();
 #endif
+TInt checkBoxOffset ( 0 );
+if ( iFlags.IsSet( EFlagMarkingMode ) )
+{
+if ( iFlags.IsSet( EFlagMirroredLayoutInUse ) )
+{
+checkBoxOffset =
+AknLayoutScalable_Avkon::list_double_graphic_pane_t1(
+0 ).LayoutLine().ir;
+}
+else
+{
+checkBoxOffset =
+AknLayoutScalable_Avkon::list_double_graphic_pane_t1(
+0 ).LayoutLine().il;
+}
+}
 #ifdef RD_UI_TRANSITION_EFFECTS_LIST
 MAknListBoxTfxInternal* transApi = CAknListLoader::TfxApiInternal( &gc );
 if ( !empty && transApi )
 {
 {
 transApi->StopDrawing();
 }
 #endif // RD_UI_TRANSITION_EFFECTS_LIST
+// text color, used to draw the separator line between list items
+TRgb textColor( KRgbBlack );
+AknsUtils::GetCachedColor( skin,
+textColor,
+KAknsIIDQsnTextColors,
+EAknsCIQsnTextColorsCG6 );
+if ( iFlags.IsSet( EFlagMarkingMode )
+&& iMarkingIconArray
+&& iMarkingIconArray->Count() == KMarkingModeIconArraySize  )
+{
+// Set sizes for marking icon bitmaps
+TRect drawRect;
+drawRect = iItems[0].Rect();
+// Rect for the marking icon
+TRect iconRect = RectFromLayout( drawRect,
+AknLayoutScalable_Avkon::list_single_graphic_pane_g1( 0 ) );
+for ( TInt ii = 0; ii < iMarkingIconArray->Count(); ++ii )
+{
+CGulIcon* icon = ( *iMarkingIconArray )[ii];
+CFbsBitmap* bitmap = icon->Bitmap();
+if ( bitmap )
+{
+TSize size( bitmap->SizeInPixels() ); // set size if not already
+TSize targetSize( iconRect.Size() );
+if ( size.iWidth != targetSize.iWidth && size.iHeight
+!= targetSize.iHeight )
+{
+AknIconUtils::SetSize( bitmap, targetSize,
+EAspectRatioPreservedAndUnusedSpaceRemoved );
+}
+}
+}
+}
 const TInt itemCount = iItems.Count();
 for ( TInt ii = 0; ii < itemCount; ++ii )
 {
 TRect drawRect( iItems[ii].Rect() );
+if ( iFlags.IsSet( EFlagMarkingMode ) )
+{
+drawRect.iBr.iX += checkBoxOffset;
+}
 if ( iItems[ii].Item() )
 {
 #ifdef RD_UI_TRANSITION_EFFECTS_LIST
 TRect tfxDrawRect( drawRect );
 tfxDrawRect.Move( 0, -offset );
 if ( transApi )
 {
 transApi->StartDrawing( MAknListBoxTfxInternal::EListNotSpecified );
 }
 TRect clippingRect( tfxDrawRect );
 // If horizontal scrollbar on, reduce clipping rect
 // based on view rect from layout data
 if ( iScrollbarFrame->ScrollBarVisibility( CEikScrollBar::EHorizontal )
 if ( clippingRect.iBr.iY > viewRect.iBr.iY )
 {
 clippingRect.iBr.iY = viewRect.iBr.iY;
 }
 }
+// Set clipping rect.
+if ( clippingRect.Intersects( aRect ) )
+{
+clippingRect.Intersection( aRect );
+gc.SetClippingRect( clippingRect );
+}
+else
+{
+//Draw nothing if no overlap between item rectangel and given rect.
+continue;
+}
-// Set clipping rect.
-gc.SetClippingRect( clippingRect );
 if ( transApi )
 {
 transApi->StopDrawing();
 }
 #endif
-TBool focused = ( IsFocused() && FocusedItem() &&
+if ( iItems[ii].Item() != iBottomItem )
+{
+TRect offsetRect( drawRect );
+offsetRect.Move( 0, -offset );
+AknListUtils::DrawSeparator( gc, offsetRect, textColor, skin );
+}
+TBool focused = ( FocusedItem() &&
 iItems[ii].Item() == FocusedItem() );
 if ( SingleClickEnabled() && !HighlightEnabled() )
 {
 focused = EFalse;
 if ( focused )
 {
 // Draw highlight for focused item.
 TRect highlightRect( iItems[ii].HighlightRect(
 iViewLevel, Indention(), IndentionWidth() ) );
+if ( iFlags.IsSet( EFlagMarkingMode ) )
+{
+highlightRect.iBr.iX = drawRect.iBr.iX;
+highlightRect.iTl.iX = drawRect.iTl.iX;
+}
 #ifdef RD_UI_TRANSITION_EFFECTS_LIST
 TRect tfxHighlightRect( highlightRect );
 tfxHighlightRect.Move( 0, -offset );
 #endif //RD_UI_TRANSITION_EFFECTS_LIST
-if ( iIsPressedDownState || !DrawAnimation( gc, highlightRect ) )
+if ( iFlags.IsSet( EFlagIsPressedDownState )
+|| !DrawAnimation( gc, highlightRect ) )
 {
 #ifdef RD_UI_TRANSITION_EFFECTS_LIST
 if ( transApi )
 {
 transApi->Invalidate(MAknListBoxTfxInternal::EListHighlight );
-transApi->BeginRedraw( MAknListBoxTfxInternal::EListHighlight, tfxHighlightRect );
+transApi->BeginRedraw( MAknListBoxTfxInternal::EListHighlight,
+tfxHighlightRect );
 transApi->StartDrawing( MAknListBoxTfxInternal::EListHighlight );
 }
 #endif //RD_UI_TRANSITION_EFFECTS_LIST
+DrawHighlight( gc, highlightRect,
-DrawHighlight( gc, highlightRect, iIsPressedDownState );
+iFlags.IsSet( EFlagIsPressedDownState ) );
 #ifdef RD_UI_TRANSITION_EFFECTS_LIST
 if ( transApi )
 {
 transApi->StopDrawing();
 #ifdef RD_UI_TRANSITION_EFFECTS_LIST
 tfxDrawRect.BoundingRect( tfxHighlightRect );
 #endif //RD_UI_TRANSITION_EFFECTS_LIST
 }
+if ( iFlags.IsSet( EFlagMarkingMode ) && iMarkingIconArray
+&& iMarkingIconArray->Count() ==
+KMarkingModeIconArraySize )
+{
+// Rect for the marking icon
+TRect iconRect = RectFromLayout( drawRect,
+AknLayoutScalable_Avkon::list_single_graphic_pane_g1( 0 ) );
+iconRect.Move( 0, -offset );
+// unchecked icon
+CGulIcon* icon = ( *iMarkingIconArray )[1];
+TBool marked = ( iItems[ii].Item()->IsMarked() );
+if ( marked )
+{
+icon = (*iMarkingIconArray)[0];
+}
+CFbsBitmap* bitmap = icon->Bitmap();
+if ( bitmap )
+{
+gc.BitBltMasked( iconRect.iTl, bitmap,
+iconRect.Size(), icon->Mask(), EFalse );
+}
+}
+if ( iFlags.IsSet( EFlagMarkingMode ) )
+{
+drawRect.iBr.iX -= checkBoxOffset;
+if ( iFlags.IsClear( EFlagMirroredLayoutInUse ) )
+{
+gc.SetOrigin( TPoint( checkBoxOffset, 0 ) );
+}
+}
 #ifdef RD_UI_TRANSITION_EFFECTS_LIST
 if (iItems[ii].Item())
 {
 if ( transApi )
 {
-transApi->BeginRedraw(MAknListBoxTfxInternal::EListItem, tfxDrawRect, iTree.VisibleItemIndex(iItems[ii].Item()));
+transApi->BeginRedraw(
+MAknListBoxTfxInternal::EListItem,
+tfxDrawRect,
+iTree.VisibleItemIndex( iItems[ii].Item() ) );
 transApi->StartDrawing( MAknListBoxTfxInternal::EListItem );
 }
 #endif //RD_UI_TRANSITION_EFFECTS_LIST
-// Draw item.
+if ( iFlags.IsSet( EFlagMarkingMode ) )
-iItems[ii].Draw( gc, iTree, drawRect, focused, iViewLevel,
+{
-StructureLines(), Indention(), IndentionWidth() );
+TBool marked = iItems[ii].Item()->IsMarked();
+if ( marked )
+{
+iItems[ii].Item()->SetMarked( EFalse );
+}
+iItems[ii].Draw( gc, iTree, drawRect, focused, iViewLevel,
+StructureLines(), Indention(), IndentionWidth() );
+if ( marked )
+{
+iItems[ii].Item()->SetMarked( ETrue );
+}
+}
+else
+{
+iItems[ii].Draw( gc, iTree, drawRect, focused, iViewLevel,
+StructureLines(), Indention(), IndentionWidth() );
+}
 #ifdef RD_UI_TRANSITION_EFFECTS_LIST
 if ( transApi )
 {
 transApi->StopDrawing();
-transApi->EndRedraw(MAknListBoxTfxInternal::EListItem, iTree.VisibleItemIndex(iItems[ii].Item()));
+transApi->EndRedraw(
+MAknListBoxTfxInternal::EListItem,
+iTree.VisibleItemIndex( iItems[ii].Item() ) );
 }
 }
 #endif //RD_UI_TRANSITION_EFFECTS_LIST
+if ( iFlags.IsSet( EFlagMarkingMode ) )
+{
+gc.SetOrigin( TPoint( 0, 0 ) );
+}
 }
 }
 }
 #ifdef RD_UI_TRANSITION_EFFECTS_LIST
 SetFocusIndex( ii );
 }
 item = iterator.Previous();
 }
 }
-iScrollPhysicsTop = EFalse;
+iFlags.Clear( EFlagScrollPhysicsTop );
 }
 }
 // ---------------------------------------------------------------------------
 // Enables or disables the highlight drawing
 // ---------------------------------------------------------------------------
 //
-void CAknTreeListView::EnableHighlight( TBool aEnabled )
+void CAknTreeListView::EnableHighlight( TBool aEnabled,
-{
+TBool aPointerEnabled )
+{
+TBool wasEnabled = iFlags.IsSet( EFlagHighlightEnabled );
 if ( aEnabled )
 {
 iFlags.Set( EFlagHighlightEnabled );
 }
 else
 {
 iFlags.Clear( EFlagHighlightEnabled );
+}
+if ( !aPointerEnabled
+&& ( ( wasEnabled && !aEnabled )
+|| ( !wasEnabled && aEnabled ) ) )
+{
+ReportCollectionChangedEvent();
 }
 }
 // ---------------------------------------------------------------------------
 // Returns ETrue if highlight is enabled
 // -----------------------------------------------------------------------------
 //
 TUint CAknTreeListView::CollectionState() const
 {
 TUint state( 0 );
-if ( IsVisible() )
+if ( IsVisible() && ( !DrawableWindow() || !DrawableWindow()->IsFaded() ) )
 {
 state |= MAknCollection::EStateCollectionVisible;
 }
 if ( HighlightEnabled() )
 {
 state |= MAknCollection::EStateHighlightVisible;
+}
+if ( iList.Flags() & KAknTreeListMarkable )
+{
+state |= MAknCollection::EStateMultipleSelection;
+}
+TBool markedItems( EFalse );
+TRAP_IGNORE( markedItems = HasMarkedItemsL() );
+if ( markedItems )
+{
+state |= MAknCollection::EStateMarkedItems;
 }
 return state;
 }
 // -----------------------------------------------------------------------------
 // CAknTreeListView::ItemActionMenuClosed
 // -----------------------------------------------------------------------------
 //
 void CAknTreeListView::ItemActionMenuClosed()
 {
-iFlags.Clear( EFlagIgnoreButtonUpEvent );
+iOldWinPos = KErrNotFound;
 EnableHighlight( EFalse );
 DrawDeferred();
 }
 // -----------------------------------------------------------------------------
 // CAknTreeListView::CollectionExtension
 // -----------------------------------------------------------------------------
 //
-TInt CAknTreeListView::CollectionExtension( TUint /*aExtensionId*/,
+TInt CAknTreeListView::CollectionExtension(
-TAny*& /*a0*/, TAny* /*a1*/ )
+TUint aExtensionId, TAny*& a0, TAny* /*a1*/ )
 {
+if ( aExtensionId == MAknMarkingCollection::TYPE )
+{
+a0 = static_cast<MAknMarkingCollection*>( this );
+}
 return KErrNone;
 }
+// -----------------------------------------------------------------------------
+// CAknTreeListView::SetMultipleMarkingState
+// -----------------------------------------------------------------------------
+//
+void CAknTreeListView::SetMultipleMarkingState( TBool aActive )
+{
+if ( iFlags.IsSet( EFlagMarkingMode ) != aActive )
+{
+if ( !aActive )
+{
+TBool markedItems( EFalse );
+TRAP_IGNORE( markedItems = HasMarkedItemsL() );
+if ( markedItems )
+{
+UnmarkAll();
+}
+}
+EnableMarking( aActive );
+if ( aActive )
+{
+iFlags.Set( EFlagMarkingMode );
+}
+else
+{
+iFlags.Clear( EFlagMarkingMode );
+}
+if ( aActive )
+{
+// Expand all items when entering marking mode
+iTree.Expand();
+}
+LayoutView();
+DrawDeferred();
+if ( iList.MarkingModeObserver() )
+{
+iList.MarkingModeObserver()->MarkingModeStatusChanged( aActive );
+}
+}
+}
+// -----------------------------------------------------------------------------
+// CAknTreeListView::MarkingState
+// -----------------------------------------------------------------------------
+//
+TUint CAknTreeListView::MarkingState() const
+{
+TUint state( 0 );
+if ( iFlags.IsSet( EFlagMarkingMode ) )
+{
+state |= MAknMarkingCollection::EStateMarkingMode;
+TBool markedItems ( EFalse );
+TRAP_IGNORE( markedItems = HasMarkedItemsL() );
+if ( markedItems )
+{
+state |= MAknMarkingCollection::EStateMarkedItems;
+}
+if ( iItems.Count() == 0 )
+{
+state |= MAknMarkingCollection::EStateCollectionEmpty;
+}
+}
+return state;
+}
+// -----------------------------------------------------------------------------
+// CAknTreeListView::MarkCurrentItemL
+// -----------------------------------------------------------------------------
+//
+void CAknTreeListView::MarkCurrentItemL()
+{
+if ( iFlags.IsSet( EFlagMarkingMode ) && FocusedItem() &&
+FocusedItem()->IsMarkable() )
+{
+MarkItem( FocusedItem(), ETrue, ETrue );
+}
+}
+// -----------------------------------------------------------------------------
+// CAknTreeListView::MarkAllL
+// -----------------------------------------------------------------------------
+//
+void CAknTreeListView::MarkAllL()
+{
+if ( iFlags.IsSet( EFlagMarkingMode ) )
+{
+TAknTreeIterator iterator = iTree.Iterator();
+CAknTreeItem* item = NULL;
+item = iterator.First();
+while ( item && iterator.HasNext() )
+{
+if ( item->IsMarkable() )
+{
+MarkItem( item, ETrue, EFalse );
+}
+item = iterator.Next();
+}
+DrawDeferred();
+}
+}
+// -----------------------------------------------------------------------------
+// CAknTreeListView::UnmarkAll
+// -----------------------------------------------------------------------------
+//
+void CAknTreeListView::UnmarkAll()
+{
+if ( iFlags.IsSet( EFlagMarkingMode ) )
+{
+TAknTreeIterator iterator = iTree.Iterator();
+CAknTreeItem* item = NULL;
+item = iterator.First();
+while ( item && iterator.HasNext() )
+{
+MarkItem( item, EFalse, EFalse );
+item = iterator.Next();
+}
+DrawDeferred();
+}
+}
+// -----------------------------------------------------------------------------
+// CAknTreeListView::CurrentItemMarkable
+// -----------------------------------------------------------------------------
+//
+TBool CAknTreeListView::CurrentItemMarkable()
+{
+if ( FocusedItem() && !FocusedItem()->IsMarkable() )
+{
+return EFalse;
+}
+return ETrue;
+}
+// -----------------------------------------------------------------------------
+// CAknTreeListView::ExitMarkingMode
+// -----------------------------------------------------------------------------
+//
+TBool CAknTreeListView::ExitMarkingMode()
+{
+if ( iList.MarkingModeObserver() )
+{
+return iList.MarkingModeObserver()->ExitMarkingMode();
+}
+return ETrue;
+}
+// -----------------------------------------------------------------------------
+// CAknTreeListView::ReportCollectionChangedEvent
+// -----------------------------------------------------------------------------
+//
+void CAknTreeListView::ReportCollectionChangedEvent()
+{
+if ( iItemActionMenu )
+{
+iItemActionMenu->CollectionChanged( *this );
+}
+}
 // ---------------------------------------------------------------------------
 // CAknTreeListView::HandleLongTapEventL
 // ---------------------------------------------------------------------------
 //
 void CAknTreeListView::HandleLongTapEventL(
 const TPoint& /*aPenEventLocation*/,
 const TPoint& aPenEventScreenLocation)
 {
-iFlags.Set( EFlagIgnoreButtonUpEvent );
 iItemActionMenu->ShowMenuL( aPenEventScreenLocation, 0 );
+iOldWinPos = DrawableWindow()->OrdinalPosition();
+IgnoreEventsUntilNextPointerUp();
 }
 // ---------------------------------------------------------------------------
 // CAknTreeListView::LongTapPointerEventL
 // ---------------------------------------------------------------------------
 //
 void CAknTreeListView::LongTapPointerEventL(
 const TPointerEvent& aPointerEvent)
 {
-if ( iLongTapDetector && iItemActionMenu && iItemActionMenu->InitMenuL() )
+if ( iLongTapDetector && iItemActionMenu
+&& !( HasMarkedItemsL() && FocusedItem()
+&& !FocusedItem()->IsMarked() ) && iItemActionMenu->InitMenuL() )
 {
 iLongTapDetector->PointerEventL( aPointerEvent );
 }
 }
 // ---------------------------------------------------------------------------
 // CAknTreeListView::HasMarkedItemsL
 // ---------------------------------------------------------------------------
 //
-TBool CAknTreeListView::HasMarkedItemsL()
+TBool CAknTreeListView::HasMarkedItemsL() const
 {
 RArray<TInt> selection;
 CleanupClosePushL( selection );
 iList.GetMarkedItemsL( selection );
 TInt count( selection.Count() );
 CleanupStack::PopAndDestroy( &selection );
-if ( count > 0 )
+return ( count > 0 );
-{
-return ETrue;
-}
-return EFalse;
 }
 #ifdef RD_UI_TRANSITION_EFFECTS_LIST
 // ---------------------------------------------------------------------------
 TInt& CAknTreeListView::BottomIndex()
 {
 return iBottomIndex;
 }
+#endif //RD_UI_TRANSITION_EFFECTS_LIST
+// ---------------------------------------------------------------------------
+// CAknTreeListView::UpdateIndexes
+// ---------------------------------------------------------------------------
+//
 void CAknTreeListView::UpdateIndexes()
 {
+#ifdef RD_UI_TRANSITION_EFFECTS_LIST
 iTopIndex = iBottomIndex = iHighlightIndex = 0;
+#else
+iBottomIndex = 0;
+#endif //RD_UI_TRANSITION_EFFECTS_LIST
 if ( iItems.Count() )
 {
 for (TInt i=iItems.Count()-1; i>=0; i--)
 {
 if (iItems[i].Item())
 {
-iBottomIndex = iTree.VisibleItemIndex(iItems[i].Item());
+iBottomItem = iItems[i].Item();
+iBottomIndex = iTree.VisibleItemIndex( iBottomItem );
 break;
 }
 }
+#ifdef RD_UI_TRANSITION_EFFECTS_LIST
 iTopIndex = iTree.VisibleItemIndex(iItems[0].Item());
 iHighlightIndex = iTree.VisibleItemIndex(FocusedItem());
+#endif //RD_UI_TRANSITION_EFFECTS_LIST
 }
 }
-#endif //RD_UI_TRANSITION_EFFECTS_LIST
+// -----------------------------------------------------------------------------
+// CAknTreeListView::LoadMarkingIconsL
+// -----------------------------------------------------------------------------
+//
+void CAknTreeListView::LoadMarkingIconsL()
+{
+if ( !iMarkingIconArray )
+{
+iMarkingIconArray = new ( ELeave )
+CAknIconArray( KMarkingModeIconArraySize );
+}
+else
+{
+iMarkingIconArray->ResetAndDestroy();
+}
+MAknsSkinInstance* skin = AknsUtils::SkinInstance();
+const TDesC& avkonIconFile = AknIconUtils::AvkonIconFileName();
+CGulIcon* icon = AknsUtils::CreateGulIconL( skin,
+KAknsIIDQgnPropCheckboxOn,
+avkonIconFile,
+EMbmAvkonQgn_prop_checkbox_on,
+EMbmAvkonQgn_prop_checkbox_on_mask );
+CleanupStack::PushL( icon );
+iMarkingIconArray->AppendL( icon );
+CleanupStack::Pop( icon );
+icon = AknsUtils::CreateGulIconL( skin,
+KAknsIIDQgnPropCheckboxOff,
+avkonIconFile,
+EMbmAvkonQgn_prop_checkbox_off,
+EMbmAvkonQgn_prop_checkbox_off_mask );
+CleanupStack::PushL( icon );
+iMarkingIconArray->AppendL( icon );
+CleanupStack::Pop( icon );
+}

branch	RCL_3
changeset 20	d48ab3b357f1
parent 19	aecbbf00d063