1 /****************************************************************************
3 ** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
4 ** Contact: http://www.qt-project.org/
6 ** This file is part of the QtDeclarative module of the Qt Toolkit.
8 ** $QT_BEGIN_LICENSE:LGPL$
9 ** GNU Lesser General Public License Usage
10 ** This file may be used under the terms of the GNU Lesser General Public
11 ** License version 2.1 as published by the Free Software Foundation and
12 ** appearing in the file LICENSE.LGPL included in the packaging of this
13 ** file. Please review the following information to ensure the GNU Lesser
14 ** General Public License version 2.1 requirements will be met:
15 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
17 ** In addition, as a special exception, Nokia gives you certain additional
18 ** rights. These rights are described in the Nokia Qt LGPL Exception
19 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
21 ** GNU General Public License Usage
22 ** Alternatively, this file may be used under the terms of the GNU General
23 ** Public License version 3.0 as published by the Free Software Foundation
24 ** and appearing in the file LICENSE.GPL included in the packaging of this
25 ** file. Please review the following information to ensure the GNU General
26 ** Public License version 3.0 requirements will be met:
27 ** http://www.gnu.org/copyleft/gpl.html.
30 ** Alternatively, this file may be used in accordance with the terms and
31 ** conditions contained in a signed written agreement between you and Nokia.
40 ****************************************************************************/
42 #include "qquickitem.h"
44 #include "qquickcanvas.h"
45 #include <QtDeclarative/qjsengine.h>
46 #include "qquickcanvas_p.h"
48 #include "qquickevents_p_p.h"
49 #include "qquickscreen_p.h"
51 #include <QtDeclarative/qdeclarativeengine.h>
52 #include <QtDeclarative/qdeclarativecomponent.h>
53 #include <QtDeclarative/qdeclarativeinfo.h>
54 #include <QtGui/qpen.h>
55 #include <QtGui/qcursor.h>
56 #include <QtGui/qguiapplication.h>
57 #include <QtGui/qinputpanel.h>
58 #include <QtCore/qdebug.h>
59 #include <QtCore/qcoreevent.h>
60 #include <QtCore/qnumeric.h>
62 #include <private/qdeclarativeengine_p.h>
63 #include <QtQuick/private/qdeclarativestategroup_p.h>
64 #include <private/qdeclarativeopenmetaobject_p.h>
65 #include <QtQuick/private/qdeclarativestate_p.h>
66 #include <private/qlistmodelinterface_p.h>
67 #include <private/qquickitem_p.h>
68 #include <private/qdeclarativeaccessors_p.h>
69 #include <QtQuick/private/qquickaccessibleattached_p.h>
73 // XXX todo Check that elements that create items handle memory correctly after visual ownership change
77 static void QQuickItem_parentNotifier(QObject *o, intptr_t, QDeclarativeNotifier **n)
79 QQuickItemPrivate *d = QQuickItemPrivate::get(static_cast<QQuickItem *>(o));
80 *n = &d->parentNotifier;
83 QML_PRIVATE_ACCESSOR(QQuickItem, QQuickItem *, parent, parentItem)
84 QML_PRIVATE_ACCESSOR(QQuickItem, qreal, x, x)
85 QML_PRIVATE_ACCESSOR(QQuickItem, qreal, y, y)
86 QML_PRIVATE_ACCESSOR(QQuickItem, qreal, width, width)
87 QML_PRIVATE_ACCESSOR(QQuickItem, qreal, height, height)
89 static QDeclarativeAccessors QQuickItem_parent = { QQuickItem_parentRead, QQuickItem_parentNotifier };
90 static QDeclarativeAccessors QQuickItem_x = { QQuickItem_xRead, 0 };
91 static QDeclarativeAccessors QQuickItem_y = { QQuickItem_yRead, 0 };
92 static QDeclarativeAccessors QQuickItem_width = { QQuickItem_widthRead, 0 };
93 static QDeclarativeAccessors QQuickItem_height = { QQuickItem_heightRead, 0 };
95 QML_DECLARE_PROPERTIES(QQuickItem) {
96 { QML_PROPERTY_NAME(parent), 0, &QQuickItem_parent },
97 { QML_PROPERTY_NAME(x), 0, &QQuickItem_x },
98 { QML_PROPERTY_NAME(y), 0, &QQuickItem_y },
99 { QML_PROPERTY_NAME(width), 0, &QQuickItem_width },
100 { QML_PROPERTY_NAME(height), 0, &QQuickItem_height }
103 void QQuickItemPrivate::registerAccessorProperties()
105 QML_DEFINE_PROPERTIES(QQuickItem);
109 \qmlclass Transform QQuickTransform
110 \inqmlmodule QtQuick 2
111 \ingroup qml-transform-elements
112 \brief The Transform elements provide a way of building advanced transformations on Items.
114 The Transform element is a base type which cannot be instantiated directly.
115 The following concrete Transform types are available:
123 The Transform elements let you create and control advanced transformations that can be configured
124 independently using specialized properties.
126 You can assign any number of Transform elements to an \l Item. Each Transform is applied in order,
131 \qmlclass Translate QQuickTranslate
132 \inqmlmodule QtQuick 2
133 \ingroup qml-transform-elements
134 \brief The Translate object provides a way to move an Item without changing its x or y properties.
136 The Translate object provides independent control over position in addition to the Item's x and y properties.
138 The following example moves the Y axis of the \l Rectangle elements while still allowing the \l Row element
139 to lay the items out as if they had not been transformed:
145 width: 100; height: 100
147 transform: Translate { y: 20 }
150 width: 100; height: 100
152 transform: Translate { y: -20 }
161 \qmlproperty real QtQuick2::Translate::x
163 The translation along the X axis.
167 \qmlproperty real QtQuick2::Translate::y
169 The translation along the Y axis.
173 \qmlclass Scale QQuickScale
174 \inqmlmodule QtQuick 2
175 \ingroup qml-transform-elements
176 \brief The Scale element provides a way to scale an Item.
178 The Scale element gives more control over scaling than using \l Item's \l{Item::scale}{scale} property. Specifically,
179 it allows a different scale for the x and y axes, and allows the scale to be relative to an
182 The following example scales the X axis of the Rectangle, relative to its interior point 25, 25:
185 width: 100; height: 100
187 transform: Scale { origin.x: 25; origin.y: 25; xScale: 3}
191 \sa Rotation, Translate
195 \qmlproperty real QtQuick2::Scale::origin.x
196 \qmlproperty real QtQuick2::Scale::origin.y
198 The point that the item is scaled from (i.e., the point that stays fixed relative to the parent as
199 the rest of the item grows). By default the origin is 0, 0.
203 \qmlproperty real QtQuick2::Scale::xScale
205 The scaling factor for the X axis.
209 \qmlproperty real QtQuick2::Scale::yScale
211 The scaling factor for the Y axis.
215 \qmlclass Rotation QQuickRotation
216 \inqmlmodule QtQuick 2
217 \ingroup qml-transform-elements
218 \brief The Rotation object provides a way to rotate an Item.
220 The Rotation object gives more control over rotation than using \l Item's \l{Item::rotation}{rotation} property.
221 Specifically, it allows (z axis) rotation to be relative to an arbitrary point.
223 The following example rotates a Rectangle around its interior point 25, 25:
226 width: 100; height: 100
228 transform: Rotation { origin.x: 25; origin.y: 25; angle: 45}
232 Rotation also provides a way to specify 3D-like rotations for Items. For these types of
233 rotations you must specify the axis to rotate around in addition to the origin point.
235 The following example shows various 3D-like rotations applied to an \l Image.
236 \snippet doc/src/snippets/declarative/rotation.qml 0
238 \image axisrotation.png
240 \sa {declarative/ui-components/dialcontrol}{Dial Control example}, {declarative/toys/clocks}{Clocks example}
244 \qmlproperty real QtQuick2::Rotation::origin.x
245 \qmlproperty real QtQuick2::Rotation::origin.y
247 The origin point of the rotation (i.e., the point that stays fixed relative to the parent as
248 the rest of the item rotates). By default the origin is 0, 0.
252 \qmlproperty real QtQuick2::Rotation::axis.x
253 \qmlproperty real QtQuick2::Rotation::axis.y
254 \qmlproperty real QtQuick2::Rotation::axis.z
256 The axis to rotate around. For simple (2D) rotation around a point, you do not need to specify an axis,
257 as the default axis is the z axis (\c{ axis { x: 0; y: 0; z: 1 } }).
259 For a typical 3D-like rotation you will usually specify both the origin and the axis.
261 \image 3d-rotation-axis.png
265 \qmlproperty real QtQuick2::Rotation::angle
267 The angle to rotate, in degrees clockwise.
270 QQuickTransformPrivate::QQuickTransformPrivate()
274 QQuickTransform::QQuickTransform(QObject *parent)
275 : QObject(*(new QQuickTransformPrivate), parent)
279 QQuickTransform::QQuickTransform(QQuickTransformPrivate &dd, QObject *parent)
280 : QObject(dd, parent)
284 QQuickTransform::~QQuickTransform()
286 Q_D(QQuickTransform);
287 for (int ii = 0; ii < d->items.count(); ++ii) {
288 QQuickItemPrivate *p = QQuickItemPrivate::get(d->items.at(ii));
289 p->transforms.removeOne(this);
290 p->dirty(QQuickItemPrivate::Transform);
294 void QQuickTransform::update()
296 Q_D(QQuickTransform);
297 for (int ii = 0; ii < d->items.count(); ++ii) {
298 QQuickItemPrivate *p = QQuickItemPrivate::get(d->items.at(ii));
299 p->dirty(QQuickItemPrivate::Transform);
303 QQuickContents::QQuickContents(QQuickItem *item)
304 : m_item(item), m_x(0), m_y(0), m_width(0), m_height(0)
308 QQuickContents::~QQuickContents()
310 QList<QQuickItem *> children = m_item->childItems();
311 for (int i = 0; i < children.count(); ++i) {
312 QQuickItem *child = children.at(i);
313 QQuickItemPrivate::get(child)->removeItemChangeListener(this, QQuickItemPrivate::Geometry | QQuickItemPrivate::Destroyed);
317 bool QQuickContents::calcHeight(QQuickItem *changed)
320 qreal oldheight = m_height;
324 qreal bottom = oldy + oldheight;
325 qreal y = changed->y();
326 if (y + changed->height() > bottom)
327 bottom = y + changed->height();
331 m_height = bottom - top;
335 QList<QQuickItem *> children = m_item->childItems();
336 for (int i = 0; i < children.count(); ++i) {
337 QQuickItem *child = children.at(i);
338 qreal y = child->y();
339 if (y + child->height() > bottom)
340 bottom = y + child->height();
344 if (!children.isEmpty())
346 m_height = qMax(bottom - top, qreal(0.0));
349 return (m_height != oldheight || m_y != oldy);
352 bool QQuickContents::calcWidth(QQuickItem *changed)
355 qreal oldwidth = m_width;
359 qreal right = oldx + oldwidth;
360 qreal x = changed->x();
361 if (x + changed->width() > right)
362 right = x + changed->width();
366 m_width = right - left;
368 qreal left = FLT_MAX;
370 QList<QQuickItem *> children = m_item->childItems();
371 for (int i = 0; i < children.count(); ++i) {
372 QQuickItem *child = children.at(i);
373 qreal x = child->x();
374 if (x + child->width() > right)
375 right = x + child->width();
379 if (!children.isEmpty())
381 m_width = qMax(right - left, qreal(0.0));
384 return (m_width != oldwidth || m_x != oldx);
387 void QQuickContents::complete()
389 QQuickItemPrivate::get(m_item)->addItemChangeListener(this, QQuickItemPrivate::Children);
391 QList<QQuickItem *> children = m_item->childItems();
392 for (int i = 0; i < children.count(); ++i) {
393 QQuickItem *child = children.at(i);
394 QQuickItemPrivate::get(child)->addItemChangeListener(this, QQuickItemPrivate::Geometry | QQuickItemPrivate::Destroyed);
395 //###what about changes to visibility?
400 void QQuickContents::updateRect()
402 QQuickItemPrivate::get(m_item)->emitChildrenRectChanged(rectF());
405 void QQuickContents::itemGeometryChanged(QQuickItem *changed, const QRectF &newGeometry, const QRectF &oldGeometry)
408 bool wChanged = false;
409 bool hChanged = false;
410 //### we can only pass changed if the left edge has moved left, or the right edge has moved right
411 if (newGeometry.width() != oldGeometry.width() || newGeometry.x() != oldGeometry.x())
412 wChanged = calcWidth(/*changed*/);
413 if (newGeometry.height() != oldGeometry.height() || newGeometry.y() != oldGeometry.y())
414 hChanged = calcHeight(/*changed*/);
415 if (wChanged || hChanged)
419 void QQuickContents::itemDestroyed(QQuickItem *item)
422 QQuickItemPrivate::get(item)->removeItemChangeListener(this, QQuickItemPrivate::Geometry | QQuickItemPrivate::Destroyed);
426 void QQuickContents::itemChildRemoved(QQuickItem *, QQuickItem *item)
429 QQuickItemPrivate::get(item)->removeItemChangeListener(this, QQuickItemPrivate::Geometry | QQuickItemPrivate::Destroyed);
433 void QQuickContents::itemChildAdded(QQuickItem *, QQuickItem *item)
436 QQuickItemPrivate::get(item)->addItemChangeListener(this, QQuickItemPrivate::Geometry | QQuickItemPrivate::Destroyed);
440 QQuickItemKeyFilter::QQuickItemKeyFilter(QQuickItem *item)
441 : m_processPost(false), m_next(0)
443 QQuickItemPrivate *p = item?QQuickItemPrivate::get(item):0;
445 m_next = p->keyHandler;
446 p->keyHandler = this;
450 QQuickItemKeyFilter::~QQuickItemKeyFilter()
454 void QQuickItemKeyFilter::keyPressed(QKeyEvent *event, bool post)
456 if (m_next) m_next->keyPressed(event, post);
459 void QQuickItemKeyFilter::keyReleased(QKeyEvent *event, bool post)
461 if (m_next) m_next->keyReleased(event, post);
464 void QQuickItemKeyFilter::inputMethodEvent(QInputMethodEvent *event, bool post)
467 m_next->inputMethodEvent(event, post);
472 QVariant QQuickItemKeyFilter::inputMethodQuery(Qt::InputMethodQuery query) const
474 if (m_next) return m_next->inputMethodQuery(query);
478 void QQuickItemKeyFilter::componentComplete()
480 if (m_next) m_next->componentComplete();
483 \qmlclass KeyNavigation QQuickKeyNavigationAttached
484 \inqmlmodule QtQuick 2
485 \ingroup qml-basic-interaction-elements
486 \brief The KeyNavigation attached property supports key navigation by arrow keys.
488 Key-based user interfaces commonly allow the use of arrow keys to navigate between
489 focusable items. The KeyNavigation attached property enables this behavior by providing a
490 convenient way to specify the item that should gain focus when an arrow or tab key is pressed.
492 The following example provides key navigation for a 2x2 grid of items:
494 \snippet doc/src/snippets/declarative/keynavigation.qml 0
496 The top-left item initially receives focus by setting \l {Item::}{focus} to
497 \c true. When an arrow key is pressed, the focus will move to the
498 appropriate item, as defined by the value that has been set for
499 the KeyNavigation \l left, \l right, \l up or \l down properties.
501 Note that if a KeyNavigation attached property receives the key press and release
502 events for a requested arrow or tab key, the event is accepted and does not
503 propagate any further.
505 By default, KeyNavigation receives key events after the item to which it is attached.
506 If the item accepts the key event, the KeyNavigation attached property will not
507 receive an event for that key. Setting the \l priority property to
508 \c KeyNavigation.BeforeItem allows the event to be used for key navigation
509 before the item, rather than after.
511 If item to which the focus is switching is not enabled or visible, an attempt will
512 be made to skip this item and focus on the next. This is possible if there are
513 a chain of items with the same KeyNavigation handler. If multiple items in a row are not enabled
514 or visible, they will also be skipped.
516 KeyNavigation will implicitly set the other direction to return focus to this item. So if you set
517 \l left to another item, \l right will be set on that item's KeyNavigation to set focus back to this
518 item. However, if that item's KeyNavigation has had right explicitly set then no change will occur.
519 This means that the above example could have been written, with the same behaviour, without specifing
520 KeyNavigation.right or KeyNavigation.down for any of the items.
522 \sa {Keys}{Keys attached property}
526 \qmlproperty Item QtQuick2::KeyNavigation::left
527 \qmlproperty Item QtQuick2::KeyNavigation::right
528 \qmlproperty Item QtQuick2::KeyNavigation::up
529 \qmlproperty Item QtQuick2::KeyNavigation::down
530 \qmlproperty Item QtQuick2::KeyNavigation::tab
531 \qmlproperty Item QtQuick2::KeyNavigation::backtab
533 These properties hold the item to assign focus to
534 when the left, right, up or down cursor keys, or the
539 \qmlproperty Item QtQuick2::KeyNavigation::tab
540 \qmlproperty Item QtQuick2::KeyNavigation::backtab
542 These properties hold the item to assign focus to
543 when the Tab key or Shift+Tab key combination (Backtab) are pressed.
546 QQuickKeyNavigationAttached::QQuickKeyNavigationAttached(QObject *parent)
547 : QObject(*(new QQuickKeyNavigationAttachedPrivate), parent),
548 QQuickItemKeyFilter(qobject_cast<QQuickItem*>(parent))
550 m_processPost = true;
553 QQuickKeyNavigationAttached *
554 QQuickKeyNavigationAttached::qmlAttachedProperties(QObject *obj)
556 return new QQuickKeyNavigationAttached(obj);
559 QQuickItem *QQuickKeyNavigationAttached::left() const
561 Q_D(const QQuickKeyNavigationAttached);
565 void QQuickKeyNavigationAttached::setLeft(QQuickItem *i)
567 Q_D(QQuickKeyNavigationAttached);
572 QQuickKeyNavigationAttached* other =
573 qobject_cast<QQuickKeyNavigationAttached*>(qmlAttachedPropertiesObject<QQuickKeyNavigationAttached>(i));
574 if (other && !other->d_func()->rightSet){
575 other->d_func()->right = qobject_cast<QQuickItem*>(parent());
576 emit other->rightChanged();
581 QQuickItem *QQuickKeyNavigationAttached::right() const
583 Q_D(const QQuickKeyNavigationAttached);
587 void QQuickKeyNavigationAttached::setRight(QQuickItem *i)
589 Q_D(QQuickKeyNavigationAttached);
594 QQuickKeyNavigationAttached* other =
595 qobject_cast<QQuickKeyNavigationAttached*>(qmlAttachedPropertiesObject<QQuickKeyNavigationAttached>(i));
596 if (other && !other->d_func()->leftSet){
597 other->d_func()->left = qobject_cast<QQuickItem*>(parent());
598 emit other->leftChanged();
603 QQuickItem *QQuickKeyNavigationAttached::up() const
605 Q_D(const QQuickKeyNavigationAttached);
609 void QQuickKeyNavigationAttached::setUp(QQuickItem *i)
611 Q_D(QQuickKeyNavigationAttached);
616 QQuickKeyNavigationAttached* other =
617 qobject_cast<QQuickKeyNavigationAttached*>(qmlAttachedPropertiesObject<QQuickKeyNavigationAttached>(i));
618 if (other && !other->d_func()->downSet){
619 other->d_func()->down = qobject_cast<QQuickItem*>(parent());
620 emit other->downChanged();
625 QQuickItem *QQuickKeyNavigationAttached::down() const
627 Q_D(const QQuickKeyNavigationAttached);
631 void QQuickKeyNavigationAttached::setDown(QQuickItem *i)
633 Q_D(QQuickKeyNavigationAttached);
638 QQuickKeyNavigationAttached* other =
639 qobject_cast<QQuickKeyNavigationAttached*>(qmlAttachedPropertiesObject<QQuickKeyNavigationAttached>(i));
640 if (other && !other->d_func()->upSet) {
641 other->d_func()->up = qobject_cast<QQuickItem*>(parent());
642 emit other->upChanged();
647 QQuickItem *QQuickKeyNavigationAttached::tab() const
649 Q_D(const QQuickKeyNavigationAttached);
653 void QQuickKeyNavigationAttached::setTab(QQuickItem *i)
655 Q_D(QQuickKeyNavigationAttached);
660 QQuickKeyNavigationAttached* other =
661 qobject_cast<QQuickKeyNavigationAttached*>(qmlAttachedPropertiesObject<QQuickKeyNavigationAttached>(i));
662 if (other && !other->d_func()->backtabSet) {
663 other->d_func()->backtab = qobject_cast<QQuickItem*>(parent());
664 emit other->backtabChanged();
669 QQuickItem *QQuickKeyNavigationAttached::backtab() const
671 Q_D(const QQuickKeyNavigationAttached);
675 void QQuickKeyNavigationAttached::setBacktab(QQuickItem *i)
677 Q_D(QQuickKeyNavigationAttached);
681 d->backtabSet = true;
682 QQuickKeyNavigationAttached* other =
683 qobject_cast<QQuickKeyNavigationAttached*>(qmlAttachedPropertiesObject<QQuickKeyNavigationAttached>(i));
684 if (other && !other->d_func()->tabSet) {
685 other->d_func()->tab = qobject_cast<QQuickItem*>(parent());
686 emit other->tabChanged();
688 emit backtabChanged();
692 \qmlproperty enumeration QtQuick2::KeyNavigation::priority
694 This property determines whether the keys are processed before
695 or after the attached item's own key handling.
698 \o KeyNavigation.BeforeItem - process the key events before normal
699 item key processing. If the event is used for key navigation, it will be accepted and will not
700 be passed on to the item.
701 \o KeyNavigation.AfterItem (default) - process the key events after normal item key
702 handling. If the item accepts the key event it will not be
703 handled by the KeyNavigation attached property handler.
706 QQuickKeyNavigationAttached::Priority QQuickKeyNavigationAttached::priority() const
708 return m_processPost ? AfterItem : BeforeItem;
711 void QQuickKeyNavigationAttached::setPriority(Priority order)
713 bool processPost = order == AfterItem;
714 if (processPost != m_processPost) {
715 m_processPost = processPost;
716 emit priorityChanged();
720 void QQuickKeyNavigationAttached::keyPressed(QKeyEvent *event, bool post)
722 Q_D(QQuickKeyNavigationAttached);
725 if (post != m_processPost) {
726 QQuickItemKeyFilter::keyPressed(event, post);
731 switch (event->key()) {
733 if (QQuickItem *parentItem = qobject_cast<QQuickItem*>(parent()))
734 mirror = QQuickItemPrivate::get(parentItem)->effectiveLayoutMirror;
735 QQuickItem* leftItem = mirror ? d->right : d->left;
737 setFocusNavigation(leftItem, mirror ? "right" : "left");
742 case Qt::Key_Right: {
743 if (QQuickItem *parentItem = qobject_cast<QQuickItem*>(parent()))
744 mirror = QQuickItemPrivate::get(parentItem)->effectiveLayoutMirror;
745 QQuickItem* rightItem = mirror ? d->left : d->right;
747 setFocusNavigation(rightItem, mirror ? "left" : "right");
754 setFocusNavigation(d->up, "up");
760 setFocusNavigation(d->down, "down");
766 setFocusNavigation(d->tab, "tab");
770 case Qt::Key_Backtab:
772 setFocusNavigation(d->backtab, "backtab");
780 if (!event->isAccepted()) QQuickItemKeyFilter::keyPressed(event, post);
783 void QQuickKeyNavigationAttached::keyReleased(QKeyEvent *event, bool post)
785 Q_D(QQuickKeyNavigationAttached);
788 if (post != m_processPost) {
789 QQuickItemKeyFilter::keyReleased(event, post);
794 switch (event->key()) {
796 if (QQuickItem *parentItem = qobject_cast<QQuickItem*>(parent()))
797 mirror = QQuickItemPrivate::get(parentItem)->effectiveLayoutMirror;
798 if (mirror ? d->right : d->left)
802 if (QQuickItem *parentItem = qobject_cast<QQuickItem*>(parent()))
803 mirror = QQuickItemPrivate::get(parentItem)->effectiveLayoutMirror;
804 if (mirror ? d->left : d->right)
822 case Qt::Key_Backtab:
831 if (!event->isAccepted()) QQuickItemKeyFilter::keyReleased(event, post);
834 void QQuickKeyNavigationAttached::setFocusNavigation(QQuickItem *currentItem, const char *dir)
836 QQuickItem *initialItem = currentItem;
837 bool isNextItem = false;
840 if (currentItem->isVisible() && currentItem->isEnabled()) {
841 currentItem->setFocus(true);
844 qmlAttachedPropertiesObject<QQuickKeyNavigationAttached>(currentItem, false);
846 QQuickItem *tempItem = qvariant_cast<QQuickItem*>(attached->property(dir));
848 currentItem = tempItem;
854 while (currentItem != initialItem && isNextItem);
857 const QQuickKeysAttached::SigMap QQuickKeysAttached::sigMap[] = {
858 { Qt::Key_Left, "leftPressed" },
859 { Qt::Key_Right, "rightPressed" },
860 { Qt::Key_Up, "upPressed" },
861 { Qt::Key_Down, "downPressed" },
862 { Qt::Key_Tab, "tabPressed" },
863 { Qt::Key_Backtab, "backtabPressed" },
864 { Qt::Key_Asterisk, "asteriskPressed" },
865 { Qt::Key_NumberSign, "numberSignPressed" },
866 { Qt::Key_Escape, "escapePressed" },
867 { Qt::Key_Return, "returnPressed" },
868 { Qt::Key_Enter, "enterPressed" },
869 { Qt::Key_Delete, "deletePressed" },
870 { Qt::Key_Space, "spacePressed" },
871 { Qt::Key_Back, "backPressed" },
872 { Qt::Key_Cancel, "cancelPressed" },
873 { Qt::Key_Select, "selectPressed" },
874 { Qt::Key_Yes, "yesPressed" },
875 { Qt::Key_No, "noPressed" },
876 { Qt::Key_Context1, "context1Pressed" },
877 { Qt::Key_Context2, "context2Pressed" },
878 { Qt::Key_Context3, "context3Pressed" },
879 { Qt::Key_Context4, "context4Pressed" },
880 { Qt::Key_Call, "callPressed" },
881 { Qt::Key_Hangup, "hangupPressed" },
882 { Qt::Key_Flip, "flipPressed" },
883 { Qt::Key_Menu, "menuPressed" },
884 { Qt::Key_VolumeUp, "volumeUpPressed" },
885 { Qt::Key_VolumeDown, "volumeDownPressed" },
889 bool QQuickKeysAttachedPrivate::isConnected(const char *signalName)
891 return isSignalConnected(signalIndex(signalName));
895 \qmlclass Keys QQuickKeysAttached
896 \inqmlmodule QtQuick 2
897 \ingroup qml-basic-interaction-elements
898 \brief The Keys attached property provides key handling to Items.
900 All visual primitives support key handling via the Keys
901 attached property. Keys can be handled via the onPressed
902 and onReleased signal properties.
904 The signal properties have a \l KeyEvent parameter, named
905 \e event which contains details of the event. If a key is
906 handled \e event.accepted should be set to true to prevent the
907 event from propagating up the item hierarchy.
909 \section1 Example Usage
911 The following example shows how the general onPressed handler can
912 be used to test for a certain key; in this case, the left cursor
915 \snippet doc/src/snippets/declarative/keys/keys-pressed.qml key item
917 Some keys may alternatively be handled via specific signal properties,
918 for example \e onSelectPressed. These handlers automatically set
919 \e event.accepted to true.
921 \snippet doc/src/snippets/declarative/keys/keys-handler.qml key item
923 See \l{Qt::Key}{Qt.Key} for the list of keyboard codes.
925 \section1 Key Handling Priorities
927 The Keys attached property can be configured to handle key events
928 before or after the item it is attached to. This makes it possible
929 to intercept events in order to override an item's default behavior,
930 or act as a fallback for keys not handled by the item.
932 If \l priority is Keys.BeforeItem (default) the order of key event processing is:
935 \o Items specified in \c forwardTo
936 \o specific key handlers, e.g. onReturnPressed
937 \o onKeyPress, onKeyRelease handlers
938 \o Item specific key handling, e.g. TextInput key handling
942 If priority is Keys.AfterItem the order of key event processing is:
945 \o Item specific key handling, e.g. TextInput key handling
946 \o Items specified in \c forwardTo
947 \o specific key handlers, e.g. onReturnPressed
948 \o onKeyPress, onKeyRelease handlers
952 If the event is accepted during any of the above steps, key
955 \sa KeyEvent, {KeyNavigation}{KeyNavigation attached property}
959 \qmlproperty bool QtQuick2::Keys::enabled
961 This flags enables key handling if true (default); otherwise
962 no key handlers will be called.
966 \qmlproperty enumeration QtQuick2::Keys::priority
968 This property determines whether the keys are processed before
969 or after the attached item's own key handling.
972 \o Keys.BeforeItem (default) - process the key events before normal
973 item key processing. If the event is accepted it will not
974 be passed on to the item.
975 \o Keys.AfterItem - process the key events after normal item key
976 handling. If the item accepts the key event it will not be
977 handled by the Keys attached property handler.
982 \qmlproperty list<Object> QtQuick2::Keys::forwardTo
984 This property provides a way to forward key presses, key releases, and keyboard input
985 coming from input methods to other items. This can be useful when you want
986 one item to handle some keys (e.g. the up and down arrow keys), and another item to
987 handle other keys (e.g. the left and right arrow keys). Once an item that has been
988 forwarded keys accepts the event it is no longer forwarded to items later in the
991 This example forwards key events to two lists:
1002 Keys.forwardTo: [list1, list2]
1009 \qmlsignal QtQuick2::Keys::onPressed(KeyEvent event)
1011 This handler is called when a key has been pressed. The \a event
1012 parameter provides information about the event.
1016 \qmlsignal QtQuick2::Keys::onReleased(KeyEvent event)
1018 This handler is called when a key has been released. The \a event
1019 parameter provides information about the event.
1023 \qmlsignal QtQuick2::Keys::onDigit0Pressed(KeyEvent event)
1025 This handler is called when the digit '0' has been pressed. The \a event
1026 parameter provides information about the event.
1030 \qmlsignal QtQuick2::Keys::onDigit1Pressed(KeyEvent event)
1032 This handler is called when the digit '1' has been pressed. The \a event
1033 parameter provides information about the event.
1037 \qmlsignal QtQuick2::Keys::onDigit2Pressed(KeyEvent event)
1039 This handler is called when the digit '2' has been pressed. The \a event
1040 parameter provides information about the event.
1044 \qmlsignal QtQuick2::Keys::onDigit3Pressed(KeyEvent event)
1046 This handler is called when the digit '3' has been pressed. The \a event
1047 parameter provides information about the event.
1051 \qmlsignal QtQuick2::Keys::onDigit4Pressed(KeyEvent event)
1053 This handler is called when the digit '4' has been pressed. The \a event
1054 parameter provides information about the event.
1058 \qmlsignal QtQuick2::Keys::onDigit5Pressed(KeyEvent event)
1060 This handler is called when the digit '5' has been pressed. The \a event
1061 parameter provides information about the event.
1065 \qmlsignal QtQuick2::Keys::onDigit6Pressed(KeyEvent event)
1067 This handler is called when the digit '6' has been pressed. The \a event
1068 parameter provides information about the event.
1072 \qmlsignal QtQuick2::Keys::onDigit7Pressed(KeyEvent event)
1074 This handler is called when the digit '7' has been pressed. The \a event
1075 parameter provides information about the event.
1079 \qmlsignal QtQuick2::Keys::onDigit8Pressed(KeyEvent event)
1081 This handler is called when the digit '8' has been pressed. The \a event
1082 parameter provides information about the event.
1086 \qmlsignal QtQuick2::Keys::onDigit9Pressed(KeyEvent event)
1088 This handler is called when the digit '9' has been pressed. The \a event
1089 parameter provides information about the event.
1093 \qmlsignal QtQuick2::Keys::onLeftPressed(KeyEvent event)
1095 This handler is called when the Left arrow has been pressed. The \a event
1096 parameter provides information about the event.
1100 \qmlsignal QtQuick2::Keys::onRightPressed(KeyEvent event)
1102 This handler is called when the Right arrow has been pressed. The \a event
1103 parameter provides information about the event.
1107 \qmlsignal QtQuick2::Keys::onUpPressed(KeyEvent event)
1109 This handler is called when the Up arrow has been pressed. The \a event
1110 parameter provides information about the event.
1114 \qmlsignal QtQuick2::Keys::onDownPressed(KeyEvent event)
1116 This handler is called when the Down arrow has been pressed. The \a event
1117 parameter provides information about the event.
1121 \qmlsignal QtQuick2::Keys::onTabPressed(KeyEvent event)
1123 This handler is called when the Tab key has been pressed. The \a event
1124 parameter provides information about the event.
1128 \qmlsignal QtQuick2::Keys::onBacktabPressed(KeyEvent event)
1130 This handler is called when the Shift+Tab key combination (Backtab) has
1131 been pressed. The \a event parameter provides information about the event.
1135 \qmlsignal QtQuick2::Keys::onAsteriskPressed(KeyEvent event)
1137 This handler is called when the Asterisk '*' has been pressed. The \a event
1138 parameter provides information about the event.
1142 \qmlsignal QtQuick2::Keys::onEscapePressed(KeyEvent event)
1144 This handler is called when the Escape key has been pressed. The \a event
1145 parameter provides information about the event.
1149 \qmlsignal QtQuick2::Keys::onReturnPressed(KeyEvent event)
1151 This handler is called when the Return key has been pressed. The \a event
1152 parameter provides information about the event.
1156 \qmlsignal QtQuick2::Keys::onEnterPressed(KeyEvent event)
1158 This handler is called when the Enter key has been pressed. The \a event
1159 parameter provides information about the event.
1163 \qmlsignal QtQuick2::Keys::onDeletePressed(KeyEvent event)
1165 This handler is called when the Delete key has been pressed. The \a event
1166 parameter provides information about the event.
1170 \qmlsignal QtQuick2::Keys::onSpacePressed(KeyEvent event)
1172 This handler is called when the Space key has been pressed. The \a event
1173 parameter provides information about the event.
1177 \qmlsignal QtQuick2::Keys::onBackPressed(KeyEvent event)
1179 This handler is called when the Back key has been pressed. The \a event
1180 parameter provides information about the event.
1184 \qmlsignal QtQuick2::Keys::onCancelPressed(KeyEvent event)
1186 This handler is called when the Cancel key has been pressed. The \a event
1187 parameter provides information about the event.
1191 \qmlsignal QtQuick2::Keys::onSelectPressed(KeyEvent event)
1193 This handler is called when the Select key has been pressed. The \a event
1194 parameter provides information about the event.
1198 \qmlsignal QtQuick2::Keys::onYesPressed(KeyEvent event)
1200 This handler is called when the Yes key has been pressed. The \a event
1201 parameter provides information about the event.
1205 \qmlsignal QtQuick2::Keys::onNoPressed(KeyEvent event)
1207 This handler is called when the No key has been pressed. The \a event
1208 parameter provides information about the event.
1212 \qmlsignal QtQuick2::Keys::onContext1Pressed(KeyEvent event)
1214 This handler is called when the Context1 key has been pressed. The \a event
1215 parameter provides information about the event.
1219 \qmlsignal QtQuick2::Keys::onContext2Pressed(KeyEvent event)
1221 This handler is called when the Context2 key has been pressed. The \a event
1222 parameter provides information about the event.
1226 \qmlsignal QtQuick2::Keys::onContext3Pressed(KeyEvent event)
1228 This handler is called when the Context3 key has been pressed. The \a event
1229 parameter provides information about the event.
1233 \qmlsignal QtQuick2::Keys::onContext4Pressed(KeyEvent event)
1235 This handler is called when the Context4 key has been pressed. The \a event
1236 parameter provides information about the event.
1240 \qmlsignal QtQuick2::Keys::onCallPressed(KeyEvent event)
1242 This handler is called when the Call key has been pressed. The \a event
1243 parameter provides information about the event.
1247 \qmlsignal QtQuick2::Keys::onHangupPressed(KeyEvent event)
1249 This handler is called when the Hangup key has been pressed. The \a event
1250 parameter provides information about the event.
1254 \qmlsignal QtQuick2::Keys::onFlipPressed(KeyEvent event)
1256 This handler is called when the Flip key has been pressed. The \a event
1257 parameter provides information about the event.
1261 \qmlsignal QtQuick2::Keys::onMenuPressed(KeyEvent event)
1263 This handler is called when the Menu key has been pressed. The \a event
1264 parameter provides information about the event.
1268 \qmlsignal QtQuick2::Keys::onVolumeUpPressed(KeyEvent event)
1270 This handler is called when the VolumeUp key has been pressed. The \a event
1271 parameter provides information about the event.
1275 \qmlsignal QtQuick2::Keys::onVolumeDownPressed(KeyEvent event)
1277 This handler is called when the VolumeDown key has been pressed. The \a event
1278 parameter provides information about the event.
1281 QQuickKeysAttached::QQuickKeysAttached(QObject *parent)
1282 : QObject(*(new QQuickKeysAttachedPrivate), parent),
1283 QQuickItemKeyFilter(qobject_cast<QQuickItem*>(parent))
1285 Q_D(QQuickKeysAttached);
1286 m_processPost = false;
1287 d->item = qobject_cast<QQuickItem*>(parent);
1290 QQuickKeysAttached::~QQuickKeysAttached()
1294 QQuickKeysAttached::Priority QQuickKeysAttached::priority() const
1296 return m_processPost ? AfterItem : BeforeItem;
1299 void QQuickKeysAttached::setPriority(Priority order)
1301 bool processPost = order == AfterItem;
1302 if (processPost != m_processPost) {
1303 m_processPost = processPost;
1304 emit priorityChanged();
1308 void QQuickKeysAttached::componentComplete()
1310 Q_D(QQuickKeysAttached);
1312 for (int ii = 0; ii < d->targets.count(); ++ii) {
1313 QQuickItem *targetItem = d->targets.at(ii);
1314 if (targetItem && (targetItem->flags() & QQuickItem::ItemAcceptsInputMethod)) {
1315 d->item->setFlag(QQuickItem::ItemAcceptsInputMethod);
1322 void QQuickKeysAttached::keyPressed(QKeyEvent *event, bool post)
1324 Q_D(QQuickKeysAttached);
1325 if (post != m_processPost || !d->enabled || d->inPress) {
1327 QQuickItemKeyFilter::keyPressed(event, post);
1331 // first process forwards
1332 if (d->item && d->item->canvas()) {
1334 for (int ii = 0; ii < d->targets.count(); ++ii) {
1335 QQuickItem *i = d->targets.at(ii);
1336 if (i && i->isVisible()) {
1337 d->item->canvas()->sendEvent(i, event);
1338 if (event->isAccepted()) {
1347 QQuickKeyEvent ke(*event);
1348 QByteArray keySignal = keyToSignal(event->key());
1349 if (!keySignal.isEmpty()) {
1350 keySignal += "(QQuickKeyEvent*)";
1351 if (d->isConnected(keySignal)) {
1352 // If we specifically handle a key then default to accepted
1353 ke.setAccepted(true);
1354 int idx = QQuickKeysAttached::staticMetaObject.indexOfSignal(keySignal);
1355 metaObject()->method(idx).invoke(this, Qt::DirectConnection, Q_ARG(QQuickKeyEvent*, &ke));
1358 if (!ke.isAccepted())
1360 event->setAccepted(ke.isAccepted());
1362 if (!event->isAccepted()) QQuickItemKeyFilter::keyPressed(event, post);
1365 void QQuickKeysAttached::keyReleased(QKeyEvent *event, bool post)
1367 Q_D(QQuickKeysAttached);
1368 if (post != m_processPost || !d->enabled || d->inRelease) {
1370 QQuickItemKeyFilter::keyReleased(event, post);
1374 if (d->item && d->item->canvas()) {
1375 d->inRelease = true;
1376 for (int ii = 0; ii < d->targets.count(); ++ii) {
1377 QQuickItem *i = d->targets.at(ii);
1378 if (i && i->isVisible()) {
1379 d->item->canvas()->sendEvent(i, event);
1380 if (event->isAccepted()) {
1381 d->inRelease = false;
1386 d->inRelease = false;
1389 QQuickKeyEvent ke(*event);
1391 event->setAccepted(ke.isAccepted());
1393 if (!event->isAccepted()) QQuickItemKeyFilter::keyReleased(event, post);
1396 void QQuickKeysAttached::inputMethodEvent(QInputMethodEvent *event, bool post)
1398 Q_D(QQuickKeysAttached);
1399 if (post == m_processPost && d->item && !d->inIM && d->item->canvas()) {
1401 for (int ii = 0; ii < d->targets.count(); ++ii) {
1402 QQuickItem *i = d->targets.at(ii);
1403 if (i && i->isVisible() && (i->flags() & QQuickItem::ItemAcceptsInputMethod)) {
1404 d->item->canvas()->sendEvent(i, event);
1405 if (event->isAccepted()) {
1414 QQuickItemKeyFilter::inputMethodEvent(event, post);
1417 QVariant QQuickKeysAttached::inputMethodQuery(Qt::InputMethodQuery query) const
1419 Q_D(const QQuickKeysAttached);
1421 for (int ii = 0; ii < d->targets.count(); ++ii) {
1422 QQuickItem *i = d->targets.at(ii);
1423 if (i && i->isVisible() && (i->flags() & QQuickItem::ItemAcceptsInputMethod) && i == d->imeItem) {
1424 //### how robust is i == d->imeItem check?
1425 QVariant v = i->inputMethodQuery(query);
1426 if (v.userType() == QVariant::RectF)
1427 v = d->item->mapRectFromItem(i, v.toRectF()); //### cost?
1432 return QQuickItemKeyFilter::inputMethodQuery(query);
1435 QQuickKeysAttached *QQuickKeysAttached::qmlAttachedProperties(QObject *obj)
1437 return new QQuickKeysAttached(obj);
1441 \qmlclass LayoutMirroring QQuickLayoutMirroringAttached
1442 \inqmlmodule QtQuick 2
1443 \ingroup qml-utility-elements
1444 \brief The LayoutMirroring attached property is used to mirror layout behavior.
1446 The LayoutMirroring attached property is used to horizontally mirror \l {anchor-layout}{Item anchors},
1447 \l{Using QML Positioner and Repeater Items}{positioner} elements (such as \l Row and \l Grid)
1448 and views (such as \l GridView and horizontal \l ListView). Mirroring is a visual change: left
1449 anchors become right anchors, and positioner elements like \l Grid and \l Row reverse the
1450 horizontal layout of child items.
1452 Mirroring is enabled for an item by setting the \l enabled property to true. By default, this
1453 only affects the item itself; setting the \l childrenInherit property to true propagates the mirroring
1454 behavior to all child elements as well. If the \c LayoutMirroring attached property has not been defined
1455 for an item, mirroring is not enabled.
1457 The following example shows mirroring in action. The \l Row below is specified as being anchored
1458 to the left of its parent. However, since mirroring has been enabled, the anchor is horizontally
1459 reversed and it is now anchored to the right. Also, since items in a \l Row are positioned
1460 from left to right by default, they are now positioned from right to left instead, as demonstrated
1461 by the numbering and opacity of the items:
1463 \snippet doc/src/snippets/declarative/layoutmirroring.qml 0
1465 \image layoutmirroring.png
1467 Layout mirroring is useful when it is necessary to support both left-to-right and right-to-left
1468 layout versions of an application to target different language areas. The \l childrenInherit
1469 property allows layout mirroring to be applied without manually setting layout configurations
1470 for every item in an application. Keep in mind, however, that mirroring does not affect any
1471 positioning that is defined by the \l Item \l {Item::}{x} coordinate value, so even with
1472 mirroring enabled, it will often be necessary to apply some layout fixes to support the
1473 desired layout direction. Also, it may be necessary to disable the mirroring of individual
1474 child items (by setting \l {enabled}{LayoutMirroring.enabled} to false for such items) if
1475 mirroring is not the desired behavior, or if the child item already implements mirroring in
1478 See \l {QML Right-to-left User Interfaces} for further details on using \c LayoutMirroring and
1479 other related features to implement right-to-left support for an application.
1483 \qmlproperty bool QtQuick2::LayoutMirroring::enabled
1485 This property holds whether the item's layout is mirrored horizontally. Setting this to true
1486 horizontally reverses \l {anchor-layout}{anchor} settings such that left anchors become right,
1487 and right anchors become left. For \l{Using QML Positioner and Repeater Items}{positioner} elements
1488 (such as \l Row and \l Grid) and view elements (such as \l {GridView}{GridView} and \l {ListView}{ListView})
1489 this also mirrors the horizontal layout direction of the item.
1491 The default value is false.
1495 \qmlproperty bool QtQuick2::LayoutMirroring::childrenInherit
1497 This property holds whether the \l {enabled}{LayoutMirroring.enabled} value for this item
1498 is inherited by its children.
1500 The default value is false.
1504 QQuickLayoutMirroringAttached::QQuickLayoutMirroringAttached(QObject *parent) : QObject(parent), itemPrivate(0)
1506 if (QQuickItem *item = qobject_cast<QQuickItem*>(parent)) {
1507 itemPrivate = QQuickItemPrivate::get(item);
1508 itemPrivate->attachedLayoutDirection = this;
1510 qmlInfo(parent) << tr("LayoutDirection attached property only works with Items");
1513 QQuickLayoutMirroringAttached * QQuickLayoutMirroringAttached::qmlAttachedProperties(QObject *object)
1515 return new QQuickLayoutMirroringAttached(object);
1518 bool QQuickLayoutMirroringAttached::enabled() const
1520 return itemPrivate ? itemPrivate->effectiveLayoutMirror : false;
1523 void QQuickLayoutMirroringAttached::setEnabled(bool enabled)
1528 itemPrivate->isMirrorImplicit = false;
1529 if (enabled != itemPrivate->effectiveLayoutMirror) {
1530 itemPrivate->setLayoutMirror(enabled);
1531 if (itemPrivate->inheritMirrorFromItem)
1532 itemPrivate->resolveLayoutMirror();
1536 void QQuickLayoutMirroringAttached::resetEnabled()
1538 if (itemPrivate && !itemPrivate->isMirrorImplicit) {
1539 itemPrivate->isMirrorImplicit = true;
1540 itemPrivate->resolveLayoutMirror();
1544 bool QQuickLayoutMirroringAttached::childrenInherit() const
1546 return itemPrivate ? itemPrivate->inheritMirrorFromItem : false;
1549 void QQuickLayoutMirroringAttached::setChildrenInherit(bool childrenInherit) {
1550 if (itemPrivate && childrenInherit != itemPrivate->inheritMirrorFromItem) {
1551 itemPrivate->inheritMirrorFromItem = childrenInherit;
1552 itemPrivate->resolveLayoutMirror();
1553 childrenInheritChanged();
1557 void QQuickItemPrivate::resolveLayoutMirror()
1560 if (QQuickItem *parentItem = q->parentItem()) {
1561 QQuickItemPrivate *parentPrivate = QQuickItemPrivate::get(parentItem);
1562 setImplicitLayoutMirror(parentPrivate->inheritedLayoutMirror, parentPrivate->inheritMirrorFromParent);
1564 setImplicitLayoutMirror(isMirrorImplicit ? false : effectiveLayoutMirror, inheritMirrorFromItem);
1568 void QQuickItemPrivate::setImplicitLayoutMirror(bool mirror, bool inherit)
1570 inherit = inherit || inheritMirrorFromItem;
1571 if (!isMirrorImplicit && inheritMirrorFromItem)
1572 mirror = effectiveLayoutMirror;
1573 if (mirror == inheritedLayoutMirror && inherit == inheritMirrorFromParent)
1576 inheritMirrorFromParent = inherit;
1577 inheritedLayoutMirror = inheritMirrorFromParent ? mirror : false;
1579 if (isMirrorImplicit)
1580 setLayoutMirror(inherit ? inheritedLayoutMirror : false);
1581 for (int i = 0; i < childItems.count(); ++i) {
1582 if (QQuickItem *child = qobject_cast<QQuickItem *>(childItems.at(i))) {
1583 QQuickItemPrivate *childPrivate = QQuickItemPrivate::get(child);
1584 childPrivate->setImplicitLayoutMirror(inheritedLayoutMirror, inheritMirrorFromParent);
1589 void QQuickItemPrivate::setLayoutMirror(bool mirror)
1591 if (mirror != effectiveLayoutMirror) {
1592 effectiveLayoutMirror = mirror;
1594 QQuickAnchorsPrivate *anchor_d = QQuickAnchorsPrivate::get(_anchors);
1595 anchor_d->fillChanged();
1596 anchor_d->centerInChanged();
1597 anchor_d->updateHorizontalAnchors();
1598 emit _anchors->mirroredChanged();
1601 if (attachedLayoutDirection) {
1602 emit attachedLayoutDirection->enabledChanged();
1607 void QQuickItemPrivate::setAccessibleFlagAndListener()
1610 QQuickItem *item = q;
1612 if (item->d_func()->isAccessible)
1613 break; // already set - grandparents should have the flag set as well.
1615 if (item->canvas() && item->canvas()->rootItem() == item)
1616 break; // don't add a listener to the canvas root item
1618 item->d_func()->isAccessible = true;
1619 item = item->d_func()->parentItem;
1625 \brief The QQuickItem class provides the most basic of all visual items in QML.
1629 All visual items in Qt Declarative inherit from QQuickItem. Although QQuickItem
1630 has no visual appearance, it defines all the properties that are
1631 common across visual items - such as the x and y position, the
1632 width and height, \l {anchor-layout}{anchoring} and key handling.
1634 You can subclass QQuickItem to provide your own custom visual item that inherits
1635 these features. Note that, because it does not draw anything, QQuickItem sets the
1636 QGraphicsItem::ItemHasNoContents flag. If you subclass QQuickItem to create a visual
1637 item, you will need to unset this flag.
1642 \qmlclass Item QQuickItem
1644 \inqmlmodule QtQuick 2
1645 \ingroup qml-basic-visual-elements
1646 \brief The Item is the most basic of all visual items in QML.
1648 All visual items in Qt Declarative inherit from Item. Although Item
1649 has no visual appearance, it defines all the properties that are
1650 common across visual items - such as the x and y position, the
1651 width and height, \l {anchor-layout}{anchoring} and key handling.
1653 Item is also useful for grouping items together.
1670 fillMode: Image.Tile
1677 \section1 Key Handling
1679 Key handling is available to all Item-based visual elements via the \l {Keys}{Keys}
1680 attached property. The \e Keys attached property provides basic handlers such
1681 as \l {Keys::onPressed}{onPressed} and \l {Keys::onReleased}{onReleased},
1682 as well as handlers for specific keys, such as
1683 \l {Keys::onCancelPressed}{onCancelPressed}. The example below
1684 assigns \l {qmlfocus}{focus} to the item and handles
1685 the Left key via the general \e onPressed handler and the Select key via the
1686 onSelectPressed handler:
1692 if (event.key == Qt.Key_Left) {
1693 console.log("move left");
1694 event.accepted = true;
1697 Keys.onSelectPressed: console.log("Selected");
1701 See the \l {Keys}{Keys} attached property for detailed documentation.
1703 \section1 Layout Mirroring
1705 Item layouts can be mirrored using the \l {LayoutMirroring}{LayoutMirroring} attached property.
1710 \fn void QQuickItem::childrenRectChanged(const QRectF &)
1715 \fn void QQuickItem::baselineOffsetChanged(qreal)
1720 \fn void QQuickItem::stateChanged(const QString &state)
1725 \fn void QQuickItem::parentChanged(QQuickItem *)
1730 \fn void QQuickItem::smoothChanged(bool)
1735 \fn void QQuickItem::clipChanged(bool)
1739 /*! \fn void QQuickItem::transformOriginChanged(TransformOrigin)
1744 \fn void QQuickItem::focusChanged(bool)
1749 \fn void QQuickItem::activeFocusChanged(bool)
1753 \fn QQuickItem::QQuickItem(QQuickItem *parent)
1755 Constructs a QQuickItem with the given \a parent.
1757 QQuickItem::QQuickItem(QQuickItem* parent)
1758 : QObject(*(new QQuickItemPrivate), parent)
1766 QQuickItem::QQuickItem(QQuickItemPrivate &dd, QQuickItem *parent)
1767 : QObject(dd, parent)
1774 static int qt_item_count = 0;
1776 static void qt_print_item_count()
1778 qDebug("Number of leaked items: %i", qt_item_count);
1784 Destroys the QQuickItem.
1786 QQuickItem::~QQuickItem()
1790 if (qt_item_count < 0)
1791 qDebug("Item destroyed after qt_print_item_count() was called.");
1798 else if (d->canvas && d->itemNodeInstance)
1799 QQuickCanvasPrivate::get(d->canvas)->cleanup(d->itemNodeInstance); // cleanup root
1800 // XXX todo - optimize
1801 while (!d->childItems.isEmpty())
1802 d->childItems.first()->setParentItem(0);
1804 for (int ii = 0; ii < d->changeListeners.count(); ++ii) {
1805 QQuickAnchorsPrivate *anchor = d->changeListeners.at(ii).listener->anchorPrivate();
1807 anchor->clearItem(this);
1811 update item anchors that depended on us unless they are our child (and will also be destroyed),
1812 or our sibling, and our parent is also being destroyed.
1814 for (int ii = 0; ii < d->changeListeners.count(); ++ii) {
1815 QQuickAnchorsPrivate *anchor = d->changeListeners.at(ii).listener->anchorPrivate();
1816 if (anchor && anchor->item && anchor->item->parentItem() && anchor->item->parentItem() != this)
1820 for (int ii = 0; ii < d->changeListeners.count(); ++ii) {
1821 const QQuickItemPrivate::ChangeListener &change = d->changeListeners.at(ii);
1822 if (change.types & QQuickItemPrivate::Destroyed)
1823 change.listener->itemDestroyed(this);
1826 d->changeListeners.clear();
1827 delete d->_anchorLines; d->_anchorLines = 0;
1828 delete d->_anchors; d->_anchors = 0;
1829 delete d->_stateGroup; d->_stateGroup = 0;
1830 delete d->_contents; d->_contents = 0;
1835 \qmlproperty enumeration QtQuick2::Item::transformOrigin
1836 This property holds the origin point around which scale and rotation transform.
1838 Nine transform origins are available, as shown in the image below.
1840 \image declarative-transformorigin.png
1842 This example rotates an image around its bottom-right corner.
1845 source: "myimage.png"
1846 transformOrigin: Item.BottomRight
1851 The default transform origin is \c Item.Center.
1853 To set an arbitrary transform origin point use the \l Scale or \l Rotation
1858 \qmlproperty Item QtQuick2::Item::parent
1859 This property holds the parent of the item.
1863 \property QQuickItem::parent
1864 This property holds the parent of the item.
1866 void QQuickItem::setParentItem(QQuickItem *parentItem)
1869 if (parentItem == d->parentItem)
1872 d->removeFromDirtyList();
1874 QQuickItem *oldParentItem = d->parentItem;
1875 QQuickItem *scopeFocusedItem = 0;
1877 if (oldParentItem) {
1878 QQuickItemPrivate *op = QQuickItemPrivate::get(oldParentItem);
1880 QQuickItem *scopeItem = 0;
1882 if (d->canvas && hasFocus()) {
1883 scopeItem = oldParentItem;
1884 while (!scopeItem->isFocusScope()) scopeItem = scopeItem->parentItem();
1885 scopeFocusedItem = this;
1886 } else if (d->canvas && !isFocusScope() && d->subFocusItem) {
1887 scopeItem = oldParentItem;
1888 while (!scopeItem->isFocusScope()) scopeItem = scopeItem->parentItem();
1889 scopeFocusedItem = d->subFocusItem;
1892 if (scopeFocusedItem)
1893 QQuickCanvasPrivate::get(d->canvas)->clearFocusInScope(scopeItem, scopeFocusedItem,
1894 QQuickCanvasPrivate::DontChangeFocusProperty);
1896 op->removeChild(this);
1897 } else if (d->canvas) {
1898 QQuickCanvasPrivate::get(d->canvas)->parentlessItems.remove(this);
1901 d->parentItem = parentItem;
1903 QQuickCanvas *parentCanvas = parentItem?QQuickItemPrivate::get(parentItem)->canvas:0;
1904 if (d->canvas != parentCanvas) {
1905 QQuickItemPrivate::InitializationState initState;
1907 d->initCanvas(&initState, parentCanvas);
1910 d->dirty(QQuickItemPrivate::ParentChanged);
1913 QQuickItemPrivate::get(d->parentItem)->addChild(this);
1915 d->setEffectiveVisibleRecur(d->calcEffectiveVisible());
1916 d->setEffectiveEnableRecur(d->calcEffectiveEnable());
1918 if (scopeFocusedItem && d->parentItem && d->canvas) {
1919 // We need to test whether this item becomes scope focused
1920 QQuickItem *scopeItem = 0;
1921 scopeItem = d->parentItem;
1922 while (!scopeItem->isFocusScope()) scopeItem = scopeItem->parentItem();
1924 if (scopeItem->scopedFocusItem()) {
1925 QQuickItemPrivate::get(scopeFocusedItem)->focus = false;
1926 emit scopeFocusedItem->focusChanged(false);
1928 QQuickCanvasPrivate::get(d->canvas)->setFocusInScope(scopeItem, scopeFocusedItem,
1929 QQuickCanvasPrivate::DontChangeFocusProperty);
1933 d->resolveLayoutMirror();
1935 d->itemChange(ItemParentHasChanged, d->parentItem);
1937 d->parentNotifier.notify();
1938 if (d->isAccessible && d->parentItem) {
1939 d->parentItem->d_func()->setAccessibleFlagAndListener();
1942 emit parentChanged(d->parentItem);
1945 void QQuickItem::stackBefore(const QQuickItem *sibling)
1948 if (!sibling || sibling == this || !d->parentItem || d->parentItem != QQuickItemPrivate::get(sibling)->parentItem) {
1949 qWarning("QQuickItem::stackBefore: Cannot stack before %p, which must be a sibling", sibling);
1953 QQuickItemPrivate *parentPrivate = QQuickItemPrivate::get(d->parentItem);
1955 int myIndex = parentPrivate->childItems.indexOf(this);
1956 int siblingIndex = parentPrivate->childItems.indexOf(const_cast<QQuickItem *>(sibling));
1958 Q_ASSERT(myIndex != -1 && siblingIndex != -1);
1960 if (myIndex == siblingIndex - 1)
1963 parentPrivate->childItems.removeAt(myIndex);
1965 if (myIndex < siblingIndex) --siblingIndex;
1967 parentPrivate->childItems.insert(siblingIndex, this);
1969 parentPrivate->dirty(QQuickItemPrivate::ChildrenStackingChanged);
1970 parentPrivate->markSortedChildrenDirty(this);
1972 for (int ii = qMin(siblingIndex, myIndex); ii < parentPrivate->childItems.count(); ++ii)
1973 QQuickItemPrivate::get(parentPrivate->childItems.at(ii))->siblingOrderChanged();
1976 void QQuickItem::stackAfter(const QQuickItem *sibling)
1979 if (!sibling || sibling == this || !d->parentItem || d->parentItem != QQuickItemPrivate::get(sibling)->parentItem) {
1980 qWarning("QQuickItem::stackAfter: Cannot stack after %p, which must be a sibling", sibling);
1984 QQuickItemPrivate *parentPrivate = QQuickItemPrivate::get(d->parentItem);
1986 int myIndex = parentPrivate->childItems.indexOf(this);
1987 int siblingIndex = parentPrivate->childItems.indexOf(const_cast<QQuickItem *>(sibling));
1989 Q_ASSERT(myIndex != -1 && siblingIndex != -1);
1991 if (myIndex == siblingIndex + 1)
1994 parentPrivate->childItems.removeAt(myIndex);
1996 if (myIndex < siblingIndex) --siblingIndex;
1998 parentPrivate->childItems.insert(siblingIndex + 1, this);
2000 parentPrivate->dirty(QQuickItemPrivate::ChildrenStackingChanged);
2001 parentPrivate->markSortedChildrenDirty(this);
2003 for (int ii = qMin(myIndex, siblingIndex + 1); ii < parentPrivate->childItems.count(); ++ii)
2004 QQuickItemPrivate::get(parentPrivate->childItems.at(ii))->siblingOrderChanged();
2008 Returns the QQuickItem parent of this item.
2010 QQuickItem *QQuickItem::parentItem() const
2012 Q_D(const QQuickItem);
2013 return d->parentItem;
2016 QSGEngine *QQuickItem::sceneGraphEngine() const
2018 return canvas()->sceneGraphEngine();
2021 QQuickCanvas *QQuickItem::canvas() const
2023 Q_D(const QQuickItem);
2027 static bool itemZOrder_sort(QQuickItem *lhs, QQuickItem *rhs)
2029 return lhs->z() < rhs->z();
2032 QList<QQuickItem *> QQuickItemPrivate::paintOrderChildItems() const
2034 if (sortedChildItems)
2035 return *sortedChildItems;
2037 // If none of the items have set Z then the paint order list is the same as
2038 // the childItems list. This is by far the most common case.
2040 for (int i = 0; i < childItems.count(); ++i) {
2041 if (QQuickItemPrivate::get(childItems.at(i))->z != 0.) {
2047 sortedChildItems = new QList<QQuickItem*>(childItems);
2048 qStableSort(sortedChildItems->begin(), sortedChildItems->end(), itemZOrder_sort);
2049 return *sortedChildItems;
2052 sortedChildItems = const_cast<QList<QQuickItem*>*>(&childItems);
2057 void QQuickItemPrivate::addChild(QQuickItem *child)
2061 Q_ASSERT(!childItems.contains(child));
2063 childItems.append(child);
2065 markSortedChildrenDirty(child);
2066 dirty(QQuickItemPrivate::ChildrenChanged);
2068 itemChange(QQuickItem::ItemChildAddedChange, child);
2070 emit q->childrenChanged();
2073 void QQuickItemPrivate::removeChild(QQuickItem *child)
2078 Q_ASSERT(childItems.contains(child));
2079 childItems.removeOne(child);
2080 Q_ASSERT(!childItems.contains(child));
2082 markSortedChildrenDirty(child);
2083 dirty(QQuickItemPrivate::ChildrenChanged);
2085 itemChange(QQuickItem::ItemChildRemovedChange, child);
2087 emit q->childrenChanged();
2090 void QQuickItemPrivate::InitializationState::clear()
2095 void QQuickItemPrivate::InitializationState::clear(QQuickItem *fs)
2100 QQuickItem *QQuickItemPrivate::InitializationState::getFocusScope(QQuickItem *item)
2103 QQuickItem *fs = item->parentItem();
2104 while (!fs->isFocusScope())
2105 fs = fs->parentItem();
2111 void QQuickItemPrivate::initCanvas(InitializationState *state, QQuickCanvas *c)
2116 removeFromDirtyList();
2117 QQuickCanvasPrivate *c = QQuickCanvasPrivate::get(canvas);
2118 if (polishScheduled)
2119 c->itemsToPolish.remove(q);
2120 if (c->mouseGrabberItem == q)
2121 c->mouseGrabberItem = 0;
2123 c->hoverItems.removeAll(q);
2124 if (itemNodeInstance)
2125 c->cleanup(itemNodeInstance);
2127 c->parentlessItems.remove(q);
2132 if (canvas && polishScheduled)
2133 QQuickCanvasPrivate::get(canvas)->itemsToPolish.insert(q);
2135 itemNodeInstance = 0;
2141 beforePaintNode = 0;
2143 InitializationState _dummy;
2144 InitializationState *childState = state;
2146 if (c && q->isFocusScope()) {
2148 childState = &_dummy;
2151 if (!parentItem && canvas)
2152 QQuickCanvasPrivate::get(canvas)->parentlessItems.insert(q);
2154 for (int ii = 0; ii < childItems.count(); ++ii) {
2155 QQuickItem *child = childItems.at(ii);
2156 QQuickItemPrivate::get(child)->initCanvas(childState, c);
2161 if (state->getFocusScope(q)->scopedFocusItem()) {
2163 emit q->focusChanged(false);
2165 QQuickCanvasPrivate::get(canvas)->setFocusInScope(state->getFocusScope(q), q);
2172 screenAttached->canvasChanged(c);
2173 itemChange(QQuickItem::ItemSceneChange, c);
2177 Returns a transform that maps points from canvas space into item space.
2179 QTransform QQuickItemPrivate::canvasToItemTransform() const
2181 // XXX todo - optimize
2182 return itemToCanvasTransform().inverted();
2186 Returns a transform that maps points from item space into canvas space.
2188 QTransform QQuickItemPrivate::itemToCanvasTransform() const
2191 QTransform rv = parentItem?QQuickItemPrivate::get(parentItem)->itemToCanvasTransform():QTransform();
2192 itemToParentTransform(rv);
2197 Motifies \a t with this items local transform relative to its parent.
2199 void QQuickItemPrivate::itemToParentTransform(QTransform &t) const
2204 if (!transforms.isEmpty()) {
2206 for (int ii = transforms.count() - 1; ii >= 0; --ii)
2207 transforms.at(ii)->applyTo(&m);
2208 t = m.toTransform();
2211 if (scale != 1. || rotation != 0.) {
2212 QPointF tp = computeTransformOrigin();
2213 t.translate(tp.x(), tp.y());
2214 t.scale(scale, scale);
2216 t.translate(-tp.x(), -tp.y());
2222 \qmlproperty real QtQuick2::Item::childrenRect.x
2223 \qmlproperty real QtQuick2::Item::childrenRect.y
2224 \qmlproperty real QtQuick2::Item::childrenRect.width
2225 \qmlproperty real QtQuick2::Item::childrenRect.height
2227 The childrenRect properties allow an item access to the geometry of its
2228 children. This property is useful if you have an item that needs to be
2229 sized to fit its children.
2234 \qmlproperty list<Item> QtQuick2::Item::children
2235 \qmlproperty list<Object> QtQuick2::Item::resources
2237 The children property contains the list of visual children of this item.
2238 The resources property contains non-visual resources that you want to
2241 Generally you can rely on Item's default property to handle all this for
2242 you, but it can come in handy in some cases.
2261 Returns true if construction of the QML component is complete; otherwise
2264 It is often desirable to delay some processing until the component is
2267 \sa componentComplete()
2269 bool QQuickItem::isComponentComplete() const
2271 Q_D(const QQuickItem);
2272 return d->componentComplete;
2275 QQuickItemPrivate::QQuickItemPrivate()
2276 : _anchors(0), _contents(0), baselineOffset(0), _anchorLines(0), _stateGroup(0), origin(QQuickItem::Center),
2278 flags(0), widthValid(false), heightValid(false), componentComplete(true),
2279 keepMouse(false), keepTouch(false), hoverEnabled(false), smooth(false), focus(false), activeFocus(false), notifiedFocus(false),
2280 notifiedActiveFocus(false), filtersChildMouseEvents(false), explicitVisible(true),
2281 effectiveVisible(true), explicitEnable(true), effectiveEnable(true), polishScheduled(false),
2282 inheritedLayoutMirror(false), effectiveLayoutMirror(false), isMirrorImplicit(true),
2283 inheritMirrorFromParent(false), inheritMirrorFromItem(false), childrenDoNotOverlap(false),
2284 staticSubtreeGeometry(false),
2285 isAccessible(false),
2287 canvas(0), parentItem(0), sortedChildItems(&childItems),
2291 x(0), y(0), width(0), height(0), implicitWidth(0), implicitHeight(0),
2292 z(0), scale(1), rotation(0), opacity(1),
2294 attachedLayoutDirection(0), acceptedMouseButtons(0),
2295 imHints(Qt::ImhNone),
2299 dirtyAttributes(0), nextDirtyItem(0), prevDirtyItem(0),
2301 itemNodeInstance(0), opacityNode(0), clipNode(0), rootNode(0), groupNode(0), paintNode(0)
2302 , beforePaintNode(0), effectRefCount(0), hideRefCount(0)
2303 , screenAttached(0), _layer(0)
2307 QQuickItemPrivate::~QQuickItemPrivate()
2309 if (sortedChildItems != &childItems)
2310 delete sortedChildItems;
2313 void QQuickItemPrivate::init(QQuickItem *parent)
2317 static bool atexit_registered = false;
2318 if (!atexit_registered) {
2319 atexit(qt_print_item_count);
2320 atexit_registered = true;
2326 registerAccessorProperties();
2328 baselineOffset.invalidate();
2331 q->setParentItem(parent);
2332 QQuickItemPrivate *parentPrivate = QQuickItemPrivate::get(parent);
2333 setImplicitLayoutMirror(parentPrivate->inheritedLayoutMirror, parentPrivate->inheritMirrorFromParent);
2337 void QQuickItemPrivate::data_append(QDeclarativeListProperty<QObject> *prop, QObject *o)
2342 QQuickItem *that = static_cast<QQuickItem *>(prop->object);
2344 // This test is measurably (albeit only slightly) faster than qobject_cast<>()
2345 const QMetaObject *mo = o->metaObject();
2346 while (mo && mo != &QQuickItem::staticMetaObject) {
2347 mo = mo->d.superdata;
2351 QQuickItem *item = static_cast<QQuickItem *>(o);
2352 item->setParentItem(that);
2354 if (o->inherits("QGraphicsItem"))
2355 qWarning("Cannot add a QtQuick 1.0 item (%s) into a QtQuick 2.0 scene!", o->metaObject()->className());
2357 // XXX todo - do we really want this behavior?
2363 \qmlproperty list<Object> QtQuick2::Item::data
2366 The data property allows you to freely mix visual children and resources
2367 in an item. If you assign a visual item to the data list it becomes
2368 a child and if you assign any other object type, it is added as a resource.
2392 data is a behind-the-scenes property: you should never need to explicitly
2396 int QQuickItemPrivate::data_count(QDeclarativeListProperty<QObject> *prop)
2403 QObject *QQuickItemPrivate::data_at(QDeclarativeListProperty<QObject> *prop, int i)
2411 void QQuickItemPrivate::data_clear(QDeclarativeListProperty<QObject> *prop)
2417 QObject *QQuickItemPrivate::resources_at(QDeclarativeListProperty<QObject> *prop, int index)
2419 const QObjectList children = prop->object->children();
2420 if (index < children.count())
2421 return children.at(index);
2426 void QQuickItemPrivate::resources_append(QDeclarativeListProperty<QObject> *prop, QObject *o)
2428 // XXX todo - do we really want this behavior?
2429 o->setParent(prop->object);
2432 int QQuickItemPrivate::resources_count(QDeclarativeListProperty<QObject> *prop)
2434 return prop->object->children().count();
2437 void QQuickItemPrivate::resources_clear(QDeclarativeListProperty<QObject> *prop)
2439 // XXX todo - do we really want this behavior?
2440 const QObjectList children = prop->object->children();
2441 for (int index = 0; index < children.count(); index++)
2442 children.at(index)->setParent(0);
2445 QQuickItem *QQuickItemPrivate::children_at(QDeclarativeListProperty<QQuickItem> *prop, int index)
2447 QQuickItemPrivate *p = QQuickItemPrivate::get(static_cast<QQuickItem *>(prop->object));
2448 if (index >= p->childItems.count() || index < 0)
2451 return p->childItems.at(index);
2454 void QQuickItemPrivate::children_append(QDeclarativeListProperty<QQuickItem> *prop, QQuickItem *o)
2459 QQuickItem *that = static_cast<QQuickItem *>(prop->object);
2460 if (o->parentItem() == that)
2461 o->setParentItem(0);
2463 o->setParentItem(that);
2466 int QQuickItemPrivate::children_count(QDeclarativeListProperty<QQuickItem> *prop)
2468 QQuickItemPrivate *p = QQuickItemPrivate::get(static_cast<QQuickItem *>(prop->object));
2469 return p->childItems.count();
2472 void QQuickItemPrivate::children_clear(QDeclarativeListProperty<QQuickItem> *prop)
2474 QQuickItem *that = static_cast<QQuickItem *>(prop->object);
2475 QQuickItemPrivate *p = QQuickItemPrivate::get(that);
2476 while (!p->childItems.isEmpty())
2477 p->childItems.at(0)->setParentItem(0);
2480 int QQuickItemPrivate::transform_count(QDeclarativeListProperty<QQuickTransform> *prop)
2482 QQuickItem *that = static_cast<QQuickItem *>(prop->object);
2483 return QQuickItemPrivate::get(that)->transforms.count();
2486 void QQuickTransform::appendToItem(QQuickItem *item)
2488 Q_D(QQuickTransform);
2492 QQuickItemPrivate *p = QQuickItemPrivate::get(item);
2494 if (!d->items.isEmpty() && !p->transforms.isEmpty() && p->transforms.contains(this)) {
2495 p->transforms.removeOne(this);
2496 p->transforms.append(this);
2498 p->transforms.append(this);
2499 d->items.append(item);
2502 p->dirty(QQuickItemPrivate::Transform);
2505 void QQuickTransform::prependToItem(QQuickItem *item)
2507 Q_D(QQuickTransform);
2511 QQuickItemPrivate *p = QQuickItemPrivate::get(item);
2513 if (!d->items.isEmpty() && !p->transforms.isEmpty() && p->transforms.contains(this)) {
2514 p->transforms.removeOne(this);
2515 p->transforms.prepend(this);
2517 p->transforms.prepend(this);
2518 d->items.append(item);
2521 p->dirty(QQuickItemPrivate::Transform);
2524 void QQuickItemPrivate::transform_append(QDeclarativeListProperty<QQuickTransform> *prop, QQuickTransform *transform)
2529 QQuickItem *that = static_cast<QQuickItem *>(prop->object);
2530 transform->appendToItem(that);
2533 QQuickTransform *QQuickItemPrivate::transform_at(QDeclarativeListProperty<QQuickTransform> *prop, int idx)
2535 QQuickItem *that = static_cast<QQuickItem *>(prop->object);
2536 QQuickItemPrivate *p = QQuickItemPrivate::get(that);
2538 if (idx < 0 || idx >= p->transforms.count())
2541 return p->transforms.at(idx);
2544 void QQuickItemPrivate::transform_clear(QDeclarativeListProperty<QQuickTransform> *prop)
2546 QQuickItem *that = static_cast<QQuickItem *>(prop->object);
2547 QQuickItemPrivate *p = QQuickItemPrivate::get(that);
2549 for (int ii = 0; ii < p->transforms.count(); ++ii) {
2550 QQuickTransform *t = p->transforms.at(ii);
2551 QQuickTransformPrivate *tp = QQuickTransformPrivate::get(t);
2552 tp->items.removeOne(that);
2555 p->transforms.clear();
2557 p->dirty(QQuickItemPrivate::Transform);
2561 \property QQuickItem::childrenRect
2562 \brief The geometry of an item's children.
2564 This property holds the (collective) position and size of the item's children.
2568 \qmlproperty real QtQuick2::Item::x
2569 \qmlproperty real QtQuick2::Item::y
2570 \qmlproperty real QtQuick2::Item::width
2571 \qmlproperty real QtQuick2::Item::height
2573 Defines the item's position and size relative to its parent.
2576 Item { x: 100; y: 100; width: 100; height: 100 }
2581 \qmlproperty real QtQuick2::Item::z
2583 Sets the stacking order of sibling items. By default the stacking order is 0.
2585 Items with a higher stacking value are drawn on top of siblings with a
2586 lower stacking order. Items with the same stacking value are drawn
2587 bottom up in the order they appear. Items with a negative stacking
2588 value are drawn under their parent's content.
2590 The following example shows the various effects of stacking order.
2594 \o \image declarative-item_stacking1.png
2595 \o Same \c z - later children above earlier children:
2600 width: 100; height: 100
2604 x: 50; y: 50; width: 100; height: 100
2609 \o \image declarative-item_stacking2.png
2610 \o Higher \c z on top:
2616 width: 100; height: 100
2620 x: 50; y: 50; width: 100; height: 100
2625 \o \image declarative-item_stacking3.png
2626 \o Same \c z - children above parents:
2631 width: 100; height: 100
2634 x: 50; y: 50; width: 100; height: 100
2640 \o \image declarative-item_stacking4.png
2641 \o Lower \c z below:
2646 width: 100; height: 100
2650 x: 50; y: 50; width: 100; height: 100
2659 \qmlproperty bool QtQuick2::Item::visible
2661 This property holds whether the item is visible. By default this is true.
2663 Setting this property directly affects the \c visible value of child
2664 items. When set to \c false, the \c visible values of all child items also
2665 become \c false. When set to \c true, the \c visible values of child items
2666 are returned to \c true, unless they have explicitly been set to \c false.
2668 (Because of this flow-on behavior, using the \c visible property may not
2669 have the intended effect if a property binding should only respond to
2670 explicit property changes. In such cases it may be better to use the
2671 \l opacity property instead.)
2673 Setting this property to \c false automatically causes \l focus to be set
2674 to \c false, and this item will longer receive mouse and keyboard events.
2675 (In contrast, setting the \l opacity to 0 does not affect the \l focus
2676 property and the receiving of key events.)
2678 \note This property's value is only affected by changes to this property or
2679 the parent's \c visible property. It does not change, for example, if this
2680 item moves off-screen, or if the \l opacity changes to 0.
2685 \qmlproperty AnchorLine QtQuick2::Item::anchors.top
2686 \qmlproperty AnchorLine QtQuick2::Item::anchors.bottom
2687 \qmlproperty AnchorLine QtQuick2::Item::anchors.left
2688 \qmlproperty AnchorLine QtQuick2::Item::anchors.right
2689 \qmlproperty AnchorLine QtQuick2::Item::anchors.horizontalCenter
2690 \qmlproperty AnchorLine QtQuick2::Item::anchors.verticalCenter
2691 \qmlproperty AnchorLine QtQuick2::Item::anchors.baseline
2693 \qmlproperty Item QtQuick2::Item::anchors.fill
2694 \qmlproperty Item QtQuick2::Item::anchors.centerIn
2696 \qmlproperty real QtQuick2::Item::anchors.margins
2697 \qmlproperty real QtQuick2::Item::anchors.topMargin
2698 \qmlproperty real QtQuick2::Item::anchors.bottomMargin
2699 \qmlproperty real QtQuick2::Item::anchors.leftMargin
2700 \qmlproperty real QtQuick2::Item::anchors.rightMargin
2701 \qmlproperty real QtQuick2::Item::anchors.horizontalCenterOffset
2702 \qmlproperty real QtQuick2::Item::anchors.verticalCenterOffset
2703 \qmlproperty real QtQuick2::Item::anchors.baselineOffset
2705 \qmlproperty bool QtQuick2::Item::anchors.mirrored
2707 Anchors provide a way to position an item by specifying its
2708 relationship with other items.
2710 Margins apply to top, bottom, left, right, and fill anchors.
2711 The \c anchors.margins property can be used to set all of the various margins at once, to the same value.
2712 Note that margins are anchor-specific and are not applied if an item does not
2715 Offsets apply for horizontal center, vertical center, and baseline anchors.
2719 \o \image declarative-anchors_example.png
2720 \o Text anchored to Image, horizontally centered and vertically below, with a margin.
2729 anchors.horizontalCenter: pic.horizontalCenter
2730 anchors.top: pic.bottom
2731 anchors.topMargin: 5
2737 \o \image declarative-anchors_example2.png
2739 Left of Text anchored to right of Image, with a margin. The y
2740 property of both defaults to 0.
2750 anchors.left: pic.right
2751 anchors.leftMargin: 5
2758 \c anchors.fill provides a convenient way for one item to have the
2759 same geometry as another item, and is equivalent to connecting all
2760 four directional anchors.
2762 To clear an anchor value, set it to \c undefined.
2764 \c anchors.mirrored returns true it the layout has been \l {LayoutMirroring}{mirrored}.
2766 \note You can only anchor an item to siblings or a parent.
2768 For more information see \l {anchor-layout}{Anchor Layouts}.
2772 \property QQuickItem::baselineOffset
2773 \brief The position of the item's baseline in local coordinates.
2775 The baseline of a \l Text item is the imaginary line on which the text
2776 sits. Controls containing text usually set their baseline to the
2777 baseline of their text.
2779 For non-text items, a default baseline offset of 0 is used.
2781 QQuickAnchors *QQuickItemPrivate::anchors() const
2784 Q_Q(const QQuickItem);
2785 _anchors = new QQuickAnchors(const_cast<QQuickItem *>(q));
2786 if (!componentComplete)
2787 _anchors->classBegin();
2792 QQuickItemPrivate::AnchorLines *QQuickItemPrivate::anchorLines() const
2794 Q_Q(const QQuickItem);
2795 if (!_anchorLines) _anchorLines =
2796 new AnchorLines(const_cast<QQuickItem *>(q));
2797 return _anchorLines;
2800 void QQuickItemPrivate::siblingOrderChanged()
2803 for (int ii = 0; ii < changeListeners.count(); ++ii) {
2804 const QQuickItemPrivate::ChangeListener &change = changeListeners.at(ii);
2805 if (change.types & QQuickItemPrivate::SiblingOrder) {
2806 change.listener->itemSiblingOrderChanged(q);
2811 QDeclarativeListProperty<QObject> QQuickItemPrivate::data()
2813 return QDeclarativeListProperty<QObject>(q_func(), 0, QQuickItemPrivate::data_append,
2814 QQuickItemPrivate::data_count,
2815 QQuickItemPrivate::data_at,
2816 QQuickItemPrivate::data_clear);
2819 QRectF QQuickItem::childrenRect()
2822 if (!d->_contents) {
2823 d->_contents = new QQuickContents(this);
2824 if (d->componentComplete)
2825 d->_contents->complete();
2827 return d->_contents->rectF();
2830 QList<QQuickItem *> QQuickItem::childItems() const
2832 Q_D(const QQuickItem);
2833 return d->childItems;
2836 bool QQuickItem::clip() const
2838 return flags() & ItemClipsChildrenToShape;
2841 void QQuickItem::setClip(bool c)
2846 setFlag(ItemClipsChildrenToShape, c);
2848 emit clipChanged(c);
2853 This function is called to handle this item's changes in
2854 geometry from \a oldGeometry to \a newGeometry. If the two
2855 geometries are the same, it doesn't do anything.
2857 void QQuickItem::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
2862 QQuickAnchorsPrivate::get(d->_anchors)->updateMe();
2864 bool xChange = (newGeometry.x() != oldGeometry.x());
2865 bool yChange = (newGeometry.y() != oldGeometry.y());
2866 bool widthChange = (newGeometry.width() != oldGeometry.width());
2867 bool heightChange = (newGeometry.height() != oldGeometry.height());
2869 for (int ii = 0; ii < d->changeListeners.count(); ++ii) {
2870 const QQuickItemPrivate::ChangeListener &change = d->changeListeners.at(ii);
2871 if (change.types & QQuickItemPrivate::Geometry) {
2872 if (change.gTypes == QQuickItemPrivate::GeometryChange) {
2873 change.listener->itemGeometryChanged(this, newGeometry, oldGeometry);
2874 } else if ((xChange && (change.gTypes & QQuickItemPrivate::XChange)) ||
2875 (yChange && (change.gTypes & QQuickItemPrivate::YChange)) ||
2876 (widthChange && (change.gTypes & QQuickItemPrivate::WidthChange)) ||
2877 (heightChange && (change.gTypes & QQuickItemPrivate::HeightChange))) {
2878 change.listener->itemGeometryChanged(this, newGeometry, oldGeometry);
2888 emit widthChanged();
2890 emit heightChanged();
2894 Called by the rendering thread when it is time to sync the state of the QML objects with the
2895 scene graph objects. The function should return the root of the scene graph subtree for
2896 this item. \a oldNode is the node that was returned the last time the function was called.
2898 The main thread is blocked while this function is executed so it is safe to read
2899 values from the QQuickItem instance and other objects in the main thread.
2901 \warning This is the only function in which it is allowed to make use of scene graph
2902 objects from the main thread. Use of scene graph objects outside this function will
2903 result in race conditions and potential crashes.
2906 QSGNode *QQuickItem::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *)
2912 QSGTransformNode *QQuickItemPrivate::createTransformNode()
2914 return new QSGTransformNode;
2917 void QQuickItem::updatePolish()
2921 void QQuickItem::sendAccessibilityUpdate()
2925 void QQuickItemPrivate::removeItemChangeListener(QQuickItemChangeListener *listener, ChangeTypes types)
2927 ChangeListener change(listener, types);
2928 changeListeners.removeOne(change);
2931 void QQuickItemPrivate::updateOrAddGeometryChangeListener(QQuickItemChangeListener *listener, GeometryChangeTypes types)
2933 ChangeListener change(listener, types);
2934 int index = changeListeners.find(change);
2936 changeListeners[index].gTypes = change.gTypes; //we may have different GeometryChangeTypes
2938 changeListeners.append(change);
2941 void QQuickItemPrivate::updateOrRemoveGeometryChangeListener(QQuickItemChangeListener *listener, GeometryChangeTypes types)
2943 ChangeListener change(listener, types);
2944 if (types == NoChange) {
2945 changeListeners.removeOne(change);
2947 int index = changeListeners.find(change);
2949 changeListeners[index].gTypes = change.gTypes; //we may have different GeometryChangeTypes
2953 void QQuickItem::keyPressEvent(QKeyEvent *event)
2958 void QQuickItem::keyReleaseEvent(QKeyEvent *event)
2963 void QQuickItem::inputMethodEvent(QInputMethodEvent *event)
2968 void QQuickItem::focusInEvent(QFocusEvent *)
2970 QAccessible::updateAccessibility(this, 0, QAccessible::Focus);
2973 void QQuickItem::focusOutEvent(QFocusEvent *)
2977 void QQuickItem::mousePressEvent(QMouseEvent *event)
2982 void QQuickItem::mouseMoveEvent(QMouseEvent *event)
2987 void QQuickItem::mouseReleaseEvent(QMouseEvent *event)
2992 void QQuickItem::mouseDoubleClickEvent(QMouseEvent *event)
2994 mousePressEvent(event);
2997 void QQuickItem::mouseUngrabEvent()
3002 void QQuickItem::touchUngrabEvent()
3007 void QQuickItem::wheelEvent(QWheelEvent *event)
3012 void QQuickItem::touchEvent(QTouchEvent *event)
3017 void QQuickItem::hoverEnterEvent(QHoverEvent *event)
3022 void QQuickItem::hoverMoveEvent(QHoverEvent *event)
3027 void QQuickItem::hoverLeaveEvent(QHoverEvent *event)
3032 void QQuickItem::dragEnterEvent(QDragEnterEvent *event)
3037 void QQuickItem::dragMoveEvent(QDragMoveEvent *event)
3043 void QQuickItem::dragLeaveEvent(QDragLeaveEvent *event)
3049 void QQuickItem::dropEvent(QDropEvent *event)
3054 bool QQuickItem::childMouseEventFilter(QQuickItem *, QEvent *)
3059 void QQuickItem::windowDeactivateEvent()
3061 foreach (QQuickItem* item, childItems()) {
3062 item->windowDeactivateEvent();
3066 Qt::InputMethodHints QQuickItem::inputMethodHints() const
3068 Q_D(const QQuickItem);
3072 void QQuickItem::setInputMethodHints(Qt::InputMethodHints hints)
3077 if (!d->canvas || d->canvas->activeFocusItem() != this)
3080 QInputPanel *p = qApp->inputPanel();
3081 if (p->inputItem() == this)
3082 qApp->inputPanel()->update(Qt::ImHints);
3085 QVariant QQuickItem::inputMethodQuery(Qt::InputMethodQuery query) const
3087 Q_D(const QQuickItem);
3092 v = (bool)(flags() & ItemAcceptsInputMethod);
3095 v = (int)inputMethodHints();
3097 case Qt::ImCursorRectangle:
3099 case Qt::ImCursorPosition:
3100 case Qt::ImSurroundingText:
3101 case Qt::ImCurrentSelection:
3102 case Qt::ImMaximumTextLength:
3103 case Qt::ImAnchorPosition:
3104 case Qt::ImPreferredLanguage:
3106 v = d->keyHandler->inputMethodQuery(query);
3114 QQuickAnchorLine QQuickItemPrivate::left() const
3116 return anchorLines()->left;
3119 QQuickAnchorLine QQuickItemPrivate::right() const
3121 return anchorLines()->right;
3124 QQuickAnchorLine QQuickItemPrivate::horizontalCenter() const
3126 return anchorLines()->hCenter;
3129 QQuickAnchorLine QQuickItemPrivate::top() const
3131 return anchorLines()->top;
3134 QQuickAnchorLine QQuickItemPrivate::bottom() const
3136 return anchorLines()->bottom;
3139 QQuickAnchorLine QQuickItemPrivate::verticalCenter() const
3141 return anchorLines()->vCenter;
3144 QQuickAnchorLine QQuickItemPrivate::baseline() const
3146 return anchorLines()->baseline;
3149 qreal QQuickItem::baselineOffset() const
3151 Q_D(const QQuickItem);
3152 if (!d->baselineOffset.isValid()) {
3155 return d->baselineOffset;
3158 void QQuickItem::setBaselineOffset(qreal offset)
3161 if (offset == d->baselineOffset)
3164 d->baselineOffset = offset;
3166 for (int ii = 0; ii < d->changeListeners.count(); ++ii) {
3167 const QQuickItemPrivate::ChangeListener &change = d->changeListeners.at(ii);
3168 if (change.types & QQuickItemPrivate::Geometry) {
3169 QQuickAnchorsPrivate *anchor = change.listener->anchorPrivate();
3171 anchor->updateVerticalAnchors();
3174 emit baselineOffsetChanged(offset);
3177 void QQuickItem::update()
3180 Q_ASSERT(flags() & ItemHasContents);
3181 d->dirty(QQuickItemPrivate::Content);
3184 void QQuickItem::polish()
3187 if (!d->polishScheduled) {
3188 d->polishScheduled = true;
3190 QQuickCanvasPrivate *p = QQuickCanvasPrivate::get(d->canvas);
3191 bool maybeupdate = p->itemsToPolish.isEmpty();
3192 p->itemsToPolish.insert(this);
3193 if (maybeupdate) d->canvas->maybeUpdate();
3198 void QQuickItem::mapFromItem(QDeclarativeV8Function *args) const
3200 if (args->Length() != 0) {
3201 v8::Local<v8::Value> item = (*args)[0];
3202 QV8Engine *engine = args->engine();
3204 QQuickItem *itemObj = 0;
3205 if (!item->IsNull())
3206 itemObj = qobject_cast<QQuickItem*>(engine->toQObject(item));
3208 if (!itemObj && !item->IsNull()) {
3209 qmlInfo(this) << "mapFromItem() given argument \"" << engine->toString(item->ToString())
3210 << "\" which is neither null nor an Item";
3214 v8::Local<v8::Object> rv = v8::Object::New();
3215 args->returnValue(rv);
3217 qreal x = (args->Length() > 1)?(*args)[1]->NumberValue():0;
3218 qreal y = (args->Length() > 2)?(*args)[2]->NumberValue():0;
3220 QPointF p = mapFromItem(itemObj, QPointF(x, y));
3222 rv->Set(v8::String::New("x"), v8::Number::New(p.x()));
3223 rv->Set(v8::String::New("y"), v8::Number::New(p.y()));
3227 QTransform QQuickItem::itemTransform(QQuickItem *other, bool *ok) const
3229 Q_D(const QQuickItem);
3231 // XXX todo - we need to be able to handle common parents better and detect
3235 QTransform t = d->itemToCanvasTransform();
3236 if (other) t *= QQuickItemPrivate::get(other)->canvasToItemTransform();
3241 void QQuickItem::mapToItem(QDeclarativeV8Function *args) const
3243 if (args->Length() != 0) {
3244 v8::Local<v8::Value> item = (*args)[0];
3245 QV8Engine *engine = args->engine();
3247 QQuickItem *itemObj = 0;
3248 if (!item->IsNull())
3249 itemObj = qobject_cast<QQuickItem*>(engine->toQObject(item));
3251 if (!itemObj && !item->IsNull()) {
3252 qmlInfo(this) << "mapToItem() given argument \"" << engine->toString(item->ToString())
3253 << "\" which is neither null nor an Item";
3257 v8::Local<v8::Object> rv = v8::Object::New();
3258 args->returnValue(rv);
3260 qreal x = (args->Length() > 1)?(*args)[1]->NumberValue():0;
3261 qreal y = (args->Length() > 2)?(*args)[2]->NumberValue():0;
3263 QPointF p = mapToItem(itemObj, QPointF(x, y));
3265 rv->Set(v8::String::New("x"), v8::Number::New(p.x()));
3266 rv->Set(v8::String::New("y"), v8::Number::New(p.y()));
3270 void QQuickItem::forceActiveFocus()
3273 QQuickItem *parent = parentItem();
3275 if (parent->flags() & QQuickItem::ItemIsFocusScope) {
3276 parent->setFocus(true);
3278 parent = parent->parentItem();
3282 QQuickItem *QQuickItem::childAt(qreal x, qreal y) const
3284 // XXX todo - should this include transform etc.?
3285 const QList<QQuickItem *> children = childItems();
3286 for (int i = children.count()-1; i >= 0; --i) {
3287 QQuickItem *child = children.at(i);
3288 if (child->isVisible() && child->x() <= x
3289 && child->x() + child->width() >= x
3291 && child->y() + child->height() >= y)
3297 QDeclarativeListProperty<QObject> QQuickItemPrivate::resources()
3299 return QDeclarativeListProperty<QObject>(q_func(), 0, QQuickItemPrivate::resources_append,
3300 QQuickItemPrivate::resources_count,
3301 QQuickItemPrivate::resources_at,
3302 QQuickItemPrivate::resources_clear);
3305 QDeclarativeListProperty<QQuickItem> QQuickItemPrivate::children()
3307 return QDeclarativeListProperty<QQuickItem>(q_func(), 0, QQuickItemPrivate::children_append,
3308 QQuickItemPrivate::children_count,
3309 QQuickItemPrivate::children_at,
3310 QQuickItemPrivate::children_clear);
3314 QDeclarativeListProperty<QDeclarativeState> QQuickItemPrivate::states()
3316 return _states()->statesProperty();
3319 QDeclarativeListProperty<QDeclarativeTransition> QQuickItemPrivate::transitions()
3321 return _states()->transitionsProperty();
3324 QString QQuickItemPrivate::state() const
3329 return _stateGroup->state();
3332 void QQuickItemPrivate::setState(const QString &state)
3334 _states()->setState(state);
3337 QString QQuickItem::state() const
3339 Q_D(const QQuickItem);
3343 void QQuickItem::setState(const QString &state)
3349 QDeclarativeListProperty<QQuickTransform> QQuickItem::transform()
3351 return QDeclarativeListProperty<QQuickTransform>(this, 0, QQuickItemPrivate::transform_append,
3352 QQuickItemPrivate::transform_count,
3353 QQuickItemPrivate::transform_at,
3354 QQuickItemPrivate::transform_clear);
3357 void QQuickItem::classBegin()
3360 d->componentComplete = false;
3362 d->_stateGroup->classBegin();
3364 d->_anchors->classBegin();
3366 d->_layer->classBegin();
3369 void QQuickItem::componentComplete()
3372 d->componentComplete = true;
3374 d->_stateGroup->componentComplete();
3376 d->_anchors->componentComplete();
3377 QQuickAnchorsPrivate::get(d->_anchors)->updateOnComplete();
3381 d->_layer->componentComplete();
3384 d->keyHandler->componentComplete();
3386 d->_contents->complete();
3389 QDeclarativeStateGroup *QQuickItemPrivate::_states()
3393 _stateGroup = new QDeclarativeStateGroup;
3394 if (!componentComplete)
3395 _stateGroup->classBegin();
3396 FAST_CONNECT(_stateGroup, SIGNAL(stateChanged(QString)),
3397 q, SIGNAL(stateChanged(QString)))
3403 QQuickItemPrivate::AnchorLines::AnchorLines(QQuickItem *q)
3406 left.anchorLine = QQuickAnchorLine::Left;
3408 right.anchorLine = QQuickAnchorLine::Right;
3410 hCenter.anchorLine = QQuickAnchorLine::HCenter;
3412 top.anchorLine = QQuickAnchorLine::Top;
3414 bottom.anchorLine = QQuickAnchorLine::Bottom;
3416 vCenter.anchorLine = QQuickAnchorLine::VCenter;
3418 baseline.anchorLine = QQuickAnchorLine::Baseline;
3421 QPointF QQuickItemPrivate::computeTransformOrigin() const
3425 case QQuickItem::TopLeft:
3426 return QPointF(0, 0);
3427 case QQuickItem::Top:
3428 return QPointF(width / 2., 0);
3429 case QQuickItem::TopRight:
3430 return QPointF(width, 0);
3431 case QQuickItem::Left:
3432 return QPointF(0, height / 2.);
3433 case QQuickItem::Center:
3434 return QPointF(width / 2., height / 2.);
3435 case QQuickItem::Right:
3436 return QPointF(width, height / 2.);
3437 case QQuickItem::BottomLeft:
3438 return QPointF(0, height);
3439 case QQuickItem::Bottom:
3440 return QPointF(width / 2., height);
3441 case QQuickItem::BottomRight:
3442 return QPointF(width, height);
3446 void QQuickItemPrivate::transformChanged()
3449 _layer->updateMatrix();
3452 void QQuickItemPrivate::deliverKeyEvent(QKeyEvent *e)
3456 Q_ASSERT(e->isAccepted());
3458 if (e->type() == QEvent::KeyPress)
3459 keyHandler->keyPressed(e, false);
3461 keyHandler->keyReleased(e, false);
3463 if (e->isAccepted())
3469 if (e->type() == QEvent::KeyPress)
3470 q->keyPressEvent(e);
3472 q->keyReleaseEvent(e);
3474 if (e->isAccepted())
3480 if (e->type() == QEvent::KeyPress)
3481 keyHandler->keyPressed(e, true);
3483 keyHandler->keyReleased(e, true);
3487 void QQuickItemPrivate::deliverInputMethodEvent(QInputMethodEvent *e)
3491 Q_ASSERT(e->isAccepted());
3493 keyHandler->inputMethodEvent(e, false);
3495 if (e->isAccepted())
3501 q->inputMethodEvent(e);
3503 if (e->isAccepted())
3509 keyHandler->inputMethodEvent(e, true);
3513 void QQuickItemPrivate::deliverFocusEvent(QFocusEvent *e)
3517 if (e->type() == QEvent::FocusIn) {
3520 q->focusOutEvent(e);
3524 void QQuickItemPrivate::deliverMouseEvent(QMouseEvent *e)
3528 Q_ASSERT(e->isAccepted());
3530 switch (e->type()) {
3532 Q_ASSERT(!"Unknown event type");
3533 case QEvent::MouseMove:
3534 q->mouseMoveEvent(e);
3536 case QEvent::MouseButtonPress:
3537 q->mousePressEvent(e);
3539 case QEvent::MouseButtonRelease:
3540 q->mouseReleaseEvent(e);
3542 case QEvent::MouseButtonDblClick:
3543 q->mouseDoubleClickEvent(e);
3548 void QQuickItemPrivate::deliverWheelEvent(QWheelEvent *e)
3554 void QQuickItemPrivate::deliverTouchEvent(QTouchEvent *e)
3560 void QQuickItemPrivate::deliverHoverEvent(QHoverEvent *e)
3563 switch (e->type()) {
3565 Q_ASSERT(!"Unknown event type");
3566 case QEvent::HoverEnter:
3567 q->hoverEnterEvent(e);
3569 case QEvent::HoverLeave:
3570 q->hoverLeaveEvent(e);
3572 case QEvent::HoverMove:
3573 q->hoverMoveEvent(e);
3578 void QQuickItemPrivate::deliverDragEvent(QEvent *e)
3581 switch (e->type()) {
3583 Q_ASSERT(!"Unknown event type");
3584 case QEvent::DragEnter:
3585 q->dragEnterEvent(static_cast<QDragEnterEvent *>(e));
3587 case QEvent::DragLeave:
3588 q->dragLeaveEvent(static_cast<QDragLeaveEvent *>(e));
3590 case QEvent::DragMove:
3591 q->dragMoveEvent(static_cast<QDragMoveEvent *>(e));
3594 q->dropEvent(static_cast<QDropEvent *>(e));
3599 void QQuickItem::itemChange(ItemChange change, const ItemChangeData &value)
3606 Notify input method on updated query values if needed. \a indicates changed attributes.
3608 void QQuickItem::updateInputMethod(Qt::InputMethodQueries queries)
3610 if (hasActiveFocus())
3611 qApp->inputPanel()->update(queries);
3615 // XXX todo - do we want/need this anymore?
3616 // Note that it's now used for varying clip rect
3617 QRectF QQuickItem::boundingRect() const
3619 Q_D(const QQuickItem);
3620 return QRectF(0, 0, d->width, d->height);
3623 QQuickItem::TransformOrigin QQuickItem::transformOrigin() const
3625 Q_D(const QQuickItem);
3629 void QQuickItem::setTransformOrigin(TransformOrigin origin)
3632 if (origin == d->origin)
3636 d->dirty(QQuickItemPrivate::TransformOrigin);
3638 emit transformOriginChanged(d->origin);
3641 QPointF QQuickItem::transformOriginPoint() const
3643 Q_D(const QQuickItem);
3644 if (!d->transformOriginPoint.isNull())
3645 return d->transformOriginPoint;
3646 return d->computeTransformOrigin();
3649 void QQuickItem::setTransformOriginPoint(const QPointF &point)
3652 if (d->transformOriginPoint == point)
3655 d->transformOriginPoint = point;
3656 d->dirty(QQuickItemPrivate::TransformOrigin);
3659 qreal QQuickItem::z() const
3661 Q_D(const QQuickItem);
3665 void QQuickItem::setZ(qreal v)
3673 d->dirty(QQuickItemPrivate::ZValue);
3674 if (d->parentItem) {
3675 QQuickItemPrivate::get(d->parentItem)->dirty(QQuickItemPrivate::ChildrenStackingChanged);
3676 QQuickItemPrivate::get(d->parentItem)->markSortedChildrenDirty(this);
3682 d->_layer->updateZ();
3687 \qmlproperty real QtQuick2::Item::rotation
3688 This property holds the rotation of the item in degrees clockwise.
3690 This specifies how many degrees to rotate the item around its transformOrigin.
3691 The default rotation is 0 degrees (i.e. not rotated at all).
3695 \o \image declarative-rotation.png
3700 width: 100; height: 100
3703 x: 25; y: 25; width: 50; height: 50
3710 \sa transform, Rotation
3714 \qmlproperty real QtQuick2::Item::scale
3715 This property holds the scale of the item.
3717 A scale of less than 1 means the item will be displayed smaller than
3718 normal, and a scale of greater than 1 means the item will be
3719 displayed larger than normal. A negative scale means the item will
3722 By default, items are displayed at a scale of 1 (i.e. at their
3725 Scaling is from the item's transformOrigin.
3729 \o \image declarative-scale.png
3734 width: 100; height: 100
3737 width: 25; height: 25
3741 x: 25; y: 25; width: 50; height: 50
3748 \sa transform, Scale
3752 \qmlproperty real QtQuick2::Item::opacity
3754 This property holds the opacity of the item. Opacity is specified as a
3755 number between 0 (fully transparent) and 1 (fully opaque). The default is 1.
3757 When this property is set, the specified opacity is also applied
3758 individually to child items. In almost all cases this is what you want,
3759 but in some cases it may produce undesired results. For example in the
3760 second set of rectangles below, the red rectangle has specified an opacity
3761 of 0.5, which affects the opacity of its blue child rectangle even though
3762 the child has not specified an opacity.
3766 \o \image declarative-item_opacity1.png
3772 width: 100; height: 100
3775 x: 50; y: 50; width: 100; height: 100
3781 \o \image declarative-item_opacity2.png
3788 width: 100; height: 100
3791 x: 50; y: 50; width: 100; height: 100
3798 If an item's opacity is set to 0, the item will no longer receive mouse
3799 events, but will continue to receive key events and will retain the keyboard
3800 \l focus if it has been set. (In contrast, setting the \l visible property
3801 to \c false stops both mouse and keyboard events, and also removes focus
3806 Returns a value indicating whether mouse input should
3807 remain with this item exclusively.
3809 \sa setKeepMouseGrab()
3812 qreal QQuickItem::rotation() const
3814 Q_D(const QQuickItem);
3818 void QQuickItem::setRotation(qreal r)
3821 if (d->rotation == r)
3826 d->dirty(QQuickItemPrivate::BasicTransform);
3828 d->itemChange(ItemRotationHasChanged, r);
3830 emit rotationChanged();
3833 qreal QQuickItem::scale() const
3835 Q_D(const QQuickItem);
3839 void QQuickItem::setScale(qreal s)
3847 d->dirty(QQuickItemPrivate::BasicTransform);
3849 emit scaleChanged();
3852 qreal QQuickItem::opacity() const
3854 Q_D(const QQuickItem);
3858 void QQuickItem::setOpacity(qreal o)
3861 if (d->opacity == o)
3866 d->dirty(QQuickItemPrivate::OpacityValue);
3868 d->itemChange(ItemOpacityHasChanged, o);
3870 emit opacityChanged();
3873 bool QQuickItem::isVisible() const
3875 Q_D(const QQuickItem);
3876 return d->effectiveVisible;
3879 void QQuickItem::setVisible(bool v)
3882 if (v == d->explicitVisible)
3885 d->explicitVisible = v;
3887 d->setEffectiveVisibleRecur(d->calcEffectiveVisible());
3890 bool QQuickItem::isEnabled() const
3892 Q_D(const QQuickItem);
3893 return d->effectiveEnable;
3896 void QQuickItem::setEnabled(bool e)
3899 if (e == d->explicitEnable)
3902 d->explicitEnable = e;
3904 d->setEffectiveEnableRecur(d->calcEffectiveEnable());
3907 bool QQuickItemPrivate::calcEffectiveVisible() const
3909 // XXX todo - Should the effective visible of an element with no parent just be the current
3910 // effective visible? This would prevent pointless re-processing in the case of an element
3911 // moving to/from a no-parent situation, but it is different from what graphics view does.
3912 return explicitVisible && (!parentItem || QQuickItemPrivate::get(parentItem)->effectiveVisible);
3915 void QQuickItemPrivate::setEffectiveVisibleRecur(bool newEffectiveVisible)
3919 if (newEffectiveVisible && !explicitVisible) {
3920 // This item locally overrides visibility
3924 if (newEffectiveVisible == effectiveVisible) {
3925 // No change necessary
3929 effectiveVisible = newEffectiveVisible;
3931 if (parentItem) QQuickItemPrivate::get(parentItem)->dirty(ChildrenStackingChanged);
3934 QQuickCanvasPrivate *canvasPriv = QQuickCanvasPrivate::get(canvas);
3935 if (canvasPriv->mouseGrabberItem == q)
3939 for (int ii = 0; ii < childItems.count(); ++ii)
3940 QQuickItemPrivate::get(childItems.at(ii))->setEffectiveVisibleRecur(newEffectiveVisible);
3942 for (int ii = 0; ii < changeListeners.count(); ++ii) {
3943 const QQuickItemPrivate::ChangeListener &change = changeListeners.at(ii);
3944 if (change.types & QQuickItemPrivate::Visibility)
3945 change.listener->itemVisibilityChanged(q);
3949 QAccessible::updateAccessibility(q, 0, effectiveVisible ? QAccessible::ObjectShow : QAccessible::ObjectHide );
3951 emit q->visibleChanged();
3954 bool QQuickItemPrivate::calcEffectiveEnable() const
3956 // XXX todo - Should the effective enable of an element with no parent just be the current
3957 // effective enable? This would prevent pointless re-processing in the case of an element
3958 // moving to/from a no-parent situation, but it is different from what graphics view does.
3959 return explicitEnable && (!parentItem || QQuickItemPrivate::get(parentItem)->effectiveEnable);
3962 void QQuickItemPrivate::setEffectiveEnableRecur(bool newEffectiveEnable)
3966 // XXX todo - need to fixup focus
3968 if (newEffectiveEnable && !explicitEnable) {
3969 // This item locally overrides enable
3973 if (newEffectiveEnable == effectiveEnable) {
3974 // No change necessary
3978 effectiveEnable = newEffectiveEnable;
3981 QQuickCanvasPrivate *canvasPriv = QQuickCanvasPrivate::get(canvas);
3982 if (canvasPriv->mouseGrabberItem == q)
3986 for (int ii = 0; ii < childItems.count(); ++ii)
3987 QQuickItemPrivate::get(childItems.at(ii))->setEffectiveEnableRecur(newEffectiveEnable);
3989 emit q->enabledChanged();
3992 QString QQuickItemPrivate::dirtyToString() const
3994 #define DIRTY_TO_STRING(value) if (dirtyAttributes & value) { \
3995 if (!rv.isEmpty()) \
3996 rv.append(QLatin1String("|")); \
3997 rv.append(QLatin1String(#value)); \
4000 // QString rv = QLatin1String("0x") + QString::number(dirtyAttributes, 16);
4003 DIRTY_TO_STRING(TransformOrigin);
4004 DIRTY_TO_STRING(Transform);
4005 DIRTY_TO_STRING(BasicTransform);
4006 DIRTY_TO_STRING(Position);
4007 DIRTY_TO_STRING(Size);
4008 DIRTY_TO_STRING(ZValue);
4009 DIRTY_TO_STRING(Content);
4010 DIRTY_TO_STRING(Smooth);
4011 DIRTY_TO_STRING(OpacityValue);
4012 DIRTY_TO_STRING(ChildrenChanged);
4013 DIRTY_TO_STRING(ChildrenStackingChanged);
4014 DIRTY_TO_STRING(ParentChanged);
4015 DIRTY_TO_STRING(Clip);
4016 DIRTY_TO_STRING(Canvas);
4017 DIRTY_TO_STRING(EffectReference);
4018 DIRTY_TO_STRING(Visible);
4019 DIRTY_TO_STRING(HideReference);
4020 DIRTY_TO_STRING(PerformanceHints);
4025 void QQuickItemPrivate::dirty(DirtyType type)
4028 if (type & (TransformOrigin | Transform | BasicTransform | Position | Size))
4031 if (!(dirtyAttributes & type) || (canvas && !prevDirtyItem)) {
4032 dirtyAttributes |= type;
4035 QQuickCanvasPrivate::get(canvas)->dirtyItem(q);
4040 void QQuickItemPrivate::addToDirtyList()
4045 if (!prevDirtyItem) {
4046 Q_ASSERT(!nextDirtyItem);
4048 QQuickCanvasPrivate *p = QQuickCanvasPrivate::get(canvas);
4049 nextDirtyItem = p->dirtyItemList;
4050 if (nextDirtyItem) QQuickItemPrivate::get(nextDirtyItem)->prevDirtyItem = &nextDirtyItem;
4051 prevDirtyItem = &p->dirtyItemList;
4052 p->dirtyItemList = q;
4055 Q_ASSERT(prevDirtyItem);
4058 void QQuickItemPrivate::removeFromDirtyList()
4060 if (prevDirtyItem) {
4061 if (nextDirtyItem) QQuickItemPrivate::get(nextDirtyItem)->prevDirtyItem = prevDirtyItem;
4062 *prevDirtyItem = nextDirtyItem;
4066 Q_ASSERT(!prevDirtyItem);
4067 Q_ASSERT(!nextDirtyItem);
4070 void QQuickItemPrivate::refFromEffectItem(bool hide)
4073 if (1 == effectRefCount) {
4074 dirty(EffectReference);
4075 if (parentItem) QQuickItemPrivate::get(parentItem)->dirty(ChildrenStackingChanged);
4078 if (++hideRefCount == 1)
4079 dirty(HideReference);
4083 void QQuickItemPrivate::derefFromEffectItem(bool unhide)
4085 Q_ASSERT(effectRefCount);
4087 if (0 == effectRefCount) {
4088 dirty(EffectReference);
4089 if (parentItem) QQuickItemPrivate::get(parentItem)->dirty(ChildrenStackingChanged);
4092 if (--hideRefCount == 0)
4093 dirty(HideReference);
4097 void QQuickItemPrivate::itemChange(QQuickItem::ItemChange change, const QQuickItem::ItemChangeData &data)
4101 case QQuickItem::ItemChildAddedChange:
4102 q->itemChange(change, data);
4103 for (int ii = 0; ii < changeListeners.count(); ++ii) {
4104 const QQuickItemPrivate::ChangeListener &change = changeListeners.at(ii);
4105 if (change.types & QQuickItemPrivate::Children) {
4106 change.listener->itemChildAdded(q, data.item);
4110 case QQuickItem::ItemChildRemovedChange:
4111 q->itemChange(change, data);
4112 for (int ii = 0; ii < changeListeners.count(); ++ii) {
4113 const QQuickItemPrivate::ChangeListener &change = changeListeners.at(ii);
4114 if (change.types & QQuickItemPrivate::Children) {
4115 change.listener->itemChildRemoved(q, data.item);
4119 case QQuickItem::ItemSceneChange:
4120 q->itemChange(change, data);
4122 case QQuickItem::ItemVisibleHasChanged:
4123 q->itemChange(change, data);
4124 for (int ii = 0; ii < changeListeners.count(); ++ii) {
4125 const QQuickItemPrivate::ChangeListener &change = changeListeners.at(ii);
4126 if (change.types & QQuickItemPrivate::Visibility) {
4127 change.listener->itemVisibilityChanged(q);
4131 case QQuickItem::ItemParentHasChanged:
4132 q->itemChange(change, data);
4133 for (int ii = 0; ii < changeListeners.count(); ++ii) {
4134 const QQuickItemPrivate::ChangeListener &change = changeListeners.at(ii);
4135 if (change.types & QQuickItemPrivate::Parent) {
4136 change.listener->itemParentChanged(q, data.item);
4140 case QQuickItem::ItemOpacityHasChanged:
4141 q->itemChange(change, data);
4142 for (int ii = 0; ii < changeListeners.count(); ++ii) {
4143 const QQuickItemPrivate::ChangeListener &change = changeListeners.at(ii);
4144 if (change.types & QQuickItemPrivate::Opacity) {
4145 change.listener->itemOpacityChanged(q);
4149 case QQuickItem::ItemActiveFocusHasChanged:
4150 q->itemChange(change, data);
4152 case QQuickItem::ItemRotationHasChanged:
4153 q->itemChange(change, data);
4154 for (int ii = 0; ii < changeListeners.count(); ++ii) {
4155 const QQuickItemPrivate::ChangeListener &change = changeListeners.at(ii);
4156 if (change.types & QQuickItemPrivate::Rotation) {
4157 change.listener->itemRotationChanged(q);
4165 \property QQuickItem::smooth
4166 \brief whether the item is smoothly transformed.
4168 This property is provided purely for the purpose of optimization. Turning
4169 smooth transforms off is faster, but looks worse; turning smooth
4170 transformations on is slower, but looks better.
4172 By default smooth transformations are off.
4176 Returns true if the item should be drawn with antialiasing and
4177 smooth pixmap filtering, false otherwise.
4179 The default is false.
4183 bool QQuickItem::smooth() const
4185 Q_D(const QQuickItem);
4190 Sets whether the item should be drawn with antialiasing and
4191 smooth pixmap filtering to \a smooth.
4195 void QQuickItem::setSmooth(bool smooth)
4198 if (d->smooth == smooth)
4202 d->dirty(QQuickItemPrivate::Smooth);
4204 emit smoothChanged(smooth);
4207 QQuickItem::Flags QQuickItem::flags() const
4209 Q_D(const QQuickItem);
4210 return (QQuickItem::Flags)d->flags;
4213 void QQuickItem::setFlag(Flag flag, bool enabled)
4217 setFlags((Flags)(d->flags | (quint32)flag));
4219 setFlags((Flags)(d->flags & ~(quint32)flag));
4222 void QQuickItem::setFlags(Flags flags)
4226 if ((flags & ItemIsFocusScope) != (d->flags & ItemIsFocusScope)) {
4227 if (flags & ItemIsFocusScope && !d->childItems.isEmpty() && d->canvas) {
4228 qWarning("QQuickItem: Cannot set FocusScope once item has children and is in a canvas.");
4229 flags &= ~ItemIsFocusScope;
4230 } else if (d->flags & ItemIsFocusScope) {
4231 qWarning("QQuickItem: Cannot unset FocusScope flag.");
4232 flags |= ItemIsFocusScope;
4236 if ((flags & ItemClipsChildrenToShape ) != (d->flags & ItemClipsChildrenToShape))
4237 d->dirty(QQuickItemPrivate::Clip);
4242 qreal QQuickItem::x() const
4244 Q_D(const QQuickItem);
4248 qreal QQuickItem::y() const
4250 Q_D(const QQuickItem);
4254 QPointF QQuickItem::pos() const
4256 Q_D(const QQuickItem);
4257 return QPointF(d->x, d->y);
4260 void QQuickItem::setX(qreal v)
4269 d->dirty(QQuickItemPrivate::Position);
4271 geometryChanged(QRectF(x(), y(), width(), height()),
4272 QRectF(oldx, y(), width(), height()));
4275 void QQuickItem::setY(qreal v)
4284 d->dirty(QQuickItemPrivate::Position);
4286 geometryChanged(QRectF(x(), y(), width(), height()),
4287 QRectF(x(), oldy, width(), height()));
4290 void QQuickItem::setPos(const QPointF &pos)
4293 if (QPointF(d->x, d->y) == pos)
4302 d->dirty(QQuickItemPrivate::Position);
4304 geometryChanged(QRectF(x(), y(), width(), height()),
4305 QRectF(oldx, oldy, width(), height()));
4308 qreal QQuickItem::width() const
4310 Q_D(const QQuickItem);
4314 void QQuickItem::setWidth(qreal w)
4320 d->widthValid = true;
4324 qreal oldWidth = d->width;
4327 d->dirty(QQuickItemPrivate::Size);
4329 geometryChanged(QRectF(x(), y(), width(), height()),
4330 QRectF(x(), y(), oldWidth, height()));
4333 void QQuickItem::resetWidth()
4336 d->widthValid = false;
4337 setImplicitWidth(implicitWidth());
4340 void QQuickItemPrivate::implicitWidthChanged()
4343 emit q->implicitWidthChanged();
4346 qreal QQuickItemPrivate::getImplicitWidth() const
4348 return implicitWidth;
4351 Returns the width of the item that is implied by other properties that determine the content.
4353 qreal QQuickItem::implicitWidth() const
4355 Q_D(const QQuickItem);
4356 return d->getImplicitWidth();
4360 \qmlproperty real QtQuick2::Item::implicitWidth
4361 \qmlproperty real QtQuick2::Item::implicitHeight
4363 Defines the natural width or height of the Item if no \l width or \l height is specified.
4365 The default implicit size for most items is 0x0, however some elements have an inherent
4366 implicit size which cannot be overridden, e.g. Image, Text.
4368 Setting the implicit size is useful for defining components that have a preferred size
4369 based on their content, for example:
4376 property alias icon: image.source
4377 property alias label: text.text
4378 implicitWidth: text.implicitWidth + image.implicitWidth
4379 implicitHeight: Math.max(text.implicitHeight, image.implicitHeight)
4384 anchors.left: image.right; anchors.right: parent.right
4385 anchors.verticalCenter: parent.verticalCenter
4390 \bold Note: using implicitWidth of Text or TextEdit and setting the width explicitly
4391 incurs a performance penalty as the text must be laid out twice.
4395 Sets the implied width of the item to \a w.
4396 This is the width implied by other properties that determine the content.
4398 void QQuickItem::setImplicitWidth(qreal w)
4401 bool changed = w != d->implicitWidth;
4402 d->implicitWidth = w;
4403 if (d->width == w || widthValid()) {
4405 d->implicitWidthChanged();
4409 qreal oldWidth = d->width;
4412 d->dirty(QQuickItemPrivate::Size);
4414 geometryChanged(QRectF(x(), y(), width(), height()),
4415 QRectF(x(), y(), oldWidth, height()));
4418 d->implicitWidthChanged();
4422 Returns whether the width property has been set explicitly.
4424 bool QQuickItem::widthValid() const
4426 Q_D(const QQuickItem);
4427 return d->widthValid;
4430 qreal QQuickItem::height() const
4432 Q_D(const QQuickItem);
4436 void QQuickItem::setHeight(qreal h)
4442 d->heightValid = true;
4446 qreal oldHeight = d->height;
4449 d->dirty(QQuickItemPrivate::Size);
4451 geometryChanged(QRectF(x(), y(), width(), height()),
4452 QRectF(x(), y(), width(), oldHeight));
4455 void QQuickItem::resetHeight()
4458 d->heightValid = false;
4459 setImplicitHeight(implicitHeight());
4462 void QQuickItemPrivate::implicitHeightChanged()
4465 emit q->implicitHeightChanged();
4468 qreal QQuickItemPrivate::getImplicitHeight() const
4470 return implicitHeight;
4474 Returns the height of the item that is implied by other properties that determine the content.
4476 qreal QQuickItem::implicitHeight() const
4478 Q_D(const QQuickItem);
4479 return d->getImplicitHeight();
4484 Sets the implied height of the item to \a h.
4485 This is the height implied by other properties that determine the content.
4487 void QQuickItem::setImplicitHeight(qreal h)
4490 bool changed = h != d->implicitHeight;
4491 d->implicitHeight = h;
4492 if (d->height == h || heightValid()) {
4494 d->implicitHeightChanged();
4498 qreal oldHeight = d->height;
4501 d->dirty(QQuickItemPrivate::Size);
4503 geometryChanged(QRectF(x(), y(), width(), height()),
4504 QRectF(x(), y(), width(), oldHeight));
4507 d->implicitHeightChanged();
4510 void QQuickItem::setImplicitSize(qreal w, qreal h)
4513 bool wChanged = w != d->implicitWidth;
4514 bool hChanged = h != d->implicitHeight;
4516 d->implicitWidth = w;
4517 d->implicitHeight = h;
4521 if (d->width == w || widthValid()) {
4523 d->implicitWidthChanged();
4526 if (d->height == h || heightValid()) {
4528 d->implicitHeightChanged();
4534 qreal oldWidth = d->width;
4535 qreal oldHeight = d->height;
4541 d->dirty(QQuickItemPrivate::Size);
4543 geometryChanged(QRectF(x(), y(), width(), height()),
4544 QRectF(x(), y(), oldWidth, oldHeight));
4546 if (!wDone && wChanged)
4547 d->implicitWidthChanged();
4548 if (!hDone && hChanged)
4549 d->implicitHeightChanged();
4553 Returns whether the height property has been set explicitly.
4555 bool QQuickItem::heightValid() const
4557 Q_D(const QQuickItem);
4558 return d->heightValid;
4561 void QQuickItem::setSize(const QSizeF &size)
4564 d->heightValid = true;
4565 d->widthValid = true;
4567 if (QSizeF(d->width, d->height) == size)
4570 qreal oldHeight = d->height;
4571 qreal oldWidth = d->width;
4572 d->height = size.height();
4573 d->width = size.width();
4575 d->dirty(QQuickItemPrivate::Size);
4577 geometryChanged(QRectF(x(), y(), width(), height()),
4578 QRectF(x(), y(), oldWidth, oldHeight));
4581 bool QQuickItem::hasActiveFocus() const
4583 Q_D(const QQuickItem);
4584 return d->activeFocus;
4587 bool QQuickItem::hasFocus() const
4589 Q_D(const QQuickItem);
4593 void QQuickItem::setFocus(bool focus)
4596 if (d->focus == focus)
4600 // Need to find our nearest focus scope
4601 QQuickItem *scope = parentItem();
4602 while (scope && !scope->isFocusScope())
4603 scope = scope->parentItem();
4605 QQuickCanvasPrivate::get(d->canvas)->setFocusInScope(scope, this);
4607 QQuickCanvasPrivate::get(d->canvas)->clearFocusInScope(scope, this);
4610 emit focusChanged(focus);
4614 bool QQuickItem::isFocusScope() const
4616 return flags() & ItemIsFocusScope;
4619 QQuickItem *QQuickItem::scopedFocusItem() const
4621 Q_D(const QQuickItem);
4622 if (!isFocusScope())
4625 return d->subFocusItem;
4629 Qt::MouseButtons QQuickItem::acceptedMouseButtons() const
4631 Q_D(const QQuickItem);
4632 return d->acceptedMouseButtons;
4635 void QQuickItem::setAcceptedMouseButtons(Qt::MouseButtons buttons)
4638 d->acceptedMouseButtons = buttons;
4641 bool QQuickItem::filtersChildMouseEvents() const
4643 Q_D(const QQuickItem);
4644 return d->filtersChildMouseEvents;
4647 void QQuickItem::setFiltersChildMouseEvents(bool filter)
4650 d->filtersChildMouseEvents = filter;
4653 bool QQuickItem::isUnderMouse() const
4655 Q_D(const QQuickItem);
4659 QPoint cursorPos = QCursor::pos();
4660 if (QRectF(0, 0, width(), height()).contains(mapFromScene(cursorPos))) // ### refactor: d->canvas->mapFromGlobal(cursorPos))))
4665 bool QQuickItem::acceptHoverEvents() const
4667 Q_D(const QQuickItem);
4668 return d->hoverEnabled;
4671 void QQuickItem::setAcceptHoverEvents(bool enabled)
4674 d->hoverEnabled = enabled;
4677 void QQuickItem::grabMouse()
4682 QQuickCanvasPrivate *canvasPriv = QQuickCanvasPrivate::get(d->canvas);
4683 if (canvasPriv->mouseGrabberItem == this)
4686 QQuickItem *oldGrabber = canvasPriv->mouseGrabberItem;
4687 canvasPriv->mouseGrabberItem = this;
4689 oldGrabber->mouseUngrabEvent();
4692 void QQuickItem::ungrabMouse()
4697 QQuickCanvasPrivate *canvasPriv = QQuickCanvasPrivate::get(d->canvas);
4698 if (canvasPriv->mouseGrabberItem != this) {
4699 qWarning("QQuickItem::ungrabMouse(): Item is not the mouse grabber.");
4703 canvasPriv->mouseGrabberItem = 0;
4707 bool QQuickItem::keepMouseGrab() const
4709 Q_D(const QQuickItem);
4710 return d->keepMouse;
4714 The flag indicating whether the mouse should remain
4715 with this item is set to \a keep.
4717 This is useful for items that wish to grab and keep mouse
4718 interaction following a predefined gesture. For example,
4719 an item that is interested in horizontal mouse movement
4720 may set keepMouseGrab to true once a threshold has been
4721 exceeded. Once keepMouseGrab has been set to true, filtering
4722 items will not react to mouse events.
4724 If the item does not indicate that it wishes to retain mouse grab,
4725 a filtering item may steal the grab. For example, Flickable may attempt
4726 to steal a mouse grab if it detects that the user has begun to
4731 void QQuickItem::setKeepMouseGrab(bool keep)
4734 d->keepMouse = keep;
4738 Grabs the touch points specified by \a ids.
4740 These touch points will be owned by the item until
4741 they are released. Alternatively, the grab can be stolen
4742 by a filtering item like Flickable. Use setKeepTouchGrab()
4743 to prevent the grab from being stolen.
4745 \sa ungrabTouchPoints(), setKeepTouchGrab()
4747 void QQuickItem::grabTouchPoints(const QList<int> &ids)
4752 QQuickCanvasPrivate *canvasPriv = QQuickCanvasPrivate::get(d->canvas);
4754 QSet<QQuickItem*> ungrab;
4755 for (int i = 0; i < ids.count(); ++i) {
4756 QQuickItem *oldGrabber = canvasPriv->itemForTouchPointId.value(ids.at(i));
4757 if (oldGrabber == this)
4760 canvasPriv->itemForTouchPointId[ids.at(i)] = this;
4762 ungrab.insert(oldGrabber);
4764 foreach (QQuickItem *oldGrabber, ungrab)
4765 oldGrabber->touchUngrabEvent();
4769 Ungrabs the touch points owned by this item.
4771 \sa grabTouchPoints()
4773 void QQuickItem::ungrabTouchPoints()
4778 QQuickCanvasPrivate *canvasPriv = QQuickCanvasPrivate::get(d->canvas);
4780 QMutableHashIterator<int, QQuickItem*> i(canvasPriv->itemForTouchPointId);
4781 while (i.hasNext()) {
4783 if (i.value() == this)
4790 Returns a value indicating whether the touch points grabbed by this item
4791 should remain with this item exclusively.
4793 \sa setKeepTouchGrab(), keepMouseGrab()
4795 bool QQuickItem::keepTouchGrab() const
4797 Q_D(const QQuickItem);
4798 return d->keepTouch;
4802 The flag indicating whether the touch points grabbed
4803 by this item should remain with this item is set to \a keep.
4805 This is useful for items that wish to grab and keep specific touch
4806 points following a predefined gesture. For example,
4807 an item that is interested in horizontal touch point movement
4808 may set setKeepTouchGrab to true once a threshold has been
4809 exceeded. Once setKeepTouchGrab has been set to true, filtering
4810 items will not react to the relevant touch points.
4812 If the item does not indicate that it wishes to retain touch point grab,
4813 a filtering item may steal the grab. For example, Flickable may attempt
4814 to steal a touch point grab if it detects that the user has begun to
4817 \sa keepTouchGrab(), setKeepMouseGrab()
4819 void QQuickItem::setKeepTouchGrab(bool keep)
4822 d->keepTouch = keep;
4826 \qmlmethod object QtQuick2::Item::mapFromItem(Item item, real x, real y)
4828 Maps the point (\a x, \a y), which is in \a item's coordinate system, to
4829 this item's coordinate system, and returns an object with \c x and \c y
4830 properties matching the mapped coordinate.
4832 If \a item is a \c null value, this maps the point from the coordinate
4833 system of the root QML view.
4836 \qmlmethod object QtQuick2::Item::mapToItem(Item item, real x, real y)
4838 Maps the point (\a x, \a y), which is in this item's coordinate system, to
4839 \a item's coordinate system, and returns an object with \c x and \c y
4840 properties matching the mapped coordinate.
4842 If \a item is a \c null value, this maps \a x and \a y to the coordinate
4843 system of the root QML view.
4845 QPointF QQuickItem::mapToItem(const QQuickItem *item, const QPointF &point) const
4847 QPointF p = mapToScene(point);
4849 p = item->mapFromScene(p);
4853 QPointF QQuickItem::mapToScene(const QPointF &point) const
4855 Q_D(const QQuickItem);
4856 return d->itemToCanvasTransform().map(point);
4859 QRectF QQuickItem::mapRectToItem(const QQuickItem *item, const QRectF &rect) const
4861 Q_D(const QQuickItem);
4862 QTransform t = d->itemToCanvasTransform();
4864 t *= QQuickItemPrivate::get(item)->canvasToItemTransform();
4865 return t.mapRect(rect);
4868 QRectF QQuickItem::mapRectToScene(const QRectF &rect) const
4870 Q_D(const QQuickItem);
4871 return d->itemToCanvasTransform().mapRect(rect);
4874 QPointF QQuickItem::mapFromItem(const QQuickItem *item, const QPointF &point) const
4876 QPointF p = item?item->mapToScene(point):point;
4877 return mapFromScene(p);
4880 QPointF QQuickItem::mapFromScene(const QPointF &point) const
4882 Q_D(const QQuickItem);
4883 return d->canvasToItemTransform().map(point);
4886 QRectF QQuickItem::mapRectFromItem(const QQuickItem *item, const QRectF &rect) const
4888 Q_D(const QQuickItem);
4889 QTransform t = item?QQuickItemPrivate::get(item)->itemToCanvasTransform():QTransform();
4890 t *= d->canvasToItemTransform();
4891 return t.mapRect(rect);
4894 QRectF QQuickItem::mapRectFromScene(const QRectF &rect) const
4896 Q_D(const QQuickItem);
4897 return d->canvasToItemTransform().mapRect(rect);
4902 \qmlmethod QtQuick2::Item::forceActiveFocus()
4904 Forces active focus on the item.
4906 This method sets focus on the item and makes sure that all the focus scopes
4907 higher in the object hierarchy are also given the focus.
4911 Forces active focus on the item.
4913 This method sets focus on the item and makes sure that all the focus scopes
4914 higher in the object hierarchy are also given the focus.
4918 \qmlmethod QtQuick2::Item::childAt(real x, real y)
4920 Returns the visible child item at point (\a x, \a y), which is in this
4921 item's coordinate system, or \c null if there is no such item.
4925 Returns the visible child item at point (\a x, \a y), which is in this
4926 item's coordinate system, or 0 if there is no such item.
4930 \qmlproperty list<State> QtQuick2::Item::states
4931 This property holds a list of states defined by the item.
4947 \sa {qmlstate}{States}
4950 \qmlproperty list<Transition> QtQuick2::Item::transitions
4951 This property holds a list of transitions defined by the item.
4967 \sa {QML Animation and Transitions}{Transitions}
4970 \qmlproperty list<Filter> QtQuick2::Item::filter
4971 This property holds a list of graphical filters to be applied to the item.
4973 \l {Filter}{Filters} include things like \l {Blur}{blurring}
4974 the item, or giving it a \l Reflection. Some
4975 filters may not be available on all canvases; if a filter is not
4976 available on a certain canvas, it will simply not be applied for
4977 that canvas (but the QML will still be considered valid).
4995 \qmlproperty bool QtQuick2::Item::clip
4996 This property holds whether clipping is enabled. The default clip value is \c false.
4998 If clipping is enabled, an item will clip its own painting, as well
4999 as the painting of its children, to its bounding rectangle.
5001 Non-rectangular clipping regions are not supported for performance reasons.
5005 \property QQuickItem::clip
5006 This property holds whether clipping is enabled. The default clip value is \c false.
5008 If clipping is enabled, an item will clip its own painting, as well
5009 as the painting of its children, to its bounding rectangle. If you set
5010 clipping during an item's paint operation, remember to re-set it to
5011 prevent clipping the rest of your scene.
5013 Non-rectangular clipping regions are not supported for performance reasons.
5017 \qmlproperty string QtQuick2::Item::state
5019 This property holds the name of the current state of the item.
5021 This property is often used in scripts to change between states. For
5026 if (button.state == 'On')
5027 button.state = 'Off';
5029 button.state = 'On';
5033 If the item is in its base state (i.e. no explicit state has been
5034 set), \c state will be a blank string. Likewise, you can return an
5035 item to its base state by setting its current state to \c ''.
5037 \sa {qmlstates}{States}
5041 \qmlproperty list<Transform> QtQuick2::Item::transform
5042 This property holds the list of transformations to apply.
5044 For more information see \l Transform.
5048 \enum QQuickItem::TransformOrigin
5050 Controls the point about which simple transforms like scale apply.
5052 \value TopLeft The top-left corner of the item.
5053 \value Top The center point of the top of the item.
5054 \value TopRight The top-right corner of the item.
5055 \value Left The left most point of the vertical middle.
5056 \value Center The center of the item.
5057 \value Right The right most point of the vertical middle.
5058 \value BottomLeft The bottom-left corner of the item.
5059 \value Bottom The center point of the bottom of the item.
5060 \value BottomRight The bottom-right corner of the item.
5065 \qmlproperty bool QtQuick2::Item::activeFocus
5067 This property indicates whether the item has active focus.
5069 An item with active focus will receive keyboard input,
5070 or is a FocusScope ancestor of the item that will receive keyboard input.
5072 Usually, activeFocus is gained by setting focus on an item and its enclosing
5073 FocusScopes. In the following example \c input will have activeFocus.
5086 \sa focus, {qmlfocus}{Keyboard Focus}
5090 \qmlproperty bool QtQuick2::Item::focus
5091 This property indicates whether the item has focus within the enclosing focus scope. If true, this item
5092 will gain active focus when the enclosing focus scope gains active focus.
5093 In the following example, \c input will be given active focus when \c scope gains active focus.
5106 For the purposes of this property, the scene as a whole is assumed to act like a focus scope.
5107 On a practical level, that means the following QML will give active focus to \c input on startup.
5118 \sa activeFocus, {qmlfocus}{Keyboard Focus}
5123 \property QQuickItem::anchors
5128 \property QQuickItem::left
5133 \property QQuickItem::right
5138 \property QQuickItem::horizontalCenter
5143 \property QQuickItem::top
5148 \property QQuickItem::bottom
5153 \property QQuickItem::verticalCenter
5158 \property QQuickItem::focus
5163 \property QQuickItem::transform
5168 \property QQuickItem::transformOrigin
5173 \property QQuickItem::activeFocus
5178 \property QQuickItem::baseline
5183 \property QQuickItem::data
5188 \property QQuickItem::resources
5193 \property QQuickItem::state
5198 \property QQuickItem::states
5203 \property QQuickItem::transformOriginPoint
5208 \property QQuickItem::transitions
5212 bool QQuickItem::event(QEvent *ev)
5215 if (ev->type() == QEvent::PolishRequest) {
5217 d->polishScheduled = false;
5221 return QObject::event(ev);
5224 if (ev->type() == QEvent::InputMethodQuery) {
5225 QInputMethodQueryEvent *query = static_cast<QInputMethodQueryEvent *>(ev);
5226 Qt::InputMethodQueries queries = query->queries();
5227 for (uint i = 0; i < 32; ++i) {
5228 Qt::InputMethodQuery q = (Qt::InputMethodQuery)(int)(queries & (1<<i));
5230 QVariant v = inputMethodQuery(q);
5231 query->setValue(q, v);
5236 } else if (ev->type() == QEvent::InputMethod) {
5237 inputMethodEvent(static_cast<QInputMethodEvent *>(ev));
5240 return QObject::event(ev);
5243 #ifndef QT_NO_DEBUG_STREAM
5244 QDebug operator<<(QDebug debug, QQuickItem *item)
5247 debug << "QQuickItem(0)";
5251 debug << item->metaObject()->className() << "(this =" << ((void*)item)
5252 << ", name=" << item->objectName()
5253 << ", parent =" << ((void*)item->parentItem())
5254 << ", geometry =" << QRectF(item->pos(), QSizeF(item->width(), item->height()))
5255 << ", z =" << item->z() << ')';
5260 qint64 QQuickItemPrivate::consistentTime = -1;
5261 void QQuickItemPrivate::setConsistentTime(qint64 t)
5266 class QElapsedTimerConsistentTimeHack
5270 t1 = QQuickItemPrivate::consistentTime;
5274 return QQuickItemPrivate::consistentTime - t1;
5277 qint64 val = QQuickItemPrivate::consistentTime - t1;
5278 t1 = QQuickItemPrivate::consistentTime;
5288 void QQuickItemPrivate::start(QElapsedTimer &t)
5290 if (QQuickItemPrivate::consistentTime == -1)
5293 ((QElapsedTimerConsistentTimeHack*)&t)->start();
5296 qint64 QQuickItemPrivate::elapsed(QElapsedTimer &t)
5298 if (QQuickItemPrivate::consistentTime == -1)
5301 return ((QElapsedTimerConsistentTimeHack*)&t)->elapsed();
5304 qint64 QQuickItemPrivate::restart(QElapsedTimer &t)
5306 if (QQuickItemPrivate::consistentTime == -1)
5309 return ((QElapsedTimerConsistentTimeHack*)&t)->restart();
5313 \fn bool QQuickItem::isTextureProvider() const
5315 Returns true if this item is a texture provider. The default
5316 implementation returns false.
5318 This function can be called from any thread.
5321 bool QQuickItem::isTextureProvider() const
5323 Q_D(const QQuickItem);
5324 return d->_layer && d->_layer->effectSource() ? d->_layer->effectSource()->isTextureProvider() : false;
5328 \fn QSGTextureProvider *QQuickItem::textureProvider() const
5330 Returns the texture provider for an item. The default implementation
5333 This function may only be called on the rendering thread.
5336 QSGTextureProvider *QQuickItem::textureProvider() const
5338 Q_D(const QQuickItem);
5339 return d->_layer && d->_layer->effectSource() ? d->_layer->effectSource()->textureProvider() : 0;
5344 QQuickItemLayer *QQuickItemPrivate::layer() const
5347 _layer = new QQuickItemLayer(const_cast<QQuickItem *>(q_func()));
5353 QQuickItemLayer::QQuickItemLayer(QQuickItem *item)
5358 , m_componentComplete(true)
5359 , m_wrapMode(QQuickShaderEffectSource::ClampToEdge)
5360 , m_format(QQuickShaderEffectSource::RGBA)
5361 , m_effectComponent(0)
5365 m_name = QLatin1String("source");
5368 QQuickItemLayer::~QQuickItemLayer()
5370 delete m_effectSource;
5377 \qmlproperty bool QtQuick2::Item::layer.enabled
5379 Holds wether the item is layered or not. Layering is disabled by default.
5381 A layered item is rendered into an offscreen surface and cached until
5382 it is changed. Enabling layering for complex QML item hierarchies can
5383 some times be an optimization.
5385 None of the other layer properties have any effect when the layer
5389 void QQuickItemLayer::setEnabled(bool e)
5394 if (m_componentComplete) {
5401 emit enabledChanged(e);
5404 void QQuickItemLayer::classBegin()
5406 m_componentComplete = false;
5409 void QQuickItemLayer::componentComplete()
5411 m_componentComplete = true;
5416 void QQuickItemLayer::activate()
5418 QQuickItem *parentItem = m_item->parentItem();
5419 if (!m_effectSource)
5420 m_effectSource = new QQuickShaderEffectSource();
5423 m_effectSource->setParentItem(parentItem);
5424 m_effectSource->stackAfter(m_item);
5427 m_effectSource->setVisible(!m_effectComponent && m_item->isVisible());
5428 m_effectSource->setSourceItem(m_item);
5429 m_effectSource->setHideSource(true);
5430 m_effectSource->setSmooth(m_smooth);
5431 m_effectSource->setTextureSize(m_size);
5432 m_effectSource->setSourceRect(m_sourceRect);
5433 m_effectSource->setMipmap(m_mipmap);
5434 m_effectSource->setWrapMode(m_wrapMode);
5435 m_effectSource->setFormat(m_format);
5437 if (m_effectComponent) {
5439 QObject *created = m_effectComponent->create();
5440 m_effect = qobject_cast<QQuickShaderEffect *>(created);
5442 qWarning("Item: layer.effect is not a shader effect");
5448 m_effect->setParentItem(parentItem);
5449 m_effect->stackAfter(m_effectSource);
5451 m_effect->setVisible(m_item->isVisible());
5452 m_effect->setProperty(m_name.toLatin1(), qVariantFromValue<QObject *>(m_effectSource));
5462 QQuickItemPrivate *id = QQuickItemPrivate::get(m_item);
5463 id->addItemChangeListener(this, QQuickItemPrivate::Geometry | QQuickItemPrivate::Opacity | QQuickItemPrivate::Parent | QQuickItemPrivate::Visibility | QQuickItemPrivate::SiblingOrder);
5466 void QQuickItemLayer::deactivate()
5468 delete m_effectSource;
5474 QQuickItemPrivate *id = QQuickItemPrivate::get(m_item);
5475 id->removeItemChangeListener(this, QQuickItemPrivate::Geometry | QQuickItemPrivate::Opacity | QQuickItemPrivate::Parent | QQuickItemPrivate::Visibility | QQuickItemPrivate::SiblingOrder);
5481 \qmlproperty Component QtQuick2::Item::layer.effect
5483 Holds the effect that is applied to this layer.
5485 The effect must be a \l ShaderEffect.
5488 void QQuickItemLayer::setEffect(QDeclarativeComponent *component)
5490 if (component == m_effectComponent)
5492 m_effectComponent = component;
5502 emit effectChanged(component);
5507 \qmlproperty bool QtQuick2::Item::layer.mipmap
5509 If this property is true, mipmaps are generated for the texture.
5511 \note Some OpenGL ES 2 implementations do not support mipmapping of
5512 non-power-of-two textures.
5515 void QQuickItemLayer::setMipmap(bool mipmap)
5517 if (mipmap == m_mipmap)
5522 m_effectSource->setMipmap(m_mipmap);
5524 emit mipmapChanged(mipmap);
5529 \qmlproperty enumeration QtQuick2::Item::layer.format
5531 This property defines the internal OpenGL format of the texture.
5532 Modifying this property makes most sense when the \a layer.effect is also
5533 specified. Depending on the OpenGL implementation, this property might
5534 allow you to save some texture memory.
5537 \o ShaderEffectSource.Alpha - GL_ALPHA
5538 \o ShaderEffectSource.RGB - GL_RGB
5539 \o ShaderEffectSource.RGBA - GL_RGBA
5542 \note Some OpenGL implementations do not support the GL_ALPHA format.
5545 void QQuickItemLayer::setFormat(QQuickShaderEffectSource::Format f)
5552 m_effectSource->setFormat(m_format);
5554 emit formatChanged(m_format);
5559 \qmlproperty enumeration QtQuick2::Item::layer.sourceRect
5561 This property defines which rectangular area of the \l sourceItem to
5562 render into the texture. The source rectangle can be larger than
5563 \l sourceItem itself. If the rectangle is null, which is the default,
5564 the whole \l sourceItem is rendered to texture.
5567 void QQuickItemLayer::setSourceRect(const QRectF &sourceRect)
5569 if (sourceRect == m_sourceRect)
5571 m_sourceRect = sourceRect;
5574 m_effectSource->setSourceRect(m_sourceRect);
5576 emit sourceRectChanged(sourceRect);
5582 \qmlproperty bool QtQuick2::Item::layer.smooth
5584 Holds whether the layer is smoothly transformed.
5587 void QQuickItemLayer::setSmooth(bool s)
5594 m_effectSource->setSmooth(m_smooth);
5596 emit smoothChanged(s);
5602 \qmlproperty size QtQuick2::Item::layer.textureSize
5604 This property holds the requested pixel size of the layers texture. If it is empty,
5605 which is the default, the size of the item is used.
5607 \note Some platforms have a limit on how small framebuffer objects can be,
5608 which means the actual texture size might be larger than the requested
5612 void QQuickItemLayer::setSize(const QSize &size)
5619 m_effectSource->setTextureSize(size);
5621 emit sizeChanged(size);
5627 \qmlproperty enumeration QtQuick2::Item::layer.wrapMode
5629 This property defines the OpenGL wrap modes associated with the texture.
5630 Modifying this property makes most sense when the \a layer.effect is
5634 \o ShaderEffectSource.ClampToEdge - GL_CLAMP_TO_EDGE both horizontally and vertically
5635 \o ShaderEffectSource.RepeatHorizontally - GL_REPEAT horizontally, GL_CLAMP_TO_EDGE vertically
5636 \o ShaderEffectSource.RepeatVertically - GL_CLAMP_TO_EDGE horizontally, GL_REPEAT vertically
5637 \o ShaderEffectSource.Repeat - GL_REPEAT both horizontally and vertically
5640 \note Some OpenGL ES 2 implementations do not support the GL_REPEAT
5641 wrap mode with non-power-of-two textures.
5644 void QQuickItemLayer::setWrapMode(QQuickShaderEffectSource::WrapMode mode)
5646 if (mode != m_wrapMode)
5651 m_effectSource->setWrapMode(m_wrapMode);
5653 emit wrapModeChanged(mode);
5657 void QQuickItemLayer::itemOpacityChanged(QQuickItem *item)
5663 void QQuickItemLayer::itemGeometryChanged(QQuickItem *, const QRectF &, const QRectF &)
5668 void QQuickItemLayer::itemParentChanged(QQuickItem *item, QQuickItem *parent)
5671 if (parent == m_effectSource || parent == m_effect)
5674 m_effectSource->setParentItem(parent);
5676 m_effectSource->stackAfter(m_item);
5679 m_effect->setParentItem(parent);
5681 m_effect->stackAfter(m_effectSource);
5685 void QQuickItemLayer::itemSiblingOrderChanged(QQuickItem *)
5687 m_effectSource->stackAfter(m_item);
5689 m_effect->stackAfter(m_effectSource);
5692 void QQuickItemLayer::itemVisibilityChanged(QQuickItem *)
5694 QQuickItem *l = m_effect ? (QQuickItem *) m_effect : (QQuickItem *) m_effectSource;
5695 l->setVisible(m_item->isVisible());
5698 void QQuickItemLayer::updateZ()
5700 QQuickItem *l = m_effect ? (QQuickItem *) m_effect : (QQuickItem *) m_effectSource;
5701 l->setZ(m_item->z());
5704 void QQuickItemLayer::updateOpacity()
5706 QQuickItem *l = m_effect ? (QQuickItem *) m_effect : (QQuickItem *) m_effectSource;
5707 l->setOpacity(m_item->opacity());
5710 void QQuickItemLayer::updateGeometry()
5712 QQuickItem *l = m_effect ? (QQuickItem *) m_effect : (QQuickItem *) m_effectSource;
5713 QRectF bounds = m_item->boundingRect();
5714 l->setWidth(bounds.width());
5715 l->setHeight(bounds.height());
5716 l->setX(bounds.x() + m_item->x());
5717 l->setY(bounds.y() + m_item->y());
5720 void QQuickItemLayer::updateMatrix()
5722 // Called directly from transformChanged(), so needs some extra
5724 if (!m_componentComplete || !m_enabled)
5726 QQuickItem *l = m_effect ? (QQuickItem *) m_effect : (QQuickItem *) m_effectSource;
5727 QQuickItemPrivate *ld = QQuickItemPrivate::get(l);
5728 l->setScale(m_item->scale());
5729 l->setRotation(m_item->rotation());
5730 ld->transforms = QQuickItemPrivate::get(m_item)->transforms;
5731 ld->origin = QQuickItemPrivate::get(m_item)->origin;
5732 ld->dirty(QQuickItemPrivate::Transform);
5737 #include <moc_qquickitem.cpp>