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

equal deleted inserted replaced

-:3d340a0166ff
+:941195f2d488
 #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"
 const TInt KLongPressInterval = 600000; // 0.6 seconds
 // Number of additional items to draw
 const TInt KAdditionalItems = 2;
-// Space for check box in marking mode
+// Number of icons in marking mode icon array
-const TInt KCheckBoxOffset = 30;
+const TInt KMarkingModeIconArraySize = 2;
 // Tree list view flag definitions.
 enum TAknTreeListViewFlags
 {
 EFlagStructureLines,
 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 ========
 // SelectItem
 // ---------------------------------------------------------------------------
 //
 void CAknTreeListView::SelectItem( CAknTreeItem* aSelectedItem )
 {
-if ( iMarkingMode )
+if ( iFlags.IsSet( EFlagMarkingMode ) )
 {
 if ( aSelectedItem->IsMarkable() )
 {
 MarkItem( aSelectedItem, !aSelectedItem->IsMarked(), ETrue );
 }
 // SetPressedDownState
 // ---------------------------------------------------------------------------
 //
 void CAknTreeListView::SetPressedDownState( const TBool& aPressedDown )
 {
-iIsPressedDownState = aPressedDown;
+if ( aPressedDown )
+{
+iFlags.Set( EFlagIsPressedDownState );
+}
+else
+{
+iFlags.Clear( EFlagIsPressedDownState );
+}
 }
 // ---------------------------------------------------------------------------
 // UpdateTreeListView
 break;
 }
 case KEikDynamicLayoutVariantSwitch:
 {
-iMirroredLayoutInUse = AknLayoutUtils::LayoutMirrored();
+if ( AknLayoutUtils::LayoutMirrored() )
+{
+iFlags.Set( EFlagMirroredLayoutInUse );
+}
+else
+{
+iFlags.Clear( EFlagMirroredLayoutInUse );
+}
 CAknTreeItem* focusedItem( FocusedItem() );
 if ( focusedItem )
 {
 if ( !FocusedItemVisible() )
 TInt index = 0;
 if ( firstItemIndex < iTree.VisibleItemIndex( focusedItem ) )
 {
 index = iItems.Count() - 1;
 }
-SetFocusedItem( focusedItem, index, ETrue );
+if( HighlightEnabled() )
+{
+SetFocusedItem( focusedItem, index, ETrue );
+}
 }
 else
 {
 SetFocusedItem( focusedItem, FocusIndex(), ETrue );
 break;
 }
 case KAknMessageFocusLost:
 {
-if ( HighlightEnabled() )
+if ( SingleClickEnabled() && HighlightEnabled() &&
+( iOldWinPos == KErrNotFound ||
+iOldWinPos == DrawableWindow()->OrdinalPosition() ) )
 {
 EnableHighlight( EFalse );
 // Redraw item
 SetFocusedItem( FocusedItem(), FocusIndex(), ETrue );
 }
 // focused.
 // ---------------------------------------------------------------------------
 //
 void CAknTreeListView::HandlePointerEventL( const TPointerEvent& aPointerEvent )
 {
-if ( iFlags.IsSet( EFlagIgnoreButtonUpEvent )
-&& aPointerEvent.iType == TPointerEvent::EButton1Up )
-{
-return;
-}
 if ( GrabbingComponent() )
 {
 iPhysicsHandler->ResetEventBlockingStatus();
 }
 else
 {
 if( aPointerEvent.iType == TPointerEvent::EButton1Down )
 {
-iFlags.Clear( EFlagIgnoreButtonUpEvent );
 iPreviouslyFocusedItem = FocusedItem();
 }
 iPhysicsHandler->HandlePointerEventL( aPointerEvent, iViewLevel,
 MarkingOngoing(), iFlags.IsSet( EFlagShiftKeyPressed ),
 {
 EnableHighlight( EFalse );
 }
 TInt thumbPosition = aScrollBar->ThumbPosition();
-if ( iMirroredLayoutInUse &&
+if ( iFlags.IsSet( EFlagMirroredLayoutInUse ) &&
 aScrollBar != iScrollbarFrame->VerticalScrollBar() )
 {
 const TEikScrollBarModel* model = aScrollBar->Model();
 thumbPosition = ( model->iScrollSpan - model->iThumbSpan )
 - thumbPosition;
 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, this );
 if ( iItemActionMenu )
 {
 iLongTapDetector = CAknLongTapDetector::NewL( this );
 }
 else
 {
 EnableHighlight( ETrue );
 }
+if ( AknLayoutUtils::LayoutMirrored() )
-iMirroredLayoutInUse = AknLayoutUtils::LayoutMirrored();
+{
+iFlags.Set( EFlagMirroredLayoutInUse );
+}
+else
+{
+iFlags.Clear( EFlagMirroredLayoutInUse );
+}
 LoadMarkingIconsL();
 }
 // ---------------------------------------------------------------------------
 void CAknTreeListView::HandleSelectionKeyEvent()
 {
 CAknTreeItem* item = FocusedItem();
 if ( item )
 {
-if ( iMarkingMode )
+if ( iFlags.IsSet( EFlagMarkingMode ) )
 {
 if ( item->IsMarkable() )
 {
 MarkItem( item, !item->IsMarked(), ETrue );
 }
 // Handles right arrow key event.
 // ---------------------------------------------------------------------------
 //
 void CAknTreeListView::HandleRightArrowKeyEvent()
 {
-if ( iMirroredLayoutInUse )
+if ( iFlags.IsSet( EFlagMirroredLayoutInUse ) )
 {
 AscendFocus();
 }
 else
 {
 // Handles left arrow key event.
 // ---------------------------------------------------------------------------
 //
 void CAknTreeListView::HandleLeftArrowKeyEvent()
 {
-if ( iMirroredLayoutInUse )
+if ( iFlags.IsSet( EFlagMirroredLayoutInUse ) )
 {
 DescendFocus();
 }
 else
 {
 if ( first )
 {
 iterator.SetCurrent( first );
 iterator.Previous();
 }
+if ( iFlags.IsSet( EFlagMarkingMode ) )
-if ( iMarkingMode )
 {
-itemRect.iBr.iX -= KCheckBoxOffset;
+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 )
 {
 // Disable the scrollbar background drawing for the duration
 // of this call.
 iScrollbarFrame->DrawBackground( EFalse, EFalse );
 }
+iPhysicsHandler->UpdateScrollIndex(
+iFlags.IsSet( EFlagScrollPhysicsTop ) );
+iFlags.Set( EFlagScrollPhysicsTop );
-iPhysicsHandler->UpdateScrollIndex( iScrollPhysicsTop );
-iScrollPhysicsTop = ETrue;
 // 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 ( iMirroredLayoutInUse )
 {
 hThumbPos = hScrollSpan - ( hThumbPos + hThumbSpan );
 }
 TEikScrollBarModel hModel( hScrollSpan, hThumbSpan, hThumbPos );
 CWindowGc& gc = iGc && !empty ? *iGc : SystemGc();
 #else
 CWindowGc& gc = SystemGc();
 #endif
+TInt 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 )
 {
 TRgb textColor( KRgbBlack );
 AknsUtils::GetCachedColor( skin,
 textColor,
 KAknsIIDQsnTextColors,
 EAknsCIQsnTextColorsCG6 );
+if ( iFlags.IsSet( EFlagMarkingMode )
-if ( iMarkingMode && iMarkingIconArray && iMarkingIconArray->Count()== 2 )
+&& iMarkingIconArray
+&& iMarkingIconArray->Count() == KMarkingModeIconArraySize  )
 {
 // Set sizes for marking icon bitmaps
 TRect drawRect;
-if ( iItems.Count() > 0 )
+drawRect = iItems[0].Rect();
-{
-drawRect = iItems[0].Rect();
-drawRect.iBr.iX += KCheckBoxOffset;
-}
 // Rect for the marking icon
 TRect iconRect = RectFromLayout( drawRect,
 AknLayoutScalable_Avkon::list_single_graphic_pane_g1( 0 ) );
-iconRect.Move( 0, -offset );
-gc.SetPenColor( textColor );
-gc.SetPenStyle( CGraphicsContext::ESolidPen );
 for ( TInt ii = 0; ii < iMarkingIconArray->Count(); ++ii )
 {
-CGulIcon* icon = (*iMarkingIconArray)[ii];
+CGulIcon* icon = ( *iMarkingIconArray )[ii];
 CFbsBitmap* bitmap = icon->Bitmap();
 if ( bitmap )
 {
 TSize size( bitmap->SizeInPixels() ); // set size if not already
 const TInt itemCount = iItems.Count();
 for ( TInt ii = 0; ii < itemCount; ++ii )
 {
 TRect drawRect( iItems[ii].Rect() );
-if ( iMarkingMode )
+if ( iFlags.IsSet( EFlagMarkingMode ) )
 {
-drawRect.iBr.iX += KCheckBoxOffset;
+drawRect.iBr.iX += checkBoxOffset;
 }
 if ( iItems[ii].Item() )
 {
 {
 transApi->StopDrawing();
 }
 #endif
-if ( iMarkingMode && iMarkingIconArray && iMarkingIconArray->Count()== 2 )
+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 );
-CGulIcon* icon = (*iMarkingIconArray)[1]; // unchecked
+// unchecked icon
+CGulIcon* icon = ( *iMarkingIconArray )[1];
 TBool marked = ( iItems[ii].Item()->IsMarked() );
 if ( marked )
 {
 icon = (*iMarkingIconArray)[0];
 TRect offsetRect( drawRect );
 offsetRect.Move( 0, -offset );
 AknListUtils::DrawSeparator( gc, offsetRect, textColor, skin );
 }
-if ( iMarkingMode )
+if ( iFlags.IsSet( EFlagMarkingMode ) )
 {
-gc.SetOrigin( TPoint( KCheckBoxOffset, 0 ) );
+gc.SetOrigin( TPoint( checkBoxOffset, 0 ) );
-drawRect.iBr.iX -= KCheckBoxOffset;
+drawRect.iBr.iX -= checkBoxOffset;
 }
 TBool focused = ( FocusedItem() &&
 iItems[ii].Item() == FocusedItem() );
 #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->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();
 iTree.VisibleItemIndex( iItems[ii].Item() ) );
 transApi->StartDrawing( MAknListBoxTfxInternal::EListItem );
 }
 #endif //RD_UI_TRANSITION_EFFECTS_LIST
-if ( iMarkingMode )
+if ( iFlags.IsSet( EFlagMarkingMode ) )
 {
 TBool marked = iItems[ii].Item()->IsMarked();
 if ( marked )
 {
 iItems[ii].Item()->SetMarked( EFalse );
 iTree.VisibleItemIndex( iItems[ii].Item() ) );
 }
 }
 #endif //RD_UI_TRANSITION_EFFECTS_LIST
-if ( iMarkingMode )
+if ( iFlags.IsSet( EFlagMarkingMode ) )
 {
 gc.SetOrigin( TPoint( 0, 0 ) );
 }
 }
 }
 SetFocusIndex( ii );
 }
 item = iterator.Previous();
 }
 }
-iScrollPhysicsTop = EFalse;
+iFlags.Clear( EFlagScrollPhysicsTop );
 }
 }
 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::SetMultipleMarkingState
 // -----------------------------------------------------------------------------
 //
 void CAknTreeListView::SetMultipleMarkingState( TBool aActive )
 {
-if ( iMarkingMode != aActive )
+if ( iFlags.IsSet( EFlagMarkingMode ) != aActive )
 {
 if ( !aActive )
 {
 TBool markedItems( EFalse );
 TRAP_IGNORE( markedItems = HasMarkedItemsL() );
 UnmarkAll();
 }
 }
 EnableMarking( aActive );
-iMarkingMode = 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() )
 {
 //
 TUint CAknTreeListView::MarkingState() const
 {
 TUint state( 0 );
-if ( iMarkingMode )
+if ( iFlags.IsSet( EFlagMarkingMode ) )
 {
 state |= MAknMarkingCollection::EStateMarkingMode;
 TBool markedItems ( EFalse );
 TRAP_IGNORE( markedItems = HasMarkedItemsL() );
 // CAknTreeListView::MarkCurrentItemL
 // -----------------------------------------------------------------------------
 //
 void CAknTreeListView::MarkCurrentItemL()
 {
-if ( iMarkingMode && FocusedItem() && FocusedItem()->IsMarkable() )
+if ( iFlags.IsSet( EFlagMarkingMode ) && FocusedItem() &&
+FocusedItem()->IsMarkable() )
 {
 MarkItem( FocusedItem(), ETrue, ETrue );
 }
 }
 // CAknTreeListView::MarkAllL
 // -----------------------------------------------------------------------------
 //
 void CAknTreeListView::MarkAllL()
 {
-if ( iMarkingMode )
+if ( iFlags.IsSet( EFlagMarkingMode ) )
 {
 TAknTreeIterator iterator = iTree.Iterator();
 CAknTreeItem* item = NULL;
 item = iterator.First();
 while ( item && iterator.HasNext() )
 // CAknTreeListView::UnmarkAll
 // -----------------------------------------------------------------------------
 //
 void CAknTreeListView::UnmarkAll()
 {
-if ( iMarkingMode )
+if ( iFlags.IsSet( EFlagMarkingMode ) )
 {
 TAknTreeIterator iterator = iTree.Iterator();
 CAknTreeItem* item = NULL;
 item = iterator.First();
 while ( item && iterator.HasNext() )
 //
 void CAknTreeListView::HandleLongTapEventL(
 const TPoint& /*aPenEventLocation*/,
 const TPoint& aPenEventScreenLocation)
 {
-iFlags.Set( EFlagIgnoreButtonUpEvent );
 iItemActionMenu->ShowMenuL( aPenEventScreenLocation, 0 );
+iOldWinPos = DrawableWindow()->OrdinalPosition();
+IgnoreEventsUntilNextPointerUp();
 }
 // ---------------------------------------------------------------------------
 // CAknTreeListView::LongTapPointerEventL
 // ---------------------------------------------------------------------------
 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
 // ---------------------------------------------------------------------------
 //
 void CAknTreeListView::LoadMarkingIconsL()
 {
 if ( !iMarkingIconArray )
 {
-iMarkingIconArray = new ( ELeave ) CAknIconArray( 2 );
+iMarkingIconArray = new ( ELeave )
+CAknIconArray( KMarkingModeIconArraySize );
 }
 else
 {
 iMarkingIconArray->ResetAndDestroy();
 }

branch	RCL_3
changeset 25	941195f2d488
parent 23	3d340a0166ff
child 38	c52421ed5f07