FCL/sf/app/photos: comparison photosgallery/viewframework/views/zoomview/src/glxzoomeventhandler.cpp

equal deleted inserted replaced

-:420f6808bf21
+:f9e827349359
 const TInt KGlxAnimeFrameInmS           = 10000     ;
 const TInt KGlxAnimeFrameCount          = 10        ;
 const TInt KGlxPanInertiaFrameInmS      = 20000     ;
-//Zoom Factor to keep the relative Zoom Ratio
+// The (neutral) zoom factor above which all zooms caused are zoom-ins and below , zoom-outs.
-//same while changing orientation.
 const TInt KGlxNeutralZoomFactor = 100;
 using namespace GestureHelper;
 // ============================ CGlxZoomPanEventHandler===============================
 //----------------------------------------------------------------------------------
 // NewL
 //----------------------------------------------------------------------------------
 //
-CGlxZoomPanEventHandler* CGlxZoomPanEventHandler::NewL(MGlxZoomEventHandlers& aZoomEventHandler)
+CGlxZoomPanEventHandler* CGlxZoomPanEventHandler::NewL(
+MGlxZoomEventHandlers& aZoomEventHandler)
 {
 TRACER("CGlxZoomPanEventHandler::NewL");
-CGlxZoomPanEventHandler* self = new (ELeave) CGlxZoomPanEventHandler(aZoomEventHandler);
+CGlxZoomPanEventHandler* self = new (ELeave) CGlxZoomPanEventHandler(
+aZoomEventHandler);
 CleanupStack::PushL(self);
 self->ConstructL();
 CleanupStack::Pop(self);
 return self;
 }
 //----------------------------------------------------------------------------------
 // CGlxZoomPanEventHandler constructor
 //----------------------------------------------------------------------------------
 //
-CGlxZoomPanEventHandler::CGlxZoomPanEventHandler(MGlxZoomEventHandlers& aZoomEventHandler):
+CGlxZoomPanEventHandler::CGlxZoomPanEventHandler(
-iZoomEventHandler(aZoomEventHandler)
+MGlxZoomEventHandlers& aZoomEventHandler) :
+iZoomEventHandler(aZoomEventHandler), iPrevPinchFactor(
+KGlxNeutralZoomFactor)
 {
 TRACER("CGlxZoomPanEventHandler::CGlxZoomPanEventHandler()");
 // No Implementation
 }
 {
 CancelAnimationTimer();
 delete iZoomAnimationTimer;
 iZoomAnimationTimer = NULL;
 }
 }
 //----------------------------------------------------------------------------------
 // CGlxZoomPanEventHandler Constructl
 //----------------------------------------------------------------------------------
 //----------------------------------------------------------------------------------
 // CGlxZoomPanEventHandler SetupAnimatedZoom
 //----------------------------------------------------------------------------------
 //
 // Todo: Combine logics of setting up animated zoom and pan.
-void CGlxZoomPanEventHandler::SetupAnimatedZoom(TZoomMode aZoomMode, TPoint* /*aZoomFocus*/)
+void CGlxZoomPanEventHandler::SetupAnimatedZoom(TZoomMode aZoomMode,
+TPoint* /*aZoomFocus*/)
 {
 TRACER("CGlxZoomPanEventHandler::SetupAnimatedZoom");
-iTargetAnimatedZoomRatio = (iMaxZoomRatio + iMinZoomRatio)/2 ;
+iTargetAnimatedZoomRatio = (iMaxZoomRatio + iMinZoomRatio) / 2;
 CancelAnimationTimer();
 CancelUITimer();
 //ToDo: Verify this with images slightly smaller or slightly larger than fullscreen size.
 if (EZoomIn == aZoomMode)
 {
 // the '1+' is to take care of the situation when there the rest of the equation returns something betn 0 and 1
-iZoomPerInterval = 1 + (iTargetAnimatedZoomRatio - iZoomRatio)/KGlxAnimeFrameCount ;
+iZoomPerInterval = 1 + (iTargetAnimatedZoomRatio - iZoomRatio)
+/ KGlxAnimeFrameCount;
 }
 else
 {
-iZoomPerInterval = 1 + (iZoomRatio - iMinZoomRatio)/KGlxAnimeFrameCount;
+iZoomPerInterval = 1 + (iZoomRatio - iMinZoomRatio)
-}
+/ KGlxAnimeFrameCount;
+}
 if (1 < iZoomPerInterval)
 {
 iIsZoomingInAnimatedState = ETrue;
-switch(aZoomMode)
+switch (aZoomMode)
 {
 case EZoomIn:
 iAnimatedZoomMode = EAnimationModeZoomIn;
 break;
 case EZoomOut:
 iAnimatedZoomMode = EAnimationModeZoomOut;
 break;
 }
-iZoomAnimationTimer->Start( 0,
+iZoomAnimationTimer->Start(0, KGlxAnimeFrameInmS, TCallBack(
-KGlxAnimeFrameInmS,
+ActivationIntervalElapsed, (TAny*) this));
-TCallBack( ActivationIntervalElapsed,(TAny*)this) );
 }
 else
 // Cant zoom in/out at less than 1 percent. so directly jump to the target zoom ratio.
 // This happens in cases where there is not much difference between the source and target zoom levels
 {
 TInt targetZoomRatio = 0;
 if (EZoomIn == aZoomMode)
 {
-targetZoomRatio = iTargetAnimatedZoomRatio ;
+targetZoomRatio = iTargetAnimatedZoomRatio;
 }
 else
 {
-targetZoomRatio = iMinZoomRatio ;
+targetZoomRatio = iMinZoomRatio;
 }
-Zoom(targetZoomRatio, 0) ;
+Zoom(targetZoomRatio, 0);
 }
 }
 //----------------------------------------------------------------------------------
 // CGlxZoomPanEventHandler ActivationIntervalElapsed
 }
 Zoom(targetZoomLevel, 0, EZoomIn, &iZoomFocus );
 // The boundary conditions.
-if ( (( targetZoomLevel >= iTargetAnimatedZoomRatio ) && (EAnimationModeZoomIn == iAnimatedZoomMode ) )
+if (((targetZoomLevel >= iTargetAnimatedZoomRatio)
-|| ((targetZoomLevel <= iMinZoomRatio) && (EAnimationModeZoomOut == iAnimatedZoomMode)))
+&& (EAnimationModeZoomIn == iAnimatedZoomMode))
+|| ((targetZoomLevel <= iMinZoomRatio) && (EAnimationModeZoomOut
+== iAnimatedZoomMode)))
 {
 iIsZoomingInAnimatedState = EFalse;
 CancelAnimationTimer();
 TSize screensize = iMathsEngine.ScreenSize();
 iZoomFocus = TPoint(screensize.iWidth>>1,screensize.iHeight>>1) ;
 // HandlekeyEvents:This function handles the key Events.
 // -----------------------------------------------------------------------------
 //
 TBool CGlxZoomPanEventHandler::HandlekeyEvents(const TAlfEvent &aEvent)
 {
-TRACER("CGlxZoomControl::HandlekeyEvents()");
+TRACER("CGlxZoomPanEventHandler::HandlekeyEvents()");
-GLX_LOG_INFO1("CGlxZoomPanEventHandler::HandlekeyEvents. Scancode = %d   ", aEvent.KeyEvent().iScanCode);
+GLX_LOG_INFO1("CGlxZoomPanEventHandler::HandlekeyEvents.Scancode = %d",
+aEvent.KeyEvent().iScanCode);
 TBool consumed = EFalse;
 if (!iIsZoomingInAnimatedState)
 {
 // -----------------------------------------------------------------------------
 // HandleZoomKey:Zooms the image on zoom stripe action.
 // -----------------------------------------------------------------------------
 //
-void CGlxZoomPanEventHandler::HandleZoomKey(TZoomMode aZoomMode ,
+void CGlxZoomPanEventHandler::HandleZoomKey(TZoomMode aZoomMode,
 TEventCode aEventCode)
 {
-TRACER("CGlxZoomControl::HandleZoomKey ");
+TRACER("CGlxZoomPanEventHandler::HandleZoomKey ");
 if ( iZoomActivated )
 {
 switch(aEventCode)
 {
 case EEventKey :
 default :
 break ;
 }
 }
 }
 // -----------------------------------------------------------------------------
 // SetupPanOperation: start the pan operation for Key based pan.
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 // HandleDragEvent
 // -----------------------------------------------------------------------------
 //
-void CGlxZoomPanEventHandler::HandleDragEvent(const GestureHelper::MGestureEvent& aEvent )
+void CGlxZoomPanEventHandler::HandleDragEvent(
-{
+const GestureHelper::MGestureEvent& aEvent)
-TRACER("CGlxZoomControl::HandleDragEvent (GestureHelper::MGestureEvent&)");
+{
+TRACER("CGlxZoomPanEventHandler::HandleDragEvent(GestureHelper::MGestureEvent&)");
 // Ignore events when we are animating in Zoom
 if (iIsZoomingInAnimatedState)
 {
 return;
 }
 if (startPos != iPreviousDragStartPosition)
 {
 iPreviousPointerPosition = startPos;
 }
-TPoint offset((iPreviousPointerPosition.iX - currPos.iX) , (iPreviousPointerPosition.iY - currPos.iY));
+TPoint offset((iPreviousPointerPosition.iX - currPos.iX),
+(iPreviousPointerPosition.iY - currPos.iY));
 HideScreenFurniture();
 TPoint topLeftCorner(0,0);
 iMathsEngine.Pan(offset, topLeftCorner, EGlxPanIncrementUniform);
+iZoomEventHandler.HandleViewPortParametersChanged(topLeftCorner,
-iZoomEventHandler.HandleViewPortParametersChanged(topLeftCorner, KGlxAnimationTimeDrag);
+KGlxAnimationTimeDrag);
 iPreviousPointerPosition = currPos ;
 iPreviousDragStartPosition = startPos;
 }
 // -----------------------------------------------------------------------------
 // HandleGestureReleased
 // -----------------------------------------------------------------------------
 //
-void CGlxZoomPanEventHandler::HandleGestureReleased(const GestureHelper::MGestureEvent& /*aEvent*/ )
+void CGlxZoomPanEventHandler::HandleGestureReleased(
+const GestureHelper::MGestureEvent& /*aEvent*/)
 {
 TRACER("CGlxZoomPanEventHandler::HandleGestureReleasedEvent(const GestureHelper::MGestureEvent& )");
-if ( /*(EGestureUnknown  == iPreviousGestureCode)
+if ( (EGestureSwipeLeft  == iPreviousGestureCode)
-||*/(EGestureSwipeLeft  == iPreviousGestureCode)
 ||(EGestureSwipeRight == iPreviousGestureCode)
 ||(EGestureSwipeUp    == iPreviousGestureCode)
 ||(EGestureSwipeDown  == iPreviousGestureCode))
 {
 SetupAnimatedPan();
 {
 CancelAnimationTimer();
 }
 else
 {
-TPoint topLeftCorner(0,0);
+TPoint topLeftCorner(0, 0);
 TBool thresholdReached = EFalse;
-iMathsEngine.Pan(inertiaOffset, topLeftCorner, EGlxPanIncrementInertic, &thresholdReached);
+iMathsEngine.Pan(inertiaOffset, topLeftCorner,
+EGlxPanIncrementInertic, &thresholdReached);
-iZoomEventHandler.HandleViewPortParametersChanged(topLeftCorner, KGlxAnimationTimeDrag);
+iZoomEventHandler.HandleViewPortParametersChanged(topLeftCorner,
+KGlxAnimationTimeDrag);
 // we dont want to continue animated PAN if we have reached one end of the image.
 if (thresholdReached)
 {
 CancelAnimationTimer();
 }
 // -----------------------------------------------------------------------------
 // HandlePinchEvent
 // -----------------------------------------------------------------------------
 //
-void CGlxZoomPanEventHandler::HandlePinchEventL(const GestureHelper::MGestureEvent& aEvent )
+void CGlxZoomPanEventHandler::HandlePinchEventL(
-{
+const GestureHelper::MGestureEvent& aEvent)
-TRACER("CGlxZoomControl::HandlePinchEvent(GestureHelper::MGestureEvent&)");
+{
+TRACER("CGlxZoomPanEventHandler::HandlePinchEvent(GestureHelper::MGestureEvent&)");
 // Ignore events when we are animating in Zoom
 if (iIsZoomingInAnimatedState)
 {
 return;
 }
 TPoint pinchFocus       = aEvent.PinchCentrePoint();
-TInt pinchPercentage    = aEvent.PinchPercent();  // Wrong convention in variable nomenclature but better than ratioInPercentOfChangeInPinchDistance which is incidentally correct
+// Wrong convention in variable nomenclature but better than
+// ratioInPercentOfChangeInPinchDistance which is incidentally correct
+TInt pinchPercentage    = aEvent.PinchPercent();
+	if (( iPrevPinchFactor >= KGlxNeutralZoomFactor ) &&
+( pinchPercentage < KGlxNeutralZoomFactor ))
+{
+		iPrevPinchFactor = pinchPercentage ;
+		//This will result in we ignoring this event
+		pinchPercentage = KGlxNeutralZoomFactor;
+}
+	else
+{
+		iPrevPinchFactor = pinchPercentage ;
+}
 // pinchPercentage == 100 => No change in finger distance => No Zoom.
-// A negative Pinch percentage signifies an error in calculations. So NOT handling these
+// A negative Pinch percentage signifies an error in calculations.
-if ( (pinchPercentage != 100)
+	// So NOT handling these
+if ( (pinchPercentage != KGlxNeutralZoomFactor)
 && (pinchPercentage > 0) )
 {
 Zoom(0, pinchPercentage, EZoomIn, &pinchFocus);
 }
 HideScreenFurniture();
+GLX_LOG_INFO1("CGlxZoomPanEventHandler::HandlePinchEventL: Percentage [%d]" , pinchPercentage);
 }
 // -----------------------------------------------------------------------------
 // HandleDoubleTap
 // -----------------------------------------------------------------------------
 //
 void CGlxZoomPanEventHandler::HandleDoubleTap(const GestureHelper::MGestureEvent& /*aEvent*/ )
 {
-TRACER("CGlxZoomControl::HandleDoubleTap(GestureHelper::MGestureEvent&)");
+TRACER("CGlxZoomPanEventHandler::HandleDoubleTap(GestureHelper::MGestureEvent&)");
 // Ignore events when we are animating in Zoom
 if (iIsZoomingInAnimatedState)
 {
 return;
 // UiTimeOut: Hides the screen furniture once the Timeout happens
 // ---------------------------------------------------------------------------
 //
 TInt CGlxZoomPanEventHandler::UiTimeOut(TAny* aSelf)
 {
-TRACER("CGlxZoomControl::UiTimeOut");
+TRACER("CGlxZoomPanEventHandler::UiTimeOut");
 if(aSelf)
 {
 CGlxZoomPanEventHandler* self = static_cast <CGlxZoomPanEventHandler*> (aSelf);
 //retreive the UI state.
 if(EUiOn == self->iZoomUiState)
 // ZoomOutTimerL
 // ---------------------------------------------------------------------------
 //
 TInt CGlxZoomPanEventHandler::ZoomOutTimerL(TAny* aSelf)
 {
-TRACER("CGlxZoomControl::ZoomOutTimerL");
+TRACER("CGlxZoomPanEventHandler::ZoomOutTimerL");
 if(aSelf)
 {
 CGlxZoomPanEventHandler* self = static_cast <CGlxZoomPanEventHandler*> (aSelf);
 self->CallZoomOutL();
 }
 {
 TRACER("CGlxZoomPanEventHandler::DoPan ");
 TBool atPanThreshold = EFalse;
 TPoint topLeftCorner;
-iMathsEngine.Pan(iPanDirection, topLeftCorner, EGlxPanIncrementExponential,  &atPanThreshold);
+iMathsEngine.Pan(iPanDirection, topLeftCorner,
+EGlxPanIncrementExponential, &atPanThreshold);
-iZoomEventHandler.HandleViewPortParametersChanged(topLeftCorner, KGlxAnimationTimekeyPan);
+iZoomEventHandler.HandleViewPortParametersChanged(topLeftCorner,
+KGlxAnimationTimekeyPan);
 if ( atPanThreshold )
 {
 CancelZoomPanTimer();
 }
 switch(EventID)
 {
 case ETypePrimaryValueChange:
 {
-GLX_LOG_INFO(" CGlxZoomPanEventHandler::HandleEvent: ETypePrimaryValueChange."  );
+GLX_LOG_INFO("CGlxZoomPanEventHandler::HandleEvent:ETypePrimaryValueChange");
 MulSliderPos* dataPtr = (MulSliderPos*)(aEvent.CustomEventData());
 TInt currentSliderValue = dataPtr->mCurrentValue;
 // Is current value within acceptable range?
 case ECustomEventIconClick :
 {
 //The Slider is held by user,so cancel the UI Timer
 //When the slider is held ,the screen furniture shouldn't disappear
-GLX_LOG_INFO( " CGlxZoomControl::offerEvent,ECustomEventIconClick");
+GLX_LOG_INFO("CGlxZoomPanEventHandler::HandleEvent, ECustomEventIconClick");
 CancelUITimer();
 eventHandledState = ETrue;
 }
 break;
 case ECustomEventIconRelease:
 {
 //The slider is not held, by the user,start the ui timer to hide the screen furniture
-GLX_LOG_INFO( " CGlxZoomControl::offerEvent,ECustomEventIconRelease");
+GLX_LOG_INFO( " CGlxZoomPanEventHandler::offerEvent,ECustomEventIconRelease");
-StartUITimer(KGlxScreenTimeout, KGlxScreenTimeout, TCallBack( UiTimeOut,this ) );
+StartUITimer(KGlxScreenTimeout, KGlxScreenTimeout,
+TCallBack(UiTimeOut, this));
 eventHandledState = ETrue;
 }
 break;
 default:
 // -----------------------------------------------------------------------------
 // Zoom
 // -----------------------------------------------------------------------------
 //
-void CGlxZoomPanEventHandler::Zoom(TInt aExpectedZoomLevel, TInt aRelativeZoomFactor, TZoomMode aZoomMode, TPoint* aZoomFocus)
+void CGlxZoomPanEventHandler::Zoom(TInt aExpectedZoomLevel,
-{
+TInt aRelativeZoomFactor, TZoomMode aZoomMode, TPoint* aZoomFocus)
-TRACER("CGlxZoomPanEventHandler::ZoomL( )");
+{
+TRACER("CGlxZoomPanEventHandler::Zoom()");
 TPoint          viewPortTopLeft(0,0);
 TSize           viewPortDimension(0,0);
 TBool           atZoomThreshold = EFalse;

branch	RCL_3
changeset 47	f9e827349359
parent 35	420f6808bf21
child 56	b023a8d2866a