diff options
Diffstat (limited to 'src/widgets/graphicsview/qgraphicsscene.cpp')
| -rw-r--r-- | src/widgets/graphicsview/qgraphicsscene.cpp | 740 |
1 files changed, 316 insertions, 424 deletions
diff --git a/src/widgets/graphicsview/qgraphicsscene.cpp b/src/widgets/graphicsview/qgraphicsscene.cpp index a47d0d879d..634c0797b9 100644 --- a/src/widgets/graphicsview/qgraphicsscene.cpp +++ b/src/widgets/graphicsview/qgraphicsscene.cpp @@ -1,41 +1,5 @@ -/**************************************************************************** -** -** Copyright (C) 2016 The Qt Company Ltd. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of the QtWidgets module of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:LGPL$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU Lesser General Public License Usage -** Alternatively, this file may be used under the terms of the GNU Lesser -** General Public License version 3 as published by the Free Software -** Foundation and appearing in the file LICENSE.LGPL3 included in the -** packaging of this file. Please review the following information to -** ensure the GNU Lesser General Public License version 3 requirements -** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 2.0 or (at your option) the GNU General -** Public license version 3 or any later version approved by the KDE Free -** Qt Foundation. The licenses are as published by the Free Software -** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-2.0.html and -** https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only /*! \class QGraphicsScene @@ -222,26 +186,28 @@ #include <QtCore/qrect.h> #include <QtCore/qset.h> #include <QtCore/qstack.h> -#include <QtCore/qtimer.h> #include <QtCore/qvarlengtharray.h> #include <QtCore/QMetaMethod> #include <QtWidgets/qapplication.h> -#include <QtWidgets/qdesktopwidget.h> #include <QtGui/qevent.h> #include <QtWidgets/qgraphicslayout.h> #include <QtWidgets/qgraphicsproxywidget.h> #include <QtWidgets/qgraphicswidget.h> -#include <QtGui/qmatrix.h> #include <QtGui/qpaintengine.h> #include <QtGui/qpainter.h> +#include <QtGui/qpainterpath.h> #include <QtGui/qpixmapcache.h> #include <QtGui/qpolygon.h> -#include <QtGui/qtouchdevice.h> +#include <QtGui/qpointingdevice.h> #include <QtWidgets/qstyleoption.h> +#if QT_CONFIG(tooltip) #include <QtWidgets/qtooltip.h> +#endif #include <QtGui/qtransform.h> #include <QtGui/qinputmethod.h> #include <private/qapplication_p.h> +#include <private/qevent_p.h> +#include <QtGui/private/qeventpoint_p.h> #include <private/qobject_p.h> #if QT_CONFIG(graphicseffect) #include <private/qgraphicseffect_p.h> @@ -249,6 +215,8 @@ #include <private/qgesturemanager_p.h> #include <private/qpathclipper_p.h> +#include <QtCore/qpointer.h> + // #define GESTURE_DEBUG #ifndef GESTURE_DEBUG # define DEBUG if (0) qDebug @@ -278,7 +246,7 @@ static void _q_hoverFromMouseEvent(QGraphicsSceneHoverEvent *hover, const QGraph */ QGraphicsScenePrivate::QGraphicsScenePrivate() : indexMethod(QGraphicsScene::BspTreeIndex), - index(0), + index(nullptr), lastItemCount(0), hasSceneRect(false), dirtyGrowingItemsBoundingRect(true), @@ -301,19 +269,19 @@ QGraphicsScenePrivate::QGraphicsScenePrivate() minimumRenderSize(0.0), selectionChanging(0), rectAdjust(2), - focusItem(0), - lastFocusItem(0), - passiveFocusItem(0), - tabFocusFirst(0), - activePanel(0), - lastActivePanel(0), + focusItem(nullptr), + lastFocusItem(nullptr), + passiveFocusItem(nullptr), + tabFocusFirst(nullptr), + activePanel(nullptr), + lastActivePanel(nullptr), activationRefCount(0), childExplicitActivation(0), - lastMouseGrabberItem(0), - dragDropItem(0), - enterWidget(0), + lastMouseGrabberItem(nullptr), + dragDropItem(nullptr), + enterWidget(nullptr), lastDropAction(Qt::IgnoreAction), - style(0) + style(nullptr) { } @@ -363,12 +331,11 @@ void QGraphicsScenePrivate::_q_emitUpdated() // needs to happen in order to keep compatibility with the behavior from // Qt 4.4 and backward. if (isSignalConnected(changedSignalIndex)) { - for (int i = 0; i < views.size(); ++i) { - QGraphicsView *view = views.at(i); + for (auto view : std::as_const(views)) { if (!view->d_func()->connectedToScene) { view->d_func()->connectedToScene = true; q->connect(q, SIGNAL(changed(QList<QRectF>)), - views.at(i), SLOT(updateScene(QList<QRectF>))); + view, SLOT(updateScene(QList<QRectF>))); } } } else { @@ -376,11 +343,11 @@ void QGraphicsScenePrivate::_q_emitUpdated() updateAll = false; return; } - for (int i = 0; i < views.size(); ++i) - views.at(i)->d_func()->processPendingUpdates(); + for (auto view : std::as_const(views)) + view->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(); + for (auto view : std::as_const(views)) + view->d_func()->dispatchPendingUpdateRequests(); return; } @@ -443,9 +410,9 @@ void QGraphicsScenePrivate::_q_polishItems() return; const QVariant booleanTrueVariant(true); - QGraphicsItem *item = 0; - QGraphicsItemPrivate *itemd = 0; - const int oldUnpolishedCount = unpolishedItems.count(); + QGraphicsItem *item = nullptr; + QGraphicsItemPrivate *itemd = nullptr; + const int oldUnpolishedCount = unpolishedItems.size(); for (int i = 0; i < oldUnpolishedCount; ++i) { item = unpolishedItems.at(i); @@ -463,7 +430,7 @@ void QGraphicsScenePrivate::_q_polishItems() } } - if (unpolishedItems.count() == oldUnpolishedCount) { + if (unpolishedItems.size() == oldUnpolishedCount) { // No new items were added to the vector. unpolishedItems.clear(); } else { @@ -482,8 +449,8 @@ void QGraphicsScenePrivate::_q_processDirtyItems() 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); + for (auto topLevelItem : std::as_const(topLevelItems)) + resetDirtyItem(topLevelItem, /*recursive=*/true); return; } @@ -491,8 +458,8 @@ void QGraphicsScenePrivate::_q_processDirtyItems() const QRectF oldGrowingItemsBoundingRect = growingItemsBoundingRect; // Process items recursively. - for (int i = 0; i < topLevelItems.size(); ++i) - processDirtyItemsRecursive(topLevelItems.at(i)); + for (auto topLevelItem : std::as_const(topLevelItems)) + processDirtyItemsRecursive(topLevelItem); dirtyGrowingItemsBoundingRect = false; if (!hasSceneRect && oldGrowingItemsBoundingRect != growingItemsBoundingRect) @@ -501,8 +468,8 @@ void QGraphicsScenePrivate::_q_processDirtyItems() if (wasPendingSceneUpdate) return; - for (int i = 0; i < views.size(); ++i) - views.at(i)->d_func()->processPendingUpdates(); + for (auto view : std::as_const(views)) + view->d_func()->processPendingUpdates(); if (calledEmitUpdated) { // We did a compatibility QGraphicsScene::update in processDirtyItemsRecursive @@ -512,8 +479,8 @@ void QGraphicsScenePrivate::_q_processDirtyItems() } // Immediately dispatch all pending update requests on the views. - for (int i = 0; i < views.size(); ++i) - views.at(i)->d_func()->dispatchPendingUpdateRequests(); + for (auto view : std::as_const(views)) + view->d_func()->dispatchPendingUpdateRequests(); } /*! @@ -555,7 +522,7 @@ void QGraphicsScenePrivate::unregisterScenePosItem(QGraphicsItem *item) */ void QGraphicsScenePrivate::_q_updateScenePosDescendants() { - foreach (QGraphicsItem *item, scenePosItems) { + for (QGraphicsItem *item : std::as_const(scenePosItems)) { QGraphicsItem *p = item->d_ptr->parent; while (p) { p->d_ptr->scenePosDescendants = 1; @@ -602,19 +569,19 @@ void QGraphicsScenePrivate::removeItemHelper(QGraphicsItem *item) unregisterScenePosItem(item); QGraphicsScene *oldScene = item->d_func()->scene; - item->d_func()->scene = 0; + item->d_func()->scene = nullptr; //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)); + for (auto child : std::as_const(item->d_ptr->children)) + q->removeItem(child); } if (!item->d_ptr->inDestructor && !item->parentItem() && item->isWidget()) { QGraphicsWidget *widget = static_cast<QGraphicsWidget *>(item); - widget->d_func()->fixFocusChainBeforeReparenting(0, oldScene, 0); + widget->d_func()->fixFocusChainBeforeReparenting(nullptr, oldScene, nullptr); } // Unregister focus proxy. @@ -625,7 +592,7 @@ void QGraphicsScenePrivate::removeItemHelper(QGraphicsItem *item) if (parentItem->scene()) { Q_ASSERT_X(parentItem->scene() == q, "QGraphicsScene::removeItem", "Parent item's scene is different from this item's scene"); - item->setParentItem(0); + item->setParentItem(nullptr); } } else { unregisterTopLevelItem(item); @@ -633,17 +600,17 @@ void QGraphicsScenePrivate::removeItemHelper(QGraphicsItem *item) // Reset the mouse grabber and focus item data. if (item == focusItem) - focusItem = 0; + focusItem = nullptr; if (item == lastFocusItem) - lastFocusItem = 0; + lastFocusItem = nullptr; if (item == passiveFocusItem) - passiveFocusItem = 0; + passiveFocusItem = nullptr; if (item == activePanel) { // ### deactivate... - activePanel = 0; + activePanel = nullptr; } if (item == lastActivePanel) - lastActivePanel = 0; + lastActivePanel = nullptr; // Change tabFocusFirst to the next widget in focus chain if removing the current one. if (item == tabFocusFirst) { @@ -651,7 +618,7 @@ void QGraphicsScenePrivate::removeItemHelper(QGraphicsItem *item) if (wd->focusNext && wd->focusNext != tabFocusFirst && wd->focusNext->scene() == q) tabFocusFirst = wd->focusNext; else - tabFocusFirst = 0; + tabFocusFirst = nullptr; } // Cancel active touches @@ -705,20 +672,19 @@ void QGraphicsScenePrivate::removeItemHelper(QGraphicsItem *item) // Reset the last mouse grabber item if (item == lastMouseGrabberItem) - lastMouseGrabberItem = 0; + lastMouseGrabberItem = nullptr; // Reset the current drop item if (item == dragDropItem) - dragDropItem = 0; + dragDropItem = nullptr; - // Reenable selectionChanged() for individual items + // Re-enable selectionChanged() for individual items --selectionChanging; if (!selectionChanging && selectedItems.size() != oldSelectedItemsSize) emit q->selectionChanged(); #ifndef QT_NO_GESTURES - QHash<QGesture *, QGraphicsObject *>::iterator it; - for (it = gestureTargets.begin(); it != gestureTargets.end();) { + for (auto it = gestureTargets.begin(); it != gestureTargets.end();) { if (it.value() == item) it = gestureTargets.erase(it); else @@ -731,8 +697,9 @@ void QGraphicsScenePrivate::removeItemHelper(QGraphicsItem *item) cachedAlreadyDeliveredGestures.remove(dummy); } - foreach (Qt::GestureType gesture, item->d_ptr->gestureContext.keys()) - ungrabGesture(item, gesture); + for (auto it = item->d_ptr->gestureContext.constBegin(); + it != item->d_ptr->gestureContext.constEnd(); ++it) + ungrabGesture(item, it.key()); #endif // QT_NO_GESTURES } @@ -752,8 +719,8 @@ void QGraphicsScenePrivate::setActivePanelHelper(QGraphicsItem *item, bool durin q->setFocus(Qt::ActiveWindowFocusReason); // Find the item's panel. - QGraphicsItem *panel = item ? item->panel() : 0; - lastActivePanel = panel ? activePanel : 0; + QGraphicsItem *panel = item ? item->panel() : nullptr; + lastActivePanel = panel ? activePanel : nullptr; if (panel == activePanel || (!q->isActive() && !duringActivationEvent)) return; @@ -764,7 +731,7 @@ void QGraphicsScenePrivate::setActivePanelHelper(QGraphicsItem *item, bool durin if (QGraphicsItem *fi = activePanel->focusItem()) { // Remove focus from the current focus item. if (fi == q->focusItem()) - setFocusItemHelper(0, Qt::ActiveWindowFocusReason, /* emitFocusChanged = */ false); + setFocusItemHelper(nullptr, Qt::ActiveWindowFocusReason, /* emitFocusChanged = */ false); } QEvent event(QEvent::WindowDeactivate); @@ -841,7 +808,7 @@ void QGraphicsScenePrivate::setFocusItemHelper(QGraphicsItem *item, // accept input focus. if (item && (!(item->flags() & QGraphicsItem::ItemIsFocusable) || !item->isVisible() || !item->isEnabled())) { - item = 0; + item = nullptr; } // Set focus on the scene if an item requests focus. @@ -849,7 +816,7 @@ void QGraphicsScenePrivate::setFocusItemHelper(QGraphicsItem *item, q->setFocus(focusReason); if (item == focusItem) { if (emitFocusChanged) - emit q->focusItemChanged(focusItem, (QGraphicsItem *)0, focusReason); + emit q->focusItemChanged(focusItem, (QGraphicsItem *)nullptr, focusReason); return; } } @@ -869,7 +836,7 @@ void QGraphicsScenePrivate::setFocusItemHelper(QGraphicsItem *item, } #endif //QT_NO_IM - focusItem = 0; + focusItem = nullptr; QFocusEvent event(QEvent::FocusOut, focusReason); sendEvent(lastFocusItem, &event); } @@ -877,7 +844,7 @@ void QGraphicsScenePrivate::setFocusItemHelper(QGraphicsItem *item, // This handles the case that the item has been removed from the // scene in response to the FocusOut event. if (item && item->scene() != q) - item = 0; + item = nullptr; if (item) focusItem = item; @@ -1038,8 +1005,8 @@ void QGraphicsScenePrivate::ungrabMouse(QGraphicsItem *item, bool itemIsDying) void QGraphicsScenePrivate::clearMouseGrabber() { if (!mouseGrabberItems.isEmpty()) - mouseGrabberItems.first()->ungrabMouse(); - lastMouseGrabberItem = 0; + mouseGrabberItems.constFirst()->ungrabMouse(); + lastMouseGrabberItem = nullptr; } /*! @@ -1114,7 +1081,7 @@ void QGraphicsScenePrivate::clearKeyboardGrabber() void QGraphicsScenePrivate::enableMouseTrackingOnViews() { - foreach (QGraphicsView *view, views) + for (QGraphicsView *view : std::as_const(views)) view->viewport()->setMouseTracking(true); } @@ -1253,7 +1220,7 @@ bool QGraphicsScenePrivate::sendEvent(QGraphicsItem *item, QEvent *event) bool spont = event->spontaneous(); if (spont ? qt_sendSpontaneousEvent(o, event) : QCoreApplication::sendEvent(o, event)) return true; - event->spont = spont; + event->m_spont = spont; } return item->sceneEvent(event); } @@ -1365,10 +1332,10 @@ void QGraphicsScenePrivate::mousePressEventHandler(QGraphicsSceneMouseEvent *mou // Update window activation. QGraphicsItem *topItem = cachedItemsUnderMouse.value(0); - QGraphicsWidget *newActiveWindow = topItem ? topItem->window() : 0; + QGraphicsWidget *newActiveWindow = topItem ? topItem->window() : nullptr; if (newActiveWindow && newActiveWindow->isBlockedByModalPanel(&topItem)) { // pass activation to the blocking modal window - newActiveWindow = topItem ? topItem->window() : 0; + newActiveWindow = topItem ? topItem->window() : nullptr; } if (newActiveWindow != q->activeWindow()) @@ -1377,7 +1344,7 @@ void QGraphicsScenePrivate::mousePressEventHandler(QGraphicsSceneMouseEvent *mou // Set focus on the topmost enabled item that can take focus. bool setFocus = false; - foreach (QGraphicsItem *item, cachedItemsUnderMouse) { + for (QGraphicsItem *item : std::as_const(cachedItemsUnderMouse)) { if (item->isBlockedByModalPanel() || (item->d_ptr->flags & QGraphicsItem::ItemStopsFocusHandling)) { // Make sure we don't clear focus. @@ -1400,8 +1367,8 @@ void QGraphicsScenePrivate::mousePressEventHandler(QGraphicsSceneMouseEvent *mou // Check for scene modality. bool sceneModality = false; - for (int i = 0; i < modalPanels.size(); ++i) { - if (modalPanels.at(i)->panelModality() == QGraphicsItem::SceneModal) { + for (auto modalPanel : std::as_const(modalPanels)) { + if (modalPanel->panelModality() == QGraphicsItem::SceneModal) { sceneModality = true; break; } @@ -1409,7 +1376,7 @@ void QGraphicsScenePrivate::mousePressEventHandler(QGraphicsSceneMouseEvent *mou // If nobody could take focus, clear it. if (!stickyFocus && !setFocus && !sceneModality) - q->setFocusItem(0, Qt::MouseFocusReason); + q->setFocusItem(nullptr, Qt::MouseFocusReason); // Any item will do. if (sceneModality && cachedItemsUnderMouse.isEmpty()) @@ -1419,7 +1386,7 @@ void QGraphicsScenePrivate::mousePressEventHandler(QGraphicsSceneMouseEvent *mou // candidates one at a time, until the event is accepted. It's accepted by // default, so the receiver has to explicitly ignore it for it to pass // through. - foreach (QGraphicsItem *item, cachedItemsUnderMouse) { + for (QGraphicsItem *item : std::as_const(cachedItemsUnderMouse)) { if (!(item->acceptedMouseButtons() & mouseEvent->button())) { // Skip items that don't accept the event's mouse button. continue; @@ -1438,11 +1405,11 @@ void QGraphicsScenePrivate::mousePressEventHandler(QGraphicsSceneMouseEvent *mou 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 + // mouse event, and mouseEvent is a double-click event, then the // event is converted to a press. Known limitation: - // Triple-clicking will not generate a doubleclick, though. + // Triple-clicking will not generate a double-click, though. QGraphicsSceneMouseEvent mousePress(QEvent::GraphicsSceneMousePress); - mousePress.spont = mouseEvent->spont; + mousePress.m_spont = mouseEvent->spontaneous(); mousePress.accept(); mousePress.setButton(mouseEvent->button()); mousePress.setButtons(mouseEvent->buttons()); @@ -1531,7 +1498,7 @@ void QGraphicsScenePrivate::ensureSequentialTopLevelSiblingIndexes() */ void QGraphicsScenePrivate::setFont_helper(const QFont &font) { - if (this->font == font && this->font.resolve() == font.resolve()) + if (this->font == font && this->font.resolveMask() == font.resolveMask()) return; updateFont(font); } @@ -1545,7 +1512,7 @@ void QGraphicsScenePrivate::setFont_helper(const QFont &font) void QGraphicsScenePrivate::resolveFont() { QFont naturalFont = QApplication::font(); - naturalFont.resolve(0); + naturalFont.setResolveMask(0); QFont resolvedFont = font.resolve(naturalFont); updateFont(resolvedFont); } @@ -1571,7 +1538,7 @@ void QGraphicsScenePrivate::updateFont(const QFont &font) // Resolvefont for an item is a noop operation, but // every item can be a widget, or can have a widget // childre. - item->d_ptr->resolveFont(font.resolve()); + item->d_ptr->resolveFont(font.resolveMask()); } } @@ -1588,7 +1555,7 @@ void QGraphicsScenePrivate::updateFont(const QFont &font) */ void QGraphicsScenePrivate::setPalette_helper(const QPalette &palette) { - if (this->palette == palette && this->palette.resolve() == palette.resolve()) + if (this->palette == palette && this->palette.resolveMask() == palette.resolveMask()) return; updatePalette(palette); } @@ -1602,7 +1569,7 @@ void QGraphicsScenePrivate::setPalette_helper(const QPalette &palette) void QGraphicsScenePrivate::resolvePalette() { QPalette naturalPalette = QGuiApplication::palette(); - naturalPalette.resolve(0); + naturalPalette.setResolveMask(0); QPalette resolvedPalette = palette.resolve(naturalPalette); updatePalette(resolvedPalette); } @@ -1628,7 +1595,7 @@ void QGraphicsScenePrivate::updatePalette(const QPalette &palette) // ResolvePalette for an item is a noop operation, but // every item can be a widget, or can have a widget // children. - item->d_ptr->resolvePalette(palette.resolve()); + item->d_ptr->resolvePalette(palette.resolveMask()); } } @@ -1693,8 +1660,10 @@ QGraphicsScene::~QGraphicsScene() clear(); // Remove this scene from all associated views. - for (int j = 0; j < d->views.size(); ++j) - d->views.at(j)->setScene(0); + // Note: d->views is modified by QGraphicsView::setScene, so must make a copy + const auto views = d->views; + for (auto view : std::as_const(views)) + view->setScene(nullptr); } /*! @@ -1812,8 +1781,8 @@ void QGraphicsScene::render(QPainter *painter, const QRectF &target, const QRect // in reverse order). QList<QGraphicsItem *> itemList = items(sourceRect, Qt::IntersectsItemBoundingRect); QGraphicsItem **itemArray = new QGraphicsItem *[itemList.size()]; - int numItems = itemList.size(); - for (int i = 0; i < numItems; ++i) + const qsizetype numItems = itemList.size(); + for (qsizetype i = 0; i < numItems; ++i) itemArray[numItems - i - 1] = itemList.at(i); itemList.clear(); @@ -1830,7 +1799,7 @@ void QGraphicsScene::render(QPainter *painter, const QRectF &target, const QRect // Generate the style options QStyleOptionGraphicsItem *styleOptionArray = new QStyleOptionGraphicsItem[numItems]; - for (int i = 0; i < numItems; ++i) + for (qsizetype i = 0; i < numItems; ++i) itemArray[i]->d_ptr->initStyleOption(&styleOptionArray[i], painterTransform, targetRect.toRect()); // Render the scene. @@ -1852,7 +1821,7 @@ void QGraphicsScene::render(QPainter *painter, const QRectF &target, const QRect item discovery functions like items() and itemAt(). Indexing is most efficient for static scenes (i.e., where items don't move around). For dynamic scenes, or scenes with many animated items, the index bookkeeping - can outweight the fast lookup speeds. + can outweigh the fast lookup speeds. For the common case, the default index method BspTreeIndex works fine. If your scene uses many animations and you are experiencing slowness, you can @@ -1937,29 +1906,6 @@ void QGraphicsScene::setBspTreeDepth(int depth) bspTree->setBspTreeDepth(depth); } -#if QT_DEPRECATED_SINCE(5, 13) -/*! - \property QGraphicsScene::sortCacheEnabled - \brief whether sort caching is enabled - \since 4.5 - \obsolete - - Since Qt 4.6, this property has no effect. -*/ -bool QGraphicsScene::isSortCacheEnabled() const -{ - Q_D(const QGraphicsScene); - return d->sortCacheEnabled; -} -void QGraphicsScene::setSortCacheEnabled(bool enabled) -{ - Q_D(QGraphicsScene); - if (d->sortCacheEnabled == enabled) - return; - d->sortCacheEnabled = enabled; -} -#endif - /*! Calculates and returns the bounding rect of all items on the scene. This function works by iterating over all items, and because of this, it can @@ -1990,18 +1936,6 @@ QList<QGraphicsItem *> QGraphicsScene::items(Qt::SortOrder order) const } /*! - \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 @@ -2150,23 +2084,6 @@ QList<QGraphicsItem *> QGraphicsScene::collidingItems(const QGraphicsItem *item, } /*! - \fn QGraphicsItem *QGraphicsScene::itemAt(const QPointF &position) const - \overload - \obsolete - - Returns the topmost visible item at the specified \a position, or - \nullptr if there are no items at this position. - - This function is deprecated and returns incorrect results if the scene - contains items that ignore transformations. Use the overload that takes - a QTransform instead. - - Note: See items() for a definition of which items are considered visible by this function. - - \sa items(), collidingItems(), {QGraphicsItem#Sorting}{Sorting} -*/ - -/*! \since 4.6 Returns the topmost visible item at the specified \a position, or \nullptr @@ -2204,24 +2121,6 @@ QGraphicsItem *QGraphicsScene::itemAt(const QPointF &position, const QTransform */ /*! - \fn QGraphicsScene::itemAt(qreal x, qreal y) const - \overload - \obsolete - - Returns the topmost visible item at the position specified by (\a x, \a - y), or \nullptr if there are no items at this position. - - This convenience function is equivalent to calling \c - {itemAt(QPointF(x, y))}. - - This function is deprecated and returns incorrect results if the scene - contains items that ignore transformations. Use the overload that takes - a QTransform instead. - - Note: See items() for a definition of which items are considered visible by this function. -*/ - -/*! Returns a list of all currently selected items. The items are returned in no particular order. @@ -2234,7 +2133,7 @@ QList<QGraphicsItem *> QGraphicsScene::selectedItems() const // Optimization: Lazily removes items that are not selected. QGraphicsScene *that = const_cast<QGraphicsScene *>(this); QSet<QGraphicsItem *> actuallySelectedSet; - foreach (QGraphicsItem *item, that->d_func()->selectedItems) { + for (QGraphicsItem *item : std::as_const(that->d_func()->selectedItems)) { if (item->isSelected()) actuallySelectedSet << item; } @@ -2274,25 +2173,7 @@ QPainterPath QGraphicsScene::selectionArea() const */ void QGraphicsScene::setSelectionArea(const QPainterPath &path, const QTransform &deviceTransform) { - setSelectionArea(path, Qt::IntersectsItemShape, deviceTransform); -} - -/*! - \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) -{ - setSelectionArea(path, Qt::ReplaceSelection, mode, deviceTransform); + setSelectionArea(path, Qt::ReplaceSelection, Qt::IntersectsItemShape, deviceTransform); } /*! @@ -2342,7 +2223,7 @@ void QGraphicsScene::setSelectionArea(const QPainterPath &path, switch (selectionOperation) { case Qt::ReplaceSelection: // Deselect all items outside path. - foreach (QGraphicsItem *item, unselectItems) { + for (QGraphicsItem *item : std::as_const(unselectItems)) { item->setSelected(false); changed = true; } @@ -2351,7 +2232,7 @@ void QGraphicsScene::setSelectionArea(const QPainterPath &path, break; } - // Reenable emitting selectionChanged() for individual items. + // Re-enable emitting selectionChanged() for individual items. --d->selectionChanging; if (!d->selectionChanging && changed) @@ -2369,13 +2250,20 @@ void QGraphicsScene::clearSelection() // Disable emitting selectionChanged ++d->selectionChanging; - bool changed = !d->selectedItems.isEmpty(); + // iterate over a copy, as clearing selection might invalidate selectedItems + const auto selectedItems = d->selectedItems; + QSet<QGraphicsItem *> stillSelectedSet; - foreach (QGraphicsItem *item, d->selectedItems) + for (QGraphicsItem *item : selectedItems) { item->setSelected(false); - d->selectedItems.clear(); + // items might override itemChange to prevent deselection + if (item->isSelected()) + stillSelectedSet << item; + } + const bool changed = stillSelectedSet != selectedItems; + d->selectedItems = stillSelectedSet; - // Reenable emitting selectionChanged() for individual items. + // Re-enable emitting selectionChanged() for individual items. --d->selectionChanging; if (!d->selectionChanging && changed) @@ -2432,7 +2320,7 @@ QGraphicsItemGroup *QGraphicsScene::createItemGroup(const QList<QGraphicsItem *> } // Find the common ancestor for all items - QGraphicsItem *commonAncestor = 0; + QGraphicsItem *commonAncestor = nullptr; if (!ancestors.isEmpty()) { while (n < items.size()) { int commonIndex = -1; @@ -2446,7 +2334,7 @@ QGraphicsItemGroup *QGraphicsScene::createItemGroup(const QList<QGraphicsItem *> } while ((parent = parent->parentItem())); if (commonIndex == -1) { - commonAncestor = 0; + commonAncestor = nullptr; break; } @@ -2480,7 +2368,7 @@ void QGraphicsScene::destroyItemGroup(QGraphicsItemGroup *group) } /*! - Adds or moves the \a item and all its childen to this scene. + Adds or moves the \a item and all its children to this scene. This scene takes ownership of the \a item. If the item is visible (i.e., QGraphicsItem::isVisible() returns @@ -2530,22 +2418,18 @@ void QGraphicsScene::addItem(QGraphicsItem *item) return; } - // QDeclarativeItems do not rely on initial itemChanged message, as the componentComplete - // function allows far more opportunity for delayed-construction optimization. - if (!item->d_ptr->isDeclarativeItem) { - if (d->unpolishedItems.isEmpty()) { - QMetaMethod method = metaObject()->method(d->polishItemsIndex); - method.invoke(this, Qt::QueuedConnection); - } - d->unpolishedItems.append(item); - item->d_ptr->pendingPolish = true; + if (d->unpolishedItems.isEmpty()) { + QMetaMethod method = metaObject()->method(d->polishItemsIndex); + method.invoke(this, Qt::QueuedConnection); } + d->unpolishedItems.append(item); + item->d_ptr->pendingPolish = true; // Detach this item from its parent if the parent's scene is different // from this scene. if (QGraphicsItem *itemParent = item->d_ptr->parent) { if (itemParent->d_ptr->scene != this) - item->setParentItem(0); + item->setParentItem(nullptr); } // Add the item to this scene @@ -2568,8 +2452,16 @@ void QGraphicsScene::addItem(QGraphicsItem *item) ++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)) { + // Enable mouse tracking if we haven't already done so, and the item needs it. + // We cannot use itemAcceptsHoverEvents_helper() here, since we need to enable + // mouse tracking also if this item is temporarily blocked by a modal panel. + + auto needsMouseTracking = [](const QGraphicsItemPrivate *item) { + return item->acceptsHover + || (item->isWidget && static_cast<const QGraphicsWidgetPrivate *>(item)->hasDecoration()); + }; + + if (d->allItemsIgnoreHoverEvents && needsMouseTracking(item->d_ptr.data())) { d->allItemsIgnoreHoverEvents = false; d->enableMouseTrackingOnViews(); } @@ -2588,9 +2480,9 @@ void QGraphicsScene::addItem(QGraphicsItem *item) } #ifndef QT_NO_GESTURES - const auto gestures = item->d_ptr->gestureContext.keys(); // FIXME: iterate over hash directly? - for (Qt::GestureType gesture : gestures) - d->grabGesture(item, gesture); + for (auto it = item->d_ptr->gestureContext.constBegin(); + it != item->d_ptr->gestureContext.constEnd(); ++it) + d->grabGesture(item, it.key()); #endif // Update selection lists @@ -2621,15 +2513,15 @@ void QGraphicsScene::addItem(QGraphicsItem *item) // Add all children recursively item->d_ptr->ensureSortedChildren(); - for (int i = 0; i < item->d_ptr->children.size(); ++i) - addItem(item->d_ptr->children.at(i)); + for (auto child : std::as_const(item->d_ptr->children)) + addItem(child); // Resolve font and palette. - item->d_ptr->resolveFont(d->font.resolve()); - item->d_ptr->resolvePalette(d->palette.resolve()); + item->d_ptr->resolveFont(d->font.resolveMask()); + item->d_ptr->resolvePalette(d->palette.resolveMask()); - // Reenable selectionChanged() for individual items + // Re-enable selectionChanged() for individual items --d->selectionChanging; if (!d->selectionChanging && d->selectedItems.size() != oldSelectedItemSize) emit selectionChanged(); @@ -2896,14 +2788,14 @@ QGraphicsSimpleTextItem *QGraphicsScene::addSimpleText(const QString &text, cons Note that widgets with the Qt::WA_PaintOnScreen widget attribute set and widgets that wrap an external application or controller - are not supported. Examples are QGLWidget and QAxWidget. + are not supported. Examples are QOpenGLWidget and QAxWidget. \sa addEllipse(), addLine(), addPixmap(), addPixmap(), addRect(), addText(), addSimpleText(), addItem() */ QGraphicsProxyWidget *QGraphicsScene::addWidget(QWidget *widget, Qt::WindowFlags wFlags) { - QGraphicsProxyWidget *proxy = new QGraphicsProxyWidget(0, wFlags); + QGraphicsProxyWidget *proxy = new QGraphicsProxyWidget(nullptr, wFlags); proxy->setWidget(widget); addItem(proxy); return proxy; @@ -2936,7 +2828,7 @@ void QGraphicsScene::removeItem(QGraphicsItem *item) const QVariant newSceneVariant(item->itemChange(QGraphicsItem::ItemSceneChange, QVariant::fromValue<QGraphicsScene *>(0))); QGraphicsScene *targetScene = qvariant_cast<QGraphicsScene *>(newSceneVariant); - if (targetScene != 0 && targetScene != this) { + if (targetScene != nullptr && targetScene != this) { targetScene->addItem(item); return; } @@ -2993,7 +2885,7 @@ void QGraphicsScene::setFocusItem(QGraphicsItem *item, Qt::FocusReason focusReas /*! Returns \c true if the scene has focus; otherwise returns \c false. If the scene - has focus, it will will forward key events from QKeyEvent to any item that + has focus, it will forward key events from QKeyEvent to any item that has focus. \sa setFocus(), setFocusItem() @@ -3038,7 +2930,7 @@ void QGraphicsScene::clearFocus() if (d->hasFocus) { d->hasFocus = false; d->passiveFocusItem = d->focusItem; - setFocusItem(0, Qt::OtherFocusReason); + setFocusItem(nullptr, Qt::OtherFocusReason); } } @@ -3124,7 +3016,7 @@ void QGraphicsScene::setBackgroundBrush(const QBrush &brush) { Q_D(QGraphicsScene); d->backgroundBrush = brush; - foreach (QGraphicsView *view, d->views) { + for (QGraphicsView *view : std::as_const(d->views)) { view->resetCachedContent(); view->viewport()->update(); } @@ -3182,13 +3074,13 @@ QVariant QGraphicsScene::inputMethodQuery(Qt::InputMethodQuery query) const return QVariant(); const QTransform matrix = d->focusItem->sceneTransform(); QVariant value = d->focusItem->inputMethodQuery(query); - if (value.type() == QVariant::RectF) + if (value.userType() == QMetaType::QRectF) value = matrix.mapRect(value.toRectF()); - else if (value.type() == QVariant::PointF) + else if (value.userType() == QMetaType::QPointF) value = matrix.map(value.toPointF()); - else if (value.type() == QVariant::Rect) + else if (value.userType() == QMetaType::QRect) value = matrix.mapRect(value.toRect()); - else if (value.type() == QVariant::Point) + else if (value.userType() == QMetaType::QPoint) value = matrix.map(value.toPoint()); return value; } @@ -3213,14 +3105,13 @@ void QGraphicsScene::update(const QRectF &rect) d->updatedRects.clear(); if (directUpdates) { // Update all views. - for (int i = 0; i < d->views.size(); ++i) - d->views.at(i)->d_func()->fullUpdatePending = true; + for (auto view : std::as_const(d->views)) + view->d_func()->fullUpdatePending = true; } } else { if (directUpdates) { // Update all views. - for (int i = 0; i < d->views.size(); ++i) { - QGraphicsView *view = d->views.at(i); + for (auto view : std::as_const(d->views)) { if (view->isTransformed()) view->d_func()->updateRectF(view->viewportTransform().mapRect(rect)); else @@ -3361,6 +3252,7 @@ bool QGraphicsScene::event(QEvent *event) // ### 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(); + break; default: break; } @@ -3449,9 +3341,15 @@ bool QGraphicsScene::event(QEvent *event) break; } case QEvent::Leave: - // hackieshly unpacking the viewport pointer from the leave event. - d->leaveScene(reinterpret_cast<QWidget *>(event->d)); + Q_ASSERT_X(false, "QGraphicsScene::event", + "QGraphicsScene must not receive QEvent::Leave, use GraphicsSceneLeave"); break; + case QEvent::GraphicsSceneLeave: + { + auto *leaveEvent = static_cast<QGraphicsSceneEvent*>(event); + d->leaveScene(leaveEvent->widget()); + break; + } case QEvent::GraphicsSceneHelp: helpEvent(static_cast<QGraphicsSceneHelpEvent *>(event)); break; @@ -3484,7 +3382,7 @@ bool QGraphicsScene::event(QEvent *event) // Deactivate the active panel (but keep it so we can // reactivate it later). QGraphicsItem *lastActivePanel = d->activePanel; - d->setActivePanelHelper(0, true); + d->setActivePanelHelper(nullptr, true); d->lastActivePanel = lastActivePanel; } else { // Activate all toplevel items. @@ -3613,7 +3511,7 @@ void QGraphicsScene::contextMenuEvent(QGraphicsSceneContextMenuEvent *contextMen void QGraphicsScene::dragEnterEvent(QGraphicsSceneDragDropEvent *event) { Q_D(QGraphicsScene); - d->dragDropItem = 0; + d->dragDropItem = nullptr; d->lastDropAction = Qt::IgnoreAction; event->accept(); } @@ -3697,7 +3595,7 @@ void QGraphicsScene::dragMoveEvent(QGraphicsSceneDragDropEvent *event) QGraphicsSceneDragDropEvent dragLeave(QEvent::GraphicsSceneDragLeave); d->cloneDragDropEvent(&dragLeave, event); d->sendDragDropEvent(d->dragDropItem, &dragLeave); - d->dragDropItem = 0; + d->dragDropItem = nullptr; } // Propagate event->setDropAction(Qt::IgnoreAction); @@ -3717,7 +3615,7 @@ void QGraphicsScene::dragLeaveEvent(QGraphicsSceneDragDropEvent *event) if (d->dragDropItem) { // Leave the last drag drop item d->sendDragDropEvent(d->dragDropItem, event); - d->dragDropItem = 0; + d->dragDropItem = nullptr; } } @@ -3735,7 +3633,7 @@ void QGraphicsScene::dropEvent(QGraphicsSceneDragDropEvent *event) if (d->dragDropItem) { // Drop on the last drag drop item d->sendDragDropEvent(d->dragDropItem, event); - d->dragDropItem = 0; + d->dragDropItem = nullptr; } } @@ -3785,7 +3683,7 @@ void QGraphicsScene::focusOutEvent(QFocusEvent *focusEvent) Q_D(QGraphicsScene); d->hasFocus = false; d->passiveFocusItem = d->focusItem; - setFocusItem(0, focusEvent->reason()); + setFocusItem(nullptr, focusEvent->reason()); // Remove all popups when the scene loses focus. if (!d->popupWidgets.isEmpty()) @@ -3809,25 +3707,24 @@ void QGraphicsScene::focusOutEvent(QFocusEvent *focusEvent) */ void QGraphicsScene::helpEvent(QGraphicsSceneHelpEvent *helpEvent) { -#ifdef QT_NO_TOOLTIP +#if !QT_CONFIG(tooltip) Q_UNUSED(helpEvent); #else // Find the first item that does tooltips Q_D(QGraphicsScene); - QList<QGraphicsItem *> itemsAtPos = d->itemsAtPosition(helpEvent->screenPos(), - helpEvent->scenePos(), - helpEvent->widget()); - QGraphicsItem *toolTipItem = 0; - for (int i = 0; i < itemsAtPos.size(); ++i) { - QGraphicsItem *tmp = itemsAtPos.at(i); - if (tmp->d_func()->isProxyWidget()) { + const QList<QGraphicsItem *> itemsAtPos = d->itemsAtPosition(helpEvent->screenPos(), + helpEvent->scenePos(), + helpEvent->widget()); + QGraphicsItem *toolTipItem = nullptr; + for (auto item : itemsAtPos) { + if (item->d_func()->isProxyWidget()) { // if the item is a proxy widget, the event is forwarded to it - sendEvent(tmp, helpEvent); + sendEvent(item, helpEvent); if (helpEvent->isAccepted()) return; } - if (!tmp->toolTip().isEmpty()) { - toolTipItem = tmp; + if (!item->toolTip().isEmpty()) { + toolTipItem = item; break; } } @@ -3875,9 +3772,8 @@ bool QGraphicsScenePrivate::dispatchHoverEvent(QGraphicsSceneHoverEvent *hoverEv hoverEvent->widget()); } - QGraphicsItem *item = 0; - for (int i = 0; i < cachedItemsUnderMouse.size(); ++i) { - QGraphicsItem *tmp = cachedItemsUnderMouse.at(i); + QGraphicsItem *item = nullptr; + for (auto tmp : std::as_const(cachedItemsUnderMouse)) { if (itemAcceptsHoverEvents_helper(tmp)) { item = tmp; break; @@ -3886,13 +3782,13 @@ bool QGraphicsScenePrivate::dispatchHoverEvent(QGraphicsSceneHoverEvent *hoverEv // Find the common ancestor item for the new topmost hoverItem and the // last item in the hoverItem list. - QGraphicsItem *commonAncestorItem = (item && !hoverItems.isEmpty()) ? item->commonAncestorItem(hoverItems.constLast()) : 0; + QGraphicsItem *commonAncestorItem = (item && !hoverItems.isEmpty()) ? item->commonAncestorItem(hoverItems.constLast()) : nullptr; while (commonAncestorItem && !itemAcceptsHoverEvents_helper(commonAncestorItem)) commonAncestorItem = commonAncestorItem->parentItem(); if (commonAncestorItem && commonAncestorItem->panel() != item->panel()) { // The common ancestor isn't in the same panel as the two hovered // items. - commonAncestorItem = 0; + commonAncestorItem = nullptr; } // Check if the common ancestor item is known. @@ -3942,7 +3838,7 @@ bool QGraphicsScenePrivate::dispatchHoverEvent(QGraphicsSceneHoverEvent *hoverEv */ void QGraphicsScenePrivate::leaveScene(QWidget *viewport) { -#ifndef QT_NO_TOOLTIP +#if QT_CONFIG(tooltip) QToolTip::hideText(); #endif QGraphicsView *view = qobject_cast<QGraphicsView *>(viewport->parent()); @@ -4122,7 +4018,7 @@ void QGraphicsScene::mouseReleaseEvent(QGraphicsSceneMouseEvent *mouseEvent) if (d->lastMouseGrabberItemHasImplicitMouseGrab) d->mouseGrabberItems.constLast()->ungrabMouse(); } else { - d->lastMouseGrabberItem = 0; + d->lastMouseGrabberItem = nullptr; } // Generate a hoverevent @@ -4134,15 +4030,15 @@ void QGraphicsScene::mouseReleaseEvent(QGraphicsSceneMouseEvent *mouseEvent) /*! This event handler, for event \a mouseEvent, can be reimplemented - in a subclass to receive mouse doubleclick events for the scene. + in a subclass to receive mouse double-click events for the scene. If someone doubleclicks on the scene, the scene will first receive a mouse press event, followed by a release event (i.e., a click), - then a doubleclick event, and finally a release event. If the - doubleclick event is delivered to a different item than the one + then a double-click event, and finally a release event. If the + double-click event is delivered to a different item than the one that received the first press and release, it will be delivered as a press event. However, tripleclick events are not delivered as - doubleclick events in this case. + double-click events in this case. The default implementation is similar to mousePressEvent(). @@ -4181,7 +4077,8 @@ void QGraphicsScene::wheelEvent(QGraphicsSceneWheelEvent *wheelEvent) // Remove all popups after the one found, or all or them if no popup is under the mouse. // Then continue with the event. QList<QGraphicsWidget *>::const_iterator iter = d->popupWidgets.constEnd(); - while (--iter >= d->popupWidgets.constBegin() && !wheelCandidates.isEmpty()) { + while (iter > d->popupWidgets.constBegin() && !wheelCandidates.isEmpty()) { + --iter; if (wheelCandidates.first() == *iter || (*iter)->isAncestorOf(wheelCandidates.first())) break; d->removePopup(*iter); @@ -4222,8 +4119,12 @@ void QGraphicsScene::wheelEvent(QGraphicsSceneWheelEvent *wheelEvent) void QGraphicsScene::inputMethodEvent(QInputMethodEvent *event) { Q_D(QGraphicsScene); - if (d->focusItem && (d->focusItem->flags() & QGraphicsItem::ItemAcceptsInputMethod)) + if (d->focusItem && (d->focusItem->flags() & QGraphicsItem::ItemAcceptsInputMethod)) { d->sendEvent(d->focusItem, event); + return; + } + if (d->lastFocusItem && d->lastFocusItem != d->focusItem && (d->lastFocusItem->flags() & QGraphicsItem::ItemAcceptsInputMethod)) + d->sendEvent(d->lastFocusItem, event); } /*! @@ -4354,7 +4255,7 @@ static void _q_paintIntoCache(QPixmap *pix, QGraphicsItem *item, const QRegion & pixmapPainter.setWorldTransform(itemToPixmap, true); // Render. - _q_paintItem(item, &pixmapPainter, option, 0, false, painterStateProtection); + _q_paintItem(item, &pixmapPainter, option, nullptr, false, painterStateProtection); pixmapPainter.end(); if (!subPix.isNull()) { @@ -4495,10 +4396,9 @@ void QGraphicsScenePrivate::drawItemHelper(QGraphicsItem *item, QPainter *painte QRegion pixmapExposed; QRectF exposedRect; if (!itemCache->allExposed) { - for (int i = 0; i < itemCache->exposed.size(); ++i) { - QRectF r = itemCache->exposed.at(i); - exposedRect |= r; - pixmapExposed += itemToPixmap.mapRect(r).toAlignedRect(); + for (const auto &rect : std::as_const(itemCache->exposed)) { + exposedRect |= rect; + pixmapExposed += itemToPixmap.mapRect(rect).toAlignedRect(); } } else { exposedRect = brect; @@ -4656,9 +4556,8 @@ void QGraphicsScenePrivate::drawItemHelper(QGraphicsItem *item, QPainter *painte // Map the item's logical expose to pixmap coordinates. QRegion pixmapExposed = scrollExposure; if (!itemCache->allExposed) { - const QVector<QRectF> &exposed = itemCache->exposed; - for (int i = 0; i < exposed.size(); ++i) - pixmapExposed += itemToPixmap.mapRect(exposed.at(i)).toRect().adjusted(-1, -1, 1, 1); + for (const auto &rect : std::as_const(itemCache->exposed)) + pixmapExposed += itemToPixmap.mapRect(rect).toRect().adjusted(-1, -1, 1, 1); } // Calculate the style option's exposedRect. @@ -4666,11 +4565,10 @@ void QGraphicsScenePrivate::drawItemHelper(QGraphicsItem *item, QPainter *painte if (itemCache->allExposed) { br = item->boundingRect(); } else { - const QVector<QRectF> &exposed = itemCache->exposed; - for (int i = 0; i < exposed.size(); ++i) - br |= exposed.at(i); + for (const auto &rect : std::as_const(itemCache->exposed)) + br |= rect; QTransform pixmapToItem = itemToPixmap.inverted(); - for (const QRect &r : scrollExposure) + for (const QRect &r : std::as_const(scrollExposure)) br |= pixmapToItem.mapRect(r); } styleOptionTmp = *option; @@ -4723,8 +4621,8 @@ void QGraphicsScenePrivate::drawItems(QPainter *painter, const QTransform *const 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); + for (const auto subTree : tli) + drawSubtreeRecursive(subTree, painter, viewTransform, exposedRegion, widget); } void QGraphicsScenePrivate::drawSubtreeRecursive(QGraphicsItem *item, QPainter *painter, @@ -4748,7 +4646,7 @@ void QGraphicsScenePrivate::drawSubtreeRecursive(QGraphicsItem *item, QPainter * return; QTransform transform(Qt::Uninitialized); - QTransform *transformPtr = 0; + QTransform *transformPtr = nullptr; bool translateOnlyTransform = false; #define ENSURE_TRANSFORM_PTR \ if (!transformPtr) { \ @@ -4806,7 +4704,7 @@ void QGraphicsScenePrivate::drawSubtreeRecursive(QGraphicsItem *item, QPainter * if (itemIsTooSmallToRender || itemIsOutsideVisibleRect) { // We cannot simply use !drawItem here. If we did it is possible - // to enter the outter if statement with drawItem == false and minimumRenderSize > 0 + // to enter the outer if statement with drawItem == false and minimumRenderSize > 0 // and finally end up inside this inner if, even though none of the above two // conditions are met. In that case we should not return from this function // but call draw() instead. @@ -4858,7 +4756,7 @@ void QGraphicsScenePrivate::drawSubtreeRecursive(QGraphicsItem *item, QPainter * item->d_ptr->graphicsEffect->draw(painter); painter->setWorldTransform(restoreTransform); - sourced->info = 0; + sourced->info = nullptr; } else #endif // QT_CONFIG(graphicseffect) { @@ -4893,9 +4791,11 @@ void QGraphicsScenePrivate::draw(QGraphicsItem *item, QPainter *painter, const Q qreal opacity, const QTransform *effectTransform, bool wasDirtyParentSceneTransform, bool drawItem) { + const auto &children = item->d_ptr->children; + const bool itemIsFullyTransparent = QGraphicsItemPrivate::isOpacityNull(opacity); const bool itemClipsChildrenToShape = (item->d_ptr->flags & QGraphicsItem::ItemClipsChildrenToShape); - const bool itemHasChildren = !item->d_ptr->children.isEmpty(); + const bool itemHasChildren = !children.isEmpty(); bool setChildClip = itemClipsChildrenToShape; bool itemHasChildrenStackedBehind = false; @@ -4907,7 +4807,7 @@ void QGraphicsScenePrivate::draw(QGraphicsItem *item, QPainter *painter, const Q item->d_ptr->ensureSortedChildren(); // Items with the 'ItemStacksBehindParent' flag are put in front of the list // so all we have to do is to check the first item. - itemHasChildrenStackedBehind = (item->d_ptr->children.at(0)->d_ptr->flags + itemHasChildrenStackedBehind = (children.at(0)->d_ptr->flags & QGraphicsItem::ItemStacksBehindParent); if (itemHasChildrenStackedBehind) { @@ -4917,8 +4817,8 @@ void QGraphicsScenePrivate::draw(QGraphicsItem *item, QPainter *painter, const Q } // Draw children behind - for (i = 0; i < item->d_ptr->children.size(); ++i) { - QGraphicsItem *child = item->d_ptr->children.at(i); + for (i = 0; i < children.size(); ++i) { + QGraphicsItem *child = children.at(i); if (wasDirtyParentSceneTransform) child->d_ptr->dirtySceneTransform = 1; if (!(child->d_ptr->flags & QGraphicsItem::ItemStacksBehindParent)) @@ -4936,7 +4836,7 @@ void QGraphicsScenePrivate::draw(QGraphicsItem *item, QPainter *painter, const Q Q_ASSERT(!(item->d_ptr->flags & QGraphicsItem::ItemHasNoContents)); Q_ASSERT(transformPtr); item->d_ptr->initStyleOption(&styleOptionTmp, *transformPtr, exposedRegion - ? *exposedRegion : QRegion(), exposedRegion == 0); + ? *exposedRegion : QRegion(), exposedRegion == nullptr); const bool itemClipsToShape = item->d_ptr->flags & QGraphicsItem::ItemClipsToShape; bool restorePainterClip = false; @@ -4996,8 +4896,8 @@ void QGraphicsScenePrivate::draw(QGraphicsItem *item, QPainter *painter, const Q if (setChildClip) setClip(painter, item); - for (; i < item->d_ptr->children.size(); ++i) { - QGraphicsItem *child = item->d_ptr->children.at(i); + for (; i < children.size(); ++i) { + QGraphicsItem *child = children.at(i); if (wasDirtyParentSceneTransform) child->d_ptr->dirtySceneTransform = 1; if (itemIsFullyTransparent && !(child->d_ptr->flags & QGraphicsItem::ItemIgnoresParentOpacity)) @@ -5075,8 +4975,8 @@ void QGraphicsScenePrivate::markDirty(QGraphicsItem *item, const QRectF &rect, b return; } - for (int i = 0; i < views.size(); ++i) { - QGraphicsViewPrivate *viewPrivate = views.at(i)->d_func(); + for (auto view : std::as_const(views)) { + QGraphicsViewPrivate *viewPrivate = view->d_func(); QRect rect = item->d_ptr->paintedViewBoundingRects.value(viewPrivate->viewport); rect.translate(viewPrivate->dirtyScrollOffset); viewPrivate->updateRect(rect); @@ -5231,8 +5131,7 @@ void QGraphicsScenePrivate::processDirtyItemsRecursive(QGraphicsItem *item, bool QRectF dirtyRect; bool uninitializedDirtyRect = true; - for (int j = 0; j < views.size(); ++j) { - QGraphicsView *view = views.at(j); + for (auto view : std::as_const(views)) { QGraphicsViewPrivate *viewPrivate = view->d_func(); QRect &paintedViewBoundingRect = item->d_ptr->paintedViewBoundingRects[viewPrivate->viewport]; if (viewPrivate->fullUpdatePending @@ -5290,8 +5189,8 @@ void QGraphicsScenePrivate::processDirtyItemsRecursive(QGraphicsItem *item, bool const bool bypassUpdateClip = !itemHasContents && wasDirtyParentViewBoundingRects; if (itemClipsChildrenToShape && !bypassUpdateClip) { // Make sure child updates are clipped to the item's bounding rect. - for (int i = 0; i < views.size(); ++i) - views.at(i)->d_func()->setUpdateClip(item); + for (auto view : std::as_const(views)) + view->d_func()->setUpdateClip(item); } if (!dirtyAncestorContainsChildren) { dirtyAncestorContainsChildren = item->d_ptr->fullUpdatePending @@ -5300,8 +5199,7 @@ void QGraphicsScenePrivate::processDirtyItemsRecursive(QGraphicsItem *item, bool 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); + for (auto child : std::as_const(item->d_ptr->children)) { if (wasDirtyParentSceneTransform) child->d_ptr->dirtySceneTransform = 1; if (wasDirtyParentViewBoundingRects) @@ -5321,8 +5219,8 @@ void QGraphicsScenePrivate::processDirtyItemsRecursive(QGraphicsItem *item, bool if (itemClipsChildrenToShape) { // Reset updateClip. - for (int i = 0; i < views.size(); ++i) - views.at(i)->d_func()->setUpdateClip(0); + for (auto view : std::as_const(views)) + view->d_func()->setUpdateClip(nullptr); } } else if (wasDirtyParentSceneTransform) { item->d_ptr->invalidateChildrenSceneTransform(); @@ -5332,7 +5230,7 @@ void QGraphicsScenePrivate::processDirtyItemsRecursive(QGraphicsItem *item, bool } /*! - \obsolete + \deprecated Paints the given \a items using the provided \a painter, after the background has been drawn, and before the foreground has been @@ -5354,7 +5252,7 @@ void QGraphicsScenePrivate::processDirtyItemsRecursive(QGraphicsItem *item, bool Example: - \snippet graphicssceneadditemsnippet.cpp 0 + \snippet graphicssceneadditem/graphicssceneadditemsnippet.cpp 0 Since Qt 4.6, this function is not called anymore unless the QGraphicsView::IndirectPainting flag is given as an Optimization @@ -5378,7 +5276,7 @@ void QGraphicsScene::drawItems(QPainter *painter, // Determine view, expose and flags. QGraphicsView *view = widget ? qobject_cast<QGraphicsView *>(widget->parentWidget()) : 0; - QRegion *expose = 0; + QRegion *expose = nullptr; const quint32 oldRectAdjust = d->rectAdjust; if (view) { d->updateAll = false; @@ -5402,8 +5300,8 @@ void QGraphicsScene::drawItems(QPainter *painter, d->rectAdjust = oldRectAdjust; // Reset discovery bits. - for (int i = 0; i < topLevelItems.size(); ++i) - topLevelItems.at(i)->d_ptr->itemDiscovered = 0; + for (auto topLevelItem : std::as_const(topLevelItems)) + topLevelItem->d_ptr->itemDiscovered = 0; painter->setWorldTransform(viewTransform); painter->setOpacity(opacity); @@ -5462,7 +5360,7 @@ bool QGraphicsScene::focusNextPrevChild(bool next) } // The item must be a widget. - QGraphicsWidget *widget = 0; + QGraphicsWidget *widget = nullptr; if (!item) { widget = next ? d->tabFocusFirst : d->tabFocusFirst->d_func()->focusPrev; } else { @@ -5478,7 +5376,7 @@ bool QGraphicsScene::focusNextPrevChild(bool next) // Run around the focus chain until we find a widget that can take tab focus. do { if (widget->flags() & QGraphicsItem::ItemIsFocusable - && widget->isEnabled() && widget->isVisibleTo(0) + && widget->isEnabled() && widget->isVisibleTo(nullptr) && (widget->focusPolicy() & Qt::TabFocus) && (!item || !item->isPanel() || item->isAncestorOf(widget)) ) { @@ -5644,7 +5542,7 @@ void QGraphicsScene::setFont(const QFont &font) { Q_D(QGraphicsScene); QFont naturalFont = QApplication::font(); - naturalFont.resolve(0); + naturalFont.setResolveMask(0); QFont resolvedFont = font.resolve(naturalFont); d->setFont_helper(resolvedFont); } @@ -5681,7 +5579,7 @@ void QGraphicsScene::setPalette(const QPalette &palette) { Q_D(QGraphicsScene); QPalette naturalPalette = QGuiApplication::palette(); - naturalPalette.resolve(0); + naturalPalette.setResolveMask(0); QPalette resolvedPalette = palette.resolve(naturalPalette); d->setPalette_helper(resolvedPalette); } @@ -5763,7 +5661,7 @@ void QGraphicsScene::setActiveWindow(QGraphicsWidget *widget) } // Activate the widget's panel (all windows are panels). - QGraphicsItem *panel = widget ? widget->panel() : 0; + QGraphicsItem *panel = widget ? widget->panel() : nullptr; setActivePanel(panel); // Raise @@ -5895,9 +5793,9 @@ void QGraphicsScenePrivate::addView(QGraphicsView *view) { views << view; #ifndef QT_NO_GESTURES - const auto gestures = grabbedGestures.keys(); - for (Qt::GestureType gesture : gestures) - view->viewport()->grabGesture(gesture); + for (auto it = grabbedGestures.constBegin(); + it != grabbedGestures.constEnd(); ++it) + view->viewport()->grabGesture(it.key()); #endif } @@ -5911,14 +5809,9 @@ void QGraphicsScenePrivate::updateTouchPointsForItem(QGraphicsItem *item, QTouch const QTransform mapFromScene = item->d_ptr->genericMapFromSceneTransform(static_cast<const QWidget *>(touchEvent->target())); - for (auto &touchPoint : touchEvent->_touchPoints) { - // Deprecated TouchPoint::setRect clobbers ellipseDiameters, restore - const QSizeF ellipseDiameters = touchPoint.ellipseDiameters(); - touchPoint.setRect(mapFromScene.map(touchPoint.sceneRect()).boundingRect()); - touchPoint.setEllipseDiameters(ellipseDiameters); - touchPoint.setPos(mapFromScene.map(touchPoint.scenePos())); - touchPoint.setStartPos(mapFromScene.map(touchPoint.startScenePos())); - touchPoint.setLastPos(mapFromScene.map(touchPoint.lastScenePos())); + for (int i = 0; i < touchEvent->pointCount(); ++i) { + auto &pt = touchEvent->point(i); + QMutableEventPoint::setPosition(pt, mapFromScene.map(pt.scenePosition())); } } @@ -5926,8 +5819,8 @@ 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(); + for (const QEventPoint &touchPoint : std::as_const(sceneCurrentTouchPoints)) { + qreal distance = QLineF(scenePos, touchPoint.scenePosition()).length(); if (closestTouchPointId == -1|| distance < closestDistance) { closestTouchPointId = touchPoint.id(); closestDistance = distance; @@ -5938,16 +5831,15 @@ int QGraphicsScenePrivate::findClosestTouchPointId(const QPointF &scenePos) void QGraphicsScenePrivate::touchEventHandler(QTouchEvent *sceneTouchEvent) { - typedef QPair<Qt::TouchPointStates, QList<QTouchEvent::TouchPoint> > StatesAndTouchPoints; + typedef QPair<QEventPoint::States, QList<QEventPoint> > StatesAndTouchPoints; QHash<QGraphicsItem *, StatesAndTouchPoints> itemsNeedingEvents; - for (int i = 0; i < sceneTouchEvent->touchPoints().count(); ++i) { - const QTouchEvent::TouchPoint &touchPoint = sceneTouchEvent->touchPoints().at(i); - + const auto &touchPoints = sceneTouchEvent->points(); + for (const auto &touchPoint : touchPoints) { // update state - QGraphicsItem *item = 0; - if (touchPoint.state() == Qt::TouchPointPressed) { - if (sceneTouchEvent->device()->type() == QTouchDevice::TouchPad) { + QGraphicsItem *item = nullptr; + if (touchPoint.state() == QEventPoint::State::Pressed) { + if (sceneTouchEvent->pointingDevice()->type() == QInputDevice::DeviceType::TouchPad) { // on touch-pad devices, send all touch points to the same item item = itemForTouchPointId.isEmpty() ? 0 @@ -5956,15 +5848,15 @@ void QGraphicsScenePrivate::touchEventHandler(QTouchEvent *sceneTouchEvent) if (!item) { // determine which item this touch point will go to - cachedItemsUnderMouse = itemsAtPosition(touchPoint.screenPos().toPoint(), - touchPoint.scenePos(), + cachedItemsUnderMouse = itemsAtPosition(touchPoint.globalPosition().toPoint(), + touchPoint.scenePosition(), static_cast<QWidget *>(sceneTouchEvent->target())); item = cachedItemsUnderMouse.isEmpty() ? 0 : cachedItemsUnderMouse.constFirst(); } - if (sceneTouchEvent->device()->type() == QTouchDevice::TouchScreen) { + if (sceneTouchEvent->pointingDevice()->type() == QInputDevice::DeviceType::TouchScreen) { // on touch-screens, combine this touch point with the closest one we find - int closestTouchPointId = findClosestTouchPointId(touchPoint.scenePos()); + int closestTouchPointId = findClosestTouchPointId(touchPoint.scenePosition()); QGraphicsItem *closestItem = itemForTouchPointId.value(closestTouchPointId); if (!item || (closestItem && cachedItemsUnderMouse.contains(closestItem))) item = closestItem; @@ -5974,7 +5866,7 @@ void QGraphicsScenePrivate::touchEventHandler(QTouchEvent *sceneTouchEvent) itemForTouchPointId.insert(touchPoint.id(), item); sceneCurrentTouchPoints.insert(touchPoint.id(), touchPoint); - } else if (touchPoint.state() == Qt::TouchPointReleased) { + } else if (touchPoint.state() == QEventPoint::State::Released) { item = itemForTouchPointId.take(touchPoint.id()); if (!item) continue; @@ -5989,7 +5881,7 @@ void QGraphicsScenePrivate::touchEventHandler(QTouchEvent *sceneTouchEvent) } StatesAndTouchPoints &statesAndTouchPoints = itemsNeedingEvents[item]; - statesAndTouchPoints.first |= touchPoint.state(); + statesAndTouchPoints.first = QEventPoint::States(statesAndTouchPoints.first | touchPoint.state()); statesAndTouchPoints.second.append(touchPoint); } @@ -6009,15 +5901,15 @@ void QGraphicsScenePrivate::touchEventHandler(QTouchEvent *sceneTouchEvent) // determine event type from the state mask QEvent::Type eventType; switch (it.value().first) { - case Qt::TouchPointPressed: + case QEventPoint::State::Pressed: // all touch points have pressed state eventType = QEvent::TouchBegin; break; - case Qt::TouchPointReleased: + case QEventPoint::State::Released: // all touch points have released state eventType = QEvent::TouchEnd; break; - case Qt::TouchPointStationary: + case QEventPoint::State::Stationary: // don't send the event if nothing changed continue; default: @@ -6026,13 +5918,9 @@ void QGraphicsScenePrivate::touchEventHandler(QTouchEvent *sceneTouchEvent) break; } - QTouchEvent touchEvent(eventType); - touchEvent.setWindow(sceneTouchEvent->window()); + QMutableTouchEvent touchEvent(eventType, sceneTouchEvent->pointingDevice(), sceneTouchEvent->modifiers(), it.value().second); touchEvent.setTarget(sceneTouchEvent->target()); - touchEvent.setDevice(sceneTouchEvent->device()); touchEvent.setModifiers(sceneTouchEvent->modifiers()); - touchEvent.setTouchPointStates(it.value().first); - touchEvent.setTouchPoints(it.value().second); touchEvent.setTimestamp(sceneTouchEvent->timestamp()); switch (touchEvent.type()) { @@ -6041,12 +5929,11 @@ void QGraphicsScenePrivate::touchEventHandler(QTouchEvent *sceneTouchEvent) // 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(); + bool res = sendTouchBeginEvent(item, &touchEvent) && touchEvent.isAccepted(); 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); + const auto &unhandledTouchPoints = touchEvent.points(); + for (const auto &touchPoint : unhandledTouchPoints) { itemForTouchPointId.remove(touchPoint.id()); sceneCurrentTouchPoints.remove(touchPoint.id()); } @@ -6063,7 +5950,8 @@ void QGraphicsScenePrivate::touchEventHandler(QTouchEvent *sceneTouchEvent) break; } } - sceneTouchEvent->setAccepted(ignoreSceneTouchEvent); + // don't override the acceptance state of the individual points + sceneTouchEvent->QInputEvent::setAccepted(ignoreSceneTouchEvent); } bool QGraphicsScenePrivate::sendTouchBeginEvent(QGraphicsItem *origin, QTouchEvent *touchEvent) @@ -6072,16 +5960,16 @@ bool QGraphicsScenePrivate::sendTouchBeginEvent(QGraphicsItem *origin, QTouchEve if (focusOnTouch) { if (cachedItemsUnderMouse.isEmpty() || cachedItemsUnderMouse.constFirst() != origin) { - const QTouchEvent::TouchPoint &firstTouchPoint = touchEvent->touchPoints().first(); - cachedItemsUnderMouse = itemsAtPosition(firstTouchPoint.screenPos().toPoint(), - firstTouchPoint.scenePos(), + const QEventPoint &firstTouchPoint = touchEvent->points().first(); + cachedItemsUnderMouse = itemsAtPosition(firstTouchPoint.globalPosition().toPoint(), + firstTouchPoint.scenePosition(), static_cast<QWidget *>(touchEvent->target())); } // Set focus on the topmost enabled item that can take focus. bool setFocus = false; - foreach (QGraphicsItem *item, cachedItemsUnderMouse) { + for (QGraphicsItem *item : std::as_const(cachedItemsUnderMouse)) { if (item->isEnabled() && ((item->flags() & QGraphicsItem::ItemIsFocusable) && item->d_ptr->mouseSetsFocus)) { if (!item->isWidget() || ((QGraphicsWidget *)item)->focusPolicy() & Qt::ClickFocus) { setFocus = true; @@ -6103,51 +5991,51 @@ bool QGraphicsScenePrivate::sendTouchBeginEvent(QGraphicsItem *origin, QTouchEve // If nobody could take focus, clear it. if (!stickyFocus && !setFocus) - q->setFocusItem(0, Qt::MouseFocusReason); + q->setFocusItem(nullptr, Qt::MouseFocusReason); } bool res = false; bool eventAccepted = touchEvent->isAccepted(); - foreach (QGraphicsItem *item, cachedItemsUnderMouse) { + for (QGraphicsItem *item : std::as_const(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) { + if (itemForTouchPointId.value(touchEvent->points().first().id()) == 0) { // item was deleted - item = 0; + item = nullptr; } else { item->d_ptr->acceptedTouchBeginEvent = (res && eventAccepted); } - touchEvent->spont = false; + touchEvent->m_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); + const auto &touchPoints = touchEvent->points(); + for (const auto &touchPoint : touchPoints) itemForTouchPointId[touchPoint.id()] = item; // can be zero - } break; } if (item && item->isPanel()) break; } - touchEvent->setAccepted(eventAccepted); + // don't override the acceptance state of the touch points + touchEvent->QInputEvent::setAccepted(eventAccepted); return res; } void QGraphicsScenePrivate::enableTouchEventsOnViews() { - foreach (QGraphicsView *view, views) + for (QGraphicsView *view : std::as_const(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(); + for (auto view : std::as_const(views)) + view->d_func()->updateInputMethodSensitivity(); } void QGraphicsScenePrivate::enterModal(QGraphicsItem *panel, QGraphicsItem::PanelModality previousModality) @@ -6163,11 +6051,12 @@ void QGraphicsScenePrivate::enterModal(QGraphicsItem *panel, QGraphicsItem::Pane } 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); + { + const auto items_ = q->items(); + for (const auto &item : items_) { + if (item->isPanel() && item->isBlockedByModalPanel()) + blockedPanels.insert(item); + } } // blockedPanels contains all currently blocked panels @@ -6195,8 +6084,8 @@ void QGraphicsScenePrivate::enterModal(QGraphicsItem *panel, QGraphicsItem::Pane QEvent windowBlockedEvent(QEvent::WindowBlocked); QEvent windowUnblockedEvent(QEvent::WindowUnblocked); - for (int i = 0; i < items.count(); ++i) { - QGraphicsItem *item = items.at(i); + const auto items_ = q->items(); + for (const auto &item : items_) { if (item->isPanel()) { if (!blockedPanels.contains(item) && item->isBlockedByModalPanel()) { // send QEvent::WindowBlocked to newly blocked panels @@ -6216,20 +6105,23 @@ void QGraphicsScenePrivate::leaveModal(QGraphicsItem *panel) 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); + { + const auto items_ = q->items(); + for (const auto &item : items_) { + 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); + { + QEvent e(QEvent::WindowUnblocked); + const auto items_ = q->items(); + for (const auto &item : items_) { + if (item->isPanel() && blockedPanels.contains(item) && !item->isBlockedByModalPanel()) + sendEvent(item, &e); + } } // send GraphicsSceneHoverEnter events to newly unblocked items @@ -6251,7 +6143,7 @@ void QGraphicsScenePrivate::gestureTargetsAtHotSpots(const QSet<QGesture *> &ges if (!gesture->hasHotSpot()) continue; const Qt::GestureType gestureType = gesture->gestureType(); - QList<QGraphicsItem *> items = itemsAtPosition(QPoint(), gesture->d_func()->sceneHotSpot, 0); + const QList<QGraphicsItem *> items = itemsAtPosition(QPoint(), gesture->d_func()->sceneHotSpot, nullptr); for (int j = 0; j < items.size(); ++j) { QGraphicsItem *item = items.at(j); @@ -6323,7 +6215,7 @@ void QGraphicsScenePrivate::gestureEventHandler(QGestureEvent *event) if (!startedGestures.isEmpty()) { QSet<QGesture *> normalGestures; // that have just one target QSet<QGesture *> conflictedGestures; // that have multiple possible targets - gestureTargetsAtHotSpots(startedGestures, Qt::GestureFlag(0), &cachedItemGestures, 0, + gestureTargetsAtHotSpots(startedGestures, Qt::GestureFlag(0), &cachedItemGestures, nullptr, &normalGestures, &conflictedGestures); cachedTargetItems = cachedItemGestures.keys(); std::sort(cachedTargetItems.begin(), cachedTargetItems.end(), qt_closestItemFirst); @@ -6423,9 +6315,9 @@ void QGraphicsScenePrivate::gestureEventHandler(QGestureEvent *event) std::sort(cachedTargetItems.begin(), cachedTargetItems.end(), qt_closestItemFirst); for (int i = 0; i < cachedTargetItems.size(); ++i) { QPointer<QGraphicsObject> receiver = cachedTargetItems.at(i); - QSet<QGesture *> gestures = - undeliveredGestures & cachedItemGestures.value(receiver.data()); - gestures -= cachedAlreadyDeliveredGestures.value(receiver.data()); + const QSet<QGesture *> gestures = (undeliveredGestures + & cachedItemGestures.value(receiver.data())) + - cachedAlreadyDeliveredGestures.value(receiver.data()); if (gestures.isEmpty()) continue; @@ -6440,7 +6332,7 @@ void QGraphicsScenePrivate::gestureEventHandler(QGestureEvent *event) ev.setWidget(event->widget()); sendEvent(receiver.data(), &ev); QSet<QGesture *> ignoredGestures; - for (QGesture *g : qAsConst(gestures)) { + for (QGesture *g : gestures) { if (!ev.isAccepted() && !ev.isAccepted(g)) { // if the gesture was ignored by its target, we will update the // targetItems list with a possible target items (items that @@ -6497,7 +6389,7 @@ void QGraphicsScenePrivate::gestureEventHandler(QGestureEvent *event) } gestureTargetsAtHotSpots(ignoredGestures, Qt::ReceivePartialGestures, - &cachedItemGestures, &targetsSet, 0, 0); + &cachedItemGestures, &targetsSet, nullptr, nullptr); cachedTargetItems = targetsSet.values(); std::sort(cachedTargetItems.begin(), cachedTargetItems.end(), qt_closestItemFirst); @@ -6508,7 +6400,7 @@ void QGraphicsScenePrivate::gestureEventHandler(QGestureEvent *event) } } - foreach (QGesture *g, startedGestures) { + for (QGesture *g : std::as_const(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 @@ -6537,7 +6429,7 @@ void QGraphicsScenePrivate::cancelGesturesForChildren(QGesture *original) { Q_ASSERT(original); QGraphicsItem *originalItem = gestureTargets.value(original); - if (originalItem == 0) // we only act on accepted gestures, which implies it has a target. + if (originalItem == nullptr) // we only act on accepted gestures, which implies it has a target. return; // iterate over all active gestures and for each find the owner @@ -6560,13 +6452,13 @@ void QGraphicsScenePrivate::cancelGesturesForChildren(QGesture *original) QSet<QGesture *> almostCanceledGestures = canceledGestures; QSet<QGesture *>::Iterator setIter; while (!almostCanceledGestures.isEmpty()) { - QGraphicsObject *target = 0; + QGraphicsObject *target = nullptr; QSet<QGesture*> gestures; setIter = almostCanceledGestures.begin(); // sort per target item while (setIter != almostCanceledGestures.end()) { QGraphicsObject *item = gestureTargets.value(*setIter); - if (target == 0) + if (target == nullptr) target = item; if (target == item) { gestures << *setIter; @@ -6590,17 +6482,17 @@ void QGraphicsScenePrivate::cancelGesturesForChildren(QGesture *original) if (!g->hasHotSpot()) continue; - QList<QGraphicsItem *> items = itemsAtPosition(QPoint(), g->d_func()->sceneHotSpot, 0); - for (int j = 0; j < items.size(); ++j) { - QGraphicsObject *item = items.at(j)->toGraphicsObject(); - if (!item) + const QList<QGraphicsItem *> items = itemsAtPosition(QPoint(), g->d_func()->sceneHotSpot, nullptr); + for (const auto &item : items) { + QGraphicsObject *object = item->toGraphicsObject(); + if (!object) continue; - QGraphicsItemPrivate *d = item->QGraphicsItem::d_func(); + QGraphicsItemPrivate *d = object->QGraphicsItem::d_func(); if (d->gestureContext.contains(g->gestureType())) { QList<QGesture *> list; list << g; QGestureEvent ev(list); - sendEvent(item, &ev); + sendEvent(object, &ev); if (ev.isAccepted() || ev.isAccepted(g)) break; // successfully delivered } @@ -6621,7 +6513,7 @@ void QGraphicsScenePrivate::grabGesture(QGraphicsItem *, Qt::GestureType gesture { (void)QGestureManager::instance(); // create a gesture manager if (!grabbedGestures[gesture]++) { - foreach (QGraphicsView *view, views) + for (QGraphicsView *view : std::as_const(views)) view->viewport()->grabGesture(gesture); } } @@ -6633,7 +6525,7 @@ void QGraphicsScenePrivate::ungrabGesture(QGraphicsItem *item, Qt::GestureType g QGraphicsObject *obj = static_cast<QGraphicsObject *>(item); QGestureManager::instance()->cleanupCachedGestures(obj, gesture); if (!--grabbedGestures[gesture]) { - foreach (QGraphicsView *view, views) + for (QGraphicsView *view : std::as_const(views)) view->viewport()->ungrabGesture(gesture); } } |