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

equal deleted inserted replaced

-:41300fa6a67c
+:f7bc934e204c
 /****************************************************************************
 **
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 **
 #ifdef Q_WS_X11
 #include <private/qt_x11_p.h>
 #endif
 #include <private/qgraphicseffect_p.h>
 #include <private/qgesturemanager_p.h>
+#include <private/qpathclipper_p.h>
 // #define GESTURE_DEBUG
 #ifndef GESTURE_DEBUG
 # define DEBUG if (0) qDebug
 #else
 q->connect(q, SIGNAL(changed(QList<QRectF>)),
 views.at(i), SLOT(updateScene(QList<QRectF>)));
 }
 }
 } else {
-updateAll = false;
+if (views.isEmpty()) {
+updateAll = false;
+return;
+}
 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();
 /*!
 \internal
 */
 void QGraphicsScenePrivate::_q_polishItems()
 {
-QSet<QGraphicsItem *>::Iterator it;
+if (unpolishedItems.isEmpty())
+return;
 const QVariant booleanTrueVariant(true);
-while (!unpolishedItems.isEmpty()) {
+QGraphicsItem *item = 0;
-it = unpolishedItems.begin();
+QGraphicsItemPrivate *itemd = 0;
-QGraphicsItem *item = *it;
+const int oldUnpolishedCount = unpolishedItems.count();
-unpolishedItems.erase(it);
-if (!item->d_ptr->explicitlyHidden) {
+for (int i = 0; i < oldUnpolishedCount; ++i) {
+item = unpolishedItems.at(i);
+if (!item)
+continue;
+itemd = item->d_ptr.data();
+itemd->pendingPolish = false;
+if (!itemd->explicitlyHidden) {
 item->itemChange(QGraphicsItem::ItemVisibleChange, booleanTrueVariant);
 item->itemChange(QGraphicsItem::ItemVisibleHasChanged, booleanTrueVariant);
 }
-if (item->isWidget()) {
+if (itemd->isWidget) {
 QEvent event(QEvent::Polish);
 QApplication::sendEvent((QGraphicsWidget *)item, &event);
 }
+}
+if (unpolishedItems.count() == oldUnpolishedCount) {
+// No new items were added to the vector.
+unpolishedItems.clear();
+} else {
+// New items were appended; keep them and remove the old ones.
+unpolishedItems.remove(0, oldUnpolishedCount);
+unpolishedItems.squeeze();
+QMetaObject::invokeMethod(q_ptr, "_q_polishItems", Qt::QueuedConnection);
 }
 }
 void QGraphicsScenePrivate::_q_processDirtyItems()
 {
 // 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);
+item->setParentItem(0);
 }
 } else {
 unregisterTopLevelItem(item);
 }
 // Update selected & hovered item bookkeeping
 selectedItems.remove(item);
 hoverItems.removeAll(item);
 cachedItemsUnderMouse.removeAll(item);
-unpolishedItems.remove(item);
+if (item->d_ptr->pendingPolish) {
+const int unpolishedIndex = unpolishedItems.indexOf(item);
+if (unpolishedIndex != -1)
+unpolishedItems[unpolishedIndex] = 0;
+item->d_ptr->pendingPolish = false;
+}
 resetDirtyItem(item);
 //We remove all references of item from the sceneEventFilter arrays
 QMultiMap<QGraphicsItem*, QGraphicsItem*>::iterator iterator = sceneEventFilters.begin();
 while (iterator != sceneEventFilters.end()) {
 // 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();
+if (views.at(i)->inputContext())
+views.at(i)->inputContext()->reset();
 }
 }
 #endif //QT_NO_IM
 }
 enabled, the event is sent; otherwise it is stopped.
 */
 bool QGraphicsScenePrivate::sendEvent(QGraphicsItem *item, QEvent *event)
 {
 if (QGraphicsObject *object = item->toGraphicsObject()) {
-if (qt_gestureManager) {
+QGestureManager *gestureManager = QApplicationPrivate::instance()->gestureManager;
-if (qt_gestureManager->filterEvent(object, event))
+if (gestureManager) {
+if (gestureManager->filterEvent(object, event))
 return true;
 }
 }
 if (filterEvent(item, event))
 d_func()->init();
 setSceneRect(x, y, width, height);
 }
 /*!
-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);
 \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.
 */
 removeItem(group);
 delete group;
 }
 /*!
-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
 true), QGraphicsScene will emit changed() once control goes back
 to the event loop.
-If the item is already in a different scene, it will first be removed from
+If the item is already in a different scene, it will first be
-its old scene, and then added to this scene as a top-level.
+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
+QGraphicsScene will send ItemSceneChange notifications to \a item
-notification is sent. If it does belong to scene already (i.e., it is
+while it is added to the scene. If item does not currently belong
-moved to this scene), QGraphicsScene will send an addition notification as
+to a scene, only one notification is sent. If it does belong to
-the item is removed from its previous scene.
+scene already (i.e., it is moved to this scene), QGraphicsScene
+will send an addition notification as the item is removed from its
-If the item is a panel, the scene is active, and there is no active panel
+previous scene.
-in the scene, then the item will be activated.
+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(), {QGraphicsItem#Sorting}{Sorting}
 */
 void QGraphicsScene::addItem(QGraphicsItem *item)
 Q_D(QGraphicsScene);
 if (!item) {
 qWarning("QGraphicsScene::addItem: cannot add null item");
 return;
 }
-if (item->scene() == this) {
+if (item->d_ptr->scene == this) {
 qWarning("QGraphicsScene::addItem: item has already been added to this scene");
 return;
 }
 // Remove this item from its existing scene
-if (QGraphicsScene *oldScene = item->scene())
+if (QGraphicsScene *oldScene = item->d_ptr->scene)
 oldScene->removeItem(item);
 // Notify the item that its scene is changing, and allow the item to
 // react.
 const QVariant newSceneVariant(item->itemChange(QGraphicsItem::ItemSceneChange,
 qVariantFromValue<QGraphicsScene *>(this)));
 QGraphicsScene *targetScene = qVariantValue<QGraphicsScene *>(newSceneVariant);
 if (targetScene != this) {
-if (targetScene && item->scene() != targetScene)
+if (targetScene && item->d_ptr->scene != targetScene)
 targetScene->addItem(item);
 return;
 }
+if (d->unpolishedItems.isEmpty())
+QMetaObject::invokeMethod(this, "_q_polishItems", Qt::QueuedConnection);
+d->unpolishedItems.append(item);
+item->d_ptr->pendingPolish = true;
 // Detach this item from its parent if the parent's scene is different
 // from this scene.
-if (QGraphicsItem *itemParent = item->parentItem()) {
+if (QGraphicsItem *itemParent = item->d_ptr->parent) {
-if (itemParent->scene() != this)
+if (itemParent->d_ptr->scene != this)
 item->setParentItem(0);
 }
 // Add the item to this scene
 item->d_func()->scene = targetScene;
 if (d->allItemsIgnoreHoverEvents && d->itemAcceptsHoverEvents_helper(item)) {
 d->allItemsIgnoreHoverEvents = false;
 d->enableMouseTrackingOnViews();
 }
 #ifndef QT_NO_CURSOR
-if (d->allItemsUseDefaultCursor && item->hasCursor()) {
+if (d->allItemsUseDefaultCursor && item->d_ptr->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()) {
+if (d->allItemsIgnoreTouchEvents && item->d_ptr->acceptTouchEvents) {
 d->allItemsIgnoreTouchEvents = false;
 d->enableTouchEventsOnViews();
 }
 // Update selection lists
 lastNew->d_func()->focusNext = d->tabFocusFirst;
 }
 }
 // Add all children recursively
-foreach (QGraphicsItem *child, item->children())
+item->d_ptr->ensureSortedChildren();
-addItem(child);
+for (int i = 0; i < item->d_ptr->children.size(); ++i)
+addItem(item->d_ptr->children.at(i));
 // Resolve font and palette.
 item->d_ptr->resolveFont(d->font.resolve());
 item->d_ptr->resolvePalette(d->palette.resolve());
-if (d->unpolishedItems.isEmpty())
-QMetaObject::invokeMethod(this, "_q_polishItems", Qt::QueuedConnection);
-d->unpolishedItems.insert(item);
 // Reenable selectionChanged() for individual items
 --d->selectionChanging;
 if (!d->selectionChanging && d->selectedItems.size() != oldSelectedItemSize)
 emit selectionChanged();
 else
 d->lastActivePanel = item;
 }
 }
-if (item->flags() & QGraphicsItem::ItemSendsScenePositionChanges)
+if (item->d_ptr->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)
 #endif
 }
 bool QGraphicsScenePrivate::itemAcceptsHoverEvents_helper(const QGraphicsItem *item) const
 {
-return (!item->isBlockedByModalPanel() &&
+return (item->d_ptr->acceptsHover
-(item->acceptHoverEvents()
+|| (item->d_ptr->isWidget
-|| (item->isWidget()
+&& static_cast<const QGraphicsWidget *>(item)->d_func()->hasDecoration()))
-&& static_cast<const QGraphicsWidget *>(item)->d_func()->hasDecoration())));
+&& !item->isBlockedByModalPanel();
 }
 /*!
 This event handler, for event \a hoverEvent, can be reimplemented in a
 subclass to receive hover enter events. The default implementation
 pixmapPainter.end();
 if (!subPix.isNull()) {
 // Blit the subpixmap into the main pixmap.
 pixmapPainter.begin(pix);
+pixmapPainter.setCompositionMode(QPainter::CompositionMode_Source);
 pixmapPainter.setClipRegion(pixmapExposed);
 pixmapPainter.drawPixmap(br.topLeft(), subPix);
 pixmapPainter.end();
 }
 }
 oldPainterOpacity != newPainterOpacity, painterStateProtection);
 return;
 }
 // Create or reuse offscreen pixmap, possibly scroll/blit from the old one.
+// If the world transform is rotated we always recreate the cache to avoid
+// wrong blending.
 bool pixModified = false;
 QGraphicsItemCache::DeviceData *deviceData = &itemCache->deviceData[widget];
 bool invertable = true;
 QTransform diff = deviceData->lastTransform.inverted(&invertable);
 if (invertable)
 diff *= painter->worldTransform();
 deviceData->lastTransform = painter->worldTransform();
-if (!invertable || diff.type() > QTransform::TxTranslate) {
+if (!invertable
+|| diff.type() > QTransform::TxTranslate
+|| painter->worldTransform().type() > QTransform::TxScale) {
 pixModified = true;
 itemCache->allExposed = true;
 itemCache->exposed.clear();
 pix = QPixmap();
 }
 {
 // Make sure we don't have unpolished items before we draw.
 if (!unpolishedItems.isEmpty())
 _q_polishItems();
+updateAll = false;
 QRectF exposedSceneRect;
 if (exposedRegion && indexMethod != QGraphicsScene::NoIndex) {
 exposedSceneRect = exposedRegion->boundingRect().adjusted(-1, -1, 1, 1);
 if (viewTransform)
 exposedSceneRect = viewTransform->inverted().mapRect(exposedSceneRect);
 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);
+const bool itemIsFullyTransparent = QGraphicsItemPrivate::isOpacityNull(opacity);
 if (itemIsFullyTransparent && (!itemHasChildren || item->d_ptr->childrenCombineOpacity()))
 return;
 QTransform transform(Qt::Uninitialized);
 QTransform *transformPtr = 0;
 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();
+drawItem = exposedRegion ? exposedRegion->intersects(viewBoundingRect)
+: !viewBoundingRect.normalized().isEmpty();
 if (!drawItem) {
 if (!itemHasChildren)
 return;
 if (itemClipsChildrenToShape) {
 if (wasDirtyParentSceneTransform)
 painter->setOpacity(opacity);
 if (sourced->currentCachedSystem() != Qt::LogicalCoordinates
 && sourced->lastEffectTransform != painter->worldTransform())
 {
+if (sourced->lastEffectTransform.type() <= QTransform::TxTranslate
+&& painter->worldTransform().type() <= QTransform::TxTranslate)
+{
+QRectF sourceRect = sourced->boundingRect(Qt::DeviceCoordinates);
+QRect effectRect = sourced->paddedEffectRect(Qt::DeviceCoordinates, sourced->currentCachedMode(), sourceRect);
+sourced->setCachedOffset(effectRect.topLeft());
+} else {
+sourced->invalidateCache(QGraphicsEffectSourcePrivate::TransformChanged);
+}
 sourced->lastEffectTransform = painter->worldTransform();
-sourced->invalidateCache(QGraphicsEffectSourcePrivate::TransformChanged);
 }
 item->d_ptr->graphicsEffect->draw(painter);
 painter->setWorldTransform(restoreTransform);
 sourced->info = 0;
 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 itemIsFullyTransparent = QGraphicsItemPrivate::isOpacityNull(opacity);
 const bool itemClipsChildrenToShape = (item->d_ptr->flags & QGraphicsItem::ItemClipsChildrenToShape);
 const bool itemHasChildren = !item->d_ptr->children.isEmpty();
 int i = 0;
 if (itemHasChildren) {
 Q_ASSERT(transformPtr);
 if (effectTransform)
 painter->setWorldTransform(*transformPtr * *effectTransform);
 else
 painter->setWorldTransform(*transformPtr);
-painter->setClipPath(item->shape(), Qt::IntersectClip);
+QRectF clipRect;
+const QPainterPath clipPath(item->shape());
+if (QPathClipper::pathToRect(clipPath, &clipRect))
+painter->setClipRect(clipRect, Qt::IntersectClip);
+else
+painter->setClipPath(clipPath, Qt::IntersectClip);
 }
 // Draw children behind
 for (i = 0; i < item->d_ptr->children.size(); ++i) {
 QGraphicsItem *child = item->d_ptr->children.at(i);
 painter->setWorldTransform(*transformPtr * *effectTransform);
 else
 painter->setWorldTransform(*transformPtr);
 }
-if (itemClipsToShape)
+if (itemClipsToShape) {
-painter->setClipPath(item->shape(), Qt::IntersectClip);
+QRectF clipRect;
+const QPainterPath clipPath(item->shape());
+if (QPathClipper::pathToRect(clipPath, &clipRect))
+painter->setClipRect(clipRect, Qt::IntersectClip);
+else
+painter->setClipPath(clipPath, Qt::IntersectClip);
+}
 painter->setOpacity(opacity);
 if (!item->d_ptr->cacheMode && !item->d_ptr->isWidget)
 item->paint(painter, &styleOptionTmp, widget);
 else
 if (itemHasChildren && itemClipsChildrenToShape)
 painter->restore();
 }
 void QGraphicsScenePrivate::markDirty(QGraphicsItem *item, const QRectF &rect, bool invalidateChildren,
-bool force, bool ignoreOpacity, bool removingItemFromScene)
+bool force, bool ignoreOpacity, bool removingItemFromScene,
+bool updateBoundingRect)
 {
 Q_ASSERT(item);
 if (updateAll)
 return;
 if (force)
 item->d_ptr->ignoreVisible = 1;
 if (ignoreOpacity)
 item->d_ptr->ignoreOpacity = 1;
-QGraphicsItem *p = item->d_ptr->parent;
+if (!updateBoundingRect)
-while (p) {
+item->d_ptr->markParentDirty();
-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)
 {
 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;
+const bool itemIsFullyTransparent = !item->d_ptr->ignoreOpacity
+&& QGraphicsItemPrivate::isOpacityNull(opacity);
 if (itemIsFullyTransparent && (!itemHasChildren || item->d_ptr->childrenCombineOpacity())) {
 resetDirtyItem(item, /*recursive=*/itemHasChildren);
 return;
 }
 resetDirtyItem(item);
 }
 /*!
+\obsolete
 Paints the given \a items using the provided \a painter, after the
 background has been drawn, and before the foreground has been
 drawn.  All painting is done in \e scene coordinates. Before
 drawing each item, the painter must be transformed using
 QGraphicsItem::sceneTransform().
 Example:
 \snippet doc/src/snippets/graphicssceneadditemsnippet.cpp 0
+Since Qt 4.6, this function is not called anymore unless
+the QGraphicsView::IndirectPainting flag is given as an Optimization
+flag.
 \sa drawBackground(), drawForeground()
 */
 void QGraphicsScene::drawItems(QPainter *painter,
 int numItems,
 QGraphicsItem *items[],
 Q_D(QGraphicsScene);
 // Make sure we don't have unpolished items before we draw.
 if (!d->unpolishedItems.isEmpty())
 d->_q_polishItems();
+d->updateAll = false;
 QTransform viewTransform = painter->worldTransform();
 Q_UNUSED(options);
 // Determine view, expose and flags.
 QGraphicsView *view = widget ? qobject_cast<QGraphicsView *>(widget->parentWidget()) : 0;
 // 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)
+if (!res) {
+// forget about these touch points, we didn't handle them
+for (int i = 0; i < touchEvent.touchPoints().count(); ++i) {
+const QTouchEvent::TouchPoint &touchPoint = touchEvent.touchPoints().at(i);
+itemForTouchPointId.remove(touchPoint.id());
+sceneCurrentTouchPoints.remove(touchPoint.id());
+}
 ignoreSceneTouchEvent = false;
+}
 break;
 }
 default:
 if (item->d_ptr->acceptedTouchBeginEvent) {
 updateTouchPointsForItem(item, &touchEvent);
 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();
+QGraphicsItem *item = items.at(j);
-if (!item)
-continue;
+// Check if the item is blocked by a modal panel and use it as
-QGraphicsItemPrivate *d = item->QGraphicsItem::d_func();
+// a target instead of this item.
-if (d->gestureContext.contains(gestureType)) {
+(void) item->isBlockedByModalPanel(&item);
-result.append(item);
+if (QGraphicsObject *itemobj = item->toGraphicsObject()) {
+QGraphicsItemPrivate *d = item->d_func();
+if (d->gestureContext.contains(gestureType)) {
+result.append(itemobj);
+}
 }
+// Don't propagate through panels.
+if (item->isPanel())
+break;
 }
 DEBUG() << "QGraphicsScenePrivate::getGestureTargets:"
 << gesture << result;
 if (result.size() == 1) {
 normalGestures->insert(gesture, result.first());
 }
 }
 }
 }
-Q_ASSERT(qt_gestureManager); // it would be very odd if we got called without a manager.
+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) {
-qt_gestureManager->recycle(*setIter);
+gestureManager->recycle(*setIter);
 gestureTargets.remove(*setIter);
 }
 }
 QT_END_NAMESPACE

changeset 7	f7bc934e204c
parent 3	41300fa6a67c