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

equal deleted inserted replaced

-:56cd8111b7f7
+:41300fa6a67c
 processDirtyItemsEmitted(false),
 selectionChanging(0),
 needSortTopLevelItems(true),
 holesInTopLevelSiblingIndex(false),
 topLevelSequentialOrdering(true),
+scenePosDescendantsUpdatePending(false),
 stickyFocus(false),
 hasFocus(false),
 focusItem(0),
 lastFocusItem(0),
 tabFocusFirst(0),
 views.at(i)->d_func()->dispatchPendingUpdateRequests();
 }
 /*!
 \internal
+*/
+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::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 if called from the item's destructor; these will
 be cleaned up the next time someone triggers purgeRemovedItems().
 Q_Q(QGraphicsScene);
 // Clear focus on the item to remove any reference in the focusWidget chain.
 item->clearFocus();
-markDirty(item, QRectF(), false, false, false, false, /*removingItemFromScene=*/true);
+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 {
 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, 0);
+widget->d_func()->fixFocusChainBeforeReparenting(0, oldScene, 0);
 }
-item->d_func()->scene = 0;
 // Unregister focus proxy.
 item->d_ptr->resetFocusProxy();
 // Remove from parent, or unregister from toplevels.
 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;
+}
+}
+}
 // Disable selectionChanged() for individual items
 ++selectionChanging;
 int oldSelectedItemsSize = selectedItems.size();
 // Update selected & hovered item bookkeeping
 while (iterator != sceneEventFilters.end()) {
 if (iterator.value() == item || iterator.key() == item)
 iterator = sceneEventFilters.erase(iterator);
 else
 ++iterator;
-}
-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->isPanel() && item->isVisible() && item->panelModality() != QGraphicsItem::NonModal)
 leaveModal(item);
 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);
 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);
 enabled, the event is sent; otherwise it is stopped.
 */
 bool QGraphicsScenePrivate::sendEvent(QGraphicsItem *item, QEvent *event)
 {
 if (QGraphicsObject *object = item->toGraphicsObject()) {
-QApplicationPrivate *qAppPriv = QApplicationPrivate::instance();
+if (qt_gestureManager) {
-if (qAppPriv->gestureManager) {
+if (qt_gestureManager->filterEvent(object, event))
-if (qAppPriv->gestureManager->filterEvent(object, event))
 return true;
 }
 }
 if (filterEvent(item, event))
 {
 Q_D(QGraphicsScene);
 // NB! We have to clear the index before deleting items; otherwise the
 // index might try to access dangling item pointers.
 d->index->clear();
-const QList<QGraphicsItem *> items = d->topLevelItems;
+// NB! QGraphicsScenePrivate::unregisterTopLevelItem() removes items
-qDeleteAll(items);
+while (!d->topLevelItems.isEmpty())
+delete d->topLevelItems.first();
 Q_ASSERT(d->topLevelItems.isEmpty());
 d->lastItemCount = 0;
 d->allItemsIgnoreHoverEvents = true;
 d->allItemsUseDefaultCursor = true;
 d->allItemsIgnoreTouchEvents = true;
 // Resolve font and palette.
 item->d_ptr->resolveFont(d->font.resolve());
 item->d_ptr->resolvePalette(d->palette.resolve());
-if (!item->d_ptr->explicitlyHidden) {
+if (d->unpolishedItems.isEmpty())
-if (d->unpolishedItems.isEmpty())
+QMetaObject::invokeMethod(this, "_q_polishItems", Qt::QueuedConnection);
-QMetaObject::invokeMethod(this, "_q_polishItems", Qt::QueuedConnection);
+d->unpolishedItems.insert(item);
-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)
+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();
 }
 /*!
-Returns the scene's current focus item, or 0 if no item currently has
+When the scene is active, this functions returns the scene's current focus
-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;
 }
 /*!
 Sets the scene's focus item to \a item, with the focus reason \a
 focusReason, after removing focus from any previous item that may have had
 QPixmap subPix;
 QPainter pixmapPainter;
 QRect br = pixmapExposed.boundingRect();
 // 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);
 } else {
 subPix = QPixmap(br.size());
 subPix.fill(Qt::transparent);
 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();
 }
 }
 #if 0
 // Only if the device rect isn't fully contained.
 bool allowPartialCacheExposure = !viewRect.contains(deviceRect);
 #else
 // Only if deviceRect is 20% taller or wider than the desktop.
-QRect desktopRect = QApplication::desktop()->availableGeometry(widget);
+bool allowPartialCacheExposure = false;
-bool allowPartialCacheExposure = (desktopRect.width() * 1.2 < deviceRect.width()
+if (widget) {
-|| desktopRect.height() * 1.2 < deviceRect.height());
+QRect desktopRect = QApplication::desktop()->availableGeometry(widget);
+allowPartialCacheExposure = (desktopRect.width() * 1.2 < deviceRect.width()
+|| desktopRect.height() * 1.2 < deviceRect.height());
+}
 #endif
 QRegion scrollExposure;
 if (deviceData->cacheIndent != QPoint() || allowPartialCacheExposure) {
 // Part of pixmap is drawn. Either device contains viewrect (big
 // item covers whole screen) or parts of device are outside the
 } // 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;
 painter->setWorldTransform(*transformPtr * *effectTransform);
 else
 painter->setWorldTransform(*transformPtr);
 painter->setOpacity(opacity);
-if (sourced->lastEffectTransform != painter->worldTransform()) {
+if (sourced->currentCachedSystem() != Qt::LogicalCoordinates
+&& sourced->lastEffectTransform != painter->worldTransform())
+{
 sourced->lastEffectTransform = painter->worldTransform();
-sourced->invalidateCache();
+sourced->invalidateCache(QGraphicsEffectSourcePrivate::TransformChanged);
 }
-item->d_ptr->graphicsEffect->draw(painter, source);
+item->d_ptr->graphicsEffect->draw(painter);
 painter->setWorldTransform(restoreTransform);
 sourced->info = 0;
-} else {
+} else
+#endif //QT_NO_GRAPHICSEFFECT
+{
 draw(item, painter, viewTransform, transformPtr, exposedRegion, widget, opacity,
 effectTransform, wasDirtyParentSceneTransform, drawItem);
 }
 }
 if (itemHasChildren && itemClipsChildrenToShape)
 painter->restore();
 }
 void QGraphicsScenePrivate::markDirty(QGraphicsItem *item, const QRectF &rect, bool invalidateChildren,
-bool maybeDirtyClipPath, bool force, bool ignoreOpacity,
+bool force, bool ignoreOpacity, bool removingItemFromScene)
-bool removingItemFromScene)
 {
 Q_ASSERT(item);
 if (updateAll)
 return;
-if (item->d_ptr->discardUpdateRequest(/*ignoreClipping=*/maybeDirtyClipPath,
+if (item->d_ptr->discardUpdateRequest(/*ignoreVisibleBit=*/force,
-/*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;
 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,
 // 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.isEmpty()) {
+if (item->d_ptr->paintedViewBoundingRectsNeedRepaint) {
 paintedViewBoundingRect.translate(viewPrivate->dirtyScrollOffset);
 if (!viewPrivate->updateRect(paintedViewBoundingRect))
 paintedViewBoundingRect = QRect(-1, -1, -1, -1); // Outside viewport.
 }
 updateTouchPointsForItem(item, touchEvent);
 bool acceptTouchEvents = item->acceptTouchEvents();
 touchEvent->setAccepted(acceptTouchEvents);
 res = acceptTouchEvents && sendEvent(item, touchEvent);
 eventAccepted = touchEvent->isAccepted();
-item->d_ptr->acceptedTouchBeginEvent = (res && eventAccepted);
+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;
+itemForTouchPointId[touchPoint.id()] = item; // can be zero
 }
 break;
 }
-if (item->isPanel())
+if (item && item->isPanel())
 break;
 }
 touchEvent->setAccepted(eventAccepted);
 return res;
 void QGraphicsScenePrivate::gestureEventHandler(QGestureEvent *event)
 {
 QWidget *viewport = event->widget();
 if (!viewport)
 return;
-QList<QGesture *> allGestures = event->allGestures();
+QList<QGesture *> allGestures = event->gestures();
 DEBUG() << "QGraphicsScenePrivate::gestureEventHandler:"
 << "Delivering gestures:" <<  allGestures;
 typedef QHash<QGraphicsObject *, QList<QGesture *> > GesturesPerItem;
 GesturesPerItem gesturesPerItem;
 if (itemIgnoredGestures.contains(item)) // don't deliver twice to the same item
 continue;
 QGraphicsItemPrivate *gid = item->QGraphicsItem::d_func();
 foreach(QGesture *g, alreadyIgnoredGestures) {
-if (gid->gestureContext.contains(g->gestureType()))
+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:"
 QGestureEvent ev(gestures);
 ev.setWidget(event->widget());
 sendEvent(item, &ev);
 QSet<QGesture *> ignoredGestures;
 foreach (QGesture *g, gestures) {
-if (!ev.isAccepted() && !ev.isAccepted(g))
+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:"
 << "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:
 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
+}
+}
+}
+}
+Q_ASSERT(qt_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);
+gestureTargets.remove(*setIter);
+}
+}
 QT_END_NAMESPACE
 #include "moc_qgraphicsscene.cpp"
 #endif // QT_NO_GRAPHICSVIEW

changeset 3	41300fa6a67c
parent 0	1918ee327afb
child 4	3b1da2848fc7