Say hello to QtQuick module

This change moves the QtQuick 2 types and C++ API (including
SceneGraph) to a new module (AKA library), QtQuick.

99% of this change is moving files from src/declarative to
src/quick, and from tests/auto/declarative to
tests/auto/qtquick2.

The loading of QtQuick 2 ("import QtQuick 2.0") is now delegated to
a plugin, src/imports/qtquick2, just like it's done for QtQuick 1.

All tools, examples, and tests that use QtQuick C++ API have gotten
"QT += quick" or "QT += quick-private" added to their .pro file.

A few additional internal QtDeclarative classes had to be exported
(via Q_DECLARATIVE_PRIVATE_EXPORT) since they're needed by the
QtQuick 2 implementation.

The old header locations (e.g. QtDeclarative/qquickitem.h) will
still be supported for some time, but will produce compile-time
warnings. (To avoid the QtQuick implementation using the
compatibility headers (since QtDeclarative's includepath comes
first), a few include statements were modified, e.g. from
"#include <qsgnode.h>" to "#include <QtQuick/qsgnode.h>".)

There's a change in qtbase that automatically adds QtQuick to the
module list if QtDeclarative is used. Together with the compatibility
headers, this should help reduce the migration pain for existing
projects.

In theory, simply getting an existing QtDeclarative-based project
to compile and link shouldn't require any changes for now -- but
porting to the new scheme is of course recommended, and will
eventually become mandatory.

Task-number: QTBUG-22889
Reviewed-by: Lars Knoll <lars.knoll@nokia.com>
Change-Id: Ia52be9373172ba2f37e7623231ecb060316c96a7
Reviewed-by: Kent Hansen <kent.hansen@nokia.com>
Reviewed-by: Sergio Ahumada <sergio.ahumada@nokia.com>

1 files changed, 752 insertions, 0 deletions

diff --git a/src/quick/items/qquickitem_p.h b/src/quick/items/qquickitem_p.h
new file mode 100644
index 0000000000..a522a19a70
--- /dev/null
+++ b/src/quick/items/qquickitem_p.h
@@ -0,0 +1,752 @@
+// Commit: 5c783d0a9a912816813945387903857a314040b5
+/****************************************************************************
+**
+** Copyright (C) 2011 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$
+** GNU Lesser General Public License Usage
+** 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.
+**
+** 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.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QQUICKITEM_P_H
+#define QQUICKITEM_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qquickitem.h"
+
+#include "qquickanchors_p.h"
+#include "qquickanchors_p_p.h"
+#include "qquickitemchangelistener_p.h"
+
+#include "qquickcanvas_p.h"
+
+#include <QtQuick/qsgnode.h>
+#include "qquickclipnode_p.h"
+
+#include <private/qpodvector_p.h>
+#include <QtQuick/private/qdeclarativestate_p.h>
+#include <private/qdeclarativenullablevalue_p_p.h>
+#include <private/qdeclarativenotifier_p.h>
+#include <private/qdeclarativeglobal_p.h>
+
+#include <qdeclarative.h>
+#include <qdeclarativecontext.h>
+
+#include <QtCore/qlist.h>
+#include <QtCore/qdebug.h>
+#include <QtCore/qelapsedtimer.h>
+
+QT_BEGIN_NAMESPACE
+
+class QNetworkReply;
+class QQuickItemKeyFilter;
+class QQuickLayoutMirroringAttached;
+
+class QQuickContents : public QQuickItemChangeListener
+{
+public:
+    QQuickContents(QQuickItem *item);
+    ~QQuickContents();
+
+    QRectF rectF() const { return QRectF(m_x, m_y, m_width, m_height); }
+
+    inline void calcGeometry(QQuickItem *changed = 0);
+    void complete();
+
+protected:
+    void itemGeometryChanged(QQuickItem *item, const QRectF &newGeometry, const QRectF &oldGeometry);
+    void itemDestroyed(QQuickItem *item);
+    void itemChildAdded(QQuickItem *, QQuickItem *);
+    void itemChildRemoved(QQuickItem *, QQuickItem *);
+    //void itemVisibilityChanged(QQuickItem *item)
+
+private:
+    bool calcHeight(QQuickItem *changed = 0);
+    bool calcWidth(QQuickItem *changed = 0);
+    void updateRect();
+
+    QQuickItem *m_item;
+    qreal m_x;
+    qreal m_y;
+    qreal m_width;
+    qreal m_height;
+};
+
+void QQuickContents::calcGeometry(QQuickItem *changed)
+{
+    bool wChanged = calcWidth(changed);
+    bool hChanged = calcHeight(changed);
+    if (wChanged || hChanged)
+        updateRect();
+}
+
+class QQuickTransformPrivate : public QObjectPrivate
+{
+    Q_DECLARE_PUBLIC(QQuickTransform);
+public:
+    static QQuickTransformPrivate* get(QQuickTransform *transform) { return transform->d_func(); }
+
+    QQuickTransformPrivate();
+
+    QList<QQuickItem *> items;
+};
+
+class Q_QUICK_EXPORT QQuickItemPrivate : public QObjectPrivate
+{
+    Q_DECLARE_PUBLIC(QQuickItem)
+
+public:
+    static QQuickItemPrivate* get(QQuickItem *item) { return item->d_func(); }
+    static const QQuickItemPrivate* get(const QQuickItem *item) { return item->d_func(); }
+
+    QQuickItemPrivate();
+    ~QQuickItemPrivate();
+    void init(QQuickItem *parent);
+
+    QDeclarativeListProperty<QObject> data();
+    QDeclarativeListProperty<QObject> resources();
+    QDeclarativeListProperty<QQuickItem> children();
+
+    QDeclarativeListProperty<QDeclarativeState> states();
+    QDeclarativeListProperty<QDeclarativeTransition> transitions();
+
+    QString state() const;
+    void setState(const QString &);
+
+    QQuickAnchorLine left() const;
+    QQuickAnchorLine right() const;
+    QQuickAnchorLine horizontalCenter() const;
+    QQuickAnchorLine top() const;
+    QQuickAnchorLine bottom() const;
+    QQuickAnchorLine verticalCenter() const;
+    QQuickAnchorLine baseline() const;
+
+    // data property
+    static void data_append(QDeclarativeListProperty<QObject> *, QObject *);
+    static int data_count(QDeclarativeListProperty<QObject> *);
+    static QObject *data_at(QDeclarativeListProperty<QObject> *, int);
+    static void data_clear(QDeclarativeListProperty<QObject> *);
+
+    // resources property
+    static QObject *resources_at(QDeclarativeListProperty<QObject> *, int);
+    static void resources_append(QDeclarativeListProperty<QObject> *, QObject *);
+    static int resources_count(QDeclarativeListProperty<QObject> *);
+    static void resources_clear(QDeclarativeListProperty<QObject> *);
+
+    // children property
+    static void children_append(QDeclarativeListProperty<QQuickItem> *, QQuickItem *);
+    static int children_count(QDeclarativeListProperty<QQuickItem> *);
+    static QQuickItem *children_at(QDeclarativeListProperty<QQuickItem> *, int);
+    static void children_clear(QDeclarativeListProperty<QQuickItem> *);
+
+    // transform property
+    static int transform_count(QDeclarativeListProperty<QQuickTransform> *list);
+    static void transform_append(QDeclarativeListProperty<QQuickTransform> *list, QQuickTransform *);
+    static QQuickTransform *transform_at(QDeclarativeListProperty<QQuickTransform> *list, int);
+    static void transform_clear(QDeclarativeListProperty<QQuickTransform> *list);
+
+    QQuickAnchors *anchors() const;
+    mutable QQuickAnchors *_anchors;
+    QQuickContents *_contents;
+
+    QDeclarativeNullableValue<qreal> baselineOffset;
+
+    struct AnchorLines {
+        AnchorLines(QQuickItem *);
+        QQuickAnchorLine left;
+        QQuickAnchorLine right;
+        QQuickAnchorLine hCenter;
+        QQuickAnchorLine top;
+        QQuickAnchorLine bottom;
+        QQuickAnchorLine vCenter;
+        QQuickAnchorLine baseline;
+    };
+    mutable AnchorLines *_anchorLines;
+    AnchorLines *anchorLines() const;
+
+    enum ChangeType {
+        Geometry = 0x01,
+        SiblingOrder = 0x02,
+        Visibility = 0x04,
+        Opacity = 0x08,
+        Destroyed = 0x10,
+        Parent = 0x20,
+        Children = 0x40,
+        Rotation = 0x80,
+    };
+
+    Q_DECLARE_FLAGS(ChangeTypes, ChangeType)
+
+    enum GeometryChangeType {
+        NoChange = 0,
+        XChange = 0x01,
+        YChange = 0x02,
+        WidthChange = 0x04,
+        HeightChange = 0x08,
+        SizeChange = WidthChange | HeightChange,
+        GeometryChange = XChange | YChange | SizeChange
+    };
+
+    Q_DECLARE_FLAGS(GeometryChangeTypes, GeometryChangeType)
+
+    struct ChangeListener {
+        ChangeListener(QQuickItemChangeListener *l, QQuickItemPrivate::ChangeTypes t) : listener(l), types(t), gTypes(GeometryChange) {}
+        ChangeListener(QQuickItemChangeListener *l, QQuickItemPrivate::GeometryChangeTypes gt) : listener(l), types(Geometry), gTypes(gt) {}
+        QQuickItemChangeListener *listener;
+        QQuickItemPrivate::ChangeTypes types;
+        QQuickItemPrivate::GeometryChangeTypes gTypes;  //NOTE: not used for ==
+        bool operator==(const ChangeListener &other) const { return listener == other.listener && types == other.types; }
+    };
+
+    void addItemChangeListener(QQuickItemChangeListener *listener, ChangeTypes types) {
+        changeListeners.append(ChangeListener(listener, types));
+    }
+    void removeItemChangeListener(QQuickItemChangeListener *, ChangeTypes types);
+    void updateOrAddGeometryChangeListener(QQuickItemChangeListener *listener, GeometryChangeTypes types);
+    void updateOrRemoveGeometryChangeListener(QQuickItemChangeListener *listener, GeometryChangeTypes types);
+    QPODVector<ChangeListener,4> changeListeners;
+
+    QDeclarativeStateGroup *_states();
+    QDeclarativeStateGroup *_stateGroup;
+
+    QQuickItem::TransformOrigin origin:5;
+    quint32 flags:5;
+    bool widthValid:1;
+    bool heightValid:1;
+    bool componentComplete:1;
+    bool keepMouse:1;
+    bool keepTouch:1;
+    bool hoverEnabled:1;
+    bool smooth:1;
+    bool focus:1;
+    bool activeFocus:1;
+    bool notifiedFocus:1;
+    bool notifiedActiveFocus:1;
+    bool filtersChildMouseEvents:1;
+    bool explicitVisible:1;
+    bool effectiveVisible:1;
+    bool explicitEnable:1;
+    bool effectiveEnable:1;
+    bool polishScheduled:1;
+    bool inheritedLayoutMirror:1;
+    bool effectiveLayoutMirror:1;
+    bool isMirrorImplicit:1;
+    bool inheritMirrorFromParent:1;
+    bool inheritMirrorFromItem:1;
+    bool childrenDoNotOverlap:1;
+
+    QQuickCanvas *canvas;
+    QSGContext *sceneGraphContext() const { Q_ASSERT(canvas); return static_cast<QQuickCanvasPrivate *>(QObjectPrivate::get(canvas))->context; }
+
+    QQuickItem *parentItem;
+    QList<QQuickItem *> childItems;
+    mutable QList<QQuickItem *> *sortedChildItems;
+    QList<QQuickItem *> paintOrderChildItems() const;
+    void addChild(QQuickItem *);
+    void removeChild(QQuickItem *);
+    void siblingOrderChanged();
+
+    inline void markSortedChildrenDirty(QQuickItem *child) {
+        // If sortedChildItems == &childItems then all in childItems have z == 0
+        // and we don't need to invalidate if the changed item also has z == 0.
+        if (child->z() != 0. || sortedChildItems != &childItems) {
+            if (sortedChildItems != &childItems)
+                delete sortedChildItems;
+            sortedChildItems = 0;
+        }
+    }
+
+    class InitializationState {
+    public:
+        QQuickItem *getFocusScope(QQuickItem *item);
+        void clear();
+        void clear(QQuickItem *focusScope);
+    private:
+        QQuickItem *focusScope;
+    };
+    void initCanvas(InitializationState *, QQuickCanvas *);
+
+    QQuickItem *subFocusItem;
+
+    QTransform canvasToItemTransform() const;
+    QTransform itemToCanvasTransform() const;
+    void itemToParentTransform(QTransform &) const;
+
+    qreal x;
+    qreal y;
+    qreal width;
+    qreal height;
+    qreal implicitWidth;
+    qreal implicitHeight;
+
+    qreal z;
+    qreal scale;
+    qreal rotation;
+    qreal opacity;
+
+    QQuickLayoutMirroringAttached* attachedLayoutDirection;
+
+    Qt::MouseButtons acceptedMouseButtons;
+    Qt::InputMethodHints imHints;
+
+    QPointF transformOriginPoint;
+
+    virtual qreal getImplicitWidth() const;
+    virtual qreal getImplicitHeight() const;
+    virtual void implicitWidthChanged();
+    virtual void implicitHeightChanged();
+
+    void resolveLayoutMirror();
+    void setImplicitLayoutMirror(bool mirror, bool inherit);
+    void setLayoutMirror(bool mirror);
+    bool isMirrored() const {
+        return effectiveLayoutMirror;
+    }
+
+    void emitChildrenRectChanged(const QRectF &rect) {
+        Q_Q(QQuickItem);
+        emit q->childrenRectChanged(rect);
+    }
+
+    QPointF computeTransformOrigin() const;
+    QList<QQuickTransform *> transforms;
+    virtual void transformChanged();
+
+    QQuickItemKeyFilter *keyHandler;
+    void deliverKeyEvent(QKeyEvent *);
+    void deliverInputMethodEvent(QInputMethodEvent *);
+    void deliverFocusEvent(QFocusEvent *);
+    void deliverMouseEvent(QMouseEvent *);
+    void deliverWheelEvent(QWheelEvent *);
+    void deliverTouchEvent(QTouchEvent *);
+    void deliverHoverEvent(QHoverEvent *);
+    void deliverDragEvent(QEvent *);
+
+    bool calcEffectiveVisible() const;
+    void setEffectiveVisibleRecur(bool);
+    bool calcEffectiveEnable() const;
+    void setEffectiveEnableRecur(bool);
+
+    // XXX todo
+    enum DirtyType {
+        TransformOrigin         = 0x00000001,
+        Transform               = 0x00000002,
+        BasicTransform          = 0x00000004,
+        Position                = 0x00000008,
+        Size                    = 0x00000010,
+
+        ZValue                  = 0x00000020,
+        Content                 = 0x00000040,
+        Smooth                  = 0x00000080,
+        OpacityValue            = 0x00000100,
+        ChildrenChanged         = 0x00000200,
+        ChildrenStackingChanged = 0x00000400,
+        ParentChanged           = 0x00000800,
+
+        Clip                    = 0x00001000,
+        Canvas                  = 0x00002000,
+
+        EffectReference         = 0x00008000,
+        Visible                 = 0x00010000,
+        HideReference           = 0x00020000,
+        // When you add an attribute here, don't forget to update
+        // dirtyToString()
+
+        TransformUpdateMask     = TransformOrigin | Transform | BasicTransform | Position | Size | Canvas,
+        ComplexTransformUpdateMask     = Transform | Canvas,
+        ContentUpdateMask       = Size | Content | Smooth | Canvas,
+        ChildrenUpdateMask      = ChildrenChanged | ChildrenStackingChanged | EffectReference | Canvas,
+
+    };
+    quint32 dirtyAttributes;
+    QString dirtyToString() const;
+    void dirty(DirtyType);
+    void addToDirtyList();
+    void removeFromDirtyList();
+    QQuickItem *nextDirtyItem;
+    QQuickItem**prevDirtyItem;
+
+    inline QSGTransformNode *itemNode();
+    inline QSGNode *childContainerNode();
+
+    /*
+      QSGNode order is:
+         - itemNode
+         - (opacityNode)
+         - (clipNode)
+         - (effectNode)
+         - groupNode
+     */
+
+    QSGTransformNode *itemNodeInstance;
+    QSGOpacityNode *opacityNode;
+    QQuickDefaultClipNode *clipNode;
+    QSGRootNode *rootNode;
+    QSGNode *groupNode;
+    QSGNode *paintNode;
+    QSGNode *beforePaintNode;
+
+    virtual QSGTransformNode *createTransformNode();
+
+    // A reference from an effect item means that this item is used by the effect, so
+    // it should insert a root node.
+    void refFromEffectItem(bool hide);
+    void derefFromEffectItem(bool unhide);
+    int effectRefCount;
+    int hideRefCount;
+
+    void itemChange(QQuickItem::ItemChange, const QQuickItem::ItemChangeData &);
+
+    virtual void mirrorChange() {}
+
+    static qint64 consistentTime;
+    static void setConsistentTime(qint64 t);
+    static void start(QElapsedTimer &);
+    static qint64 elapsed(QElapsedTimer &);
+    static qint64 restart(QElapsedTimer &);
+};
+
+/*
+    Key filters can be installed on a QQuickItem, but not removed.  Currently they
+    are only used by attached objects (which are only destroyed on Item
+    destruction), so this isn't a problem.  If in future this becomes any form
+    of public API, they will have to support removal too.
+*/
+class QQuickItemKeyFilter
+{
+public:
+    QQuickItemKeyFilter(QQuickItem * = 0);
+    virtual ~QQuickItemKeyFilter();
+
+    virtual void keyPressed(QKeyEvent *event, bool post);
+    virtual void keyReleased(QKeyEvent *event, bool post);
+    virtual void inputMethodEvent(QInputMethodEvent *event, bool post);
+    virtual QVariant inputMethodQuery(Qt::InputMethodQuery query) const;
+    virtual void componentComplete();
+
+    bool m_processPost;
+
+private:
+    QQuickItemKeyFilter *m_next;
+};
+
+class QQuickKeyNavigationAttachedPrivate : public QObjectPrivate
+{
+public:
+    QQuickKeyNavigationAttachedPrivate()
+        : QObjectPrivate(),
+          left(0), right(0), up(0), down(0), tab(0), backtab(0),
+          leftSet(false), rightSet(false), upSet(false), downSet(false),
+          tabSet(false), backtabSet(false) {}
+
+    QQuickItem *left;
+    QQuickItem *right;
+    QQuickItem *up;
+    QQuickItem *down;
+    QQuickItem *tab;
+    QQuickItem *backtab;
+    bool leftSet : 1;
+    bool rightSet : 1;
+    bool upSet : 1;
+    bool downSet : 1;
+    bool tabSet : 1;
+    bool backtabSet : 1;
+};
+
+class QQuickKeyNavigationAttached : public QObject, public QQuickItemKeyFilter
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QQuickKeyNavigationAttached)
+
+    Q_PROPERTY(QQuickItem *left READ left WRITE setLeft NOTIFY leftChanged)
+    Q_PROPERTY(QQuickItem *right READ right WRITE setRight NOTIFY rightChanged)
+    Q_PROPERTY(QQuickItem *up READ up WRITE setUp NOTIFY upChanged)
+    Q_PROPERTY(QQuickItem *down READ down WRITE setDown NOTIFY downChanged)
+    Q_PROPERTY(QQuickItem *tab READ tab WRITE setTab NOTIFY tabChanged)
+    Q_PROPERTY(QQuickItem *backtab READ backtab WRITE setBacktab NOTIFY backtabChanged)
+    Q_PROPERTY(Priority priority READ priority WRITE setPriority NOTIFY priorityChanged)
+
+    Q_ENUMS(Priority)
+
+public:
+    QQuickKeyNavigationAttached(QObject * = 0);
+
+    QQuickItem *left() const;
+    void setLeft(QQuickItem *);
+    QQuickItem *right() const;
+    void setRight(QQuickItem *);
+    QQuickItem *up() const;
+    void setUp(QQuickItem *);
+    QQuickItem *down() const;
+    void setDown(QQuickItem *);
+    QQuickItem *tab() const;
+    void setTab(QQuickItem *);
+    QQuickItem *backtab() const;
+    void setBacktab(QQuickItem *);
+
+    enum Priority { BeforeItem, AfterItem };
+    Priority priority() const;
+    void setPriority(Priority);
+
+    static QQuickKeyNavigationAttached *qmlAttachedProperties(QObject *);
+
+Q_SIGNALS:
+    void leftChanged();
+    void rightChanged();
+    void upChanged();
+    void downChanged();
+    void tabChanged();
+    void backtabChanged();
+    void priorityChanged();
+
+private:
+    virtual void keyPressed(QKeyEvent *event, bool post);
+    virtual void keyReleased(QKeyEvent *event, bool post);
+    void setFocusNavigation(QQuickItem *currentItem, const char *dir);
+};
+
+class QQuickLayoutMirroringAttached : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(bool enabled READ enabled WRITE setEnabled RESET resetEnabled NOTIFY enabledChanged)
+    Q_PROPERTY(bool childrenInherit READ childrenInherit WRITE setChildrenInherit NOTIFY childrenInheritChanged)
+
+public:
+    explicit QQuickLayoutMirroringAttached(QObject *parent = 0);
+
+    bool enabled() const;
+    void setEnabled(bool);
+    void resetEnabled();
+
+    bool childrenInherit() const;
+    void setChildrenInherit(bool);
+
+    static QQuickLayoutMirroringAttached *qmlAttachedProperties(QObject *);
+Q_SIGNALS:
+    void enabledChanged();
+    void childrenInheritChanged();
+private:
+    friend class QQuickItemPrivate;
+    QQuickItemPrivate *itemPrivate;
+};
+
+class QQuickKeysAttachedPrivate : public QObjectPrivate
+{
+public:
+    QQuickKeysAttachedPrivate()
+        : QObjectPrivate(), inPress(false), inRelease(false)
+        , inIM(false), enabled(true), imeItem(0), item(0)
+    {}
+
+    bool isConnected(const char *signalName);
+
+    //loop detection
+    bool inPress:1;
+    bool inRelease:1;
+    bool inIM:1;
+
+    bool enabled : 1;
+
+    QQuickItem *imeItem;
+    QList<QQuickItem *> targets;
+    QQuickItem *item;
+};
+
+class QQuickKeysAttached : public QObject, public QQuickItemKeyFilter
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QQuickKeysAttached)
+
+    Q_PROPERTY(bool enabled READ enabled WRITE setEnabled NOTIFY enabledChanged)
+    Q_PROPERTY(QDeclarativeListProperty<QQuickItem> forwardTo READ forwardTo)
+    Q_PROPERTY(Priority priority READ priority WRITE setPriority NOTIFY priorityChanged)
+
+    Q_ENUMS(Priority)
+
+public:
+    QQuickKeysAttached(QObject *parent=0);
+    ~QQuickKeysAttached();
+
+    bool enabled() const { Q_D(const QQuickKeysAttached); return d->enabled; }
+    void setEnabled(bool enabled) {
+        Q_D(QQuickKeysAttached);
+        if (enabled != d->enabled) {
+            d->enabled = enabled;
+            emit enabledChanged();
+        }
+    }
+
+    enum Priority { BeforeItem, AfterItem};
+    Priority priority() const;
+    void setPriority(Priority);
+
+    QDeclarativeListProperty<QQuickItem> forwardTo() {
+        Q_D(QQuickKeysAttached);
+        return QDeclarativeListProperty<QQuickItem>(this, d->targets);
+    }
+
+    virtual void componentComplete();
+
+    static QQuickKeysAttached *qmlAttachedProperties(QObject *);
+
+Q_SIGNALS:
+    void enabledChanged();
+    void priorityChanged();
+    void pressed(QQuickKeyEvent *event);
+    void released(QQuickKeyEvent *event);
+    void digit0Pressed(QQuickKeyEvent *event);
+    void digit1Pressed(QQuickKeyEvent *event);
+    void digit2Pressed(QQuickKeyEvent *event);
+    void digit3Pressed(QQuickKeyEvent *event);
+    void digit4Pressed(QQuickKeyEvent *event);
+    void digit5Pressed(QQuickKeyEvent *event);
+    void digit6Pressed(QQuickKeyEvent *event);
+    void digit7Pressed(QQuickKeyEvent *event);
+    void digit8Pressed(QQuickKeyEvent *event);
+    void digit9Pressed(QQuickKeyEvent *event);
+
+    void leftPressed(QQuickKeyEvent *event);
+    void rightPressed(QQuickKeyEvent *event);
+    void upPressed(QQuickKeyEvent *event);
+    void downPressed(QQuickKeyEvent *event);
+    void tabPressed(QQuickKeyEvent *event);
+    void backtabPressed(QQuickKeyEvent *event);
+
+    void asteriskPressed(QQuickKeyEvent *event);
+    void numberSignPressed(QQuickKeyEvent *event);
+    void escapePressed(QQuickKeyEvent *event);
+    void returnPressed(QQuickKeyEvent *event);
+    void enterPressed(QQuickKeyEvent *event);
+    void deletePressed(QQuickKeyEvent *event);
+    void spacePressed(QQuickKeyEvent *event);
+    void backPressed(QQuickKeyEvent *event);
+    void cancelPressed(QQuickKeyEvent *event);
+    void selectPressed(QQuickKeyEvent *event);
+    void yesPressed(QQuickKeyEvent *event);
+    void noPressed(QQuickKeyEvent *event);
+    void context1Pressed(QQuickKeyEvent *event);
+    void context2Pressed(QQuickKeyEvent *event);
+    void context3Pressed(QQuickKeyEvent *event);
+    void context4Pressed(QQuickKeyEvent *event);
+    void callPressed(QQuickKeyEvent *event);
+    void hangupPressed(QQuickKeyEvent *event);
+    void flipPressed(QQuickKeyEvent *event);
+    void menuPressed(QQuickKeyEvent *event);
+    void volumeUpPressed(QQuickKeyEvent *event);
+    void volumeDownPressed(QQuickKeyEvent *event);
+
+private:
+    virtual void keyPressed(QKeyEvent *event, bool post);
+    virtual void keyReleased(QKeyEvent *event, bool post);
+    virtual void inputMethodEvent(QInputMethodEvent *, bool post);
+    virtual QVariant inputMethodQuery(Qt::InputMethodQuery query) const;
+
+    const QByteArray keyToSignal(int key) {
+        QByteArray keySignal;
+        if (key >= Qt::Key_0 && key <= Qt::Key_9) {
+            keySignal = "digit0Pressed";
+            keySignal[5] = '0' + (key - Qt::Key_0);
+        } else {
+            int i = 0;
+            while (sigMap[i].key && sigMap[i].key != key)
+                ++i;
+            keySignal = sigMap[i].sig;
+        }
+        return keySignal;
+    }
+
+    struct SigMap {
+        int key;
+        const char *sig;
+    };
+
+    static const SigMap sigMap[];
+};
+
+QSGTransformNode *QQuickItemPrivate::itemNode()
+{
+    if (!itemNodeInstance) {
+        itemNodeInstance = createTransformNode();
+        itemNodeInstance->setFlag(QSGNode::OwnedByParent, false);
+#ifdef QML_RUNTIME_TESTING
+        Q_Q(QQuickItem);
+        itemNodeInstance->description = QString::fromLatin1("QQuickItem(%1)").arg(QString::fromLatin1(q->metaObject()->className()));
+#endif
+    }
+    return itemNodeInstance;
+}
+
+QSGNode *QQuickItemPrivate::childContainerNode()
+{
+    if (!groupNode) {
+        groupNode = new QSGNode();
+        if (rootNode)
+            rootNode->appendChildNode(groupNode);
+        else if (clipNode)
+            clipNode->appendChildNode(groupNode);
+        else if (opacityNode)
+            opacityNode->appendChildNode(groupNode);
+        else
+            itemNode()->appendChildNode(groupNode);
+        groupNode->setFlag(QSGNode::ChildrenDoNotOverlap, childrenDoNotOverlap);
+#ifdef QML_RUNTIME_TESTING
+        groupNode->description = QLatin1String("group");
+#endif
+    }
+    return groupNode;
+}
+
+Q_DECLARE_OPERATORS_FOR_FLAGS(QQuickItemPrivate::ChangeTypes);
+
+QT_END_NAMESPACE
+
+QML_DECLARE_TYPE(QQuickKeysAttached)
+QML_DECLARE_TYPEINFO(QQuickKeysAttached, QML_HAS_ATTACHED_PROPERTIES)
+QML_DECLARE_TYPE(QQuickKeyNavigationAttached)
+QML_DECLARE_TYPEINFO(QQuickKeyNavigationAttached, QML_HAS_ATTACHED_PROPERTIES)
+QML_DECLARE_TYPE(QQuickLayoutMirroringAttached)
+QML_DECLARE_TYPEINFO(QQuickLayoutMirroringAttached, QML_HAS_ATTACHED_PROPERTIES)
+
+#endif // QQUICKITEM_P_H