/*
* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, version 2.1 of the License.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not,
* see "http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html/".
*
* Description:
*
*/
#include "qstmgestureengine.h"
#include "qstmfilelogger.h"
#include "qstmutils.h"
using namespace qstmGesture ;
QStm_GestureEngine::QStm_GestureEngine()
{
m_loggingEnabled = 0;
m_numOfActiveStreams = 0 ;
m_currentGestureOwner = -1 ;
m_currentLockedGesture = -1 ;
for (int i = 0; i < qstmUiEventEngine::KMaxNumberOfPointers; i++) {
m_uiEventStream[i] = NULL ;
}
}
QStm_GestureEngine::~QStm_GestureEngine()
{
m_gestures.clear() ;
}
bool QStm_GestureEngine::addGesture(const QStm_GestureRecogniserIf* newGesture)
{
// Add the new gesture recogniser to our list of recognisers
if (newGesture) {
QStm_GestureRecogniserIf* p = const_cast<QStm_GestureRecogniserIf*>(newGesture);
m_gestures.append(p);
}
return true;
}
bool QStm_GestureEngine::insertGesture(const QStm_GestureRecogniserIf* newGesture, int startPos)
{
QStm_GestureRecogniserIf* p = const_cast<QStm_GestureRecogniserIf*>(newGesture);
m_gestures.insert(startPos, p);
return true;
}
int QStm_GestureEngine::findGesture(const QStm_GestureRecogniserIf* gesture, int startPos) const
{
for(int i = MAX(startPos, 0); i < m_gestures.count(); ++i) {
if(m_gestures[i] == gesture) {
return i;
}
}
return -1;
}
int QStm_GestureEngine::findGestureReverse(const QStm_GestureRecogniserIf* gesture, int startPos) const
{
for(int i = MIN(startPos, m_gestures.count() - 1); i >=0; --i) {
if(m_gestures[i] == gesture) {
return i;
}
}
return -1;
}
int QStm_GestureEngine::findGesture(QStm_GestureUid uid, int startPos) const
{
for(int i = MAX(startPos, 0); i < m_gestures.count(); ++i) {
if(m_gestures[i]->gestureUid() == uid) {
return i;
}
}
return -1;
}
int QStm_GestureEngine::findGestureReverse(QStm_GestureUid uid, int startPos) const
{
for(int i = MIN(startPos, m_gestures.count() - 1); i >=0; --i) {
if(m_gestures[i]->gestureUid() == uid) {
return i;
}
}
return -1;
}
int QStm_GestureEngine::gestureCount() const
{
return m_gestures.count();
}
bool QStm_GestureEngine::removeGesture(const QStm_GestureRecogniserIf* oldGesture)
{
// If gestures are removed, there cannot be current gesture owner...
if (m_currentGestureOwner != -1)
{
QStm_GestureRecogniserIf* pgrif = m_gestures[m_currentGestureOwner] ;
pgrif->release(this) ;
m_currentGestureOwner = -1 ; // no more gesture owners...
}
QStm_GestureRecogniserIf* p = const_cast<QStm_GestureRecogniserIf*>(oldGesture);
int ix = m_gestures.indexOf(p) ;
bool found = (ix != -1);
if (found) {
m_gestures.removeAt(ix) ;
}
return found ;
}
int QStm_GestureEngine::activeStreamCount() const
{
return m_numOfActiveStreams ;
}
const qstmUiEventEngine::QStm_UiEventIf* QStm_GestureEngine::getUiEvents(int indexOfActiveStream) const
{
//#if defined(ADVANCED_POINTER_EVENTS)
// create temporary array of active event streams and initialize with zero
const qstmUiEventEngine::QStm_UiEventIf* activeEventPointers[qstmUiEventEngine::KMaxNumberOfPointers] ;
for (int x = 0; x < qstmUiEventEngine::KMaxNumberOfPointers; activeEventPointers[x++] = 0);
// then fill from currently active event streams
int indextoactiveEventPointers = 0 ;
for (int i = 0; i < qstmUiEventEngine::KMaxNumberOfPointers; i++) {
if (m_uiEventStream[i] != NULL) {
activeEventPointers[indextoactiveEventPointers++] = m_uiEventStream[i] ;
}
}
// then return the active event stream asked
return activeEventPointers[indexOfActiveStream] ;
//#else
// in single touch it is enough to return the only possible pointer
// return m_uiEventStream[indexOfActiveStream] ;
//#endif
}
/*!
* Process the UI events
*/
void QStm_GestureEngine::handleUiEvent(const qstmUiEventEngine::QStm_UiEventIf& event )
{
// process one incoming UI event
storeUiEvent(event) ; // store the event to the "stream" based on the index of pointer
walkTroughGestures() ; // and walk trough the gestures to process the UI event
updateUiEvents() ;
// If it was last release event, make sure no-one has the gestures locked
m_numOfActiveStreams = 0 ;
for (int i = 0; i < qstmUiEventEngine::KMaxNumberOfPointers; i++) {
if (m_uiEventStream[i] != NULL) m_numOfActiveStreams++ ;
}
if (m_numOfActiveStreams == 0)
{
if (m_currentLockedGesture != -1)
{
QStm_GestureRecogniserIf* pgrif = m_gestures[m_currentLockedGesture] ;
pgrif->release(this) ;
}
m_currentLockedGesture = -1 ;
}
}
/*!
* Store the UI event. There are max X "streams" of events, one for each
* pointer. The streams are actually just pointers to the latest event, since the
* MUiEvent interface has methods to walk trough the chain of events.
*/
void QStm_GestureEngine::storeUiEvent(const qstmUiEventEngine::QStm_UiEventIf& event)
{
m_uiEventStream[event.index()] = &event ;
m_numOfActiveStreams = 0 ;
for (int i = 0; i < qstmUiEventEngine::KMaxNumberOfPointers; i++) {
if (m_uiEventStream[i] != NULL) m_numOfActiveStreams++ ;
}
}
/*!
* Call each gesture handler in turn until one claims to be in control of the gesture.
*/
void QStm_GestureEngine::walkTroughGestures()
{
int newowner = -1 ;
int newlocker = -1; //m_currentLockedGesture ;
// check if someone has locked the gesture
QStm_GestureRecognitionState thestate = ENotMyGesture ;
if (m_currentLockedGesture != -1) {
QStm_GestureRecogniserIf* pgrif = m_gestures[m_currentLockedGesture] ;
if (pgrif != NULL) {
if (m_loggingEnabled) {
// log entry about locked gesture (hmm.. should have added names to the MGestureRecogniserIf
LOGARG("locked gesture recognizer %d (addr %d), active streams %d",
m_currentLockedGesture, pgrif, m_numOfActiveStreams);
}
thestate = pgrif->recognise(m_numOfActiveStreams, this) ;
switch (thestate) {
case EGestureActive:
{
// This gesture recogniser owns the gesture, so release the lock
newlocker = -1 ;
newowner = m_currentLockedGesture ;
if (m_loggingEnabled) {
LOGARG("new owner %d lock release", m_currentLockedGesture);
}
break;
}
case ELockToThisGesture:
{
// this gesture recogniser wants to keep the lock
newowner = m_currentLockedGesture ;
newlocker = m_currentLockedGesture ;
if (m_loggingEnabled) {
LOGARG("new owner %d keep lock", m_currentLockedGesture);
}
break;
}
case ENotMyGesture:
{
break;
}
}
}
else {
if (m_loggingEnabled) {
LOGARG("NULL recogniser for %d", m_currentLockedGesture);
}
}
}
QStm_GestureRecognitionState currentState = ENotMyGesture;
if (thestate == ENotMyGesture) {
if (m_loggingEnabled) {
LOGARG("walk trough recognizers active streams %d", m_numOfActiveStreams);
}
// No locking gesture, walk trough the list until someone handles this
int gcount = m_gestures.count();
if (m_currentGestureOwner > -1) {
QStm_GestureRecogniserIf* gestureOwner = m_gestures[m_currentGestureOwner] ;
currentState = gestureOwner->state();
}
else {
currentState = ENotMyGesture;
}
for (int i = 0; i < gcount; i++) {
bool controlObtained = false;
QStm_GestureRecogniserIf* pgrif = m_gestures[i];
if (pgrif != NULL) {
switch (pgrif->recognise(m_numOfActiveStreams, this)) {
case EGestureActive:
{
// This gesture recogniser owns the gesture, stop looping...
controlObtained = true;
newowner = i;
break;
}
case ELockToThisGesture:
{
// this gesture recogniser wants to take ownership
controlObtained = true;
newowner = i;
newlocker = i;
break;
}
case ENotMyGesture:
{
break;
}
}
LOGARG("walkTroughGestures: 0x%x, recognizers count %d, newowner %d, m_currentGestureOwner %d",
pgrif, gcount, newowner, m_currentGestureOwner);
}
if (controlObtained) {
break; // do not process rest of the gestures
}
}
}
if (newowner != m_currentGestureOwner) {
if (m_currentGestureOwner != -1 ) {
QStm_GestureRecogniserIf* pgrif = m_gestures[m_currentGestureOwner] ;
if ((currentState == EGestureActive || currentState == ELockToThisGesture) &&
pgrif->state() == ENotMyGesture) {
pgrif->release(this) ;
}
}
m_currentGestureOwner = newowner ;
}
m_currentLockedGesture = newlocker ; // if someone locked it or released the lock
}
void QStm_GestureEngine::updateUiEvents()
{
for (int i = 0; i < qstmUiEventEngine::KMaxNumberOfPointers; i++) {
if (m_uiEventStream[i] != NULL) {
if (m_uiEventStream[i]->code() == qstmUiEventEngine::ERelease) {
// Event can be removed since Release is the last event
// note that it is the lower layer event engine
// which actually deletes the object
m_uiEventStream[i] = NULL ;
}
}
}
}