1 /****************************************************************************
3 ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4 ** All rights reserved.
5 ** Contact: Nokia Corporation (qt-info@nokia.com)
7 ** This file is part of the QtDeclarative module of the Qt Toolkit.
9 ** $QT_BEGIN_LICENSE:LGPL$
10 ** GNU Lesser General Public License Usage
11 ** This file may be used under the terms of the GNU Lesser General Public
12 ** License version 2.1 as published by the Free Software Foundation and
13 ** appearing in the file LICENSE.LGPL included in the packaging of this
14 ** file. Please review the following information to ensure the GNU Lesser
15 ** General Public License version 2.1 requirements will be met:
16 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
18 ** In addition, as a special exception, Nokia gives you certain additional
19 ** rights. These rights are described in the Nokia Qt LGPL Exception
20 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
22 ** GNU General Public License Usage
23 ** Alternatively, this file may be used under the terms of the GNU General
24 ** Public License version 3.0 as published by the Free Software Foundation
25 ** and appearing in the file LICENSE.GPL included in the packaging of this
26 ** file. Please review the following information to ensure the GNU General
27 ** Public License version 3.0 requirements will be met:
28 ** http://www.gnu.org/copyleft/gpl.html.
31 ** Alternatively, this file may be used in accordance with the terms and
32 ** 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
1643 \inqmlmodule QtQuick 2
1644 \ingroup qml-basic-visual-elements
1645 \brief The Item is the most basic of all visual items in QML.
1647 All visual items in Qt Declarative inherit from Item. Although Item
1648 has no visual appearance, it defines all the properties that are
1649 common across visual items - such as the x and y position, the
1650 width and height, \l {anchor-layout}{anchoring} and key handling.
1652 Item is also useful for grouping items together.
1669 fillMode: Image.Tile
1676 \section1 Key Handling
1678 Key handling is available to all Item-based visual elements via the \l {Keys}{Keys}
1679 attached property. The \e Keys attached property provides basic handlers such
1680 as \l {Keys::onPressed}{onPressed} and \l {Keys::onReleased}{onReleased},
1681 as well as handlers for specific keys, such as
1682 \l {Keys::onCancelPressed}{onCancelPressed}. The example below
1683 assigns \l {qmlfocus}{focus} to the item and handles
1684 the Left key via the general \e onPressed handler and the Select key via the
1685 onSelectPressed handler:
1691 if (event.key == Qt.Key_Left) {
1692 console.log("move left");
1693 event.accepted = true;
1696 Keys.onSelectPressed: console.log("Selected");
1700 See the \l {Keys}{Keys} attached property for detailed documentation.
1702 \section1 Layout Mirroring
1704 Item layouts can be mirrored using the \l {LayoutMirroring}{LayoutMirroring} attached property.
1709 \fn void QQuickItem::childrenRectChanged(const QRectF &)
1714 \fn void QQuickItem::baselineOffsetChanged(qreal)
1719 \fn void QQuickItem::stateChanged(const QString &state)
1724 \fn void QQuickItem::parentChanged(QQuickItem *)
1729 \fn void QQuickItem::smoothChanged(bool)
1734 \fn void QQuickItem::clipChanged(bool)
1738 /*! \fn void QQuickItem::transformOriginChanged(TransformOrigin)
1743 \fn void QQuickItem::focusChanged(bool)
1748 \fn void QQuickItem::activeFocusChanged(bool)
1752 \fn QQuickItem::QQuickItem(QQuickItem *parent)
1754 Constructs a QQuickItem with the given \a parent.
1756 QQuickItem::QQuickItem(QQuickItem* parent)
1757 : QObject(*(new QQuickItemPrivate), parent)
1765 QQuickItem::QQuickItem(QQuickItemPrivate &dd, QQuickItem *parent)
1766 : QObject(dd, parent)
1773 static int qt_item_count = 0;
1775 static void qt_print_item_count()
1777 qDebug("Number of leaked items: %i", qt_item_count);
1783 Destroys the QQuickItem.
1785 QQuickItem::~QQuickItem()
1789 if (qt_item_count < 0)
1790 qDebug("Item destroyed after qt_print_item_count() was called.");
1797 else if (d->canvas && d->itemNodeInstance)
1798 QQuickCanvasPrivate::get(d->canvas)->cleanup(d->itemNodeInstance); // cleanup root
1799 // XXX todo - optimize
1800 while (!d->childItems.isEmpty())
1801 d->childItems.first()->setParentItem(0);
1803 for (int ii = 0; ii < d->changeListeners.count(); ++ii) {
1804 QQuickAnchorsPrivate *anchor = d->changeListeners.at(ii).listener->anchorPrivate();
1806 anchor->clearItem(this);
1810 update item anchors that depended on us unless they are our child (and will also be destroyed),
1811 or our sibling, and our parent is also being destroyed.
1813 for (int ii = 0; ii < d->changeListeners.count(); ++ii) {
1814 QQuickAnchorsPrivate *anchor = d->changeListeners.at(ii).listener->anchorPrivate();
1815 if (anchor && anchor->item && anchor->item->parentItem() && anchor->item->parentItem() != this)
1819 for (int ii = 0; ii < d->changeListeners.count(); ++ii) {
1820 const QQuickItemPrivate::ChangeListener &change = d->changeListeners.at(ii);
1821 if (change.types & QQuickItemPrivate::Destroyed)
1822 change.listener->itemDestroyed(this);
1825 d->changeListeners.clear();
1826 delete d->_anchorLines; d->_anchorLines = 0;
1827 delete d->_anchors; d->_anchors = 0;
1828 delete d->_stateGroup; d->_stateGroup = 0;
1829 delete d->_contents; d->_contents = 0;
1834 \qmlproperty enumeration QtQuick2::Item::transformOrigin
1835 This property holds the origin point around which scale and rotation transform.
1837 Nine transform origins are available, as shown in the image below.
1839 \image declarative-transformorigin.png
1841 This example rotates an image around its bottom-right corner.
1844 source: "myimage.png"
1845 transformOrigin: Item.BottomRight
1850 The default transform origin is \c Item.Center.
1852 To set an arbitrary transform origin point use the \l Scale or \l Rotation
1857 \qmlproperty Item QtQuick2::Item::parent
1858 This property holds the parent of the item.
1862 \property QQuickItem::parent
1863 This property holds the parent of the item.
1865 void QQuickItem::setParentItem(QQuickItem *parentItem)
1868 if (parentItem == d->parentItem)
1871 d->removeFromDirtyList();
1873 QQuickItem *oldParentItem = d->parentItem;
1874 QQuickItem *scopeFocusedItem = 0;
1876 if (oldParentItem) {
1877 QQuickItemPrivate *op = QQuickItemPrivate::get(oldParentItem);
1879 QQuickItem *scopeItem = 0;
1881 if (d->canvas && hasFocus()) {
1882 scopeItem = oldParentItem;
1883 while (!scopeItem->isFocusScope()) scopeItem = scopeItem->parentItem();
1884 scopeFocusedItem = this;
1885 } else if (d->canvas && !isFocusScope() && d->subFocusItem) {
1886 scopeItem = oldParentItem;
1887 while (!scopeItem->isFocusScope()) scopeItem = scopeItem->parentItem();
1888 scopeFocusedItem = d->subFocusItem;
1891 if (scopeFocusedItem)
1892 QQuickCanvasPrivate::get(d->canvas)->clearFocusInScope(scopeItem, scopeFocusedItem,
1893 QQuickCanvasPrivate::DontChangeFocusProperty);
1895 op->removeChild(this);
1896 } else if (d->canvas) {
1897 QQuickCanvasPrivate::get(d->canvas)->parentlessItems.remove(this);
1900 d->parentItem = parentItem;
1902 QQuickCanvas *parentCanvas = parentItem?QQuickItemPrivate::get(parentItem)->canvas:0;
1903 if (d->canvas != parentCanvas) {
1904 QQuickItemPrivate::InitializationState initState;
1906 d->initCanvas(&initState, parentCanvas);
1909 d->dirty(QQuickItemPrivate::ParentChanged);
1912 QQuickItemPrivate::get(d->parentItem)->addChild(this);
1914 d->setEffectiveVisibleRecur(d->calcEffectiveVisible());
1915 d->setEffectiveEnableRecur(d->calcEffectiveEnable());
1917 if (scopeFocusedItem && d->parentItem && d->canvas) {
1918 // We need to test whether this item becomes scope focused
1919 QQuickItem *scopeItem = 0;
1920 scopeItem = d->parentItem;
1921 while (!scopeItem->isFocusScope()) scopeItem = scopeItem->parentItem();
1923 if (scopeItem->scopedFocusItem()) {
1924 QQuickItemPrivate::get(scopeFocusedItem)->focus = false;
1925 emit scopeFocusedItem->focusChanged(false);
1927 QQuickCanvasPrivate::get(d->canvas)->setFocusInScope(scopeItem, scopeFocusedItem,
1928 QQuickCanvasPrivate::DontChangeFocusProperty);
1932 d->resolveLayoutMirror();
1934 d->itemChange(ItemParentHasChanged, d->parentItem);
1936 d->parentNotifier.notify();
1937 if (d->isAccessible && d->parentItem) {
1938 d->parentItem->d_func()->setAccessibleFlagAndListener();
1941 emit parentChanged(d->parentItem);
1944 void QQuickItem::stackBefore(const QQuickItem *sibling)
1947 if (!sibling || sibling == this || !d->parentItem || d->parentItem != QQuickItemPrivate::get(sibling)->parentItem) {
1948 qWarning("QQuickItem::stackBefore: Cannot stack before %p, which must be a sibling", sibling);
1952 QQuickItemPrivate *parentPrivate = QQuickItemPrivate::get(d->parentItem);
1954 int myIndex = parentPrivate->childItems.indexOf(this);
1955 int siblingIndex = parentPrivate->childItems.indexOf(const_cast<QQuickItem *>(sibling));
1957 Q_ASSERT(myIndex != -1 && siblingIndex != -1);
1959 if (myIndex == siblingIndex - 1)
1962 parentPrivate->childItems.removeAt(myIndex);
1964 if (myIndex < siblingIndex) --siblingIndex;
1966 parentPrivate->childItems.insert(siblingIndex, this);
1968 parentPrivate->dirty(QQuickItemPrivate::ChildrenStackingChanged);
1969 parentPrivate->markSortedChildrenDirty(this);
1971 for (int ii = qMin(siblingIndex, myIndex); ii < parentPrivate->childItems.count(); ++ii)
1972 QQuickItemPrivate::get(parentPrivate->childItems.at(ii))->siblingOrderChanged();
1975 void QQuickItem::stackAfter(const QQuickItem *sibling)
1978 if (!sibling || sibling == this || !d->parentItem || d->parentItem != QQuickItemPrivate::get(sibling)->parentItem) {
1979 qWarning("QQuickItem::stackAfter: Cannot stack after %p, which must be a sibling", sibling);
1983 QQuickItemPrivate *parentPrivate = QQuickItemPrivate::get(d->parentItem);
1985 int myIndex = parentPrivate->childItems.indexOf(this);
1986 int siblingIndex = parentPrivate->childItems.indexOf(const_cast<QQuickItem *>(sibling));
1988 Q_ASSERT(myIndex != -1 && siblingIndex != -1);
1990 if (myIndex == siblingIndex + 1)
1993 parentPrivate->childItems.removeAt(myIndex);
1995 if (myIndex < siblingIndex) --siblingIndex;
1997 parentPrivate->childItems.insert(siblingIndex + 1, this);
1999 parentPrivate->dirty(QQuickItemPrivate::ChildrenStackingChanged);
2000 parentPrivate->markSortedChildrenDirty(this);
2002 for (int ii = qMin(myIndex, siblingIndex + 1); ii < parentPrivate->childItems.count(); ++ii)
2003 QQuickItemPrivate::get(parentPrivate->childItems.at(ii))->siblingOrderChanged();
2007 Returns the QQuickItem parent of this item.
2009 QQuickItem *QQuickItem::parentItem() const
2011 Q_D(const QQuickItem);
2012 return d->parentItem;
2015 QSGEngine *QQuickItem::sceneGraphEngine() const
2017 return canvas()->sceneGraphEngine();
2020 QQuickCanvas *QQuickItem::canvas() const
2022 Q_D(const QQuickItem);
2026 static bool itemZOrder_sort(QQuickItem *lhs, QQuickItem *rhs)
2028 return lhs->z() < rhs->z();
2031 QList<QQuickItem *> QQuickItemPrivate::paintOrderChildItems() const
2033 if (sortedChildItems)
2034 return *sortedChildItems;
2036 // If none of the items have set Z then the paint order list is the same as
2037 // the childItems list. This is by far the most common case.
2039 for (int i = 0; i < childItems.count(); ++i) {
2040 if (QQuickItemPrivate::get(childItems.at(i))->z != 0.) {
2046 sortedChildItems = new QList<QQuickItem*>(childItems);
2047 qStableSort(sortedChildItems->begin(), sortedChildItems->end(), itemZOrder_sort);
2048 return *sortedChildItems;
2051 sortedChildItems = const_cast<QList<QQuickItem*>*>(&childItems);
2056 void QQuickItemPrivate::addChild(QQuickItem *child)
2060 Q_ASSERT(!childItems.contains(child));
2062 childItems.append(child);
2064 markSortedChildrenDirty(child);
2065 dirty(QQuickItemPrivate::ChildrenChanged);
2067 itemChange(QQuickItem::ItemChildAddedChange, child);
2069 emit q->childrenChanged();
2072 void QQuickItemPrivate::removeChild(QQuickItem *child)
2077 Q_ASSERT(childItems.contains(child));
2078 childItems.removeOne(child);
2079 Q_ASSERT(!childItems.contains(child));
2081 markSortedChildrenDirty(child);
2082 dirty(QQuickItemPrivate::ChildrenChanged);
2084 itemChange(QQuickItem::ItemChildRemovedChange, child);
2086 emit q->childrenChanged();
2089 void QQuickItemPrivate::InitializationState::clear()
2094 void QQuickItemPrivate::InitializationState::clear(QQuickItem *fs)
2099 QQuickItem *QQuickItemPrivate::InitializationState::getFocusScope(QQuickItem *item)
2102 QQuickItem *fs = item->parentItem();
2103 while (!fs->isFocusScope())
2104 fs = fs->parentItem();
2110 void QQuickItemPrivate::initCanvas(InitializationState *state, QQuickCanvas *c)
2115 removeFromDirtyList();
2116 QQuickCanvasPrivate *c = QQuickCanvasPrivate::get(canvas);
2117 if (polishScheduled)
2118 c->itemsToPolish.remove(q);
2119 if (c->mouseGrabberItem == q)
2120 c->mouseGrabberItem = 0;
2122 c->hoverItems.removeAll(q);
2123 if (itemNodeInstance)
2124 c->cleanup(itemNodeInstance);
2126 c->parentlessItems.remove(q);
2131 if (canvas && polishScheduled)
2132 QQuickCanvasPrivate::get(canvas)->itemsToPolish.insert(q);
2134 itemNodeInstance = 0;
2140 beforePaintNode = 0;
2142 InitializationState _dummy;
2143 InitializationState *childState = state;
2145 if (c && q->isFocusScope()) {
2147 childState = &_dummy;
2150 if (!parentItem && canvas)
2151 QQuickCanvasPrivate::get(canvas)->parentlessItems.insert(q);
2153 for (int ii = 0; ii < childItems.count(); ++ii) {
2154 QQuickItem *child = childItems.at(ii);
2155 QQuickItemPrivate::get(child)->initCanvas(childState, c);
2160 if (state->getFocusScope(q)->scopedFocusItem()) {
2162 emit q->focusChanged(false);
2164 QQuickCanvasPrivate::get(canvas)->setFocusInScope(state->getFocusScope(q), q);
2171 screenAttached->canvasChanged(c);
2172 itemChange(QQuickItem::ItemSceneChange, c);
2176 Returns a transform that maps points from canvas space into item space.
2178 QTransform QQuickItemPrivate::canvasToItemTransform() const
2180 // XXX todo - optimize
2181 return itemToCanvasTransform().inverted();
2185 Returns a transform that maps points from item space into canvas space.
2187 QTransform QQuickItemPrivate::itemToCanvasTransform() const
2190 QTransform rv = parentItem?QQuickItemPrivate::get(parentItem)->itemToCanvasTransform():QTransform();
2191 itemToParentTransform(rv);
2196 Motifies \a t with this items local transform relative to its parent.
2198 void QQuickItemPrivate::itemToParentTransform(QTransform &t) const
2203 if (!transforms.isEmpty()) {
2205 for (int ii = transforms.count() - 1; ii >= 0; --ii)
2206 transforms.at(ii)->applyTo(&m);
2207 t = m.toTransform();
2210 if (scale != 1. || rotation != 0.) {
2211 QPointF tp = computeTransformOrigin();
2212 t.translate(tp.x(), tp.y());
2213 t.scale(scale, scale);
2215 t.translate(-tp.x(), -tp.y());
2221 \qmlproperty real QtQuick2::Item::childrenRect.x
2222 \qmlproperty real QtQuick2::Item::childrenRect.y
2223 \qmlproperty real QtQuick2::Item::childrenRect.width
2224 \qmlproperty real QtQuick2::Item::childrenRect.height
2226 The childrenRect properties allow an item access to the geometry of its
2227 children. This property is useful if you have an item that needs to be
2228 sized to fit its children.
2233 \qmlproperty list<Item> QtQuick2::Item::children
2234 \qmlproperty list<Object> QtQuick2::Item::resources
2236 The children property contains the list of visual children of this item.
2237 The resources property contains non-visual resources that you want to
2240 Generally you can rely on Item's default property to handle all this for
2241 you, but it can come in handy in some cases.
2260 Returns true if construction of the QML component is complete; otherwise
2263 It is often desirable to delay some processing until the component is
2266 \sa componentComplete()
2268 bool QQuickItem::isComponentComplete() const
2270 Q_D(const QQuickItem);
2271 return d->componentComplete;
2274 QQuickItemPrivate::QQuickItemPrivate()
2275 : _anchors(0), _contents(0), baselineOffset(0), _anchorLines(0), _stateGroup(0), origin(QQuickItem::Center),
2277 flags(0), widthValid(false), heightValid(false), componentComplete(true),
2278 keepMouse(false), keepTouch(false), hoverEnabled(false), smooth(false), focus(false), activeFocus(false), notifiedFocus(false),
2279 notifiedActiveFocus(false), filtersChildMouseEvents(false), explicitVisible(true),
2280 effectiveVisible(true), explicitEnable(true), effectiveEnable(true), polishScheduled(false),
2281 inheritedLayoutMirror(false), effectiveLayoutMirror(false), isMirrorImplicit(true),
2282 inheritMirrorFromParent(false), inheritMirrorFromItem(false), childrenDoNotOverlap(false),
2283 staticSubtreeGeometry(false),
2284 isAccessible(false),
2286 canvas(0), parentItem(0), sortedChildItems(&childItems),
2290 x(0), y(0), width(0), height(0), implicitWidth(0), implicitHeight(0),
2291 z(0), scale(1), rotation(0), opacity(1),
2293 attachedLayoutDirection(0), acceptedMouseButtons(0),
2294 imHints(Qt::ImhNone),
2298 dirtyAttributes(0), nextDirtyItem(0), prevDirtyItem(0),
2300 itemNodeInstance(0), opacityNode(0), clipNode(0), rootNode(0), groupNode(0), paintNode(0)
2301 , beforePaintNode(0), effectRefCount(0), hideRefCount(0)
2302 , screenAttached(0), _layer(0)
2306 QQuickItemPrivate::~QQuickItemPrivate()
2308 if (sortedChildItems != &childItems)
2309 delete sortedChildItems;
2312 void QQuickItemPrivate::init(QQuickItem *parent)
2316 static bool atexit_registered = false;
2317 if (!atexit_registered) {
2318 atexit(qt_print_item_count);
2319 atexit_registered = true;
2325 registerAccessorProperties();
2327 baselineOffset.invalidate();
2330 q->setParentItem(parent);
2331 QQuickItemPrivate *parentPrivate = QQuickItemPrivate::get(parent);
2332 setImplicitLayoutMirror(parentPrivate->inheritedLayoutMirror, parentPrivate->inheritMirrorFromParent);
2336 void QQuickItemPrivate::data_append(QDeclarativeListProperty<QObject> *prop, QObject *o)
2341 QQuickItem *that = static_cast<QQuickItem *>(prop->object);
2343 // This test is measurably (albeit only slightly) faster than qobject_cast<>()
2344 const QMetaObject *mo = o->metaObject();
2345 while (mo && mo != &QQuickItem::staticMetaObject) {
2346 mo = mo->d.superdata;
2350 QQuickItem *item = static_cast<QQuickItem *>(o);
2351 item->setParentItem(that);
2353 if (o->inherits("QGraphicsItem"))
2354 qWarning("Cannot add a QtQuick 1.0 item (%s) into a QtQuick 2.0 scene!", o->metaObject()->className());
2356 // XXX todo - do we really want this behavior?
2362 \qmlproperty list<Object> QtQuick2::Item::data
2365 The data property allows you to freely mix visual children and resources
2366 in an item. If you assign a visual item to the data list it becomes
2367 a child and if you assign any other object type, it is added as a resource.
2391 data is a behind-the-scenes property: you should never need to explicitly
2395 int QQuickItemPrivate::data_count(QDeclarativeListProperty<QObject> *prop)
2402 QObject *QQuickItemPrivate::data_at(QDeclarativeListProperty<QObject> *prop, int i)
2410 void QQuickItemPrivate::data_clear(QDeclarativeListProperty<QObject> *prop)
2416 QObject *QQuickItemPrivate::resources_at(QDeclarativeListProperty<QObject> *prop, int index)
2418 const QObjectList children = prop->object->children();
2419 if (index < children.count())
2420 return children.at(index);
2425 void QQuickItemPrivate::resources_append(QDeclarativeListProperty<QObject> *prop, QObject *o)
2427 // XXX todo - do we really want this behavior?
2428 o->setParent(prop->object);
2431 int QQuickItemPrivate::resources_count(QDeclarativeListProperty<QObject> *prop)
2433 return prop->object->children().count();
2436 void QQuickItemPrivate::resources_clear(QDeclarativeListProperty<QObject> *prop)
2438 // XXX todo - do we really want this behavior?
2439 const QObjectList children = prop->object->children();
2440 for (int index = 0; index < children.count(); index++)
2441 children.at(index)->setParent(0);
2444 QQuickItem *QQuickItemPrivate::children_at(QDeclarativeListProperty<QQuickItem> *prop, int index)
2446 QQuickItemPrivate *p = QQuickItemPrivate::get(static_cast<QQuickItem *>(prop->object));
2447 if (index >= p->childItems.count() || index < 0)
2450 return p->childItems.at(index);
2453 void QQuickItemPrivate::children_append(QDeclarativeListProperty<QQuickItem> *prop, QQuickItem *o)
2458 QQuickItem *that = static_cast<QQuickItem *>(prop->object);
2459 if (o->parentItem() == that)
2460 o->setParentItem(0);
2462 o->setParentItem(that);
2465 int QQuickItemPrivate::children_count(QDeclarativeListProperty<QQuickItem> *prop)
2467 QQuickItemPrivate *p = QQuickItemPrivate::get(static_cast<QQuickItem *>(prop->object));
2468 return p->childItems.count();
2471 void QQuickItemPrivate::children_clear(QDeclarativeListProperty<QQuickItem> *prop)
2473 QQuickItem *that = static_cast<QQuickItem *>(prop->object);
2474 QQuickItemPrivate *p = QQuickItemPrivate::get(that);
2475 while (!p->childItems.isEmpty())
2476 p->childItems.at(0)->setParentItem(0);
2479 int QQuickItemPrivate::transform_count(QDeclarativeListProperty<QQuickTransform> *prop)
2481 QQuickItem *that = static_cast<QQuickItem *>(prop->object);
2482 return QQuickItemPrivate::get(that)->transforms.count();
2485 void QQuickTransform::appendToItem(QQuickItem *item)
2487 Q_D(QQuickTransform);
2491 QQuickItemPrivate *p = QQuickItemPrivate::get(item);
2493 if (!d->items.isEmpty() && !p->transforms.isEmpty() && p->transforms.contains(this)) {
2494 p->transforms.removeOne(this);
2495 p->transforms.append(this);
2497 p->transforms.append(this);
2498 d->items.append(item);
2501 p->dirty(QQuickItemPrivate::Transform);
2504 void QQuickTransform::prependToItem(QQuickItem *item)
2506 Q_D(QQuickTransform);
2510 QQuickItemPrivate *p = QQuickItemPrivate::get(item);
2512 if (!d->items.isEmpty() && !p->transforms.isEmpty() && p->transforms.contains(this)) {
2513 p->transforms.removeOne(this);
2514 p->transforms.prepend(this);
2516 p->transforms.prepend(this);
2517 d->items.append(item);
2520 p->dirty(QQuickItemPrivate::Transform);
2523 void QQuickItemPrivate::transform_append(QDeclarativeListProperty<QQuickTransform> *prop, QQuickTransform *transform)
2528 QQuickItem *that = static_cast<QQuickItem *>(prop->object);
2529 transform->appendToItem(that);
2532 QQuickTransform *QQuickItemPrivate::transform_at(QDeclarativeListProperty<QQuickTransform> *prop, int idx)
2534 QQuickItem *that = static_cast<QQuickItem *>(prop->object);
2535 QQuickItemPrivate *p = QQuickItemPrivate::get(that);
2537 if (idx < 0 || idx >= p->transforms.count())
2540 return p->transforms.at(idx);
2543 void QQuickItemPrivate::transform_clear(QDeclarativeListProperty<QQuickTransform> *prop)
2545 QQuickItem *that = static_cast<QQuickItem *>(prop->object);
2546 QQuickItemPrivate *p = QQuickItemPrivate::get(that);
2548 for (int ii = 0; ii < p->transforms.count(); ++ii) {
2549 QQuickTransform *t = p->transforms.at(ii);
2550 QQuickTransformPrivate *tp = QQuickTransformPrivate::get(t);
2551 tp->items.removeOne(that);
2554 p->transforms.clear();
2556 p->dirty(QQuickItemPrivate::Transform);
2560 \property QQuickItem::childrenRect
2561 \brief The geometry of an item's children.
2563 This property holds the (collective) position and size of the item's children.
2567 \qmlproperty real QtQuick2::Item::x
2568 \qmlproperty real QtQuick2::Item::y
2569 \qmlproperty real QtQuick2::Item::width
2570 \qmlproperty real QtQuick2::Item::height
2572 Defines the item's position and size relative to its parent.
2575 Item { x: 100; y: 100; width: 100; height: 100 }
2580 \qmlproperty real QtQuick2::Item::z
2582 Sets the stacking order of sibling items. By default the stacking order is 0.
2584 Items with a higher stacking value are drawn on top of siblings with a
2585 lower stacking order. Items with the same stacking value are drawn
2586 bottom up in the order they appear. Items with a negative stacking
2587 value are drawn under their parent's content.
2589 The following example shows the various effects of stacking order.
2593 \o \image declarative-item_stacking1.png
2594 \o Same \c z - later children above earlier children:
2599 width: 100; height: 100
2603 x: 50; y: 50; width: 100; height: 100
2608 \o \image declarative-item_stacking2.png
2609 \o Higher \c z on top:
2615 width: 100; height: 100
2619 x: 50; y: 50; width: 100; height: 100
2624 \o \image declarative-item_stacking3.png
2625 \o Same \c z - children above parents:
2630 width: 100; height: 100
2633 x: 50; y: 50; width: 100; height: 100
2639 \o \image declarative-item_stacking4.png
2640 \o Lower \c z below:
2645 width: 100; height: 100
2649 x: 50; y: 50; width: 100; height: 100
2658 \qmlproperty bool QtQuick2::Item::visible
2660 This property holds whether the item is visible. By default this is true.
2662 Setting this property directly affects the \c visible value of child
2663 items. When set to \c false, the \c visible values of all child items also
2664 become \c false. When set to \c true, the \c visible values of child items
2665 are returned to \c true, unless they have explicitly been set to \c false.
2667 (Because of this flow-on behavior, using the \c visible property may not
2668 have the intended effect if a property binding should only respond to
2669 explicit property changes. In such cases it may be better to use the
2670 \l opacity property instead.)
2672 Setting this property to \c false automatically causes \l focus to be set
2673 to \c false, and this item will longer receive mouse and keyboard events.
2674 (In contrast, setting the \l opacity to 0 does not affect the \l focus
2675 property and the receiving of key events.)
2677 \note This property's value is only affected by changes to this property or
2678 the parent's \c visible property. It does not change, for example, if this
2679 item moves off-screen, or if the \l opacity changes to 0.
2684 \qmlproperty AnchorLine QtQuick2::Item::anchors.top
2685 \qmlproperty AnchorLine QtQuick2::Item::anchors.bottom
2686 \qmlproperty AnchorLine QtQuick2::Item::anchors.left
2687 \qmlproperty AnchorLine QtQuick2::Item::anchors.right
2688 \qmlproperty AnchorLine QtQuick2::Item::anchors.horizontalCenter
2689 \qmlproperty AnchorLine QtQuick2::Item::anchors.verticalCenter
2690 \qmlproperty AnchorLine QtQuick2::Item::anchors.baseline
2692 \qmlproperty Item QtQuick2::Item::anchors.fill
2693 \qmlproperty Item QtQuick2::Item::anchors.centerIn
2695 \qmlproperty real QtQuick2::Item::anchors.margins
2696 \qmlproperty real QtQuick2::Item::anchors.topMargin
2697 \qmlproperty real QtQuick2::Item::anchors.bottomMargin
2698 \qmlproperty real QtQuick2::Item::anchors.leftMargin
2699 \qmlproperty real QtQuick2::Item::anchors.rightMargin
2700 \qmlproperty real QtQuick2::Item::anchors.horizontalCenterOffset
2701 \qmlproperty real QtQuick2::Item::anchors.verticalCenterOffset
2702 \qmlproperty real QtQuick2::Item::anchors.baselineOffset
2704 \qmlproperty bool QtQuick2::Item::anchors.mirrored
2706 Anchors provide a way to position an item by specifying its
2707 relationship with other items.
2709 Margins apply to top, bottom, left, right, and fill anchors.
2710 The \c anchors.margins property can be used to set all of the various margins at once, to the same value.
2711 Note that margins are anchor-specific and are not applied if an item does not
2714 Offsets apply for horizontal center, vertical center, and baseline anchors.
2718 \o \image declarative-anchors_example.png
2719 \o Text anchored to Image, horizontally centered and vertically below, with a margin.
2728 anchors.horizontalCenter: pic.horizontalCenter
2729 anchors.top: pic.bottom
2730 anchors.topMargin: 5
2736 \o \image declarative-anchors_example2.png
2738 Left of Text anchored to right of Image, with a margin. The y
2739 property of both defaults to 0.
2749 anchors.left: pic.right
2750 anchors.leftMargin: 5
2757 \c anchors.fill provides a convenient way for one item to have the
2758 same geometry as another item, and is equivalent to connecting all
2759 four directional anchors.
2761 To clear an anchor value, set it to \c undefined.
2763 \c anchors.mirrored returns true it the layout has been \l {LayoutMirroring}{mirrored}.
2765 \note You can only anchor an item to siblings or a parent.
2767 For more information see \l {anchor-layout}{Anchor Layouts}.
2771 \property QQuickItem::baselineOffset
2772 \brief The position of the item's baseline in local coordinates.
2774 The baseline of a \l Text item is the imaginary line on which the text
2775 sits. Controls containing text usually set their baseline to the
2776 baseline of their text.
2778 For non-text items, a default baseline offset of 0 is used.
2780 QQuickAnchors *QQuickItemPrivate::anchors() const
2783 Q_Q(const QQuickItem);
2784 _anchors = new QQuickAnchors(const_cast<QQuickItem *>(q));
2785 if (!componentComplete)
2786 _anchors->classBegin();
2791 QQuickItemPrivate::AnchorLines *QQuickItemPrivate::anchorLines() const
2793 Q_Q(const QQuickItem);
2794 if (!_anchorLines) _anchorLines =
2795 new AnchorLines(const_cast<QQuickItem *>(q));
2796 return _anchorLines;
2799 void QQuickItemPrivate::siblingOrderChanged()
2802 for (int ii = 0; ii < changeListeners.count(); ++ii) {
2803 const QQuickItemPrivate::ChangeListener &change = changeListeners.at(ii);
2804 if (change.types & QQuickItemPrivate::SiblingOrder) {
2805 change.listener->itemSiblingOrderChanged(q);
2810 QDeclarativeListProperty<QObject> QQuickItemPrivate::data()
2812 return QDeclarativeListProperty<QObject>(q_func(), 0, QQuickItemPrivate::data_append,
2813 QQuickItemPrivate::data_count,
2814 QQuickItemPrivate::data_at,
2815 QQuickItemPrivate::data_clear);
2818 QRectF QQuickItem::childrenRect()
2821 if (!d->_contents) {
2822 d->_contents = new QQuickContents(this);
2823 if (d->componentComplete)
2824 d->_contents->complete();
2826 return d->_contents->rectF();
2829 QList<QQuickItem *> QQuickItem::childItems() const
2831 Q_D(const QQuickItem);
2832 return d->childItems;
2835 bool QQuickItem::clip() const
2837 return flags() & ItemClipsChildrenToShape;
2840 void QQuickItem::setClip(bool c)
2845 setFlag(ItemClipsChildrenToShape, c);
2847 emit clipChanged(c);
2852 This function is called to handle this item's changes in
2853 geometry from \a oldGeometry to \a newGeometry. If the two
2854 geometries are the same, it doesn't do anything.
2856 void QQuickItem::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
2861 QQuickAnchorsPrivate::get(d->_anchors)->updateMe();
2863 bool xChange = (newGeometry.x() != oldGeometry.x());
2864 bool yChange = (newGeometry.y() != oldGeometry.y());
2865 bool widthChange = (newGeometry.width() != oldGeometry.width());
2866 bool heightChange = (newGeometry.height() != oldGeometry.height());
2868 for (int ii = 0; ii < d->changeListeners.count(); ++ii) {
2869 const QQuickItemPrivate::ChangeListener &change = d->changeListeners.at(ii);
2870 if (change.types & QQuickItemPrivate::Geometry) {
2871 if (change.gTypes == QQuickItemPrivate::GeometryChange) {
2872 change.listener->itemGeometryChanged(this, newGeometry, oldGeometry);
2873 } else if ((xChange && (change.gTypes & QQuickItemPrivate::XChange)) ||
2874 (yChange && (change.gTypes & QQuickItemPrivate::YChange)) ||
2875 (widthChange && (change.gTypes & QQuickItemPrivate::WidthChange)) ||
2876 (heightChange && (change.gTypes & QQuickItemPrivate::HeightChange))) {
2877 change.listener->itemGeometryChanged(this, newGeometry, oldGeometry);
2887 emit widthChanged();
2889 emit heightChanged();
2893 Called by the rendering thread when it is time to sync the state of the QML objects with the
2894 scene graph objects. The function should return the root of the scene graph subtree for
2895 this item. \a oldNode is the node that was returned the last time the function was called.
2897 The main thread is blocked while this function is executed so it is safe to read
2898 values from the QQuickItem instance and other objects in the main thread.
2900 \warning This is the only function in which it is allowed to make use of scene graph
2901 objects from the main thread. Use of scene graph objects outside this function will
2902 result in race conditions and potential crashes.
2905 QSGNode *QQuickItem::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *)
2911 QSGTransformNode *QQuickItemPrivate::createTransformNode()
2913 return new QSGTransformNode;
2916 void QQuickItem::updatePolish()
2920 void QQuickItem::sendAccessibilityUpdate()
2925 void QQuickItemPrivate::removeItemChangeListener(QQuickItemChangeListener *listener, ChangeTypes types)
2927 ChangeListener change(listener, types);
2928 changeListeners.removeOne(change);
2931 void QQuickItemPrivate::updateOrAddGeometryChangeListener(QQuickItemChangeListener *listener, GeometryChangeTypes types)
2933 ChangeListener change(listener, types);
2934 int index = changeListeners.find(change);
2936 changeListeners[index].gTypes = change.gTypes; //we may have different GeometryChangeTypes
2938 changeListeners.append(change);
2941 void QQuickItemPrivate::updateOrRemoveGeometryChangeListener(QQuickItemChangeListener *listener, GeometryChangeTypes types)
2943 ChangeListener change(listener, types);
2944 if (types == NoChange) {
2945 changeListeners.removeOne(change);
2947 int index = changeListeners.find(change);
2949 changeListeners[index].gTypes = change.gTypes; //we may have different GeometryChangeTypes
2953 void QQuickItem::keyPressEvent(QKeyEvent *event)
2958 void QQuickItem::keyReleaseEvent(QKeyEvent *event)
2963 void QQuickItem::inputMethodEvent(QInputMethodEvent *event)
2968 void QQuickItem::focusInEvent(QFocusEvent *)
2970 QAccessible::updateAccessibility(this, 0, QAccessible::Focus);
2973 void QQuickItem::focusOutEvent(QFocusEvent *)
2977 void QQuickItem::mousePressEvent(QMouseEvent *event)
2982 void QQuickItem::mouseMoveEvent(QMouseEvent *event)
2987 void QQuickItem::mouseReleaseEvent(QMouseEvent *event)
2992 void QQuickItem::mouseDoubleClickEvent(QMouseEvent *event)
2994 mousePressEvent(event);
2997 void QQuickItem::mouseUngrabEvent()
3002 void QQuickItem::touchUngrabEvent()
3007 void QQuickItem::wheelEvent(QWheelEvent *event)
3012 void QQuickItem::touchEvent(QTouchEvent *event)
3017 void QQuickItem::hoverEnterEvent(QHoverEvent *event)
3022 void QQuickItem::hoverMoveEvent(QHoverEvent *event)
3027 void QQuickItem::hoverLeaveEvent(QHoverEvent *event)
3032 void QQuickItem::dragEnterEvent(QDragEnterEvent *event)
3037 void QQuickItem::dragMoveEvent(QDragMoveEvent *event)
3043 void QQuickItem::dragLeaveEvent(QDragLeaveEvent *event)
3049 void QQuickItem::dropEvent(QDropEvent *event)
3054 bool QQuickItem::childMouseEventFilter(QQuickItem *, QEvent *)
3059 void QQuickItem::windowDeactivateEvent()
3061 foreach (QQuickItem* item, childItems()) {
3062 item->windowDeactivateEvent();
3066 Qt::InputMethodHints QQuickItem::inputMethodHints() const
3068 Q_D(const QQuickItem);
3072 void QQuickItem::setInputMethodHints(Qt::InputMethodHints hints)
3077 if (!d->canvas || d->canvas->activeFocusItem() != this)
3080 QInputPanel *p = qApp->inputPanel();
3081 if (p->inputItem() == this)
3082 qApp->inputPanel()->update(Qt::ImHints);
3085 void QQuickItem::updateMicroFocus()
3087 QInputPanel *p = qApp->inputPanel();
3088 if (p->inputItem() == this)
3089 qApp->inputPanel()->update(Qt::ImQueryInput);
3092 QVariant QQuickItem::inputMethodQuery(Qt::InputMethodQuery query) const
3094 Q_D(const QQuickItem);
3099 v = (bool)(flags() & ItemAcceptsInputMethod);
3102 v = (int)inputMethodHints();
3104 case Qt::ImCursorRectangle:
3106 case Qt::ImCursorPosition:
3107 case Qt::ImSurroundingText:
3108 case Qt::ImCurrentSelection:
3109 case Qt::ImMaximumTextLength:
3110 case Qt::ImAnchorPosition:
3111 case Qt::ImPreferredLanguage:
3113 v = d->keyHandler->inputMethodQuery(query);
3121 QQuickAnchorLine QQuickItemPrivate::left() const
3123 return anchorLines()->left;
3126 QQuickAnchorLine QQuickItemPrivate::right() const
3128 return anchorLines()->right;
3131 QQuickAnchorLine QQuickItemPrivate::horizontalCenter() const
3133 return anchorLines()->hCenter;
3136 QQuickAnchorLine QQuickItemPrivate::top() const
3138 return anchorLines()->top;
3141 QQuickAnchorLine QQuickItemPrivate::bottom() const
3143 return anchorLines()->bottom;
3146 QQuickAnchorLine QQuickItemPrivate::verticalCenter() const
3148 return anchorLines()->vCenter;
3151 QQuickAnchorLine QQuickItemPrivate::baseline() const
3153 return anchorLines()->baseline;
3156 qreal QQuickItem::baselineOffset() const
3158 Q_D(const QQuickItem);
3159 if (!d->baselineOffset.isValid()) {
3162 return d->baselineOffset;
3165 void QQuickItem::setBaselineOffset(qreal offset)
3168 if (offset == d->baselineOffset)
3171 d->baselineOffset = offset;
3173 for (int ii = 0; ii < d->changeListeners.count(); ++ii) {
3174 const QQuickItemPrivate::ChangeListener &change = d->changeListeners.at(ii);
3175 if (change.types & QQuickItemPrivate::Geometry) {
3176 QQuickAnchorsPrivate *anchor = change.listener->anchorPrivate();
3178 anchor->updateVerticalAnchors();
3181 emit baselineOffsetChanged(offset);
3184 void QQuickItem::update()
3187 Q_ASSERT(flags() & ItemHasContents);
3188 d->dirty(QQuickItemPrivate::Content);
3191 void QQuickItem::polish()
3194 if (!d->polishScheduled) {
3195 d->polishScheduled = true;
3197 QQuickCanvasPrivate *p = QQuickCanvasPrivate::get(d->canvas);
3198 bool maybeupdate = p->itemsToPolish.isEmpty();
3199 p->itemsToPolish.insert(this);
3200 if (maybeupdate) d->canvas->maybeUpdate();
3205 void QQuickItem::mapFromItem(QDeclarativeV8Function *args) const
3207 if (args->Length() != 0) {
3208 v8::Local<v8::Value> item = (*args)[0];
3209 QV8Engine *engine = args->engine();
3211 QQuickItem *itemObj = 0;
3212 if (!item->IsNull())
3213 itemObj = qobject_cast<QQuickItem*>(engine->toQObject(item));
3215 if (!itemObj && !item->IsNull()) {
3216 qmlInfo(this) << "mapFromItem() given argument \"" << engine->toString(item->ToString())
3217 << "\" which is neither null nor an Item";
3221 v8::Local<v8::Object> rv = v8::Object::New();
3222 args->returnValue(rv);
3224 qreal x = (args->Length() > 1)?(*args)[1]->NumberValue():0;
3225 qreal y = (args->Length() > 2)?(*args)[2]->NumberValue():0;
3227 QPointF p = mapFromItem(itemObj, QPointF(x, y));
3229 rv->Set(v8::String::New("x"), v8::Number::New(p.x()));
3230 rv->Set(v8::String::New("y"), v8::Number::New(p.y()));
3234 QTransform QQuickItem::itemTransform(QQuickItem *other, bool *ok) const
3236 Q_D(const QQuickItem);
3238 // XXX todo - we need to be able to handle common parents better and detect
3242 QTransform t = d->itemToCanvasTransform();
3243 if (other) t *= QQuickItemPrivate::get(other)->canvasToItemTransform();
3248 void QQuickItem::mapToItem(QDeclarativeV8Function *args) const
3250 if (args->Length() != 0) {
3251 v8::Local<v8::Value> item = (*args)[0];
3252 QV8Engine *engine = args->engine();
3254 QQuickItem *itemObj = 0;
3255 if (!item->IsNull())
3256 itemObj = qobject_cast<QQuickItem*>(engine->toQObject(item));
3258 if (!itemObj && !item->IsNull()) {
3259 qmlInfo(this) << "mapToItem() given argument \"" << engine->toString(item->ToString())
3260 << "\" which is neither null nor an Item";
3264 v8::Local<v8::Object> rv = v8::Object::New();
3265 args->returnValue(rv);
3267 qreal x = (args->Length() > 1)?(*args)[1]->NumberValue():0;
3268 qreal y = (args->Length() > 2)?(*args)[2]->NumberValue():0;
3270 QPointF p = mapToItem(itemObj, QPointF(x, y));
3272 rv->Set(v8::String::New("x"), v8::Number::New(p.x()));
3273 rv->Set(v8::String::New("y"), v8::Number::New(p.y()));
3277 void QQuickItem::forceActiveFocus()
3280 QQuickItem *parent = parentItem();
3282 if (parent->flags() & QQuickItem::ItemIsFocusScope) {
3283 parent->setFocus(true);
3285 parent = parent->parentItem();
3289 QQuickItem *QQuickItem::childAt(qreal x, qreal y) const
3291 // XXX todo - should this include transform etc.?
3292 const QList<QQuickItem *> children = childItems();
3293 for (int i = children.count()-1; i >= 0; --i) {
3294 QQuickItem *child = children.at(i);
3295 if (child->isVisible() && child->x() <= x
3296 && child->x() + child->width() >= x
3298 && child->y() + child->height() >= y)
3304 QDeclarativeListProperty<QObject> QQuickItemPrivate::resources()
3306 return QDeclarativeListProperty<QObject>(q_func(), 0, QQuickItemPrivate::resources_append,
3307 QQuickItemPrivate::resources_count,
3308 QQuickItemPrivate::resources_at,
3309 QQuickItemPrivate::resources_clear);
3312 QDeclarativeListProperty<QQuickItem> QQuickItemPrivate::children()
3314 return QDeclarativeListProperty<QQuickItem>(q_func(), 0, QQuickItemPrivate::children_append,
3315 QQuickItemPrivate::children_count,
3316 QQuickItemPrivate::children_at,
3317 QQuickItemPrivate::children_clear);
3321 QDeclarativeListProperty<QDeclarativeState> QQuickItemPrivate::states()
3323 return _states()->statesProperty();
3326 QDeclarativeListProperty<QDeclarativeTransition> QQuickItemPrivate::transitions()
3328 return _states()->transitionsProperty();
3331 QString QQuickItemPrivate::state() const
3336 return _stateGroup->state();
3339 void QQuickItemPrivate::setState(const QString &state)
3341 _states()->setState(state);
3344 QString QQuickItem::state() const
3346 Q_D(const QQuickItem);
3350 void QQuickItem::setState(const QString &state)
3356 QDeclarativeListProperty<QQuickTransform> QQuickItem::transform()
3358 return QDeclarativeListProperty<QQuickTransform>(this, 0, QQuickItemPrivate::transform_append,
3359 QQuickItemPrivate::transform_count,
3360 QQuickItemPrivate::transform_at,
3361 QQuickItemPrivate::transform_clear);
3364 void QQuickItem::classBegin()
3367 d->componentComplete = false;
3369 d->_stateGroup->classBegin();
3371 d->_anchors->classBegin();
3373 d->_layer->classBegin();
3376 void QQuickItem::componentComplete()
3379 d->componentComplete = true;
3381 d->_stateGroup->componentComplete();
3383 d->_anchors->componentComplete();
3384 QQuickAnchorsPrivate::get(d->_anchors)->updateOnComplete();
3388 d->_layer->componentComplete();
3391 d->keyHandler->componentComplete();
3393 d->_contents->complete();
3396 QDeclarativeStateGroup *QQuickItemPrivate::_states()
3400 _stateGroup = new QDeclarativeStateGroup;
3401 if (!componentComplete)
3402 _stateGroup->classBegin();
3403 FAST_CONNECT(_stateGroup, SIGNAL(stateChanged(QString)),
3404 q, SIGNAL(stateChanged(QString)))
3410 QQuickItemPrivate::AnchorLines::AnchorLines(QQuickItem *q)
3413 left.anchorLine = QQuickAnchorLine::Left;
3415 right.anchorLine = QQuickAnchorLine::Right;
3417 hCenter.anchorLine = QQuickAnchorLine::HCenter;
3419 top.anchorLine = QQuickAnchorLine::Top;
3421 bottom.anchorLine = QQuickAnchorLine::Bottom;
3423 vCenter.anchorLine = QQuickAnchorLine::VCenter;
3425 baseline.anchorLine = QQuickAnchorLine::Baseline;
3428 QPointF QQuickItemPrivate::computeTransformOrigin() const
3432 case QQuickItem::TopLeft:
3433 return QPointF(0, 0);
3434 case QQuickItem::Top:
3435 return QPointF(width / 2., 0);
3436 case QQuickItem::TopRight:
3437 return QPointF(width, 0);
3438 case QQuickItem::Left:
3439 return QPointF(0, height / 2.);
3440 case QQuickItem::Center:
3441 return QPointF(width / 2., height / 2.);
3442 case QQuickItem::Right:
3443 return QPointF(width, height / 2.);
3444 case QQuickItem::BottomLeft:
3445 return QPointF(0, height);
3446 case QQuickItem::Bottom:
3447 return QPointF(width / 2., height);
3448 case QQuickItem::BottomRight:
3449 return QPointF(width, height);
3453 void QQuickItemPrivate::transformChanged()
3456 _layer->updateMatrix();
3459 void QQuickItemPrivate::deliverKeyEvent(QKeyEvent *e)
3463 Q_ASSERT(e->isAccepted());
3465 if (e->type() == QEvent::KeyPress)
3466 keyHandler->keyPressed(e, false);
3468 keyHandler->keyReleased(e, false);
3470 if (e->isAccepted())
3476 if (e->type() == QEvent::KeyPress)
3477 q->keyPressEvent(e);
3479 q->keyReleaseEvent(e);
3481 if (e->isAccepted())
3487 if (e->type() == QEvent::KeyPress)
3488 keyHandler->keyPressed(e, true);
3490 keyHandler->keyReleased(e, true);
3494 void QQuickItemPrivate::deliverInputMethodEvent(QInputMethodEvent *e)
3498 Q_ASSERT(e->isAccepted());
3500 keyHandler->inputMethodEvent(e, false);
3502 if (e->isAccepted())
3508 q->inputMethodEvent(e);
3510 if (e->isAccepted())
3516 keyHandler->inputMethodEvent(e, true);
3520 void QQuickItemPrivate::deliverFocusEvent(QFocusEvent *e)
3524 if (e->type() == QEvent::FocusIn) {
3527 q->focusOutEvent(e);
3531 void QQuickItemPrivate::deliverMouseEvent(QMouseEvent *e)
3535 Q_ASSERT(e->isAccepted());
3537 switch (e->type()) {
3539 Q_ASSERT(!"Unknown event type");
3540 case QEvent::MouseMove:
3541 q->mouseMoveEvent(e);
3543 case QEvent::MouseButtonPress:
3544 q->mousePressEvent(e);
3546 case QEvent::MouseButtonRelease:
3547 q->mouseReleaseEvent(e);
3549 case QEvent::MouseButtonDblClick:
3550 q->mouseDoubleClickEvent(e);
3555 void QQuickItemPrivate::deliverWheelEvent(QWheelEvent *e)
3561 void QQuickItemPrivate::deliverTouchEvent(QTouchEvent *e)
3567 void QQuickItemPrivate::deliverHoverEvent(QHoverEvent *e)
3570 switch (e->type()) {
3572 Q_ASSERT(!"Unknown event type");
3573 case QEvent::HoverEnter:
3574 q->hoverEnterEvent(e);
3576 case QEvent::HoverLeave:
3577 q->hoverLeaveEvent(e);
3579 case QEvent::HoverMove:
3580 q->hoverMoveEvent(e);
3585 void QQuickItemPrivate::deliverDragEvent(QEvent *e)
3588 switch (e->type()) {
3590 Q_ASSERT(!"Unknown event type");
3591 case QEvent::DragEnter:
3592 q->dragEnterEvent(static_cast<QDragEnterEvent *>(e));
3594 case QEvent::DragLeave:
3595 q->dragLeaveEvent(static_cast<QDragLeaveEvent *>(e));
3597 case QEvent::DragMove:
3598 q->dragMoveEvent(static_cast<QDragMoveEvent *>(e));
3601 q->dropEvent(static_cast<QDropEvent *>(e));
3606 void QQuickItem::itemChange(ItemChange change, const ItemChangeData &value)
3613 // XXX todo - do we want/need this anymore?
3614 // Note that it's now used for varying clip rect
3615 QRectF QQuickItem::boundingRect() const
3617 Q_D(const QQuickItem);
3618 return QRectF(0, 0, d->width, d->height);
3621 QQuickItem::TransformOrigin QQuickItem::transformOrigin() const
3623 Q_D(const QQuickItem);
3627 void QQuickItem::setTransformOrigin(TransformOrigin origin)
3630 if (origin == d->origin)
3634 d->dirty(QQuickItemPrivate::TransformOrigin);
3636 emit transformOriginChanged(d->origin);
3639 QPointF QQuickItem::transformOriginPoint() const
3641 Q_D(const QQuickItem);
3642 if (!d->transformOriginPoint.isNull())
3643 return d->transformOriginPoint;
3644 return d->computeTransformOrigin();
3647 void QQuickItem::setTransformOriginPoint(const QPointF &point)
3650 if (d->transformOriginPoint == point)
3653 d->transformOriginPoint = point;
3654 d->dirty(QQuickItemPrivate::TransformOrigin);
3657 qreal QQuickItem::z() const
3659 Q_D(const QQuickItem);
3663 void QQuickItem::setZ(qreal v)
3671 d->dirty(QQuickItemPrivate::ZValue);
3672 if (d->parentItem) {
3673 QQuickItemPrivate::get(d->parentItem)->dirty(QQuickItemPrivate::ChildrenStackingChanged);
3674 QQuickItemPrivate::get(d->parentItem)->markSortedChildrenDirty(this);
3680 d->_layer->updateZ();
3685 \qmlproperty real QtQuick2::Item::rotation
3686 This property holds the rotation of the item in degrees clockwise.
3688 This specifies how many degrees to rotate the item around its transformOrigin.
3689 The default rotation is 0 degrees (i.e. not rotated at all).
3693 \o \image declarative-rotation.png
3698 width: 100; height: 100
3701 x: 25; y: 25; width: 50; height: 50
3708 \sa transform, Rotation
3712 \qmlproperty real QtQuick2::Item::scale
3713 This property holds the scale of the item.
3715 A scale of less than 1 means the item will be displayed smaller than
3716 normal, and a scale of greater than 1 means the item will be
3717 displayed larger than normal. A negative scale means the item will
3720 By default, items are displayed at a scale of 1 (i.e. at their
3723 Scaling is from the item's transformOrigin.
3727 \o \image declarative-scale.png
3732 width: 100; height: 100
3735 width: 25; height: 25
3739 x: 25; y: 25; width: 50; height: 50
3746 \sa transform, Scale
3750 \qmlproperty real QtQuick2::Item::opacity
3752 This property holds the opacity of the item. Opacity is specified as a
3753 number between 0 (fully transparent) and 1 (fully opaque). The default is 1.
3755 When this property is set, the specified opacity is also applied
3756 individually to child items. In almost all cases this is what you want,
3757 but in some cases it may produce undesired results. For example in the
3758 second set of rectangles below, the red rectangle has specified an opacity
3759 of 0.5, which affects the opacity of its blue child rectangle even though
3760 the child has not specified an opacity.
3764 \o \image declarative-item_opacity1.png
3770 width: 100; height: 100
3773 x: 50; y: 50; width: 100; height: 100
3779 \o \image declarative-item_opacity2.png
3786 width: 100; height: 100
3789 x: 50; y: 50; width: 100; height: 100
3796 If an item's opacity is set to 0, the item will no longer receive mouse
3797 events, but will continue to receive key events and will retain the keyboard
3798 \l focus if it has been set. (In contrast, setting the \l visible property
3799 to \c false stops both mouse and keyboard events, and also removes focus
3804 Returns a value indicating whether mouse input should
3805 remain with this item exclusively.
3807 \sa setKeepMouseGrab()
3810 qreal QQuickItem::rotation() const
3812 Q_D(const QQuickItem);
3816 void QQuickItem::setRotation(qreal r)
3819 if (d->rotation == r)
3824 d->dirty(QQuickItemPrivate::BasicTransform);
3826 d->itemChange(ItemRotationHasChanged, r);
3828 emit rotationChanged();
3831 qreal QQuickItem::scale() const
3833 Q_D(const QQuickItem);
3837 void QQuickItem::setScale(qreal s)
3845 d->dirty(QQuickItemPrivate::BasicTransform);
3847 emit scaleChanged();
3850 qreal QQuickItem::opacity() const
3852 Q_D(const QQuickItem);
3856 void QQuickItem::setOpacity(qreal o)
3859 if (d->opacity == o)
3864 d->dirty(QQuickItemPrivate::OpacityValue);
3866 d->itemChange(ItemOpacityHasChanged, o);
3868 emit opacityChanged();
3871 bool QQuickItem::isVisible() const
3873 Q_D(const QQuickItem);
3874 return d->effectiveVisible;
3877 void QQuickItem::setVisible(bool v)
3880 if (v == d->explicitVisible)
3883 d->explicitVisible = v;
3885 d->setEffectiveVisibleRecur(d->calcEffectiveVisible());
3888 bool QQuickItem::isEnabled() const
3890 Q_D(const QQuickItem);
3891 return d->effectiveEnable;
3894 void QQuickItem::setEnabled(bool e)
3897 if (e == d->explicitEnable)
3900 d->explicitEnable = e;
3902 d->setEffectiveEnableRecur(d->calcEffectiveEnable());
3905 bool QQuickItemPrivate::calcEffectiveVisible() const
3907 // XXX todo - Should the effective visible of an element with no parent just be the current
3908 // effective visible? This would prevent pointless re-processing in the case of an element
3909 // moving to/from a no-parent situation, but it is different from what graphics view does.
3910 return explicitVisible && (!parentItem || QQuickItemPrivate::get(parentItem)->effectiveVisible);
3913 void QQuickItemPrivate::setEffectiveVisibleRecur(bool newEffectiveVisible)
3917 if (newEffectiveVisible && !explicitVisible) {
3918 // This item locally overrides visibility
3922 if (newEffectiveVisible == effectiveVisible) {
3923 // No change necessary
3927 effectiveVisible = newEffectiveVisible;
3929 if (parentItem) QQuickItemPrivate::get(parentItem)->dirty(ChildrenStackingChanged);
3932 QQuickCanvasPrivate *canvasPriv = QQuickCanvasPrivate::get(canvas);
3933 if (canvasPriv->mouseGrabberItem == q)
3937 for (int ii = 0; ii < childItems.count(); ++ii)
3938 QQuickItemPrivate::get(childItems.at(ii))->setEffectiveVisibleRecur(newEffectiveVisible);
3940 for (int ii = 0; ii < changeListeners.count(); ++ii) {
3941 const QQuickItemPrivate::ChangeListener &change = changeListeners.at(ii);
3942 if (change.types & QQuickItemPrivate::Visibility)
3943 change.listener->itemVisibilityChanged(q);
3947 QAccessible::updateAccessibility(q, 0, effectiveVisible ? QAccessible::ObjectShow : QAccessible::ObjectHide );
3949 emit q->visibleChanged();
3952 bool QQuickItemPrivate::calcEffectiveEnable() const
3954 // XXX todo - Should the effective enable of an element with no parent just be the current
3955 // effective enable? This would prevent pointless re-processing in the case of an element
3956 // moving to/from a no-parent situation, but it is different from what graphics view does.
3957 return explicitEnable && (!parentItem || QQuickItemPrivate::get(parentItem)->effectiveEnable);
3960 void QQuickItemPrivate::setEffectiveEnableRecur(bool newEffectiveEnable)
3964 // XXX todo - need to fixup focus
3966 if (newEffectiveEnable && !explicitEnable) {
3967 // This item locally overrides enable
3971 if (newEffectiveEnable == effectiveEnable) {
3972 // No change necessary
3976 effectiveEnable = newEffectiveEnable;
3979 QQuickCanvasPrivate *canvasPriv = QQuickCanvasPrivate::get(canvas);
3980 if (canvasPriv->mouseGrabberItem == q)
3984 for (int ii = 0; ii < childItems.count(); ++ii)
3985 QQuickItemPrivate::get(childItems.at(ii))->setEffectiveEnableRecur(newEffectiveEnable);
3987 emit q->enabledChanged();
3990 QString QQuickItemPrivate::dirtyToString() const
3992 #define DIRTY_TO_STRING(value) if (dirtyAttributes & value) { \
3993 if (!rv.isEmpty()) \
3994 rv.append(QLatin1String("|")); \
3995 rv.append(QLatin1String(#value)); \
3998 // QString rv = QLatin1String("0x") + QString::number(dirtyAttributes, 16);
4001 DIRTY_TO_STRING(TransformOrigin);
4002 DIRTY_TO_STRING(Transform);
4003 DIRTY_TO_STRING(BasicTransform);
4004 DIRTY_TO_STRING(Position);
4005 DIRTY_TO_STRING(Size);
4006 DIRTY_TO_STRING(ZValue);
4007 DIRTY_TO_STRING(Content);
4008 DIRTY_TO_STRING(Smooth);
4009 DIRTY_TO_STRING(OpacityValue);
4010 DIRTY_TO_STRING(ChildrenChanged);
4011 DIRTY_TO_STRING(ChildrenStackingChanged);
4012 DIRTY_TO_STRING(ParentChanged);
4013 DIRTY_TO_STRING(Clip);
4014 DIRTY_TO_STRING(Canvas);
4015 DIRTY_TO_STRING(EffectReference);
4016 DIRTY_TO_STRING(Visible);
4017 DIRTY_TO_STRING(HideReference);
4018 DIRTY_TO_STRING(PerformanceHints);
4023 void QQuickItemPrivate::dirty(DirtyType type)
4026 if (type & (TransformOrigin | Transform | BasicTransform | Position | Size))
4029 if (!(dirtyAttributes & type) || (canvas && !prevDirtyItem)) {
4030 dirtyAttributes |= type;
4033 QQuickCanvasPrivate::get(canvas)->dirtyItem(q);
4038 void QQuickItemPrivate::addToDirtyList()
4043 if (!prevDirtyItem) {
4044 Q_ASSERT(!nextDirtyItem);
4046 QQuickCanvasPrivate *p = QQuickCanvasPrivate::get(canvas);
4047 nextDirtyItem = p->dirtyItemList;
4048 if (nextDirtyItem) QQuickItemPrivate::get(nextDirtyItem)->prevDirtyItem = &nextDirtyItem;
4049 prevDirtyItem = &p->dirtyItemList;
4050 p->dirtyItemList = q;
4053 Q_ASSERT(prevDirtyItem);
4056 void QQuickItemPrivate::removeFromDirtyList()
4058 if (prevDirtyItem) {
4059 if (nextDirtyItem) QQuickItemPrivate::get(nextDirtyItem)->prevDirtyItem = prevDirtyItem;
4060 *prevDirtyItem = nextDirtyItem;
4064 Q_ASSERT(!prevDirtyItem);
4065 Q_ASSERT(!nextDirtyItem);
4068 void QQuickItemPrivate::refFromEffectItem(bool hide)
4071 if (1 == effectRefCount) {
4072 dirty(EffectReference);
4073 if (parentItem) QQuickItemPrivate::get(parentItem)->dirty(ChildrenStackingChanged);
4076 if (++hideRefCount == 1)
4077 dirty(HideReference);
4081 void QQuickItemPrivate::derefFromEffectItem(bool unhide)
4083 Q_ASSERT(effectRefCount);
4085 if (0 == effectRefCount) {
4086 dirty(EffectReference);
4087 if (parentItem) QQuickItemPrivate::get(parentItem)->dirty(ChildrenStackingChanged);
4090 if (--hideRefCount == 0)
4091 dirty(HideReference);
4095 void QQuickItemPrivate::itemChange(QQuickItem::ItemChange change, const QQuickItem::ItemChangeData &data)
4099 case QQuickItem::ItemChildAddedChange:
4100 q->itemChange(change, data);
4101 for (int ii = 0; ii < changeListeners.count(); ++ii) {
4102 const QQuickItemPrivate::ChangeListener &change = changeListeners.at(ii);
4103 if (change.types & QQuickItemPrivate::Children) {
4104 change.listener->itemChildAdded(q, data.item);
4108 case QQuickItem::ItemChildRemovedChange:
4109 q->itemChange(change, data);
4110 for (int ii = 0; ii < changeListeners.count(); ++ii) {
4111 const QQuickItemPrivate::ChangeListener &change = changeListeners.at(ii);
4112 if (change.types & QQuickItemPrivate::Children) {
4113 change.listener->itemChildRemoved(q, data.item);
4117 case QQuickItem::ItemSceneChange:
4118 q->itemChange(change, data);
4120 case QQuickItem::ItemVisibleHasChanged:
4121 q->itemChange(change, data);
4122 for (int ii = 0; ii < changeListeners.count(); ++ii) {
4123 const QQuickItemPrivate::ChangeListener &change = changeListeners.at(ii);
4124 if (change.types & QQuickItemPrivate::Visibility) {
4125 change.listener->itemVisibilityChanged(q);
4129 case QQuickItem::ItemParentHasChanged:
4130 q->itemChange(change, data);
4131 for (int ii = 0; ii < changeListeners.count(); ++ii) {
4132 const QQuickItemPrivate::ChangeListener &change = changeListeners.at(ii);
4133 if (change.types & QQuickItemPrivate::Parent) {
4134 change.listener->itemParentChanged(q, data.item);
4138 case QQuickItem::ItemOpacityHasChanged:
4139 q->itemChange(change, data);
4140 for (int ii = 0; ii < changeListeners.count(); ++ii) {
4141 const QQuickItemPrivate::ChangeListener &change = changeListeners.at(ii);
4142 if (change.types & QQuickItemPrivate::Opacity) {
4143 change.listener->itemOpacityChanged(q);
4147 case QQuickItem::ItemActiveFocusHasChanged:
4148 q->itemChange(change, data);
4150 case QQuickItem::ItemRotationHasChanged:
4151 q->itemChange(change, data);
4152 for (int ii = 0; ii < changeListeners.count(); ++ii) {
4153 const QQuickItemPrivate::ChangeListener &change = changeListeners.at(ii);
4154 if (change.types & QQuickItemPrivate::Rotation) {
4155 change.listener->itemRotationChanged(q);
4163 \property QQuickItem::smooth
4164 \brief whether the item is smoothly transformed.
4166 This property is provided purely for the purpose of optimization. Turning
4167 smooth transforms off is faster, but looks worse; turning smooth
4168 transformations on is slower, but looks better.
4170 By default smooth transformations are off.
4174 Returns true if the item should be drawn with antialiasing and
4175 smooth pixmap filtering, false otherwise.
4177 The default is false.
4181 bool QQuickItem::smooth() const
4183 Q_D(const QQuickItem);
4188 Sets whether the item should be drawn with antialiasing and
4189 smooth pixmap filtering to \a smooth.
4193 void QQuickItem::setSmooth(bool smooth)
4196 if (d->smooth == smooth)
4200 d->dirty(QQuickItemPrivate::Smooth);
4202 emit smoothChanged(smooth);
4205 QQuickItem::Flags QQuickItem::flags() const
4207 Q_D(const QQuickItem);
4208 return (QQuickItem::Flags)d->flags;
4211 void QQuickItem::setFlag(Flag flag, bool enabled)
4215 setFlags((Flags)(d->flags | (quint32)flag));
4217 setFlags((Flags)(d->flags & ~(quint32)flag));
4220 void QQuickItem::setFlags(Flags flags)
4224 if ((flags & ItemIsFocusScope) != (d->flags & ItemIsFocusScope)) {
4225 if (flags & ItemIsFocusScope && !d->childItems.isEmpty() && d->canvas) {
4226 qWarning("QQuickItem: Cannot set FocusScope once item has children and is in a canvas.");
4227 flags &= ~ItemIsFocusScope;
4228 } else if (d->flags & ItemIsFocusScope) {
4229 qWarning("QQuickItem: Cannot unset FocusScope flag.");
4230 flags |= ItemIsFocusScope;
4234 if ((flags & ItemClipsChildrenToShape ) != (d->flags & ItemClipsChildrenToShape))
4235 d->dirty(QQuickItemPrivate::Clip);
4240 qreal QQuickItem::x() const
4242 Q_D(const QQuickItem);
4246 qreal QQuickItem::y() const
4248 Q_D(const QQuickItem);
4252 QPointF QQuickItem::pos() const
4254 Q_D(const QQuickItem);
4255 return QPointF(d->x, d->y);
4258 void QQuickItem::setX(qreal v)
4267 d->dirty(QQuickItemPrivate::Position);
4269 geometryChanged(QRectF(x(), y(), width(), height()),
4270 QRectF(oldx, y(), width(), height()));
4273 void QQuickItem::setY(qreal v)
4282 d->dirty(QQuickItemPrivate::Position);
4284 geometryChanged(QRectF(x(), y(), width(), height()),
4285 QRectF(x(), oldy, width(), height()));
4288 void QQuickItem::setPos(const QPointF &pos)
4291 if (QPointF(d->x, d->y) == pos)
4300 d->dirty(QQuickItemPrivate::Position);
4302 geometryChanged(QRectF(x(), y(), width(), height()),
4303 QRectF(oldx, oldy, width(), height()));
4306 qreal QQuickItem::width() const
4308 Q_D(const QQuickItem);
4312 void QQuickItem::setWidth(qreal w)
4318 d->widthValid = true;
4322 qreal oldWidth = d->width;
4325 d->dirty(QQuickItemPrivate::Size);
4327 geometryChanged(QRectF(x(), y(), width(), height()),
4328 QRectF(x(), y(), oldWidth, height()));
4331 void QQuickItem::resetWidth()
4334 d->widthValid = false;
4335 setImplicitWidth(implicitWidth());
4338 void QQuickItemPrivate::implicitWidthChanged()
4341 emit q->implicitWidthChanged();
4344 qreal QQuickItemPrivate::getImplicitWidth() const
4346 return implicitWidth;
4349 Returns the width of the item that is implied by other properties that determine the content.
4351 qreal QQuickItem::implicitWidth() const
4353 Q_D(const QQuickItem);
4354 return d->getImplicitWidth();
4358 \qmlproperty real QtQuick2::Item::implicitWidth
4359 \qmlproperty real QtQuick2::Item::implicitHeight
4361 Defines the natural width or height of the Item if no \l width or \l height is specified.
4363 The default implicit size for most items is 0x0, however some elements have an inherent
4364 implicit size which cannot be overridden, e.g. Image, Text.
4366 Setting the implicit size is useful for defining components that have a preferred size
4367 based on their content, for example:
4374 property alias icon: image.source
4375 property alias label: text.text
4376 implicitWidth: text.implicitWidth + image.implicitWidth
4377 implicitHeight: Math.max(text.implicitHeight, image.implicitHeight)
4382 anchors.left: image.right; anchors.right: parent.right
4383 anchors.verticalCenter: parent.verticalCenter
4388 \bold Note: using implicitWidth of Text or TextEdit and setting the width explicitly
4389 incurs a performance penalty as the text must be laid out twice.
4393 Sets the implied width of the item to \a w.
4394 This is the width implied by other properties that determine the content.
4396 void QQuickItem::setImplicitWidth(qreal w)
4399 bool changed = w != d->implicitWidth;
4400 d->implicitWidth = w;
4401 if (d->width == w || widthValid()) {
4403 d->implicitWidthChanged();
4407 qreal oldWidth = d->width;
4410 d->dirty(QQuickItemPrivate::Size);
4412 geometryChanged(QRectF(x(), y(), width(), height()),
4413 QRectF(x(), y(), oldWidth, height()));
4416 d->implicitWidthChanged();
4420 Returns whether the width property has been set explicitly.
4422 bool QQuickItem::widthValid() const
4424 Q_D(const QQuickItem);
4425 return d->widthValid;
4428 qreal QQuickItem::height() const
4430 Q_D(const QQuickItem);
4434 void QQuickItem::setHeight(qreal h)
4440 d->heightValid = true;
4444 qreal oldHeight = d->height;
4447 d->dirty(QQuickItemPrivate::Size);
4449 geometryChanged(QRectF(x(), y(), width(), height()),
4450 QRectF(x(), y(), width(), oldHeight));
4453 void QQuickItem::resetHeight()
4456 d->heightValid = false;
4457 setImplicitHeight(implicitHeight());
4460 void QQuickItemPrivate::implicitHeightChanged()
4463 emit q->implicitHeightChanged();
4466 qreal QQuickItemPrivate::getImplicitHeight() const
4468 return implicitHeight;
4472 Returns the height of the item that is implied by other properties that determine the content.
4474 qreal QQuickItem::implicitHeight() const
4476 Q_D(const QQuickItem);
4477 return d->getImplicitHeight();
4482 Sets the implied height of the item to \a h.
4483 This is the height implied by other properties that determine the content.
4485 void QQuickItem::setImplicitHeight(qreal h)
4488 bool changed = h != d->implicitHeight;
4489 d->implicitHeight = h;
4490 if (d->height == h || heightValid()) {
4492 d->implicitHeightChanged();
4496 qreal oldHeight = d->height;
4499 d->dirty(QQuickItemPrivate::Size);
4501 geometryChanged(QRectF(x(), y(), width(), height()),
4502 QRectF(x(), y(), width(), oldHeight));
4505 d->implicitHeightChanged();
4508 void QQuickItem::setImplicitSize(qreal w, qreal h)
4511 bool wChanged = w != d->implicitWidth;
4512 bool hChanged = h != d->implicitHeight;
4514 d->implicitWidth = w;
4515 d->implicitHeight = h;
4519 if (d->width == w || widthValid()) {
4521 d->implicitWidthChanged();
4524 if (d->height == h || heightValid()) {
4526 d->implicitHeightChanged();
4532 qreal oldWidth = d->width;
4533 qreal oldHeight = d->height;
4539 d->dirty(QQuickItemPrivate::Size);
4541 geometryChanged(QRectF(x(), y(), width(), height()),
4542 QRectF(x(), y(), oldWidth, oldHeight));
4544 if (!wDone && wChanged)
4545 d->implicitWidthChanged();
4546 if (!hDone && hChanged)
4547 d->implicitHeightChanged();
4551 Returns whether the height property has been set explicitly.
4553 bool QQuickItem::heightValid() const
4555 Q_D(const QQuickItem);
4556 return d->heightValid;
4559 void QQuickItem::setSize(const QSizeF &size)
4562 d->heightValid = true;
4563 d->widthValid = true;
4565 if (QSizeF(d->width, d->height) == size)
4568 qreal oldHeight = d->height;
4569 qreal oldWidth = d->width;
4570 d->height = size.height();
4571 d->width = size.width();
4573 d->dirty(QQuickItemPrivate::Size);
4575 geometryChanged(QRectF(x(), y(), width(), height()),
4576 QRectF(x(), y(), oldWidth, oldHeight));
4579 bool QQuickItem::hasActiveFocus() const
4581 Q_D(const QQuickItem);
4582 return d->activeFocus;
4585 bool QQuickItem::hasFocus() const
4587 Q_D(const QQuickItem);
4591 void QQuickItem::setFocus(bool focus)
4594 if (d->focus == focus)
4598 // Need to find our nearest focus scope
4599 QQuickItem *scope = parentItem();
4600 while (scope && !scope->isFocusScope())
4601 scope = scope->parentItem();
4603 QQuickCanvasPrivate::get(d->canvas)->setFocusInScope(scope, this);
4605 QQuickCanvasPrivate::get(d->canvas)->clearFocusInScope(scope, this);
4608 emit focusChanged(focus);
4612 bool QQuickItem::isFocusScope() const
4614 return flags() & ItemIsFocusScope;
4617 QQuickItem *QQuickItem::scopedFocusItem() const
4619 Q_D(const QQuickItem);
4620 if (!isFocusScope())
4623 return d->subFocusItem;
4627 Qt::MouseButtons QQuickItem::acceptedMouseButtons() const
4629 Q_D(const QQuickItem);
4630 return d->acceptedMouseButtons;
4633 void QQuickItem::setAcceptedMouseButtons(Qt::MouseButtons buttons)
4636 d->acceptedMouseButtons = buttons;
4639 bool QQuickItem::filtersChildMouseEvents() const
4641 Q_D(const QQuickItem);
4642 return d->filtersChildMouseEvents;
4645 void QQuickItem::setFiltersChildMouseEvents(bool filter)
4648 d->filtersChildMouseEvents = filter;
4651 bool QQuickItem::isUnderMouse() const
4653 Q_D(const QQuickItem);
4657 QPoint cursorPos = QCursor::pos();
4658 if (QRectF(0, 0, width(), height()).contains(mapFromScene(cursorPos))) // ### refactor: d->canvas->mapFromGlobal(cursorPos))))
4663 bool QQuickItem::acceptHoverEvents() const
4665 Q_D(const QQuickItem);
4666 return d->hoverEnabled;
4669 void QQuickItem::setAcceptHoverEvents(bool enabled)
4672 d->hoverEnabled = enabled;
4675 void QQuickItem::grabMouse()
4680 QQuickCanvasPrivate *canvasPriv = QQuickCanvasPrivate::get(d->canvas);
4681 if (canvasPriv->mouseGrabberItem == this)
4684 QQuickItem *oldGrabber = canvasPriv->mouseGrabberItem;
4685 canvasPriv->mouseGrabberItem = this;
4687 oldGrabber->mouseUngrabEvent();
4690 void QQuickItem::ungrabMouse()
4695 QQuickCanvasPrivate *canvasPriv = QQuickCanvasPrivate::get(d->canvas);
4696 if (canvasPriv->mouseGrabberItem != this) {
4697 qWarning("QQuickItem::ungrabMouse(): Item is not the mouse grabber.");
4701 canvasPriv->mouseGrabberItem = 0;
4705 bool QQuickItem::keepMouseGrab() const
4707 Q_D(const QQuickItem);
4708 return d->keepMouse;
4712 The flag indicating whether the mouse should remain
4713 with this item is set to \a keep.
4715 This is useful for items that wish to grab and keep mouse
4716 interaction following a predefined gesture. For example,
4717 an item that is interested in horizontal mouse movement
4718 may set keepMouseGrab to true once a threshold has been
4719 exceeded. Once keepMouseGrab has been set to true, filtering
4720 items will not react to mouse events.
4722 If the item does not indicate that it wishes to retain mouse grab,
4723 a filtering item may steal the grab. For example, Flickable may attempt
4724 to steal a mouse grab if it detects that the user has begun to
4729 void QQuickItem::setKeepMouseGrab(bool keep)
4732 d->keepMouse = keep;
4736 Grabs the touch points specified by \a ids.
4738 These touch points will be owned by the item until
4739 they are released. Alternatively, the grab can be stolen
4740 by a filtering item like Flickable. Use setKeepTouchGrab()
4741 to prevent the grab from being stolen.
4743 \sa ungrabTouchPoints(), setKeepTouchGrab()
4745 void QQuickItem::grabTouchPoints(const QList<int> &ids)
4750 QQuickCanvasPrivate *canvasPriv = QQuickCanvasPrivate::get(d->canvas);
4752 QSet<QQuickItem*> ungrab;
4753 for (int i = 0; i < ids.count(); ++i) {
4754 QQuickItem *oldGrabber = canvasPriv->itemForTouchPointId.value(ids.at(i));
4755 if (oldGrabber == this)
4758 canvasPriv->itemForTouchPointId[ids.at(i)] = this;
4760 ungrab.insert(oldGrabber);
4762 foreach (QQuickItem *oldGrabber, ungrab)
4763 oldGrabber->touchUngrabEvent();
4767 Ungrabs the touch points owned by this item.
4769 \sa grabTouchPoints()
4771 void QQuickItem::ungrabTouchPoints()
4776 QQuickCanvasPrivate *canvasPriv = QQuickCanvasPrivate::get(d->canvas);
4778 QMutableHashIterator<int, QQuickItem*> i(canvasPriv->itemForTouchPointId);
4779 while (i.hasNext()) {
4781 if (i.value() == this)
4788 Returns a value indicating whether the touch points grabbed by this item
4789 should remain with this item exclusively.
4791 \sa setKeepTouchGrab(), keepMouseGrab()
4793 bool QQuickItem::keepTouchGrab() const
4795 Q_D(const QQuickItem);
4796 return d->keepTouch;
4800 The flag indicating whether the touch points grabbed
4801 by this item should remain with this item is set to \a keep.
4803 This is useful for items that wish to grab and keep specific touch
4804 points following a predefined gesture. For example,
4805 an item that is interested in horizontal touch point movement
4806 may set setKeepTouchGrab to true once a threshold has been
4807 exceeded. Once setKeepTouchGrab has been set to true, filtering
4808 items will not react to the relevant touch points.
4810 If the item does not indicate that it wishes to retain touch point grab,
4811 a filtering item may steal the grab. For example, Flickable may attempt
4812 to steal a touch point grab if it detects that the user has begun to
4815 \sa keepTouchGrab(), setKeepMouseGrab()
4817 void QQuickItem::setKeepTouchGrab(bool keep)
4820 d->keepTouch = keep;
4824 \qmlmethod object QtQuick2::Item::mapFromItem(Item item, real x, real y)
4826 Maps the point (\a x, \a y), which is in \a item's coordinate system, to
4827 this item's coordinate system, and returns an object with \c x and \c y
4828 properties matching the mapped coordinate.
4830 If \a item is a \c null value, this maps the point from the coordinate
4831 system of the root QML view.
4834 \qmlmethod object QtQuick2::Item::mapToItem(Item item, real x, real y)
4836 Maps the point (\a x, \a y), which is in this item's coordinate system, to
4837 \a item's coordinate system, and returns an object with \c x and \c y
4838 properties matching the mapped coordinate.
4840 If \a item is a \c null value, this maps \a x and \a y to the coordinate
4841 system of the root QML view.
4843 QPointF QQuickItem::mapToItem(const QQuickItem *item, const QPointF &point) const
4845 QPointF p = mapToScene(point);
4847 p = item->mapFromScene(p);
4851 QPointF QQuickItem::mapToScene(const QPointF &point) const
4853 Q_D(const QQuickItem);
4854 return d->itemToCanvasTransform().map(point);
4857 QRectF QQuickItem::mapRectToItem(const QQuickItem *item, const QRectF &rect) const
4859 Q_D(const QQuickItem);
4860 QTransform t = d->itemToCanvasTransform();
4862 t *= QQuickItemPrivate::get(item)->canvasToItemTransform();
4863 return t.mapRect(rect);
4866 QRectF QQuickItem::mapRectToScene(const QRectF &rect) const
4868 Q_D(const QQuickItem);
4869 return d->itemToCanvasTransform().mapRect(rect);
4872 QPointF QQuickItem::mapFromItem(const QQuickItem *item, const QPointF &point) const
4874 QPointF p = item?item->mapToScene(point):point;
4875 return mapFromScene(p);
4878 QPointF QQuickItem::mapFromScene(const QPointF &point) const
4880 Q_D(const QQuickItem);
4881 return d->canvasToItemTransform().map(point);
4884 QRectF QQuickItem::mapRectFromItem(const QQuickItem *item, const QRectF &rect) const
4886 Q_D(const QQuickItem);
4887 QTransform t = item?QQuickItemPrivate::get(item)->itemToCanvasTransform():QTransform();
4888 t *= d->canvasToItemTransform();
4889 return t.mapRect(rect);
4892 QRectF QQuickItem::mapRectFromScene(const QRectF &rect) const
4894 Q_D(const QQuickItem);
4895 return d->canvasToItemTransform().mapRect(rect);
4900 \qmlmethod QtQuick2::Item::forceActiveFocus()
4902 Forces active focus on the item.
4904 This method sets focus on the item and makes sure that all the focus scopes
4905 higher in the object hierarchy are also given the focus.
4909 Forces active focus on the item.
4911 This method sets focus on the item and makes sure that all the focus scopes
4912 higher in the object hierarchy are also given the focus.
4916 \qmlmethod QtQuick2::Item::childAt(real x, real y)
4918 Returns the visible child item at point (\a x, \a y), which is in this
4919 item's coordinate system, or \c null if there is no such item.
4923 Returns the visible child item at point (\a x, \a y), which is in this
4924 item's coordinate system, or 0 if there is no such item.
4928 \qmlproperty list<State> QtQuick2::Item::states
4929 This property holds a list of states defined by the item.
4945 \sa {qmlstate}{States}
4948 \qmlproperty list<Transition> QtQuick2::Item::transitions
4949 This property holds a list of transitions defined by the item.
4965 \sa {QML Animation and Transitions}{Transitions}
4968 \qmlproperty list<Filter> QtQuick2::Item::filter
4969 This property holds a list of graphical filters to be applied to the item.
4971 \l {Filter}{Filters} include things like \l {Blur}{blurring}
4972 the item, or giving it a \l Reflection. Some
4973 filters may not be available on all canvases; if a filter is not
4974 available on a certain canvas, it will simply not be applied for
4975 that canvas (but the QML will still be considered valid).
4993 \qmlproperty bool QtQuick2::Item::clip
4994 This property holds whether clipping is enabled. The default clip value is \c false.
4996 If clipping is enabled, an item will clip its own painting, as well
4997 as the painting of its children, to its bounding rectangle.
4999 Non-rectangular clipping regions are not supported for performance reasons.
5003 \property QQuickItem::clip
5004 This property holds whether clipping is enabled. The default clip value is \c false.
5006 If clipping is enabled, an item will clip its own painting, as well
5007 as the painting of its children, to its bounding rectangle. If you set
5008 clipping during an item's paint operation, remember to re-set it to
5009 prevent clipping the rest of your scene.
5011 Non-rectangular clipping regions are not supported for performance reasons.
5015 \qmlproperty string QtQuick2::Item::state
5017 This property holds the name of the current state of the item.
5019 This property is often used in scripts to change between states. For
5024 if (button.state == 'On')
5025 button.state = 'Off';
5027 button.state = 'On';
5031 If the item is in its base state (i.e. no explicit state has been
5032 set), \c state will be a blank string. Likewise, you can return an
5033 item to its base state by setting its current state to \c ''.
5035 \sa {qmlstates}{States}
5039 \qmlproperty list<Transform> QtQuick2::Item::transform
5040 This property holds the list of transformations to apply.
5042 For more information see \l Transform.
5046 \enum QQuickItem::TransformOrigin
5048 Controls the point about which simple transforms like scale apply.
5050 \value TopLeft The top-left corner of the item.
5051 \value Top The center point of the top of the item.
5052 \value TopRight The top-right corner of the item.
5053 \value Left The left most point of the vertical middle.
5054 \value Center The center of the item.
5055 \value Right The right most point of the vertical middle.
5056 \value BottomLeft The bottom-left corner of the item.
5057 \value Bottom The center point of the bottom of the item.
5058 \value BottomRight The bottom-right corner of the item.
5063 \qmlproperty bool QtQuick2::Item::activeFocus
5065 This property indicates whether the item has active focus.
5067 An item with active focus will receive keyboard input,
5068 or is a FocusScope ancestor of the item that will receive keyboard input.
5070 Usually, activeFocus is gained by setting focus on an item and its enclosing
5071 FocusScopes. In the following example \c input will have activeFocus.
5084 \sa focus, {qmlfocus}{Keyboard Focus}
5088 \qmlproperty bool QtQuick2::Item::focus
5089 This property indicates whether the item has focus within the enclosing focus scope. If true, this item
5090 will gain active focus when the enclosing focus scope gains active focus.
5091 In the following example, \c input will be given active focus when \c scope gains active focus.
5104 For the purposes of this property, the scene as a whole is assumed to act like a focus scope.
5105 On a practical level, that means the following QML will give active focus to \c input on startup.
5116 \sa activeFocus, {qmlfocus}{Keyboard Focus}
5121 \property QQuickItem::anchors
5126 \property QQuickItem::left
5131 \property QQuickItem::right
5136 \property QQuickItem::horizontalCenter
5141 \property QQuickItem::top
5146 \property QQuickItem::bottom
5151 \property QQuickItem::verticalCenter
5156 \property QQuickItem::focus
5161 \property QQuickItem::transform
5166 \property QQuickItem::transformOrigin
5171 \property QQuickItem::activeFocus
5176 \property QQuickItem::baseline
5181 \property QQuickItem::data
5186 \property QQuickItem::resources
5191 \property QQuickItem::state
5196 \property QQuickItem::states
5201 \property QQuickItem::transformOriginPoint
5206 \property QQuickItem::transitions
5210 bool QQuickItem::event(QEvent *ev)
5213 if (ev->type() == QEvent::PolishRequest) {
5215 d->polishScheduled = false;
5219 return QObject::event(ev);
5222 if (ev->type() == QEvent::InputMethodQuery) {
5223 QInputMethodQueryEvent *query = static_cast<QInputMethodQueryEvent *>(ev);
5224 Qt::InputMethodQueries queries = query->queries();
5225 for (uint i = 0; i < 32; ++i) {
5226 Qt::InputMethodQuery q = (Qt::InputMethodQuery)(int)(queries & (1<<i));
5228 QVariant v = inputMethodQuery(q);
5229 query->setValue(q, v);
5234 } else if (ev->type() == QEvent::InputMethod) {
5235 inputMethodEvent(static_cast<QInputMethodEvent *>(ev));
5238 return QObject::event(ev);
5241 #ifndef QT_NO_DEBUG_STREAM
5242 QDebug operator<<(QDebug debug, QQuickItem *item)
5245 debug << "QQuickItem(0)";
5249 debug << item->metaObject()->className() << "(this =" << ((void*)item)
5250 << ", name=" << item->objectName()
5251 << ", parent =" << ((void*)item->parentItem())
5252 << ", geometry =" << QRectF(item->pos(), QSizeF(item->width(), item->height()))
5253 << ", z =" << item->z() << ')';
5258 qint64 QQuickItemPrivate::consistentTime = -1;
5259 void QQuickItemPrivate::setConsistentTime(qint64 t)
5264 class QElapsedTimerConsistentTimeHack
5268 t1 = QQuickItemPrivate::consistentTime;
5272 return QQuickItemPrivate::consistentTime - t1;
5275 qint64 val = QQuickItemPrivate::consistentTime - t1;
5276 t1 = QQuickItemPrivate::consistentTime;
5286 void QQuickItemPrivate::start(QElapsedTimer &t)
5288 if (QQuickItemPrivate::consistentTime == -1)
5291 ((QElapsedTimerConsistentTimeHack*)&t)->start();
5294 qint64 QQuickItemPrivate::elapsed(QElapsedTimer &t)
5296 if (QQuickItemPrivate::consistentTime == -1)
5299 return ((QElapsedTimerConsistentTimeHack*)&t)->elapsed();
5302 qint64 QQuickItemPrivate::restart(QElapsedTimer &t)
5304 if (QQuickItemPrivate::consistentTime == -1)
5307 return ((QElapsedTimerConsistentTimeHack*)&t)->restart();
5311 \fn bool QQuickItem::isTextureProvider() const
5313 Returns true if this item is a texture provider. The default
5314 implementation returns false.
5316 This function can be called from any thread.
5319 bool QQuickItem::isTextureProvider() const
5321 Q_D(const QQuickItem);
5322 return d->_layer && d->_layer->effectSource() ? d->_layer->effectSource()->isTextureProvider() : false;
5326 \fn QSGTextureProvider *QQuickItem::textureProvider() const
5328 Returns the texture provider for an item. The default implementation
5331 This function may only be called on the rendering thread.
5334 QSGTextureProvider *QQuickItem::textureProvider() const
5336 Q_D(const QQuickItem);
5337 return d->_layer && d->_layer->effectSource() ? d->_layer->effectSource()->textureProvider() : 0;
5342 QQuickItemLayer *QQuickItemPrivate::layer() const
5345 _layer = new QQuickItemLayer(const_cast<QQuickItem *>(q_func()));
5351 QQuickItemLayer::QQuickItemLayer(QQuickItem *item)
5356 , m_componentComplete(true)
5357 , m_wrapMode(QQuickShaderEffectSource::ClampToEdge)
5358 , m_format(QQuickShaderEffectSource::RGBA)
5359 , m_effectComponent(0)
5363 m_name = QLatin1String("source");
5366 QQuickItemLayer::~QQuickItemLayer()
5368 delete m_effectSource;
5375 \qmlproperty bool QtQuick2::Item::layer.enabled
5377 Holds wether the item is layered or not. Layering is disabled by default.
5379 A layered item is rendered into an offscreen surface and cached until
5380 it is changed. Enabling layering for complex QML item hierarchies can
5381 some times be an optimization.
5383 None of the other layer properties have any effect when the layer
5387 void QQuickItemLayer::setEnabled(bool e)
5392 if (m_componentComplete) {
5399 emit enabledChanged(e);
5402 void QQuickItemLayer::classBegin()
5404 m_componentComplete = false;
5407 void QQuickItemLayer::componentComplete()
5409 m_componentComplete = true;
5414 void QQuickItemLayer::activate()
5416 QQuickItem *parentItem = m_item->parentItem();
5417 if (!m_effectSource)
5418 m_effectSource = new QQuickShaderEffectSource();
5421 m_effectSource->setParentItem(parentItem);
5422 m_effectSource->stackAfter(m_item);
5425 m_effectSource->setVisible(!m_effectComponent && m_item->isVisible());
5426 m_effectSource->setSourceItem(m_item);
5427 m_effectSource->setHideSource(true);
5428 m_effectSource->setSmooth(m_smooth);
5429 m_effectSource->setTextureSize(m_size);
5430 m_effectSource->setSourceRect(m_sourceRect);
5431 m_effectSource->setMipmap(m_mipmap);
5432 m_effectSource->setWrapMode(m_wrapMode);
5433 m_effectSource->setFormat(m_format);
5435 if (m_effectComponent) {
5437 QObject *created = m_effectComponent->create();
5438 m_effect = qobject_cast<QQuickShaderEffect *>(created);
5440 qWarning("Item: layer.effect is not a shader effect");
5446 m_effect->setParentItem(parentItem);
5447 m_effect->stackAfter(m_effectSource);
5449 m_effect->setVisible(m_item->isVisible());
5450 m_effect->setProperty(m_name.toLatin1(), qVariantFromValue<QObject *>(m_effectSource));
5460 QQuickItemPrivate *id = QQuickItemPrivate::get(m_item);
5461 id->addItemChangeListener(this, QQuickItemPrivate::Geometry | QQuickItemPrivate::Opacity | QQuickItemPrivate::Parent | QQuickItemPrivate::Visibility | QQuickItemPrivate::SiblingOrder);
5464 void QQuickItemLayer::deactivate()
5466 delete m_effectSource;
5472 QQuickItemPrivate *id = QQuickItemPrivate::get(m_item);
5473 id->removeItemChangeListener(this, QQuickItemPrivate::Geometry | QQuickItemPrivate::Opacity | QQuickItemPrivate::Parent | QQuickItemPrivate::Visibility | QQuickItemPrivate::SiblingOrder);
5479 \qmlproperty Component QtQuick2::Item::layer.effect
5481 Holds the effect that is applied to this layer.
5483 The effect must be a \l ShaderEffect.
5486 void QQuickItemLayer::setEffect(QDeclarativeComponent *component)
5488 if (component == m_effectComponent)
5490 m_effectComponent = component;
5500 emit effectChanged(component);
5505 \qmlproperty bool QtQuick2::Item::layer.mipmap
5507 If this property is true, mipmaps are generated for the texture.
5509 \note Some OpenGL ES 2 implementations do not support mipmapping of
5510 non-power-of-two textures.
5513 void QQuickItemLayer::setMipmap(bool mipmap)
5515 if (mipmap == m_mipmap)
5520 m_effectSource->setMipmap(m_mipmap);
5522 emit mipmapChanged(mipmap);
5527 \qmlproperty enumeration QtQuick2::Item::layer.format
5529 This property defines the internal OpenGL format of the texture.
5530 Modifying this property makes most sense when the \a layer.effect is also
5531 specified. Depending on the OpenGL implementation, this property might
5532 allow you to save some texture memory.
5535 \o ShaderEffectSource.Alpha - GL_ALPHA
5536 \o ShaderEffectSource.RGB - GL_RGB
5537 \o ShaderEffectSource.RGBA - GL_RGBA
5540 \note Some OpenGL implementations do not support the GL_ALPHA format.
5543 void QQuickItemLayer::setFormat(QQuickShaderEffectSource::Format f)
5550 m_effectSource->setFormat(m_format);
5552 emit formatChanged(m_format);
5557 \qmlproperty enumeration QtQuick2::Item::layer.sourceRect
5559 This property defines which rectangular area of the \l sourceItem to
5560 render into the texture. The source rectangle can be larger than
5561 \l sourceItem itself. If the rectangle is null, which is the default,
5562 the whole \l sourceItem is rendered to texture.
5565 void QQuickItemLayer::setSourceRect(const QRectF &sourceRect)
5567 if (sourceRect == m_sourceRect)
5569 m_sourceRect = sourceRect;
5572 m_effectSource->setSourceRect(m_sourceRect);
5574 emit sourceRectChanged(sourceRect);
5580 \qmlproperty bool QtQuick2::Item::layer.smooth
5582 Holds whether the layer is smoothly transformed.
5585 void QQuickItemLayer::setSmooth(bool s)
5592 m_effectSource->setSmooth(m_smooth);
5594 emit smoothChanged(s);
5600 \qmlproperty size QtQuick2::Item::layer.textureSize
5602 This property holds the requested pixel size of the layers texture. If it is empty,
5603 which is the default, the size of the item is used.
5605 \note Some platforms have a limit on how small framebuffer objects can be,
5606 which means the actual texture size might be larger than the requested
5610 void QQuickItemLayer::setSize(const QSize &size)
5617 m_effectSource->setTextureSize(size);
5619 emit sizeChanged(size);
5625 \qmlproperty enumeration QtQuick2::Item::layer.wrapMode
5627 This property defines the OpenGL wrap modes associated with the texture.
5628 Modifying this property makes most sense when the \a layer.effect is
5632 \o ShaderEffectSource.ClampToEdge - GL_CLAMP_TO_EDGE both horizontally and vertically
5633 \o ShaderEffectSource.RepeatHorizontally - GL_REPEAT horizontally, GL_CLAMP_TO_EDGE vertically
5634 \o ShaderEffectSource.RepeatVertically - GL_CLAMP_TO_EDGE horizontally, GL_REPEAT vertically
5635 \o ShaderEffectSource.Repeat - GL_REPEAT both horizontally and vertically
5638 \note Some OpenGL ES 2 implementations do not support the GL_REPEAT
5639 wrap mode with non-power-of-two textures.
5642 void QQuickItemLayer::setWrapMode(QQuickShaderEffectSource::WrapMode mode)
5644 if (mode != m_wrapMode)
5649 m_effectSource->setWrapMode(m_wrapMode);
5651 emit wrapModeChanged(mode);
5655 void QQuickItemLayer::itemOpacityChanged(QQuickItem *item)
5660 void QQuickItemLayer::itemGeometryChanged(QQuickItem *, const QRectF &, const QRectF &)
5665 void QQuickItemLayer::itemParentChanged(QQuickItem *item, QQuickItem *parent)
5667 if (parent == m_effectSource || parent == m_effect)
5670 m_effectSource->setParentItem(parent);
5672 m_effectSource->stackAfter(m_item);
5675 m_effect->setParentItem(parent);
5677 m_effect->stackAfter(m_effectSource);
5681 void QQuickItemLayer::itemSiblingOrderChanged(QQuickItem *)
5683 m_effectSource->stackAfter(m_item);
5685 m_effect->stackAfter(m_effectSource);
5688 void QQuickItemLayer::itemVisibilityChanged(QQuickItem *)
5690 QQuickItem *l = m_effect ? (QQuickItem *) m_effect : (QQuickItem *) m_effectSource;
5691 l->setVisible(m_item->isVisible());
5694 void QQuickItemLayer::updateZ()
5696 QQuickItem *l = m_effect ? (QQuickItem *) m_effect : (QQuickItem *) m_effectSource;
5697 l->setZ(m_item->z());
5700 void QQuickItemLayer::updateOpacity()
5702 QQuickItem *l = m_effect ? (QQuickItem *) m_effect : (QQuickItem *) m_effectSource;
5703 l->setOpacity(m_item->opacity());
5706 void QQuickItemLayer::updateGeometry()
5708 QQuickItem *l = m_effect ? (QQuickItem *) m_effect : (QQuickItem *) m_effectSource;
5709 QRectF bounds = m_item->boundingRect();
5710 l->setWidth(bounds.width());
5711 l->setHeight(bounds.height());
5712 l->setX(bounds.x() + m_item->x());
5713 l->setY(bounds.y() + m_item->y());
5716 void QQuickItemLayer::updateMatrix()
5718 // Called directly from transformChanged(), so needs some extra
5720 if (!m_componentComplete || !m_enabled)
5722 QQuickItem *l = m_effect ? (QQuickItem *) m_effect : (QQuickItem *) m_effectSource;
5723 QQuickItemPrivate *ld = QQuickItemPrivate::get(l);
5724 l->setScale(m_item->scale());
5725 l->setRotation(m_item->rotation());
5726 ld->transforms = QQuickItemPrivate::get(m_item)->transforms;
5727 ld->origin = QQuickItemPrivate::get(m_item)->origin;
5728 ld->dirty(QQuickItemPrivate::Transform);
5733 #include <moc_qquickitem.cpp>