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

equal deleted inserted replaced

-:dee5afe5301f
+:3f74d0d4af4c
 #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();
 // 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
 }
 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())
 {
-bool unclipped = false;
 if (sourced->lastEffectTransform.type() <= QTransform::TxTranslate
 && painter->worldTransform().type() <= QTransform::TxTranslate)
 {
-QRectF itemRect = item->boundingRect();
+QRectF sourceRect = sourced->boundingRect(Qt::DeviceCoordinates);
-if (!item->d_ptr->children.isEmpty())
+QRect effectRect = sourced->paddedEffectRect(Qt::DeviceCoordinates, sourced->currentCachedMode(), sourceRect);
-itemRect |= item->childrenBoundingRect();
+sourced->setCachedOffset(effectRect.topLeft());
-QRectF oldSourceRect = sourced->lastEffectTransform.mapRect(itemRect);
+} else {
-QRectF newSourceRect = painter->worldTransform().mapRect(itemRect);
+sourced->invalidateCache(QGraphicsEffectSourcePrivate::TransformChanged);
-QRect oldEffectRect = sourced->paddedEffectRect(sourced->currentCachedSystem(), sourced->currentCachedMode(), oldSourceRect);
-QRect newEffectRect = sourced->paddedEffectRect(sourced->currentCachedSystem(), sourced->currentCachedMode(), newSourceRect);
-QRect deviceRect(0, 0, painter->device()->width(), painter->device()->height());
-if (deviceRect.contains(oldEffectRect) && deviceRect.contains(newEffectRect)) {
-sourced->setCachedOffset(newEffectRect.topLeft());
-unclipped = true;
-}
 }
 sourced->lastEffectTransform = painter->worldTransform();
-if (!unclipped)
-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 (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
-\obsolete Since Qt 4.6, this function is not called anymore unless
+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);
 // 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());

branch	RCL_3
changeset 7	3f74d0d4af4c
parent 5	d3bac044e0f0
child 13	c0432d11811c