FCL/sf/mw/qt: comparison src/gui/kernel/qapplication.cpp

equal deleted inserted replaced

-:56cd8111b7f7
+:41300fa6a67c
 bool QApplicationPrivate::autoSipEnabled = false;
 #else
 bool QApplicationPrivate::autoSipEnabled = true;
 #endif
-QGestureManager* QGestureManager::instance()
-{
-QApplicationPrivate *d = qApp->d_func();
-if (!d->gestureManager)
-d->gestureManager = new QGestureManager(qApp);
-return d->gestureManager;
-}
 QApplicationPrivate::QApplicationPrivate(int &argc, char **argv, QApplication::Type type)
 : QCoreApplicationPrivate(argc, argv)
 {
 application_type = type;
 qt_appType = type;
 #endif
 #if defined(Q_WS_QWS) && !defined(QT_NO_DIRECTPAINTER)
 directPainters = 0;
 #endif
-gestureManager = 0;
+gestureWidget = 0;
 if (!self)
 self = this;
 }
 bool QApplicationPrivate::animate_tooltip = false;
 bool QApplicationPrivate::fade_tooltip = false;
 bool QApplicationPrivate::animate_toolbox = false;
 bool QApplicationPrivate::widgetCount = false;
 bool QApplicationPrivate::load_testability = false;
-#if defined(Q_WS_WIN) && !defined(Q_WS_WINCE)
-bool QApplicationPrivate::inSizeMove = false;
-#endif
 #ifdef QT_KEYPAD_NAVIGATION
 #  ifdef Q_OS_SYMBIAN
 Qt::NavigationMode QApplicationPrivate::navigationMode = Qt::NavigationModeKeypadDirectional;
 #  else
 Qt::NavigationMode QApplicationPrivate::navigationMode = Qt::NavigationModeKeypadTabOrder;
 qCritical("Library qttestability load failed!");
 }
 }
 //make sure the plugin is loaded
-qt_guiPlatformPlugin();
+if (qt_is_gui_used)
+qt_guiPlatformPlugin();
 #endif
 }
 #if defined(Q_WS_X11)
 // ### a string literal is a cont char*
 // qt_init() in qapplication_x11.cpp because of several reasons.
 // On QWS, the graphics system is set by the QScreen plugin.
 graphics_system = QGraphicsSystemFactory::create(graphics_system_name);
 #endif
 #ifndef QT_NO_WHEELEVENT
-#ifdef Q_OS_MAC
-QApplicationPrivate::wheel_scroll_lines = 1;
-#else
 QApplicationPrivate::wheel_scroll_lines = 3;
 #endif
-#endif
+if (qt_is_gui_used)
 initializeMultitouch();
 }
 /*!
 Returns the type of application (\l Tty, GuiClient, or
 GuiServer). The type is set when constructing the QApplication
 else if (focus && reason == Qt::ShortcutFocusReason) {
 focus->window()->setAttribute(Qt::WA_KeyboardFocusChange);
 }
 QWidget *prev = focus_widget;
 focus_widget = focus;
+#ifndef QT_NO_IM
 if (prev && ((reason != Qt::PopupFocusReason && reason != Qt::MenuBarFocusReason
 && prev->testAttribute(Qt::WA_InputMethodEnabled))
 // Do reset the input context, in case the new focus widget won't accept keyboard input
 // or it is not created fully yet.
 || (focus_widget && (!focus_widget->testAttribute(Qt::WA_InputMethodEnabled)
 if(qic) {
 qic->reset();
 qic->setFocusWidget(0);
 }
 }
+#endif //QT_NO_IM
 if(focus_widget)
 focus_widget->d_func()->setFocus_sys();
 if (reason != Qt::NoFocusReason) {
 //send events
 if (prev) {
 #ifdef QT_KEYPAD_NAVIGATION
 if (QApplication::keypadNavigationEnabled()) {
-if (prev->hasEditFocus() && reason != Qt::PopupFocusReason)
+if (prev->hasEditFocus() && reason != Qt::PopupFocusReason
+#ifdef Q_OS_SYMBIAN
+&& reason != Qt::ActiveWindowFocusReason
+#endif
+)
 prev->setEditFocus(false);
 }
 #endif
 #ifndef QT_NO_IM
 if (focus) {
 QApplication::sendEvent(prev, &out);
 if (that)
 QApplication::sendEvent(that->style(), &out);
 }
 if(focus && QApplicationPrivate::focus_widget == focus) {
+#ifndef QT_NO_IM
 if (focus->testAttribute(Qt::WA_InputMethodEnabled)) {
 QInputContext *qic = focus->inputContext();
 if (qic && focus->testAttribute(Qt::WA_WState_Created)
 && focus->isEnabled())
 qic->setFocusWidget(focus);
 }
+#endif //QT_NO_IM
 QFocusEvent in(QEvent::FocusIn, reason);
 QPointer<QWidget> that = focus;
 QApplication::sendEvent(focus, &in);
 if (that)
 QApplication::sendEvent(that->style(), &in);
 }
 #endif // !QT_NO_WHEELEVENT || !QT_NO_TABLETEVENT
 }
 // walk through parents and check for gestures
-if (d->gestureManager) {
+if (qt_gestureManager) {
-if (receiver->isWidgetType()) {
+switch (e->type()) {
-if (d->gestureManager->filterEvent(static_cast<QWidget *>(receiver), e))
+case QEvent::Paint:
-return true;
+case QEvent::MetaCall:
-} else if (QGesture *gesture = qobject_cast<QGesture *>(receiver)) {
+case QEvent::DeferredDelete:
-if (d->gestureManager->filterEvent(gesture, e))
+case QEvent::DragEnter: case QEvent::DragMove: case QEvent::DragLeave:
-return true;
+case QEvent::Drop: case QEvent::DragResponse:
+case QEvent::ChildAdded: case QEvent::ChildPolished:
+#ifdef QT3_SUPPORT
+case QEvent::ChildInsertedRequest:
+case QEvent::ChildInserted:
+case QEvent::LayoutHint:
+#endif
+case QEvent::ChildRemoved:
+case QEvent::UpdateRequest:
+case QEvent::UpdateLater:
+case QEvent::AccessibilityPrepare:
+case QEvent::LocaleChange:
+case QEvent::Style:
+case QEvent::IconDrag:
+case QEvent::StyleChange:
+case QEvent::AccessibilityHelp:
+case QEvent::AccessibilityDescription:
+case QEvent::GraphicsSceneDragEnter:
+case QEvent::GraphicsSceneDragMove:
+case QEvent::GraphicsSceneDragLeave:
+case QEvent::GraphicsSceneDrop:
+case QEvent::DynamicPropertyChange:
+case QEvent::NetworkReplyUpdated:
+break;
+default:
+if (receiver->isWidgetType()) {
+if (qt_gestureManager->filterEvent(static_cast<QWidget *>(receiver), e))
+return true;
+} else {
+// a special case for events that go to QGesture objects.
+// We pass the object to the gesture manager and it'll figure
+// out if it's QGesture or not.
+if (qt_gestureManager->filterEvent(receiver, e))
+return true;
+}
 }
 }
 // User input and window activation makes tooltips sleep
 while (widget) {
 // first, try to deliver the touch event
 bool acceptTouchEvents = widget->testAttribute(Qt::WA_AcceptTouchEvents);
 touchEvent->setWidget(widget);
 touchEvent->setAccepted(acceptTouchEvents);
+QWeakPointer<QWidget> p = widget;
 res = acceptTouchEvents && d->notify_helper(widget, touchEvent);
 eventAccepted = touchEvent->isAccepted();
-widget->setAttribute(Qt::WA_WState_AcceptedTouchBeginEvent, res && eventAccepted);
+if (p.isNull()) {
+// widget was deleted
+widget = 0;
+} else {
+widget->setAttribute(Qt::WA_WState_AcceptedTouchBeginEvent, res && eventAccepted);
+}
 touchEvent->spont = false;
 if (res && eventAccepted) {
 // the first widget to accept the TouchBegin gets an implicit grab.
 for (int i = 0; i < touchEvent->touchPoints().count(); ++i) {
 const QTouchEvent::TouchPoint &touchPoint = touchEvent->touchPoints().at(i);
 d->widgetForTouchPointId[touchPoint.id()] = widget;
 }
 break;
-} else if (widget->isWindow() || widget->testAttribute(Qt::WA_NoMousePropagation)) {
+} else if (p.isNull() || widget->isWindow() || widget->testAttribute(Qt::WA_NoMousePropagation)) {
 break;
 }
+QPoint offset = widget->pos();
 widget = widget->parentWidget();
-d->updateTouchPointsForWidget(widget, touchEvent);
+touchEvent->setWidget(widget);
+for (int i = 0; i < touchEvent->_touchPoints.size(); ++i) {
+QTouchEvent::TouchPoint &pt = touchEvent->_touchPoints[i];
+QRectF rect = pt.rect();
+rect.moveCenter(offset);
+pt.d->rect = rect;
+pt.d->startPos = pt.startPos() + offset;
+pt.d->lastPos = pt.lastPos() + offset;
+}
 }
 touchEvent->setAccepted(eventAccepted);
 break;
 }
 case QEvent::GestureOverride:
 {
 if (receiver->isWidgetType()) {
 QWidget *w = static_cast<QWidget *>(receiver);
 QGestureEvent *gestureEvent = static_cast<QGestureEvent *>(e);
-QList<QGesture *> allGestures = gestureEvent->allGestures();
+QList<QGesture *> allGestures = gestureEvent->gestures();
 bool eventAccepted = gestureEvent->isAccepted();
 bool wasAccepted = eventAccepted;
 while (w) {
 // send only gestures the widget expects
 QList<QGesture *> gestures;
 QWidgetPrivate *wd = w->d_func();
 for (int i = 0; i < allGestures.size();) {
 QGesture *g = allGestures.at(i);
 Qt::GestureType type = g->gestureType();
-if (wd->gestureContext.contains(type)) {
+QMap<Qt::GestureType, Qt::GestureFlags>::iterator contextit =
+wd->gestureContext.find(type);
+bool deliver = contextit != wd->gestureContext.end() &&
+(g->state() == Qt::GestureStarted || w == receiver ||
+(contextit.value() & Qt::ReceivePartialGestures));
+if (deliver) {
 allGestures.removeAt(i);
 gestures.append(g);
 } else {
 ++i;
 }
 QRectF rect = touchPoint.screenRect();
 const QPointF screenPos = rect.center();
 const QPointF delta = screenPos - screenPos.toPoint();
 rect.moveCenter(widget->mapFromGlobal(screenPos.toPoint()) + delta);
-touchPoint.setRect(rect);
+touchPoint.d->rect = rect;
-touchPoint.setStartPos(widget->mapFromGlobal(touchPoint.startScreenPos().toPoint()) + delta);
+if (touchPoint.state() == Qt::TouchPointPressed) {
-touchPoint.setLastPos(widget->mapFromGlobal(touchPoint.lastScreenPos().toPoint()) + delta);
+touchPoint.d->startPos = widget->mapFromGlobal(touchPoint.startScreenPos().toPoint()) + delta;
+touchPoint.d->lastPos = widget->mapFromGlobal(touchPoint.lastScreenPos().toPoint()) + delta;
+}
 }
 }
 void QApplicationPrivate::initializeMultitouch()
 {
 typedef QPair<Qt::TouchPointStates, QList<QTouchEvent::TouchPoint> > StatesAndTouchPoints;
 QHash<QWidget *, StatesAndTouchPoints> widgetsNeedingEvents;
 for (int i = 0; i < touchPoints.count(); ++i) {
 QTouchEvent::TouchPoint touchPoint = touchPoints.at(i);
+// explicitly detach from the original touch point that we got, so even
+// if the touchpoint structs are reused, we will make a copy that we'll
+// deliver to the user (which might want to store the struct for later use).
+touchPoint.d = touchPoint.d->detach();
 // update state
-QWidget *widget = 0;
+QWeakPointer<QWidget> widget;
 switch (touchPoint.state()) {
 case Qt::TouchPointPressed:
 {
 if (deviceType == QTouchEvent::TouchPad) {
 // on touch-pads, send all touch points to the same widget
 widget = d->widgetForTouchPointId.isEmpty()
-? 0
+? QWeakPointer<QWidget>()
 : d->widgetForTouchPointId.constBegin().value();
 }
 if (!widget) {
 // determine which widget this event will go to
 widget = window;
 }
 if (deviceType == QTouchEvent::TouchScreen) {
 int closestTouchPointId = d->findClosestTouchPointId(touchPoint.screenPos());
-QWidget *closestWidget = d->widgetForTouchPointId.value(closestTouchPointId);
+QWidget *closestWidget = d->widgetForTouchPointId.value(closestTouchPointId).data();
 if (closestWidget
-&& (widget->isAncestorOf(closestWidget) || closestWidget->isAncestorOf(widget))) {
+&& (widget.data()->isAncestorOf(closestWidget) || closestWidget->isAncestorOf(widget.data()))) {
 widget = closestWidget;
 }
 }
 d->widgetForTouchPointId[touchPoint.id()] = widget;
-touchPoint.setStartScreenPos(touchPoint.screenPos());
+touchPoint.d->startScreenPos = touchPoint.screenPos();
-touchPoint.setLastScreenPos(touchPoint.screenPos());
+touchPoint.d->lastScreenPos = touchPoint.screenPos();
-touchPoint.setStartNormalizedPos(touchPoint.normalizedPos());
+touchPoint.d->startNormalizedPos = touchPoint.normalizedPos();
-touchPoint.setLastNormalizedPos(touchPoint.normalizedPos());
+touchPoint.d->lastNormalizedPos = touchPoint.normalizedPos();
 if (touchPoint.pressure() < qreal(0.))
-touchPoint.setPressure(qreal(1.));
+touchPoint.d->pressure = qreal(1.);
 d->appCurrentTouchPoints.insert(touchPoint.id(), touchPoint);
 break;
 }
 case Qt::TouchPointReleased:
 {
 widget = d->widgetForTouchPointId.take(touchPoint.id());
 if (!widget)
 continue;
 QTouchEvent::TouchPoint previousTouchPoint = d->appCurrentTouchPoints.take(touchPoint.id());
-touchPoint.setStartScreenPos(previousTouchPoint.startScreenPos());
+touchPoint.d->startScreenPos = previousTouchPoint.startScreenPos();
-touchPoint.setLastScreenPos(previousTouchPoint.screenPos());
+touchPoint.d->lastScreenPos = previousTouchPoint.screenPos();
-touchPoint.setStartNormalizedPos(previousTouchPoint.startNormalizedPos());
+touchPoint.d->startPos = previousTouchPoint.startPos();
-touchPoint.setLastNormalizedPos(previousTouchPoint.normalizedPos());
+touchPoint.d->lastPos = previousTouchPoint.pos();
+touchPoint.d->startNormalizedPos = previousTouchPoint.startNormalizedPos();
+touchPoint.d->lastNormalizedPos = previousTouchPoint.normalizedPos();
 if (touchPoint.pressure() < qreal(0.))
-touchPoint.setPressure(qreal(0.));
+touchPoint.d->pressure = qreal(0.);
 break;
 }
 default:
 widget = d->widgetForTouchPointId.value(touchPoint.id());
 if (!widget)
 continue;
 Q_ASSERT(d->appCurrentTouchPoints.contains(touchPoint.id()));
 QTouchEvent::TouchPoint previousTouchPoint = d->appCurrentTouchPoints.value(touchPoint.id());
-touchPoint.setStartScreenPos(previousTouchPoint.startScreenPos());
+touchPoint.d->startScreenPos = previousTouchPoint.startScreenPos();
-touchPoint.setLastScreenPos(previousTouchPoint.screenPos());
+touchPoint.d->lastScreenPos = previousTouchPoint.screenPos();
-touchPoint.setStartNormalizedPos(previousTouchPoint.startNormalizedPos());
+touchPoint.d->startPos = previousTouchPoint.startPos();
-touchPoint.setLastNormalizedPos(previousTouchPoint.normalizedPos());
+touchPoint.d->lastPos = previousTouchPoint.pos();
+touchPoint.d->startNormalizedPos = previousTouchPoint.startNormalizedPos();
+touchPoint.d->lastNormalizedPos = previousTouchPoint.normalizedPos();
 if (touchPoint.pressure() < qreal(0.))
-touchPoint.setPressure(qreal(1.));
+touchPoint.d->pressure = qreal(1.);
 d->appCurrentTouchPoints[touchPoint.id()] = touchPoint;
 break;
 }
-Q_ASSERT(widget != 0);
+Q_ASSERT(widget.data() != 0);
 // make the *scene* functions return the same as the *screen* functions
-touchPoint.setSceneRect(touchPoint.screenRect());
+touchPoint.d->sceneRect = touchPoint.screenRect();
-touchPoint.setStartScenePos(touchPoint.startScreenPos());
+touchPoint.d->startScenePos = touchPoint.startScreenPos();
-touchPoint.setLastScenePos(touchPoint.lastScreenPos());
+touchPoint.d->lastScenePos = touchPoint.lastScreenPos();
-StatesAndTouchPoints &maskAndPoints = widgetsNeedingEvents[widget];
+StatesAndTouchPoints &maskAndPoints = widgetsNeedingEvents[widget.data()];
 maskAndPoints.first |= touchPoint.state();
 if (touchPoint.isPrimary())
 maskAndPoints.first |= Qt::TouchPointPrimary;
 maskAndPoints.second.append(touchPoint);
 }
 const QList<QTouchEvent::TouchPoint> &touchPoints)
 {
 QApplicationPrivate::translateRawTouchEvent(window, deviceType, touchPoints);
 }
-/*!
-\since 4.6
-Registers the given \a recognizer in the gesture framework and returns a gesture ID
-for it.
-The application takes ownership of the \a recognizer and returns the gesture type
-ID associated with it. For gesture recognizers which handle custom QGesture
-objects (i.e., those which return Qt::CustomGesture in a QGesture::gestureType()
-function) the return value is a gesture ID between Qt::CustomGesture and
-Qt::LastGestureType, inclusive.
-\sa unregisterGestureRecognizer(), QGestureRecognizer::createGesture(), QGesture
-*/
-Qt::GestureType QApplication::registerGestureRecognizer(QGestureRecognizer *recognizer)
-{
-return QGestureManager::instance()->registerGestureRecognizer(recognizer);
-}
-/*!
-\since 4.6
-Unregisters all gesture recognizers of the specified \a type.
-\sa registerGestureRecognizer()
-*/
-void QApplication::unregisterGestureRecognizer(Qt::GestureType type)
-{
-QGestureManager::instance()->unregisterGestureRecognizer(type);
-}
 QT_END_NAMESPACE
 #include "moc_qapplication.cpp"

changeset 3	41300fa6a67c
parent 0	1918ee327afb
child 4	3b1da2848fc7
child 7	f7bc934e204c
child 18	2f34d5167611