MCL/sf/app/homescreen: comparison menufw/menufwui/mmwidgets/src/mmwidgetcontainer.cpp

equal deleted inserted replaced

-:f72a12da539e
+:5315654608de
 * Nokia Corporation - initial contribution.
 *
 * Contributors:
 *
 * Description:
-*  Version     : %version: MM_71.1.17.1.42 % << Don't touch! Updated by Synergy at check-out.
+*  Version     : %version: MM_71.1.17.1.44 % << Don't touch! Updated by Synergy at check-out.
 *
 */
 #include <e32keys.h>
 #include <e32math.h>
 #include <AknsDrawUtils.h>
 #include <layoutmetadata.cdl.h>
 #include <aknlongtapdetector.h>
 #ifdef RD_UI_TRANSITION_EFFECTS_LIST
 #include <aknlistloadertfx.h>
 #include <aknlistboxtfxinternal.h>
 #include <aknlistboxtfx.h>
 if ( aType == KEikDynamicLayoutVariantSwitch ||
 aType == KAknsMessageSkinChange )
 {
 static_cast<CMmListBoxItemDrawer*>( iDrawer )->InvalidateCache();
 }
 CCoeControl::HandleResourceChange( aType );
 }
 // -----------------------------------------------------------------------------
 //
 {
 if (aAnimate)
 {
 iDrawer->AnimateDragItemTransitionL();
 }
 SetHighlightAfterDrag();
 iDraggedIndex = -1;
 iDrawer->SetDraggedIndexL( iDraggedIndex, TPoint(0,0) );
 SetDraggableL( EFalse );
 TInt dragFloatingItem;
 {
 if ( iMarqueeAdapter && aPointerEvent.iType == TPointerEvent::EButton1Down )
 	{
 	iMarqueeAdapter->StopMarqueeDrawing();
 	}
 TInt index = KErrNotFound;
 TBool itemExists = iWidget->View()->XYPosToItemIndex( aPointerEvent.iPosition, index );
 CCoeControl::HandlePointerEventL(aPointerEvent);
 if ( aPointerEvent.iType == TPointerEvent::EButton1Down
 && itemExists  )
 {
 SetHighlightL( index );
 }
 		iTimer->StopL();
 		}
 	}
 	TInt lastTopItemIndex = Widget()->TopItemIndex();
 TBool abortAnimation = lastTopItemIndex != Widget()->TopItemIndex();
 if (abortAnimation)
 {
 iDrawer->GetAnimator()->CancelAnimationsL();
 if ( IsEditMode() && iDragAndDropObserver )
 	{
 		HandlePointerEventsInEditModeL(aPointerEvent, abortAnimation);
 	}
 if ( iLongTapDetector )
 	{
 	TPointerEvent longTapPointerEvent = aPointerEvent;
 if ( aPointerEvent.iType == TPointerEvent::EButtonRepeat )
 	{
 	longTapPointerEvent.iType = TPointerEvent::EDrag;
 	}
 iLongTapDetector->PointerEventL( longTapPointerEvent );
 	}
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 //
 void CMmWidgetContainer::SetDraggableL( TBool aDraggable )
 {
 iDrawer = STATIC_CAST(CMmListBoxItemDrawer*, iWidget->View()->ItemDrawer());
 iDrawer->SetDraggableL( aDraggable );
 }
 // -----------------------------------------------------------------------------
 if ( iPreviousHighlight != iCurrentHighlight )
 {
 HideOptionsMenuIfDisplayed();
 }
 CHnSuiteModel* suiteModel = GetMmModel()->GetSuiteModel();
 if (suiteModel)
 {
 suiteModel->SetSuiteHighlightL( iCurrentHighlight );
 }
 }
 	iMarqueeAdapter->StopMarqueeDrawing();
 	}
 if (!AknLayoutUtils::PenEnabled() && iIsEditMode )
 {
 		if ((GetHighlight() + ColumnsInCurrentView() > NumberOfItems() - 1)
 						&& aKeyEvent.iScanCode == EStdKeyDownArrow)
 			// the second condition is needed to block moving item down when there is no item below the moved item.
 			{
 			return resp;
 			}
 static_cast<CMmListBoxItemDrawer*>(iDrawer)->SetHighlightShown( EFalse );
 resp = iWidget->OfferKeyEventL( aKeyEvent, aType );
 static_cast<CMmListBoxItemDrawer*>(iDrawer)->SetHighlightShown( ETrue );
 SetHighlightL( iWidget->CurrentItemIndex() );
 ScrollViewIfNeededL(); //only edit mode non-touch
 if ( prevIndex != GetHighlight()
 		&& KErrNotFound != prevIndex  )
 	{
 	iDraggedIndex = prevIndex;
 iDragAndDropObserver->HandleDragStartL( iDraggedIndex );
 //
 // -----------------------------------------------------------------------------
 //
 TInt CMmWidgetContainer::RowsInCurrentView()
 {
 //should be overridden by deriving classes
 CListBoxView *view = ((CListBoxView*) Widget()->View());
 return view->NumberOfItemsThatFitInRect( Rect());//Widget()->View()->ViewRect());
 }
 // -----------------------------------------------------------------------------
 		HandleRockerPressL();
 		resp = EKeyWasConsumed;
 	}
 else if ( iAllowLongPress && aType == EEventKey && aKeyEvent.iRepeats > 0 &&
 		( aKeyEvent.iScanCode == EStdKeyDevice3
 				|| aKeyEvent.iScanCode == EStdKeyEnter
 				|| aKeyEvent.iScanCode == EStdKeyNkpEnter ) )
 	{
 	HandleRockerPressL();
 	resp = EKeyWasConsumed;
 	iAllowLongPress = EFalse;
 	}
 return resp;
 }
 // -----------------------------------------------------------------------------
 //
 {
 SetupWidgetLayoutL();
 }
 iWidget->MakeVisible(ETrue);
 Widget()->View()->ItemDrawer()->ClearFlags(
 		CListItemDrawer::EPressedDownState );
 	iPostProcessor->StartAt( iWidget->BottomItemIndex() + 1 );
 }
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
-TBool CMmWidgetContainer::FlipOpen()
-	{
-	return iFlipOpen;
-	}
-// ---------------------------------------------------------------------------
-//
-// ---------------------------------------------------------------------------
-//
-EXPORT_C void CMmWidgetContainer::SetFlipOpenL( TBool aIsFlipOpen )
-	{
-if ( aIsFlipOpen != iFlipOpen )
-	{
-	iFlipOpen = aIsFlipOpen;
-	FlipStateChangedL();
-		}
-	}
-// ---------------------------------------------------------------------------
-//
-// ---------------------------------------------------------------------------
-//
-void CMmWidgetContainer::FlipStateChangedL()
-	{
-//	default do nothing
-	}
-// ---------------------------------------------------------------------------
-//
-// ---------------------------------------------------------------------------
-//
 EXPORT_C void CMmWidgetContainer::StopMovingL()
 	{
 	if ( !AknLayoutUtils::PenEnabled() && iDragAndDropObserver )
 		iDragAndDropObserver->HandleDragStopL( GetHighlight() );
 	}
 			-  iWidget->TopItemIndex() / ColumnsInCurrentView() ) <= 1 )
 		{
 		return;
 		}
 	TBool needToScrollUp =
 		GetHighlight() - iWidget->TopItemIndex() < ColumnsInCurrentView()
 		&& iWidget->TopItemIndex() != 0;
 	TBool needToScrollDown =
 		iWidget->BottomItemIndex() - GetHighlight() < ColumnsInCurrentView()
 		&& iWidget->BottomItemIndex() / ColumnsInCurrentView()
 			!= ( NumberOfItems() - 1 )  / ColumnsInCurrentView();
 	if ( WidgetType() == EGridWidget )
 		{
 		// TODO: temporary - invisible partial items in MCL grid :/
 		needToScrollDown =
 			iWidget->BottomItemIndex() - ColumnsInCurrentView() - GetHighlight() < ColumnsInCurrentView()
 		    && ( iWidget->BottomItemIndex() / ColumnsInCurrentView() ) - 1
 				!= ( NumberOfItems() - 1 ) / ColumnsInCurrentView()
 			&& iWidget->BottomItemIndex() - iWidget->TopItemIndex()
 				> ColumnsInCurrentView() * RowsInCurrentView();
 		}
 	if ( needToScrollUp )
 		{
 #ifdef RD_UI_TRANSITION_EFFECTS_LIST
 			MAknListBoxTfxInternal *transApi = CAknListLoader::TfxApiInternal( iDrawer->Gc() );
 			if ( transApi )
 #endif
 		UpdateViewScrollBarThumbs();
 		}
 	else if ( needToScrollDown )
 		{
 #ifdef RD_UI_TRANSITION_EFFECTS_LIST
 			MAknListBoxTfxInternal *transApi = CAknListLoader::TfxApiInternal( iDrawer->Gc() );
 			if ( transApi )
 				{
 				transApi->SetMoveType( MAknListBoxTfxInternal::EListScrollDown );
 			if ( transApi )
 				{
 				transApi->Draw( Rect() );
 				}
 #endif
 		UpdateViewScrollBarThumbs();
 		}
 	}
 //----------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CMmWidgetContainer::UpdateViewScrollBarThumbs()
 	{
 	}
 //----------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 {
 if ( iMarqueeAdapter )
 {
 TBool marqueeShouldBeEnabled = iHasFocus && iInForeground
 && !iIsFaded && !IsEditMode();
 // logical Ex-OR
 if ( !!marqueeShouldBeEnabled != !!iMarqueeAdapter->IsMarqueeEnabled() )
 {
 if ( !marqueeShouldBeEnabled )
 {
 iMarqueeAdapter->EnableMarquee( marqueeShouldBeEnabled );
 }
 }
 }
-//----------------------------------------------------------------------------
-//
-// ---------------------------------------------------------------------------
-//
-EXPORT_C void CMmWidgetContainer::HandleZoomChanged( TAknUiZoom aZoom )
-	{
-	SetZoom( aZoom );
-	if( WidgetType() == EGridWidget )
-	    {
-	    CMmGrid* grid = static_cast<CMmGrid*>( iWidget );
-	    grid->SetupLayout();
-	    }
-	Widget()->DrawDeferred();
-	}
-// ---------------------------------------------------------------------------
-//
-// ---------------------------------------------------------------------------
-//
-EXPORT_C void CMmWidgetContainer::SetZoom( TAknUiZoom aZoom )
-	{
-	CMmTemplateLibrary * templateLibrary =
-	static_cast<CMmListBoxItemDrawer*> (
-			Widget()->View()->ItemDrawer() )->TemplateLibrary();
-	if ( WidgetType() == EGridWidget && EAknUiZoomSmall == aZoom )
-		{
-		aZoom = EAknUiZoomNormal;
-		}
-	templateLibrary->SetZoom( aZoom );
-	}
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CMmWidgetContainer::SetHighlightAfterDrag()
 	{
 if ( AknLayoutUtils::PenEnabled() &&
 		iDraggedIndex != KErrNotFound &&
 			iDraggedIndex != Widget()->CurrentItemIndex()
 			&& iDraggedIndex < NumberOfItems() )
 	{
 	TBool isFolder(EFalse);
 	CHnSuiteModel* model = GetMmModel()->GetSuiteModel();
 		CHnItemModel* onItemModel = model->GetItemModel(
 				model->IdByIndex( Widget()->CurrentItemIndex() ));
 	    if (onItemModel)
 	    	{
 	    	isFolder = onItemModel->GetItemType() == EItemTypeParentFolder ||
 				onItemModel->GetItemType() == EItemTypeFolder;
 //
 // ---------------------------------------------------------------------------
 //
 void CMmWidgetContainer::ValidateWidgetCurrentItemIndex()
 	{
 	if (Widget()->CurrentItemIndex() >= GetMmModel()->NumberOfItems()
 			|| Widget()->CurrentItemIndex() == KErrNotFound )
 		{
 		iCurrentHighlight = GetMmModel()->NumberOfItems();
 		if( iCurrentHighlight > 0 )
 			{
 	iWidgetPositionCache.iVerticalItemOffset = VerticalItemOffset();
 	iWidgetPositionCache.iTopItemIndex = Widget()->TopItemIndex();
 	iWidgetPositionCache.iLandscape
 			= Layout_Meta_Data::IsLandscapeOrientation();
 	iWidgetPositionCache.iHighlightedItemId = KErrNotFound;
 	TInt highlightedItemIndex = Widget()->CurrentItemIndex();
 	CHnSuiteModel* suiteModel = GetMmModel()->GetSuiteModel();
 	if ( suiteModel && highlightedItemIndex != KErrNotFound
 	        && suiteModel->GetSuiteHighlight() == highlightedItemIndex
 	        && ItemIsVisible( highlightedItemIndex ) )
 	    {
 	    iWidgetPositionCache.iHighlightedItemId =
 suiteModel->IdByIndex( highlightedItemIndex );
 	    }
 	iWidgetPositionCache.iValid = ETrue;
 	}
 // ---------------------------------------------------------------------------
 //
 }
 			Widget()->View()->SetTopItemIndex(iWidgetPositionCache.iTopItemIndex);
 			SetVerticalItemOffset(iWidgetPositionCache.iVerticalItemOffset);
 			TRAP_IGNORE( AlignBottomOfViewL() );
 			// Important: If an item that was previously highlighted and visible is
 			// still highlighted and yet somehow is not visible after the position
 			// has been restored, fix the problem by scrolling the view until that
 			// item is visible again:
 			CHnSuiteModel* suiteModel = GetMmModel()->GetSuiteModel();
 			}
 		else
 			{
 			TRAP_IGNORE( ScrollToItemL(Widget()->CurrentItemIndex()) );
 			}
 		iWidgetPositionCache.iValid = EFalse;
 		}
 	}
 // ---------------------------------------------------------------------------
 	{
 	if ( AknLayoutUtils::PenEnabled() )
 		{
 		CacheWidgetPosition();
 		Widget()->View()->SetDisableRedraw( ETrue );
 		HandleNumberOfItemsChangedL( aChange );
 		Widget()->View()->SetDisableRedraw( EFalse );
 		RestoreWidgetPosition();
 		}
 	else
 		{
 //
 TBool CMmWidgetContainer::AlignBottomOfViewL()
 	{
 	TInt scrollConsumed( EFalse );
 	TInt pixelsToScroll( 0 );
 	if ( NumberOfItems() > 0 )
 		{
 		pixelsToScroll = CalcBottomPixelsToScroll();
 		}
 TInt lastItemIndex = NumberOfItems() - 1;
 TInt viewHeight = Widget()->View()->ViewRect().Height();
 TInt lastItemBottomY = Widget()->View()->ItemPos(lastItemIndex).iY
 + Widget()->ItemHeight();
 TInt pixelsToScroll( 0 );
 if ( Widget()->ScrollBarFrame()->VerticalScrollBar()->IsVisible() )
 {
 pixelsToScroll = Min( 0, lastItemBottomY - viewHeight );
 }
 else
 {
 pixelsToScroll = Widget()->View()->ItemPos( firstItemIndex ).iY;
 }
 return pixelsToScroll;
 }
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 //
 void CMmWidgetContainer::ScrollInPixelsL(TInt aPixels)
 	{
 	SetupScrollingEffectsL( aPixels > 0 );
 	if ( AknLayoutUtils::PenEnabled() )
 		{
 		Widget()->HandlePhysicsScrollEventL(aPixels);
 		}
 	else
 		{
 		// non-touch avkon doesn't seem to support scrolling by given
 		// amount of pixels
 		TInt delta = aPixels / Widget()->View()->ItemHeight();
 		Widget()->View()->VScrollTo( Widget()->TopItemIndex() +
 				delta * ColumnsInCurrentView() );
 		}
 	}
 // -----------------------------------------------------------------------------
 	if (aIndex >= 0 && aIndex <= NumberOfItems())
 		{
 		scrollConsumed = AlignBottomOfViewL();
 		if ( !scrollConsumed && Widget()->View()->ItemIsPartiallyVisible(aIndex))
 			{
 //			the case when the item is partially visible at top or
 //			bottom of screen. Th e view is scrolled the offset to
 //			make the item entirely visible.
 			TInt offsetBottom = Widget()->View()->ItemPos(aIndex).iY
 					+ Widget()->ItemHeight()
 					- Widget()->View()->ViewRect().Height();
 			if (offset != 0)
 				{
 				ScrollInPixelsL( offset );
 				scrollConsumed = ETrue;
 				}
 			}
 		else if (!Widget()->View()->ItemIsVisible(aIndex))
 			{
 //			the case when the item is not visible on screen
 			SetupScrollingEffectsL( aIndex > Widget()->BottomItemIndex() );
 // -----------------------------------------------------------------------------
 //
 EXPORT_C void CMmWidgetContainer::PrepareForGarbage()
 	{
 //	This is called when the suite model is destoyed and the container is set to be destroyed
 //	by the garbage collector. There should be no redraws done to the widget in this period
 //	because this will cause the screen to be redrawn only containing the balnk background.
 //	Before garbage cleanup an asynchronous redraw event may intend to redraw the widget.
 //	SetDisableRedraw() prevents redrawing. Animator is also prepared for garbage so there is
 //	no instance which can enable redraw of the widget.
 	Widget()->View()->SetDisableRedraw( ETrue );
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 //
 void CMmWidgetContainer::HandleLongTapEventL( const TPoint& aPenEventLocation,
 const TPoint& aPenEventScreenLocation )
 	{
 	TInt index( KErrNotFound );
 	if ( iWidget->View()->XYPosToItemIndex( aPenEventLocation, index ) )
 		{
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 //
-EXPORT_C void CMmWidgetContainer::HandleTopFocusL( TBool aStopTimer )
+EXPORT_C void CMmWidgetContainer::EndLongTapL( TBool aStopTimer )
 	{
 	if ( iLongTapInProgress )
 		{
 		iLongTapInProgress = EFalse;
 		if( aStopTimer )
 			}
 		}
 	}
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CMmWidgetContainer::HandleListBoxEventL( CEikListBox* aListBox,
 TListBoxEvent aEventType )
 {
 			{
 			iTimer->StopL( EFalse );
 			break;
 			}
 		}
 //    handle different behaviour in edit mode and normal mode
 	if ( !IsEditMode() )
 		{
 		switch ( aEventType )
 			{
 			case MEikListBoxObserver::EEventFlickStarted:
 				{
 				static_cast<CMmListBoxItemDrawer*>(
 						Widget()->View()->ItemDrawer() )->
 						EnableCachedDataUse( ETrue );
 				break;
 				}
 			case MEikListBoxObserver::EEventFlickStopped:
 				{
 				static_cast<CMmListBoxItemDrawer*>(
 						Widget()->View()->ItemDrawer() )->
 						EnableCachedDataUse( EFalse );
 				DrawView();
 				break;
 				}
 			}
 		}
 	else
 		{
 		switch ( aEventType )
 			{
 			case MEikListBoxObserver::EEventFlickStopped:
 				{
 				// this fixes some problems with messed edit mode
 				// caused by kinetic scrolling
 				iDrawer->GetAnimator()->SetNextRedrawToWholeScreen();
 				break;
 				}
 			}
 		}
 if ( iListBoxObserver && !iLongTapInProgress )
 {
 iListBoxObserver->HandleListBoxEventL( aListBox, aEventType );
 }
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 EXPORT_C void CMmWidgetContainer::HandleOptionsMenuVisibilityChangeL(
 		TBool aOptionsMenuVisible )
 	{
 	if ( IsTimerActive() )
 		{
 		TInt delay = (aOptionsMenuVisible) ? KDelayInfinite : KDelayInSeconds6;

changeset 1	5315654608de
parent 0	f72a12da539e
child 2	08c6ee43b396