FCL/sf/mw/qt: comparison src/gui/graphicsview/qgraphicsitem.cpp

equal deleted inserted replaced

-:b72c6db6890b
+:5dc02b23752f
 \ingroup graphicsview-api
 It provides a light-weight foundation for writing your own custom items.
 This includes defining the item's geometry, collision detection, its
 painting implementation and item interaction through its event handlers.
-QGraphicsItem is part of \l{The Graphics View Framework}
+QGraphicsItem is part of the \l{Graphics View Framework}
 \image graphicsview-items.png
 For convenience, Qt provides a set of standard graphics items for the most
 common shapes. These are:
 in it using a key-value pair (the key being an integer, and the value is a
 QVariant). To get custom data from an item, call data(). This
 functionality is completely untouched by Qt itself; it is provided for the
 user's convenience.
-\sa QGraphicsScene, QGraphicsView, {The Graphics View Framework}
+\sa QGraphicsScene, QGraphicsView, {Graphics View Framework}
 */
 /*!
 \variable QGraphicsItem::Type
 do not need to be painted to ensure that Graphics View avoids unnecessary
 painting preparations. This flag was introduced in Qt 4.6.
 \value ItemSendsGeometryChanges The item enables itemChange()
 notifications for ItemPositionChange, ItemPositionHasChanged,
-ItemMatrixChange, ItemTransformChange, and ItemTransformHasChanged. For
+ItemMatrixChange, ItemTransformChange, ItemTransformHasChanged,
+ItemRotationChange, ItemRotationHasChanged, ItemScaleChange, ItemScaleHasChanged,
+ItemTransformOriginPointChange, and ItemTransformOriginPointHasChanged. For
 performance reasons, these notifications are disabled by default. You must
 enable this flag to receive notifications for position and transform
 changes. This flag was introduced in Qt 4.6.
 \value ItemAcceptsInputMethod The item supports input methods typically
 transformation properties is changed. This notification is sent if the
 ItemSendsGeometryChanges flag is enabled, and after the item's local
 transformation matrix has changed. The value argument is the new matrix
 (same as transform()), and QGraphicsItem ignores the return value for this
 notification (i.e., a read-only notification).
+\value ItemRotationChange The item's rotation property changes. This
+notification is sent if the ItemSendsGeometryChanges flag is enabled, and
+when the item's rotation property changes (i.e., as a result of calling
+setRotation()). The value argument is the new rotation (i.e., a double);
+to get the old rotation, call rotation(). Do not call setRotation() in
+itemChange() as this notification is delivered; instead, you can return
+the new rotation from itemChange().
+\value ItemRotationHasChanged The item's rotation property has changed.
+This notification is sent if the ItemSendsGeometryChanges flag is enabled,
+and after the item's rotation property has changed. The value argument is
+the new rotation (i.e., a double), and QGraphicsItem ignores the return
+value for this notification (i.e., a read-only notification). Do not call
+setRotation() in itemChange() as this notification is delivered.
+\value ItemScaleChange The item's scale property changes. This notification
+is sent if the ItemSendsGeometryChanges flag is enabled, and when the item's
+scale property changes (i.e., as a result of calling setScale()). The value
+argument is the new scale (i.e., a double); to get the old scale, call
+scale(). Do not call setScale() in itemChange() as this notification is
+delivered; instead, you can return the new scale from itemChange().
+\value ItemScaleHasChanged The item's scale property has changed. This
+notification is sent if the ItemSendsGeometryChanges flag is enabled, and
+after the item's scale property has changed. The value argument is the new
+scale (i.e., a double), and QGraphicsItem ignores the return value for this
+notification (i.e., a read-only notification). Do not call setScale() in
+itemChange() as this notification is delivered.
+\value ItemTransformOriginPointChange The item's transform origin point
+property changes. This notification is sent if the ItemSendsGeometryChanges
+flag is enabled, and when the item's transform origin point property changes
+(i.e., as a result of calling setTransformOriginPoint()). The value argument
+is the new origin point (i.e., a QPointF); to get the old origin point, call
+transformOriginPoint(). Do not call setTransformOriginPoint() in itemChange()
+as this notification is delivered; instead, you can return the new transform
+origin point from itemChange().
+\value ItemTransformOriginPointHasChanged The item's transform origin point
+property has changed. This notification is sent if the ItemSendsGeometryChanges
+flag is enabled, and after the item's transform origin point property has
+changed. The value argument is the new origin point (i.e., a QPointF), and
+QGraphicsItem ignores the return value for this notification (i.e., a read-only
+notification). Do not call setTransformOriginPoint() in itemChange() as this
+notification is delivered.
 \value ItemSelectedChange The item's selected state changes. If the item is
 presently selected, it will become unselected, and vice verca. The value
 argument is the new selected state (i.e., true or false). Do not call
 setSelected() in itemChange() as this notification is delivered; instead, you
 #include <QtCore/qpoint.h>
 #include <QtCore/qstack.h>
 #include <QtCore/qtimer.h>
 #include <QtCore/qvariant.h>
 #include <QtCore/qvarlengtharray.h>
+#include <QtCore/qnumeric.h>
 #include <QtGui/qapplication.h>
 #include <QtGui/qbitmap.h>
 #include <QtGui/qpainter.h>
 #include <QtGui/qpainterpath.h>
 #include <QtGui/qpixmapcache.h>
 #include <QtGui/qstyleoption.h>
 #include <QtGui/qevent.h>
 #include <QtGui/qinputcontext.h>
 #include <QtGui/qgraphicseffect.h>
+#ifndef QT_NO_ACCESSIBILITY
+# include "qaccessible.h"
+#endif
 #include <private/qgraphicsitem_p.h>
 #include <private/qgraphicswidget_p.h>
 #include <private/qtextcontrol_p.h>
 #include <private/qtextdocumentlayout_p.h>
 #include <private/qtextengine_p.h>
 #include <private/qwidget_p.h>
+#include <private/qapplication_p.h>
 #ifdef Q_WS_X11
 #include <private/qt_x11_p.h>
 #include <private/qpixmap_x11_p.h>
 #endif
 {
 Q_Q(QGraphicsItem);
 if (newParent == parent)
 return;
+if (isWidget)
+static_cast<QGraphicsWidgetPrivate *>(this)->fixFocusChainBeforeReparenting((newParent &&
+newParent->isWidget()) ? static_cast<QGraphicsWidget *>(newParent) : 0,
+scene);
 if (scene) {
 // Deliver the change to the index
 if (scene->d_func()->indexMethod != QGraphicsScene::NoIndex)
 scene->d_func()->index->itemChange(q, QGraphicsItem::ItemParentChange, newParent);
 setEnabledHelper(true, /* explicit = */ false);
 }
 }
 dirtySceneTransform = 1;
+if (!inDestructor && (transformData || (newParent && newParent->d_ptr->transformData)))
+transformChanged();
 // Restore the sub focus chain.
 if (subFocusItem) {
 subFocusItem->d_ptr->setSubFocus(newParent);
 if (parent && parent->isActive())
 \note It is more efficient to remove the item from the QGraphicsScene before
 destroying the item.
 */
 QGraphicsItem::~QGraphicsItem()
 {
-if (d_ptr->isObject)
+if (d_ptr->isObject) {
-QObjectPrivate::get(static_cast<QGraphicsObject *>(this))->wasDeleted = true;
+QGraphicsObject *o = static_cast<QGraphicsObject *>(this);
+QObjectPrivate *p = QObjectPrivate::get(o);
+p->wasDeleted = true;
+if (p->declarativeData) {
+QAbstractDeclarativeData::destroyed(p->declarativeData, o);
+p->declarativeData = 0;
+}
+}
 d_ptr->inDestructor = 1;
 d_ptr->removeExtraItemCache();
+if (d_ptr->isObject && !d_ptr->gestureContext.isEmpty()) {
+QGraphicsObject *o = static_cast<QGraphicsObject *>(this);
+QGestureManager *manager = QGestureManager::instance();
+foreach (Qt::GestureType type, d_ptr->gestureContext.keys())
+manager->cleanupCachedGestures(o, type);
+}
 clearFocus();
 // Update focus scope item ptr.
 QGraphicsItem *p = d_ptr->parent;
 \sa flags(), setFlag()
 */
 void QGraphicsItem::setFlags(GraphicsItemFlags flags)
 {
-if (isWindow())
-flags |= ItemIsPanel;
 // Notify change and check for adjustment.
 if (quint32(d_ptr->flags) == quint32(flags))
 return;
 flags = GraphicsItemFlags(itemChange(ItemFlagsChange, quint32(flags)).toUInt());
 if (quint32(d_ptr->flags) == quint32(flags))
 // Flags that alter the geometry of the item (or its children).
 const quint32 geomChangeFlagsMask = (ItemClipsChildrenToShape | ItemClipsToShape | ItemIgnoresTransformations | ItemIsSelectable);
 bool fullUpdate = (quint32(flags) & geomChangeFlagsMask) != (d_ptr->flags & geomChangeFlagsMask);
 if (fullUpdate)
-d_ptr->paintedViewBoundingRectsNeedRepaint = 1;
+d_ptr->updatePaintedViewBoundingRects(/*children=*/true);
 // Keep the old flags to compare the diff.
 GraphicsItemFlags oldFlags = GraphicsItemFlags(d_ptr->flags);
 // Update flags.
 void QGraphicsItem::setX(qreal x)
 {
 if (d_ptr->inDestructor)
 return;
-d_ptr->setPosHelper(QPointF(x, d_ptr->pos.y()));
+if (qIsNaN(x))
+return;
+setPos(QPointF(x, d_ptr->pos.y()));
 }
 /*!
 \fn QGraphicsItem::y() const
 void QGraphicsItem::setY(qreal y)
 {
 if (d_ptr->inDestructor)
 return;
-d_ptr->setPosHelper(QPointF(d_ptr->pos.x(), y));
+if (qIsNaN(y))
+return;
+setPos(QPointF(d_ptr->pos.x(), y));
 }
 /*!
 Returns the item's position in scene coordinates. This is
 equivalent to calling \c mapToScene(0, 0).
 void QGraphicsItemPrivate::setTransformHelper(const QTransform &transform)
 {
 q_ptr->prepareGeometryChange();
 transformData->transform = transform;
 dirtySceneTransform = 1;
+transformChanged();
 }
 /*!
 Sets the position of the item to \a pos, which is in parent
 coordinates.  For items with no parent, \a pos is in scene
 if (d_ptr->inDestructor)
 return;
 // Update and repositition.
-if (!(d_ptr->flags & ItemSendsGeometryChanges)) {
+if (!(d_ptr->flags & (ItemSendsGeometryChanges | ItemSendsScenePositionChanges))) {
 d_ptr->setPosHelper(pos);
 if (d_ptr->isWidget)
 static_cast<QGraphicsWidget *>(this)->d_func()->setGeometryFromSetPos();
 return;
 }
 \sa rotation(), setTransformOriginPoint(), {Transformations}
 */
 void QGraphicsItem::setRotation(qreal angle)
 {
 prepareGeometryChange();
+qreal newRotation = angle;
+if (d_ptr->flags & ItemSendsGeometryChanges) {
+// Notify the item that the rotation is changing.
+const QVariant newRotationVariant(itemChange(ItemRotationChange, angle));
+newRotation = newRotationVariant.toReal();
+}
 if (!d_ptr->transformData)
 d_ptr->transformData = new QGraphicsItemPrivate::TransformData;
-d_ptr->transformData->rotation = angle;
+if (d_ptr->transformData->rotation == newRotation)
+return;
+d_ptr->transformData->rotation = newRotation;
 d_ptr->transformData->onlyTransform = false;
 d_ptr->dirtySceneTransform = 1;
+// Send post-notification.
+if (d_ptr->flags & ItemSendsGeometryChanges)
+itemChange(ItemRotationHasChanged, newRotation);
 if (d_ptr->isObject)
 emit static_cast<QGraphicsObject *>(this)->rotationChanged();
+d_ptr->transformChanged();
 }
 /*!
 \since 4.6
 \sa scale(), setTransformOriginPoint(), {Transformations}
 */
 void QGraphicsItem::setScale(qreal factor)
 {
 prepareGeometryChange();
+qreal newScale = factor;
+if (d_ptr->flags & ItemSendsGeometryChanges) {
+// Notify the item that the scale is changing.
+const QVariant newScaleVariant(itemChange(ItemScaleChange, factor));
+newScale = newScaleVariant.toReal();
+}
 if (!d_ptr->transformData)
 d_ptr->transformData = new QGraphicsItemPrivate::TransformData;
-d_ptr->transformData->scale = factor;
+if (d_ptr->transformData->scale == newScale)
+return;
+d_ptr->transformData->scale = newScale;
 d_ptr->transformData->onlyTransform = false;
 d_ptr->dirtySceneTransform = 1;
+// Send post-notification.
+if (d_ptr->flags & ItemSendsGeometryChanges)
+itemChange(ItemScaleHasChanged, newScale);
 if (d_ptr->isObject)
 emit static_cast<QGraphicsObject *>(this)->scaleChanged();
+d_ptr->transformChanged();
 }
 /*!
 \since 4.6
 d_ptr->transformData->graphicsTransforms = transformations;
 for (int i = 0; i < transformations.size(); ++i)
 transformations.at(i)->d_func()->setItem(this);
 d_ptr->transformData->onlyTransform = false;
 d_ptr->dirtySceneTransform = 1;
+d_ptr->transformChanged();
+}
+/*!
+\internal
+*/
+void QGraphicsItemPrivate::prependGraphicsTransform(QGraphicsTransform *t)
+{
+if (!transformData)
+transformData = new QGraphicsItemPrivate::TransformData;
+if (!transformData->graphicsTransforms.contains(t))
+transformData->graphicsTransforms.prepend(t);
+Q_Q(QGraphicsItem);
+t->d_func()->setItem(q);
+transformData->onlyTransform = false;
+dirtySceneTransform = 1;
+transformChanged();
 }
 /*!
 \internal
 */
 Q_Q(QGraphicsItem);
 t->d_func()->setItem(q);
 transformData->onlyTransform = false;
 dirtySceneTransform = 1;
+transformChanged();
 }
 /*!
 \since 4.6
 \sa transformOriginPoint(), {Transformations}
 */
 void QGraphicsItem::setTransformOriginPoint(const QPointF &origin)
 {
 prepareGeometryChange();
+QPointF newOrigin = origin;
+if (d_ptr->flags & ItemSendsGeometryChanges) {
+// Notify the item that the origin point is changing.
+const QVariant newOriginVariant(itemChange(ItemTransformOriginPointChange,
+qVariantFromValue<QPointF>(origin)));
+newOrigin = newOriginVariant.toPointF();
+}
 if (!d_ptr->transformData)
 d_ptr->transformData = new QGraphicsItemPrivate::TransformData;
-d_ptr->transformData->xOrigin = origin.x();
-d_ptr->transformData->yOrigin = origin.y();
+if (d_ptr->transformData->xOrigin == newOrigin.x()
+&& d_ptr->transformData->yOrigin == newOrigin.y()) {
+return;
+}
+d_ptr->transformData->xOrigin = newOrigin.x();
+d_ptr->transformData->yOrigin = newOrigin.y();
 d_ptr->transformData->onlyTransform = false;
 d_ptr->dirtySceneTransform = 1;
+// Send post-notification.
+if (d_ptr->flags & ItemSendsGeometryChanges)
+itemChange(ItemTransformOriginPointHasChanged, qVariantFromValue<QPointF>(newOrigin));
 }
 /*!
 \fn void QGraphicsItem::setTransformOriginPoint(qreal x, qreal y)
 // number is equal to the size of the children list.
 ensureSequentialSiblingIndex();
 needSortChildren = 1; // ### maybe 0
 child->d_ptr->siblingIndex = children.size();
 children.append(child);
+if (isObject)
+emit static_cast<QGraphicsObject *>(q_ptr)->childrenChanged();
 }
 /*!
 \internal
 children.removeOne(child);
 // NB! Do not use children.removeAt(child->d_ptr->siblingIndex) because
 // the child is not guaranteed to be at the index after the list is sorted.
 // (see ensureSortedChildren()).
 child->d_ptr->siblingIndex = -1;
+if (isObject)
+emit static_cast<QGraphicsObject *>(q_ptr)->childrenChanged();
 }
 /*!
 \internal
 */
 if (c) {
 c->purge();
 delete c;
 }
 unsetExtra(ExtraCacheData);
+}
+void QGraphicsItemPrivate::updatePaintedViewBoundingRects(bool updateChildren)
+{
+if (!scene)
+return;
+for (int i = 0; i < scene->d_func()->views.size(); ++i) {
+QGraphicsViewPrivate *viewPrivate = scene->d_func()->views.at(i)->d_func();
+QRect rect = paintedViewBoundingRects.value(viewPrivate->viewport);
+rect.translate(viewPrivate->dirtyScrollOffset);
+viewPrivate->updateRect(rect);
+}
+if (updateChildren) {
+for (int i = 0; i < children.size(); ++i)
+children.at(i)->d_ptr->updatePaintedViewBoundingRects(true);
+}
 }
 // Traverses all the ancestors up to the top-level and updates the pointer to
 // always point to the top-most item that has a dirty scene transform.
 // It then backtracks to the top-most dirty item and start calculating the
 After scrolling, the item will issue an update for the newly exposed
 areas. If scrolling is not supported (e.g., you are rendering to an OpenGL
 viewport, which does not benefit from scroll optimizations), this function
 is equivalent to calling update(\a rect).
+\bold{Note:} Scrolling is only supported when QGraphicsItem::ItemCoordinateCache
+is enabled; in all other cases calling this function is equivalent to calling
+update(\a rect). If you for sure know that the item is opaque and not overlapped
+by other items, you can map the \a rect to viewport coordinates and scroll the
+viewport.
+\snippet doc/src/snippets/code/src_gui_graphicsview_qgraphicsitem.cpp 19
 \sa boundingRect()
 */
 void QGraphicsItem::scroll(qreal dx, qreal dy, const QRectF &rect)
 {
 Q_D(QGraphicsItem);
 if (dx == 0.0 && dy == 0.0)
 return;
 if (!d->scene)
 return;
-if (d->cacheMode != NoCache) {
-QGraphicsItemCache *c;
+// Accelerated scrolling means moving pixels from one location to another
-bool scrollCache = qFuzzyIsNull(dx - int(dx)) && qFuzzyIsNull(dy - int(dy))
+// and only redraw the newly exposed area. The following requirements must
-&& (c = (QGraphicsItemCache *)qVariantValue<void *>(d_ptr->extra(QGraphicsItemPrivate::ExtraCacheData)))
+// be fulfilled in order to do that:
-&& (d->cacheMode == ItemCoordinateCache && !c->fixedSize.isValid());
+//
-if (scrollCache) {
+// 1) Item is opaque.
-QPixmap pix;
+// 2) Item is not overlapped by other items.
-if (QPixmapCache::find(c->key, &pix)) {
+//
-// Adjust with 2 pixel margin. Notice the loss of precision
+// There's (yet) no way to detect whether an item is opaque or not, which means
-// when converting to QRect.
+// we cannot do accelerated scrolling unless the cache is enabled. In case of using
-int adjust = 2;
+// DeviceCoordinate cache we also have to take the device transform into account in
-QRectF br = boundingRect().adjusted(-adjust, -adjust, adjust, adjust);
+// order to determine whether we can do accelerated scrolling or not. That's left out
-QRect irect = rect.toRect().translated(-br.x(), -br.y());
+// for simplicity here, but it is definitely something we can consider in the future
+// as a performance improvement.
-pix.scroll(dx, dy, irect);
+if (d->cacheMode != QGraphicsItem::ItemCoordinateCache
+|| !qFuzzyIsNull(dx - int(dx)) || !qFuzzyIsNull(dy - int(dy))) {
-QPixmapCache::replace(c->key, pix);
+update(rect);
-// Translate the existing expose.
-foreach (QRectF exposedRect, c->exposed)
-c->exposed += exposedRect.translated(dx, dy) & rect;
-// Calculate exposure.
-QRegion exposed;
-QRect r = rect.toRect();
-exposed += r;
-exposed -= r.translated(dx, dy);
-foreach (QRect rect, exposed.rects())
-update(rect);
-d->scene->d_func()->markDirty(this);
-} else {
-update(rect);
-}
-} else {
-// ### This is very slow, and can be done much better. If the cache is
-// local and matches the below criteria for rotation and scaling, we
-// can easily scroll. And if the cache is in device coordinates, we
-// can scroll both the viewport and the cache.
-update(rect);
-}
 return;
 }
-QRectF scrollRect = !rect.isNull() ? rect : boundingRect();
+QGraphicsItemCache *cache = d->extraItemCache();
-int couldntScroll = d->scene->views().size();
+if (cache->allExposed || cache->fixedSize.isValid()) {
-foreach (QGraphicsView *view, d->scene->views()) {
+// Cache is either invalidated or item is scaled (see QGraphicsItem::setCacheMode).
-if (view->viewport()->inherits("QGLWidget")) {
+update(rect);
-// ### Please replace with a widget attribute; any widget that
+return;
-// doesn't support partial updates / doesn't support scrolling
+}
-// should be skipped in this code. Qt::WA_NoPartialUpdates or so.
+QPixmap cachedPixmap;
+if (!QPixmapCache::find(cache->key, &cachedPixmap)) {
+update(rect);
+return;
+}
+QRegion exposed;
+const bool scrollEntirePixmap = rect.isNull();
+if (scrollEntirePixmap) {
+// Scroll entire pixmap.
+cachedPixmap.scroll(dx, dy, cachedPixmap.rect(), &exposed);
+} else {
+if (!rect.intersects(cache->boundingRect))
+return; // Nothing to scroll.
+// Scroll sub-rect of pixmap. The rect is in item coordinates
+// so we have to translate it to pixmap coordinates.
+QRect scrollRect = rect.toAlignedRect();
+cachedPixmap.scroll(dx, dy, scrollRect.translated(-cache->boundingRect.topLeft()), &exposed);
+}
+QPixmapCache::replace(cache->key, cachedPixmap);
+// Translate the existing expose.
+for (int i = 0; i < cache->exposed.size(); ++i) {
+QRectF &e = cache->exposed[i];
+if (!scrollEntirePixmap && !e.intersects(rect))
 continue;
-}
+e.translate(dx, dy);
+}
-static const QLineF up(0, 0, 0, -1);
-static const QLineF down(0, 0, 0, 1);
+// Append newly exposed areas. Note that the exposed region is currently
-static const QLineF left(0, 0, -1, 0);
+// in pixmap coordinates, so we have to translate it to item coordinates.
-static const QLineF right(0, 0, 1, 0);
+exposed.translate(cache->boundingRect.topLeft());
+const QVector<QRect> exposedRects = exposed.rects();
-QTransform deviceTr = deviceTransform(view->viewportTransform());
+for (int i = 0; i < exposedRects.size(); ++i)
-QRect deviceScrollRect = deviceTr.mapRect(scrollRect).toRect();
+cache->exposed += exposedRects.at(i);
-QLineF v1 = deviceTr.map(right);
-QLineF v2 = deviceTr.map(down);
+// Trigger update. This will redraw the newly exposed area and make sure
-QLineF u1 = v1.unitVector(); u1.translate(-v1.p1());
+// the pixmap is re-blitted in case there are overlapping items.
-QLineF u2 = v2.unitVector(); u2.translate(-v2.p1());
+d->scene->d_func()->markDirty(this, rect);
-bool noScroll = false;
-// Check if the delta resolves to ints in device space.
-QPointF deviceDelta = deviceTr.map(QPointF(dx, dy));
-if ((deviceDelta.x() - int(deviceDelta.x()))
-|| (deviceDelta.y() - int(deviceDelta.y()))) {
-noScroll = true;
-} else {
-// Check if the unit vectors have no fraction in device space.
-qreal v1l = v1.length();
-if (v1l - int(v1l)) {
-noScroll = true;
-} else {
-dx *= v1.length();
-}
-qreal v2l = v2.length();
-if (v2l - int(v2l)) {
-noScroll = true;
-} else {
-dy *= v2.length();
-}
-}
-if (!noScroll) {
-if (u1 == right) {
-if (u2 == up) {
-// flipped
-dy = -dy;
-} else if (u2 == down) {
-// normal
-} else {
-noScroll = true;
-}
-} else if (u1 == left) {
-if (u2 == up) {
-// mirrored & flipped / rotated 180 degrees
-dx = -dx;
-dy = -dy;
-} else if (u2 == down) {
-// mirrored
-dx = -dx;
-} else {
-noScroll = true;
-}
-} else if (u1 == up) {
-if (u2 == left) {
-// rotated -90 & mirrored
-qreal tmp = dy;
-dy = -dx;
-dx = -tmp;
-} else if (u2 == right) {
-// rotated -90
-qreal tmp = dy;
-dy = -dx;
-dx = tmp;
-} else {
-noScroll = true;
-}
-} else if (u1 == down) {
-if (u2 == left) {
-// rotated 90
-qreal tmp = dy;
-dy = dx;
-dx = -tmp;
-} else if (u2 == right) {
-// rotated 90 & mirrored
-qreal tmp = dy;
-dy = dx;
-dx = tmp;
-} else {
-noScroll = true;
-}
-}
-}
-if (!noScroll) {
-view->viewport()->scroll(int(dx), int(dy), deviceScrollRect);
---couldntScroll;
-}
-}
-if (couldntScroll)
-update(rect);
 }
 /*!
 \fn void QGraphicsItem::update(qreal x, qreal y, qreal width, qreal height)
 \overload
 buttonDownParentPos = mapToParent(viewToItemTransform.map(QPointF(view->mapFromGlobal(event->buttonDownScreenPos(Qt::LeftButton)))));
 } else if (item->flags() & ItemIgnoresTransformations) {
 // Root items that ignore transformations need to
 // calculate their diff by mapping viewport coordinates
 // directly to parent coordinates.
-QTransform viewToParentTransform = (item->transform().translate(item->d_ptr->pos.x(), item->d_ptr->pos.y()))
+// COMBINE
+QTransform itemTransform;
+if (item->d_ptr->transformData)
+itemTransform = item->d_ptr->transformData->computedFullTransform();
+itemTransform.translate(item->d_ptr->pos.x(), item->d_ptr->pos.y());
+QTransform viewToParentTransform = itemTransform
 * (item->sceneTransform() * view->viewportTransform()).inverted();
 currentParentPos = viewToParentTransform.map(QPointF(view->mapFromGlobal(event->screenPos())));
 buttonDownParentPos = viewToParentTransform.map(QPointF(view->mapFromGlobal(event->buttonDownScreenPos(Qt::LeftButton))));
 } else {
 // All other items simply map from the scene.
 */
 void QGraphicsItem::setInputMethodHints(Qt::InputMethodHints hints)
 {
 Q_D(QGraphicsItem);
 d->imHints = hints;
+if (!hasFocus())
+return;
+d->scene->d_func()->updateInputMethodSensitivityInViews();
+#if !defined(QT_NO_IM) && (defined(Q_WS_X11) || defined(Q_WS_QWS) || defined(Q_OS_SYMBIAN))
+QWidget *fw = QApplication::focusWidget();
+if (!fw)
+return;
+for (int i = 0 ; i < scene()->views().count() ; ++i)
+if (scene()->views().at(i) == fw)
+if (QInputContext *inputContext = fw->inputContext())
+inputContext->update();
+#endif
+}
+/*!
+Updates the item's micro focus.
+\since 4.7
+\sa QInputContext
+*/
+void QGraphicsItem::updateMicroFocus()
+{
+#if !defined(QT_NO_IM) && (defined(Q_WS_X11) || defined(Q_WS_QWS) || defined(Q_OS_SYMBIAN))
+if (QWidget *fw = QApplication::focusWidget()) {
+for (int i = 0 ; i < scene()->views().count() ; ++i)
+if (scene()->views().at(i) == fw)
+if (QInputContext *inputContext = fw->inputContext())
+inputContext->update();
+#ifndef QT_NO_ACCESSIBILITY
+// ##### is this correct
+QAccessible::updateAccessibility(fw, 0, QAccessible::StateChanged);
+#endif
+}
+#endif
 }
 /*!
 This virtual function is called by QGraphicsItem to notify custom items
 that some part of the item's state changes. By reimplementing this
 \sa ungrabGesture(), QGestureEvent
 */
 void QGraphicsObject::grabGesture(Qt::GestureType gesture, Qt::GestureFlags flags)
 {
-QGraphicsItemPrivate * const d = QGraphicsItem::d_func();
+bool contains = QGraphicsItem::d_ptr->gestureContext.contains(gesture);
-d->gestureContext.insert(gesture, flags);
+QGraphicsItem::d_ptr->gestureContext.insert(gesture, flags);
-(void)QGestureManager::instance(); // create a gesture manager
+if (!contains && QGraphicsItem::d_ptr->scene)
+QGraphicsItem::d_ptr->scene->d_func()->grabGesture(this, gesture);
 }
 /*!
 Unsubscribes the graphics object from the given \a gesture.
 \sa grabGesture(), QGestureEvent
 */
 void QGraphicsObject::ungrabGesture(Qt::GestureType gesture)
 {
-QGraphicsItemPrivate * const d = QGraphicsItem::d_func();
+if (QGraphicsItem::d_ptr->gestureContext.remove(gesture) && QGraphicsItem::d_ptr->scene)
-if (d->gestureContext.remove(gesture)) {
+QGraphicsItem::d_ptr->scene->d_func()->ungrabGesture(this, gesture);
-QGestureManager *manager = QGestureManager::instance();
+}
-manager->cleanupCachedGestures(this, gesture);
+/*!
-}
+Updates the item's micro focus. This is slot for convenience.
+\since 4.7
+\sa QInputContext
+*/
+void QGraphicsObject::updateMicroFocus()
+{
+QGraphicsItem::updateMicroFocus();
+}
+void QGraphicsItemPrivate::children_append(QDeclarativeListProperty<QGraphicsObject> *list, QGraphicsObject *item)
+{
+QGraphicsItemPrivate::get(item)->setParentItemHelper(static_cast<QGraphicsObject *>(list->object), /*newParentVariant=*/0, /*thisPointerVariant=*/0);
+}
+int QGraphicsItemPrivate::children_count(QDeclarativeListProperty<QGraphicsObject> *list)
+{
+QGraphicsItemPrivate *d = QGraphicsItemPrivate::get(static_cast<QGraphicsObject *>(list->object));
+return d->children.count();
+}
+QGraphicsObject *QGraphicsItemPrivate::children_at(QDeclarativeListProperty<QGraphicsObject> *list, int index)
+{
+QGraphicsItemPrivate *d = QGraphicsItemPrivate::get(static_cast<QGraphicsObject *>(list->object));
+if (index >= 0 && index < d->children.count())
+return d->children.at(index)->toGraphicsObject();
+else
+return 0;
+}
+/*!
+Returns a list of this item's children.
+The items are sorted by stacking order. This takes into account both the
+items' insertion order and their Z-values.
+*/
+QDeclarativeListProperty<QGraphicsObject> QGraphicsItemPrivate::childrenList()
+{
+Q_Q(QGraphicsItem);
+if (isObject) {
+QGraphicsObject *that = static_cast<QGraphicsObject *>(q);
+return QDeclarativeListProperty<QGraphicsObject>(that, &children, children_append,
+children_count, children_at);
+} else {
+//QGraphicsItem is not supported for this property
+return QDeclarativeListProperty<QGraphicsObject>();
+}
+}
+/*!
+\internal
+Returns the width of the item
+Reimplemented by QGraphicsWidget
+*/
+qreal QGraphicsItemPrivate::width() const
+{
+return 0;
+}
+/*!
+\internal
+Set the width of the item
+Reimplemented by QGraphicsWidget
+*/
+void QGraphicsItemPrivate::setWidth(qreal w)
+{
+Q_UNUSED(w);
+}
+/*!
+\internal
+Reset the width of the item
+Reimplemented by QGraphicsWidget
+*/
+void QGraphicsItemPrivate::resetWidth()
+{
+}
+/*!
+\internal
+Returns the height of the item
+Reimplemented by QGraphicsWidget
+*/
+qreal QGraphicsItemPrivate::height() const
+{
+return 0;
+}
+/*!
+\internal
+Set the height of the item
+Reimplemented by QGraphicsWidget
+*/
+void QGraphicsItemPrivate::setHeight(qreal h)
+{
+Q_UNUSED(h);
+}
+/*!
+\internal
+Reset the height of the item
+Reimplemented by QGraphicsWidget
+*/
+void QGraphicsItemPrivate::resetHeight()
+{
 }
 /*!
 \property QGraphicsObject::parent
 \brief the parent of the item
 origin for scale and rotation.
 \sa scale, rotation, QGraphicsItem::transformOriginPoint()
 */
+/*!
+\fn void QGraphicsObject::widthChanged()
+\internal
+*/
+/*!
+\fn void QGraphicsObject::heightChanged()
+\internal
+*/
+/*!
+\fn QGraphicsObject::childrenChanged()
+This signal gets emitted whenever the children list changes
+\internal
+*/
+/*!
+\property QGraphicsObject::effect
+\brief the effect attached to this item
+\sa QGraphicsItem::setGraphicsEffect(), QGraphicsItem::graphicsEffect()
+*/
 /*!
 \class QAbstractGraphicsShapeItem
 \brief The QAbstractGraphicsShapeItem class provides a common base for
 all path items.
 You can subclass this item to provide a simple base implementation of
 accessors for the item's pen and brush.
 \sa QGraphicsRectItem, QGraphicsEllipseItem, QGraphicsPathItem,
 QGraphicsPolygonItem, QGraphicsTextItem, QGraphicsLineItem,
-QGraphicsPixmapItem, {The Graphics View Framework}
+QGraphicsPixmapItem, {Graphics View Framework}
 */
 class QAbstractGraphicsShapeItemPrivate : public QGraphicsItemPrivate
 {
 Q_DECLARE_PUBLIC(QAbstractGraphicsShapeItem)
 paint() function draws the path using the item's associated pen
 and brush, which you can set by calling the setPen() and
 setBrush() functions.
 \sa QGraphicsRectItem, QGraphicsEllipseItem, QGraphicsPolygonItem,
-QGraphicsTextItem, QGraphicsLineItem, QGraphicsPixmapItem, {The Graphics
+QGraphicsTextItem, QGraphicsLineItem, QGraphicsPixmapItem, {Graphics
 View Framework}
 */
 class QGraphicsPathItemPrivate : public QAbstractGraphicsShapeItemPrivate
 {
 rectangles using data from an unreliable source) then you should
 use QRectF::normalized() to create normalized rectangles, and use
 those instead.
 \sa QGraphicsPathItem, QGraphicsEllipseItem, QGraphicsPolygonItem,
-QGraphicsTextItem, QGraphicsLineItem, QGraphicsPixmapItem, {The Graphics
+QGraphicsTextItem, QGraphicsLineItem, QGraphicsPixmapItem, {Graphics
 View Framework}
 */
 class QGraphicsRectItemPrivate : public QAbstractGraphicsShapeItemPrivate
 {
 reasonable implementation of boundingRect(), shape(), and contains(). The
 paint() function draws the ellipse using the item's associated pen and
 brush, which you can set by calling setPen() and setBrush().
 \sa QGraphicsPathItem, QGraphicsRectItem, QGraphicsPolygonItem,
-QGraphicsTextItem, QGraphicsLineItem, QGraphicsPixmapItem, {The Graphics
+QGraphicsTextItem, QGraphicsLineItem, QGraphicsPixmapItem, {Graphics
 View Framework}
 */
 class QGraphicsEllipseItemPrivate : public QAbstractGraphicsShapeItemPrivate
 {
 contains(). The paint() function draws the polygon using the
 item's associated pen and brush, which you can set by calling the
 setPen() and setBrush() functions.
 \sa QGraphicsPathItem, QGraphicsRectItem, QGraphicsEllipseItem,
-QGraphicsTextItem, QGraphicsLineItem, QGraphicsPixmapItem, {The Graphics
+QGraphicsTextItem, QGraphicsLineItem, QGraphicsPixmapItem, {Graphics
 View Framework}
 */
 class QGraphicsPolygonItemPrivate : public QAbstractGraphicsShapeItemPrivate
 {
 QGraphicsLineItem uses the line and the pen width to provide a reasonable
 implementation of boundingRect(), shape(), and contains(). The paint()
 function draws the line using the item's associated pen.
 \sa QGraphicsPathItem, QGraphicsRectItem, QGraphicsEllipseItem,
-QGraphicsTextItem, QGraphicsPolygonItem, QGraphicsPixmapItem, {The
+QGraphicsTextItem, QGraphicsPolygonItem, QGraphicsPixmapItem,
-Graphics View Framework}
+{Graphics View Framework}
 */
 class QGraphicsLineItemPrivate : public QGraphicsItemPrivate
 {
 Q_DECLARE_PUBLIC(QGraphicsLineItem)
 the platform and viewport. The result is usually not as good as calling
 QPixmap::scale() directly. Call transformationMode() to get the current
 transformation mode for the item.
 \sa QGraphicsPathItem, QGraphicsRectItem, QGraphicsEllipseItem,
-QGraphicsTextItem, QGraphicsPolygonItem, QGraphicsLineItem, {The
+QGraphicsTextItem, QGraphicsPolygonItem, QGraphicsLineItem,
-Graphics View Framework}
+{Graphics View Framework}
 */
 /*!
 \enum QGraphicsPixmapItem::ShapeMode
 \note QGraphicsTextItem accepts \l{QGraphicsItem::acceptHoverEvents()}{hover events}
 by default. You can change this with \l{QGraphicsItem::}{setAcceptHoverEvents()}.
 \sa QGraphicsSimpleTextItem, QGraphicsPathItem, QGraphicsRectItem,
 QGraphicsEllipseItem, QGraphicsPixmapItem, QGraphicsPolygonItem,
-QGraphicsLineItem, {The Graphics View Framework}
+QGraphicsLineItem, {Graphics View Framework}
 */
 class QGraphicsTextItemPrivate
 {
 public:
 qic->update();
 }
 #endif //QT_NO_IM
 }
 break;
+case QEvent::ShortcutOverride:
+dd->sendControlEvent(event);
+return true;
 default:
 break;
 }
 return result;
 QGraphicsSimpleText does not display rich text; instead, you can use
 QGraphicsTextItem, which provides full text control capabilities.
 \img graphicsview-simpletextitem.png
-\sa QGraphicsTextItem, QGraphicsPathItem, QGraphicsRectItem, QGraphicsEllipseItem,
+\sa QGraphicsTextItem, QGraphicsPathItem, QGraphicsRectItem,
-QGraphicsPixmapItem, QGraphicsPolygonItem, QGraphicsLineItem, {The
+QGraphicsEllipseItem, QGraphicsPixmapItem, QGraphicsPolygonItem,
-Graphics View Framework}
+QGraphicsLineItem, {Graphics View Framework}
 */
 /*!
 Constructs a QGraphicsSimpleTextItem.
 The removeFromGroup() function has similar semantics to
 setParentItem(); it reparents the item to the parent item of the
 item group. As with addToGroup(), the item's scene-relative
 position and transformation remain intact.
-\sa QGraphicsItem, {The Graphics View Framework}
+\sa QGraphicsItem, {Graphics View Framework}
 */
 class QGraphicsItemGroupPrivate : public QGraphicsItemPrivate
 {
 public:
 newEffectTransform *= effectTransform;
 scened->draw(item, &pixmapPainter, 0, &sceneTransform, 0, 0, qreal(1.0),
 &newEffectTransform, false, true);
 } else if (deviceCoordinates) {
 // Device coordinates with info.
-scened->draw(item, &pixmapPainter, info->viewTransform, info->transformPtr, info->exposedRegion,
+scened->draw(item, &pixmapPainter, info->viewTransform, info->transformPtr, 0,
 info->widget, info->opacity, &effectTransform, info->wasDirtySceneTransform,
 info->drawItem);
 } else {
 // Item coordinates with info.
 QTransform newEffectTransform = info->transformPtr->inverted();
 newEffectTransform *= effectTransform;
-scened->draw(item, &pixmapPainter, info->viewTransform, info->transformPtr, info->exposedRegion,
+scened->draw(item, &pixmapPainter, info->viewTransform, info->transformPtr, 0,
 info->widget, info->opacity, &newEffectTransform, info->wasDirtySceneTransform,
 info->drawItem);
 }
 pixmapPainter.end();
 str = "ItemOpacityHasChanged";
 break;
 case QGraphicsItem::ItemScenePositionHasChanged:
 str = "ItemScenePositionHasChanged";
 break;
+case QGraphicsItem::ItemRotationChange:
+str = "ItemRotationChange";
+break;
+case QGraphicsItem::ItemRotationHasChanged:
+str = "ItemRotationHasChanged";
+break;
+case QGraphicsItem::ItemScaleChange:
+str = "ItemScaleChange";
+break;
+case QGraphicsItem::ItemScaleHasChanged:
+str = "ItemScaleHasChanged";
+break;
+case QGraphicsItem::ItemTransformOriginPointChange:
+str = "ItemTransformOriginPointChange";
+break;
+case QGraphicsItem::ItemTransformOriginPointHasChanged:
+str = "ItemTransformOriginPointHasChanged";
+break;
 }
 debug << str;
 return debug;
 }
 QDebug operator<<(QDebug debug, QGraphicsItem::GraphicsItemFlags flags)
 {
 debug << '(';
 bool f = false;
-for (int i = 0; i < 16; ++i) {
+for (int i = 0; i < 17; ++i) {
 if (flags & (1 << i)) {
 if (f)
 debug << '|';
 f = true;
 debug << QGraphicsItem::GraphicsItemFlag(int(flags & (1 << i)));

changeset 30	5dc02b23752f
parent 25	e24348a560a6
child 33	3e2da88830cd