/**************************************************************************** ** ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). ** All rights reserved. ** Contact: Nokia Corporation (qt-info@nokia.com) ** ** This file is part of the QtGui module of the Qt Toolkit. ** ** $QT_BEGIN_LICENSE:LGPL$ ** No Commercial Usage ** This file contains pre-release code and may not be distributed. ** You may use this file in accordance with the terms and conditions ** contained in the Technology Preview License Agreement accompanying ** this package. ** ** GNU Lesser General Public License Usage ** Alternatively, this file may be used under the terms of the GNU Lesser ** General Public License version 2.1 as published by the Free Software ** Foundation and appearing in the file LICENSE.LGPL included in the ** packaging of this file. Please review the following information to ** ensure the GNU Lesser General Public License version 2.1 requirements ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. ** ** In addition, as a special exception, Nokia gives you certain additional ** rights. These rights are described in the Nokia Qt LGPL Exception ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. ** ** If you have questions regarding the use of this file, please contact ** Nokia at qt-info@nokia.com. ** ** ** ** ** ** ** ** ** $QT_END_LICENSE$ ** ****************************************************************************/ #include "private/qgesturemanager_p.h" #include "private/qstandardgestures_p.h" #include "private/qwidget_p.h" #include "private/qgesture_p.h" #include "private/qgraphicsitem_p.h" #include "private/qevent_p.h" #include "qgesture.h" #include "qevent.h" #include "qgraphicsitem.h" #ifdef Q_WS_MAC #include "qmacgesturerecognizer_mac_p.h" #endif #include "qdebug.h" // #define GESTURE_DEBUG #ifndef GESTURE_DEBUG # define DEBUG if (0) qDebug #else # define DEBUG qDebug #endif QT_BEGIN_NAMESPACE QGestureManager::QGestureManager(QObject *parent) : QObject(parent), state(NotGesture), lastCustomGestureId(0) { qRegisterMetaType(); #if defined(Q_WS_MAC) registerGestureRecognizer(new QMacSwipeGestureRecognizer); registerGestureRecognizer(new QMacPinchGestureRecognizer); #if defined(QT_MAC_USE_COCOA) registerGestureRecognizer(new QMacPanGestureRecognizer); #endif #else registerGestureRecognizer(new QPanGestureRecognizer); #endif } QGestureManager::~QGestureManager() { } Qt::GestureType QGestureManager::registerGestureRecognizer(QGestureRecognizer *recognizer) { QGesture *dummy = recognizer->createGesture(0); if (!dummy) { qWarning("QGestureManager::registerGestureRecognizer: " "the recognizer fails to create a gesture object, skipping registration."); return Qt::GestureType(0); } Qt::GestureType type = dummy->gestureType(); if (type == Qt::CustomGesture) { // generate a new custom gesture id ++lastCustomGestureId; type = Qt::GestureType(Qt::CustomGesture + lastCustomGestureId); } recognizers.insertMulti(type, recognizer); delete dummy; return type; } void QGestureManager::unregisterGestureRecognizer(Qt::GestureType) { } QGesture *QGestureManager::getState(QObject *object, Qt::GestureType type) { // if the widget is being deleted we should be carefull and not to // create a new state, as it will create QWeakPointer which doesnt work // from the destructor. if (object->isWidgetType()) { if (static_cast(object)->d_func()->data.in_destructor) return 0; } else if (QGesture *g = qobject_cast(object)) { return g; } else { Q_ASSERT(qobject_cast(object)); } QGesture *state = objectGestures.value(QGestureManager::ObjectGesture(object, type)); if (!state) { QGestureRecognizer *recognizer = recognizers.value(type); if (recognizer) { state = recognizer->createGesture(object); if (!state) return 0; if (state->gestureType() == Qt::CustomGesture) { // if the recognizer didn't fill in the gesture type, then this // is a custom gesture with autogenerated it and we fill it. state->d_func()->gestureType = type; #if defined(GESTURE_DEBUG) state->setObjectName(QString::number((int)type)); #endif } objectGestures.insert(QGestureManager::ObjectGesture(object, type), state); gestureToRecognizer[state] = recognizer; gestureOwners[state] = object; } } return state; } bool QGestureManager::filterEventThroughContexts(const QMap &contexts, QEvent *event) { QSet triggeredGestures; QSet finishedGestures; QSet newMaybeGestures; QSet canceledGestures; QSet notGestures; // TODO: sort contexts by the gesture type and check if one of the contexts // is already active. // filter the event through recognizers typedef QMap::const_iterator ContextIterator; for (ContextIterator cit = contexts.begin(), ce = contexts.end(); cit != ce; ++cit) { Qt::GestureType gestureType = cit.value(); QMap::const_iterator rit = recognizers.lowerBound(gestureType), re = recognizers.upperBound(gestureType); for (; rit != re; ++rit) { QGestureRecognizer *recognizer = rit.value(); QObject *target = cit.key(); QGesture *state = getState(target, gestureType); if (!state) continue; QGestureRecognizer::Result result = recognizer->filterEvent(state, target, event); QGestureRecognizer::Result type = result & QGestureRecognizer::ResultState_Mask; if (type == QGestureRecognizer::GestureTriggered) { DEBUG() << "QGestureManager: gesture triggered: " << state; triggeredGestures << state; } else if (type == QGestureRecognizer::GestureFinished) { DEBUG() << "QGestureManager: gesture finished: " << state; finishedGestures << state; } else if (type == QGestureRecognizer::MaybeGesture) { DEBUG() << "QGestureManager: maybe gesture: " << state; newMaybeGestures << state; } else if (type == QGestureRecognizer::NotGesture) { DEBUG() << "QGestureManager: not gesture: " << state; notGestures << state; } else if (type == QGestureRecognizer::Ignore) { DEBUG() << "QGestureManager: gesture ignored the event: " << state; } else { DEBUG() << "QGestureManager: hm, lets assume the recognizer" << "ignored the event: " << state; } if (result & QGestureRecognizer::ConsumeEventHint) { DEBUG() << "QGestureManager: we were asked to consume the event: " << state; //TODO: consume events if asked } } } QSet startedGestures = triggeredGestures - activeGestures; triggeredGestures &= activeGestures; // check if a running gesture switched back to maybe state QSet activeToMaybeGestures = activeGestures & newMaybeGestures; // check if a running gesture switched back to not gesture state, // i.e. were canceled QSet activeToCancelGestures = activeGestures & notGestures; canceledGestures += activeToCancelGestures; // start timers for new gestures in maybe state foreach (QGesture *state, newMaybeGestures) { QBasicTimer &timer = maybeGestures[state]; if (!timer.isActive()) timer.start(3000, this); } // kill timers for gestures that were in maybe state QSet notMaybeGestures = (startedGestures | triggeredGestures | finishedGestures | canceledGestures | notGestures); foreach(QGesture *gesture, notMaybeGestures) { QMap::iterator it = maybeGestures.find(gesture); if (it != maybeGestures.end()) { it.value().stop(); maybeGestures.erase(it); } } Q_ASSERT((startedGestures & finishedGestures).isEmpty()); Q_ASSERT((startedGestures & newMaybeGestures).isEmpty()); Q_ASSERT((startedGestures & canceledGestures).isEmpty()); Q_ASSERT((finishedGestures & newMaybeGestures).isEmpty()); Q_ASSERT((finishedGestures & canceledGestures).isEmpty()); Q_ASSERT((canceledGestures & newMaybeGestures).isEmpty()); QSet notStarted = finishedGestures - activeGestures; if (!notStarted.isEmpty()) { // there are some gestures that claim to be finished, but never started. // probably those are "singleshot" gestures so we'll fake the started state. foreach (QGesture *gesture, notStarted) gesture->d_func()->state = Qt::GestureStarted; QSet undeliveredGestures; deliverEvents(notStarted, &undeliveredGestures); finishedGestures -= undeliveredGestures; } activeGestures += startedGestures; // sanity check: all triggered gestures should already be in active gestures list Q_ASSERT((activeGestures & triggeredGestures).size() == triggeredGestures.size()); activeGestures -= finishedGestures; activeGestures -= activeToMaybeGestures; activeGestures -= canceledGestures; // set the proper gesture state on each gesture foreach (QGesture *gesture, startedGestures) gesture->d_func()->state = Qt::GestureStarted; foreach (QGesture *gesture, triggeredGestures) gesture->d_func()->state = Qt::GestureUpdated; foreach (QGesture *gesture, finishedGestures) gesture->d_func()->state = Qt::GestureFinished; foreach (QGesture *gesture, canceledGestures) gesture->d_func()->state = Qt::GestureCanceled; foreach (QGesture *gesture, activeToMaybeGestures) gesture->d_func()->state = Qt::GestureFinished; if (!activeGestures.isEmpty() || !maybeGestures.isEmpty() || !startedGestures.isEmpty() || !triggeredGestures.isEmpty() || !finishedGestures.isEmpty() || !canceledGestures.isEmpty()) { DEBUG() << "QGestureManager::filterEvent:" << "\n\tactiveGestures:" << activeGestures << "\n\tmaybeGestures:" << maybeGestures.keys() << "\n\tstarted:" << startedGestures << "\n\ttriggered:" << triggeredGestures << "\n\tfinished:" << finishedGestures << "\n\tcanceled:" << canceledGestures; } QSet undeliveredGestures; deliverEvents(startedGestures+triggeredGestures+finishedGestures+canceledGestures, &undeliveredGestures); activeGestures -= undeliveredGestures; // reset gestures that ended QSet endedGestures = finishedGestures + canceledGestures + undeliveredGestures; foreach (QGesture *gesture, endedGestures) { if (QGestureRecognizer *recognizer = gestureToRecognizer.value(gesture, 0)) { recognizer->reset(gesture); } gestureTargets.remove(gesture); } return false; } bool QGestureManager::filterEvent(QWidget *receiver, QEvent *event) { QSet types; QMap contexts; QWidget *w = receiver; typedef QMap::const_iterator ContextIterator; if (!w->d_func()->gestureContext.isEmpty()) { for(ContextIterator it = w->d_func()->gestureContext.begin(), e = w->d_func()->gestureContext.end(); it != e; ++it) { types.insert(it.key()); contexts.insertMulti(w, it.key()); } } // find all gesture contexts for the widget tree w = w->isWindow() ? 0 : w->parentWidget(); while (w) { for (ContextIterator it = w->d_func()->gestureContext.begin(), e = w->d_func()->gestureContext.end(); it != e; ++it) { if (it.value() == Qt::WidgetWithChildrenGesture) { if (!types.contains(it.key())) { types.insert(it.key()); contexts.insertMulti(w, it.key()); } } } if (w->isWindow()) break; w = w->parentWidget(); } return filterEventThroughContexts(contexts, event); } #ifndef QT_NO_GRAPHICSVIEW bool QGestureManager::filterEvent(QGraphicsObject *receiver, QEvent *event) { QSet types; QMap contexts; QGraphicsObject *item = receiver; if (!item->QGraphicsItem::d_func()->gestureContext.isEmpty()) { typedef QMap::const_iterator ContextIterator; for(ContextIterator it = item->QGraphicsItem::d_func()->gestureContext.begin(), e = item->QGraphicsItem::d_func()->gestureContext.end(); it != e; ++it) { types.insert(it.key()); contexts.insertMulti(item, it.key()); } } // find all gesture contexts for the graphics object tree item = item->parentObject(); while (item) { typedef QMap::const_iterator ContextIterator; for (ContextIterator it = item->QGraphicsItem::d_func()->gestureContext.begin(), e = item->QGraphicsItem::d_func()->gestureContext.end(); it != e; ++it) { if (it.value() == Qt::ItemWithChildrenGesture) { if (!types.contains(it.key())) contexts.insertMulti(item, it.key()); } } item = item->parentObject(); } return filterEventThroughContexts(contexts, event); } #endif bool QGestureManager::filterEvent(QGesture *state, QEvent *event) { QMap contexts; contexts.insert(state, state->gestureType()); return filterEventThroughContexts(contexts, event); } void QGestureManager::getGestureTargets(const QSet &gestures, QMap > *conflicts, QMap > *normal) { typedef QHash > GestureByTypes; GestureByTypes gestureByTypes; // sort gestures by types foreach (QGesture *gesture, gestures) { QWidget *receiver = gestureTargets.value(gesture, 0); Q_ASSERT(receiver); gestureByTypes[gesture->gestureType()].insert(receiver, gesture); } // for each gesture type foreach (Qt::GestureType type, gestureByTypes.keys()) { QHash gestures = gestureByTypes.value(type); foreach (QWidget *widget, gestures.keys()) { QWidget *w = widget->parentWidget(); while (w) { QMap::const_iterator it = w->d_func()->gestureContext.find(type); if (it != w->d_func()->gestureContext.end()) { // i.e. 'w' listens to gesture 'type' Qt::GestureContext context = it.value(); if (context == Qt::WidgetWithChildrenGesture && w != widget) { // conflicting gesture! (*conflicts)[widget].append(gestures[widget]); break; } } if (w->isWindow()) { w = 0; break; } w = w->parentWidget(); } if (!w) (*normal)[widget].append(gestures[widget]); } } } void QGestureManager::deliverEvents(const QSet &gestures, QSet *undeliveredGestures) { if (gestures.isEmpty()) return; typedef QMap > GesturesPerWidget; GesturesPerWidget conflictedGestures; GesturesPerWidget normalStartedGestures; QSet startedGestures; // first figure out the initial receivers of gestures for (QSet::const_iterator it = gestures.begin(), e = gestures.end(); it != e; ++it) { QGesture *gesture = *it; QWidget *target = gestureTargets.value(gesture, 0); if (!target) { // the gesture has just started and doesn't have a target yet. Q_ASSERT(gesture->state() == Qt::GestureStarted); if (gesture->hasHotSpot()) { // guess the target widget using the hotspot of the gesture QPoint pt = gesture->hotSpot().toPoint(); if (QWidget *w = qApp->topLevelAt(pt)) { target = w->childAt(w->mapFromGlobal(pt)); } } else { // or use the context of the gesture QObject *context = gestureOwners.value(gesture, 0); if (context->isWidgetType()) target = static_cast(context); } if (target) gestureTargets.insert(gesture, target); } Qt::GestureType gestureType = gesture->gestureType(); Q_ASSERT(gestureType != Qt::CustomGesture); if (target) { if (gesture->state() == Qt::GestureStarted) { startedGestures.insert(gesture); } else { normalStartedGestures[target].append(gesture); } } else { DEBUG() << "QGestureManager::deliverEvent: could not find the target for gesture" << gesture->gestureType(); qWarning("QGestureManager::deliverEvent: could not find the target for gesture"); undeliveredGestures->insert(gesture); } } getGestureTargets(startedGestures, &conflictedGestures, &normalStartedGestures); DEBUG() << "QGestureManager::deliverEvents:" << "\nstarted: " << startedGestures << "\nconflicted: " << conflictedGestures << "\nnormal: " << normalStartedGestures << "\n"; // if there are conflicting gestures, send the GestureOverride event for (GesturesPerWidget::const_iterator it = conflictedGestures.begin(), e = conflictedGestures.end(); it != e; ++it) { QWidget *receiver = it.key(); QList gestures = it.value(); DEBUG() << "QGestureManager::deliverEvents: sending GestureOverride to" << receiver << "gestures:" << gestures; QGestureEvent event(gestures); event.t = QEvent::GestureOverride; // mark event and individual gestures as ignored event.ignore(); foreach(QGesture *g, gestures) event.setAccepted(g, false); QApplication::sendEvent(receiver, &event); bool eventAccepted = event.isAccepted(); foreach(QGesture *gesture, event.allGestures()) { if (eventAccepted || event.isAccepted(gesture)) { QWidget *w = event.d_func()->targetWidgets.value(gesture->gestureType(), 0); Q_ASSERT(w); DEBUG() << "override event: gesture was accepted:" << gesture << w; QList &gestures = normalStartedGestures[w]; gestures.append(gesture); // override the target gestureTargets[gesture] = w; } else { DEBUG() << "override event: gesture wasn't accepted. putting back:" << gesture; QList &gestures = normalStartedGestures[receiver]; gestures.append(gesture); } } } // delivering gestures that are not in conflicted state for (GesturesPerWidget::const_iterator it = normalStartedGestures.begin(), e = normalStartedGestures.end(); it != e; ++it) { if (!it.value().isEmpty()) { DEBUG() << "QGestureManager::deliverEvents: sending to" << it.key() << "gestures:" << it.value(); QGestureEvent event(it.value()); QApplication::sendEvent(it.key(), &event); } } } void QGestureManager::timerEvent(QTimerEvent *event) { QMap::iterator it = maybeGestures.begin(), e = maybeGestures.end(); for (; it != e; ) { QBasicTimer &timer = it.value(); Q_ASSERT(timer.isActive()); if (timer.timerId() == event->timerId()) { timer.stop(); QGesture *gesture = it.key(); it = maybeGestures.erase(it); DEBUG() << "QGestureManager::timerEvent: gesture stopped due to timeout:" << gesture; QGestureRecognizer *recognizer = gestureToRecognizer.value(gesture, 0); if (recognizer) recognizer->reset(gesture); } else { ++it; } } } QT_END_NAMESPACE #include "moc_qgesturemanager_p.cpp"