Changeset 846 for trunk/src/gui/graphicsview

trunk

Property svn:mergeinfo changed
/branches/vendor/nokia/qt/4.7.2 (added) merged: 845
/branches/vendor/nokia/qt/current merged: 844
/branches/vendor/nokia/qt/4.6.3 removed

trunk/src/gui/graphicsview/qgraph_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation ([email protected])

trunk/src/gui/graphicsview/qgraphicsanchorlayout.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation ([email protected])

trunk/src/gui/graphicsview/qgraphicsanchorlayout.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation ([email protected])

trunk/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation ([email protected])

trunk/src/gui/graphicsview/qgraphicsanchorlayout_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation ([email protected])

trunk/src/gui/graphicsview/qgraphicsgridlayout.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation ([email protected])
 …
     destroying it.
     \sa QGraphicsLinearLayout, QGraphicsWidget
 */
 …
 };
 QLayoutStyleInfo QGraphicsGridLayoutPrivate::styleInfo() const
+{
-    static QWidget *wid = 0;
-    if (!wid)
-        wid = new QWidget;
     QGraphicsItem *item = parentItem();
     QStyle *style = (item && item->isWidget()) ? static_cast<QGraphicsWidget*>(item)->style() : QApplication::style();
     return QLayoutStyleInfo(style, wid);
+    return QLayoutStyleInfo(style, );
+}
 …
             layoutItem->setParentLayoutItem(0);
         d->engine.removeItem(gridItem);
         delete gridItem;
         invalidate();
 …
     qreal left, top, right, bottom;
     getContentsMargins(&left, &top, &right, &bottom);
+    return d->engine.sizeHint(d->styleInfo(), which , constraint) + QSizeF(left + right, top + bottom);
+    const QSizeF extraMargins(left + right, top + bottom);
+    return d->engine.sizeHint(d->styleInfo(), which , constraint - extraMargins) + extraMargins;
+}

trunk/src/gui/graphicsview/qgraphicsgridlayout.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation ([email protected])

trunk/src/gui/graphicsview/qgraphicsitem.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation ([email protected])
 …
     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 Graphics View Framework}
     \image graphicsview-items.png
 …
     \img graphicsview-parentchild.png
+    \section1 Transformation
+    \target Transformations
+    \section1 Transformations
     QGraphicsItem supports projective transformations in addition to its base
 …
     user's convenience.
     \sa QGraphicsScene, QGraphicsView, {The Graphics View Framework}
+    \sa QGraphicsScene, QGraphicsView, {Graphics View Framework}
 */
 …
     \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
 …
     to receive notifications for scene position changes. This flag was
     introduced in Qt 4.6.
 */
 …
     (same as transform()), and QGraphicsItem ignores the return value for this
     notification (i.e., a read-only notification).
     \value ItemSelectedChange The item's selected state changes. If the item is
 …
 #include <QtCore/qvariant.h>
 #include <QtCore/qvarlengtharray.h>
 #include <QtGui/qapplication.h>
 #include <QtGui/qbitmap.h>
 …
 #include <QtGui/qinputcontext.h>
 #include <QtGui/qgraphicseffect.h>
 #include <private/qgraphicsitem_p.h>
 …
 #include <private/qtextengine_p.h>
 #include <private/qwidget_p.h>
 #ifdef Q_WS_X11
 …
         return;
     if (scene) {
         // Deliver the change to the index
 …
                 parentFocusScopeItem = fsi;
                 p->d_ptr->focusScopeItem = 0;
+            }
             break;
 …
             if (p->d_ptr->flags & QGraphicsItem::ItemIsFocusScope) {
                 p->d_ptr->focusScopeItem = newFocusScopeItem;
                 // Ensure the new item is no longer the subFocusItem. The
                 // only way to set focus on a child of a focus scope is
 …
     dirtySceneTransform = 1;
     // Restore the sub focus chain.
 …
     Returns the bounding rect of this item's children (excluding itself).
 */
+void QGraphicsItemPrivate::childrenBoundingRectHelper(QTransform *x, QRectF *rect)
+{
+void QGraphicsItemPrivate::childrenBoundingRectHelper(QTransform *x, QRectF *rect, QGraphicsItem *topMostEffectItem)
+{
+    Q_Q(QGraphicsItem);
+    QRectF childrenRect;
+    QRectF *result = rect;
+    rect = &childrenRect;
+    const bool setTopMostEffectItem = !topMostEffectItem;
     for (int i = 0; i < children.size(); ++i) {
         QGraphicsItem *child = children.at(i);
         QGraphicsItemPrivate *childd = child->d_ptr.data();
         bool hasPos = !childd->pos.isNull();
         if (hasPos || childd->transformData) {
 …
             if (x)
                 matrix *= *x;
             *rect |= matrix.mapRect(child->boundingRect());
+            *rect |= matrix.mapRect(child->));
             if (!childd->children.isEmpty())
                 childd->childrenBoundingRectHelper(&matrix, rect);
+                childd->childrenBoundingRectHelper(&matrix, rect);
         } else {
             if (x)
                 *rect |= x->mapRect(child->boundingRect());
+                *rect |= x->mapRect(child->));
             else
                 *rect |= child->boundingRect();
+                *rect |= child->);
             if (!childd->children.isEmpty())
                 childd->childrenBoundingRectHelper(x, rect);
+                childd->childrenBoundingRectHelper(x, rect);
+        }
+    }
+}
 …
 QGraphicsItem::~QGraphicsItem()
+{
+    if (d_ptr->isObject)
+        QObjectPrivate::get(static_cast<QGraphicsObject *>(this))->wasDeleted = true;
+    if (d_ptr->isObject) {
+        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();
     clearFocus();
 …
 void QGraphicsItem::setFlags(GraphicsItemFlags flags)
+{
-    if (isWindow())
-        flags |= ItemIsPanel;
     // Notify change and check for adjustment.
     if (quint32(d_ptr->flags) == quint32(flags))
 …
     bool fullUpdate = (quint32(flags) & geomChangeFlagsMask) != (d_ptr->flags & geomChangeFlagsMask);
     if (fullUpdate)
         d_ptr->paintedViewBoundingRectsNeedRepaint = 1;
+        d_ptr->;
     // Keep the old flags to compare the diff.
 …
         // all children.
         d_ptr->updateAncestorFlag(ItemClipsChildrenToShape);
+    }
 …
     \snippet doc/src/snippets/code/src_gui_graphicsview_qgraphicsitem.cpp 2
     If no cursor has been set, the parent's cursor is used.
+    If no cursor has been set, the  is used.
     \sa setCursor(), hasCursor(), unsetCursor(), QWidget::cursor,
 …
                             fsi = fsi->d_ptr->focusScopeItem;
                         fsi->d_ptr->setFocusHelper(Qt::OtherFocusReason, /* climb = */ true,
                                                    /* focusFromShow = */ true);
+                                                   /* focusFrome);
+                    }
                     break;
 …
                 if (fi && fi != scene->focusItem()) {
                     scene->setFocusItem(fi);
+                }
+            }
 …
                         if (p->d_ptr->visible) {
                             p->d_ptr->setFocusHelper(Qt::OtherFocusReason, /* climb = */ true,
                                                      /* focusFromShow = */ true);
+                                                     /* focusFrom = */ true);
+                        }
                         break;
 …
     QGraphicsEffect *effect = graphicsEffect;
     if (scene && effect && effect->isEnabled()) {
         QRectF sceneRect = q->mapRectToScene(rect);
         QRectF sceneEffectRect;
 …
     \sa boundingRect()
 */
 QRectF QGraphicsItemPrivate::effectiveBoundingRect() const
+QRectF QGraphicsItemPrivate::effectiveBoundingRect() const
+{
 #ifndef QT_NO_GRAPHICSEFFECT
     Q_Q(const QGraphicsItem);
     QRectF brect = effectiveBoundingRect(q_ptr->boundingRect());
     if (ancestorFlags & QGraphicsItemPrivate::AncestorClipsChildren)
+    if (ancestorFlags & QGraphicsItemPrivate::AncestorClipsChildren)
         return brect;
 …
             brect = effectParent->mapRectToItem(q, effectRectInParentSpace);
+        }
+        if (effectParent->d_ptr->ancestorFlags & QGraphicsItemPrivate::AncestorClipsChildren)
+        if (effectParent->d_ptr->ancestorFlags & QGraphicsItemPrivate::AncestorClipsChildren
+            || topMostEffectItem == effectParent) {
             return brect;
         effectParent = effectParent->d_ptr->parent;
+    }
 …
 void QGraphicsItem::setFocus(Qt::FocusReason focusReason)
+{
     d_ptr->setFocusHelper(focusReason, /* climb = */ true, /* focusFromShow = */ false);
+    d_ptr->setFocusHelper(focusReason, /* climb = */ true, /* focusFrom = */ false);
+}
 …
     \internal
 */
 void QGraphicsItemPrivate::setFocusHelper(Qt::FocusReason focusReason, bool climb, bool focusFromShow)
+void QGraphicsItemPrivate::setFocusHelper(Qt::FocusReason focusReason, bool climb, bool focusFrom)
+{
     // Disabled / unfocusable items cannot accept focus.
 …
     while (p) {
         if (p->flags() & QGraphicsItem::ItemIsFocusScope) {
             p->d_ptr->focusScopeItem = q_ptr;
+            if (!p->focusItem() && !focusFromShow) {
+            if (!p->focusItem() && !focusFromHide) {
+                if (oldFocusScopeItem)
+                    oldFocusScopeItem->d_ptr->focusScopeItemChange(false);
+                focusScopeItemChange(true);
                 // If you call setFocus on a child of a focus scope that
                 // doesn't currently have a focus item, then stop.
 …
     // Update the child focus chain.
+    f->d_ptr->setSubFocus();
+    QGraphicsItem *commonAncestor = 0;
+    if (scene && scene->focusItem()) {
+        commonAncestor = scene->focusItem()->commonAncestorItem(f);
+        scene->focusItem()->d_ptr->clearSubFocus(scene->focusItem(), commonAncestor);
+    }
+    f->d_ptr->setSubFocus(f, commonAncestor);
     // Update the scene's focus item.
 …
             while (p) {
                 if (p->flags() & QGraphicsItem::ItemIsFocusScope) {
+                    p->d_ptr->setFocusHelper(Qt::OtherFocusReason, /* climb = */ false,
+                                             /* focusFromShow = */ false);
+                    if (p->d_ptr->focusScopeItem == q_ptr) {
+                        p->d_ptr->focusScopeItem = 0;
+                        if (!q_ptr->hasFocus()) //if it has focus, focusScopeItemChange is called elsewhere
+                            focusScopeItemChange(false);
+                    }
+                    if (q_ptr->hasFocus())
+                        p->d_ptr->setFocusHelper(Qt::OtherFocusReason, /* climb = */ false,
+                                                 /* focusFromHide = */ false);
                     return;
+                }
 …
+    }
-    // Invisible items with focus must explicitly clear subfocus.
-    clearSubFocus(q_ptr);
     if (q_ptr->hasFocus()) {
         // If this item has the scene's input focus, clear it.
         scene->setFocusItem(0);
 …
         return;
+    d_ptr->setPosHelper(QPointF(x, d_ptr->pos.y()));
+    if (qIsNaN(x))
+        return;
+    setPos(QPointF(x, d_ptr->pos.y()));
+}
 …
         return;
+    d_ptr->setPosHelper(QPointF(d_ptr->pos.x(), y));
+    if (qIsNaN(y))
+        return;
+    setPos(QPointF(d_ptr->pos.x(), y));
+}
 …
     transformData->transform = transform;
     dirtySceneTransform = 1;
+}
 …
     // Update and repositition.
     if (!(d_ptr->flags & ItemSendsGeometryChanges)) {
+    if (!(d_ptr->flags & )) {
         d_ptr->setPosHelper(pos);
         if (d_ptr->isWidget)
             static_cast<QGraphicsWidget *>(this)->d_func()->setGeometryFromSetPos();
         return;
+    }
 …
+{
     prepareGeometryChange();
     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;
     if (d_ptr->isObject)
         emit static_cast<QGraphicsObject *>(this)->rotationChanged();
+}
 …
     transformations() to map the item's coordinate system to the parent item.
     \sa scale(), setTransformOriginPoint(), {Transformations}
+    \sa scale(), setTransformOriginPoint(), {Transformations}
 */
 void QGraphicsItem::setScale(qreal factor)
+{
     prepareGeometryChange();
     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;
     if (d_ptr->isObject)
         emit static_cast<QGraphicsObject *>(this)->scaleChanged();
+}
 …
     QGraphicsTransform is for applying and controlling a chain of individual
     transformation operations on an item. It's particularily useful in
+    transformation operations on an item. It's particularly useful in
     animations, where each transform operation needs to be interpolated
     independently, or differently.
 …
     QGraphicsTransform is for applying and controlling a chain of individual
     transformation operations on an item. It's particularily useful in
+    transformation operations on an item. It's particularly useful in
     animations, where each transform operation needs to be interpolated
     independently, or differently.
 …
     d_ptr->transformData->onlyTransform = false;
     d_ptr->dirtySceneTransform = 1;
+}
 …
     transformData->onlyTransform = false;
     dirtySceneTransform = 1;
+}
 …
+{
     prepareGeometryChange();
     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;
+}
 …
     // Update and set the new transformation.
     if (!(d_ptr->flags & ItemSendsGeometryChanges)) {
+    if (!(d_ptr->flags & )) {
         d_ptr->setTransformHelper(newTransform);
         return;
+    }
 …
     d_ptr->childrenBoundingRect = QRectF();
     d_ptr->childrenBoundingRectHelper(0, &d_ptr->childrenBoundingRect);
+    d_ptr->childrenBoundingRectHelper(0, &d_ptr->childrenBoundingRect);
     d_ptr->dirtyChildrenBoundingRect = 0;
     return d_ptr->childrenBoundingRect;
 …
     contents. Although it's expensive to calculate, it's also more precise
     than boundingRect(), and it can help to avoid unnecessary repainting when
     an item is updated. This is particularily efficient for thin items (e.g.,
+    an item is updated. This is particularly efficient for thin items (e.g.,
     lines or simple polygons). You can tune the granularity for the bounding
     region by calling setBoundingRegionGranularity(). The default granularity
 …
     child->d_ptr->siblingIndex = children.size();
     children.append(child);
+}
 …
     // (see ensureSortedChildren()).
     child->d_ptr->siblingIndex = -1;
+}
 …
+    }
     unsetExtra(ExtraCacheData);
+}
 …
     \internal
 */
 void QGraphicsItemPrivate::setSubFocus(QGraphicsItem *rootItem)
+void QGraphicsItemPrivate::setSubFocus(QGraphicsItem *rootItem)
+{
     // Update focus child chain. Stop at panels, or if this item
     // is hidden, stop at the first item with a visible parent.
     QGraphicsItem *parent = rootItem ? rootItem : q_ptr;
     do {
         // Clear any existing ancestor's subFocusItem.
 …
             if (parent->d_ptr->subFocusItem == q_ptr)
                 break;
             parent->d_ptr->subFocusItem->d_ptr->clearSubFocus();
+            parent->d_ptr->subFocusItem->d_ptr->clearSubFocus();
+        }
         parent->d_ptr->subFocusItem = q_ptr;
 …
     \internal
 */
 void QGraphicsItemPrivate::clearSubFocus(QGraphicsItem *rootItem)
+void QGraphicsItemPrivate::clearSubFocus(QGraphicsItem *rootItem)
+{
     // Reset sub focus chain.
 …
             break;
         parent->d_ptr->subFocusItem = 0;
+        parent->d_ptr->subFocusItemChange();
+        if (parent != stopItem && !parent->isAncestorOf(stopItem))
+            parent->d_ptr->subFocusItemChange();
     } while (!parent->isPanel() && (parent = parent->d_ptr->parent));
+}
 …
 void QGraphicsItemPrivate::subFocusItemChange()
+{
+}
 …
+    }
-    if (d_ptr->discardUpdateRequest())
-        return;
     if (d_ptr->scene)
         d_ptr->scene->d_func()->markDirty(this, rect);
 …
     is equivalent to calling update(\a rect).
     \sa boundingRect()
 */
 …
     if (!d->scene)
         return;
+    if (d->cacheMode != NoCache) {
+        QGraphicsItemCache *c;
+        bool scrollCache = qFuzzyIsNull(dx - int(dx)) && qFuzzyIsNull(dy - int(dy))
+                           && (c = (QGraphicsItemCache *)qVariantValue<void *>(d_ptr->extra(QGraphicsItemPrivate::ExtraCacheData)))
+                           && (d->cacheMode == ItemCoordinateCache && !c->fixedSize.isValid());
+        if (scrollCache) {
+            QPixmap pix;
+            if (QPixmapCache::find(c->key, &pix)) {
+                // Adjust with 2 pixel margin. Notice the loss of precision
+                // when converting to QRect.
+                int adjust = 2;
+                QRectF br = boundingRect().adjusted(-adjust, -adjust, adjust, adjust);
+                QRect irect = rect.toRect().translated(-br.x(), -br.y());
+                pix.scroll(dx, dy, irect);
+                QPixmapCache::replace(c->key, pix);
+                // 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);
+        }
+    // Accelerated scrolling means moving pixels from one location to another
+    // and only redraw the newly exposed area. The following requirements must
+    // be fulfilled in order to do that:
+    //
+    // 1) Item is opaque.
+    // 2) Item is not overlapped by other items.
+    //
+    // There's (yet) no way to detect whether an item is opaque or not, which means
+    // we cannot do accelerated scrolling unless the cache is enabled. In case of using
+    // DeviceCoordinate cache we also have to take the device transform into account in
+    // order to determine whether we can do accelerated scrolling or not. That's left out
+    // for simplicity here, but it is definitely something we can consider in the future
+    // as a performance improvement.
+    if (d->cacheMode != QGraphicsItem::ItemCoordinateCache
+        || !qFuzzyIsNull(dx - int(dx)) || !qFuzzyIsNull(dy - int(dy))) {
+        update(rect);
         return;
+    }
+    QRectF scrollRect = !rect.isNull() ? rect : boundingRect();
+    int couldntScroll = d->scene->views().size();
+    foreach (QGraphicsView *view, d->scene->views()) {
+        if (view->viewport()->inherits("QGLWidget")) {
+            // ### Please replace with a widget attribute; any widget that
+            // doesn't support partial updates / doesn't support scrolling
+            // should be skipped in this code. Qt::WA_NoPartialUpdates or so.
+    QGraphicsItemCache *cache = d->extraItemCache();
+    if (cache->allExposed || cache->fixedSize.isValid()) {
+        // Cache is either invalidated or item is scaled (see QGraphicsItem::setCacheMode).
+        update(rect);
+        return;
+    }
+    // Find pixmap in cache.
+    QPixmap cachedPixmap;
+    if (!QPixmapCache::find(cache->key, &cachedPixmap)) {
+        update(rect);
+        return;
+    }
+    QRect scrollRect = (rect.isNull() ? boundingRect() : rect).toAlignedRect();
+    if (!scrollRect.intersects(cache->boundingRect))
+        return; // Nothing to scroll.
+    // Remove from cache to avoid deep copy when modifying.
+    QPixmapCache::remove(cache->key);
+    QRegion exposed;
+    cachedPixmap.scroll(dx, dy, scrollRect.translated(-cache->boundingRect.topLeft()), &exposed);
+    // Reinsert into cache.
+    cache->key = QPixmapCache::insert(cachedPixmap);
+    // Translate the existing expose.
+    for (int i = 0; i < cache->exposed.size(); ++i) {
+        QRectF &e = cache->exposed[i];
+        if (!rect.isNull() && !e.intersects(rect))
             continue;
+        }
+        static const QLineF up(0, 0, 0, -1);
+        static const QLineF down(0, 0, 0, 1);
+        static const QLineF left(0, 0, -1, 0);
+        static const QLineF right(0, 0, 1, 0);
+        QTransform deviceTr = deviceTransform(view->viewportTransform());
+        QRect deviceScrollRect = deviceTr.mapRect(scrollRect).toRect();
+        QLineF v1 = deviceTr.map(right);
+        QLineF v2 = deviceTr.map(down);
+        QLineF u1 = v1.unitVector(); u1.translate(-v1.p1());
+        QLineF u2 = v2.unitVector(); u2.translate(-v2.p1());
+        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);
+        e.translate(dx, dy);
+    }
+    // Append newly exposed areas. Note that the exposed region is currently
+    // in pixmap coordinates, so we have to translate it to item coordinates.
+    exposed.translate(cache->boundingRect.topLeft());
+    const QVector<QRect> exposedRects = exposed.rects();
+    for (int i = 0; i < exposedRects.size(); ++i)
+        cache->exposed += exposedRects.at(i);
+    // Trigger update. This will redraw the newly exposed area and make sure
+    // the pixmap is re-blitted in case there are overlapping items.
+    d->scene->d_func()->markDirty(this, rect);
+}
 …
+    }
     if (!d_ptr->visible) {
         // Eaten
 …
     case QEvent::FocusIn:
         focusInEvent(static_cast<QFocusEvent *>(event));
-        break;
-    case QEvent::FocusOut:
-        focusOutEvent(static_cast<QFocusEvent *>(event));
         break;
     case QEvent::GraphicsSceneContextMenu:
 …
                     // 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())));
 …
     Q_D(QGraphicsItem);
     d->imHints = hints;
+}
 …
+}
 /*!
     Subscribes the graphics object to the given \a gesture with specific \a flags.
 …
 void QGraphicsObject::grabGesture(Qt::GestureType gesture, Qt::GestureFlags flags)
+{
+    QGraphicsItemPrivate * const d = QGraphicsItem::d_func();
+    d->gestureContext.insert(gesture, flags);
+    (void)QGestureManager::instance(); // create a gesture manager
+    bool contains = QGraphicsItem::d_ptr->gestureContext.contains(gesture);
+    QGraphicsItem::d_ptr->gestureContext.insert(gesture, flags);
+    if (!contains && QGraphicsItem::d_ptr->scene)
+        QGraphicsItem::d_ptr->scene->d_func()->grabGesture(this, gesture);
+}
 …
 void QGraphicsObject::ungrabGesture(Qt::GestureType gesture)
+{
+    QGraphicsItemPrivate * const d = QGraphicsItem::d_func();
+    if (d->gestureContext.remove(gesture)) {
+        QGestureManager *manager = QGestureManager::instance();
+        manager->cleanupCachedGestures(this, gesture);
+    }
+}
+    if (QGraphicsItem::d_ptr->gestureContext.remove(gesture) && QGraphicsItem::d_ptr->scene)
+        QGraphicsItem::d_ptr->scene->d_func()->ungrabGesture(this, gesture);
+}
+#endif // QT_NO_GESTURES
+/*!
+    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)
+{
+    QGraphicsObject *graphicsObject = static_cast<QGraphicsObject *>(list->object);
+    if (QGraphicsItemPrivate::get(graphicsObject)->sendParentChangeNotification) {
+        item->setParentItem(graphicsObject);
+    } else {
+        QGraphicsItemPrivate::get(item)->setParentItemHelper(graphicsObject, 0, 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;
+}
+void QGraphicsItemPrivate::children_clear(QDeclarativeListProperty<QGraphicsObject> *list)
+{
+    QGraphicsItemPrivate *d = QGraphicsItemPrivate::get(static_cast<QGraphicsObject *>(list->object));
+    int childCount = d->children.count();
+    if (d->sendParentChangeNotification) {
+        for (int index = 0; index < childCount; index++)
+            d->children.at(0)->setParentItem(0);
+    } else {
+        for (int index = 0; index < childCount; index++)
+            QGraphicsItemPrivate::get(d->children.at(0))->setParentItemHelper(0, 0, 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, children_clear);
+    } 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::children
+    \since 4.7
+    \internal
+*/
+/*!
+    \property QGraphicsObject::width
+    \since 4.7
+    \internal
+*/
+/*!
+    \property QGraphicsObject::height
+    \since 4.7
+    \internal
+*/
 /*!
 …
 */
 /*!
 …
     \sa QGraphicsRectItem, QGraphicsEllipseItem, QGraphicsPathItem,
     QGraphicsPolygonItem, QGraphicsTextItem, QGraphicsLineItem,
     QGraphicsPixmapItem, {The Graphics View Framework}
+    QGraphicsPixmapItem, {Graphics View Framework}
 */
 …
     \sa QGraphicsRectItem, QGraphicsEllipseItem, QGraphicsPolygonItem,
     QGraphicsTextItem, QGraphicsLineItem, QGraphicsPixmapItem, {The Graphics
+    QGraphicsTextItem, QGraphicsLineItem, QGraphicsPixmapItem, {Graphics
     View Framework}
 */
 …
     \sa QGraphicsPathItem, QGraphicsEllipseItem, QGraphicsPolygonItem,
     QGraphicsTextItem, QGraphicsLineItem, QGraphicsPixmapItem, {The Graphics
+    QGraphicsTextItem, QGraphicsLineItem, QGraphicsPixmapItem, {Graphics
     View Framework}
 */
 …
     \sa QGraphicsPathItem, QGraphicsRectItem, QGraphicsPolygonItem,
     QGraphicsTextItem, QGraphicsLineItem, QGraphicsPixmapItem, {The Graphics
+    QGraphicsTextItem, QGraphicsLineItem, QGraphicsPixmapItem, {Graphics
     View Framework}
 */
 …
     \sa QGraphicsPathItem, QGraphicsRectItem, QGraphicsEllipseItem,
     QGraphicsTextItem, QGraphicsLineItem, QGraphicsPixmapItem, {The Graphics
+    QGraphicsTextItem, QGraphicsLineItem, QGraphicsPixmapItem, {Graphics
     View Framework}
 */
 …
     \sa QGraphicsPathItem, QGraphicsRectItem, QGraphicsEllipseItem,
     QGraphicsTextItem, QGraphicsPolygonItem, QGraphicsPixmapItem, {The
     Graphics View Framework}
+    QGraphicsTextItem, QGraphicsPolygonItem, QGraphicsPixmapItem,
+    Graphics View Framework}
 */
 …
     \sa QGraphicsPathItem, QGraphicsRectItem, QGraphicsEllipseItem,
     QGraphicsTextItem, QGraphicsPolygonItem, QGraphicsLineItem, {The
     Graphics View Framework}
+    QGraphicsTextItem, QGraphicsPolygonItem, QGraphicsLineItem,
+    Graphics View Framework}
 */
 …
     \sa QGraphicsSimpleTextItem, QGraphicsPathItem, QGraphicsRectItem,
         QGraphicsEllipseItem, QGraphicsPixmapItem, QGraphicsPolygonItem,
         QGraphicsLineItem, {The Graphics View Framework}
+        QGraphicsLineItem, {Graphics View Framework}
 */
 …
+        }
         break;
     default:
         break;
 …
     \img graphicsview-simpletextitem.png
     \sa QGraphicsTextItem, QGraphicsPathItem, QGraphicsRectItem, QGraphicsEllipseItem,
     QGraphicsPixmapItem, QGraphicsPolygonItem, QGraphicsLineItem, {The
     Graphics View Framework}
+    \sa QGraphicsTextItem, QGraphicsPathItem, QGraphicsRectItem,
+    QGraphics
+    Graphics View Framework}
 */
 …
 /*!
     \class QGraphicsItemGroup
     \brief The QGraphicsItemGroup class provides treating a group of items as
     one.
+    \brief The QGraphicsItemGroup class provides s
+    .
     \since 4.2
     \ingroup graphicsview-api
 …
     position and transformation remain intact.
     \sa QGraphicsItem, {The Graphics View Framework}
+    \sa QGraphicsItem, {Graphics View Framework}
 */
 …
     } 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, ,
                      info->widget, info->opacity, &effectTransform, info->wasDirtySceneTransform,
                      info->drawItem);
 …
         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, ,
                      info->widget, info->opacity, &newEffectTransform, info->wasDirtySceneTransform,
                      info->drawItem);
 …
         str = "ItemScenePositionHasChanged";
         break;
+    }
     debug << str;
 …
         str = "ItemSendsScenePositionChanges";
         break;
+    }
     debug << str;
 …
     debug << '(';
     bool f = false;
     for (int i = 0; i < 16; ++i) {
+    for (int i = 0; i < 1; ++i) {
         if (flags & (1 << i)) {
             if (f)

trunk/src/gui/graphicsview/qgraphicsitem.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation ([email protected])
 …
         ItemIsPanel = 0x4000,
         ItemIsFocusScope = 0x8000, // internal
+        ItemSendsScenePositionChanges = 0x10000
+        ItemSendsScenePositionChanges = 0x10000,
+        ItemStopsClickFocusPropagation = 0x20000
         // NB! Don't forget to increase the d_ptr->flags bit field by 1 when adding a new flag.
     };
 …
         ItemOpacityChange,
         ItemOpacityHasChanged,
+        ItemScenePositionHasChanged
+        ItemScenePositionHasChanged,
+        ItemRotationChange,
+        ItemRotationHasChanged,
+        ItemScaleChange,
+        ItemScaleHasChanged,
+        ItemTransformOriginPointChange,
+        ItemTransformOriginPointHasChanged
     };
 …
 protected:
     virtual bool sceneEventFilter(QGraphicsItem *watched, QEvent *event);
     virtual bool sceneEvent(QEvent *event);
 …
     friend class QGraphicsItemEffectSourcePrivate;
     friend class QGraphicsTransformPrivate;
     friend class QGestureManager;
     friend class ::tst_QGraphicsItem;
     friend bool qt_closestLeaf(const QGraphicsItem *, const QGraphicsItem *);
 …
     Q_PROPERTY(bool enabled READ isEnabled WRITE setEnabled NOTIFY enabledChanged)
     Q_PROPERTY(bool visible READ isVisible WRITE setVisible NOTIFY visibleChanged FINAL)
     Q_PROPERTY(QPointF pos READ pos WRITE setPos)
     Q_PROPERTY(qreal x READ x WRITE setX NOTIFY xChanged)
     Q_PROPERTY(qreal y READ y WRITE setY NOTIFY yChanged)
     Q_PROPERTY(qreal z READ zValue WRITE setZValue NOTIFY zChanged)
+    Q_PROPERTY(QPointF pos READ pos WRITE setPos)
+    Q_PROPERTY(qreal x READ x WRITE setX NOTIFY xChanged)
+    Q_PROPERTY(qreal y READ y WRITE setY NOTIFY yChanged)
+    Q_PROPERTY(qreal z READ zValue WRITE setZValue NOTIFY zChanged)
     Q_PROPERTY(qreal rotation READ rotation WRITE setRotation NOTIFY rotationChanged)
     Q_PROPERTY(qreal scale READ scale WRITE setScale NOTIFY scaleChanged)
     Q_PROPERTY(QPointF transformOriginPoint READ transformOriginPoint WRITE setTransformOriginPoint)
     Q_INTERFACES(QGraphicsItem)
 public:
 …
 #endif
     void grabGesture(Qt::GestureType type, Qt::GestureFlags flags = Qt::GestureFlags());
     void ungrabGesture(Qt::GestureType type);
 Q_SIGNALS:
 …
     void rotationChanged();
     void scaleChanged();
 protected:

trunk/src/gui/graphicsview/qgraphicsitem_p.h

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation ([email protected])
 …
 class QGraphicsItemPrivate;
 class QGraphicsItemCache
 …
         allChildrenDirty(0),
         fullUpdatePending(0),
         flags(0),
-        dirtyChildrenBoundingRect(1),
         paintedViewBoundingRectsNeedRepaint(0),
         dirtySceneTransform(1),
 …
         pendingPolish(0),
         mayHaveChildWithGraphicsEffect(0),
         globalStackingOrder(-1),
         q_ptr(0)
 …
     virtual void setPosHelper(const QPointF &pos);
     void setTransformHelper(const QTransform &transform);
     void appendGraphicsTransform(QGraphicsTransform *t);
     void setVisibleHelper(bool newVisible, bool explicitly, bool update = true);
 …
     bool discardUpdateRequest(bool ignoreVisibleBit = false,
                               bool ignoreDirtyBit = false, bool ignoreOpacity = false) const;
     int depth() const;
 #ifndef QT_NO_GRAPHICSEFFECT
 …
     void addChild(QGraphicsItem *child);
     void removeChild(QGraphicsItem *child);
     void setParentItemHelper(QGraphicsItem *parent, const QVariant *newParentVariant,
                              const QVariant *thisPointerVariant);
     void childrenBoundingRectHelper(QTransform *x, QRectF *rect);
+    void childrenBoundingRectHelper(QTransform *x, QRectF *rect);
     void initStyleOption(QStyleOptionGraphicsItem *option, const QTransform &worldTransform,
                          const QRegion &exposedRegion, bool allItems = false) const;
     QRectF effectiveBoundingRect() const;
+    QRectF effectiveBoundingRect() const;
     QRectF sceneEffectiveBoundingRect() const;
 …
     void removeExtraItemCache();
     void ensureSceneTransformRecursive(QGraphicsItem **topMostDirtyItem);
     inline void ensureSceneTransform()
 …
     inline void markParentDirty(bool updateBoundingRect = false);
     void setFocusHelper(Qt::FocusReason focusReason, bool climb, bool focusFromShow);
+    void setFocusHelper(Qt::FocusReason focusReason, bool climb, bool focusFrom);
     void clearFocusHelper(bool giveFocusToParent);
     void setSubFocus(QGraphicsItem *rootItem = 0);
     void clearSubFocus(QGraphicsItem *rootItem = 0);
+    void setSubFocus(QGraphicsItem *rootItem = 0);
+    void clearSubFocus(QGraphicsItem *rootItem = 0);
     void resetFocusProxy();
     virtual void subFocusItemChange();
     inline QTransform transformToParent() const;
 …
     inline void sendScenePosChange();
     virtual void siblingOrderChange();
     QRectF childrenBoundingRect;
 …
     Qt::InputMethodHints imHints;
     QGraphicsItem::PanelModality panelModality;
     QMap<Qt::GestureType, Qt::GestureFlags> gestureContext;
     // Packed 32 bits
 …
     quint32 needSortChildren : 1;
     quint32 allChildrenDirty : 1;
     // Packed 32 bits
+    quint32 fullUpdatePending : 1;
+    quint32 flags : 17;
+    quint32 dirtyChildrenBoundingRect : 1;
+    quint32 flags : 18;
     quint32 paintedViewBoundingRectsNeedRepaint : 1;
     quint32 dirtySceneTransform : 1;
 …
     quint32 notifyBoundingRectChanged : 1;
     quint32 notifyInvalidated : 1;
     // New 32 bits
-    quint32 mouseSetsFocus : 1;
     quint32 explicitActivate : 1;
     quint32 wantsActive : 1;
 …
     quint32 pendingPolish : 1;
     quint32 mayHaveChildWithGraphicsEffect : 1;
     // Optional stacking order
 …
                && !(item->flags() & QGraphicsItem::ItemIsSelectable)
                && item->d_ptr->children.size() == 0;
             //|| (item->d_ptr->isObject && qobject_cast<QmlGraphicsImage *>(q_func()));
+            //|| (item->d_ptr->isObject && qobject_cast<QImage *>(q_func()));
+    }
 …
 /*!
     Returns true if \a item1 is on top of \a item2.
     The items dont need to be siblings.
+    The items dont need to be siblings.
     \internal
 …
 /*!
     Returns true if \a item2 is on top of \a item1.
     The items dont need to be siblings.
+    The items dont need to be siblings.
     \internal
 …
         if (parentp->graphicsEffect) {
             if (updateBoundingRect) {
-                parentp->notifyInvalidated = 1;
                 static_cast<QGraphicsItemEffectSourcePrivate *>(parentp->graphicsEffect->d_func()
                                                                 ->source->d_func())->invalidateCache();
+            }
             if (parentp->graphicsEffect->isEnabled()) {
+            if (parentp->graphicsEffect->isEnabled()) {
                 parentp->dirty = 1;
                 parentp->fullUpdatePending = 1;

trunk/src/gui/graphicsview/qgraphicsitemanimation.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation ([email protected])
 …
     rotations) at the same step is not recommended.
     \sa QTimeLine, {The Graphics View Framework}
+    \sa QTimeLine, {Graphics View Framework}
 */

trunk/src/gui/graphicsview/qgraphicsitemanimation.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation ([email protected])

trunk/src/gui/graphicsview/qgraphicslayout.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation ([email protected])
 …
         // does more than we need.
         layoutItem->d_func()->sizeHintCacheDirty = true;
+        layoutItem = layoutItem->parentLayoutItem();
+    }
+    if (layoutItem)
+        layoutItem->d_func()->sizeHintWithConstraintCacheDirty = true;
+        layoutItem = layoutItem->parentLayoutItem();
+    }
+    if (layoutItem) {
         layoutItem->d_func()->sizeHintCacheDirty = true;
     bool postIt = layoutItem ? !layoutItem->isLayout() : false;

trunk/src/gui/graphicsview/qgraphicslayout.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation ([email protected])

trunk/src/gui/graphicsview/qgraphicslayout_p.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation ([email protected])

trunk/src/gui/graphicsview/qgraphicslayout_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation ([email protected])

trunk/src/gui/graphicsview/qgraphicslayoutitem.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation ([email protected])
 …
 #include "qgraphicslayoutitem_p.h"
 #include "qwidget.h"
 #include <QtDebug>
 …
+{
     sizeHintCacheDirty = true;
     sizePolicy = QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
+    size;
+}
 …
+{
     Q_Q(const QGraphicsLayoutItem);
+    if (!sizeHintCacheDirty && cachedConstraint == constraint)
+        return cachedSizeHints;
+    QSizeF *sizeHintCache;
+    const bool hasConstraint = constraint.width() >= 0 || constraint.height() >= 0;
+    if (hasConstraint) {
+        if (!sizeHintWithConstraintCacheDirty && constraint == cachedConstraint)
+            return cachedSizeHintsWithConstraints;
+        sizeHintCache = cachedSizeHintsWithConstraints;
+    } else {
+        if (!sizeHintCacheDirty)
+            return cachedSizeHints;
+        sizeHintCache = cachedSizeHints;
+    }
     for (int i = 0; i < Qt::NSizeHints; ++i) {
         cachedSizeHints[i] = constraint;
+        [i] = constraint;
         if (userSizeHints)
             combineSize(cachedSizeHints[i], userSizeHints[i]);
+            combineSize([i], userSizeHints[i]);
+    }
     QSizeF &minS = cachedSizeHints[Qt::MinimumSize];
     QSizeF &prefS = cachedSizeHints[Qt::PreferredSize];
     QSizeF &maxS = cachedSizeHints[Qt::MaximumSize];
     QSizeF &descentS = cachedSizeHints[Qt::MinimumDescent];
+    QSizeF &minS = [Qt::MinimumSize];
+    QSizeF &prefS = [Qt::PreferredSize];
+    QSizeF &maxS = [Qt::MaximumSize];
+    QSizeF &descentS = [Qt::MinimumDescent];
     normalizeHints(minS.rwidth(), prefS.rwidth(), maxS.rwidth(), descentS.rwidth());
 …
     // COMBINE_SIZE(descentS, q->sizeHint(Qt::MinimumDescent, constraint));
+    cachedConstraint = constraint;
+    sizeHintCacheDirty = false;
+    return cachedSizeHints;
+    if (hasConstraint) {
+        cachedConstraint = constraint;
+        sizeHintWithConstraintCacheDirty = false;
+    } else {
+        sizeHintCacheDirty = false;
+    }
+    return sizeHintCache;
+}
 …
         if (size == userSizeHints[which])
             return;
     } else if (!size.isValid()) {
+    } else if () {
         return;
+    }
 …
+}
 /*!
     \class QGraphicsLayoutItem
 …
     Qt uses QGraphicsLayoutItem to provide layout functionality in the
     \l{The Graphics View Framework}, but in the future its use may spread
+    \l{Graphics View Framework}, but in the future its use may spread
     throughout Qt itself.
 …
     Q_D(QGraphicsLayoutItem);
     d->init();
     d->q_ptr = this;
+}
 …
+{
     Q_D(QGraphicsLayoutItem);
     d->q_ptr = this;
+}
 …
     Q_D(QGraphicsLayoutItem);
     d->sizeHintCacheDirty = true;
+}

trunk/src/gui/graphicsview/qgraphicslayoutitem.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation ([email protected])

trunk/src/gui/graphicsview/qgraphicslayoutitem_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation ([email protected])
 …
     virtual ~QGraphicsLayoutItemPrivate();
     QGraphicsLayoutItemPrivate(QGraphicsLayoutItem *parent, bool isLayout);
     void init();
     QSizeF *effectiveSizeHints(const QSizeF &constraint) const;
 …
     void setSizeComponent(Qt::SizeHint which, SizeComponent component, qreal value);
     QSizePolicy sizePolicy;
     QGraphicsLayoutItem *parent;
 …
     mutable QSizeF cachedSizeHints[Qt::NSizeHints];
     mutable QSizeF cachedConstraint;
     mutable quint32 sizeHintCacheDirty : 1;
     quint32 isLayout : 1;
     quint32 ownedByLayout : 1;

trunk/src/gui/graphicsview/qgraphicslinearlayout.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation ([email protected])
 …
     an alignment for each item by calling setAlignment(), and check the
     alignment for any item by calling alignment(). By default, items are
     centered both vertically and horizontally.
+    .
     \section1 Spacing within QGraphicsLinearLayout
 …
     int index = gridItem->firstRow(orientation);
     engine.removeItem(gridItem);
     engine.removeRow(index, orientation);
+    engine.removeRow, orientation);
+}
 …
+}
 QLayoutStyleInfo QGraphicsLinearLayoutPrivate::styleInfo() const
+{
-    static QWidget *wid = 0;
-    if (!wid)
-        wid = new QWidget;
     QGraphicsItem *item = parentItem();
     QStyle *style = (item && item->isWidget()) ? static_cast<QGraphicsWidget*>(item)->style() : QApplication::style();
     return QLayoutStyleInfo(style, wid);
+    return QLayoutStyleInfo(style, );
+}
 …
         return;
+    }
     d->addChildLayoutItem(item);
-    Q_ASSERT(item);
     d->fixIndex(&index);
     d->engine.insertRow(index, d->orientation);
     new QGridLayoutItem(&d->engine, item, d->gridRow(index), d->gridColumn(index), 1, 1, 0, index);
-    invalidate();
+}
 …
 /*!
     Returns the alignment for \a item. The default alignment is
     Qt::AlignCenter.
+    Qt::Align.
     The alignment decides how the item is positioned within its assigned space
 …
     qreal left, top, right, bottom;
     getContentsMargins(&left, &top, &right, &bottom);
+    return d->engine.sizeHint(d->styleInfo(), which , constraint) + QSizeF(left + right, top + bottom);
+    const QSizeF extraMargins(left + right, top + bottom);
+    return d->engine.sizeHint(d->styleInfo(), which , constraint - extraMargins) + extraMargins;
+}
 …
         d->engine.dump(indent + 1);
+    }
 #endif
+}

trunk/src/gui/graphicsview/qgraphicslinearlayout.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation ([email protected])

trunk/src/gui/graphicsview/qgraphicsproxywidget.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation ([email protected])
 …
+            }
             break;
         case QEvent::ToolTipChange:
             // Propagate tooltip change to the proxy.
 …
+            }
             break;
         default:
             break;
 …
     pos = d->mapToReceiver(pos, receiver);
     // Send mouse event. ### Doesn't propagate the event.
     QContextMenuEvent contextMenuEvent(QContextMenuEvent::Reason(event->reason()),
                                        pos.toPoint(), receiver->mapToGlobal(pos.toPoint()), event->modifiers());
+                                       pos.toPoint(), , event->modifiers());
     QApplication::sendEvent(receiver, &contextMenuEvent);
 …
   contained in this proxy.
   This function makes it possible to aquire proxies for
+  This function makes it possible to aquire proxies for
   non top-level widgets. For instance, you can embed a dialog,
   and then transform only one of its widgets.

trunk/src/gui/graphicsview/qgraphicsproxywidget.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation ([email protected])

trunk/src/gui/graphicsview/qgraphicsproxywidget_p.h

r769	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation ([email protected])

trunk/src/gui/graphicsview/qgraphicsscene.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation ([email protected])
 …
     with QGraphicsView for visualizing graphical items, such as lines,
     rectangles, text, or even custom items, on a 2D surface. QGraphicsScene is
     part of \l{The Graphics View Framework}.
+    part of Graphics View Framework}.
     QGraphicsScene also provides functionality that lets you efficiently
 …
 #include <QtCore/qtimer.h>
 #include <QtCore/qvarlengtharray.h>
 #include <QtGui/qapplication.h>
 #include <QtGui/qdesktopwidget.h>
 …
+}
-int QGraphicsScenePrivate::changedSignalIndex;
 /*!
     \internal
 …
       calledEmitUpdated(false),
       processDirtyItemsEmitted(false),
-      selectionChanging(0),
       needSortTopLevelItems(true),
       holesInTopLevelSiblingIndex(false),
 …
       stickyFocus(false),
       hasFocus(false),
       focusItem(0),
       lastFocusItem(0),
 …
       childExplicitActivation(0),
       lastMouseGrabberItem(0),
-      lastMouseGrabberItemHasImplicitMouseGrab(false),
       dragDropItem(0),
       enterWidget(0),
       lastDropAction(Qt::IgnoreAction),
+      allItemsIgnoreHoverEvents(true),
+      allItemsUseDefaultCursor(true),
+      painterStateProtection(true),
+      sortCacheEnabled(false),
+      style(0),
+      allItemsIgnoreTouchEvents(true)
+      style(0)
+{
+}
 …
     // Keep this index so we can check for connected slots later on.
+    if (!changedSignalIndex) {
+        changedSignalIndex = signalIndex("changed(QList<QRectF>)");
+    }
+    changedSignalIndex = signalIndex("changed(QList<QRectF>)");
+    processDirtyItemsIndex = q->metaObject()->indexOfSlot("_q_processDirtyItems()");
+    polishItemsIndex = q->metaObject()->indexOfSlot("_q_polishItems()");
     qApp->d_func()->scene_list.append(q);
     q->update();
 …
         lastMouseGrabberItem = 0;
     // Reenable selectionChanged() for individual items
     --selectionChanging;
 …
         emit q->selectionChanged();
     QHash<QGesture *, QGraphicsObject *>::iterator it;
     for (it = gestureTargets.begin(); it != gestureTargets.end();) {
 …
             ++it;
+    }
+}
 …
 #endif //QT_NO_IM
+    }
     if (item)
 …
+        }
         if (!itemIsDying && widget->isVisible()) {
+            widget->hide();
+            widget->QGraphicsItem::d_ptr->explicitlyHidden = 0;
+            widget->QGraphicsItem::d_ptr->setVisibleHelper(false, /* explicit = */ false);
+        }
+    }
 …
     Returns all items for the screen position in \a event.
 */
 QList<QGraphicsItem *> QGraphicsScenePrivate::itemsAtPosition(const QPoint &screenPos,
+QList<QGraphicsItem *> QGraphicsScenePrivate::itemsAtPosition(const QPoint &,
                                                               const QPointF &scenePos,
                                                               QWidget *widget) const
 …
         return q->items(scenePos, Qt::IntersectsItemShape, Qt::DescendingOrder, QTransform());
     const QRectF pointRect(QPointF(widget->mapFromGlobal(screenPos)), QSizeF(1, 1));
+    const QRectF pointRect(, QSizeF(1, 1));
     if (!view->isTransformed())
         return q->items(pointRect, Qt::IntersectsItemShape, Qt::DescendingOrder);
     const QTransform viewTransform = view->viewportTransform();
+    if (viewTransform.type() <= QTransform::TxScale) {
+        return q->items(viewTransform.inverted().mapRect(pointRect), Qt::IntersectsItemShape,
+                        Qt::DescendingOrder, viewTransform);
+    }
+    return q->items(viewTransform.inverted().map(pointRect), Qt::IntersectsItemShape,
+    return q->items(pointRect, Qt::IntersectsItemShape,
                     Qt::DescendingOrder, viewTransform);
+}
 …
+{
     if (QGraphicsObject *object = item->toGraphicsObject()) {
         QGestureManager *gestureManager = QApplicationPrivate::instance()->gestureManager;
         if (gestureManager) {
 …
                 return true;
+        }
+    }
 …
             break;
+        }
         if (item->isEnabled() && ((item->flags() & QGraphicsItem::ItemIsFocusable) && item->d_ptr->mouseSetsFocus)) {
+        if (item->isEnabled() && ((item->flags() & QGraphicsItem::ItemIsFocusable))) {
             if (!item->isWidget() || ((QGraphicsWidget *)item)->focusPolicy() & Qt::ClickFocus) {
                 setFocus = true;
                 if (item != q->focusItem())
+                if (item != q->focusItem())
                     q->setFocusItem(item, Qt::MouseFocusReason);
                 break;
+            }
+        }
         if (item->isPanel())
             break;
 …
     // Transform the painter.
     painter->setClipRect(targetRect);
+    painter->setClipRect(targetRect);
     QTransform painterTransform;
     painterTransform *= QTransform()
 …
+    }
+    if (d->unpolishedItems.isEmpty())
+        QMetaObject::invokeMethod(this, "_q_polishItems", Qt::QueuedConnection);
+    d->unpolishedItems.append(item);
+    item->d_ptr->pendingPolish = true;
+    // QDeclarativeItems do not rely on initial itemChanged message, as the componentComplete
+    // function allows far more opportunity for delayed-construction optimization.
+    if (!item->d_ptr->isDeclarativeItem) {
+        if (d->unpolishedItems.isEmpty()) {
+            QMetaMethod method = metaObject()->method(d->polishItemsIndex);
+            method.invoke(this, Qt::QueuedConnection);
+        }
+        d->unpolishedItems.append(item);
+        item->d_ptr->pendingPolish = true;
+    }
     // Detach this item from its parent if the parent's scene is different
 …
         d->enableTouchEventsOnViews();
+    }
     // Update selection lists
 …
             for (int i = 0; i < d->views.size(); ++i) {
                 QGraphicsView *view = d->views.at(i);
+                view->d_func()->updateRegion(QRegion(view->mapFromScene(rect).boundingRect()));
+                if (view->isTransformed())
+                    view->d_func()->updateRectF(view->viewportTransform().mapRect(rect));
+                else
+                    view->d_func()->updateRectF(rect);
+            }
         } else {
 …
         d->touchEventHandler(static_cast<QTouchEvent *>(event));
         break;
     case QEvent::Gesture:
     case QEvent::GestureOverride:
         d->gestureEventHandler(static_cast<QGestureEvent *>(event));
         break;
     default:
         return QObject::event(event);
 …
                                                                 wheelEvent->widget());
     bool hasSetFocus = false;
     foreach (QGraphicsItem *item, wheelCandidates) {
 …
         if (painterStateProtection)
             painter->restore();
+    }
 …
+}
 /*!
     \internal
 …
     QGraphicsItemCache *itemCache = itemd->extraItemCache();
     if (cacheMode == QGraphicsItem::ItemCoordinateCache) {
-        if (itemCache->boundingRect != brect.toRect()) {
-            itemCache->boundingRect = brect.toRect();
-            itemCache->allExposed = true;
-            itemCache->exposed.clear();
+        }
         pixmapKey = itemCache->key;
     } else {
 …
         QSize pixmapSize;
         bool fixedCacheSize = false;
         QRectF brectAligned = brect.toAlignedRect();
+        QRect = brect.toAlignedRect();
         if ((fixedCacheSize = itemCache->fixedSize.isValid())) {
             pixmapSize = itemCache->fixedSize;
         } else {
             pixmapSize = brectAligned.size().toSize();
+            pixmapSize = brize();
+        }
 …
         int adjust = itemCache->fixedSize.isValid() ? 0 : 2;
         QSize adjustSize(adjust*2, adjust*2);
         QRectF br = brectAligned.adjusted(-adjust, -adjust, adjust, adjust);
+        (-adjust, -adjust, adjust, adjust);
         if (pix.isNull() || (!fixedCacheSize && (pixmapSize + adjustSize) != pix.size())) {
             pix = QPixmap(pixmapSize + adjustSize);
             itemCache->exposed.clear();
             itemCache->allExposed = true;
 …
         if (newPainterOpacity != oldPainterOpacity) {
             painter->setOpacity(newPainterOpacity);
             painter->drawPixmap(br, pix, QRectF(QPointF(), pix.size()));
+            painter->drawPixmap(br);
             painter->setOpacity(oldPainterOpacity);
         } else {
             painter->drawPixmap(br, pix, QRectF(QPointF(), pix.size()));
+            painter->drawPixmap(br);
+        }
         return;
 …
             diff *= painter->worldTransform();
         deviceData->lastTransform = painter->worldTransform();
+        if (!invertable
+            || diff.type() > QTransform::TxTranslate
+            || painter->worldTransform().type() > QTransform::TxScale) {
+        bool allowPartialCacheExposure = false;
+        bool simpleTransform = invertable && diff.type() <= QTransform::TxTranslate
+                               && transformIsSimple(painter->worldTransform());
+        if (!simpleTransform) {
             pixModified = true;
             itemCache->allExposed = true;
             itemCache->exposed.clear();
             pix = QPixmap();
+        }
+        // ### This is a pretty bad way to determine when to start partial
+        // exposure for DeviceCoordinateCache but it's the least intrusive
+        // approach for now.
+#if 0
+        // Only if the device rect isn't fully contained.
+        bool allowPartialCacheExposure = !viewRect.contains(deviceRect);
+#else
+        // Only if deviceRect is 20% taller or wider than the desktop.
+        bool allowPartialCacheExposure = false;
+        if (widget) {
+            QRect desktopRect = QApplication::desktop()->availableGeometry(widget);
+            allowPartialCacheExposure = (desktopRect.width() * 1.2 < deviceRect.width()
+                                         || desktopRect.height() * 1.2 < deviceRect.height());
+        }
+#endif
+        } else if (!viewRect.isNull()) {
+            allowPartialCacheExposure = deviceData->cacheIndent != QPoint();
+        }
+        // Allow partial cache exposure if the device rect isn't fully contained and
+        // deviceRect is 20% taller or wider than the viewRect.
+        if (!allowPartialCacheExposure && !viewRect.isNull() && !viewRect.contains(deviceRect)) {
+            allowPartialCacheExposure = (viewRect.width() * 1.2 < deviceRect.width())
+                                         || (viewRect.height() * 1.2 < deviceRect.height());
+        }
         QRegion scrollExposure;
         if (deviceData->cacheIndent != QPoint() || allowPartialCacheExposure) {
+        if (allowPartialCacheExposure) {
             // Part of pixmap is drawn. Either device contains viewrect (big
             // item covers whole screen) or parts of device are outside the
 …
         const QRectF brect = adjustedItemEffectiveBoundingRect(item);
         ENSURE_TRANSFORM_PTR
+        QRect viewBoundingRect = translateOnlyTransform ? brect.translated(transformPtr->dx(), transformPtr->dy()).toRect()
+                                                        : transformPtr->mapRect(brect).toRect();
+        QRect viewBoundingRect = translateOnlyTransform ? brect.translated(transformPtr->dx(), transformPtr->dy()).toAlignedRect()
+                                                        : transformPtr->mapRect(brect).toAlignedRect();
+        viewBoundingRect.adjust(-int(rectAdjust), -int(rectAdjust), rectAdjust, rectAdjust);
         if (widget)
             item->d_ptr->paintedViewBoundingRects.insert(widget, viewBoundingRect);
-        viewBoundingRect.adjust(-1, -1, 1, 1);
         drawItem = exposedRegion ? exposedRegion->intersects(viewBoundingRect)
                                  : !viewBoundingRect.normalized().isEmpty();
 …
         ENSURE_TRANSFORM_PTR;
         QGraphicsItemPaintInfo info(viewTransform, transformPtr, effectTransform, exposedRegion, widget, &styleOptionTmp,
                                     painter, opacity, wasDirtyParentSceneTransform, drawItem);
+                                    painter, opacity, wasDirtyParentSceneTransform, );
         QGraphicsEffectSource *source = item->d_ptr->graphicsEffect->d_func()->source;
         QGraphicsItemEffectSourcePrivate *sourced = static_cast<QGraphicsItemEffectSourcePrivate *>
 …
+}
 void QGraphicsScenePrivate::draw(QGraphicsItem *item, QPainter *painter, const QTransform *const viewTransform,
                                  const QTransform *const transformPtr, QRegion *exposedRegion, QWidget *widget,
 …
     const bool itemClipsChildrenToShape = (item->d_ptr->flags & QGraphicsItem::ItemClipsChildrenToShape);
     const bool itemHasChildren = !item->d_ptr->children.isEmpty();
     int i = 0;
     if (itemHasChildren) {
         item->d_ptr->ensureSortedChildren();
+        if (itemClipsChildrenToShape) {
+            painter->save();
+            Q_ASSERT(transformPtr);
+            if (effectTransform)
+                painter->setWorldTransform(*transformPtr * *effectTransform);
+            else
+                painter->setWorldTransform(*transformPtr);
+            QRectF clipRect;
+            const QPainterPath clipPath(item->shape());
+            if (QPathClipper::pathToRect(clipPath, &clipRect))
+                painter->setClipRect(clipRect, Qt::IntersectClip);
+            else
+                painter->setClipPath(clipPath, Qt::IntersectClip);
+        }
+        // Draw children behind
+        for (i = 0; i < item->d_ptr->children.size(); ++i) {
+            QGraphicsItem *child = item->d_ptr->children.at(i);
+            if (wasDirtyParentSceneTransform)
+                child->d_ptr->dirtySceneTransform = 1;
+            if (!(child->d_ptr->flags & QGraphicsItem::ItemStacksBehindParent))
+                break;
+            if (itemIsFullyTransparent && !(child->d_ptr->flags & QGraphicsItem::ItemIgnoresParentOpacity))
+                continue;
+            drawSubtreeRecursive(child, painter, viewTransform, exposedRegion, widget, opacity, effectTransform);
+        // Items with the 'ItemStacksBehindParent' flag are put in front of the list
+        // so all we have to do is to check the first item.
+        itemHasChildrenStackedBehind = (item->d_ptr->children.at(0)->d_ptr->flags
+                                        & QGraphicsItem::ItemStacksBehindParent);
+        if (itemHasChildrenStackedBehind) {
+            if (itemClipsChildrenToShape) {
+                setClip(painter, item);
+                setChildClip = false;
+            }
+            // Draw children behind
+            for (i = 0; i < item->d_ptr->children.size(); ++i) {
+                QGraphicsItem *child = item->d_ptr->children.at(i);
+                if (wasDirtyParentSceneTransform)
+                    child->d_ptr->dirtySceneTransform = 1;
+                if (!(child->d_ptr->flags & QGraphicsItem::ItemStacksBehindParent))
+                    break;
+                if (itemIsFullyTransparent && !(child->d_ptr->flags & QGraphicsItem::ItemIgnoresParentOpacity))
+                    continue;
+                drawSubtreeRecursive(child, painter, viewTransform, exposedRegion, widget, opacity, effectTransform);
+            }
+        }
+    }
 …
         const bool itemClipsToShape = item->d_ptr->flags & QGraphicsItem::ItemClipsToShape;
+        const bool savePainter = itemClipsToShape || painterStateProtection;
+        if (savePainter)
+        bool restorePainterClip = false;
+        if (!itemHasChildren || !itemClipsChildrenToShape) {
+            // Item does not have children or clip children to shape.
+            setWorldTransform(painter, transformPtr, effectTransform);
+            if ((restorePainterClip = itemClipsToShape))
+                setClip(painter, item);
+        } else if (itemHasChildrenStackedBehind){
+            // Item clips children to shape and has children stacked behind, which means
+            // the painter is already clipped to the item's shape.
+            if (itemClipsToShape) {
+                // The clip is already correct. Ensure correct world transform.
+                setWorldTransform(painter, transformPtr, effectTransform);
+            } else {
+                // Remove clip (this also ensures correct world transform).
+                painter->restore();
+                setChildClip = true;
+            }
+        } else if (itemClipsToShape) {
+            // Item clips children and itself to shape. It does not have hildren stacked
+            // behind, which means the clip has not yet been set. We set it now and re-use it
+            // for the children.
+            setClip(painter, item);
+            setChildClip = false;
+        }
+        if (painterStateProtection && !restorePainterClip)
             painter->save();
-        if (!itemHasChildren || !itemClipsChildrenToShape) {
-            if (effectTransform)
-                painter->setWorldTransform(*transformPtr * *effectTransform);
-            else
-                painter->setWorldTransform(*transformPtr);
+        }
-        if (itemClipsToShape) {
-            QRectF clipRect;
-            const QPainterPath clipPath(item->shape());
-            if (QPathClipper::pathToRect(clipPath, &clipRect))
-                painter->setClipRect(clipRect, Qt::IntersectClip);
-            else
-                painter->setClipPath(clipPath, Qt::IntersectClip);
+        }
         painter->setOpacity(opacity);
         if (!item->d_ptr->cacheMode && !item->d_ptr->isWidget)
             item->paint(painter, &styleOptionTmp, widget);
 …
             drawItemHelper(item, painter, &styleOptionTmp, widget, painterStateProtection);
         if (savePainter)
+        if ()
             painter->restore();
+    }
 …
     // Draw children in front
     if (itemHasChildren) {
         for (; i < item->d_ptr->children.size(); ++i) {
             QGraphicsItem *child = item->d_ptr->children.at(i);
 …
             drawSubtreeRecursive(child, painter, viewTransform, exposedRegion, widget, opacity, effectTransform);
+        }
+    }
     // Restore child clip
     if (itemHasChildren && itemClipsChildrenToShape)
         painter->restore();
+        // Restore child clip
+}
 …
     if (updateAll)
         return;
     if (item->d_ptr->discardUpdateRequest(/*ignoreVisibleBit=*/force,
 …
     if (!processDirtyItemsEmitted) {
+        QMetaObject::invokeMethod(q_ptr, "_q_processDirtyItems", Qt::QueuedConnection);
+        QMetaMethod method = q_ptr->metaObject()->method(processDirtyItemsIndex);
+        method.invoke(q_ptr, Qt::QueuedConnection);
+//        QMetaObject::invokeMethod(q_ptr, "_q_processDirtyItems", Qt::QueuedConnection);
         processDirtyItemsEmitted = true;
+    }
 …
+    }
+    bool hasNoContents = item->d_ptr->flags & QGraphicsItem::ItemHasNoContents
+                         && !item->d_ptr->graphicsEffect;
+    bool hasNoContents = item->d_ptr->flags & QGraphicsItem::ItemHasNoContents;
     if (!hasNoContents) {
         item->d_ptr->dirty = 1;
 …
         else if (!item->d_ptr->fullUpdatePending)
             item->d_ptr->needsRepaint |= rect;
+    }
 …
         const QTransform xform = itemq->deviceTransform(viewq->viewportTransform());
         if (!item->hasBoundingRegionGranularity)
             return view->updateRect(xform.mapRect(rect).toRect());
         return view->updateRegion(xform.map(QRegion(rect.toRect())));
+            return view->updateRect));
+        return view->updateRegion();
+    }
 …
         const qreal dx = item->sceneTransform.dx();
         const qreal dy = item->sceneTransform.dy();
+        if (!item->hasBoundingRegionGranularity) {
+            QRectF r(rect);
+            r.translate(dx - view->horizontalScroll(), dy - view->verticalScroll());
+            return view->updateRect(r.toRect());
+        }
+        QRegion r(rect.toRect());
+        r.translate(qRound(dx) - view->horizontalScroll(), qRound(dy) - view->verticalScroll());
+        return view->updateRegion(r);
+        QRectF r(rect);
+        r.translate(dx - view->horizontalScroll(), dy - view->verticalScroll());
+        return view->updateRectF(r);
+    }
     if (!viewq->isTransformed()) {
         if (!item->hasBoundingRegionGranularity)
             return view->updateRect(item->sceneTransform.mapRect(rect).toRect());
         return view->updateRegion(item->sceneTransform.map(QRegion(rect.toRect())));
+            return view->updateRect));
+        return view->updateRegion();
+    }
 …
     xform *= viewq->viewportTransform();
     if (!item->hasBoundingRegionGranularity)
         return view->updateRect(xform.mapRect(rect).toRect());
     return view->updateRegion(xform.map(QRegion(rect.toRect())));
+        return view->updateRect));
+    return view->updateRegion();
+}
 …
                                                       item->d_ptr->sceneTransform.dy()));
             } else {
+                q->update(item->d_ptr->sceneTransform.mapRect(itemBoundingRect));
+                QRectF rect = item->d_ptr->sceneTransform.mapRect(itemBoundingRect);
+                if (!rect.isEmpty())
+                    q->update(rect);
+            }
         } else {
 …
     // Process children.
     if (itemHasChildren && item->d_ptr->dirtyChildren) {
         if (!dirtyAncestorContainsChildren) {
             dirtyAncestorContainsChildren = item->d_ptr->fullUpdatePending
                                             && (item->d_ptr->flags & QGraphicsItem::ItemClipsChildrenToShape);
+                                            && ;
+        }
         const bool allChildrenDirty = item->d_ptr->allChildrenDirty;
 …
             processDirtyItemsRecursive(child, dirtyAncestorContainsChildren, opacity);
+        }
     } else if (wasDirtyParentSceneTransform) {
         item->d_ptr->invalidateChildrenSceneTransform();
 …
         d->_q_polishItems();
     d->updateAll = false;
+    ;
     QTransform viewTransform = painter->worldTransform();
     Q_UNUSED(options);
 …
     QGraphicsView *view = widget ? qobject_cast<QGraphicsView *>(widget->parentWidget()) : 0;
     QRegion *expose = 0;
+    if (view)
+    const quint32 oldRectAdjust = d->rectAdjust;
+    if (view) {
+        d->updateAll = false;
         expose = &view->d_func()->exposedRegion;
     // Find all toplevels, they are already sorted.
 …
+    }
     // Reset discovery bits.
     for (int i = 0; i < topLevelItems.size(); ++i)
 …
     painter->setWorldTransform(viewTransform);
+}
 …
+{
     views << view;
+}
 …
             if (sceneTouchEvent->deviceType() == QTouchEvent::TouchScreen) {
+                // on touch-screens, combine this touch point with the closest one we find if it
+                // is a a direct descendent or ancestor (
+                // on touch-screens, combine this touch point with the closest one we find
                 int closestTouchPointId = findClosestTouchPointId(touchPoint.scenePos());
                 QGraphicsItem *closestItem = itemForTouchPointId.value(closestTouchPointId);
+                if (!item
+                    || (closestItem
+                        && (item->isAncestorOf(closestItem)
+                            || closestItem->isAncestorOf(item)))) {
+                if (!item || (closestItem && cachedItemsUnderMouse.contains(closestItem)))
                     item = closestItem;
+                }
+            }
             if (!item)
 …
+}
+void QGraphicsScenePrivate::getGestureTargets(const QSet<QGesture *> &gestures,
+                                              QWidget *viewport,
+                                              QMap<Qt::GestureType, QGesture *> *conflictedGestures,
+                                              QList<QList<QGraphicsObject *> > *conflictedItems,
+                                              QHash<QGesture *, QGraphicsObject *> *normalGestures)
+{
+#ifndef QT_NO_GESTURES
+void QGraphicsScenePrivate::gestureTargetsAtHotSpots(const QSet<QGesture *> &gestures,
+                                              Qt::GestureFlag flag,
+                                              QHash<QGraphicsObject *, QSet<QGesture *> > *targets,
+                                              QSet<QGraphicsObject *> *itemsSet,
+                                              QSet<QGesture *> *normal,
+                                              QSet<QGesture *> *conflicts)
+{
+    QSet<QGesture *> normalGestures; // that are not in conflicted state.
     foreach (QGesture *gesture, gestures) {
+        Qt::GestureType gestureType = gesture->gestureType();
+        if (gesture->hasHotSpot()) {
+            QPoint screenPos = gesture->hotSpot().toPoint();
+            QList<QGraphicsItem *> items = itemsAtPosition(screenPos, QPointF(), viewport);
+            QList<QGraphicsObject *> result;
+            for (int j = 0; j < items.size(); ++j) {
+                QGraphicsItem *item = items.at(j);
+                // Check if the item is blocked by a modal panel and use it as
+                // a target instead of this item.
+                (void) item->isBlockedByModalPanel(&item);
+                if (QGraphicsObject *itemobj = item->toGraphicsObject()) {
+                    QGraphicsItemPrivate *d = item->d_func();
+                    if (d->gestureContext.contains(gestureType)) {
+                        result.append(itemobj);
+        if (!gesture->hasHotSpot())
+            continue;
+        const Qt::GestureType gestureType = gesture->gestureType();
+        QList<QGraphicsItem *> items = itemsAtPosition(QPoint(), gesture->d_func()->sceneHotSpot, 0);
+        for (int j = 0; j < items.size(); ++j) {
+            QGraphicsItem *item = items.at(j);
+            // Check if the item is blocked by a modal panel and use it as
+            // a target instead of this item.
+            (void) item->isBlockedByModalPanel(&item);
+            if (QGraphicsObject *itemobj = item->toGraphicsObject()) {
+                QGraphicsItemPrivate *d = item->QGraphicsItem::d_func();
+                QMap<Qt::GestureType, Qt::GestureFlags>::const_iterator it =
+                        d->gestureContext.find(gestureType);
+                if (it != d->gestureContext.end() && (!flag || (it.value() & flag))) {
+                    if (normalGestures.contains(gesture)) {
+                        normalGestures.remove(gesture);
+                        if (conflicts)
+                            conflicts->insert(gesture);
+                    } else {
+                        normalGestures.insert(gesture);
+                    }
+                }
-                // Don't propagate through panels.
-                if (item->isPanel())
-                    break;
+            }
+            DEBUG() << "QGraphicsScenePrivate::getGestureTargets:"
+                    << gesture << result;
+            if (result.size() == 1) {
+                normalGestures->insert(gesture, result.first());
+            } else if (!result.isEmpty()) {
+                conflictedGestures->insert(gestureType, gesture);
+                conflictedItems->append(result);
+            }
+        }
+    }
+            // Don't propagate through panels.
+            if (item->isPanel())
+                break;
+        }
+    }
+    if (normal)
+        *normal = normalGestures;
+}
 …
     if (!viewport)
         return;
     QList<QGesture *> allGestures = event->gestures();
     DEBUG() << "QGraphicsScenePrivate::gestureEventHandler:"
+            << "Delivering gestures:" <<  allGestures;
+    typedef QHash<QGraphicsObject *, QList<QGesture *> > GesturesPerItem;
+    GesturesPerItem gesturesPerItem;
+            << "Gestures:" <<  allGestures;
     QSet<QGesture *> startedGestures;
     foreach (QGesture *gesture, allGestures) {
         QGraphicsObject *target = gestureTargets.value(gesture, 0);
         if (!target) {
 …
             if (gesture->state() == Qt::GestureStarted)
                 startedGestures.insert(gesture);
+        } else {
+            gesturesPerItem[target].append(gesture);
+        }
+    }
+    QMap<Qt::GestureType, QGesture *> conflictedGestures;
+    QList<QList<QGraphicsObject *> > conflictedItems;
+    QHash<QGesture *, QGraphicsObject *> normalGestures;
+    getGestureTargets(startedGestures, viewport, &conflictedGestures, &conflictedItems,
+                      &normalGestures);
+    DEBUG() << "QGraphicsScenePrivate::gestureEventHandler:"
+            << "Conflicting gestures:" <<  conflictedGestures.values() << conflictedItems;
+    Q_ASSERT((conflictedGestures.isEmpty() && conflictedItems.isEmpty()) ||
+              (!conflictedGestures.isEmpty() && !conflictedItems.isEmpty()));
+    // gestures that were sent as override events, but no one accepted them
+    QHash<QGesture *, QGraphicsObject *> ignoredConflictedGestures;
+    // deliver conflicted gestures as override events first
+    while (!conflictedGestures.isEmpty() && !conflictedItems.isEmpty()) {
+        // get the topmost item to deliver the override event
+        Q_ASSERT(!conflictedItems.isEmpty());
+        Q_ASSERT(!conflictedItems.first().isEmpty());
+        QGraphicsObject *topmost = conflictedItems.first().first();
+        for (int i = 1; i < conflictedItems.size(); ++i) {
+            QGraphicsObject *item = conflictedItems.at(i).first();
+            if (qt_closestItemFirst(item, topmost)) {
+                topmost = item;
+        }
+    }
+    if (!startedGestures.isEmpty()) {
+        QSet<QGesture *> normalGestures; // that have just one target
+        QSet<QGesture *> conflictedGestures; // that have multiple possible targets
+        gestureTargetsAtHotSpots(startedGestures, Qt::GestureFlag(0), &cachedItemGestures, 0,
+                                 &normalGestures, &conflictedGestures);
+        cachedTargetItems = cachedItemGestures.keys();
+        qSort(cachedTargetItems.begin(), cachedTargetItems.end(), qt_closestItemFirst);
+        DEBUG() << "QGraphicsScenePrivate::gestureEventHandler:"
+                << "Normal gestures:" << normalGestures
+                << "Conflicting gestures:" << conflictedGestures;
+        // deliver conflicted gestures as override events AND remember
+        // initial gesture targets
+        if (!conflictedGestures.isEmpty()) {
+            for (int i = 0; i < cachedTargetItems.size(); ++i) {
+                QWeakPointer<QGraphicsObject> item = cachedTargetItems.at(i);
+                // get gestures to deliver to the current item
+                QSet<QGesture *> gestures = conflictedGestures & cachedItemGestures.value(item.data());
+                if (gestures.isEmpty())
+                    continue;
+                DEBUG() << "QGraphicsScenePrivate::gestureEventHandler:"
+                        << "delivering override to"
+                        << item.data() << gestures;
+                // send gesture override
+                QGestureEvent ev(gestures.toList());
+                ev.t = QEvent::GestureOverride;
+                ev.setWidget(event->widget());
+                // mark event and individual gestures as ignored
+                ev.ignore();
+                foreach(QGesture *g, gestures)
+                    ev.setAccepted(g, false);
+                sendEvent(item.data(), &ev);
+                // mark all accepted gestures to deliver them as normal gesture events
+                foreach (QGesture *g, gestures) {
+                    if (ev.isAccepted() || ev.isAccepted(g)) {
+                        conflictedGestures.remove(g);
+                        // mark the item as a gesture target
+                        if (item) {
+                            gestureTargets.insert(g, item.data());
+                            QHash<QGraphicsObject *, QSet<QGesture *> >::iterator it, e;
+                            it = cachedItemGestures.begin();
+                            e = cachedItemGestures.end();
+                            for(; it != e; ++it)
+                                it.value().remove(g);
+                            cachedItemGestures[item.data()].insert(g);
+                        }
+                        DEBUG() << "QGraphicsScenePrivate::gestureEventHandler:"
+                                << "override was accepted:"
+                                << g << item.data();
+                    }
+                    // remember the first item that received the override event
+                    // as it most likely become a target if no one else accepts
+                    // the override event
+                    if (!gestureTargets.contains(g) && item)
+                        gestureTargets.insert(g, item.data());
+                }
+                if (conflictedGestures.isEmpty())
+                    break;
+            }
+        }
+        // get a list of gestures to send to the item
+        QList<Qt::GestureType> grabbedGestures =
+                topmost->QGraphicsItem::d_func()->gestureContext.keys();
+        QList<QGesture *> gestures;
+        for (int i = 0; i < grabbedGestures.size(); ++i) {
+            if (QGesture *g = conflictedGestures.value(grabbedGestures.at(i), 0)) {
+                gestures.append(g);
+                if (!ignoredConflictedGestures.contains(g))
+                    ignoredConflictedGestures.insert(g, topmost);
+            }
+        }
+        // send gesture override to the topmost item
+        QGestureEvent ev(gestures);
+        ev.t = QEvent::GestureOverride;
+        ev.setWidget(event->widget());
+        // mark event and individual gestures as ignored
+        ev.ignore();
+        foreach(QGesture *g, gestures)
+            ev.setAccepted(g, false);
+        DEBUG() << "QGraphicsScenePrivate::gestureEventHandler:"
+                << "delivering override to"
+                << topmost << gestures;
+        sendEvent(topmost, &ev);
+        // mark all accepted gestures to deliver them as normal gesture events
+        foreach (QGesture *g, gestures) {
+            if (ev.isAccepted() || ev.isAccepted(g)) {
+                conflictedGestures.remove(g->gestureType());
+                gestureTargets.remove(g);
+                // add the gesture to the list of normal delivered gestures
+                normalGestures.insert(g, topmost);
+                DEBUG() << "QGraphicsScenePrivate::gestureEventHandler:"
+                        << "override was accepted:"
+                        << g << topmost;
+                ignoredConflictedGestures.remove(g);
+            }
+        }
+        // remove the item that we've already delivered from the list
+        for (int i = 0; i < conflictedItems.size(); ) {
+            QList<QGraphicsObject *> &items = conflictedItems[i];
+            if (items.first() == topmost) {
+                items.removeFirst();
+                if (items.isEmpty()) {
+                    conflictedItems.removeAt(i);
+                    continue;
+        // remember the initial target item for each gesture that was not in
+        // the conflicted state.
+        if (!normalGestures.isEmpty()) {
+            for (int i = 0; i < cachedTargetItems.size() && !normalGestures.isEmpty(); ++i) {
+                QGraphicsObject *item = cachedTargetItems.at(i);
+                // get gestures to deliver to the current item
+                foreach (QGesture *g, cachedItemGestures.value(item)) {
+                    if (!gestureTargets.contains(g)) {
+                        gestureTargets.insert(g, item);
+                        normalGestures.remove(g);
+                    }
+                }
+            }
+            ++i;
+        }
+    }
+    // put back those started gestures that are not in the conflicted state
+    // and remember their targets
+    QHash<QGesture *, QGraphicsObject *>::const_iterator it = normalGestures.begin(),
+                                                          e = normalGestures.end();
+    for (; it != e; ++it) {
+        QGesture *g = it.key();
+        QGraphicsObject *receiver = it.value();
+        Q_ASSERT(!gestureTargets.contains(g));
+        gestureTargets.insert(g, receiver);
+        gesturesPerItem[receiver].append(g);
+    }
+    it = ignoredConflictedGestures.begin();
+    e = ignoredConflictedGestures.end();
+    for (; it != e; ++it) {
+        QGesture *g = it.key();
+        QGraphicsObject *receiver = it.value();
+        Q_ASSERT(!gestureTargets.contains(g));
+        gestureTargets.insert(g, receiver);
+        gesturesPerItem[receiver].append(g);
+    }
+    DEBUG() << "QGraphicsScenePrivate::gestureEventHandler:"
+            << "Started gestures:" << normalGestures.keys()
+            << "All gestures:" << gesturesPerItem.values();
+    // deliver all events
+    QList<QGesture *> alreadyIgnoredGestures;
+    QHash<QGraphicsObject *, QSet<QGesture *> > itemIgnoredGestures;
+    QList<QGraphicsObject *> targetItems = gesturesPerItem.keys();
+    qSort(targetItems.begin(), targetItems.end(), qt_closestItemFirst);
+    for (int i = 0; i < targetItems.size(); ++i) {
+        QGraphicsObject *item = targetItems.at(i);
+        QList<QGesture *> gestures = gesturesPerItem.value(item);
+        // remove gestures that were already delivered once and were ignored
+        DEBUG() << "QGraphicsScenePrivate::gestureEventHandler:"
+                << "already ignored gestures for item"
+                << item << ":" << itemIgnoredGestures.value(item);
+        if (itemIgnoredGestures.contains(item)) // don't deliver twice to the same item
+            continue;
+        QGraphicsItemPrivate *gid = item->QGraphicsItem::d_func();
+        foreach(QGesture *g, alreadyIgnoredGestures) {
+            QMap<Qt::GestureType, Qt::GestureFlags>::iterator contextit =
+                    gid->gestureContext.find(g->gestureType());
+            bool deliver = contextit != gid->gestureContext.end() &&
+                (g->state() == Qt::GestureStarted ||
+                 (contextit.value() & Qt::ReceivePartialGestures));
+            if (deliver)
+                gestures += g;
+        }
+        }
+    }
+    // deliver all gesture events
+    QSet<QGesture *> undeliveredGestures;
+    QSet<QGesture *> parentPropagatedGestures;
+    foreach (QGesture *gesture, allGestures) {
+        if (QGraphicsObject *target = gestureTargets.value(gesture, 0)) {
+            cachedItemGestures[target].insert(gesture);
+            cachedTargetItems.append(target);
+            undeliveredGestures.insert(gesture);
+            QGraphicsItemPrivate *d = target->QGraphicsItem::d_func();
+            const Qt::GestureFlags flags = d->gestureContext.value(gesture->gestureType());
+            if (flags & Qt::IgnoredGesturesPropagateToParent)
+                parentPropagatedGestures.insert(gesture);
+        } else {
+            DEBUG() << "QGraphicsScenePrivate::gestureEventHandler:"
+                    << "no target for" << gesture << "at"
+                    << gesture->hotSpot() << gesture->d_func()->sceneHotSpot;
+        }
+    }
+    qSort(cachedTargetItems.begin(), cachedTargetItems.end(), qt_closestItemFirst);
+    for (int i = 0; i < cachedTargetItems.size(); ++i) {
+        QWeakPointer<QGraphicsObject> receiver = cachedTargetItems.at(i);
+        QSet<QGesture *> gestures =
+                undeliveredGestures & cachedItemGestures.value(receiver.data());
+        gestures -= cachedAlreadyDeliveredGestures.value(receiver.data());
         if (gestures.isEmpty())
             continue;
         DEBUG() << "QGraphicsScenePrivate::gestureEventHandler:"
                 << "delivering to"
                 << item << gestures;
         QGestureEvent ev(gestures);
+                <<  << gestures;
+        QGestureEvent ev(gestures);
         ev.setWidget(event->widget());
         sendEvent(item, &ev);
+        sendEvent(, &ev);
         QSet<QGesture *> ignoredGestures;
         foreach (QGesture *g, gestures) {
             if (!ev.isAccepted() && !ev.isAccepted(g)) {
+                ignoredGestures.insert(g);
+                // if the gesture was ignored by its target, we will update the
+                // targetItems list with a possible target items (items that
+                // want to receive partial gestures).
+                // ### wont' work if the target was destroyed in the event
+                //     we will just stop delivering it.
+                if (receiver && receiver.data() == gestureTargets.value(g, 0))
+                    ignoredGestures.insert(g);
             } else {
+                if (g->state() == Qt::GestureStarted)
+                    gestureTargets[g] = item;
+                if (receiver && g->state() == Qt::GestureStarted) {
+                    // someone accepted the propagated initial GestureStarted
+                    // event, let it be the new target for all following events.
+                    gestureTargets[g] = receiver.data();
+                }
+                undeliveredGestures.remove(g);
+            }
+        }
+        if (!ignoredGestures.isEmpty()) {
+            // get a list of items under the (current) hotspot of each ignored
+            // gesture and start delivery again from the beginning
+        if (undeliveredGestures.isEmpty())
+            break;
+        // ignoredGestures list is only filled when delivering to the gesture
+        // target item, so it is safe to assume item == target.
+        if (!ignoredGestures.isEmpty() && !isPanel) {
+            // look for new potential targets for gestures that were ignored
+            // and should be propagated.
+            QSet<QGraphicsObject *> targetsSet = cachedTargetItems.toSet();
+            if (receiver) {
+                // first if the gesture should be propagated to parents only
+                for (QSet<QGesture *>::iterator it = ignoredGestures.begin();
+                     it != ignoredGestures.end();) {
+                    if (parentPropagatedGestures.contains(*it)) {
+                        QGesture *gesture = *it;
+                        const Qt::GestureType gestureType = gesture->gestureType();
+                        QGraphicsItem *item = receiver.data();
+                        while (item) {
+                            if (QGraphicsObject *obj = item->toGraphicsObject()) {
+                                if (item->d_func()->gestureContext.contains(gestureType)) {
+                                    targetsSet.insert(obj);
+                                    cachedItemGestures[obj].insert(gesture);
+                                }
+                            }
+                            if (item->isPanel())
+                                break;
+                            item = item->parentItem();
+                        }
+                        it = ignoredGestures.erase(it);
+                        continue;
+                    }
+                    ++it;
+                }
+            }
+            gestureTargetsAtHotSpots(ignoredGestures, Qt::ReceivePartialGestures,
+                                     &cachedItemGestures, &targetsSet, 0, 0);
+            cachedTargetItems = targetsSet.toList();
+            qSort(cachedTargetItems.begin(), cachedTargetItems.end(), qt_closestItemFirst);
             DEBUG() << "QGraphicsScenePrivate::gestureEventHandler:"
+                    << "item has ignored the event, will propagate."
+                    << item << ignoredGestures;
+            itemIgnoredGestures[item] += ignoredGestures;
+            QMap<Qt::GestureType, QGesture *> conflictedGestures;
+            QList<QList<QGraphicsObject *> > itemsForConflictedGestures;
+            QHash<QGesture *, QGraphicsObject *> normalGestures;
+            getGestureTargets(ignoredGestures, viewport,
+                              &conflictedGestures, &itemsForConflictedGestures,
+                              &normalGestures);
+            QSet<QGraphicsObject *> itemsSet = targetItems.toSet();
+            for (int k = 0; k < itemsForConflictedGestures.size(); ++k)
+                itemsSet += itemsForConflictedGestures.at(k).toSet();
+            targetItems = itemsSet.toList();
+            qSort(targetItems.begin(), targetItems.end(), qt_closestItemFirst);
+            alreadyIgnoredGestures = conflictedGestures.values();
+            DEBUG() << "QGraphicsScenePrivate::gestureEventHandler:"
+                    << "new targets:" << targetItems;
+                    << "new targets:" << cachedTargetItems;
             i = -1; // start delivery again
             continue;
+        }
+    }
     foreach (QGesture *g, startedGestures) {
         if (g->gestureCancelPolicy() == QGesture::CancelAllInContext) {
             DEBUG() << "lets try to cancel some";
             // find gestures in context in Qt::GestureStarted or Qt::GestureUpdated state and cancel them
             cancelGesturesForChildren(g, event->widget());
+            cancelGesturesForChildren(g);
+        }
+    }
 …
+        }
+    }
+}
+void QGraphicsScenePrivate::cancelGesturesForChildren(QGesture *original, QWidget *viewport)
+    cachedTargetItems.clear();
+    cachedItemGestures.clear();
+    cachedAlreadyDeliveredGestures.clear();
+}
+void QGraphicsScenePrivate::cancelGesturesForChildren(QGesture *original)
+{
     Q_ASSERT(original);
     QGraphicsItem *originalItem = gestureTargets.value(original);
+    Q_ASSERT(originalItem);
+    if (originalItem == 0) // we only act on accepted gestures, which implies it has a target.
+        return;
     // iterate over all active gestures and for each find the owner
 …
                 continue;
+            QPoint screenPos = g->hotSpot().toPoint();
+            QList<QGraphicsItem *> items = itemsAtPosition(screenPos, QPointF(), viewport);
+            QList<QGraphicsItem *> items = itemsAtPosition(QPoint(), g->d_func()->sceneHotSpot, 0);
             for (int j = 0; j < items.size(); ++j) {
                 QGraphicsObject *item = items.at(j)->toGraphicsObject();
 …
+}
 QT_END_NAMESPACE

trunk/src/gui/graphicsview/qgraphicsscene.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation ([email protected])
 …
     friend class QGraphicsItem;
     friend class QGraphicsItemPrivate;
     friend class QGraphicsView;
     friend class QGraphicsViewPrivate;
 …
     friend class QGraphicsSceneBspTreeIndexPrivate;
     friend class QGraphicsItemEffectSourcePrivate;
     friend class QGesture;
 };

trunk/src/gui/graphicsview/qgraphicsscene_bsp.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation ([email protected])

trunk/src/gui/graphicsview/qgraphicsscene_bsp_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation ([email protected])

trunk/src/gui/graphicsview/qgraphicsscene_p.h

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation ([email protected])
 …
     static QGraphicsScenePrivate *get(QGraphicsScene *q);
+    static int changedSignalIndex;
+    int changedSignalIndex;
+    int processDirtyItemsIndex;
+    int polishItemsIndex;
     QGraphicsScene::ItemIndexMethod indexMethod;
 …
     QRectF sceneRect;
+    bool hasSceneRect;
+    bool dirtyGrowingItemsBoundingRect;
+    quint32 hasSceneRect : 1;
+    quint32 dirtyGrowingItemsBoundingRect : 1;
+    quint32 updateAll : 1;
+    quint32 calledEmitUpdated : 1;
+    quint32 processDirtyItemsEmitted : 1;
+    quint32 needSortTopLevelItems : 1;
+    quint32 holesInTopLevelSiblingIndex : 1;
+    quint32 topLevelSequentialOrdering : 1;
+    quint32 scenePosDescendantsUpdatePending : 1;
+    quint32 stickyFocus : 1;
+    quint32 hasFocus : 1;
+    quint32 lastMouseGrabberItemHasImplicitMouseGrab : 1;
+    quint32 allItemsIgnoreHoverEvents : 1;
+    quint32 allItemsUseDefaultCursor : 1;
+    quint32 painterStateProtection : 1;
+    quint32 sortCacheEnabled : 1; // for compatibility
+    quint32 allItemsIgnoreTouchEvents : 1;
+    quint32 padding : 15;
     QRectF growingItemsBoundingRect;
     void _q_emitUpdated();
     QList<QRectF> updatedRects;
-    bool updateAll;
-    bool calledEmitUpdated;
-    bool processDirtyItemsEmitted;
     QPainterPath selectionArea;
 …
     QVector<QGraphicsItem *> unpolishedItems;
     QList<QGraphicsItem *> topLevelItems;
-    bool needSortTopLevelItems;
-    bool holesInTopLevelSiblingIndex;
-    bool topLevelSequentialOrdering;
     QMap<QGraphicsItem *, QPointF> movingItemsInitialPositions;
 …
     QSet<QGraphicsItem *> scenePosItems;
-    bool scenePosDescendantsUpdatePending;
     void setScenePosItemEnabled(QGraphicsItem *item, bool enabled);
     void registerScenePosItem(QGraphicsItem *item);
 …
     QBrush foregroundBrush;
+    bool stickyFocus;
+    bool hasFocus;
+    quint32 rectAdjust;
     QGraphicsItem *focusItem;
     QGraphicsItem *lastFocusItem;
 …
     QGraphicsItem *lastMouseGrabberItem;
-    bool lastMouseGrabberItemHasImplicitMouseGrab;
     QList<QGraphicsItem *> mouseGrabberItems;
     void grabMouse(QGraphicsItem *item, bool implicit = false);
 …
     QList<QGraphicsItem *> hoverItems;
     QPointF lastSceneMousePos;
-    bool allItemsIgnoreHoverEvents;
-    bool allItemsUseDefaultCursor;
     void enableMouseTrackingOnViews();
     QMap<Qt::MouseButton, QPointF> mouseGrabberButtonDownPos;
 …
     void addView(QGraphicsView *view);
     void removeView(QGraphicsView *view);
-    bool painterStateProtection;
     QMultiMap<QGraphicsItem *, QGraphicsItem *> sceneEventFilters;
 …
     void mousePressEventHandler(QGraphicsSceneMouseEvent *mouseEvent);
     QGraphicsWidget *windowForItem(const QGraphicsItem *item) const;
-    bool sortCacheEnabled; // for compatibility
     void drawItemHelper(QGraphicsItem *item, QPainter *painter,
 …
     void touchEventHandler(QTouchEvent *touchEvent);
     bool sendTouchBeginEvent(QGraphicsItem *item, QTouchEvent *touchEvent);
-    bool allItemsIgnoreTouchEvents;
     void enableTouchEventsOnViews();
     QHash<QGesture *, QGraphicsObject *> gestureTargets;
     void gestureEventHandler(QGestureEvent *event);
+    void getGestureTargets(const QSet<QGesture *> &gestures, QWidget *viewport,
+                           QMap<Qt::GestureType, QGesture *> *conflictedGestures,
+                           QList<QList<QGraphicsObject *> > *conflictedItems,
+                           QHash<QGesture *, QGraphicsObject *> *normalGestures);
+    void cancelGesturesForChildren(QGesture *original, QWidget *viewport);
+    void gestureTargetsAtHotSpots(const QSet<QGesture *> &gestures,
+                           Qt::GestureFlag flag,
+                           QHash<QGraphicsObject *, QSet<QGesture *> > *targets,
+                           QSet<QGraphicsObject *> *itemsSet = 0,
+                           QSet<QGesture *> *normal = 0,
+                           QSet<QGesture *> *conflicts = 0);
+    void cancelGesturesForChildren(QGesture *original);
+    void grabGesture(QGraphicsItem *, Qt::GestureType gesture);
+    void ungrabGesture(QGraphicsItem *, Qt::GestureType gesture);
+#endif // QT_NO_GESTURES
     void updateInputMethodSensitivityInViews();

trunk/src/gui/graphicsview/qgraphicsscenebsptreeindex.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation ([email protected])

trunk/src/gui/graphicsview/qgraphicsscenebsptreeindex_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation ([email protected])

trunk/src/gui/graphicsview/qgraphicssceneevent.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation ([email protected])
 …
 /*!
     Returns the old position (i.e., the position immediatly before the widget
+    Returns the old position (i.e., the position immediatly before the widget
     was moved).

trunk/src/gui/graphicsview/qgraphicssceneevent.h

r769	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation ([email protected])

trunk/src/gui/graphicsview/qgraphicssceneindex.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation ([email protected])

trunk/src/gui/graphicsview/qgraphicssceneindex_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation ([email protected])

trunk/src/gui/graphicsview/qgraphicsscenelinearindex.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation ([email protected])

trunk/src/gui/graphicsview/qgraphicsscenelinearindex_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation ([email protected])

trunk/src/gui/graphicsview/qgraphicstransform.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation ([email protected])
 …
     order, one at a time, to the QGraphicsItem it's assigned to.
     QGraphicsTransform is particularily useful for animations. Whereas
+    QGraphicsTransform is particularly useful for animations. Whereas
     QGraphicsItem::setTransform() lets you assign any transform directly to an
     item, there is no direct way to interpolate between two different
 …
     d->xScale = scale;
     update();
     emit scaleChanged();
+}
 …
     d->yScale = scale;
     update();
     emit scaleChanged();
+}
 …
     d->zScale = scale;
     update();
     emit scaleChanged();
+}
 …
     \sa QGraphicsScale::origin
 */

trunk/src/gui/graphicsview/qgraphicstransform.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation ([email protected])
 …
     Q_PROPERTY(QVector3D origin READ origin WRITE setOrigin NOTIFY originChanged)
     Q_PROPERTY(qreal xScale READ xScale WRITE setXScale NOTIFY scaleChanged)
     Q_PROPERTY(qreal yScale READ yScale WRITE setYScale NOTIFY scaleChanged)
     Q_PROPERTY(qreal zScale READ zScale WRITE setZScale NOTIFY scaleChanged)
+    Q_PROPERTY(qreal xScale READ xScale WRITE setXScale NOTIFY caleChanged)
+    Q_PROPERTY(qreal yScale READ yScale WRITE setYScale NOTIFY caleChanged)
+    Q_PROPERTY(qreal zScale READ zScale WRITE setZScale NOTIFY caleChanged)
 public:
     QGraphicsScale(QObject *parent = 0);
 …
 Q_SIGNALS:
     void originChanged();
     void scaleChanged();

trunk/src/gui/graphicsview/qgraphicstransform_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation ([email protected])

trunk/src/gui/graphicsview/qgraphicsview.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation ([email protected])
 …
     QGraphicsView visualizes the contents of a QGraphicsScene in a scrollable
     viewport. To create a scene with geometrical items, see QGraphicsScene's
     documentation. QGraphicsView is part of \l{The Graphics View Framework}.
+    documentation. QGraphicsView is part of Graphics View Framework}.
     To visualize a scene, you start by constructing a QGraphicsView object,
 …
       sceneInteractionAllowed(true), hasSceneRect(false),
       connectedToScene(false),
       mousePressButton(Qt::NoButton),
+      ),
       identityMatrix(true),
       dirtyScroll(true),
       accelerateScrolling(true),
       leftIndent(0), topIndent(0),
       lastMouseEvent(QEvent::None, QPoint(), Qt::NoButton, 0, 0),
-      useLastMouseEvent(false),
-      keepLastCenterPoint(true),
       alignment(Qt::AlignCenter),
-      transforming(false),
       transformationAnchor(QGraphicsView::AnchorViewCenter), resizeAnchor(QGraphicsView::NoAnchor),
       viewportUpdateMode(QGraphicsView::MinimalViewportUpdate),
 …
       rubberBandSelectionMode(Qt::IntersectsItemShape),
 #endif
+      handScrolling(false), handScrollMotions(0), cacheMode(0),
+      mustAllocateStyleOptions(false),
+      mustResizeBackgroundPixmap(true),
+      handScrollMotions(0), cacheMode(0),
 #ifndef QT_NO_CURSOR
       hasStoredOriginalCursor(false),
 #endif
       lastDragDropEvent(0),
-      fullUpdatePending(true),
       updateSceneSlotReimplementedChecked(false)
+{
 …
     // Restore the original viewport cursor.
+    hasStoredOriginalCursor = false;
+    if (dragMode == QGraphicsView::ScrollHandDrag)
+        viewport->setCursor(Qt::OpenHandCursor);
+    else
+        viewport->setCursor(originalCursor);
+    if (hasStoredOriginalCursor) {
+        hasStoredOriginalCursor = false;
+        if (dragMode == QGraphicsView::ScrollHandDrag)
+            viewport->setCursor(Qt::OpenHandCursor);
+        else
+            viewport->setCursor(originalCursor);
+    }
+}
 #endif
 …
         viewport->update();
     } else if (viewportUpdateMode == QGraphicsView::BoundingRectViewportUpdate) {
+        if (optimizationFlags & QGraphicsView::DontAdjustForAntialiasing)
+            viewport->update(dirtyBoundingRect.adjusted(-1, -1, 1, 1));
+        else
+            viewport->update(dirtyBoundingRect.adjusted(-2, -2, 2, 2));
+        viewport->update(dirtyBoundingRect);
     } else {
         viewport->update(dirtyRegion); // Already adjusted in updateRect/Region.
 …
+}
+bool QGraphicsViewPrivate::updateRegion(const QRegion &r)
+{
+    if (fullUpdatePending || viewportUpdateMode == QGraphicsView::NoViewportUpdate || r.isEmpty())
+/*
+   Calling this function results in update rects being clipped to the item's
+   bounding rect. Note that updates prior to this function call is not clipped.
+   The clip is removed by passing 0.
+*/
+void QGraphicsViewPrivate::setUpdateClip(QGraphicsItem *item)
+{
+    Q_Q(QGraphicsView);
+    // We simply ignore the request if the update mode is either FullViewportUpdate
+    // or NoViewportUpdate; in that case there's no point in clipping anything.
+    if (!item || viewportUpdateMode == QGraphicsView::NoViewportUpdate
+        || viewportUpdateMode == QGraphicsView::FullViewportUpdate) {
+        hasUpdateClip = false;
+        return;
+    }
+    // Calculate the clip (item's bounding rect in view coordinates).
+    // Optimized version of:
+    // QRect clip = item->deviceTransform(q->viewportTransform())
+    //              .mapRect(item->boundingRect()).toAlignedRect();
+    QRect clip;
+    if (item->d_ptr->itemIsUntransformable()) {
+        QTransform xform = item->deviceTransform(q->viewportTransform());
+        clip = xform.mapRect(item->boundingRect()).toAlignedRect();
+    } else if (item->d_ptr->sceneTransformTranslateOnly && identityMatrix) {
+        QRectF r(item->boundingRect());
+        r.translate(item->d_ptr->sceneTransform.dx() - horizontalScroll(),
+                    item->d_ptr->sceneTransform.dy() - verticalScroll());
+        clip = r.toAlignedRect();
+    } else if (!q->isTransformed()) {
+        clip = item->d_ptr->sceneTransform.mapRect(item->boundingRect()).toAlignedRect();
+    } else {
+        QTransform xform = item->d_ptr->sceneTransform;
+        xform *= q->viewportTransform();
+        clip = xform.mapRect(item->boundingRect()).toAlignedRect();
+    }
+    if (hasUpdateClip) {
+        // Intersect with old clip.
+        updateClip &= clip;
+    } else {
+        updateClip = clip;
+        hasUpdateClip = true;
+    }
+}
+bool QGraphicsViewPrivate::updateRegion(const QRectF &rect, const QTransform &xform)
+{
+    if (rect.isEmpty())
         return false;
+    const QRect boundingRect = r.boundingRect();
+    if (!intersectsViewport(boundingRect, viewport->width(), viewport->height()))
+        return false; // Update region outside viewport.
+    if (viewportUpdateMode != QGraphicsView::MinimalViewportUpdate
+        && viewportUpdateMode != QGraphicsView::SmartViewportUpdate) {
+        // No point in updating with QRegion granularity; use the rect instead.
+        return updateRectF(xform.mapRect(rect));
+    }
+    // Update mode is either Minimal or Smart, so we have to do a potentially slow operation,
+    // which is clearly documented here: QGraphicsItem::setBoundingRegionGranularity.
+    const QRegion region = xform.map(QRegion(rect.toAlignedRect()));
+    QRect viewRect = region.boundingRect();
+    const bool dontAdjustForAntialiasing = optimizationFlags & QGraphicsView::DontAdjustForAntialiasing;
+    if (dontAdjustForAntialiasing)
+        viewRect.adjust(-1, -1, 1, 1);
+    else
+        viewRect.adjust(-2, -2, 2, 2);
+    if (!intersectsViewport(viewRect, viewport->width(), viewport->height()))
+        return false; // Update region for sure outside viewport.
+    const QVector<QRect> &rects = region.rects();
+    for (int i = 0; i < rects.size(); ++i) {
+        viewRect = rects.at(i);
+        if (dontAdjustForAntialiasing)
+            viewRect.adjust(-1, -1, 1, 1);
+        else
+            viewRect.adjust(-2, -2, 2, 2);
+        if (hasUpdateClip)
+            viewRect &= updateClip;
+        dirtyRegion += viewRect;
+    }
+    return true;
+}
+// NB! Assumes the rect 'r' is already aligned and adjusted for antialiasing.
+// For QRectF use updateRectF(const QRectF &) to ensure proper adjustments.
+bool QGraphicsViewPrivate::updateRect(const QRect &r)
+{
+    if (fullUpdatePending || viewportUpdateMode == QGraphicsView::NoViewportUpdate
+        || !intersectsViewport(r, viewport->width(), viewport->height())) {
+        return false;
+    }
     switch (viewportUpdateMode) {
 …
         break;
     case QGraphicsView::BoundingRectViewportUpdate:
+        QRect_unite(&dirtyBoundingRect, boundingRect);
+        if (hasUpdateClip)
+            QRect_unite(&dirtyBoundingRect, r & updateClip);
+        else
+            QRect_unite(&dirtyBoundingRect, r);
         if (containsViewport(dirtyBoundingRect, viewport->width(), viewport->height())) {
             fullUpdatePending = true;
 …
     case QGraphicsView::SmartViewportUpdate: // ### DEPRECATE
     case QGraphicsView::MinimalViewportUpdate:
+    {
+        const QVector<QRect> &rects = r.rects();
+        for (int i = 0; i < rects.size(); ++i) {
+            if (optimizationFlags & QGraphicsView::DontAdjustForAntialiasing)
+                dirtyRegion += rects.at(i).adjusted(-1, -1, 1, 1);
+            else
+                dirtyRegion += rects.at(i).adjusted(-2, -2, 2, 2);
+        }
+        break;
+    }
+    default:
+        break;
+    }
+    return true;
+}
+bool QGraphicsViewPrivate::updateRect(const QRect &r)
+{
+    if (fullUpdatePending || viewportUpdateMode == QGraphicsView::NoViewportUpdate
+        || !intersectsViewport(r, viewport->width(), viewport->height())) {
+        return false;
+    }
+    switch (viewportUpdateMode) {
+    case QGraphicsView::FullViewportUpdate:
+        fullUpdatePending = true;
+        viewport->update();
+        break;
+    case QGraphicsView::BoundingRectViewportUpdate:
+        QRect_unite(&dirtyBoundingRect, r);
+        if (containsViewport(dirtyBoundingRect, viewport->width(), viewport->height())) {
+            fullUpdatePending = true;
+            viewport->update();
+        }
+        break;
+    case QGraphicsView::SmartViewportUpdate: // ### DEPRECATE
+    case QGraphicsView::MinimalViewportUpdate:
+        if (optimizationFlags & QGraphicsView::DontAdjustForAntialiasing)
+            dirtyRegion += r.adjusted(-1, -1, 1, 1);
+        if (hasUpdateClip)
+            dirtyRegion += r & updateClip;
         else
             dirtyRegion += r.adjusted(-2, -2, 2, 2);
+            dirtyRegion += r;
         break;
     default:
 …
+{
     Q_Q(QGraphicsView);
+    bool enabled = scene && scene->focusItem()
+                   && (scene->focusItem()->flags() & QGraphicsItem::ItemAcceptsInputMethod);
+    QGraphicsItem *focusItem = 0;
+    bool enabled = scene && (focusItem = scene->focusItem())
+                   && (focusItem->d_ptr->flags & QGraphicsItem::ItemAcceptsInputMethod);
     q->setAttribute(Qt::WA_InputMethodEnabled, enabled);
     q->viewport()->setAttribute(Qt::WA_InputMethodEnabled, enabled);
+}
 …
+{
     Q_D(QGraphicsView);
-    Q_UNUSED(xmargin);
-    Q_UNUSED(ymargin);
     qreal width = viewport()->width();
     qreal height = viewport()->height();
 …
     QVariant value = d->scene->inputMethodQuery(query);
     if (value.type() == QVariant::RectF)
         value = mapFromScene(value.toRectF()).boundingRect();
+        value = );
     else if (value.type() == QVariant::PointF)
         value = mapFromScene(value.toPointF());
 …
     // Convert scene rects to viewport rects.
     foreach (const QRectF &rect, rects) {
         QRect xrect = transform.mapRect(rect).toRect();
+        QRect xrect = transform.mapRect(rect).toRect();
         if (!(d->optimizationFlags & DontAdjustForAntialiasing))
             xrect.adjust(-2, -2, 2, 2);
         if (!viewportRect.intersects(xrect))
             continue;
 …
     if (d->scene && !d->scene->d_func()->allItemsIgnoreTouchEvents)
         widget->setAttribute(Qt::WA_AcceptTouchEvents);
     widget->setAcceptDrops(acceptDrops());
 …
         return true;
+    }
     case QEvent::Gesture:
     case QEvent::GestureOverride:
 …
         return true;
+    }
     default:
         break;
 …
     // Items
     if (!(d->optimizationFlags & IndirectPainting)) {
         d->scene->d_func()->drawItems(&painter, viewTransformed ? &viewTransform : 0,
                                       &d->exposedRegion, viewport());
         // Make sure the painter's world transform is restored correctly when
         // drawing without painter state protection (DontSavePainterState).
 …
         // and restore() in QGraphicsScene::drawItems().
         if (!d->scene->d_func()->painterStateProtection)
+            painter.setWorldTransform(viewTransform);
+            painter.setOpacity(1.0);
+        painter.setWorldTransform(viewTransform);
     } else {
         // Make sure we don't have unpolished items before we draw

trunk/src/gui/graphicsview/qgraphicsview.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation ([email protected])

trunk/src/gui/graphicsview/qgraphicsview_p.h

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation ([email protected])
 …
 QT_BEGIN_NAMESPACE
 class Q_AUTOTEST_EXPORT QGraphicsViewPrivate : public QAbstractScrollAreaPrivate
+class Q__EXPORT QGraphicsViewPrivate : public QAbstractScrollAreaPrivate
+{
     Q_DECLARE_PUBLIC(QGraphicsView)
 …
     QGraphicsView::DragMode dragMode;
+    bool sceneInteractionAllowed;
+    quint32 sceneInteractionAllowed : 1;
+    quint32 hasSceneRect : 1;
+    quint32 connectedToScene : 1;
+    quint32 useLastMouseEvent : 1;
+    quint32 identityMatrix : 1;
+    quint32 dirtyScroll : 1;
+    quint32 accelerateScrolling : 1;
+    quint32 keepLastCenterPoint : 1;
+    quint32 transforming : 1;
+    quint32 handScrolling : 1;
+    quint32 mustAllocateStyleOptions : 1;
+    quint32 mustResizeBackgroundPixmap : 1;
+    quint32 fullUpdatePending : 1;
+    quint32 hasUpdateClip : 1;
+    quint32 padding : 18;
     QRectF sceneRect;
-    bool hasSceneRect;
     void updateLastCenterPoint();
-    bool connectedToScene;
     qint64 horizontalScroll() const;
 …
     QRectF mapRectFromScene(const QRectF &rect) const;
     QPointF mousePressItemPoint;
     QPointF mousePressScenePoint;
 …
     Qt::MouseButton mousePressButton;
     QTransform matrix;
-    bool identityMatrix;
     qint64 scrollX, scrollY;
-    bool dirtyScroll;
     void updateScroll();
-    bool accelerateScrolling;
     qreal leftIndent;
     qreal topIndent;
 …
     // Replaying mouse events
     QMouseEvent lastMouseEvent;
-    bool useLastMouseEvent;
     void replayLastMouseEvent();
     void storeMouseEvent(QMouseEvent *event);
 …
     QPointF lastCenterPoint;
-    bool keepLastCenterPoint;
     Qt::Alignment alignment;
-    bool transforming;
     QGraphicsView::ViewportAnchor transformationAnchor;
 …
     Qt::ItemSelectionMode rubberBandSelectionMode;
 #endif
-    bool handScrolling;
     int handScrollMotions;
 …
     QVector<QStyleOptionGraphicsItem> styleOptions;
-    bool mustAllocateStyleOptions;
     QStyleOptionGraphicsItem *allocStyleOptionsArray(int numItems);
     void freeStyleOptionsArray(QStyleOptionGraphicsItem *array);
 …
     QBrush foregroundBrush;
     QPixmap backgroundPixmap;
-    bool mustResizeBackgroundPixmap;
     QRegion backgroundPixmapExposed;
 …
     QRect mapToViewRect(const QGraphicsItem *item, const QRectF &rect) const;
     QRegion mapToViewRegion(const QGraphicsItem *item, const QRectF &rect) const;
-    bool fullUpdatePending;
     QRegion dirtyRegion;
     QRect dirtyBoundingRect;
 …
+    }
     bool updateRect(const QRect &rect);
     bool updateRegion(const QRegion &region);
+    bool updateRegion(const QRe);
     bool updateSceneSlotReimplementedChecked;
     QRegion exposedRegion;

trunk/src/gui/graphicsview/qgraphicswidget.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation ([email protected])
 …
 /*!
     \property QGraphicsWidget::geometry
     \brief the geometry of the widget
 …
             //set the new pos
             d->geom.moveTopLeft(pos());
             return;
+        }
 …
     QSizeF oldSize = size();
     QGraphicsLayoutItem::setGeometry(newGeom);
     // Send resize event
     bool resized = newGeom.size() != oldSize;
 …
         re.setOldSize(oldSize);
         re.setNewSize(newGeom.size());
         QApplication::sendEvent(this, &re);
+    }
+}
 …
     Contents margins are used by the assigned layout to define the placement
     of subwidgets and layouts. Margins are particularily useful for widgets
+    of subwidgets and layouts. Margins are particularly useful for widgets
     that constrain subwidgets to only a section of its own geometry. For
     example, a group box with a layout will place subwidgets inside its frame,
 …
 /*!
     Returns this widget's layout, or 0 if no layout is currently managing this
     widget.
 …
     l->d_func()->reparentChildItems(this);
     l->invalidate();
+}
 …
+{
     Q_D(const QGraphicsWidget);
+    return d->font;
+    QFont fnt = d->font;
+    fnt.resolve(fnt.resolve() | d->inheritedFontResolveMask);
+    return fnt;
+}
 void QGraphicsWidget::setFont(const QFont &font)
 …
     QPalette resolvedPalette = palette.resolve(naturalPalette);
     d->setPalette_helper(resolvedPalette);
+}
 …
         break;
     case ItemParentChange: {
-        QGraphicsItem *parent = qVariantValue<QGraphicsItem *>(value);
-        d->fixFocusChainBeforeReparenting((parent && parent->isWidget()) ? static_cast<QGraphicsWidget *>(parent) : 0, scene());
         // Deliver ParentAboutToChange.
         QEvent event(QEvent::ParentAboutToChange);

trunk/src/gui/graphicsview/qgraphicswidget.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation ([email protected])
 …
     Q_PROPERTY(QFont font READ font WRITE setFont)
     Q_PROPERTY(Qt::LayoutDirection layoutDirection READ layoutDirection WRITE setLayoutDirection RESET unsetLayoutDirection)
     Q_PROPERTY(QSizeF size READ size WRITE resize)
+    Q_PROPERTY(QSizeF size READ size WRITE resize)
     Q_PROPERTY(QSizeF minimumSize READ minimumSize WRITE setMinimumSize)
     Q_PROPERTY(QSizeF preferredSize READ preferredSize WRITE setPreferredSize)
 …
     Q_PROPERTY(Qt::WindowFlags windowFlags READ windowFlags WRITE setWindowFlags)
     Q_PROPERTY(QString windowTitle READ windowTitle WRITE setWindowTitle)
+    Q_PROPERTY(QRectF geometry READ geometry WRITE setGeometry)
+    Q_PROPERTY(QRectF geometry READ geometry WRITE setGeometry NOTIFY geometryChanged)
+    Q_PROPERTY(bool autoFillBackground READ autoFillBackground WRITE setAutoFillBackground)
+    Q_PROPERTY(QGraphicsLayout* layout READ layout WRITE setLayout NOTIFY layoutChanged)
 public:
     QGraphicsWidget(QGraphicsItem *parent = 0, Qt::WindowFlags wFlags = 0);
     ~QGraphicsWidget();
     QGraphicsLayout *layout() const;
     void setLayout(QGraphicsLayout *layout);
 …
     QPalette palette() const;
     void setPalette(const QPalette &palette);
     void resize(const QSizeF &size);
 …
     using QObject::children;
 #endif
 public Q_SLOTS:

trunk/src/gui/graphicsview/qgraphicswidget_p.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation ([email protected])
 …
 #include <QtCore/qdebug.h>
 #include "qgraphicswidget_p.h"
 #include "qgraphicslayout.h"
 …
     windowFlags = wFlags;
+    q->setParentItem(parentItem);
+    if (parentItem)
+        setParentItemHelper(parentItem, 0, 0);
     q->setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred, QSizePolicy::DefaultType));
     q->setGraphicsItem(q);
 …
     resolveLayoutDirection();
     q->unsetWindowFrameMargins();
+    q->setFlag(QGraphicsItem::ItemUsesExtendedStyleOption);
+    q->setFlag(QGraphicsItem::ItemSendsGeometryChanges);
+    flags |= QGraphicsItem::ItemUsesExtendedStyleOption;
+    flags |= QGraphicsItem::ItemSendsGeometryChanges;
+    if (windowFlags & Qt::Window)
+        flags |= QGraphicsItem::ItemIsPanel;
+}
 …
 void QGraphicsWidgetPrivate::resolveFont(uint inheritedMask)
+{
     inheritedFontResolveMask = inheritedMask;
     QFont naturalFont = naturalWidgetFont();
     QFont resolvedFont = font.resolve(naturalFont);
 …
     QGraphicsWidget *firstOld = 0;
     bool wasPreviousNew = true;
     while (w != q) {
         bool isCurrentNew = q->isAncestorOf(w);
 …
     if (oldScene && newScene != oldScene)
         oldScene->d_func()->tabFocusFirst = firstOld;
+        oldScene->d_func()->tabFocusFirst = ;
     QGraphicsItem *topLevelItem = newParent ? newParent->topLevelItem() : 0;
 …
+}
 void QGraphicsWidgetPrivate::setGeometryFromSetPos()
+{

trunk/src/gui/graphicsview/qgraphicswidget_p.h

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation ([email protected])
 …
           polished(0),
           inSetPos(0),
           focusPolicy(Qt::NoFocus),
           focusNext(0),
 …
     bool hasDecoration() const;
     void setGeometryFromSetPos();
 …
     quint32 polished: 1;
     quint32 inSetPos : 1;
     // Focus

trunk/src/gui/graphicsview/qgridlayoutengine.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation ([email protected])
 …
+}
 void QGridLayoutRowData::distributeMultiCells()
+void QGridLayoutRowData::distributeMultiCells()
+{
     MultiCellMap::const_iterator i = multiCellMap.constBegin();
 …
             if (extra > 0.0) {
                 calculateGeometries(start, end, box.q_sizes(j), dummy.data(), newSizes.data(),
 , totalBox);
+, totalBox);
                 for (int k = 0; k < span; ++k)
 …
         for (int k = 0; k < span; ++k) {
             boxes[start + k].combine(extras[k]);
+            stretches[start + k] = qMax(stretches[start + k], stretch);
+            if (stretch != 0)
+                stretches[start + k] = qMax(stretches[start + k], stretch);
+        }
+    }
 …
 void QGridLayoutRowData::calculateGeometries(int start, int end, qreal targetSize, qreal *positions,
                                              qreal *sizes, qreal *descents,
+                                             const QGridLayoutBox &totalBox)
+                                             const QGridLayoutBox &totalBox,
+                                             const QGridLayoutRowInfo &rowInfo)
+{
     Q_ASSERT(end > start);
     targetSize = qBound(totalBox.q_minimumSize, targetSize, totalBox.q_maximumSize);
+    targetSize = qSize);
     int n = end - start;
 …
+        }
     } else {
+        stealBox(start, end, PreferredSize, positions, sizes);
+        sumAvailable = targetSize - totalBox.q_preferredSize;
+        bool isLargerThanMaximum = (targetSize > totalBox.q_maximumSize);
+        if (isLargerThanMaximum) {
+            stealBox(start, end, MaximumSize, positions, sizes);
+            sumAvailable = targetSize - totalBox.q_maximumSize;
+        } else {
+            stealBox(start, end, PreferredSize, positions, sizes);
+            sumAvailable = targetSize - totalBox.q_preferredSize;
+        }
         if (sumAvailable > 0.0) {
             bool somethingHasAMaximumSize = false;
             qreal sumPreferredSizes = 0.0;
+            qreal sumSizes = 0.0;
             for (int i = 0; i < n; ++i)
                 sumPreferredSizes += sizes[i];
+                sumSizes += sizes[i];
             for (int i = 0; i < n; ++i) {
 …
                 const QGridLayoutBox &box = boxes.at(start + i);
+                qreal desired = box.q_maximumSize - box.q_preferredSize;
+                qreal boxSize;
+                qreal desired;
+                if (isLargerThanMaximum) {
+                    boxSize = box.q_maximumSize;
+                    desired = rowInfo.boxes.value(start + i).q_maximumSize - boxSize;
+                } else {
+                    boxSize = box.q_preferredSize;
+                    desired = box.q_maximumSize - boxSize;
+                }
                 if (desired == 0.0) {
                     newSizes[i] = sizes[i];
 …
                         factors[i] = 0.0;
                     } else {
                         qreal ultimatePreferredSize;
                         qreal ultimateSumPreferredSizes;
                         qreal x = ((stretch * sumPreferredSizes)
                                    - (sumStretches * box.q_preferredSize))
+                        qreal ultimateSize;
+                        qreal ultimateSumSizes;
+                        qreal x = ((stretch * sumSizes)
+                                   - (sumStretches * boxSize))
                                   / (sumStretches - stretch);
                         if (x >= 0.0) {
                             ultimatePreferredSize = box.q_preferredSize + x;
                             ultimateSumPreferredSizes = sumPreferredSizes + x;
+                            ultimateSize + x;
+                            ultimateSumSizes + x;
                         } else {
                             ultimatePreferredSize = box.q_preferredSize;
                             ultimateSumPreferredSizes = (sumStretches * box.q_preferredSize)
+                            ultimateSize;
+                            ultimateSumSize)
                                                         / stretch;
+                        }
 …
                             during the transition).
                         */
+                        ultimatePreferredSize = ultimatePreferredSize * 3 / 2;
+                        ultimateSumPreferredSizes = ultimateSumPreferredSizes * 3 / 2;
+                        qreal ultimateFactor = (stretch * ultimateSumPreferredSizes
+                                                / sumStretches)
+                                               - (box.q_preferredSize);
+                        qreal transitionalFactor = sumAvailable
+                                                   * (ultimatePreferredSize - box.q_preferredSize)
+                                                   / (ultimateSumPreferredSizes
+                                                      - sumPreferredSizes);
+                        qreal alpha = qMin(sumAvailable,
+                                           ultimateSumPreferredSizes - sumPreferredSizes);
+                        qreal beta = ultimateSumPreferredSizes - sumPreferredSizes;
+                        factors[i] = ((alpha * ultimateFactor)
+                                      + ((beta - alpha) * transitionalFactor)) / beta;
+                        ultimateSize = ultimateSize * 3 / 2;
+                        ultimateSumSizes = ultimateSumSizes * 3 / 2;
+                        qreal beta = ultimateSumSizes - sumSizes;
+                        if (!beta) {
+                            factors[i] = 1;
+                        } else {
+                            qreal alpha = qMin(sumCurrentAvailable, beta);
+                            qreal ultimateFactor = (stretch * ultimateSumSizes / sumStretches)
+                                                   - (boxSize);
+                            qreal transitionalFactor = sumCurrentAvailable * (ultimateSize - boxSize) / beta;
+                            factors[i] = ((alpha * ultimateFactor)
+                                          + ((beta - alpha) * transitionalFactor)) / beta;
+                        }
+                    }
                     sumFactors += factors[i];
                     if (desired < sumAvailable)
+                    if (desired < sumAvailable)
                         somethingHasAMaximumSize = true;
 …
                         continue;
+                    const QGridLayoutBox &box = boxes.at(start + i);
+                    qreal avail = sumAvailable * factors[i] / sumFactors;
+                    if (sizes[i] + avail >= box.q_maximumSize) {
+                        newSizes[i] = box.q_maximumSize;
+                        sumAvailable -= box.q_maximumSize - sizes[i];
+                    qreal maxBoxSize;
+                    if (isLargerThanMaximum)
+                        maxBoxSize = rowInfo.boxes.value(start + i).q_maximumSize;
+                    else
+                        maxBoxSize = boxes.at(start + i).q_maximumSize;
+                    qreal avail = sumCurrentAvailable * factors[i] / sumFactors;
+                    if (sizes[i] + avail >= maxBoxSize) {
+                        newSizes[i] = maxBoxSize;
+                        sumCurrentAvailable -= maxBoxSize - sizes[i];
                         sumFactors -= factors[i];
                         keepGoing = (sumAvailable > 0.0);
+                        keepGoing = (sumAvailable > 0.0);
                         if (!keepGoing)
                             break;
 …
                 if (newSizes[i] < 0.0) {
                     qreal delta = (sumFactors == 0.0) ? 0.0
                                                       : sumAvailable * factors[i] / sumFactors;
+                                                      : sumAvailable * factors[i] / sumFactors;
                     newSizes[i] = sizes[i] + delta;
+                }
 …
+}
 QSizePolicy::ControlTypes QGridLayoutItem::controlTypes(LayoutSide /* side */) const
+{
 …
         qreal cellHeight = height;
+        QSizeF size = effectiveMaxSize().boundedTo(QSizeF(cellWidth, cellHeight));
+        QSizeF size = effectiveMaxSize(QSizeF(-1,-1));
+        if (hasDynamicConstraint()) {
+            if (dynamicConstraintOrientation() == Qt::Vertical) {
+               if (size.width() > cellWidth)
+                   size = effectiveMaxSize(QSizeF(cellWidth, -1));
+            } else if (size.height() > cellHeight) {
+                size = effectiveMaxSize(QSizeF(-1, cellHeight));
+            }
+        }
+        size = size.boundedTo(QSizeF(cellWidth, cellHeight));
         width = size.width();
         height = size.height();
 …
     (since it only evaluates the hints, as the name implies)
 */
 QSizeF QGridLayoutItem::effectiveMaxSize() const
+{
     QSizeF size;
+QSizeF QGridLayoutItem::effectiveMaxSize() const
+{
+    QSizeF size;
     bool vGrow = (sizePolicy(Qt::Vertical) & QSizePolicy::GrowFlag) == QSizePolicy::GrowFlag;
     bool hGrow = (sizePolicy(Qt::Horizontal) & QSizePolicy::GrowFlag) == QSizePolicy::GrowFlag;
     if (!vGrow || !hGrow) {
         QSizeF pref = layoutItem()->effectiveSizeHint(Qt::PreferredSize);
+        QSizeF pref = layoutItem()->effectiveSizeHint(Qt::PreferredSize);
         if (!vGrow)
             size.setHeight(pref.height());
 …
     if (!size.isValid()) {
         QSizeF maxSize = layoutItem()->effectiveSizeHint(Qt::MaximumSize);
+        QSizeF maxSize = layoutItem()->effectiveSizeHint(Qt::MaximumSize);
         if (size.width() == -1)
             size.setWidth(maxSize.width());
 …
     q_cachedDataForStyleInfo.invalidate();
     q_cachedSize = QSizeF();
+}
 …
 QSizeF QGridLayoutEngine::sizeHint(const QLayoutStyleInfo &styleInfo, Qt::SizeHint which,
+                                   const QSizeF & /* constraint */) const
+{
+    ensureColumnAndRowData(styleInfo);
+                                   const QSizeF &constraint) const
+{
+    QGridLayoutBox sizehint_totalBoxes[NOrientations];
+    bool sizeHintCalculated = false;
+    if (hasDynamicConstraint() && rowCount() > 0 && columnCount() > 0) {
+        if (constraintOrientation() == Qt::Vertical) {
+            //We have items whose height depends on their width
+            if (constraint.width() >= 0) {
+                if (q_cachedDataForStyleInfo != styleInfo)
+                    ensureColumnAndRowData(&q_columnData, &sizehint_totalBoxes[Hor], styleInfo, NULL, NULL, Qt::Horizontal);
+                else
+                    sizehint_totalBoxes[Hor] = q_totalBoxes[Hor];
+                QVector<qreal> sizehint_xx;
+                QVector<qreal> sizehint_widths;
+                sizehint_xx.resize(columnCount());
+                sizehint_widths.resize(columnCount());
+                qreal width = constraint.width();
+                //Calculate column widths and positions, and put results in q_xx.data() and q_widths.data() so that we can use this information as
+                //constraints to find the row heights
+                q_columnData.calculateGeometries(0, columnCount(), width, sizehint_xx.data(), sizehint_widths.data(),
+, sizehint_totalBoxes[Hor], q_infos[Hor]);
+                ensureColumnAndRowData(&q_rowData, &sizehint_totalBoxes[Ver], styleInfo, sizehint_xx.data(), sizehint_widths.data(), Qt::Vertical);
+                sizeHintCalculated = true;
+            }
+        } else {
+            if (constraint.height() >= 0) {
+                //We have items whose width depends on their height
+                ensureColumnAndRowData(&q_rowData, &sizehint_totalBoxes[Ver], styleInfo, NULL, NULL, Qt::Vertical);
+                QVector<qreal> sizehint_yy;
+                QVector<qreal> sizehint_heights;
+                sizehint_yy.resize(rowCount());
+                sizehint_heights.resize(rowCount());
+                qreal height = constraint.height();
+                //Calculate row heights and positions, and put results in q_yy.data() and q_heights.data() so that we can use this information as
+                //constraints to find the column widths
+                q_rowData.calculateGeometries(0, rowCount(), height, sizehint_yy.data(), sizehint_heights.data(),
+, sizehint_totalBoxes[Ver], q_infos[Ver]);
+                ensureColumnAndRowData(&q_columnData, &sizehint_totalBoxes[Hor], styleInfo, sizehint_yy.data(), sizehint_heights.data(), Qt::Vertical);
+                sizeHintCalculated = true;
+            }
+        }
+    }
+    if (!sizeHintCalculated) {
+        //No items with height for width, so it doesn't matter which order we do these in
+        if (q_cachedDataForStyleInfo != styleInfo) {
+            ensureColumnAndRowData(&q_columnData, &sizehint_totalBoxes[Hor], styleInfo, NULL, NULL, Qt::Horizontal);
+            ensureColumnAndRowData(&q_rowData, &sizehint_totalBoxes[Ver], styleInfo, NULL, NULL, Qt::Vertical);
+        } else {
+            sizehint_totalBoxes[Hor] = q_totalBoxes[Hor];
+            sizehint_totalBoxes[Ver] = q_totalBoxes[Ver];
+        }
+    }
     switch (which) {
     case Qt::MinimumSize:
         return QSizeF(q_totalBoxes[Hor].q_minimumSize, q_totalBoxes[Ver].q_minimumSize);
+        return QSizeF(_totalBoxes[Ver].q_minimumSize);
     case Qt::PreferredSize:
         return QSizeF(q_totalBoxes[Hor].q_preferredSize, q_totalBoxes[Ver].q_preferredSize);
+        return QSizeF(_totalBoxes[Ver].q_preferredSize);
     case Qt::MaximumSize:
         return QSizeF(q_totalBoxes[Hor].q_maximumSize, q_totalBoxes[Ver].q_maximumSize);
+        return QSizeF(_totalBoxes[Ver].q_maximumSize);
     case Qt::MinimumDescent:
         return QSizeF(-1.0, q_totalBoxes[Hor].q_minimumDescent);    // ### doesn't work
+        return QSizeF(-1.0, _totalBoxes[Hor].q_minimumDescent);    // ### doesn't work
     default:
         break;
 …
 void QGridLayoutEngine::fillRowData(QGridLayoutRowData *rowData, const QLayoutStyleInfo &styleInfo,
                                     Qt::Orientation orientation) const
+{
 …
                     if (effectiveRowSpan == 1) {
                         box = &rowBox;
                         if (!userRowStretch)
+                        if (!userRowStretch)
                             rowStretch = qMax(rowStretch, itemStretch);
                     } else {
 …
                         multiCell.q_stretch = itemStretch;
+                    }
+                    box->combine(item->box(orientation));
+                    // Items with constraints need to be passed the constraint
+                    if (colSizes && colPositions && item->hasDynamicConstraint() && orientation == item->dynamicConstraintOrientation()) {
+                        /* Get the width of the item by summing up the widths of the columns that it spans.
+                         * We need to have already calculated the widths of the columns by calling
+                         * q_columns->calculateGeometries() before hand and passing the value in the colSizes
+                         * and colPositions parameters.
+                         * The variable name is still colSizes even when it actually has the row sizes
+                         */
+                        qreal length = colSizes[item->lastColumn(orientation)];
+                        if (item->columnSpan(orientation) != 1)
+                            length += colPositions[item->lastColumn(orientation)] - colPositions[item->firstColumn(orientation)];
+                        box->combine(item->box(orientation, length));
+                    } else {
+                        box->combine(item->box(orientation));
+                    }
                     if (effectiveRowSpan == 1) {
 …
+}
+void QGridLayoutEngine::ensureColumnAndRowData(const QLayoutStyleInfo &styleInfo) const
+{
+    if (q_cachedDataForStyleInfo == styleInfo)
+        return;
+    q_columnData.reset(columnCount());
+    q_rowData.reset(rowCount());
+    fillRowData(&q_columnData, styleInfo, Qt::Horizontal);
+    fillRowData(&q_rowData, styleInfo, Qt::Vertical);
+    q_columnData.distributeMultiCells();
+    q_rowData.distributeMultiCells();
+    q_totalBoxes[Hor] = q_columnData.totalBox(0, columnCount());
+    q_totalBoxes[Ver] = q_rowData.totalBox(0, rowCount());
+    q_cachedDataForStyleInfo = styleInfo;
+void QGridLayoutEngine::ensureColumnAndRowData(QGridLayoutRowData *rowData, QGridLayoutBox *totalBox,
+                                            const QLayoutStyleInfo &styleInfo,
+                                            qreal *colPositions, qreal *colSizes,
+                                            Qt::Orientation orientation) const
+{
+    rowData->reset(rowCount(orientation));
+    fillRowData(rowData, styleInfo, colPositions, colSizes, orientation);
+    const QGridLayoutRowInfo &rowInfo = q_infos[orientation == Qt::Vertical];
+    rowData->distributeMultiCells(rowInfo);
+    *totalBox = rowData->totalBox(0, rowCount(orientation));
+        //We have items whose width depends on their height
+}
+/**
+   returns false if the layout has contradicting constraints (i.e. some items with a horizontal
+   constraint and other items with a vertical constraint)
+ */
+bool QGridLayoutEngine::ensureDynamicConstraint() const
+{
+    if (q_cachedConstraintOrientation == UnknownConstraint) {
+        for (int i = q_items.count() - 1; i >= 0; --i) {
+            QGridLayoutItem *item = q_items.at(i);
+            if (item->hasDynamicConstraint()) {
+                Qt::Orientation itemConstraintOrientation = item->dynamicConstraintOrientation();
+                if (q_cachedConstraintOrientation == UnknownConstraint) {
+                    q_cachedConstraintOrientation = itemConstraintOrientation;
+                } else if (q_cachedConstraintOrientation != itemConstraintOrientation) {
+                    q_cachedConstraintOrientation = UnfeasibleConstraint;
+                    qWarning("QGridLayoutEngine: Unfeasible, cannot mix horizontal and"
+                             " vertical constraint in the same layout");
+                    return false;
+                }
+            }
+        }
+        if (q_cachedConstraintOrientation == UnknownConstraint)
+            q_cachedConstraintOrientation = NoConstraint;
+    }
+    return true;
+}
+bool QGridLayoutEngine::hasDynamicConstraint() const
+{
+    if (!ensureDynamicConstraint())
+        return false;
+    return q_cachedConstraintOrientation != NoConstraint;
+}
+/*
+ * return value is only valid if hasConstraint() returns true
+ */
+Qt::Orientation QGridLayoutEngine::constraintOrientation() const
+{
+    (void)ensureDynamicConstraint();
+    return (Qt::Orientation)q_cachedConstraintOrientation;
+}
 …
                                          const QSizeF &size) const
+{
+    ensureColumnAndRowData(styleInfo);
+    if (q_cachedSize == size)
+    if (q_cachedDataForStyleInfo == styleInfo && q_cachedSize == size)
         return;
     q_xx.resize(columnCount());
     q_yy.resize(rowCount());
-    q_widths.resize(columnCount());
     q_heights.resize(rowCount());
     q_descents.resize(rowCount());
+    q_columnData.calculateGeometries(0, columnCount(), size.width(), q_xx.data(), q_widths.data(),
+, q_totalBoxes[Hor]);
+    q_rowData.calculateGeometries(0, rowCount(), size.height(), q_yy.data(), q_heights.data(),
+                                  q_descents.data(), q_totalBoxes[Ver]);
+    q_cachedSize = size;
+    if (constraintOrientation() != Qt::Horizontal) {
+        //We might have items whose width depends on their height
+        ensureColumnAndRowData(&q_columnData, &q_totalBoxes[Hor], styleInfo, NULL, NULL, Qt::Horizontal);
+        //Calculate column widths and positions, and put results in q_xx.data() and q_widths.data() so that we can use this information as
+        //constraints to find the row heights
+        q_columnData.calculateGeometries(0, columnCount(), size.width(), q_xx.data(), q_widths.data(),
+, q_totalBoxes[Hor], q_infos[Hor] );
+        ensureColumnAndRowData(&q_rowData, &q_totalBoxes[Ver], styleInfo, q_xx.data(), q_widths.data(), Qt::Vertical);
+        //Calculate row heights and positions, and put results in q_yy.data() and q_heights.data()
+        q_rowData.calculateGeometries(0, rowCount(), size.height(), q_yy.data(), q_heights.data(),
+                q_descents.data(), q_totalBoxes[Ver], q_infos[Ver]);
+    } else {
+        //We have items whose height depends on their width
+        ensureColumnAndRowData(&q_rowData, &q_totalBoxes[Ver], styleInfo, NULL, NULL, Qt::Vertical);
+        //Calculate row heights and positions, and put results in q_yy.data() and q_heights.data() so that we can use this information as
+        //constraints to find the column widths
+        q_rowData.calculateGeometries(0, rowCount(), size.height(), q_yy.data(), q_heights.data(),
+                q_descents.data(), q_totalBoxes[Ver], q_infos[Ver]);
+        ensureColumnAndRowData(&q_columnData, &q_totalBoxes[Hor], styleInfo, q_yy.data(), q_heights.data(), Qt::Horizontal);
+        //Calculate row heights and positions, and put results in q_yy.data() and q_heights.data()
+        q_columnData.calculateGeometries(0, columnCount(), size.width(), q_xx.data(), q_widths.data(),
+, q_totalBoxes[Hor], q_infos[Hor]);
+    }
+}

trunk/src/gui/graphicsview/qgridlayoutengine_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation ([email protected])
 …
     Right,
     Bottom
 };
 …
 typedef QMap<QPair<int, int>, QGridLayoutMultiCellData> MultiCellMap;
 class QGridLayoutRowData
+{
 public:
     void reset(int count);
     void distributeMultiCells();
+    void distributeMultiCells();
     void calculateGeometries(int start, int end, qreal targetSize, qreal *positions, qreal *sizes,
+                             qreal *descents, const QGridLayoutBox &totalBox);
+                             qreal *descents, const QGridLayoutBox &totalBox,
+                             const QGridLayoutRowInfo &rowInfo);
     QGridLayoutBox totalBox(int start, int end) const;
     void stealBox(int start, int end, int which, qreal *positions, qreal *sizes);
 …
     QSizePolicy::Policy sizePolicy(Qt::Orientation orientation) const;
     QSizePolicy::ControlTypes controlTypes(LayoutSide side) const;
     QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const;
 …
     void transpose();
     void insertOrRemoveRows(int row, int delta, Qt::Orientation orientation = Qt::Vertical);
     QSizeF effectiveMaxSize() const;
+    QSizeF effectiveMaxSize() const;
 #ifdef QT_DEBUG
 …
     inline void insertRow(int row, Qt::Orientation orientation = Qt::Vertical)
         { insertOrRemoveRows(row, +1, orientation); }
     inline void removeRow(int row, Qt::Orientation orientation = Qt::Vertical)
         { insertOrRemoveRows(row, -1, orientation); }
+    inline void removeRow)
+        { insertOrRemoveRows(row, -, orientation); }
     void invalidate();
 …
     QSizeF sizeHint(const QLayoutStyleInfo &styleInfo, Qt::SizeHint which,
                     const QSizeF &constraint) const;
     QSizePolicy::ControlTypes controlTypes(LayoutSide side) const;
     void transpose();
 …
     void insertOrRemoveRows(int row, int delta, Qt::Orientation orientation = Qt::Vertical);
     void fillRowData(QGridLayoutRowData *rowData, const QLayoutStyleInfo &styleInfo,
+                     Qt::Orientation orientation = Qt::Vertical) const;
+                                    qreal *colPositions, qreal *colSizes,
+                                    Qt::Orientation orientation = Qt::Vertical) const;
     void ensureEffectiveFirstAndLastRows() const;
+    void ensureColumnAndRowData(const QLayoutStyleInfo &styleInfo) const;
+    void ensureColumnAndRowData(QGridLayoutRowData *rowData, QGridLayoutBox *totalBox,
+                                            const QLayoutStyleInfo &styleInfo,
+                                            qreal *colPositions, qreal *colSizes,
+                                            Qt::Orientation orientation) const;
     void ensureGeometries(const QLayoutStyleInfo &styleInfo, const QSizeF &size) const;
 …
     mutable int q_cachedEffectiveFirstRows[NOrientations];
     mutable int q_cachedEffectiveLastRows[NOrientations];
     // Layout item input

trunk/src/gui/graphicsview/qsimplex_p.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation ([email protected])

trunk/src/gui/graphicsview/qsimplex_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation ([email protected])

/branches/vendor/nokia/qt/4.7.2 (added)	merged: 845
/branches/vendor/nokia/qt/current	merged: 844
/branches/vendor/nokia/qt/4.6.3	removed

Context Navigation

Legend:

Download in other formats: