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

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtDeclarative 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/qdeclarativemousearea_p.h"

#include "private/qdeclarativemousearea_p_p.h"

#include "private/qdeclarativeevents_p_p.h"

#include <QGraphicsSceneMouseEvent>

QT_BEGIN_NAMESPACE

static const int PressAndHoldDelay = 800;

QDeclarativeDrag::QDeclarativeDrag(QObject *parent)

: QObject(parent), _target(0), _axis(XandYAxis), _xmin(0), _xmax(0), _ymin(0), _ymax(0),

_active(false)

{

}

QDeclarativeDrag::~QDeclarativeDrag()

{

}

QGraphicsObject *QDeclarativeDrag::target() const

{

    return _target;

}

void QDeclarativeDrag::setTarget(QGraphicsObject *t)

{

    if (_target == t)

        return;

    _target = t;

    emit targetChanged();

}

void QDeclarativeDrag::resetTarget()

{

    if (!_target)

        return;

    _target = 0;

    emit targetChanged();

}

QDeclarativeDrag::Axis QDeclarativeDrag::axis() const

{

    return _axis;

}

void QDeclarativeDrag::setAxis(QDeclarativeDrag::Axis a)

{

    if (_axis == a)

        return;

    _axis = a;

    emit axisChanged();

}

qreal QDeclarativeDrag::xmin() const

{

    return _xmin;

}

void QDeclarativeDrag::setXmin(qreal m)

{

    if (_xmin == m)

        return;

    _xmin = m;

    emit minimumXChanged();

}

qreal QDeclarativeDrag::xmax() const

{

    return _xmax;

}

void QDeclarativeDrag::setXmax(qreal m)

{

    if (_xmax == m)

        return;

    _xmax = m;

    emit maximumXChanged();

}

qreal QDeclarativeDrag::ymin() const

{

    return _ymin;

}

void QDeclarativeDrag::setYmin(qreal m)

{

    if (_ymin == m)

        return;

    _ymin = m;

    emit minimumYChanged();

}

qreal QDeclarativeDrag::ymax() const

{

    return _ymax;

}

void QDeclarativeDrag::setYmax(qreal m)

{

    if (_ymax == m)

        return;

    _ymax = m;

    emit maximumYChanged();

}

bool QDeclarativeDrag::active() const

{

    return _active;

}

void QDeclarativeDrag::setActive(bool drag)

{

    if (_active == drag)

        return;

    _active = drag;

    emit activeChanged();

}

QDeclarativeMouseAreaPrivate::~QDeclarativeMouseAreaPrivate()

{

    delete drag;

}

/*!

    \qmlclass MouseArea QDeclarativeMouseArea

    \since 4.7

    \brief The MouseArea item enables simple mouse handling.

    \inherits Item

    A MouseArea is typically used in conjunction with a visible item,

    where the MouseArea effectively 'proxies' mouse handling for that

    item. For example, we can put a MouseArea in a Rectangle that changes

    the Rectangle color to red when clicked:

    \snippet doc/src/snippets/declarative/mouseregion.qml 0

    Many MouseArea signals pass a \l {MouseEvent}{mouse} parameter that contains

    additional information about the mouse event, such as the position, button,

    and any key modifiers.

    Below we have the previous

    example extended so as to give a different color when you right click.

    \snippet doc/src/snippets/declarative/mouseregion.qml 1

    For basic key handling, see the \l {Keys}{Keys attached property}.

    MouseArea is an invisible item: it is never painted.

    \sa MouseEvent

*/

/*!

    \qmlsignal MouseArea::onEntered()

    This handler is called when the mouse enters the mouse area.

    By default the onEntered handler is only called while a button is

    pressed. Setting hoverEnabled to true enables handling of

    onEntered when no mouse button is pressed.

    \sa hoverEnabled

*/

/*!

    \qmlsignal MouseArea::onExited()

    This handler is called when the mouse exists the mouse area.

    By default the onExited handler is only called while a button is

    pressed. Setting hoverEnabled to true enables handling of

    onExited when no mouse button is pressed.

    \sa hoverEnabled

*/

/*!

    \qmlsignal MouseArea::onPositionChanged(MouseEvent mouse)

    This handler is called when the mouse position changes.

    The \l {MouseEvent}{mouse} parameter provides information about the mouse, including the x and y

    position, and any buttons currently pressed.

    The \e accepted property of the MouseEvent parameter is ignored in this handler.

    By default the onPositionChanged handler is only called while a button is

    pressed.  Setting hoverEnabled to true enables handling of

    onPositionChanged when no mouse button is pressed.

*/

/*!

    \qmlsignal MouseArea::onClicked(mouse)

    This handler is called when there is a click. A click is defined as a press followed by a release,

    both inside the MouseArea (pressing, moving outside the MouseArea, and then moving back inside and

    releasing is also considered a click).

    The \l {MouseEvent}{mouse} parameter provides information about the click, including the x and y

    position of the release of the click, and whether the click wasHeld.

    The \e accepted property of the MouseEvent parameter is ignored in this handler.

*/

/*!

    \qmlsignal MouseArea::onPressed(mouse)

    This handler is called when there is a press.

    The \l {MouseEvent}{mouse} parameter provides information about the press, including the x and y

    position and which button was pressed.

    The \e accepted property of the MouseEvent parameter determines whether this MouseArea

    will handle the press and all future mouse events until release.  The default is to accept

    the event and not allow other MouseArea beneath this one to handle the event.  If \e accepted

    is set to false, no further events will be sent to this MouseArea until the button is next

    pressed.

*/

/*!

    \qmlsignal MouseArea::onReleased(mouse)

    This handler is called when there is a release.

    The \l {MouseEvent}{mouse} parameter provides information about the click, including the x and y

    position of the release of the click, and whether the click wasHeld.

    The \e accepted property of the MouseEvent parameter is ignored in this handler.

*/

/*!

    \qmlsignal MouseArea::onPressAndHold(mouse)

    This handler is called when there is a long press (currently 800ms).

    The \l {MouseEvent}{mouse} parameter provides information about the press, including the x and y

    position of the press, and which button is pressed.

    The \e accepted property of the MouseEvent parameter is ignored in this handler.

*/

/*!

    \qmlsignal MouseArea::onDoubleClicked(mouse)

    This handler is called when there is a double-click (a press followed by a release followed by a press).

    The \l {MouseEvent}{mouse} parameter provides information about the click, including the x and y

    position of the release of the click, and whether the click wasHeld.

    The \e accepted property of the MouseEvent parameter is ignored in this handler.

*/

/*!

    \qmlsignal MouseArea::onCanceled()

    This handler is called when the mouse events are canceled, either because the event was not accepted or

    another element stole the mouse event handling. This signal is for advanced users, it's useful in case there

    is more than one mouse areas handling input, or when there is a mouse area inside a flickable. In the latter

    case, if you do some logic on pressed and then start dragging, the flickable will steal the mouse handling

    from the mouse area. In these cases, to reset the logic when there is no mouse handling anymore, you should

    use onCanceled, in addition to onReleased.

*/

/*!

    \internal

    \class QDeclarativeMouseArea

    \brief The QDeclarativeMouseArea class provides a simple mouse handling abstraction for use within Qml.

    All QDeclarativeItem derived classes can do mouse handling but the QDeclarativeMouseArea class exposes mouse

    handling data as properties and tracks flicking and dragging of the mouse.

    A QDeclarativeMouseArea object can be instantiated in Qml using the tag \l MouseArea.

 */

QDeclarativeMouseArea::QDeclarativeMouseArea(QDeclarativeItem *parent)

  : QDeclarativeItem(*(new QDeclarativeMouseAreaPrivate), parent)

{

    Q_D(QDeclarativeMouseArea);

    d->init();

}

QDeclarativeMouseArea::~QDeclarativeMouseArea()

{

}

/*!

    \qmlproperty real MouseArea::mouseX

    \qmlproperty real MouseArea::mouseY

    These properties hold the coordinates of the mouse.

    If the hoverEnabled property is false then these properties will only be valid

    while a button is pressed, and will remain valid as long as the button is held

    even if the mouse is moved outside the area.

    If hoverEnabled is true then these properties will be valid:

    \list

        \i when no button is pressed, but the mouse is within the MouseArea (containsMouse is true).

        \i if a button is pressed and held, even if it has since moved out of the area.

    \endlist

    The coordinates are relative to the MouseArea.

*/

qreal QDeclarativeMouseArea::mouseX() const

{

    Q_D(const QDeclarativeMouseArea);

    return d->lastPos.x();

}

qreal QDeclarativeMouseArea::mouseY() const

{

    Q_D(const QDeclarativeMouseArea);

    return d->lastPos.y();

}

/*!

    \qmlproperty bool MouseArea::enabled

    This property holds whether the item accepts mouse events.

*/

bool QDeclarativeMouseArea::isEnabled() const

{

    Q_D(const QDeclarativeMouseArea);

    return d->absorb;

}

void QDeclarativeMouseArea::setEnabled(bool a)

{

    Q_D(QDeclarativeMouseArea);

    if (a != d->absorb) {

        d->absorb = a;

        emit enabledChanged();

    }

}

/*!

    \qmlproperty MouseButtons MouseArea::pressedButtons

    This property holds the mouse buttons currently pressed.

    It contains a bitwise combination of:

    \list

    \o Qt.LeftButton

    \o Qt.RightButton

    \o Qt.MiddleButton

    \endlist

    The code below displays "right" when the right mouse buttons is pressed:

    \code

    Text {

        text: mr.pressedButtons & Qt.RightButton ? "right" : ""

        horizontalAlignment: Text.AlignHCenter

        verticalAlignment: Text.AlignVCenter

        MouseArea {

            id: mr

            acceptedButtons: Qt.LeftButton | Qt.RightButton

            anchors.fill: parent

        }

    }

    \endcode

    \sa acceptedButtons

*/

Qt::MouseButtons QDeclarativeMouseArea::pressedButtons() const

{

    Q_D(const QDeclarativeMouseArea);

    return d->lastButtons;

}

void QDeclarativeMouseArea::mousePressEvent(QGraphicsSceneMouseEvent *event)

{

    Q_D(QDeclarativeMouseArea);

    d->moved = false;

    if (!d->absorb)

        QDeclarativeItem::mousePressEvent(event);

    else {

        d->longPress = false;

        d->saveEvent(event);

        if (d->drag) {

            d->dragX = drag()->axis() & QDeclarativeDrag::XAxis;

            d->dragY = drag()->axis() & QDeclarativeDrag::YAxis;

        }

        if (d->drag)

            d->drag->setActive(false);

        setHovered(true);

        d->startScene = event->scenePos();

        // we should only start timer if pressAndHold is connected to.

        if (d->isConnected("pressAndHold(QDeclarativeMouseEvent*)"))

            d->pressAndHoldTimer.start(PressAndHoldDelay, this);

        setKeepMouseGrab(false);

        event->setAccepted(setPressed(true));

    }

}

void QDeclarativeMouseArea::mouseMoveEvent(QGraphicsSceneMouseEvent *event)

{

    Q_D(QDeclarativeMouseArea);

    if (!d->absorb) {

        QDeclarativeItem::mouseMoveEvent(event);

        return;

    }

    d->saveEvent(event);

    // ### we should skip this if these signals aren't used

    // ### can GV handle this for us?

    bool contains = boundingRect().contains(d->lastPos);

    if (d->hovered && !contains)

        setHovered(false);

    else if (!d->hovered && contains)

        setHovered(true);

    if (d->drag && d->drag->target()) {

        if (!d->moved) {

            d->startX = drag()->target()->x();

            d->startY = drag()->target()->y();

        }

        QPointF startLocalPos;

        QPointF curLocalPos;

        if (drag()->target()->parent()) {

            startLocalPos = drag()->target()->parentItem()->mapFromScene(d->startScene);

            curLocalPos = drag()->target()->parentItem()->mapFromScene(event->scenePos());

        } else {

            startLocalPos = d->startScene;

            curLocalPos = event->scenePos();

        }

        const int dragThreshold = QApplication::startDragDistance();

        qreal dx = qAbs(curLocalPos.x() - startLocalPos.x());

        qreal dy = qAbs(curLocalPos.y() - startLocalPos.y());

        if ((d->dragX && !(dx < dragThreshold)) || (d->dragY && !(dy < dragThreshold)))

            d->drag->setActive(true);

        if (!keepMouseGrab()) {

            if ((!d->dragY && dy < dragThreshold && d->dragX && dx > dragThreshold)

                || (!d->dragX && dx < dragThreshold && d->dragY && dy > dragThreshold)

                || (d->dragX && d->dragY)) {

                setKeepMouseGrab(true);

            }

        }

        if (d->dragX && d->drag->active()) {

            qreal x = (curLocalPos.x() - startLocalPos.x()) + d->startX;

            if (x < drag()->xmin())

                x = drag()->xmin();

            else if (x > drag()->xmax())

                x = drag()->xmax();

            drag()->target()->setX(x);

        }

        if (d->dragY && d->drag->active()) {

            qreal y = (curLocalPos.y() - startLocalPos.y()) + d->startY;

            if (y < drag()->ymin())

                y = drag()->ymin();

            else if (y > drag()->ymax())

                y = drag()->ymax();

            drag()->target()->setY(y);

        }

        d->moved = true;

    }

    QDeclarativeMouseEvent me(d->lastPos.x(), d->lastPos.y(), d->lastButton, d->lastButtons, d->lastModifiers, false, d->longPress);

    emit mousePositionChanged(&me);

    me.setX(d->lastPos.x());

    me.setY(d->lastPos.y());

    emit positionChanged(&me);

}

void QDeclarativeMouseArea::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)

{

    Q_D(QDeclarativeMouseArea);

    if (!d->absorb) {

        QDeclarativeItem::mouseReleaseEvent(event);

    } else {

        d->saveEvent(event);

        setPressed(false);

        if (d->drag)

            d->drag->setActive(false);

        // If we don't accept hover, we need to reset containsMouse.

        if (!acceptHoverEvents())

            setHovered(false);

        setKeepMouseGrab(false);

    }

}

void QDeclarativeMouseArea::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event)

{

    Q_D(QDeclarativeMouseArea);

    if (!d->absorb) {

        QDeclarativeItem::mouseDoubleClickEvent(event);

    } else {

        QDeclarativeItem::mouseDoubleClickEvent(event);

        if (event->isAccepted()) {

            // Only deliver the event if we have accepted the press.

            d->saveEvent(event);

            QDeclarativeMouseEvent me(d->lastPos.x(), d->lastPos.y(), d->lastButton, d->lastButtons, d->lastModifiers, true, false);

            emit this->doubleClicked(&me);