QRM: set ItemIsDrag/DropEnabled flags if there are mime types

Items in a read-only models that implement support for any mime type can
be dragged. If the model is mutable, then data can also be dropped on
items. In addition, items can also be dropped into invalid indexes, i.e.
into the empty areas of a view.

Since mimeTypes() is likely to construct a QStringList on each call, and
since that list is implementation-static and never changes, cache the
value.

[ChangeLog][QtCore][QRangeModel] The flags() implementation sets the
ItemIsDragEnabled flag for all items in a model that supports mime types
(including the default mime type), and the ItemIsDropEnabled flag for
items in models that are not read-only. ItemIsDropEnabled is also set
for the invalid index to allow dropping of data into empty spaces of a
view.

Task-number: QTBUG-145800
Change-Id: I81567e4a8a11e21eedb10ec4e542369e4c220260
Reviewed-by: Artem Dyomin <artem.dyomin@qt.io>

Author: vohi

src/corelib/itemmodels/qrangemodel.cpp

@@ -40,6 +40,7 @@ class QRangeModelPrivate : QAbstractItemModelPrivate
     int m_interfaceVersion = -1;
     int m_sortRole = Qt::DisplayRole;
     std::optional<QCollator> m_sortCollator;
+    mutable std::optional<QStringList> m_mimeTypes;
     Qt::DropActions m_supportedDragActions = Qt::CopyAction;
     Qt::DropActions m_supportedDropActions = Qt::CopyAction;
 
@@ -1053,6 +1054,13 @@ int QRangeModel::columnCount(const QModelIndex &parent) const
     models operating on a range with mutable data, it also sets the flag
     that allows the item to be editable (\c ItemIsEditable).
 
+    Models that return a non-empty list of \l{mimeTypes()}{mimeTypes()} also
+    set the Qt::ItemIsDragEnabled, and - unless read-only - the
+    Qt::ItemIsDropEnabled flag.
+
+    Flat models set the Qt::ItemNeverHasChildren for all items, while
+    hierarchical models set that flag for all items in columns above 0.
+
     To customize the flags for your own data types, provide a specialization
     of RowOptions and/or ItemAccess for your row or item types.
 
@@ -1426,9 +1434,12 @@ QMimeData *QRangeModel::mimeData(const QModelIndexList &indexes) const
 QStringList QRangeModel::mimeTypes() const
 {
     Q_D(const QRangeModel);
-    if (d->m_interfaceVersion < QT_VERSION_CHECK(6, 12, 0))
-        return QAbstractItemModel::mimeTypes();
-    return d->impl->call<QRangeModelImplBase::MimeTypes>();
+    if (!d->m_mimeTypes) {
+        d->m_mimeTypes = d->m_interfaceVersion < QT_VERSION_CHECK(6, 12, 0)
+                       ? QAbstractItemModel::mimeTypes()
+                       : d->impl->call<QRangeModelImplBase::MimeTypes>();
+    }
+    return *d->m_mimeTypes;
 }
 
 /*!

src/corelib/itemmodels/qrangemodel_impl.h

@@ -1360,8 +1360,12 @@ class QRangeModelImpl
 
     Qt::ItemFlags flags(const QModelIndex &index) const
     {
-        if (!index.isValid())
-            return Qt::NoItemFlags;
+        if (!index.isValid()) {
+            if constexpr (isMutable())
+                return Qt::ItemIsDropEnabled;
+            else
+                return Qt::NoItemFlags;
+        }
 
         // try customization
         std::optional<Qt::ItemFlags> customFlags;
@@ -1384,14 +1388,24 @@ class QRangeModelImpl
         Qt::ItemFlags f = customFlags ? *customFlags : Structure::defaultFlags();
         // adjust custom flags based on what is not possible
         if constexpr (!isMutable())
-            f &= ~Qt::ItemIsEditable;
+            f &= ~(Qt::ItemIsEditable | Qt::ItemIsDropEnabled);
         if (index.column())
             f |= Qt::ItemNeverHasChildren;
         if (customFlags)
             return f;
 
         // compute flags ourselves
+        if (!this->itemModel().mimeTypes().isEmpty()) {
+            f |= Qt::ItemIsDragEnabled;
+            if constexpr (isMutable())
+                f |= Qt::ItemIsDropEnabled;
+        }
+
         if constexpr (isMutable()) {
+            // Note: Read-only items are still droppable - we can't know here
+            // whether the model will insert data as new rows or children, or if
+            // it will overwrite the data of the dropped-on item. So we allow
+            // dropping on items that are not editable.
             if constexpr (row_traits::hasMetaObject) {
                 if (index.column() < row_traits::fixed_size()) {
                     const QMetaObject mo = wrapped_row_type::staticMetaObject;
@@ -1416,7 +1430,7 @@ class QRangeModelImpl
                     });
                 } else {
                     // If there's no usable value stored in the row, then we can't
-                    // do anything with this item.
+                    // do anything with this item, except perhaps drop data into it
                     f &= ~Qt::ItemIsEditable;
                 }
             }

tests/auto/corelib/itemmodels/qrangemodel/data.h

@@ -119,7 +119,7 @@ struct QRangeModel::ItemAccess<ItemAccessType>
 {
     static Qt::ItemFlags flags(const ItemAccessType &)
     {
-        return Qt::ItemIsEditable;
+        return Qt::ItemIsEditable | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled;
     }
 
     static QVariant readRole(const ItemAccessType &item, int role)

tests/auto/corelib/itemmodels/qrangemodel/tst_qrangemodel.cpp

@@ -776,6 +776,7 @@ void tst_QRangeModel::flags()
     auto model = factory();
     QFETCH(const ChangeActions, changeActions);
 
+    const bool hasMimeTypes = !model->mimeTypes().isEmpty();
     const QModelIndex first = model->index(0, 0);
     QVERIFY(first.isValid());
     const QModelIndex last = model->index(model->rowCount() - 1, model->columnCount() - 1);
@@ -787,6 +788,9 @@ void tst_QRangeModel::flags()
              changeActions.testFlags(ChangeAction::SetData));
     if (last.column() != 0)
         QVERIFY(last.flags().testFlag(Qt::ItemNeverHasChildren));
+    QCOMPARE(first.flags().testFlag(Qt::ItemIsDragEnabled), hasMimeTypes);
+    QCOMPARE(first.flags().testFlag(Qt::ItemIsDropEnabled),
+             changeActions.testAnyFlags(ChangeAction::SetData | ChangeAction::InsertRows));
 }
 
 void tst_QRangeModel::headerData()

tests/manual/corelib/itemmodels/qrangemodel/main.cpp

@@ -61,8 +61,7 @@ struct QRangeModel::RowOptions<Gadget>
     static Qt::ItemFlags flags(const Gadget &)
     {
         return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemNeverHasChildren
-             | Qt::ItemIsEditable
-             | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled;
+             | Qt::ItemIsEditable;
     }
 
     static QVariant headerData(int section, int role)