Initial import of kinetic-dui branch from the old kinetic

1 files changed, 589 insertions, 0 deletions

diff --git a/src/declarative/fx/qfxmouseregion.cpp b/src/declarative/fx/qfxmouseregion.cpp
new file mode 100644
index 0000000..2bf7aa7
--- /dev/null
+++ b/src/declarative/fx/qfxmouseregion.cpp
@@ -0,0 +1,589 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, 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.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qfxmouseregion.h"
+#include "qfxmouseregion_p.h"
+#include <QGraphicsSceneMouseEvent>
+
+
+QT_BEGIN_NAMESPACE
+static const int DragThreshold = 5;
+static const int PressAndHoldDelay = 800;
+
+QML_DEFINE_TYPE(QFxDrag,Drag);
+QFxDrag::QFxDrag(QObject *parent)
+: QObject(parent), _target(0), _xmin(0), _xmax(0), _ymin(0), _ymax(0)
+{
+}
+
+QFxDrag::~QFxDrag()
+{
+}
+
+QFxItem *QFxDrag::target() const
+{
+    return _target;
+}
+
+void QFxDrag::setTarget(QFxItem *t)
+{
+    _target = t;
+}
+
+QString QFxDrag::axis() const
+{
+    return _axis;
+}
+
+void QFxDrag::setAxis(const QString &a)
+{
+    _axis = a;
+}
+
+/*!
+    \property QFxDrag::xmin
+    \brief the minimum x position for the target
+
+    If x-axis dragging is enabled, xmin limits how far to the left the target can be dragged. If x-axis dragging is not enabled, this property has no effect.
+*/
+int QFxDrag::xmin() const
+{
+    return _xmin;
+}
+
+void QFxDrag::setXmin(int m)
+{
+    _xmin = m;
+}
+
+/*!
+    \property QFxDrag::xmax
+    \brief the maximum x position for the target
+
+    If x-axis dragging is enabled, xmax limits how far to the right the target can be dragged. If x-axis dragging is not enabled, this property has no effect.
+*/
+int QFxDrag::xmax() const
+{
+    return _xmax;
+}
+
+void QFxDrag::setXmax(int m)
+{
+    _xmax = m;
+}
+
+/*!
+    \property QFxDrag::ymin
+    \brief the minimum y position for the target
+
+    If y-axis dragging is enabled, ymin limits how far up the target can be dragged. If y-axis dragging is not enabled, this property has no effect.
+*/
+int QFxDrag::ymin() const
+{
+    return _ymin;
+}
+
+void QFxDrag::setYmin(int m)
+{
+    _ymin = m;
+}
+
+/*!
+    \property QFxDrag::ymax
+    \brief the maximum y position for the target
+
+    If y-axis dragging is enabled, ymax limits how far down the target can be dragged. If y-axis dragging is not enabled, this property has no effect.
+*/
+int QFxDrag::ymax() const
+{
+    return _ymax;
+}
+
+void QFxDrag::setYmax(int m)
+{
+    _ymax = m;
+}
+
+/*!
+    \qmlclass MouseRegion
+    \brief The MouseRegion element enables simple mouse handling.
+    \inherits Item
+
+    A MouseRegion is typically used in conjunction with a visible element, where the MouseRegion effectively 'proxies' mouse handling for that element. For example, we can put a MouseRegion in a Rect that changes the Rect color to red when clicked:
+    \code
+    <Rect width="100" height="100">
+        <MouseRegion anchors.fill="{parent}" onClick="parent.color = 'red';"/>
+    </Rect>
+    \endcode
+
+    For the mouse handlers the variable mouseButton is set to be one of 'Left', 'Right', 'Middle',
+    or 'None'. This allows you to distinguish left and right clicking. Below we have the previous 
+    example extended so as to give a different color when you right click.
+    \code
+    <Rect width="100" height="100">
+        <MouseRegion anchors.fill="{parent}" onClick="if(mouseButton=='Right') { parent.color='blue';} else { parent.color = 'red';}"/>
+    </Rect>
+    \endcode
+
+    For basic key handling, see \l KeyActions.
+
+    MouseRegion is an invisible element: it is never painted.
+*/
+
+/*!
+    \qmlsignal MouseRegion::onEntered
+
+    This handler is called when the mouse enters the mouse region.
+
+    \warning This handler is not yet implemented.
+*/
+
+/*!
+    \qmlsignal MouseRegion::onExited
+
+    This handler is called when the mouse exists the mouse region.
+
+    \warning This handler is not yet implemented.
+*/
+
+/*!
+    \qmlsignal MouseRegion::onReenteredWhilePressed
+
+    This handler is called when the mouse reenters the mouse region while pressed.
+*/
+
+/*!
+    \qmlsignal MouseRegion::onExitedWhilePressed
+
+    This handler is called when the mouse exists the mouse region while pressed.
+*/
+
+/*!
+    \qmlsignal MouseRegion::onClicked
+
+    This handler is called when there is a click. A click is defined as a press followed by a release,
+    both inside the MouseRegion (pressing, moving outside the MouseRegion, and then moving back inside and
+    releasing is also considered a click).
+    The x and y parameters tell you the position of the release of the click. The followsPressAndHold parameter tells
+    you whether or not the release portion of the click followed a long press.
+*/
+
+/*!
+    \qmlsignal MouseRegion::onPressed
+
+    This handler is called when there is a press.
+    The x and y parameters tell you the position of the press.
+*/
+
+/*!
+    \qmlsignal MouseRegion::onReleased
+
+    This handler is called when there is a release.
+    The x and y parameters tell you the position of the release. The isClick parameter tells you whether
+    or not the release is part of a click. The followsPressAndHold parameter tells you whether or not the
+    release followed a long press.
+*/
+
+/*!
+    \qmlsignal MouseRegion::onPressAndHold
+
+    This handler is called when there is a long press (currently 800ms).
+    The x and y parameters tell you the position of the long press.
+*/
+
+/*!
+    \qmlsignal MouseRegion::onDoubleClicked
+
+    This handler is called when there is a double-click (a press followed by a release followed by a press).
+    The x and y parameters tell you the position of the double-click.
+*/
+
+QML_DEFINE_TYPE(QFxMouseRegion,MouseRegion);
+/*!
+    \internal
+    \class QFxMouseRegion
+    \brief The QFxMouseRegion class provides a simple mouse handling abstraction for use within Qml.
+
+    \ingroup coreitems
+
+    All QFxItem derived classes can do mouse handling but the QFxMouseRegion class exposes mouse
+    handling data as properties and tracks flicking and dragging of the mouse.
+
+    A QFxMouseRegion object can be instantiated in Qml using the tag \l MouseRegion.
+ */
+QFxMouseRegion::QFxMouseRegion(QFxItem *parent)
+  : QFxItem(*(new QFxMouseRegionPrivate), parent)
+{
+    Q_D(QFxMouseRegion);
+    d->init();
+}
+
+QFxMouseRegion::QFxMouseRegion(QFxMouseRegionPrivate &dd, QFxItem *parent)
+  : QFxItem(dd, parent)
+{
+    Q_D(QFxMouseRegion);
+    d->init();
+}
+
+QFxMouseRegion::~QFxMouseRegion()
+{
+}
+
+/*!
+    \qmlproperty int MouseRegion::mouseX
+    \qmlproperty int MouseRegion::mouseY
+
+    The coordinates of the mouse while pressed. The coordinates are relative to the item that was pressed.
+*/
+int QFxMouseRegion::mouseX() const
+{
+    Q_D(const QFxMouseRegion);
+    return int(d->lastPos.x());
+}
+
+int QFxMouseRegion::mouseY() const
+{
+    Q_D(const QFxMouseRegion);
+    return int(d->lastPos.y());
+}
+
+/*!
+    \qmlproperty bool MouseRegion::enabled
+    This property holds whether the item accepts mouse events.
+*/
+bool QFxMouseRegion::isEnabled() const
+{
+    Q_D(const QFxMouseRegion);
+    return d->absorb;
+}
+
+void QFxMouseRegion::setEnabled(bool a)
+{
+    Q_D(QFxMouseRegion);
+    d->absorb = a;
+}
+
+void QFxMouseRegionPrivate::bindButtonValue(Qt::MouseButton b)
+{
+    Q_Q(QFxMouseRegion);
+    QString bString;
+    switch(b){
+        case Qt::LeftButton:
+            bString = QLatin1String("Left"); break;
+        case Qt::RightButton:
+            bString = QLatin1String("Right"); break;
+        case Qt::MidButton:
+            bString = QLatin1String("Middle"); break;
+        default:
+            bString = QLatin1String("None"); break;
+    }
+    q->itemContext()->setContextProperty(QLatin1String("mouseButton"), bString);
+}
+
+void QFxMouseRegion::mousePressEvent(QGraphicsSceneMouseEvent *event)
+{
+    Q_D(QFxMouseRegion);
+    d->moved = false;
+    if(!d->absorb)
+        QFxItem::mousePressEvent(event);
+    else {
+        if (!d->inside) {
+            d->inside = true;
+            emit hoveredChanged();
+        }
+        d->longPress = false;
+        d->lastPos = event->pos();
+        d->dragX = drag()->axis().contains(QLatin1String("x"));
+        d->dragY = drag()->axis().contains(QLatin1String("y"));
+        d->dragged = false;
+        d->start = event->pos();
+        d->startScene = event->scenePos();
+        // ### we should only start timer if pressAndHold is connected to (but connectNotify doesn't work)
+        d->pressAndHoldTimer.start(PressAndHoldDelay, this);
+        setKeepMouseGrab(false);
+        d->bindButtonValue(event->button());
+        setPressed(true);
+        emit positionChanged();
+        event->accept();
+    }
+}
+
+void QFxMouseRegion::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
+{
+    Q_D(QFxMouseRegion);
+    if(!d->absorb) {
+        QFxItem::mouseMoveEvent(event);
+        return;
+    }
+
+    d->lastPos = event->pos();
+
+    // ### we should skip this if these signals aren't used
+    const QRect &bounds = itemBoundingRect();
+    bool contains = bounds.contains(d->lastPos.toPoint());
+    if (d->inside && !contains) {
+        d->inside = false;
+        emit hoveredChanged();
+        emit exitedWhilePressed();
+    } else if (!d->inside && contains) {
+        d->inside = true;
+        emit hoveredChanged();
+        emit reenteredWhilePressed();
+    }
+
+    if(drag()->target()) {
+        if(!d->moved) {
+            if(d->dragX) d->startX = int(drag()->target()->x());   //### change startX and startY to qreal?
+            if(d->dragY) d->startY = int(drag()->target()->y());
+        }
+
+        QPointF startLocalPos;
+        QPointF curLocalPos;
+        if (drag()->target()->parent()) {
+            startLocalPos = drag()->target()->parent()->mapFromScene(d->startScene);
+            curLocalPos = drag()->target()->parent()->mapFromScene(event->scenePos());
+        } else {
+            startLocalPos = d->startScene;
+            curLocalPos = event->scenePos();
+        }
+
+        int dx = int(qAbs(curLocalPos.x() - startLocalPos.x()));
+        int dy = int(qAbs(curLocalPos.y() - startLocalPos.y()));
+        if ((d->dragX && !(dx < DragThreshold)) || (d->dragY && !(dy < DragThreshold)))
+            d->dragged = 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) {
+            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) {
+            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;
+    emit positionChanged();
+    event->accept();
+}
+
+
+void QFxMouseRegion::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
+{
+    Q_D(QFxMouseRegion);
+    if(!d->absorb)
+        QFxItem::mouseReleaseEvent(event);
+    else {
+        setPressed(false);
+        //d->inside = false;
+        //emit hoveredChanged();
+        event->accept();
+    }
+}
+
+void QFxMouseRegion::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event)
+{
+    Q_D(QFxMouseRegion);
+    if(!d->absorb)
+        QFxItem::mouseDoubleClickEvent(event);
+    else {
+        //d->inside = true;
+        //emit hoveredChanged();
+        setPressed(true);
+        emit this->doubleClicked(d->lastPos.x(), d->lastPos.y());
+        event->accept();
+    }
+}
+
+void QFxMouseRegion::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
+{
+    Q_D(QFxMouseRegion);
+    if(!d->absorb)
+        QFxItem::hoverEnterEvent(event);
+    else {
+        setHovered(true);
+        emit entered();
+    }
+}
+
+void QFxMouseRegion::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
+{
+    Q_D(QFxMouseRegion);
+    if(!d->absorb)
+        QFxItem::hoverLeaveEvent(event);
+    else {
+        setHovered(false);
+        emit exited();
+    }
+}
+
+void QFxMouseRegion::mouseUngrabEvent()
+{
+    Q_D(QFxMouseRegion);
+    if (d->pressed) {
+        // if our mouse grab has been removed (probably by Flickable), fix our 
+        // state
+        d->pressed = false;
+        //d->inside = false;
+        setKeepMouseGrab(false);
+        emit pressedChanged();
+        //emit hoveredChanged();
+    }
+}
+
+void QFxMouseRegion::timerEvent(QTimerEvent *event)
+{
+    Q_D(QFxMouseRegion);
+    if (event->timerId() == d->pressAndHoldTimer.timerId()) {
+        d->pressAndHoldTimer.stop();
+        if (d->pressed && d->dragged == false && d->inside == true) {
+            d->longPress = true;
+            emit pressAndHold(d->lastPos.x(), d->lastPos.y());
+        }
+    }
+}
+
+/*!
+    \qmlproperty bool MouseRegion::containsMouse
+    This property holds whether the mouse is currently inside the mouse region.
+
+    \warning This property is only partially implemented -- it is only valid when the mouse is pressed, and not for hover events.
+*/
+bool QFxMouseRegion::hovered()
+{
+    Q_D(QFxMouseRegion);
+    return d->hovered || d->inside;
+}
+
+/*!
+    \qmlproperty bool MouseRegion::pressed
+    This property holds whether the mouse region is currently pressed.
+*/
+bool QFxMouseRegion::pressed()
+{
+    Q_D(QFxMouseRegion);
+    return d->pressed;
+}
+
+void QFxMouseRegion::setHovered(bool h)
+{
+    Q_D(QFxMouseRegion);
+    if(d->hovered != h) {
+        d->hovered = h;
+        emit hoveredChanged();
+    }
+}
+
+void QFxMouseRegion::setPressed(bool p)
+{
+    Q_D(QFxMouseRegion);
+    bool isclick = d->pressed == true && p == false && d->dragged == false && d->inside == true;
+
+    if(d->pressed != p) {
+        d->pressed = p;
+        if(d->pressed)
+            emit pressed(d->lastPos.x(), d->lastPos.y());
+        else {
+            emit released(d->lastPos.x(), d->lastPos.y(), isclick, d->longPress);
+            if (isclick)
+                emit clicked(d->lastPos.x(), d->lastPos.y(), d->longPress);
+        }
+
+        emit pressedChanged();
+    }
+}
+
+/*!
+    \property QFxMouseRegion::drag
+    \brief The current drag being performed on the Mouse Region.
+*/
+QFxDrag *QFxMouseRegion::drag()
+{
+    Q_D(QFxMouseRegion);
+    return &(d->drag);
+}
+
+/*!
+    \qmlproperty Item MouseRegion::drag.target
+    \qmlproperty string MouseRegion::drag.axis
+    \qmlproperty int MouseRegion::drag.xmin
+    \qmlproperty int MouseRegion::drag.xmax
+    \qmlproperty int MouseRegion::drag.ymin
+    \qmlproperty int MouseRegion::drag.ymax
+
+    drag provides a convenient way to make an item draggable.
+
+    \list
+    \i \c target specifies the item to drag.
+    \i \c axis specifies whether dragging can be done horizontally (x), vertically (y), or both (x,y)
+    \i the min and max properties limit how far the target can be dragged along the corresponding axes.
+    \endlist
+
+    The following example uses drag to blur an image as it moves to the right:
+    \code
+    <Item id="blurtest" width="600" height="200">
+        <Image id="pic" file="pic.png" anchors.verticalCenter="{parent.verticalCenter}" >
+            <filter><Blur radius="{pic.x/10}"/></filter>
+            <MouseRegion anchors.fill="{parent}"
+                        drag.target="{pic}"
+                        drag.axis="x"
+                        drag.xmin="0"
+                        drag.xmax="{blurtest.width-pic.width}" />
+        </Image>
+    </Item>
+    \endcode
+*/
+
+QT_END_NAMESPACE