Changeset 561 for trunk/src/gui/graphicsview

trunk

Property svn:mergeinfo set to (toggle deleted branches)
/branches/vendor/nokia/qt/4.6.1 merged eligible
/branches/vendor/nokia/qt/current merged eligible
/branches/vendor/trolltech/qt/current 3-149

trunk/src/gui/graphicsview/graphicsview.pri

-              r2
+              r561
 # Qt graphicsview module
+HEADERS += graphicsview/qgraphicsgridlayout.h \
+    graphicsview/qgraphicsitem.h \
+    graphicsview/qgraphicsitem_p.h \
+    graphicsview/qgraphicsitemanimation.h \
+    graphicsview/qgraphicslayout.h \
+    graphicsview/qgraphicslayout_p.h \
+    graphicsview/qgraphicslayoutitem.h \
+    graphicsview/qgraphicslayoutitem_p.h \
+    graphicsview/qgraphicslinearlayout.h \
+    graphicsview/qgraphicsproxywidget.h \
+    graphicsview/qgraphicsscene.h \
+    graphicsview/qgraphicsscene_bsp_p.h \
+    graphicsview/qgraphicsscene_p.h \
+    graphicsview/qgraphicsscenebsptreeindex_p.h \
+    graphicsview/qgraphicssceneevent.h \
+    graphicsview/qgraphicssceneindex_p.h \
+    graphicsview/qgraphicsscenelinearindex_p.h \
+    graphicsview/qgraphicstransform.h \
+    graphicsview/qgraphicstransform_p.h \
+    graphicsview/qgraphicsview.h \
+    graphicsview/qgraphicsview_p.h \
+    graphicsview/qgraphicswidget.h \
+    graphicsview/qgraphicswidget_p.h \
+    graphicsview/qgridlayoutengine_p.h \
+    graphicsview/qgraph_p.h \
+    graphicsview/qsimplex_p.h \
+    graphicsview/qgraphicsanchorlayout_p.h \
+    graphicsview/qgraphicsanchorlayout.h
+HEADERS += \
+        graphicsview/qgraphicsitem.h \
+        graphicsview/qgraphicsitem_p.h \
+        graphicsview/qgraphicsitemanimation.h \
+        graphicsview/qgraphicsscene.h \
+        graphicsview/qgraphicsscene_p.h \
+        graphicsview/qgraphicsscene_bsp_p.h \
+        graphicsview/qgraphicssceneevent.h \
+        graphicsview/qgraphicsview_p.h \
+        graphicsview/qgraphicsview.h
+SOURCES += \
+        graphicsview/qgraphicsitem.cpp \
+        graphicsview/qgraphicsitemanimation.cpp \
+        graphicsview/qgraphicsscene.cpp \
+        graphicsview/qgraphicsscene_bsp.cpp \
+        graphicsview/qgraphicssceneevent.cpp \
+        graphicsview/qgraphicsview.cpp
+# Widgets on the canvas
+HEADERS += \
+        graphicsview/qgraphicslayout.h \
+        graphicsview/qgraphicslayout_p.h \
+        graphicsview/qgraphicslayoutitem.h \
+        graphicsview/qgraphicslayoutitem_p.h \
+        graphicsview/qgraphicslinearlayout.h \
+        graphicsview/qgraphicswidget.h \
+        graphicsview/qgraphicswidget_p.h \
+        graphicsview/qgridlayoutengine_p.h \
+        graphicsview/qgraphicsproxywidget.h \
+        graphicsview/qgraphicsgridlayout.h
+SOURCES += \
+        graphicsview/qgraphicslayout.cpp \
+        graphicsview/qgraphicslayout_p.cpp \
+        graphicsview/qgraphicslayoutitem.cpp \
+        graphicsview/qgraphicslinearlayout.cpp \
+        graphicsview/qgraphicswidget.cpp \
+        graphicsview/qgraphicswidget_p.cpp \
+        graphicsview/qgridlayoutengine.cpp \
+        graphicsview/qgraphicsproxywidget.cpp \
+        graphicsview/qgraphicsgridlayout.cpp
+SOURCES += graphicsview/qgraphicsgridlayout.cpp \
+    graphicsview/qgraphicsitem.cpp \
+    graphicsview/qgraphicsitemanimation.cpp \
+    graphicsview/qgraphicslayout.cpp \
+    graphicsview/qgraphicslayout_p.cpp \
+    graphicsview/qgraphicslayoutitem.cpp \
+    graphicsview/qgraphicslinearlayout.cpp \
+    graphicsview/qgraphicsproxywidget.cpp \
+    graphicsview/qgraphicsscene.cpp \
+    graphicsview/qgraphicsscene_bsp.cpp \
+    graphicsview/qgraphicsscenebsptreeindex.cpp \
+    graphicsview/qgraphicssceneevent.cpp \
+    graphicsview/qgraphicssceneindex.cpp \
+    graphicsview/qgraphicsscenelinearindex.cpp \
+    graphicsview/qgraphicstransform.cpp \
+    graphicsview/qgraphicsview.cpp \
+    graphicsview/qgraphicswidget.cpp \
+    graphicsview/qgraphicswidget_p.cpp \
+    graphicsview/qgridlayoutengine.cpp \
+    graphicsview/qsimplex_p.cpp \
+    graphicsview/qgraphicsanchorlayout_p.cpp \
+    graphicsview/qgraphicsanchorlayout.cpp

trunk/src/gui/graphicsview/qgraphicsgridlayout.cpp

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 …
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
     widgets in Graphics View.
     \since 4.4
+    \ingroup multimedia
     \ingroup graphicsview-api
 …
     removeAt() will remove an item from the layout, without
     destroying it.
     \sa QGraphicsLinearLayout, QGraphicsWidget
 */
 …
     QGridLayoutEngine engine;
 #ifdef QT_DEBUG
+#ifdef QT_DEBUG
     void dump(int indent) const;
 #endif
 …
         wid = new QWidget;
     QGraphicsItem *item = parentItem();
     QStyle *style = (item && item->isWidget()) ? static_cast<QGraphicsWidget*>(item)->style() : qApp->style();
+    QStyle *style = (item && item->isWidget()) ? static_cast<QGraphicsWidget*>(item)->style() : QApplication::style();
     return QLayoutStyleInfo(style, wid);
+}
 …
         QGraphicsLayoutItem *item = itemAt(i);
         // The following lines can be removed, but this removes the item
         // from the layout more efficiently than the implementation of
+        // from the layout more efficiently than the implementation of
         // ~QGraphicsLayoutItem.
         removeAt(i);
 …
     Q_D(QGraphicsGridLayout);
     if (row < 0 || column < 0) {
         qWarning("QGraphicsGridLayout::addItem: invalid row/column: %d",
                  row < 0 ? row : column);
         return;
+        qWarning("QGraphicsGridLayout::addItem: invalid row/column: %d",
+                 row < 0 ? row : column);
+        return;
+    }
     if (columnSpan < 1 || rowSpan < 1) {
         qWarning("QGraphicsGridLayout::addItem: invalid row span/column span: %d",
                  rowSpan < 1 ? rowSpan : columnSpan);
         return;
+        qWarning("QGraphicsGridLayout::addItem: invalid row span/column span: %d",
+                 rowSpan < 1 ? rowSpan : columnSpan);
+        return;
+    }
     if (!item) {
+        qWarning("QGraphicsGridLayout::addItem: cannot add null item");
+        return;
+        qWarning("QGraphicsGridLayout::addItem: cannot add null item");
+        return;
+    }
+    if (item == this) {
+        qWarning("QGraphicsGridLayout::addItem: cannot insert itself");
+        return;
+    }
 …
 QT_END_NAMESPACE
 #endif //QT_NO_GRAPHICSVIEW
+#endif //QT_NO_GRAPHICSVIEW

trunk/src/gui/graphicsview/qgraphicsgridlayout.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 …
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **

trunk/src/gui/graphicsview/qgraphicsitem.cpp

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 …
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
     items in a QGraphicsScene.
     \since 4.2
+    \ingroup multimedia
     \ingroup graphicsview-api
 …
     QGraphicsItem is part of \l{The Graphics View Framework}
     \img graphicsview-items.png
+    \image graphicsview-items.png
     For convenience, Qt provides a set of standard graphics items for the most
 …
     \snippet doc/src/snippets/code/src_gui_graphicsview_qgraphicsitem.cpp 0
+    The boundingRect() function has many different purposes. QGraphicsScene
+    bases its item index on boundingRect(), and QGraphicsView uses it both for
+    culling invisible items, and for determining the area that needs to be
+    recomposed when drawing overlapping items. In addition, QGraphicsItem's
+    collision detection mechanisms use boundingRect() to provide an efficient
+    cut-off. The fine grained collision algorithm in collidesWithItem() is based
+    on calling shape(), which returns an accurate outline of the item's shape
+    as a QPainterPath.
+    QGraphicsScene expects all items boundingRect() and shape() to remain
+    unchanged unless it is notified. If you want to change an item's geometry
+    in any way, you must first call prepareGeometryChange() to allow
+    QGraphicsScene to update its bookkeeping.
+    The boundingRect() function has many different purposes.
+    QGraphicsScene bases its item index on boundingRect(), and
+    QGraphicsView uses it both for culling invisible items, and for
+    determining the area that needs to be recomposed when drawing
+    overlapping items. In addition, QGraphicsItem's collision
+    detection mechanisms use boundingRect() to provide an efficient
+    cut-off. The fine grained collision algorithm in
+    collidesWithItem() is based on calling shape(), which returns an
+    accurate outline of the item's shape as a QPainterPath.
+    QGraphicsScene expects all items boundingRect() and shape() to
+    remain unchanged unless it is notified. If you want to change an
+    item's geometry in any way, you must first call
+    prepareGeometryChange() to allow QGraphicsScene to update its
+    bookkeeping.
     Collision detection can be done in two ways:
 …
     \list 1
+    \o Reimplement shape() to return an accurate shape for your item, and rely
+    on the default implementation of collidesWithItem() to do shape-shape
+    intersection. This can be rather expensive if the shapes are complex.
+    \o Reimplement collidesWithItem() to provide your own custom item and shape
+    collision algorithm.
+    \o Reimplement shape() to return an accurate shape for your item,
+    and rely on the default implementation of collidesWithItem() to do
+    shape-shape intersection. This can be rather expensive if the
+    shapes are complex.
+    \o Reimplement collidesWithItem() to provide your own custom item
+    and shape collision algorithm.
     \endlist
 …
     \img graphicsview-parentchild.png
+    QGraphicsItem supports affine transformations in addition to its base
+    position, pos(). To change the item's transformation, you can either pass
+    a transformation matrix to setTransform(), or call one of the convenience
+    functions rotate(), scale(), translate(), or shear(). Item transformations
+    accumulate from parent to child, so if both a parent and child item are
+    rotated 90 degrees, the child's total transformation will be 180 degrees.
+    Similarly, if the item's parent is scaled to 2x its original size, its
+    children will also be twice as large. An item's transformation does not
+    affect its own local geometry; all geometry functions (e.g., contains(),
+    update(), and all the mapping functions) still operate in local
+    coordinates. For convenience, QGraphicsItem provides the functions
+    sceneTransform(), which returns the item's total transformation matrix
+    (including its position and all parents' positions and transformations),
+    and scenePos(), which returns its position in scene coordinates. To reset
+    an item's matrix, call resetTransform().
+    \section1 Transformation
+    QGraphicsItem supports projective transformations in addition to its base
+    position, pos(). There are several ways to change an item's transformation.
+    For simple transformations, you can call either of the convenience
+    functions setRotation() or setScale(), or you can pass any transformation
+    matrix to setTransform(). For advanced transformation control you also have
+    the option of setting several combined transformations by calling
+    setTransformations().
+    Item transformations accumulate from parent to child, so if both a parent
+    and child item are rotated 90 degrees, the child's total transformation
+    will be 180 degrees. Similarly, if the item's parent is scaled to 2x its
+    original size, its children will also be twice as large. An item's
+    transformation does not affect its own local geometry; all geometry
+    functions (e.g., contains(), update(), and all the mapping functions) still
+    operate in local coordinates. For convenience, QGraphicsItem provides the
+    functions sceneTransform(), which returns the item's total transformation
+    matrix (including its position and all parents' positions and
+    transformations), and scenePos(), which returns its position in scene
+    coordinates. To reset an item's matrix, call resetTransform().
+    Certain transformation operations produce a different outcome depending on
+    the order in which they are applied. For example, if you scale an
+    transform, and then rotate it, you may get a different result than if the
+    transform was rotated first. However, the order you set the transformation
+    properties on QGraphicsItem does not affect the resulting transformation;
+    QGraphicsItem always applies the properties in a fixed, defined order:
+    \list
+    \o The item's base transform is applied (transform())
+    \o The item's transformations list is applied in order (transformations())
+    \o The item is rotated relative to its transform origin point (rotation(), transformOriginPoint())
+    \o The item is scaled relative to its transform origin point (scale(), transformOriginPoint())
+    \endlist
+    \section1 Painting
     The paint() function is called by QGraphicsView to paint the item's
 …
     drawn before their children.
+    \section1 Sorting
+    All items are drawn in a defined, stable order, and this same order decides
+    which items will receive mouse input first when you click on the scene.
+    Normally you don't have to worry about sorting, as the items follow a
+    "natural order", following the logical structure of the scene.
+    An item's children are stacked on top of the parent, and sibling items are
+    stacked by insertion order (i.e., in the same order that they were either
+    added to the scene, or added to the same parent). If you add item A, and
+    then B, then B will be on top of A. If you then add C, the items' stacking
+    order will be A, then B, then C.
+    \image graphicsview-zorder.png
+    This example shows the stacking order of all limbs of the robot from the
+    \l{graphicsview/dragdroprobot}{Drag and Drop Robot} example. The torso is
+    the root item (all other items are children or descendants of the torso),
+    so it is drawn first. Next, the head is drawn, as it is the first item in
+    the torso's list of children. Then the upper left arm is drawn. As the
+    lower arm is a child of the upper arm, the lower arm is then drawn,
+    followed by the upper arm's next sibling, which is the upper right arm, and
+    so on.
+    For advanced users, there are ways to alter how your items are sorted:
+    \list
+    \o You can call setZValue() on an item to explicitly stack it on top of, or
+    under, other sibling items. The default Z value for an item is 0. Items
+    with the same Z value are stacked by insertion order.
+    \o You can call stackBefore() to reorder the list of children. This will
+    directly modify the insertion order.
+    \o You can set the ItemStacksBehindParent flag to stack a child item behind
+    its parent.
+    \endlist
+    The stacking order of two sibling items also counts for each item's
+    children and descendant items. So if one item is on top of another, then
+    all its children will also be on top of all the other item's children as
+    well.
+    \section1 Events
     QGraphicsItem receives events from QGraphicsScene through the virtual
     function sceneEvent(). This function distributes the most common events
 …
     hover enter, move and leave events
     \o inputMethodEvent() handles input events, for accessibility support
     \o keyPressEvent() and keyReleaseEvent handle key press and release events
+    \o keyPressEvent() and keyReleaseEvent() handle key press and release events
     \o mousePressEvent(), mouseMoveEvent(), mouseReleaseEvent(), and
     mouseDoubleClickEvent() handles mouse press, move, release, click and
 …
     \endlist
+    You can filter events for any other item by installing event
+    filters. This functionaly is separate from from Qt's regular
+    event filters (see QObject::installEventFilter()), which only
+    work on subclasses of QObject. After installing your item as an
+    event filter for another item by calling
+    installSceneEventFilter(), the filtered events will be received
+    by the virtual function sceneEventFilter(). You can remove item
+    event filters by calling removeSceneEventFilter().
+    You can filter events for any other item by installing event filters. This
+    functionality is separate from Qt's regular event filters (see
+    QObject::installEventFilter()), which only work on subclasses of QObject. After
+    installing your item as an event filter for another item by calling
+    installSceneEventFilter(), the filtered events will be received by the virtual
+    function sceneEventFilter(). You can remove item event filters by calling
+    removeSceneEventFilter().
+    \section1 Custom Data
     Sometimes it's useful to register custom data with an item, be it a custom
 …
     drop shadow effects and for decoration objects that follow the parent
     item's geometry without drawing on top of it.
+    \value ItemUsesExtendedStyleOption The item makes use of either
+    \l{QStyleOptionGraphicsItem::}{exposedRect} or
+    \l{QStyleOptionGraphicsItem::}{matrix} in QStyleOptionGraphicsItem. By default,
+    the \l{QStyleOptionGraphicsItem::}{exposedRect} is initialized to the item's
+    boundingRect() and the \l{QStyleOptionGraphicsItem::}{matrix} is untransformed.
+    You can enable this flag for the style options to be set up with more
+    fine-grained values.
+    Note that QStyleOptionGraphicsItem::levelOfDetail is unaffected by this flag
+    and always initialized to 1. Use
+    QStyleOptionGraphicsItem::levelOfDetailFromTransform() if you need a higher
+    value.
+    \value ItemHasNoContents The item does not paint anything (i.e., calling
+    paint() on the item has no effect). You should set this flag on items that
+    do not need to be painted to ensure that Graphics View avoids unnecessary
+    painting preparations. This flag was introduced in Qt 4.6.
+    \value ItemSendsGeometryChanges The item enables itemChange()
+    notifications for ItemPositionChange, ItemPositionHasChanged,
+    ItemMatrixChange, ItemTransformChange, and ItemTransformHasChanged. For
+    performance reasons, these notifications are disabled by default. You must
+    enable this flag to receive notifications for position and transform
+    changes. This flag was introduced in Qt 4.6.
+    \value ItemAcceptsInputMethod The item supports input methods typically
+    used for Asian languages.
+    This flag was introduced in Qt 4.6.
+    \value ItemNegativeZStacksBehindParent The item automatically stacks behind
+    it's parent if it's z-value is negative. This flag enables setZValue() to
+    toggle ItemStacksBehindParent.
+    \value ItemIsPanel The item is a panel. A panel provides activation and
+    contained focus handling. Only one panel can be active at a time (see
+    QGraphicsItem::isActive()). When no panel is active, QGraphicsScene
+    activates all non-panel items. Window items (i.e.,
+    QGraphicsItem::isWindow() returns true) are panels. This flag was
+    introduced in Qt 4.6.
+    \omitvalue ItemIsFocusScope \omit Internal only (for now). \endomit
+    \value ItemSendsScenePositionChanges The item enables itemChange()
+    notifications for ItemScenePositionHasChanged. For performance reasons,
+    these notifications are disabled by default. You must enable this flag
+    to receive notifications for scene position changes. This flag was
+    introduced in Qt 4.6.
 */
 …
     \value ItemPositionChange The item's position changes. This notification
     is only sent when the item's local position changes, relative to its
     parent, has changed (i.e., as a result of calling setPos() or
     moveBy()). The value argument is the new position (i.e., a QPointF).  You
     can call pos() to get the original position. Do not call setPos() or
     moveBy() in itemChange() as this notification is delivered; instead, you
     can return the new, adjusted position from itemChange(). After this
     notification, QGraphicsItem immediately sends the ItemPositionHasChanged
     notification if the position changed.
+    is sent if the ItemSendsGeometryChanges flag is enabled, and when the
+    item's local position changes, relative to its parent (i.e., as a result
+    of calling setPos() or moveBy()). The value argument is the new position
+    (i.e., a QPointF).  You can call pos() to get the original position. Do
+    not call setPos() or moveBy() in itemChange() as this notification is
+    delivered; instead, you can return the new, adjusted position from
+    itemChange(). After this notification, QGraphicsItem immediately sends the
+    ItemPositionHasChanged notification if the position changed.
     \value ItemPositionHasChanged The item's position has changed. This
+    notification is only sent after the item's local position, relative to its
+    parent, has changed. The value argument is the new position (the same as
+    pos()), and QGraphicsItem ignores the return value for this notification
+    (i.e., a read-only notification).
+    notification is sent if the ItemSendsGeometryChanges flag is enabled, and
+    after the item's local position, relative to its parent, has changed. The
+    value argument is the new position (the same as pos()), and QGraphicsItem
+    ignores the return value for this notification (i.e., a read-only
+    notification).
     \value ItemTransformChange The item's transformation matrix changes. This
+    notification is only sent when the item's local transformation matrix
+    changes (i.e., as a result of calling setTransform(), or one of the
+    convenience transformation functions, such as rotate()). The value
+    argument is the new matrix (i.e., a QTransform); to get the old matrix,
+    call transform(). Do not call setTransform() or any of the transformation
+    convenience functions in itemChange() as this notification is delivered;
+    instead, you can return the new matrix from itemChange().
+    notification is send if the ItemSendsGeometryChanges flag is enabled, and
+    when the item's local transformation matrix changes (i.e., as a result of
+    calling setTransform(). The value argument is the new matrix (i.e., a
+    QTransform); to get the old matrix, call transform(). Do not call
+    setTransform() or set any of the transformation properties in itemChange()
+    as this notification is delivered; instead, you can return the new matrix
+    from itemChange().  This notification is not sent if you change the
+    transformation properties.
     \value ItemTransformHasChanged The item's transformation matrix has
+    changed.  This notification is only sent after the item's local
+    trasformation matrix has changed. The value argument is the new matrix
+    changed either because setTransform is called, or one of the
+    transformation properties is changed. This notification is sent if the
+    ItemSendsGeometryChanges flag is enabled, and after the item's local
+    transformation matrix has changed. The value argument is the new matrix
     (same as transform()), and QGraphicsItem ignores the return value for this
     notification (i.e., a read-only notification).
     \value ItemSelectedChange The item's selected state changes. If the item
     is presently selected, it will become unselected, and vice verca. The
     value argument is the new selected state (i.e., true or false). Do not
     call setSelected() in itemChange() as this notification is delivered();
     instead, you can return the new selected state from itemChange().
+    \value ItemSelectedChange The item's selected state changes. If the item is
+    presently selected, it will become unselected, and vice verca. The value
+    argument is the new selected state (i.e., true or false). Do not call
+    setSelected() in itemChange() as this notification is delivered; instead, you
+    can return the new selected state from itemChange().
     \value ItemSelectedHasChanged The item's selected state has changed. The
 …
     argument is the new opacity (i.e., a double). Do not call setOpacity() as
     this notification is delivered. The return value is ignored.
+    \value ItemScenePositionHasChanged The item's scene position has changed.
+    This notification is sent if the ItemSendsScenePositionChanges flag is
+    enabled, and after the item's scene position has changed (i.e., the
+    position or transformation of the item itself or the position or
+    transformation of any ancestor has changed). The value argument is the
+    new scene position (the same as scenePos()), and QGraphicsItem ignores
+    the return value for this notification (i.e., a read-only notification).
 */
 …
 */
+/*!
+    \enum QGraphicsItem::PanelModality
+    \since 4.6
+    This enum specifies the behavior of a modal panel. A modal panel
+    is one that blocks input to other panels. Note that items that
+    are children of a modal panel are not blocked.
+    The values are:
+    \value NonModal   The panel is not modal and does not block input to other panels.
+    \value PanelModal The panel is modal to a single item hierarchy and blocks input to its parent pane, all grandparent panels, and all siblings of its parent and grandparent panels.
+    \value SceneModal The window is modal to the entire scene and blocks input to all panels.
+    \sa QGraphicsItem::setPanelModality(), QGraphicsItem::panelModality(), QGraphicsItem::ItemIsPanel
+*/
 #include "qgraphicsitem.h"
 …
 #include "qgraphicswidget.h"
 #include "qgraphicsproxywidget.h"
+#include "qgraphicsscenebsptreeindex_p.h"
 #include <QtCore/qbitarray.h>
 #include <QtCore/qdebug.h>
 …
 #include <QtGui/qstyleoption.h>
 #include <QtGui/qevent.h>
+#include <QtGui/qinputcontext.h>
+#include <QtGui/qgraphicseffect.h>
 #include <private/qgraphicsitem_p.h>
 …
 #include <private/qtextdocumentlayout_p.h>
 #include <private/qtextengine_p.h>
+#include <private/qwidget_p.h>
+#ifdef Q_WS_X11
+#include <private/qt_x11_p.h>
+#include <private/qpixmap_x11_p.h>
+#endif
+#include <private/qgesturemanager_p.h>
 #include <math.h>
 QT_BEGIN_NAMESPACE
-// QRectF::intersects() returns false always if either the source or target
-// rectangle's width or height are 0. This works around that problem.
-static inline void _q_adjustRect(QRectF *rect)
+{
-    Q_ASSERT(rect);
-    if (!rect->width())
-        rect->adjust(-0.00001, 0, 0.00001, 0);
-    if (!rect->height())
-        rect->adjust(0, -0.00001, 0, 0.00001);
+}
 static inline void _q_adjustRect(QRect *rect)
 …
 };
 Q_GLOBAL_STATIC(QGraphicsItemCustomDataStore, qt_dataStore)
-/*!
-    \internal
-    Removes the first instance of \a child from \a children. This is a
-    heuristic approach that assumes that it's common to remove items from the
-    start or end of the list.
-*/
-static void qt_graphicsitem_removeChild(QGraphicsItem *child, QList<QGraphicsItem *> *children)
+{
-    const int n = children->size();
-    for (int i = 0; i < (n + 1) / 2; ++i) {
-        if (children->at(i) == child) {
-            children->removeAt(i);
-            return;
+        }
-        int j = n - i - 1;
-        if (children->at(j) == child) {
-            children->removeAt(j);
-            return;
+        }
+    }
+}
 /*!
 …
         // disabled \a childFlag, or has been reparented.
         switch (int(childFlag)) {
+        case -2:
+            flag = AncestorFiltersChildEvents;
+            enabled = q->filtersChildEvents();
+            break;
         case -1:
             flag = AncestorHandlesChildEvents;
 …
             flag = AncestorClipsChildren;
             enabled = flags & QGraphicsItem::ItemClipsChildrenToShape;
-            invalidateCachedClipPathRecursively(/*childrenOnly=*/true);
             break;
         case QGraphicsItem::ItemIgnoresTransformations:
 …
+        }
+        // Inherit the enabled-state from our parents.
+        if ((parent && ((parent->d_ptr->ancestorFlags & flag)
+                        || (int(parent->d_ptr->flags & childFlag) == childFlag)
+                        || (childFlag == -1 && parent->d_ptr->handlesChildEvents)))) {
+            enabled = true;
+            ancestorFlags |= flag;
+        if (parent) {
+            // Inherit the enabled-state from our parents.
+            if ((parent->d_ptr->ancestorFlags & flag)
+                    || (int(parent->d_ptr->flags & childFlag) == childFlag)
+                        || (childFlag == -1 && parent->d_ptr->handlesChildEvents)
+                        || (childFlag == -2 && parent->d_ptr->filtersDescendantEvents)) {
+                enabled = true;
+                ancestorFlags |= flag;
+            } else {
+                ancestorFlags &= ~flag;
+            }
+        } else {
+            // Top-level root items don't have any ancestors, so there are no
+            // ancestor flags either.
+            ancestorFlags = 0;
+        }
-        // Top-level root items don't have any ancestors, so there are no
-        // ancestor flags either.
-        if (!parent)
-            ancestorFlags = 0;
     } else {
         // Don't set or propagate the ancestor flag if it's already correct.
 …
         // Don't process children if the item has the main flag set on itself.
+        if ((childFlag != -1 &&  int(flags & childFlag) == childFlag) || (int(childFlag) == -1 && handlesChildEvents))
+        if ((childFlag != -1 &&  int(flags & childFlag) == childFlag)
+            || (int(childFlag) == -1 && handlesChildEvents)
+            || (int(childFlag) == -2 && filtersDescendantEvents))
             return;
+    }
 …
     \internal
+    Returns true if this item or any of its ancestors are untransformable.
+*/
+bool QGraphicsItemPrivate::itemIsUntransformable() const
+{
+    return (flags & QGraphicsItem::ItemIgnoresTransformations)
+        || (ancestorFlags & AncestorIgnoresTransformations);
+    Combines this item's position and transform onto \a transform.
+    If you need to change this function (e.g., adding more transformation
+    modes / options), make sure to change all places marked with COMBINE.
+*/
+void QGraphicsItemPrivate::combineTransformToParent(QTransform *x, const QTransform *viewTransform) const
+{
+    // COMBINE
+    if (viewTransform && itemIsUntransformable()) {
+        *x = q_ptr->deviceTransform(*viewTransform);
+    } else {
+        if (transformData)
+            *x *= transformData->computedFullTransform();
+        if (!pos.isNull())
+            *x *= QTransform::fromTranslate(pos.x(), pos.y());
+    }
+}
+/*!
+    \internal
+    Combines this item's position and transform onto \a transform.
+    If you need to change this function (e.g., adding more transformation
+    modes / options), make sure to change QGraphicsItem::deviceTransform() as
+    well.
+*/
+void QGraphicsItemPrivate::combineTransformFromParent(QTransform *x, const QTransform *viewTransform) const
+{
+    // COMBINE
+    if (viewTransform && itemIsUntransformable()) {
+        *x = q_ptr->deviceTransform(*viewTransform);
+    } else {
+        x->translate(pos.x(), pos.y());
+        if (transformData)
+            *x = transformData->computedFullTransform(x);
+    }
+}
+void QGraphicsItemPrivate::updateSceneTransformFromParent()
+{
+    if (parent) {
+        Q_ASSERT(!parent->d_ptr->dirtySceneTransform);
+        if (parent->d_ptr->sceneTransformTranslateOnly) {
+            sceneTransform = QTransform::fromTranslate(parent->d_ptr->sceneTransform.dx() + pos.x(),
+                                                       parent->d_ptr->sceneTransform.dy() + pos.y());
+        } else {
+            sceneTransform = parent->d_ptr->sceneTransform;
+            sceneTransform.translate(pos.x(), pos.y());
+        }
+        if (transformData) {
+            sceneTransform = transformData->computedFullTransform(&sceneTransform);
+            sceneTransformTranslateOnly = (sceneTransform.type() <= QTransform::TxTranslate);
+        } else {
+            sceneTransformTranslateOnly = parent->d_ptr->sceneTransformTranslateOnly;
+        }
+    } else if (!transformData) {
+        sceneTransform = QTransform::fromTranslate(pos.x(), pos.y());
+        sceneTransformTranslateOnly = 1;
+    } else if (transformData->onlyTransform) {
+        sceneTransform = transformData->transform;
+        if (!pos.isNull())
+            sceneTransform *= QTransform::fromTranslate(pos.x(), pos.y());
+        sceneTransformTranslateOnly = (sceneTransform.type() <= QTransform::TxTranslate);
+    } else if (pos.isNull()) {
+        sceneTransform = transformData->computedFullTransform();
+        sceneTransformTranslateOnly = (sceneTransform.type() <= QTransform::TxTranslate);
+    } else {
+        sceneTransform = QTransform::fromTranslate(pos.x(), pos.y());
+        sceneTransform = transformData->computedFullTransform(&sceneTransform);
+        sceneTransformTranslateOnly = (sceneTransform.type() <= QTransform::TxTranslate);
+    }
+    dirtySceneTransform = 0;
+}
 …
     \internal
+    Make sure not to trigger any pure virtual function calls (e.g.,
+    prepareGeometryChange) if the item is in its destructor, i.e.
+    inDestructor is 1.
+*/
+void QGraphicsItemPrivate::setParentItemHelper(QGraphicsItem *newParent)
+{
+    Q_Q(QGraphicsItem);
+    if (newParent == q) {
+        qWarning("QGraphicsItem::setParentItem: cannot assign %p as a parent of itself", this);
+        return;
+    }
+    if (newParent == parent)
+        return;
+    const QVariant newParentVariant(q->itemChange(QGraphicsItem::ItemParentChange,
+                                                  qVariantFromValue<QGraphicsItem *>(newParent)));
+    newParent = qVariantValue<QGraphicsItem *>(newParentVariant);
+    if (newParent == parent)
+        return;
+    if (scene) {
+        // Deliver the change to the index
+        scene->d_func()->index->itemChange(q, QGraphicsItem::ItemParentChange, newParentVariant);
+        // Disable scene pos notifications for old ancestors
+        if (scenePosDescendants || (flags & QGraphicsItem::ItemSendsScenePositionChanges))
+            scene->d_func()->setScenePosItemEnabled(q, false);
+    }
+    if (subFocusItem && parent) {
+        // Make sure none of the old parents point to this guy.
+        subFocusItem->d_ptr->clearSubFocus(parent);
+    }
+    // We anticipate geometry changes. If the item is deleted, it will be
+    // removed from the index at a later stage, and the whole scene will be
+    // updated.
+    if (!inDestructor)
+        q_ptr->prepareGeometryChange();
+    const QVariant thisPointerVariant(qVariantFromValue<QGraphicsItem *>(q));
+    if (parent) {
+        // Remove from current parent
+        parent->d_ptr->removeChild(q);
+        parent->itemChange(QGraphicsItem::ItemChildRemovedChange, thisPointerVariant);
+    }
+    // Update toplevelitem list. If this item is being deleted, its parent
+    // will be 0 but we don't want to register/unregister it in the TLI list.
+    if (scene && !inDestructor) {
+        if (parent && !newParent) {
+            scene->d_func()->registerTopLevelItem(q);
+        } else if (!parent && newParent) {
+            scene->d_func()->unregisterTopLevelItem(q);
+        }
+    }
+    // Ensure any last parent focus scope does not point to this item or any of
+    // its descendents.
+    QGraphicsItem *p = parent;
+    QGraphicsItem *parentFocusScopeItem = 0;
+    while (p) {
+        if (p->flags() & QGraphicsItem::ItemIsFocusScope) {
+            // If this item's focus scope's focus scope item points
+            // to this item or a descendent, then clear it.
+            QGraphicsItem *fsi = p->d_ptr->focusScopeItem;
+            if (q_ptr == fsi || q_ptr->isAncestorOf(fsi)) {
+                parentFocusScopeItem = fsi;
+                p->d_ptr->focusScopeItem = 0;
+            }
+            break;
+        }
+        p = p->d_ptr->parent;
+    }
+    // Update focus scope item ptr in new scope.
+    QGraphicsItem *newFocusScopeItem = subFocusItem ? subFocusItem : parentFocusScopeItem;
+    if (newFocusScopeItem && newParent) {
+        if (subFocusItem) {
+            // Find the subFocusItem's topmost focus scope.
+            QGraphicsItem *ancestorScope = 0;
+            QGraphicsItem *p = subFocusItem->d_ptr->parent;
+            while (p) {
+                if (p->flags() & QGraphicsItem::ItemIsFocusScope)
+                    ancestorScope = p;
+                if (p->isPanel())
+                    break;
+                p = p->parentItem();
+            }
+            if (ancestorScope)
+                newFocusScopeItem = ancestorScope;
+        }
+        QGraphicsItem *p = newParent;
+        while (p) {
+            if (p->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
+                // by setting focus on the scope itself.
+                if (subFocusItem && !p->focusItem())
+                    subFocusItem->d_ptr->clearSubFocus();
+                break;
+            }
+            p = p->d_ptr->parent;
+        }
+    }
+    if ((parent = newParent)) {
+        bool implicitUpdate = false;
+        if (parent->d_func()->scene && parent->d_func()->scene != scene) {
+            // Move this item to its new parent's scene
+            parent->d_func()->scene->addItem(q);
+            implicitUpdate = true;
+        } else if (!parent->d_func()->scene && scene) {
+            // Remove this item from its former scene
+            scene->removeItem(q);
+        }
+        parent->d_ptr->addChild(q);
+        parent->itemChange(QGraphicsItem::ItemChildAddedChange, thisPointerVariant);
+        if (scene) {
+            if (!implicitUpdate)
+                scene->d_func()->markDirty(q_ptr);
+            // Re-enable scene pos notifications for new ancestors
+            if (scenePosDescendants || (flags & QGraphicsItem::ItemSendsScenePositionChanges))
+                scene->d_func()->setScenePosItemEnabled(q, true);
+        }
+        // Inherit ancestor flags from the new parent.
+        updateAncestorFlag(QGraphicsItem::GraphicsItemFlag(-2));
+        updateAncestorFlag(QGraphicsItem::GraphicsItemFlag(-1));
+        updateAncestorFlag(QGraphicsItem::ItemClipsChildrenToShape);
+        updateAncestorFlag(QGraphicsItem::ItemIgnoresTransformations);
+        // Update item visible / enabled.
+        if (parent->isVisible() != visible) {
+            if (!parent->isVisible() || !explicitlyHidden)
+                setVisibleHelper(parent->isVisible(), /* explicit = */ false, /* update = */ !implicitUpdate);
+        }
+        if (parent->isEnabled() != enabled) {
+            if (!parent->isEnabled() || !explicitlyDisabled)
+                setEnabledHelper(parent->isEnabled(), /* explicit = */ false, /* update = */ !implicitUpdate);
+        }
+        // Auto-activate if visible and the parent is active.
+        if (q->isVisible() && parent->isActive())
+            q->setActive(true);
+    } else {
+        // Inherit ancestor flags from the new parent.
+        updateAncestorFlag(QGraphicsItem::GraphicsItemFlag(-2));
+        updateAncestorFlag(QGraphicsItem::GraphicsItemFlag(-1));
+        updateAncestorFlag(QGraphicsItem::ItemClipsChildrenToShape);
+        updateAncestorFlag(QGraphicsItem::ItemIgnoresTransformations);
+        if (!inDestructor) {
+            // Update item visible / enabled.
+            if (!visible && !explicitlyHidden)
+                setVisibleHelper(true, /* explicit = */ false);
+            if (!enabled && !explicitlyDisabled)
+                setEnabledHelper(true, /* explicit = */ false);
+            // If the item is being deleted, the whole scene will be updated.
+            if (scene)
+                scene->d_func()->markDirty(q_ptr);
+        }
+    }
+    // Resolve depth.
+    invalidateDepthRecursively();
+    dirtySceneTransform = 1;
+    // Restore the sub focus chain.
+    if (subFocusItem) {
+        subFocusItem->d_ptr->setSubFocus(newParent);
+        if (parent && parent->isActive())
+            subFocusItem->setFocus();
+    }
+    // Deliver post-change notification
+    q->itemChange(QGraphicsItem::ItemParentHasChanged, newParentVariant);
+    if (isObject)
+        emit static_cast<QGraphicsObject *>(q)->parentChanged();
+}
+/*!
+    \internal
+    Returns the bounding rect of this item's children (excluding itself).
+*/
+void QGraphicsItemPrivate::childrenBoundingRectHelper(QTransform *x, QRectF *rect)
+{
+    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) {
+            // COMBINE
+            QTransform matrix = childd->transformToParent();
+            if (x)
+                matrix *= *x;
+            *rect |= matrix.mapRect(child->boundingRect());
+            if (!childd->children.isEmpty())
+                childd->childrenBoundingRectHelper(&matrix, rect);
+        } else {
+            if (x)
+                *rect |= x->mapRect(child->boundingRect());
+            else
+                *rect |= child->boundingRect();
+            if (!childd->children.isEmpty())
+                childd->childrenBoundingRectHelper(x, rect);
+        }
+    }
+}
+void QGraphicsItemPrivate::initStyleOption(QStyleOptionGraphicsItem *option, const QTransform &worldTransform,
+                                           const QRegion &exposedRegion, bool allItems) const
+{
+    Q_ASSERT(option);
+    Q_Q(const QGraphicsItem);
+    // Initialize standard QStyleOption values.
+    const QRectF brect = q->boundingRect();
+    option->state = QStyle::State_None;
+    option->rect = brect.toRect();
+    option->levelOfDetail = 1;
+    option->exposedRect = brect;
+    if (selected)
+        option->state |= QStyle::State_Selected;
+    if (enabled)
+        option->state |= QStyle::State_Enabled;
+    if (q->hasFocus())
+        option->state |= QStyle::State_HasFocus;
+    if (scene) {
+        if (scene->d_func()->hoverItems.contains(q_ptr))
+            option->state |= QStyle::State_MouseOver;
+        if (q == scene->mouseGrabberItem())
+            option->state |= QStyle::State_Sunken;
+    }
+    if (!(flags & QGraphicsItem::ItemUsesExtendedStyleOption))
+        return;
+    // Initialize QStyleOptionGraphicsItem specific values (matrix, exposedRect).
+    option->matrix = worldTransform.toAffine(); //### discards perspective
+    if (!allItems) {
+        // Determine the item's exposed area
+        option->exposedRect = QRectF();
+        const QTransform reverseMap = worldTransform.inverted();
+        const QVector<QRect> exposedRects(exposedRegion.rects());
+        for (int i = 0; i < exposedRects.size(); ++i) {
+            option->exposedRect |= reverseMap.mapRect(QRectF(exposedRects.at(i)));
+            if (option->exposedRect.contains(brect))
+                break;
+        }
+        option->exposedRect &= brect;
+    }
+}
+/*!
+    \internal
     Empty all cached pixmaps from the pixmap cache.
 */
 …
+{
     QPixmapCache::remove(key);
+    key = QPixmapCache::Key();
     QMutableMapIterator<QPaintDevice *, DeviceData> it(deviceData);
     while (it.hasNext()) {
 …
 /*!
+    Constructs a QGraphicsItem with the given \a parent.
+    Constructs a QGraphicsItem with the given \a parent item.
+    It does not modify the parent object returned by QObject::parent().
     If \a parent is 0, you can add the item to a scene by calling
 …
     associated with a scene, the item will be removed from the scene before it
     is deleted.
+    \note It is more efficient to remove the item from the QGraphicsScene before
+    destroying the item.
 */
 QGraphicsItem::~QGraphicsItem()
+{
+    if (d_ptr->isObject)
+        QObjectPrivate::get(static_cast<QGraphicsObject *>(this))->wasDeleted = true;
+    d_ptr->inDestructor = 1;
+    d_ptr->removeExtraItemCache();
     clearFocus();
+    d_ptr->removeExtraItemCache();
+    QVariant variant;
+    foreach (QGraphicsItem *child, d_ptr->children) {
+        if (QGraphicsItem *parent = child->parentItem()) {
+            qVariantSetValue<QGraphicsItem *>(variant, child);
+            parent->itemChange(ItemChildRemovedChange, variant);
+    // Update focus scope item ptr.
+    QGraphicsItem *p = d_ptr->parent;
+    while (p) {
+        if (p->flags() & ItemIsFocusScope) {
+            if (p->d_ptr->focusScopeItem == this)
+                p->d_ptr->focusScopeItem = 0;
+            break;
+        }
+        delete child;
+    }
+    d_ptr->children.clear();
+    if (QGraphicsItem *parent = parentItem()) {
+        qVariantSetValue<QGraphicsItem *>(variant, this);
+        parent->itemChange(ItemChildRemovedChange, variant);
+        qt_graphicsitem_removeChild(this, &parent->d_func()->children);
+    }
+    if (d_ptr->scene)
+        d_ptr->scene->d_func()->_q_removeItemLater(this);
+    delete d_ptr;
+        p = p->d_ptr->parent;
+    }
+    if (!d_ptr->children.isEmpty()) {
+        while (!d_ptr->children.isEmpty())
+            delete d_ptr->children.first();
+        Q_ASSERT(d_ptr->children.isEmpty());
+    }
+    if (d_ptr->scene) {
+        d_ptr->scene->d_func()->removeItemHelper(this);
+    } else {
+        d_ptr->resetFocusProxy();
+        d_ptr->setParentItemHelper(0);
+    }
+#ifndef QT_NO_GRAPHICSEFFECT
+    delete d_ptr->graphicsEffect;
+#endif //QT_NO_GRAPHICSEFFECT
+    if (d_ptr->transformData) {
+        for(int i = 0; i < d_ptr->transformData->graphicsTransforms.size(); ++i) {
+            QGraphicsTransform *t = d_ptr->transformData->graphicsTransforms.at(i);
+            static_cast<QGraphicsTransformPrivate *>(t->d_ptr.data())->item = 0;
+            delete t;
+        }
+    }
+    delete d_ptr->transformData;
     qt_dataStore()->data.remove(this);
 …
     parent, 0 is returned.
     \sa setParentItem(), children()
+    \sa setParentItem(), childItems()
 */
 QGraphicsItem *QGraphicsItem::parentItem() const
 …
 /*!
+    \since 4.6
+    Returns a pointer to the item's parent, cast to a QGraphicsObject. returns 0 if the parent item
+    is not a QGraphicsObject.
+    \sa parentItem(), childItems()
+*/
+QGraphicsObject *QGraphicsItem::parentObject() const
+{
+    QGraphicsItem *p = d_ptr->parent;
+    return (p && p->d_ptr->isObject) ? static_cast<QGraphicsObject *>(p) : 0;
+}
+/*!
     \since 4.4
 …
 QGraphicsWidget *QGraphicsItem::window() const
+{
+    if (isWidget() && static_cast<const QGraphicsWidget *>(this)->isWindow())
+        return static_cast<QGraphicsWidget *>(const_cast<QGraphicsItem *>(this));
+    if (QGraphicsWidget *parent = parentWidget())
+        return parent->window();
+    QGraphicsItem *p = panel();
+    if (p && p->isWindow())
+        return static_cast<QGraphicsWidget *>(p);
     return 0;
+}
+/*!
+    \since 4.6
+    Returns the item's panel, or 0 if this item does not have a panel. If the
+    item is a panel, it will return itself. Otherwise it will return the
+    closest ancestor that is a panel.
+    \sa isPanel(), ItemIsPanel
+*/
+QGraphicsItem *QGraphicsItem::panel() const
+{
+    if (d_ptr->flags & ItemIsPanel)
+        return const_cast<QGraphicsItem *>(this);
+    return d_ptr->parent ? d_ptr->parent->panel() : 0;
+}
+/*!
+  \since 4.6
+  Return the graphics item cast to a QGraphicsObject, if the class is actually a
+  graphics object, 0 otherwise.
+*/
+QGraphicsObject *QGraphicsItem::toGraphicsObject()
+{
+    return d_ptr->isObject ? static_cast<QGraphicsObject *>(this) : 0;
+}
+/*!
+  \since 4.6
+  Return the graphics item cast to a QGraphicsObject, if the class is actually a
+  graphics object, 0 otherwise.
+*/
+const QGraphicsObject *QGraphicsItem::toGraphicsObject() const
+{
+    return d_ptr->isObject ? static_cast<const QGraphicsObject *>(this) : 0;
+}
 …
     item to the scene yourself.
+    \sa parentItem(), children()
+    Calling this function on an item that is an ancestor of \a parent have undefined behaviour.
+    \sa parentItem(), childItems()
 */
 void QGraphicsItem::setParentItem(QGraphicsItem *parent)
+{
+    if (parent == this) {
+        qWarning("QGraphicsItem::setParentItem: cannot assign %p as a parent of itself", this);
+        return;
+    }
+    if (parent == d_ptr->parent)
+        return;
+    const QVariant newParentVariant(itemChange(ItemParentChange, qVariantFromValue<QGraphicsItem *>(parent)));
+    parent = qVariantValue<QGraphicsItem *>(newParentVariant);
+    if (parent == d_ptr->parent)
+        return;
+    if (QGraphicsWidget *w = d_ptr->isWidget ? static_cast<QGraphicsWidget *>(this) : parentWidget()) {
+        // Update the child focus chain; when reparenting a widget that has a
+        // focus child, ensure that that focus child clears its focus child
+        // chain from our parents before it's reparented.
+        if (QGraphicsWidget *focusChild = w->focusWidget())
+            focusChild->clearFocus();
+    }
+    // We anticipate geometry changes
+    prepareGeometryChange();
+    const QVariant thisPointerVariant(qVariantFromValue<QGraphicsItem *>(this));
+    if (d_ptr->parent) {
+        // Remove from current parent
+        qt_graphicsitem_removeChild(this, &d_ptr->parent->d_func()->children);
+        d_ptr->parent->itemChange(ItemChildRemovedChange, thisPointerVariant);
+    }
+    if ((d_ptr->parent = parent)) {
+        bool implicitUpdate = false;
+        if (parent->d_func()->scene && parent->d_func()->scene != d_ptr->scene) {
+            // Move this item to its new parent's scene
+            parent->d_func()->scene->addItem(this);
+            implicitUpdate = true;
+        } else if (!parent->d_func()->scene && d_ptr->scene) {
+            // Remove this item from its former scene
+            d_ptr->scene->removeItem(this);
+        }
+        d_ptr->parent->d_func()->children << this;
+        d_ptr->parent->itemChange(ItemChildAddedChange, thisPointerVariant);
+        if (!implicitUpdate)
+            d_ptr->updateHelper(QRectF(), false, true);
+        // Inherit ancestor flags from the new parent.
+        d_ptr->updateAncestorFlag(QGraphicsItem::GraphicsItemFlag(-1));
+        d_ptr->updateAncestorFlag(ItemClipsChildrenToShape);
+        d_ptr->updateAncestorFlag(ItemIgnoresTransformations);
+        // Update item visible / enabled.
+        if (d_ptr->parent->isVisible() != d_ptr->visible) {
+            if (!d_ptr->parent->isVisible() || !d_ptr->explicitlyHidden)
+                d_ptr->setVisibleHelper(d_ptr->parent->isVisible(), /* explicit = */ false, /* update = */ !implicitUpdate);
+        }
+        if (d_ptr->parent->isEnabled() != d_ptr->enabled) {
+            if (!d_ptr->parent->isEnabled() || !d_ptr->explicitlyDisabled)
+                d_ptr->setEnabledHelper(d_ptr->parent->isEnabled(), /* explicit = */ false, /* update = */ !implicitUpdate);
+        }
+    } else {
+        // Inherit ancestor flags from the new parent.
+        d_ptr->updateAncestorFlag(QGraphicsItem::GraphicsItemFlag(-1));
+        d_ptr->updateAncestorFlag(ItemClipsChildrenToShape);
+        d_ptr->updateAncestorFlag(ItemIgnoresTransformations);
+        // Update item visible / enabled.
+        if (!d_ptr->visible && !d_ptr->explicitlyHidden)
+            d_ptr->setVisibleHelper(true, /* explicit = */ false);
+        if (!d_ptr->enabled && !d_ptr->explicitlyDisabled)
+            d_ptr->setEnabledHelper(true, /* explicit = */ false);
+        d_ptr->updateHelper(QRectF(), false, true);
+    }
+    if (d_ptr->scene) {
+        // Invalidate any sort caching; arrival of a new item means we need to
+        // resort.
+        d_ptr->scene->d_func()->invalidateSortCache();
+    }
+    // Resolve opacity.
+    d_ptr->updateEffectiveOpacity();
+    // Resolve depth.
+    d_ptr->resolveDepth(parent ? parent->d_ptr->depth : -1);
+    // Invalidate transform cache.
+    d_ptr->invalidateSceneTransformCache();
+    // Deliver post-change notification
+    itemChange(QGraphicsItem::ItemParentHasChanged, newParentVariant);
+    d_ptr->setParentItemHelper(parent);
+}
 …
     \since 4.4
+    Returns a list of this item's children. The items are returned in no
+    particular order.
+    \sa setParentItem()
+    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.
+    \sa setParentItem(), zValue(), {QGraphicsItem#Sorting}{Sorting}
 */
 QList<QGraphicsItem *> QGraphicsItem::childItems() const
+{
+    const_cast<QGraphicsItem *>(this)->d_ptr->ensureSortedChildren();
     return d_ptr->children;
+}
 …
+{
     return isWidget() && (static_cast<const QGraphicsWidget *>(this)->windowType() & Qt::Window);
+}
+/*!
+    \since 4.6
+    Returns true if the item is a panel; otherwise returns false.
+    \sa QGraphicsItem::panel(), ItemIsPanel
+*/
+bool QGraphicsItem::isPanel() const
+{
+    return d_ptr->flags & ItemIsPanel;
+}
 …
     item is automatically unselected.
+    By default, no flags are enabled.
+    By default, no flags are enabled. (QGraphicsWidget enables the
+    ItemSendsGeometryChanges flag by default in order to track position
+    changes.)
     \sa flags(), setFlag()
 …
 void QGraphicsItem::setFlags(GraphicsItemFlags flags)
+{
+    if (isWindow())
+        flags |= ItemIsPanel;
     // Notify change and check for adjustment.
     if (quint32(d_ptr->flags) == quint32(flags))
 …
     if (quint32(d_ptr->flags) == quint32(flags))
         return;
+    if (d_ptr->scene)
+        d_ptr->scene->d_func()->index->itemChange(this, ItemFlagsChange, quint32(flags));
     // Flags that alter the geometry of the item (or its children).
     int geomChangeFlagsMask = (ItemClipsChildrenToShape | ItemClipsToShape | ItemIgnoresTransformations);
     bool fullUpdate = (flags & geomChangeFlagsMask) != (d_ptr->flags & geomChangeFlagsMask);
+    const quint32 geomChangeFlagsMask = (ItemClipsChildrenToShape | ItemClipsToShape | ItemIgnoresTransformations | ItemIsSelectable);
+    bool fullUpdate = (quint32(flags) & geomChangeFlagsMask) != (d_ptr->flags & geomChangeFlagsMask);
     if (fullUpdate)
         d_ptr->fullUpdateHelper(false, true);
+        d_ptr->paintedViewBoundingRectsNeedRepaint = 1;
     // Keep the old flags to compare the diff.
 …
     // Update flags.
     d_ptr->flags = flags;
-    // Reresolve effective opacity if the opacity flags change.
-    static const quint32 opacityFlagsMask = ItemIgnoresParentOpacity | ItemDoesntPropagateOpacityToChildren;
-    if ((flags & opacityFlagsMask) != (oldFlags & opacityFlagsMask))
-        d_ptr->updateEffectiveOpacity();
     if (!(d_ptr->flags & ItemIsFocusable) && hasFocus()) {
 …
+    }
-    if ((flags & ItemClipsToShape) != (oldFlags & ItemClipsToShape))
-        d_ptr->invalidateCachedClipPath();
     if ((flags & ItemIgnoresTransformations) != (oldFlags & ItemIgnoresTransformations)) {
         // Item children clipping changes. Propagate the ancestor flag to
 …
+    }
+    // ### Why updateHelper?
+    d_ptr->updateHelper(QRectF(), false, true);
+    if ((flags & ItemStacksBehindParent) != (oldFlags & ItemStacksBehindParent)) {
+        // Ensure child item sorting is up to date when toggling this flag.
+        if (d_ptr->parent)
+            d_ptr->parent->d_ptr->needSortChildren = 1;
+        else if (d_ptr->scene)
+            d_ptr->scene->d_func()->needSortTopLevelItems = 1;
+    }
+    if ((flags & ItemAcceptsInputMethod) != (oldFlags & ItemAcceptsInputMethod)) {
+        // Update input method sensitivity in any views.
+        if (d_ptr->scene)
+            d_ptr->scene->d_func()->updateInputMethodSensitivityInViews();
+    }
+    if ((flags & ItemNegativeZStacksBehindParent) != (oldFlags & ItemNegativeZStacksBehindParent)) {
+        // Update stack-behind.
+        setFlag(ItemStacksBehindParent, d_ptr->z < qreal(0.0));
+    }
+    if ((d_ptr->panelModality != NonModal)
+        && d_ptr->scene
+        && (flags & ItemIsPanel) != (oldFlags & ItemIsPanel)) {
+        // update the panel's modal state
+        if (flags & ItemIsPanel)
+            d_ptr->scene->d_func()->enterModal(this);
+        else
+            d_ptr->scene->d_func()->leaveModal(this);
+    }
+    if (d_ptr->scene) {
+        if ((flags & ItemSendsScenePositionChanges) != (oldFlags & ItemSendsScenePositionChanges)) {
+            if (flags & ItemSendsScenePositionChanges)
+                d_ptr->scene->d_func()->registerScenePosItem(this);
+            else
+                d_ptr->scene->d_func()->unregisterScenePosItem(this);
+        }
+        d_ptr->scene->d_func()->markDirty(this, QRectF(), /*invalidateChildren=*/true);
+    }
     // Notify change.
 …
         if (mode == ItemCoordinateCache) {
-            if (cache->key.isEmpty()) {
-                // Generate new simple pixmap cache key.
-                QString tmp;
-                tmp.sprintf("qgv-%p", this);
-                cache->key = tmp;
+            }
             if (lastMode == mode && cache->fixedSize == logicalCacheSize)
                 noVisualChange = true;
 …
+}
+/*!
+    \since 4.6
+    Returns the modality for this item.
+*/
+QGraphicsItem::PanelModality QGraphicsItem::panelModality() const
+{
+    return d_ptr->panelModality;
+}
+/*!
+    \since 4.6
+    Sets the modality for this item to \a panelModality.
+    Changing the modality of a visible item takes effect immediately.
+*/
+void QGraphicsItem::setPanelModality(PanelModality panelModality)
+{
+    if (d_ptr->panelModality == panelModality)
+        return;
+    PanelModality previousModality = d_ptr->panelModality;
+    bool enterLeaveModal = (isPanel() && d_ptr->scene && isVisible());
+    if (enterLeaveModal && panelModality == NonModal)
+        d_ptr->scene->d_func()->leaveModal(this);
+    d_ptr->panelModality = panelModality;
+    if (enterLeaveModal && d_ptr->panelModality != NonModal)
+        d_ptr->scene->d_func()->enterModal(this, previousModality);
+}
+/*!
+    \since 4.6
+    Returns true if this item is blocked by a modal panel, false otherwise. If \a blockingPanel is
+    non-zero, \a blockingPanel will be set to the modal panel that is blocking this item. If this
+    item is not blocked, \a blockingPanel will not be set by this function.
+    This function always returns false for items not in a scene.
+    \sa panelModality() setPanelModality() PanelModality
+*/
+bool QGraphicsItem::isBlockedByModalPanel(QGraphicsItem **blockingPanel) const
+{
+    if (!d_ptr->scene)
+        return false;
+    QGraphicsItem *dummy = 0;
+    if (!blockingPanel)
+        blockingPanel = &dummy;
+    QGraphicsScenePrivate *scene_d = d_ptr->scene->d_func();
+    if (scene_d->modalPanels.isEmpty())
+        return false;
+    // ###
+    if (!scene_d->popupWidgets.isEmpty() && scene_d->popupWidgets.first() == this)
+        return false;
+    for (int i = 0; i < scene_d->modalPanels.count(); ++i) {
+        QGraphicsItem *modalPanel = scene_d->modalPanels.at(i);
+        if (modalPanel->panelModality() == QGraphicsItem::SceneModal) {
+            // Scene modal panels block all non-descendents.
+            if (modalPanel != this && !modalPanel->isAncestorOf(this)) {
+                *blockingPanel = modalPanel;
+                return true;
+            }
+        } else {
+            // Window modal panels block ancestors and siblings/cousins.
+            if (modalPanel != this
+                && !modalPanel->isAncestorOf(this)
+                && commonAncestorItem(modalPanel)) {
+                *blockingPanel = modalPanel;
+                return true;
+            }
+        }
+    }
+    return false;
+}
 #ifndef QT_NO_TOOLTIP
 /*!
 …
     d_ptr->hasCursor = 1;
     if (d_ptr->scene) {
+        d_ptr->scene->d_func()->allItemsUseDefaultCursor = false;
         foreach (QGraphicsView *view, d_ptr->scene->views()) {
+            view->viewport()->setMouseTracking(true);
             // Note: Some of this logic is duplicated in QGraphicsView's mouse events.
             if (view->underMouse()) {
 …
         return;
+    // Don't show child if parent is not visible
+    if (parent && newVisible && !parent->d_ptr->visible)
+        return;
     // Modify the property.
     const QVariant newVisibleVariant(q_ptr->itemChange(QGraphicsItem::ItemVisibleChange,
 …
         if (c)
             c->purge();
+        updateHelper(QRectF(), /* force = */ true);
+        if (scene)
+            scene->d_func()->markDirty(q_ptr, QRectF(), /*invalidateChildren=*/false, /*force=*/true);
+    }
 …
             if (scene->d_func()->keyboardGrabberItems.contains(q))
                 q->ungrabKeyboard();
+            if (q->isPanel() && panelModality != QGraphicsItem::NonModal)
+                scene->d_func()->leaveModal(q_ptr);
+        }
         if (q_ptr->hasFocus() && scene) {
             // Hiding the closest non-window ancestor of the focus item
+            // Hiding the closest non-panel ancestor of the focus item
             QGraphicsItem *focusItem = scene->focusItem();
             bool clear = true;
             if (isWidget && !focusItem->isWindow()) {
+            if (isWidget && !focusItem->isPanel()) {
                 do {
                     if (focusItem == q_ptr) {
 …
                         break;
+                    }
                 } while ((focusItem = focusItem->parentWidget()) && !focusItem->isWindow());
+                } while ((focusItem = focusItem->parentWidget()) && !focusItem->isPanel());
+            }
             if (clear)
 …
             q_ptr->setSelected(false);
     } else {
+        if (isWidget && scene) {
+            QGraphicsWidget *widget = static_cast<QGraphicsWidget *>(q_ptr);
+            if (widget->windowType() == Qt::Popup)
+                scene->d_func()->addPopup(widget);
+        geometryChanged = 1;
+        paintedViewBoundingRectsNeedRepaint = 1;
+        if (scene) {
+            if (isWidget) {
+                QGraphicsWidget *widget = static_cast<QGraphicsWidget *>(q_ptr);
+                if (widget->windowType() == Qt::Popup)
+                    scene->d_func()->addPopup(widget);
+            }
+            if (q->isPanel() && panelModality != QGraphicsItem::NonModal) {
+                scene->d_func()->enterModal(q_ptr);
+            }
+        }
+    }
 …
+    }
+    // Update activation
+    if (scene && q->isPanel()) {
+        if (newVisible) {
+            if (parent && parent->isActive())
+                q->setActive(true);
+        } else {
+            if (q->isActive())
+                scene->setActivePanel(parent);
+        }
+    }
     // Enable subfocus
+    if (newVisible && isWidget) {
+        QGraphicsWidget *widget = static_cast<QGraphicsWidget *>(q_ptr);
+        QGraphicsWidget *fw = widget->focusWidget();
+        if (fw && fw != scene->focusItem())
+            scene->setFocusItem(fw);
+    if (scene && newVisible) {
+        QGraphicsItem *p = parent;
+        bool done = false;
+        while (p) {
+            if (p->flags() & QGraphicsItem::ItemIsFocusScope) {
+                QGraphicsItem *fsi = p->d_ptr->focusScopeItem;
+                if (q_ptr == fsi || q_ptr->isAncestorOf(fsi)) {
+                    done = true;
+                    while (fsi->d_ptr->focusScopeItem && fsi->d_ptr->focusScopeItem->isVisible())
+                        fsi = fsi->d_ptr->focusScopeItem;
+                    scene->setFocusItem(fsi);
+                }
+                break;
+            }
+            p = p->d_ptr->parent;
+        }
+        if (!done) {
+            QGraphicsItem *fi = subFocusItem;
+            if (fi && fi != scene->focusItem()) {
+                scene->setFocusItem(fi);
+            }
+        }
+    }
     // Deliver post-change notification.
     q_ptr->itemChange(QGraphicsItem::ItemVisibleHasChanged, newVisibleVariant);
+    if (isObject)
+        emit static_cast<QGraphicsObject *>(q_ptr)->visibleChanged();
+}
 …
             q_ptr->ungrabMouse();
         if (q_ptr->hasFocus()) {
             // Disabling the closest non-window ancestor of the focus item
+            // Disabling the closest non-panel ancestor of the focus item
             // causes focus to pop to the next item, otherwise it's cleared.
             QGraphicsItem *focusItem = scene->focusItem();
             bool clear = true;
             if (isWidget && !focusItem->isWindow() && q_ptr->isAncestorOf(focusItem)) {
+            if (isWidget && !focusItem->isPanel() && q_ptr->isAncestorOf(focusItem)) {
                 do {
                     if (focusItem == q_ptr) {
 …
                         break;
+                    }
                 } while ((focusItem = focusItem->parentWidget()) && !focusItem->isWindow());
+                } while ((focusItem = focusItem->parentWidget()) && !focusItem->isPanel());
+            }
             if (clear)
 …
     // Schedule redraw.
     if (update)
         updateHelper();
+        q_ptr->update();
     foreach (QGraphicsItem *child, children) {
 …
     // Deliver post-change notification.
     q_ptr->itemChange(QGraphicsItem::ItemEnabledHasChanged, newEnabledVariant);
+    if (isObject)
+        emit static_cast<QGraphicsObject *>(q_ptr)->enabledChanged();
+}
 …
     d_ptr->selected = newSelected;
+    d_ptr->updateHelper();
+    update();
     if (d_ptr->scene) {
         QGraphicsScenePrivate *sceneD = d_ptr->scene->d_func();
 …
 qreal QGraphicsItem::opacity() const
+{
+    if (d_ptr->hasOpacity) {
+        QVariant o = d_ptr->extra(QGraphicsItemPrivate::ExtraOpacity);
+        if (!o.isNull())
+            return o.toDouble();
+    }
+    return qreal(1.0);
+    return d_ptr->opacity;
+}
 …
 qreal QGraphicsItem::effectiveOpacity() const
+{
+    if (!d_ptr->hasEffectiveOpacity)
+        return qreal(1.0);
+    QVariant effectiveOpacity = d_ptr->extra(QGraphicsItemPrivate::ExtraEffectiveOpacity);
+    return effectiveOpacity.isNull() ? qreal(1.0) : qreal(effectiveOpacity.toDouble());
+    return d_ptr->effectiveOpacity();
+}
 …
+{
     // Notify change.
+    const QVariant newOpacityVariant(itemChange(ItemOpacityChange, double(opacity)));
+    qreal newOpacity = newOpacityVariant.toDouble();
+    // Normalize.
+    newOpacity = qBound<qreal>(0.0, newOpacity, 1.0);
+    const QVariant newOpacityVariant(itemChange(ItemOpacityChange, opacity));
+    // Normalized opacity
+    qreal newOpacity = qBound(qreal(0), newOpacityVariant.toReal(), qreal(1));
     // No change? Done.
     if (qFuzzyCompare(newOpacity, this->opacity()))
+    if (newOpacity == d_ptr->opacity)
         return;
+    // Assign local opacity.
+    if (qFuzzyCompare(newOpacity, qreal(1.0))) {
+        // Opaque, unset opacity.
+        d_ptr->hasOpacity = 0;
+        d_ptr->unsetExtra(QGraphicsItemPrivate::ExtraOpacity);
+    } else {
+        d_ptr->hasOpacity = 1;
+        d_ptr->setExtra(QGraphicsItemPrivate::ExtraOpacity, double(newOpacity));
+    }
+    // Resolve effective opacity.
+    if (QGraphicsItem *p = d_ptr->parent)
+        d_ptr->resolveEffectiveOpacity(p->effectiveOpacity());
+    else
+        d_ptr->resolveEffectiveOpacity(1.0);
+    d_ptr->opacity = newOpacity;
     // Notify change.
     itemChange(ItemOpacityHasChanged, newOpacity);
+    itemChange(ItemOpacityHasChanged, newOpacityVariant);
     // Update.
+    d_ptr->fullUpdateHelper();
+    if (d_ptr->scene) {
+#ifndef QT_NO_GRAPHICSEFFECT
+        d_ptr->invalidateGraphicsEffectsRecursively();
+#endif //QT_NO_GRAPHICSEFFECT
+        d_ptr->scene->d_func()->markDirty(this, QRectF(),
+                                          /*invalidateChildren=*/true,
+                                          /*force=*/false,
+                                          /*ignoreOpacity=*/true);
+    }
+    if (d_ptr->isObject)
+        emit static_cast<QGraphicsObject *>(this)->opacityChanged();
+}
+/*!
+    Returns a pointer to this item's effect if it has one; otherwise 0.
+    \since 4.6
+*/
+#ifndef QT_NO_GRAPHICSEFFECT
+QGraphicsEffect *QGraphicsItem::graphicsEffect() const
+{
+    return d_ptr->graphicsEffect;
+}
+/*!
+    Sets \a effect as the item's effect. If there already is an effect installed
+    on this item, QGraphicsItem will delete the existing effect before installing
+    the new \a effect.
+    If \a effect is the installed on a different item, setGraphicsEffect() will remove
+    the effect from the item and install it on this item.
+    QGraphicsItem takes ownership of \a effect.
+    \note This function will apply the effect on itself and all its children.
+    \since 4.6
+*/
+void QGraphicsItem::setGraphicsEffect(QGraphicsEffect *effect)
+{
+    if (d_ptr->graphicsEffect == effect)
+        return;
+    if (d_ptr->graphicsEffect) {
+        delete d_ptr->graphicsEffect;
+        d_ptr->graphicsEffect = 0;
+    }
+    if (effect) {
+        // Set new effect.
+        QGraphicsEffectSourcePrivate *sourced = new QGraphicsItemEffectSourcePrivate(this);
+        QGraphicsEffectSource *source = new QGraphicsEffectSource(*sourced);
+        d_ptr->graphicsEffect = effect;
+        effect->d_func()->setGraphicsEffectSource(source);
+        prepareGeometryChange();
+    }
+}
+#endif //QT_NO_GRAPHICSEFFECT
+/*!
+    \internal
+    \since 4.6
+    Returns the effective bounding rect of the given item space rect.
+    If the item has no effect, the rect is returned unmodified.
+    If the item has an effect, the effective rect can be extend beyond the
+    item's bounding rect, depending on the effect.
+    \sa boundingRect()
+*/
+QRectF QGraphicsItemPrivate::effectiveBoundingRect(const QRectF &rect) const
+{
+#ifndef QT_NO_GRAPHICSEFFECT
+    Q_Q(const QGraphicsItem);
+    QGraphicsEffect *effect = graphicsEffect;
+    if (scene && effect && effect->isEnabled()) {
+        QRectF sceneRect = q->mapRectToScene(rect);
+        QRectF sceneEffectRect;
+        foreach (QGraphicsView *view, scene->views()) {
+            QRectF deviceRect = view->d_func()->mapRectFromScene(sceneRect);
+            QRect deviceEffectRect = effect->boundingRectFor(deviceRect).toAlignedRect();
+            sceneEffectRect |= view->d_func()->mapRectToScene(deviceEffectRect);
+        }
+        return q->mapRectFromScene(sceneEffectRect);
+    }
+#endif //QT_NO_GRAPHICSEFFECT
+    return rect;
+}
+/*!
+    \internal
+    \since 4.6
+    Returns the effective bounding rect of the item.
+    If the item has no effect, this is the same as the item's bounding rect.
+    If the item has an effect, the effective rect can be larger than the item's
+    bouding rect, depending on the effect.
+    \sa boundingRect()
+*/
+QRectF QGraphicsItemPrivate::effectiveBoundingRect() const
+{
+#ifndef QT_NO_GRAPHICSEFFECT
+    Q_Q(const QGraphicsItem);
+    QRectF brect = effectiveBoundingRect(q_ptr->boundingRect());
+    if (ancestorFlags & QGraphicsItemPrivate::AncestorClipsChildren)
+        return brect;
+    const QGraphicsItem *effectParent = parent;
+    while (effectParent) {
+        QGraphicsEffect *effect = effectParent->d_ptr->graphicsEffect;
+        if (scene && effect && effect->isEnabled()) {
+            const QRectF brectInParentSpace = q->mapRectToItem(effectParent, brect);
+            const QRectF effectRectInParentSpace = effectParent->d_ptr->effectiveBoundingRect(brectInParentSpace);
+            brect = effectParent->mapRectToItem(q, effectRectInParentSpace);
+        }
+        if (effectParent->d_ptr->ancestorFlags & QGraphicsItemPrivate::AncestorClipsChildren)
+            return brect;
+        effectParent = effectParent->d_ptr->parent;
+    }
+    return brect;
+#else //QT_NO_GRAPHICSEFFECT
+    return q_ptr->boundingRect();
+#endif //QT_NO_GRAPHICSEFFECT
+}
+/*!
+    \internal
+    \since 4.6
+    Returns the effective bounding rect of this item in scene coordinates,
+    by combining sceneTransform() with boundingRect(), taking into account
+    the effect that the item might have.
+    If the item has no effect, this is the same as sceneBoundingRect().
+    \sa effectiveBoundingRect(), sceneBoundingRect()
+*/
+QRectF QGraphicsItemPrivate::sceneEffectiveBoundingRect() const
+{
+    // Find translate-only offset
+    // COMBINE
+    QPointF offset;
+    const QGraphicsItem *parentItem = q_ptr;
+    const QGraphicsItemPrivate *itemd;
+    do {
+        itemd = parentItem->d_ptr.data();
+        if (itemd->transformData)
+            break;
+        offset += itemd->pos;
+    } while ((parentItem = itemd->parent));
+    QRectF br = effectiveBoundingRect();
+    br.translate(offset);
+    return !parentItem ? br : parentItem->sceneTransform().mapRect(br);
+}
 …
     children's areas.
     If a parent item handles child events (setHandlesChildEvents()), it will
     receive hover move, drag move, and drop events as the cursor passes
     through its children, but it does not receive hover enter and hover leave,
     nor drag enter and drag leave events on behalf of its children.
+    If a parent item handles child events, it will receive hover move,
+    drag move, and drop events as the cursor passes through its
+    children, but it does not receive hover enter and hover leave, nor
+    drag enter and drag leave events on behalf of its children.
     A QGraphicsWidget with window decorations will accept hover events
 …
 void QGraphicsItem::setAcceptHoverEvents(bool enabled)
+{
+    if (d_ptr->acceptsHover == quint32(enabled))
+        return;
     d_ptr->acceptsHover = quint32(enabled);
+    if (d_ptr->acceptsHover && d_ptr->scene && d_ptr->scene->d_func()->allItemsIgnoreHoverEvents) {
+        d_ptr->scene->d_func()->allItemsIgnoreHoverEvents = false;
+        d_ptr->scene->d_func()->enableMouseTrackingOnViews();
+    }
+}
 …
 void QGraphicsItem::setAcceptsHoverEvents(bool enabled)
+{
+    d_ptr->acceptsHover = quint32(enabled);
+}
+/*!
+    setAcceptHoverEvents(enabled);
+}
+/*! \since 4.6
+    Returns true if an item accepts \l{QTouchEvent}{touch events};
+    otherwise, returns false. By default, items do not accept touch events.
+    \sa setAcceptTouchEvents()
+*/
+bool QGraphicsItem::acceptTouchEvents() const
+{
+    return d_ptr->acceptTouchEvents;
+}
+/*!
+    \since 4.6
+    If \a enabled is true, this item will accept \l{QTouchEvent}{touch events};
+    otherwise, it will ignore them. By default, items do not accept
+    touch events.
+*/
+void QGraphicsItem::setAcceptTouchEvents(bool enabled)
+{
+    if (d_ptr->acceptTouchEvents == quint32(enabled))
+        return;
+    d_ptr->acceptTouchEvents = quint32(enabled);
+    if (d_ptr->acceptTouchEvents && d_ptr->scene && d_ptr->scene->d_func()->allItemsIgnoreTouchEvents) {
+        d_ptr->scene->d_func()->allItemsIgnoreTouchEvents = false;
+        d_ptr->scene->d_func()->enableTouchEventsOnViews();
+    }
+}
+/*!
+    \since 4.6
+    Returns true if this item filters child events (i.e., all events
+    intended for any of its children are instead sent to this item);
+    otherwise, false is returned.
+    The default value is false; child events are not filtered.
+    \sa setFiltersChildEvents()
+*/
+bool QGraphicsItem::filtersChildEvents() const
+{
+    return d_ptr->filtersDescendantEvents;
+}
+/*!
+    \since 4.6
+    If \a enabled is true, this item is set to filter all events for
+    all its children (i.e., all events intented for any of its
+    children are instead sent to this item); otherwise, if \a enabled
+    is false, this item will only handle its own events. The default
+    value is false.
+    \sa filtersChildEvents()
+*/
+void QGraphicsItem::setFiltersChildEvents(bool enabled)
+{
+    if (d_ptr->filtersDescendantEvents == enabled)
+        return;
+    d_ptr->filtersDescendantEvents = enabled;
+    d_ptr->updateAncestorFlag(QGraphicsItem::GraphicsItemFlag(-2));
+}
+/*!
+    \obsolete
     Returns true if this item handles child events (i.e., all events
     intended for any of its children are instead sent to this item);
 …
 /*!
+    \obsolete
     If \a enabled is true, this item is set to handle all events for
     all its children (i.e., all events intented for any of its
 …
     d_ptr->updateAncestorFlag(QGraphicsItem::GraphicsItemFlag(-1));
+}
+/*!
+    Returns true if this item has keyboard input focus; otherwise, returns
+    false.
+    \sa QGraphicsScene::focusItem(), setFocus(), QGraphicsScene::setFocusItem()
+/*!
+    \since 4.6
+    Returns true if this item is active; otherwise returns false.
+    An item can only be active if the scene is active. An item is active
+    if it is, or is a descendent of, an active panel. Items in non-active
+    panels are not active.
+    Items that are not part of a panel follow scene activation when the
+    scene has no active panel.
+    Only active items can gain input focus.
+    \sa QGraphicsScene::isActive(), QGraphicsScene::activePanel(), panel(), isPanel()
+*/
+bool QGraphicsItem::isActive() const
+{
+    if (!d_ptr->scene || !d_ptr->scene->isActive())
+        return false;
+    return panel() == d_ptr->scene->activePanel();
+}
+/*!
+    \since 4.6
+    If \a active is true, and the scene is active, this item's panel will be
+    activated. Otherwise, the panel is deactivated.
+    If the item is not part of an active scene, \a active will decide what
+    happens to the panel when the scene becomes active or the item is added to
+    the scene. If true, the item's panel will be activated when the item is
+    either added to the scene or the scene is activated. Otherwise, the item
+    will stay inactive independent of the scene's activated state.
+    \sa isPanel(), QGraphicsScene::setActivePanel(), QGraphicsScene::isActive()
+*/
+void QGraphicsItem::setActive(bool active)
+{
+    d_ptr->explicitActivate = 1;
+    d_ptr->wantsActive = active;
+    if (d_ptr->scene) {
+        if (active) {
+            // Activate this item.
+            d_ptr->scene->setActivePanel(this);
+        } else {
+            // Deactivate this item, and reactivate the last active item
+            // (if any).
+            QGraphicsItem *lastActive = d_ptr->scene->d_func()->lastActivePanel;
+            d_ptr->scene->setActivePanel(lastActive != this ? lastActive : 0);
+        }
+    }
+}
+/*!
+    Returns true if this item is active, and it or its \l{focusProxy()}{focus
+    proxy} has keyboard input focus; otherwise, returns false.
+    \sa focusItem(), setFocus(), QGraphicsScene::setFocusItem(), isActive()
 */
 bool QGraphicsItem::hasFocus() const
+{
+    return (d_ptr->scene && d_ptr->scene->focusItem() == this);
+    if (d_ptr->focusProxy)
+        return d_ptr->focusProxy->hasFocus();
+    return isActive() && (d_ptr->scene && d_ptr->scene->focusItem() == this);
+}
 /*!
     Gives keyboard input focus to this item. The \a focusReason argument will
+    be passed into any focus event generated by this function; it is used to
+    give an explanation of what caused the item to get focus.
+    Only items that set the ItemIsFocusable flag can accept keyboard focus.
+    If this item is not visible (i.e., isVisible() returns false), not
+    enabled, not associated with a scene, or if it already has input focus,
+    this function will do nothing.
+    As a result of calling this function, this item will receive a focus in
+    event with \a focusReason. If another item already has focus, that item
+    will first receive a focus out event indicating that it has lost input
+    be passed into any \l{QFocusEvent}{focus event} generated by this function;
+    it is used to give an explanation of what caused the item to get focus.
+    Only enabled items that set the ItemIsFocusable flag can accept keyboard
     focus.
+    \sa clearFocus(), hasFocus()
+    If this item is not visible, not active, or not associated with a scene,
+    it will not gain immediate input focus. However, it will be registered as
+    the preferred focus item for its subtree of items, should it later become
+    visible.
+    As a result of calling this function, this item will receive a
+    \l{focusInEvent()}{focus in event} with \a focusReason. If another item
+    already has focus, that item will first receive a \l{focusOutEvent()}
+    {focus out event} indicating that it has lost input focus.
+    \sa clearFocus(), hasFocus(), focusItem(), focusProxy()
 */
 void QGraphicsItem::setFocus(Qt::FocusReason focusReason)
+{
+    if (!d_ptr->scene || !isEnabled() || hasFocus() || !(d_ptr->flags & ItemIsFocusable))
+    d_ptr->setFocusHelper(focusReason, /* climb = */ true);
+}
+/*!
+    \internal
+*/
+void QGraphicsItemPrivate::setFocusHelper(Qt::FocusReason focusReason, bool climb)
+{
+    // Disabled / unfocusable items cannot accept focus.
+    if (!q_ptr->isEnabled() || !(flags & QGraphicsItem::ItemIsFocusable))
         return;
+    if (isVisible()) {
+        // Visible items immediately gain focus from scene.
+        d_ptr->scene->setFocusItem(this, focusReason);
+    } else if (d_ptr->isWidget) {
+        // Just set up subfocus.
+        static_cast<QGraphicsWidget *>(this)->d_func()->setFocusWidget();
+    // Find focus proxy.
+    QGraphicsItem *f = q_ptr;
+    while (f->d_ptr->focusProxy)
+        f = f->d_ptr->focusProxy;
+    // Return if it already has focus.
+    if (scene && scene->focusItem() == f)
+        return;
+    // Update focus scope item ptr.
+    QGraphicsItem *p = parent;
+    while (p) {
+        if (p->flags() & QGraphicsItem::ItemIsFocusScope) {
+            p->d_ptr->focusScopeItem = q_ptr;
+            if (!p->focusItem()) {
+                // If you call setFocus on a child of a focus scope that
+                // doesn't currently have a focus item, then stop.
+                return;
+            }
+            break;
+        }
+        p = p->d_ptr->parent;
+    }
+    if (climb) {
+        while (f->d_ptr->focusScopeItem && f->d_ptr->focusScopeItem->isVisible())
+            f = f->d_ptr->focusScopeItem;
+    }
+    // Update the child focus chain.
+    f->d_ptr->setSubFocus();
+    // Update the scene's focus item.
+    if (scene) {
+        QGraphicsItem *p = q_ptr->panel();
+        if ((!p && scene->isActive()) || (p && p->isActive())) {
+            // Visible items immediately gain focus from scene.
+            scene->d_func()->setFocusItemHelper(f, focusReason);
+        }
+    }
+}
 …
     Takes keyboard input focus from the item.
     If it has focus, a focus out event is sent to this item to tell it that it
     is about to lose the focus.
+    If it has focus, a \l{focusOutEvent()}{focus out event} is sent to this
+    item to tell it that it is about to lose the focus.
     Only items that set the ItemIsFocusable flag, or widgets that set an
     appropriate focus policy, can accept keyboard focus.
     \sa setFocus(), QGraphicsWidget::focusPolicy
+    \sa setFocus(), hasFocus(), QGraphicsWidget::focusPolicy
 */
 void QGraphicsItem::clearFocus()
+{
+    if (!d_ptr->scene)
+        return;
+    if (d_ptr->isWidget) {
+        // Invisible widget items with focus must explicitly clear subfocus.
+        static_cast<QGraphicsWidget *>(this)->d_func()->clearFocusWidget();
+    }
+    if (d_ptr->scene->focusItem() == this) {
+    // Pass focus to the closest parent focus scope.
+    if (!d_ptr->inDestructor) {
+        QGraphicsItem *p = d_ptr->parent;
+        while (p) {
+            if (p->flags() & ItemIsFocusScope) {
+                p->d_ptr->setFocusHelper(Qt::OtherFocusReason, /* climb = */ false);
+                return;
+            }
+            p = p->d_ptr->parent;
+        }
+    }
+    // Invisible items with focus must explicitly clear subfocus.
+    d_ptr->clearSubFocus(this);
+    if (hasFocus()) {
         // If this item has the scene's input focus, clear it.
         d_ptr->scene->setFocusItem(0);
+    }
+}
+/*!
+    \since 4.6
+    Returns this item's focus proxy, or 0 if this item has no
+    focus proxy.
+    \sa setFocusProxy(), setFocus(), hasFocus()
+*/
+QGraphicsItem *QGraphicsItem::focusProxy() const
+{
+    return d_ptr->focusProxy;
+}
+/*!
+    \since 4.6
+    Sets the item's focus proxy to \a item.
+    If an item has a focus proxy, the focus proxy will receive
+    input focus when the item gains input focus. The item itself
+    will still have focus (i.e., hasFocus() will return true),
+    but only the focus proxy will receive the keyboard input.
+    A focus proxy can itself have a focus proxy, and so on. In
+    such case, keyboard input will be handled by the outermost
+    focus proxy.
+    The focus proxy \a item must belong to the same scene as
+    this item.
+    \sa focusProxy(), setFocus(), hasFocus()
+*/
+void QGraphicsItem::setFocusProxy(QGraphicsItem *item)
+{
+    if (item == d_ptr->focusProxy)
+        return;
+    if (item == this) {
+        qWarning("QGraphicsItem::setFocusProxy: cannot assign self as focus proxy");
+        return;
+    }
+    if (item) {
+        if (item->d_ptr->scene != d_ptr->scene) {
+            qWarning("QGraphicsItem::setFocusProxy: focus proxy must be in same scene");
+            return;
+        }
+        for (QGraphicsItem *f = item->focusProxy(); f != 0; f = f->focusProxy()) {
+            if (f == this) {
+                qWarning("QGraphicsItem::setFocusProxy: %p is already in the focus proxy chain", item);
+                return;
+            }
+        }
+    }
+    QGraphicsItem *lastFocusProxy = d_ptr->focusProxy;
+    if (lastFocusProxy)
+        lastFocusProxy->d_ptr->focusProxyRefs.removeOne(&d_ptr->focusProxy);
+    d_ptr->focusProxy = item;
+    if (item)
+        item->d_ptr->focusProxyRefs << &d_ptr->focusProxy;
+}
+/*!
+    \since 4.6
+    If this item, a child or descendant of this item currently has input
+    focus, this function will return a pointer to that item. If
+    no descendant has input focus, 0 is returned.
+    \sa hasFocus(), setFocus(), QWidget::focusWidget()
+*/
+QGraphicsItem *QGraphicsItem::focusItem() const
+{
+    return d_ptr->subFocusItem;
+}
+/*!
+    \internal
+    Returns this item's focus scope item.
+*/
+QGraphicsItem *QGraphicsItem::focusScopeItem() const
+{
+    return d_ptr->focusScopeItem;
+}
 …
     item's position in scene coordinates, regardless of its parent.
     \sa x(), y(), setPos(), matrix(), {The Graphics View Coordinate System}
+    \sa x(), y(), setPos(), transform(), {The Graphics View Coordinate System}
 */
 QPointF QGraphicsItem::pos() const
 …
 /*!
+    \since 4.6
+    Set's the \a x coordinate of the item's position. Equivalent to
+    calling setPos(x, y()).
+    \sa x(), setPos()
+*/
+void QGraphicsItem::setX(qreal x)
+{
+    if (d_ptr->inDestructor)
+        return;
+    d_ptr->setPosHelper(QPointF(x, d_ptr->pos.y()));
+}
+/*!
     \fn QGraphicsItem::y() const
 …
     \sa x()
 */
+/*!
+    \since 4.6
+    Set's the \a y coordinate of the item's position. Equivalent to
+    calling setPos(x(), y).
+    \sa x(), setPos()
+*/
+void QGraphicsItem::setY(qreal y)
+{
+    if (d_ptr->inDestructor)
+        return;
+    d_ptr->setPosHelper(QPointF(d_ptr->pos.x(), y));
+}
 /*!
 …
     \internal
+    Sets the position \a pos and notifies the change. If \a update is true,
+    the item is also updated; otherwise it is not updated before and after the
+    change.
+    Sets the position \a pos.
 */
 void QGraphicsItemPrivate::setPosHelper(const QPointF &pos)
+{
     Q_Q(QGraphicsItem);
-    if (this->pos == pos)
-        return;
-    // Notify the item that the position is changing.
-    const QVariant newPosVariant(q->itemChange(QGraphicsItem::ItemPositionChange, pos));
-    QPointF newPos = newPosVariant.toPointF();
-    if (newPos == this->pos)
-        return;
-    // Update and repositition.
     inSetPosHelper = 1;
+    updateCachedClipPathFromSetPosHelper(newPos);
+    if (scene) {
+        fullUpdateHelper(true);
+    if (scene)
         q->prepareGeometryChange();
+    }
+    this->pos = newPos;
+    invalidateSceneTransformCache();
+    // Send post-notification.
+    q->itemChange(QGraphicsItem::ItemPositionHasChanged, newPosVariant);
+    QPointF oldPos = this->pos;
+    this->pos = pos;
+    dirtySceneTransform = 1;
     inSetPosHelper = 0;
+    if (isObject) {
+        if (pos.x() != oldPos.x())
+            emit static_cast<QGraphicsObject *>(q_ptr)->xChanged();
+        if (pos.y() != oldPos.y())
+            emit static_cast<QGraphicsObject *>(q_ptr)->yChanged();
+    }
+}
+/*!
+    \internal
+    Sets the transform \a transform.
+*/
+void QGraphicsItemPrivate::setTransformHelper(const QTransform &transform)
+{
+    q_ptr->prepareGeometryChange();
+    transformData->transform = transform;
+    dirtySceneTransform = 1;
+}
 …
 void QGraphicsItem::setPos(const QPointF &pos)
+{
+    d_ptr->setPosHelper(pos);
+    if (d_ptr->pos == pos)
+        return;
+    if (d_ptr->inDestructor)
+        return;
+    // Update and repositition.
+    if (!(d_ptr->flags & ItemSendsGeometryChanges)) {
+        d_ptr->setPosHelper(pos);
+        return;
+    }
+    // Notify the item that the position is changing.
+    const QVariant newPosVariant(itemChange(ItemPositionChange, qVariantFromValue<QPointF>(pos)));
+    QPointF newPos = newPosVariant.toPointF();
+    if (newPos == d_ptr->pos)
+        return;
+    // Update and repositition.
+    d_ptr->setPosHelper(newPos);
+    // Send post-notification.
+    itemChange(QGraphicsItem::ItemPositionHasChanged, newPosVariant);
+    d_ptr->sendScenePosChange();
+}
 …
     \since 4.3
+    Returns this item's transformation matrix. If no matrix has been set, the
+    identity matrix is returned.
+    Returns this item's transformation matrix.
+    The transformation matrix is combined with the item's rotation(), scale()
+    and transformations() into a combined transformations for the item.
+    The default transformation matrix is an identity matrix.
     \sa setTransform(), sceneTransform()
 …
 QTransform QGraphicsItem::transform() const
+{
     if (!d_ptr->hasTransform)
+    if (!d_ptr->transformData)
         return QTransform();
+    return qVariantValue<QTransform>(d_ptr->extra(QGraphicsItemPrivate::ExtraTransform));
+}
+    return d_ptr->transformData->transform;
+}
+/*!
+    \since 4.6
+    Returns the clockwise rotation, in degrees, around the Z axis. The default
+    value is 0 (i.e., the item is not rotated).
+    The rotation is combined with the item's scale(), transform() and
+    transformations() to map the item's coordinate system to the parent item.
+    \sa setRotation(), transformOriginPoint(), {Transformations}
+*/
+qreal QGraphicsItem::rotation() const
+{
+    if (!d_ptr->transformData)
+        return 0;
+    return d_ptr->transformData->rotation;
+}
+/*!
+    \since 4.6
+    Sets the clockwise rotation \a angle, in degrees, around the Z axis. The
+    default value is 0 (i.e., the item is not rotated). Assigning a negative
+    value will rotate the item counter-clockwise. Normally the rotation angle
+    is in the range (-360, 360), but it's also possible to assign values
+    outside of this range (e.g., a rotation of 370 degrees is the same as a
+    rotation of 10 degrees).
+    The item is rotated around its transform origin point, which by default
+    is (0, 0). You can select a different transformation origin by calling
+    setTransformOriginPoint().
+    The rotation is combined with the item's scale(), transform() and
+    transformations() to map the item's coordinate system to the parent item.
+    \sa rotation(), setTransformOriginPoint(), {Transformations}
+*/
+void QGraphicsItem::setRotation(qreal angle)
+{
+    prepareGeometryChange();
+    if (!d_ptr->transformData)
+        d_ptr->transformData = new QGraphicsItemPrivate::TransformData;
+    d_ptr->transformData->rotation = angle;
+    d_ptr->transformData->onlyTransform = false;
+    d_ptr->dirtySceneTransform = 1;
+    if (d_ptr->isObject)
+        emit static_cast<QGraphicsObject *>(this)->rotationChanged();
+}
+/*!
+    \since 4.6
+    Returns the scale factor of the item. The default scale factor is 1.0
+    (i.e., the item is not scaled).
+    The scale is combined with the item's rotation(), transform() and
+    transformations() to map the item's coordinate system to the parent item.
+    \sa setScale(), rotation(), {Transformations}
+*/
+qreal QGraphicsItem::scale() const
+{
+    if (!d_ptr->transformData)
+        return 1.;
+    return d_ptr->transformData->scale;
+}
+/*!
+    \since 4.6
+    Sets the scale \a factor of the item. The default scale factor is 1.0
+    (i.e., the item is not scaled). A scale factor of 0.0 will collapse the
+    item to a single point. If you provide a negative scale factor, the
+    item will be flipped and mirrored (i.e., rotated 180 degrees).
+    The item is scaled around its transform origin point, which by default
+    is (0, 0). You can select a different transformation origin by calling
+    setTransformOriginPoint().
+    The scale is combined with the item's rotation(), transform() and
+    transformations() to map the item's coordinate system to the parent item.
+    \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;
+    d_ptr->transformData->onlyTransform = false;
+    d_ptr->dirtySceneTransform = 1;
+    if (d_ptr->isObject)
+        emit static_cast<QGraphicsObject *>(this)->scaleChanged();
+}
+/*!
+    \since 4.6
+    Returns a list of graphics transforms that currently apply to this item.
+    QGraphicsTransform is for applying and controlling a chain of individual
+    transformation operations on an item. It's particularily useful in
+    animations, where each transform operation needs to be interpolated
+    independently, or differently.
+    The transformations are combined with the item's rotation(), scale() and
+    transform() to map the item's coordinate system to the parent item.
+    \sa scale(), rotation(), transformOriginPoint(), {Transformations}
+*/
+QList<QGraphicsTransform *> QGraphicsItem::transformations() const
+{
+    if (!d_ptr->transformData)
+        return QList<QGraphicsTransform *>();
+    return d_ptr->transformData->graphicsTransforms;
+}
+/*!
+    \since 4.6
+    Sets a list of graphics \a transformations (QGraphicsTransform) that
+    currently apply to this item.
+    If all you want is to rotate or scale an item, you should call setRotation()
+    or setScale() instead. If you want to set an arbitrary transformation on
+    an item, you can call setTransform().
+    QGraphicsTransform is for applying and controlling a chain of individual
+    transformation operations on an item. It's particularily useful in
+    animations, where each transform operation needs to be interpolated
+    independently, or differently.
+    The transformations are combined with the item's rotation(), scale() and
+    transform() to map the item's coordinate system to the parent item.
+    \sa scale(), setTransformOriginPoint(), {Transformations}
+*/
+void QGraphicsItem::setTransformations(const QList<QGraphicsTransform *> &transformations)
+{
+    prepareGeometryChange();
+    if (!d_ptr->transformData)
+        d_ptr->transformData = new QGraphicsItemPrivate::TransformData;
+    d_ptr->transformData->graphicsTransforms = transformations;
+    for (int i = 0; i < transformations.size(); ++i)
+        transformations.at(i)->d_func()->setItem(this);
+    d_ptr->transformData->onlyTransform = false;
+    d_ptr->dirtySceneTransform = 1;
+}
+/*!
+    \internal
+*/
+void QGraphicsItemPrivate::appendGraphicsTransform(QGraphicsTransform *t)
+{
+    if (!transformData)
+        transformData = new QGraphicsItemPrivate::TransformData;
+    if (!transformData->graphicsTransforms.contains(t))
+        transformData->graphicsTransforms.append(t);
+    Q_Q(QGraphicsItem);
+    t->d_func()->setItem(q);
+    transformData->onlyTransform = false;
+    dirtySceneTransform = 1;
+}
+/*!
+    \since 4.6
+    Returns the origin point for the transformation in item coordinates.
+    The default is QPointF(0,0).
+    \sa setTransformOriginPoint(), {Transformations}
+*/
+QPointF QGraphicsItem::transformOriginPoint() const
+{
+    if (!d_ptr->transformData)
+        return QPointF(0,0);
+    return QPointF(d_ptr->transformData->xOrigin, d_ptr->transformData->yOrigin);
+}
+/*!
+    \since 4.6
+    Sets the \a origin point for the transformation in item coordinates.
+    \sa transformOriginPoint(), {Transformations}
+*/
+void QGraphicsItem::setTransformOriginPoint(const QPointF &origin)
+{
+    prepareGeometryChange();
+    if (!d_ptr->transformData)
+        d_ptr->transformData = new QGraphicsItemPrivate::TransformData;
+    d_ptr->transformData->xOrigin = origin.x();
+    d_ptr->transformData->yOrigin = origin.y();
+    d_ptr->transformData->onlyTransform = false;
+    d_ptr->dirtySceneTransform = 1;
+}
+/*!
+    \fn void QGraphicsItem::setTransformOriginPoint(qreal x, qreal y)
+    \since 4.6
+    \overload
+    Sets the origin point for the transformation in item coordinates.
+    This is equivalent to calling setTransformOriginPoint(QPointF(\a x, \a y)).
+    \sa setTransformOriginPoint(), {Transformations}
+*/
 /*!
 …
 QMatrix QGraphicsItem::sceneMatrix() const
+{
+    return sceneTransform().toAffine();
+    d_ptr->ensureSceneTransform();
+    return d_ptr->sceneTransform.toAffine();
+}
 …
     Unlike transform(), which returns only an item's local transformation, this
     function includes the item's (and any parents') position.
     \sa transform(), setTransform(), scenePos(), {The Graphics View Coordinate System}
+    function includes the item's (and any parents') position, and all the transfomation properties.
+    \sa transform(), setTransform(), scenePos(), {The Graphics View Coordinate System}, {Transformations}
 */
 QTransform QGraphicsItem::sceneTransform() const
+{
+    // Check if there's any entry in the transform cache.
+    QGraphicsScenePrivate *sd = d_ptr->scene ? d_ptr->scene->d_func() : 0;
+    int index = d_ptr->sceneTransformIndex;
+    if (sd && index != -1 && sd->validTransforms.testBit(index))
+        return sd->sceneTransformCache[index];
+    // Calculate local transform.
+    QTransform m;
+    if (d_ptr->hasTransform) {
+        m = transform();
+        if (!d_ptr->pos.isNull())
+            m *= QTransform::fromTranslate(d_ptr->pos.x(), d_ptr->pos.y());
+    } else if (!d_ptr->pos.isNull()) {
+        m = QTransform::fromTranslate(d_ptr->pos.x(), d_ptr->pos.y());
+    }
+    // Combine with parent and add to cache.
+    if (d_ptr->parent) {
+        m *= d_ptr->parent->sceneTransform();
+        // Don't cache toplevels
+        if (sd) {
+            if (index == -1) {
+                if (!sd->freeSceneTransformSlots.isEmpty()) {
+                    index = sd->freeSceneTransformSlots.last();
+                    sd->freeSceneTransformSlots.pop_back();
+                } else {
+                    index = sd->sceneTransformCache.size();
+                }
+                d_ptr->sceneTransformIndex = index;
+                if (index >= sd->validTransforms.size()) {
+                    sd->validTransforms.resize(index + 1);
+                    sd->sceneTransformCache.resize(index + 1);
+                }
+            }
+            sd->validTransforms.setBit(index, 1);
+            sd->sceneTransformCache[index] = m;
+        }
+    }
+    return m;
+    d_ptr->ensureSceneTransform();
+    return d_ptr->sceneTransform;
+}
 …
 QTransform QGraphicsItem::deviceTransform(const QTransform &viewportTransform) const
+{
+    // Ensure we return the standard transform if we're not untransformable.
+    if (!d_ptr->itemIsUntransformable()) {
+        d_ptr->ensureSceneTransform();
+        return d_ptr->sceneTransform * viewportTransform;
+    }
     // Find the topmost item that ignores view transformations.
     const QGraphicsItem *untransformedAncestor = this;
 …
     // First translate the base untransformable item.
+    QPointF mappedPoint = (untransformedAncestor->sceneTransform() * viewportTransform).map(QPointF(0, 0));
+    QTransform matrix;
+    matrix.translate(mappedPoint.x(), mappedPoint.y());
+    matrix = untransformedAncestor->transform() * matrix;
+    untransformedAncestor->d_ptr->ensureSceneTransform();
+    QPointF mappedPoint = (untransformedAncestor->d_ptr->sceneTransform * viewportTransform).map(QPointF(0, 0));
+    // COMBINE
+    QTransform matrix = QTransform::fromTranslate(mappedPoint.x(), mappedPoint.y());
+    if (untransformedAncestor->d_ptr->transformData)
+        matrix = untransformedAncestor->d_ptr->transformData->computedFullTransform(&matrix);
     // Then transform and translate all children.
     for (int i = 0; i < parents.size(); ++i) {
         const QGraphicsItem *parent = parents.at(i);
+        QPointF pos = parent->pos();
+        QTransform moveMatrix;
+        moveMatrix.translate(pos.x(), pos.y());
+        matrix = (parent->transform() * moveMatrix) * matrix;
+        parent->d_ptr->combineTransformFromParent(&matrix);
+    }
 …
         if (ok)
             *ok = true;
+        const QPointF &itemPos = d_ptr->pos;
+        if (itemPos.isNull())
+            return d_ptr->hasTransform ? transform() : QTransform();
+        if (d_ptr->hasTransform)
+            return transform() * QTransform::fromTranslate(itemPos.x(), itemPos.y());
+        return QTransform::fromTranslate(itemPos.x(), itemPos.y());
+        QTransform x;
+        d_ptr->combineTransformFromParent(&x);
+        return x;
+    }
 …
     if (otherParent == this) {
         const QPointF &otherPos = other->d_ptr->pos;
+        if (other->d_ptr->hasTransform) {
+            QTransform otherToParent = other->transform();
+            if (!otherPos.isNull())
+                otherToParent *= QTransform::fromTranslate(otherPos.x(), otherPos.y());
+        if (other->d_ptr->transformData) {
+            QTransform otherToParent;
+            other->d_ptr->combineTransformFromParent(&otherToParent);
             return otherToParent.inverted(ok);
-        } else {
-            if (ok)
-                *ok = true;
-            return QTransform::fromTranslate(-otherPos.x(), -otherPos.y());
+        }
+        if (ok)
+            *ok = true;
+        return QTransform::fromTranslate(-otherPos.x(), -otherPos.y());
+    }
     // Siblings
     if (parent == otherParent) {
+        bool hasTr = d_ptr->hasTransform;
+        bool otherHasTr = other->d_ptr->hasTransform;
+        // COMBINE
         const QPointF &itemPos = d_ptr->pos;
         const QPointF &otherPos = other->d_ptr->pos;
+        if (!hasTr && !otherHasTr) {
+        if (!d_ptr->transformData && !other->d_ptr->transformData) {
             QPointF delta = itemPos - otherPos;
             if (ok)
 …
+        }
+        QTransform itemToParent = QTransform::fromTranslate(itemPos.x(), itemPos.y());
+        if (hasTr)
+            itemToParent = itemPos.isNull() ? transform() : transform() * itemToParent;
+        QTransform otherToParent = QTransform::fromTranslate(otherPos.x(), otherPos.y());
+        if (otherHasTr)
+            otherToParent = otherPos.isNull() ? other->transform() : other->transform() * otherToParent;
+        QTransform itemToParent;
+        d_ptr->combineTransformFromParent(&itemToParent);
+        QTransform otherToParent;
+        other->d_ptr->combineTransformFromParent(&otherToParent);
         return itemToParent * otherToParent.inverted(ok);
+    }
 …
     // ancestor, then the only way is to combine their scene transforms.
     const QGraphicsItem *commonAncestor = commonAncestorItem(other);
+    if (!commonAncestor)
+        return sceneTransform() * other->sceneTransform().inverted(ok);
+    if (!commonAncestor) {
+        d_ptr->ensureSceneTransform();
+        other->d_ptr->ensureSceneTransform();
+        return d_ptr->sceneTransform * other->d_ptr->sceneTransform.inverted(ok);
+    }
     // If the two items are cousins (in sibling branches), map both to the
 …
     if (cousins) {
         bool good = false;
+        QTransform thisToScene;
+        QTransform otherToScene;
+        thisToScene = itemTransform(commonAncestor, &good);
+        QTransform thisToScene = itemTransform(commonAncestor, &good);
+        QTransform otherToScene(Qt::Uninitialized);
         if (good)
             otherToScene = other->itemTransform(commonAncestor, &good);
 …
     const QGraphicsItem *p = child;
     do {
+        const QGraphicsItemPrivate *pd = p->d_ptr;
+        if (pd->hasTransform)
+            x *= p->transform();
+        if (!pd->pos.isNull())
+            x *= QTransform::fromTranslate(pd->pos.x(), pd->pos.y());
+        p->d_ptr.data()->combineTransformToParent(&x);
     } while ((p = p->d_ptr->parent) && p != root);
     if (parentOfOther)
 …
     Use setTransform() instead.
     \sa transform(), rotate(), scale(), shear(), translate(), {The Graphics View Coordinate System}
+    \sa transform(), {The Graphics View Coordinate System}
 */
 void QGraphicsItem::setMatrix(const QMatrix &matrix, bool combine)
+{
+    QTransform oldTransform = this->transform();
+    QTransform newTransform;
+    if (!combine)
+        newTransform = QTransform(matrix);
+    else
+        newTransform = QTransform(matrix) * oldTransform;
+    if (oldTransform == newTransform)
+    if (!d_ptr->transformData)
+        d_ptr->transformData = new QGraphicsItemPrivate::TransformData;
+    QTransform newTransform(combine ? QTransform(matrix) * d_ptr->transformData->transform : QTransform(matrix));
+    if (d_ptr->transformData->transform == newTransform)
         return;
+    // Notify the item that the matrix is changing.
+    QVariant newTransformVariant(itemChange(ItemMatrixChange,
+                                            qVariantFromValue<QMatrix>(newTransform.toAffine())));
+    newTransform = QTransform(qVariantValue<QMatrix>(newTransformVariant));
+    if (oldTransform == newTransform)
+    // Update and set the new transformation.
+    if (!(d_ptr->flags & ItemSendsGeometryChanges)) {
+        d_ptr->setTransformHelper(newTransform);
         return;
+    }
+    // Notify the item that the transformation matrix is changing.
+    const QVariant newMatrixVariant = qVariantFromValue<QMatrix>(newTransform.toAffine());
+    newTransform = QTransform(qVariantValue<QMatrix>(itemChange(ItemMatrixChange, newMatrixVariant)));
+    if (d_ptr->transformData->transform == newTransform)
+        return;
     // Update and set the new transformation.
+    d_ptr->fullUpdateHelper(true, true);
+    prepareGeometryChange();
+    d_ptr->hasTransform = !newTransform.isIdentity();
+    d_ptr->setExtra(QGraphicsItemPrivate::ExtraTransform, newTransform);
+    d_ptr->invalidateSceneTransformCache();
+    d_ptr->setTransformHelper(newTransform);
     // Send post-notification.
+    // NB! We have to change the value from QMatrix to QTransform.
+    qVariantSetValue<QTransform>(newTransformVariant, newTransform);
+    itemChange(ItemTransformHasChanged, newTransformVariant);
+    itemChange(ItemTransformHasChanged, qVariantFromValue<QTransform>(newTransform));
+}
 …
     from scene coordinates to item coordinates.
+    \sa transform(), rotate(), scale(), shear(), translate(), {The Graphics View Coordinate System}
+    The transformation matrix is combined with the item's rotation(), scale()
+    and transformations() into a combined transformation that maps the item's
+    coordinate system to its parent.
+    \sa transform(), setRotation(), setScale(), setTransformOriginPoint(), {The Graphics View Coordinate System}, {Transformations}
 */
 void QGraphicsItem::setTransform(const QTransform &matrix, bool combine)
+{
+    QTransform oldTransform = this->transform();
+    QTransform newTransform;
+    if (!combine)
+        newTransform = matrix;
+    else
+        newTransform = matrix * oldTransform;
+    if (oldTransform == newTransform)
+    if (!d_ptr->transformData)
+        d_ptr->transformData = new QGraphicsItemPrivate::TransformData;
+    QTransform newTransform(combine ? matrix * d_ptr->transformData->transform : matrix);
+    if (d_ptr->transformData->transform == newTransform)
         return;
+    // Update and set the new transformation.
+    if (!(d_ptr->flags & ItemSendsGeometryChanges)) {
+        d_ptr->setTransformHelper(newTransform);
+        return;
+    }
     // Notify the item that the transformation matrix is changing.
 …
                                                   qVariantFromValue<QTransform>(newTransform)));
     newTransform = qVariantValue<QTransform>(newTransformVariant);
     if (oldTransform == newTransform)
+    if (d_ptr->transformData->transform == newTransform)
         return;
     // Update and set the new transformation.
+    d_ptr->fullUpdateHelper(true, true);
+    prepareGeometryChange();
+    d_ptr->hasTransform = !newTransform.isIdentity();
+    d_ptr->setExtra(QGraphicsItemPrivate::ExtraTransform, newTransform);
+    d_ptr->invalidateSceneTransformCache();
+    d_ptr->setTransformHelper(newTransform);
     // Send post-notification.
     itemChange(ItemTransformHasChanged, newTransformVariant);
+    d_ptr->sendScenePosChange();
+}
 …
     \since 4.3
+    Resets this item's transformation matrix to the identity matrix. This is
+    equivalent to calling \c setTransform(QTransform()).
+    Resets this item's transformation matrix to the identity matrix or
+    all the transformation properties to their default values.
+    This is equivalent to calling \c setTransform(QTransform()).
     \sa setTransform(), transform()
 …
 /*!
+    \obsolete
+    Use
+    \code
+    setRotation(rotation() + angle);
+    \endcode
+    instead.
     Rotates the current item transformation \a angle degrees clockwise around
     its origin. To translate around an arbitrary point (x, y), you need to
 …
 /*!
+    \obsolete
+    Use
+    \code
+    setTransform(QTransform::fromScale(sx, sy), true);
+    \endcode
+    instead.
     Scales the current item transformation by (\a sx, \a sy) around its
     origin. To scale from an arbitrary point (x, y), you need to combine
 …
     \snippet doc/src/snippets/code/src_gui_graphicsview_qgraphicsitem.cpp 7
     \sa setTransform(), transform(), rotate(), shear(), translate()
+    \sa setTransform(), transform()
 */
 void QGraphicsItem::scale(qreal sx, qreal sy)
 …
 /*!
+    \obsolete
+    Use
+    \code
+    setTransform(QTransform().shear(sh, sv), true);
+    \endcode
+    instead.
     Shears the current item transformation by (\a sh, \a sv).
     \sa setTransform(), transform(), rotate(), scale(), translate()
+    \sa setTransform(), transform()
 */
 void QGraphicsItem::shear(qreal sh, qreal sv)
 …
 /*!
+    \obsolete
+    Use setPos() or setTransformOriginPoint() instead. For identical
+    behavior, use
+    \code
+    setTransform(QTransform::fromTranslate(dx, dy), true);
+    \endcode
     Translates the current item transformation by (\a dx, \a dy).
 …
     which is conceptually separate from its position.
     \sa setTransform(), transform(), rotate(), scale(), shear()
+    \sa setTransform(), transform()
 */
 void QGraphicsItem::translate(qreal dx, qreal dy)
 …
 /*!
     Returns the Z-value, or the elevation, of the item. The Z-value decides
     the stacking order of sibling (neighboring) items.
+    Returns the Z-value of the item. The Z-value affects the stacking order of
+    sibling (neighboring) items.
     The default Z-value is 0.
     \sa setZValue()
+    \sa setZValue(), {QGraphicsItem#Sorting}{Sorting}, stackBefore(), ItemStacksBehindParent
 */
 qreal QGraphicsItem::zValue() const
 …
 /*!
+    Sets the Z-value, or the elevation, of the item, to \a z. The elevation
+    decides the stacking order of sibling (neighboring) items. An item of high
+    Z-value will be drawn on top of an item with a lower Z-value if they
+    share the same parent item. In addition, children of an item will always be drawn
+    on top of the parent, regardless of the child's Z-value. Sibling items
+    that share the same Z-value will be drawn in an undefined order, although
+    the order will stay the same for as long as the items live.
+    \img graphicsview-zorder.png
+    Children of different parents are stacked according to the Z-value of
+    each item's ancestor item which is an immediate child of the two
+    items' closest common ancestor. For example, a robot item might
+    define a torso item as the parent of a head item, two arm items,
+    and two upper-leg items. The upper-leg items would each be parents
+    of one lower-leg item, and each lower-leg item would be parents of
+    one foot item.  The stacking order of the feet is the same as the
+    stacking order of each foot's ancestor that is an immediate child
+    of the two feet's common ancestor (i.e., the torso item); so the
+    feet are stacked in the same order as the upper-leg items,
+    regardless of each foot's Z-value.
+    Sets the Z-value of the item to \a z. The Z value decides the stacking
+    order of sibling (neighboring) items. A sibling item of high Z value will
+    always be drawn on top of another sibling item with a lower Z value.
+    If you restore the Z value, the item's insertion order will decide its
+    stacking order.
     The Z-value does not affect the item's size in any way.
 …
     The default Z-value is 0.
     \sa zValue()
+    \sa zValue(), {QGraphicsItem#Sorting}{Sorting}, stackBefore(), ItemStacksBehindParent
 */
 void QGraphicsItem::setZValue(qreal z)
+{
     const QVariant newZVariant(itemChange(ItemZValueChange, double(z)));
     qreal newZ = qreal(newZVariant.toDouble());
+    const QVariant newZVariant(itemChange(ItemZValueChange, z));
+    qreal newZ = newZVariant.toReal();
     if (newZ == d_ptr->z)
         return;
-    d_ptr->z = z;
-    d_ptr->fullUpdateHelper();
     if (d_ptr->scene) {
+        // Invalidate any sort caching; arrival of a new item means we need to
+        // resort.
+        d_ptr->scene->d_func()->invalidateSortCache();
+    }
+        // Z Value has changed, we have to notify the index.
+        d_ptr->scene->d_func()->index->itemChange(this, ItemZValueChange, newZVariant);
+    }
+    d_ptr->z = newZ;
+    if (d_ptr->parent)
+        d_ptr->parent->d_ptr->needSortChildren = 1;
+    else if (d_ptr->scene)
+        d_ptr->scene->d_func()->needSortTopLevelItems = 1;
+    if (d_ptr->scene)
+        d_ptr->scene->d_func()->markDirty(this, QRectF(), /*invalidateChildren=*/true);
     itemChange(ItemZValueHasChanged, newZVariant);
+    if (d_ptr->flags & ItemNegativeZStacksBehindParent)
+        setFlag(QGraphicsItem::ItemStacksBehindParent, z < qreal(0.0));
+    if (d_ptr->isObject)
+        emit static_cast<QGraphicsObject *>(this)->zChanged();
+}
+/*!
+    \internal
+    Ensures that the list of children is sorted by insertion order, and that
+    the siblingIndexes are packed (no gaps), and start at 0.
+    ### This function is almost identical to
+    QGraphicsScenePrivate::ensureSequentialTopLevelSiblingIndexes().
+*/
+void QGraphicsItemPrivate::ensureSequentialSiblingIndex()
+{
+    if (!sequentialOrdering) {
+        qSort(children.begin(), children.end(), insertionOrder);
+        sequentialOrdering = 1;
+        needSortChildren = 1;
+    }
+    if (holesInSiblingIndex) {
+        holesInSiblingIndex = 0;
+        for (int i = 0; i < children.size(); ++i)
+            children[i]->d_ptr->siblingIndex = i;
+    }
+}
+/*!
+    \internal
+*/
+inline void QGraphicsItemPrivate::sendScenePosChange()
+{
+    Q_Q(QGraphicsItem);
+    if (scene) {
+        if (flags & QGraphicsItem::ItemSendsScenePositionChanges)
+            q->itemChange(QGraphicsItem::ItemScenePositionHasChanged, q->scenePos());
+        if (scenePosDescendants) {
+            foreach (QGraphicsItem *item, scene->d_func()->scenePosItems) {
+                if (q->isAncestorOf(item))
+                    item->itemChange(QGraphicsItem::ItemScenePositionHasChanged, item->scenePos());
+            }
+        }
+    }
+}
+/*!
+    \since 4.6
+    Stacks this item before \a sibling, which must be a sibling item (i.e., the
+    two items must share the same parent item, or must both be toplevel items).
+    The \a sibling must have the same Z value as this item, otherwise calling
+    this function will have no effect.
+    By default, all sibling items are stacked by insertion order (i.e., the
+    first item you add is drawn before the next item you add). If two items' Z
+    values are different, then the item with the highest Z value is drawn on
+    top. When the Z values are the same, the insertion order will decide the
+    stacking order.
+    \sa setZValue(), ItemStacksBehindParent, {QGraphicsItem#Sorting}{Sorting}
+*/
+void QGraphicsItem::stackBefore(const QGraphicsItem *sibling)
+{
+    if (sibling == this)
+        return;
+    if (!sibling || d_ptr->parent != sibling->parentItem()) {
+        qWarning("QGraphicsItem::stackUnder: cannot stack under %p, which must be a sibling", sibling);
+        return;
+    }
+    QList<QGraphicsItem *> *siblings = d_ptr->parent
+                                       ? &d_ptr->parent->d_ptr->children
+                                       : (d_ptr->scene ? &d_ptr->scene->d_func()->topLevelItems : 0);
+    if (!siblings) {
+        qWarning("QGraphicsItem::stackUnder: cannot stack under %p, which must be a sibling", sibling);
+        return;
+    }
+    // First, make sure that the sibling indexes have no holes. This also
+    // marks the children list for sorting.
+    if (d_ptr->parent)
+        d_ptr->parent->d_ptr->ensureSequentialSiblingIndex();
+    else
+        d_ptr->scene->d_func()->ensureSequentialTopLevelSiblingIndexes();
+    // Only move items with the same Z value, and that need moving.
+    int siblingIndex = sibling->d_ptr->siblingIndex;
+    int myIndex = d_ptr->siblingIndex;
+    if (myIndex >= siblingIndex) {
+        siblings->move(myIndex, siblingIndex);
+        // Fixup the insertion ordering.
+        for (int i = 0; i < siblings->size(); ++i) {
+            int &index = siblings->at(i)->d_ptr->siblingIndex;
+            if (i != siblingIndex && index >= siblingIndex && index <= myIndex)
+                ++index;
+        }
+        d_ptr->siblingIndex = siblingIndex;
+        for (int i = 0; i < siblings->size(); ++i) {
+            int &index = siblings->at(i)->d_ptr->siblingIndex;
+            if (i != siblingIndex && index >= siblingIndex && index <= myIndex)
+                siblings->at(i)->d_ptr->siblingOrderChange();
+        }
+        d_ptr->siblingOrderChange();
+    }
+}
 …
 QRectF QGraphicsItem::childrenBoundingRect() const
+{
+    QRectF childRect;
+    foreach (QGraphicsItem *child, children()) {
+        QPointF childPos = child->pos();
+        QTransform matrix = child->transform();
+        if (!childPos.isNull())
+            matrix *= QTransform::fromTranslate(childPos.x(), childPos.y());
+        childRect |= matrix.mapRect(child->boundingRect() | child->childrenBoundingRect());
+    }
+    return childRect;
+    if (!d_ptr->dirtyChildrenBoundingRect)
+        return d_ptr->childrenBoundingRect;
+    d_ptr->childrenBoundingRect = QRectF();
+    d_ptr->childrenBoundingRectHelper(0, &d_ptr->childrenBoundingRect);
+    d_ptr->dirtyChildrenBoundingRect = 0;
+    return d_ptr->childrenBoundingRect;
+}
 …
     Although the item's shape can be arbitrary, the bounding rect is
     always rectangular, and it is unaffected by the items'
     transformation (scale(), rotate(), etc.).
+    transformation.
     If you want to change the item's bounding rectangle, you must first call
 …
+{
     // Find translate-only offset
+    // COMBINE
     QPointF offset;
     const QGraphicsItem *parentItem = this;
     const QGraphicsItemPrivate *itemd;
     do {
         itemd = parentItem->d_ptr;
         if (itemd->hasTransform)
+        itemd = parentItem->d_ptr.data();
+        if (itemd->transformData)
             break;
         offset += itemd->pos;
 …
     QRectF br = boundingRect();
     br.translate(offset);
+    return !parentItem ? br : parentItem->sceneTransform().mapRect(br);
+    if (!parentItem)
+        return br;
+    if (parentItem->d_ptr->hasTranslateOnlySceneTransform()) {
+        br.translate(parentItem->d_ptr->sceneTransform.dx(), parentItem->d_ptr->sceneTransform.dy());
+        return br;
+    }
+    return parentItem->d_ptr->sceneTransform.mapRect(br);
+}
 …
+{
     Q_D(const QGraphicsItem);
+    if (!d->dirtyClipPath)
+        return d->emptyClipPath ? QPainterPath() : d->cachedClipPath;
+    if (!isClipped()) {
+        d_ptr->setCachedClipPath(QPainterPath());
+        return d->cachedClipPath;
+    }
+    if (!isClipped())
+        return QPainterPath();
     const QRectF thisBoundingRect(boundingRect());
+    if (thisBoundingRect.isEmpty()) {
+        if (d_ptr->flags & ItemClipsChildrenToShape)
+            d_ptr->setEmptyCachedClipPathRecursively();
+        else
+            d_ptr->setEmptyCachedClipPath();
+    if (thisBoundingRect.isEmpty())
         return QPainterPath();
+    }
     QPainterPath clip;
 …
         // Intersect any in-between clips starting at the top and moving downwards.
-        bool foundValidClipPath = false;
         while ((parent = parent->d_ptr->parent)) {
             if (parent->d_ptr->flags & ItemClipsChildrenToShape) {
                 // Map clip to the current parent and intersect with its shape/clipPath
                 clip = lastParent->itemTransform(parent).map(clip);
+                if ((foundValidClipPath = !parent->d_ptr->dirtyClipPath && parent->isClipped())) {
+                    if (parent->d_ptr->emptyClipPath) {
+                        if (d_ptr->flags & ItemClipsChildrenToShape)
+                            d_ptr->setEmptyCachedClipPathRecursively();
+                        else
+                            d_ptr->setEmptyCachedClipPath();
+                        return QPainterPath();
+                    }
+                    clip = clip.intersected(parent->d_ptr->cachedClipPath);
+                    if (!(parent->d_ptr->flags & ItemClipsToShape))
+                        clip = clip.intersected(parent->shape());
+                } else {
+                    clip = clip.intersected(parent->shape());
+                }
+                if (clip.isEmpty()) {
+                    if (d_ptr->flags & ItemClipsChildrenToShape)
+                        d_ptr->setEmptyCachedClipPathRecursively();
+                    else
+                        d_ptr->setEmptyCachedClipPath();
+                clip = clip.intersected(parent->shape());
+                if (clip.isEmpty())
                     return clip;
+                }
                 lastParent = parent;
+            }
+            if (!(parent->d_ptr->ancestorFlags & QGraphicsItemPrivate::AncestorClipsChildren)
+                || foundValidClipPath) {
+            if (!(parent->d_ptr->ancestorFlags & QGraphicsItemPrivate::AncestorClipsChildren))
                 break;
+            }
+        }
 …
         clip = clip.intersected(shape());
-    d_ptr->setCachedClipPath(clip);
     return clip;
+}
 …
 /*!
+    Returns true if this item collides with \a other; otherwise returns false.
+    The ways items collide is determined by \a mode. The default value for \a
+    mode is Qt::IntersectsItemShape; \a other collides with this item if it
+    either intersects, contains, or is contained by this item's shape.
+    Returns true if this item collides with \a other; otherwise
+    returns false.
+    The \a mode is applied to \a other, and the resulting shape or
+    bounding rectangle is then compared to this item's shape. The
+    default value for \a mode is Qt::IntersectsItemShape; \a other
+    collides with this item if it either intersects, contains, or is
+    contained by this item's shape (see Qt::ItemSelectionMode for
+    details).
     The default implementation is based on shape intersection, and it calls
 …
     intersects, contains, or is contained by this item's shape.
+    Note that this function checks whether the item's shape or
+    bounding rectangle (depending on \a mode) is contained within \a
+    path, and not whether \a path is contained within the items shape
+    or bounding rectangle.
     \sa collidesWithItem(), contains(), shape()
 */
 …
     Returns a list of all items that collide with this item.
+    The way collisions are detected is determined by \a mode. The default
+    value for \a mode is Qt::IntersectsItemShape; All items whose shape
+    intersects or is contained by this item's shape are returned.
+    \sa QGraphicsScene::collidingItems(), collidesWithItem()
+    The way collisions are detected is determined by applying \a mode
+    to items that are compared to this item, i.e., each item's shape
+    or bounding rectangle is checked against this item's shape. The
+    default value for \a mode is Qt::IntersectsItemShape.
+    \sa collidesWithItem()
 */
 QList<QGraphicsItem *> QGraphicsItem::collidingItems(Qt::ItemSelectionMode mode) const
 …
     if (!item)
         return false;
     return QGraphicsScenePrivate::closestItemFirst_withoutCache(item, this)
+    return qt_closestItemFirst(item, this)
         && qt_QGraphicsItem_isObscured(this, item, boundingRect());
+}
 …
     // Transform QRegion back to device space
+    QTransform unscale;
+    unscale.scale(1 / granularity, 1 / granularity);
+    QTransform unscale = QTransform::fromScale(1 / granularity, 1 / granularity);
     QRegion r;
     QBitmap colorMask = QBitmap::fromImage(mask.createMaskFromColor(0));
 …
     All painting is done in local coordinates.
     \sa setCacheMode(), QPen::width(), {Item Coordinates}
+    \sa setCacheMode(), QPen::width(), {Item Coordinates}, ItemUsesExtendedStyleOption
 */
 …
     Returns true if we can discard an update request; otherwise false.
 */
+bool QGraphicsItemPrivate::discardUpdateRequest(bool ignoreClipping,
+                                                bool ignoreVisibleBit,
+                                                bool ignoreDirtyBit) const
+bool QGraphicsItemPrivate::discardUpdateRequest(bool ignoreVisibleBit, bool ignoreDirtyBit,
+                                                bool ignoreOpacity) const
+{
     // No scene, or if the scene is updating everything, means we have nothing
     // to do. The only exception is if the scene tracks the growing scene rect.
+    return (!visible && !ignoreVisibleBit)
+           || (dirty && !ignoreDirtyBit)
+           || !scene
+           || (scene->d_func()->updateAll && scene->d_func()->hasSceneRect)
+           || (!ignoreClipping && (childrenClippedToShape() && isClippedAway()))
+           || (childrenCombineOpacity() && isFullyTransparent());
+    return !scene
+           || (!visible && !ignoreVisibleBit && !this->ignoreVisible)
+           || (!ignoreDirtyBit && fullUpdatePending)
+           || (!ignoreOpacity && !this->ignoreOpacity && childrenCombineOpacity() && isFullyTransparent());
+}
 /*!
     \internal
+    Asks the scene to mark this item's scene rect as dirty, requesting a
+    redraw.  This does not invalidate any cache.
+    The \a force argument is for the update call in setVisible(), which is the
+    only case where the item's background should be marked as dirty even when
+    the item isn't visible.
+*/
+void QGraphicsItemPrivate::updateHelper(const QRectF &rect, bool force, bool maybeDirtyClipPath)
+{
+    // No scene, or if the scene is updating everything, means we have nothing
+    // to do. The only exception is if the scene tracks the growing scene rect.
+    if (discardUpdateRequest(/*ignoreClipping=*/maybeDirtyClipPath, /*ignoreVisibleBit=*/force))
+*/
+int QGraphicsItemPrivate::depth() const
+{
+    if (itemDepth == -1)
+        const_cast<QGraphicsItemPrivate *>(this)->resolveDepth();
+    return itemDepth;
+}
+/*!
+    \internal
+*/
+#ifndef QT_NO_GRAPHICSEFFECT
+void QGraphicsItemPrivate::invalidateGraphicsEffectsRecursively()
+{
+    QGraphicsItemPrivate *itemPrivate = this;
+    do {
+        if (itemPrivate->graphicsEffect) {
+            itemPrivate->notifyInvalidated = 1;
+            if (!itemPrivate->updateDueToGraphicsEffect)
+                static_cast<QGraphicsItemEffectSourcePrivate *>(itemPrivate->graphicsEffect->d_func()->source->d_func())->invalidateCache();
+        }
+    } while ((itemPrivate = itemPrivate->parent ? itemPrivate->parent->d_ptr.data() : 0));
+}
+#endif //QT_NO_GRAPHICSEFFECT
+/*!
+    \internal
+*/
+void QGraphicsItemPrivate::invalidateDepthRecursively()
+{
+    if (itemDepth == -1)
         return;
     if (rect.isNull())
         dirty = 1;
     scene->itemUpdated(q_ptr, rect);
+    itemDepth = -1;
+    for (int i = 0; i < children.size(); ++i)
+        children.at(i)->d_ptr->invalidateDepthRecursively();
+}
 …
     \internal
+    Propagates updates to \a item and all its children.
+*/
+void QGraphicsItemPrivate::fullUpdateHelper(bool childrenOnly, bool maybeDirtyClipPath)
+{
+    if (discardUpdateRequest(/*ignoreClipping=*/maybeDirtyClipPath,
+                             /*ignoreVisibleBit=*/false,
+                             /*ignoreDirtyBit=*/true)) {
+        return;
+    }
+    if (!childrenOnly && !dirty) {
+        // Effectively the same as updateHelper(QRectF(), false, maybeDirtyClipPath).
+        dirty = 1;
+        scene->itemUpdated(q_ptr, QRectF());
+    }
+    if (dirtyChildren || childrenClippedToShape()) {
+        // Unnecessary to update children as well.
+        return;
+    }
+    if (ancestorFlags & AncestorClipsChildren) {
+        Q_Q(QGraphicsItem);
+        // Check if we can avoid updating all children.
+        QGraphicsItem *p = parent;
+        QRectF br = q->boundingRect();
+        while (p) {
+            if (p->d_ptr->flags & QGraphicsItem::ItemClipsChildrenToShape) {
+                bool ok;
+                QTransform x = q->itemTransform(p, &ok);
+                if (!ok)
+                    break;
+                if (x.mapRect(br).contains(p->boundingRect()))
+                    return;
+            }
+            p = p->d_ptr->parent;
+            if (!p || !(p->d_ptr->ancestorFlags & AncestorClipsChildren))
+                break;
+            // ### check one level only
+            break;
+        }
+    }
+    foreach (QGraphicsItem *child, children)
+        child->d_ptr->fullUpdateHelper(false, maybeDirtyClipPath);
+    dirtyChildren = 1;
+}
+static inline bool qt_allChildrenCombineOpacity(QGraphicsItem *parent)
+{
+    Q_ASSERT(parent);
+    if (parent->flags() & QGraphicsItem::ItemDoesntPropagateOpacityToChildren)
+        return false;
+    const QList<QGraphicsItem *> children(parent->childItems());
+    for (int i = 0; i < children.size(); ++i) {
+        if (children.at(i)->flags() & QGraphicsItem::ItemIgnoresParentOpacity)
+            return false;
+    }
+    return true;
+}
+void QGraphicsItemPrivate::updateEffectiveOpacity()
+{
+    Q_Q(QGraphicsItem);
+    if (parent) {
+        resolveEffectiveOpacity(parent->effectiveOpacity());
+        parent->d_ptr->allChildrenCombineOpacity = qt_allChildrenCombineOpacity(parent);
+    } else {
+        resolveEffectiveOpacity(1.0);
+    }
+    allChildrenCombineOpacity = qt_allChildrenCombineOpacity(q);
+    Resolves the stacking depth of this object and all its ancestors.
+*/
+void QGraphicsItemPrivate::resolveDepth()
+{
+    if (!parent)
+        itemDepth = 0;
+    else {
+        if (parent->d_ptr->itemDepth == -1)
+            parent->d_ptr->resolveDepth();
+        itemDepth = parent->d_ptr->itemDepth + 1;
+    }
+}
 …
     \internal
+    Resolves and propagates this item's effective opacity to its children.
+*/
+void QGraphicsItemPrivate::resolveEffectiveOpacity(qreal parentEffectiveOpacity)
+{
+    Q_Q(QGraphicsItem);
+    QGraphicsItem::GraphicsItemFlags myFlags = q->flags();
+    QGraphicsItem::GraphicsItemFlags parentFlags = parent ? parent->flags() : QGraphicsItem::GraphicsItemFlags(0);
+    // My local opacity is always part of my effective opacity.
+    qreal myEffectiveOpacity = q->opacity();
+    // If I have a parent, and I don't ignore my parent's opacity, and my
+    // parent propagates to me, then combine my local opacity with my parent's
+    // effective opacity into my effective opacity.
+    if (parent
+        && !(myFlags & QGraphicsItem::ItemIgnoresParentOpacity)
+        && !(parentFlags & QGraphicsItem::ItemDoesntPropagateOpacityToChildren)) {
+        myEffectiveOpacity *= parentEffectiveOpacity;
+    }
+    // Set this item's resolved opacity.
+    if (qFuzzyCompare(myEffectiveOpacity, qreal(1.0))) {
+        // Opaque, unset effective opacity.
+        hasEffectiveOpacity = 0;
+        unsetExtra(ExtraEffectiveOpacity);
+    } else {
+        hasEffectiveOpacity = 1;
+        setExtra(ExtraEffectiveOpacity, myEffectiveOpacity);
+    }
+    // Resolve children always.
+    for (int i = 0; i < children.size(); ++i)
+        children.at(i)->d_ptr->resolveEffectiveOpacity(myEffectiveOpacity);
+    ### This function is almost identical to
+    QGraphicsScenePrivate::registerTopLevelItem().
+*/
+void QGraphicsItemPrivate::addChild(QGraphicsItem *child)
+{
+    // Remove all holes from the sibling index list. Now the max index
+    // number is equal to the size of the children list.
+    ensureSequentialSiblingIndex();
+    needSortChildren = 1; // ### maybe 0
+    child->d_ptr->siblingIndex = children.size();
+    children.append(child);
+}
 …
     \internal
+    Resolves the stacking depth of this object and all its children.
+*/
+void QGraphicsItemPrivate::resolveDepth(int parentDepth)
+{
+    depth = parentDepth + 1;
+    for (int i = 0; i < children.size(); ++i)
+        children.at(i)->d_ptr->resolveDepth(depth);
+    ### This function is almost identical to
+    QGraphicsScenePrivate::unregisterTopLevelItem().
+*/
+void QGraphicsItemPrivate::removeChild(QGraphicsItem *child)
+{
+    // When removing elements in the middle of the children list,
+    // there will be a "gap" in the list of sibling indexes (0,1,3,4).
+    if (!holesInSiblingIndex)
+        holesInSiblingIndex = child->d_ptr->siblingIndex != children.size() - 1;
+    if (sequentialOrdering && !holesInSiblingIndex)
+        children.removeAt(child->d_ptr->siblingIndex);
+    else
+        children.removeOne(child);
+    // NB! Do not use children.removeAt(child->d_ptr->siblingIndex) because
+    // the child is not guaranteed to be at the index after the list is sorted.
+    // (see ensureSortedChildren()).
+    child->d_ptr->siblingIndex = -1;
+}
 …
     \internal
 */
+void QGraphicsItemPrivate::invalidateSceneTransformCache()
+{
+    if (!scene || (parent && sceneTransformIndex == -1))
+        return;
+    if (sceneTransformIndex != -1)
+        scene->d_func()->validTransforms.setBit(sceneTransformIndex, 0);
+    for (int i = 0; i < children.size(); ++i)
+        children.at(i)->d_ptr->invalidateSceneTransformCache();
+}
+QGraphicsItemCache *QGraphicsItemPrivate::maybeExtraItemCache() const
+{
+    return (QGraphicsItemCache *)qVariantValue<void *>(extra(ExtraCacheData));
+}
+/*!
+    \internal
+*/
 QGraphicsItemCache *QGraphicsItemPrivate::extraItemCache() const
+{
 …
+}
+/*!
+    \internal
+*/
 void QGraphicsItemPrivate::removeExtraItemCache()
+{
 …
+}
+void QGraphicsItemPrivate::setEmptyCachedClipPathRecursively(const QRectF &emptyIfOutsideThisRect)
+{
+    setEmptyCachedClipPath();
+    const bool checkRect = !emptyIfOutsideThisRect.isNull()
+                           && !(flags & QGraphicsItem::ItemClipsChildrenToShape);
+    for (int i = 0; i < children.size(); ++i) {
+        if (!checkRect) {
+            children.at(i)->d_ptr->setEmptyCachedClipPathRecursively();
+            continue;
+// Traverses all the ancestors up to the top-level and updates the pointer to
+// always point to the top-most item that has a dirty scene transform.
+// It then backtracks to the top-most dirty item and start calculating the
+// scene transform by combining the item's transform (+pos) with the parent's
+// cached scene transform (which we at this point know for sure is valid).
+void QGraphicsItemPrivate::ensureSceneTransformRecursive(QGraphicsItem **topMostDirtyItem)
+{
+    Q_ASSERT(topMostDirtyItem);
+    if (dirtySceneTransform)
+        *topMostDirtyItem = q_ptr;
+    if (parent)
+        parent->d_ptr->ensureSceneTransformRecursive(topMostDirtyItem);
+    if (*topMostDirtyItem == q_ptr) {
+        if (!dirtySceneTransform)
+            return; // OK, neither my ancestors nor I have dirty scene transforms.
+        *topMostDirtyItem = 0;
+    } else if (*topMostDirtyItem) {
+        return; // Continue backtrack.
+    }
+    // This item and all its descendants have dirty scene transforms.
+    // We're about to validate this item's scene transform, so we have to
+    // invalidate all the children; otherwise there's no way for the descendants
+    // to detect that the ancestor has changed.
+    invalidateChildrenSceneTransform();
+    // COMBINE my transform with the parent's scene transform.
+    updateSceneTransformFromParent();
+    Q_ASSERT(!dirtySceneTransform);
+}
+/*!
+    \internal
+*/
+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 != q_ptr && parent->d_ptr->subFocusItem) {
+            if (parent->d_ptr->subFocusItem == q_ptr)
+                break;
+            parent->d_ptr->subFocusItem->d_ptr->clearSubFocus();
+        }
+        QGraphicsItem *child = children.at(i);
+        const QRectF rect = child->mapRectFromParent(emptyIfOutsideThisRect);
+        if (rect.intersects(child->boundingRect()))
+            child->d_ptr->invalidateCachedClipPathRecursively(false, rect);
+        else
+            child->d_ptr->setEmptyCachedClipPathRecursively(rect);
+    }
+}
+void QGraphicsItemPrivate::invalidateCachedClipPathRecursively(bool childrenOnly, const QRectF &emptyIfOutsideThisRect)
+{
+    if (!childrenOnly)
+        invalidateCachedClipPath();
+    const bool checkRect = !emptyIfOutsideThisRect.isNull();
+    for (int i = 0; i < children.size(); ++i) {
+        if (!checkRect) {
+            children.at(i)->d_ptr->invalidateCachedClipPathRecursively(false);
+            continue;
+        }
+        QGraphicsItem *child = children.at(i);
+        const QRectF rect = child->mapRectFromParent(emptyIfOutsideThisRect);
+        if (rect.intersects(child->boundingRect()))
+            child->d_ptr->invalidateCachedClipPathRecursively(false, rect);
+        else
+            child->d_ptr->setEmptyCachedClipPathRecursively(rect);
+    }
+}
+void QGraphicsItemPrivate::updateCachedClipPathFromSetPosHelper(const QPointF &newPos)
+{
+    Q_ASSERT(inSetPosHelper);
+    if (!(ancestorFlags & QGraphicsItemPrivate::AncestorClipsChildren))
+        return; // Not clipped by any ancestor.
+    // Find closest clip ancestor and transform.
+    Q_Q(QGraphicsItem);
+    QTransform thisToParentTransform = hasTransform
+                                       ? q->transform() * QTransform::fromTranslate(newPos.x(), newPos.y())
+                                       : QTransform::fromTranslate(newPos.x(), newPos.y());
+    QGraphicsItem *clipParent = parent;
+    while (clipParent && !(clipParent->d_ptr->flags & QGraphicsItem::ItemClipsChildrenToShape)) {
+        if (clipParent->d_ptr->hasTransform)
+            thisToParentTransform *= clipParent->transform();
+        if (!clipParent->d_ptr->pos.isNull()) {
+            thisToParentTransform *= QTransform::fromTranslate(clipParent->d_ptr->pos.x(),
+                                                               clipParent->d_ptr->pos.y());
+        }
+        clipParent = clipParent->d_ptr->parent;
+    }
+    // thisToParentTransform is now the same as q->itemTransform(clipParent), except
+    // that the new position (which is not yet set on the item) is taken into account.
+    Q_ASSERT(clipParent);
+    Q_ASSERT(clipParent->d_ptr->flags & QGraphicsItem::ItemClipsChildrenToShape);
+    // From here everything is calculated in clip parent's coordinates.
+    const QRectF parentBoundingRect(clipParent->boundingRect());
+    const QRectF thisBoundingRect(thisToParentTransform.mapRect(q->boundingRect()));
+    if (!parentBoundingRect.intersects(thisBoundingRect)) {
+        // Item is moved outside the clip parent's bounding rect,
+        // i.e. it is fully clipped and the clip path is empty.
+        if (flags & QGraphicsItem::ItemClipsChildrenToShape)
+            setEmptyCachedClipPathRecursively();
+        else
+            setEmptyCachedClipPathRecursively(thisToParentTransform.inverted().mapRect(parentBoundingRect));
+        return;
+    }
+    const QPainterPath parentClip(clipParent->isClipped() ? clipParent->clipPath() : clipParent->shape());
+    if (parentClip.contains(thisBoundingRect))
+        return; // Item is inside the clip parent's shape. No update required.
+    const QRectF parentClipRect(parentClip.controlPointRect());
+    if (!parentClipRect.intersects(thisBoundingRect)) {
+        // Item is moved outside the clip parent's shape,
+        // i.e. it is fully clipped and the clip path is empty.
+        if (flags & QGraphicsItem::ItemClipsChildrenToShape)
+            setEmptyCachedClipPathRecursively();
+        else
+            setEmptyCachedClipPathRecursively(thisToParentTransform.inverted().mapRect(parentClipRect));
+    } else {
+        // Item is partially inside the clip parent's shape,
+        // i.e. the cached clip path must be invalidated.
+        invalidateCachedClipPathRecursively(false, thisToParentTransform.inverted().mapRect(parentClipRect));
+    }
+        parent->d_ptr->subFocusItem = q_ptr;
+        parent->d_ptr->subFocusItemChange();
+    } while (!parent->isPanel() && (parent = parent->d_ptr->parent) && (visible || !parent->d_ptr->visible));
+    if (scene && !scene->isActive())
+        scene->d_func()->lastFocusItem = subFocusItem;
+}
+/*!
+    \internal
+*/
+void QGraphicsItemPrivate::clearSubFocus(QGraphicsItem *rootItem)
+{
+    // Reset sub focus chain.
+    QGraphicsItem *parent = rootItem ? rootItem : q_ptr;
+    do {
+        if (parent->d_ptr->subFocusItem != q_ptr)
+            break;
+        parent->d_ptr->subFocusItem = 0;
+        parent->d_ptr->subFocusItemChange();
+    } while (!parent->isPanel() && (parent = parent->d_ptr->parent));
+}
+/*!
+    \internal
+    Sets the focusProxy pointer to 0 for all items that have this item as their
+    focusProxy. ### Qt 5: Use QPointer instead.
+*/
+void QGraphicsItemPrivate::resetFocusProxy()
+{
+    for (int i = 0; i < focusProxyRefs.size(); ++i)
+        *focusProxyRefs.at(i) = 0;
+    focusProxyRefs.clear();
+}
+/*!
+    \internal
+    Subclasses can reimplement this function to be notified when subFocusItem
+    changes.
+*/
+void QGraphicsItemPrivate::subFocusItemChange()
+{
+}
+/*!
+    \internal
+    Subclasses can reimplement this function to be notified when its
+    siblingIndex order is changed.
+*/
+void QGraphicsItemPrivate::siblingOrderChange()
+{
+}
 …
         return;
+    // Make sure we notify effects about invalidated source.
+#ifndef QT_NO_GRAPHICSEFFECT
+    d_ptr->invalidateGraphicsEffectsRecursively();
+#endif //QT_NO_GRAPHICSEFFECT
     if (CacheMode(d_ptr->cacheMode) != NoCache) {
+        // Invalidate cache.
         QGraphicsItemCache *cache = d_ptr->extraItemCache();
+        if (d_ptr->discardUpdateRequest(/* ignoreVisibleBit = */ false,
+                                        /* ignoreClipping = */ false,
+                                        /* ignoreDirtyBit = */ true)) {
+            return;
+        }
+        // Invalidate cache.
+        if (rect.isNull()) {
+            cache->allExposed = true;
+            cache->exposed.clear();
+        } else {
+            cache->exposed.append(rect);
+        if (!cache->allExposed) {
+            if (rect.isNull()) {
+                cache->allExposed = true;
+                cache->exposed.clear();
+            } else {
+                cache->exposed.append(rect);
+            }
+        }
         // Only invalidate cache; item is already dirty.
         if (d_ptr->dirty)
+        if (d_ptr->fullUpdatePending)
             return;
+    } else if (d_ptr->discardUpdateRequest()) {
+    }
+    if (d_ptr->discardUpdateRequest())
         return;
+    }
+    // Effectively the same as updateHelper(rect);
+    if (rect.isNull())
+        d_ptr->dirty = 1;
+    d_ptr->scene->itemUpdated(this, rect);
+}
+    if (d_ptr->scene)
+        d_ptr->scene->d_func()->markDirty(this, rect);
+}
 /*!
 …
         return;
     if (d->cacheMode != NoCache) {
+        // ### 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);
+        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);
+        }
         return;
+    }
 …
         static const QLineF right(0, 0, 1, 0);
+        QTransform deviceTr;
+        if (d->itemIsUntransformable()) {
+            deviceTr = deviceTransform(view->viewportTransform());
+        } else {
+            deviceTr = sceneTransform() * view->viewportTransform();
+        }
+        QTransform deviceTr = deviceTransform(view->viewportTransform());
         QRect deviceScrollRect = deviceTr.mapRect(scrollRect).toRect();
         QLineF v1 = deviceTr.map(right);
 …
 QPointF QGraphicsItem::mapToParent(const QPointF &point) const
+{
+    return d_ptr->pos + (d_ptr->hasTransform ? transform().map(point) : point);
+    // COMBINE
+    if (!d_ptr->transformData)
+        return point + d_ptr->pos;
+    return d_ptr->transformToParent().map(point);
+}
 …
 QPointF QGraphicsItem::mapToScene(const QPointF &point) const
+{
+    return sceneTransform().map(point);
+    if (d_ptr->hasTranslateOnlySceneTransform())
+        return QPointF(point.x() + d_ptr->sceneTransform.dx(), point.y() + d_ptr->sceneTransform.dy());
+    return d_ptr->sceneTransform.map(point);
+}
 …
 QPolygonF QGraphicsItem::mapToParent(const QRectF &rect) const
+{
+    QPolygonF p = !d_ptr->hasTransform ? rect : transform().map(rect);
+    p.translate(d_ptr->pos);
+    return p;
+    // COMBINE
+    if (!d_ptr->transformData)
+        return rect.translated(d_ptr->pos);
+    return d_ptr->transformToParent().map(rect);
+}
 …
 QPolygonF QGraphicsItem::mapToScene(const QRectF &rect) const
+{
+    return sceneTransform().map(rect);
+    if (d_ptr->hasTranslateOnlySceneTransform())
+        return rect.translated(d_ptr->sceneTransform.dx(), d_ptr->sceneTransform.dy());
+    return d_ptr->sceneTransform.map(rect);
+}
 …
 QRectF QGraphicsItem::mapRectToParent(const QRectF &rect) const
+{
+    QRectF r = !d_ptr->hasTransform ? rect : transform().mapRect(rect);
+    return r.translated(d_ptr->pos);
+    // COMBINE
+    if (!d_ptr->transformData)
+        return rect.translated(d_ptr->pos);
+    return d_ptr->transformToParent().mapRect(rect);
+}
 …
 QRectF QGraphicsItem::mapRectToScene(const QRectF &rect) const
+{
+    return sceneTransform().mapRect(rect);
+    if (d_ptr->hasTranslateOnlySceneTransform())
+        return rect.translated(d_ptr->sceneTransform.dx(), d_ptr->sceneTransform.dy());
+    return d_ptr->sceneTransform.mapRect(rect);
+}
 …
 QRectF QGraphicsItem::mapRectFromParent(const QRectF &rect) const
+{
+    QRectF r = rect.translated(-d_ptr->pos);
+    return d_ptr->hasTransform ? transform().inverted().mapRect(r) : r;
+    // COMBINE
+    if (!d_ptr->transformData)
+        return rect.translated(-d_ptr->pos);
+    return d_ptr->transformToParent().inverted().mapRect(rect);
+}
 …
 QRectF QGraphicsItem::mapRectFromScene(const QRectF &rect) const
+{
+    return sceneTransform().inverted().mapRect(rect);
+    if (d_ptr->hasTranslateOnlySceneTransform())
+        return rect.translated(-d_ptr->sceneTransform.dx(), -d_ptr->sceneTransform.dy());
+    return d_ptr->sceneTransform.inverted().mapRect(rect);
+}
 …
 QPolygonF QGraphicsItem::mapToParent(const QPolygonF &polygon) const
+{
+    QPolygonF p = !d_ptr->hasTransform ? polygon : transform().map(polygon);
+    p.translate(d_ptr->pos);
+    return p;
+    // COMBINE
+    if (!d_ptr->transformData)
+        return polygon.translated(d_ptr->pos);
+    return d_ptr->transformToParent().map(polygon);
+}
 …
 QPolygonF QGraphicsItem::mapToScene(const QPolygonF &polygon) const
+{
+    return sceneTransform().map(polygon);
+    if (d_ptr->hasTranslateOnlySceneTransform())
+        return polygon.translated(d_ptr->sceneTransform.dx(), d_ptr->sceneTransform.dy());
+    return d_ptr->sceneTransform.map(polygon);
+}
 …
 QPainterPath QGraphicsItem::mapToParent(const QPainterPath &path) const
+{
     QTransform x = QTransform::fromTranslate(d_ptr->pos.x(), d_ptr->pos.y());
     if (d_ptr->hasTransform)
         x = transform() * x;
     return x.map(path);
+    // COMBINE
+    if (!d_ptr->transformData)
+        return path.translated(d_ptr->pos);
+    return d_ptr->transformToParent().map(path);
+}
 …
 QPainterPath QGraphicsItem::mapToScene(const QPainterPath &path) const
+{
+    return sceneTransform().map(path);
+    if (d_ptr->hasTranslateOnlySceneTransform())
+        return path.translated(d_ptr->sceneTransform.dx(), d_ptr->sceneTransform.dy());
+    return d_ptr->sceneTransform.map(path);
+}
 …
 QPointF QGraphicsItem::mapFromParent(const QPointF &point) const
+{
+    if (d_ptr->hasTransform)
+        return transform().inverted().map(point - d_ptr->pos);
+    // COMBINE
+    if (d_ptr->transformData)
+        return d_ptr->transformToParent().inverted().map(point);
     return point - d_ptr->pos;
+}
 …
 QPointF QGraphicsItem::mapFromScene(const QPointF &point) const
+{
+    return sceneTransform().inverted().map(point);
+    if (d_ptr->hasTranslateOnlySceneTransform())
+        return QPointF(point.x() - d_ptr->sceneTransform.dx(), point.y() - d_ptr->sceneTransform.dy());
+    return d_ptr->sceneTransform.inverted().map(point);
+}
 …
 QPolygonF QGraphicsItem::mapFromParent(const QRectF &rect) const
+{
+    QRectF r = rect.translated(-d_ptr->pos);
+    return d_ptr->hasTransform ? transform().inverted().map(r) : r;
+    // COMBINE
+    if (!d_ptr->transformData)
+        return rect.translated(-d_ptr->pos);
+    return d_ptr->transformToParent().inverted().map(rect);
+}
 …
 QPolygonF QGraphicsItem::mapFromScene(const QRectF &rect) const
+{
+    return sceneTransform().inverted().map(rect);
+    if (d_ptr->hasTranslateOnlySceneTransform())
+        return rect.translated(-d_ptr->sceneTransform.dx(), -d_ptr->sceneTransform.dy());
+    return d_ptr->sceneTransform.inverted().map(rect);
+}
 …
 QPolygonF QGraphicsItem::mapFromParent(const QPolygonF &polygon) const
+{
+    QPolygonF p = polygon;
+    p.translate(-d_ptr->pos);
+    return d_ptr->hasTransform ? transform().inverted().map(p) : p;
+    // COMBINE
+    if (!d_ptr->transformData)
+        return polygon.translated(-d_ptr->pos);
+    return d_ptr->transformToParent().inverted().map(polygon);
+}
 …
 QPolygonF QGraphicsItem::mapFromScene(const QPolygonF &polygon) const
+{
+    return sceneTransform().inverted().map(polygon);
+    if (d_ptr->hasTranslateOnlySceneTransform())
+        return polygon.translated(-d_ptr->sceneTransform.dx(), -d_ptr->sceneTransform.dy());
+    return d_ptr->sceneTransform.inverted().map(polygon);
+}
 …
 QPainterPath QGraphicsItem::mapFromParent(const QPainterPath &path) const
+{
+    if (d_ptr->parent)
+        return d_ptr->parent->itemTransform(this).map(path);
+    return mapFromScene(path);
+    // COMBINE
+    if (!d_ptr->transformData)
+            return path.translated(-d_ptr->pos);
+    return d_ptr->transformToParent().inverted().map(path);
+}
 …
 QPainterPath QGraphicsItem::mapFromScene(const QPainterPath &path) const
+{
+    return sceneTransform().inverted().map(path);
+    if (d_ptr->hasTranslateOnlySceneTransform())
+        return path.translated(-d_ptr->sceneTransform.dx(), -d_ptr->sceneTransform.dy());
+    return d_ptr->sceneTransform.inverted().map(path);
+}
 …
+{
     if (!child || child == this)
+        return false;
+    if (child->d_ptr->depth() < d_ptr->depth())
         return false;
     const QGraphicsItem *ancestor = child;
 …
     const QGraphicsItem *thisw = this;
     const QGraphicsItem *otherw = other;
     int thisDepth = d_ptr->depth;
     int otherDepth = other->d_ptr->depth;
+    int thisDepth = d_ptr->depth();
+    int otherDepth = other->d_ptr->depth();
     while (thisDepth > otherDepth) {
         thisw = thisw->d_ptr->parent;
 …
         inputMethodEvent(static_cast<QInputMethodEvent *>(event));
         break;
+    case QEvent::WindowActivate:
+    case QEvent::WindowDeactivate:
+        // Propagate panel activation.
+        if (d_ptr->scene) {
+            for (int i = 0; i < d_ptr->children.size(); ++i) {
+                QGraphicsItem *child = d_ptr->children.at(i);
+                if (child->isVisible() && !child->isPanel()) {
+                    if (!(child->d_ptr->ancestorFlags & QGraphicsItemPrivate::AncestorHandlesChildEvents))
+                        d_ptr->scene->sendEvent(child, event);
+                }
+            }
+        }
+        break;
     default:
         return false;
 …
     ensureVisible().
     \sa focusOutEvent(), sceneEvent()
+    \sa focusOutEvent(), sceneEvent(), setFocus()
 */
 void QGraphicsItem::focusInEvent(QFocusEvent *event)
+{
     Q_UNUSED(event);
+    update();
+}
 …
     focus out events for this item. The default implementation does nothing.
     \sa focusInEvent(), sceneEvent()
+    \sa focusInEvent(), sceneEvent(), setFocus()
 */
 void QGraphicsItem::focusOutEvent(QFocusEvent *event)
+{
     Q_UNUSED(event);
+    update();
+}
 …
+{
     Q_UNUSED(event);
     d_ptr->updateHelper();
+    update();
+}
 …
+{
     Q_UNUSED(event);
     d_ptr->updateHelper();
+    update();
+}
 …
         // Qt::Popup closes when you click outside.
         QGraphicsWidget *w = static_cast<QGraphicsWidget *>(this);
         if (w->windowFlags() & Qt::Popup) {
+        if ((w->windowFlags() & Qt::Popup) == Qt::Popup) {
             event->accept();
             if (!w->rect().contains(event->pos()))
 …
     property is queried.
     \sa inputMethodEvent()
+    \sa inputMethodEvent(), QInputMethodEvent, QInputContext
 */
 QVariant QGraphicsItem::inputMethodQuery(Qt::InputMethodQuery query) const
 …
 /*!
+    Returns the current input method hints of this item.
+    Input method hints are only relevant for input items.
+    The hints are used by the input method to indicate how it should operate.
+    For example, if the Qt::ImhNumbersOnly flag is set, the input method may change
+    its visual components to reflect that only numbers can be entered.
+    The effect may vary between input method implementations.
+    \since 4.6
+    \sa setInputMethodHints(), inputMethodQuery(), QInputContext
+*/
+Qt::InputMethodHints QGraphicsItem::inputMethodHints() const
+{
+    Q_D(const QGraphicsItem);
+    return d->imHints;
+}
+/*!
+    Sets the current input method hints of this item to \a hints.
+    \since 4.6
+    \sa inputMethodHints(), inputMethodQuery(), QInputContext
+*/
+void QGraphicsItem::setInputMethodHints(Qt::InputMethodHints hints)
+{
+    Q_D(QGraphicsItem);
+    d->imHints = hints;
+}
+/*!
     This virtual function is called by QGraphicsItem to notify custom items
     that some part of the item's state changes. By reimplementing this
 …
+    }
     if (d_ptr->scene)
+        d_ptr->scene->d_func()->addToIndex(this);
+    d_ptr->updateHelper();
+        d_ptr->scene->d_func()->index->addItem(this);
+}
 …
         return;
+    }
-    d_ptr->updateHelper();
     if (d_ptr->scene)
         d_ptr->scene->d_func()->removeFromIndex(this);
+        d_ptr->scene->d_func()->index->removeItem(this);
+}
 …
 void QGraphicsItem::prepareGeometryChange()
+{
+    if (d_ptr->inDestructor)
+        return;
     if (d_ptr->scene) {
+        d_ptr->updateHelper(QRectF(), false, /*maybeDirtyClipPath=*/!d_ptr->inSetPosHelper);
+        d_ptr->scene->d_func()->dirtyGrowingItemsBoundingRect = true;
+        d_ptr->geometryChanged = 1;
+        d_ptr->paintedViewBoundingRectsNeedRepaint = 1;
+        d_ptr->notifyBoundingRectChanged = !d_ptr->inSetPosHelper;
         QGraphicsScenePrivate *scenePrivate = d_ptr->scene->d_func();
+        scenePrivate->removeFromIndex(this);
+    }
+    if (d_ptr->inSetPosHelper)
+        return;
+    if (d_ptr->flags & ItemClipsChildrenToShape)
+        d_ptr->invalidateCachedClipPathRecursively();
+    else
+        d_ptr->invalidateCachedClipPath();
+        scenePrivate->index->prepareBoundingRectChange(this);
+        scenePrivate->markDirty(this, QRectF(), /*invalidateChildren=*/true);
+        // For compatibility reasons, we have to update the item's old geometry
+        // if someone is connected to the changed signal or the scene has no views.
+        // Note that this has to be done *after* markDirty to ensure that
+        // _q_processDirtyItems is called before _q_emitUpdated.
+        if (scenePrivate->isSignalConnected(scenePrivate->changedSignalIndex)
+            || scenePrivate->views.isEmpty()) {
+            if (d_ptr->hasTranslateOnlySceneTransform()) {
+                d_ptr->scene->update(boundingRect().translated(d_ptr->sceneTransform.dx(),
+                                                               d_ptr->sceneTransform.dy()));
+            } else {
+                d_ptr->scene->update(d_ptr->sceneTransform.mapRect(boundingRect()));
+            }
+        }
+    }
+    QGraphicsItem *parent = this;
+    while ((parent = parent->d_ptr->parent)) {
+        QGraphicsItemPrivate *parentp = parent->d_ptr.data();
+        parentp->dirtyChildrenBoundingRect = 1;
+        // ### Only do this if the parent's effect applies to the entire subtree.
+        parentp->notifyBoundingRectChanged = 1;
+#ifndef QT_NO_GRAPHICSEFFECT
+        if (parentp->scene && parentp->graphicsEffect) {
+            parentp->notifyInvalidated = 1;
+            static_cast<QGraphicsItemEffectSourcePrivate *>(parentp->graphicsEffect->d_func()->source->d_func())->invalidateCache();
+        }
+#endif
+    }
+}
 …
+{
     const QRectF murect = painter->transform().mapRect(QRectF(0, 0, 1, 1));
     if (qFuzzyCompare(qMax(murect.width(), murect.height()) + 1, 1))
+    if (qFuzzyIsNull(qMax(murect.width(), murect.height())))
         return;
 …
 /*!
+    \class QGraphicsObject
+    \brief The QGraphicsObject class provides a base class for all graphics items that
+    require signals, slots and properties.
+    \since 4.6
+    \ingroup graphicsview-api
+    The class extends a QGraphicsItem with QObject's signal/slot and property mechanisms.
+    It maps many of QGraphicsItem's basic setters and getters to properties and adds notification
+    signals for many of them.
+    \section1 Parents and Children
+    Each graphics object can be constructed with a parent item. This ensures that the
+    item will be destroyed when its parent item is destroyed. Although QGraphicsObject
+    inherits from both QObject and QGraphicsItem, you should use the functions provided
+    by QGraphicsItem, \e not QObject, to manage the relationships between parent and
+    child items.
+    The relationships between items can be explored using the parentItem() and childItems()
+    functions. In the hierarchy of items in a scene, the parentObject() and parentWidget()
+    functions are the equivalent of the QWidget::parent() and QWidget::parentWidget()
+    functions for QWidget subclasses.
+    \sa QGraphicsWidget
+*/
+/*!
+    Constructs a QGraphicsObject with \a parent.
+*/
+QGraphicsObject::QGraphicsObject(QGraphicsItem *parent)
+        : QGraphicsItem(parent)
+{
+    QGraphicsItem::d_ptr->isObject = true;
+}
+/*!
+  \internal
+*/
+QGraphicsObject::QGraphicsObject(QGraphicsItemPrivate &dd, QGraphicsItem *parent, QGraphicsScene *scene)
+    : QGraphicsItem(dd, parent, scene)
+{
+    QGraphicsItem::d_ptr->isObject = true;
+}
+/*!
+    Subscribes the graphics object to the given \a gesture with specific \a flags.
+    \sa ungrabGesture(), QGestureEvent
+*/
+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
+}
+/*!
+    Unsubscribes the graphics object from the given \a gesture.
+    \sa grabGesture(), QGestureEvent
+*/
+void QGraphicsObject::ungrabGesture(Qt::GestureType gesture)
+{
+    QGraphicsItemPrivate * const d = QGraphicsItem::d_func();
+    if (d->gestureContext.remove(gesture)) {
+        QGestureManager *manager = QGestureManager::instance();
+        manager->cleanupCachedGestures(this, gesture);
+    }
+}
+/*!
+  \property QGraphicsObject::parent
+  \brief the parent of the item
+  \note The item's parent is set independently of the parent object returned
+  by QObject::parent().
+  \sa QGraphicsItem::setParentItem(), QGraphicsItem::parentObject()
+*/
+/*!
+  \property QGraphicsObject::opacity
+  \brief the opacity of the item
+  \sa QGraphicsItem::setOpacity(), QGraphicsItem::opacity()
+*/
+/*!
+  \fn QGraphicsObject::opacityChanged()
+  This signal gets emitted whenever the opacity of the item changes
+  \sa QGraphicsItem::opacity()
+*/
+/*!
+  \fn QGraphicsObject::parentChanged()
+  This signal gets emitted whenever the parent of the item changes
+*/
+/*!
+  \property QGraphicsObject::pos
+  \brief the position of the item
+  Describes the items position.
+  \sa QGraphicsItem::setPos(), QGraphicsItem::pos()
+*/
+/*!
+  \property QGraphicsObject::x
+  \brief the x position of the item
+  Describes the items x position.
+  \sa QGraphicsItem::setX(), setPos(), xChanged()
+*/
+/*!
+  \fn QGraphicsObject::xChanged()
+  This signal gets emitted whenever the x position of the item changes
+  \sa pos()
+*/
+/*!
+  \property QGraphicsObject::y
+  \brief the y position of the item
+  Describes the items y position.
+  \sa QGraphicsItem::setY(), setPos(), yChanged()
+*/
+/*!
+  \fn QGraphicsObject::yChanged()
+  This signal gets emitted whenever the y position of the item changes.
+  \sa pos()
+*/
+/*!
+  \property QGraphicsObject::z
+  \brief the z value of the item
+  Describes the items z value.
+  \sa QGraphicsItem::setZValue(), zValue(), zChanged()
+*/
+/*!
+  \fn QGraphicsObject::zChanged()
+  This signal gets emitted whenever the z value of the item changes.
+  \sa pos()
+*/
+/*!
+  \property QGraphicsObject::rotation
+  This property holds the rotation of the item in degrees.
+  This specifies how many degrees to rotate the item around its transformOrigin.
+  The default rotation is 0 degrees (i.e. not rotated at all).
+*/
+/*!
+  \fn QGraphicsObject::rotationChanged()
+  This signal gets emitted whenever the roation of the item changes.
+*/
+/*!
+  \property QGraphicsObject::scale
+  This property holds the scale of the item.
+  A scale of less than 1 means the item will be displayed smaller than
+  normal, and a scale of greater than 1 means the item will be
+  displayed larger than normal.  A negative scale means the item will
+  be mirrored.
+  By default, items are displayed at a scale of 1 (i.e. at their
+  normal size).
+  Scaling is from the item's transformOrigin.
+*/
+/*!
+  \fn void QGraphicsObject::scaleChanged()
+  This signal is emitted when the scale of the item changes.
+*/
+/*!
+  \property QGraphicsObject::enabled
+  \brief whether the item is enabled or not
+  This property is declared in QGraphicsItem.
+  By default, this property is true.
+  \sa QGraphicsItem::isEnabled(), QGraphicsItem::setEnabled()
+  \sa QGraphicsObject::enabledChanged()
+*/
+/*!
+  \fn void QGraphicsObject::enabledChanged()
+  This signal gets emitted whenever the item get's enabled or disabled.
+  \sa isEnabled()
+*/
+/*!
+  \property QGraphicsObject::visible
+  \brief whether the item is visible or not
+  This property is declared in QGraphicsItem.
+  By default, this property is true.
+  \sa QGraphicsItem::isVisible(), QGraphicsItem::setVisible(), visibleChanged()
+*/
+/*!
+  \fn QGraphicsObject::visibleChanged()
+  This signal gets emitted whenever the visibility of the item changes
+  \sa visible
+*/
+/*!
+  \fn const QObjectList &QGraphicsObject::children() const
+  \internal
+  This function returns the same value as QObject::children(). It's
+  provided to differentiate between the obsolete member
+  QGraphicsItem::children() and QObject::children(). QGraphicsItem now
+  provides childItems() instead.
+*/
+/*!
+  \property QGraphicsObject::transformOriginPoint
+  \brief the transformation origin
+  This property sets a specific point in the items coordiante system as the
+  origin for scale and rotation.
+  \sa scale, rotation, QGraphicsItem::transformOriginPoint()
+*/
+/*!
     \class QAbstractGraphicsShapeItem
     \brief The QAbstractGraphicsShapeItem class provides a common base for
     all path items.
     \since 4.2
     \ingroup multimedia
+    \ingroup graphicsview-api
     This class does not fully implement an item by itself; in particular, it
 …
     can add to a QGraphicsScene.
     \since 4.2
-    \ingroup multimedia
     \ingroup graphicsview-api
 …
     can add to a QGraphicsScene.
     \since 4.2
-    \ingroup multimedia
     \ingroup graphicsview-api
 …
     can add to a QGraphicsScene.
     \since 4.2
-    \ingroup multimedia
     \ingroup graphicsview-api
 …
     can add to a QGraphicsScene.
     \since 4.2
-    \ingroup multimedia
     \ingroup graphicsview-api
 …
     QGraphicsScene.
     \since 4.2
-    \ingroup multimedia
     \ingroup graphicsview-api
 …
     a QGraphicsScene.
     \since 4.2
-    \ingroup multimedia
     \ingroup graphicsview-api
 …
     Q_D(QGraphicsPixmapItem);
     if (mode != d->transformationMode) {
-        d_ptr->updateHelper();
         d->transformationMode = mode;
         update();
 …
+{
     Q_D(const QGraphicsPixmapItem);
-    qreal pw = 1.0;
     if (d->pixmap.isNull())
         return QRectF();
+    return QRectF(d->offset, d->pixmap.size()).adjusted(-pw/2, -pw/2, pw/2, pw/2);
+    if (d->flags & ItemIsSelectable) {
+        qreal pw = 1.0;
+        return QRectF(d->offset, d->pixmap.size()).adjusted(-pw/2, -pw/2, pw/2, pw/2);
+    } else {
+        return QRectF(d->offset, d->pixmap.size());
+    }
+}
 …
                            (d->transformationMode == Qt::SmoothTransformation));
+    QRectF exposed = option->exposedRect.adjusted(-1, -1, 1, 1);
+    exposed &= QRectF(d->offset.x(), d->offset.y(), d->pixmap.width(), d->pixmap.height());
+    painter->drawPixmap(exposed, d->pixmap, exposed.translated(-d->offset));
+    painter->drawPixmap(d->offset, d->pixmap);
     if (option->state & QStyle::State_Selected)
 …
     a QGraphicsScene to display formatted text.
     \since 4.2
-    \ingroup multimedia
     \ingroup graphicsview-api
 …
 public:
     QGraphicsTextItemPrivate()
         : control(0), pageNumber(0), useDefaultImpl(false), tabChangesFocus(false)
+        : control(0), pageNumber(0), useDefaultImpl(false), tabChangesFocus(false), clickCausedFocus(0)
     { }
 …
     bool tabChangesFocus;
+    uint clickCausedFocus : 1;
     QGraphicsTextItem *qq;
 };
 /*!
 …
 #endif
+    )
     : QGraphicsItem(parent, scene), dd(new QGraphicsTextItemPrivate)
+    : QGraphicsObject(*new QGraphicsItemPrivate, parent, scene), dd(new QGraphicsTextItemPrivate)
+{
     dd->qq = this;
 …
     setAcceptDrops(true);
     setAcceptHoverEvents(true);
+    setFlags(ItemUsesExtendedStyleOption);
+}
 …
 #endif
+    )
     : QGraphicsItem(parent, scene), dd(new QGraphicsTextItemPrivate)
+    : QGraphicsObject(*new QGraphicsItemPrivate, parent, scene), dd(new QGraphicsTextItemPrivate)
+{
     dd->qq = this;
     setAcceptDrops(true);
     setAcceptHoverEvents(true);
+    setFlag(ItemUsesExtendedStyleOption);
+}
 …
     QTextControl *c = dd->textControl();
     QPalette pal = c->palette();
+    QColor old = pal.color(QPalette::Text);
     pal.setColor(QPalette::Text, col);
     c->setPalette(pal);
+    if (old != col)
+        update();
+}
 …
+        }
+    }
+    return QGraphicsItem::sceneEvent(event);
+    bool result = QGraphicsItem::sceneEvent(event);
+    // Ensure input context is updated.
+    switch (event->type()) {
+    case QEvent::ContextMenu:
+    case QEvent::FocusIn:
+    case QEvent::FocusOut:
+    case QEvent::GraphicsSceneDragEnter:
+    case QEvent::GraphicsSceneDragLeave:
+    case QEvent::GraphicsSceneDragMove:
+    case QEvent::GraphicsSceneDrop:
+    case QEvent::GraphicsSceneHoverEnter:
+    case QEvent::GraphicsSceneHoverLeave:
+    case QEvent::GraphicsSceneHoverMove:
+    case QEvent::GraphicsSceneMouseDoubleClick:
+    case QEvent::GraphicsSceneMousePress:
+    case QEvent::GraphicsSceneMouseMove:
+    case QEvent::GraphicsSceneMouseRelease:
+    case QEvent::KeyPress:
+    case QEvent::KeyRelease:
+        // Reset the focus widget's input context, regardless
+        // of how this item gained or lost focus.
+        if (QWidget *fw = qApp->focusWidget()) {
+#ifndef QT_NO_IM
+            if (QInputContext *qic = fw->inputContext()) {
+                if (event->type() == QEvent::FocusIn || event->type() == QEvent::FocusOut)
+                    qic->reset();
+                else
+                    qic->update();
+            }
+#endif //QT_NO_IM
+        }
+        break;
+    default:
+        break;
+    }
+    return result;
+}
 …
+{
     if ((QGraphicsItem::d_ptr->flags & (ItemIsSelectable | ItemIsMovable))
         && (event->buttons() & Qt::LeftButton) && dd->_q_mouseOnEdge(event)) {
         // User left-pressed on edge of selectable/movable item, use
         // base impl.
         dd->useDefaultImpl = true;
+        && (event->buttons() & Qt::LeftButton) && dd->_q_mouseOnEdge(event)) {
+        // User left-pressed on edge of selectable/movable item, use
+        // base impl.
+        dd->useDefaultImpl = true;
     } else if (event->buttons() == event->button()
                && dd->control->textInteractionFlags() == Qt::NoTextInteraction) {
         // User pressed first button on non-interactive item.
         dd->useDefaultImpl = true;
+               && dd->control->textInteractionFlags() == Qt::NoTextInteraction) {
+        // User pressed first button on non-interactive item.
+        dd->useDefaultImpl = true;
+    }
     if (dd->useDefaultImpl) {
         QGraphicsItem::mousePressEvent(event);
         if (!event->isAccepted())
             dd->useDefaultImpl = false;
+        if (!event->isAccepted())
+            dd->useDefaultImpl = false;
         return;
+    }
     dd->sendControlEvent(event);
+}
 …
         return;
+    }
     dd->sendControlEvent(event);
+}
 …
     if (dd->useDefaultImpl) {
         QGraphicsItem::mouseReleaseEvent(event);
         if (dd->control->textInteractionFlags() == Qt::NoTextInteraction
             && !event->buttons()) {
             // User released last button on non-interactive item.
+        if (dd->control->textInteractionFlags() == Qt::NoTextInteraction
+            && !event->buttons()) {
+            // User released last button on non-interactive item.
             dd->useDefaultImpl = false;
         } else  if ((event->buttons() & Qt::LeftButton) == 0) {
             // User released the left button on an interactive item.
+        } else  if ((event->buttons() & Qt::LeftButton) == 0) {
+            // User released the left button on an interactive item.
             dd->useDefaultImpl = false;
+        }
+        }
         return;
+    }
+    QWidget *widget = event->widget();
+    if (widget && (dd->control->textInteractionFlags() & Qt::TextEditable) && boundingRect().contains(event->pos())) {
+        qt_widget_private(widget)->handleSoftwareInputPanel(event->button(), dd->clickCausedFocus);
+    }
+    dd->clickCausedFocus = 0;
     dd->sendControlEvent(event);
+}
 …
+{
     dd->sendControlEvent(event);
+    if (event->reason() == Qt::MouseFocusReason) {
+        dd->clickCausedFocus = 1;
+    }
     update();
+}
 …
     input.
     The default for a QGraphicsTextItem is Qt::NoTextInteraction. Setting a
     value different to Qt::NoTextInteraction will also set the ItemIsFocusable
     QGraphicsItem flag.
+    The default for a QGraphicsTextItem is Qt::NoTextInteraction. This function
+    also affects the ItemIsFocusable QGraphicsItem flag by setting it if \a flags
+    is different from Qt::NoTextInteraction and clearing it otherwise.
     By default, the text is read-only. To transform the item into an editor,
 …
+{
     if (flags == Qt::NoTextInteraction)
         setFlags(this->flags() & ~QGraphicsItem::ItemIsFocusable);
+        setFlags(this->flags() & ~(QGraphicsItem::ItemIsFocusable | QGraphicsItem::ItemAcceptsInputMethod));
     else
+        setFlags(this->flags() | QGraphicsItem::ItemIsFocusable);
+        setFlags(this->flags() | QGraphicsItem::ItemIsFocusable | QGraphicsItem::ItemAcceptsInputMethod);
     dd->textControl()->setTextInteractionFlags(flags);
+}
 …
     that you can add to a QGraphicsScene.
     \since 4.2
-    \ingroup multimedia
     \ingroup graphicsview-api
 …
     one.
     \since 4.2
-    \ingroup multimedia
     \ingroup graphicsview-api
 …
     The boundingRect() function of QGraphicsItemGroup returns the
+    bounding rectangle of all items in the item group. In addition,
+    item groups have handlesChildEvents() enabled by default, so all
+    events sent to a member of the group go to the item group (i.e.,
+    selecting one item in a group will select them all).
+    QGraphicsItemGroup ignores the ItemIgnoresTransformations flag on its
+    children (i.e., with respect to the geometry of the group item, the
+    children are treated as if they were transformable).
+    bounding rectangle of all items in the item group.
+    QGraphicsItemGroup ignores the ItemIgnoresTransformations flag on
+    its children (i.e., with respect to the geometry of the group
+    item, the children are treated as if they were transformable).
     There are two ways to construct an item group. The easiest and
 …
+    }
+    QTransform oldSceneMatrix = item->sceneTransform();
+    // COMBINE
+    bool ok;
+    QTransform itemTransform = item->itemTransform(this, &ok);
+    if (!ok) {
+        qWarning("QGraphicsItemGroup::addToGroup: could not find a valid transformation from item to group coordinates");
+        return;
+    }
+    QTransform newItemTransform(itemTransform);
     item->setPos(mapFromItem(item, 0, 0));
     item->setParentItem(this);
+    QTransform newItemTransform(oldSceneMatrix);
     newItemTransform *= sceneTransform().inverted();
+    // removing position from translation component of the new transform
     if (!item->pos().isNull())
         newItemTransform *= QTransform::fromTranslate(-item->x(), -item->y());
+    // removing additional transformations properties applied with itemTransform()
+    QPointF origin = item->transformOriginPoint();
+    QMatrix4x4 m;
+    QList<QGraphicsTransform*> transformList = item->transformations();
+    for (int i = 0; i < transformList.size(); ++i)
+        transformList.at(i)->applyTo(&m);
+    newItemTransform *= m.toTransform().inverted();
+    newItemTransform.translate(origin.x(), origin.y());
+    newItemTransform.rotate(-item->rotation());
+    newItemTransform.scale(1/item->scale(), 1/item->scale());
+    newItemTransform.translate(-origin.x(), -origin.y());
+    // ### Expensive, we could maybe use dirtySceneTransform bit for optimization
     item->setTransform(newItemTransform);
     item->d_func()->setIsMemberOfGroup(true);
     prepareGeometryChange();
-    QTransform itemTransform(item->transform());
-    if (!item->pos().isNull())
-        itemTransform *= QTransform::fromTranslate(item->x(), item->y());
     d->itemsBoundingRect |= itemTransform.mapRect(item->boundingRect() | item->childrenBoundingRect());
     update();
 …
     QGraphicsItem *newParent = d_ptr->parent;
+    // COMBINE
+    bool ok;
+    QTransform itemTransform;
+    if (newParent)
+        itemTransform = item->itemTransform(newParent, &ok);
+    else
+        itemTransform = item->sceneTransform();
     QPointF oldPos = item->mapToItem(newParent, 0, 0);
     item->setParentItem(newParent);
-    // ### This function should remap the item's matrix to keep the item's
-    // transformation unchanged relative to the scene.
     item->setPos(oldPos);
+    // removing position from translation component of the new transform
+    if (!item->pos().isNull())
+        itemTransform *= QTransform::fromTranslate(-item->x(), -item->y());
+    // removing additional transformations properties applied
+    // with itemTransform() or sceneTransform()
+    QPointF origin = item->transformOriginPoint();
+    QMatrix4x4 m;
+    QList<QGraphicsTransform*> transformList = item->transformations();
+    for (int i = 0; i < transformList.size(); ++i)
+        transformList.at(i)->applyTo(&m);
+    itemTransform *= m.toTransform().inverted();
+    itemTransform.translate(origin.x(), origin.y());
+    itemTransform.rotate(-item->rotation());
+    itemTransform.scale(1 / item->scale(), 1 / item->scale());
+    itemTransform.translate(-origin.x(), -origin.y());
+    // ### Expensive, we could maybe use dirtySceneTransform bit for optimization
+    item->setTransform(itemTransform);
     item->d_func()->setIsMemberOfGroup(item->group() != 0);
 …
+}
+#ifndef QT_NO_GRAPHICSEFFECT
+QRectF QGraphicsItemEffectSourcePrivate::boundingRect(Qt::CoordinateSystem system) const
+{
+    const bool deviceCoordinates = (system == Qt::DeviceCoordinates);
+    if (!info && deviceCoordinates) {
+        // Device coordinates without info not yet supported.
+        qWarning("QGraphicsEffectSource::boundingRect: Not yet implemented, lacking device context");
+        return QRectF();
+    }
+    QRectF rect = item->boundingRect();
+    if (!item->d_ptr->children.isEmpty())
+        rect |= item->childrenBoundingRect();
+    if (deviceCoordinates) {
+        Q_ASSERT(info->painter);
+        rect = info->painter->worldTransform().mapRect(rect);
+    }
+    return rect;
+}
+void QGraphicsItemEffectSourcePrivate::draw(QPainter *painter)
+{
+    if (!info) {
+        qWarning("QGraphicsEffectSource::draw: Can only begin as a result of QGraphicsEffect::draw");
+        return;
+    }
+    Q_ASSERT(item->d_ptr->scene);
+    QGraphicsScenePrivate *scened = item->d_ptr->scene->d_func();
+    if (painter == info->painter) {
+        scened->draw(item, painter, info->viewTransform, info->transformPtr, info->exposedRegion,
+                     info->widget, info->opacity, info->effectTransform, info->wasDirtySceneTransform,
+                     info->drawItem);
+    } else {
+        QTransform effectTransform = info->painter->worldTransform().inverted();
+        effectTransform *= painter->worldTransform();
+        scened->draw(item, painter, info->viewTransform, info->transformPtr, info->exposedRegion,
+                     info->widget, info->opacity, &effectTransform, info->wasDirtySceneTransform,
+                     info->drawItem);
+    }
+}
+QPixmap QGraphicsItemEffectSourcePrivate::pixmap(Qt::CoordinateSystem system, QPoint *offset,
+                                                 QGraphicsEffect::PixmapPadMode mode) const
+{
+    const bool deviceCoordinates = (system == Qt::DeviceCoordinates);
+    if (!info && deviceCoordinates) {
+        // Device coordinates without info not yet supported.
+        qWarning("QGraphicsEffectSource::pixmap: Not yet implemented, lacking device context");
+        return QPixmap();
+    }
+    if (!item->d_ptr->scene)
+        return QPixmap();
+    QGraphicsScenePrivate *scened = item->d_ptr->scene->d_func();
+    const QRectF sourceRect = boundingRect(system);
+    QRectF effectRectF;
+    bool unpadded = false;
+    if (mode == QGraphicsEffect::PadToEffectiveBoundingRect) {
+        if (info) {
+            effectRectF = item->graphicsEffect()->boundingRectFor(boundingRect(Qt::DeviceCoordinates));
+            unpadded = (effectRectF.size() == sourceRect.size());
+            if (info && system == Qt::LogicalCoordinates)
+                effectRectF = info->painter->worldTransform().inverted().mapRect(effectRectF);
+        } else {
+            // no choice but to send a logical coordinate bounding rect to boundingRectFor
+            effectRectF = item->graphicsEffect()->boundingRectFor(sourceRect);
+        }
+    } else if (mode == QGraphicsEffect::PadToTransparentBorder) {
+        // adjust by 1.5 to account for cosmetic pens
+        effectRectF = sourceRect.adjusted(-1.5, -1.5, 1.5, 1.5);
+    } else {
+        effectRectF = sourceRect;
+        unpadded = true;
+    }
+    QRect effectRect = effectRectF.toAlignedRect();
+    if (offset)
+        *offset = effectRect.topLeft();
+    bool untransformed = !deviceCoordinates
+            || info->painter->worldTransform().type() <= QTransform::TxTranslate;
+    if (untransformed && unpadded && isPixmap()) {
+        if (offset)
+            *offset = boundingRect(system).topLeft().toPoint();
+        return static_cast<QGraphicsPixmapItem *>(item)->pixmap();
+    }
+    if (deviceCoordinates) {
+        // Clip to viewport rect.
+        int left, top, right, bottom;
+        effectRect.getCoords(&left, &top, &right, &bottom);
+        if (left < 0) {
+            if (offset)
+                offset->rx() += -left;
+            effectRect.setX(0);
+        }
+        if (top < 0) {
+            if (offset)
+                offset->ry() += -top;
+            effectRect.setY(0);
+        }
+        // NB! We use +-1 for historical reasons (see QRect documentation).
+        QPaintDevice *device = info->painter->device();
+        const int deviceWidth = device->width();
+        const int deviceHeight = device->height();
+        if (right + 1 > deviceWidth)
+            effectRect.setRight(deviceWidth - 1);
+        if (bottom + 1 > deviceHeight)
+            effectRect.setBottom(deviceHeight -1);
+    }
+    if (effectRect.isEmpty())
+        return QPixmap();
+    QPixmap pixmap(effectRect.size());
+    pixmap.fill(Qt::transparent);
+    QPainter pixmapPainter(&pixmap);
+    pixmapPainter.setRenderHints(info ? info->painter->renderHints() : QPainter::TextAntialiasing);
+    QTransform effectTransform = QTransform::fromTranslate(-effectRect.x(), -effectRect.y());
+    if (deviceCoordinates && info->effectTransform)
+        effectTransform *= *info->effectTransform;
+    if (!info) {
+        // Logical coordinates without info.
+        QTransform sceneTransform = item->sceneTransform();
+        QTransform newEffectTransform = sceneTransform.inverted();
+        newEffectTransform *= effectTransform;
+        scened->draw(item, &pixmapPainter, 0, &sceneTransform, 0, 0, qreal(1.0),
+                     &newEffectTransform, false, true);
+    } else if (deviceCoordinates) {
+        // Device coordinates with info.
+        scened->draw(item, &pixmapPainter, info->viewTransform, info->transformPtr, info->exposedRegion,
+                     info->widget, info->opacity, &effectTransform, info->wasDirtySceneTransform,
+                     info->drawItem);
+    } else {
+        // Item coordinates with info.
+        QTransform newEffectTransform = info->transformPtr->inverted();
+        newEffectTransform *= effectTransform;
+        scened->draw(item, &pixmapPainter, info->viewTransform, info->transformPtr, info->exposedRegion,
+                     info->widget, info->opacity, &newEffectTransform, info->wasDirtySceneTransform,
+                     info->drawItem);
+    }
+    pixmapPainter.end();
+    return pixmap;
+}
+#endif //QT_NO_GRAPHICSEFFECT
 #ifndef QT_NO_DEBUG_STREAM
 QDebug operator<<(QDebug debug, QGraphicsItem *item)
 …
+    }
+    QStringList flags;
+    if (item->isVisible()) flags << QLatin1String("isVisible");
+    if (item->isEnabled()) flags << QLatin1String("isEnabled");
+    if (item->isSelected()) flags << QLatin1String("isSelected");
+    if (item->hasFocus()) flags << QLatin1String("HasFocus");
+    debug << "QGraphicsItem(this =" << ((void*)item)
+          << ", parent =" << ((void*)item->parentItem())
+    if (QGraphicsObject *o = item->toGraphicsObject())
+        debug << o->metaObject()->className();
+    else
+        debug << "QGraphicsItem";
+    debug << "(this =" << (void*)item
+          << ", parent =" << (void*)item->parentItem()
           << ", pos =" << item->pos()
           << ", z =" << item->zValue() << ", flags = {"
           << flags.join(QLatin1String("|")) << " })";
+          << ", z =" << item->zValue() << ", flags = "
+          << item->flags() << ")";
     return debug;
+}
+QDebug operator<<(QDebug debug, QGraphicsObject *item)
+{
+    if (!item) {
+        debug << "QGraphicsObject(0)";
+        return debug;
+    }
+    debug.nospace() << item->metaObject()->className() << '(' << (void*)item;
+    if (!item->objectName().isEmpty())
+        debug << ", name = " << item->objectName();
+    debug.nospace() << ", parent = " << ((void*)item->parentItem())
+          << ", pos = " << item->pos()
+          << ", z = " << item->zValue() << ", flags = "
+          << item->flags() << ')';
+    return debug.space();
+}
 …
         str = "ItemOpacityHasChanged";
         break;
+    case QGraphicsItem::ItemScenePositionHasChanged:
+        str = "ItemScenePositionHasChanged";
+        break;
+    }
     debug << str;
 …
         str = "ItemStacksBehindParent";
         break;
+    case QGraphicsItem::ItemUsesExtendedStyleOption:
+        str = "ItemUsesExtendedStyleOption";
+        break;
+    case QGraphicsItem::ItemHasNoContents:
+        str = "ItemHasNoContents";
+        break;
+    case QGraphicsItem::ItemSendsGeometryChanges:
+        str = "ItemSendsGeometryChanges";
+        break;
+    case QGraphicsItem::ItemAcceptsInputMethod:
+        str = "ItemAcceptsInputMethod";
+        break;
+    case QGraphicsItem::ItemNegativeZStacksBehindParent:
+        str = "ItemNegativeZStacksBehindParent";
+        break;
+    case QGraphicsItem::ItemIsPanel:
+        str = "ItemIsPanel";
+        break;
+    case QGraphicsItem::ItemIsFocusScope:
+        str = "ItemIsFocusScope";
+        break;
+    case QGraphicsItem::ItemSendsScenePositionChanges:
+        str = "ItemSendsScenePositionChanges";
+        break;
+    }
     debug << str;
 …
 QDebug operator<<(QDebug debug, QGraphicsItem::GraphicsItemFlags flags)
+{
     debug << "(";
+    debug << '(';
     bool f = false;
     for (int i = 0; i < 9; ++i) {
+    for (int i = 0; i < 16; ++i) {
         if (flags & (1 << i)) {
             if (f)
                 debug << "|";
+                debug << '|';
             f = true;
             debug << QGraphicsItem::GraphicsItemFlag(int(flags & (1 << i)));
+        }
+    }
     debug << ")";
+    debug << ')';
     return debug;
+}

trunk/src/gui/graphicsview/qgraphicsitem.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 …
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 #include <QtCore/qvariant.h>
 #include <QtCore/qrect.h>
+#include <QtCore/qscopedpointer.h>
 #include <QtGui/qpainterpath.h>
 #include <QtGui/qpixmap.h>
 …
 class QCursor;
 class QFocusEvent;
+class QGraphicsEffect;
 class QGraphicsItemGroup;
+class QGraphicsObject;
 class QGraphicsSceneContextMenuEvent;
 class QGraphicsSceneDragDropEvent;
 …
 class QGraphicsSceneWheelEvent;
 class QGraphicsScene;
+class QGraphicsTransform;
 class QGraphicsWidget;
 class QInputMethodEvent;
 …
         ItemIgnoresParentOpacity = 0x40,
         ItemDoesntPropagateOpacityToChildren = 0x80,
+        ItemStacksBehindParent = 0x100
+        ItemStacksBehindParent = 0x100,
+        ItemUsesExtendedStyleOption = 0x200,
+        ItemHasNoContents = 0x400,
+        ItemSendsGeometryChanges = 0x800,
+        ItemAcceptsInputMethod = 0x1000,
+        ItemNegativeZStacksBehindParent = 0x2000,
+        ItemIsPanel = 0x4000,
+        ItemIsFocusScope = 0x8000, // internal
+        ItemSendsScenePositionChanges = 0x10000
+        // NB! Don't forget to increase the d_ptr->flags bit field by 1 when adding a new flag.
     };
     Q_DECLARE_FLAGS(GraphicsItemFlags, GraphicsItemFlag)
 …
         ItemZValueHasChanged,
         ItemOpacityChange,
+        ItemOpacityHasChanged
+        ItemOpacityHasChanged,
+        ItemScenePositionHasChanged
     };
 …
     };
+    enum PanelModality
+    {
+        NonModal,
+        PanelModal,
+        SceneModal
+    };
     QGraphicsItem(QGraphicsItem *parent = 0
 #ifndef Q_QDOC
                   // obsolete argument
+                  // ### obsolete argument
                   , QGraphicsScene *scene = 0
 #endif
 …
     QGraphicsItem *parentItem() const;
     QGraphicsItem *topLevelItem() const;
+    QGraphicsObject *parentObject() const;
     QGraphicsWidget *parentWidget() const;
     QGraphicsWidget *topLevelWidget() const;
     QGraphicsWidget *window() const;
+    QGraphicsItem *panel() const;
     void setParentItem(QGraphicsItem *parent);
     QList<QGraphicsItem *> children() const; // ### obsolete
 …
     bool isWidget() const;
     bool isWindow() const;
+    bool isPanel() const;
+    QGraphicsObject *toGraphicsObject();
+    const QGraphicsObject *toGraphicsObject() const;
     QGraphicsItemGroup *group() const;
 …
     CacheMode cacheMode() const;
     void setCacheMode(CacheMode mode, const QSize &cacheSize = QSize());
+    PanelModality panelModality() const;
+    void setPanelModality(PanelModality panelModality);
+    bool isBlockedByModalPanel(QGraphicsItem **blockingPanel = 0) const;
 #ifndef QT_NO_TOOLTIP
 …
     void setOpacity(qreal opacity);
+#ifndef QT_NO_GRAPHICSEFFECT
+    // Effect
+    QGraphicsEffect *graphicsEffect() const;
+    void setGraphicsEffect(QGraphicsEffect *effect);
+#endif //QT_NO_GRAPHICSEFFECT
     Qt::MouseButtons acceptedMouseButtons() const;
     void setAcceptedMouseButtons(Qt::MouseButtons buttons);
     bool acceptsHoverEvents() const; // obsolete
     void setAcceptsHoverEvents(bool enabled); // obsolete
+    bool acceptsHoverEvents() const; // ### obsolete
+    void setAcceptsHoverEvents(bool enabled); // ### obsolete
     bool acceptHoverEvents() const;
     void setAcceptHoverEvents(bool enabled);
+    bool acceptTouchEvents() const;
+    void setAcceptTouchEvents(bool enabled);
+    bool filtersChildEvents() const;
+    void setFiltersChildEvents(bool enabled);
     bool handlesChildEvents() const;
     void setHandlesChildEvents(bool enabled);
+    bool isActive() const;
+    void setActive(bool active);
     bool hasFocus() const;
     void setFocus(Qt::FocusReason focusReason = Qt::OtherFocusReason);
     void clearFocus();
+    QGraphicsItem *focusProxy() const;
+    void setFocusProxy(QGraphicsItem *item);
+    QGraphicsItem *focusItem() const;
+    QGraphicsItem *focusScopeItem() const;
     void grabMouse();
 …
     QPointF pos() const;
     inline qreal x() const { return pos().x(); }
+    void setX(qreal x);
     inline qreal y() const { return pos().y(); }
+    void setY(qreal y);
     QPointF scenePos() const;
     void setPos(const QPointF &pos);
 …
     void setTransform(const QTransform &matrix, bool combine = false);
     void resetTransform();
+    void rotate(qreal angle);
+    void scale(qreal sx, qreal sy);
+    void shear(qreal sh, qreal sv);
+    void translate(qreal dx, qreal dy);
+    void rotate(qreal angle);           // ### obsolete
+    void scale(qreal sx, qreal sy);     // ### obsolete
+    void shear(qreal sh, qreal sv);     // ### obsolete
+    void translate(qreal dx, qreal dy); // ### obsolete
+    void setRotation(qreal angle);
+    qreal rotation() const;
+    void setScale(qreal scale);
+    qreal scale() const;
+    QList<QGraphicsTransform *> transformations() const;
+    void setTransformations(const QList<QGraphicsTransform *> &transformations);
+    QPointF transformOriginPoint() const;
+    void setTransformOriginPoint(const QPointF &origin);
+    inline void setTransformOriginPoint(qreal ax, qreal ay)
+    { setTransformOriginPoint(QPointF(ax,ay)); }
     virtual void advance(int phase);
 …
     qreal zValue() const;
     void setZValue(qreal z);
+    void stackBefore(const QGraphicsItem *sibling);
     // Hit test
 …
     void setData(int key, const QVariant &value);
+    Qt::InputMethodHints inputMethodHints() const;
+    void setInputMethodHints(Qt::InputMethodHints hints);
     enum {
         Type = 1,
 …
     QGraphicsItem(QGraphicsItemPrivate &dd,
                   QGraphicsItem *parent, QGraphicsScene *scene);
     QGraphicsItemPrivate *d_ptr;
+    QScopedPointer<QGraphicsItemPrivate> d_ptr;
     void addToIndex();
 …
     friend class QGraphicsScenePrivate;
     friend class QGraphicsSceneFindItemBspTreeVisitor;
+    friend class QGraphicsSceneBspTree;
     friend class QGraphicsView;
     friend class QGraphicsViewPrivate;
+    friend class QGraphicsObject;
     friend class QGraphicsWidget;
     friend class QGraphicsWidgetPrivate;
     friend class QGraphicsProxyWidgetPrivate;
+    friend class QGraphicsSceneIndex;
+    friend class QGraphicsSceneIndexPrivate;
+    friend class QGraphicsSceneBspTreeIndex;
+    friend class QGraphicsSceneBspTreeIndexPrivate;
+    friend class QGraphicsItemEffectSourcePrivate;
+    friend class QGraphicsTransformPrivate;
+    friend class QGestureManager;
     friend class ::tst_QGraphicsItem;
     friend bool qt_closestLeaf(const QGraphicsItem *, const QGraphicsItem *);
 …
 Q_DECLARE_OPERATORS_FOR_FLAGS(QGraphicsItem::GraphicsItemFlags)
+Q_DECLARE_INTERFACE(QGraphicsItem, "com.trolltech.Qt.QGraphicsItem")
 inline void QGraphicsItem::setPos(qreal ax, qreal ay)
 …
 { return mapRectFromScene(QRectF(ax, ay, w, h)); }
+class Q_GUI_EXPORT QGraphicsObject : public QObject, public QGraphicsItem
+{
+    Q_OBJECT
+    Q_PROPERTY(QGraphicsObject * parent READ parentObject WRITE setParentItem NOTIFY parentChanged DESIGNABLE false)
+    Q_PROPERTY(qreal opacity READ opacity WRITE setOpacity NOTIFY opacityChanged FINAL)
+    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(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:
+    QGraphicsObject(QGraphicsItem *parent = 0);
+    // ### Qt 5: Disambiguate
+#ifdef Q_NO_USING_KEYWORD
+    const QObjectList &children() const { return QObject::children(); }
+#else
+    using QObject::children;
+#endif
+    void grabGesture(Qt::GestureType type, Qt::GestureFlags flags = Qt::GestureFlags());
+    void ungrabGesture(Qt::GestureType type);
+Q_SIGNALS:
+    void parentChanged();
+    void opacityChanged();
+    void visibleChanged();
+    void enabledChanged();
+    void xChanged();
+    void yChanged();
+    void zChanged();
+    void rotationChanged();
+    void scaleChanged();
+protected:
+    QGraphicsObject(QGraphicsItemPrivate &dd, QGraphicsItem *parent, QGraphicsScene *scene);
+private:
+    friend class QGraphicsItem;
+    friend class QGraphicsItemPrivate;
+};
 class QAbstractGraphicsShapeItemPrivate;
 class Q_GUI_EXPORT QAbstractGraphicsShapeItem : public QGraphicsItem
 …
     QAbstractGraphicsShapeItem(QGraphicsItem *parent = 0
 #ifndef Q_QDOC
                                // obsolete argument
+                               // ### obsolete argument
                                , QGraphicsScene *scene = 0
 #endif
 …
     QGraphicsPathItem(QGraphicsItem *parent = 0
 #ifndef Q_QDOC
                       // obsolete argument
+                      // ### obsolete argument
                       , QGraphicsScene *scene = 0
 #endif
 …
     QGraphicsPathItem(const QPainterPath &path, QGraphicsItem *parent = 0
 #ifndef Q_QDOC
                       // obsolete argument
+                      // ### obsolete argument
                       , QGraphicsScene *scene = 0
 #endif
 …
     QGraphicsRectItem(QGraphicsItem *parent = 0
 #ifndef Q_QDOC
                       // obsolete argument
+                      // ### obsolete argument
                       , QGraphicsScene *scene = 0
 #endif
 …
     QGraphicsRectItem(const QRectF &rect, QGraphicsItem *parent = 0
 #ifndef Q_QDOC
                       // obsolete argument
+                      // ### obsolete argument
                       , QGraphicsScene *scene = 0
 #endif
 …
     QGraphicsRectItem(qreal x, qreal y, qreal w, qreal h, QGraphicsItem *parent = 0
 #ifndef Q_QDOC
                       // obsolete argument
+                      // ### obsolete argument
                       , QGraphicsScene *scene = 0
 #endif
 …
     QGraphicsEllipseItem(QGraphicsItem *parent = 0
 #ifndef Q_QDOC
                          // obsolete argument
+                         // ### obsolete argument
                          , QGraphicsScene *scene = 0
 #endif
 …
     QGraphicsEllipseItem(const QRectF &rect, QGraphicsItem *parent = 0
 #ifndef Q_QDOC
                          // obsolete argument
+                         // ### obsolete argument
                          , QGraphicsScene *scene = 0
 #endif
 …
     QGraphicsEllipseItem(qreal x, qreal y, qreal w, qreal h, QGraphicsItem *parent = 0
 #ifndef Q_QDOC
                          // obsolete argument
+                         // ### obsolete argument
                          , QGraphicsScene *scene = 0
 #endif
 …
     QGraphicsPolygonItem(QGraphicsItem *parent = 0
 #ifndef Q_QDOC
                          // obsolete argument
+                         // ### obsolete argument
                          , QGraphicsScene *scene = 0
 #endif
 …
                          QGraphicsItem *parent = 0
 #ifndef Q_QDOC
                          // obsolete argument
+                         // ### obsolete argument
                          , QGraphicsScene *scene = 0
 #endif
 …
     QGraphicsLineItem(QGraphicsItem *parent = 0
 #ifndef Q_QDOC
                       // obsolete argument
+                      // ### obsolete argument
                       , QGraphicsScene *scene = 0
 #endif
 …
     QGraphicsLineItem(const QLineF &line, QGraphicsItem *parent = 0
 #ifndef Q_QDOC
                       // obsolete argument
+                      // ### obsolete argument
                       , QGraphicsScene *scene = 0
 #endif
 …
     QGraphicsLineItem(qreal x1, qreal y1, qreal x2, qreal y2, QGraphicsItem *parent = 0
 #ifndef Q_QDOC
                       // obsolete argument
+                      // ### obsolete argument
                       , QGraphicsScene *scene = 0
 #endif
 …
     QGraphicsPixmapItem(QGraphicsItem *parent = 0
 #ifndef Q_QDOC
                         // obsolete argument
+                        // ### obsolete argument
                         , QGraphicsScene *scene = 0
 #endif
 …
     QGraphicsPixmapItem(const QPixmap &pixmap, QGraphicsItem *parent = 0
 #ifndef Q_QDOC
                         // obsolete argument
+                        // ### obsolete argument
                         , QGraphicsScene *scene = 0
 #endif
 …
 class QTextDocument;
 class QTextCursor;
 class Q_GUI_EXPORT QGraphicsTextItem : public QObject, public QGraphicsItem
+class Q_GUI_EXPORT QGraphicsTextItem : public QGraphicsObject
+{
     Q_OBJECT
 …
     QGraphicsTextItem(QGraphicsItem *parent = 0
 #ifndef Q_QDOC
                       // obsolete argument
+                      // ### obsolete argument
                       , QGraphicsScene *scene = 0
 #endif
 …
     QGraphicsTextItem(const QString &text, QGraphicsItem *parent = 0
 #ifndef Q_QDOC
                       // obsolete argument
+                      // ### obsolete argument
                       , QGraphicsScene *scene = 0
 #endif
 …
     QGraphicsSimpleTextItem(QGraphicsItem *parent = 0
 #ifndef Q_QDOC
                             // obsolete argument
+                            // ### obsolete argument
                             , QGraphicsScene *scene = 0
 #endif
 …
     QGraphicsSimpleTextItem(const QString &text, QGraphicsItem *parent = 0
 #ifndef Q_QDOC
                             // obsolete argument
+                            // ### obsolete argument
                             , QGraphicsScene *scene = 0
 #endif
 …
     QGraphicsItemGroup(QGraphicsItem *parent = 0
 #ifndef Q_QDOC
                        // obsolete argument
+                       // ### obsolete argument
                        , QGraphicsScene *scene = 0
 #endif
 …
 #ifndef QT_NO_DEBUG_STREAM
 Q_GUI_EXPORT QDebug operator<<(QDebug debug, QGraphicsItem *item);
+Q_GUI_EXPORT QDebug operator<<(QDebug debug, QGraphicsObject *item);
 Q_GUI_EXPORT QDebug operator<<(QDebug debug, QGraphicsItem::GraphicsItemChange change);
 Q_GUI_EXPORT QDebug operator<<(QDebug debug, QGraphicsItem::GraphicsItemFlag flag);
 …
 #endif // QGRAPHICSITEM_H

trunk/src/gui/graphicsview/qgraphicsitem_p.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 …
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 //
 // This file is not part of the Qt API.  It exists for the convenience
 // of qapplication_*.cpp, qwidget*.cpp and qfiledialog.cpp.  This header
 // file may change from version to version without notice, or even be removed.
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
 //
 // We mean it.
 …
 #include "qgraphicsitem.h"
+#include "qset.h"
+#include "qpixmapcache.h"
+#include <private/qgraphicsview_p.h>
+#include "qgraphicstransform.h"
+#include <private/qgraphicstransform_p.h>
+#include <private/qgraphicseffect_p.h>
+#include <qgraphicseffect.h>
+#include <QtCore/qpoint.h>
 #if !defined(QT_NO_GRAPHICSVIEW) || (QT_EDITION & QT_MODULE_GRAPHICSVIEW) != QT_MODULE_GRAPHICSVIEW
 …
     QRect boundingRect;
     QSize fixedSize;
     QString key;
+    QPixmapCache::Key key;
     // DeviceCoordinateCache only
     struct DeviceData {
+        DeviceData() {}
         QTransform lastTransform;
         QPoint cacheIndent;
         QString key;
+        QPixmapCache::Key key;
     };
     QMap<QPaintDevice *, DeviceData> deviceData;
 …
 };
 class Q_AUTOTEST_EXPORT QGraphicsItemPrivate
+class Q_GUI_EXPORT QGraphicsItemPrivate
+{
     Q_DECLARE_PUBLIC(QGraphicsItem)
 public:
     enum Extra {
-        ExtraTransform,
         ExtraToolTip,
         ExtraCursor,
         ExtraCacheData,
         ExtraMaxDeviceCoordCacheSize,
+        ExtraBoundingRegionGranularity,
+        ExtraOpacity,
+        ExtraEffectiveOpacity
+        ExtraBoundingRegionGranularity
     };
 …
         AncestorHandlesChildEvents = 0x1,
         AncestorClipsChildren = 0x2,
+        AncestorIgnoresTransformations = 0x4
+        AncestorIgnoresTransformations = 0x4,
+        AncestorFiltersChildEvents = 0x8
     };
     inline QGraphicsItemPrivate()
         : z(0),
+        opacity(1.),
         scene(0),
         parent(0),
+        transformData(0),
+        graphicsEffect(0),
         index(-1),
+        depth(0),
+        siblingIndex(-1),
+        itemDepth(-1),
+        focusProxy(0),
+        subFocusItem(0),
+        focusScopeItem(0),
+        imHints(Qt::ImhNone),
+        panelModality(QGraphicsItem::NonModal),
         acceptedMouseButtons(0x1f),
         visible(1),
 …
         handlesChildEvents(0),
         itemDiscovered(0),
-        hasTransform(0),
         hasCursor(0),
         ancestorFlags(0),
         cacheMode(0),
         hasBoundingRegionGranularity(0),
-        flags(0),
-        hasOpacity(0),
-        hasEffectiveOpacity(0),
         isWidget(0),
         dirty(0),
         dirtyChildren(0),
         localCollisionHack(0),
-        dirtyClipPath(1),
-        emptyClipPath(0),
         inSetPosHelper(0),
+        allChildrenCombineOpacity(1),
+        needSortChildren(1), // ### can be 0 by default?
+        allChildrenDirty(0),
+        fullUpdatePending(0),
+        flags(0),
+        dirtyChildrenBoundingRect(1),
+        paintedViewBoundingRectsNeedRepaint(0),
+        dirtySceneTransform(1),
+        geometryChanged(1),
+        inDestructor(0),
+        isObject(0),
+        ignoreVisible(0),
+        ignoreOpacity(0),
+        acceptTouchEvents(0),
+        acceptedTouchBeginEvent(0),
+        filtersDescendantEvents(0),
+        sceneTransformTranslateOnly(0),
+        notifyBoundingRectChanged(0),
+        notifyInvalidated(0),
+        mouseSetsFocus(1),
+        explicitActivate(0),
+        wantsActive(0),
+        holesInSiblingIndex(0),
+        sequentialOrdering(1),
+        updateDueToGraphicsEffect(0),
+        scenePosDescendants(0),
         globalStackingOrder(-1),
-        sceneTransformIndex(-1),
         q_ptr(0)
+    {
 …
     inline virtual ~QGraphicsItemPrivate()
     { }
+    static const QGraphicsItemPrivate *get(const QGraphicsItem *item)
+    {
+        return item->d_ptr.data();
+    }
+    static QGraphicsItemPrivate *get(QGraphicsItem *item)
+    {
+        return item->d_ptr.data();
+    }
     void updateAncestorFlag(QGraphicsItem::GraphicsItemFlag childFlag,
 …
     void remapItemPos(QEvent *event, QGraphicsItem *item);
     QPointF genericMapFromScene(const QPointF &pos, const QWidget *viewport) const;
+    bool itemIsUntransformable() const;
+    inline bool itemIsUntransformable() const
+    {
+        return (flags & QGraphicsItem::ItemIgnoresTransformations)
+            || (ancestorFlags & AncestorIgnoresTransformations);
+    }
+    void combineTransformToParent(QTransform *x, const QTransform *viewTransform = 0) const;
+    void combineTransformFromParent(QTransform *x, const QTransform *viewTransform = 0) const;
+    virtual void updateSceneTransformFromParent();
     // ### Qt 5: Remove. Workaround for reimplementation added after Qt 4.4.
 …
     static bool movableAncestorIsSelected(const QGraphicsItem *item);
+    void setPosHelper(const QPointF &pos);
+    virtual void setPosHelper(const QPointF &pos);
+    void setTransformHelper(const QTransform &transform);
+    void appendGraphicsTransform(QGraphicsTransform *t);
     void setVisibleHelper(bool newVisible, bool explicitly, bool update = true);
     void setEnabledHelper(bool newEnabled, bool explicitly, bool update = true);
+    bool discardUpdateRequest(bool ignoreClipping = false,
+                              bool ignoreVisibleBit = false,
+                              bool ignoreDirtyBit = false) const;
+    void updateHelper(const QRectF &rect = QRectF(), bool force = false, bool maybeDirtyClipPath = false);
+    void fullUpdateHelper(bool childrenOnly = false, bool maybeDirtyClipPath = false);
+    void updateEffectiveOpacity();
+    void resolveEffectiveOpacity(qreal effectiveParentOpacity);
+    void resolveDepth(int parentDepth);
+    void invalidateSceneTransformCache();
+    bool discardUpdateRequest(bool ignoreVisibleBit = false,
+                              bool ignoreDirtyBit = false, bool ignoreOpacity = false) const;
+    int depth() const;
+#ifndef QT_NO_GRAPHICSEFFECT
+    void invalidateGraphicsEffectsRecursively();
+#endif //QT_NO_GRAPHICSEFFECT
+    void invalidateDepthRecursively();
+    void resolveDepth();
+    void addChild(QGraphicsItem *child);
+    void removeChild(QGraphicsItem *child);
+    void setParentItemHelper(QGraphicsItem *parent);
+    void childrenBoundingRectHelper(QTransform *x, QRectF *rect);
+    void initStyleOption(QStyleOptionGraphicsItem *option, const QTransform &worldTransform,
+                         const QRegion &exposedRegion, bool allItems = false) const;
+    QRectF effectiveBoundingRect() const;
+    QRectF sceneEffectiveBoundingRect() const;
+    QRectF effectiveBoundingRect(const QRectF &rect) const;
     virtual void resolveFont(uint inheritedMask)
 …
         { return type < extra; }
     };
     QList<ExtraStruct> extras;
+    QGraphicsItemCache *maybeExtraItemCache() const;
     QGraphicsItemCache *extraItemCache() const;
     void removeExtraItemCache();
+    inline void setCachedClipPath(const QPainterPath &path)
+    {
+        cachedClipPath = path;
+        dirtyClipPath = 0;
+        emptyClipPath = 0;
+    }
+    inline void setEmptyCachedClipPath()
+    {
+        emptyClipPath = 1;
+        dirtyClipPath = 0;
+    }
+    void setEmptyCachedClipPathRecursively(const QRectF &emptyIfOutsideThisRect = QRectF());
+    inline void invalidateCachedClipPath()
+    { /*static int count = 0 ;qWarning("%i", ++count);*/ dirtyClipPath = 1; emptyClipPath = 0; }
+    void invalidateCachedClipPathRecursively(bool childrenOnly = false, const QRectF &emptyIfOutsideThisRect = QRectF());
+    void updateCachedClipPathFromSetPosHelper(const QPointF &newPos);
+    void ensureSceneTransformRecursive(QGraphicsItem **topMostDirtyItem);
+    inline void ensureSceneTransform()
+    {
+        QGraphicsItem *that = q_func();
+        ensureSceneTransformRecursive(&that);
+    }
+    inline bool hasTranslateOnlySceneTransform()
+    {
+        ensureSceneTransform();
+        return sceneTransformTranslateOnly;
+    }
+    inline void invalidateChildrenSceneTransform()
+    {
+        for (int i = 0; i < children.size(); ++i)
+            children.at(i)->d_ptr->dirtySceneTransform = 1;
+    }
+    inline qreal calcEffectiveOpacity() const
+    {
+        qreal o = opacity;
+        QGraphicsItem *p = parent;
+        int myFlags = flags;
+        while (p) {
+            int parentFlags = p->d_ptr->flags;
+            // If I have a parent, and I don't ignore my parent's opacity, and my
+            // parent propagates to me, then combine my local opacity with my parent's
+            // effective opacity into my effective opacity.
+            if ((myFlags & QGraphicsItem::ItemIgnoresParentOpacity)
+                || (parentFlags & QGraphicsItem::ItemDoesntPropagateOpacityToChildren)) {
+                break;
+            }
+            o *= p->d_ptr->opacity;
+            p = p->d_ptr->parent;
+            myFlags = parentFlags;
+        }
+        return o;
+    }
     inline bool isFullyTransparent() const
+    { return hasEffectiveOpacity && qFuzzyCompare(q_func()->effectiveOpacity() + 1, qreal(1.0)); }
+    {
+        if (opacity < 0.001)
+            return true;
+        if (!parent)
+            return false;
+        return calcEffectiveOpacity() < 0.001;
+    }
+    inline qreal effectiveOpacity() const {
+        if (!parent || !opacity)
+            return opacity;
+        return calcEffectiveOpacity();
+    }
+    inline qreal combineOpacityFromParent(qreal parentOpacity) const
+    {
+        if (parent && !(flags & QGraphicsItem::ItemIgnoresParentOpacity)
+            && !(parent->d_ptr->flags & QGraphicsItem::ItemDoesntPropagateOpacityToChildren)) {
+            return parentOpacity * opacity;
+        }
+        return opacity;
+    }
     inline bool childrenCombineOpacity() const
+    { return allChildrenCombineOpacity || children.isEmpty(); }
+    inline bool isClippedAway() const
+    { return !dirtyClipPath && q_func()->isClipped() && (emptyClipPath || cachedClipPath.isEmpty()); }
+    {
+        if (!children.size())
+            return true;
+        if (flags & QGraphicsItem::ItemDoesntPropagateOpacityToChildren)
+            return false;
+        for (int i = 0; i < children.size(); ++i) {
+            if (children.at(i)->d_ptr->flags & QGraphicsItem::ItemIgnoresParentOpacity)
+                return false;
+        }
+        return true;
+    }
     inline bool childrenClippedToShape() const
 …
     inline bool isInvisible() const
+    {
+        return !visible
+               || (childrenClippedToShape() && isClippedAway())
+               || (childrenCombineOpacity() && isFullyTransparent());
+    }
+    QPainterPath cachedClipPath;
+        return !visible || (childrenCombineOpacity() && isFullyTransparent());
+    }
+    void setFocusHelper(Qt::FocusReason focusReason, bool climb);
+    void setSubFocus(QGraphicsItem *rootItem = 0);
+    void clearSubFocus(QGraphicsItem *rootItem = 0);
+    void resetFocusProxy();
+    virtual void subFocusItemChange();
+    inline QTransform transformToParent() const;
+    inline void ensureSortedChildren();
+    static inline bool insertionOrder(QGraphicsItem *a, QGraphicsItem *b);
+    void ensureSequentialSiblingIndex();
+    inline void sendScenePosChange();
+    virtual void siblingOrderChange();
+    QRectF childrenBoundingRect;
+    QRectF needsRepaint;
+    QMap<QWidget *, QRect> paintedViewBoundingRects;
     QPointF pos;
     qreal z;
+    qreal opacity;
     QGraphicsScene *scene;
     QGraphicsItem *parent;
     QList<QGraphicsItem *> children;
+    struct TransformData;
+    TransformData *transformData;
+    QGraphicsEffect *graphicsEffect;
+    QTransform sceneTransform;
     int index;
+    int depth;
+    // Packed 32 bytes
+    int siblingIndex;
+    int itemDepth;  // Lazily calculated when calling depth().
+    QGraphicsItem *focusProxy;
+    QList<QGraphicsItem **> focusProxyRefs;
+    QGraphicsItem *subFocusItem;
+    QGraphicsItem *focusScopeItem;
+    Qt::InputMethodHints imHints;
+    QGraphicsItem::PanelModality panelModality;
+    QMap<Qt::GestureType, Qt::GestureFlags> gestureContext;
+    // Packed 32 bits
     quint32 acceptedMouseButtons : 5;
     quint32 visible : 1;
 …
     quint32 handlesChildEvents : 1;
     quint32 itemDiscovered : 1;
-    quint32 hasTransform : 1;
     quint32 hasCursor : 1;
     quint32 ancestorFlags : 3;
+    quint32 ancestorFlags : 4;
     quint32 cacheMode : 2;
     quint32 hasBoundingRegionGranularity : 1;
-    quint32 flags : 9;
-    // New 32 bytes
-    quint32 hasOpacity : 1;
-    quint32 hasEffectiveOpacity : 1;
     quint32 isWidget : 1;
     quint32 dirty : 1;
     quint32 dirtyChildren : 1;
+    quint32 dirty : 1;
+    quint32 dirtyChildren : 1;
     quint32 localCollisionHack : 1;
-    quint32 dirtyClipPath : 1;
-    quint32 emptyClipPath : 1;
     quint32 inSetPosHelper : 1;
+    quint32 allChildrenCombineOpacity : 1;
+    quint32 needSortChildren : 1;
+    quint32 allChildrenDirty : 1;
+    // Packed 32 bits
+    quint32 fullUpdatePending : 1;
+    quint32 flags : 17;
+    quint32 dirtyChildrenBoundingRect : 1;
+    quint32 paintedViewBoundingRectsNeedRepaint : 1;
+    quint32 dirtySceneTransform : 1;
+    quint32 geometryChanged : 1;
+    quint32 inDestructor : 1;
+    quint32 isObject : 1;
+    quint32 ignoreVisible : 1;
+    quint32 ignoreOpacity : 1;
+    quint32 acceptTouchEvents : 1;
+    quint32 acceptedTouchBeginEvent : 1;
+    quint32 filtersDescendantEvents : 1;
+    quint32 sceneTransformTranslateOnly : 1;
+    quint32 notifyBoundingRectChanged : 1;
+    quint32 notifyInvalidated : 1;
+    // New 32 bits
+    quint32 mouseSetsFocus : 1;
+    quint32 explicitActivate : 1;
+    quint32 wantsActive : 1;
+    quint32 holesInSiblingIndex : 1;
+    quint32 sequentialOrdering : 1;
+    quint32 updateDueToGraphicsEffect : 1;
+    quint32 scenePosDescendants : 1;
     // Optional stacking order
     int globalStackingOrder;
-    int sceneTransformIndex;
     QGraphicsItem *q_ptr;
 };
+struct QGraphicsItemPrivate::TransformData
+{
+    QTransform transform;
+    qreal scale;
+    qreal rotation;
+    qreal xOrigin;
+    qreal yOrigin;
+    QList<QGraphicsTransform *> graphicsTransforms;
+    bool onlyTransform;
+    TransformData() :
+        scale(1.0), rotation(0.0),
+        xOrigin(0.0), yOrigin(0.0),
+        onlyTransform(true)
+    { }
+    QTransform computedFullTransform(QTransform *postmultiplyTransform = 0) const
+    {
+        if (onlyTransform) {
+            if (!postmultiplyTransform || postmultiplyTransform->isIdentity())
+                return transform;
+            if (transform.isIdentity())
+                return *postmultiplyTransform;
+            return transform * *postmultiplyTransform;
+        }
+        QTransform x(transform);
+        if (!graphicsTransforms.isEmpty()) {
+            QMatrix4x4 m;
+            for (int i = 0; i < graphicsTransforms.size(); ++i)
+                graphicsTransforms.at(i)->applyTo(&m);
+            x *= m.toTransform();
+        }
+        x.translate(xOrigin, yOrigin);
+        x.rotate(rotation);
+        x.scale(scale, scale);
+        x.translate(-xOrigin, -yOrigin);
+        if (postmultiplyTransform)
+            x *= *postmultiplyTransform;
+        return x;
+    }
+};
+struct QGraphicsItemPaintInfo
+{
+    inline QGraphicsItemPaintInfo(const QTransform *const xform1, const QTransform *const xform2,
+                                  const QTransform *const xform3,
+                                  QRegion *r, QWidget *w, QStyleOptionGraphicsItem *opt,
+                                  QPainter *p, qreal o, bool b1, bool b2)
+        : viewTransform(xform1), transformPtr(xform2), effectTransform(xform3), exposedRegion(r), widget(w),
+          option(opt), painter(p), opacity(o), wasDirtySceneTransform(b1), drawItem(b2)
+    {}
+    const QTransform *viewTransform;
+    const QTransform *transformPtr;
+    const QTransform *effectTransform;
+    QRegion *exposedRegion;
+    QWidget *widget;
+    QStyleOptionGraphicsItem *option;
+    QPainter *painter;
+    qreal opacity;
+    quint32 wasDirtySceneTransform : 1;
+    quint32 drawItem : 1;
+};
+#ifndef QT_NO_GRAPHICSEFFECT
+class QGraphicsItemEffectSourcePrivate : public QGraphicsEffectSourcePrivate
+{
+public:
+    QGraphicsItemEffectSourcePrivate(QGraphicsItem *i)
+        : QGraphicsEffectSourcePrivate(), item(i), info(0)
+    {}
+    inline void detach()
+    {
+        item->d_ptr->graphicsEffect = 0;
+        item->prepareGeometryChange();
+    }
+    inline const QGraphicsItem *graphicsItem() const
+    { return item; }
+    inline const QWidget *widget() const
+    { return 0; }
+    inline void update() {
+        item->d_ptr->updateDueToGraphicsEffect = true;
+        item->update();
+        item->d_ptr->updateDueToGraphicsEffect = false;
+    }
+    inline void effectBoundingRectChanged()
+    { item->prepareGeometryChange(); }
+    inline bool isPixmap() const
+    {
+        return item->type() == QGraphicsPixmapItem::Type
+               && !(item->flags() & QGraphicsItem::ItemIsSelectable)
+               && item->d_ptr->children.size() == 0;
+            //|| (item->d_ptr->isObject && qobject_cast<QmlGraphicsImage *>(q_func()));
+    }
+    inline const QStyleOption *styleOption() const
+    { return info ? info->option : 0; }
+    inline QRect deviceRect() const
+    {
+        if (!info || !info->widget) {
+            qWarning("QGraphicsEffectSource::deviceRect: Not yet implemented, lacking device context");
+            return QRect();
+        }
+        return info->widget->rect();
+    }
+    QRectF boundingRect(Qt::CoordinateSystem system) const;
+    void draw(QPainter *);
+    QPixmap pixmap(Qt::CoordinateSystem system,
+                   QPoint *offset,
+                   QGraphicsEffect::PixmapPadMode mode) const;
+    QGraphicsItem *item;
+    QGraphicsItemPaintInfo *info;
+    QTransform lastEffectTransform;
+};
+#endif //QT_NO_GRAPHICSEFFECT
+/*!
+    Returns true if \a item1 is on top of \a item2.
+    The items dont need to be siblings.
+    \internal
+*/
+inline bool qt_closestItemFirst(const QGraphicsItem *item1, const QGraphicsItem *item2)
+{
+    // Siblings? Just check their z-values.
+    const QGraphicsItemPrivate *d1 = item1->d_ptr.data();
+    const QGraphicsItemPrivate *d2 = item2->d_ptr.data();
+    if (d1->parent == d2->parent)
+        return qt_closestLeaf(item1, item2);
+    // Find common ancestor, and each item's ancestor closest to the common
+    // ancestor.
+    int item1Depth = d1->depth();
+    int item2Depth = d2->depth();
+    const QGraphicsItem *p = item1;
+    const QGraphicsItem *t1 = item1;
+    while (item1Depth > item2Depth && (p = p->d_ptr->parent)) {
+        if (p == item2) {
+            // item2 is one of item1's ancestors; item1 is on top
+            return !(t1->d_ptr->flags & QGraphicsItem::ItemStacksBehindParent);
+        }
+        t1 = p;
+        --item1Depth;
+    }
+    p = item2;
+    const QGraphicsItem *t2 = item2;
+    while (item2Depth > item1Depth && (p = p->d_ptr->parent)) {
+        if (p == item1) {
+            // item1 is one of item2's ancestors; item1 is not on top
+            return (t2->d_ptr->flags & QGraphicsItem::ItemStacksBehindParent);
+        }
+        t2 = p;
+        --item2Depth;
+    }
+    // item1Ancestor is now at the same level as item2Ancestor, but not the same.
+    const QGraphicsItem *p1 = t1;
+    const QGraphicsItem *p2 = t2;
+    while (t1 && t1 != t2) {
+        p1 = t1;
+        p2 = t2;
+        t1 = t1->d_ptr->parent;
+        t2 = t2->d_ptr->parent;
+    }
+    // in case we have a common ancestor, we compare the immediate children in the ancestor's path.
+    // otherwise we compare the respective items' topLevelItems directly.
+    return qt_closestLeaf(p1, p2);
+}
+/*!
+    Returns true if \a item2 is on top of \a item1.
+    The items dont need to be siblings.
+    \internal
+*/
+inline bool qt_closestItemLast(const QGraphicsItem *item1, const QGraphicsItem *item2)
+{
+    return qt_closestItemFirst(item2, item1);
+}
+/*!
+    \internal
+*/
+inline bool qt_closestLeaf(const QGraphicsItem *item1, const QGraphicsItem *item2)
+{
+    // Return true if sibling item1 is on top of item2.
+    const QGraphicsItemPrivate *d1 = item1->d_ptr.data();
+    const QGraphicsItemPrivate *d2 = item2->d_ptr.data();
+    bool f1 = d1->flags & QGraphicsItem::ItemStacksBehindParent;
+    bool f2 = d2->flags & QGraphicsItem::ItemStacksBehindParent;
+    if (f1 != f2)
+        return f2;
+    if (d1->z != d2->z)
+        return d1->z > d2->z;
+    return d1->siblingIndex > d2->siblingIndex;
+}
+/*!
+    \internal
+*/
+inline bool qt_notclosestLeaf(const QGraphicsItem *item1, const QGraphicsItem *item2)
+{ return qt_closestLeaf(item2, item1); }
+/*
+   return the full transform of the item to the parent.  This include the position and all the transform data
+*/
+inline QTransform QGraphicsItemPrivate::transformToParent() const
+{
+    QTransform matrix;
+    combineTransformToParent(&matrix);
+    return matrix;
+}
+/*!
+    \internal
+*/
+inline void QGraphicsItemPrivate::ensureSortedChildren()
+{
+    if (needSortChildren) {
+        qSort(children.begin(), children.end(), qt_notclosestLeaf);
+        needSortChildren = 0;
+        sequentialOrdering = 1;
+        for (int i = 0; i < children.size(); ++i) {
+            if (children[i]->d_ptr->siblingIndex != i) {
+                sequentialOrdering = 0;
+                break;
+            }
+        }
+    }
+}
+/*!
+    \internal
+*/
+inline bool QGraphicsItemPrivate::insertionOrder(QGraphicsItem *a, QGraphicsItem *b)
+{
+    return a->d_ptr->siblingIndex < b->d_ptr->siblingIndex;
+}
 QT_END_NAMESPACE

trunk/src/gui/graphicsview/qgraphicsitemanimation.cpp

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 …
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
     support for QGraphicsItem.
     \since 4.2
-    \ingroup multimedia
     \ingroup graphicsview-api
+    \deprecated
     The QGraphicsItemAnimation class animates a QGraphicsItem. You can

trunk/src/gui/graphicsview/qgraphicsitemanimation.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 …
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **

trunk/src/gui/graphicsview/qgraphicslayout.cpp

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 …
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
     in Graphics View.
     \since 4.4
-    \ingroup multimedia
     \ingroup graphicsview-api
 …
     \a parent is passed to QGraphicsLayoutItem's constructor and the
     QGraphicsLayoutItem's isLayout argument is set to \e true.
+    If \a parent is a QGraphicsWidget the layout will be installed
+    on that widget. (Note that installing a layout will delete the old one
+    installed.)
 */
 QGraphicsLayout::QGraphicsLayout(QGraphicsLayoutItem *parent)
 …
     reimplementation can assume that \a i is valid (i.e., it respects the
     value of count()).
+    The subclass is free to decide how to store the items.
+    Together with count(), it is provided as a means of iterating over all items in a layout.
+    The subclass is free to decide how to store the items, and the visual arrangement
+    does not have to be reflected through this function.
     \sa count(), removeAt()
 …
 */
+/*!
+    \since 4.6
+    This function is a convenience function provided for custom layouts, and will go through
+    all items in the layout and reparent their graphics items to the closest QGraphicsWidget
+    ancestor of the layout.
+    If \a layoutItem is already in a different layout, it will be removed  from that layout.
+    If custom layouts want special behaviour they can ignore to use this function, and implement
+    their own behaviour.
+    \sa graphicsItem()
+ */
+void QGraphicsLayout::addChildLayoutItem(QGraphicsLayoutItem *layoutItem)
+{
+    Q_D(QGraphicsLayout);
+    d->addChildLayoutItem(layoutItem);
+}
 QT_END_NAMESPACE

trunk/src/gui/graphicsview/qgraphicslayout.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 …
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 protected:
     QGraphicsLayout(QGraphicsLayoutPrivate &, QGraphicsLayoutItem *);
+    void addChildLayoutItem(QGraphicsLayoutItem *layoutItem);
 private:
 …
     friend class QGraphicsWidget;
 };
+Q_DECLARE_INTERFACE(QGraphicsLayout, "com.trolltech.Qt.QGraphicsLayout")
 #endif

trunk/src/gui/graphicsview/qgraphicslayout_p.cpp

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 …
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
         return false;
     QGraphicsLayoutItem *child;
     for (int i = 0; (child = lay->itemAt(i)); ++i) {
+    for (int i = lay->count() - 1; i >= 0; --i) {
+        QGraphicsLayoutItem *child = lay->itemAt(i);
         if (child && child->isLayout()) {
             if (removeLayoutItemFromLayout(static_cast<QGraphicsLayout*>(child), layoutItem))

trunk/src/gui/graphicsview/qgraphicslayout_p.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 …
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 //
 // This file is not part of the Qt API.  It exists for the convenience
 // of qapplication_*.cpp, qwidget*.cpp and qfiledialog.cpp.  This header
 // file may change from version to version without notice, or even be removed.
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
 //
 // We mean it.
 …
 #include "qgraphicslayoutitem_p.h"
 #include <QtGui/qstyle.h>
+#include <QtGui/qwidget.h>
+#include <QtGui/qstyleoption.h>
 QT_BEGIN_NAMESPACE
 …
+}
 #endif
+class QLayoutStyleInfo
+{
+public:
+    inline QLayoutStyleInfo() { invalidate(); }
+    inline QLayoutStyleInfo(QStyle *style, QWidget *widget)
+        : m_valid(true), m_style(style), m_widget(widget)
+    {
+        Q_ASSERT(style);
+        if (widget) //###
+            m_styleOption.initFrom(widget);
+        m_defaultSpacing[0] = style->pixelMetric(QStyle::PM_LayoutHorizontalSpacing);
+        m_defaultSpacing[1] = style->pixelMetric(QStyle::PM_LayoutVerticalSpacing);
+    }
+    inline void invalidate() { m_valid = false; m_style = 0; m_widget = 0; }
+    inline QStyle *style() const { return m_style; }
+    inline QWidget *widget() const { return m_widget; }
+    inline bool operator==(const QLayoutStyleInfo &other)
+        { return m_style == other.m_style && m_widget == other.m_widget; }
+    inline bool operator!=(const QLayoutStyleInfo &other)
+        { return !(*this == other); }
+    inline void setDefaultSpacing(Qt::Orientation o, qreal spacing){
+        if (spacing >= 0)
+            m_defaultSpacing[o - 1] = spacing;
+    }
+    inline qreal defaultSpacing(Qt::Orientation o) const {
+        return m_defaultSpacing[o - 1];
+    }
+    inline qreal perItemSpacing(QSizePolicy::ControlType control1,
+                                  QSizePolicy::ControlType control2,
+                                  Qt::Orientation orientation) const
+    {
+        Q_ASSERT(style());
+        return style()->layoutSpacing(control1, control2, orientation, &m_styleOption, widget());
+    }
+private:
+    bool m_valid;
+    QStyle *m_style;
+    QWidget *m_widget;
+    QStyleOption m_styleOption;
+    qreal m_defaultSpacing[2];
+};
 class Q_AUTOTEST_EXPORT QGraphicsLayoutPrivate : public QGraphicsLayoutItemPrivate

trunk/src/gui/graphicsview/qgraphicslayoutitem.cpp

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 …
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 */
 QGraphicsLayoutItemPrivate::QGraphicsLayoutItemPrivate(QGraphicsLayoutItem *par, bool layout)
+    : parent(par), isLayout(layout), ownedByLayout(false), graphicsItem(0)
+{
+    : parent(par), userSizeHints(0), isLayout(layout), ownedByLayout(false), graphicsItem(0)
+{
+}
+/*!
+    \internal
+*/
+QGraphicsLayoutItemPrivate::~QGraphicsLayoutItemPrivate()
+{
+    // Remove any lazily allocated data
+    delete[] userSizeHints;
+}
 …
     for (int i = 0; i < Qt::NSizeHints; ++i) {
         cachedSizeHints[i] = constraint;
+        combineSize(cachedSizeHints[i], userSizeHints[i]);
+        if (userSizeHints)
+            combineSize(cachedSizeHints[i], userSizeHints[i]);
+    }
 …
 /*!
+    \internal
+     Ensures that userSizeHints is allocated.
+     This function must be called before any dereferencing.
+*/
+void QGraphicsLayoutItemPrivate::ensureUserSizeHints()
+{
+    if (!userSizeHints)
+        userSizeHints = new QSizeF[Qt::NSizeHints];
+}
+/*!
+    \internal
+    Sets the user size hint \a which to \a size. Use an invalid size to unset the size hint.
+ */
+void QGraphicsLayoutItemPrivate::setSize(Qt::SizeHint which, const QSizeF &size)
+{
+    Q_Q(QGraphicsLayoutItem);
+    if (userSizeHints) {
+        if (size == userSizeHints[which])
+            return;
+    } else if (!size.isValid()) {
+        return;
+    }
+    ensureUserSizeHints();
+    userSizeHints[which] = size;
+    q->updateGeometry();
+}
+/*!
+    \internal
+    Sets the width of the user size hint \a which to \a width.
+ */
+void QGraphicsLayoutItemPrivate::setSizeComponent(
+    Qt::SizeHint which, SizeComponent component, qreal value)
+{
+    Q_Q(QGraphicsLayoutItem);
+    ensureUserSizeHints();
+    qreal &userValue = (component == Width)
+        ? userSizeHints[which].rwidth()
+        : userSizeHints[which].rheight();
+    if (value == userValue)
+        return;
+    userValue = value;
+    q->updateGeometry();
+}
+/*!
     \class QGraphicsLayoutItem
     \brief The QGraphicsLayoutItem class can be inherited to allow your custom
     items to be managed by layouts.
     \since 4.4
-    \ingroup multimedia
     \ingroup graphicsview-api
 …
     protected constructor, or by calling setParentLayoutItem(). The
     parentLayoutItem() function returns a pointer to the item's layoutItem
     parent. If the item's parent is 0 or if the the parent does not inherit
+    parent. If the item's parent is 0 or if the parent does not inherit
     from QGraphicsItem, the parentLayoutItem() function then returns 0.
     isLayout() returns true if the QGraphicsLayoutItem subclass is itself a
 …
+        }
+    }
-    delete d_ptr;
+}
 …
 void QGraphicsLayoutItem::setMinimumSize(const QSizeF &size)
+{
+    Q_D(QGraphicsLayoutItem);
+    if (size == d->userSizeHints[Qt::MinimumSize])
+        return;
+    d->userSizeHints[Qt::MinimumSize] = size;
+    updateGeometry();
+    d_ptr->setSize(Qt::MinimumSize, size);
+}
 …
 void QGraphicsLayoutItem::setMinimumWidth(qreal width)
+{
+    Q_D(QGraphicsLayoutItem);
+    qreal &userSizeHint = d->userSizeHints[Qt::MinimumSize].rwidth();
+    if (width == userSizeHint)
+        return;
+    userSizeHint = width;
+    updateGeometry();
+    d_ptr->setSizeComponent(Qt::MinimumSize, d_ptr->Width, width);
+}
 …
 void QGraphicsLayoutItem::setMinimumHeight(qreal height)
+{
+    Q_D(QGraphicsLayoutItem);
+    qreal &userSizeHint = d->userSizeHints[Qt::MinimumSize].rheight();
+    if (height == userSizeHint)
+        return;
+    userSizeHint = height;
+    updateGeometry();
+    d_ptr->setSizeComponent(Qt::MinimumSize, d_ptr->Height, height);
+}
 …
 void QGraphicsLayoutItem::setPreferredSize(const QSizeF &size)
+{
+    Q_D(QGraphicsLayoutItem);
+    if (size == d->userSizeHints[Qt::PreferredSize])
+        return;
+    d->userSizeHints[Qt::PreferredSize] = size;
+    updateGeometry();
+    d_ptr->setSize(Qt::PreferredSize, size);
+}
 …
 void QGraphicsLayoutItem::setPreferredHeight(qreal height)
+{
+    Q_D(QGraphicsLayoutItem);
+    qreal &userSizeHint = d->userSizeHints[Qt::PreferredSize].rheight();
+    if (height == userSizeHint)
+        return;
+    userSizeHint = height;
+    updateGeometry();
+    d_ptr->setSizeComponent(Qt::PreferredSize, d_ptr->Height, height);
+}
 …
 void QGraphicsLayoutItem::setPreferredWidth(qreal width)
+{
+    Q_D(QGraphicsLayoutItem);
+    qreal &userSizeHint = d->userSizeHints[Qt::PreferredSize].rwidth();
+    if (width == userSizeHint)
+        return;
+    userSizeHint = width;
+    updateGeometry();
+    d_ptr->setSizeComponent(Qt::PreferredSize, d_ptr->Width, width);
+}
 …
 void QGraphicsLayoutItem::setMaximumSize(const QSizeF &size)
+{
+    Q_D(QGraphicsLayoutItem);
+    if (size == d->userSizeHints[Qt::MaximumSize])
+        return;
+    d->userSizeHints[Qt::MaximumSize] = size;
+    updateGeometry();
+    d_ptr->setSize(Qt::MaximumSize, size);
+}
 …
 void QGraphicsLayoutItem::setMaximumWidth(qreal width)
+{
+    Q_D(QGraphicsLayoutItem);
+    qreal &userSizeHint = d->userSizeHints[Qt::MaximumSize].rwidth();
+    if (width == userSizeHint)
+        return;
+    userSizeHint = width;
+    updateGeometry();
+    d_ptr->setSizeComponent(Qt::MaximumSize, d_ptr->Width, width);
+}
 …
 void QGraphicsLayoutItem::setMaximumHeight(qreal height)
+{
+    Q_D(QGraphicsLayoutItem);
+    qreal &userSizeHint = d->userSizeHints[Qt::MaximumSize].rheight();
+    if (height == userSizeHint)
+        return;
+    userSizeHint = height;
+    updateGeometry();
+    d_ptr->setSizeComponent(Qt::MaximumSize, d_ptr->Height, height);
+}
 …
 QSizeF QGraphicsLayoutItem::effectiveSizeHint(Qt::SizeHint which, const QSizeF &constraint) const
+{
+    Q_D(const QGraphicsLayoutItem);
+    if (!d->userSizeHints && constraint.isValid())
+        return constraint;
     // ### should respect size policy???
     return d_ptr->effectiveSizeHints(constraint)[which];
 …
 /*!
+    \since 4.6
     Returns whether a layout should delete this item in its destructor.
     If its true, then the layout will delete it. If its false, then it is
 …
+}
 /*!
+    \since 4.6
     Sets whether a layout should delete this item in its destructor or not.
     \a ownership must be true to in order for the layout to delete it.

trunk/src/gui/graphicsview/qgraphicslayoutitem.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 …
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 #define QGRAPHICSLAYOUTITEM_H
+#include <QtCore/qscopedpointer.h>
 #include <QtGui/qsizepolicy.h>
 #include <QtGui/qevent.h>
 …
     virtual QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const = 0;
     QGraphicsLayoutItemPrivate *d_ptr;
+    QScopedPointer<QGraphicsLayoutItemPrivate> d_ptr;
 private:
 …
     friend class QGraphicsLayout;
 };
+Q_DECLARE_INTERFACE(QGraphicsLayoutItem, "com.trolltech.Qt.QGraphicsLayoutItem")
 inline void QGraphicsLayoutItem::setMinimumSize(qreal aw, qreal ah)

trunk/src/gui/graphicsview/qgraphicslayoutitem_p.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 …
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 //
 // This file is not part of the Qt API.  It exists for the convenience
 // of qapplication_*.cpp, qwidget*.cpp and qfiledialog.cpp.  This header
 // file may change from version to version without notice, or even be removed.
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
 //
 // We mean it.
 …
     Q_DECLARE_PUBLIC(QGraphicsLayoutItem)
 public:
     virtual ~QGraphicsLayoutItemPrivate() {}
+    virtual ~QGraphicsLayoutItemPrivate();
     QGraphicsLayoutItemPrivate(QGraphicsLayoutItem *parent, bool isLayout);
     void init();
     QSizeF *effectiveSizeHints(const QSizeF &constraint) const;
     QGraphicsItem *parentItem() const;
+    void ensureUserSizeHints();
+    void setSize(Qt::SizeHint which, const QSizeF &size);
+    enum SizeComponent { Width, Height };
+    void setSizeComponent(Qt::SizeHint which, SizeComponent component, qreal value);
     QSizePolicy sizePolicy;
     QGraphicsLayoutItem *parent;
     QSizeF userSizeHints[Qt::NSizeHints];
+    QSizeF *userSizeHints;
     mutable QSizeF cachedSizeHints[Qt::NSizeHints];
     mutable QSizeF cachedConstraint;

trunk/src/gui/graphicsview/qgraphicslinearlayout.cpp

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 …
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
     layout for managing widgets in Graphics View.
     \since 4.4
-    \ingroup multimedia
     \ingroup graphicsview-api
 …
     You can add widgets, layouts, stretches (addStretch(), insertStretch() or
     setStretchFactor()), and spacings (setItemSpacing()) to a linear
     layout. The layout takes ownership of the items. In some cases when the layout
+    layout. The layout takes ownership of the items. In some cases when the layout
     item also inherits from QGraphicsItem (such as QGraphicsWidget) there will be a
     ambiguity in ownership because the layout item belongs to two ownership hierarchies.
 …
         wid = new QWidget;
     QGraphicsItem *item = parentItem();
     QStyle *style = (item && item->isWidget()) ? static_cast<QGraphicsWidget*>(item)->style() : qApp->style();
+    QStyle *style = (item && item->isWidget()) ? static_cast<QGraphicsWidget*>(item)->style() : QApplication::style();
     return QLayoutStyleInfo(style, wid);
+}
 …
         QGraphicsLayoutItem *item = itemAt(i);
         // The following lines can be removed, but this removes the item
         // from the layout more efficiently than the implementation of
+        // from the layout more efficiently than the implementation of
         // ~QGraphicsLayoutItem.
         removeAt(i);
 …
         return;
+    }
+    if (item == this) {
+        qWarning("QGraphicsLinearLayout::insertItem: cannot insert itself");
+        return;
+    }
     d->addChildLayoutItem(item);
 …
     d->fixIndex(&index);
     d->engine.insertRow(index, d->orientation);
     new QGridLayoutItem(&d->engine, item, d->gridRow(index), d->gridColumn(index));
+    new QGridLayoutItem(&d->engine, item, d->gridRow(index), d->gridColumn(index), 1, 1, 0, index);
     invalidate();
+}
 …
+{
     Q_D(QGraphicsLinearLayout);
+    if (QGridLayoutItem *gridItem = d->engine.itemAt(d->gridRow(index), d->gridColumn(index))) {
+    if (index < 0 || index >= d->engine.itemCount()) {
+        qWarning("QGraphicsLinearLayout::removeAt: invalid index %d", index);
+        return;
+    }
+    if (QGridLayoutItem *gridItem = d->engine.itemAt(index)) {
         if (QGraphicsLayoutItem *layoutItem = gridItem->layoutItem())
             layoutItem->setParentLayoutItem(0);
 …
+{
     Q_D(const QGraphicsLinearLayout);
     return d->engine.rowCount(d->orientation);
+    return d->engine.itemCount();
+}
 /*!
     \reimp
+    When iterating from 0 and up, it will return the items in the visual arranged order.
 */
 QGraphicsLayoutItem *QGraphicsLinearLayout::itemAt(int index) const
+{
     Q_D(const QGraphicsLinearLayout);
+    if (index < 0 || index >= d->engine.itemCount()) {
+        qWarning("QGraphicsLinearLayout::itemAt: invalid index %d", index);
+        return 0;
+    }
     QGraphicsLayoutItem *item = 0;
     if (QGridLayoutItem *gridItem = d->engine.itemAt(d->gridRow(index), d->gridColumn(index)))
+    if (QGridLayoutItem *gridItem = d->engine.itemAt(index))
         item = gridItem->layoutItem();
     return item;
 …
+}
+/*!
+    \internal
+*/
+void QGraphicsLinearLayout::dump(int indent) const
+{
 #ifdef QT_DEBUG
-void QGraphicsLinearLayout::dump(int indent) const
+{
     if (qt_graphicsLayoutDebug()) {
         Q_D(const QGraphicsLinearLayout);
 …
         d->engine.dump(indent + 1);
+    }
+}
 #endif
+}
 QT_END_NAMESPACE
 #endif //QT_NO_GRAPHICSVIEW

trunk/src/gui/graphicsview/qgraphicslinearlayout.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 …
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 #endif
-#ifdef QT_DEBUG
     void dump(int indent = 0) const;
-#endif
 protected:

trunk/src/gui/graphicsview/qgraphicsproxywidget.cpp

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 …
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 #include <QtGui/qstyleoption.h>
 #include <QtGui/qgraphicsview.h>
+#include <QtGui/qlistview.h>
+#include <QtGui/qlineedit.h>
+#include <QtGui/qtextedit.h>
 QT_BEGIN_NAMESPACE
 …
     a QWidget in a QGraphicsScene.
     \since 4.4
-    \ingroup multimedia
     \ingroup graphicsview-api
 …
     means that when an embedded QComboBox shows its popup list, a new
     QGraphicsProxyWidget is created automatically, embedding the popup, and
+    positioning it correctly.
+    positioning it correctly. This only works if the popup is child of the
+    embedded widget (for example QToolButton::setMenu() requires the QMenu instance
+    to be child of the QToolButton).
     \section1 Embedding a Widget with QGraphicsProxyWidget
 …
     in behavior from when it is not embedded.
+    \warning This class is provided for convenience when bridging
+    QWidgets and QGraphicsItems, it should not be used for
+    high-performance scenarios.
     \sa QGraphicsScene::addWidget(), QGraphicsWidget
 */
 extern bool qt_sendSpontaneousEvent(QObject *, QEvent *);
+extern bool qt_tab_all_widgets;
 /*!
 …
     QWidget *embeddedMouseGrabberPtr = (QWidget *)embeddedMouseGrabber;
     QApplicationPrivate::sendMouseEvent(receiver, mouseEvent, alienWidget, widget,
                                         &embeddedMouseGrabberPtr, lastWidgetUnderMouse);
+                                        &embeddedMouseGrabberPtr, lastWidgetUnderMouse, event->spontaneous());
     embeddedMouseGrabber = embeddedMouseGrabberPtr;
 …
 /*!
     \internal
+    Some of the logic is shared with QApplicationPrivate::focusNextPrevChild_helper
 */
 QWidget *QGraphicsProxyWidgetPrivate::findFocusChild(QWidget *child, bool next) const
 …
         if ((next && child == widget) || (!next && child == widget->d_func()->focus_prev)) {
              return 0;
+        }
+        }
+    }
     QWidget *oldChild = child;
+    uint focus_flag = qt_tab_all_widgets ? Qt::TabFocus : Qt::StrongFocus;
     do {
         if (child->isEnabled()
             && child->isVisibleTo(widget)
+            && (child->focusPolicy() & Qt::TabFocus)) {
+            return child;
+            && ((child->focusPolicy() & focus_flag) == focus_flag)
+            && !(child->d_func()->extra && child->d_func()->extra->focus_proxy)) {
+            return child;
+        }
         child = next ? child->d_func()->focus_next : child->d_func()->focus_prev;
 …
 /*!
     \internal
+*/
+void QGraphicsProxyWidgetPrivate::updateProxyInputMethodAcceptanceFromWidget()
+{
+    Q_Q(QGraphicsProxyWidget);
+    if (!widget)
+        return;
+    QWidget *focusWidget = widget->focusWidget();
+    if (!focusWidget)
+        focusWidget = widget;
+    q->setFlag(QGraphicsItem::ItemAcceptsInputMethod,
+               focusWidget->testAttribute(Qt::WA_InputMethodEnabled));
+}
+/*!
+    \internal
     Embeds \a subWin as a subwindow of this proxy widget. \a subWin must be a top-level
 …
     QWExtra *extra;
     if (!((extra = subWin->d_func()->extra) && extra->proxyWidget)) {
         QGraphicsProxyWidget *subProxy = new QGraphicsProxyWidget(q_func());
+        QGraphicsProxyWidget *subProxy = new QGraphicsProxyWidget(q_func(), subWin->windowFlags());
         subProxy->d_func()->setWidget_helper(subWin, false);
+    }
 …
     hidden or disabled after embedding is complete. The class documentation
     has a full overview over the shared state.
+    QGraphicsProxyWidget's window flags determine whether the widget, after
+    embedding, will be given window decorations or not.
     After this function returns, QGraphicsProxyWidget will keep its state
 …
         q->setCursor(widget->cursor());
 #endif
-    Qt::WFlags flags = newWidget->windowFlags();
-    if (newWidget->windowType() == Qt::Window)
-        flags &= ~Qt::Window;
-    q->setWindowFlags(flags);
     q->setEnabled(newWidget->isEnabled());
     q->setVisible(newWidget->isVisible());
 …
     updateProxyGeometryFromWidget();
+    updateProxyInputMethodAcceptanceFromWidget();
     // Hook up the event filter to keep the state up to date.
 …
         // of inputMethodEvent().
         QWidget *focusWidget = d->widget->focusWidget();
         if (focusWidget->testAttribute(Qt::WA_InputMethodEnabled))
+        if (focusWidget && focusWidget->testAttribute(Qt::WA_InputMethodEnabled))
             QApplication::sendEvent(focusWidget, event);
         break;
 …
+{
     Q_D(QGraphicsProxyWidget);
     if (!event || !d->widget || !d->widget->isVisible())
+    if (!event || !d->widget || !d->widget->isVisible() || !hasFocus())
         return;
 …
 #endif // QT_NO_CONTEXTMENU
+#ifndef QT_NO_DRAGANDDROP
 /*!
     \reimp
 …
             // Try to enter before we leave
             QDragEnterEvent dragEnter(receiverPos, event->possibleActions(), event->mimeData(), event->buttons(), event->modifiers());
             dragEnter.setDropAction(event->proposedAction());
+            dragEnter.setDropAction(event->proposedAction());
             QApplication::sendEvent(receiver, &dragEnter);
             event->setAccepted(dragEnter.isAccepted());
 …
 #endif
+}
+#endif
 /*!
 …
             d->widget->focusWidget()->setFocus(event->reason());
             return;
+        }
         break;
+        }
+        break;
+    }
+}
 …
   Creates a proxy widget for the given \a child of the widget
   contained in this proxy.
   This function makes it possible to aquire proxies for
   non top-level widgets. For instance, you can embed a dialog,

trunk/src/gui/graphicsview/qgraphicsproxywidget.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 …
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 #endif
+#ifndef QT_NO_DRAGANDDROP
     void dragEnterEvent(QGraphicsSceneDragDropEvent *event);
     void dragLeaveEvent(QGraphicsSceneDragDropEvent *event);
     void dragMoveEvent(QGraphicsSceneDragDropEvent *event);
     void dropEvent(QGraphicsSceneDragDropEvent *event);
+#endif
     void hoverEnterEvent(QGraphicsSceneHoverEvent *event);
 …
 private:
     Q_DISABLE_COPY(QGraphicsProxyWidget)
     Q_DECLARE_PRIVATE_D(QGraphicsItem::d_ptr, QGraphicsProxyWidget)
+    Q_DECLARE_PRIVATE_D(QGraphicsItem::d_ptr.data(), QGraphicsProxyWidget)
     Q_PRIVATE_SLOT(d_func(), void _q_removeWidgetSlot())

trunk/src/gui/graphicsview/qgraphicsproxywidget_p.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 …
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 //
 // This file is not part of the Qt API.  It exists for the convenience
 // of qapplication_*.cpp, qwidget*.cpp and qfiledialog.cpp.  This header
 // file may change from version to version without notice, or even be removed.
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
 //
 // We mean it.
 …
     void updateProxyGeometryFromWidget();
+    void updateProxyInputMethodAcceptanceFromWidget();
     QPointF mapToReceiver(const QPointF &pos, const QWidget *receiver) const;

trunk/src/gui/graphicsview/qgraphicsscene.cpp

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 …
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/
-static const int QGRAPHICSSCENE_INDEXTIMER_TIMEOUT = 2000;
 /*!
 …
     number of 2D graphical items.
     \since 4.2
-    \ingroup multimedia
     \ingroup graphicsview-api
+    \mainclass
     The class serves as a container for QGraphicsItems. It is used together
 …
 #include "qgraphicswidget.h"
 #include "qgraphicswidget_p.h"
+#include "qgraphicssceneindex_p.h"
+#include "qgraphicsscenebsptreeindex_p.h"
+#include "qgraphicsscenelinearindex_p.h"
 #include <QtCore/qdebug.h>
 …
 #include <QtGui/qtooltip.h>
 #include <QtGui/qtransform.h>
+#include <QtGui/qinputcontext.h>
+#include <QtGui/qgraphicseffect.h>
 #include <private/qapplication_p.h>
 #include <private/qobject_p.h>
 …
 #include <private/qt_x11_p.h>
 #endif
+#include <private/qgraphicseffect_p.h>
+#include <private/qgesturemanager_p.h>
+// #define GESTURE_DEBUG
+#ifndef GESTURE_DEBUG
+# define DEBUG if (0) qDebug
+#else
+# define DEBUG qDebug
+#endif
 QT_BEGIN_NAMESPACE
+static inline bool QRectF_intersects(const QRectF &s, const QRectF &r)
+{
+    qreal xp = s.left();
+    qreal yp = s.top();
+    qreal w = s.width();
+    qreal h = s.height();
+    qreal l1 = xp;
+    qreal r1 = xp;
+    if (w < 0)
+        l1 += w;
+    else
+        r1 += w;
+    qreal l2 = r.left();
+    qreal r2 = r.left();
+    if (w < 0)
+        l2 += r.width();
+    else
+        r2 += r.width();
+    if (l1 >= r2 || l2 >= r1)
+        return false;
+    qreal t1 = yp;
+    qreal b1 = yp;
+    if (h < 0)
+        t1 += h;
+    else
+        b1 += h;
+    qreal t2 = r.top();
+    qreal b2 = r.top();
+    if (r.height() < 0)
+        t2 += r.height();
+    else
+        b2 += r.height();
+    return !(t1 >= b2 || t2 >= b1);
+}
+// QRectF::intersects() returns false always if either the source or target
+// rectangle's width or height are 0. This works around that problem.
+static inline void _q_adjustRect(QRectF *rect)
+{
+    Q_ASSERT(rect);
+    if (!rect->width())
+        rect->adjust(-0.00001, 0, 0.00001, 0);
+    if (!rect->height())
+        rect->adjust(0, -0.00001, 0, 0.00001);
+}
+static inline QRectF adjustedItemBoundingRect(const QGraphicsItem *item)
+{
+    Q_ASSERT(item);
+    QRectF boundingRect(item->boundingRect());
+    _q_adjustRect(&boundingRect);
+    return boundingRect;
+}
+bool qt_sendSpontaneousEvent(QObject *receiver, QEvent *event);
 static void _q_hoverFromMouseEvent(QGraphicsSceneHoverEvent *hover, const QGraphicsSceneMouseEvent *mouseEvent)
 …
+}
+int QGraphicsScenePrivate::changedSignalIndex;
 /*!
     \internal
 */
 QGraphicsScenePrivate::QGraphicsScenePrivate()
+    : changedSignalMask(0),
+      indexMethod(QGraphicsScene::BspTreeIndex),
+      bspTreeDepth(0),
+    : indexMethod(QGraphicsScene::BspTreeIndex),
+      index(0),
       lastItemCount(0),
       hasSceneRect(false),
+      dirtyGrowingItemsBoundingRect(true),
       updateAll(false),
       calledEmitUpdated(false),
+      processDirtyItemsEmitted(false),
       selectionChanging(0),
       dirtyItemResetPending(false),
       regenerateIndex(true),
       purgePending(false),
       indexTimerId(0),
       restartIndexTimer(false),
+      needSortTopLevelItems(true),
+      unpolishedItemsModified(true),
+      holesInTopLevelSiblingIndex(false),
+      topLevelSequentialOrdering(true),
+      scenePosDescendantsUpdatePending(false),
       stickyFocus(false),
       hasFocus(false),
 …
       lastFocusItem(0),
       tabFocusFirst(0),
+      activeWindow(0),
+      activePanel(0),
+      lastActivePanel(0),
       activationRefCount(0),
+      childExplicitActivation(0),
       lastMouseGrabberItem(0),
       lastMouseGrabberItemHasImplicitMouseGrab(false),
 …
       enterWidget(0),
       lastDropAction(Qt::IgnoreAction),
+      allItemsIgnoreHoverEvents(true),
+      allItemsUseDefaultCursor(true),
       painterStateProtection(true),
       sortCacheEnabled(false),
       updatingSortCache(false),
       style(0)
+      style(0),
+      allItemsIgnoreTouchEvents(true)
+{
+}
 …
     Q_Q(QGraphicsScene);
+    index = new QGraphicsSceneBspTreeIndex(q);
     // Keep this index so we can check for connected slots later on.
+    changedSignalMask = (1 << q->metaObject()->indexOfSignal("changed(QList<QRectF>)"));
+    if (!changedSignalIndex) {
+        changedSignalIndex = signalIndex("changed(QList<QRectF>)");
+    }
     qApp->d_func()->scene_list.append(q);
     q->update();
 …
     \internal
 */
+QList<QGraphicsItem *> QGraphicsScenePrivate::estimateItemsInRect(const QRectF &rect) const
+{
+    const_cast<QGraphicsScenePrivate *>(this)->purgeRemovedItems();
+    const_cast<QGraphicsScenePrivate *>(this)->_q_updateSortCache();
+    if (indexMethod == QGraphicsScene::BspTreeIndex) {
+        // ### Only do this once in a while.
+        QGraphicsScenePrivate *that = const_cast<QGraphicsScenePrivate *>(this);
+        // Get items from BSP tree
+        QList<QGraphicsItem *> items = that->bspTree.items(rect);
+        // Fill in with any unindexed items
+        for (int i = 0; i < unindexedItems.size(); ++i) {
+            if (QGraphicsItem *item = unindexedItems.at(i)) {
+                if (!item->d_ptr->itemDiscovered && item->d_ptr->visible && !(item->d_ptr->ancestorFlags & QGraphicsItemPrivate::AncestorClipsChildren)) {
+                    QRectF boundingRect = item->sceneBoundingRect();
+                    if (QRectF_intersects(boundingRect, rect)) {
+                        item->d_ptr->itemDiscovered = 1;
+                        items << item;
+                    }
+                }
+            }
+        }
+        // Reset the discovered state of all discovered items
+        for (int i = 0; i < items.size(); ++i)
+            items.at(i)->d_func()->itemDiscovered = 0;
+        return items;
+    }
+    QList<QGraphicsItem *> itemsInRect;
+    for (int i = 0; i < unindexedItems.size(); ++i) {
+        if (QGraphicsItem *item = unindexedItems.at(i)) {
+            if (item->d_ptr->ancestorFlags & QGraphicsItemPrivate::AncestorClipsChildren)
+                continue;
+            if (item->d_ptr->visible && item->effectiveOpacity() > qreal(0.0))
+                itemsInRect << item;
+        }
+    }
+    for (int i = 0; i < indexedItems.size(); ++i) {
+        if (QGraphicsItem *item = indexedItems.at(i)) {
+            if (item->d_ptr->ancestorFlags & QGraphicsItemPrivate::AncestorClipsChildren)
+                continue;
+            if (item->d_ptr->visible && item->effectiveOpacity() > qreal(0.0))
+                itemsInRect << item;
+        }
+    }
+    return itemsInRect;
+}
+/*!
+    \internal
+*/
+void QGraphicsScenePrivate::addToIndex(QGraphicsItem *item)
+{
+    if (indexMethod == QGraphicsScene::BspTreeIndex) {
+        if (item->d_func()->index != -1) {
+            bspTree.insertItem(item, item->sceneBoundingRect());
+            foreach (QGraphicsItem *child, item->children())
+                child->addToIndex();
+        } else {
+            // The BSP tree is regenerated if the number of items grows to a
+            // certain threshold, or if the bounding rect of the graph doubles in
+            // size.
+            startIndexTimer();
+        }
+    }
+}
+/*!
+    \internal
+*/
+void QGraphicsScenePrivate::removeFromIndex(QGraphicsItem *item)
+{
+    if (indexMethod == QGraphicsScene::BspTreeIndex) {
+        int index = item->d_func()->index;
+        if (index != -1) {
+            bspTree.removeItem(item, item->sceneBoundingRect());
+            freeItemIndexes << index;
+            indexedItems[index] = 0;
+            item->d_func()->index = -1;
+            unindexedItems << item;
+            foreach (QGraphicsItem *child, item->children())
+                child->removeFromIndex();
+        }
+        startIndexTimer();
+    }
+}
+/*!
+    \internal
+*/
+void QGraphicsScenePrivate::resetIndex()
+{
+    purgeRemovedItems();
+    if (indexMethod == QGraphicsScene::BspTreeIndex) {
+        for (int i = 0; i < indexedItems.size(); ++i) {
+            if (QGraphicsItem *item = indexedItems.at(i)) {
+                item->d_ptr->index = -1;
+                unindexedItems << item;
+            }
+        }
+        indexedItems.clear();
+        freeItemIndexes.clear();
+        regenerateIndex = true;
+        startIndexTimer();
+    }
+}
+static inline int intmaxlog(int n)
+{
+    return  (n > 0 ? qMax(qCeil(qLn(qreal(n)) / qLn(qreal(2))), 5) : 0);
+}
+/*!
+    \internal
+*/
+void QGraphicsScenePrivate::_q_updateIndex()
+{
+    if (!indexTimerId)
+        return;
+    Q_Q(QGraphicsScene);
+    q->killTimer(indexTimerId);
+    indexTimerId = 0;
+    purgeRemovedItems();
+    // Add unindexedItems to indexedItems
+    QRectF unindexedItemsBoundingRect;
+    for (int i = 0; i < unindexedItems.size(); ++i) {
+        if (QGraphicsItem *item = unindexedItems.at(i)) {
+            unindexedItemsBoundingRect |= item->sceneBoundingRect();
+            if (!freeItemIndexes.isEmpty()) {
+                int freeIndex = freeItemIndexes.takeFirst();
+                item->d_func()->index = freeIndex;
+                indexedItems[freeIndex] = item;
+            } else {
+                item->d_func()->index = indexedItems.size();
+                indexedItems << item;
+            }
+        }
+    }
+    // Update growing scene rect.
+    QRectF oldGrowingItemsBoundingRect = growingItemsBoundingRect;
+    growingItemsBoundingRect |= unindexedItemsBoundingRect;
+    // Determine whether we should regenerate the BSP tree.
+    if (indexMethod == QGraphicsScene::BspTreeIndex) {
+        int depth = bspTreeDepth;
+        if (depth == 0) {
+            int oldDepth = intmaxlog(lastItemCount);
+            depth = intmaxlog(indexedItems.size());
+            static const int slack = 100;
+            if (bspTree.leafCount() == 0 || (oldDepth != depth && qAbs(lastItemCount - indexedItems.size()) > slack)) {
+                // ### Crude algorithm.
+                regenerateIndex = true;
+            }
+        }
+        // Regenerate the tree.
+        if (regenerateIndex) {
+            regenerateIndex = false;
+            bspTree.initialize(q->sceneRect(), depth);
+            unindexedItems = indexedItems;
+            lastItemCount = indexedItems.size();
+            q->update();
+            // Take this opportunity to reset our largest-item counter for
+            // untransformable items. When the items are inserted into the BSP
+            // tree, we'll get an accurate calculation.
+            largestUntransformableItem = QRectF();
+        }
+    }
+    // Insert all unindexed items into the tree.
+    for (int i = 0; i < unindexedItems.size(); ++i) {
+        if (QGraphicsItem *item = unindexedItems.at(i)) {
+            QRectF rect = item->sceneBoundingRect();
+            if (item->d_ptr->ancestorFlags & QGraphicsItemPrivate::AncestorClipsChildren)
+                continue;
+            if (indexMethod == QGraphicsScene::BspTreeIndex)
+                bspTree.insertItem(item, rect);
+            // If the item ignores view transformations, update our
+            // largest-item-counter to ensure that the view can accurately
+            // discover untransformable items when drawing.
+            if (item->d_ptr->itemIsUntransformable()) {
+                QGraphicsItem *topmostUntransformable = item;
+                while (topmostUntransformable && (topmostUntransformable->d_ptr->ancestorFlags
+                                                  & QGraphicsItemPrivate::AncestorIgnoresTransformations)) {
+                    topmostUntransformable = topmostUntransformable->parentItem();
+                }
+                // ### Verify that this is the correct largest untransformable rectangle.
+                largestUntransformableItem |= item->mapToItem(topmostUntransformable, item->boundingRect()).boundingRect();
+            }
+        }
+    }
+    unindexedItems.clear();
+    // Notify scene rect changes.
+    if (!hasSceneRect && growingItemsBoundingRect != oldGrowingItemsBoundingRect)
+        emit q->sceneRectChanged(growingItemsBoundingRect);
+}
+/*!
+    \internal
+*/
+QGraphicsScenePrivate *QGraphicsScenePrivate::get(QGraphicsScene *q)
+{
+    return q->d_func();
+}
 void QGraphicsScenePrivate::_q_emitUpdated()
+{
     Q_Q(QGraphicsScene);
     calledEmitUpdated = false;
+    if (dirtyGrowingItemsBoundingRect) {
+        if (!hasSceneRect) {
+            const QRectF oldGrowingItemsBoundingRect = growingItemsBoundingRect;
+            growingItemsBoundingRect |= q->itemsBoundingRect();
+            if (oldGrowingItemsBoundingRect != growingItemsBoundingRect)
+                emit q->sceneRectChanged(growingItemsBoundingRect);
+        }
+        dirtyGrowingItemsBoundingRect = false;
+    }
     // Ensure all views are connected if anything is connected. This disables
 …
     // needs to happen in order to keep compatibility with the behavior from
     // Qt 4.4 and backward.
     if (!views.isEmpty() && (connectedSignals & changedSignalMask)) {
+    if (isSignalConnected(changedSignalIndex)) {
         for (int i = 0; i < views.size(); ++i) {
             QGraphicsView *view = views.at(i);
 …
+            }
+        }
+    }
+    // Ensure all dirty items's current positions are recorded in the list of
+    // updated rects.
+    for (int i = 0; i < dirtyItems.size(); ++i)
+        updatedRects += dirtyItems.at(i)->sceneBoundingRect();
+    } else {
+        updateAll = false;
+        for (int i = 0; i < views.size(); ++i)
+            views.at(i)->d_func()->processPendingUpdates();
+        // It's important that we update all views before we dispatch, hence two for-loops.
+        for (int i = 0; i < views.size(); ++i)
+            views.at(i)->d_func()->dispatchPendingUpdateRequests();
+        return;
+    }
     // Notify the changes to anybody interested.
 …
     \internal
     Updates all items in the pending update list. At this point, the list is
+    unlikely to contain partially constructed items.
+*/
+void QGraphicsScenePrivate::_q_updateLater()
+{
     foreach (QGraphicsItem *item, pendingUpdateItems)
         item->update();
     pendingUpdateItems.clear();
+    ### This function is almost identical to QGraphicsItemPrivate::addChild().
+*/
+void QGraphicsScenePrivate::registerTopLevelItem(QGraphicsItem *item)
+{
+    item->d_ptr->ensureSequentialSiblingIndex();
+    needSortTopLevelItems = true; // ### maybe false
+    item->d_ptr->siblingIndex = topLevelItems.size();
+    topLevelItems.append(item);
+}
 /*!
     \internal
+    ### This function is almost identical to QGraphicsItemPrivate::removeChild().
+*/
+void QGraphicsScenePrivate::unregisterTopLevelItem(QGraphicsItem *item)
+{
+    if (!holesInTopLevelSiblingIndex)
+        holesInTopLevelSiblingIndex = item->d_ptr->siblingIndex != topLevelItems.size() - 1;
+    if (topLevelSequentialOrdering && !holesInTopLevelSiblingIndex)
+        topLevelItems.removeAt(item->d_ptr->siblingIndex);
+    else
+        topLevelItems.removeOne(item);
+    // NB! Do not use topLevelItems.removeAt(item->d_ptr->siblingIndex) because
+    // the item is not guaranteed to be at the index after the list is sorted
+    // (see ensureSortedTopLevelItems()).
+    item->d_ptr->siblingIndex = -1;
+    if (topLevelSequentialOrdering)
+        topLevelSequentialOrdering = !holesInTopLevelSiblingIndex;
+}
+/*!
+    \internal
 */
 void QGraphicsScenePrivate::_q_polishItems()
+{
+    QSet<QGraphicsItem *>::Iterator it = unpolishedItems.begin();
     const QVariant booleanTrueVariant(true);
+    foreach (QGraphicsItem *item, unpolishedItems) {
+    while (!unpolishedItems.isEmpty()) {
+        QGraphicsItem *item = *it;
+        it = unpolishedItems.erase(it);
+        unpolishedItemsModified = false;
         if (!item->d_ptr->explicitlyHidden) {
             item->itemChange(QGraphicsItem::ItemVisibleChange, booleanTrueVariant);
 …
             QApplication::sendEvent((QGraphicsWidget *)item, &event);
+        }
+    }
+    unpolishedItems.clear();
+        if (unpolishedItemsModified)
+            it = unpolishedItems.begin();
+    }
+}
+void QGraphicsScenePrivate::_q_processDirtyItems()
+{
+    processDirtyItemsEmitted = false;
+    if (updateAll) {
+        Q_ASSERT(calledEmitUpdated);
+        // No need for further processing (except resetting the dirty states).
+        // The growingItemsBoundingRect is updated in _q_emitUpdated.
+        for (int i = 0; i < topLevelItems.size(); ++i)
+            resetDirtyItem(topLevelItems.at(i), /*recursive=*/true);
+        return;
+    }
+    const bool wasPendingSceneUpdate = calledEmitUpdated;
+    const QRectF oldGrowingItemsBoundingRect = growingItemsBoundingRect;
+    // Process items recursively.
+    for (int i = 0; i < topLevelItems.size(); ++i)
+        processDirtyItemsRecursive(topLevelItems.at(i));
+    dirtyGrowingItemsBoundingRect = false;
+    if (!hasSceneRect && oldGrowingItemsBoundingRect != growingItemsBoundingRect)
+        emit q_func()->sceneRectChanged(growingItemsBoundingRect);
+    if (wasPendingSceneUpdate)
+        return;
+    for (int i = 0; i < views.size(); ++i)
+        views.at(i)->d_func()->processPendingUpdates();
+    if (calledEmitUpdated) {
+        // We did a compatibility QGraphicsScene::update in processDirtyItemsRecursive
+        // and we cannot wait for the control to reach the eventloop before the
+        // changed signal is emitted, so we emit it now.
+        _q_emitUpdated();
+    }
+    // Immediately dispatch all pending update requests on the views.
+    for (int i = 0; i < views.size(); ++i)
+        views.at(i)->d_func()->dispatchPendingUpdateRequests();
+}
 …
     \internal
 */
+void QGraphicsScenePrivate::_q_resetDirtyItems()
+{
+    for (int i = 0; i < dirtyItems.size(); ++i) {
+        QGraphicsItem *item = dirtyItems.at(i);
+        item->d_ptr->dirty = 0;
+        item->d_ptr->dirtyChildren = 0;
+    }
+    dirtyItems.clear();
+    dirtyItemResetPending = false;
+void QGraphicsScenePrivate::setScenePosItemEnabled(QGraphicsItem *item, bool enabled)
+{
+    QGraphicsItem *p = item->d_ptr->parent;
+    while (p) {
+        p->d_ptr->scenePosDescendants = enabled;
+        p = p->d_ptr->parent;
+    }
+    if (!enabled && !scenePosDescendantsUpdatePending) {
+        scenePosDescendantsUpdatePending = true;
+        QMetaObject::invokeMethod(q_func(), "_q_updateScenePosDescendants", Qt::QueuedConnection);
+    }
+}
 …
     \internal
 */
+void QGraphicsScenePrivate::resetDirtyItemsLater()
+{
+    Q_Q(QGraphicsScene);
+    if (dirtyItemResetPending)
+        return;
+    // dirtyItems.reserve(indexedItems.size() + unindexedItems.size());
+    dirtyItemResetPending = true;
+    QMetaObject::invokeMethod(q, "_q_resetDirtyItems", Qt::QueuedConnection);
+void QGraphicsScenePrivate::registerScenePosItem(QGraphicsItem *item)
+{
+    scenePosItems.insert(item);
+    setScenePosItemEnabled(item, true);
+}
 /*!
     \internal
+*/
+void QGraphicsScenePrivate::unregisterScenePosItem(QGraphicsItem *item)
+{
+    scenePosItems.remove(item);
+    setScenePosItemEnabled(item, false);
+}
+/*!
+    \internal
+*/
+void QGraphicsScenePrivate::_q_updateScenePosDescendants()
+{
+    foreach (QGraphicsItem *item, scenePosItems) {
+        QGraphicsItem *p = item->d_ptr->parent;
+        while (p) {
+            p->d_ptr->scenePosDescendants = 1;
+            p = p->d_ptr->parent;
+        }
+    }
+    scenePosDescendantsUpdatePending = false;
+}
+/*!
+    \internal
     Schedules an item for removal. This function leaves some stale indexes
     around in the BSP tree; these will be cleaned up the next time someone
     triggers purgeRemovedItems().
     Note: This function is called from QGraphicsItem's destructor. \a item is
+    around in the BSP tree if called from the item's destructor; these will
+    be cleaned up the next time someone triggers purgeRemovedItems().
+    Note: This function might get called from QGraphicsItem's destructor. \a item is
     being destroyed, so we cannot call any pure virtual functions on it (such
     as boundingRect()). Also, it is unnecessary to update the item's own state
     in any way.
+    ### Refactoring: This function shares much functionality with removeItem()
+*/
+void QGraphicsScenePrivate::_q_removeItemLater(QGraphicsItem *item)
+*/
+void QGraphicsScenePrivate::removeItemHelper(QGraphicsItem *item)
+{
     Q_Q(QGraphicsScene);
+    // Clear focus on the item to remove any reference in the focusWidget
+    // chain.
+    // Clear focus on the item to remove any reference in the focusWidget chain.
     item->clearFocus();
+    int index = item->d_func()->index;
+    if (index != -1) {
+        // Important: The index is useless until purgeRemovedItems() is
+        // called.
+        indexedItems[index] = (QGraphicsItem *)0;
+        if (!purgePending) {
+            purgePending = true;
+            q->update();
+        }
+        removedItems << item;
+    markDirty(item, QRectF(), /*invalidateChildren=*/false, /*force=*/false,
+              /*ignoreOpacity=*/false, /*removingItemFromScene=*/true);
+    if (item->d_ptr->inDestructor) {
+        // The item is actually in its destructor, we call the special method in the index.
+        index->deleteItem(item);
     } else {
+        // Recently added items are purged immediately. unindexedItems() never
+        // contains stale items.
+        unindexedItems.removeAll(item);
+        q->update();
+        // Can potentially call item->boundingRect() (virtual function), that's why
+        // we only can call this function if the item is not in its destructor.
+        index->removeItem(item);
+    }
+    item->d_ptr->clearSubFocus();
+    if (item->flags() & QGraphicsItem::ItemSendsScenePositionChanges)
+        unregisterScenePosItem(item);
+    QGraphicsScene *oldScene = item->d_func()->scene;
+    item->d_func()->scene = 0;
+    //We need to remove all children first because they might use their parent
+    //attributes (e.g. sceneTransform).
+    if (!item->d_ptr->inDestructor) {
+        // Remove all children recursively
+        for (int i = 0; i < item->d_ptr->children.size(); ++i)
+            q->removeItem(item->d_ptr->children.at(i));
+    }
+    if (!item->d_ptr->inDestructor && item == tabFocusFirst) {
+        QGraphicsWidget *widget = static_cast<QGraphicsWidget *>(item);
+        widget->d_func()->fixFocusChainBeforeReparenting(0, oldScene, 0);
+    }
+    // Unregister focus proxy.
+    item->d_ptr->resetFocusProxy();
+    // Remove from parent, or unregister from toplevels.
+    if (QGraphicsItem *parentItem = item->parentItem()) {
+        if (parentItem->scene()) {
+            Q_ASSERT_X(parentItem->scene() == q, "QGraphicsScene::removeItem",
+                       "Parent item's scene is different from this item's scene");
+            item->d_ptr->setParentItemHelper(0);
+        }
+    } else {
+        unregisterTopLevelItem(item);
+    }
 …
     if (item == lastFocusItem)
         lastFocusItem = 0;
     if (item == activeWindow) {
+    if (item == activePanel) {
         // ### deactivate...
+        activeWindow = 0;
+        activePanel = 0;
+    }
+    if (item == lastActivePanel)
+        lastActivePanel = 0;
+    // Cancel active touches
+    {
+        QMap<int, QGraphicsItem *>::iterator it = itemForTouchPointId.begin();
+        while (it != itemForTouchPointId.end()) {
+            if (it.value() == item) {
+                sceneCurrentTouchPoints.remove(it.key());
+                it = itemForTouchPointId.erase(it);
+            } else {
+                ++it;
+            }
+        }
+    }
 …
     selectedItems.remove(item);
     hoverItems.removeAll(item);
-    pendingUpdateItems.removeAll(item);
     cachedItemsUnderMouse.removeAll(item);
+    unpolishedItems.removeAll(item);
+    dirtyItems.removeAll(item);
+    unpolishedItems.remove(item);
+    unpolishedItemsModified = true;
+    resetDirtyItem(item);
     //We remove all references of item from the sceneEventFilter arrays
 …
+    }
+    // Remove from scene transform cache
+    int transformIndex = item->d_func()->sceneTransformIndex;
+    if (transformIndex != -1) {
+        validTransforms.setBit(transformIndex, 0);
+        freeSceneTransformSlots.append(transformIndex);
+    }
+    // Remove all children recursively.
+    foreach (QGraphicsItem *child, item->children())
+        _q_removeItemLater(child);
+    // Reset the mouse grabber
+    if (item->isPanel() && item->isVisible() && item->panelModality() != QGraphicsItem::NonModal)
+        leaveModal(item);
+    // Reset the mouse grabber and focus item data.
     if (mouseGrabberItems.contains(item))
         ungrabMouse(item, /* item is dying */ true);
+        ungrabMouse(item, /* item is dying */ item->d_ptr->inDestructor);
     // Reset the keyboard grabber
     if (keyboardGrabberItems.contains(item))
         ungrabKeyboard(item, /* item is dying */ true);
+        ungrabKeyboard(item, /* item is dying */ item->d_ptr->inDestructor);
     // Reset the last mouse grabber item
 …
 /*!
     \internal
+    Removes stale pointers from all data structures.
+*/
+void QGraphicsScenePrivate::purgeRemovedItems()
+*/
+void QGraphicsScenePrivate::setActivePanelHelper(QGraphicsItem *item, bool duringActivationEvent)
+{
     Q_Q(QGraphicsScene);
+    if (!purgePending && removedItems.isEmpty())
+    if (item && item->scene() != q) {
+        qWarning("QGraphicsScene::setActivePanel: item %p must be part of this scene",
+                 item);
         return;
+    // Remove stale items from the BSP tree.
+    if (indexMethod != QGraphicsScene::NoIndex)
+        bspTree.removeItems(removedItems);
+    // Purge this list.
+    removedItems.clear();
+    freeItemIndexes.clear();
+    for (int i = 0; i < indexedItems.size(); ++i) {
+        if (!indexedItems.at(i))
+            freeItemIndexes << i;
+    }
+    purgePending = false;
+    // No locality info for the items; update the whole scene.
+    q->update();
+    }
+    // Ensure the scene has focus when we change panel activation.
+    q->setFocus(Qt::ActiveWindowFocusReason);
+    // Find the item's panel.
+    QGraphicsItem *panel = item ? item->panel() : 0;
+    lastActivePanel = panel ? activePanel : 0;
+    if (panel == activePanel || (!q->isActive() && !duringActivationEvent))
+        return;
+    // Deactivate the last active panel.
+    if (activePanel) {
+        if (QGraphicsItem *fi = activePanel->focusItem()) {
+            // Remove focus from the current focus item.
+            if (fi == q->focusItem())
+                q->setFocusItem(0, Qt::ActiveWindowFocusReason);
+        }
+        QEvent event(QEvent::WindowDeactivate);
+        q->sendEvent(activePanel, &event);
+    } else if (panel && !duringActivationEvent) {
+        // Deactivate the scene if changing activation to a panel.
+        QEvent event(QEvent::WindowDeactivate);
+        foreach (QGraphicsItem *item, q->items()) {
+            if (item->isVisible() && !item->isPanel() && !item->parentItem())
+                q->sendEvent(item, &event);
+        }
+    }
+    // Update activate state.
+    activePanel = panel;
+    QEvent event(QEvent::ActivationChange);
+    QApplication::sendEvent(q, &event);
+    // Activate
+    if (panel) {
+        QEvent event(QEvent::WindowActivate);
+        q->sendEvent(panel, &event);
+        // Set focus on the panel's focus item.
+        if (QGraphicsItem *focusItem = panel->focusItem())
+            focusItem->setFocus(Qt::ActiveWindowFocusReason);
+    } else if (q->isActive()) {
+        // Activate the scene
+        QEvent event(QEvent::WindowActivate);
+        foreach (QGraphicsItem *item, q->items()) {
+            if (item->isVisible() && !item->isPanel() && !item->parentItem())
+                q->sendEvent(item, &event);
+        }
+    }
+}
 /*!
     \internal
+    Starts or restarts the timer used for reindexing unindexed items.
+*/
+void QGraphicsScenePrivate::startIndexTimer()
+*/
+void QGraphicsScenePrivate::setFocusItemHelper(QGraphicsItem *item,
+                                               Qt::FocusReason focusReason)
+{
     Q_Q(QGraphicsScene);
+    if (indexTimerId) {
+        restartIndexTimer = true;
+    } else {
+        indexTimerId = q->startTimer(QGRAPHICSSCENE_INDEXTIMER_TIMEOUT);
+    }
+    if (item == focusItem)
+        return;
+    // Clear focus if asked to set focus on something that can't
+    // accept input focus.
+    if (item && (!(item->flags() & QGraphicsItem::ItemIsFocusable)
+                 || !item->isVisible() || !item->isEnabled())) {
+        item = 0;
+    }
+    // Set focus on the scene if an item requests focus.
+    if (item) {
+        q->setFocus(focusReason);
+        if (item == focusItem)
+            return;
+    }
+    if (focusItem) {
+        QFocusEvent event(QEvent::FocusOut, focusReason);
+        lastFocusItem = focusItem;
+        focusItem = 0;
+        sendEvent(lastFocusItem, &event);
+#ifndef QT_NO_IM
+        if (lastFocusItem
+            && (lastFocusItem->flags() & QGraphicsItem::ItemAcceptsInputMethod)) {
+            // Reset any visible preedit text
+            QInputMethodEvent imEvent;
+            sendEvent(lastFocusItem, &imEvent);
+            // Close any external input method panel. This happens
+            // automatically by removing WA_InputMethodEnabled on
+            // the views, but if we are changing focus, we have to
+            // do it ourselves.
+            if (item) {
+                for (int i = 0; i < views.size(); ++i)
+                    views.at(i)->inputContext()->reset();
+            }
+        }
+#endif //QT_NO_IM
+    }
+    if (item) {
+        focusItem = item;
+        QFocusEvent event(QEvent::FocusIn, focusReason);
+        sendEvent(item, &event);
+    }
+    updateInputMethodSensitivityInViews();
+}
 …
             QFocusEvent event(QEvent::FocusIn, Qt::PopupFocusReason);
             sendEvent(focusItem, &event);
         } else {
             ungrabKeyboard((QGraphicsItem *)widget, itemIsDying);
+        } else if (keyboardGrabberItems.contains(static_cast<QGraphicsItem *>(widget))) {
+            ungrabKeyboard(static_cast<QGraphicsItem *>(widget), itemIsDying);
+        }
         if (!itemIsDying && widget->isVisible()) {
 …
     // Append to list of mouse grabber items, and send a mouse grab event.
     if (mouseGrabberItems.contains(item)) {
+        if (mouseGrabberItems.last() == item)
+            qWarning("QGraphicsItem::grabMouse: already a mouse grabber");
+        else
+        if (mouseGrabberItems.last() == item) {
+            Q_ASSERT(!implicit);
+            if (!lastMouseGrabberItemHasImplicitMouseGrab) {
+                qWarning("QGraphicsItem::grabMouse: already a mouse grabber");
+            } else {
+                // Upgrade to an explicit mouse grab
+                lastMouseGrabberItemHasImplicitMouseGrab = false;
+            }
+        } else {
             qWarning("QGraphicsItem::grabMouse: already blocked by mouse grabber: %p",
                      mouseGrabberItems.last());
+        }
         return;
+    }
 …
+}
+void QGraphicsScenePrivate::enableMouseTrackingOnViews()
+{
+    foreach (QGraphicsView *view, views)
+        view->viewport()->setMouseTracking(true);
+}
 /*!
     Returns all items for the screen position in \a event.
 …
     Q_Q(const QGraphicsScene);
     QGraphicsView *view = widget ? qobject_cast<QGraphicsView *>(widget->parentWidget()) : 0;
+    QList<QGraphicsItem *> items;
+    if (view)
+        items = view->items(view->viewport()->mapFromGlobal(screenPos));
+    else
+        items = q->items(scenePos);
+    return items;
+}
+/*!
+    \internal
+    Checks if item collides with the path and mode, but also checks that if it
+    doesn't collide, maybe its frame rect will.
+*/
+bool QGraphicsScenePrivate::itemCollidesWithPath(QGraphicsItem *item,
+                                                 const QPainterPath &path,
+                                                 Qt::ItemSelectionMode mode)
+{
+    if (item->collidesWithPath(path, mode))
+        return true;
+    if (item->isWidget()) {
+        // Check if this is a window, and if its frame rect collides.
+        QGraphicsWidget *widget = static_cast<QGraphicsWidget *>(item);
+        if (widget->isWindow()) {
+            QRectF frameRect = widget->windowFrameRect();
+            QPainterPath framePath;
+            framePath.addRect(frameRect);
+            bool intersects = path.intersects(frameRect);
+            if (mode == Qt::IntersectsItemShape || mode == Qt::IntersectsItemBoundingRect)
+                return intersects || path.contains(frameRect.topLeft())
+                    || framePath.contains(path.elementAt(0));
+            return !intersects && path.contains(frameRect.topLeft());
+        }
+    }
+    return false;
+    if (!view)
+        return q->items(scenePos, Qt::IntersectsItemShape, Qt::DescendingOrder, QTransform());
+    const QRectF pointRect(QPointF(widget->mapFromGlobal(screenPos)), 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,
+                    Qt::DescendingOrder, viewTransform);
+}
 …
             mouseGrabberButtonDownPos.insert(Qt::MouseButton(i),
                                              mouseGrabberItems.last()->d_ptr->genericMapFromScene(event->scenePos(),
                                                                                           event->widget()));
+                                                                                                  event->widget()));
             mouseGrabberButtonDownScenePos.insert(Qt::MouseButton(i), event->scenePos());
             mouseGrabberButtonDownScreenPos.insert(Qt::MouseButton(i), event->screenPos());
 …
 /*!
+  \internal
+*/
+bool QGraphicsScenePrivate::filterDescendantEvent(QGraphicsItem *item, QEvent *event)
+{
+    if (item && (item->d_ptr->ancestorFlags & QGraphicsItemPrivate::AncestorFiltersChildEvents)) {
+        QGraphicsItem *parent = item->parentItem();
+        while (parent) {
+            if (parent->d_ptr->filtersDescendantEvents && parent->sceneEventFilter(item, event))
+                return true;
+            if (!(parent->d_ptr->ancestorFlags & QGraphicsItemPrivate::AncestorFiltersChildEvents))
+                return false;
+            parent = parent->parentItem();
+        }
+    }
+    return false;
+}
+/*!
     \internal
 */
 …
 bool QGraphicsScenePrivate::sendEvent(QGraphicsItem *item, QEvent *event)
+{
+    if (QGraphicsObject *object = item->toGraphicsObject()) {
+        QGestureManager *gestureManager = QApplicationPrivate::instance()->gestureManager;
+        if (gestureManager) {
+            if (gestureManager->filterEvent(object, event))
+                return true;
+        }
+    }
     if (filterEvent(item, event))
         return false;
+    return (item && item->isEnabled()) ? item->sceneEvent(event) : false;
+    if (filterDescendantEvent(item, event))
+        return false;
+    if (!item || !item->isEnabled())
+        return false;
+    if (QGraphicsObject *o = item->toGraphicsObject()) {
+        bool spont = event->spontaneous();
+        if (spont ? qt_sendSpontaneousEvent(o, event) : QApplication::sendEvent(o, event))
+            return true;
+        event->spont = spont;
+    }
+    return item->sceneEvent(event);
+}
 …
     QGraphicsItem *item = mouseGrabberItems.last();
+    if (item->isBlockedByModalPanel())
+        return;
     for (int i = 0x1; i <= 0x10; i <<= 1) {
         Qt::MouseButton button = Qt::MouseButton(i);
 …
     // Deliver to any existing mouse grabber.
     if (!mouseGrabberItems.isEmpty()) {
+        if (mouseGrabberItems.last()->isBlockedByModalPanel())
+            return;
         // The event is ignored by default, but we disregard the event's
         // accepted state after delivery; the mouse is grabbed, after all.
 …
     // Update window activation.
+    QGraphicsWidget *newActiveWindow = windowForItem(cachedItemsUnderMouse.value(0));
+    if (newActiveWindow != activeWindow)
+    QGraphicsItem *topItem = cachedItemsUnderMouse.value(0);
+    QGraphicsWidget *newActiveWindow = topItem ? topItem->window() : 0;
+    if (newActiveWindow && newActiveWindow->isBlockedByModalPanel(&topItem)) {
+        // pass activation to the blocking modal window
+        newActiveWindow = topItem ? topItem->window() : 0;
+    }
+    if (newActiveWindow != q->activeWindow())
         q->setActiveWindow(newActiveWindow);
 …
     bool setFocus = false;
     foreach (QGraphicsItem *item, cachedItemsUnderMouse) {
+        if (item->isEnabled() && (item->flags() & QGraphicsItem::ItemIsFocusable)) {
+        if (item->isBlockedByModalPanel()) {
+            // Make sure we don't clear focus.
+            setFocus = true;
+            break;
+        }
+        if (item->isEnabled() && ((item->flags() & QGraphicsItem::ItemIsFocusable) && item->d_ptr->mouseSetsFocus)) {
             if (!item->isWidget() || ((QGraphicsWidget *)item)->focusPolicy() & Qt::ClickFocus) {
                 setFocus = true;
 …
+            }
+        }
+        if (item->isPanel())
+            break;
+    }
+    // Check for scene modality.
+    bool sceneModality = false;
+    for (int i = 0; i < modalPanels.size(); ++i) {
+        if (modalPanels.at(i)->panelModality() == QGraphicsItem::SceneModal) {
+            sceneModality = true;
+            break;
+        }
+    }
     // If nobody could take focus, clear it.
     if (!stickyFocus && !setFocus)
+    if (!stickyFocus && !setFocus && !sceneModality)
         q->setFocusItem(0, Qt::MouseFocusReason);
+    // Any item will do.
+    if (sceneModality && cachedItemsUnderMouse.isEmpty())
+        cachedItemsUnderMouse << modalPanels.first();
     // Find a mouse grabber by sending mouse press events to all mouse grabber
 …
+        }
+        // Check if this item is blocked by a modal panel and deliver the mouse event to the
+        // blocking panel instead of this item if blocked.
+        (void) item->isBlockedByModalPanel(&item);
         grabMouse(item, /* implicit = */ true);
         mouseEvent->accept();
 …
         // check if the item we are sending to are disabled (before we send the event)
         bool disabled = !item->isEnabled();
+        bool isWindow = item->isWindow();
+        if (mouseEvent->type() == QEvent::GraphicsSceneMouseDoubleClick && item != lastMouseGrabberItem) {
+        bool isPanel = item->isPanel();
+        if (mouseEvent->type() == QEvent::GraphicsSceneMouseDoubleClick
+            && item != lastMouseGrabberItem && lastMouseGrabberItem) {
             // If this item is different from the item that received the last
             // mouse event, and mouseEvent is a doubleclick event, then the
 …
             // Triple-clicking will not generate a doubleclick, though.
             QGraphicsSceneMouseEvent mousePress(QEvent::GraphicsSceneMousePress);
+            mousePress.spont = mouseEvent->spont;
             mousePress.accept();
             mousePress.setButton(mouseEvent->button());
 …
         ungrabMouse(item, /* itemIsDying = */ dontSendUngrabEvents);
         // Don't propagate through windows.
         if (isWindow)
+        // Don't propagate through panels.
+        if (isPanel)
             break;
+    }
 …
+}
-QGraphicsWidget *QGraphicsScenePrivate::windowForItem(const QGraphicsItem *item) const
+{
-    if (!item)
-        return 0;
-    do {
-        if (item->isWidget())
-            return static_cast<const QGraphicsWidget *>(item)->window();
-        item = item->parentItem();
-    } while (item);
-    return 0;
+}
-QList<QGraphicsItem *> QGraphicsScenePrivate::items_helper(const QPointF &pos) const
+{
-    QList<QGraphicsItem *> items;
-    // The index returns a rough estimate of what items are inside the rect.
-    // Refine it by iterating through all returned items.
-    QRectF adjustedRect = QRectF(pos, QSize(1,1));
-    foreach (QGraphicsItem *item, estimateItemsInRect(adjustedRect)) {
-        // Find the item's scene transform in a clever way.
-        QTransform x = item->sceneTransform();
-        bool keep = false;
-        // ### _q_adjustedRect is only needed because QRectF::intersects,
-        // QRectF::contains and QTransform::map() and friends don't work with
-        // flat rectangles.
-        const QRectF br(adjustedItemBoundingRect(item));
-            // Rect intersects/contains item's shape
-        if (QRectF_intersects(adjustedRect, x.mapRect(br))) {
-            bool ok;
-            QTransform xinv = x.inverted(&ok);
-            if (ok) {
-                if (item->contains(xinv.map(pos))) {
-                    items << item;
-                    keep = true;
+                }
+            }
+        }
-        if (keep && (item->flags() & QGraphicsItem::ItemClipsChildrenToShape)) {
-            // Recurse into children that clip children.
-            bool ok;
-            QTransform xinv = x.inverted(&ok);
-            if (ok)
-                childItems_helper(&items, item, xinv.map(pos));
+        }
+    }
-    sortItems(&items, Qt::AscendingOrder, sortCacheEnabled);
-    return items;
+}
-QList<QGraphicsItem *> QGraphicsScenePrivate::items_helper(const QRectF &rect,
-                                                           Qt::ItemSelectionMode mode,
-                                                           Qt::SortOrder order) const
+{
-    QList<QGraphicsItem *> items;
-    QPainterPath path;
-    // The index returns a rough estimate of what items are inside the rect.
-    // Refine it by iterating through all returned items.
-    QRectF adjustedRect(rect);
-    _q_adjustRect(&adjustedRect);
-    foreach (QGraphicsItem *item, estimateItemsInRect(adjustedRect)) {
-        // Find the item's scene transform in a clever way.
-        QTransform x = item->sceneTransform();
-        bool keep = false;
-        // ### _q_adjustedRect is only needed because QRectF::intersects,
-        // QRectF::contains and QTransform::map() and friends don't work with
-        // flat rectangles.
-        const QRectF br(adjustedItemBoundingRect(item));
-        if (mode >= Qt::ContainsItemBoundingRect) {
-            // Rect intersects/contains item's bounding rect
-            QRectF mbr = x.mapRect(br);
-            if ((mode == Qt::IntersectsItemBoundingRect && QRectF_intersects(rect, mbr))
-                || (mode == Qt::ContainsItemBoundingRect && rect != mbr && rect.contains(mbr))) {
-                items << item;
-                keep = true;
+            }
-        } else {
-            // Rect intersects/contains item's shape
-            if (QRectF_intersects(adjustedRect, x.mapRect(br))) {
-                bool ok;
-                QTransform xinv = x.inverted(&ok);
-                if (ok) {
-                    if (path.isEmpty())
-                        path.addRect(rect);
-                    if (itemCollidesWithPath(item, xinv.map(path), mode)) {
-                        items << item;
-                        keep = true;
+                    }
+                }
+            }
+        }
-        if (keep && (item->flags() & QGraphicsItem::ItemClipsChildrenToShape)) {
-            // Recurse into children that clip children.
-            bool ok;
-            QTransform xinv = x.inverted(&ok);
-            if (ok) {
-                if (x.type() <= QTransform::TxScale) {
-                    // Rect
-                    childItems_helper(&items, item, xinv.mapRect(rect), mode);
-                } else {
-                    // Polygon
-                    childItems_helper(&items, item, xinv.map(rect), mode);
+                }
+            }
+        }
+    }
-    if (order != Qt::SortOrder(-1))
-        sortItems(&items, order, sortCacheEnabled);
-    return items;
+}
-QList<QGraphicsItem *> QGraphicsScenePrivate::items_helper(const QPolygonF &polygon,
-                                                           Qt::ItemSelectionMode mode,
-                                                           Qt::SortOrder order) const
+{
-    QList<QGraphicsItem *> items;
-    QRectF polyRect(polygon.boundingRect());
-     _q_adjustRect(&polyRect);
-    QPainterPath path;
-    // The index returns a rough estimate of what items are inside the rect.
-    // Refine it by iterating through all returned items.
-    foreach (QGraphicsItem *item, estimateItemsInRect(polyRect)) {
-        // Find the item's scene transform in a clever way.
-        QTransform x = item->sceneTransform();
-        bool keep = false;
-        // ### _q_adjustedRect is only needed because QRectF::intersects,
-        // QRectF::contains and QTransform::map() and friends don't work with
-        // flat rectangles.
-        const QRectF br(adjustedItemBoundingRect(item));
-        if (mode >= Qt::ContainsItemBoundingRect) {
-            // Polygon contains/intersects item's bounding rect
-            if (path == QPainterPath())
-                path.addPolygon(polygon);
-            if ((mode == Qt::IntersectsItemBoundingRect && path.intersects(x.mapRect(br)))
-                || (mode == Qt::ContainsItemBoundingRect && path.contains(x.mapRect(br)))) {
-                items << item;
-                keep = true;
+            }
-        } else {
-            // Polygon contains/intersects item's shape
-            if (QRectF_intersects(polyRect, x.mapRect(br))) {
-                bool ok;
-                QTransform xinv = x.inverted(&ok);
-                if (ok) {
-                    if (path == QPainterPath())
-                        path.addPolygon(polygon);
-                    if (itemCollidesWithPath(item, xinv.map(path), mode)) {
-                        items << item;
-                        keep = true;
+                    }
+                }
+            }
+        }
-        if (keep && (item->flags() & QGraphicsItem::ItemClipsChildrenToShape)) {
-            // Recurse into children that clip children.
-            bool ok;
-            QTransform xinv = x.inverted(&ok);
-            if (ok)
-                childItems_helper(&items, item, xinv.map(polygon), mode);
+        }
+    }
-    if (order != Qt::SortOrder(-1))
-        sortItems(&items, order, sortCacheEnabled);
-    return items;
+}
-QList<QGraphicsItem *> QGraphicsScenePrivate::items_helper(const QPainterPath &path,
-                                                           Qt::ItemSelectionMode mode,
-                                                           Qt::SortOrder order) const
+{
-    QList<QGraphicsItem *> items;
-    QRectF pathRect(path.controlPointRect());
-    _q_adjustRect(&pathRect);
-    // The index returns a rough estimate of what items are inside the rect.
-    // Refine it by iterating through all returned items.
-    foreach (QGraphicsItem *item, estimateItemsInRect(pathRect)) {
-        // Find the item's scene transform in a clever way.
-        QTransform x = item->sceneTransform();
-        bool keep = false;
-        // ### _q_adjustedRect is only needed because QRectF::intersects,
-        // QRectF::contains and QTransform::map() and friends don't work with
-        // flat rectangles.
-        const QRectF br(adjustedItemBoundingRect(item));
-        if (mode >= Qt::ContainsItemBoundingRect) {
-            // Path contains/intersects item's bounding rect
-            if ((mode == Qt::IntersectsItemBoundingRect && path.intersects(x.mapRect(br)))
-                || (mode == Qt::ContainsItemBoundingRect && path.contains(x.mapRect(br)))) {
-                items << item;
-                keep = true;
+            }
-        } else {
-            // Path contains/intersects item's shape
-            if (QRectF_intersects(pathRect, x.mapRect(br))) {
-                bool ok;
-                QTransform xinv = x.inverted(&ok);
-                if (ok) {
-                    if (itemCollidesWithPath(item, xinv.map(path), mode)) {
-                        items << item;
-                        keep = true;
+                    }
+                }
+            }
+        }
-        if (keep && (item->flags() & QGraphicsItem::ItemClipsChildrenToShape)) {
-            bool ok;
-            QTransform xinv = x.inverted(&ok);
-            if (ok)
-                childItems_helper(&items, item, xinv.map(path), mode);
+        }
+    }
-    if (order != Qt::SortOrder(-1))
-        sortItems(&items, order, sortCacheEnabled);
-    return items;
+}
-void QGraphicsScenePrivate::childItems_helper(QList<QGraphicsItem *> *items,
-                                              const QGraphicsItem *parent,
-                                              const QPointF &pos) const
+{
-    bool parentClip = (parent->flags() & QGraphicsItem::ItemClipsChildrenToShape);
-    if (parentClip && parent->d_ptr->isClippedAway())
-        return;
-    // ### is this needed?
-    if (parentClip && !parent->boundingRect().contains(pos))
-        return;
-    QList<QGraphicsItem *> &children = parent->d_ptr->children;
-    for (int i = 0; i < children.size(); ++i) {
-        QGraphicsItem *item = children.at(i);
-        if (item->d_ptr->hasTransform && !item->transform().isInvertible())
-            continue;
-        // Skip invisible items and all their children.
-        if (item->d_ptr->isInvisible())
-            continue;
-        bool keep = false;
-        if (!item->d_ptr->isClippedAway()) {
-            if (item->contains(item->mapFromParent(pos))) {
-                items->append(item);
-                keep = true;
+            }
+        }
-        if ((keep || !(item->flags() & QGraphicsItem::ItemClipsChildrenToShape)) && !item->d_ptr->children.isEmpty())
-            // Recurse into children.
-            childItems_helper(items, item, item->mapFromParent(pos));
+    }
+}
-void QGraphicsScenePrivate::childItems_helper(QList<QGraphicsItem *> *items,
-                                              const QGraphicsItem *parent,
-                                              const QRectF &rect,
-                                              Qt::ItemSelectionMode mode) const
+{
-    bool parentClip = (parent->flags() & QGraphicsItem::ItemClipsChildrenToShape);
-    if (parentClip && parent->d_ptr->isClippedAway())
-        return;
-    QRectF adjustedRect(rect);
-    _q_adjustRect(&adjustedRect);
-    QRectF r = !parentClip ? adjustedRect : adjustedRect.intersected(adjustedItemBoundingRect(parent));
-    if (r.isEmpty())
-        return;
-    QPainterPath path;
-    QList<QGraphicsItem *> &children = parent->d_ptr->children;
-    for (int i = 0; i < children.size(); ++i) {
-        QGraphicsItem *item = children.at(i);
-        if (item->d_ptr->hasTransform && !item->transform().isInvertible())
-            continue;
-        // Skip invisible items and all their children.
-        if (item->d_ptr->isInvisible())
-            continue;
-        bool keep = false;
-        if (!item->d_ptr->isClippedAway()) {
-            // ### _q_adjustedRect is only needed because QRectF::intersects,
-            // QRectF::contains and QTransform::map() and friends don't work with
-            // flat rectangles.
-            const QRectF br(adjustedItemBoundingRect(item));
-            QRectF mbr = item->mapRectToParent(br);
-            if (mode >= Qt::ContainsItemBoundingRect) {
-                // Rect intersects/contains item's bounding rect
-                if ((mode == Qt::IntersectsItemBoundingRect && QRectF_intersects(rect, mbr))
-                    || (mode == Qt::ContainsItemBoundingRect && rect != mbr && rect.contains(br))) {
-                    items->append(item);
-                    keep = true;
+                }
-            } else {
-                // Rect intersects/contains item's shape
-                if (QRectF_intersects(rect, mbr)) {
-                    if (path == QPainterPath())
-                        path.addRect(rect);
-                    if (itemCollidesWithPath(item, item->mapFromParent(path), mode)) {
-                        items->append(item);
-                        keep = true;
+                    }
+                }
+            }
+        }
-        if ((keep || !(item->flags() & QGraphicsItem::ItemClipsChildrenToShape)) && !item->d_ptr->children.isEmpty()) {
-            // Recurse into children.
-            if (!item->d_ptr->hasTransform || item->transform().type() <= QTransform::TxScale) {
-                // Rect
-                childItems_helper(items, item, item->mapRectFromParent(rect), mode);
-            } else {
-                // Polygon
-                childItems_helper(items, item, item->mapFromParent(rect), mode);
+            }
+        }
+    }
+}
-void QGraphicsScenePrivate::childItems_helper(QList<QGraphicsItem *> *items,
-                                              const QGraphicsItem *parent,
-                                              const QPolygonF &polygon,
-                                              Qt::ItemSelectionMode mode) const
+{
-    bool parentClip = (parent->flags() & QGraphicsItem::ItemClipsChildrenToShape);
-    if (parentClip && parent->d_ptr->isClippedAway())
-        return;
-    QRectF polyRect(polygon.boundingRect());
-    _q_adjustRect(&polyRect);
-    QRectF r = !parentClip ? polyRect : polyRect.intersected(adjustedItemBoundingRect(parent));
-    if (r.isEmpty())
-        return;
-    QPainterPath path;
-    QList<QGraphicsItem *> &children = parent->d_ptr->children;
-    for (int i = 0; i < children.size(); ++i) {
-        QGraphicsItem *item = children.at(i);
-        if (item->d_ptr->hasTransform && !item->transform().isInvertible())
-            continue;
-        // Skip invisible items.
-        if (item->d_ptr->isInvisible())
-            continue;
-        bool keep = false;
-        if (!item->d_ptr->isClippedAway()) {
-            // ### _q_adjustedRect is only needed because QRectF::intersects,
-            // QRectF::contains and QTransform::map() and friends don't work with
-            // flat rectangles.
-            const QRectF br(adjustedItemBoundingRect(item));
-            if (mode >= Qt::ContainsItemBoundingRect) {
-                // Polygon contains/intersects item's bounding rect
-                if (path == QPainterPath())
-                    path.addPolygon(polygon);
-                if ((mode == Qt::IntersectsItemBoundingRect && path.intersects(item->mapRectToParent(br)))
-                    || (mode == Qt::ContainsItemBoundingRect && path.contains(item->mapRectToParent(br)))) {
-                    items->append(item);
-                    keep = true;
+                }
-            } else {
-                // Polygon contains/intersects item's shape
-                if (QRectF_intersects(polyRect, item->mapRectToParent(br))) {
-                    if (path == QPainterPath())
-                        path.addPolygon(polygon);
-                    if (itemCollidesWithPath(item, item->mapFromParent(path), mode)) {
-                        items->append(item);
-                        keep = true;
+                    }
+                }
+            }
+        }
-        if ((keep || !(item->flags() & QGraphicsItem::ItemClipsChildrenToShape)) && !item->d_ptr->children.isEmpty()) {
-            // Recurse into children that clip children.
-            childItems_helper(items, item, item->mapFromParent(polygon), mode);
+        }
+    }
+}
-void QGraphicsScenePrivate::childItems_helper(QList<QGraphicsItem *> *items,
-                                              const QGraphicsItem *parent,
-                                              const QPainterPath &path,
-                                              Qt::ItemSelectionMode mode) const
+{
-    bool parentClip = (parent->flags() & QGraphicsItem::ItemClipsChildrenToShape);
-    if (parentClip && parent->d_ptr->isClippedAway())
-        return;
-    QRectF pathRect(path.boundingRect());
-    _q_adjustRect(&pathRect);
-    QRectF r = !parentClip ? pathRect : pathRect.intersected(adjustedItemBoundingRect(parent));
-    if (r.isEmpty())
-        return;
-    QList<QGraphicsItem *> &children = parent->d_ptr->children;
-    for (int i = 0; i < children.size(); ++i) {
-        QGraphicsItem *item = children.at(i);
-        if (item->d_ptr->hasTransform && !item->transform().isInvertible())
-            continue;
-        // Skip invisible items.
-        if (item->d_ptr->isInvisible())
-            continue;
-        bool keep = false;
-        if (!item->d_ptr->isClippedAway()) {
-            // ### _q_adjustedRect is only needed because QRectF::intersects,
-            // QRectF::contains and QTransform::map() and friends don't work with
-            // flat rectangles.
-            const QRectF br(adjustedItemBoundingRect(item));
-            if (mode >= Qt::ContainsItemBoundingRect) {
-                // Polygon contains/intersects item's bounding rect
-                if ((mode == Qt::IntersectsItemBoundingRect && path.intersects(item->mapRectToParent(br)))
-                    || (mode == Qt::ContainsItemBoundingRect && path.contains(item->mapRectToParent(br)))) {
-                    items->append(item);
-                    keep = true;
+                }
-            } else {
-                // Path contains/intersects item's shape
-                if (QRectF_intersects(pathRect, item->mapRectToParent(br))) {
-                    if (itemCollidesWithPath(item, item->mapFromParent(path), mode)) {
-                        items->append(item);
-                        keep = true;
+                    }
+                }
+            }
+        }
-        if ((keep || !(item->flags() & QGraphicsItem::ItemClipsChildrenToShape)) && !item->d_ptr->children.isEmpty()) {
-            // Recurse into children that clip children.
-            childItems_helper(items, item, item->mapFromParent(path), mode);
+        }
+    }
+}
-void QGraphicsScenePrivate::invalidateSortCache()
+{
-    Q_Q(QGraphicsScene);
-    if (!sortCacheEnabled || updatingSortCache)
-        return;
-    updatingSortCache = true;
-    QMetaObject::invokeMethod(q, "_q_updateSortCache", Qt::QueuedConnection);
+}
 /*!
     \internal
+    Should not be exported, but we can't change that now.
+    ### Qt 5: Remove symbol / make static
+*/
+inline bool qt_closestLeaf(const QGraphicsItem *item1, const QGraphicsItem *item2)
+{
+    // Return true if sibling item1 is on top of item2.
+    const QGraphicsItemPrivate *d1 = item1->d_ptr;
+    const QGraphicsItemPrivate *d2 = item2->d_ptr;
+    bool f1 = d1->flags & QGraphicsItem::ItemStacksBehindParent;
+    bool f2 = d2->flags & QGraphicsItem::ItemStacksBehindParent;
+    if (f1 != f2) return f2;
+    qreal z1 = d1->z;
+    qreal z2 = d2->z;
+    return z1 != z2 ? z1 > z2 : item1 > item2;
+}
+/*!
+    \internal
+    Should not be exported, but we can't change that now.
+*/
+inline bool qt_closestItemFirst(const QGraphicsItem *item1, const QGraphicsItem *item2)
+{
+    return QGraphicsScenePrivate::closestItemFirst_withoutCache(item1, item2);
+}
+/*!
+    Returns true if \a item1 is on top of \a item2.
+    \internal
+*/
+bool QGraphicsScenePrivate::closestItemFirst_withoutCache(const QGraphicsItem *item1, const QGraphicsItem *item2)
+{
+    // Siblings? Just check their z-values.
+    const QGraphicsItemPrivate *d1 = item1->d_ptr;
+    const QGraphicsItemPrivate *d2 = item2->d_ptr;
+    if (d1->parent == d2->parent)
+        return qt_closestLeaf(item1, item2);
+    // Find common ancestor, and each item's ancestor closest to the common
+    // ancestor.
+    int item1Depth = d1->depth;
+    int item2Depth = d2->depth;
+    const QGraphicsItem *p = item1;
+    const QGraphicsItem *t1 = item1;
+    while (item1Depth > item2Depth && (p = p->d_ptr->parent)) {
+        if (p == item2) {
+            // item2 is one of item1's ancestors; item1 is on top
+            return !(t1->d_ptr->flags & QGraphicsItem::ItemStacksBehindParent);
+        }
+        t1 = p;
+        --item1Depth;
+    }
+    p = item2;
+    const QGraphicsItem *t2 = item2;
+    while (item2Depth > item1Depth && (p = p->d_ptr->parent)) {
+        if (p == item1) {
+            // item1 is one of item2's ancestors; item1 is not on top
+            return (t2->d_ptr->flags & QGraphicsItem::ItemStacksBehindParent);
+        }
+        t2 = p;
+        --item2Depth;
+    }
+    // item1Ancestor is now at the same level as item2Ancestor, but not the same.
+    const QGraphicsItem *a1 = t1;
+    const QGraphicsItem *a2 = t2;
+    while (a1) {
+        const QGraphicsItem *p1 = a1;
+        const QGraphicsItem *p2 = a2;
+        a1 = a1->parentItem();
+        a2 = a2->parentItem();
+        if (a1 && a1 == a2)
+            return qt_closestLeaf(p1, p2);
+    }
+    // No common ancestor? Then just compare the items' toplevels directly.
+    return qt_closestLeaf(t1->topLevelItem(), t2->topLevelItem());
+}
+/*!
+    Returns true if \a item2 is on top of \a item1.
+    \internal
+*/
+bool QGraphicsScenePrivate::closestItemLast_withoutCache(const QGraphicsItem *item1, const QGraphicsItem *item2)
+{
+    return closestItemFirst_withoutCache(item2, item1);
+}
+void QGraphicsScenePrivate::climbTree(QGraphicsItem *item, int *stackingOrder)
+{
+    if (!item->d_ptr->children.isEmpty()) {
+        QList<QGraphicsItem *> childList = item->d_ptr->children;
+        qSort(childList.begin(), childList.end(), qt_closestLeaf);
+        for (int i = 0; i < childList.size(); ++i) {
+            QGraphicsItem *item = childList.at(i);
+            if (!(item->flags() & QGraphicsItem::ItemStacksBehindParent))
+                climbTree(childList.at(i), stackingOrder);
+        }
+        item->d_ptr->globalStackingOrder = (*stackingOrder)++;
+        for (int i = 0; i < childList.size(); ++i) {
+            QGraphicsItem *item = childList.at(i);
+            if (item->flags() & QGraphicsItem::ItemStacksBehindParent)
+                climbTree(childList.at(i), stackingOrder);
+        }
+    } else {
+        item->d_ptr->globalStackingOrder = (*stackingOrder)++;
+    }
+}
+void QGraphicsScenePrivate::_q_updateSortCache()
+{
+    _q_updateIndex();
+    if (!sortCacheEnabled || !updatingSortCache)
+        return;
+    updatingSortCache = false;
+    int stackingOrder = 0;
+    QList<QGraphicsItem *> topLevels;
+    for (int i = 0; i < indexedItems.size(); ++i) {
+        QGraphicsItem *item = indexedItems.at(i);
+        if (item && item->parentItem() == 0)
+            topLevels << item;
+    }
+    for (int i = 0; i < unindexedItems.size(); ++i) {
+        QGraphicsItem *item = unindexedItems.at(i);
+        if (item->parentItem() == 0)
+            topLevels << item;
+    }
+    qSort(topLevels.begin(), topLevels.end(), qt_closestLeaf);
+    for (int i = 0; i < topLevels.size(); ++i)
+        climbTree(topLevels.at(i), &stackingOrder);
+}
+void QGraphicsScenePrivate::sortItems(QList<QGraphicsItem *> *itemList, Qt::SortOrder order,
+                                      bool sortCacheEnabled)
+{
+    if (sortCacheEnabled) {
+        if (order == Qt::AscendingOrder) {
+            qSort(itemList->begin(), itemList->end(), closestItemFirst_withCache);
+        } else if (order == Qt::DescendingOrder) {
+            qSort(itemList->begin(), itemList->end(), closestItemLast_withCache);
+        }
+    } else {
+        if (order == Qt::AscendingOrder) {
+            qSort(itemList->begin(), itemList->end(), closestItemFirst_withoutCache);
+        } else if (order == Qt::DescendingOrder) {
+            qSort(itemList->begin(), itemList->end(), closestItemLast_withoutCache);
+        }
+    Ensures that the list of toplevels is sorted by insertion order, and that
+    the siblingIndexes are packed (no gaps), and start at 0.
+    ### This function is almost identical to
+    QGraphicsItemPrivate::ensureSequentialSiblingIndex().
+*/
+void QGraphicsScenePrivate::ensureSequentialTopLevelSiblingIndexes()
+{
+    if (!topLevelSequentialOrdering) {
+        qSort(topLevelItems.begin(), topLevelItems.end(), QGraphicsItemPrivate::insertionOrder);
+        topLevelSequentialOrdering = true;
+        needSortTopLevelItems = 1;
+    }
+    if (holesInTopLevelSiblingIndex) {
+        holesInTopLevelSiblingIndex = 0;
+        for (int i = 0; i < topLevelItems.size(); ++i)
+            topLevelItems[i]->d_ptr->siblingIndex = i;
+    }
+}
 …
 void QGraphicsScenePrivate::resolveFont()
+{
     QFont naturalFont = qApp->font();
+    QFont naturalFont = QApplication::font();
     naturalFont.resolve(0);
     QFont resolvedFont = font.resolve(naturalFont);
 …
 void QGraphicsScenePrivate::resolvePalette()
+{
     QPalette naturalPalette = qApp->palette();
+    QPalette naturalPalette = QApplication::palette();
     naturalPalette.resolve(0);
     QPalette resolvedPalette = palette.resolve(naturalPalette);
 …
     : QObject(*new QGraphicsScenePrivate, parent)
+{
+    d_func()->init();
     setSceneRect(sceneRect);
-    d_func()->init();
+}
 …
     : QObject(*new QGraphicsScenePrivate, parent)
+{
+    d_func()->init();
     setSceneRect(x, y, width, height);
+    d_func()->init();
+}
+/*!
+    Destroys the QGraphicsScene object.
+}
+/*!
+  Removes and deletes all items from the scene object
+  before destroying the scene object. The scene object
+  is removed from the application's global scene list,
+  and it is removed from all associated views.
 */
 QGraphicsScene::~QGraphicsScene()
+{
     Q_D(QGraphicsScene);
     // Remove this scene from qApp's global scene list.
     qApp->d_func()->scene_list.removeAll(this);
 …
+{
     Q_D(const QGraphicsScene);
+    const_cast<QGraphicsScenePrivate *>(d)->_q_updateIndex();
+    return d->hasSceneRect ? d->sceneRect : d->growingItemsBoundingRect;
+    if (d->hasSceneRect)
+        return d->sceneRect;
+    if (d->dirtyGrowingItemsBoundingRect) {
+        // Lazily update the growing items bounding rect
+        QGraphicsScenePrivate *thatd = const_cast<QGraphicsScenePrivate *>(d);
+        QRectF oldGrowingBoundingRect = thatd->growingItemsBoundingRect;
+        thatd->growingItemsBoundingRect |= itemsBoundingRect();
+        thatd->dirtyGrowingItemsBoundingRect = false;
+        if (oldGrowingBoundingRect != thatd->growingItemsBoundingRect)
+            emit const_cast<QGraphicsScene *>(this)->sceneRectChanged(thatd->growingItemsBoundingRect);
+    }
+    return d->growingItemsBoundingRect;
+}
 void QGraphicsScene::setSceneRect(const QRectF &rect)
 …
         d->hasSceneRect = !rect.isNull();
         d->sceneRect = rect;
+        d->resetIndex();
+        emit sceneRectChanged(rect);
+        emit sceneRectChanged(d->hasSceneRect ? rect : d->growingItemsBoundingRect);
+    }
+}
 …
                             Qt::AspectRatioMode aspectRatioMode)
+{
     Q_D(QGraphicsScene);
+    // ### Switch to using the recursive rendering algorithm instead.
     // Default source rect = scene rect
 …
     // Generate the style options
     QStyleOptionGraphicsItem *styleOptionArray = new QStyleOptionGraphicsItem[numItems];
+    for (int i = 0; i < numItems; ++i) {
+        QGraphicsItem *item = itemArray[i];
+        QStyleOptionGraphicsItem option;
+        option.state = QStyle::State_None;
+        option.rect = item->boundingRect().toRect();
+        if (item->isSelected())
+            option.state |= QStyle::State_Selected;
+        if (item->isEnabled())
+            option.state |= QStyle::State_Enabled;
+        if (item->hasFocus())
+            option.state |= QStyle::State_HasFocus;
+        if (d->hoverItems.contains(item))
+            option.state |= QStyle::State_MouseOver;
+        if (item == mouseGrabberItem())
+            option.state |= QStyle::State_Sunken;
+        // Calculate a simple level-of-detail metric.
+        // ### almost identical code in QGraphicsView::paintEvent()
+        //     and QGraphicsView::render() - consider refactoring
+        QTransform itemToDeviceTransform;
+        if (item->d_ptr->itemIsUntransformable()) {
+            itemToDeviceTransform = item->deviceTransform(painterTransform);
+        } else {
+            itemToDeviceTransform = item->sceneTransform() * painterTransform;
+        }
+        option.levelOfDetail = qSqrt(itemToDeviceTransform.map(v1).length() * itemToDeviceTransform.map(v2).length());
+        option.matrix = itemToDeviceTransform.toAffine(); //### discards perspective
+        option.exposedRect = item->boundingRect();
+        option.exposedRect &= itemToDeviceTransform.inverted().mapRect(targetRect);
+        styleOptionArray[i] = option;
+    }
+    for (int i = 0; i < numItems; ++i)
+        itemArray[i]->d_ptr->initStyleOption(&styleOptionArray[i], painterTransform, targetRect.toRect());
     // Render the scene.
 …
+{
     Q_D(QGraphicsScene);
+    d->resetIndex();
+    if (d->indexMethod == method)
+        return;
     d->indexMethod = method;
+    QList<QGraphicsItem *> oldItems = d->index->items(Qt::DescendingOrder);
+    delete d->index;
+    if (method == BspTreeIndex)
+        d->index = new QGraphicsSceneBspTreeIndex(this);
+    else
+        d->index = new QGraphicsSceneLinearIndex(this);
+    for (int i = oldItems.size() - 1; i >= 0; --i)
+        d->index->addItem(oldItems.at(i));
+}
 …
+{
     Q_D(const QGraphicsScene);
+    return d->bspTreeDepth;
+    QGraphicsSceneBspTreeIndex *bspTree = qobject_cast<QGraphicsSceneBspTreeIndex *>(d->index);
+    return bspTree ? bspTree->bspTreeDepth() : 0;
+}
 void QGraphicsScene::setBspTreeDepth(int depth)
+{
     Q_D(QGraphicsScene);
-    if (d->bspTreeDepth == depth)
-        return;
     if (depth < 0) {
         qWarning("QGraphicsScene::setBspTreeDepth: invalid depth %d ignored; must be >= 0", depth);
 …
+    }
+    d->bspTreeDepth = depth;
+    d->resetIndex();
+    QGraphicsSceneBspTreeIndex *bspTree = qobject_cast<QGraphicsSceneBspTreeIndex *>(d->index);
+    if (!bspTree) {
+        qWarning("QGraphicsScene::setBspTreeDepth: can not apply if indexing method is not BSP");
+        return;
+    }
+    bspTree->setBspTreeDepth(depth);
+}
 …
     \brief whether sort caching is enabled
     \since 4.5
+    When enabled, this property adds a cache that speeds up sorting and
+    transformations for scenes with deep hierarchies (i.e., items with many
+    levels of descendents), at the cost of using more memory (approx. 100 more
+    bytes of memory per item).
+    Items that are not part of a deep hierarchy suffer no penalty from this
+    cache.
+    \obsolete
+    Since Qt 4.6, this property has no effect.
 */
 bool QGraphicsScene::isSortCacheEnabled() const
 …
+{
     Q_D(QGraphicsScene);
     if (enabled == d->sortCacheEnabled)
+    if (d->sortCacheEnabled == enabled)
         return;
+    if ((d->sortCacheEnabled = enabled))
+        d->invalidateSortCache();
+    d->sortCacheEnabled = enabled;
+}
 …
 QRectF QGraphicsScene::itemsBoundingRect() const
+{
+    // Does not take untransformable items into account.
     QRectF boundingRect;
     foreach (QGraphicsItem *item, items())
 …
 /*!
     Returns a list of all items on the scene, in no particular order.
     \sa addItem(), removeItem()
+    Returns a list of all items in the scene in descending stacking order.
+    \sa addItem(), removeItem(), {QGraphicsItem#Sorting}{Sorting}
 */
 QList<QGraphicsItem *> QGraphicsScene::items() const
+{
     Q_D(const QGraphicsScene);
+    const_cast<QGraphicsScenePrivate *>(d)->purgeRemovedItems();
+    // If freeItemIndexes is empty, we know there are no holes in indexedItems and
+    // unindexedItems.
+    if (d->freeItemIndexes.isEmpty()) {
+        if (d->unindexedItems.isEmpty())
+            return d->indexedItems;
+        return d->indexedItems + d->unindexedItems;
+    }
+    // Rebuild the list of items to avoid holes. ### We could also just
+    // compress the item lists at this point.
+    QList<QGraphicsItem *> itemList;
+    foreach (QGraphicsItem *item, d->indexedItems + d->unindexedItems) {
+        if (item)
+            itemList << item;
+    }
+    return itemList;
+}
+/*!
+    return d->index->items(Qt::DescendingOrder);
+}
+/*!
+    Returns an ordered list of all items on the scene. \a order decides the
+    stacking order.
+    \sa addItem(), removeItem(), {QGraphicsItem#Sorting}{Sorting}
+*/
+QList<QGraphicsItem *> QGraphicsScene::items(Qt::SortOrder order) const
+{
+    Q_D(const QGraphicsScene);
+    return d->index->items(order);
+}
+/*!
+    \obsolete
     Returns all visible items at position \a pos in the scene. The items are
     listed in descending Z order (i.e., the first item in the list is the
+    listed in descending stacking order (i.e., the first item in the list is the
     top-most item, and the last item is the bottom-most item).
+    \sa itemAt()
+    This function is deprecated and returns incorrect results if the scene
+    contains items that ignore transformations. Use the overload that takes
+    a QTransform instead.
+    \sa itemAt(), {QGraphicsItem#Sorting}{Sorting}
 */
 QList<QGraphicsItem *> QGraphicsScene::items(const QPointF &pos) const
+{
     Q_D(const QGraphicsScene);
+    return d->items_helper(pos);
+}
+/*!
+    \fn QList<QGraphicsItem *> QGraphicsScene::items(const QRectF &rectangle, Qt::ItemSelectionMode mode) const
+    return d->index->items(pos, Qt::IntersectsItemShape, Qt::DescendingOrder);
+}
+/*!
     \overload
+    \obsolete
     Returns all visible items that, depending on \a mode, are either inside or
 …
     exact shape intersects with or is contained by \a rectangle are returned.
+    \sa itemAt()
+*/
+QList<QGraphicsItem *> QGraphicsScene::items(const QRectF &rect, Qt::ItemSelectionMode mode) const
+    This function is deprecated and returns incorrect results if the scene
+    contains items that ignore transformations. Use the overload that takes
+    a QTransform instead.
+    \sa itemAt(), {QGraphicsItem#Sorting}{Sorting}
+*/
+QList<QGraphicsItem *> QGraphicsScene::items(const QRectF &rectangle, Qt::ItemSelectionMode mode) const
+{
     Q_D(const QGraphicsScene);
     return d->items_helper(rect, mode, Qt::AscendingOrder);
+    return d->index->items(rectangle, mode, Qt::DescendingOrder);
+}
 /*!
     \fn QList<QGraphicsItem *> QGraphicsScene::items(qreal x, qreal y, qreal w, qreal h, Qt::ItemSelectionMode mode) const
+    \obsolete
     \since 4.3
     This convenience function is equivalent to calling items(QRectF(\a x, \a y, \a w, \a h), \a mode).
+*/
+/*!
+    This function is deprecated and returns incorrect results if the scene
+    contains items that ignore transformations. Use the overload that takes
+    a QTransform instead.
+*/
+/*!
+    \fn QList<QGraphicsItem *> QGraphicsScene::items(qreal x, qreal y, qreal w, qreal h, Qt::ItemSelectionMode mode, Qt::SortOrder order, const QTransform &deviceTransform) const
     \overload
+    \since 4.6
+    \brief Returns all visible items that, depending on \a mode, are
+    either inside or intersect with the rectangle defined by \a x, \a y,
+    \a w and \a h, in a list sorted using \a order.
+    \a deviceTransform is the transformation that applies to the view, and needs to
+    be provided if the scene contains items that ignore transformations.
+*/
+/*!
+    \fn QList<QGraphicsItem *> QGraphicsScene::items(const QPolygonF &polygon, Qt::ItemSelectionMode mode) const
+    \overload
+    \obsolete
     Returns all visible items that, depending on \a mode, are either inside or
 …
     exact shape intersects with or is contained by \a polygon are returned.
+    \sa itemAt()
+    This function is deprecated and returns incorrect results if the scene
+    contains items that ignore transformations. Use the overload that takes
+    a QTransform instead.
+    \sa itemAt(), {QGraphicsItem#Sorting}{Sorting}
 */
 QList<QGraphicsItem *> QGraphicsScene::items(const QPolygonF &polygon, Qt::ItemSelectionMode mode) const
+{
     Q_D(const QGraphicsScene);
+    return d->items_helper(polygon, mode, Qt::AscendingOrder);
+}
+/*!
+    return d->index->items(polygon, mode, Qt::DescendingOrder);
+}
+/*!
+    \fn QList<QGraphicsItem *> QGraphicsScene::items(const QPainterPath &path, Qt::ItemSelectionMode mode) const
     \overload
+    \obsolete
     Returns all visible items that, depending on \a path, are either inside or
 …
     exact shape intersects with or is contained by \a path are returned.
+    \sa itemAt()
+    This function is deprecated and returns incorrect results if the scene
+    contains items that ignore transformations. Use the overload that takes
+    a QTransform instead.
+    \sa itemAt(), {QGraphicsItem#Sorting}{Sorting}
 */
 QList<QGraphicsItem *> QGraphicsScene::items(const QPainterPath &path, Qt::ItemSelectionMode mode) const
+{
     Q_D(const QGraphicsScene);
+    return d->items_helper(path, mode, Qt::AscendingOrder);
+    return d->index->items(path, mode, Qt::DescendingOrder);
+}
+/*!
+    \fn QList<QGraphicsItem *> QGraphicsScene::items(const QPointF &pos, Qt::ItemSelectionMode mode, Qt::SortOrder order, const QTransform &deviceTransform) const
+    \since 4.6
+    \brief Returns all visible items that, depending on \a mode, are at
+    the specified \a pos in a list sorted using \a order.
+    The default value for \a mode is Qt::IntersectsItemShape; all items whose
+    exact shape intersects with \a pos are returned.
+    \a deviceTransform is the transformation that applies to the view, and needs to
+    be provided if the scene contains items that ignore transformations.
+    \sa itemAt(), {QGraphicsItem#Sorting}{Sorting}
+*/
+QList<QGraphicsItem *> QGraphicsScene::items(const QPointF &pos, Qt::ItemSelectionMode mode,
+                                             Qt::SortOrder order, const QTransform &deviceTransform) const
+{
+    Q_D(const QGraphicsScene);
+    return d->index->items(pos, mode, order, deviceTransform);
+}
+/*!
+    \fn QList<QGraphicsItem *> QGraphicsScene::items(const QRectF &rect, Qt::ItemSelectionMode mode, Qt::SortOrder order, const QTransform &deviceTransform) const
+    \overload
+    \since 4.6
+    \brief Returns all visible items that, depending on \a mode, are
+    either inside or intersect with the specified \a rect and return a
+    list sorted using \a order.
+    The default value for \a mode is Qt::IntersectsItemShape; all items whose
+    exact shape intersects with or is contained by \a rect are returned.
+    \a deviceTransform is the transformation that applies to the view, and needs to
+    be provided if the scene contains items that ignore transformations.
+    \sa itemAt(), {QGraphicsItem#Sorting}{Sorting}
+*/
+QList<QGraphicsItem *> QGraphicsScene::items(const QRectF &rect, Qt::ItemSelectionMode mode,
+                                             Qt::SortOrder order, const QTransform &deviceTransform) const
+{
+    Q_D(const QGraphicsScene);
+    return d->index->items(rect, mode, order, deviceTransform);
+}
+/*!
+    \fn QList<QGraphicsItem *> QGraphicsScene::items(const QPolygonF &polygon, Qt::ItemSelectionMode mode, Qt::SortOrder order, const QTransform &deviceTransform) const
+    \overload
+    \since 4.6
+    \brief Returns all visible items that, depending on \a mode, are
+    either inside or intersect with the specified \a polygon and return
+    a list sorted using \a order.
+    The default value for \a mode is Qt::IntersectsItemShape; all items whose
+    exact shape intersects with or is contained by \a polygon are returned.
+    \a deviceTransform is the transformation that applies to the view, and needs to
+    be provided if the scene contains items that ignore transformations.
+    \sa itemAt(), {QGraphicsItem#Sorting}{Sorting}
+*/
+QList<QGraphicsItem *> QGraphicsScene::items(const QPolygonF &polygon, Qt::ItemSelectionMode mode,
+                                             Qt::SortOrder order, const QTransform &deviceTransform) const
+{
+    Q_D(const QGraphicsScene);
+    return d->index->items(polygon, mode, order, deviceTransform);
+}
+/*!
+    \fn QList<QGraphicsItem *> QGraphicsScene::items(const QPainterPath &path, Qt::ItemSelectionMode mode, Qt::SortOrder order, const QTransform &deviceTransform) const
+    \overload
+    \since 4.6
+    \brief Returns all visible items that, depending on \a mode, are
+    either inside or intersect with the specified \a path and return a
+    list sorted using \a order.
+    The default value for \a mode is Qt::IntersectsItemShape; all items whose
+    exact shape intersects with or is contained by \a path are returned.
+    \a deviceTransform is the transformation that applies to the view, and needs to
+    be provided if the scene contains items that ignore transformations.
+    \sa itemAt(), {QGraphicsItem#Sorting}{Sorting}
+*/
+QList<QGraphicsItem *> QGraphicsScene::items(const QPainterPath &path, Qt::ItemSelectionMode mode,
+                                             Qt::SortOrder order, const QTransform &deviceTransform) const
+{
+    Q_D(const QGraphicsScene);
+    return d->index->items(path, mode, order, deviceTransform);
+}
 …
     intersects \a item or is contained inside \a item's shape are returned.
+    The items are returned in descending Z order (i.e., the first item in the
+    list is the top-most item, and the last item is the bottom-most item).
+    \sa items(), itemAt(), QGraphicsItem::collidesWithItem()
+    The items are returned in descending stacking order (i.e., the first item
+    in the list is the uppermost item, and the last item is the lowermost
+    item).
+    \sa items(), itemAt(), QGraphicsItem::collidesWithItem(), {QGraphicsItem#Sorting}{Sorting}
 */
 QList<QGraphicsItem *> QGraphicsScene::collidingItems(const QGraphicsItem *item,
 …
+    }
+    // Does not support ItemIgnoresTransformations.
     QList<QGraphicsItem *> tmp;
     foreach (QGraphicsItem *itemInVicinity, d->estimateItemsInRect(item->sceneBoundingRect())) {
+    foreach (QGraphicsItem *itemInVicinity, d->index->estimateItems(item->sceneBoundingRect(), Qt::DescendingOrder)) {
         if (item != itemInVicinity && item->collidesWithItem(itemInVicinity, mode))
             tmp << itemInVicinity;
+    }
-    d->sortItems(&tmp, Qt::AscendingOrder, d->sortCacheEnabled);
     return tmp;
+}
 /*!
+    \fn QGraphicsItem *QGraphicsScene::itemAt(const QPointF &position) const
+    \overload
+    \obsolete
     Returns the topmost visible item at the specified \a position, or 0 if
     there are no items at this position.
+    \note The topmost item is the one with the highest Z-value.
+    \sa items(), collidingItems(), QGraphicsItem::setZValue()
+*/
+QGraphicsItem *QGraphicsScene::itemAt(const QPointF &pos) const
+{
+    QList<QGraphicsItem *> itemsAtPoint = items(pos);
+    This function is deprecated and returns incorrect results if the scene
+    contains items that ignore transformations. Use the overload that takes
+    a QTransform instead.
+    \sa items(), collidingItems(), {QGraphicsItem#Sorting}{Sorting}
+*/
+QGraphicsItem *QGraphicsScene::itemAt(const QPointF &position) const
+{
+    QList<QGraphicsItem *> itemsAtPoint = items(position);
     return itemsAtPoint.isEmpty() ? 0 : itemsAtPoint.first();
+}
+/*!
+    \since 4.6
+    Returns the topmost visible item at the specified \a position, or 0
+    if there are no items at this position.
+    \a deviceTransform is the transformation that applies to the view, and needs to
+    be provided if the scene contains items that ignore transformations.
+    \sa items(), collidingItems(), {QGraphicsItem#Sorting}{Sorting}
+*/
+QGraphicsItem *QGraphicsScene::itemAt(const QPointF &position, const QTransform &deviceTransform) const
+{
+    QList<QGraphicsItem *> itemsAtPoint = items(position, Qt::IntersectsItemShape,
+                                                Qt::DescendingOrder, deviceTransform);
+    return itemsAtPoint.isEmpty() ? 0 : itemsAtPoint.first();
+}
+/*!
+    \fn QGraphicsScene::itemAt(qreal x, qreal y, const QTransform &deviceTransform) const
+    \overload
+    \since 4.6
+    Returns the topmost item at the position specified by (\a x, \a
+    y), or 0 if there are no items at this position.
+    \a deviceTransform is the transformation that applies to the view, and needs to
+    be provided if the scene contains items that ignore transformations.
+    This convenience function is equivalent to calling \c
+    {itemAt(QPointF(x, y), deviceTransform)}.
+*/
 /*!
     \fn QGraphicsScene::itemAt(qreal x, qreal y) const
     \overload
+    \obsolete
     Returns the topmost item at the position specified by (\a x, \a
 …
     {itemAt(QPointF(x, y))}.
+    \note The topmost item is the one with the highest Z-value.
+    This function is deprecated and returns incorrect results if the scene
+    contains items that ignore transformations. Use the overload that takes
+    a QTransform instead.
 */
 …
 /*!
+    \since 4.6
     Sets the selection area to \a path. All items within this area are
     immediately selected, and all items outside are unselected. You can get
     the list of all selected items by calling selectedItems().
+    \a deviceTransform is the transformation that applies to the view, and needs to
+    be provided if the scene contains items that ignore transformations.
     For an item to be selected, it must be marked as \e selectable
     (QGraphicsItem::ItemIsSelectable).
 …
     \sa clearSelection(), selectionArea()
 */
+void QGraphicsScene::setSelectionArea(const QPainterPath &path, const QTransform &deviceTransform)
+{
+    setSelectionArea(path, Qt::IntersectsItemShape, deviceTransform);
+}
+/*!
+    \obsolete
+    \overload
+    Sets the selection area to \a path.
+    This function is deprecated and leads to incorrect results if the scene
+    contains items that ignore transformations. Use the overload that takes
+    a QTransform instead.
+*/
 void QGraphicsScene::setSelectionArea(const QPainterPath &path)
+{
+    setSelectionArea(path, Qt::IntersectsItemShape);
+}
+/*!
+    setSelectionArea(path, Qt::IntersectsItemShape, QTransform());
+}
+/*!
+    \obsolete
     \overload
     \since 4.3
 …
 */
 void QGraphicsScene::setSelectionArea(const QPainterPath &path, Qt::ItemSelectionMode mode)
+{
+    setSelectionArea(path, mode, QTransform());
+}
+/*!
+    \overload
+    \since 4.6
+    Sets the selection area to \a path using \a mode to determine if items are
+    included in the selection area.
+    \a deviceTransform is the transformation that applies to the view, and needs to
+    be provided if the scene contains items that ignore transformations.
+    \sa clearSelection(), selectionArea()
+*/
+void QGraphicsScene::setSelectionArea(const QPainterPath &path, Qt::ItemSelectionMode mode,
+                                      const QTransform &deviceTransform)
+{
     Q_D(QGraphicsScene);
 …
     // Set all items in path to selected.
     foreach (QGraphicsItem *item, items(path, mode)) {
+    foreach (QGraphicsItem *item, items(path, mode, Qt::DescendingOrder, deviceTransform)) {
         if (item->flags() & QGraphicsItem::ItemIsSelectable) {
             if (!item->isSelected())
 …
+{
     Q_D(QGraphicsScene);
+    // Recursive descent delete
+    for (int i = 0; i < d->indexedItems.size(); ++i) {
+        if (QGraphicsItem *item = d->indexedItems.at(i)) {
+            if (!item->parentItem())
+                delete item;
+        }
+    }
+    QList<QGraphicsItem *> unindexedParents;
+    for (int i = 0; i < d->unindexedItems.size(); ++i) {
+        QGraphicsItem *item = d->unindexedItems.at(i);
+        if (!item->parentItem())
+            unindexedParents << item;
+    }
+    d->unindexedItems.clear();
+    qDeleteAll(unindexedParents);
+    d->indexedItems.clear();
+    d->freeItemIndexes.clear();
+    // NB! We have to clear the index before deleting items; otherwise the
+    // index might try to access dangling item pointers.
+    d->index->clear();
+    // NB! QGraphicsScenePrivate::unregisterTopLevelItem() removes items
+    while (!d->topLevelItems.isEmpty())
+        delete d->topLevelItems.first();
+    Q_ASSERT(d->topLevelItems.isEmpty());
     d->lastItemCount = 0;
+    d->bspTree.clear();
+    d->largestUntransformableItem = QRectF();
+    d->allItemsIgnoreHoverEvents = true;
+    d->allItemsUseDefaultCursor = true;
+    d->allItemsIgnoreTouchEvents = true;
+}
 …
 /*!
+    Adds or moves the item \a item and all its childen to the scene.
+    Adds or moves the \a item and all its childen to this scene.
+    This scene takes ownership of the \a item.
     If the item is visible (i.e., QGraphicsItem::isVisible() returns
 …
     to the event loop.
+    If the item is already in a different scene, it will first be removed from
+    its old scene, and then added to this scene as a top-level.
+    QGraphicsScene will send ItemSceneChange notifications to \a item while
+    it is added to the scene. If item does not currently belong to a scene, only one
+    notification is sent. If it does belong to scene already (i.e., it is
+    moved to this scene), QGraphicsScene will send an addition notification as
+    the item is removed from its previous scene.
+    If the item is already in a different scene, it will first be
+    removed from its old scene, and then added to this scene as a
+    top-level.
+    QGraphicsScene will send ItemSceneChange notifications to \a item
+    while it is added to the scene. If item does not currently belong
+    to a scene, only one notification is sent. If it does belong to
+    scene already (i.e., it is moved to this scene), QGraphicsScene
+    will send an addition notification as the item is removed from its
+    previous scene.
+    If the item is a panel, the scene is active, and there is no
+    active panel in the scene, then the item will be activated.
     \sa removeItem(), addEllipse(), addLine(), addPath(), addPixmap(),
     addRect(), addText(), addWidget()
+    addRect(), addText(), addWidget(), {QGraphicsItem#Sorting}{Sorting}
 */
 void QGraphicsScene::addItem(QGraphicsItem *item)
 …
         return;
+    }
     // Remove this item from its existing scene
     if (QGraphicsScene *oldScene = item->scene())
 …
+    }
-    // Prevent reusing a recently deleted pointer: purge all removed items
-    // from our lists.
-    d->purgeRemovedItems();
-    // Invalidate any sort caching; arrival of a new item means we need to
-    // resort.
-    d->invalidateSortCache();
     // Detach this item from its parent if the parent's scene is different
     // from this scene.
 …
     item->d_func()->scene = targetScene;
+    // Indexing requires sceneBoundingRect(), but because \a item might
+    // not be completely constructed at this point, we need to store it in
+    // a temporary list and schedule an indexing for later.
+    d->unindexedItems << item;
+    item->d_func()->index = -1;
+    d->startIndexTimer();
+    // Update the scene's sort cache settings.
+    item->d_ptr->globalStackingOrder = -1;
+    d->invalidateSortCache();
+    // Add the item in the index
+    d->index->addItem(item);
+    // Add to list of toplevels if this item is a toplevel.
+    if (!item->d_ptr->parent)
+        d->registerTopLevelItem(item);
     // Add to list of items that require an update. We cannot assume that the
     // item is fully constructed, so calling item->update() can lead to a pure
     // virtual function call to boundingRect().
+    if (!d->updateAll) {
+        if (d->pendingUpdateItems.isEmpty())
+            QMetaObject::invokeMethod(this, "_q_updateLater", Qt::QueuedConnection);
+        d->pendingUpdateItems << item;
+    }
+    d->markDirty(item);
+    d->dirtyGrowingItemsBoundingRect = true;
     // Disable selectionChanged() for individual items
     ++d->selectionChanging;
     int oldSelectedItemSize = d->selectedItems.size();
+    // Enable mouse tracking if the item accepts hover events or has a cursor set.
+    if (d->allItemsIgnoreHoverEvents && d->itemAcceptsHoverEvents_helper(item)) {
+        d->allItemsIgnoreHoverEvents = false;
+        d->enableMouseTrackingOnViews();
+    }
+#ifndef QT_NO_CURSOR
+    if (d->allItemsUseDefaultCursor && item->hasCursor()) {
+        d->allItemsUseDefaultCursor = false;
+        if (d->allItemsIgnoreHoverEvents) // already enabled otherwise
+            d->enableMouseTrackingOnViews();
+    }
+#endif //QT_NO_CURSOR
+    // Enable touch events if the item accepts touch events.
+    if (d->allItemsIgnoreTouchEvents && item->acceptTouchEvents()) {
+        d->allItemsIgnoreTouchEvents = false;
+        d->enableTouchEventsOnViews();
+    }
     // Update selection lists
 …
     if (item->isWidget() && item->isVisible() && static_cast<QGraphicsWidget *>(item)->windowType() == Qt::Popup)
         d->addPopup(static_cast<QGraphicsWidget *>(item));
+    if (item->isPanel() && item->isVisible() && item->panelModality() != QGraphicsItem::NonModal)
+        d->enterModal(item);
     // Update creation order focus chain. Make sure to leave the widget's
 …
     item->d_ptr->resolvePalette(d->palette.resolve());
+    if (!item->d_ptr->explicitlyHidden) {
+       if (d->unpolishedItems.isEmpty())
+           QMetaObject::invokeMethod(this, "_q_polishItems", Qt::QueuedConnection);
+       d->unpolishedItems << item;
+    }
+    if (d->unpolishedItems.isEmpty())
+        QMetaObject::invokeMethod(this, "_q_polishItems", Qt::QueuedConnection);
+    d->unpolishedItems.insert(item);
+    d->unpolishedItemsModified = true;
     // Reenable selectionChanged() for individual items
 …
     // Deliver post-change notification
     item->itemChange(QGraphicsItem::ItemSceneHasChanged, newSceneVariant);
+    // Update explicit activation
+    bool autoActivate = true;
+    if (!d->childExplicitActivation && item->d_ptr->explicitActivate)
+        d->childExplicitActivation = item->d_ptr->wantsActive ? 1 : 2;
+    if (d->childExplicitActivation && item->isPanel()) {
+        if (d->childExplicitActivation == 1)
+            setActivePanel(item);
+        else
+            autoActivate = false;
+        d->childExplicitActivation = 0;
+    } else if (!item->d_ptr->parent) {
+        d->childExplicitActivation = 0;
+    }
+    // Auto-activate this item's panel if nothing else has been activated
+    if (autoActivate) {
+        if (!d->lastActivePanel && !d->activePanel && item->isPanel()) {
+            if (isActive())
+                setActivePanel(item);
+            else
+                d->lastActivePanel = item;
+        }
+    }
+    if (item->flags() & QGraphicsItem::ItemSendsScenePositionChanges)
+        d->registerScenePosItem(item);
+    // Ensure that newly added items that have subfocus set, gain
+    // focus automatically if there isn't a focus item already.
+    if (!d->focusItem && item != d->lastFocusItem && item->focusItem() == item)
+        item->focusItem()->setFocus();
+    d->updateInputMethodSensitivityInViews();
+}
 …
+    }
+    // If the item has focus, remove it (and any focusWidget reference).
+    item->clearFocus();
+    // Clear its background
+    item->update();
+    // Note: This will access item's sceneBoundingRect(), which (as this is
+    // C++) is why we cannot call removeItem() from QGraphicsItem's
+    // destructor.
+    d->removeFromIndex(item);
+    if (item == d->tabFocusFirst) {
+        QGraphicsWidget *widget = static_cast<QGraphicsWidget *>(item);
+        widget->d_func()->fixFocusChainBeforeReparenting(0, 0);
+    }
+    // Set the item's scene ptr to 0.
+    item->d_func()->scene = 0;
+    // Detach the item from its parent.
+    if (QGraphicsItem *parentItem = item->parentItem()) {
+        if (parentItem->scene()) {
+            Q_ASSERT_X(parentItem->scene() == this, "QGraphicsScene::removeItem",
+                       "Parent item's scene is different from this item's scene");
+            item->setParentItem(0);
+        }
+    }
+    // Remove from our item lists.
+    int index = item->d_func()->index;
+    if (index != -1) {
+        d->freeItemIndexes << index;
+        d->indexedItems[index] = 0;
+    } else {
+        d->unindexedItems.removeAll(item);
+    }
+    // Remove from scene transform cache
+    int transformIndex = item->d_func()->sceneTransformIndex;
+    if (transformIndex != -1) {
+        d->validTransforms.setBit(transformIndex, 0);
+        d->freeSceneTransformSlots.append(transformIndex);
+        item->d_func()->sceneTransformIndex = -1;
+    }
+    if (item == d->focusItem)
+        d->focusItem = 0;
+    if (item == d->lastFocusItem)
+        d->lastFocusItem = 0;
+    if (item == d->activeWindow) {
+        // ### deactivate...
+        d->activeWindow = 0;
+    }
+    // Disable selectionChanged() for individual items
+    ++d->selectionChanging;
+    int oldSelectedItemsSize = d->selectedItems.size();
+    // Update selected & hovered item bookkeeping
+    d->selectedItems.remove(item);
+    d->hoverItems.removeAll(item);
+    d->pendingUpdateItems.removeAll(item);
+    d->cachedItemsUnderMouse.removeAll(item);
+    d->unpolishedItems.removeAll(item);
+    d->dirtyItems.removeAll(item);
+    //We remove all references of item from the sceneEventFilter arrays
+    QMultiMap<QGraphicsItem*, QGraphicsItem*>::iterator iterator = d->sceneEventFilters.begin();
+    while (iterator != d->sceneEventFilters.end()) {
+        if (iterator.value() == item || iterator.key() == item)
+            iterator = d->sceneEventFilters.erase(iterator);
+        else
+            ++iterator;
+    }
+    //Ensure dirty flag have the correct default value so the next time it will be added it will receive updates
+    item->d_func()->dirty = 0;
+    item->d_func()->dirtyChildren = 0;
+    // Remove all children recursively
+    foreach (QGraphicsItem *child, item->children())
+        removeItem(child);
+    // Reset the mouse grabber and focus item data.
+    if (d->mouseGrabberItems.contains(item))
+        d->ungrabMouse(item);
+    // Reset the keyboard grabber
+    if (d->keyboardGrabberItems.contains(item))
+        item->ungrabKeyboard();
+    // Reset the last mouse grabber item
+    if (item == d->lastMouseGrabberItem)
+        d->lastMouseGrabberItem = 0;
+    // Reenable selectionChanged() for individual items
+    --d->selectionChanging;
+    if (!d->selectionChanging && d->selectedItems.size() != oldSelectedItemsSize)
+        emit selectionChanged();
+    d->removeItemHelper(item);
     // Deliver post-change notification
     item->itemChange(QGraphicsItem::ItemSceneHasChanged, newSceneVariant);
+}
+/*!
+    Returns the scene's current focus item, or 0 if no item currently has
+    focus.
+    d->updateInputMethodSensitivityInViews();
+}
+/*!
+    When the scene is active, this functions returns the scene's current focus
+    item, or 0 if no item currently has focus. When the scene is inactive, this
+    functions returns the item that will gain input focus when the scene becomes
+    active.
     The focus item receives keyboard input when the scene receives a
     key event.
     \sa setFocusItem(), QGraphicsItem::hasFocus()
+    \sa setFocusItem(), QGraphicsItem::hasFocus(), isActive()
 */
 QGraphicsItem *QGraphicsScene::focusItem() const
+{
     Q_D(const QGraphicsScene);
     return d->focusItem;
+    return isActive() ? d->focusItem : d->lastFocusItem;
+}
 …
+{
     Q_D(QGraphicsScene);
+    if (item == d->focusItem)
+        return;
+    if (item && (!(item->flags() & QGraphicsItem::ItemIsFocusable)
+                 || !item->isVisible() || !item->isEnabled())) {
+        item = 0;
+    }
+    if (item) {
+        setFocus(focusReason);
+        if (item == d->focusItem)
+            return;
+    }
+    if (d->focusItem) {
+        QFocusEvent event(QEvent::FocusOut, focusReason);
+        d->lastFocusItem = d->focusItem;
+        d->focusItem = 0;
+        d->sendEvent(d->lastFocusItem, &event);
+    }
+    if (item) {
+        if (item->isWidget()) {
+            // Update focus child chain.
+            static_cast<QGraphicsWidget *>(item)->d_func()->setFocusWidget();
+        }
+        d->focusItem = item;
+        QFocusEvent event(QEvent::FocusIn, focusReason);
+        d->sendEvent(item, &event);
+    }
+    if (item)
+        item->setFocus(focusReason);
+    else
+        d->setFocusItemHelper(item, focusReason);
+}
 …
+{
     Q_D(QGraphicsScene);
     if (d->hasFocus)
+    if (d->hasFocus || !isActive())
         return;
     QFocusEvent event(QEvent::FocusIn, focusReason);
 …
 /*!
     \property QGraphicsScene::stickyFocus
+    \brief whether or not clicking the scene will clear focus
+    If this property is false (the default), then clicking on the scene
+    background or on an item that does not accept focus, will clear
+    focus. Otherwise, focus will remain unchanged.
+    The focus change happens in response to a mouse press. You can reimplement
+    \brief whether clicking into the scene background will clear focus
+    \since 4.6
+    In a QGraphicsScene with stickyFocus set to true, focus will remain
+    unchanged when the user clicks into the scene background or on an item
+    that does not accept focus. Otherwise, focus will be cleared.
+    By default, this property is false.
+    Focus changes in response to a mouse press. You can reimplement
     mousePressEvent() in a subclass of QGraphicsScene to toggle this property
     based on where the user has clicked.
 …
+{
     Q_D(const QGraphicsScene);
     if (!d->focusItem)
+    if (!d->focusItem || !(d->focusItem->flags() & QGraphicsItem::ItemAcceptsInputMethod))
         return QVariant();
     const QTransform matrix = d->focusItem->sceneTransform();
 …
     // Check if anyone's connected; if not, we can send updates directly to
     // the views. Otherwise or if there are no views, use old behavior.
     bool directUpdates = !(d->connectedSignals & d->changedSignalMask) && !d->views.isEmpty();
+    bool directUpdates = !(d->isSignalConnected(d->changedSignalIndex)) && !d->views.isEmpty();
     if (rect.isNull()) {
         d->updateAll = true;
 …
             // Update all views.
             for (int i = 0; i < d->views.size(); ++i)
                 d->views.at(i)->d_func()->updateAll();
+                d->views.at(i)->d_func()->fullUpdatePending = true;
+        }
     } else {
 …
+    }
     if (!directUpdates && !d->calledEmitUpdated) {
+    if (!d->calledEmitUpdated) {
         d->calledEmitUpdated = true;
         QMetaObject::invokeMethod(this, "_q_emitUpdated", Qt::QueuedConnection);
 …
     case QEvent::GraphicsSceneHoverLeave:
     case QEvent::GraphicsSceneHoverMove:
+    case QEvent::TouchBegin:
+    case QEvent::TouchUpdate:
+    case QEvent::TouchEnd:
         // Reset the under-mouse list to ensure that this event gets fresh
         // item-under-mouse data. Be careful about this list; if people delete
 …
         // having stale pointers in it. We need to clear it before dispatching
         // events that use it.
+        // ### this should only be cleared if we received a new mouse move event,
+        // which relies on us fixing the replay mechanism in QGraphicsView.
         d->cachedItemsUnderMouse.clear();
     default:
 …
         return false;
     case QEvent::GraphicsSceneMouseMove:
+        mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent *>(event));
+    {
+        QGraphicsSceneMouseEvent *mouseEvent = static_cast<QGraphicsSceneMouseEvent *>(event);
+        d->lastSceneMousePos = mouseEvent->scenePos();
+        mouseMoveEvent(mouseEvent);
         break;
+    }
     case QEvent::GraphicsSceneMousePress:
         mousePressEvent(static_cast<QGraphicsSceneMouseEvent *>(event));
 …
     case QEvent::GraphicsSceneHoverLeave:
     case QEvent::GraphicsSceneHoverMove:
+        d->dispatchHoverEvent(static_cast<QGraphicsSceneHoverEvent *>(event));
+    {
+        QGraphicsSceneHoverEvent *hoverEvent = static_cast<QGraphicsSceneHoverEvent *>(event);
+        d->lastSceneMousePos = hoverEvent->scenePos();
+        d->dispatchHoverEvent(hoverEvent);
         break;
+    }
     case QEvent::Leave:
         d->leaveScene();
 …
         inputMethodEvent(static_cast<QInputMethodEvent *>(event));
         break;
     case QEvent::WindowActivate: {
+    case QEvent::WindowActivate:
         if (!d->activationRefCount++) {
+            // Notify all non-window widgets.
+            foreach (QGraphicsItem *item, items()) {
+                if (item->isWidget() && item->isVisible() && !item->isWindow() && !item->parentWidget()) {
+                    QEvent event(QEvent::WindowActivate);
+                    QApplication::sendEvent(static_cast<QGraphicsWidget *>(item), &event);
+            if (d->lastActivePanel) {
+                // Activate the last panel.
+                d->setActivePanelHelper(d->lastActivePanel, true);
+            } else if (d->tabFocusFirst && d->tabFocusFirst->isPanel()) {
+                // Activate the panel of the first item in the tab focus
+                // chain.
+                d->setActivePanelHelper(d->tabFocusFirst, true);
+            } else {
+                // Activate all toplevel items.
+                QEvent event(QEvent::WindowActivate);
+                foreach (QGraphicsItem *item, items()) {
+                    if (item->isVisible() && !item->isPanel() && !item->parentItem())
+                        sendEvent(item, &event);
+                }
+            }
-            // Restore window activation.
-            QGraphicsItem *nextFocusItem = d->focusItem ? d->focusItem : d->lastFocusItem;
-            if (nextFocusItem && nextFocusItem->window())
-                setActiveWindow(static_cast<QGraphicsWidget *>(nextFocusItem));
-            else if (d->tabFocusFirst && d->tabFocusFirst->isWindow())
-                setActiveWindow(d->tabFocusFirst);
+        }
         break;
+    }
+    case QEvent::WindowDeactivate: {
+    case QEvent::WindowDeactivate:
         if (!--d->activationRefCount) {
+            // Remove window activation.
+            setActiveWindow(0);
+            // Notify all non-window widgets.
+            foreach (QGraphicsItem *item, items()) {
+                if (item->isWidget() && item->isVisible() && !item->isWindow() && !item->parentWidget()) {
+                    QEvent event(QEvent::WindowDeactivate);
+                    QApplication::sendEvent(static_cast<QGraphicsWidget *>(item), &event);
+            if (d->activePanel) {
+                // Deactivate the active panel (but keep it so we can
+                // reactivate it later).
+                QGraphicsItem *lastActivePanel = d->activePanel;
+                d->setActivePanelHelper(0, true);
+                d->lastActivePanel = lastActivePanel;
+            } else {
+                // Activate all toplevel items.
+                QEvent event(QEvent::WindowDeactivate);
+                foreach (QGraphicsItem *item, items()) {
+                    if (item->isVisible() && !item->isPanel() && !item->parentItem())
+                        sendEvent(item, &event);
+                }
+            }
+        }
         break;
+    }
     case QEvent::ApplicationFontChange: {
         // Resolve the existing scene font.
 …
         update();
         break;
+    case QEvent::Timer:
+        if (d->indexTimerId && static_cast<QTimerEvent *>(event)->timerId() == d->indexTimerId) {
+            if (d->restartIndexTimer) {
+                d->restartIndexTimer = false;
+            } else {
+                // this call will kill the timer
+                d->_q_updateIndex();
+            }
+        }
+        // Fallthrough intended - support timers in subclasses.
+    case QEvent::TouchBegin:
+    case QEvent::TouchUpdate:
+    case QEvent::TouchEnd:
+        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);
 …
     switch (event->type()) {
     case QEvent::ApplicationPaletteChange:
         qApp->postEvent(this, new QEvent(QEvent::ApplicationPaletteChange));
+        QApplication::postEvent(this, new QEvent(QEvent::ApplicationPaletteChange));
         break;
     case QEvent::ApplicationFontChange:
         qApp->postEvent(this, new QEvent(QEvent::ApplicationFontChange));
+        QApplication::postEvent(this, new QEvent(QEvent::ApplicationFontChange));
         break;
     default:
 …
         point = helpEvent->screenPos();
+    }
     QToolTip::showText(point, text);
+    QToolTip::showText(point, text, helpEvent->widget());
     helpEvent->setAccepted(!text.isEmpty());
 #endif
 …
 bool QGraphicsScenePrivate::itemAcceptsHoverEvents_helper(const QGraphicsItem *item) const
+{
+    return item->acceptHoverEvents()
+        || (item->isWidget() && static_cast<const QGraphicsWidget *>(item)->d_func()->hasDecoration());
+    return (!item->isBlockedByModalPanel() &&
+            (item->acceptHoverEvents()
+             || (item->isWidget()
+                 && static_cast<const QGraphicsWidget *>(item)->d_func()->hasDecoration())));
+}
 …
 bool QGraphicsScenePrivate::dispatchHoverEvent(QGraphicsSceneHoverEvent *hoverEvent)
+{
+    if (allItemsIgnoreHoverEvents)
+        return false;
     // Find the first item that accepts hover events, reusing earlier
     // calculated data is possible.
 …
     while (commonAncestorItem && !itemAcceptsHoverEvents_helper(commonAncestorItem))
         commonAncestorItem = commonAncestorItem->parentItem();
     if (commonAncestorItem && commonAncestorItem->window() != item->window()) {
         // The common ancestor isn't in the same window as the two hovered
+    if (commonAncestorItem && commonAncestorItem->panel() != item->panel()) {
+        // The common ancestor isn't in the same panel as the two hovered
         // items.
         commonAncestorItem = 0;
 …
     while (parent && parent != commonAncestorItem) {
         parents.prepend(parent);
         if (parent->isWindow()) {
             // Stop at the window - we don't deliver beyond this point.
+        if (parent->isPanel()) {
+            // Stop at the panel - we don't deliver beyond this point.
             break;
+        }
 …
     // Generate a move event for the item itself
+    if (item && !hoverItems.isEmpty() && item == hoverItems.last()) {
+    if (item
+        && !hoverItems.isEmpty()
+        && item == hoverItems.last()) {
         sendHoverEvent(QEvent::GraphicsSceneHoverMove, item, hoverEvent);
         return true;
 …
     Q_Q(QGraphicsScene);
 #ifndef QT_NO_TOOLTIP
+    // Remove any tooltips
+    QToolTip::showText(QPoint(), QString());
+    QToolTip::hideText();
 #endif
     // Send HoverLeave events to all existing hover items, topmost first.
 …
     while (!hoverItems.isEmpty()) {
         QGraphicsItem *lastItem = hoverItems.takeLast();
+        if (lastItem->acceptHoverEvents()
+            || (lastItem->isWidget() && static_cast<QGraphicsWidget*>(lastItem)->d_func()->hasDecoration()))
+        if (itemAcceptsHoverEvents_helper(lastItem))
             sendHoverEvent(QEvent::GraphicsSceneHoverLeave, lastItem, &hoverEvent);
+    }
 …
             // Send it; QGraphicsItem::keyPressEvent ignores it.  If the event
             // is filtered out, stop propagating it.
+            if (p->isBlockedByModalPanel())
+                break;
             if (!d->sendEvent(p, keyEvent))
                 break;
         } while (!keyEvent->isAccepted() && !p->isWindow() && (p = p->parentItem()));
+        } while (!keyEvent->isAccepted() && !p->isPanel() && (p = p->parentItem()));
     } else {
         keyEvent->ignore();
 …
             // Send it; QGraphicsItem::keyPressEvent ignores it.  If the event
             // is filtered out, stop propagating it.
+            if (p->isBlockedByModalPanel())
+                break;
             if (!d->sendEvent(p, keyEvent))
                 break;
         } while (!keyEvent->isAccepted() && !p->isWindow() && (p = p->parentItem()));
+        } while (!keyEvent->isAccepted() && !p->isPanel() && (p = p->parentItem()));
     } else {
         keyEvent->ignore();
 …
+{
     Q_D(QGraphicsScene);
+    if (d->mouseGrabberItems.isEmpty()) {
+        // Dispatch hover events
+        QGraphicsSceneHoverEvent hover;
+        _q_hoverFromMouseEvent(&hover, mouseEvent);
+        d->dispatchHoverEvent(&hover);
+    }
     d->mousePressEventHandler(mouseEvent);
+}
 …
     bool hasSetFocus = false;
     foreach (QGraphicsItem *item, wheelCandidates) {
+        if (!hasSetFocus && item->isEnabled() && (item->flags() & QGraphicsItem::ItemIsFocusable)) {
+        if (!hasSetFocus && item->isEnabled()
+            && ((item->flags() & QGraphicsItem::ItemIsFocusable) && item->d_ptr->mouseSetsFocus)) {
             if (item->isWidget() && static_cast<QGraphicsWidget *>(item)->focusPolicy() == Qt::WheelFocus) {
                 hasSetFocus = true;
 …
                                                             wheelEvent->widget()));
         wheelEvent->accept();
         bool isWindow = item->isWindow();
+        bool isPanel = item->isPanel();
         d->sendEvent(item, wheelEvent);
         if (isWindow || wheelEvent->isAccepted())
+        if (isPanel || wheelEvent->isAccepted())
             break;
+    }
 …
     The default implementation forwards the event to the focusItem().
+    If no item currently has focus, this function does nothing.
+    If no item currently has focus or the current focus item does not
+    accept input methods, this function does nothing.
     \sa QGraphicsItem::inputMethodEvent()
 …
+{
     Q_D(QGraphicsScene);
+    if (!d->focusItem)
+        return;
+    d->sendEvent(d->focusItem, event);
+    if (d->focusItem && (d->focusItem->flags() & QGraphicsItem::ItemAcceptsInputMethod))
+        d->sendEvent(d->focusItem, event);
+}
 …
     const qreal oldPainterOpacity = painter->opacity();
     if (qFuzzyCompare(windowOpacity + 1, qreal(1.0)))
+    if (qFuzzyIsNull(windowOpacity))
         return;
     // Set new painter opacity.
 …
     // Don't use subpixmap if we get a full update.
     if (pixmapExposed.isEmpty() || (pixmapExposed.numRects() == 1 && br.contains(pix->rect()))) {
+    if (pixmapExposed.isEmpty() || (pixmapExposed.rectCount() == 1 && br.contains(pix->rect()))) {
         pix->fill(Qt::transparent);
         pixmapPainter.begin(pix);
 …
         // Blit the subpixmap into the main pixmap.
         pixmapPainter.begin(pix);
-        pixmapPainter.setCompositionMode(QPainter::CompositionMode_Source);
         pixmapPainter.setClipRegion(pixmapExposed);
         pixmapPainter.drawPixmap(br.topLeft(), subPix);
 …
                                            bool painterStateProtection)
+{
     QGraphicsItemPrivate *itemd = item->d_ptr;
+    QGraphicsItemPrivate *itemd = item->d_ptr.data();
     QGraphicsItem::CacheMode cacheMode = QGraphicsItem::CacheMode(itemd->cacheMode);
 …
     // Fetch the off-screen transparent buffer and exposed area info.
     QString pixmapKey;
+    QPixmapCache::Key pixmapKey;
     QPixmap pix;
+    bool pixmapFound;
     QGraphicsItemCache *itemCache = itemd->extraItemCache();
     if (cacheMode == QGraphicsItem::ItemCoordinateCache) {
 …
         pixmapKey = itemCache->key;
     } else {
+        if ((pixmapKey = itemCache->deviceData.value(widget).key).isEmpty()) {
+            pixmapKey.sprintf("qgv-%p-%p", item, widget);
+            QGraphicsItemCache::DeviceData data;
+            data.key = pixmapKey;
+            itemCache->deviceData.insert(widget, data);
+        }
+        pixmapKey = itemCache->deviceData.value(widget).key;
+    }
     // Find pixmap in cache.
+    if (!itemCache->allExposed)
+        QPixmapCache::find(pixmapKey, pix);
+    pixmapFound = QPixmapCache::find(pixmapKey, &pix);
     // Render using item coordinate cache mode.
 …
         // Redraw any newly exposed areas.
         if (itemCache->allExposed || !itemCache->exposed.isEmpty()) {
+            //We know that we will modify the pixmap, removing it from the cache
+            //will detach the one we have and avoid a deep copy
+            if (pixmapFound)
+                QPixmapCache::remove(pixmapKey);
             // Fit the item's bounding rect into the pixmap's coordinates.
             QTransform itemToPixmap;
 …
             // Generate the item's exposedRect and map its list of expose
             // rects to device coordinates.
             QStyleOptionGraphicsItem cacheOption = *option;
+            styleOptionTmp = *option;
             QRegion pixmapExposed;
             QRectF exposedRect;
 …
                 exposedRect = brect;
+            }
             cacheOption.exposedRect = exposedRect;
+            styleOptionTmp.exposedRect = exposedRect;
             // Render.
             _q_paintIntoCache(&pix, item, pixmapExposed, itemToPixmap, painter->renderHints(),
                               &cacheOption, painterStateProtection);
             // Reinsert this pixmap into the cache.
             QPixmapCache::insert(pixmapKey, pix);
+                              &styleOptionTmp, painterStateProtection);
+            // insert this pixmap into the cache.
+            itemCache->key = QPixmapCache::insert(pix);
             // Reset expose data.
 …
 #else
         // Only if deviceRect is 20% taller or wider than the desktop.
+        QRect desktopRect = qApp->desktop()->availableGeometry(widget);
+        bool allowPartialCacheExposure = (desktopRect.width() * 1.2 < deviceRect.width()
+                                          || desktopRect.height() * 1.2 < deviceRect.height());
+        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
         QRegion scrollExposure;
 …
         // Check for newly invalidated areas.
         if (itemCache->allExposed || !itemCache->exposed.isEmpty() || !scrollExposure.isEmpty()) {
+            //We know that we will modify the pixmap, removing it from the cache
+            //will detach the one we have and avoid a deep copy
+            if (pixmapFound)
+                QPixmapCache::remove(pixmapKey);
             // Construct an item-to-pixmap transform.
             QPointF p = deviceRect.topLeft();
 …
                     br |= pixmapToItem.mapRect(r);
+            }
             QStyleOptionGraphicsItem cacheOption = *option;
             cacheOption.exposedRect = br.adjusted(-1, -1, 1, 1);
+            styleOptionTmp = *option;
+            styleOptionTmp.exposedRect = br.adjusted(-1, -1, 1, 1);
             // Render the exposed areas.
             _q_paintIntoCache(&pix, item, pixmapExposed, itemToPixmap, painter->renderHints(),
                               &cacheOption, painterStateProtection);
+                              &styleOptionTmp, painterStateProtection);
             // Reset expose data.
 …
         if (pixModified) {
             // Reinsert this pixmap into the cache
             QPixmapCache::insert(pixmapKey, pix);
+            // Insert this pixmap into the cache.
+            deviceData->key = QPixmapCache::insert(pix);
+        }
 …
+}
+void QGraphicsScenePrivate::drawItems(QPainter *painter, const QTransform *const viewTransform,
+                                      QRegion *exposedRegion, QWidget *widget)
+{
+    // Make sure we don't have unpolished items before we draw.
+    if (!unpolishedItems.isEmpty())
+        _q_polishItems();
+    QRectF exposedSceneRect;
+    if (exposedRegion && indexMethod != QGraphicsScene::NoIndex) {
+        exposedSceneRect = exposedRegion->boundingRect().adjusted(-1, -1, 1, 1);
+        if (viewTransform)
+            exposedSceneRect = viewTransform->inverted().mapRect(exposedSceneRect);
+    }
+    const QList<QGraphicsItem *> tli = index->estimateTopLevelItems(exposedSceneRect, Qt::AscendingOrder);
+    for (int i = 0; i < tli.size(); ++i)
+        drawSubtreeRecursive(tli.at(i), painter, viewTransform, exposedRegion, widget);
+}
+void QGraphicsScenePrivate::drawSubtreeRecursive(QGraphicsItem *item, QPainter *painter,
+                                                 const QTransform *const viewTransform,
+                                                 QRegion *exposedRegion, QWidget *widget,
+                                                 qreal parentOpacity, const QTransform *const effectTransform)
+{
+    Q_ASSERT(item);
+    if (!item->d_ptr->visible)
+        return;
+    const bool itemHasContents = !(item->d_ptr->flags & QGraphicsItem::ItemHasNoContents);
+    const bool itemHasChildren = !item->d_ptr->children.isEmpty();
+    if (!itemHasContents && !itemHasChildren)
+        return; // Item has neither contents nor children!(?)
+    const qreal opacity = item->d_ptr->combineOpacityFromParent(parentOpacity);
+    const bool itemIsFullyTransparent = (opacity < 0.0001);
+    if (itemIsFullyTransparent && (!itemHasChildren || item->d_ptr->childrenCombineOpacity()))
+        return;
+    QTransform transform(Qt::Uninitialized);
+    QTransform *transformPtr = 0;
+    bool translateOnlyTransform = false;
+#define ENSURE_TRANSFORM_PTR \
+    if (!transformPtr) { \
+        Q_ASSERT(!itemIsUntransformable); \
+        if (viewTransform) { \
+            transform = item->d_ptr->sceneTransform; \
+            transform *= *viewTransform; \
+            transformPtr = &transform; \
+        } else { \
+            transformPtr = &item->d_ptr->sceneTransform; \
+            translateOnlyTransform = item->d_ptr->sceneTransformTranslateOnly; \
+        } \
+    }
+    // Update the item's scene transform if the item is transformable;
+    // otherwise calculate the full transform,
+    bool wasDirtyParentSceneTransform = false;
+    const bool itemIsUntransformable = item->d_ptr->itemIsUntransformable();
+    if (itemIsUntransformable) {
+        transform = item->deviceTransform(viewTransform ? *viewTransform : QTransform());
+        transformPtr = &transform;
+    } else if (item->d_ptr->dirtySceneTransform) {
+        item->d_ptr->updateSceneTransformFromParent();
+        Q_ASSERT(!item->d_ptr->dirtySceneTransform);
+        wasDirtyParentSceneTransform = true;
+    }
+    const bool itemClipsChildrenToShape = (item->d_ptr->flags & QGraphicsItem::ItemClipsChildrenToShape);
+    bool drawItem = itemHasContents && !itemIsFullyTransparent;
+    if (drawItem) {
+        const QRectF brect = adjustedItemEffectiveBoundingRect(item);
+        ENSURE_TRANSFORM_PTR
+        QRect viewBoundingRect = translateOnlyTransform ? brect.translated(transformPtr->dx(), transformPtr->dy()).toRect()
+                                                        : transformPtr->mapRect(brect).toRect();
+        if (widget)
+            item->d_ptr->paintedViewBoundingRects.insert(widget, viewBoundingRect);
+        viewBoundingRect.adjust(-1, -1, 1, 1);
+        drawItem = exposedRegion ? exposedRegion->intersects(viewBoundingRect) : !viewBoundingRect.isEmpty();
+        if (!drawItem) {
+            if (!itemHasChildren)
+                return;
+            if (itemClipsChildrenToShape) {
+                if (wasDirtyParentSceneTransform)
+                    item->d_ptr->invalidateChildrenSceneTransform();
+                return;
+            }
+        }
+    } // else we know for sure this item has children we must process.
+    if (itemHasChildren && itemClipsChildrenToShape)
+        ENSURE_TRANSFORM_PTR;
+#ifndef QT_NO_GRAPHICSEFFECT
+    if (item->d_ptr->graphicsEffect && item->d_ptr->graphicsEffect->isEnabled()) {
+        ENSURE_TRANSFORM_PTR;
+        QGraphicsItemPaintInfo info(viewTransform, transformPtr, effectTransform, exposedRegion, widget, &styleOptionTmp,
+                                    painter, opacity, wasDirtyParentSceneTransform, drawItem);
+        QGraphicsEffectSource *source = item->d_ptr->graphicsEffect->d_func()->source;
+        QGraphicsItemEffectSourcePrivate *sourced = static_cast<QGraphicsItemEffectSourcePrivate *>
+                                                    (source->d_func());
+        sourced->info = &info;
+        const QTransform restoreTransform = painter->worldTransform();
+        if (effectTransform)
+            painter->setWorldTransform(*transformPtr * *effectTransform);
+        else
+            painter->setWorldTransform(*transformPtr);
+        painter->setOpacity(opacity);
+        if (sourced->currentCachedSystem() != Qt::LogicalCoordinates
+            && sourced->lastEffectTransform != painter->worldTransform())
+        {
+            sourced->lastEffectTransform = painter->worldTransform();
+            sourced->invalidateCache(QGraphicsEffectSourcePrivate::TransformChanged);
+        }
+        item->d_ptr->graphicsEffect->draw(painter);
+        painter->setWorldTransform(restoreTransform);
+        sourced->info = 0;
+    } else
+#endif //QT_NO_GRAPHICSEFFECT
+    {
+        draw(item, painter, viewTransform, transformPtr, exposedRegion, widget, opacity,
+             effectTransform, wasDirtyParentSceneTransform, drawItem);
+    }
+}
+void QGraphicsScenePrivate::draw(QGraphicsItem *item, QPainter *painter, const QTransform *const viewTransform,
+                                 const QTransform *const transformPtr, QRegion *exposedRegion, QWidget *widget,
+                                 qreal opacity, const QTransform *effectTransform,
+                                 bool wasDirtyParentSceneTransform, bool drawItem)
+{
+    const bool itemIsFullyTransparent = (opacity < 0.0001);
+    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);
+            painter->setClipPath(item->shape(), 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);
+        }
+    }
+    // Draw item
+    if (drawItem) {
+        Q_ASSERT(!itemIsFullyTransparent);
+        Q_ASSERT(!(item->d_ptr->flags & QGraphicsItem::ItemHasNoContents));
+        Q_ASSERT(transformPtr);
+        item->d_ptr->initStyleOption(&styleOptionTmp, *transformPtr, exposedRegion
+                                     ? *exposedRegion : QRegion(), exposedRegion == 0);
+        const bool itemClipsToShape = item->d_ptr->flags & QGraphicsItem::ItemClipsToShape;
+        const bool savePainter = itemClipsToShape || painterStateProtection;
+        if (savePainter)
+            painter->save();
+        if (!itemHasChildren || !itemClipsChildrenToShape) {
+            if (effectTransform)
+                painter->setWorldTransform(*transformPtr * *effectTransform);
+            else
+                painter->setWorldTransform(*transformPtr);
+        }
+        if (itemClipsToShape)
+            painter->setClipPath(item->shape(), Qt::IntersectClip);
+        painter->setOpacity(opacity);
+        if (!item->d_ptr->cacheMode && !item->d_ptr->isWidget)
+            item->paint(painter, &styleOptionTmp, widget);
+        else
+            drawItemHelper(item, painter, &styleOptionTmp, widget, painterStateProtection);
+        if (savePainter)
+            painter->restore();
+    }
+    // Draw children in front
+    if (itemHasChildren) {
+        for (; i < item->d_ptr->children.size(); ++i) {
+            QGraphicsItem *child = item->d_ptr->children.at(i);
+            if (wasDirtyParentSceneTransform)
+                child->d_ptr->dirtySceneTransform = 1;
+            if (itemIsFullyTransparent && !(child->d_ptr->flags & QGraphicsItem::ItemIgnoresParentOpacity))
+                continue;
+            drawSubtreeRecursive(child, painter, viewTransform, exposedRegion, widget, opacity, effectTransform);
+        }
+    }
+    // Restore child clip
+    if (itemHasChildren && itemClipsChildrenToShape)
+        painter->restore();
+}
+void QGraphicsScenePrivate::markDirty(QGraphicsItem *item, const QRectF &rect, bool invalidateChildren,
+                                      bool force, bool ignoreOpacity, bool removingItemFromScene)
+{
+    Q_ASSERT(item);
+    if (updateAll)
+        return;
+    if (item->d_ptr->discardUpdateRequest(/*ignoreVisibleBit=*/force,
+                                          /*ignoreDirtyBit=*/removingItemFromScene || invalidateChildren,
+                                          /*ignoreOpacity=*/ignoreOpacity)) {
+        if (item->d_ptr->dirty) {
+            // The item is already marked as dirty and will be processed later. However,
+            // we have to make sure ignoreVisible and ignoreOpacity are set properly;
+            // otherwise things like: item->update(); item->hide() (force is now true)
+            // won't work as expected.
+            if (force)
+                item->d_ptr->ignoreVisible = 1;
+            if (ignoreOpacity)
+                item->d_ptr->ignoreOpacity = 1;
+        }
+        return;
+    }
+    const bool fullItemUpdate = rect.isNull();
+    if (!fullItemUpdate && rect.isEmpty())
+        return;
+    if (!processDirtyItemsEmitted) {
+        QMetaObject::invokeMethod(q_ptr, "_q_processDirtyItems", Qt::QueuedConnection);
+        processDirtyItemsEmitted = true;
+    }
+    if (removingItemFromScene) {
+        // Note that this function can be called from the item's destructor, so
+        // do NOT call any virtual functions on it within this block.
+        if (isSignalConnected(changedSignalIndex) || views.isEmpty()) {
+            // This block of code is kept for compatibility. Since 4.5, by default
+            // QGraphicsView does not connect the signal and we use the below
+            // method of delivering updates.
+            q_func()->update();
+            return;
+        }
+        for (int i = 0; i < views.size(); ++i) {
+            QGraphicsViewPrivate *viewPrivate = views.at(i)->d_func();
+            QRect rect = item->d_ptr->paintedViewBoundingRects.value(viewPrivate->viewport);
+            rect.translate(viewPrivate->dirtyScrollOffset);
+            viewPrivate->updateRect(rect);
+        }
+        return;
+    }
+    bool hasNoContents = item->d_ptr->flags & QGraphicsItem::ItemHasNoContents
+                         && !item->d_ptr->graphicsEffect;
+    if (!hasNoContents) {
+        item->d_ptr->dirty = 1;
+        if (fullItemUpdate)
+            item->d_ptr->fullUpdatePending = 1;
+        else if (!item->d_ptr->fullUpdatePending)
+            item->d_ptr->needsRepaint |= rect;
+    }
+    if (invalidateChildren) {
+        item->d_ptr->allChildrenDirty = 1;
+        item->d_ptr->dirtyChildren = 1;
+    }
+    if (force)
+        item->d_ptr->ignoreVisible = 1;
+    if (ignoreOpacity)
+        item->d_ptr->ignoreOpacity = 1;
+    QGraphicsItem *p = item->d_ptr->parent;
+    while (p) {
+        p->d_ptr->dirtyChildren = 1;
+#ifndef QT_NO_GRAPHICSEFFECT
+        if (p->d_ptr->graphicsEffect && p->d_ptr->graphicsEffect->isEnabled()) {
+            p->d_ptr->dirty = 1;
+            p->d_ptr->fullUpdatePending = 1;
+        }
+#endif //QT_NO_GRAPHICSEFFECT
+        p = p->d_ptr->parent;
+    }
+}
+static inline bool updateHelper(QGraphicsViewPrivate *view, QGraphicsItemPrivate *item,
+                                const QRectF &rect, bool itemIsUntransformable)
+{
+    Q_ASSERT(view);
+    Q_ASSERT(item);
+    QGraphicsItem *itemq = static_cast<QGraphicsItem *>(item->q_ptr);
+    QGraphicsView *viewq = static_cast<QGraphicsView *>(view->q_ptr);
+    if (itemIsUntransformable) {
+        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())));
+    }
+    if (item->sceneTransformTranslateOnly && view->identityMatrix) {
+        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);
+    }
+    if (!viewq->isTransformed()) {
+        if (!item->hasBoundingRegionGranularity)
+            return view->updateRect(item->sceneTransform.mapRect(rect).toRect());
+        return view->updateRegion(item->sceneTransform.map(QRegion(rect.toRect())));
+    }
+    QTransform xform = item->sceneTransform;
+    xform *= viewq->viewportTransform();
+    if (!item->hasBoundingRegionGranularity)
+        return view->updateRect(xform.mapRect(rect).toRect());
+    return view->updateRegion(xform.map(QRegion(rect.toRect())));
+}
+void QGraphicsScenePrivate::processDirtyItemsRecursive(QGraphicsItem *item, bool dirtyAncestorContainsChildren,
+                                                       qreal parentOpacity)
+{
+    Q_Q(QGraphicsScene);
+    Q_ASSERT(item);
+    Q_ASSERT(!updateAll);
+    if (!item->d_ptr->dirty && !item->d_ptr->dirtyChildren) {
+        resetDirtyItem(item);
+        return;
+    }
+    const bool itemIsHidden = !item->d_ptr->ignoreVisible && !item->d_ptr->visible;
+    if (itemIsHidden) {
+        resetDirtyItem(item, /*recursive=*/true);
+        return;
+    }
+    bool itemHasContents = !(item->d_ptr->flags & QGraphicsItem::ItemHasNoContents);
+    const bool itemHasChildren = !item->d_ptr->children.isEmpty();
+    if (!itemHasContents) {
+        if (!itemHasChildren) {
+            resetDirtyItem(item);
+            return; // Item has neither contents nor children!(?)
+        }
+        if (item->d_ptr->graphicsEffect)
+            itemHasContents = true;
+    }
+    const qreal opacity = item->d_ptr->combineOpacityFromParent(parentOpacity);
+    const bool itemIsFullyTransparent = !item->d_ptr->ignoreOpacity && opacity < 0.0001;
+    if (itemIsFullyTransparent && (!itemHasChildren || item->d_ptr->childrenCombineOpacity())) {
+        resetDirtyItem(item, /*recursive=*/itemHasChildren);
+        return;
+    }
+    bool wasDirtyParentSceneTransform = item->d_ptr->dirtySceneTransform;
+    const bool itemIsUntransformable = item->d_ptr->itemIsUntransformable();
+    if (wasDirtyParentSceneTransform && !itemIsUntransformable) {
+        item->d_ptr->updateSceneTransformFromParent();
+        Q_ASSERT(!item->d_ptr->dirtySceneTransform);
+    }
+    const bool wasDirtyParentViewBoundingRects = item->d_ptr->paintedViewBoundingRectsNeedRepaint;
+    if (itemIsFullyTransparent || !itemHasContents || dirtyAncestorContainsChildren) {
+        // Make sure we don't process invisible items or items with no content.
+        item->d_ptr->dirty = 0;
+        item->d_ptr->fullUpdatePending = 0;
+        // Might have a dirty view bounding rect otherwise.
+        if (itemIsFullyTransparent || !itemHasContents)
+            item->d_ptr->paintedViewBoundingRectsNeedRepaint = 0;
+    }
+    if (!hasSceneRect && item->d_ptr->geometryChanged && item->d_ptr->visible) {
+        // Update growingItemsBoundingRect.
+        if (item->d_ptr->sceneTransformTranslateOnly) {
+            growingItemsBoundingRect |= item->boundingRect().translated(item->d_ptr->sceneTransform.dx(),
+                                                                        item->d_ptr->sceneTransform.dy());
+        } else {
+            growingItemsBoundingRect |= item->d_ptr->sceneTransform.mapRect(item->boundingRect());
+        }
+    }
+    // Process item.
+    if (item->d_ptr->dirty || item->d_ptr->paintedViewBoundingRectsNeedRepaint) {
+        const bool useCompatUpdate = views.isEmpty() || isSignalConnected(changedSignalIndex);
+        const QRectF itemBoundingRect = adjustedItemEffectiveBoundingRect(item);
+        if (useCompatUpdate && !itemIsUntransformable && qFuzzyIsNull(item->boundingRegionGranularity())) {
+            // This block of code is kept for compatibility. Since 4.5, by default
+            // QGraphicsView does not connect the signal and we use the below
+            // method of delivering updates.
+            if (item->d_ptr->sceneTransformTranslateOnly) {
+                q->update(itemBoundingRect.translated(item->d_ptr->sceneTransform.dx(),
+                                                      item->d_ptr->sceneTransform.dy()));
+            } else {
+                q->update(item->d_ptr->sceneTransform.mapRect(itemBoundingRect));
+            }
+        } else {
+            QRectF dirtyRect;
+            bool uninitializedDirtyRect = true;
+            for (int j = 0; j < views.size(); ++j) {
+                QGraphicsView *view = views.at(j);
+                QGraphicsViewPrivate *viewPrivate = view->d_func();
+                QRect &paintedViewBoundingRect = item->d_ptr->paintedViewBoundingRects[viewPrivate->viewport];
+                if (viewPrivate->fullUpdatePending
+                    || viewPrivate->viewportUpdateMode == QGraphicsView::NoViewportUpdate) {
+                    // Okay, if we have a full update pending or no viewport update, this item's
+                    // paintedViewBoundingRect  will be updated correctly in the next paintEvent if
+                    // it is inside the viewport, but for now we can pretend that it is outside.
+                    paintedViewBoundingRect = QRect(-1, -1, -1, -1);
+                    continue;
+                }
+                if (item->d_ptr->paintedViewBoundingRectsNeedRepaint) {
+                    paintedViewBoundingRect.translate(viewPrivate->dirtyScrollOffset);
+                    if (!viewPrivate->updateRect(paintedViewBoundingRect))
+                        paintedViewBoundingRect = QRect(-1, -1, -1, -1); // Outside viewport.
+                }
+                if (!item->d_ptr->dirty)
+                    continue;
+                if (!item->d_ptr->paintedViewBoundingRectsNeedRepaint
+                    && paintedViewBoundingRect.x() == -1 && paintedViewBoundingRect.y() == -1
+                    && paintedViewBoundingRect.width() == -1 && paintedViewBoundingRect.height() == -1) {
+                    continue; // Outside viewport.
+                }
+                if (uninitializedDirtyRect) {
+                    dirtyRect = itemBoundingRect;
+                    if (!item->d_ptr->fullUpdatePending) {
+                        _q_adjustRect(&item->d_ptr->needsRepaint);
+                        dirtyRect &= item->d_ptr->needsRepaint;
+                    }
+                    uninitializedDirtyRect = false;
+                }
+                if (dirtyRect.isEmpty())
+                    continue; // Discard updates outside the bounding rect.
+                if (!updateHelper(viewPrivate, item->d_ptr.data(), dirtyRect, itemIsUntransformable)
+                    && item->d_ptr->paintedViewBoundingRectsNeedRepaint) {
+                    paintedViewBoundingRect = QRect(-1, -1, -1, -1); // Outside viewport.
+                }
+            }
+        }
+    }
+    // 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;
+        const bool parentIgnoresVisible = item->d_ptr->ignoreVisible;
+        const bool parentIgnoresOpacity = item->d_ptr->ignoreOpacity;
+        for (int 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 (wasDirtyParentViewBoundingRects)
+                child->d_ptr->paintedViewBoundingRectsNeedRepaint = 1;
+            if (parentIgnoresVisible)
+                child->d_ptr->ignoreVisible = 1;
+            if (parentIgnoresOpacity)
+                child->d_ptr->ignoreOpacity = 1;
+            if (allChildrenDirty) {
+                child->d_ptr->dirty = 1;
+                child->d_ptr->fullUpdatePending = 1;
+                child->d_ptr->dirtyChildren = 1;
+                child->d_ptr->allChildrenDirty = 1;
+            }
+            processDirtyItemsRecursive(child, dirtyAncestorContainsChildren, opacity);
+        }
+    } else if (wasDirtyParentSceneTransform) {
+        item->d_ptr->invalidateChildrenSceneTransform();
+    }
+    resetDirtyItem(item);
+}
 /*!
     Paints the given \a items using the provided \a painter, after the
 …
     drawn.  All painting is done in \e scene coordinates. Before
     drawing each item, the painter must be transformed using
     QGraphicsItem::sceneMatrix().
+    QGraphicsItem::sceneTransform().
     The \a options parameter is the list of style option objects for
 …
     \snippet doc/src/snippets/graphicssceneadditemsnippet.cpp 0
+    \obsolete Since Qt 4.6, this function is not called anymore unless
+    the QGraphicsView::IndirectPainting flag is given as an Optimization
+    flag.
     \sa drawBackground(), drawForeground()
 */
 …
+{
     Q_D(QGraphicsScene);
+    // Detect if painter state protection is disabled.
+    // Make sure we don't have unpolished items before we draw.
+    if (!d->unpolishedItems.isEmpty())
+        d->_q_polishItems();
     QTransform viewTransform = painter->worldTransform();
+    QVarLengthArray<QGraphicsItem *, 16> childClippers;
+    Q_UNUSED(options);
+    // Determine view, expose and flags.
+    QGraphicsView *view = widget ? qobject_cast<QGraphicsView *>(widget->parentWidget()) : 0;
+    QRegion *expose = 0;
+    if (view)
+        expose = &view->d_func()->exposedRegion;
+    // Find all toplevels, they are already sorted.
+    QList<QGraphicsItem *> topLevelItems;
     for (int i = 0; i < numItems; ++i) {
+        QGraphicsItem *item = items[i];
+        if (!(item->d_ptr->ancestorFlags & QGraphicsItemPrivate::AncestorClipsChildren)) {
+            if (!childClippers.isEmpty()) {
+                // Item is not clipped to any ancestor: pop all current clippers.
+                for (int i = 0; i < childClippers.size(); ++i)
+                    painter->restore();
+                childClippers.clear();
+            }
+        } else {
+            // Item is clipped to an ancestor, which may or may not be in our
+            // child clipper list. Let's start by finding the item's closest
+            // clipping ancestor.
+            QGraphicsItem *clipParent = item->parentItem();
+            while (clipParent && !(clipParent->d_ptr->flags & QGraphicsItem::ItemClipsChildrenToShape))
+                clipParent = clipParent->parentItem();
+            // Pop any in-between clippers. If the clipper is unknown, pop
+            // them all.  ### QVarLengthArray::lastIndexOf().
+            int index = -1;
+            for (int n = childClippers.size() - 1; n >= 0; --n) {
+                if (childClippers[n] == clipParent) {
+                    index = n;
+                    break;
+                }
+            }
+            if (index != -1) {
+                int toPop = childClippers.size() - index - 1;
+                if (toPop > 0) {
+                    for (int i = 0; i < toPop; ++i)
+                        painter->restore();
+                    childClippers.resize(index + 1);
+                }
+            }
+            // Sanity check
+            if (!childClippers.isEmpty())
+                Q_ASSERT(childClippers[childClippers.size() - 1] == clipParent);
+            // If the clipper list is empty at this point, but we're still
+            // clipped to an ancestor, then we need to build the clip chain
+            // ourselves. There is only one case that can produce this issue:
+            // This item is stacked behind an ancestor:
+            // ItemStacksBehindParent.
+            if (childClippers.isEmpty()) {
+                Q_ASSERT(clipParent != 0);
+                // Build a stack of clippers.
+                QVarLengthArray<QGraphicsItem *, 16> clippers;
+                QGraphicsItem *p = clipParent;
+                do {
+                    if (p->d_ptr->flags & QGraphicsItem::ItemClipsChildrenToShape)
+                        clippers.append(p);
+                } while ((p = p->parentItem()) && (p->d_ptr->ancestorFlags & QGraphicsItemPrivate::AncestorClipsChildren));
+                // ### This code path can also use the itemTransform
+                // optimization, but it's hit very rarely.
+                for (int i = clippers.size() - 1; i >= 0; --i) {
+                    QGraphicsItem *clipper = clippers[i];
+                    if (clipper->d_ptr->itemIsUntransformable()) {
+                        painter->setWorldTransform(clipper->deviceTransform(viewTransform), false);
+                    } else {
+                        painter->setWorldTransform(clipper->sceneTransform() * viewTransform, false);
+                    }
+                    childClippers.append(clipper);
+                    painter->save();
+                    painter->setClipPath(clipper->shape(), Qt::IntersectClip);
+                }
+                Q_ASSERT(childClippers[childClippers.size() - 1] == clipParent);
+            }
+        }
+        // Set up the painter transform
+        if (item->d_ptr->itemIsUntransformable()) {
+            painter->setWorldTransform(item->deviceTransform(viewTransform), false);
+        } else {
+            painter->setWorldTransform(item->sceneTransform() * viewTransform, false);
+        }
+        // Save painter
+        bool saveState = (d->painterStateProtection || (item->flags() & QGraphicsItem::ItemClipsToShape));
+        if (saveState)
+            painter->save();
+        // Set local clip
+        if (item->flags() & QGraphicsItem::ItemClipsToShape)
+            painter->setClipPath(item->shape(), Qt::IntersectClip);
+        // Setup opacity
+        painter->setOpacity(item->effectiveOpacity());
+        // Draw the item
+        d->drawItemHelper(item, painter, &options[i], widget, d->painterStateProtection);
+        if (saveState)
+            painter->restore();
+        if (item->flags() & QGraphicsItem::ItemClipsChildrenToShape) {
+            // Clip descendents to this item's shape, and keep the painter
+            // saved.
+            childClippers.append(item);
+            painter->save();
+            painter->setClipPath(item->shape(), Qt::IntersectClip);
+        }
+    }
+    for (int i = 0; i < childClippers.size(); ++i)
+        painter->restore();
+        QGraphicsItem *item = items[i]->topLevelItem();
+        if (!item->d_ptr->itemDiscovered) {
+            topLevelItems << item;
+            item->d_ptr->itemDiscovered = 1;
+            d->drawSubtreeRecursive(item, painter, &viewTransform, expose, widget);
+        }
+    }
+    // Reset discovery bits.
+    for (int i = 0; i < topLevelItems.size(); ++i)
+        topLevelItems.at(i)->d_ptr->itemDiscovered = 0;
     painter->setWorldTransform(viewTransform);
 …
             && widget->isEnabled() && widget->isVisibleTo(0)
             && (widget->focusPolicy() & Qt::TabFocus)
             && (!item || !item->isWindow() || item->isAncestorOf(widget))
+            && (!item || !item->isPanel() || item->isAncestorOf(widget))
             ) {
             setFocusItem(widget, next ? Qt::TabFocusReason : Qt::BacktabFocusReason);
 …
 /*!
-    \internal
-    This private function is called by QGraphicsItem, which is a friend of
-    QGraphicsScene. It is used by QGraphicsScene to record the rectangles that
-    need updating. It also launches a single-shot timer to ensure that
-    updated() will be emitted later.
-    The \a item parameter is the item that changed, and \a rect is the
-    area of the item that changed given in item coordinates.
-*/
-void QGraphicsScene::itemUpdated(QGraphicsItem *item, const QRectF &rect)
+{
-    Q_D(QGraphicsScene);
-    // Deliver the actual update.
-    if (!d->updateAll) {
-        if (d->views.isEmpty() || ((d->connectedSignals & d->changedSignalMask) && !item->d_ptr->itemIsUntransformable()
-                                   && qFuzzyCompare(item->boundingRegionGranularity(), qreal(0.0)))) {
-            // This block of code is kept for compatibility. Since 4.5, by default
-            // QGraphicsView does not connect the signal and we use the below
-            // method of delivering updates.
-            update(item->sceneBoundingRect());
-        } else {
-            // ### Remove _q_adjustedRects().
-            QRectF boundingRect(adjustedItemBoundingRect(item));
-            if (!rect.isNull()) {
-                QRectF adjustedRect(rect);
-                _q_adjustRect(&adjustedRect);
-                boundingRect &= adjustedRect;
+            }
-            // Update each view directly.
-            for (int i = 0; i < d->views.size(); ++i)
-                d->views.at(i)->d_func()->itemUpdated(item, boundingRect);
+        }
+    }
-    if (item->d_ptr->dirty) {
-        d->dirtyItems << item;
-        d->resetDirtyItemsLater();
+    }
-    if (!item->isVisible())
-        return; // Hiding an item won't effect the largestUntransformableItem/sceneRect.
-    // Update d->largestUntransformableItem by mapping this item's bounding
-    // rect back to the topmost untransformable item's untransformed
-    // coordinate system (which sort of equals the 1:1 coordinate system of an
-    // untransformed view).
-    if (item->d_ptr->itemIsUntransformable()) {
-        QGraphicsItem *parent = item;
-        while (parent && (parent->d_ptr->ancestorFlags & QGraphicsItemPrivate::AncestorIgnoresTransformations))
-            parent = parent->parentItem();
-        d->largestUntransformableItem |= item->mapToItem(parent, item->boundingRect()).boundingRect();
+    }
-    // Only track the automatically growing scene rect if the scene has no
-    // defined scene rect.
-    if (!d->hasSceneRect) {
-        QRectF oldGrowingItemsBoundingRect = d->growingItemsBoundingRect;
-        QRectF adjustedItemSceneBoundingRect(item->sceneBoundingRect());
-        _q_adjustRect(&adjustedItemSceneBoundingRect);
-        d->growingItemsBoundingRect |= adjustedItemSceneBoundingRect;
-        if (d->growingItemsBoundingRect != oldGrowingItemsBoundingRect)
-            emit sceneRectChanged(d->growingItemsBoundingRect);
+    }
+}
-/*!
     \since 4.4
 …
     Q_D(const QGraphicsScene);
     // ### This function, and the use of styles in general, is non-reentrant.
     return d->style ? d->style : qApp->style();
+    return d->style ? d->style : QApplication::style();
+}
 …
+{
     Q_D(QGraphicsScene);
     QFont naturalFont = qApp->font();
+    QFont naturalFont = QApplication::font();
     naturalFont.resolve(0);
     QFont resolvedFont = font.resolve(naturalFont);
 …
+{
     Q_D(QGraphicsScene);
     QPalette naturalPalette = qApp->palette();
+    QPalette naturalPalette = QApplication::palette();
     naturalPalette.resolve(0);
     QPalette resolvedPalette = palette.resolve(naturalPalette);
 …
 /*!
+    \since 4.6
+    Returns true if the scene is active (e.g., it's viewed by
+    at least one QGraphicsView that is active); otherwise returns false.
+    \sa QGraphicsItem::isActive(), QWidget::isActiveWindow()
+*/
+bool QGraphicsScene::isActive() const
+{
+    Q_D(const QGraphicsScene);
+    return d->activationRefCount > 0;
+}
+/*!
+    \since 4.6
+    Returns the current active panel, or 0 if no panel is currently active.
+    \sa QGraphicsScene::setActivePanel()
+*/
+QGraphicsItem *QGraphicsScene::activePanel() const
+{
+    Q_D(const QGraphicsScene);
+    return d->activePanel;
+}
+/*!
+    \since 4.6
+    Activates \a item, which must be an item in this scene. You
+    can also pass 0 for \a item, in which case QGraphicsScene will
+    deactivate any currently active panel.
+    If the scene is currently inactive, \a item remains inactive until the
+    scene becomes active (or, ir \a item is 0, no item will be activated).
+    \sa activePanel(), isActive(), QGraphicsItem::isActive()
+*/
+void QGraphicsScene::setActivePanel(QGraphicsItem *item)
+{
+    Q_D(QGraphicsScene);
+    d->setActivePanelHelper(item, false);
+}
+/*!
     \since 4.4
     Returns the current active window, or 0 if there is no window is currently
+    Returns the current active window, or 0 if no window is currently
     active.
 …
+{
     Q_D(const QGraphicsScene);
+    return d->activeWindow;
+    if (d->activePanel && d->activePanel->isWindow())
+        return static_cast<QGraphicsWidget *>(d->activePanel);
+    return 0;
+}
 …
 void QGraphicsScene::setActiveWindow(QGraphicsWidget *widget)
+{
-    Q_D(QGraphicsScene);
     if (widget && widget->scene() != this) {
         qWarning("QGraphicsScene::setActiveWindow: widget %p must be part of this scene",
 …
+    }
+    // Activate the widget's window.
+    QGraphicsWidget *window = widget ? widget->window() : 0;
+    if (window == d->activeWindow)
+        return;
+    // Deactivate the last active window.
+    if (d->activeWindow) {
+        if (QGraphicsWidget *fw = d->activeWindow->focusWidget()) {
+            // Remove focus from the current focus item.
+            if (fw == focusItem())
+                setFocusItem(0, Qt::ActiveWindowFocusReason);
+        }
+        QEvent event(QEvent::WindowDeactivate);
+        QApplication::sendEvent(d->activeWindow, &event);
+    }
+    // Update activate state.
+    d->activeWindow = window;
+    QEvent event(QEvent::ActivationChange);
+    QApplication::sendEvent(this, &event);
+    // Activate
+    if (window) {
+        QEvent event(QEvent::WindowActivate);
+        QApplication::sendEvent(window, &event);
+    // Activate the widget's panel (all windows are panels).
+    QGraphicsItem *panel = widget ? widget->panel() : 0;
+    setActivePanel(panel);
+    // Raise
+    if (panel) {
         QList<QGraphicsItem *> siblingWindows;
         QGraphicsItem *parent = window->parentItem();
+        QGraphicsItem *parent = panel->parentItem();
         // Raise ### inefficient for toplevels
         foreach (QGraphicsItem *sibling, parent ? parent->children() : items()) {
+            if (sibling != window && sibling->isWidget()
+                && static_cast<QGraphicsWidget *>(sibling)->isWindow()) {
+            if (sibling != panel && sibling->isWindow())
                 siblingWindows << sibling;
+            }
+        }
         // Find the highest z value.
         qreal z = window->zValue();
+        qreal z = panel->zValue();
         for (int i = 0; i < siblingWindows.size(); ++i)
             z = qMax(z, siblingWindows.at(i)->zValue());
 …
         // This will probably never overflow.
         const qreal litt = qreal(0.001);
+        window->setZValue(z + litt);
+        if (QGraphicsWidget *focusChild = window->focusWidget())
+            focusChild->setFocus(Qt::ActiveWindowFocusReason);
+        panel->setZValue(z + litt);
+    }
+}
+/*!
+    \since 4.6
+    Sends event \a event to item \a item through possible event filters.
+    The event is sent only if the item is enabled.
+    Returns \c false if the event was filtered or if the item is disabled.
+    Otherwise returns the value that was returned from the event handler.
+    \sa QGraphicsItem::sceneEvent(), QGraphicsItem::sceneEventFilter()
+*/
+bool QGraphicsScene::sendEvent(QGraphicsItem *item, QEvent *event)
+{
+    Q_D(QGraphicsScene);
+    if (!item) {
+        qWarning("QGraphicsScene::sendEvent: cannot send event to a null item");
+        return false;
+    }
+    if (item->scene() != this) {
+        qWarning("QGraphicsScene::sendEvent: item %p's scene (%p)"
+                 " is different from this scene (%p)",
+                 item, item->scene(), this);
+        return false;
+    }
+    return d->sendEvent(item, event);
+}
+void QGraphicsScenePrivate::addView(QGraphicsView *view)
+{
+    views << view;
+}
+void QGraphicsScenePrivate::removeView(QGraphicsView *view)
+{
+    views.removeAll(view);
+}
+void QGraphicsScenePrivate::updateTouchPointsForItem(QGraphicsItem *item, QTouchEvent *touchEvent)
+{
+    QList<QTouchEvent::TouchPoint> touchPoints = touchEvent->touchPoints();
+    for (int i = 0; i < touchPoints.count(); ++i) {
+        QTouchEvent::TouchPoint &touchPoint = touchPoints[i];
+        touchPoint.setRect(item->mapFromScene(touchPoint.sceneRect()).boundingRect());
+        touchPoint.setStartPos(item->d_ptr->genericMapFromScene(touchPoint.startScenePos(), touchEvent->widget()));
+        touchPoint.setLastPos(item->d_ptr->genericMapFromScene(touchPoint.lastScenePos(), touchEvent->widget()));
+    }
+    touchEvent->setTouchPoints(touchPoints);
+}
+int QGraphicsScenePrivate::findClosestTouchPointId(const QPointF &scenePos)
+{
+    int closestTouchPointId = -1;
+    qreal closestDistance = qreal(0.);
+    foreach (const QTouchEvent::TouchPoint &touchPoint, sceneCurrentTouchPoints) {
+        qreal distance = QLineF(scenePos, touchPoint.scenePos()).length();
+        if (closestTouchPointId == -1|| distance < closestDistance) {
+            closestTouchPointId = touchPoint.id();
+            closestDistance = distance;
+        }
+    }
+    return closestTouchPointId;
+}
+void QGraphicsScenePrivate::touchEventHandler(QTouchEvent *sceneTouchEvent)
+{
+    typedef QPair<Qt::TouchPointStates, QList<QTouchEvent::TouchPoint> > StatesAndTouchPoints;
+    QHash<QGraphicsItem *, StatesAndTouchPoints> itemsNeedingEvents;
+    for (int i = 0; i < sceneTouchEvent->touchPoints().count(); ++i) {
+        const QTouchEvent::TouchPoint &touchPoint = sceneTouchEvent->touchPoints().at(i);
+        // update state
+        QGraphicsItem *item = 0;
+        if (touchPoint.state() == Qt::TouchPointPressed) {
+            if (sceneTouchEvent->deviceType() == QTouchEvent::TouchPad) {
+                // on touch-pad devices, send all touch points to the same item
+                item = itemForTouchPointId.isEmpty()
+                       ? 0
+                       : itemForTouchPointId.constBegin().value();
+            }
+            if (!item) {
+                // determine which item this touch point will go to
+                cachedItemsUnderMouse = itemsAtPosition(touchPoint.screenPos().toPoint(),
+                                                        touchPoint.scenePos(),
+                                                        sceneTouchEvent->widget());
+                item = cachedItemsUnderMouse.isEmpty() ? 0 : cachedItemsUnderMouse.first();
+            }
+            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 (
+                int closestTouchPointId = findClosestTouchPointId(touchPoint.scenePos());
+                QGraphicsItem *closestItem = itemForTouchPointId.value(closestTouchPointId);
+                if (!item
+                    || (closestItem
+                        && (item->isAncestorOf(closestItem)
+                            || closestItem->isAncestorOf(item)))) {
+                    item = closestItem;
+                }
+            }
+            if (!item)
+                continue;
+            itemForTouchPointId.insert(touchPoint.id(), item);
+            sceneCurrentTouchPoints.insert(touchPoint.id(), touchPoint);
+        } else if (touchPoint.state() == Qt::TouchPointReleased) {
+            item = itemForTouchPointId.take(touchPoint.id());
+            if (!item)
+                continue;
+            sceneCurrentTouchPoints.remove(touchPoint.id());
+        } else {
+            item = itemForTouchPointId.value(touchPoint.id());
+            if (!item)
+                continue;
+            Q_ASSERT(sceneCurrentTouchPoints.contains(touchPoint.id()));
+            sceneCurrentTouchPoints[touchPoint.id()] = touchPoint;
+        }
+        StatesAndTouchPoints &statesAndTouchPoints = itemsNeedingEvents[item];
+        statesAndTouchPoints.first |= touchPoint.state();
+        statesAndTouchPoints.second.append(touchPoint);
+    }
+    if (itemsNeedingEvents.isEmpty()) {
+        sceneTouchEvent->accept();
+        return;
+    }
+    bool ignoreSceneTouchEvent = true;
+    QHash<QGraphicsItem *, StatesAndTouchPoints>::ConstIterator it = itemsNeedingEvents.constBegin();
+    const QHash<QGraphicsItem *, StatesAndTouchPoints>::ConstIterator end = itemsNeedingEvents.constEnd();
+    for (; it != end; ++it) {
+        QGraphicsItem *item = it.key();
+        (void) item->isBlockedByModalPanel(&item);
+        // determine event type from the state mask
+        QEvent::Type eventType;
+        switch (it.value().first) {
+        case Qt::TouchPointPressed:
+            // all touch points have pressed state
+            eventType = QEvent::TouchBegin;
+            break;
+        case Qt::TouchPointReleased:
+            // all touch points have released state
+            eventType = QEvent::TouchEnd;
+            break;
+        case Qt::TouchPointStationary:
+            // don't send the event if nothing changed
+            continue;
+        default:
+            // all other combinations
+            eventType = QEvent::TouchUpdate;
+            break;
+        }
+        QTouchEvent touchEvent(eventType);
+        touchEvent.setWidget(sceneTouchEvent->widget());
+        touchEvent.setDeviceType(sceneTouchEvent->deviceType());
+        touchEvent.setModifiers(sceneTouchEvent->modifiers());
+        touchEvent.setTouchPointStates(it.value().first);
+        touchEvent.setTouchPoints(it.value().second);
+        switch (touchEvent.type()) {
+        case QEvent::TouchBegin:
+        {
+            // if the TouchBegin handler recurses, we assume that means the event
+            // has been implicitly accepted and continue to send touch events
+            item->d_ptr->acceptedTouchBeginEvent = true;
+            bool res = sendTouchBeginEvent(item, &touchEvent)
+                       && touchEvent.isAccepted();
+            if (!res)
+                ignoreSceneTouchEvent = false;
+            break;
+        }
+        default:
+            if (item->d_ptr->acceptedTouchBeginEvent) {
+                updateTouchPointsForItem(item, &touchEvent);
+                (void) sendEvent(item, &touchEvent);
+                ignoreSceneTouchEvent = false;
+            }
+            break;
+        }
+    }
+    sceneTouchEvent->setAccepted(ignoreSceneTouchEvent);
+}
+bool QGraphicsScenePrivate::sendTouchBeginEvent(QGraphicsItem *origin, QTouchEvent *touchEvent)
+{
+    Q_Q(QGraphicsScene);
+    if (cachedItemsUnderMouse.isEmpty() || cachedItemsUnderMouse.first() != origin) {
+        const QTouchEvent::TouchPoint &firstTouchPoint = touchEvent->touchPoints().first();
+        cachedItemsUnderMouse = itemsAtPosition(firstTouchPoint.screenPos().toPoint(),
+                                                firstTouchPoint.scenePos(),
+                                                touchEvent->widget());
+    }
+    Q_ASSERT(cachedItemsUnderMouse.first() == origin);
+    // Set focus on the topmost enabled item that can take focus.
+    bool setFocus = false;
+    foreach (QGraphicsItem *item, cachedItemsUnderMouse) {
+        if (item->isEnabled() && ((item->flags() & QGraphicsItem::ItemIsFocusable) && item->d_ptr->mouseSetsFocus)) {
+            if (!item->isWidget() || ((QGraphicsWidget *)item)->focusPolicy() & Qt::ClickFocus) {
+                setFocus = true;
+                if (item != q->focusItem())
+                    q->setFocusItem(item, Qt::MouseFocusReason);
+                break;
+            }
+        }
+        if (item->isPanel())
+            break;
+    }
+    // If nobody could take focus, clear it.
+    if (!stickyFocus && !setFocus)
+        q->setFocusItem(0, Qt::MouseFocusReason);
+    bool res = false;
+    bool eventAccepted = touchEvent->isAccepted();
+    foreach (QGraphicsItem *item, cachedItemsUnderMouse) {
+        // first, try to deliver the touch event
+        updateTouchPointsForItem(item, touchEvent);
+        bool acceptTouchEvents = item->acceptTouchEvents();
+        touchEvent->setAccepted(acceptTouchEvents);
+        res = acceptTouchEvents && sendEvent(item, touchEvent);
+        eventAccepted = touchEvent->isAccepted();
+        if (itemForTouchPointId.value(touchEvent->touchPoints().first().id()) == 0) {
+            // item was deleted
+            item = 0;
+        } else {
+            item->d_ptr->acceptedTouchBeginEvent = (res && eventAccepted);
+        }
+        touchEvent->spont = false;
+        if (res && eventAccepted) {
+            // the first item to accept the TouchBegin gets an implicit grab.
+            for (int i = 0; i < touchEvent->touchPoints().count(); ++i) {
+                const QTouchEvent::TouchPoint &touchPoint = touchEvent->touchPoints().at(i);
+                itemForTouchPointId[touchPoint.id()] = item; // can be zero
+            }
+            break;
+        }
+        if (item && item->isPanel())
+            break;
+    }
+    touchEvent->setAccepted(eventAccepted);
+    return res;
+}
+void QGraphicsScenePrivate::enableTouchEventsOnViews()
+{
+    foreach (QGraphicsView *view, views)
+        view->viewport()->setAttribute(Qt::WA_AcceptTouchEvents, true);
+}
+void QGraphicsScenePrivate::updateInputMethodSensitivityInViews()
+{
+    for (int i = 0; i < views.size(); ++i)
+        views.at(i)->d_func()->updateInputMethodSensitivity();
+}
+void QGraphicsScenePrivate::enterModal(QGraphicsItem *panel, QGraphicsItem::PanelModality previousModality)
+{
+    Q_Q(QGraphicsScene);
+    Q_ASSERT(panel && panel->isPanel());
+    QGraphicsItem::PanelModality panelModality = panel->d_ptr->panelModality;
+    if (previousModality != QGraphicsItem::NonModal) {
+        // the panel is changing from one modality type to another... temporarily set it back so
+        // that blockedPanels is populated correctly
+        panel->d_ptr->panelModality = previousModality;
+    }
+    QSet<QGraphicsItem *> blockedPanels;
+    QList<QGraphicsItem *> items = q->items(); // ### store panels separately
+    for (int i = 0; i < items.count(); ++i) {
+        QGraphicsItem *item = items.at(i);
+        if (item->isPanel() && item->isBlockedByModalPanel())
+            blockedPanels.insert(item);
+    }
+    // blockedPanels contains all currently blocked panels
+    if (previousModality != QGraphicsItem::NonModal) {
+        // reset the modality to the proper value, since we changed it above
+        panel->d_ptr->panelModality = panelModality;
+        // remove this panel so that it will be reinserted at the front of the stack
+        modalPanels.removeAll(panel);
+    }
+    modalPanels.prepend(panel);
+    if (!hoverItems.isEmpty()) {
+        // send GraphicsSceneHoverLeave events to newly blocked hoverItems
+        QGraphicsSceneHoverEvent hoverEvent;
+        hoverEvent.setScenePos(lastSceneMousePos);
+        dispatchHoverEvent(&hoverEvent);
+    }
+    if (!mouseGrabberItems.isEmpty() && lastMouseGrabberItemHasImplicitMouseGrab) {
+        QGraphicsItem *item = mouseGrabberItems.last();
+        if (item->isBlockedByModalPanel())
+            ungrabMouse(item, /*itemIsDying =*/ false);
+    }
+    QEvent windowBlockedEvent(QEvent::WindowBlocked);
+    QEvent windowUnblockedEvent(QEvent::WindowUnblocked);
+    for (int i = 0; i < items.count(); ++i) {
+        QGraphicsItem *item = items.at(i);
+        if (item->isPanel()) {
+            if (!blockedPanels.contains(item) && item->isBlockedByModalPanel()) {
+                // send QEvent::WindowBlocked to newly blocked panels
+                sendEvent(item, &windowBlockedEvent);
+            } else if (blockedPanels.contains(item) && !item->isBlockedByModalPanel()) {
+                // send QEvent::WindowUnblocked to unblocked panels when downgrading
+                // a panel from SceneModal to PanelModal
+                sendEvent(item, &windowUnblockedEvent);
+            }
+        }
+    }
+}
+void QGraphicsScenePrivate::leaveModal(QGraphicsItem *panel)
+{
+    Q_Q(QGraphicsScene);
+    Q_ASSERT(panel && panel->isPanel());
+    QSet<QGraphicsItem *> blockedPanels;
+    QList<QGraphicsItem *> items = q->items(); // ### same as above
+    for (int i = 0; i < items.count(); ++i) {
+        QGraphicsItem *item = items.at(i);
+        if (item->isPanel() && item->isBlockedByModalPanel())
+            blockedPanels.insert(item);
+    }
+    modalPanels.removeAll(panel);
+    QEvent e(QEvent::WindowUnblocked);
+    for (int i = 0; i < items.count(); ++i) {
+        QGraphicsItem *item = items.at(i);
+        if (item->isPanel() && blockedPanels.contains(item) && !item->isBlockedByModalPanel())
+            sendEvent(item, &e);
+    }
+    // send GraphicsSceneHoverEnter events to newly unblocked items
+    QGraphicsSceneHoverEvent hoverEvent;
+    hoverEvent.setScenePos(lastSceneMousePos);
+    dispatchHoverEvent(&hoverEvent);
+}
+void QGraphicsScenePrivate::getGestureTargets(const QSet<QGesture *> &gestures,
+                                              QWidget *viewport,
+                                              QMap<Qt::GestureType, QGesture *> *conflictedGestures,
+                                              QList<QList<QGraphicsObject *> > *conflictedItems,
+                                              QHash<QGesture *, QGraphicsObject *> *normalGestures)
+{
+    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) {
+                QGraphicsObject *item = items.at(j)->toGraphicsObject();
+                if (!item)
+                    continue;
+                QGraphicsItemPrivate *d = item->QGraphicsItem::d_func();
+                if (d->gestureContext.contains(gestureType)) {
+                    result.append(item);
+                }
+            }
+            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);
+            }
+        }
+    }
+}
+void QGraphicsScenePrivate::gestureEventHandler(QGestureEvent *event)
+{
+    QWidget *viewport = event->widget();
+    if (!viewport)
+        return;
+    QList<QGesture *> allGestures = event->gestures();
+    DEBUG() << "QGraphicsScenePrivate::gestureEventHandler:"
+            << "Delivering gestures:" <<  allGestures;
+    typedef QHash<QGraphicsObject *, QList<QGesture *> > GesturesPerItem;
+    GesturesPerItem gesturesPerItem;
+    QSet<QGesture *> startedGestures;
+    foreach (QGesture *gesture, allGestures) {
+        QGraphicsObject *target = gestureTargets.value(gesture, 0);
+        if (!target) {
+            // when we are not in started mode but don't have a target
+            // then the only one interested in gesture is the view/scene
+            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;
+            }
+        }
+        // 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;
+                }
+            }
+            ++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;
+        }
+        if (gestures.isEmpty())
+            continue;
+        DEBUG() << "QGraphicsScenePrivate::gestureEventHandler:"
+                << "delivering to"
+                << item << gestures;
+        QGestureEvent ev(gestures);
+        ev.setWidget(event->widget());
+        sendEvent(item, &ev);
+        QSet<QGesture *> ignoredGestures;
+        foreach (QGesture *g, gestures) {
+            if (!ev.isAccepted() && !ev.isAccepted(g)) {
+                ignoredGestures.insert(g);
+            } else {
+                if (g->state() == Qt::GestureStarted)
+                    gestureTargets[g] = item;
+            }
+        }
+        if (!ignoredGestures.isEmpty()) {
+            // get a list of items under the (current) hotspot of each ignored
+            // gesture and start delivery again from the beginning
+            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;
+            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());
+        }
+    }
+    // forget about targets for gestures that have ended
+    foreach (QGesture *g, allGestures) {
+        switch (g->state()) {
+        case Qt::GestureFinished:
+        case Qt::GestureCanceled:
+            gestureTargets.remove(g);
+            break;
+        default:
+            break;
+        }
+    }
+}
+void QGraphicsScenePrivate::cancelGesturesForChildren(QGesture *original, QWidget *viewport)
+{
+    Q_ASSERT(original);
+    QGraphicsItem *originalItem = gestureTargets.value(original);
+    Q_ASSERT(originalItem);
+    // iterate over all active gestures and for each find the owner
+    // if the owner is part of our sub-hierarchy, cancel it.
+    QSet<QGesture *> canceledGestures;
+    QHash<QGesture *, QGraphicsObject *>::Iterator iter = gestureTargets.begin();
+    while (iter != gestureTargets.end()) {
+        QGraphicsObject *item = iter.value();
+        // note that we don't touch the gestures for our originalItem
+        if (item != originalItem && originalItem->isAncestorOf(item)) {
+            DEBUG() << "  found a gesture to cancel" << iter.key();
+            iter.key()->d_func()->state = Qt::GestureCanceled;
+            canceledGestures << iter.key();
+        }
+        ++iter;
+    }
+    // sort them per target item by cherry picking from almostCanceledGestures and delivering
+    QSet<QGesture *> almostCanceledGestures = canceledGestures;
+    QSet<QGesture *>::Iterator setIter;
+    while (!almostCanceledGestures.isEmpty()) {
+        QGraphicsObject *target = 0;
+        QSet<QGesture*> gestures;
+        setIter = almostCanceledGestures.begin();
+        // sort per target item
+        while (setIter != almostCanceledGestures.end()) {
+            QGraphicsObject *item = gestureTargets.value(*setIter);
+            if (target == 0)
+                target = item;
+            if (target == item) {
+                gestures << *setIter;
+                setIter = almostCanceledGestures.erase(setIter);
+            } else {
+                ++setIter;
+            }
+        }
+        Q_ASSERT(target);
+        QList<QGesture *> list = gestures.toList();
+        QGestureEvent ev(list);
+        sendEvent(target, &ev);
+        foreach (QGesture *g, list) {
+            if (ev.isAccepted() || ev.isAccepted(g))
+                gestures.remove(g);
+        }
+        foreach (QGesture *g, gestures) {
+            if (!g->hasHotSpot())
+                continue;
+            QPoint screenPos = g->hotSpot().toPoint();
+            QList<QGraphicsItem *> items = itemsAtPosition(screenPos, QPointF(), viewport);
+            for (int j = 0; j < items.size(); ++j) {
+                QGraphicsObject *item = items.at(j)->toGraphicsObject();
+                if (!item)
+                    continue;
+                QGraphicsItemPrivate *d = item->QGraphicsItem::d_func();
+                if (d->gestureContext.contains(g->gestureType())) {
+                    QList<QGesture *> list;
+                    list << g;
+                    QGestureEvent ev(list);
+                    sendEvent(item, &ev);
+                    if (ev.isAccepted() || ev.isAccepted(g))
+                        break; // successfully delivered
+                }
+            }
+        }
+    }
+    QGestureManager *gestureManager = QApplicationPrivate::instance()->gestureManager;
+    Q_ASSERT(gestureManager); // it would be very odd if we got called without a manager.
+    for (setIter = canceledGestures.begin(); setIter != canceledGestures.end(); ++setIter) {
+        gestureManager->recycle(*setIter);
+        gestureTargets.remove(*setIter);
+    }
+}

trunk/src/gui/graphicsview/qgraphicsscene.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 …
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 class QGraphicsView;
 class QGraphicsWidget;
+class QGraphicsSceneIndex;
 class QHelpEvent;
 class QInputMethodEvent;
 …
     QList<QGraphicsItem *> items() const;
+    QList<QGraphicsItem *> items(const QPointF &pos) const;
+    QList<QGraphicsItem *> items(const QRectF &rect, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const;
+    QList<QGraphicsItem *> items(const QPolygonF &polygon, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const;
+    QList<QGraphicsItem *> items(const QPainterPath &path, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const;
+    QList<QGraphicsItem *> items(Qt::SortOrder order) const; // ### Qt 5: unify
+    QList<QGraphicsItem *> items(const QPointF &pos, Qt::ItemSelectionMode mode, Qt::SortOrder order, const QTransform &deviceTransform = QTransform()) const;
+    QList<QGraphicsItem *> items(const QRectF &rect, Qt::ItemSelectionMode mode, Qt::SortOrder order, const QTransform &deviceTransform = QTransform()) const;
+    QList<QGraphicsItem *> items(const QPolygonF &polygon, Qt::ItemSelectionMode mode, Qt::SortOrder order, const QTransform &deviceTransform = QTransform()) const;
+    QList<QGraphicsItem *> items(const QPainterPath &path, Qt::ItemSelectionMode mode, Qt::SortOrder order, const QTransform &deviceTransform = QTransform()) const;
+    QList<QGraphicsItem *> items(const QPointF &pos) const; // ### obsolete
+    QList<QGraphicsItem *> items(const QRectF &rect, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const; // ### obsolete
+    QList<QGraphicsItem *> items(const QPolygonF &polygon, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const; // ### obsolete
+    QList<QGraphicsItem *> items(const QPainterPath &path, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const; // ### obsolete
     QList<QGraphicsItem *> collidingItems(const QGraphicsItem *item, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const;
+    QGraphicsItem *itemAt(const QPointF &pos) const;
+    QGraphicsItem *itemAt(const QPointF &pos) const; // ### obsolete
+    QGraphicsItem *itemAt(const QPointF &pos, const QTransform &deviceTransform) const;
     inline QList<QGraphicsItem *> items(qreal x, qreal y, qreal w, qreal h, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const
+    { return items(QRectF(x, y, w, h), mode); }
+    inline QGraphicsItem *itemAt(qreal x, qreal y) const
+    { return items(QRectF(x, y, w, h), mode); } // ### obsolete
+    inline QList<QGraphicsItem *> items(qreal x, qreal y, qreal w, qreal h, Qt::ItemSelectionMode mode, Qt::SortOrder order,
+                                        const QTransform &deviceTransform = QTransform()) const
+    { return items(QRectF(x, y, w, h), mode, order, deviceTransform); }
+    inline QGraphicsItem *itemAt(qreal x, qreal y) const // ### obsolete
     { return itemAt(QPointF(x, y)); }
+    inline QGraphicsItem *itemAt(qreal x, qreal y, const QTransform &deviceTransform) const
+    { return itemAt(QPointF(x, y), deviceTransform); }
     QList<QGraphicsItem *> selectedItems() const;
     QPainterPath selectionArea() const;
+    void setSelectionArea(const QPainterPath &path);
+    void setSelectionArea(const QPainterPath &path, Qt::ItemSelectionMode);
+    void setSelectionArea(const QPainterPath &path); // ### obsolete
+    void setSelectionArea(const QPainterPath &path, const QTransform &deviceTransform);
+    void setSelectionArea(const QPainterPath &path, Qt::ItemSelectionMode mode); // ### obsolete
+    void setSelectionArea(const QPainterPath &path, Qt::ItemSelectionMode mode, const QTransform &deviceTransform);
     QGraphicsItemGroup *createItemGroup(const QList<QGraphicsItem *> &items);
 …
     { return addRect(QRectF(x, y, w, h), pen, brush); }
     void removeItem(QGraphicsItem *item);
     QGraphicsItem *focusItem() const;
     void setFocusItem(QGraphicsItem *item, Qt::FocusReason focusReason = Qt::OtherFocusReason);
 …
     void setPalette(const QPalette &palette);
+    bool isActive() const;
+    QGraphicsItem *activePanel() const;
+    void setActivePanel(QGraphicsItem *item);
     QGraphicsWidget *activeWindow() const;
     void setActiveWindow(QGraphicsWidget *widget);
+    bool sendEvent(QGraphicsItem *item, QEvent *event);
 public Q_SLOTS:
 …
 private:
-    void itemUpdated(QGraphicsItem *item, const QRectF &rect);
     Q_DECLARE_PRIVATE(QGraphicsScene)
     Q_DISABLE_COPY(QGraphicsScene)
-    Q_PRIVATE_SLOT(d_func(), void _q_updateIndex())
     Q_PRIVATE_SLOT(d_func(), void _q_emitUpdated())
-    Q_PRIVATE_SLOT(d_func(), void _q_removeItemLater(QGraphicsItem *item))
-    Q_PRIVATE_SLOT(d_func(), void _q_updateLater())
     Q_PRIVATE_SLOT(d_func(), void _q_polishItems())
     Q_PRIVATE_SLOT(d_func(), void _q_updateSortCache())
     Q_PRIVATE_SLOT(d_func(), void _q_resetDirtyItems())
+    Q_PRIVATE_SLOT(d_func(), void _q_processDirtyItems())
+    Q_PRIVATE_SLOT(d_func(), void _q_updateScenePosDescendants())
     friend class QGraphicsItem;
     friend class QGraphicsItemPrivate;
 …
     friend class QGraphicsWidget;
     friend class QGraphicsWidgetPrivate;
+    friend class QGraphicsEffect;
+    friend class QGraphicsSceneIndex;
+    friend class QGraphicsSceneIndexPrivate;
+    friend class QGraphicsSceneBspTreeIndex;
+    friend class QGraphicsSceneBspTreeIndexPrivate;
+    friend class QGraphicsItemEffectSourcePrivate;
+    friend class QGesture;
 };

trunk/src/gui/graphicsview/qgraphicsscene_bsp.cpp

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 …
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 public:
     QList<QGraphicsItem *> *foundItems;
+    bool onlyTopLevelItems;
     void visit(QList<QGraphicsItem *> *items)
 …
         for (int i = 0; i < items->size(); ++i) {
             QGraphicsItem *item = items->at(i);
+            if (!item->d_func()->itemDiscovered && item->isVisible()) {
+            if (onlyTopLevelItems && item->d_ptr->parent)
+                item = item->topLevelItem();
+            if (!item->d_func()->itemDiscovered && item->d_ptr->visible) {
                 item->d_func()->itemDiscovered = 1;
                 foundItems->prepend(item);
 …
+}
 QList<QGraphicsItem *> QGraphicsSceneBspTree::items(const QRectF &rect)
+QList<QGraphicsItem *> QGraphicsSceneBspTree::items(const QRectF &rect, bool onlyTopLevelItems) const
+{
     QList<QGraphicsItem *> tmp;
     findVisitor->foundItems = &tmp;
+    findVisitor->onlyTopLevelItems = onlyTopLevelItems;
     climbTree(findVisitor, rect);
+    return tmp;
+}
+QList<QGraphicsItem *> QGraphicsSceneBspTree::items(const QPointF &pos)
+{
+    QList<QGraphicsItem *> tmp;
+    findVisitor->foundItems = &tmp;
+    climbTree(findVisitor, pos);
+    // Reset discovery bits.
+    for (int i = 0; i < tmp.size(); ++i)
+        tmp.at(i)->d_ptr->itemDiscovered = 0;
     return tmp;
+}
 …
+}
 void QGraphicsSceneBspTree::climbTree(QGraphicsSceneBspTreeVisitor *visitor, const QPointF &pos, int index)
+void QGraphicsSceneBspTree::climbTree(QGraphicsSceneBspTreeVisitor *visitor, const QRectF &rect, int index) const
+{
     if (nodes.isEmpty())
 …
     const Node &node = nodes.at(index);
     int childIndex = firstChildIndex(index);
+    const int childIndex = firstChildIndex(index);
     switch (node.type) {
     case Node::Leaf: {
+        visitor->visit(&leaves[node.leafIndex]);
+        break;
+    }
+    case Node::Vertical:
+        if (pos.x() < node.offset) {
+            climbTree(visitor, pos, childIndex);
+        } else {
+            climbTree(visitor, pos, childIndex + 1);
+        }
+        break;
+    case Node::Horizontal:
+        if (pos.y() < node.offset) {
+            climbTree(visitor, pos, childIndex);
+        } else {
+            climbTree(visitor, pos, childIndex + 1);
+        }
+        break;
+    }
+}
+void QGraphicsSceneBspTree::climbTree(QGraphicsSceneBspTreeVisitor *visitor, const QRectF &rect, int index)
+{
+    if (nodes.isEmpty())
+        return;
+    const Node &node = nodes.at(index);
+    int childIndex = firstChildIndex(index);
+    switch (node.type) {
+    case Node::Leaf: {
+        visitor->visit(&leaves[node.leafIndex]);
+        visitor->visit(const_cast<QList<QGraphicsItem*>*>(&leaves[node.leafIndex]));
         break;
+    }
 …
         break;
     case Node::Horizontal:
-        int childIndex = firstChildIndex(index);
         if (rect.top() < node.offset) {
             climbTree(visitor, rect, childIndex);

trunk/src/gui/graphicsview/qgraphicsscene_bsp_p.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 …
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
     void removeItems(const QSet<QGraphicsItem *> &items);
+    QList<QGraphicsItem *> items(const QRectF &rect);
+    QList<QGraphicsItem *> items(const QPointF &pos);
+    QList<QGraphicsItem *> items(const QRectF &rect, bool onlyTopLevelItems = false) const;
     int leafCount() const;
 …
 private:
     void initialize(const QRectF &rect, int depth, int index);
+    void climbTree(QGraphicsSceneBspTreeVisitor *visitor, const QPointF &pos, int index = 0);
+    void climbTree(QGraphicsSceneBspTreeVisitor *visitor, const QRectF &rect, int index = 0);
+    void findItems(QList<QGraphicsItem *> *foundItems, const QRectF &rect, int index);
+    void findItems(QList<QGraphicsItem *> *foundItems, const QPointF &pos, int index);
+    void climbTree(QGraphicsSceneBspTreeVisitor *visitor, const QRectF &rect, int index = 0) const;
     QRectF rectForIndex(int index) const;

trunk/src/gui/graphicsview/qgraphicsscene_p.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 …
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 //
 // This file is not part of the Qt API.  It exists for the convenience
 // of qapplication_*.cpp, qwidget*.cpp and qfiledialog.cpp.  This header
 // file may change from version to version without notice, or even be removed.
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
 //
 // We mean it.
 …
 #if !defined(QT_NO_GRAPHICSVIEW) || (QT_EDITION & QT_MODULE_GRAPHICSVIEW) != QT_MODULE_GRAPHICSVIEW
+#include "qgraphicsscene_bsp_p.h"
+#include "qgraphicssceneevent.h"
+#include "qgraphicsview.h"
+#include "qgraphicsview_p.h"
 #include "qgraphicsitem_p.h"
 …
 #include <QtGui/qpalette.h>
 #include <QtGui/qstyle.h>
+#include <QtGui/qstyleoption.h>
 QT_BEGIN_NAMESPACE
+class QGraphicsSceneIndex;
 class QGraphicsView;
 class QGraphicsWidget;
 class QGraphicsScenePrivate : public QObjectPrivate
+class Q_AUTOTEST_EXPORT QGraphicsScenePrivate : public QObjectPrivate
+{
     Q_DECLARE_PUBLIC(QGraphicsScene)
 …
     void init();
+    quint32 changedSignalMask;
+    static QGraphicsScenePrivate *get(QGraphicsScene *q);
+    static int changedSignalIndex;
     QGraphicsScene::ItemIndexMethod indexMethod;
+    int bspTreeDepth;
+    QList<QGraphicsItem *> estimateItemsInRect(const QRectF &rect) const;
+    void addToIndex(QGraphicsItem *item);
+    void removeFromIndex(QGraphicsItem *item);
+    void resetIndex();
+    QGraphicsSceneBspTree bspTree;
+    void _q_updateIndex();
+    QGraphicsSceneIndex *index;
     int lastItemCount;
     QRectF sceneRect;
     bool hasSceneRect;
+    bool dirtyGrowingItemsBoundingRect;
     QRectF growingItemsBoundingRect;
-    QRectF largestUntransformableItem;
     void _q_emitUpdated();
 …
     bool updateAll;
     bool calledEmitUpdated;
+    bool processDirtyItemsEmitted;
     QPainterPath selectionArea;
     int selectionChanging;
     QSet<QGraphicsItem *> selectedItems;
+    QList<QGraphicsItem *> unindexedItems;
+    QList<QGraphicsItem *> indexedItems;
+    QList<QGraphicsItem *> dirtyItems;
+    QList<QGraphicsItem *> pendingUpdateItems;
+    QList<QGraphicsItem *> unpolishedItems;
+    QSet<QGraphicsItem *> unpolishedItems;
+    QList<QGraphicsItem *> topLevelItems;
+    bool needSortTopLevelItems;
+    bool unpolishedItemsModified;
+    bool holesInTopLevelSiblingIndex;
+    bool topLevelSequentialOrdering;
     QMap<QGraphicsItem *, QPointF> movingItemsInitialPositions;
+    void registerTopLevelItem(QGraphicsItem *item);
+    void unregisterTopLevelItem(QGraphicsItem *item);
     void _q_updateLater();
     void _q_polishItems();
+    void _q_resetDirtyItems();
+    void resetDirtyItemsLater();
+    bool dirtyItemResetPending;
+    QList<int> freeItemIndexes;
+    bool regenerateIndex;
+    bool purgePending;
+    void _q_removeItemLater(QGraphicsItem *item);
+    QSet<QGraphicsItem *> removedItems;
+    void purgeRemovedItems();
+    void _q_processDirtyItems();
+    QSet<QGraphicsItem *> scenePosItems;
+    bool scenePosDescendantsUpdatePending;
+    void setScenePosItemEnabled(QGraphicsItem *item, bool enabled);
+    void registerScenePosItem(QGraphicsItem *item);
+    void unregisterScenePosItem(QGraphicsItem *item);
+    void _q_updateScenePosDescendants();
+    void removeItemHelper(QGraphicsItem *item);
     QBrush backgroundBrush;
     QBrush foregroundBrush;
-    int indexTimerId;
-    bool restartIndexTimer;
-    void startIndexTimer();
     bool stickyFocus;
 …
     QGraphicsItem *lastFocusItem;
     QGraphicsWidget *tabFocusFirst;
+    QGraphicsWidget *activeWindow;
+    QGraphicsItem *activePanel;
+    QGraphicsItem *lastActivePanel;
     int activationRefCount;
+    int childExplicitActivation;
+    void setActivePanelHelper(QGraphicsItem *item, bool duringActivationEvent);
+    void setFocusItemHelper(QGraphicsItem *item, Qt::FocusReason focusReason);
     QList<QGraphicsWidget *> popupWidgets;
 …
     void ungrabKeyboard(QGraphicsItem *item, bool itemIsDying = false);
     void clearKeyboardGrabber();
     QGraphicsItem *dragDropItem;
     QGraphicsWidget *enterWidget;
 …
     QList<QGraphicsItem *> cachedItemsUnderMouse;
     QList<QGraphicsItem *> hoverItems;
+    QPointF lastSceneMousePos;
+    bool allItemsIgnoreHoverEvents;
+    bool allItemsUseDefaultCursor;
+    void enableMouseTrackingOnViews();
     QMap<Qt::MouseButton, QPointF> mouseGrabberButtonDownPos;
     QMap<Qt::MouseButton, QPointF> mouseGrabberButtonDownScenePos;
 …
                                            const QPointF &scenePos,
                                            QWidget *widget) const;
-    static bool itemCollidesWithPath(QGraphicsItem *item, const QPainterPath &path, Qt::ItemSelectionMode mode);
     void storeMouseButtonsForMouseGrabber(QGraphicsSceneMouseEvent *event);
     QList<QGraphicsView *> views;
+    void addView(QGraphicsView *view);
+    void removeView(QGraphicsView *view);
     bool painterStateProtection;
 …
     void installSceneEventFilter(QGraphicsItem *watched, QGraphicsItem *filter);
     void removeSceneEventFilter(QGraphicsItem *watched, QGraphicsItem *filter);
+    bool filterDescendantEvent(QGraphicsItem *item, QEvent *event);
     bool filterEvent(QGraphicsItem *item, QEvent *event);
     bool sendEvent(QGraphicsItem *item, QEvent *event);
 …
     QGraphicsWidget *windowForItem(const QGraphicsItem *item) const;
+    QList<QGraphicsItem *> items_helper(const QPointF &pos) const;
+    QList<QGraphicsItem *> items_helper(const QRectF &rect,
+                                        Qt::ItemSelectionMode mode,
+                                        Qt::SortOrder order) const;
+    QList<QGraphicsItem *> items_helper(const QPolygonF &rect,
+                                        Qt::ItemSelectionMode mode,
+                                        Qt::SortOrder order) const;
+    QList<QGraphicsItem *> items_helper(const QPainterPath &rect,
+                                        Qt::ItemSelectionMode mode,
+                                        Qt::SortOrder order) const;
+    void childItems_helper(QList<QGraphicsItem *> *items,
+                           const QGraphicsItem *parent,
+                           const QPointF &pos) const;
+    void childItems_helper(QList<QGraphicsItem *> *items,
+                           const QGraphicsItem *parent,
+                           const QRectF &rect,
+                           Qt::ItemSelectionMode mode) const;
+    void childItems_helper(QList<QGraphicsItem *> *items,
+                           const QGraphicsItem *parent,
+                           const QPolygonF &polygon,
+                           Qt::ItemSelectionMode mode) const;
+    void childItems_helper(QList<QGraphicsItem *> *items,
+                           const QGraphicsItem *parent,
+                           const QPainterPath &path,
+                           Qt::ItemSelectionMode mode) const;
+    bool sortCacheEnabled;
+    bool updatingSortCache;
+    void invalidateSortCache();
+    static void climbTree(QGraphicsItem *item, int *stackingOrder);
+    void _q_updateSortCache();
+    static bool closestItemFirst_withoutCache(const QGraphicsItem *item1, const QGraphicsItem *item2);
+    static bool closestItemLast_withoutCache(const QGraphicsItem *item1, const QGraphicsItem *item2);
+    static inline bool closestItemFirst_withCache(const QGraphicsItem *item1, const QGraphicsItem *item2)
+    {
+        return item1->d_ptr->globalStackingOrder < item2->d_ptr->globalStackingOrder;
+    }
+    static inline bool closestItemLast_withCache(const QGraphicsItem *item1, const QGraphicsItem *item2)
+    {
+        return item1->d_ptr->globalStackingOrder >= item2->d_ptr->globalStackingOrder;
+    }
+    static void sortItems(QList<QGraphicsItem *> *itemList, Qt::SortOrder order, bool cached);
+    bool sortCacheEnabled; // for compatibility
     void drawItemHelper(QGraphicsItem *item, QPainter *painter,
                         const QStyleOptionGraphicsItem *option, QWidget *widget,
                         bool painterStateProtection);
+    void drawItems(QPainter *painter, const QTransform *const viewTransform,
+                   QRegion *exposedRegion, QWidget *widget);
+    void drawSubtreeRecursive(QGraphicsItem *item, QPainter *painter, const QTransform *const,
+                              QRegion *exposedRegion, QWidget *widget, qreal parentOpacity = qreal(1.0),
+                              const QTransform *const effectTransform = 0);
+    void draw(QGraphicsItem *, QPainter *, const QTransform *const, const QTransform *const,
+              QRegion *, QWidget *, qreal, const QTransform *const, bool, bool);
+    void markDirty(QGraphicsItem *item, const QRectF &rect = QRectF(), bool invalidateChildren = false,
+                   bool force = false, bool ignoreOpacity = false, bool removingItemFromScene = false);
+    void processDirtyItemsRecursive(QGraphicsItem *item, bool dirtyAncestorContainsChildren = false,
+                                    qreal parentOpacity = qreal(1.0));
+    inline void resetDirtyItem(QGraphicsItem *item, bool recursive = false)
+    {
+        Q_ASSERT(item);
+        item->d_ptr->dirty = 0;
+        item->d_ptr->paintedViewBoundingRectsNeedRepaint = 0;
+        item->d_ptr->geometryChanged = 0;
+        if (!item->d_ptr->dirtyChildren)
+            recursive = false;
+        item->d_ptr->dirtyChildren = 0;
+        item->d_ptr->needsRepaint = QRectF();
+        item->d_ptr->allChildrenDirty = 0;
+        item->d_ptr->fullUpdatePending = 0;
+        item->d_ptr->ignoreVisible = 0;
+        item->d_ptr->ignoreOpacity = 0;
+#ifndef QT_NO_GRAPHICSEFFECT
+        QGraphicsEffect::ChangeFlags flags;
+        if (item->d_ptr->notifyBoundingRectChanged) {
+            flags |= QGraphicsEffect::SourceBoundingRectChanged;
+            item->d_ptr->notifyBoundingRectChanged = 0;
+        }
+        if (item->d_ptr->notifyInvalidated) {
+            flags |= QGraphicsEffect::SourceInvalidated;
+            item->d_ptr->notifyInvalidated = 0;
+        }
+#endif //QT_NO_GRAPHICSEFFECT
+        if (recursive) {
+            for (int i = 0; i < item->d_ptr->children.size(); ++i)
+                resetDirtyItem(item->d_ptr->children.at(i), recursive);
+        }
+#ifndef QT_NO_GRAPHICSEFFECT
+        if (flags && item->d_ptr->graphicsEffect)
+            item->d_ptr->graphicsEffect->sourceChanged(flags);
+#endif //QT_NO_GRAPHICSEFFECT
+    }
+    inline void ensureSortedTopLevelItems()
+    {
+        if (needSortTopLevelItems) {
+            qSort(topLevelItems.begin(), topLevelItems.end(), qt_notclosestLeaf);
+            topLevelSequentialOrdering = false;
+            needSortTopLevelItems = false;
+        }
+    }
+    void ensureSequentialTopLevelSiblingIndexes();
     QStyle *style;
     QFont font;
 …
     void updatePalette(const QPalette &palette);
+    mutable QVector<QTransform> sceneTransformCache;
+    mutable QBitArray validTransforms;
+    mutable QVector<int> freeSceneTransformSlots;
+    QStyleOptionGraphicsItem styleOptionTmp;
+    QMap<int, QTouchEvent::TouchPoint> sceneCurrentTouchPoints;
+    QMap<int, QGraphicsItem *> itemForTouchPointId;
+    static void updateTouchPointsForItem(QGraphicsItem *item, QTouchEvent *touchEvent);
+    int findClosestTouchPointId(const QPointF &scenePos);
+    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 updateInputMethodSensitivityInViews();
+    QList<QGraphicsItem *> modalPanels;
+    void enterModal(QGraphicsItem *item,
+                    QGraphicsItem::PanelModality panelModality = QGraphicsItem::NonModal);
+    void leaveModal(QGraphicsItem *item);
 };
+// QRectF::intersects() returns false always if either the source or target
+// rectangle's width or height are 0. This works around that problem.
+static inline void _q_adjustRect(QRectF *rect)
+{
+    Q_ASSERT(rect);
+    if (!rect->width())
+        rect->adjust(qreal(-0.00001), 0, qreal(0.00001), 0);
+    if (!rect->height())
+        rect->adjust(0, qreal(-0.00001), 0, qreal(0.00001));
+}
+static inline QRectF adjustedItemBoundingRect(const QGraphicsItem *item)
+{
+    Q_ASSERT(item);
+    QRectF boundingRect(item->boundingRect());
+    _q_adjustRect(&boundingRect);
+    return boundingRect;
+}
+static inline QRectF adjustedItemEffectiveBoundingRect(const QGraphicsItem *item)
+{
+    Q_ASSERT(item);
+    QRectF boundingRect(QGraphicsItemPrivate::get(item)->effectiveBoundingRect());
+    _q_adjustRect(&boundingRect);
+    return boundingRect;
+}
 QT_END_NAMESPACE

trunk/src/gui/graphicsview/qgraphicssceneevent.cpp

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 …
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
     graphics view related events.
     \since 4.2
-    \ingroup multimedia
     \ingroup graphicsview-api
 …
     \l{QGraphicsSceneMouseEvent::}{lastScreenPos()},
     \l{QGraphicsSceneMouseEvent::}{lastScenePos()}, and
     \l{QGraphicsSceneMouseEvent::}{lastPos()}).
+    \l{QGraphicsSceneMouseEvent::}{lastPos()}).
     \sa QEvent
 …
 /*!
     \class QGraphicsSceneMouseEvent
     \brief The QGraphicsSceneMouseEvent class provides mouse events
+    \brief The QGraphicsSceneMouseEvent class provides mouse events
            in the graphics view framework.
     \since 4.2
-    \ingroup multimedia
     \ingroup graphicsview-api
+    When a QGraphicsView receives a QMouseEvent, it translates it to
+    a QGraphicsSceneMouseEvent. The event is then forwarded to the
+    QGraphicsScene associated with the view.
+    When a QGraphicsView receives a QMouseEvent, it translates it to a
+    QGraphicsSceneMouseEvent. The event is then forwarded to the
+    QGraphicsScene associated with the view. If the event is not
+    handled by the scene, the view may use it, e.g., for the
+    \l{QGraphicsView::}{DragMode}.
     In addition to containing the item, scene, and screen coordinates
 …
 /*!
     \class QGraphicsSceneWheelEvent
     \brief The QGraphicsSceneWheelEvent class provides wheel events
+    \brief The QGraphicsSceneWheelEvent class provides wheel events
            in the graphics view framework.
     \brief The QGraphicsSceneWheelEvent class provides wheel events in the
     graphics view framework.
     \since 4.2
-    \ingroup multimedia
     \ingroup graphicsview-api
 …
            menu events in the graphics view framework.
     \since 4.2
-    \ingroup multimedia
     \ingroup graphicsview-api
 …
 /*!
     \class QGraphicsSceneHoverEvent
     \brief The QGraphicsSceneHoverEvent class provides hover events
+    \brief The QGraphicsSceneHoverEvent class provides hover events
            in the graphics view framework.
     \since 4.2
-    \ingroup multimedia
     \ingroup graphicsview-api
 …
 /*!
     \class QGraphicsSceneHelpEvent
     \brief The QGraphicsSceneHelpEvent class provides events when a
+    \brief The QGraphicsSceneHelpEvent class provides events when a
            tooltip is requested.
     \since 4.2
-    \ingroup multimedia
     \ingroup graphicsview-api
 …
     \class QGraphicsSceneDragDropEvent
     \brief The QGraphicsSceneDragDropEvent class provides events for
            drag and drop in the graphics view framework.
+           drag and drop in the graphics view framework.
     \since 4.2
-    \ingroup multimedia
     \ingroup graphicsview-api
 …
     resizing in the graphics view framework.
     \since 4.4
-    \ingroup multimedia
     \ingroup graphicsview-api
 …
     moving in the graphics view framework.
     \since 4.4
-    \ingroup multimedia
     \ingroup graphicsview-api
 …
 #include <QtCore/qsize.h>
 #include <QtCore/qstring.h>
+#include "qgraphicsview.h"
+#include "qgraphicsitem.h"
+#include <QtGui/qgesture.h>
+#include <private/qevent_p.h>
 QT_BEGIN_NAMESPACE
 …
 QGraphicsSceneEvent::~QGraphicsSceneEvent()
+{
-    delete d_ptr;
+}
 …
 /*!
     Returns the last recorded mouse cursor position in scene
+    Returns the last recorded mouse cursor position in scene
     coordinates. The last recorded position is the position of
     the previous mouse event received by the view that created
 …
 /*!
     Returns the last recorded mouse cursor position in screen
+    Returns the last recorded mouse cursor position in screen
     coordinates. The last recorded position is the position of
     the previous mouse event received by the view that created
 …
 /*!
     Returns the position of the mouse cursor in item coordinates at the moment
     the the context menu was requested.
+    the context menu was requested.
     \sa scenePos(), screenPos()
 …
 /*!
     Returns the position of the mouse cursor in item coordinates at the moment
     the the hover event was sent.
+    the hover event was sent.
     \sa scenePos(), screenPos()
 …
 /*!
     Returns the position of the mouse cursor in scene coordinates at the
     moment the the hover event was sent.
+    moment the hover event was sent.
     \sa pos(), screenPos()
 …
 /*!
     Returns the position of the mouse cursor in screen coordinates at the
     moment the the hover event was sent.
+    moment the hover event was sent.
     \sa pos(), scenePos()
 …
     \since 4.4
     Returns the keyboard modifiers at the moment the the hover event was sent.
+    Returns the keyboard modifiers at the moment the hover event was sent.
 */
 Qt::KeyboardModifiers QGraphicsSceneHoverEvent::modifiers() const
 …
 /*!
     Returns the position of the mouse cursor in scene coordinates at the
     moment the the help event was sent.
+    moment the help event was sent.
     \sa screenPos()
 …
 /*!
     Returns the position of the mouse cursor in screen coordinates at the
     moment the the help event was sent.
+    moment the help event was sent.
   \sa scenePos()
 …
     Returns the mouse position of the event relative to the
     view that sent the event.
     \sa QGraphicsView, screenPos(), scenePos()
 */
 …
 /*!
     Returns the keyboard modifiers that were pressed when the drag
     and drop event was created.
+    and drop event was created.
     \sa Qt::KeyboardModifiers
 …
     \c possibleActions().
     \sa Qt::DropAction, possibleActions()
+    \sa Qt::DropAction, possibleActions()
 */
 …
     Returns the action that was performed in this drag and drop.
     This should be set by the receiver of the drop and is
     returned by QDrag::start().
+    returned by QDrag::exec().
     \sa setDropAction(), acceptProposedAction()

trunk/src/gui/graphicsview/qgraphicssceneevent.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 …
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 #include <QtCore/qcoreevent.h>
 #include <QtCore/qpoint.h>
+#include <QtCore/qscopedpointer.h>
+#include <QtCore/qrect.h>
+#include <QtGui/qpolygon.h>
+#include <QtCore/qset.h>
+#include <QtCore/qhash.h>
 QT_BEGIN_HEADER
 …
 protected:
     QGraphicsSceneEvent(QGraphicsSceneEventPrivate &dd, Type type = None);
     QGraphicsSceneEventPrivate *d_ptr;
+    QScopedPointer<QGraphicsSceneEventPrivate> d_ptr;
     Q_DECLARE_PRIVATE(QGraphicsSceneEvent)
 };

trunk/src/gui/graphicsview/qgraphicsview.cpp

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 …
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/
-//#define QGRAPHICSVIEW_DEBUG
 static const int QGRAPHICSVIEW_REGION_RECT_THRESHOLD = 50;
 …
     contents of a QGraphicsScene.
     \since 4.2
-    \ingroup multimedia
     \ingroup graphicsview-api
+    \mainclass
     QGraphicsView visualizes the contents of a QGraphicsScene in a scrollable
 …
     widget.
     QGraphicsView supports affine transformations, using QMatrix. You can
     either pass a matrix to setMatrix(), or you can call one of the
+    QGraphicsView supports affine transformations, using QTransform. You can
+    either pass a matrix to setTransform(), or you can call one of the
     convenience functions rotate(), scale(), translate() or shear(). The most
     two common transformations are scaling, which is used to implement
 …
     can vary between paint devices and platforms.
+    \value DontClipPainter QGraphicsView sometimes clips the painter when
+    rendering the scene contents. This can generally improve performance
+    (e.g., rendering only small parts of a large pixmap), and protects against
+    rendering mistakes (e.g., drawing outside bounding rectangles, or outside
+    the exposed area). In some situations, however, the painter clip can slow
+    down rendering; especially when all painting is restricted to inside
+    exposed areas. By enabling this flag, QGraphicsView will completely
+    disable its implicit clipping. Note that rendering artifacts from using a
+    semi-transparent foreground or background brush can occur if clipping is
+    disabled.
+    \value DontClipPainter This value is obsolete and has no effect.
     \value DontSavePainterState When rendering, QGraphicsView protects the
 …
     common side effect is that items that do draw with antialiasing can leave
     painting traces behind on the scene as they are moved.
+    \value IndirectPainting Since Qt 4.6, restore the old painting algorithm
+    that calls QGraphicsView::drawItems() and QGraphicsScene::drawItems().
+    To be used only for compatibility with old code.
 */
 …
 #include <QtGui/qscrollbar.h>
 #include <QtGui/qstyleoption.h>
+#include <QtGui/qinputcontext.h>
 #ifdef Q_WS_X11
+#include <QtGui/qpaintengine.h>
 #include <private/qt_x11_p.h>
 #endif
+#include <private/qevent_p.h>
 QT_BEGIN_NAMESPACE
+bool qt_sendSpontaneousEvent(QObject *receiver, QEvent *event);
 inline int q_round_bound(qreal d) //### (int)(qreal) INT_MAX != INT_MAX for single precision
 …
         return INT_MAX;
     return d >= 0.0 ? int(d + 0.5) : int(d - int(d-1) + 0.5) + int(d-1);
+}
+void QGraphicsViewPrivate::translateTouchEvent(QGraphicsViewPrivate *d, QTouchEvent *touchEvent)
+{
+    QList<QTouchEvent::TouchPoint> touchPoints = touchEvent->touchPoints();
+    for (int i = 0; i < touchPoints.count(); ++i) {
+        QTouchEvent::TouchPoint &touchPoint = touchPoints[i];
+        // the scene will set the item local pos, startPos, lastPos, and rect before delivering to
+        // an item, but for now those functions are returning the view's local coordinates
+        touchPoint.setSceneRect(d->mapToScene(touchPoint.rect()));
+        touchPoint.setStartScenePos(d->mapToScene(touchPoint.startPos()));
+        touchPoint.setLastScenePos(d->mapToScene(touchPoint.lastPos()));
+        // screenPos, startScreenPos, lastScreenPos, and screenRect are already set
+    }
+    touchEvent->setTouchPoints(touchPoints);
+}
 …
       lastDragDropEvent(0),
       fullUpdatePending(true),
-      dirtyRectCount(0),
-      updatingLater(false),
       updateSceneSlotReimplementedChecked(false)
+{
 …
     int right = q_round_bound(viewRect.right() - width);
     if (left >= right) {
         q->horizontalScrollBar()->setRange(0, 0);
+        hbar->setRange(0, 0);
         switch (alignment & Qt::AlignHorizontal_Mask) {
 …
+        }
     } else {
         q->horizontalScrollBar()->setRange(left, right);
         q->horizontalScrollBar()->setPageStep(width);
         q->horizontalScrollBar()->setSingleStep(width / 20);
+        hbar->setRange(left, right);
+        hbar->setPageStep(width);
+        hbar->setSingleStep(width / 20);
         leftIndent = 0;
+    }
 …
     int bottom = q_round_bound(viewRect.bottom()  - height);
     if (top >= bottom) {
         q->verticalScrollBar()->setRange(0, 0);
+        vbar->setRange(0, 0);
         switch (alignment & Qt::AlignVertical_Mask) {
 …
+        }
     } else {
         q->verticalScrollBar()->setRange(top, bottom);
         q->verticalScrollBar()->setPageStep(height);
         q->verticalScrollBar()->setSingleStep(height / 20);
+        vbar->setRange(top, bottom);
+        vbar->setPageStep(height);
+        vbar->setSingleStep(height / 20);
         topIndent = 0;
+    }
 …
     if (oldLeftIndent != leftIndent || oldTopIndent != topIndent) {
         dirtyScroll = true;
         q->viewport()->update();
+        updateAll();
     } else if (q->isRightToLeft() && !leftIndent) {
         // In reverse mode, the horizontal scroll always changes after the content
 …
             // Last scene pos: lastMouseMoveScenePoint
             // Current mouse pos:
             QPointF transformationDiff = q->mapToScene(q->viewport()->rect().center())
                                          - q->mapToScene(q->mapFromGlobal(QCursor::pos()));
             q->centerOn(lastMouseMoveScenePoint + transformationDiff);;
+            QPointF transformationDiff = q->mapToScene(viewport->rect().center())
+                                         - q->mapToScene(viewport->mapFromGlobal(QCursor::pos()));
+            q->centerOn(lastMouseMoveScenePoint + transformationDiff);
         } else {
             q->centerOn(lastCenterPoint);
 …
+{
     Q_Q(QGraphicsView);
     lastCenterPoint = q->mapToScene(q->viewport()->rect().center());
+    lastCenterPoint = q->mapToScene(viewport->rect().center());
+}
 …
         const_cast<QGraphicsViewPrivate *>(this)->updateScroll();
     return scrollY;
+}
+/*!
+    \internal
+    Maps the given rectangle to the scene using QTransform::mapRect()
+*/
+QRectF QGraphicsViewPrivate::mapRectToScene(const QRect &rect) const
+{
+    if (dirtyScroll)
+        const_cast<QGraphicsViewPrivate *>(this)->updateScroll();
+    QRectF scrolled = QRectF(rect.translated(scrollX, scrollY));
+    return identityMatrix ? scrolled : matrix.inverted().mapRect(scrolled);
+}
+/*!
+    \internal
+    Maps the given rectangle from the scene using QTransform::mapRect()
+*/
+QRectF QGraphicsViewPrivate::mapRectFromScene(const QRectF &rect) const
+{
+    if (dirtyScroll)
+        const_cast<QGraphicsViewPrivate *>(this)->updateScroll();
+    return (identityMatrix ? rect : matrix.mapRect(rect)).translated(-scrollX, -scrollY);
+}
 …
     if (q->isRightToLeft()) {
         if (!leftIndent) {
             scrollX += q->horizontalScrollBar()->minimum();
             scrollX += q->horizontalScrollBar()->maximum();
             scrollX -= q->horizontalScrollBar()->value();
+            scrollX += hbar->minimum();
+            scrollX += hbar->maximum();
+            scrollX -= hbar->value();
+        }
     } else {
         scrollX += q->horizontalScrollBar()->value();
+    }
     scrollY = qint64(q->verticalScrollBar()->value() - topIndent);
+        scrollX += hbar->value();
+    }
+    scrollY = qint64(vbar->value() - topIndent);
     dirtyScroll = false;
 …
     QGraphicsSceneMouseEvent mouseEvent(QEvent::GraphicsSceneMouseMove);
     mouseEvent.setWidget(q->viewport());
+    mouseEvent.setWidget(viewport);
     mouseEvent.setButtonDownScenePos(mousePressButton, mousePressScenePoint);
     mouseEvent.setButtonDownScreenPos(mousePressButton, mousePressScreenPoint);
 …
     lastMouseMoveScreenPoint = mouseEvent.screenPos();
     mouseEvent.setAccepted(false);
+    QApplication::sendEvent(scene, &mouseEvent);
+    if (event->spontaneous())
+        qt_sendSpontaneousEvent(scene, &mouseEvent);
+    else
+        QApplication::sendEvent(scene, &mouseEvent);
     // Remember whether the last event was accepted or not.
 …
 #ifndef QT_NO_CURSOR
+    // If all the items ignore hover events, we don't look-up any items
+    // in QGraphicsScenePrivate::dispatchHoverEvent, hence the
+    // cachedItemsUnderMouse list will be empty. We therefore do the look-up
+    // for cursor items here if not all items use the default cursor.
+    if (scene->d_func()->allItemsIgnoreHoverEvents && !scene->d_func()->allItemsUseDefaultCursor
+        && scene->d_func()->cachedItemsUnderMouse.isEmpty()) {
+        scene->d_func()->cachedItemsUnderMouse = scene->d_func()->itemsAtPosition(mouseEvent.screenPos(),
+                                                                                  mouseEvent.scenePos(),
+                                                                                  mouseEvent.widget());
+    }
     // Find the topmost item under the mouse with a cursor.
     foreach (QGraphicsItem *item, scene->d_func()->cachedItemsUnderMouse) {
 …
         // Restore the original viewport cursor.
         hasStoredOriginalCursor = false;
         q->viewport()->setCursor(originalCursor);
+        viewport->setCursor(originalCursor);
+    }
 #endif
 …
 void QGraphicsViewPrivate::_q_setViewportCursor(const QCursor &cursor)
+{
-    Q_Q(QGraphicsView);
-    QWidget *viewport = q->viewport();
     if (!hasStoredOriginalCursor) {
         hasStoredOriginalCursor = true;
 …
     hasStoredOriginalCursor = false;
     if (dragMode == QGraphicsView::ScrollHandDrag)
         q->viewport()->setCursor(Qt::OpenHandCursor);
+        viewport->setCursor(Qt::OpenHandCursor);
     else
         q->viewport()->setCursor(originalCursor);
+        viewport->setCursor(originalCursor);
+}
 #endif
 …
     dest->setDropAction(source->dropAction());
     dest->setMimeData(source->mimeData());
     dest->setWidget(q->viewport());
+    dest->setWidget(viewport);
     dest->setSource(source->source());
 #else
 …
     // Translate-only
+    // COMBINE
     QPointF offset;
     const QGraphicsItem *parentItem = item;
     const QGraphicsItemPrivate *itemd;
     do {
         itemd = parentItem->d_ptr;
         if (itemd->hasTransform)
+        itemd = parentItem->d_ptr.data();
+        if (itemd->transformData)
             break;
         offset += itemd->pos;
 …
     // Accurate bounding region
     QTransform itv = item->sceneTransform() * q->viewportTransform();
+    QTransform itv = item->deviceTransform(q->viewportTransform());
     return item->boundingRegion(itv) & itv.mapRect(rect).toAlignedRect();
+}
-// QRectF::intersects() returns false always if either the source or target
-// rectangle's width or height are 0. This works around that problem.
-static inline QRectF adjustedItemBoundingRect(const QGraphicsItem *item)
+{
-    Q_ASSERT(item);
-    QRectF boundingRect(item->boundingRect());
-    if (!boundingRect.width())
-        boundingRect.adjust(-0.00001, 0, 0.00001, 0);
-    if (!boundingRect.height())
-        boundingRect.adjust(0, -0.00001, 0, 0.00001);
-    return boundingRect;
+}
 /*!
     \internal
 */
+void QGraphicsViewPrivate::itemUpdated(QGraphicsItem *item, const QRectF &rect)
+{
+    if (fullUpdatePending || viewportUpdateMode == QGraphicsView::NoViewportUpdate)
+        return;
+    if (item->d_ptr->dirty)
+        updateLater();
+    QRectF updateRect = rect;
+    if ((item->d_ptr->flags & QGraphicsItem::ItemClipsChildrenToShape) || item->d_ptr->children.isEmpty()) {
+        updateRect &= adjustedItemBoundingRect(item);
+        if (updateRect.isEmpty())
+            return;
+    }
+    QGraphicsItem *clipItem = item;
+    if (item->d_ptr->ancestorFlags & QGraphicsItemPrivate::AncestorClipsChildren) {
+        // Minimize unnecessary redraw.
+        QGraphicsItem *parent = item;
+        while ((parent = parent->d_ptr->parent)) {
+            if (parent->d_ptr->flags & QGraphicsItem::ItemClipsChildrenToShape) {
+                // Map update rect to the current parent and itersect with its bounding rect.
+                updateRect = clipItem->itemTransform(parent).mapRect(updateRect)
+                             & adjustedItemBoundingRect(parent);
+                if (updateRect.isEmpty())
+                    return;
+                clipItem = parent;
+            }
+            if (!(parent->d_ptr->ancestorFlags & QGraphicsItemPrivate::AncestorClipsChildren))
+                break;
+        }
+    }
+    // Map update rect from clipItem coordinates to view coordinates.
+    Q_ASSERT(clipItem);
+    if (!item->d_ptr->hasBoundingRegionGranularity)
+        this->updateRect(mapToViewRect(clipItem, updateRect) & viewport->rect());
+    else
+        updateRegion(mapToViewRegion(clipItem, updateRect) & viewport->rect());
+}
+void QGraphicsViewPrivate::updateLater()
+{
+    Q_Q(QGraphicsView);
+    if (updatingLater)
+        return;
+    updatingLater = true;
+    QMetaObject::invokeMethod(q, "_q_updateLaterSlot", Qt::QueuedConnection);
+}
+void QGraphicsViewPrivate::_q_updateLaterSlot()
+{
+    Q_Q(QGraphicsView);
+void QGraphicsViewPrivate::processPendingUpdates()
+{
     if (!scene)
         return;
+    QRect vr = viewport->rect();
+    QTransform viewTransform = q->viewportTransform();
+    const QList<QGraphicsItem *> &dirtyItems = scene->d_func()->dirtyItems;
+    for (int i = 0; i < dirtyItems.size(); ++i) {
+        const QGraphicsItem *item = dirtyItems.at(i);
+        if (item->d_ptr->discardUpdateRequest(/*ignoreClipping=*/false,
+                                              /*ignoreVisibleBit=*/false,
+                                              /*ignoreDirtyBit=*/true)) {
+            continue;
+        }
+        QTransform x = item->sceneTransform() * viewTransform;
+        updateRect(x.mapRect(item->boundingRect()).toAlignedRect() & vr);
+    }
+    dirtyRectCount += dirtyRects.size();
+    bool noUpdate = !fullUpdatePending && viewportUpdateMode == QGraphicsView::FullViewportUpdate;
+    if ((dirtyRectCount > 0 || !dirtyBoundingRect.isEmpty()) && !fullUpdatePending && !noUpdate) {
+        if (viewportUpdateMode == QGraphicsView::BoundingRectViewportUpdate
+            || (viewportUpdateMode == QGraphicsView::SmartViewportUpdate
+                && dirtyRectCount >= QGRAPHICSVIEW_REGION_RECT_THRESHOLD)) {
+            if (!(optimizationFlags & QGraphicsView::DontAdjustForAntialiasing)) {
+                viewport->update(dirtyBoundingRect.adjusted(-2, -2, 2, 2));
+            } else {
+                viewport->update(dirtyBoundingRect);
+            }
+        } else {
+            // ### Improve this block, which is very slow for complex regions. We
+            // need to strike the balance between having an accurate update
+            // region, and running fast. The below approach is the simplest way to
+            // create a region from a bunch of rects, but we might want to use
+            // other approaches; e.g., a grid of a fixed size representing
+            // quadrants of the viewport, which we mark as dirty depending on the
+            // rectangles in the list. Perhaps this should go into a
+            // QRegion::fromRects(rects, how) function.
+            QRegion region;
+            if (!(optimizationFlags & QGraphicsView::DontAdjustForAntialiasing)) {
+                for (int i = 0; i < dirtyRegions.size(); ++i) {
+                    QVector<QRect> rects = dirtyRegions.at(i).rects();
+                    for (int j = 0; j < rects.size(); ++j)
+                        region += rects.at(j).adjusted(-2, -2, 2, 2);
+                }
+                for (int i = 0; i < dirtyRects.size(); ++i)
+                    region += dirtyRects.at(i).adjusted(-2, -2, 2, 2);
+            } else {
+                for (int i = 0; i < dirtyRegions.size(); ++i)
+                    region += dirtyRegions.at(i);
+                for (int i = 0; i < dirtyRects.size(); ++i)
+                    region += dirtyRects.at(i);
+            }
+            viewport->update(region);
+        }
+    }
+    dirtyRegions.clear();
+    dirtyRects.clear();
+    dirtyRectCount = 0;
+    if (fullUpdatePending) {
+        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));
+    } else {
+        viewport->update(dirtyRegion); // Already adjusted in updateRect/Region.
+    }
     dirtyBoundingRect = QRect();
+    updatingLater = false;
+}
+void QGraphicsViewPrivate::updateAll()
+{
+    Q_Q(QGraphicsView);
+    q->viewport()->update();
+    fullUpdatePending = true;
+    dirtyRectCount = 0;
+    dirtyBoundingRect = QRect();
+    updatingLater = false;
+}
+void QGraphicsViewPrivate::updateRegion(const QRegion &r)
+{
+    if (r.isEmpty())
+        return;
+    Q_Q(QGraphicsView);
+    // Rect intersects viewport - update everything?
+    dirtyRegion = QRegion();
+}
+static inline bool intersectsViewport(const QRect &r, int width, int height)
+{ return !(r.left() > width) && !(r.right() < 0) && !(r.top() >= height) && !(r.bottom() < 0); }
+static inline bool containsViewport(const QRect &r, int width, int height)
+{ return r.left() <= 0 && r.top() <= 0 && r.right() >= width - 1 && r.bottom() >= height - 1; }
+static inline void QRect_unite(QRect *rect, const QRect &other)
+{
+    if (rect->isEmpty()) {
+        *rect = other;
+    } else {
+        rect->setCoords(qMin(rect->left(), other.left()), qMin(rect->top(), other.top()),
+                        qMax(rect->right(), other.right()), qMax(rect->bottom(), other.bottom()));
+    }
+}
+bool QGraphicsViewPrivate::updateRegion(const QRegion &r)
+{
+    if (fullUpdatePending || viewportUpdateMode == QGraphicsView::NoViewportUpdate || r.isEmpty())
+        return false;
+    const QRect boundingRect = r.boundingRect();
+    if (!intersectsViewport(boundingRect, viewport->width(), viewport->height()))
+        return false; // Update region outside viewport.
     switch (viewportUpdateMode) {
     case QGraphicsView::FullViewportUpdate:
         fullUpdatePending = true;
         q->viewport()->update();
+        viewport->update();
         break;
     case QGraphicsView::BoundingRectViewportUpdate:
         dirtyBoundingRect |= r.boundingRect();
         if (dirtyBoundingRect == q->viewport()->rect()) {
+        QRect_unite(&dirtyBoundingRect, boundingRect);
+        if (containsViewport(dirtyBoundingRect, viewport->width(), viewport->height())) {
             fullUpdatePending = true;
+            q->viewport()->update();
+        } else {
+            updateLater();
+            viewport->update();
+        }
         break;
+    case QGraphicsView::SmartViewportUpdate:
+        dirtyBoundingRect |= r.boundingRect();
+        if ((dirtyRectCount + r.numRects()) < QGRAPHICSVIEW_REGION_RECT_THRESHOLD)
+            dirtyRegions << r;
+        dirtyRectCount += r.numRects();
+        updateLater();
+    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;
+    case QGraphicsView::MinimalViewportUpdate:
+        dirtyRegions << r;
+        dirtyRectCount += r.numRects();
+        updateLater();
+    }
+    default:
         break;
+    case QGraphicsView::NoViewportUpdate:
+        // Unreachable
+        break;
+    }
+    // Compress the regions...
+    if (dirtyRectCount > QGRAPHICSVIEW_REGION_RECT_THRESHOLD && dirtyRegions.size() > 1) {
+        QRegion masterRegion;
+        for (int i=0; i<dirtyRegions.size(); ++i) {
+            masterRegion |= dirtyRegions.at(i);
+        }
+        dirtyRectCount = masterRegion.numRects();
+        dirtyRegions.clear();
+        dirtyRegions << masterRegion;
+    }
+}
+void QGraphicsViewPrivate::updateRect(const QRect &r)
+{
+    if (r.isEmpty())
+        return;
+    Q_Q(QGraphicsView);
+    // Rect intersects viewport - update everything?
+    }
+    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;
         q->viewport()->update();
+        viewport->update();
         break;
     case QGraphicsView::BoundingRectViewportUpdate:
         dirtyBoundingRect |= r;
         if (dirtyBoundingRect == q->viewport()->rect()) {
+        QRect_unite(&dirtyBoundingRect, r);
+        if (containsViewport(dirtyBoundingRect, viewport->width(), viewport->height())) {
             fullUpdatePending = true;
+            q->viewport()->update();
+        } else {
+            updateLater();
+            viewport->update();
+        }
         break;
+    case QGraphicsView::SmartViewportUpdate:
+        dirtyBoundingRect |= r;
+        if ((dirtyRectCount + dirtyRects.size()) < QGRAPHICSVIEW_REGION_RECT_THRESHOLD)
+            dirtyRects << r;
+        updateLater();
+    case QGraphicsView::SmartViewportUpdate: // ### DEPRECATE
+    case QGraphicsView::MinimalViewportUpdate:
+        if (optimizationFlags & QGraphicsView::DontAdjustForAntialiasing)
+            dirtyRegion += r.adjusted(-1, -1, 1, 1);
+        else
+            dirtyRegion += r.adjusted(-2, -2, 2, 2);
         break;
+    case QGraphicsView::MinimalViewportUpdate:
+        dirtyRects << r;
+        updateLater();
+    default:
         break;
+    case QGraphicsView::NoViewportUpdate:
+        // Unreachable
+        break;
+    }
+    }
+    return true;
+}
 …
 extern QPainterPath qt_regionToPath(const QRegion &region);
+QList<QGraphicsItem *> QGraphicsViewPrivate::findItems(const QRegion &exposedRegion, bool *allItems) const
+/*!
+    ### Adjustments in findItems: mapToScene(QRect) forces us to adjust the
+    input rectangle by (0, 0, 1, 1), because it uses QRect::bottomRight()
+    (etc) when mapping the rectangle to a polygon (which is _wrong_). In
+    addition, as QGraphicsItem::boundingRect() is defined in logical space,
+    but the default pen for QPainter is cosmetic with a width of 0, QPainter
+    is at risk of painting 1 pixel outside the bounding rect. Therefore we
+    must search for items with an adjustment of (-1, -1, 1, 1).
+*/
+QList<QGraphicsItem *> QGraphicsViewPrivate::findItems(const QRegion &exposedRegion, bool *allItems,
+                                                       const QTransform &viewTransform) const
+{
     Q_Q(const QGraphicsView);
+    const QPainterPath exposedPath(qt_regionToPath(exposedRegion));
+    const QPainterPath exposedScenePath(q->mapToScene(exposedPath));
+    if (exposedScenePath.contains(scene->d_func()->growingItemsBoundingRect)) {
+    // Step 1) If all items are contained within the expose region, then
+    // return a list of all visible items. ### the scene's growing bounding
+    // rect does not take into account untransformable items.
+    const QRectF exposedRegionSceneBounds = q->mapToScene(exposedRegion.boundingRect().adjusted(-1, -1, 1, 1))
+                                            .boundingRect();
+    if (exposedRegionSceneBounds.contains(scene->sceneRect())) {
         Q_ASSERT(allItems);
         *allItems = true;
+        // All items are guaranteed within the exposed region, don't bother using the index.
+        QList<QGraphicsItem *> itemList(scene->items());
+        int i = 0;
+        while (i < itemList.size()) {
+            // But we only want to include items that are visible
+            if (!itemList.at(i)->isVisible())
+                itemList.removeAt(i);
+            else
+                ++i;
+        }
+        // Sort the items.
+        QGraphicsScenePrivate::sortItems(&itemList, Qt::DescendingOrder, scene->d_func()->sortCacheEnabled);
+        return itemList;
+    }
+    if (scene->d_func()->largestUntransformableItem.isNull()) {
+        if (exposedRegion.numRects() == 1 && matrix.type() <= QTransform::TxScale) {
+            return scene->d_func()->items_helper(exposedScenePath.controlPointRect(),
+                                                 Qt::IntersectsItemBoundingRect,
+                                                 Qt::DescendingOrder);
+        }
+        return scene->d_func()->items_helper(exposedScenePath,
+                                             Qt::IntersectsItemBoundingRect,
+                                             Qt::DescendingOrder);
+    }
+    // NB! Path must be in viewport coordinates.
+    return itemsInArea(exposedPath, Qt::IntersectsItemBoundingRect, Qt::DescendingOrder);
+}
+void QGraphicsViewPrivate::generateStyleOptions(const QList<QGraphicsItem *> &itemList,
+                                                QGraphicsItem **itemArray,
+                                                QStyleOptionGraphicsItem *styleOptionArray,
+                                                const QTransform &worldTransform,
+                                                bool allItems,
+                                                const QRegion &exposedRegion) const
+{
+    // Two unit vectors.
+    QLineF v1(0, 0, 1, 0);
+    QLineF v2(0, 0, 0, 1);
+    QTransform itemToViewportTransform;
+    QRectF brect;
+    QTransform reverseMap;
+    for (int i = 0; i < itemList.size(); ++i) {
+        QGraphicsItem *item = itemArray[i] = itemList[i];
+        QStyleOptionGraphicsItem &option = styleOptionArray[i];
+        brect = item->boundingRect();
+        option.state = QStyle::State_None;
+        option.rect = brect.toRect();
+        option.exposedRect = QRectF();
+        if (item->d_ptr->selected)
+            option.state |= QStyle::State_Selected;
+        if (item->d_ptr->enabled)
+            option.state |= QStyle::State_Enabled;
+        if (item->hasFocus())
+            option.state |= QStyle::State_HasFocus;
+        if (scene->d_func()->hoverItems.contains(item))
+            option.state |= QStyle::State_MouseOver;
+        if (item == scene->mouseGrabberItem())
+            option.state |= QStyle::State_Sunken;
+        // Calculate a simple level-of-detail metric.
+        // ### almost identical code in QGraphicsScene::render()
+        //     and QGraphicsView::render() - consider refactoring
+        if (item->d_ptr->itemIsUntransformable()) {
+            itemToViewportTransform = item->deviceTransform(worldTransform);
+        } else {
+            itemToViewportTransform = item->sceneTransform() * worldTransform;
+        }
+        if (itemToViewportTransform.type() <= QTransform::TxTranslate) {
+            // Translation and rotation only? The LOD is 1.
+            option.levelOfDetail = 1;
+        } else {
+            // LOD is the transformed area of a 1x1 rectangle.
+            option.levelOfDetail = qSqrt(itemToViewportTransform.map(v1).length() * itemToViewportTransform.map(v2).length());
+        }
+        option.matrix = itemToViewportTransform.toAffine(); //### discards perspective
+        if (!allItems) {
+            // Determine the item's exposed area
+            reverseMap = itemToViewportTransform.inverted();
+            foreach (const QRect &rect, exposedRegion.rects()) {
+                option.exposedRect |= reverseMap.mapRect(QRectF(rect.adjusted(-1, -1, 1, 1)));
+                if (option.exposedRect.contains(brect))
+                    break;
+            }
+            option.exposedRect &= brect;
+        } else {
+            // The whole item is exposed
+            option.exposedRect = brect;
+        }
+    }
+        // All items are guaranteed within the exposed region.
+        return scene->items(Qt::AscendingOrder);
+    }
+    // Step 2) If the expose region is a simple rect and the view is only
+    // translated or scaled, search for items using
+    // QGraphicsScene::items(QRectF).
+    bool simpleRectLookup =  exposedRegion.rectCount() == 1 && matrix.type() <= QTransform::TxScale;
+    if (simpleRectLookup) {
+        return scene->items(exposedRegionSceneBounds,
+                            Qt::IntersectsItemBoundingRect,
+                            Qt::AscendingOrder, viewTransform);
+    }
+    // If the region is complex or the view has a complex transform, adjust
+    // the expose region, convert it to a path, and then search for items
+    // using QGraphicsScene::items(QPainterPath);
+    QRegion adjustedRegion;
+    foreach (const QRect &r, exposedRegion.rects())
+        adjustedRegion += r.adjusted(-1, -1, 1, 1);
+    const QPainterPath exposedScenePath(q->mapToScene(qt_regionToPath(adjustedRegion)));
+    return scene->items(exposedScenePath, Qt::IntersectsItemBoundingRect,
+                        Qt::AscendingOrder, viewTransform);
+}
+/*!
+    \internal
+    Enables input methods for the view if and only if the current focus item of
+    the scene accepts input methods. Call function whenever that condition has
+    potentially changed.
+*/
+void QGraphicsViewPrivate::updateInputMethodSensitivity()
+{
+    Q_Q(QGraphicsView);
+    bool enabled = scene && scene->focusItem()
+                   && (scene->focusItem()->flags() & QGraphicsItem::ItemAcceptsInputMethod);
+    q->setAttribute(Qt::WA_InputMethodEnabled, enabled);
+    q->viewport()->setAttribute(Qt::WA_InputMethodEnabled, enabled);
+}
 …
     setAcceptDrops(true);
     setBackgroundRole(QPalette::Base);
+    // ### Ideally this would be enabled/disabled depending on whether any
+    // widgets in the current scene enabled input methods. We could do that
+    // using a simple reference count. The same goes for acceptDrops and mouse
+    // tracking.
+    // Investigate leaving these disabled by default.
     setAttribute(Qt::WA_InputMethodEnabled);
+    viewport()->setAttribute(Qt::WA_InputMethodEnabled);
+}
 …
     setAcceptDrops(true);
     setBackgroundRole(QPalette::Base);
+    // Investigate leaving these disabled by default.
     setAttribute(Qt::WA_InputMethodEnabled);
+    viewport()->setAttribute(Qt::WA_InputMethodEnabled);
+}
 …
     setAcceptDrops(true);
     setBackgroundRole(QPalette::Base);
+    // Investigate leaving these disabled by default.
     setAttribute(Qt::WA_InputMethodEnabled);
+    viewport()->setAttribute(Qt::WA_InputMethodEnabled);
+}
 …
         return;
     d->renderHints = hints;
     viewport()->update();
+    d->updateAll();
+}
 …
         d->renderHints &= ~hint;
     if (oldHints != d->renderHints)
         viewport()->update();
+        d->updateAll();
+}
 …
     Q_D(QGraphicsView);
     d->transformationAnchor = anchor;
+    // Ensure mouse tracking is enabled in the case we are using AnchorUnderMouse
+    // in order to have up-to-date information for centering the view.
+    if (d->transformationAnchor == AnchorUnderMouse)
+        d->viewport->setMouseTracking(true);
+}
 …
     Q_D(QGraphicsView);
     d->resizeAnchor = anchor;
+    // Ensure mouse tracking is enabled in the case we are using AnchorUnderMouse
+    // in order to have up-to-date information for centering the view.
+    if (d->resizeAnchor == AnchorUnderMouse)
+        d->viewport->setMouseTracking(true);
+}
 …
         // Background caching is enabled.
         d->mustResizeBackgroundPixmap = true;
         viewport()->update();
+        d->updateAll();
     } else if (d->mustResizeBackgroundPixmap) {
         // Background caching is disabled.
 …
     // Always update the viewport when the scene changes.
     viewport()->update();
+    d->updateAll();
     // Remove the previously assigned scene.
 …
         disconnect(d->scene, SIGNAL(sceneRectChanged(QRectF)),
                    this, SLOT(updateSceneRect(QRectF)));
+        d->scene->d_func()->views.removeAll(this);
+        d->scene->d_func()->removeView(this);
+        d->connectedToScene = false;
+        if (isActiveWindow() && isVisible()) {
+            QEvent windowDeactivate(QEvent::WindowDeactivate);
+            QApplication::sendEvent(d->scene, &windowDeactivate);
+        }
+        if(hasFocus())
+            d->scene->clearFocus();
+    }
 …
                 this, SLOT(updateSceneRect(QRectF)));
         d->updateSceneSlotReimplementedChecked = false;
         d->scene->d_func()->views << this;
+        d->scene->d_func()->addView(this);
         d->recalculateContentSize();
         d->lastCenterPoint = sceneRect().center();
         d->keepLastCenterPoint = true;
+        // We are only interested in mouse tracking if items accept
+        // hover events or use non-default cursors.
+        if (!d->scene->d_func()->allItemsIgnoreHoverEvents
+            || !d->scene->d_func()->allItemsUseDefaultCursor) {
+            d->viewport->setMouseTracking(true);
+        }
+        // enable touch events if any items is interested in them
+        if (!d->scene->d_func()->allItemsIgnoreTouchEvents)
+            d->viewport->setAttribute(Qt::WA_AcceptTouchEvents);
+        if (isActiveWindow() && isVisible()) {
+            QEvent windowActivate(QEvent::WindowActivate);
+            QApplication::sendEvent(d->scene, &windowActivate);
+        }
     } else {
         d->recalculateContentSize();
+    }
+    d->updateInputMethodSensitivity();
+    if (d->scene && hasFocus())
+        d->scene->setFocus();
+}
 …
     transformation is set, the identity matrix is returned.
     \sa setMatrix(), rotate(), scale(), shear(), translate()
+    \sa setMatrix(), transform(), rotate(), scale(), shear(), translate()
 */
 QMatrix QGraphicsView::matrix() const
 …
     to map from floating point scene coordinates to view coordinates.
     \sa matrix(), rotate(), scale(), shear(), translate()
+    \sa matrix(), setTransform(), rotate(), scale(), shear(), translate()
 */
 void QGraphicsView::setMatrix(const QMatrix &matrix, bool combine)
 …
 /*!
     Resets the view transformation matrix to the identity matrix.
+    \sa resetTransform()
 */
 void QGraphicsView::resetMatrix()
 …
     Rotates the current view transformation \a angle degrees clockwise.
     \sa setMatrix(), matrix(), scale(), shear(), translate()
+    \sa setTransform(), transform(), scale(), shear(), translate()
 */
 void QGraphicsView::rotate(qreal angle)
 …
     Scales the current view transformation by (\a sx, \a sy).
     \sa setMatrix(), matrix(), rotate(), shear(), translate()
+    \sa setTransform(), transform(), rotate(), shear(), translate()
 */
 void QGraphicsView::scale(qreal sx, qreal sy)
 …
     Shears the current view transformation by (\a sh, \a sv).
     \sa setMatrix(), matrix(), rotate(), scale(), translate()
+    \sa setTransform(), transform(), rotate(), scale(), translate()
 */
 void QGraphicsView::shear(qreal sh, qreal sv)
 …
     Translates the current view transformation by (\a dx, \a dy).
     \sa setMatrix(), matrix(), rotate(), shear()
+    \sa setTransform(), transform(), rotate(), shear()
 */
 void QGraphicsView::translate(qreal dx, qreal dy)
 …
     function will do nothing.
     \sa setMatrix(), ensureVisible(), centerOn()
+    \sa setTransform(), ensureVisible(), centerOn()
 */
 void QGraphicsView::fitInView(const QRectF &rect, Qt::AspectRatioMode aspectRatioMode)
 …
+{
     QPainterPath path = item->isClipped() ? item->clipPath() : item->shape();
+    fitInView(item->sceneTransform().map(path).boundingRect(), aspectRatioMode);
+    if (item->d_ptr->hasTranslateOnlySceneTransform()) {
+        path.translate(item->d_ptr->sceneTransform.dx(), item->d_ptr->sceneTransform.dy());
+        fitInView(path.boundingRect(), aspectRatioMode);
+    } else {
+        fitInView(item->d_ptr->sceneTransform.map(path).boundingRect(), aspectRatioMode);
+    }
+}
 …
                            Qt::AspectRatioMode aspectRatioMode)
+{
+    // ### Switch to using the recursive rendering algorithm instead.
     Q_D(QGraphicsView);
     if (!d->scene || !(painter && painter->isActive()))
 …
     // Setup painter matrix.
+    QTransform moveMatrix;
+    moveMatrix.translate(-d->horizontalScroll(), -d->verticalScroll());
+    QTransform moveMatrix = QTransform::fromTranslate(-d->horizontalScroll(), -d->verticalScroll());
     QTransform painterMatrix = d->matrix * moveMatrix;
     painterMatrix *= QTransform()
 …
                      .translate(-sourceRect.left(), -sourceRect.top());
-    // Two unit vectors.
-    QLineF v1(0, 0, 1, 0);
-    QLineF v2(0, 0, 0, 1);
     // Generate the style options
     QStyleOptionGraphicsItem *styleOptionArray = d->allocStyleOptionsArray(numItems);
+    QStyleOptionGraphicsItem* option = styleOptionArray;
+    for (int i = 0; i < numItems; ++i, ++option) {
+        QGraphicsItem *item = itemArray[i];
+        option->state = QStyle::State_None;
+        option->rect = item->boundingRect().toRect();
+        if (item->isSelected())
+            option->state |= QStyle::State_Selected;
+        if (item->isEnabled())
+            option->state |= QStyle::State_Enabled;
+        if (item->hasFocus())
+            option->state |= QStyle::State_HasFocus;
+        if (d->scene->d_func()->hoverItems.contains(item))
+            option->state |= QStyle::State_MouseOver;
+        if (item == d->scene->mouseGrabberItem())
+            option->state |= QStyle::State_Sunken;
+        // Calculate a simple level-of-detail metric.
+        // ### almost identical code in QGraphicsScene::render()
+        //     and QGraphicsView::paintEvent() - consider refactoring
+        QTransform itemToViewportTransform;
+        if (item->d_ptr->itemIsUntransformable()) {
+            itemToViewportTransform = item->deviceTransform(painterMatrix);
+        } else {
+            itemToViewportTransform = item->sceneTransform() * painterMatrix;
+        }
+        option->levelOfDetail = qSqrt(itemToViewportTransform.map(v1).length() * itemToViewportTransform.map(v2).length());
+        option->matrix = itemToViewportTransform.toAffine();
+        option->exposedRect = item->boundingRect();
+        option->exposedRect &= itemToViewportTransform.inverted().mapRect(targetRect);
+    }
+    for (int i = 0; i < numItems; ++i)
+        itemArray[i]->d_ptr->initStyleOption(&styleOptionArray[i], painterMatrix, targetRect.toRect());
     painter->save();
 …
 /*!
+    Returns a list of all the items in the associated scene.
+    \sa QGraphicsScene::items()
+    Returns a list of all the items in the associated scene, in descending
+    stacking order (i.e., the first item in the returned list is the uppermost
+    item).
+    \sa QGraphicsScene::items(), {QGraphicsItem#Sorting}{Sorting}
 */
 QList<QGraphicsItem *> QGraphicsView::items() const
 …
 /*!
-    Returns all items in the area \a path, which is in viewport coordinates,
-    also taking untransformable items into consideration. This function is
-    considerably slower than just checking the scene directly. There is
-    certainly room for improvement.
-*/
-QList<QGraphicsItem *> QGraphicsViewPrivate::itemsInArea(const QPainterPath &path,
-                                                         Qt::ItemSelectionMode mode,
-                                                         Qt::SortOrder order) const
+{
-    Q_Q(const QGraphicsView);
-    // Determine the size of the largest untransformable subtree of children
-    // mapped to scene coordinates.
-    QRectF untr = scene->d_func()->largestUntransformableItem;
-    QRectF ltri = matrix.inverted().mapRect(untr);
-    ltri.adjust(-untr.width(), -untr.height(), untr.width(), untr.height());
-    QRectF rect = path.controlPointRect();
-    // Find all possible items in the relevant area.
-    // ### Improve this algorithm; it might be searching a too large area.
-    QRectF adjustedRect = q->mapToScene(rect.adjusted(-1, -1, 1, 1).toRect()).boundingRect();
-    adjustedRect.adjust(-ltri.width(), -ltri.height(), ltri.width(), ltri.height());
-    // First build a (potentially large) list of all items in the vicinity
-    // that might be untransformable.
-    QList<QGraphicsItem *> allCandidates = scene->d_func()->estimateItemsInRect(adjustedRect);
-    // Then find the minimal list of items that are inside \a path, and
-    // convert it to a set.
-    QList<QGraphicsItem *> regularCandidates = scene->items(q->mapToScene(path), mode);
-    QSet<QGraphicsItem *> candSet = QSet<QGraphicsItem *>::fromList(regularCandidates);
-    QTransform viewMatrix = q->viewportTransform();
-    QList<QGraphicsItem *> result;
-    // Run through all candidates and keep all items that are in candSet, or
-    // are untransformable and collide with \a path. ### We can improve this
-    // algorithm.
-    QList<QGraphicsItem *>::Iterator it = allCandidates.begin();
-    while (it != allCandidates.end()) {
-        QGraphicsItem *item = *it;
-        if (item->d_ptr->itemIsUntransformable()) {
-            // Check if this untransformable item collides with the
-            // original selection rect.
-            QTransform itemTransform = item->deviceTransform(viewMatrix);
-            if (QGraphicsScenePrivate::itemCollidesWithPath(item, itemTransform.inverted().map(path), mode))
-                result << item;
-        } else {
-            if (candSet.contains(item))
-                result << item;
+        }
-        ++it;
+    }
-    // ### Insertion sort would be faster.
-    if (order != Qt::SortOrder(-1))
-        QGraphicsScenePrivate::sortItems(&result, order, scene->d_func()->sortCacheEnabled);
-    return result;
+}
-/*!
     Returns a list of all the items at the position \a pos in the view. The
     items are listed in descending Z order (i.e., the first item in the list
     is the top-most item, and the last item is the bottom-most item). \a pos
     is in viewport coordinates.
+    items are listed in descending stacking order (i.e., the first item in the
+    list is the uppermost item, and the last item is the lowermost item). \a
+    pos is in viewport coordinates.
     This function is most commonly called from within mouse event handlers in
 …
     \snippet doc/src/snippets/code/src_gui_graphicsview_qgraphicsview.cpp 5
     \sa QGraphicsScene::items(), QGraphicsItem::zValue()
+    \sa QGraphicsScene::items(), {QGraphicsItem#Sorting}{Sorting}
 */
 QList<QGraphicsItem *> QGraphicsView::items(const QPoint &pos) const
 …
     if (!d->scene)
         return QList<QGraphicsItem *>();
+    if (d->scene->d_func()->largestUntransformableItem.isNull()) {
+        if ((d->identityMatrix || d->matrix.type() <= QTransform::TxScale)) {
+            QTransform xinv = viewportTransform().inverted();
+            return d->scene->items(xinv.mapRect(QRectF(pos.x(), pos.y(), 1, 1)));
+        }
+        return d->scene->items(mapToScene(pos.x(), pos.y(), 2, 2));
+    }
+    QPainterPath path;
+    path.addRect(QRectF(pos.x(), pos.y(), 1, 1));
+    return d->itemsInArea(path);
+    // ### Unify these two, and use the items(QPointF) version in
+    // QGraphicsScene instead. The scene items function could use the viewport
+    // transform to map the point to a rect/polygon.
+    if ((d->identityMatrix || d->matrix.type() <= QTransform::TxScale)) {
+        // Use the rect version
+        QTransform xinv = viewportTransform().inverted();
+        return d->scene->items(xinv.mapRect(QRectF(pos.x(), pos.y(), 1, 1)),
+                               Qt::IntersectsItemShape,
+                               Qt::DescendingOrder,
+                               viewportTransform());
+    }
+    // Use the polygon version
+    return d->scene->items(mapToScene(pos.x(), pos.y(), 1, 1),
+                           Qt::IntersectsItemShape,
+                           Qt::DescendingOrder,
+                           viewportTransform());
+}
 …
     exact shape intersects with or is contained by \a rect are returned.
+    \sa itemAt(), items(), mapToScene()
+    The items are sorted in descending stacking order (i.e., the first item in
+    the returned list is the uppermost item).
+    \sa itemAt(), items(), mapToScene(), {QGraphicsItem#Sorting}{Sorting}
 */
 QList<QGraphicsItem *> QGraphicsView::items(const QRect &rect, Qt::ItemSelectionMode mode) const
 …
     if (!d->scene)
         return QList<QGraphicsItem *>();
+    if (d->scene->d_func()->largestUntransformableItem.isNull())
+        return d->scene->items(mapToScene(rect), mode);
+    QPainterPath path;
+    path.addRect(rect);
+    return d->itemsInArea(path);
+    return d->scene->items(mapToScene(rect), mode, Qt::DescendingOrder, viewportTransform());
+}
 …
     exact shape intersects with or is contained by \a polygon are returned.
+    \sa itemAt(), items(), mapToScene()
+    The items are sorted by descending stacking order (i.e., the first item in
+    the returned list is the uppermost item).
+    \sa itemAt(), items(), mapToScene(), {QGraphicsItem#Sorting}{Sorting}
 */
 QList<QGraphicsItem *> QGraphicsView::items(const QPolygon &polygon, Qt::ItemSelectionMode mode) const
 …
     if (!d->scene)
         return QList<QGraphicsItem *>();
+    if (d->scene->d_func()->largestUntransformableItem.isNull())
+        return d->scene->items(mapToScene(polygon), mode);
+    QPainterPath path;
+    path.addPolygon(polygon);
+    path.closeSubpath();
+    return d->itemsInArea(path);
+    return d->scene->items(mapToScene(polygon), mode, Qt::DescendingOrder, viewportTransform());
+}
 …
     exact shape intersects with or is contained by \a path are returned.
     \sa itemAt(), items(), mapToScene()
+    \sa itemAt(), items(), mapToScene(), {QGraphicsItem#Sorting}{Sorting}
 */
 QList<QGraphicsItem *> QGraphicsView::items(const QPainterPath &path, Qt::ItemSelectionMode mode) const
 …
     if (!d->scene)
         return QList<QGraphicsItem *>();
+    if (d->scene->d_func()->largestUntransformableItem.isNull())
+        return d->scene->items(mapToScene(path), mode);
+    return d->itemsInArea(path);
+    return d->scene->items(mapToScene(path), mode, Qt::DescendingOrder, viewportTransform());
+}
 …
     \snippet doc/src/snippets/code/src_gui_graphicsview_qgraphicsview.cpp 6
     \sa items()
+    \sa items(), {QGraphicsItem#Sorting}{Sorting}
 */
 QGraphicsItem *QGraphicsView::itemAt(const QPoint &pos) const
 …
     QPointF scrollOffset(d->horizontalScroll(), d->verticalScroll());
     QPointF tl = scrollOffset + rect.topLeft();
     QPointF tr = scrollOffset + rect.topRight();
     QPointF br = scrollOffset + rect.bottomRight();
     QPointF bl = scrollOffset + rect.bottomLeft();
+    QPolygonF poly;
     poly.resize(4);
+    QRect r = rect.adjusted(0, 0, 1, 1);
+    QPointF tl = scrollOffset + r.topLeft();
+    QPointF tr = scrollOffset + r.topRight();
+    QPointF br = scrollOffset + r.bottomRight();
+    QPointF bl = scrollOffset + r.bottomLeft();
+    QPolygonF poly(4);
     if (!d->identityMatrix) {
         QTransform x = d->matrix.inverted();
 …
+{
     Q_D(const QGraphicsView);
     QTransform moveMatrix;
     moveMatrix.translate(d->horizontalScroll(), d->verticalScroll());
     return (moveMatrix * d->matrix.inverted()).map(path);
+    QTransform matrix = QTransform::fromTranslate(d->horizontalScroll(), d->verticalScroll());
+    matrix *= d->matrix.inverted();
+    return matrix.map(path);
+}
 …
     bl -= scrollOffset;
+    QPolygon poly;
+    poly.resize(4);
+    QPolygon poly(4);
     poly[0] = tl.toPoint();
     poly[1] = tr.toPoint();
 …
+{
     Q_D(const QGraphicsView);
     QTransform moveMatrix;
     moveMatrix.translate(-d->horizontalScroll(), -d->verticalScroll());
     return (d->matrix * moveMatrix).map(path);
+    QTransform matrix = d->matrix;
+    matrix *= QTransform::fromTranslate(-d->horizontalScroll(), -d->verticalScroll());
+    return matrix.map(path);
+}
 …
     Q_D(QGraphicsView);
     d->backgroundBrush = brush;
     viewport()->update();
+    d->updateAll();
     if (d->cacheMode & CacheBackground) {
 …
     Q_D(QGraphicsView);
     d->foregroundBrush = brush;
     viewport()->update();
+    d->updateAll();
+}
 …
     // Extract and reset dirty scene rect info.
     QVector<QRect> dirtyViewportRects;
+    for (int i = 0; i < d->dirtyRegions.size(); ++i)
+        dirtyViewportRects += d->dirtyRegions.at(i).rects();
+    d->dirtyRegions.clear();
+    const QVector<QRect> &dirtyRects = d->dirtyRegion.rects();
+    for (int i = 0; i < dirtyRects.size(); ++i)
+        dirtyViewportRects += dirtyRects.at(i);
+    d->dirtyRegion = QRegion();
+    d->dirtyBoundingRect = QRect();
     bool fullUpdate = !d->accelerateScrolling || d->viewportUpdateMode == QGraphicsView::FullViewportUpdate;
 …
     const bool isGLWidget = widget->inherits("QGLWidget");
+    d->accelerateScrolling = !(isGLWidget
+                               || widget->testAttribute(Qt::WA_MSWindowsUseDirect3D)
+                               || qApp->testAttribute(Qt::AA_MSWindowsUseDirect3DByDefault));
+    d->accelerateScrolling = !(isGLWidget);
     widget->setFocusPolicy(Qt::StrongFocus);
 …
+    }
+    widget->setMouseTracking(true);
+    // We are only interested in mouse tracking if items
+    // accept hover events or use non-default cursors or if
+    // AnchorUnderMouse is used as transformation or resize anchor.
+    if ((d->scene && (!d->scene->d_func()->allItemsIgnoreHoverEvents
+                     || !d->scene->d_func()->allItemsUseDefaultCursor))
+        || d->transformationAnchor == AnchorUnderMouse
+        || d->resizeAnchor == AnchorUnderMouse) {
+        widget->setMouseTracking(true);
+    }
+    // enable touch events if any items is interested in them
+    if (d->scene && !d->scene->d_func()->allItemsIgnoreTouchEvents)
+        widget->setAttribute(Qt::WA_AcceptTouchEvents);
     widget->setAcceptDrops(acceptDrops());
+}
 …
+{
     Q_D(QGraphicsView);
     if (!d->scene)
         return QAbstractScrollArea::viewportEvent(event);
 …
             d->scene->d_func()->removePopup(d->scene->d_func()->popupWidgets.first());
         QApplication::sendEvent(d->scene, event);
+        break;
+    case QEvent::Show:
+        if (d->scene && isActiveWindow()) {
+            QEvent windowActivate(QEvent::WindowActivate);
+            QApplication::sendEvent(d->scene, &windowActivate);
+        }
+        break;
+    case QEvent::Hide:
+        // spontaneous event will generate a WindowDeactivate.
+        if (!event->spontaneous() && d->scene && isActiveWindow()) {
+            QEvent windowDeactivate(QEvent::WindowDeactivate);
+            QApplication::sendEvent(d->scene, &windowDeactivate);
+        }
         break;
     case QEvent::Leave:
 …
         // Reset full update
         d->fullUpdatePending = false;
+        d->dirtyScrollOffset = QPoint();
         if (d->scene) {
             // Check if this view reimplements the updateScene slot; if it
 …
+        }
         break;
+    case QEvent::TouchBegin:
+    case QEvent::TouchUpdate:
+    case QEvent::TouchEnd:
+    {
+        if (!isEnabled())
+            return false;
+        if (d->scene && d->sceneInteractionAllowed) {
+            // Convert and deliver the touch event to the scene.
+            QTouchEvent *touchEvent = static_cast<QTouchEvent *>(event);
+            touchEvent->setWidget(viewport());
+            QGraphicsViewPrivate::translateTouchEvent(d, touchEvent);
+            (void) QApplication::sendEvent(d->scene, touchEvent);
+        }
+        return true;
+    }
+    case QEvent::Gesture:
+    case QEvent::GestureOverride:
+    {
+        if (!isEnabled())
+            return false;
+        if (d->scene && d->sceneInteractionAllowed) {
+            QGestureEvent *gestureEvent = static_cast<QGestureEvent *>(event);
+            gestureEvent->setWidget(viewport());
+            (void) QApplication::sendEvent(d->scene, gestureEvent);
+        }
+        return true;
+    }
     default:
         break;
 …
+{
     Q_D(QGraphicsView);
+    d->updateInputMethodSensitivity();
     QAbstractScrollArea::focusInEvent(event);
     if (d->scene)
 …
     mouseEvent.setButton(event->button());
     mouseEvent.setModifiers(event->modifiers());
+    QApplication::sendEvent(d->scene, &mouseEvent);
+    if (event->spontaneous())
+        qt_sendSpontaneousEvent(d->scene, &mouseEvent);
+    else
+        QApplication::sendEvent(d->scene, &mouseEvent);
+}
 …
             mouseEvent.setModifiers(event->modifiers());
             mouseEvent.setAccepted(false);
+            QApplication::sendEvent(d->scene, &mouseEvent);
+            if (event->spontaneous())
+                qt_sendSpontaneousEvent(d->scene, &mouseEvent);
+            else
+                QApplication::sendEvent(d->scene, &mouseEvent);
             // Update the original mouse event accepted state.
 …
                     viewport()->update(d->rubberBandRegion(viewport(), d->rubberBandRect));
                 else
                     viewport()->update();
+                    d->updateAll();
+            }
 …
                     viewport()->update(d->rubberBandRegion(viewport(), d->rubberBandRect));
                 else
                     viewport()->update();
+                    d->updateAll();
+            }
             // Set the new selection area
 …
             selectionArea.closeSubpath();
             if (d->scene)
+                d->scene->setSelectionArea(selectionArea, d->rubberBandSelectionMode);
+                d->scene->setSelectionArea(selectionArea, d->rubberBandSelectionMode,
+                                           viewportTransform());
             return;
+        }
 …
                     viewport()->update(d->rubberBandRegion(viewport(), d->rubberBandRect));
                 else
                     viewport()->update();
+                    d->updateAll();
+            }
             d->rubberBanding = false;
 …
     } else
 #endif
     if (d->dragMode == QGraphicsView::ScrollHandDrag) {
+    if (d->dragMode == QGraphicsView::ScrollHandDrag && event->button() == Qt::LeftButton) {
 #ifndef QT_NO_CURSOR
         // Restore the open hand cursor. ### There might be items
 …
     mouseEvent.setModifiers(event->modifiers());
     mouseEvent.setAccepted(false);
+    QApplication::sendEvent(d->scene, &mouseEvent);
+    if (event->spontaneous())
+        qt_sendSpontaneousEvent(d->scene, &mouseEvent);
+    else
+        QApplication::sendEvent(d->scene, &mouseEvent);
     // Update the last mouse event selected state.
 …
     // Determine the exposed region
+    QRegion exposedRegion = event->region();
+    if (!d->accelerateScrolling)
+        exposedRegion = viewport()->rect();
+    else if (d->viewportUpdateMode == BoundingRectViewportUpdate)
+        exposedRegion = event->rect();
+    QRectF exposedSceneRect = mapToScene(exposedRegion.boundingRect().adjusted(0, 0, 1, 1)).boundingRect();
+    d->exposedRegion = event->region();
+    QRectF exposedSceneRect = mapToScene(d->exposedRegion.boundingRect()).boundingRect();
     // Set up the painter
     QPainter painter(viewport());
-    QTransform original = painter.worldTransform();
 #ifndef QT_NO_RUBBERBAND
     if (d->rubberBanding && !d->rubberBandRect.isEmpty())
 …
     // Set up viewport transform
+    const QTransform viewTransform = viewportTransform();
+    painter.setTransform(viewTransform, true);
+#ifdef QGRAPHICSVIEW_DEBUG
+    QTime stopWatch;
+    stopWatch.start();
+    qDebug() << "QGraphicsView::paintEvent(" << exposedRegion << ")";
+#endif
+    // Find all exposed items
+    bool allItems = false;
+    QList<QGraphicsItem *> itemList = d->findItems(exposedRegion, &allItems);
+#ifdef QGRAPHICSVIEW_DEBUG
+    int exposedTime = stopWatch.elapsed();
+#endif
+    const bool viewTransformed = isTransformed();
+    if (viewTransformed)
+        painter.setWorldTransform(viewportTransform());
+    const QTransform viewTransform = painter.worldTransform();
+    // Draw background
     if ((d->cacheMode & CacheBackground)
 #ifdef Q_WS_X11
 …
             QPainter backgroundPainter(&d->backgroundPixmap);
             backgroundPainter.setClipRegion(d->backgroundPixmapExposed, Qt::ReplaceClip);
+            backgroundPainter.setTransform(viewportTransform());
+            drawBackground(&backgroundPainter, exposedSceneRect);
+            if (viewTransformed)
+                backgroundPainter.setTransform(viewTransform);
+#ifdef Q_WS_X11
+#undef X11
+            if (backgroundPainter.paintEngine()->type() != QPaintEngine::X11)
+#define X11 qt_x11Data
+#endif
+                backgroundPainter.setCompositionMode(QPainter::CompositionMode_Source);
+            QRectF backgroundExposedSceneRect = mapToScene(d->backgroundPixmapExposed.boundingRect()).boundingRect();
+            drawBackground(&backgroundPainter, backgroundExposedSceneRect);
             d->backgroundPixmapExposed = QRegion();
+        }
         // Blit the background from the background pixmap
+        QTransform oldMatrix = painter.worldTransform();
+        painter.setWorldTransform(original);
+        painter.drawPixmap(QPoint(), d->backgroundPixmap);
+        painter.setWorldTransform(oldMatrix);
+        if (viewTransformed) {
+            painter.setWorldTransform(QTransform());
+            painter.drawPixmap(QPoint(), d->backgroundPixmap);
+            painter.setWorldTransform(viewTransform);
+        } else {
+            painter.drawPixmap(QPoint(), d->backgroundPixmap);
+        }
     } else {
         if (!(d->optimizationFlags & DontSavePainterState))
 …
+    }
-#ifdef QGRAPHICSVIEW_DEBUG
-    int backgroundTime = stopWatch.elapsed() - exposedTime;
-#endif
-    // Generate the style options
-    QGraphicsItem **itemArray = new QGraphicsItem *[itemList.size()];
-    QStyleOptionGraphicsItem *styleOptionArray = d->allocStyleOptionsArray(itemList.size());
-    d->generateStyleOptions(itemList, itemArray, styleOptionArray, viewTransform,
-                            allItems, exposedRegion);
     // Items
+    drawItems(&painter, itemList.size(), itemArray, styleOptionArray);
+#ifdef QGRAPHICSVIEW_DEBUG
+    int itemsTime = stopWatch.elapsed() - exposedTime - backgroundTime;
+#endif
+    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).
+        // We only change the worldTransform() so there's no need to do a full-blown
+        // save() and restore(). Also note that we don't have to do this in case of
+        // IndirectPainting (the else branch), because in that case we always save()
+        // and restore() in QGraphicsScene::drawItems().
+        if (!d->scene->d_func()->painterStateProtection)
+            painter.setWorldTransform(viewTransform);
+    } else {
+        // Find all exposed items
+        bool allItems = false;
+        QList<QGraphicsItem *> itemList = d->findItems(d->exposedRegion, &allItems, viewTransform);
+        if (!itemList.isEmpty()) {
+            // Generate the style options.
+            const int numItems = itemList.size();
+            QGraphicsItem **itemArray = &itemList[0]; // Relies on QList internals, but is perfectly valid.
+            QStyleOptionGraphicsItem *styleOptionArray = d->allocStyleOptionsArray(numItems);
+            for (int i = 0; i < numItems; ++i) {
+                itemArray[i]->d_ptr->initStyleOption(&styleOptionArray[i], viewTransform,
+                                                     d->exposedRegion, allItems);
+            }
+            // Draw the items.
+            drawItems(&painter, numItems, itemArray, styleOptionArray);
+            d->freeStyleOptionsArray(styleOptionArray);
+        }
+    }
     // Foreground
     drawForeground(&painter, exposedSceneRect);
-    delete [] itemArray;
-    d->freeStyleOptionsArray(styleOptionArray);
-#ifdef QGRAPHICSVIEW_DEBUG
-    int foregroundTime = stopWatch.elapsed() - exposedTime - backgroundTime - itemsTime;
-#endif
 #ifndef QT_NO_RUBBERBAND
 …
     painter.end();
-#ifdef QGRAPHICSVIEW_DEBUG
-    qDebug() << "\tItem discovery....... " << exposedTime << "msecs (" << itemList.size() << "items,"
-             << (exposedTime > 0 ? (itemList.size() * 1000.0 / exposedTime) : -1) << "/ sec )";
-    qDebug() << "\tDrawing background... " << backgroundTime << "msecs (" << exposedRegion.numRects() << "segments )";
-    qDebug() << "\tDrawing items........ " << itemsTime << "msecs ("
-             << (itemsTime > 0 ? (itemList.size() * 1000.0 / itemsTime) : -1) << "/ sec )";
-    qDebug() << "\tDrawing foreground... " << foregroundTime << "msecs (" << exposedRegion.numRects() << "segments )";
-    qDebug() << "\tTotal rendering time: " << stopWatch.elapsed() << "msecs ("
-             << (stopWatch.elapsed() > 0 ? (1000.0 / stopWatch.elapsed()) : -1.0) << "fps )";
-#endif
     // Restore painter state protection.
     d->scene->d_func()->painterStateProtection = true;
 …
     if (d->viewportUpdateMode != QGraphicsView::NoViewportUpdate) {
         if (d->viewportUpdateMode != QGraphicsView::FullViewportUpdate) {
-            for (int i = 0; i < d->dirtyRects.size(); ++i)
-                d->dirtyRects[i].translate(dx, dy);
-            for (int i = 0; i < d->dirtyRegions.size(); ++i)
-                d->dirtyRegions[i].translate(dx, dy);
             if (d->accelerateScrolling) {
 #ifndef QT_NO_RUBBERBAND
 …
+                }
 #endif
+                d->dirtyScrollOffset.rx() += dx;
+                d->dirtyScrollOffset.ry() += dy;
+                d->dirtyRegion.translate(dx, dy);
                 viewport()->scroll(dx, dy);
             } else {
                 viewport()->update();
+                d->updateAll();
+            }
         } else {
             viewport()->update();
+            d->updateAll();
+        }
+    }
 …
 #endif
         ) {
+        // Scroll the background pixmap
+        QRegion exposed;
+        if (!d->backgroundPixmap.isNull())
+            d->backgroundPixmap.scroll(dx, dy, d->backgroundPixmap.rect(), &exposed);
         // Invalidate the background pixmap
+        d->backgroundPixmapExposed.translate(dx, 0);
+        if (dx > 0) {
+            d->backgroundPixmapExposed += QRect(0, 0, dx, viewport()->height());
+        } else if (dx < 0) {
+            d->backgroundPixmapExposed += QRect(viewport()->width() + dx, 0,
+                                                -dx, viewport()->height());
+        }
+        d->backgroundPixmapExposed.translate(0, dy);
+        if (dy > 0) {
+            d->backgroundPixmapExposed += QRect(0, 0, viewport()->width(), dy);
+        } else if (dy < 0) {
+            d->backgroundPixmapExposed += QRect(0, viewport()->height() + dy,
+                                                viewport()->width(), -dy);
+        }
+        // Scroll the background pixmap
+        if (!d->backgroundPixmap.isNull()) {
+            QPixmap tmp = d->backgroundPixmap.copy();
+            QBrush bgBrush = viewport()->palette().brush(viewport()->backgroundRole());
+            if (!bgBrush.isOpaque())
+                d->backgroundPixmap.fill(Qt::transparent);
+            QPainter painter(&d->backgroundPixmap);
+            painter.drawPixmap(dx, dy, tmp);
+        }
+        d->backgroundPixmapExposed.translate(dx, dy);
+        d->backgroundPixmapExposed += exposed;
+    }
 …
     The default implementation calls the scene's drawItems() function.
+    \obsolete Since Qt 4.6, this function is not called anymore unless
+    the QGraphicsView::IndirectPainting flag is given as an Optimization
+    flag.
     \sa drawForeground(), drawBackground(), QGraphicsScene::drawItems()
 */
 …
+{
     Q_D(QGraphicsView);
+    if (d->scene)
+        d->scene->drawItems(painter, numItems, items, options, viewport());
+    if (d->scene) {
+        QWidget *widget = painter->device() == viewport() ? viewport() : 0;
+        d->scene->drawItems(painter, numItems, items, options, widget);
+    }
+}
 …
+{
     Q_D(const QGraphicsView);
+    QTransform moveMatrix;
+    moveMatrix.translate(-d->horizontalScroll(), -d->verticalScroll());
+    QTransform moveMatrix = QTransform::fromTranslate(-d->horizontalScroll(), -d->verticalScroll());
     return d->identityMatrix ? moveMatrix : d->matrix * moveMatrix;
+}
+/*!
+    \since 4.6
+    Returns true if the view is transformed (i.e., a non-identity transform
+    has been assigned, or the scrollbars are adjusted).
+    \sa setTransform(), horizontalScrollBar(), verticalScrollBar()
+*/
+bool QGraphicsView::isTransformed() const
+{
+    Q_D(const QGraphicsView);
+    return !d->identityMatrix || d->horizontalScroll() || d->verticalScroll();
+}
 …
     // Any matrix operation requires a full update.
     viewport()->update();
+    d->updateAll();
+}
 …
+}
+QPointF QGraphicsViewPrivate::mapToScene(const QPointF &point) const
+{
+    QPointF p = point;
+    p.rx() += horizontalScroll();
+    p.ry() += verticalScroll();
+    return identityMatrix ? p : matrix.inverted().map(p);
+}
+QRectF QGraphicsViewPrivate::mapToScene(const QRectF &rect) const
+{
+    QPointF scrollOffset(horizontalScroll(), verticalScroll());
+    QPointF tl = scrollOffset + rect.topLeft();
+    QPointF tr = scrollOffset + rect.topRight();
+    QPointF br = scrollOffset + rect.bottomRight();
+    QPointF bl = scrollOffset + rect.bottomLeft();
+    QPolygonF poly(4);
+    if (!identityMatrix) {
+        QTransform x = matrix.inverted();
+        poly[0] = x.map(tl);
+        poly[1] = x.map(tr);
+        poly[2] = x.map(br);
+        poly[3] = x.map(bl);
+    } else {
+        poly[0] = tl;
+        poly[1] = tr;
+        poly[2] = br;
+        poly[3] = bl;
+    }
+    return poly.boundingRect();
+}
 QT_END_NAMESPACE

trunk/src/gui/graphicsview/qgraphicsview.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 …
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
     enum OptimizationFlag {
         DontClipPainter = 0x1,
+        DontClipPainter = 0x1, // obsolete
         DontSavePainterState = 0x2,
+        DontAdjustForAntialiasing = 0x4
+        DontAdjustForAntialiasing = 0x4,
+        IndirectPainting = 0x8
     };
     Q_DECLARE_FLAGS(OptimizationFlags, OptimizationFlag)
 …
     QTransform transform() const;
     QTransform viewportTransform() const;
+    bool isTransformed() const;
     void setTransform(const QTransform &matrix, bool combine = false);
     void resetTransform();
 …
     Q_PRIVATE_SLOT(d_func(), void _q_unsetViewportCursor())
 #endif
-    Q_PRIVATE_SLOT(d_func(), void _q_updateLaterSlot())
     friend class QGraphicsSceneWidget;
     friend class QGraphicsScene;
     friend class QGraphicsScenePrivate;
+    friend class QGraphicsItemPrivate;
 };

trunk/src/gui/graphicsview/qgraphicsview_p.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 …
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 //
 // This file is not part of the Qt API.  It exists for the convenience
 // of qapplication_*.cpp, qwidget*.cpp and qfiledialog.cpp.  This header
 // file may change from version to version without notice, or even be removed.
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
 //
 // We mean it.
 …
 #include <QtGui/qevent.h>
+#include <QtCore/qcoreapplication.h>
 #include "qgraphicssceneevent.h"
+#include <QtGui/qstyleoption.h>
 #include <private/qabstractscrollarea_p.h>
 QT_BEGIN_NAMESPACE
 class Q_GUI_EXPORT QGraphicsViewPrivate : public QAbstractScrollAreaPrivate
+class Q_AUTOTEST_EXPORT QGraphicsViewPrivate : public QAbstractScrollAreaPrivate
+{
     Q_DECLARE_PUBLIC(QGraphicsView)
 …
     qint64 verticalScroll() const;
+    QList<QGraphicsItem *> itemsInArea(const QPainterPath &path,
+                                       Qt::ItemSelectionMode mode = Qt::IntersectsItemShape,
+                                       Qt::SortOrder = Qt::AscendingOrder) const;
+    QRectF mapRectToScene(const QRect &rect) const;
+    QRectF mapRectFromScene(const QRectF &rect) const;
     QPointF mousePressItemPoint;
 …
     QPointF lastMouseMoveScenePoint;
     QPoint lastMouseMoveScreenPoint;
+    QPoint dirtyScrollOffset;
     Qt::MouseButton mousePressButton;
     QTransform matrix;
 …
     QRect mapToViewRect(const QGraphicsItem *item, const QRectF &rect) const;
     QRegion mapToViewRegion(const QGraphicsItem *item, const QRectF &rect) const;
-    void itemUpdated(QGraphicsItem *item, const QRectF &rect);
     bool fullUpdatePending;
+    QList<QRect> dirtyRects;
+    QList<QRegion> dirtyRegions;
+    int dirtyRectCount;
+    QRegion dirtyRegion;
     QRect dirtyBoundingRect;
+    void updateLater();
+    bool updatingLater;
+    void _q_updateLaterSlot();
+    void updateAll();
+    void updateRect(const QRect &rect);
+    void updateRegion(const QRegion &region);
+    void processPendingUpdates();
+    inline void updateAll()
+    {
+        viewport->update();
+        fullUpdatePending = true;
+        dirtyBoundingRect = QRect();
+        dirtyRegion = QRegion();
+    }
+    inline void dispatchPendingUpdateRequests()
+    {
+#ifndef Q_WS_MAC
+        // QWidget::update() works slightly different on the Mac; it's not part of
+        // our backing store so it needs special threatment.
+        if (qt_widget_private(viewport)->paintOnScreen())
+            QCoreApplication::sendPostedEvents(viewport, QEvent::UpdateRequest);
+        else
+            QCoreApplication::sendPostedEvents(viewport->window(), QEvent::UpdateRequest);
+#else
+        QCoreApplication::processEvents(QEventLoop::AllEvents | QEventLoop::ExcludeSocketNotifiers
+                                        | QEventLoop::ExcludeUserInputEvents);
+#endif
+    }
+    bool updateRect(const QRect &rect);
+    bool updateRegion(const QRegion &region);
     bool updateSceneSlotReimplementedChecked;
+    QList<QGraphicsItem *> findItems(const QRegion &exposedRegion, bool *allItems) const;
     void generateStyleOptions(const QList<QGraphicsItem *> &itemList,
+                              QGraphicsItem **itemArray,
+                              QStyleOptionGraphicsItem *styleOptionArray,
+                              const QTransform &worldTransform,
+                              bool allItems,
                               const QRegion &exposedRegion) const;
+    QRegion exposedRegion;
+    QList<QGraphicsItem *> findItems(const QRegion &exposedRegion, bool *allItems,
+                                     const QTransform &viewTransform) const;
+    QPointF mapToScene(const QPointF &point) const;
+    QRectF mapToScene(const QRectF &rect) const;
+    static void translateTouchEvent(QGraphicsViewPrivate *d, QTouchEvent *touchEvent);
+    void updateInputMethodSensitivity();
 };

trunk/src/gui/graphicsview/qgraphicswidget.cpp

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 …
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
     items in a QGraphicsScene.
     \since 4.4
-    \ingroup multimedia
     \ingroup graphicsview-api
 …
 /*!
-    \property QGraphicsWidget::enabled
-    \brief whether the item is enabled or not
-    This property is declared in QGraphicsItem.
-    By default, this property is true.
-    \sa QGraphicsItem::isEnabled(), QGraphicsItem::setEnabled()
-*/
-/*!
-    \property QGraphicsWidget::visible
-    \brief whether the item is visible or not
-    This property is declared in QGraphicsItem.
-    By default, this property is true.
-    \sa QGraphicsItem::isVisible(), QGraphicsItem::setVisible(), show(),
-    hide()
-*/
-/*!
-    \property QGraphicsWidget::opacity
-    \brief the opacity of the widget
-*/
-/*!
-    \property QGraphicsWidget::pos
-    \brief the position of the widget
-*/
-/*!
     Constructs a QGraphicsWidget instance. The optional \a parent argument is
     passed to QGraphicsItem's constructor. The optional \a wFlags argument
 …
 */
 QGraphicsWidget::QGraphicsWidget(QGraphicsItem *parent, Qt::WindowFlags wFlags)
     : QGraphicsItem(*new QGraphicsWidgetPrivate, 0, 0), QGraphicsLayoutItem(0, false)
+    : QGraphicsObject(*new QGraphicsWidgetPrivate, 0, 0), QGraphicsLayoutItem(0, false)
+{
     Q_D(QGraphicsWidget);
 …
 */
 QGraphicsWidget::QGraphicsWidget(QGraphicsWidgetPrivate &dd, QGraphicsItem *parent, QGraphicsScene *scene, Qt::WindowFlags wFlags)
     : QGraphicsItem(dd, 0, scene), QGraphicsLayoutItem(0, false)
+    : QGraphicsObject(dd, 0, scene), QGraphicsLayoutItem(0, false)
+{
     Q_D(QGraphicsWidget);
 …
     //we check if we have a layout previously
     if (d->layout) {
         delete d->layout;
+        QGraphicsLayout *temp = d->layout;
         foreach (QGraphicsItem * item, childItems()) {
             // In case of a custom layout which doesn't remove and delete items, we ensure that
 …
+            }
+        }
+        d->layout = 0;
+        delete temp;
+    }
 …
 /*!
+    \property QGraphicsWidget::sizePolicy
+    \brief the size policy for the widget
+    \sa sizePolicy(), setSizePolicy(), QWidget::sizePolicy()
+*/
+/*!
     \property QGraphicsWidget::geometry
     \brief the geometry of the widget
 …
+{
     QGraphicsWidgetPrivate *wd = QGraphicsWidget::d_func();
     QGraphicsLayoutItemPrivate *d = QGraphicsLayoutItem::d_ptr;
+    QGraphicsLayoutItemPrivate *d = QGraphicsLayoutItem::d_ptr.data();
     QRectF newGeom;
     QPointF oldPos = d->geom.topLeft();
 …
         // setPos triggers ItemPositionChange, which can adjust position
         wd->inSetGeometry = 1;
         wd->setPosHelper(newGeom.topLeft());
+        setPos(newGeom.topLeft());
         wd->inSetGeometry = 0;
         newGeom.moveTopLeft(pos());
 …
 /*!
+    \property QGraphicsWidget::minimumSize
+    \brief the minimum size of the widget
+    \sa setMinimumSize(), minimumSize(), preferredSize, maximumSize
+*/
+/*!
+    \property QGraphicsWidget::preferredSize
+    \brief the preferred size of the widget
+    \sa setPreferredSize(), preferredSize(), minimumSize, maximumSize
+*/
+/*!
+    \property QGraphicsWidget::maximumSize
+    \brief the maximum size of the widget
+    \sa setMaximumSize(), maximumSize(), minimumSize, preferredSize
+*/
+/*!
     Sets the widget's contents margins to \a left, \a top, \a right and \a
     bottom.
 …
     Q_D(QGraphicsWidget);
+    if (left == d->leftMargin
+        && top == d->topMargin
+        && right == d->rightMargin
+        && bottom == d->bottomMargin) {
+    if (!d->margins && left == 0 && top == 0 && right == 0 && bottom == 0)
         return;
+    }
+    d->leftMargin = left;
+    d->topMargin = top;
+    d->rightMargin = right;
+    d->bottomMargin = bottom;
+    d->ensureMargins();
+    if (left == d->margins[d->Left]
+        && top == d->margins[d->Top]
+        && right == d->margins[d->Right]
+        && bottom == d->margins[d->Bottom])
+        return;
+    d->margins[d->Left] = left;
+    d->margins[d->Top] = top;
+    d->margins[d->Right] = right;
+    d->margins[d->Bottom] = bottom;
     if (QGraphicsLayout *l = d->layout)
 …
+{
     Q_D(const QGraphicsWidget);
+    if (left || top || right || bottom)
+        d->ensureMargins();
     if (left)
         *left = d->leftMargin;
+        *left = d->margins[d->Left];
     if (top)
         *top = d->topMargin;
+        *top = d->margins[d->Top];
     if (right)
         *right = d->rightMargin;
+        *right = d->margins[d->Right];
     if (bottom)
         *bottom = d->bottomMargin;
+        *bottom = d->margins[d->Bottom];
+}
 …
+{
     Q_D(QGraphicsWidget);
+    bool unchanged = left == d->leftWindowFrameMargin && top == d->topWindowFrameMargin
+                     && right == d->rightWindowFrameMargin && bottom == d->bottomWindowFrameMargin;
+    if (!d->windowFrameMargins && left == 0 && top == 0 && right == 0 && bottom == 0)
+        return;
+    d->ensureWindowFrameMargins();
+    bool unchanged =
+        d->windowFrameMargins[d->Left] == left
+        && d->windowFrameMargins[d->Top] == top
+        && d->windowFrameMargins[d->Right] == right
+        && d->windowFrameMargins[d->Bottom] == bottom;
     if (d->setWindowFrameMargins && unchanged)
         return;
     if (!unchanged)
         prepareGeometryChange();
     d->leftWindowFrameMargin = left;
     d->topWindowFrameMargin = top;
     d->rightWindowFrameMargin = right;
     d->bottomWindowFrameMargin = bottom;
+    d->windowFrameMargins[d->Left] = left;
+    d->windowFrameMargins[d->Top] = top;
+    d->windowFrameMargins[d->Right] = right;
+    d->windowFrameMargins[d->Bottom] = bottom;
     d->setWindowFrameMargins = true;
+}
 …
+{
     Q_D(const QGraphicsWidget);
+    if (left || top || right || bottom)
+        d->ensureWindowFrameMargins();
     if (left)
         *left = d->leftWindowFrameMargin;
+        *left = d->windowFrameMargins[d->Left];
     if (top)
         *top = d->topWindowFrameMargin;
+        *top = d->windowFrameMargins[d->Top];
     if (right)
         *right = d->rightWindowFrameMargin;
+        *right = d->windowFrameMargins[d->Right];
     if (bottom)
         *bottom = d->bottomWindowFrameMargin;
+        *bottom = d->windowFrameMargins[d->Bottom];
+}
 …
+{
     Q_D(const QGraphicsWidget);
+    return geometry().adjusted(-d->leftWindowFrameMargin, -d->topWindowFrameMargin,
+                               d->rightWindowFrameMargin, d->bottomWindowFrameMargin);
+    return d->windowFrameMargins
+        ? geometry().adjusted(-d->windowFrameMargins[d->Left], -d->windowFrameMargins[d->Top],
+                              d->windowFrameMargins[d->Right], d->windowFrameMargins[d->Bottom])
+        : geometry();
+}
 …
+{
     Q_D(const QGraphicsWidget);
+    return rect().adjusted(-d->leftWindowFrameMargin, -d->topWindowFrameMargin,
+                           d->rightWindowFrameMargin, d->bottomWindowFrameMargin);
+    return d->windowFrameMargins
+        ? rect().adjusted(-d->windowFrameMargins[d->Left], -d->windowFrameMargins[d->Top],
+                          d->windowFrameMargins[d->Right], d->windowFrameMargins[d->Bottom])
+        : rect();
+}
 …
     QSizeF sh;
     if (d->layout) {
+        sh = d->layout->effectiveSizeHint(which, constraint);
+        sh += QSizeF(d->leftMargin + d->rightMargin, d->topMargin + d->bottomMargin);
+        QSizeF marginSize(0,0);
+        if (d->margins) {
+            marginSize = QSizeF(d->margins[d->Left] + d->margins[d->Right],
+                         d->margins[d->Top] + d->margins[d->Bottom]);
+        }
+        sh = d->layout->effectiveSizeHint(which, constraint - marginSize);
+        sh += marginSize;
     } else {
         switch (which) {
 …
     very important that subclasses call the base implementation.
+    For example, QGraphicsWidget uses ItemVisibleChange to deliver \l Show and
+    \l Hide events, ItemPositionHasChanged to deliver \l Move events, and
+    ItemParentChange both to deliver \l ParentChange events, and for managing
+    the focus chain.
+    \sa propertyChange()
+    \a change specifies the type of change, and \a value is the new value.
+    For example, QGraphicsWidget uses ItemVisibleChange to deliver
+    \l{QEvent::Show} {Show} and \l{QEvent::Hide}{Hide} events,
+    ItemPositionHasChanged to deliver \l{QEvent::Move}{Move} events,
+    and ItemParentChange both to deliver \l{QEvent::ParentChange}
+    {ParentChange} events, and for managing the focus chain.
+    QGraphicsWidget enables the ItemSendsGeometryChanges flag by default in
+    order to track position changes.
+    \sa QGraphicsItem::itemChange()
 */
 QVariant QGraphicsWidget::itemChange(GraphicsItemChange change, const QVariant &value)
 …
     case ItemParentChange: {
         QGraphicsItem *parent = qVariantValue<QGraphicsItem *>(value);
         d->fixFocusChainBeforeReparenting((parent && parent->isWidget()) ? static_cast<QGraphicsWidget *>(parent) : 0);
+        d->fixFocusChainBeforeReparenting((parent && parent->isWidget()) ? static_cast<QGraphicsWidget *>(parent) : 0, scene());
         // Deliver ParentAboutToChange.
 …
+    }
     case ItemParentHasChanged: {
-        // reset window type on parent change in order to automagically remove decorations etc.
-        Qt::WindowFlags wflags = d->windowFlags & ~Qt::WindowType_Mask;
-        d->adjustWindowFlags(&wflags);
-        setWindowFlags(wflags);
         // Deliver ParentChange.
         QEvent event(QEvent::ParentChange);
 …
 bool QGraphicsWidget::sceneEvent(QEvent *event)
+{
     return QCoreApplication::sendEvent(this, event) || QGraphicsItem::sceneEvent(event);
+    return QGraphicsItem::sceneEvent(event);
+}
 …
         break;
     case QEvent::GraphicsSceneMouseMove:
+        if (d->grabbedSection != Qt::NoSection) {
+        d->ensureWindowData();
+        if (d->windowData->grabbedSection != Qt::NoSection) {
             d->windowFrameMouseMoveEvent(static_cast<QGraphicsSceneMouseEvent *>(event));
             event->accept();
 …
     const qreal cornerMargin = 20;
     //### Not sure of this one, it should be the same value for all edges.
+    const qreal windowFrameWidth = d->leftWindowFrameMargin;
+    const qreal windowFrameWidth = d->windowFrameMargins
+        ? d->windowFrameMargins[d->Left] : 0;
     Qt::WindowFrameSection s = Qt::NoSection;
 …
     if (s == Qt::NoSection) {
         QRectF r1 = r;
+        r1.setHeight(d->topWindowFrameMargin);
+        r1.setHeight(d->windowFrameMargins
+                     ? d->windowFrameMargins[d->Top] : 0);
         if (r1.contains(pos))
             s = Qt::TitleBarArea;
 …
     \reimp
+    QGraphicsWidget handles the following events:
+    Handles the \a event.  QGraphicsWidget handles the following
+    events:
     \table   \o Event                 \o Usage
 …
         polishEvent();
         d->polished = true;
+        d->updateFont(d->font);
+        if (!d->font.isCopyOf(QApplication::font()))
+            d->updateFont(d->font);
         break;
     case QEvent::WindowActivate:
     case QEvent::WindowDeactivate:
         update();
-        foreach (QGraphicsItem *child, childItems()) {
-            if (child->isWidget())
-                QApplication::sendEvent(static_cast<QGraphicsWidget *>(child), event);
+        }
         break;
         // Taken from QWidget::event
 …
     case QEvent::GraphicsSceneMouseRelease:
     case QEvent::GraphicsSceneMouseDoubleClick:
+        if (d->hasDecoration() && d->grabbedSection != Qt::NoSection)
+        d->ensureWindowData();
+        if (d->hasDecoration() && d->windowData->grabbedSection != Qt::NoSection)
             return windowFrameEvent(event);
         break;
 …
         // ### Don't unset if the margins are explicitly set.
         unsetWindowFrameMargins();
+        if (d->layout)
+            d->layout->invalidate();
     case QEvent::FontChange:
         update();
 …
 /*!
     Returns the widgets window type.
+    \sa windowFlags(), isWindow(), isPanel()
 */
 Qt::WindowType QGraphicsWidget::windowType() const
 …
     By default, this property contains no window flags.
+    Windows are panels. If you set the Qt::Window flag, the ItemIsPanel flag
+    will be set automatically. If you clear the Qt::Window flag, the
+    ItemIsPanel flag is also cleared. Note that the ItemIsPanel flag can be
+    set independently of Qt::Window.
+    \sa isWindow(), isPanel()
 */
 Qt::WindowFlags QGraphicsWidget::windowFlags() const
 …
     bool wasPopup = (d->windowFlags & Qt::WindowType_Mask) == Qt::Popup;
+    d->adjustWindowFlags(&wFlags);
     d->windowFlags = wFlags;
     if (!d->setWindowFrameMargins)
         unsetWindowFrameMargins();
+    setFlag(ItemIsPanel, d->windowFlags & Qt::Window);
     bool isPopup = (d->windowFlags & Qt::WindowType_Mask) == Qt::Popup;
 …
             d->scene->d_func()->addPopup(this);
+    }
+    if (d->scene && d->scene->d_func()->allItemsIgnoreHoverEvents && d->hasDecoration()) {
+        d->scene->d_func()->allItemsIgnoreHoverEvents = false;
+        d->scene->d_func()->enableMouseTrackingOnViews();
+    }
+}
 …
     currently has input focus, or that itself has input focus.
     \sa QGraphicsScene::activeWindow(), QGraphicsScene::setActiveWindow()
+    \sa QGraphicsScene::activeWindow(), QGraphicsScene::setActiveWindow(), isActive()
 */
 bool QGraphicsWidget::isActiveWindow() const
+{
+    Q_D(const QGraphicsWidget);
+    if (!d->scene)
+        return false;
+    const QGraphicsWidget *w = window();
+    return (!w && d->scene->d_func()->activationRefCount) || (w && d->scene->activeWindow() == w);
+    return isActive();
+}
 …
     This property is only used for windows.
+    By default, if no title has been set, this property contains an empty string.
+    By default, if no title has been set, this property contains an
+    empty string.
 */
 void QGraphicsWidget::setWindowTitle(const QString &title)
+{
     Q_D(QGraphicsWidget);
+    d->windowTitle = title;
+    d->ensureWindowData();
+    d->windowData->windowTitle = title;
+}
 QString QGraphicsWidget::windowTitle() const
+{
     Q_D(const QGraphicsWidget);
     return d->windowTitle;
+    return d->windowData ? d->windowData->windowTitle : QString();
+}
 …
     If this widget, a child or descendant of this widget currently has input
     focus, this function will return a pointer to that widget. If
     no descendant has input focus, 0 is returned.
     \sa QWidget::focusWidget()
+    no descendant widget has input focus, 0 is returned.
+    \sa QGraphicsItem::focusItem(), QWidget::focusWidget()
 */
 QGraphicsWidget *QGraphicsWidget::focusWidget() const
+{
     Q_D(const QGraphicsWidget);
+    return d->focusChild;
+}
+    if (d->subFocusItem && d->subFocusItem->d_ptr->isWidget)
+        return static_cast<QGraphicsWidget *>(d->subFocusItem);
+    return 0;
+}
 #ifndef QT_NO_SHORTCUT
 …
     d->actions.insert(pos, action);
+    QActionPrivate *apriv = action->d_func();
+    apriv->graphicsWidgets.append(this);
+    if (index == -1) {
+        QActionPrivate *apriv = action->d_func();
+        apriv->graphicsWidgets.append(this);
+    }
     QActionEvent e(QEvent::ActionAdded, action, before);
 …
     bar.QStyleOption::operator=(*option);
     d->initStyleOptionTitleBar(&bar);   // this clear flags in bar.state
+    if (d->buttonMouseOver)
+    d->ensureWindowData();
+    if (d->windowData->buttonMouseOver)
         bar.state |= QStyle::State_MouseOver;
     else
         bar.state &= ~QStyle::State_MouseOver;
     if (d->buttonSunken)
+    if (d->windowData->buttonSunken)
         bar.state |= QStyle::State_Sunken;
     else
 …
 /*!
     \fn const QObjectList &QGraphicsWidget::children() const
+    \internal
     This function returns the same value as QObject::children(). It's
 …
             break;
+        }
         qDebug() << i++ << QString::number(uint(next), 16) << next->className() << next->data(0) << QString::fromAscii("focusItem:%1").arg(next->hasFocus() ? "1" : "0") << QLatin1String("next:") << next->d_func()->focusNext->data(0) << QLatin1String("prev:") << next->d_func()->focusPrev->data(0);
+        qDebug() << i++ << QString::number(uint(next), 16) << next->className() << next->data(0) << QString::fromAscii("focusItem:%1").arg(next->hasFocus() ? '1' : '0') << QLatin1String("next:") << next->d_func()->focusNext->data(0) << QLatin1String("prev:") << next->d_func()->focusPrev->data(0);
         if (visited.contains(next)) {
             qWarning("Already visited this node. However, I expected to dump until I found myself.");

trunk/src/gui/graphicsview/qgraphicswidget.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 …
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 class QGraphicsWidgetPrivate;
 class Q_GUI_EXPORT QGraphicsWidget : public QObject, public QGraphicsItem, public QGraphicsLayoutItem
+class Q_GUI_EXPORT QGraphicsWidget : public QGraphicsObject, public QGraphicsLayoutItem
+{
     Q_OBJECT
+    Q_INTERFACES(QGraphicsItem QGraphicsLayoutItem)
     Q_PROPERTY(QPalette palette READ palette WRITE setPalette)
     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 minimumSize READ minimumSize WRITE setMinimumSize)
+    Q_PROPERTY(QSizeF preferredSize READ preferredSize WRITE setPreferredSize)
+    Q_PROPERTY(QSizeF maximumSize READ maximumSize WRITE setMaximumSize)
+    Q_PROPERTY(QSizePolicy sizePolicy READ sizePolicy WRITE setSizePolicy)
     Q_PROPERTY(Qt::FocusPolicy focusPolicy READ focusPolicy WRITE setFocusPolicy)
-    Q_PROPERTY(bool enabled READ isEnabled WRITE setEnabled)
-    Q_PROPERTY(bool visible READ isVisible WRITE setVisible)
     Q_PROPERTY(Qt::WindowFlags windowFlags READ windowFlags WRITE setWindowFlags)
     Q_PROPERTY(QString windowTitle READ windowTitle WRITE setWindowTitle)
-    Q_PROPERTY(qreal opacity READ opacity WRITE setOpacity)
-    Q_PROPERTY(QPointF pos READ pos WRITE setPos)
     Q_PROPERTY(QRectF geometry READ geometry WRITE setGeometry)
 public:
     QGraphicsWidget(QGraphicsItem *parent = 0, Qt::WindowFlags wFlags = 0);
 …
 private:
     Q_DISABLE_COPY(QGraphicsWidget)
     Q_DECLARE_PRIVATE_D(QGraphicsItem::d_ptr, QGraphicsWidget)
+    Q_DECLARE_PRIVATE_D(QGraphicsItem::d_ptr.data(), QGraphicsWidget)
     friend class QGraphicsScene;
     friend class QGraphicsScenePrivate;

trunk/src/gui/graphicsview/qgraphicswidget_p.cpp

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 …
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
     focusNext = focusPrev = q;
     focusPolicy = Qt::NoFocus;
+    adjustWindowFlags(&wFlags);
+    windowFlags = wFlags;
     q->setParentItem(parentItem);
     q->setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred, QSizePolicy::DefaultType));
 …
     resolveLayoutDirection();
-    if (!parentItem)
-        adjustWindowFlags(&wFlags);
-    windowFlags = wFlags;
     q->unsetWindowFrameMargins();
+}
+    q->setFlag(QGraphicsItem::ItemUsesExtendedStyleOption);
+    q->setFlag(QGraphicsItem::ItemSendsGeometryChanges);
+}
 qreal QGraphicsWidgetPrivate::titleBarHeight(const QStyleOptionTitleBar &options) const
+{
 …
+}
+void QGraphicsWidgetPrivate::getLayoutItemMargins(qreal *left, qreal *top, qreal *right, qreal *bottom) const
+{
+    if (left)
+        *left = leftLayoutItemMargin;
+    if (top)
+        *top = topLayoutItemMargin;
+    if (right)
+        *right = rightLayoutItemMargin;
+    if (bottom)
+        *bottom = bottomLayoutItemMargin;
+}
+void QGraphicsWidgetPrivate::setLayoutItemMargins(qreal left, qreal top, qreal right, qreal bottom)
+{
+    if (leftLayoutItemMargin == left
+        && topLayoutItemMargin == top
+        && rightLayoutItemMargin == right
+        && bottomLayoutItemMargin == bottom)
+        return;
+    Q_Q(QGraphicsWidget);
+    leftLayoutItemMargin = left;
+    topLayoutItemMargin = top;
+    rightLayoutItemMargin = right;
+    bottomLayoutItemMargin = bottom;
+    q->updateGeometry();
+}
+void QGraphicsWidgetPrivate::setLayoutItemMargins(QStyle::SubElement element, const QStyleOption *opt)
+{
+    Q_Q(QGraphicsWidget);
+    QStyleOption myOpt;
+    if (!opt) {
+        q->initStyleOption(&myOpt);
+        myOpt.rect.setRect(0, 0, 32768, 32768);     // arbitrary
+        opt = &myOpt;
+    }
+    QRect liRect = q->style()->subElementRect(element, opt, /* q */ 0);
+    if (liRect.isValid()) {
+        leftLayoutItemMargin = (opt->rect.left() - liRect.left());
+        topLayoutItemMargin = (opt->rect.top() - liRect.top());
+        rightLayoutItemMargin = (liRect.right() - opt->rect.right());
+        bottomLayoutItemMargin = (liRect.bottom() - opt->rect.bottom());
+    } else {
+        leftLayoutItemMargin = 0;
+        topLayoutItemMargin = 0;
+        rightLayoutItemMargin = 0;
+        bottomLayoutItemMargin = 0;
+    }
+/*!
+    \internal
+*/
+QGraphicsWidgetPrivate::~QGraphicsWidgetPrivate()
+{
+    // Remove any lazily allocated data
+    delete[] margins;
+    delete[] windowFrameMargins;
+    delete windowData;
+}
+/*!
+    \internal
+     Ensures that margins is allocated.
+     This function must be called before any dereferencing.
+*/
+void QGraphicsWidgetPrivate::ensureMargins() const
+{
+    if (!margins) {
+        margins = new qreal[4];
+        for (int i = 0; i < 4; ++i)
+            margins[i] = 0;
+    }
+}
+/*!
+    \internal
+     Ensures that windowFrameMargins is allocated.
+     This function must be called before any dereferencing.
+*/
+void QGraphicsWidgetPrivate::ensureWindowFrameMargins() const
+{
+    if (!windowFrameMargins) {
+        windowFrameMargins = new qreal[4];
+        for (int i = 0; i < 4; ++i)
+            windowFrameMargins[i] = 0;
+    }
+}
+/*!
+    \internal
+     Ensures that windowData is allocated.
+     This function must be called before any dereferencing.
+*/
+void QGraphicsWidgetPrivate::ensureWindowData()
+{
+    if (!windowData)
+        windowData = new WindowData;
+}
 …
+{
     Q_Q(QGraphicsWidget);
+    ensureWindowData();
     q->initStyleOption(option);
     option->rect.setHeight(titleBarHeight(*option));
     option->titleBarFlags = windowFlags;
     option->subControls = QStyle::SC_TitleBarCloseButton | QStyle::SC_TitleBarLabel | QStyle::SC_TitleBarSysMenu;
     option->activeSubControls = hoveredSubControl;
+    option->activeSubControls = windowData->hoveredSubControl;
     bool isActive = q->isActiveWindow();
     if (isActive) {
 …
     QFont windowTitleFont = QApplication::font("QWorkspaceTitleBar");
     QRect textRect = q->style()->subControlRect(QStyle::CC_TitleBar, option, QStyle::SC_TitleBarLabel, 0);
+    option->text = QFontMetrics(windowTitleFont).elidedText(windowTitle, Qt::ElideRight, textRect.width());
+    option->text = QFontMetrics(windowTitleFont).elidedText(
+        windowData->windowTitle, Qt::ElideRight, textRect.width());
+}
 …
+{
     Q_Q(QGraphicsWidget);
+    if (grabbedSection != Qt::NoSection) {
+        if (grabbedSection == Qt::TitleBarArea) {
+            buttonSunken = false;
+    ensureWindowData();
+    if (windowData->grabbedSection != Qt::NoSection) {
+        if (windowData->grabbedSection == Qt::TitleBarArea) {
+            windowData->buttonSunken = false;
             QStyleOptionTitleBar bar;
             initStyleOptionTitleBar(&bar);
 …
             bar.rect.setHeight(q->style()->pixelMetric(QStyle::PM_TitleBarHeight, &bar));
             QPointF pos = event->pos();
+            pos.rx() += leftWindowFrameMargin;
+            pos.ry() += topWindowFrameMargin;
+            if (windowFrameMargins) {
+                pos.rx() += windowFrameMargins[Left];
+                pos.ry() += windowFrameMargins[Top];
+            }
             bar.subControls = QStyle::SC_TitleBarCloseButton;
             if (q->style()->subControlRect(QStyle::CC_TitleBar, &bar,
 …
+        }
         if (!(static_cast<QGraphicsSceneMouseEvent *>(event)->buttons()))
             grabbedSection = Qt::NoSection;
+            windowData->grabbedSection = Qt::NoSection;
         event->accept();
+    }
 …
         return;
+    startGeometry = q->geometry();
+    grabbedSection = q->windowFrameSectionAt(event->pos());
+    switch (grabbedSection) {
+    case Qt::LeftSection:
+    case Qt::TopLeftSection:
+        mouseDelta = event->pos() - q->rect().topLeft();
+        break;
+    case Qt::TopSection:
+    case Qt::TopRightSection:
+        mouseDelta = event->pos() - q->rect().topRight();
+        break;
+    case Qt::RightSection:
+    case Qt::BottomRightSection:
+        mouseDelta = event->pos() - q->rect().bottomRight();
+        break;
+    case Qt::BottomSection:
+    case Qt::BottomLeftSection:
+        mouseDelta = event->pos() - q->rect().bottomLeft();
+        break;
+    case Qt::TitleBarArea:
+        if (hoveredSubControl == QStyle::SC_TitleBarCloseButton) {
+            buttonSunken = true;
+            q->update();
+        }
+        break;
+    case Qt::NoSection:
+        break;
+    }
+    event->setAccepted(grabbedSection != Qt::NoSection);
+    ensureWindowData();
+    windowData->startGeometry = q->geometry();
+    windowData->grabbedSection = q->windowFrameSectionAt(event->pos());
+    ensureWindowData();
+    if (windowData->grabbedSection == Qt::TitleBarArea
+        && windowData->hoveredSubControl == QStyle::SC_TitleBarCloseButton) {
+        windowData->buttonSunken = true;
+        q->update();
+    }
+    event->setAccepted(windowData->grabbedSection != Qt::NoSection);
+}
+/*!
+  Used to calculate the
+  Precondition:
+  \a widget should support either hfw or wfh
+  If \a heightForWidth is set to false, this function will query the width for height
+  instead. \a width will then be interpreted as height, \a minh and \a maxh will be interpreted
+  as minimum width and maximum width.
+ */
+static qreal minimumHeightForWidth(qreal width, qreal minh, qreal maxh,
+                                   const QGraphicsWidget *widget,
+                                   bool heightForWidth = true)
+{
+    qreal minimumHeightForWidth = -1;
+    const QSizePolicy sp = widget->layout() ? widget->layout()->sizePolicy() : widget->sizePolicy();
+    const bool hasHFW = sp.hasHeightForWidth();
+    if (hasHFW == heightForWidth) {
+        minimumHeightForWidth = hasHFW
+                                ? widget->effectiveSizeHint(Qt::MinimumSize, QSizeF(width, -1)).height()
+                                : widget->effectiveSizeHint(Qt::MinimumSize, QSizeF(-1, width)).width();    //"width" is here height!
+    } else {
+        // widthForHeight
+        const qreal constraint = width;
+        while (maxh - minh > 0.1) {
+            qreal middle = minh + (maxh - minh)/2;
+            // ### really bad, if we are a widget with a layout it will call
+            // layout->effectiveSizeHint(Qt::MiniumumSize), which again will call
+            // sizeHint three times because of how the cache works
+            qreal hfw = hasHFW
+                        ? widget->effectiveSizeHint(Qt::MinimumSize, QSizeF(middle, -1)).height()
+                        : widget->effectiveSizeHint(Qt::MinimumSize, QSizeF(-1, middle)).width();
+            if (hfw > constraint) {
+                minh = middle;
+            } else if (hfw <= constraint) {
+                maxh = middle;
+            }
+        }
+        minimumHeightForWidth = maxh;
+    }
+    return minimumHeightForWidth;
+}
+static qreal minimumWidthForHeight(qreal height, qreal minw, qreal maxw,
+                                   const QGraphicsWidget *widget)
+{
+    return minimumHeightForWidth(height, minw, maxw, widget, false);
+}
+static QSizeF closestAcceptableSize(const QSizeF &proposed,
+                                    const QGraphicsWidget *widget)
+{
+    const QSizeF current = widget->size();
+    qreal minw = proposed.width();
+    qreal maxw = current.width();
+    qreal minh = proposed.height();
+    qreal maxh = current.height();
+    qreal middlew = maxw;
+    qreal middleh = maxh;
+    qreal min_hfw;
+    min_hfw = minimumHeightForWidth(maxw, minh, maxh, widget);
+    do {
+        if (maxw - minw < 0.1) {
+            // we still havent found anything, cut off binary search
+            minw = maxw;
+            minh = maxh;
+        }
+        middlew = minw + (maxw - minw)/2.0;
+        middleh = minh + (maxh - minh)/2.0;
+        min_hfw = minimumHeightForWidth(middlew, minh, maxh, widget);
+        if (min_hfw > middleh) {
+            minw = middlew;
+            minh = middleh;
+        } else if (min_hfw <= middleh) {
+            maxw = middlew;
+            maxh = middleh;
+        }
+    } while (maxw != minw);
+    min_hfw = minimumHeightForWidth(middlew, minh, maxh, widget);
+    QSizeF result;
+    if (min_hfw < maxh) {
+        result = QSizeF(middlew, min_hfw);
+    } else {
+        // Needed because of the cut-off we do above.
+        result = QSizeF(minimumWidthForHeight(maxh, proposed.width(), current.width(), widget), maxh);
+    }
+    return result;
+}
 static void _q_boundGeometryToSizeConstraints(const QRectF &startGeometry,
                                               QRectF *rect, Qt::WindowFrameSection section,
+                                              const QSizeF &min, const QSizeF &max)
+{
+    int height;
+    int width;
+                                              const QSizeF &min, const QSizeF &max,
+                                              const QGraphicsWidget *widget)
+{
+    const QRectF proposedRect = *rect;
+    qreal width = qBound(min.width(), proposedRect.width(), max.width());
+    qreal height = qBound(min.height(), proposedRect.height(), max.height());
+    QSizePolicy sp = widget->sizePolicy();
+    if (const QGraphicsLayout *l = widget->layout()) {
+        sp = l->sizePolicy();
+    }
+    const bool hasHFW = sp.hasHeightForWidth(); // || sp.hasWidthForHeight();
+    const bool widthChanged = proposedRect.width() < widget->size().width();
+    const bool heightChanged = proposedRect.height() < widget->size().height();
+    if (hasHFW) {
+        if (widthChanged || heightChanged) {
+            const qreal minh = min.height();
+            const qreal maxh = max.height();
+            const qreal proposedHFW = minimumHeightForWidth(width, minh, maxh, widget);
+            if (proposedHFW > proposedRect.height()) {
+                QSizeF effectiveSize = closestAcceptableSize(QSizeF(width, height), widget);
+                width = effectiveSize.width();
+                height = effectiveSize.height();
+            }
+        }
+    }
     switch (section) {
     case Qt::LeftSection:
+        width = qRound(qBound(min.width(), rect->width(), max.width()));
+        rect->setRect(startGeometry.right() - width, startGeometry.top(),
+                      width, startGeometry.height());
+        rect->setRect(startGeometry.right() - qRound(width), startGeometry.top(),
+                      qRound(width), startGeometry.height());
         break;
     case Qt::TopLeftSection:
+        width = qRound(qBound(min.width(), rect->width(), max.width()));
+        height = qRound(qBound(min.height(), rect->height(), max.height()));
+        rect->setRect(startGeometry.right() - width, startGeometry.bottom() - height,
+                      width, height);
+        rect->setRect(startGeometry.right() - qRound(width), startGeometry.bottom() - qRound(height),
+                      qRound(width), qRound(height));
         break;
     case Qt::TopSection:
+        height = qRound(qBound(min.height(), rect->height(), max.height()));
+        rect->setRect(startGeometry.left(), startGeometry.bottom() - height,
+                      startGeometry.width(), height);
+        rect->setRect(startGeometry.left(), startGeometry.bottom() - qRound(height),
+                      startGeometry.width(), qRound(height));
         break;
     case Qt::TopRightSection:
+        height = qRound(qBound(min.height(), rect->height(), max.height()));
+        rect->setTop(rect->bottom() - height);
+        rect->setWidth(qBound(min.width(), rect->width(), max.width()));
+        rect->setTop(rect->bottom() - qRound(height));
+        rect->setWidth(qRound(width));
         break;
     case Qt::RightSection:
         rect->setWidth(qBound(min.width(), rect->width(), max.width()));
+        rect->setWidth(qRound(width));
         break;
     case Qt::BottomRightSection:
         rect->setWidth(qBound(min.width(), rect->width(), max.width()));
         rect->setHeight(qBound(min.height(), rect->height(), max.height()));
+        rect->setWidth(qRound(width));
+        rect->setHeight(qRound(height));
         break;
     case Qt::BottomSection:
         rect->setHeight(qBound(min.height(), rect->height(), max.height()));
+        rect->setHeight(qRound(height));
         break;
     case Qt::BottomLeftSection:
+        height = qRound(qBound(min.height(), rect->height(), max.height()));
+        width = qRound(qBound(min.width(), rect->width(), max.width()));
+        rect->setRect(startGeometry.right() - width, startGeometry.top(),
+                      width, height);
+        rect->setRect(startGeometry.right() - qRound(width), startGeometry.top(),
+                      qRound(width), qRound(height));
         break;
     default:
 …
+{
     Q_Q(QGraphicsWidget);
+    if (!(event->buttons() & Qt::LeftButton) || hoveredSubControl != QStyle::SC_TitleBarLabel)
+    ensureWindowData();
+    if (!(event->buttons() & Qt::LeftButton) || windowData->hoveredSubControl != QStyle::SC_TitleBarLabel)
         return;
 …
     QRectF newGeometry;
     switch (grabbedSection) {
+    switch (windowData->grabbedSection) {
     case Qt::LeftSection:
+        newGeometry = QRectF(startGeometry.topLeft() + QPointF(parentXDelta.dx(), parentXDelta.dy()),
+                             startGeometry.size() - QSizeF(delta.dx(), delta.dy()));
+        newGeometry = QRectF(windowData->startGeometry.topLeft()
+                             + QPointF(parentXDelta.dx(), parentXDelta.dy()),
+                             windowData->startGeometry.size() - QSizeF(delta.dx(), delta.dy()));
         break;
     case Qt::TopLeftSection:
+        newGeometry = QRectF(startGeometry.topLeft() + QPointF(parentDelta.dx(), parentDelta.dy()),
+                             startGeometry.size() - QSizeF(delta.dx(), delta.dy()));
+        newGeometry = QRectF(windowData->startGeometry.topLeft()
+                             + QPointF(parentDelta.dx(), parentDelta.dy()),
+                             windowData->startGeometry.size() - QSizeF(delta.dx(), delta.dy()));
         break;
     case Qt::TopSection:
+        newGeometry = QRectF(startGeometry.topLeft() + QPointF(parentYDelta.dx(), parentYDelta.dy()),
+                             startGeometry.size() - QSizeF(0, delta.dy()));
+        newGeometry = QRectF(windowData->startGeometry.topLeft()
+                             + QPointF(parentYDelta.dx(), parentYDelta.dy()),
+                             windowData->startGeometry.size() - QSizeF(0, delta.dy()));
         break;
     case Qt::TopRightSection:
+        newGeometry = QRectF(startGeometry.topLeft() + QPointF(parentYDelta.dx(), parentYDelta.dy()),
+                             startGeometry.size() - QSizeF(-delta.dx(), delta.dy()));
+        newGeometry = QRectF(windowData->startGeometry.topLeft()
+                             + QPointF(parentYDelta.dx(), parentYDelta.dy()),
+                             windowData->startGeometry.size() - QSizeF(-delta.dx(), delta.dy()));
         break;
     case Qt::RightSection:
         newGeometry = QRectF(startGeometry.topLeft(),
                              startGeometry.size() + QSizeF(delta.dx(), 0));
+        newGeometry = QRectF(windowData->startGeometry.topLeft(),
+                             windowData->startGeometry.size() + QSizeF(delta.dx(), 0));
         break;
     case Qt::BottomRightSection:
         newGeometry = QRectF(startGeometry.topLeft(),
                              startGeometry.size() + QSizeF(delta.dx(), delta.dy()));
+        newGeometry = QRectF(windowData->startGeometry.topLeft(),
+                             windowData->startGeometry.size() + QSizeF(delta.dx(), delta.dy()));
         break;
     case Qt::BottomSection:
         newGeometry = QRectF(startGeometry.topLeft(),
                              startGeometry.size() + QSizeF(0, delta.dy()));
+        newGeometry = QRectF(windowData->startGeometry.topLeft(),
+                             windowData->startGeometry.size() + QSizeF(0, delta.dy()));
         break;
     case Qt::BottomLeftSection:
+        newGeometry = QRectF(startGeometry.topLeft() + QPointF(parentXDelta.dx(), parentXDelta.dy()),
+                             startGeometry.size() - QSizeF(delta.dx(), -delta.dy()));
+        newGeometry = QRectF(windowData->startGeometry.topLeft()
+                             + QPointF(parentXDelta.dx(), parentXDelta.dy()),
+                             windowData->startGeometry.size() - QSizeF(delta.dx(), -delta.dy()));
         break;
     case Qt::TitleBarArea:
+        newGeometry = QRectF(startGeometry.topLeft() + QPointF(parentDelta.dx(), parentDelta.dy()),
+                             startGeometry.size());
+        newGeometry = QRectF(windowData->startGeometry.topLeft()
+                             + QPointF(parentDelta.dx(), parentDelta.dy()),
+                             windowData->startGeometry.size());
         break;
     case Qt::NoSection:
 …
+    }
+    if (grabbedSection != Qt::NoSection) {
+        _q_boundGeometryToSizeConstraints(startGeometry, &newGeometry, grabbedSection,
+    if (windowData->grabbedSection != Qt::NoSection) {
+        _q_boundGeometryToSizeConstraints(windowData->startGeometry, &newGeometry,
+                                          windowData->grabbedSection,
                                           q->effectiveSizeHint(Qt::MinimumSize),
+                                          q->effectiveSizeHint(Qt::MaximumSize));
+                                          q->effectiveSizeHint(Qt::MaximumSize),
+                                          q);
         q->setGeometry(newGeometry);
+    }
 …
         return;
+    ensureWindowData();
     if (q->rect().contains(event->pos())) {
         if (buttonMouseOver || hoveredSubControl != QStyle::SC_None)
+        if (windowData->buttonMouseOver || windowData->hoveredSubControl != QStyle::SC_None)
             windowFrameHoverLeaveEvent(event);
         return;
+    }
     bool wasMouseOver = buttonMouseOver;
     QRect oldButtonRect = buttonRect;
     buttonRect = QRect();
     buttonMouseOver = false;
+    bool wasMouseOver = windowData->buttonMouseOver;
+    QRect oldButtonRect = windowData->buttonRect;
+    windowData->buttonRect = QRect();
+    windowData->buttonMouseOver = false;
     QPointF pos = event->pos();
     QStyleOptionTitleBar bar;
     // make sure that the coordinates (rect and pos) we send to the style are positive.
+    pos.rx() += leftWindowFrameMargin;
+    pos.ry() += topWindowFrameMargin;
+    if (windowFrameMargins) {
+        pos.rx() += windowFrameMargins[Left];
+        pos.ry() += windowFrameMargins[Top];
+    }
     initStyleOptionTitleBar(&bar);
     bar.rect = q->windowFrameRect().toRect();
 …
             break;
         case Qt::TitleBarArea:
+            buttonRect = q->style()->subControlRect(QStyle::CC_TitleBar, &bar, QStyle::SC_TitleBarCloseButton, 0);
+            windowData->buttonRect = q->style()->subControlRect(
+                QStyle::CC_TitleBar, &bar, QStyle::SC_TitleBarCloseButton, 0);
 #ifdef Q_WS_MAC
             // On mac we should hover if we are in the 'area' of the buttons
+            buttonRect |= q->style()->subControlRect(QStyle::CC_TitleBar, &bar, QStyle::SC_TitleBarMinButton, 0);
+            buttonRect |= q->style()->subControlRect(QStyle::CC_TitleBar, &bar, QStyle::SC_TitleBarMaxButton, 0);
+            windowData->buttonRect |= q->style()->subControlRect(
+                QStyle::CC_TitleBar, &bar, QStyle::SC_TitleBarMinButton, 0);
+            windowData->buttonRect |= q->style()->subControlRect(
+                QStyle::CC_TitleBar, &bar, QStyle::SC_TitleBarMaxButton, 0);
 #endif
             if (buttonRect.contains(pos.toPoint()))
                 buttonMouseOver = true;
+            if (windowData->buttonRect.contains(pos.toPoint()))
+                windowData->buttonMouseOver = true;
             event->ignore();
             break;
 …
 #endif
     // update buttons if we hover over them
     hoveredSubControl = q->style()->hitTestComplexControl(QStyle::CC_TitleBar, &bar, pos.toPoint(), 0);
     if (hoveredSubControl != QStyle::SC_TitleBarCloseButton)
         hoveredSubControl = QStyle::SC_TitleBarLabel;
     if (buttonMouseOver != wasMouseOver) {
+    windowData->hoveredSubControl = q->style()->hitTestComplexControl(QStyle::CC_TitleBar, &bar, pos.toPoint(), 0);
+    if (windowData->hoveredSubControl != QStyle::SC_TitleBarCloseButton)
+        windowData->hoveredSubControl = QStyle::SC_TitleBarLabel;
+    if (windowData->buttonMouseOver != wasMouseOver) {
         if (!oldButtonRect.isNull())
             q->update(QRectF(oldButtonRect).translated(q->windowFrameRect().topLeft()));
         if (!buttonRect.isNull())
             q->update(QRectF(buttonRect).translated(q->windowFrameRect().topLeft()));
+        if (!windowData->buttonRect.isNull())
+            q->update(QRectF(windowData->buttonRect).translated(q->windowFrameRect().topLeft()));
+    }
+}
 …
 #endif
+        ensureWindowData();
         bool needsUpdate = false;
+        if (hoveredSubControl == QStyle::SC_TitleBarCloseButton || buttonMouseOver)
+        if (windowData->hoveredSubControl == QStyle::SC_TitleBarCloseButton
+            || windowData->buttonMouseOver)
             needsUpdate = true;
         // update the hover state (of buttons etc...)
         hoveredSubControl = QStyle::SC_None;
         buttonMouseOver = false;
         buttonRect = QRect();
+        windowData->hoveredSubControl = QStyle::SC_None;
+        windowData->buttonMouseOver = false;
+        windowData->buttonRect = QRect();
         if (needsUpdate)
             q->update(buttonRect);
+            q->update(windowData->buttonRect);
+    }
+}
 …
+{
     return (windowFlags & Qt::Window) && (windowFlags & Qt::WindowTitleHint);
+}
-/*!
-    \internal
-*/
-void QGraphicsWidgetPrivate::setFocusWidget()
+{
-    // Update focus child chain.
-    QGraphicsWidget *widget = static_cast<QGraphicsWidget *>(q_ptr);
-    QGraphicsWidget *parent = widget;
-    bool hidden = !visible;
-    do {
-        parent->d_func()->focusChild = widget;
-    } while (!parent->isWindow() && (parent = parent->parentWidget()) && (!hidden || !parent->d_func()->visible));
+}
-/*!
-    \internal
-*/
-void QGraphicsWidgetPrivate::clearFocusWidget()
+{
-    // Reset focus child chain.
-    QGraphicsWidget *parent = static_cast<QGraphicsWidget *>(q_ptr);
-    do {
-        if (parent->d_func()->focusChild != q_ptr)
-            break;
-        parent->d_func()->focusChild = 0;
-    } while (!parent->isWindow() && (parent = parent->parentWidget()));
+}
 …
  * is called after a reparent has taken place to fix up the focus chain(s)
  */
 void QGraphicsWidgetPrivate::fixFocusChainBeforeReparenting(QGraphicsWidget *newParent, QGraphicsScene *newScene)
+void QGraphicsWidgetPrivate::fixFocusChainBeforeReparenting(QGraphicsWidget *newParent, QGraphicsScene *oldScene, QGraphicsScene *newScene)
+{
     Q_Q(QGraphicsWidget);
 …
     QGraphicsWidget *firstOld = 0;
     bool wasPreviousNew = true;
-    if (focusChild) {
-        // Ensure that the current focus child doesn't leave pointers around
-        // before reparenting.
-        focusChild->clearFocus();
+    }
     while (w != q) {
 …
     if (newParent)
         newScene = newParent->scene();
+    QGraphicsScene *oldScene = q->scene();
     if (oldScene && newScene != oldScene)
         oldScene->d_func()->tabFocusFirst = firstOld;

trunk/src/gui/graphicsview/qgraphicswidget_p.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 …
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 //
 // This file is not part of the Qt API.  It exists for the convenience
 // of qapplication_*.cpp, qwidget*.cpp and qfiledialog.cpp.  This header
 // file may change from version to version without notice, or even be removed.
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
 //
 // We mean it.
 …
 #if !defined(QT_NO_GRAPHICSVIEW) || (QT_EDITION & QT_MODULE_GRAPHICSVIEW) != QT_MODULE_GRAPHICSVIEW
 class Q_GUI_EXPORT QGraphicsWidgetPrivate : public QGraphicsItemPrivate
+class QGraphicsWidgetPrivate : public QGraphicsItemPrivate
+{
     Q_DECLARE_PUBLIC(QGraphicsWidget)
 public:
     QGraphicsWidgetPrivate()
+        : leftMargin(0),
+          topMargin(0),
+          rightMargin(0),
+          bottomMargin(0),
+          leftLayoutItemMargin(0),
+          topLayoutItemMargin(0),
+          rightLayoutItemMargin(0),
+          bottomLayoutItemMargin(0),
+        : margins(0),
           layout(0),
           inheritedPaletteResolveMask(0),
 …
           focusNext(0),
           focusPrev(0),
-          focusChild(0),
           windowFlags(0),
+          hoveredSubControl(QStyle::SC_None),
+          grabbedSection(Qt::NoSection),
+          buttonMouseOver(false),
+          buttonSunken(false),
+          windowData(0),
           setWindowFrameMargins(false),
+          leftWindowFrameMargin(0),
+          topWindowFrameMargin(0),
+          rightWindowFrameMargin(0),
+          bottomWindowFrameMargin(0)
+          windowFrameMargins(0)
     { }
+    virtual ~QGraphicsWidgetPrivate();
     void init(QGraphicsItem *parentItem, Qt::WindowFlags wFlags);
 …
     // Margins
+    qreal leftMargin;
+    qreal topMargin;
+    qreal rightMargin;
+    qreal bottomMargin;
+    QRectF contentsRect;
+    // Layout item margins
+    void getLayoutItemMargins(qreal *left, qreal *top, qreal *right, qreal *bottom) const;
+    void setLayoutItemMargins(qreal left, qreal top, qreal right, qreal bottom);
+    void setLayoutItemMargins(QStyle::SubElement element, const QStyleOption *opt = 0);
+    void fixFocusChainBeforeReparenting(QGraphicsWidget *newParent, QGraphicsScene *newScene = 0);
+    enum {Left, Top, Right, Bottom};
+    mutable qreal *margins;
+    void ensureMargins() const;
+    void fixFocusChainBeforeReparenting(QGraphicsWidget *newParent, QGraphicsScene *oldScene, QGraphicsScene *newScene = 0);
     void setLayout_helper(QGraphicsLayout *l);
-    qreal leftLayoutItemMargin;
-    qreal topLayoutItemMargin;
-    qreal rightLayoutItemMargin;
-    qreal bottomLayoutItemMargin;
     // Layouts
 …
     QGraphicsWidget *focusNext;
     QGraphicsWidget *focusPrev;
-    QGraphicsWidget *focusChild;
-    void setFocusWidget();
-    void clearFocusWidget();
     // Windows
     Qt::WindowFlags windowFlags;
+    QString windowTitle;
+    QStyle::SubControl hoveredSubControl;
+    Qt::WindowFrameSection grabbedSection;
+    uint buttonMouseOver : 1;
+    uint buttonSunken : 1;
+    QPointF mouseDelta; // to compensate for small error when interactively resizing
+    QRectF startGeometry;
+    QRect buttonRect;
+    struct WindowData {
+        QString windowTitle;
+        QStyle::SubControl hoveredSubControl;
+        Qt::WindowFrameSection grabbedSection;
+        uint buttonMouseOver : 1;
+        uint buttonSunken : 1;
+        QRectF startGeometry;
+        QRect buttonRect;
+        WindowData()
+            : hoveredSubControl(QStyle::SC_None)
+            , grabbedSection(Qt::NoSection)
+            , buttonMouseOver(false)
+            , buttonSunken(false)
+        {}
+    } *windowData;
+    void ensureWindowData();
     bool setWindowFrameMargins;
+    qreal leftWindowFrameMargin;
+    qreal topWindowFrameMargin;
+    qreal rightWindowFrameMargin;
+    qreal bottomWindowFrameMargin;
+    mutable qreal *windowFrameMargins;
+    void ensureWindowFrameMargins() const;
 #ifndef QT_NO_ACTION

trunk/src/gui/graphicsview/qgridlayoutengine.cpp

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 …
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 #include <QtDebug>
+#include <QtCore/qmath.h>
 QT_BEGIN_NAMESPACE
 …
+{
     Q_ASSERT(sumDesired != 0.0);
     return desired * ::pow(sumAvailable / sumDesired, desired / sumDesired);
+    return desired * qPow(sumAvailable / sumDesired, desired / sumDesired);
+}
 …
                             factors[i] = (stretch < 0) ? 1.0 : 0.0;
                         } else {
                             factors[i] = (stretch < 0) ? sizes[i] : 0.0;
+                            factors[i] = (stretch < 0) ? sizes[i] : 0.0;
+                        }
                     } else if (stretch == sumStretches) {
 …
 QGridLayoutItem::QGridLayoutItem(QGridLayoutEngine *engine, QGraphicsLayoutItem *layoutItem,
                                  int row, int column, int rowSpan, int columnSpan,
                                  Qt::Alignment alignment)
+                                 Qt::Alignment alignment, int itemAtIndex)
     : q_engine(engine), q_layoutItem(layoutItem), q_alignment(alignment)
+{
 …
     q_stretches[Ver] = -1;
     q_engine->addItem(this);
+    q_engine->insertItem(this, itemAtIndex);
+}
 …
         width = size.width();
         height = size.height();
         Qt::Alignment align = q_engine->effectiveAlignment(this);
         switch (align & Qt::AlignHorizontal_Mask) {
 …
+{
     count += delta;
     insertOrRemoveItems(stretches, row, delta);
     insertOrRemoveItems(spacings, row, delta);
 …
+}
+void QGridLayoutEngine::addItem(QGridLayoutItem *item)
+/*!
+    \internal
+    The \a index is only used by QGraphicsLinearLayout to ensure that itemAt() reflects the order
+    of visual arrangement. Strictly speaking it does not have to, but most people expect it to.
+    (And if it didn't we would have to add itemArrangedAt(int index) or something..)
+ */
+void QGridLayoutEngine::insertItem(QGridLayoutItem *item, int index)
+{
     maybeExpandGrid(item->lastRow(), item->lastColumn());
+    q_items.append(item);
+    if (index == -1)
+        q_items.append(item);
+    else
+        q_items.insert(index, item);
     for (int i = item->firstRow(); i <= item->lastRow(); ++i) {
 …
+        }
+    }
+}
+void QGridLayoutEngine::addItem(QGridLayoutItem *item)
+{
+    insertItem(item, -1);
+}
 …
+    }
     return QSizeF();
+}
+}
 QSizePolicy::ControlTypes QGridLayoutEngine::controlTypes(LayoutSide side) const
 …
         for (int column = 0; column < internalGridColumnCount(); ++column) {
             message += QString::number(q_items.indexOf(itemAt(row, column))).rightJustified(3);
             message += QLatin1String(" ");
+        }
         message += QLatin1String("]");
+            message += QLatin1Char(' ');
+        }
+        message += QLatin1Char(']');
         qDebug("%*s  %s", indent, "", qPrintable(message));
+    }
 …
     qDebug("%*s Geometries output", indent, "");
+    QVector<qreal> *cellPos = &q_yy;
     for (int pass = 0; pass < 2; ++pass) {
-        QVector<qreal> &cellPos = q_yy;
         QString message;
         for (i = 0; i < cellPos.count(); ++i) {
+        for (i = 0; i < cellPos->count(); ++i) {
             message += QLatin1String((message.isEmpty() ? "[" : ", "));
             message += QString::number(cellPos.at(i));
+        }
         message += QLatin1String("]");
+            message += QString::number(cellPos->at(i));
+        }
+        message += QLatin1Char(']');
         qDebug("%*s %s %s", indent, "", (pass == 0 ? "rows:" : "columns:"), qPrintable(message));
         cellPos = q_xx;
+        cellPos = &q_xx;
+    }
+}
 …
 QT_END_NAMESPACE
 #endif //QT_NO_GRAPHICSVIEW

trunk/src/gui/graphicsview/qgridlayoutengine_p.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 …
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 #include "qpair.h"
 #include "qvector.h"
+#include "qgraphicslayout_p.h"
 #include <float.h>
 …
 };
-class QLayoutStyleInfo
+{
-public:
-    inline QLayoutStyleInfo() { invalidate(); }
-    inline QLayoutStyleInfo(QStyle *style, QWidget *widget)
-        : q_valid(true), q_style(style), q_widget(widget) {}
-    inline void invalidate() { q_valid = false; q_style = 0; q_widget = 0; }
-    inline QStyle *style() const { return q_style; }
-    inline QWidget *widget() const { return q_widget; }
-    inline bool operator==(const QLayoutStyleInfo &other)
-        { return q_style == other.q_style && q_widget == other.q_widget; }
-    inline bool operator!=(const QLayoutStyleInfo &other)
-        { return !(*this == other); }
-private:
-    bool q_valid;
-    QStyle *q_style;
-    QWidget *q_widget;
-};
 class QGridLayoutBox
+{
 …
 public:
     QGridLayoutItem(QGridLayoutEngine *engine, QGraphicsLayoutItem *layoutItem, int row, int column,
+                    int rowSpan = 1, int columnSpan = 1, Qt::Alignment alignment = 0);
+                    int rowSpan = 1, int columnSpan = 1, Qt::Alignment alignment = 0,
+                    int itemAtIndex = -1);
     inline int firstRow() const { return q_firstRows[Ver]; }
 …
+    void insertItem(QGridLayoutItem *item, int index);
     void addItem(QGridLayoutItem *item);
     void removeItem(QGridLayoutItem *item);

/branches/vendor/nokia/qt/4.6.1	merged	eligible
/branches/vendor/nokia/qt/current	merged	eligible
/branches/vendor/trolltech/qt/current	3-149

Context Navigation

Legend:

Download in other formats: