FCL/sf/mw/qt: comparison src/declarative/graphicsitems/qdeclarativeitem.cpp

equal deleted inserted replaced

-:ef0373b55136
+:758a864f9613
 QT_BEGIN_NAMESPACE
 /*!
 \qmlclass Transform QGraphicsTransform
+\ingroup qml-transform-elements
 \since 4.7
 \brief The Transform elements provide a way of building advanced transformations on Items.
 The Transform element is a base type which cannot be instantiated directly.
 The following concrete Transform types are available:
 one at a time.
 */
 /*!
 \qmlclass Translate QDeclarativeTranslate
+\ingroup qml-transform-elements
 \since 4.7
 \brief The Translate object provides a way to move an Item without changing its x or y properties.
 The Translate object provides independent control over position in addition to the Item's x and y properties.
 The translation along the Y axis.
 */
 /*!
 \qmlclass Scale QGraphicsScale
+\ingroup qml-transform-elements
 \since 4.7
 \brief The Scale element provides a way to scale an Item.
 The Scale element gives more control over scaling than using \l Item's \l{Item::scale}{scale} property. Specifically,
 it allows a different scale for the x and y axes, and allows the scale to be relative to an
 The scaling factor for the Y axis.
 */
 /*!
 \qmlclass Rotation QGraphicsRotation
+\ingroup qml-transform-elements
 \since 4.7
 \brief The Rotation object provides a way to rotate an Item.
 The Rotation object gives more control over rotation than using \l Item's \l{Item::rotation}{rotation} property.
 Specifically, it allows (z axis) rotation to be relative to an arbitrary point.
 \qmlproperty real Rotation::angle
 The angle to rotate, in degrees clockwise.
 */
-/*!
-\internal
-\class QDeclarativeContents
-\brief The QDeclarativeContents class gives access to the height and width of an item's contents.
-*/
 QDeclarativeContents::QDeclarativeContents(QDeclarativeItem *item) : m_item(item), m_x(0), m_y(0), m_width(0), m_height(0)
 {
 //### optimize
 connect(this, SIGNAL(rectChanged(QRectF)), m_item, SIGNAL(childrenRectChanged(QRectF)));
 }
 }
 /*!
 \qmlclass KeyNavigation QDeclarativeKeyNavigationAttached
+\ingroup qml-basic-interaction-elements
 \since 4.7
 \brief The KeyNavigation attached property supports key navigation by arrow keys.
 It is common in key-based UIs to use arrow keys to navigate
-between focussed items.  The KeyNavigation property provides a
+between focused items.  The KeyNavigation property provides a
 convenient way of specifying which item will gain focus
 when an arrow key is pressed.  The following example provides
 key navigation for a 2x2 grid of items.
 \code
 }
 void QDeclarativeKeyNavigationAttached::setLeft(QDeclarativeItem *i)
 {
 Q_D(QDeclarativeKeyNavigationAttached);
+if (d->left == i)
+return;
 d->left = i;
-emit changed();
+emit leftChanged();
 }
 QDeclarativeItem *QDeclarativeKeyNavigationAttached::right() const
 {
 Q_D(const QDeclarativeKeyNavigationAttached);
 }
 void QDeclarativeKeyNavigationAttached::setRight(QDeclarativeItem *i)
 {
 Q_D(QDeclarativeKeyNavigationAttached);
+if (d->right == i)
+return;
 d->right = i;
-emit changed();
+emit rightChanged();
 }
 QDeclarativeItem *QDeclarativeKeyNavigationAttached::up() const
 {
 Q_D(const QDeclarativeKeyNavigationAttached);
 }
 void QDeclarativeKeyNavigationAttached::setUp(QDeclarativeItem *i)
 {
 Q_D(QDeclarativeKeyNavigationAttached);
+if (d->up == i)
+return;
 d->up = i;
-emit changed();
+emit upChanged();
 }
 QDeclarativeItem *QDeclarativeKeyNavigationAttached::down() const
 {
 Q_D(const QDeclarativeKeyNavigationAttached);
 }
 void QDeclarativeKeyNavigationAttached::setDown(QDeclarativeItem *i)
 {
 Q_D(QDeclarativeKeyNavigationAttached);
+if (d->down == i)
+return;
 d->down = i;
-emit changed();
+emit downChanged();
 }
 QDeclarativeItem *QDeclarativeKeyNavigationAttached::tab() const
 {
 Q_D(const QDeclarativeKeyNavigationAttached);
 }
 void QDeclarativeKeyNavigationAttached::setTab(QDeclarativeItem *i)
 {
 Q_D(QDeclarativeKeyNavigationAttached);
+if (d->tab == i)
+return;
 d->tab = i;
-emit changed();
+emit tabChanged();
 }
 QDeclarativeItem *QDeclarativeKeyNavigationAttached::backtab() const
 {
 Q_D(const QDeclarativeKeyNavigationAttached);
 }
 void QDeclarativeKeyNavigationAttached::setBacktab(QDeclarativeItem *i)
 {
 Q_D(QDeclarativeKeyNavigationAttached);
+if (d->backtab == i)
+return;
 d->backtab = i;
-emit changed();
+emit backtabChanged();
 }
 /*!
 \qmlproperty enumeration KeyNavigation::priority
 if (!event->isAccepted()) QDeclarativeItemKeyFilter::keyReleased(event, post);
 }
 /*!
 \qmlclass Keys QDeclarativeKeysAttached
+\ingroup qml-basic-interaction-elements
 \since 4.7
 \brief The Keys attached property provides key handling to Items.
 All visual primitives support key handling via the \e Keys
 attached property.  Keys can be handled via the \e onPressed
 */
 /*!
 \qmlclass Item QDeclarativeItem
+\ingroup qml-basic-visual-elements
 \since 4.7
 \brief The Item is the most basic of all visual items in QML.
 All visual items in Qt Declarative inherit from Item.  Although Item
 has no visual appearance, it defines all the properties that are
 \internal
 */
 /*! \fn void QDeclarativeItem::transformOriginChanged(TransformOrigin)
 \internal
-*/
-/*!
-\fn void QDeclarativeItem::childrenChanged()
-\internal
 */
 /*!
 \fn void QDeclarativeItem::focusChanged(bool)
 \internal
 data is a behind-the-scenes property: you should never need to explicitly
 specify it.
 */
-/*! \internal */
 QDeclarativeListProperty<QObject> QDeclarativeItemPrivate::data()
 {
 return QDeclarativeListProperty<QObject>(q_func(), 0, QDeclarativeItemPrivate::data_append);
 }
 } else {
 d->transformOriginDirty = true;
 }
 }
+for(int ii = 0; ii < d->changeListeners.count(); ++ii) {
+const QDeclarativeItemPrivate::ChangeListener &change = d->changeListeners.at(ii);
+if (change.types & QDeclarativeItemPrivate::Geometry)
+change.listener->itemGeometryChanged(this, newGeometry, oldGeometry);
+}
 if (newGeometry.x() != oldGeometry.x())
 emit xChanged();
 if (newGeometry.width() != oldGeometry.width())
 emit widthChanged();
 if (newGeometry.y() != oldGeometry.y())
 emit yChanged();
 if (newGeometry.height() != oldGeometry.height())
 emit heightChanged();
-for(int ii = 0; ii < d->changeListeners.count(); ++ii) {
-const QDeclarativeItemPrivate::ChangeListener &change = d->changeListeners.at(ii);
-if (change.types & QDeclarativeItemPrivate::Geometry)
-change.listener->itemGeometryChanged(this, newGeometry, oldGeometry);
-}
 }
 void QDeclarativeItemPrivate::removeItemChangeListener(QDeclarativeItemChangeListener *listener, ChangeTypes types)
 {
 ChangeListener change(listener, types);
 void QDeclarativeItemPrivate::focusChanged(bool flag)
 {
 Q_Q(QDeclarativeItem);
 if (!(flags & QGraphicsItem::ItemIsFocusScope) && parent)
 emit q->activeFocusChanged(flag);   //see also QDeclarativeItemPrivate::subFocusItemChange()
+emit q->focusChanged(flag);
-bool inScope = false;
+}
-QGraphicsItem *p = parent;
-while (p) {
-if (p->flags() & QGraphicsItem::ItemIsFocusScope) {
-inScope = true;
-break;
-}
-p = p->parentItem();
-}
-if (!inScope)
-emit q->focusChanged(flag);
-}
-/*! \internal */
 QDeclarativeListProperty<QObject> QDeclarativeItemPrivate::resources()
 {
 return QDeclarativeListProperty<QObject>(q_func(), 0, QDeclarativeItemPrivate::resources_append,
 QDeclarativeItemPrivate::resources_count,
 QDeclarativeItemPrivate::resources_at);
 \endqml
 \sa {qmlstate}{States}
 */
-/*! \internal */
 QDeclarativeListProperty<QDeclarativeState> QDeclarativeItemPrivate::states()
 {
 return _states()->statesProperty();
 }
 ...
 ]
 }
 \endqml
-\sa {state-transitions}{Transitions}
+\sa {qdeclarativeanimation.html#transitions}{QML Transitions}
 */
-/*! \internal */
 QDeclarativeListProperty<QDeclarativeTransition> QDeclarativeItemPrivate::transitions()
 {
 return _states()->transitionsProperty();
 }
 \qml
 Item {
 filter: [
 Blur { ... },
-Relection { ... }
+Reflection { ... }
 ...
 ]
 }
 \endqml
 */
 /*!
 \property QDeclarativeItem::clip
 This property holds whether clipping is enabled.
 if clipping is enabled, an item will clip its own painting, as well
-as the painting of its children, to its bounding rectangle.
+as the painting of its children, to its bounding rectangle. If you set
+clipping during an item's paint operation, remember to re-set it to
+prevent clipping the rest of your scene.
 Non-rectangular clipping regions are not supported for performance reasons.
 */
 /*!
 item to its base state by setting its current state to \c ''.
 \sa {qmlstates}{States}
 */
-/*! \internal */
 QString QDeclarativeItemPrivate::state() const
 {
 if (!_stateGroup)
 return QString();
 else
 return _stateGroup->state();
 }
-/*! \internal */
 void QDeclarativeItemPrivate::setState(const QString &state)
 {
 _states()->setState(state);
 }
 }
 }
 }
 break;
 case ItemChildAddedChange:
-if (d->_contents)
+if (d->_contents && d->componentComplete)
 d->_contents->childAdded(qobject_cast<QDeclarativeItem*>(
 value.value<QGraphicsItem*>()));
 break;
 case ItemChildRemovedChange:
-if (d->_contents)
+if (d->_contents && d->componentComplete)
 d->_contents->childRemoved(qobject_cast<QDeclarativeItem*>(
 value.value<QGraphicsItem*>()));
 break;
 default:
 break;
 emit smoothChanged(smooth);
 update();
 }
 /*!
+\property QDeclarativeItem::anchors
+\internal
+*/
+/*!
+\property QDeclarativeItem::left
+\internal
+*/
+/*!
+\property QDeclarativeItem::right
+\internal
+*/
+/*!
+\property QDeclarativeItem::horizontalCenter
+\internal
+*/
+/*!
+\property QDeclarativeItem::top
+\internal
+*/
+/*!
+\property QDeclarativeItem::bottom
+\internal
+*/
+/*!
+\property QDeclarativeItem::verticalCenter
+\internal
+*/
+/*!
 \property QDeclarativeItem::focus
 \internal
 */
 /*!
 \internal
 */
 /*!
 \property QDeclarativeItem::activeFocus
+\internal
+*/
+/*!
+\property QDeclarativeItem::baseline
+\internal
+*/
+/*!
+\property QDeclarativeItem::data
+\internal
+*/
+/*!
+\property QDeclarativeItem::resources
+\internal
+*/
+/*!
+\property QDeclarativeItem::state
+\internal
+*/
+/*!
+\property QDeclarativeItem::states
+\internal
+*/
+/*!
+\property QDeclarativeItem::transformOriginPoint
+\internal
+*/
+/*!
+\property QDeclarativeItem::transitions
 \internal
 */
 /*!
 \internal
 /*! \internal */
 bool QDeclarativeItem::hasActiveFocus() const
 {
 Q_D(const QDeclarativeItem);
 return focusItem() == this ||
-(d->flags & QGraphicsItem::ItemIsFocusScope && focusItem() != 0) ||
+(d->flags & QGraphicsItem::ItemIsFocusScope && focusItem() != 0);
-(!parentItem() && focusItem() != 0);
 }
 /*!
 \qmlproperty bool Item::focus
 This property indicates whether the item has focus within the enclosing focus scope. If true, this item
 }
 }
 }
 \endqml
-For the purposes of this property, the top level item in the scene
+For the purposes of this property, the scene as a whole is assumed to act like a focus scope.
-is assumed to act like a focus scope, and to always have active focus
+On a practical level, that means the following QML will give active focus to \c input on startup.
-when the scene has focus. On a practical level, that means the following
-QML will give active focus to \c input on startup.
 \qml
 Rectangle {
 TextInput {
 id: input
 return p->focusScopeItem() == this;
 }
 p = p->parentItem();
 }
-return hasActiveFocus() ? true : (!QGraphicsItem::parentItem() ? true : false);
+return hasActiveFocus();
 }
 /*! \internal */
 void QDeclarativeItem::setFocus(bool focus)
 {

changeset 37	758a864f9613
parent 33	3e2da88830cd