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)
1873 QQuickItem *itemAncestor = parentItem->parentItem();
1874 while (itemAncestor != 0) {
1875 if (itemAncestor == this) {
1876 qWarning("QQuickItem::setParentItem: Parent is already part of this items subtree.");
1879 itemAncestor = itemAncestor->parentItem();
1883 d->removeFromDirtyList();
1885 QQuickItem *oldParentItem = d->parentItem;
1886 QQuickItem *scopeFocusedItem = 0;
1888 if (oldParentItem) {
1889 QQuickItemPrivate *op = QQuickItemPrivate::get(oldParentItem);
1891 QQuickItem *scopeItem = 0;
1893 if (d->canvas && hasFocus()) {
1894 scopeItem = oldParentItem;
1895 while (!scopeItem->isFocusScope()) scopeItem = scopeItem->parentItem();
1896 scopeFocusedItem = this;
1897 } else if (d->canvas && !isFocusScope() && d->subFocusItem) {
1898 scopeItem = oldParentItem;
1899 while (!scopeItem->isFocusScope()) scopeItem = scopeItem->parentItem();
1900 scopeFocusedItem = d->subFocusItem;
1903 if (scopeFocusedItem)
1904 QQuickCanvasPrivate::get(d->canvas)->clearFocusInScope(scopeItem, scopeFocusedItem,
1905 QQuickCanvasPrivate::DontChangeFocusProperty);
1907 op->removeChild(this);
1908 } else if (d->canvas) {
1909 QQuickCanvasPrivate::get(d->canvas)->parentlessItems.remove(this);
1912 d->parentItem = parentItem;
1914 QQuickCanvas *parentCanvas = parentItem?QQuickItemPrivate::get(parentItem)->canvas:0;
1915 if (d->canvas != parentCanvas) {
1916 QQuickItemPrivate::InitializationState initState;
1918 d->initCanvas(&initState, parentCanvas);
1921 d->dirty(QQuickItemPrivate::ParentChanged);
1924 QQuickItemPrivate::get(d->parentItem)->addChild(this);
1926 d->setEffectiveVisibleRecur(d->calcEffectiveVisible());
1927 d->setEffectiveEnableRecur(0, d->calcEffectiveEnable());
1929 if (scopeFocusedItem && d->parentItem && d->canvas) {
1930 // We need to test whether this item becomes scope focused
1931 QQuickItem *scopeItem = 0;
1932 scopeItem = d->parentItem;
1933 while (!scopeItem->isFocusScope()) scopeItem = scopeItem->parentItem();
1935 if (scopeItem->scopedFocusItem()) {
1936 QQuickItemPrivate::get(scopeFocusedItem)->focus = false;
1937 emit scopeFocusedItem->focusChanged(false);
1939 QQuickCanvasPrivate::get(d->canvas)->setFocusInScope(scopeItem, scopeFocusedItem,
1940 QQuickCanvasPrivate::DontChangeFocusProperty);
1944 d->resolveLayoutMirror();
1946 d->itemChange(ItemParentHasChanged, d->parentItem);
1948 d->parentNotifier.notify();
1949 if (d->isAccessible && d->parentItem) {
1950 d->parentItem->d_func()->setAccessibleFlagAndListener();
1953 emit parentChanged(d->parentItem);
1956 void QQuickItem::stackBefore(const QQuickItem *sibling)
1959 if (!sibling || sibling == this || !d->parentItem || d->parentItem != QQuickItemPrivate::get(sibling)->parentItem) {
1960 qWarning("QQuickItem::stackBefore: Cannot stack before %p, which must be a sibling", sibling);
1964 QQuickItemPrivate *parentPrivate = QQuickItemPrivate::get(d->parentItem);
1966 int myIndex = parentPrivate->childItems.indexOf(this);
1967 int siblingIndex = parentPrivate->childItems.indexOf(const_cast<QQuickItem *>(sibling));
1969 Q_ASSERT(myIndex != -1 && siblingIndex != -1);
1971 if (myIndex == siblingIndex - 1)
1974 parentPrivate->childItems.removeAt(myIndex);
1976 if (myIndex < siblingIndex) --siblingIndex;
1978 parentPrivate->childItems.insert(siblingIndex, this);
1980 parentPrivate->dirty(QQuickItemPrivate::ChildrenStackingChanged);
1981 parentPrivate->markSortedChildrenDirty(this);
1983 for (int ii = qMin(siblingIndex, myIndex); ii < parentPrivate->childItems.count(); ++ii)
1984 QQuickItemPrivate::get(parentPrivate->childItems.at(ii))->siblingOrderChanged();
1987 void QQuickItem::stackAfter(const QQuickItem *sibling)
1990 if (!sibling || sibling == this || !d->parentItem || d->parentItem != QQuickItemPrivate::get(sibling)->parentItem) {
1991 qWarning("QQuickItem::stackAfter: Cannot stack after %p, which must be a sibling", sibling);
1995 QQuickItemPrivate *parentPrivate = QQuickItemPrivate::get(d->parentItem);
1997 int myIndex = parentPrivate->childItems.indexOf(this);
1998 int siblingIndex = parentPrivate->childItems.indexOf(const_cast<QQuickItem *>(sibling));
2000 Q_ASSERT(myIndex != -1 && siblingIndex != -1);
2002 if (myIndex == siblingIndex + 1)
2005 parentPrivate->childItems.removeAt(myIndex);
2007 if (myIndex < siblingIndex) --siblingIndex;
2009 parentPrivate->childItems.insert(siblingIndex + 1, this);
2011 parentPrivate->dirty(QQuickItemPrivate::ChildrenStackingChanged);
2012 parentPrivate->markSortedChildrenDirty(this);
2014 for (int ii = qMin(myIndex, siblingIndex + 1); ii < parentPrivate->childItems.count(); ++ii)
2015 QQuickItemPrivate::get(parentPrivate->childItems.at(ii))->siblingOrderChanged();
2019 Returns the QQuickItem parent of this item.
2021 QQuickItem *QQuickItem::parentItem() const
2023 Q_D(const QQuickItem);
2024 return d->parentItem;
2027 QSGEngine *QQuickItem::sceneGraphEngine() const
2029 return canvas()->sceneGraphEngine();
2032 QQuickCanvas *QQuickItem::canvas() const
2034 Q_D(const QQuickItem);
2038 static bool itemZOrder_sort(QQuickItem *lhs, QQuickItem *rhs)
2040 return lhs->z() < rhs->z();
2043 QList<QQuickItem *> QQuickItemPrivate::paintOrderChildItems() const
2045 if (sortedChildItems)
2046 return *sortedChildItems;
2048 // If none of the items have set Z then the paint order list is the same as
2049 // the childItems list. This is by far the most common case.
2051 for (int i = 0; i < childItems.count(); ++i) {
2052 if (QQuickItemPrivate::get(childItems.at(i))->z != 0.) {
2058 sortedChildItems = new QList<QQuickItem*>(childItems);
2059 qStableSort(sortedChildItems->begin(), sortedChildItems->end(), itemZOrder_sort);
2060 return *sortedChildItems;
2063 sortedChildItems = const_cast<QList<QQuickItem*>*>(&childItems);
2068 void QQuickItemPrivate::addChild(QQuickItem *child)
2072 Q_ASSERT(!childItems.contains(child));
2074 childItems.append(child);
2076 markSortedChildrenDirty(child);
2077 dirty(QQuickItemPrivate::ChildrenChanged);
2079 itemChange(QQuickItem::ItemChildAddedChange, child);
2081 emit q->childrenChanged();
2084 void QQuickItemPrivate::removeChild(QQuickItem *child)
2089 Q_ASSERT(childItems.contains(child));
2090 childItems.removeOne(child);
2091 Q_ASSERT(!childItems.contains(child));
2093 markSortedChildrenDirty(child);
2094 dirty(QQuickItemPrivate::ChildrenChanged);
2096 itemChange(QQuickItem::ItemChildRemovedChange, child);
2098 emit q->childrenChanged();
2101 void QQuickItemPrivate::InitializationState::clear()
2106 void QQuickItemPrivate::InitializationState::clear(QQuickItem *fs)
2111 QQuickItem *QQuickItemPrivate::InitializationState::getFocusScope(QQuickItem *item)
2114 QQuickItem *fs = item->parentItem();
2115 while (!fs->isFocusScope())
2116 fs = fs->parentItem();
2122 void QQuickItemPrivate::initCanvas(InitializationState *state, QQuickCanvas *c)
2127 removeFromDirtyList();
2128 QQuickCanvasPrivate *c = QQuickCanvasPrivate::get(canvas);
2129 if (polishScheduled)
2130 c->itemsToPolish.remove(q);
2131 if (c->mouseGrabberItem == q)
2132 c->mouseGrabberItem = 0;
2134 c->hoverItems.removeAll(q);
2135 if (itemNodeInstance)
2136 c->cleanup(itemNodeInstance);
2138 c->parentlessItems.remove(q);
2143 if (canvas && polishScheduled)
2144 QQuickCanvasPrivate::get(canvas)->itemsToPolish.insert(q);
2146 itemNodeInstance = 0;
2152 beforePaintNode = 0;
2154 InitializationState _dummy;
2155 InitializationState *childState = state;
2157 if (c && q->isFocusScope()) {
2159 childState = &_dummy;
2162 if (!parentItem && canvas)
2163 QQuickCanvasPrivate::get(canvas)->parentlessItems.insert(q);
2165 for (int ii = 0; ii < childItems.count(); ++ii) {
2166 QQuickItem *child = childItems.at(ii);
2167 QQuickItemPrivate::get(child)->initCanvas(childState, c);
2172 if (state->getFocusScope(q)->scopedFocusItem()) {
2174 emit q->focusChanged(false);
2176 QQuickCanvasPrivate::get(canvas)->setFocusInScope(state->getFocusScope(q), q);
2183 screenAttached->canvasChanged(c);
2184 itemChange(QQuickItem::ItemSceneChange, c);
2188 Returns a transform that maps points from canvas space into item space.
2190 QTransform QQuickItemPrivate::canvasToItemTransform() const
2192 // XXX todo - optimize
2193 return itemToCanvasTransform().inverted();
2197 Returns a transform that maps points from item space into canvas space.
2199 QTransform QQuickItemPrivate::itemToCanvasTransform() const
2202 QTransform rv = parentItem?QQuickItemPrivate::get(parentItem)->itemToCanvasTransform():QTransform();
2203 itemToParentTransform(rv);
2208 Motifies \a t with this items local transform relative to its parent.
2210 void QQuickItemPrivate::itemToParentTransform(QTransform &t) const
2215 if (!transforms.isEmpty()) {
2217 for (int ii = transforms.count() - 1; ii >= 0; --ii)
2218 transforms.at(ii)->applyTo(&m);
2219 t = m.toTransform();
2222 if (scale != 1. || rotation != 0.) {
2223 QPointF tp = computeTransformOrigin();
2224 t.translate(tp.x(), tp.y());
2225 t.scale(scale, scale);
2227 t.translate(-tp.x(), -tp.y());
2233 \qmlproperty real QtQuick2::Item::childrenRect.x
2234 \qmlproperty real QtQuick2::Item::childrenRect.y
2235 \qmlproperty real QtQuick2::Item::childrenRect.width
2236 \qmlproperty real QtQuick2::Item::childrenRect.height
2238 The childrenRect properties allow an item access to the geometry of its
2239 children. This property is useful if you have an item that needs to be
2240 sized to fit its children.
2245 \qmlproperty list<Item> QtQuick2::Item::children
2246 \qmlproperty list<Object> QtQuick2::Item::resources
2248 The children property contains the list of visual children of this item.
2249 The resources property contains non-visual resources that you want to
2252 Generally you can rely on Item's default property to handle all this for
2253 you, but it can come in handy in some cases.
2272 Returns true if construction of the QML component is complete; otherwise
2275 It is often desirable to delay some processing until the component is
2278 \sa componentComplete()
2280 bool QQuickItem::isComponentComplete() const
2282 Q_D(const QQuickItem);
2283 return d->componentComplete;
2286 QQuickItemPrivate::QQuickItemPrivate()
2287 : _anchors(0), _contents(0), baselineOffset(0), _anchorLines(0), _stateGroup(0), origin(QQuickItem::Center),
2289 flags(0), widthValid(false), heightValid(false), componentComplete(true),
2290 keepMouse(false), keepTouch(false), hoverEnabled(false), smooth(false), focus(false), activeFocus(false), notifiedFocus(false),
2291 notifiedActiveFocus(false), filtersChildMouseEvents(false), explicitVisible(true),
2292 effectiveVisible(true), explicitEnable(true), effectiveEnable(true), polishScheduled(false),
2293 inheritedLayoutMirror(false), effectiveLayoutMirror(false), isMirrorImplicit(true),
2294 inheritMirrorFromParent(false), inheritMirrorFromItem(false), childrenDoNotOverlap(false),
2295 staticSubtreeGeometry(false),
2296 isAccessible(false),
2298 canvas(0), parentItem(0), sortedChildItems(&childItems),
2302 x(0), y(0), width(0), height(0), implicitWidth(0), implicitHeight(0),
2303 z(0), scale(1), rotation(0), opacity(1),
2305 attachedLayoutDirection(0), acceptedMouseButtons(0),
2306 imHints(Qt::ImhNone),
2310 dirtyAttributes(0), nextDirtyItem(0), prevDirtyItem(0),
2312 itemNodeInstance(0), opacityNode(0), clipNode(0), rootNode(0), groupNode(0), paintNode(0)
2313 , beforePaintNode(0), effectRefCount(0), hideRefCount(0)
2314 , screenAttached(0), _layer(0)
2318 QQuickItemPrivate::~QQuickItemPrivate()
2320 if (sortedChildItems != &childItems)
2321 delete sortedChildItems;
2324 void QQuickItemPrivate::init(QQuickItem *parent)
2328 static bool atexit_registered = false;
2329 if (!atexit_registered) {
2330 atexit(qt_print_item_count);
2331 atexit_registered = true;
2337 registerAccessorProperties();
2339 baselineOffset.invalidate();
2342 q->setParentItem(parent);
2343 QQuickItemPrivate *parentPrivate = QQuickItemPrivate::get(parent);
2344 setImplicitLayoutMirror(parentPrivate->inheritedLayoutMirror, parentPrivate->inheritMirrorFromParent);
2348 void QQuickItemPrivate::data_append(QDeclarativeListProperty<QObject> *prop, QObject *o)
2353 QQuickItem *that = static_cast<QQuickItem *>(prop->object);
2355 // This test is measurably (albeit only slightly) faster than qobject_cast<>()
2356 const QMetaObject *mo = o->metaObject();
2357 while (mo && mo != &QQuickItem::staticMetaObject) {
2358 mo = mo->d.superdata;
2362 QQuickItem *item = static_cast<QQuickItem *>(o);
2363 item->setParentItem(that);
2365 if (o->inherits("QGraphicsItem"))
2366 qWarning("Cannot add a QtQuick 1.0 item (%s) into a QtQuick 2.0 scene!", o->metaObject()->className());
2368 // XXX todo - do we really want this behavior?
2374 \qmlproperty list<Object> QtQuick2::Item::data
2377 The data property allows you to freely mix visual children and resources
2378 in an item. If you assign a visual item to the data list it becomes
2379 a child and if you assign any other object type, it is added as a resource.
2403 data is a behind-the-scenes property: you should never need to explicitly
2407 int QQuickItemPrivate::data_count(QDeclarativeListProperty<QObject> *prop)
2414 QObject *QQuickItemPrivate::data_at(QDeclarativeListProperty<QObject> *prop, int i)
2422 void QQuickItemPrivate::data_clear(QDeclarativeListProperty<QObject> *prop)
2428 QObject *QQuickItemPrivate::resources_at(QDeclarativeListProperty<QObject> *prop, int index)
2430 const QObjectList children = prop->object->children();
2431 if (index < children.count())
2432 return children.at(index);
2437 void QQuickItemPrivate::resources_append(QDeclarativeListProperty<QObject> *prop, QObject *o)
2439 // XXX todo - do we really want this behavior?
2440 o->setParent(prop->object);
2443 int QQuickItemPrivate::resources_count(QDeclarativeListProperty<QObject> *prop)
2445 return prop->object->children().count();
2448 void QQuickItemPrivate::resources_clear(QDeclarativeListProperty<QObject> *prop)
2450 // XXX todo - do we really want this behavior?
2451 const QObjectList children = prop->object->children();
2452 for (int index = 0; index < children.count(); index++)
2453 children.at(index)->setParent(0);
2456 QQuickItem *QQuickItemPrivate::children_at(QDeclarativeListProperty<QQuickItem> *prop, int index)
2458 QQuickItemPrivate *p = QQuickItemPrivate::get(static_cast<QQuickItem *>(prop->object));
2459 if (index >= p->childItems.count() || index < 0)
2462 return p->childItems.at(index);
2465 void QQuickItemPrivate::children_append(QDeclarativeListProperty<QQuickItem> *prop, QQuickItem *o)
2470 QQuickItem *that = static_cast<QQuickItem *>(prop->object);
2471 if (o->parentItem() == that)
2472 o->setParentItem(0);
2474 o->setParentItem(that);
2477 int QQuickItemPrivate::children_count(QDeclarativeListProperty<QQuickItem> *prop)
2479 QQuickItemPrivate *p = QQuickItemPrivate::get(static_cast<QQuickItem *>(prop->object));
2480 return p->childItems.count();
2483 void QQuickItemPrivate::children_clear(QDeclarativeListProperty<QQuickItem> *prop)
2485 QQuickItem *that = static_cast<QQuickItem *>(prop->object);
2486 QQuickItemPrivate *p = QQuickItemPrivate::get(that);
2487 while (!p->childItems.isEmpty())
2488 p->childItems.at(0)->setParentItem(0);
2491 int QQuickItemPrivate::transform_count(QDeclarativeListProperty<QQuickTransform> *prop)
2493 QQuickItem *that = static_cast<QQuickItem *>(prop->object);
2494 return QQuickItemPrivate::get(that)->transforms.count();
2497 void QQuickTransform::appendToItem(QQuickItem *item)
2499 Q_D(QQuickTransform);
2503 QQuickItemPrivate *p = QQuickItemPrivate::get(item);
2505 if (!d->items.isEmpty() && !p->transforms.isEmpty() && p->transforms.contains(this)) {
2506 p->transforms.removeOne(this);
2507 p->transforms.append(this);
2509 p->transforms.append(this);
2510 d->items.append(item);
2513 p->dirty(QQuickItemPrivate::Transform);
2516 void QQuickTransform::prependToItem(QQuickItem *item)
2518 Q_D(QQuickTransform);
2522 QQuickItemPrivate *p = QQuickItemPrivate::get(item);
2524 if (!d->items.isEmpty() && !p->transforms.isEmpty() && p->transforms.contains(this)) {
2525 p->transforms.removeOne(this);
2526 p->transforms.prepend(this);
2528 p->transforms.prepend(this);
2529 d->items.append(item);
2532 p->dirty(QQuickItemPrivate::Transform);
2535 void QQuickItemPrivate::transform_append(QDeclarativeListProperty<QQuickTransform> *prop, QQuickTransform *transform)
2540 QQuickItem *that = static_cast<QQuickItem *>(prop->object);
2541 transform->appendToItem(that);
2544 QQuickTransform *QQuickItemPrivate::transform_at(QDeclarativeListProperty<QQuickTransform> *prop, int idx)
2546 QQuickItem *that = static_cast<QQuickItem *>(prop->object);
2547 QQuickItemPrivate *p = QQuickItemPrivate::get(that);
2549 if (idx < 0 || idx >= p->transforms.count())
2552 return p->transforms.at(idx);
2555 void QQuickItemPrivate::transform_clear(QDeclarativeListProperty<QQuickTransform> *prop)
2557 QQuickItem *that = static_cast<QQuickItem *>(prop->object);
2558 QQuickItemPrivate *p = QQuickItemPrivate::get(that);
2560 for (int ii = 0; ii < p->transforms.count(); ++ii) {
2561 QQuickTransform *t = p->transforms.at(ii);
2562 QQuickTransformPrivate *tp = QQuickTransformPrivate::get(t);
2563 tp->items.removeOne(that);
2566 p->transforms.clear();
2568 p->dirty(QQuickItemPrivate::Transform);
2572 \property QQuickItem::childrenRect
2573 \brief The geometry of an item's children.
2575 This property holds the (collective) position and size of the item's children.
2579 \qmlproperty real QtQuick2::Item::x
2580 \qmlproperty real QtQuick2::Item::y
2581 \qmlproperty real QtQuick2::Item::width
2582 \qmlproperty real QtQuick2::Item::height
2584 Defines the item's position and size relative to its parent.
2587 Item { x: 100; y: 100; width: 100; height: 100 }
2592 \qmlproperty real QtQuick2::Item::z
2594 Sets the stacking order of sibling items. By default the stacking order is 0.
2596 Items with a higher stacking value are drawn on top of siblings with a
2597 lower stacking order. Items with the same stacking value are drawn
2598 bottom up in the order they appear. Items with a negative stacking
2599 value are drawn under their parent's content.
2601 The following example shows the various effects of stacking order.
2605 \o \image declarative-item_stacking1.png
2606 \o Same \c z - later children above earlier children:
2611 width: 100; height: 100
2615 x: 50; y: 50; width: 100; height: 100
2620 \o \image declarative-item_stacking2.png
2621 \o Higher \c z on top:
2627 width: 100; height: 100
2631 x: 50; y: 50; width: 100; height: 100
2636 \o \image declarative-item_stacking3.png
2637 \o Same \c z - children above parents:
2642 width: 100; height: 100
2645 x: 50; y: 50; width: 100; height: 100
2651 \o \image declarative-item_stacking4.png
2652 \o Lower \c z below:
2657 width: 100; height: 100
2661 x: 50; y: 50; width: 100; height: 100
2670 \qmlproperty bool QtQuick2::Item::visible
2672 This property holds whether the item is visible. By default this is true.
2674 Setting this property directly affects the \c visible value of child
2675 items. When set to \c false, the \c visible values of all child items also
2676 become \c false. When set to \c true, the \c visible values of child items
2677 are returned to \c true, unless they have explicitly been set to \c false.
2679 (Because of this flow-on behavior, using the \c visible property may not
2680 have the intended effect if a property binding should only respond to
2681 explicit property changes. In such cases it may be better to use the
2682 \l opacity property instead.)
2684 Setting this property to \c false automatically causes \l focus to be set
2685 to \c false, and this item will longer receive mouse and keyboard events.
2686 (In contrast, setting the \l opacity to 0 does not affect the \l focus
2687 property and the receiving of key events.)
2689 \note This property's value is only affected by changes to this property or
2690 the parent's \c visible property. It does not change, for example, if this
2691 item moves off-screen, or if the \l opacity changes to 0.
2696 \qmlproperty AnchorLine QtQuick2::Item::anchors.top
2697 \qmlproperty AnchorLine QtQuick2::Item::anchors.bottom
2698 \qmlproperty AnchorLine QtQuick2::Item::anchors.left
2699 \qmlproperty AnchorLine QtQuick2::Item::anchors.right
2700 \qmlproperty AnchorLine QtQuick2::Item::anchors.horizontalCenter
2701 \qmlproperty AnchorLine QtQuick2::Item::anchors.verticalCenter
2702 \qmlproperty AnchorLine QtQuick2::Item::anchors.baseline
2704 \qmlproperty Item QtQuick2::Item::anchors.fill
2705 \qmlproperty Item QtQuick2::Item::anchors.centerIn
2707 \qmlproperty real QtQuick2::Item::anchors.margins
2708 \qmlproperty real QtQuick2::Item::anchors.topMargin
2709 \qmlproperty real QtQuick2::Item::anchors.bottomMargin
2710 \qmlproperty real QtQuick2::Item::anchors.leftMargin
2711 \qmlproperty real QtQuick2::Item::anchors.rightMargin
2712 \qmlproperty real QtQuick2::Item::anchors.horizontalCenterOffset
2713 \qmlproperty real QtQuick2::Item::anchors.verticalCenterOffset
2714 \qmlproperty real QtQuick2::Item::anchors.baselineOffset
2716 \qmlproperty bool QtQuick2::Item::anchors.mirrored
2718 Anchors provide a way to position an item by specifying its
2719 relationship with other items.
2721 Margins apply to top, bottom, left, right, and fill anchors.
2722 The \c anchors.margins property can be used to set all of the various margins at once, to the same value.
2723 Note that margins are anchor-specific and are not applied if an item does not
2726 Offsets apply for horizontal center, vertical center, and baseline anchors.
2730 \o \image declarative-anchors_example.png
2731 \o Text anchored to Image, horizontally centered and vertically below, with a margin.
2740 anchors.horizontalCenter: pic.horizontalCenter
2741 anchors.top: pic.bottom
2742 anchors.topMargin: 5
2748 \o \image declarative-anchors_example2.png
2750 Left of Text anchored to right of Image, with a margin. The y
2751 property of both defaults to 0.
2761 anchors.left: pic.right
2762 anchors.leftMargin: 5
2769 \c anchors.fill provides a convenient way for one item to have the
2770 same geometry as another item, and is equivalent to connecting all
2771 four directional anchors.
2773 To clear an anchor value, set it to \c undefined.
2775 \c anchors.mirrored returns true it the layout has been \l {LayoutMirroring}{mirrored}.
2777 \note You can only anchor an item to siblings or a parent.
2779 For more information see \l {anchor-layout}{Anchor Layouts}.
2783 \property QQuickItem::baselineOffset
2784 \brief The position of the item's baseline in local coordinates.
2786 The baseline of a \l Text item is the imaginary line on which the text
2787 sits. Controls containing text usually set their baseline to the
2788 baseline of their text.
2790 For non-text items, a default baseline offset of 0 is used.
2792 QQuickAnchors *QQuickItemPrivate::anchors() const
2795 Q_Q(const QQuickItem);
2796 _anchors = new QQuickAnchors(const_cast<QQuickItem *>(q));
2797 if (!componentComplete)
2798 _anchors->classBegin();
2803 QQuickItemPrivate::AnchorLines *QQuickItemPrivate::anchorLines() const
2805 Q_Q(const QQuickItem);
2806 if (!_anchorLines) _anchorLines =
2807 new AnchorLines(const_cast<QQuickItem *>(q));
2808 return _anchorLines;
2811 void QQuickItemPrivate::siblingOrderChanged()
2814 for (int ii = 0; ii < changeListeners.count(); ++ii) {
2815 const QQuickItemPrivate::ChangeListener &change = changeListeners.at(ii);
2816 if (change.types & QQuickItemPrivate::SiblingOrder) {
2817 change.listener->itemSiblingOrderChanged(q);
2822 QDeclarativeListProperty<QObject> QQuickItemPrivate::data()
2824 return QDeclarativeListProperty<QObject>(q_func(), 0, QQuickItemPrivate::data_append,
2825 QQuickItemPrivate::data_count,
2826 QQuickItemPrivate::data_at,
2827 QQuickItemPrivate::data_clear);
2830 QRectF QQuickItem::childrenRect()
2833 if (!d->_contents) {
2834 d->_contents = new QQuickContents(this);
2835 if (d->componentComplete)
2836 d->_contents->complete();
2838 return d->_contents->rectF();
2841 QList<QQuickItem *> QQuickItem::childItems() const
2843 Q_D(const QQuickItem);
2844 return d->childItems;
2847 bool QQuickItem::clip() const
2849 return flags() & ItemClipsChildrenToShape;
2852 void QQuickItem::setClip(bool c)
2857 setFlag(ItemClipsChildrenToShape, c);
2859 emit clipChanged(c);
2864 This function is called to handle this item's changes in
2865 geometry from \a oldGeometry to \a newGeometry. If the two
2866 geometries are the same, it doesn't do anything.
2868 void QQuickItem::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
2873 QQuickAnchorsPrivate::get(d->_anchors)->updateMe();
2875 bool xChange = (newGeometry.x() != oldGeometry.x());
2876 bool yChange = (newGeometry.y() != oldGeometry.y());
2877 bool widthChange = (newGeometry.width() != oldGeometry.width());
2878 bool heightChange = (newGeometry.height() != oldGeometry.height());
2880 for (int ii = 0; ii < d->changeListeners.count(); ++ii) {
2881 const QQuickItemPrivate::ChangeListener &change = d->changeListeners.at(ii);
2882 if (change.types & QQuickItemPrivate::Geometry) {
2883 if (change.gTypes == QQuickItemPrivate::GeometryChange) {
2884 change.listener->itemGeometryChanged(this, newGeometry, oldGeometry);
2885 } else if ((xChange && (change.gTypes & QQuickItemPrivate::XChange)) ||
2886 (yChange && (change.gTypes & QQuickItemPrivate::YChange)) ||
2887 (widthChange && (change.gTypes & QQuickItemPrivate::WidthChange)) ||
2888 (heightChange && (change.gTypes & QQuickItemPrivate::HeightChange))) {
2889 change.listener->itemGeometryChanged(this, newGeometry, oldGeometry);
2899 emit widthChanged();
2901 emit heightChanged();
2905 Called by the rendering thread when it is time to sync the state of the QML objects with the
2906 scene graph objects. The function should return the root of the scene graph subtree for
2907 this item. \a oldNode is the node that was returned the last time the function was called.
2909 The main thread is blocked while this function is executed so it is safe to read
2910 values from the QQuickItem instance and other objects in the main thread.
2912 \warning This is the only function in which it is allowed to make use of scene graph
2913 objects from the main thread. Use of scene graph objects outside this function will
2914 result in race conditions and potential crashes.
2917 QSGNode *QQuickItem::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *)
2923 QSGTransformNode *QQuickItemPrivate::createTransformNode()
2925 return new QSGTransformNode;
2928 void QQuickItem::updatePolish()
2932 void QQuickItem::sendAccessibilityUpdate()
2936 void QQuickItemPrivate::removeItemChangeListener(QQuickItemChangeListener *listener, ChangeTypes types)
2938 ChangeListener change(listener, types);
2939 changeListeners.removeOne(change);
2942 void QQuickItemPrivate::updateOrAddGeometryChangeListener(QQuickItemChangeListener *listener, GeometryChangeTypes types)
2944 ChangeListener change(listener, types);
2945 int index = changeListeners.find(change);
2947 changeListeners[index].gTypes = change.gTypes; //we may have different GeometryChangeTypes
2949 changeListeners.append(change);
2952 void QQuickItemPrivate::updateOrRemoveGeometryChangeListener(QQuickItemChangeListener *listener, GeometryChangeTypes types)
2954 ChangeListener change(listener, types);
2955 if (types == NoChange) {
2956 changeListeners.removeOne(change);
2958 int index = changeListeners.find(change);
2960 changeListeners[index].gTypes = change.gTypes; //we may have different GeometryChangeTypes
2964 void QQuickItem::keyPressEvent(QKeyEvent *event)
2969 void QQuickItem::keyReleaseEvent(QKeyEvent *event)
2974 void QQuickItem::inputMethodEvent(QInputMethodEvent *event)
2979 void QQuickItem::focusInEvent(QFocusEvent *)
2981 QAccessible::updateAccessibility(QAccessibleEvent(QAccessible::Focus, this, 0));
2984 void QQuickItem::focusOutEvent(QFocusEvent *)
2988 void QQuickItem::mousePressEvent(QMouseEvent *event)
2993 void QQuickItem::mouseMoveEvent(QMouseEvent *event)
2998 void QQuickItem::mouseReleaseEvent(QMouseEvent *event)
3003 void QQuickItem::mouseDoubleClickEvent(QMouseEvent *event)
3005 mousePressEvent(event);
3008 void QQuickItem::mouseUngrabEvent()
3013 void QQuickItem::touchUngrabEvent()
3018 void QQuickItem::wheelEvent(QWheelEvent *event)
3023 void QQuickItem::touchEvent(QTouchEvent *event)
3028 void QQuickItem::hoverEnterEvent(QHoverEvent *event)
3033 void QQuickItem::hoverMoveEvent(QHoverEvent *event)
3038 void QQuickItem::hoverLeaveEvent(QHoverEvent *event)
3043 void QQuickItem::dragEnterEvent(QDragEnterEvent *event)
3048 void QQuickItem::dragMoveEvent(QDragMoveEvent *event)
3054 void QQuickItem::dragLeaveEvent(QDragLeaveEvent *event)
3060 void QQuickItem::dropEvent(QDropEvent *event)
3065 bool QQuickItem::childMouseEventFilter(QQuickItem *, QEvent *)
3070 void QQuickItem::windowDeactivateEvent()
3072 foreach (QQuickItem* item, childItems()) {
3073 item->windowDeactivateEvent();
3077 Qt::InputMethodHints QQuickItem::inputMethodHints() const
3079 Q_D(const QQuickItem);
3083 void QQuickItem::setInputMethodHints(Qt::InputMethodHints hints)
3088 if (!d->canvas || d->canvas->activeFocusItem() != this)
3091 if (qApp->focusObject() == this)
3092 qApp->inputPanel()->update(Qt::ImHints);
3095 QVariant QQuickItem::inputMethodQuery(Qt::InputMethodQuery query) const
3097 Q_D(const QQuickItem);
3102 v = (bool)(flags() & ItemAcceptsInputMethod);
3105 v = (int)inputMethodHints();
3107 case Qt::ImCursorRectangle:
3109 case Qt::ImCursorPosition:
3110 case Qt::ImSurroundingText:
3111 case Qt::ImCurrentSelection:
3112 case Qt::ImMaximumTextLength:
3113 case Qt::ImAnchorPosition:
3114 case Qt::ImPreferredLanguage:
3116 v = d->keyHandler->inputMethodQuery(query);
3124 QQuickAnchorLine QQuickItemPrivate::left() const
3126 return anchorLines()->left;
3129 QQuickAnchorLine QQuickItemPrivate::right() const
3131 return anchorLines()->right;
3134 QQuickAnchorLine QQuickItemPrivate::horizontalCenter() const
3136 return anchorLines()->hCenter;
3139 QQuickAnchorLine QQuickItemPrivate::top() const
3141 return anchorLines()->top;
3144 QQuickAnchorLine QQuickItemPrivate::bottom() const
3146 return anchorLines()->bottom;
3149 QQuickAnchorLine QQuickItemPrivate::verticalCenter() const
3151 return anchorLines()->vCenter;
3154 QQuickAnchorLine QQuickItemPrivate::baseline() const
3156 return anchorLines()->baseline;
3159 qreal QQuickItem::baselineOffset() const
3161 Q_D(const QQuickItem);
3162 if (!d->baselineOffset.isValid()) {
3165 return d->baselineOffset;
3168 void QQuickItem::setBaselineOffset(qreal offset)
3171 if (offset == d->baselineOffset)
3174 d->baselineOffset = offset;
3176 for (int ii = 0; ii < d->changeListeners.count(); ++ii) {
3177 const QQuickItemPrivate::ChangeListener &change = d->changeListeners.at(ii);
3178 if (change.types & QQuickItemPrivate::Geometry) {
3179 QQuickAnchorsPrivate *anchor = change.listener->anchorPrivate();
3181 anchor->updateVerticalAnchors();
3184 emit baselineOffsetChanged(offset);
3187 void QQuickItem::update()
3190 Q_ASSERT(flags() & ItemHasContents);
3191 d->dirty(QQuickItemPrivate::Content);
3194 void QQuickItem::polish()
3197 if (!d->polishScheduled) {
3198 d->polishScheduled = true;
3200 QQuickCanvasPrivate *p = QQuickCanvasPrivate::get(d->canvas);
3201 bool maybeupdate = p->itemsToPolish.isEmpty();
3202 p->itemsToPolish.insert(this);
3203 if (maybeupdate) d->canvas->maybeUpdate();
3208 void QQuickItem::mapFromItem(QDeclarativeV8Function *args) const
3210 if (args->Length() != 0) {
3211 v8::Local<v8::Value> item = (*args)[0];
3212 QV8Engine *engine = args->engine();
3214 QQuickItem *itemObj = 0;
3215 if (!item->IsNull())
3216 itemObj = qobject_cast<QQuickItem*>(engine->toQObject(item));
3218 if (!itemObj && !item->IsNull()) {
3219 qmlInfo(this) << "mapFromItem() given argument \"" << engine->toString(item->ToString())
3220 << "\" which is neither null nor an Item";
3224 v8::Local<v8::Object> rv = v8::Object::New();
3225 args->returnValue(rv);
3227 qreal x = (args->Length() > 1)?(*args)[1]->NumberValue():0;
3228 qreal y = (args->Length() > 2)?(*args)[2]->NumberValue():0;
3230 QPointF p = mapFromItem(itemObj, QPointF(x, y));
3232 rv->Set(v8::String::New("x"), v8::Number::New(p.x()));
3233 rv->Set(v8::String::New("y"), v8::Number::New(p.y()));
3237 QTransform QQuickItem::itemTransform(QQuickItem *other, bool *ok) const
3239 Q_D(const QQuickItem);
3241 // XXX todo - we need to be able to handle common parents better and detect
3245 QTransform t = d->itemToCanvasTransform();
3246 if (other) t *= QQuickItemPrivate::get(other)->canvasToItemTransform();
3251 void QQuickItem::mapToItem(QDeclarativeV8Function *args) const
3253 if (args->Length() != 0) {
3254 v8::Local<v8::Value> item = (*args)[0];
3255 QV8Engine *engine = args->engine();
3257 QQuickItem *itemObj = 0;
3258 if (!item->IsNull())
3259 itemObj = qobject_cast<QQuickItem*>(engine->toQObject(item));
3261 if (!itemObj && !item->IsNull()) {
3262 qmlInfo(this) << "mapToItem() given argument \"" << engine->toString(item->ToString())
3263 << "\" which is neither null nor an Item";
3267 v8::Local<v8::Object> rv = v8::Object::New();
3268 args->returnValue(rv);
3270 qreal x = (args->Length() > 1)?(*args)[1]->NumberValue():0;
3271 qreal y = (args->Length() > 2)?(*args)[2]->NumberValue():0;
3273 QPointF p = mapToItem(itemObj, QPointF(x, y));
3275 rv->Set(v8::String::New("x"), v8::Number::New(p.x()));
3276 rv->Set(v8::String::New("y"), v8::Number::New(p.y()));
3280 void QQuickItem::forceActiveFocus()
3283 QQuickItem *parent = parentItem();
3285 if (parent->flags() & QQuickItem::ItemIsFocusScope) {
3286 parent->setFocus(true);
3288 parent = parent->parentItem();
3292 QQuickItem *QQuickItem::childAt(qreal x, qreal y) const
3294 // XXX todo - should this include transform etc.?
3295 const QList<QQuickItem *> children = childItems();
3296 for (int i = children.count()-1; i >= 0; --i) {
3297 QQuickItem *child = children.at(i);
3298 if (child->isVisible() && child->x() <= x
3299 && child->x() + child->width() >= x
3301 && child->y() + child->height() >= y)
3307 QDeclarativeListProperty<QObject> QQuickItemPrivate::resources()
3309 return QDeclarativeListProperty<QObject>(q_func(), 0, QQuickItemPrivate::resources_append,
3310 QQuickItemPrivate::resources_count,
3311 QQuickItemPrivate::resources_at,
3312 QQuickItemPrivate::resources_clear);
3315 QDeclarativeListProperty<QQuickItem> QQuickItemPrivate::children()
3317 return QDeclarativeListProperty<QQuickItem>(q_func(), 0, QQuickItemPrivate::children_append,
3318 QQuickItemPrivate::children_count,
3319 QQuickItemPrivate::children_at,
3320 QQuickItemPrivate::children_clear);
3324 QDeclarativeListProperty<QDeclarativeState> QQuickItemPrivate::states()
3326 return _states()->statesProperty();
3329 QDeclarativeListProperty<QDeclarativeTransition> QQuickItemPrivate::transitions()
3331 return _states()->transitionsProperty();
3334 QString QQuickItemPrivate::state() const
3339 return _stateGroup->state();
3342 void QQuickItemPrivate::setState(const QString &state)
3344 _states()->setState(state);
3347 QString QQuickItem::state() const
3349 Q_D(const QQuickItem);
3353 void QQuickItem::setState(const QString &state)
3359 QDeclarativeListProperty<QQuickTransform> QQuickItem::transform()
3361 return QDeclarativeListProperty<QQuickTransform>(this, 0, QQuickItemPrivate::transform_append,
3362 QQuickItemPrivate::transform_count,
3363 QQuickItemPrivate::transform_at,
3364 QQuickItemPrivate::transform_clear);
3367 void QQuickItem::classBegin()
3370 d->componentComplete = false;
3372 d->_stateGroup->classBegin();
3374 d->_anchors->classBegin();
3376 d->_layer->classBegin();
3379 void QQuickItem::componentComplete()
3382 d->componentComplete = true;
3384 d->_stateGroup->componentComplete();
3386 d->_anchors->componentComplete();
3387 QQuickAnchorsPrivate::get(d->_anchors)->updateOnComplete();
3391 d->_layer->componentComplete();
3394 d->keyHandler->componentComplete();
3396 d->_contents->complete();
3399 QDeclarativeStateGroup *QQuickItemPrivate::_states()
3403 _stateGroup = new QDeclarativeStateGroup;
3404 if (!componentComplete)
3405 _stateGroup->classBegin();
3406 FAST_CONNECT(_stateGroup, SIGNAL(stateChanged(QString)),
3407 q, SIGNAL(stateChanged(QString)))
3413 QQuickItemPrivate::AnchorLines::AnchorLines(QQuickItem *q)
3416 left.anchorLine = QQuickAnchorLine::Left;
3418 right.anchorLine = QQuickAnchorLine::Right;
3420 hCenter.anchorLine = QQuickAnchorLine::HCenter;
3422 top.anchorLine = QQuickAnchorLine::Top;
3424 bottom.anchorLine = QQuickAnchorLine::Bottom;
3426 vCenter.anchorLine = QQuickAnchorLine::VCenter;
3428 baseline.anchorLine = QQuickAnchorLine::Baseline;
3431 QPointF QQuickItemPrivate::computeTransformOrigin() const
3435 case QQuickItem::TopLeft:
3436 return QPointF(0, 0);
3437 case QQuickItem::Top:
3438 return QPointF(width / 2., 0);
3439 case QQuickItem::TopRight:
3440 return QPointF(width, 0);
3441 case QQuickItem::Left:
3442 return QPointF(0, height / 2.);
3443 case QQuickItem::Center:
3444 return QPointF(width / 2., height / 2.);
3445 case QQuickItem::Right:
3446 return QPointF(width, height / 2.);
3447 case QQuickItem::BottomLeft:
3448 return QPointF(0, height);
3449 case QQuickItem::Bottom:
3450 return QPointF(width / 2., height);
3451 case QQuickItem::BottomRight:
3452 return QPointF(width, height);
3456 void QQuickItemPrivate::transformChanged()
3459 _layer->updateMatrix();
3462 void QQuickItemPrivate::deliverKeyEvent(QKeyEvent *e)
3466 Q_ASSERT(e->isAccepted());
3468 if (e->type() == QEvent::KeyPress)
3469 keyHandler->keyPressed(e, false);
3471 keyHandler->keyReleased(e, false);
3473 if (e->isAccepted())
3479 if (e->type() == QEvent::KeyPress)
3480 q->keyPressEvent(e);
3482 q->keyReleaseEvent(e);
3484 if (e->isAccepted())
3490 if (e->type() == QEvent::KeyPress)
3491 keyHandler->keyPressed(e, true);
3493 keyHandler->keyReleased(e, true);
3497 void QQuickItemPrivate::deliverInputMethodEvent(QInputMethodEvent *e)
3501 Q_ASSERT(e->isAccepted());
3503 keyHandler->inputMethodEvent(e, false);
3505 if (e->isAccepted())
3511 q->inputMethodEvent(e);
3513 if (e->isAccepted())
3519 keyHandler->inputMethodEvent(e, true);
3523 void QQuickItemPrivate::deliverFocusEvent(QFocusEvent *e)
3527 if (e->type() == QEvent::FocusIn) {
3530 q->focusOutEvent(e);
3534 void QQuickItemPrivate::deliverMouseEvent(QMouseEvent *e)
3538 Q_ASSERT(e->isAccepted());
3540 switch (e->type()) {
3542 Q_ASSERT(!"Unknown event type");
3543 case QEvent::MouseMove:
3544 q->mouseMoveEvent(e);
3546 case QEvent::MouseButtonPress:
3547 q->mousePressEvent(e);
3549 case QEvent::MouseButtonRelease:
3550 q->mouseReleaseEvent(e);
3552 case QEvent::MouseButtonDblClick:
3553 q->mouseDoubleClickEvent(e);
3558 void QQuickItemPrivate::deliverWheelEvent(QWheelEvent *e)
3564 void QQuickItemPrivate::deliverTouchEvent(QTouchEvent *e)
3570 void QQuickItemPrivate::deliverHoverEvent(QHoverEvent *e)
3573 switch (e->type()) {
3575 Q_ASSERT(!"Unknown event type");
3576 case QEvent::HoverEnter:
3577 q->hoverEnterEvent(e);
3579 case QEvent::HoverLeave:
3580 q->hoverLeaveEvent(e);
3582 case QEvent::HoverMove:
3583 q->hoverMoveEvent(e);
3588 void QQuickItemPrivate::deliverDragEvent(QEvent *e)
3591 switch (e->type()) {
3593 Q_ASSERT(!"Unknown event type");
3594 case QEvent::DragEnter:
3595 q->dragEnterEvent(static_cast<QDragEnterEvent *>(e));
3597 case QEvent::DragLeave:
3598 q->dragLeaveEvent(static_cast<QDragLeaveEvent *>(e));
3600 case QEvent::DragMove:
3601 q->dragMoveEvent(static_cast<QDragMoveEvent *>(e));
3604 q->dropEvent(static_cast<QDropEvent *>(e));
3609 void QQuickItem::itemChange(ItemChange change, const ItemChangeData &value)
3616 Notify input method on updated query values if needed. \a indicates changed attributes.
3618 void QQuickItem::updateInputMethod(Qt::InputMethodQueries queries)
3620 if (hasActiveFocus())
3621 qApp->inputPanel()->update(queries);
3625 // XXX todo - do we want/need this anymore?
3626 // Note that it's now used for varying clip rect
3627 QRectF QQuickItem::boundingRect() const
3629 Q_D(const QQuickItem);
3630 return QRectF(0, 0, d->width, d->height);
3633 QQuickItem::TransformOrigin QQuickItem::transformOrigin() const
3635 Q_D(const QQuickItem);
3639 void QQuickItem::setTransformOrigin(TransformOrigin origin)
3642 if (origin == d->origin)
3646 d->dirty(QQuickItemPrivate::TransformOrigin);
3648 emit transformOriginChanged(d->origin);
3651 QPointF QQuickItem::transformOriginPoint() const
3653 Q_D(const QQuickItem);
3654 if (!d->transformOriginPoint.isNull())
3655 return d->transformOriginPoint;
3656 return d->computeTransformOrigin();
3659 void QQuickItem::setTransformOriginPoint(const QPointF &point)
3662 if (d->transformOriginPoint == point)
3665 d->transformOriginPoint = point;
3666 d->dirty(QQuickItemPrivate::TransformOrigin);
3669 qreal QQuickItem::z() const
3671 Q_D(const QQuickItem);
3675 void QQuickItem::setZ(qreal v)
3683 d->dirty(QQuickItemPrivate::ZValue);
3684 if (d->parentItem) {
3685 QQuickItemPrivate::get(d->parentItem)->dirty(QQuickItemPrivate::ChildrenStackingChanged);
3686 QQuickItemPrivate::get(d->parentItem)->markSortedChildrenDirty(this);
3692 d->_layer->updateZ();
3697 \qmlproperty real QtQuick2::Item::rotation
3698 This property holds the rotation of the item in degrees clockwise.
3700 This specifies how many degrees to rotate the item around its transformOrigin.
3701 The default rotation is 0 degrees (i.e. not rotated at all).
3705 \o \image declarative-rotation.png
3710 width: 100; height: 100
3713 x: 25; y: 25; width: 50; height: 50
3720 \sa transform, Rotation
3724 \qmlproperty real QtQuick2::Item::scale
3725 This property holds the scale of the item.
3727 A scale of less than 1 means the item will be displayed smaller than
3728 normal, and a scale of greater than 1 means the item will be
3729 displayed larger than normal. A negative scale means the item will
3732 By default, items are displayed at a scale of 1 (i.e. at their
3735 Scaling is from the item's transformOrigin.
3739 \o \image declarative-scale.png
3744 width: 100; height: 100
3747 width: 25; height: 25
3751 x: 25; y: 25; width: 50; height: 50
3758 \sa transform, Scale
3762 \qmlproperty real QtQuick2::Item::opacity
3764 This property holds the opacity of the item. Opacity is specified as a
3765 number between 0 (fully transparent) and 1 (fully opaque). The default is 1.
3767 When this property is set, the specified opacity is also applied
3768 individually to child items. In almost all cases this is what you want,
3769 but in some cases it may produce undesired results. For example in the
3770 second set of rectangles below, the red rectangle has specified an opacity
3771 of 0.5, which affects the opacity of its blue child rectangle even though
3772 the child has not specified an opacity.
3776 \o \image declarative-item_opacity1.png
3782 width: 100; height: 100
3785 x: 50; y: 50; width: 100; height: 100
3791 \o \image declarative-item_opacity2.png
3798 width: 100; height: 100
3801 x: 50; y: 50; width: 100; height: 100
3808 If an item's opacity is set to 0, the item will no longer receive mouse
3809 events, but will continue to receive key events and will retain the keyboard
3810 \l focus if it has been set. (In contrast, setting the \l visible property
3811 to \c false stops both mouse and keyboard events, and also removes focus
3816 Returns a value indicating whether mouse input should
3817 remain with this item exclusively.
3819 \sa setKeepMouseGrab()
3822 qreal QQuickItem::rotation() const
3824 Q_D(const QQuickItem);
3828 void QQuickItem::setRotation(qreal r)
3831 if (d->rotation == r)
3836 d->dirty(QQuickItemPrivate::BasicTransform);
3838 d->itemChange(ItemRotationHasChanged, r);
3840 emit rotationChanged();
3843 qreal QQuickItem::scale() const
3845 Q_D(const QQuickItem);
3849 void QQuickItem::setScale(qreal s)
3857 d->dirty(QQuickItemPrivate::BasicTransform);
3859 emit scaleChanged();
3862 qreal QQuickItem::opacity() const
3864 Q_D(const QQuickItem);
3868 void QQuickItem::setOpacity(qreal o)
3871 if (d->opacity == o)
3876 d->dirty(QQuickItemPrivate::OpacityValue);
3878 d->itemChange(ItemOpacityHasChanged, o);
3880 emit opacityChanged();
3883 bool QQuickItem::isVisible() const
3885 Q_D(const QQuickItem);
3886 return d->effectiveVisible;
3889 void QQuickItem::setVisible(bool v)
3892 if (v == d->explicitVisible)
3895 d->explicitVisible = v;
3897 d->setEffectiveVisibleRecur(d->calcEffectiveVisible());
3900 bool QQuickItem::isEnabled() const
3902 Q_D(const QQuickItem);
3903 return d->effectiveEnable;
3906 void QQuickItem::setEnabled(bool e)
3909 if (e == d->explicitEnable)
3912 d->explicitEnable = e;
3914 QQuickItem *scope = parentItem();
3915 while (scope && !scope->isFocusScope())
3916 scope = scope->parentItem();
3918 d->setEffectiveEnableRecur(scope, d->calcEffectiveEnable());
3921 bool QQuickItemPrivate::calcEffectiveVisible() const
3923 // XXX todo - Should the effective visible of an element with no parent just be the current
3924 // effective visible? This would prevent pointless re-processing in the case of an element
3925 // moving to/from a no-parent situation, but it is different from what graphics view does.
3926 return explicitVisible && (!parentItem || QQuickItemPrivate::get(parentItem)->effectiveVisible);
3929 void QQuickItemPrivate::setEffectiveVisibleRecur(bool newEffectiveVisible)
3933 if (newEffectiveVisible && !explicitVisible) {
3934 // This item locally overrides visibility
3938 if (newEffectiveVisible == effectiveVisible) {
3939 // No change necessary
3943 effectiveVisible = newEffectiveVisible;
3945 if (parentItem) QQuickItemPrivate::get(parentItem)->dirty(ChildrenStackingChanged);
3948 QQuickCanvasPrivate *canvasPriv = QQuickCanvasPrivate::get(canvas);
3949 if (canvasPriv->mouseGrabberItem == q)
3953 for (int ii = 0; ii < childItems.count(); ++ii)
3954 QQuickItemPrivate::get(childItems.at(ii))->setEffectiveVisibleRecur(newEffectiveVisible);
3956 for (int ii = 0; ii < changeListeners.count(); ++ii) {
3957 const QQuickItemPrivate::ChangeListener &change = changeListeners.at(ii);
3958 if (change.types & QQuickItemPrivate::Visibility)
3959 change.listener->itemVisibilityChanged(q);
3963 QAccessible::updateAccessibility(QAccessibleEvent(effectiveVisible ? QAccessible::ObjectShow : QAccessible::ObjectHide, q, 0));
3965 emit q->visibleChanged();
3968 bool QQuickItemPrivate::calcEffectiveEnable() const
3970 // XXX todo - Should the effective enable of an element with no parent just be the current
3971 // effective enable? This would prevent pointless re-processing in the case of an element
3972 // moving to/from a no-parent situation, but it is different from what graphics view does.
3973 return explicitEnable && (!parentItem || QQuickItemPrivate::get(parentItem)->effectiveEnable);
3976 void QQuickItemPrivate::setEffectiveEnableRecur(QQuickItem *scope, bool newEffectiveEnable)
3980 if (newEffectiveEnable && !explicitEnable) {
3981 // This item locally overrides enable
3985 if (newEffectiveEnable == effectiveEnable) {
3986 // No change necessary
3990 effectiveEnable = newEffectiveEnable;
3993 QQuickCanvasPrivate *canvasPriv = QQuickCanvasPrivate::get(canvas);
3994 if (canvasPriv->mouseGrabberItem == q)
3996 if (scope && !effectiveEnable && activeFocus) {
3997 canvasPriv->clearFocusInScope(
3998 scope, q, QQuickCanvasPrivate::DontChangeFocusProperty | QQuickCanvasPrivate::DontChangeSubFocusItem);
4002 for (int ii = 0; ii < childItems.count(); ++ii) {
4003 QQuickItemPrivate::get(childItems.at(ii))->setEffectiveEnableRecur(
4004 flags & QQuickItem::ItemIsFocusScope ? q : scope, newEffectiveEnable);
4007 if (canvas && scope && effectiveEnable && focus) {
4008 QQuickCanvasPrivate::get(canvas)->setFocusInScope(
4009 scope, q, QQuickCanvasPrivate::DontChangeFocusProperty | QQuickCanvasPrivate::DontChangeSubFocusItem);
4012 emit q->enabledChanged();
4015 QString QQuickItemPrivate::dirtyToString() const
4017 #define DIRTY_TO_STRING(value) if (dirtyAttributes & value) { \
4018 if (!rv.isEmpty()) \
4019 rv.append(QLatin1String("|")); \
4020 rv.append(QLatin1String(#value)); \
4023 // QString rv = QLatin1String("0x") + QString::number(dirtyAttributes, 16);
4026 DIRTY_TO_STRING(TransformOrigin);
4027 DIRTY_TO_STRING(Transform);
4028 DIRTY_TO_STRING(BasicTransform);
4029 DIRTY_TO_STRING(Position);
4030 DIRTY_TO_STRING(Size);
4031 DIRTY_TO_STRING(ZValue);
4032 DIRTY_TO_STRING(Content);
4033 DIRTY_TO_STRING(Smooth);
4034 DIRTY_TO_STRING(OpacityValue);
4035 DIRTY_TO_STRING(ChildrenChanged);
4036 DIRTY_TO_STRING(ChildrenStackingChanged);
4037 DIRTY_TO_STRING(ParentChanged);
4038 DIRTY_TO_STRING(Clip);
4039 DIRTY_TO_STRING(Canvas);
4040 DIRTY_TO_STRING(EffectReference);
4041 DIRTY_TO_STRING(Visible);
4042 DIRTY_TO_STRING(HideReference);
4043 DIRTY_TO_STRING(PerformanceHints);
4048 void QQuickItemPrivate::dirty(DirtyType type)
4051 if (type & (TransformOrigin | Transform | BasicTransform | Position | Size))
4054 if (!(dirtyAttributes & type) || (canvas && !prevDirtyItem)) {
4055 dirtyAttributes |= type;
4058 QQuickCanvasPrivate::get(canvas)->dirtyItem(q);
4063 void QQuickItemPrivate::addToDirtyList()
4068 if (!prevDirtyItem) {
4069 Q_ASSERT(!nextDirtyItem);
4071 QQuickCanvasPrivate *p = QQuickCanvasPrivate::get(canvas);
4072 nextDirtyItem = p->dirtyItemList;
4073 if (nextDirtyItem) QQuickItemPrivate::get(nextDirtyItem)->prevDirtyItem = &nextDirtyItem;
4074 prevDirtyItem = &p->dirtyItemList;
4075 p->dirtyItemList = q;
4078 Q_ASSERT(prevDirtyItem);
4081 void QQuickItemPrivate::removeFromDirtyList()
4083 if (prevDirtyItem) {
4084 if (nextDirtyItem) QQuickItemPrivate::get(nextDirtyItem)->prevDirtyItem = prevDirtyItem;
4085 *prevDirtyItem = nextDirtyItem;
4089 Q_ASSERT(!prevDirtyItem);
4090 Q_ASSERT(!nextDirtyItem);
4093 void QQuickItemPrivate::refFromEffectItem(bool hide)
4096 if (1 == effectRefCount) {
4097 dirty(EffectReference);
4098 if (parentItem) QQuickItemPrivate::get(parentItem)->dirty(ChildrenStackingChanged);
4101 if (++hideRefCount == 1)
4102 dirty(HideReference);
4106 void QQuickItemPrivate::derefFromEffectItem(bool unhide)
4108 Q_ASSERT(effectRefCount);
4110 if (0 == effectRefCount) {
4111 dirty(EffectReference);
4112 if (parentItem) QQuickItemPrivate::get(parentItem)->dirty(ChildrenStackingChanged);
4115 if (--hideRefCount == 0)
4116 dirty(HideReference);
4120 void QQuickItemPrivate::itemChange(QQuickItem::ItemChange change, const QQuickItem::ItemChangeData &data)
4124 case QQuickItem::ItemChildAddedChange:
4125 q->itemChange(change, data);
4126 for (int ii = 0; ii < changeListeners.count(); ++ii) {
4127 const QQuickItemPrivate::ChangeListener &change = changeListeners.at(ii);
4128 if (change.types & QQuickItemPrivate::Children) {
4129 change.listener->itemChildAdded(q, data.item);
4133 case QQuickItem::ItemChildRemovedChange:
4134 q->itemChange(change, data);
4135 for (int ii = 0; ii < changeListeners.count(); ++ii) {
4136 const QQuickItemPrivate::ChangeListener &change = changeListeners.at(ii);
4137 if (change.types & QQuickItemPrivate::Children) {
4138 change.listener->itemChildRemoved(q, data.item);
4142 case QQuickItem::ItemSceneChange:
4143 q->itemChange(change, data);
4145 case QQuickItem::ItemVisibleHasChanged:
4146 q->itemChange(change, data);
4147 for (int ii = 0; ii < changeListeners.count(); ++ii) {
4148 const QQuickItemPrivate::ChangeListener &change = changeListeners.at(ii);
4149 if (change.types & QQuickItemPrivate::Visibility) {
4150 change.listener->itemVisibilityChanged(q);
4154 case QQuickItem::ItemParentHasChanged:
4155 q->itemChange(change, data);
4156 for (int ii = 0; ii < changeListeners.count(); ++ii) {
4157 const QQuickItemPrivate::ChangeListener &change = changeListeners.at(ii);
4158 if (change.types & QQuickItemPrivate::Parent) {
4159 change.listener->itemParentChanged(q, data.item);
4163 case QQuickItem::ItemOpacityHasChanged:
4164 q->itemChange(change, data);
4165 for (int ii = 0; ii < changeListeners.count(); ++ii) {
4166 const QQuickItemPrivate::ChangeListener &change = changeListeners.at(ii);
4167 if (change.types & QQuickItemPrivate::Opacity) {
4168 change.listener->itemOpacityChanged(q);
4172 case QQuickItem::ItemActiveFocusHasChanged:
4173 q->itemChange(change, data);
4175 case QQuickItem::ItemRotationHasChanged:
4176 q->itemChange(change, data);
4177 for (int ii = 0; ii < changeListeners.count(); ++ii) {
4178 const QQuickItemPrivate::ChangeListener &change = changeListeners.at(ii);
4179 if (change.types & QQuickItemPrivate::Rotation) {
4180 change.listener->itemRotationChanged(q);
4188 \property QQuickItem::smooth
4189 \brief whether the item is smoothly transformed.
4191 This property is provided purely for the purpose of optimization. Turning
4192 smooth transforms off is faster, but looks worse; turning smooth
4193 transformations on is slower, but looks better.
4195 By default smooth transformations are off.
4199 Returns true if the item should be drawn with antialiasing and
4200 smooth pixmap filtering, false otherwise.
4202 The default is false.
4206 bool QQuickItem::smooth() const
4208 Q_D(const QQuickItem);
4213 Sets whether the item should be drawn with antialiasing and
4214 smooth pixmap filtering to \a smooth.
4218 void QQuickItem::setSmooth(bool smooth)
4221 if (d->smooth == smooth)
4225 d->dirty(QQuickItemPrivate::Smooth);
4227 emit smoothChanged(smooth);
4230 QQuickItem::Flags QQuickItem::flags() const
4232 Q_D(const QQuickItem);
4233 return (QQuickItem::Flags)d->flags;
4236 void QQuickItem::setFlag(Flag flag, bool enabled)
4240 setFlags((Flags)(d->flags | (quint32)flag));
4242 setFlags((Flags)(d->flags & ~(quint32)flag));
4245 void QQuickItem::setFlags(Flags flags)
4249 if ((flags & ItemIsFocusScope) != (d->flags & ItemIsFocusScope)) {
4250 if (flags & ItemIsFocusScope && !d->childItems.isEmpty() && d->canvas) {
4251 qWarning("QQuickItem: Cannot set FocusScope once item has children and is in a canvas.");
4252 flags &= ~ItemIsFocusScope;
4253 } else if (d->flags & ItemIsFocusScope) {
4254 qWarning("QQuickItem: Cannot unset FocusScope flag.");
4255 flags |= ItemIsFocusScope;
4259 if ((flags & ItemClipsChildrenToShape ) != (d->flags & ItemClipsChildrenToShape))
4260 d->dirty(QQuickItemPrivate::Clip);
4265 qreal QQuickItem::x() const
4267 Q_D(const QQuickItem);
4271 qreal QQuickItem::y() const
4273 Q_D(const QQuickItem);
4277 QPointF QQuickItem::pos() const
4279 Q_D(const QQuickItem);
4280 return QPointF(d->x, d->y);
4283 void QQuickItem::setX(qreal v)
4292 d->dirty(QQuickItemPrivate::Position);
4294 geometryChanged(QRectF(x(), y(), width(), height()),
4295 QRectF(oldx, y(), width(), height()));
4298 void QQuickItem::setY(qreal v)
4307 d->dirty(QQuickItemPrivate::Position);
4309 geometryChanged(QRectF(x(), y(), width(), height()),
4310 QRectF(x(), oldy, width(), height()));
4313 void QQuickItem::setPos(const QPointF &pos)
4316 if (QPointF(d->x, d->y) == pos)
4325 d->dirty(QQuickItemPrivate::Position);
4327 geometryChanged(QRectF(x(), y(), width(), height()),
4328 QRectF(oldx, oldy, width(), height()));
4331 qreal QQuickItem::width() const
4333 Q_D(const QQuickItem);
4337 void QQuickItem::setWidth(qreal w)
4343 d->widthValid = true;
4347 qreal oldWidth = d->width;
4350 d->dirty(QQuickItemPrivate::Size);
4352 geometryChanged(QRectF(x(), y(), width(), height()),
4353 QRectF(x(), y(), oldWidth, height()));
4356 void QQuickItem::resetWidth()
4359 d->widthValid = false;
4360 setImplicitWidth(implicitWidth());
4363 void QQuickItemPrivate::implicitWidthChanged()
4366 emit q->implicitWidthChanged();
4369 qreal QQuickItemPrivate::getImplicitWidth() const
4371 return implicitWidth;
4374 Returns the width of the item that is implied by other properties that determine the content.
4376 qreal QQuickItem::implicitWidth() const
4378 Q_D(const QQuickItem);
4379 return d->getImplicitWidth();
4383 \qmlproperty real QtQuick2::Item::implicitWidth
4384 \qmlproperty real QtQuick2::Item::implicitHeight
4386 Defines the natural width or height of the Item if no \l width or \l height is specified.
4388 The default implicit size for most items is 0x0, however some elements have an inherent
4389 implicit size which cannot be overridden, e.g. Image, Text.
4391 Setting the implicit size is useful for defining components that have a preferred size
4392 based on their content, for example:
4399 property alias icon: image.source
4400 property alias label: text.text
4401 implicitWidth: text.implicitWidth + image.implicitWidth
4402 implicitHeight: Math.max(text.implicitHeight, image.implicitHeight)
4407 anchors.left: image.right; anchors.right: parent.right
4408 anchors.verticalCenter: parent.verticalCenter
4413 \bold Note: using implicitWidth of Text or TextEdit and setting the width explicitly
4414 incurs a performance penalty as the text must be laid out twice.
4418 Sets the implied width of the item to \a w.
4419 This is the width implied by other properties that determine the content.
4421 void QQuickItem::setImplicitWidth(qreal w)
4424 bool changed = w != d->implicitWidth;
4425 d->implicitWidth = w;
4426 if (d->width == w || widthValid()) {
4428 d->implicitWidthChanged();
4432 qreal oldWidth = d->width;
4435 d->dirty(QQuickItemPrivate::Size);
4437 geometryChanged(QRectF(x(), y(), width(), height()),
4438 QRectF(x(), y(), oldWidth, height()));
4441 d->implicitWidthChanged();
4445 Returns whether the width property has been set explicitly.
4447 bool QQuickItem::widthValid() const
4449 Q_D(const QQuickItem);
4450 return d->widthValid;
4453 qreal QQuickItem::height() const
4455 Q_D(const QQuickItem);
4459 void QQuickItem::setHeight(qreal h)
4465 d->heightValid = true;
4469 qreal oldHeight = d->height;
4472 d->dirty(QQuickItemPrivate::Size);
4474 geometryChanged(QRectF(x(), y(), width(), height()),
4475 QRectF(x(), y(), width(), oldHeight));
4478 void QQuickItem::resetHeight()
4481 d->heightValid = false;
4482 setImplicitHeight(implicitHeight());
4485 void QQuickItemPrivate::implicitHeightChanged()
4488 emit q->implicitHeightChanged();
4491 qreal QQuickItemPrivate::getImplicitHeight() const
4493 return implicitHeight;
4497 Returns the height of the item that is implied by other properties that determine the content.
4499 qreal QQuickItem::implicitHeight() const
4501 Q_D(const QQuickItem);
4502 return d->getImplicitHeight();
4507 Sets the implied height of the item to \a h.
4508 This is the height implied by other properties that determine the content.
4510 void QQuickItem::setImplicitHeight(qreal h)
4513 bool changed = h != d->implicitHeight;
4514 d->implicitHeight = h;
4515 if (d->height == h || heightValid()) {
4517 d->implicitHeightChanged();
4521 qreal oldHeight = d->height;
4524 d->dirty(QQuickItemPrivate::Size);
4526 geometryChanged(QRectF(x(), y(), width(), height()),
4527 QRectF(x(), y(), width(), oldHeight));
4530 d->implicitHeightChanged();
4533 void QQuickItem::setImplicitSize(qreal w, qreal h)
4536 bool wChanged = w != d->implicitWidth;
4537 bool hChanged = h != d->implicitHeight;
4539 d->implicitWidth = w;
4540 d->implicitHeight = h;
4544 if (d->width == w || widthValid()) {
4546 d->implicitWidthChanged();
4549 if (d->height == h || heightValid()) {
4551 d->implicitHeightChanged();
4557 qreal oldWidth = d->width;
4558 qreal oldHeight = d->height;
4564 d->dirty(QQuickItemPrivate::Size);
4566 geometryChanged(QRectF(x(), y(), width(), height()),
4567 QRectF(x(), y(), oldWidth, oldHeight));
4569 if (!wDone && wChanged)
4570 d->implicitWidthChanged();
4571 if (!hDone && hChanged)
4572 d->implicitHeightChanged();
4576 Returns whether the height property has been set explicitly.
4578 bool QQuickItem::heightValid() const
4580 Q_D(const QQuickItem);
4581 return d->heightValid;
4584 void QQuickItem::setSize(const QSizeF &size)
4587 d->heightValid = true;
4588 d->widthValid = true;
4590 if (QSizeF(d->width, d->height) == size)
4593 qreal oldHeight = d->height;
4594 qreal oldWidth = d->width;
4595 d->height = size.height();
4596 d->width = size.width();
4598 d->dirty(QQuickItemPrivate::Size);
4600 geometryChanged(QRectF(x(), y(), width(), height()),
4601 QRectF(x(), y(), oldWidth, oldHeight));
4604 bool QQuickItem::hasActiveFocus() const
4606 Q_D(const QQuickItem);
4607 return d->activeFocus;
4610 bool QQuickItem::hasFocus() const
4612 Q_D(const QQuickItem);
4616 void QQuickItem::setFocus(bool focus)
4619 if (d->focus == focus)
4623 // Need to find our nearest focus scope
4624 QQuickItem *scope = parentItem();
4625 while (scope && !scope->isFocusScope())
4626 scope = scope->parentItem();
4628 QQuickCanvasPrivate::get(d->canvas)->setFocusInScope(scope, this);
4630 QQuickCanvasPrivate::get(d->canvas)->clearFocusInScope(scope, this);
4633 emit focusChanged(focus);
4637 bool QQuickItem::isFocusScope() const
4639 return flags() & ItemIsFocusScope;
4642 QQuickItem *QQuickItem::scopedFocusItem() const
4644 Q_D(const QQuickItem);
4645 if (!isFocusScope())
4648 return d->subFocusItem;
4652 Qt::MouseButtons QQuickItem::acceptedMouseButtons() const
4654 Q_D(const QQuickItem);
4655 return d->acceptedMouseButtons;
4658 void QQuickItem::setAcceptedMouseButtons(Qt::MouseButtons buttons)
4661 d->acceptedMouseButtons = buttons;
4664 bool QQuickItem::filtersChildMouseEvents() const
4666 Q_D(const QQuickItem);
4667 return d->filtersChildMouseEvents;
4670 void QQuickItem::setFiltersChildMouseEvents(bool filter)
4673 d->filtersChildMouseEvents = filter;
4676 bool QQuickItem::isUnderMouse() const
4678 Q_D(const QQuickItem);
4682 QPoint cursorPos = QCursor::pos();
4683 if (QRectF(0, 0, width(), height()).contains(mapFromScene(cursorPos))) // ### refactor: d->canvas->mapFromGlobal(cursorPos))))
4688 bool QQuickItem::acceptHoverEvents() const
4690 Q_D(const QQuickItem);
4691 return d->hoverEnabled;
4694 void QQuickItem::setAcceptHoverEvents(bool enabled)
4697 d->hoverEnabled = enabled;
4700 void QQuickItem::grabMouse()
4705 QQuickCanvasPrivate *canvasPriv = QQuickCanvasPrivate::get(d->canvas);
4706 if (canvasPriv->mouseGrabberItem == this)
4709 QQuickItem *oldGrabber = canvasPriv->mouseGrabberItem;
4710 canvasPriv->mouseGrabberItem = this;
4712 oldGrabber->mouseUngrabEvent();
4715 void QQuickItem::ungrabMouse()
4720 QQuickCanvasPrivate *canvasPriv = QQuickCanvasPrivate::get(d->canvas);
4721 if (canvasPriv->mouseGrabberItem != this) {
4722 qWarning("QQuickItem::ungrabMouse(): Item is not the mouse grabber.");
4726 canvasPriv->mouseGrabberItem = 0;
4730 bool QQuickItem::keepMouseGrab() const
4732 Q_D(const QQuickItem);
4733 return d->keepMouse;
4737 The flag indicating whether the mouse should remain
4738 with this item is set to \a keep.
4740 This is useful for items that wish to grab and keep mouse
4741 interaction following a predefined gesture. For example,
4742 an item that is interested in horizontal mouse movement
4743 may set keepMouseGrab to true once a threshold has been
4744 exceeded. Once keepMouseGrab has been set to true, filtering
4745 items will not react to mouse events.
4747 If the item does not indicate that it wishes to retain mouse grab,
4748 a filtering item may steal the grab. For example, Flickable may attempt
4749 to steal a mouse grab if it detects that the user has begun to
4754 void QQuickItem::setKeepMouseGrab(bool keep)
4757 d->keepMouse = keep;
4761 Grabs the touch points specified by \a ids.
4763 These touch points will be owned by the item until
4764 they are released. Alternatively, the grab can be stolen
4765 by a filtering item like Flickable. Use setKeepTouchGrab()
4766 to prevent the grab from being stolen.
4768 \sa ungrabTouchPoints(), setKeepTouchGrab()
4770 void QQuickItem::grabTouchPoints(const QList<int> &ids)
4775 QQuickCanvasPrivate *canvasPriv = QQuickCanvasPrivate::get(d->canvas);
4777 QSet<QQuickItem*> ungrab;
4778 for (int i = 0; i < ids.count(); ++i) {
4779 QQuickItem *oldGrabber = canvasPriv->itemForTouchPointId.value(ids.at(i));
4780 if (oldGrabber == this)
4783 canvasPriv->itemForTouchPointId[ids.at(i)] = this;
4785 ungrab.insert(oldGrabber);
4787 foreach (QQuickItem *oldGrabber, ungrab)
4788 oldGrabber->touchUngrabEvent();
4792 Ungrabs the touch points owned by this item.
4794 \sa grabTouchPoints()
4796 void QQuickItem::ungrabTouchPoints()
4801 QQuickCanvasPrivate *canvasPriv = QQuickCanvasPrivate::get(d->canvas);
4803 QMutableHashIterator<int, QQuickItem*> i(canvasPriv->itemForTouchPointId);
4804 while (i.hasNext()) {
4806 if (i.value() == this)
4813 Returns a value indicating whether the touch points grabbed by this item
4814 should remain with this item exclusively.
4816 \sa setKeepTouchGrab(), keepMouseGrab()
4818 bool QQuickItem::keepTouchGrab() const
4820 Q_D(const QQuickItem);
4821 return d->keepTouch;
4825 The flag indicating whether the touch points grabbed
4826 by this item should remain with this item is set to \a keep.
4828 This is useful for items that wish to grab and keep specific touch
4829 points following a predefined gesture. For example,
4830 an item that is interested in horizontal touch point movement
4831 may set setKeepTouchGrab to true once a threshold has been
4832 exceeded. Once setKeepTouchGrab has been set to true, filtering
4833 items will not react to the relevant touch points.
4835 If the item does not indicate that it wishes to retain touch point grab,
4836 a filtering item may steal the grab. For example, Flickable may attempt
4837 to steal a touch point grab if it detects that the user has begun to
4840 \sa keepTouchGrab(), setKeepMouseGrab()
4842 void QQuickItem::setKeepTouchGrab(bool keep)
4845 d->keepTouch = keep;
4849 \qmlmethod object QtQuick2::Item::mapFromItem(Item item, real x, real y)
4851 Maps the point (\a x, \a y), which is in \a item's coordinate system, to
4852 this item's coordinate system, and returns an object with \c x and \c y
4853 properties matching the mapped coordinate.
4855 If \a item is a \c null value, this maps the point from the coordinate
4856 system of the root QML view.
4859 \qmlmethod object QtQuick2::Item::mapToItem(Item item, real x, real y)
4861 Maps the point (\a x, \a y), which is in this item's coordinate system, to
4862 \a item's coordinate system, and returns an object with \c x and \c y
4863 properties matching the mapped coordinate.
4865 If \a item is a \c null value, this maps \a x and \a y to the coordinate
4866 system of the root QML view.
4868 QPointF QQuickItem::mapToItem(const QQuickItem *item, const QPointF &point) const
4870 QPointF p = mapToScene(point);
4872 p = item->mapFromScene(p);
4876 QPointF QQuickItem::mapToScene(const QPointF &point) const
4878 Q_D(const QQuickItem);
4879 return d->itemToCanvasTransform().map(point);
4882 QRectF QQuickItem::mapRectToItem(const QQuickItem *item, const QRectF &rect) const
4884 Q_D(const QQuickItem);
4885 QTransform t = d->itemToCanvasTransform();
4887 t *= QQuickItemPrivate::get(item)->canvasToItemTransform();
4888 return t.mapRect(rect);
4891 QRectF QQuickItem::mapRectToScene(const QRectF &rect) const
4893 Q_D(const QQuickItem);
4894 return d->itemToCanvasTransform().mapRect(rect);
4897 QPointF QQuickItem::mapFromItem(const QQuickItem *item, const QPointF &point) const
4899 QPointF p = item?item->mapToScene(point):point;
4900 return mapFromScene(p);
4903 QPointF QQuickItem::mapFromScene(const QPointF &point) const
4905 Q_D(const QQuickItem);
4906 return d->canvasToItemTransform().map(point);
4909 QRectF QQuickItem::mapRectFromItem(const QQuickItem *item, const QRectF &rect) const
4911 Q_D(const QQuickItem);
4912 QTransform t = item?QQuickItemPrivate::get(item)->itemToCanvasTransform():QTransform();
4913 t *= d->canvasToItemTransform();
4914 return t.mapRect(rect);
4917 QRectF QQuickItem::mapRectFromScene(const QRectF &rect) const
4919 Q_D(const QQuickItem);
4920 return d->canvasToItemTransform().mapRect(rect);
4925 \qmlmethod QtQuick2::Item::forceActiveFocus()
4927 Forces active focus on the item.
4929 This method sets focus on the item and makes sure that all the focus scopes
4930 higher in the object hierarchy are also given the focus.
4934 Forces active focus on the item.
4936 This method sets focus on the item and makes sure that all the focus scopes
4937 higher in the object hierarchy are also given the focus.
4941 \qmlmethod QtQuick2::Item::childAt(real x, real y)
4943 Returns the visible child item at point (\a x, \a y), which is in this
4944 item's coordinate system, or \c null if there is no such item.
4948 Returns the visible child item at point (\a x, \a y), which is in this
4949 item's coordinate system, or 0 if there is no such item.
4953 \qmlproperty list<State> QtQuick2::Item::states
4954 This property holds a list of states defined by the item.
4970 \sa {qmlstate}{States}
4973 \qmlproperty list<Transition> QtQuick2::Item::transitions
4974 This property holds a list of transitions defined by the item.
4990 \sa {QML Animation and Transitions}{Transitions}
4993 \qmlproperty list<Filter> QtQuick2::Item::filter
4994 This property holds a list of graphical filters to be applied to the item.
4996 \l {Filter}{Filters} include things like \l {Blur}{blurring}
4997 the item, or giving it a \l Reflection. Some
4998 filters may not be available on all canvases; if a filter is not
4999 available on a certain canvas, it will simply not be applied for
5000 that canvas (but the QML will still be considered valid).
5018 \qmlproperty bool QtQuick2::Item::clip
5019 This property holds whether clipping is enabled. The default clip value is \c false.
5021 If clipping is enabled, an item will clip its own painting, as well
5022 as the painting of its children, to its bounding rectangle.
5024 Non-rectangular clipping regions are not supported for performance reasons.
5028 \property QQuickItem::clip
5029 This property holds whether clipping is enabled. The default clip value is \c false.
5031 If clipping is enabled, an item will clip its own painting, as well
5032 as the painting of its children, to its bounding rectangle. If you set
5033 clipping during an item's paint operation, remember to re-set it to
5034 prevent clipping the rest of your scene.
5036 Non-rectangular clipping regions are not supported for performance reasons.
5040 \qmlproperty string QtQuick2::Item::state
5042 This property holds the name of the current state of the item.
5044 This property is often used in scripts to change between states. For
5049 if (button.state == 'On')
5050 button.state = 'Off';
5052 button.state = 'On';
5056 If the item is in its base state (i.e. no explicit state has been
5057 set), \c state will be a blank string. Likewise, you can return an
5058 item to its base state by setting its current state to \c ''.
5060 \sa {qmlstates}{States}
5064 \qmlproperty list<Transform> QtQuick2::Item::transform
5065 This property holds the list of transformations to apply.
5067 For more information see \l Transform.
5071 \enum QQuickItem::TransformOrigin
5073 Controls the point about which simple transforms like scale apply.
5075 \value TopLeft The top-left corner of the item.
5076 \value Top The center point of the top of the item.
5077 \value TopRight The top-right corner of the item.
5078 \value Left The left most point of the vertical middle.
5079 \value Center The center of the item.
5080 \value Right The right most point of the vertical middle.
5081 \value BottomLeft The bottom-left corner of the item.
5082 \value Bottom The center point of the bottom of the item.
5083 \value BottomRight The bottom-right corner of the item.
5088 \qmlproperty bool QtQuick2::Item::activeFocus
5090 This property indicates whether the item has active focus.
5092 An item with active focus will receive keyboard input,
5093 or is a FocusScope ancestor of the item that will receive keyboard input.
5095 Usually, activeFocus is gained by setting focus on an item and its enclosing
5096 FocusScopes. In the following example \c input will have activeFocus.
5109 \sa focus, {qmlfocus}{Keyboard Focus}
5113 \qmlproperty bool QtQuick2::Item::focus
5114 This property indicates whether the item has focus within the enclosing focus scope. If true, this item
5115 will gain active focus when the enclosing focus scope gains active focus.
5116 In the following example, \c input will be given active focus when \c scope gains active focus.
5129 For the purposes of this property, the scene as a whole is assumed to act like a focus scope.
5130 On a practical level, that means the following QML will give active focus to \c input on startup.
5141 \sa activeFocus, {qmlfocus}{Keyboard Focus}
5146 \property QQuickItem::anchors
5151 \property QQuickItem::left
5156 \property QQuickItem::right
5161 \property QQuickItem::horizontalCenter
5166 \property QQuickItem::top
5171 \property QQuickItem::bottom
5176 \property QQuickItem::verticalCenter
5181 \property QQuickItem::focus
5186 \property QQuickItem::transform
5191 \property QQuickItem::transformOrigin
5196 \property QQuickItem::activeFocus
5201 \property QQuickItem::baseline
5206 \property QQuickItem::data
5211 \property QQuickItem::resources
5216 \property QQuickItem::state
5221 \property QQuickItem::states
5226 \property QQuickItem::transformOriginPoint
5231 \property QQuickItem::transitions
5235 bool QQuickItem::event(QEvent *ev)
5238 if (ev->type() == QEvent::PolishRequest) {
5240 d->polishScheduled = false;
5244 return QObject::event(ev);
5247 if (ev->type() == QEvent::InputMethodQuery) {
5248 QInputMethodQueryEvent *query = static_cast<QInputMethodQueryEvent *>(ev);
5249 Qt::InputMethodQueries queries = query->queries();
5250 for (uint i = 0; i < 32; ++i) {
5251 Qt::InputMethodQuery q = (Qt::InputMethodQuery)(int)(queries & (1<<i));
5253 QVariant v = inputMethodQuery(q);
5254 query->setValue(q, v);
5259 } else if (ev->type() == QEvent::InputMethod) {
5260 inputMethodEvent(static_cast<QInputMethodEvent *>(ev));
5263 return QObject::event(ev);
5266 #ifndef QT_NO_DEBUG_STREAM
5267 QDebug operator<<(QDebug debug, QQuickItem *item)
5270 debug << "QQuickItem(0)";
5274 debug << item->metaObject()->className() << "(this =" << ((void*)item)
5275 << ", name=" << item->objectName()
5276 << ", parent =" << ((void*)item->parentItem())
5277 << ", geometry =" << QRectF(item->pos(), QSizeF(item->width(), item->height()))
5278 << ", z =" << item->z() << ')';
5283 qint64 QQuickItemPrivate::consistentTime = -1;
5284 void QQuickItemPrivate::setConsistentTime(qint64 t)
5289 class QElapsedTimerConsistentTimeHack
5293 t1 = QQuickItemPrivate::consistentTime;
5297 return QQuickItemPrivate::consistentTime - t1;
5300 qint64 val = QQuickItemPrivate::consistentTime - t1;
5301 t1 = QQuickItemPrivate::consistentTime;
5311 void QQuickItemPrivate::start(QElapsedTimer &t)
5313 if (QQuickItemPrivate::consistentTime == -1)
5316 ((QElapsedTimerConsistentTimeHack*)&t)->start();
5319 qint64 QQuickItemPrivate::elapsed(QElapsedTimer &t)
5321 if (QQuickItemPrivate::consistentTime == -1)
5324 return ((QElapsedTimerConsistentTimeHack*)&t)->elapsed();
5327 qint64 QQuickItemPrivate::restart(QElapsedTimer &t)
5329 if (QQuickItemPrivate::consistentTime == -1)
5332 return ((QElapsedTimerConsistentTimeHack*)&t)->restart();
5336 \fn bool QQuickItem::isTextureProvider() const
5338 Returns true if this item is a texture provider. The default
5339 implementation returns false.
5341 This function can be called from any thread.
5344 bool QQuickItem::isTextureProvider() const
5346 Q_D(const QQuickItem);
5347 return d->_layer && d->_layer->effectSource() ? d->_layer->effectSource()->isTextureProvider() : false;
5351 \fn QSGTextureProvider *QQuickItem::textureProvider() const
5353 Returns the texture provider for an item. The default implementation
5356 This function may only be called on the rendering thread.
5359 QSGTextureProvider *QQuickItem::textureProvider() const
5361 Q_D(const QQuickItem);
5362 return d->_layer && d->_layer->effectSource() ? d->_layer->effectSource()->textureProvider() : 0;
5367 QQuickItemLayer *QQuickItemPrivate::layer() const
5370 _layer = new QQuickItemLayer(const_cast<QQuickItem *>(q_func()));
5376 QQuickItemLayer::QQuickItemLayer(QQuickItem *item)
5381 , m_componentComplete(true)
5382 , m_wrapMode(QQuickShaderEffectSource::ClampToEdge)
5383 , m_format(QQuickShaderEffectSource::RGBA)
5384 , m_effectComponent(0)
5388 m_name = QLatin1String("source");
5391 QQuickItemLayer::~QQuickItemLayer()
5393 delete m_effectSource;
5400 \qmlproperty bool QtQuick2::Item::layer.enabled
5402 Holds wether the item is layered or not. Layering is disabled by default.
5404 A layered item is rendered into an offscreen surface and cached until
5405 it is changed. Enabling layering for complex QML item hierarchies can
5406 some times be an optimization.
5408 None of the other layer properties have any effect when the layer
5412 void QQuickItemLayer::setEnabled(bool e)
5417 if (m_componentComplete) {
5424 emit enabledChanged(e);
5427 void QQuickItemLayer::classBegin()
5429 m_componentComplete = false;
5432 void QQuickItemLayer::componentComplete()
5434 m_componentComplete = true;
5439 void QQuickItemLayer::activate()
5441 QQuickItem *parentItem = m_item->parentItem();
5442 if (!m_effectSource)
5443 m_effectSource = new QQuickShaderEffectSource();
5446 m_effectSource->setParentItem(parentItem);
5447 m_effectSource->stackAfter(m_item);
5450 m_effectSource->setVisible(!m_effectComponent && m_item->isVisible());
5451 m_effectSource->setSourceItem(m_item);
5452 m_effectSource->setHideSource(true);
5453 m_effectSource->setSmooth(m_smooth);
5454 m_effectSource->setTextureSize(m_size);
5455 m_effectSource->setSourceRect(m_sourceRect);
5456 m_effectSource->setMipmap(m_mipmap);
5457 m_effectSource->setWrapMode(m_wrapMode);
5458 m_effectSource->setFormat(m_format);
5460 if (m_effectComponent) {
5462 QObject *created = m_effectComponent->create();
5463 m_effect = qobject_cast<QQuickShaderEffect *>(created);
5465 qWarning("Item: layer.effect is not a shader effect");
5471 m_effect->setParentItem(parentItem);
5472 m_effect->stackAfter(m_effectSource);
5474 m_effect->setVisible(m_item->isVisible());
5475 m_effect->setProperty(m_name.toLatin1(), qVariantFromValue<QObject *>(m_effectSource));
5485 QQuickItemPrivate *id = QQuickItemPrivate::get(m_item);
5486 id->addItemChangeListener(this, QQuickItemPrivate::Geometry | QQuickItemPrivate::Opacity | QQuickItemPrivate::Parent | QQuickItemPrivate::Visibility | QQuickItemPrivate::SiblingOrder);
5489 void QQuickItemLayer::deactivate()
5491 delete m_effectSource;
5497 QQuickItemPrivate *id = QQuickItemPrivate::get(m_item);
5498 id->removeItemChangeListener(this, QQuickItemPrivate::Geometry | QQuickItemPrivate::Opacity | QQuickItemPrivate::Parent | QQuickItemPrivate::Visibility | QQuickItemPrivate::SiblingOrder);
5504 \qmlproperty Component QtQuick2::Item::layer.effect
5506 Holds the effect that is applied to this layer.
5508 The effect must be a \l ShaderEffect.
5511 void QQuickItemLayer::setEffect(QDeclarativeComponent *component)
5513 if (component == m_effectComponent)
5515 m_effectComponent = component;
5525 emit effectChanged(component);
5530 \qmlproperty bool QtQuick2::Item::layer.mipmap
5532 If this property is true, mipmaps are generated for the texture.
5534 \note Some OpenGL ES 2 implementations do not support mipmapping of
5535 non-power-of-two textures.
5538 void QQuickItemLayer::setMipmap(bool mipmap)
5540 if (mipmap == m_mipmap)
5545 m_effectSource->setMipmap(m_mipmap);
5547 emit mipmapChanged(mipmap);
5552 \qmlproperty enumeration QtQuick2::Item::layer.format
5554 This property defines the internal OpenGL format of the texture.
5555 Modifying this property makes most sense when the \a layer.effect is also
5556 specified. Depending on the OpenGL implementation, this property might
5557 allow you to save some texture memory.
5560 \o ShaderEffectSource.Alpha - GL_ALPHA
5561 \o ShaderEffectSource.RGB - GL_RGB
5562 \o ShaderEffectSource.RGBA - GL_RGBA
5565 \note Some OpenGL implementations do not support the GL_ALPHA format.
5568 void QQuickItemLayer::setFormat(QQuickShaderEffectSource::Format f)
5575 m_effectSource->setFormat(m_format);
5577 emit formatChanged(m_format);
5582 \qmlproperty enumeration QtQuick2::Item::layer.sourceRect
5584 This property defines which rectangular area of the \l sourceItem to
5585 render into the texture. The source rectangle can be larger than
5586 \l sourceItem itself. If the rectangle is null, which is the default,
5587 the whole \l sourceItem is rendered to texture.
5590 void QQuickItemLayer::setSourceRect(const QRectF &sourceRect)
5592 if (sourceRect == m_sourceRect)
5594 m_sourceRect = sourceRect;
5597 m_effectSource->setSourceRect(m_sourceRect);
5599 emit sourceRectChanged(sourceRect);
5605 \qmlproperty bool QtQuick2::Item::layer.smooth
5607 Holds whether the layer is smoothly transformed.
5610 void QQuickItemLayer::setSmooth(bool s)
5617 m_effectSource->setSmooth(m_smooth);
5619 emit smoothChanged(s);
5625 \qmlproperty size QtQuick2::Item::layer.textureSize
5627 This property holds the requested pixel size of the layers texture. If it is empty,
5628 which is the default, the size of the item is used.
5630 \note Some platforms have a limit on how small framebuffer objects can be,
5631 which means the actual texture size might be larger than the requested
5635 void QQuickItemLayer::setSize(const QSize &size)
5642 m_effectSource->setTextureSize(size);
5644 emit sizeChanged(size);
5650 \qmlproperty enumeration QtQuick2::Item::layer.wrapMode
5652 This property defines the OpenGL wrap modes associated with the texture.
5653 Modifying this property makes most sense when the \a layer.effect is
5657 \o ShaderEffectSource.ClampToEdge - GL_CLAMP_TO_EDGE both horizontally and vertically
5658 \o ShaderEffectSource.RepeatHorizontally - GL_REPEAT horizontally, GL_CLAMP_TO_EDGE vertically
5659 \o ShaderEffectSource.RepeatVertically - GL_CLAMP_TO_EDGE horizontally, GL_REPEAT vertically
5660 \o ShaderEffectSource.Repeat - GL_REPEAT both horizontally and vertically
5663 \note Some OpenGL ES 2 implementations do not support the GL_REPEAT
5664 wrap mode with non-power-of-two textures.
5667 void QQuickItemLayer::setWrapMode(QQuickShaderEffectSource::WrapMode mode)
5669 if (mode != m_wrapMode)
5674 m_effectSource->setWrapMode(m_wrapMode);
5676 emit wrapModeChanged(mode);
5680 void QQuickItemLayer::itemOpacityChanged(QQuickItem *item)
5686 void QQuickItemLayer::itemGeometryChanged(QQuickItem *, const QRectF &, const QRectF &)
5691 void QQuickItemLayer::itemParentChanged(QQuickItem *item, QQuickItem *parent)
5694 if (parent == m_effectSource || parent == m_effect)
5697 m_effectSource->setParentItem(parent);
5699 m_effectSource->stackAfter(m_item);
5702 m_effect->setParentItem(parent);
5704 m_effect->stackAfter(m_effectSource);
5708 void QQuickItemLayer::itemSiblingOrderChanged(QQuickItem *)
5710 m_effectSource->stackAfter(m_item);
5712 m_effect->stackAfter(m_effectSource);
5715 void QQuickItemLayer::itemVisibilityChanged(QQuickItem *)
5717 QQuickItem *l = m_effect ? (QQuickItem *) m_effect : (QQuickItem *) m_effectSource;
5718 l->setVisible(m_item->isVisible());
5721 void QQuickItemLayer::updateZ()
5723 QQuickItem *l = m_effect ? (QQuickItem *) m_effect : (QQuickItem *) m_effectSource;
5724 l->setZ(m_item->z());
5727 void QQuickItemLayer::updateOpacity()
5729 QQuickItem *l = m_effect ? (QQuickItem *) m_effect : (QQuickItem *) m_effectSource;
5730 l->setOpacity(m_item->opacity());
5733 void QQuickItemLayer::updateGeometry()
5735 QQuickItem *l = m_effect ? (QQuickItem *) m_effect : (QQuickItem *) m_effectSource;
5736 QRectF bounds = m_item->boundingRect();
5737 l->setWidth(bounds.width());
5738 l->setHeight(bounds.height());
5739 l->setX(bounds.x() + m_item->x());
5740 l->setY(bounds.y() + m_item->y());
5743 void QQuickItemLayer::updateMatrix()
5745 // Called directly from transformChanged(), so needs some extra
5747 if (!m_componentComplete || !m_enabled)
5749 QQuickItem *l = m_effect ? (QQuickItem *) m_effect : (QQuickItem *) m_effectSource;
5750 QQuickItemPrivate *ld = QQuickItemPrivate::get(l);
5751 l->setScale(m_item->scale());
5752 l->setRotation(m_item->rotation());
5753 ld->transforms = QQuickItemPrivate::get(m_item)->transforms;
5754 ld->origin = QQuickItemPrivate::get(m_item)->origin;
5755 ld->dirty(QQuickItemPrivate::Transform);
5760 #include <moc_qquickitem.cpp>