MCL/sf/mw/qt: comparison src/gui/kernel/qevent.cpp

equal deleted inserted replaced

-:56cd8111b7f7
+:41300fa6a67c
 Mouse events occur when a mouse cursor is moved into, out of, or within a
 widget, and if the widget has the Qt::WA_Hover attribute.
 The function pos() gives the current cursor position, while oldPos() gives
 the old mouse position.
+There are a few similarities between the events QEvent::HoverEnter
+and QEvent::HoverLeave, and the events QEvent::Enter and QEvent::Leave.
+However, they are slightly different because we do an update() in the event
+handler of HoverEnter and HoverLeave.
+QEvent::HoverMove is also slightly different from QEvent::MouseMove. Let us
+consider a top-level window A containing a child B which in turn contains a
+child C (all with mouse tracking enabled):
+\image hoverevents.png
+Now, if you move the cursor from the top to the bottom in the middle of A,
+you will get the following QEvent::MouseMove events:
+\list 1
+\o A::MouseMove
+\o B::MouseMove
+\o C::MouseMove
+\endlist
+You will get the same events for QEvent::HoverMove, except that the event
+always propagates to the top-level regardless whether the event is accepted
+or not. It will only stop propagating with the Qt::WA_NoMousePropagation
+attribute.
+In this case the events will occur in the following way:
+\list 1
+\o A::HoverMove
+\o A::HoverMove, B::HoverMove
+\o A::HoverMove, B::HoverMove, C::HoverMove
+\endlist
 */
 /*!
 \fn const QPoint &QHoverEvent::pos() const
 */
 /*!
 \class QFileOpenEvent
 \brief The QFileOpenEvent class provides an event that will be
-sent when there is a request to open a file.
+sent when there is a request to open a file or a URL.
 \ingroup events
 File open events will be sent to the QApplication::instance()
-when the operating system requests that a file be opened. This is
+when the operating system requests that a file or URL should be opened.
-a high-level event that can be caused by different user actions
+This is a high-level event that can be caused by different user actions
 depending on the user's desktop environment; for example, double
 clicking on an file icon in the Finder on Mac OS X.
 This event is only used to notify the application of a request.
 It may be safely ignored.
-\note This class is currently supported for Mac Os X only.
+\note This class is currently supported for Mac OS X only.
 */
 /*!
 \internal
 Constructs a file open event for the given \a file.
 */
 QFileOpenEvent::QFileOpenEvent(const QString &file)
 : QEvent(FileOpen), f(file)
-{}
+{
+d = reinterpret_cast<QEventPrivate *>(new QFileOpenEventPrivate(QUrl::fromLocalFile(file)));
+}
+/*!
+\internal
+Constructs a file open event for the given \a url.
+*/
+QFileOpenEvent::QFileOpenEvent(const QUrl &url)
+: QEvent(FileOpen)
+{
+d = reinterpret_cast<QEventPrivate *>(new QFileOpenEventPrivate(url));
+f = url.toLocalFile();
+}
 /*! \internal
 */
 QFileOpenEvent::~QFileOpenEvent()
 {
+delete reinterpret_cast<QFileOpenEventPrivate *>(d);
 }
 /*!
 \fn QString QFileOpenEvent::file() const
 Returns the file that is being opened.
 */
+/*!
+\fn QUrl QFileOpenEvent::url() const
+Returns the url that is being opened.
+\since 4.6
+*/
+QUrl QFileOpenEvent::url() const
+{
+return reinterpret_cast<const QFileOpenEventPrivate *>(d)->url;
+}
 #ifndef QT_NO_TOOLBAR
 /*!
 \internal
 \class QToolBarChangeEvent
 \ingroup gestures
 \brief The QGestureEvent class provides the description of triggered gestures.
 The QGestureEvent class contains a list of gestures, which can be obtained using the
-allGestures() function.
+gestures() function.
 The gestures are either active or canceled. A list of those that are currently being
 executed can be obtained using the activeGestures() function. A list of those which
 were previously active and have been canceled can be accessed using the
 canceledGestures() function. A gesture might be canceled if the current window loses
 focus, for example, or because of a timeout, or for other reasons.
 If the event handler does not accept the event by calling the generic
-QEvent::accept() function, all individual QGesture object that were not accepted
+QEvent::accept() function, all individual QGesture object that were not
-will be propagated up the parent widget chain until a widget accepts them
+accepted and in the Qt::GestureStarted state will be propagated up the
-individually, by calling QGestureEvent::accept() for each of them, or an event
+parent widget chain until a widget accepts them individually, by calling
-filter consumes the event.
+QGestureEvent::accept() for each of them, or an event filter consumes the
+event.
 \sa QGesture, QGestureRecognizer,
 QWidget::grabGesture(), QGraphicsObject::grabGesture()
 */
 }
 /*!
 Returns all gestures that are delivered in the event.
 */
-QList<QGesture *> QGestureEvent::allGestures() const
+QList<QGesture *> QGestureEvent::gestures() const
 {
 return d_func()->gestures;
 }
 /*!
 /*!
 Returns a list of active (not canceled) gestures.
 */
 QList<QGesture *> QGestureEvent::activeGestures() const
 {
-return d_func()->gestures;
+QList<QGesture *> gestures;
+foreach (QGesture *gesture, d_func()->gestures) {
+if (gesture->state() != Qt::GestureCanceled)
+gestures.append(gesture);
+}
+return gestures;
 }
 /*!
 Returns a list of canceled gestures.
 */
 QList<QGesture *> QGestureEvent::canceledGestures() const
 {
-return d_func()->gestures;
+QList<QGesture *> gestures;
+foreach (QGesture *gesture, d_func()->gestures) {
+if (gesture->state() == Qt::GestureCanceled)
+gestures.append(gesture);
+}
+return gestures;
 }
 /*!
 Sets the accept flag of the given \a gesture object to the specified \a value.
 \l{QGestureEvent::accept()}{accept(gesture)}, and cleared with
 \l{QGestureEvent::ignore()}{ignore(gesture)}.
 */
 void QGestureEvent::setAccepted(QGesture *gesture, bool value)
 {
-setAccepted(false);
 if (gesture)
-d_func()->accepted[gesture->gestureType()] = value;
+setAccepted(gesture->gestureType(), value);
 }
 /*!
 Sets the accept flag of the given \a gesture object, the equivalent of calling
 \l{QGestureEvent::setAccepted()}{setAccepted(gesture, true)}.
 \sa QGestureEvent::ignore()
 */
 void QGestureEvent::accept(QGesture *gesture)
 {
-setAccepted(gesture, true);
+if (gesture)
+setAccepted(gesture->gestureType(), true);
 }
 /*!
 Clears the accept flag parameter of the given \a gesture object, the equivalent
 of calling \l{QGestureEvent::setAccepted()}{setAccepted(gesture, false)}.
 \sa QGestureEvent::accept()
 */
 void QGestureEvent::ignore(QGesture *gesture)
 {
-setAccepted(gesture, false);
+if (gesture)
+setAccepted(gesture->gestureType(), false);
 }
 /*!
 Returns true if the \a gesture is accepted; otherwise returns false.
 */
 bool QGestureEvent::isAccepted(QGesture *gesture) const
 {
-return gesture ? d_func()->accepted.value(gesture->gestureType(), true) : false;
+return gesture ? isAccepted(gesture->gestureType()) : false;
 }
 /*!
-Sets the widget for this event.
+Sets the accept flag of the given \a gestureType object to the specified
+\a value.
+Setting the accept flag indicates that the event receiver wants to receive
+gestures of the specified type, \a gestureType. Unwanted gestures may be
+propagated to the parent widget.
+By default, gestures in events of type QEvent::Gesture are accepted, and
+gestures in QEvent::GestureOverride events are ignored.
+For convenience, the accept flag can also be set with
+\l{QGestureEvent::accept()}{accept(gestureType)}, and cleared with
+\l{QGestureEvent::ignore()}{ignore(gestureType)}.
+*/
+void QGestureEvent::setAccepted(Qt::GestureType gestureType, bool value)
+{
+setAccepted(false);
+d_func()->accepted[gestureType] = value;
+}
+/*!
+Sets the accept flag of the given \a gestureType, the equivalent of calling
+\l{QGestureEvent::setAccepted()}{setAccepted(gestureType, true)}.
+Setting the accept flag indicates that the event receiver wants the
+gesture. Unwanted gestures may be propagated to the parent widget.
+\sa QGestureEvent::ignore()
+*/
+void QGestureEvent::accept(Qt::GestureType gestureType)
+{
+setAccepted(gestureType, true);
+}
+/*!
+Clears the accept flag parameter of the given \a gestureType, the equivalent
+of calling \l{QGestureEvent::setAccepted()}{setAccepted(gesture, false)}.
+Clearing the accept flag indicates that the event receiver does not
+want the gesture. Unwanted gestures may be propgated to the parent widget.
+\sa QGestureEvent::accept()
+*/
+void QGestureEvent::ignore(Qt::GestureType gestureType)
+{
+setAccepted(gestureType, false);
+}
+/*!
+Returns true if the gesture of type \a gestureType is accepted; otherwise
+returns false.
+*/
+bool QGestureEvent::isAccepted(Qt::GestureType gestureType) const
+{
+return d_func()->accepted.value(gestureType, true);
+}
+/*!
+\internal
+Sets the widget for this event to the \a widget specified.
 */
 void QGestureEvent::setWidget(QWidget *widget)
 {
 d_func()->widget = widget;
 }
 QWidget *QGestureEvent::widget() const
 {
 return d_func()->widget;
 }
-/*!
+#ifndef QT_NO_GRAPHICSVIEW
-Returns the scene-local coordinates if the \a gesturePoint is inside a graphics view.
+/*!
+Returns the scene-local coordinates if the \a gesturePoint is inside a
+graphics view.
+This functional might be useful when the gesture event is delivered to a
+QGraphicsObject to translate a point in screen coordinates to scene-local
+coordinates.
 \sa QPointF::isNull().
 */
-QPointF QGestureEvent::mapToScene(const QPointF &gesturePoint) const
+QPointF QGestureEvent::mapToGraphicsScene(const QPointF &gesturePoint) const
 {
 QWidget *w = widget();
 if (w) // we get the viewport as widget, not the graphics view
 w = w->parentWidget();
 QGraphicsView *view = qobject_cast<QGraphicsView*>(w);
 if (view) {
 return view->mapToScene(view->mapFromGlobal(gesturePoint.toPoint()));
 }
 return QPointF();
 }
+#endif //QT_NO_GRAPHICSVIEW
 /*!
 \internal
 */
 QGestureEventPrivate *QGestureEvent::d_func()

changeset 3	41300fa6a67c
parent 0	1918ee327afb
child 4	3b1da2848fc7