| /**************************************************************************** | |
| ** | |
| ** Copyright (C) 2011 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$ | |
| ** GNU Lesser General Public License Usage | |
| ** 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. | |
| ** | |
| ** GNU General Public License Usage | |
| ** Alternatively, this file may be used under the terms of the GNU General | |
| ** Public License version 3.0 as published by the Free Software Foundation | |
| ** and appearing in the file LICENSE.GPL included in the packaging of this | |
| ** file. Please review the following information to ensure the GNU General | |
| ** Public License version 3.0 requirements will be met: | |
| ** http://www.gnu.org/copyleft/gpl.html. | |
| ** | |
| ** Other Usage | |
| ** Alternatively, this file may be used in accordance with the terms and | |
| ** conditions contained in a signed written agreement between you and Nokia. | |
| ** | |
| ** | |
| ** | |
| ** | |
| ** | |
| ** $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 "private/qapplication_p.h" | |
| #include "qgesture.h" | |
| #include "qevent.h" | |
| #include "qgraphicsitem.h" | |
| #ifdef Q_WS_MAC | |
| #include "qmacgesturerecognizer_mac_p.h" | |
| #endif | |
| #if defined(Q_OS_WIN) && !defined(QT_NO_NATIVE_GESTURES) | |
| #include "qwinnativepangesturerecognizer_win_p.h" | |
| #endif | |
| #include "qdebug.h" | |
| // #define GESTURE_DEBUG | |
| #ifndef GESTURE_DEBUG | |
| # define DEBUG if (0) qDebug | |
| #else | |
| # define DEBUG qDebug | |
| #endif | |
| #ifndef QT_NO_GESTURES | |
| QT_BEGIN_NAMESPACE | |
| QGestureManager::QGestureManager(QObject *parent) | |
| : QObject(parent), state(NotGesture), m_lastCustomGestureId(Qt::CustomGesture) | |
| { | |
| qRegisterMetaType<Qt::GestureState>(); | |
| #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); | |
| registerGestureRecognizer(new QPinchGestureRecognizer); | |
| registerGestureRecognizer(new QSwipeGestureRecognizer); | |
| registerGestureRecognizer(new QTapGestureRecognizer); | |
| #endif | |
| #if defined(Q_OS_WIN) | |
| #if !defined(QT_NO_NATIVE_GESTURES) | |
| if (QApplicationPrivate::HasTouchSupport) | |
| registerGestureRecognizer(new QWinNativePanGestureRecognizer); | |
| #endif | |
| #else | |
| registerGestureRecognizer(new QTapAndHoldGestureRecognizer); | |
| #endif | |
| } | |
| QGestureManager::~QGestureManager() | |
| { | |
| qDeleteAll(m_recognizers.values()); | |
| foreach (QGestureRecognizer *recognizer, m_obsoleteGestures.keys()) { | |
| qDeleteAll(m_obsoleteGestures.value(recognizer)); | |
| delete recognizer; | |
| } | |
| m_obsoleteGestures.clear(); | |
| } | |
| Qt::GestureType QGestureManager::registerGestureRecognizer(QGestureRecognizer *recognizer) | |
| { | |
| QGesture *dummy = recognizer->create(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 | |
| ++m_lastCustomGestureId; | |
| type = Qt::GestureType(m_lastCustomGestureId); | |
| } | |
| m_recognizers.insertMulti(type, recognizer); | |
| delete dummy; | |
| return type; | |
| } | |
| void QGestureManager::unregisterGestureRecognizer(Qt::GestureType type) | |
| { | |
| QList<QGestureRecognizer *> list = m_recognizers.values(type); | |
| while (QGestureRecognizer *recognizer = m_recognizers.take(type)) { | |
| if (!m_obsoleteGestures.contains(recognizer)) { | |
| // inserting even an empty QSet will cause the recognizer to be deleted on destruction of the manager | |
| m_obsoleteGestures.insert(recognizer, QSet<QGesture *>()); | |
| } | |
| } | |
| foreach (QGesture *g, m_gestureToRecognizer.keys()) { | |
| QGestureRecognizer *recognizer = m_gestureToRecognizer.value(g); | |
| if (list.contains(recognizer)) { | |
| m_deletedRecognizers.insert(g, recognizer); | |
| } | |
| } | |
| QMap<ObjectGesture, QList<QGesture *> >::const_iterator iter = m_objectGestures.begin(); | |
| while (iter != m_objectGestures.end()) { | |
| ObjectGesture objectGesture = iter.key(); | |
| if (objectGesture.gesture == type) { | |
| foreach (QGesture *g, iter.value()) { | |
| if (QGestureRecognizer *recognizer = m_gestureToRecognizer.value(g)) { | |
| m_gestureToRecognizer.remove(g); | |
| m_obsoleteGestures[recognizer].insert(g); | |
| } | |
| } | |
| } | |
| ++iter; | |
| } | |
| } | |
| void QGestureManager::cleanupCachedGestures(QObject *target, Qt::GestureType type) | |
| { | |
| QMap<ObjectGesture, QList<QGesture *> >::Iterator iter = m_objectGestures.begin(); | |
| while (iter != m_objectGestures.end()) { | |
| ObjectGesture objectGesture = iter.key(); | |
| if (objectGesture.gesture == type && target == objectGesture.object) { | |
| QSet<QGesture *> gestures = iter.value().toSet(); | |
| for (QHash<QGestureRecognizer *, QSet<QGesture *> >::iterator | |
| it = m_obsoleteGestures.begin(), e = m_obsoleteGestures.end(); it != e; ++it) { | |
| it.value() -= gestures; | |
| } | |
| foreach (QGesture *g, gestures) { | |
| m_deletedRecognizers.remove(g); | |
| m_gestureToRecognizer.remove(g); | |
| m_maybeGestures.remove(g); | |
| m_activeGestures.remove(g); | |
| m_gestureOwners.remove(g); | |
| m_gestureTargets.remove(g); | |
| m_gesturesToDelete.insert(g); | |
| } | |
| iter = m_objectGestures.erase(iter); | |
| } else { | |
| ++iter; | |
| } | |
| } | |
| } | |
| // get or create a QGesture object that will represent the state for a given object, used by the recognizer | |
| QGesture *QGestureManager::getState(QObject *object, QGestureRecognizer *recognizer, Qt::GestureType type) | |
| { | |
| // if the widget is being deleted we should be careful not to | |
| // create a new state, as it will create QWeakPointer which doesn't work | |
| // from the destructor. | |
| if (object->isWidgetType()) { | |
| if (static_cast<QWidget *>(object)->d_func()->data.in_destructor) | |
| return 0; | |
| } else if (QGesture *g = qobject_cast<QGesture *>(object)) { | |
| return g; | |
| #ifndef QT_NO_GRAPHICSVIEW | |
| } else { | |
| Q_ASSERT(qobject_cast<QGraphicsObject *>(object)); | |
| QGraphicsObject *graphicsObject = static_cast<QGraphicsObject *>(object); | |
| if (graphicsObject->QGraphicsItem::d_func()->inDestructor) | |
| return 0; | |
| #endif | |
| } | |
| // check if the QGesture for this recognizer has already been created | |
| foreach (QGesture *state, m_objectGestures.value(QGestureManager::ObjectGesture(object, type))) { | |
| if (m_gestureToRecognizer.value(state) == recognizer) | |
| return state; | |
| } | |
| Q_ASSERT(recognizer); | |
| QGesture *state = recognizer->create(object); | |
| if (!state) | |
| return 0; | |
| state->setParent(this); | |
| if (state->gestureType() == Qt::CustomGesture) { | |
| // if the recognizer didn't fill in the gesture type, then this | |
| // is a custom gesture with autogenerated id and we fill it. | |
| state->d_func()->gestureType = type; | |
| #if defined(GESTURE_DEBUG) | |
| state->setObjectName(QString::number((int)type)); | |
| #endif | |
| } | |
| m_objectGestures[QGestureManager::ObjectGesture(object, type)].append(state); | |
| m_gestureToRecognizer[state] = recognizer; | |
| m_gestureOwners[state] = object; | |
| return state; | |
| } | |
| bool QGestureManager::filterEventThroughContexts(const QMultiMap<QObject *, | |
| Qt::GestureType> &contexts, | |
| QEvent *event) | |
| { | |
| QSet<QGesture *> triggeredGestures; | |
| QSet<QGesture *> finishedGestures; | |
| QSet<QGesture *> newMaybeGestures; | |
| QSet<QGesture *> notGestures; | |
| // TODO: sort contexts by the gesture type and check if one of the contexts | |
| // is already active. | |
| bool ret = false; | |
| // filter the event through recognizers | |
| typedef QMultiMap<QObject *, Qt::GestureType>::const_iterator ContextIterator; | |
| for (ContextIterator cit = contexts.begin(), ce = contexts.end(); cit != ce; ++cit) { | |
| Qt::GestureType gestureType = cit.value(); | |
| QMap<Qt::GestureType, QGestureRecognizer *>::const_iterator | |
| rit = m_recognizers.lowerBound(gestureType), | |
| re = m_recognizers.upperBound(gestureType); | |
| for (; rit != re; ++rit) { | |
| QGestureRecognizer *recognizer = rit.value(); | |
| QObject *target = cit.key(); | |
| QGesture *state = getState(target, recognizer, gestureType); | |
| if (!state) | |
| continue; | |
| QGestureRecognizer::Result result = recognizer->recognize(state, target, event); | |
| QGestureRecognizer::Result type = result & QGestureRecognizer::ResultState_Mask; | |
| result &= QGestureRecognizer::ResultHint_Mask; | |
| if (type == QGestureRecognizer::TriggerGesture) { | |
| DEBUG() << "QGestureManager:Recognizer: gesture triggered: " << state; | |
| triggeredGestures << state; | |
| } else if (type == QGestureRecognizer::FinishGesture) { | |
| DEBUG() << "QGestureManager:Recognizer: gesture finished: " << state; | |
| finishedGestures << state; | |
| } else if (type == QGestureRecognizer::MayBeGesture) { | |
| DEBUG() << "QGestureManager:Recognizer: maybe gesture: " << state; | |
| newMaybeGestures << state; | |
| } else if (type == QGestureRecognizer::CancelGesture) { | |
| DEBUG() << "QGestureManager:Recognizer: not gesture: " << state; | |
| notGestures << state; | |
| } else if (type == QGestureRecognizer::Ignore) { | |
| DEBUG() << "QGestureManager:Recognizer: ignored the event: " << state; | |
| } else { | |
| DEBUG() << "QGestureManager:Recognizer: hm, lets assume the recognizer" | |
| << "ignored the event: " << state; | |
| } | |
| if (result & QGestureRecognizer::ConsumeEventHint) { | |
| DEBUG() << "QGestureManager: we were asked to consume the event: " | |
| << state; | |
| ret = true; | |
| } | |
| } | |
| } | |
| if (triggeredGestures.isEmpty() && finishedGestures.isEmpty() | |
| && newMaybeGestures.isEmpty() && notGestures.isEmpty()) | |
| return ret; | |
| QSet<QGesture *> startedGestures = triggeredGestures - m_activeGestures; | |
| triggeredGestures &= m_activeGestures; | |
| // check if a running gesture switched back to maybe state | |
| QSet<QGesture *> activeToMaybeGestures = m_activeGestures & newMaybeGestures; | |
| // check if a maybe gesture switched to canceled - reset it but don't send an event | |
| QSet<QGesture *> maybeToCanceledGestures = m_maybeGestures & notGestures; | |
| // check if a running gesture switched back to not gesture state, | |
| // i.e. were canceled | |
| QSet<QGesture *> canceledGestures = m_activeGestures & notGestures; | |
| // new gestures in maybe state | |
| m_maybeGestures += newMaybeGestures; | |
| // gestures that were in maybe state | |
| QSet<QGesture *> notMaybeGestures = (startedGestures | triggeredGestures | |
| | finishedGestures | canceledGestures | |
| | notGestures); | |
| m_maybeGestures -= notMaybeGestures; | |
| 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<QGesture *> notStarted = finishedGestures - m_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<QGesture *> undeliveredGestures; | |
| deliverEvents(notStarted, &undeliveredGestures); | |
| finishedGestures -= undeliveredGestures; | |
| } | |
| m_activeGestures += startedGestures; | |
| // sanity check: all triggered gestures should already be in active gestures list | |
| Q_ASSERT((m_activeGestures & triggeredGestures).size() == triggeredGestures.size()); | |
| m_activeGestures -= finishedGestures; | |
| m_activeGestures -= activeToMaybeGestures; | |
| m_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 (!m_activeGestures.isEmpty() || !m_maybeGestures.isEmpty() || | |
| !startedGestures.isEmpty() || !triggeredGestures.isEmpty() || | |
| !finishedGestures.isEmpty() || !canceledGestures.isEmpty()) { | |
| DEBUG() << "QGestureManager::filterEventThroughContexts:" | |
| << "\n\tactiveGestures:" << m_activeGestures | |
| << "\n\tmaybeGestures:" << m_maybeGestures | |
| << "\n\tstarted:" << startedGestures | |
| << "\n\ttriggered:" << triggeredGestures | |
| << "\n\tfinished:" << finishedGestures | |
| << "\n\tcanceled:" << canceledGestures | |
| << "\n\tmaybe-canceled:" << maybeToCanceledGestures; | |
| } | |
| QSet<QGesture *> undeliveredGestures; | |
| deliverEvents(startedGestures+triggeredGestures+finishedGestures+canceledGestures, | |
| &undeliveredGestures); | |
| foreach (QGesture *g, startedGestures) { | |
| if (undeliveredGestures.contains(g)) | |
| continue; | |
| if (g->gestureCancelPolicy() == QGesture::CancelAllInContext) { | |
| DEBUG() << "lets try to cancel some"; | |
| // find gestures in context in Qt::GestureStarted or Qt::GestureUpdated state and cancel them | |
| cancelGesturesForChildren(g); | |
| } | |
| } | |
| m_activeGestures -= undeliveredGestures; | |
| // reset gestures that ended | |
| QSet<QGesture *> endedGestures = | |
| finishedGestures + canceledGestures + undeliveredGestures + maybeToCanceledGestures; | |
| foreach (QGesture *gesture, endedGestures) { | |
| recycle(gesture); | |
| m_gestureTargets.remove(gesture); | |
| } | |
| //Clean up the Gestures | |
| qDeleteAll(m_gesturesToDelete); | |
| m_gesturesToDelete.clear(); | |
| return ret; | |
| } | |
| // Cancel all gestures of children of the widget that original is associated with | |
| void QGestureManager::cancelGesturesForChildren(QGesture *original) | |
| { | |
| Q_ASSERT(original); | |
| QWidget *originatingWidget = m_gestureTargets.value(original); | |
| Q_ASSERT(originatingWidget); | |
| // iterate over all active gestures and all maybe gestures | |
| // for each find the owner | |
| // if the owner is part of our sub-hierarchy, cancel it. | |
| QSet<QGesture*> cancelledGestures; | |
| QSet<QGesture*>::Iterator iter = m_activeGestures.begin(); | |
| while (iter != m_activeGestures.end()) { | |
| QWidget *widget = m_gestureTargets.value(*iter); | |
| // note that we don't touch the gestures for our originatingWidget | |
| if (widget != originatingWidget && originatingWidget->isAncestorOf(widget)) { | |
| DEBUG() << " found a gesture to cancel" << (*iter); | |
| (*iter)->d_func()->state = Qt::GestureCanceled; | |
| cancelledGestures << *iter; | |
| iter = m_activeGestures.erase(iter); | |
| } else { | |
| ++iter; | |
| } | |
| } | |
| // TODO handle 'maybe' gestures too | |
| // sort them per target widget by cherry picking from almostCanceledGestures and delivering | |
| QSet<QGesture *> almostCanceledGestures = cancelledGestures; | |
| while (!almostCanceledGestures.isEmpty()) { | |
| QWidget *target = 0; | |
| QSet<QGesture*> gestures; | |
| iter = almostCanceledGestures.begin(); | |
| // sort per target widget | |
| while (iter != almostCanceledGestures.end()) { | |
| QWidget *widget = m_gestureTargets.value(*iter); | |
| if (target == 0) | |
| target = widget; | |
| if (target == widget) { | |
| gestures << *iter; | |
| iter = almostCanceledGestures.erase(iter); | |
| } else { | |
| ++iter; | |
| } | |
| } | |
| Q_ASSERT(target); | |
| QSet<QGesture*> undeliveredGestures; | |
| deliverEvents(gestures, &undeliveredGestures); | |
| } | |
| for (iter = cancelledGestures.begin(); iter != cancelledGestures.end(); ++iter) | |
| recycle(*iter); | |
| } | |
| void QGestureManager::cleanupGesturesForRemovedRecognizer(QGesture *gesture) | |
| { | |
| QGestureRecognizer *recognizer = m_deletedRecognizers.value(gesture); | |
| if(!recognizer) //The Gesture is removed while in the even loop, so the recognizers for this gestures was removed | |
| return; | |
| m_deletedRecognizers.remove(gesture); | |
| if (m_deletedRecognizers.keys(recognizer).isEmpty()) { | |
| // no more active gestures, cleanup! | |
| qDeleteAll(m_obsoleteGestures.value(recognizer)); | |
| m_obsoleteGestures.remove(recognizer); | |
| delete recognizer; | |
| } | |
| } | |
| // return true if accepted (consumed) | |
| bool QGestureManager::filterEvent(QWidget *receiver, QEvent *event) | |
| { | |
| QMap<Qt::GestureType, int> types; | |
| QMultiMap<QObject *, Qt::GestureType> contexts; | |
| QWidget *w = receiver; | |
| typedef QMap<Qt::GestureType, Qt::GestureFlags>::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(), 0); | |
| 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::DontStartGestureOnChildren)) { | |
| if (!types.contains(it.key())) { | |
| types.insert(it.key(), 0); | |
| contexts.insertMulti(w, it.key()); | |
| } | |
| } | |
| } | |
| if (w->isWindow()) | |
| break; | |
| w = w->parentWidget(); | |
| } | |
| return contexts.isEmpty() ? false : filterEventThroughContexts(contexts, event); | |
| } | |
| #ifndef QT_NO_GRAPHICSVIEW | |
| bool QGestureManager::filterEvent(QGraphicsObject *receiver, QEvent *event) | |
| { | |
| QMap<Qt::GestureType, int> types; | |
| QMultiMap<QObject *, Qt::GestureType> contexts; | |
| QGraphicsObject *item = receiver; | |
| if (!item->QGraphicsItem::d_func()->gestureContext.isEmpty()) { | |
| typedef QMap<Qt::GestureType, Qt::GestureFlags>::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(), 0); | |
| contexts.insertMulti(item, it.key()); | |
| } | |
| } | |
| // find all gesture contexts for the graphics object tree | |
| item = item->parentObject(); | |
| while (item) | |
| { | |
| typedef QMap<Qt::GestureType, Qt::GestureFlags>::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::DontStartGestureOnChildren)) { | |
| if (!types.contains(it.key())) { | |
| types.insert(it.key(), 0); | |
| contexts.insertMulti(item, it.key()); | |
| } | |
| } | |
| } | |
| item = item->parentObject(); | |
| } | |
| return contexts.isEmpty() ? false : filterEventThroughContexts(contexts, event); | |
| } | |
| #endif | |
| bool QGestureManager::filterEvent(QObject *receiver, QEvent *event) | |
| { | |
| if (!m_gestureToRecognizer.contains(static_cast<QGesture *>(receiver))) | |
| return false; | |
| QGesture *state = static_cast<QGesture *>(receiver); | |
| QMultiMap<QObject *, Qt::GestureType> contexts; | |
| contexts.insert(state, state->gestureType()); | |
| return filterEventThroughContexts(contexts, event); | |
| } | |
| void QGestureManager::getGestureTargets(const QSet<QGesture*> &gestures, | |
| QMap<QWidget *, QList<QGesture *> > *conflicts, | |
| QMap<QWidget *, QList<QGesture *> > *normal) | |
| { | |
| typedef QHash<Qt::GestureType, QHash<QWidget *, QGesture *> > GestureByTypes; | |
| GestureByTypes gestureByTypes; | |
| // sort gestures by types | |
| foreach (QGesture *gesture, gestures) { | |
| QWidget *receiver = m_gestureTargets.value(gesture, 0); | |
| Q_ASSERT(receiver); | |
| gestureByTypes[gesture->gestureType()].insert(receiver, gesture); | |
| } | |
| // for each gesture type | |
| foreach (Qt::GestureType type, gestureByTypes.keys()) { | |
| QHash<QWidget *, QGesture *> gestures = gestureByTypes.value(type); | |
| foreach (QWidget *widget, gestures.keys()) { | |
| QWidget *w = widget->parentWidget(); | |
| while (w) { | |
| QMap<Qt::GestureType, Qt::GestureFlags>::const_iterator it | |
| = w->d_func()->gestureContext.find(type); | |
| if (it != w->d_func()->gestureContext.end()) { | |
| // i.e. 'w' listens to gesture 'type' | |
| Qt::GestureFlags flags = it.value(); | |
| if (!(it.value() & Qt::DontStartGestureOnChildren) && 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<QGesture *> &gestures, | |
| QSet<QGesture *> *undeliveredGestures) | |
| { | |
| if (gestures.isEmpty()) | |
| return; | |
| typedef QMap<QWidget *, QList<QGesture *> > GesturesPerWidget; | |
| GesturesPerWidget conflictedGestures; | |
| GesturesPerWidget normalStartedGestures; | |
| QSet<QGesture *> startedGestures; | |
| // first figure out the initial receivers of gestures | |
| for (QSet<QGesture *>::const_iterator it = gestures.begin(), | |
| e = gestures.end(); it != e; ++it) { | |
| QGesture *gesture = *it; | |
| QWidget *target = m_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 *topLevel = qApp->topLevelAt(pt)) { | |
| QWidget *child = topLevel->childAt(topLevel->mapFromGlobal(pt)); | |
| target = child ? child : topLevel; | |
| } | |
| } else { | |
| // or use the context of the gesture | |
| QObject *context = m_gestureOwners.value(gesture, 0); | |
| if (context->isWidgetType()) | |
| target = static_cast<QWidget *>(context); | |
| } | |
| if (target) | |
| m_gestureTargets.insert(gesture, target); | |
| } | |
| Qt::GestureType gestureType = gesture->gestureType(); | |
| Q_ASSERT(gestureType != Qt::CustomGesture); | |
| Q_UNUSED(gestureType); | |
| 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<QGesture *> 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.gestures()) { | |
| 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<QGesture *> &gestures = normalStartedGestures[w]; | |
| gestures.append(gesture); | |
| // override the target | |
| m_gestureTargets[gesture] = w; | |
| } else { | |
| DEBUG() << "override event: gesture wasn't accepted. putting back:" << gesture; | |
| QList<QGesture *> &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); | |
| bool eventAccepted = event.isAccepted(); | |
| foreach (QGesture *gesture, event.gestures()) { | |
| if (gesture->state() == Qt::GestureStarted && | |
| (eventAccepted || event.isAccepted(gesture))) { | |
| QWidget *w = event.d_func()->targetWidgets.value(gesture->gestureType(), 0); | |
| Q_ASSERT(w); | |
| DEBUG() << "started gesture was delivered and accepted by" << w; | |
| m_gestureTargets[gesture] = w; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| void QGestureManager::recycle(QGesture *gesture) | |
| { | |
| QGestureRecognizer *recognizer = m_gestureToRecognizer.value(gesture, 0); | |
| if (recognizer) { | |
| gesture->setGestureCancelPolicy(QGesture::CancelNone); | |
| recognizer->reset(gesture); | |
| m_activeGestures.remove(gesture); | |
| } else { | |
| cleanupGesturesForRemovedRecognizer(gesture); | |
| } | |
| } | |
| QT_END_NAMESPACE | |
| #endif // QT_NO_GESTURES | |
| #include "moc_qgesturemanager_p.cpp" |