MCL/sf/app/photos: comparison photosgallery/viewframework/views/cloudview/src/glxcloudviewcontrol.cpp

equal deleted inserted replaced

-:9ba538e329bd
+:7d9067c6fcb1
 #include <alf/alfwidgetcontrol.h> // For CAlfWidgetControl
 #include <alf/alfroster.h> // For CalfRoster
 #include <alf/alfdisplay.h> // For CAlfDisplay
 #include <alf/ialfscrollbarmodel.h> // For alfScrollbar model
 #include <aknlayoutscalable_uiaccel.cdl.h>
+#include <aknphysics.h> // For Kinetic Scrolling
 #include <glxuiutility.h>
 #include <glxgeneraluiutilities.h>
 #include <glxuistd.h>
 //AlfT
 const TInt KNumMinRowSpace = 2;
 const TInt KColSpace = 20;
 const TInt KRightmargin = 20;
 const TInt KMinTagSize = 77;
 const TInt KTagScreenHeight = 460;
-const TInt KDragHoldTime = 500;
+const TReal KBoundaryMargin = 0.1; //10% = 10/100 = 0.1
+const TInt KFastCloudMovement = 100; //Transition time to move cloud view
+const TInt KSlowCloudMovement = 1000; //Transition time to move cloud view
 // ---------------------------------------------------------------------------
 // Two-phased constructor.
 // ---------------------------------------------------------------------------
 //
 AknLayoutUtils::LayoutMetricsRect (AknLayoutUtils::EMainPane, rect);
 iScreenHeight = rect.Height ();
 iParentLayout = CAlfLayout::AddNewL(*this, aAnchorLayout);
 iTagScreenWidth = rect.Width() - iScrollPaneHandle.iW - KRightmargin;
-if (GlxGeneralUiUtilities::IsLandscape())
+if(IsLandscape())
 {
 iTagScreenHeight = rect.Height();
 }
 else
 {
 UpdateRowDataL ();
 }
 }
 //get touch feedback instance
 iTouchFeedback = MTouchFeedback::Instance();
+iPhysics = CAknPhysics::NewL(*this, NULL);
+InitPhysicsL();
 }
 // ---------------------------------------------------------------------------
 //VisualLayoutUpdated()
 void CGlxCloudViewControl::VisualLayoutUpdated(CAlfVisual &/* aVisual*/)
 {
 TRACER("GLX_CLOUD::CGlxCloudViewControl::VisualLayoutUpdated");
 TRect rect;
 AknLayoutUtils::LayoutMetricsRect (AknLayoutUtils::EMainPane, rect);
-if ( (rect.Width() != iTagScreenWidth) && ( rect.Height () != iScreenHeight))
+if ((rect.Width() != (iTagScreenWidth + iScrollPaneHandle.iW + KRightmargin)) || (rect.Height() != iScreenHeight))
 {
 //set the new screen dimensions
-UpdateLayoutL();
+TRAP_IGNORE(UpdateLayoutL());
 }
 }
 // ---------------------------------------------------------------------------
 // Destructor
 if ( iUiUtility )
 {
 iUiUtility->Close ();
 }
 delete iEmptyText;
+delete iPhysics;
 }
 // ---------------------------------------------------------------------------
 // LayoutVisibleRows()
 // ---------------------------------------------------------------------------
 iViewPortLayout->SetViewportSize(TAlfRealSize(iTagScreenWidth,iTagScreenHeight), 0);
 iViewPortLayout->SetSize(TAlfRealSize(iTagScreenWidth,iTagScreenHeight), 0);
 iViewPortSize.iWidth = iTagScreenWidth;
 iViewPortSize.iHeight = iTagScreenHeight;
-iViewPortLayout->SetViewportPos(TAlfRealPoint(0, 0),1000);
+iViewPortLayout->SetViewportPos(TAlfRealPoint(0, 0), KSlowCloudMovement);
 iViewPortPosition.iX =0;
 iViewPortPosition.iY =0;
 iScrollEventData.mSpan = iViewPortVirtualSize.iHeight ;
 }
 break;
 case EKeyDownArrow:
 {
-if(iCloudInfo.Count() >1 )
+if (iCloudInfo.Count() > 1)
 {
 HandleKeyDownL ();
 consumed = ETrue;
 iFocusRowIndex = RowNumber (iMediaList.FocusIndex ());
 if(aEvent.IsPointerEvent() )
 {
 //if its a pointer event
 consumed = HandlePointerEventL(aEvent);
 }
-else if( aEvent.IsCustomEvent() )
-{
-if(aEvent.CustomParameter() == ECustomEventFocusDragScroll)
-{
-//dragging down
-if( iIsDragging == 1 )
-{
-if(iFocusRowIndex!=iCloudInfo.Count()-1)
-{
-SetRelativeFocusL(iFocusRowIndex+1);
-iFocusRowIndex = RowNumber (iMediaList.FocusIndex ());
-// iScrollDirection = 0;
-MoveDownIfRequired();
-}
-}
-//dragging up
-else if(iIsDragging == 2)
-{
-if(iFocusRowIndex!=0)
-{
-SetRelativeFocusL(iFocusRowIndex-1);
-iFocusRowIndex = RowNumber (iMediaList.FocusIndex ());
-// iScrollDirection = 0;
-MoveUpIfRequired();
-}
-}
-}
-consumed = EFalse;
-}
 return consumed;
 }
 // ---------------------------------------------------------------------------
 // HandleKeyUp()
 {
 TRACER("GLX_CLOUD:: CGlxCloudViewControl::HandleKeyDownL");
 // If the last item is focused and if we are navigating downwards,then set the
 // focus to first element.
-if( iFocusRowIndex == iCloudInfo.Count()-1 )
+if (iFocusRowIndex == iCloudInfo.Count() - 1)
 {
-iMediaList.SetFocusL (NGlxListDefs::EAbsolute,
+iMediaList.SetFocusL(NGlxListDefs::EAbsolute, 0);
-0);
 }
 //else set the focus to the item which is in the next row,that overlaps with midpoint of the
 //focused item.
 else
 //of items in array will remain same.
 FetchAttributeFromCacheL();
 UpdateRowDataL (); //updates the row data and reassigns font sizes and draw the layout on screen.
 }
+InitPhysicsL();
 }
 // ---------------------------------------------------------------------------
 // HandleMediaL().
 else
 {
 DisplayEmptyCloudViewL();
 }
 }
+InitPhysicsL();
 }
 // ---------------------------------------------------------------------------
 // HandleItemModifiedL().
 // ---------------------------------------------------------------------------
 {
 iMediaList.SetFocusL (NGlxListDefs::EAbsolute, 0);
 }
 //generate row structures and draw rows on screen
 UpdateRowDataL ();
+InitPhysicsL();
 }
 }
 // ---------------------------------------------------------------------------
 // HandleFocusChangedL().
 //if its key event then it should be cyclic
 else if( rownumber == (iCloudInfo.Count()-1))
 {
 iViewPortPosition.iY = iViewPortVirtualSize.iHeight - iViewPortSize.iHeight;
 }
-iViewPortLayout->SetViewportPos (iViewPortPosition,1000);
+iViewPortLayout->SetViewportPos(iViewPortPosition, KSlowCloudMovement);
 iScrollEventData.mViewStartPos = iViewPortPosition.iY;
 Scroll();
 //CalculateBubleMidPoint ();
 }
 //if its key event then it should be cyclic
 else if (iMediaList.FocusIndex() == 0)
 {
 iViewPortPosition.iY = 0;
 }
-iViewPortLayout->SetViewportPos (iViewPortPosition,1000);
+iViewPortLayout->SetViewportPos(iViewPortPosition, KSlowCloudMovement);
 iScrollEventData.mViewStartPos = iViewPortPosition.iY;
 if(iScrollBarWidget)
 {
 Scroll();
 }
 TBool CGlxCloudViewControl::HandlePointerEventL( const TAlfEvent &aEvent )
 {
 TRACER("GLX_CLOUD::CGlxCloudViewControl::HandlePointerEventL");
 CAlfVisual* tappedvisual = aEvent.Visual();
 TBool consumed = EFalse;
 if(aEvent.PointerEvent().iType == TPointerEvent::EButton1Down)
 {
+//reset variables & Physics simulator
+iPhysics->StopPhysics();
+iPhysics->ResetFriction();
+iDragging = EFalse;
+iPhysicsStarted = EFalse;
+iStartTime.HomeTime();
+iViewDragged = EFalse;
+Display()->Roster().SetPointerEventObservers(
+EAlfPointerEventReportDrag + EAlfPointerEventReportLongTap
++ EAlfPointerEventReportUnhandled, *this);
+Display()->Roster().DisableLongTapEventsWhenDragging(*this);
 if(tappedvisual)
 {
 for(TInt index=0;index<iLayout->Count();index++)
 {
 CAlfVisual* layoutvisual = &(iLayout->Visual(index));
 //if the tapped visual is same as the visual in the layout then focus that visual
 if(layoutvisual == tappedvisual)
 {
 TInt focus = iMediaList.FocusIndex();
-//if the visual is already focused then for next tap open the next view
+if (index != focus)
-if( focus == index )
 {
-iTouchFeedback->InstantFeedback( ETouchFeedbackBasic );
+iTouchFeedback->InstantFeedback(ETouchFeedbackBasic);
-iObserverEnterKeyEvent.HandleEnterKeyEventL( (TInt)EAknCmdOpen );
+iMediaList.SetFocusL(NGlxListDefs::EAbsolute, index);
-consumed = ETrue;
+SetFocusColor();
 }
-else if( index!= focus )
+consumed = ETrue;
+break;
+}
+}
+}
+}
+else if (aEvent.PointerEvent().iType == TPointerEvent::EDrag)
+{
+GLX_LOG_INFO("GLX_CLOUD :: CGlxCloudViewControl::HandlePointerEventL(EDrag) event");
+iTouchFeedback->InstantFeedback(ETouchFeedbackBasic);
+consumed = HandleDragL(aEvent.PointerEvent());
+}
+else if (aEvent.PointerUp())
+{
+Display()->Roster().SetPointerEventObservers(0, *this);
+consumed = ETrue;
+//Check if dragging actually happened using iViewDragged
+if (iDragging && iViewDragged)
+{
+iDragging = EFalse;
+TPoint drag = iStart - aEvent.PointerEvent().iPosition;
+iPhysics->StartPhysics(drag, iStartTime);
+iPhysicsStarted = ETrue;
+}
+//If dragging not happened consider it as Tapped event
+else if (tappedvisual && !iViewDragged)
+{
+for (TInt index = 0; index < iLayout->Count(); index++)
+{
+CAlfVisual* layoutvisual = &(iLayout->Visual(index));
+//if the tapped visual is same as the visual in the layout then focus that visual
+if (layoutvisual == tappedvisual)
+{
+TInt focus = iMediaList.FocusIndex();
+if (index != focus)
 {
 iTouchFeedback->InstantFeedback( ETouchFeedbackBasic );
 TInt focusrowindex = iFocusRowIndex;
-iMediaList.SetFocusL (NGlxListDefs::EAbsolute,
+iMediaList.SetFocusL(NGlxListDefs::EAbsolute, index);
-index);
 SetFocusColor();
 iFocusRowIndex = RowNumber (iMediaList.FocusIndex ());
 if( iFocusRowIndex > focusrowindex)
 {
 GLX_LOG_INFO("GLX_CLOUD :: CGlxCloudViewControl::HandleDragL,b4 movedown");
 GLX_LOG_INFO("GLX_CLOUD :: CGlxCloudViewControl::HandleDragL,b4 moveup");
 iScrollDirection = 1;
 MoveUpIfRequired();
 }
 }
+iTouchFeedback->InstantFeedback(ETouchFeedbackBasic);
+iObserverEnterKeyEvent.HandleEnterKeyEventL((TInt) EAknCmdOpen);
 consumed = ETrue;
-Display()->Roster().SetPointerEventObservers( EAlfPointerEventReportDrag
-+ EAlfPointerEventReportLongTap
-+ EAlfPointerEventReportUnhandled, *this );
-Display()->Roster().DisableLongTapEventsWhenDragging(*this);
 break;
 }
 }
 }
-}
+iViewDragged = EFalse;
-else if (aEvent.PointerEvent().iType == TPointerEvent::EDrag)
-{
-GLX_LOG_INFO("GLX_CLOUD :: CGlxCloudViewControl::HandlePointerEventL(EDrag) event");
-iTouchFeedback->InstantFeedback( ETouchFeedbackBasic );
-consumed =  HandleDragL(aEvent.PointerEvent());
-}
-else if (aEvent.PointerUp())
-{
-Env().CancelCustomCommands(this,ECustomEventFocusDragScroll);
-Display()->Roster().SetPointerEventObservers(0, *this);
-consumed =  ETrue;
 }
 return consumed;
 }
 // ---------------------------------------------------------------------------
 // HandleDragL()
 // ---------------------------------------------------------------------------
 //
 TBool CGlxCloudViewControl::HandleDragL(const TPointerEvent& aPointerEvent)
 {
-TRACER("GLX_CLOUD::CGlxCloudViewControl::HandleDragL");
+TBool consumed(EFalse);
-TBool consumed = EFalse;
-TInt itemindex = GetAbsoluteIndex(aPointerEvent.iPosition);
+// If Physics Emulation is going on, no need to entertain drag event
-TInt focus = iMediaList.FocusIndex();
+if (iPhysicsStarted)
-TInt focusrowindex = iFocusRowIndex;
+return consumed;
-//if index is not NULL then focus the tag and move the viewport down if necessary
+//Simply ignore the first drag event as there is huge difference between position
-if ( itemindex != KErrNotFound )
+//coordinates in drag event and corordinates in normal pointer down / up events
-{
+if (!iDragging)
-if (focus != itemindex )
+{
-{
+//Note the current position for future reference
-iTouchFeedback->InstantFeedback( ETouchFeedbackSensitive );
+iStart = aPointerEvent.iPosition;
-iMediaList.SetFocusL (NGlxListDefs::EAbsolute,itemindex);
+iPrev = iStart;
-iFocusRowIndex = RowNumber (iMediaList.FocusIndex ());
+iDragging = ETrue;
-GLX_LOG_INFO1("GLX_CLOUD :: CGlxCloudViewControl::HandleDragL,focusrowindex = %d",iFocusRowIndex);
+return consumed;
-if( iFocusRowIndex > focusrowindex)
+}
-{
-GLX_LOG_INFO("GLX_CLOUD :: CGlxCloudViewControl::HandleDragL,b4 movedown");
+TRect rect;
-iScrollDirection = 0;
+AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EMainPane, rect);
-MoveDownIfRequired();
+TInt cntrlTopYLimit = rect.iTl.iY;
-}
+TInt cntrlBottomYLimit = rect.iBr.iY;
-else if( iFocusRowIndex < focusrowindex )
+TInt delta = iPrev.iY - aPointerEvent.iPosition.iY;
-{
-GLX_LOG_INFO("GLX_CLOUD :: CGlxCloudViewControl::HandleDragL,b4 moveup");
+//Check for physics threshold, before regidterting drag corordinates
-iScrollDirection = 1;
+TInt deltaAbs = delta < 0 ? -delta : delta;
-MoveUpIfRequired();
+TBool panning = deltaAbs >= iPhysics->DragThreshold();
-}
+if (panning)
-}
+{
-consumed = ETrue;
+TPoint deltaPt = iPrev - aPointerEvent.iPosition;
-}
+iPhysics->RegisterPanningPosition(deltaPt);
+iPrev = aPointerEvent.iPosition;
-TRect screenstartrect;
+iViewDragged = ETrue;
-//the starting rect of the visible screen
+}
-screenstartrect.SetRect(0,0,iTagScreenWidth,2*KRowHeight);
+consumed = ETrue;
-TRect screenendrect;
+//Calculate margin after which we might get pointer out of screen, and we might not
-//the end rect of the visible screen
+//get further pointer events. Also This is currently only 10% of total delta we can find,
-screenendrect.SetRect(0,(iTagScreenHeight-(2*KRowHeight)),iTagScreenWidth,iTagScreenHeight);
+//to get margin corresponding to movement of user flicking speed
+//This implies higher speed - higher margin
-//dragging down
+//Lower speed - 0 margin
-if(screenendrect.Contains(aPointerEvent.iPosition))
+TInt deltaMargin = deltaAbs * KBoundaryMargin;
-{
-iIsDragging = 1;
+//Code to predict future movement if same delta movement we might get in future
-Env().Send(TAlfCustomEventCommand(ECustomEventFocusDragScroll,
+//For flick event down - If the movement goes below screen, start physics
-this),KDragHoldTime);
+//or For flick event up - If the movement goes above screen, start physics
-}
+if (((delta < 0) && (aPointerEvent.iPosition.iY - delta >= cntrlBottomYLimit - deltaMargin))
-//dragging up
+|| ((delta > 0) && (aPointerEvent.iPosition.iY - delta <= cntrlTopYLimit + deltaMargin)))
-else if  (screenstartrect.Contains(aPointerEvent.iPosition))
+{
-{
+iPhysicsStarted = ETrue;
-iIsDragging = 2;
+}
-Env().Send(TAlfCustomEventCommand(ECustomEventFocusDragScroll,
-this),KDragHoldTime);
+//If found that possibly in next move it might go out of bounds, start physics
-}
+//emulation
+if (iPhysicsStarted && iDragging)
+{
+TPoint drag = iStart - aPointerEvent.iPosition;
+iPhysics->StartPhysics(drag, iStartTime);
+iDragging = EFalse;
+}
 return consumed;
 }
 // ---------------------------------------------------------------------------
 {
 GLX_LOG_INFO("GLX_CLOUD :: CGlxCloudViewControl::offerEvent(EEventScrollDown) event");
 TInt steps = TInt(aEvent.CustomEventData());
 UpdateScrollBar(steps,EFalse);
 Scroll();
+iPhysics->StopPhysics();
 status = EEventHandled;
 }
 break;
 case EEventScrollPageUp:
 {
 GLX_LOG_INFO("GLX_CLOUD :: CGlxCloudViewControl::offerEvent(EEventScrollPageUp) event");
 UpdateScrollBar(-iScrollEventData.mViewLength);
 Scroll();
-status = EEventHandled;
+iPhysics->StopPhysics();
+status = EEventHandled;
 }
 break;
 case EEventScrollPageDown:
 {
 GLX_LOG_INFO("GLX_CLOUD :: CGlxCloudViewControl::offerEvent(EEventScrollPageDown) event");
 UpdateScrollBar(iScrollEventData.mViewLength);
 Scroll();
+iPhysics->StopPhysics();
 status = EEventHandled;
 }
 break;
 }//end switch
 }
 baseelement->makeInterface (IAlfWidgetEventHandler::type()));
 //pass the custom event to scrollbar element so as to scroll to the required position
 iScrollbarElement->offerEvent(*(iScrollBarWidget->control()),customevent);
 GLX_LOG_INFO1("GLX_CLOUD ::CGlxCloudViewControl::Scroll(),position %d ",iScrollEventData.mViewStartPos);
 iViewPortPosition.iY = iScrollEventData.mViewStartPos;
-iViewPortLayout->SetViewportPos (iViewPortPosition,1000);
+iViewPortLayout->SetViewportPos(iViewPortPosition, KSlowCloudMovement);
 }
 // ---------------------------------------------------------------------------
 // UpdateScrollBar()
 // ---------------------------------------------------------------------------
 //
 void CGlxCloudViewControl::UpdateLayoutL()
 {
 TRect rect;
 AknLayoutUtils::LayoutMetricsRect (AknLayoutUtils::EMainPane, rect);
-if ( (rect.Width() != iTagScreenWidth) && ( rect.Height () != iScreenHeight))
+if ((rect.Width() != (iTagScreenWidth + iScrollPaneHandle.iW + KRightmargin)) || (rect.Height() != iScreenHeight))
 {
 //set the new screen dimensions
 iScreenHeight=rect.Height();
 iTagScreenWidth = rect.Width()- iScrollPaneHandle.iW - KRightmargin;
-if (GlxGeneralUiUtilities::IsLandscape())
+if(IsLandscape())
 {
 iTagScreenHeight = rect.Height();
 }
 else
 {
 {
 UpdateLayout();
 FetchAttributeFromCacheL();
 //generate row structures and draw rows on screen
 UpdateRowDataL ();
-}
-}
+InitPhysicsL();
 }
+}
+}
+// ---------------------------------------------------------------------------
+// InitPhysicsL()
+// ---------------------------------------------------------------------------
+//
+void CGlxCloudViewControl::InitPhysicsL()
+{
+//Update physics with new total layout, viewable size and our landscape mode
+iPhysics->InitPhysicsL(TSize(iViewPortVirtualSize.iWidth,
+iViewPortVirtualSize.iHeight), TSize(iTagScreenWidth,
+iTagScreenHeight), EFalse);
+//Note: Physics viewposition must always be mid of viewable screen size to get best result
+//I learned the hard way
+iViewPosition.SetXY(iTagScreenWidth / 2, iTagScreenHeight / 2);
+}
+// ---------------------------------------------------------------------------
+// ViewPositionChanged()
+// ---------------------------------------------------------------------------
+//
+void CGlxCloudViewControl::ViewPositionChanged(const TPoint& aNewPosition,
+TBool aDrawNow, TUint /*aFlags*/)
+{
+iViewPosition = aNewPosition;
+iViewPortPosition.iY = iViewPosition.iY - iTagScreenHeight / 2;
+if (aDrawNow)
+{
+iViewPortLayout->SetViewportPos(iViewPortPosition, KFastCloudMovement);
+iScrollEventData.mViewStartPos = iViewPortPosition.iY;
+Scroll();
+}
+}
+// ---------------------------------------------------------------------------
+// PhysicEmulationEnded()
+// ---------------------------------------------------------------------------
+//
+void CGlxCloudViewControl::PhysicEmulationEnded()
+{
+iPhysicsStarted = EFalse;
+}
+// ---------------------------------------------------------------------------
+// ViewPosition()
+// ---------------------------------------------------------------------------
+//
+TPoint CGlxCloudViewControl::ViewPosition() const
+{
+return iViewPosition;
+}
+// ---------------------------------------------------------------------------
+// IsLandscape()
+// ---------------------------------------------------------------------------
+//
+TBool CGlxCloudViewControl::IsLandscape()
+{
+TRect rect;
+AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EScreen, rect);
+if(rect.Width() > rect.Height())
+{
+return ETrue;
+}
+else
+{
+return EFalse;
+}
+}
 //End of file

changeset 2	7d9067c6fcb1
parent 0	4e91876724a2
child 9	6b87b143d312