/****************************************************************************

**

** 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 "qevent.h"

#include "qcursor.h"

#include "qapplication.h"

#include "private/qapplication_p.h"

#include "private/qkeysequence_p.h"

#include "qwidget.h"

#include "qgraphicsview.h"

#include "qdebug.h"

#include "qmime.h"

#include "qdnd_p.h"

#include "qevent_p.h"

#include "qgesture.h"

#include "qgesture_p.h"

QT_BEGIN_NAMESPACE

/*!

    \class QInputEvent

    \ingroup events

    \brief The QInputEvent class is the base class for events that

    describe user input.

*/

/*!

  \internal

*/

QInputEvent::QInputEvent(Type type, Qt::KeyboardModifiers modifiers)

    : QEvent(type), modState(modifiers)

{}

/*!

  \internal

*/

QInputEvent::~QInputEvent()

{

}

/*!

    \fn Qt::KeyboardModifiers QInputEvent::modifiers() const

    Returns the keyboard modifier flags that existed immediately

    before the event occurred.

    \sa QApplication::keyboardModifiers()

*/

/*! \fn void QInputEvent::setModifiers(Qt::KeyboardModifiers modifiers)

    \internal

    Sets the keyboard modifiers flags for this event.

*/

/*!

    \class QMouseEvent

    \ingroup events

    \brief The QMouseEvent class contains parameters that describe a mouse event.

    Mouse events occur when a mouse button is pressed or released

    inside a widget, or when the mouse cursor is moved.

    Mouse move events will occur only when a mouse button is pressed

    down, unless mouse tracking has been enabled with

    QWidget::setMouseTracking().

    Qt automatically grabs the mouse when a mouse button is pressed

    inside a widget; the widget will continue to receive mouse events

    until the last mouse button is released.

    A mouse event contains a special accept flag that indicates

    whether the receiver wants the event. You should call ignore() if

    the mouse event is not handled by your widget. A mouse event is

    propagated up the parent widget chain until a widget accepts it

    with accept(), or an event filter consumes it.

    \note If a mouse event is propagated to a \l{QWidget}{widget} for

    which Qt::WA_NoMousePropagation has been set, that mouse event

    will not be propagated further up the parent widget chain.

    The state of the keyboard modifier keys can be found by calling the

    \l{QInputEvent::modifiers()}{modifiers()} function, inherited from

    QInputEvent.

    The functions pos(), x(), and y() give the cursor position

    relative to the widget that receives the mouse event. If you

    move the widget as a result of the mouse event, use the global

    position returned by globalPos() to avoid a shaking motion.

    The QWidget::setEnabled() function can be used to enable or

    disable mouse and keyboard events for a widget.

    Reimplement the QWidget event handlers, QWidget::mousePressEvent(),

    QWidget::mouseReleaseEvent(), QWidget::mouseDoubleClickEvent(),

    and QWidget::mouseMoveEvent() to receive mouse events in your own

    widgets.

    \sa QWidget::setMouseTracking() QWidget::grabMouse()

    QCursor::pos()

*/

/*!

    Constructs a mouse event object.

    The \a type parameter must be one of QEvent::MouseButtonPress,

    QEvent::MouseButtonRelease, QEvent::MouseButtonDblClick,

    or QEvent::MouseMove.

    The \a position is the mouse cursor's position relative to the

    receiving widget.

    The \a button that caused the event is given as a value from

    the Qt::MouseButton enum. If the event \a type is

    \l MouseMove, the appropriate button for this event is Qt::NoButton.

    The mouse and keyboard states at the time of the event are specified by

    \a buttons and \a modifiers.

    The globalPos() is initialized to QCursor::pos(), which may not

    be appropriate. Use the other constructor to specify the global

    position explicitly.

*/

QMouseEvent::QMouseEvent(Type type, const QPoint &position, Qt::MouseButton button,

                         Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers)

    : QInputEvent(type, modifiers), p(position), b(button), mouseState(buttons)

{

    g = QCursor::pos();

}

/*!

    \internal

*/

QMouseEvent::~QMouseEvent()

{

}

#ifdef QT3_SUPPORT

/*!

    Use QMouseEvent(\a type, \a pos, \a button, \c buttons, \c

    modifiers) instead, where \c buttons is \a state &

    Qt::MouseButtonMask and \c modifiers is \a state &

    Qt::KeyButtonMask.

*/

QMouseEvent::QMouseEvent(Type type, const QPoint &pos, Qt::ButtonState button, int state)

    : QInputEvent(type), p(pos), b((Qt::MouseButton)button)

{

    g = QCursor::pos();

    mouseState = Qt::MouseButtons((state ^ b) & Qt::MouseButtonMask);

    modState = Qt::KeyboardModifiers(state & (int)Qt::KeyButtonMask);

}

/*!

    Use QMouseEvent(\a type, \a pos, \a globalPos, \a button,

    \c buttons, \c modifiers) instead, where

    \c buttons is \a state & Qt::MouseButtonMask and

    \c modifiers is \a state & Qt::KeyButtonMask.

*/

QMouseEvent::QMouseEvent(Type type, const QPoint &pos, const QPoint &globalPos,

                         Qt::ButtonState button, int state)

    : QInputEvent(type), p(pos), g(globalPos), b((Qt::MouseButton)button)

{

    mouseState = Qt::MouseButtons((state ^ b) & Qt::MouseButtonMask);

    modState = Qt::KeyboardModifiers(state & (int)Qt::KeyButtonMask);

}

#endif

/*!

    Constructs a mouse event object.

    The \a type parameter must be QEvent::MouseButtonPress,

    QEvent::MouseButtonRelease, QEvent::MouseButtonDblClick,

    or QEvent::MouseMove.

    The \a pos is the mouse cursor's position relative to the

    receiving widget. The cursor's position in global coordinates is

    specified by \a globalPos.  The \a button that caused the event is

    given as a value from the \l Qt::MouseButton enum. If the event \a

    type is \l MouseMove, the appropriate button for this event is

    Qt::NoButton. \a buttons is the state of all buttons at the

    time of the event, \a modifiers the state of all keyboard

    modifiers.

*/

QMouseEvent::QMouseEvent(Type type, const QPoint &pos, const QPoint &globalPos,

                         Qt::MouseButton button, Qt::MouseButtons buttons,

                         Qt::KeyboardModifiers modifiers)

    : QInputEvent(type, modifiers), p(pos), g(globalPos), b(button), mouseState(buttons)

{}

/*!

    \internal

*/

QMouseEvent *QMouseEvent::createExtendedMouseEvent(Type type, const QPointF &pos,

                                                   const QPoint &globalPos, Qt::MouseButton button,

                                                   Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers)

{

    return new QMouseEventEx(type, pos, globalPos, button, buttons, modifiers);

}

/*!

    \fn bool QMouseEvent::hasExtendedInfo() const

    \internal

*/

/*!

    \since 4.4

    Returns the position of the mouse cursor as a QPointF, relative to the

    widget that received the event.

    If you move the widget as a result of the mouse event, use the

    global position returned by globalPos() to avoid a shaking

    motion.

    \sa x() y() pos() globalPos()

*/

QPointF QMouseEvent::posF() const

{

    return hasExtendedInfo() ? reinterpret_cast<const QMouseEventEx *>(this)->posF : QPointF(pos());

}

/*!

    \internal

*/

QMouseEventEx::QMouseEventEx(Type type, const QPointF &pos, const QPoint &globalPos,

                             Qt::MouseButton button, Qt::MouseButtons buttons,

                             Qt::KeyboardModifiers modifiers)

    : QMouseEvent(type, pos.toPoint(), globalPos, button, buttons, modifiers), posF(pos)

{

    d = reinterpret_cast<QEventPrivate *>(this);

}

/*!

    \internal

*/

QMouseEventEx::~QMouseEventEx()

{

}

/*!

    \fn const QPoint &QMouseEvent::pos() const

    Returns the position of the mouse cursor, relative to the widget

    that received the event.

    If you move the widget as a result of the mouse event, use the

    global position returned by globalPos() to avoid a shaking

    motion.

    \sa x() y() globalPos()

*/

/*!

    \fn const QPoint &QMouseEvent::globalPos() const

    Returns the global position of the mouse cursor \e{at the time

    of the event}. This is important on asynchronous window systems

    like X11. Whenever you move your widgets around in response to

    mouse events, globalPos() may differ a lot from the current

    pointer position QCursor::pos(), and from

    QWidget::mapToGlobal(pos()).

    \sa globalX() globalY()

*/

/*!

    \fn int QMouseEvent::x() const

    Returns the x position of the mouse cursor, relative to the

    widget that received the event.

    \sa y() pos()

*/

/*!

    \fn int QMouseEvent::y() const

    Returns the y position of the mouse cursor, relative to the

    widget that received the event.

    \sa x() pos()

*/

/*!

    \fn int QMouseEvent::globalX() const

    Returns the global x position of the mouse cursor at the time of

    the event.

    \sa globalY() globalPos()

*/

/*!

    \fn int QMouseEvent::globalY() const

    Returns the global y position of the mouse cursor at the time of

    the event.

    \sa globalX() globalPos()

*/

/*!

    \fn Qt::MouseButton QMouseEvent::button() const

    Returns the button that caused the event.

    Note that the returned value is always Qt::NoButton for mouse

    move events.

    \sa buttons() Qt::MouseButton

*/

/*!

    \fn Qt::MouseButton QMouseEvent::buttons() const

    Returns the button state when the event was generated. The button

    state is a combination of Qt::LeftButton, Qt::RightButton,

    Qt::MidButton using the OR operator. For mouse move events,

    this is all buttons that are pressed down. For mouse press and

    double click events this includes the button that caused the

    event. For mouse release events this excludes the button that

    caused the event.

    \sa button() Qt::MouseButton

*/

/*!

    \fn Qt::ButtonState QMouseEvent::state() const

    Returns the button state immediately before the event was

    generated. The button state is a combination of mouse buttons

    (see Qt::ButtonState) and keyboard modifiers (Qt::MouseButtons).

    Use buttons() and/or modifiers() instead. Be aware that buttons()

    return the state immediately \e after the event was generated.

*/

/*!

    \fn Qt::ButtonState QMouseEvent::stateAfter() const

    Returns the button state immediately after the event was

    generated. The button state is a combination of mouse buttons

    (see Qt::ButtonState) and keyboard modifiers (Qt::MouseButtons).

    Use buttons() and/or modifiers() instead.

*/

/*!

    \class QHoverEvent

    \ingroup events

    \brief The QHoverEvent class contains parameters that describe a mouse event.

    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.

*/

/*!

    \fn const QPoint &QHoverEvent::pos() const

    Returns the position of the mouse cursor, relative to the widget

    that received the event.

    On QEvent::HoverLeave events, this position will always be

    QPoint(-1, -1).

    \sa oldPos()

*/

/*!

    \fn const QPoint &QHoverEvent::oldPos() const

    Returns the previous position of the mouse cursor, relative to the widget

    that received the event. If there is no previous position, oldPos() will

    return the same position as pos().

    On QEvent::HoverEnter events, this position will always be

    QPoint(-1, -1).

    \sa pos()

*/

/*!

    Constructs a hover event object.

    The \a type parameter must be QEvent::HoverEnter,

    QEvent::HoverLeave, or QEvent::HoverMove.

    The \a pos is the current mouse cursor's position relative to the

    receiving widget, while \a oldPos is the previous mouse cursor's

    position relative to the receiving widget.

*/

QHoverEvent::QHoverEvent(Type type, const QPoint &pos, const QPoint &oldPos)

    : QEvent(type), p(pos), op(oldPos)

{

}

/*!

    \internal

*/

QHoverEvent::~QHoverEvent()

{

}

/*!

    \class QWheelEvent

    \brief The QWheelEvent class contains parameters that describe a wheel event.

    \ingroup events

    Wheel events are sent to the widget under the mouse cursor, but

    if that widget does not handle the event they are sent to the

    focus widget. The rotation distance is provided by delta().

    The functions pos() and globalPos() return the mouse cursor's

    location at the time of the event.

    A wheel event contains a special accept flag that indicates

    whether the receiver wants the event. You should call ignore() if

    you do not handle the wheel event; this ensures that it will be

    sent to the parent widget.

    The QWidget::setEnabled() function can be used to enable or

    disable mouse and keyboard events for a widget.

    The event handler QWidget::wheelEvent() receives wheel events.

    \sa QMouseEvent QWidget::grabMouse()

*/

/*!

    \fn Qt::MouseButtons QWheelEvent::buttons() const

    Returns the mouse state when the event occurred.

*/

/*!

    \fn Qt::Orientation QWheelEvent::orientation() const

    Returns the wheel's orientation.

*/

/*!

    Constructs a wheel event object.

    The position, \a pos, is the location of the mouse cursor within

    the widget. The globalPos() is initialized to QCursor::pos()

    which is usually, but not always, correct.

    Use the other constructor if you need to specify the global

    position explicitly.

    The \a buttons describe the state of the mouse buttons at the time

    of the event, \a delta contains the rotation distance,

    \a modifiers holds the keyboard modifier flags at the time of the

    event, and \a orient holds the wheel's orientation.

    \sa pos() delta() state()

*/

#ifndef QT_NO_WHEELEVENT

QWheelEvent::QWheelEvent(const QPoint &pos, int delta,

                         Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers,

                         Qt::Orientation orient)

    : QInputEvent(Wheel, modifiers), p(pos), d(delta), mouseState(buttons), o(orient)

{

    g = QCursor::pos();

}

/*!

  \internal

*/

QWheelEvent::~QWheelEvent()

{

}

#ifdef QT3_SUPPORT

/*!

    Use one of the other constructors instead.

*/

QWheelEvent::QWheelEvent(const QPoint &pos, int delta, int state, Qt::Orientation orient)

    : QInputEvent(Wheel), p(pos), d(delta), o(orient)

{

    g = QCursor::pos();