qstmgesturelib/recognisers/qstmzoomgesturerecogniser.cpp
changeset 0 1450b09d0cfd
child 3 0954f5dd2cd0
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/qstmgesturelib/recognisers/qstmzoomgesturerecogniser.cpp	Tue May 04 12:39:35 2010 +0300
@@ -0,0 +1,227 @@
+/*
+* Copyright (c) 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".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: 
+*
+*/
+
+#include <qstmuievent_if.h>
+#include <qstmfilelogger.h>
+#include "qstmzoomgesturerecogniser.h"
+#include "qstmgenericsimplegesture.h"
+#include "qstmutils.h"
+
+using namespace qstmGesture ;
+using namespace qstmUiEventEngine;
+
+QStm_ZoomGestureRecogniser::QStm_ZoomGestureRecogniser(QStm_GestureListenerIf* listener) :
+                             QStm_GestureRecogniser(listener), m_area(QRect())
+{
+    m_rangesizeInPixels = 20 ;  // by default 20 pixels from the edges is the area
+    m_zooming = false ;
+}
+
+QStm_ZoomGestureRecogniser::~QStm_ZoomGestureRecogniser()
+{
+}
+
+QStm_GestureRecognitionState QStm_ZoomGestureRecogniser::recognise(int numOfActiveStreams,
+                                            QStm_GestureEngineIf* pge)
+{
+    QStm_GestureRecognitionState state = m_state = ENotMyGesture;
+    // Check if we are enabled or not
+    if (!m_gestureEnabled) return state ;
+
+    // Look at the events to see if it looks like zoom with one pointer
+    if (numOfActiveStreams == 1) {
+        const qstmUiEventEngine::QStm_UiEventIf* puie = pge->getUiEvents(0);
+        int countOfEvents = puie->countOfEvents();
+        qstmUiEventEngine::QStm_UiEventCode eventCode = puie->code();
+
+        if (m_loggingenabled) {
+            LOGARG("QStm_ZoomGestureRecogniser: %d num %d code %d", eventCode, countOfEvents, eventCode);
+
+        }
+        if (!m_zooming) {
+            // We are not yet zoomin, check if we should start, i.e. whether we are
+            // inside the zoom trigger areas near the corners when touch is done...
+            if (eventCode == qstmUiEventEngine::ETouch) { // It must be ETouch inside the corner
+
+                if (m_loggingenabled)  {
+                    LOGARG("QStm_ZoomGestureRecogniser: 0x%x ETouch: num %d code %d, %d", 
+                    		this, countOfEvents, puie->currentXY().x(), puie->currentXY().y());
+                    LOGARG("QStm_ZoomGestureRecogniser: area, %d,%d %d,%d, range: %d", 
+                    		m_area.x(), m_area.y(), m_area.x() + m_area.width(), m_area.y() + m_area.height(), 
+                    		m_rangesizeInPixels);
+                }
+
+                // the lower left rectangle is m_rangesizeIPixels from the corner
+                QRect lowerleft(m_area.x(), m_area.y() + m_area.height() - m_rangesizeInPixels,
+                                m_area.x() + m_rangesizeInPixels, m_area.y() + m_area.height()) ;
+                QRect upperright(m_area.x() + m_area.width() - m_rangesizeInPixels, m_area.y(),
+                                 m_area.x() + m_area.width(), m_area.y() + m_rangesizeInPixels) ;
+
+                m_previoustouch = m_startingtouch = puie->currentXY() ;
+                m_delta = 0 ;
+                if (lowerleft.contains(m_startingtouch) || upperright.contains(m_startingtouch)) {
+                    if (m_loggingenabled) {
+                        LOGARG("QStm_ZoomGestureRecogniser: ZOOM IN/OUT, (%d,%d) in %d,%d %d,%d, range: %d",
+                            m_startingtouch.x(), m_startingtouch.y(),
+                            m_area.x(), m_area.y(), m_area.x() + m_area.width(), m_area.y() + m_area.height(),
+                            m_rangesizeInPixels);
+                    }
+                    m_zooming = true ;
+                    if (lowerleft.contains(m_startingtouch)) {
+                        m_zoomtype = EZoomIn ;
+                    }
+                    else {
+                        m_zoomtype = EZoomOut ;
+                    }
+                    state = ELockToThisGesture ;    // keep zooming until release
+                    QStm_TwoPointGesture pgest(KUid, m_startingtouch, m_startingtouch);
+                    pgest.setLogging(m_loggingenabled) ;
+                    pgest.setDetails(&m_delta) ;
+                    pgest.setName(m_zoomtype == EZoomIn ? QString("ZoomIn") : QString("ZoomOut")) ;
+                    pgest.setType(m_zoomtype);
+                    pgest.setTarget(puie->target());
+
+                    // Call the listener to inform that a gesture has happened
+                    m_listener->gestureEnter(pgest) ;
+                }
+                else {
+                    // It is not our gesture so do nothing...
+                }
+            }
+            else {
+                // It is not touch, so not our initiating UI event.. do nothing
+            }
+        }
+        else {
+            // We are already zooming, calculate the changes in zooming factor if it looks we are still zooming
+            if (eventCode == qstmUiEventEngine::ERelease) { // ERelease stops zooming
+                // We were zooming, but if there are multiple touches we are not any more
+            	const qstmUiEventEngine::QStm_UiEventIf* puie = pge->getUiEvents(0);
+            	QStm_TwoPointGesture pgest = QStm_TwoPointGesture(KUid, puie->currentXY(), m_startingtouch);
+                m_listener->gestureExit(pgest) ; // should we call this or not?
+            }
+            else {   // all other UI events will keep on zooming
+                state = ELockToThisGesture ;    // Keep the gesture
+                const QPoint& p = puie->currentXY() ;
+                float newdist = calculateDistance(p) ;
+                float olddist = calculateDistance(m_previoustouch) ;
+                m_previoustouch = p ;
+                m_delta = adjustZoom(olddist, newdist) ;
+                state = EGestureActive ;
+
+                // Inform listener only if there is something to say
+                if (m_delta != 0) {
+                    QStm_TwoPointGesture pgest = QStm_TwoPointGesture(KUid, p, m_startingtouch);
+                    pgest.setLogging(m_loggingenabled) ;
+                    pgest.setDetails(&m_delta) ;
+                    pgest.setName(m_zoomtype == EZoomIn ? QString("ZoomIn") : QString("ZoomOut")) ;
+                    pgest.setType(m_zoomtype);
+                    pgest.setTarget(puie->target());
+                    // Call the listener to inform that a gesture has happened
+                    m_listener->gestureEnter(pgest) ;
+                }
+            }
+        }
+    }
+    else {
+        if (m_zooming) {
+            // We were zooming, but if there are multiple touches we are not any more
+        	const qstmUiEventEngine::QStm_UiEventIf* puie = pge->getUiEvents(0);
+        	QStm_TwoPointGesture pgest = QStm_TwoPointGesture(KUid, puie->currentXY(), m_startingtouch);
+        	pgest.setTarget(puie->target());
+            m_listener->gestureExit(pgest) ; // should we call this or not?
+        }
+        m_zooming = false ;
+    }
+    m_state = state;
+    return state;
+}
+
+void QStm_ZoomGestureRecogniser::release(QStm_GestureEngineIf* pge)
+{
+    if (m_zooming) {
+        m_zooming = false ;
+    	const qstmUiEventEngine::QStm_UiEventIf* puie = pge->getUiEvents(0);
+    	QStm_TwoPointGesture pgest = QStm_TwoPointGesture(KUid, puie->currentXY(), m_startingtouch);
+    	pgest.setTarget(puie->target());
+        m_listener->gestureExit(pgest) ; // should we call this or not?
+    }
+    if (m_loggingenabled) {
+        LOGARG("QStm_ZoomGestureRecogniser: 0x%x release", this);
+    }
+    m_state = ENotMyGesture;
+}
+
+void QStm_ZoomGestureRecogniser::setRange(int rangeInMm)
+{
+    m_rangesizeInPixels = QStm_Utils::mm2Pixels(rangeInMm) ;
+}
+
+void QStm_ZoomGestureRecogniser::setArea(const QRect& theArea)
+{
+    m_area = theArea ;
+    if (m_loggingenabled) {
+        LOGARG("QStm_ZoomGestureRecogniser: set area, %d,%d %d,%d", 
+        	   m_area.x(), m_area.y(), m_area.x() + m_area.width(), m_area.y() + m_area.height());
+    }
+}
+
+/*!
+ * calculate the distance, return as as float
+ */
+float QStm_ZoomGestureRecogniser::calculateDistance(const QPoint& tp)
+{
+	const QPoint p = m_startingtouch;
+	return QStm_Utils::distanceF(p, tp);
+    /*
+	double x = ((m_startingtouch.iX-tp.iX)*(m_startingtouch.iX-tp.iX))+((m_startingtouch.iY-tp.iY)*(m_startingtouch.iY-tp.iY)) ;
+    double ddist ;
+    Math::Sqrt(ddist, x) ;
+    return ddist ;
+    */
+}
+
+int QStm_ZoomGestureRecogniser::adjustZoom(float& previousDistance, float newDistance)
+{
+    float diff = newDistance - previousDistance ;
+    float logdiff = diff ;
+    if (diff < 0) diff = -diff ;
+    float changePercentage = (diff/previousDistance)*100.f ;
+    if (changePercentage > 10.f)
+    {
+        // change more than 10%, make at most 10%
+        float newdiff = previousDistance*0.1f;
+        if (previousDistance > newDistance) newdiff = -newdiff ;
+        if (m_loggingenabled) {
+            LOGARG("QStm_ZoomGestureRecogniser: adjust zoom from %f to %f : was, now %f %f",
+                double(logdiff), double(newdiff), double(previousDistance), double(newDistance));
+        }
+
+        previousDistance = previousDistance + newdiff ;
+        diff = newdiff ;
+
+    }
+    else {
+        if (m_loggingenabled)  {
+            LOGARG("QStm_ZoomGestureRecogniser: adjust zoom from %f to %f : was, now %f %f",
+                double(logdiff), double(diff), double(previousDistance), double(newDistance));
+        }
+        previousDistance = newDistance ;  // accept the new value and update the new length
+        diff = logdiff ;    // put the original back
+    }
+    return (int)diff ;
+}