allow selecting conflict resolutions for many conflicts

Signed-off-by: Matthieu Gallien <matthieu.gallien@nextcloud.com>

src/gui/ConflictDelegate.qml

@@ -32,6 +32,7 @@ Item {
     required property bool conflictSelected
     required property url existingPreviewUrl
     required property url conflictPreviewUrl
+    required property var model
 
     EnforcedPlainTextLabel {
         id: existingFileNameLabel
@@ -66,6 +67,10 @@ Item {
                 spacing: 0
 
                 checked: root.existingSelected
+
+                onToggled: function() {
+                    model.existingSelected = checked
+                }
             }
 
             Image {
@@ -139,6 +144,10 @@ Item {
                 spacing: 0
 
                 checked: root.conflictSelected
+
+                onToggled: function() {
+                    model.conflictSelected = checked
+                }
             }
 
             Image {

src/gui/ResolveConflictsDialog.qml

@@ -80,6 +80,11 @@ QtWindow.Window {
                 implicitWidth: 100
 
                 font.pixelSize: 15
+
+                checked: realModel.allExistingsSelected
+                onToggled: function() {
+                    realModel.selectAllExisting(checked)
+                }
             }
 
             CheckBox {
@@ -93,6 +98,11 @@ QtWindow.Window {
                 implicitWidth: 100
 
                 font.pixelSize: 15
+
+                checked: realModel.allConflictingSelected
+                onToggled: function() {
+                    realModel.selectAllConflicting(checked)
+                }
             }
         }
 

src/gui/syncconflictsmodel.cpp

@@ -82,6 +82,50 @@ QVariant SyncConflictsModel::data(const QModelIndex &index, int role) const
     return result;
 }
 
+bool SyncConflictsModel::setData(const QModelIndex &index, const QVariant &value, int role)
+{
+    auto result = false;
+
+    Q_ASSERT(checkIndex(index, CheckIndexOption::IndexIsValid | CheckIndexOption::ParentIsInvalid));
+
+    if (index.parent().isValid()) {
+        return result;
+    }
+
+    if (role >= static_cast<int>(SyncConflictRoles::ExistingFileName) && role <= static_cast<int>(SyncConflictRoles::ConflictPreviewUrl)) {
+        auto convertedRole = static_cast<SyncConflictRoles>(role);
+
+        switch(convertedRole) {
+        case SyncConflictRoles::ExistingFileName:
+            break;
+        case SyncConflictRoles::ExistingSize:
+            break;
+        case SyncConflictRoles::ConflictSize:
+            break;
+        case SyncConflictRoles::ExistingDate:
+            break;
+        case SyncConflictRoles::ConflictDate:
+            break;
+        case SyncConflictRoles::ExistingSelected:
+            setExistingSelected(value.toBool(), index, role);
+            result = true;
+            break;
+        case SyncConflictRoles::ConflictSelected:
+            setConflictingSelected(value.toBool(), index, role);
+            result = true;
+            break;
+        case SyncConflictRoles::ExistingPreviewUrl:
+            break;
+        case SyncConflictRoles::ConflictPreviewUrl:
+            break;
+        }
+
+        result = false;
+    }
+
+    return result;
+}
+
 QHash<int, QByteArray> SyncConflictsModel::roleNames() const
 {
     auto result = QAbstractListModel::roleNames();
@@ -99,11 +143,34 @@ QHash<int, QByteArray> SyncConflictsModel::roleNames() const
     return result;
 }
 
+Qt::ItemFlags SyncConflictsModel::flags(const QModelIndex &index) const
+{
+    auto result = Qt::ItemFlags{};
+
+    if (!index.parent().isValid()) {
+        result = QAbstractListModel::flags(index);
+        return result;
+    }
+
+    result = Qt::ItemIsSelectable | Qt::ItemIsEditable;
+    return result;
+}
+
 ActivityList SyncConflictsModel::conflictActivities() const
 {
     return mData;
 }
 
+bool SyncConflictsModel::allExistingsSelected() const
+{
+    return mAllExistingsSelected;
+}
+
+bool SyncConflictsModel::allConflictingSelected() const
+{
+    return mAllConflictingsSelected;
+}
+
 void SyncConflictsModel::setConflictActivities(ActivityList conflicts)
 {
     if (mData == conflicts) {
@@ -120,6 +187,40 @@ void SyncConflictsModel::setConflictActivities(ActivityList conflicts)
     endResetModel();
 }
 
+void SyncConflictsModel::selectAllExisting(bool selected)
+{
+    for (auto &singleConflict : mConflictData) {
+        singleConflict.mExistingSelected = selected;
+    }
+
+    Q_EMIT dataChanged(index(0), index(rowCount() - 1), {static_cast<int>(SyncConflictRoles::ExistingSelected)});
+
+    if (selected && !mAllExistingsSelected) {
+        mAllExistingsSelected = true;
+        Q_EMIT allExistingsSelectedChanged();
+    } else if (!selected && mAllExistingsSelected) {
+        mAllExistingsSelected = false;
+        Q_EMIT allExistingsSelectedChanged();
+    }
+}
+
+void SyncConflictsModel::selectAllConflicting(bool selected)
+{
+    for (auto &singleConflict : mConflictData) {
+        singleConflict.mConflictSelected = selected;
+    }
+
+    Q_EMIT dataChanged(index(0), index(rowCount() - 1), {static_cast<int>(SyncConflictRoles::ConflictSelected)});
+
+    if (selected && !mAllConflictingsSelected) {
+        mAllConflictingsSelected = true;
+        Q_EMIT allConflictingSelectedChanged();
+    } else if (!selected && mAllConflictingsSelected) {
+        mAllConflictingsSelected = false;
+        Q_EMIT allConflictingSelectedChanged();
+    }
+}
+
 void SyncConflictsModel::updateConflictsData()
 {
     mConflictData.clear();
@@ -165,4 +266,54 @@ void SyncConflictsModel::updateConflictsData()
     }
 }
 
+void SyncConflictsModel::setExistingSelected(bool value,
+                                             const QModelIndex &index,
+                                             int role)
+{
+    mConflictData[index.row()].mExistingSelected = value;
+    Q_EMIT dataChanged(index, index, {role});
+
+    if (!mConflictData[index.row()].mExistingSelected && mAllExistingsSelected) {
+        mAllExistingsSelected = false;
+        Q_EMIT allExistingsSelectedChanged();
+    } else if (mConflictData[index.row()].mExistingSelected && !mAllExistingsSelected) {
+        auto allSelected = true;
+        for (const auto &singleConflict : qAsConst(mConflictData)) {
+            if (!singleConflict.mExistingSelected) {
+                allSelected = false;
+                break;
+            }
+        }
+        if (allSelected) {
+            mAllExistingsSelected = true;
+            Q_EMIT allExistingsSelectedChanged();
+        }
+    }
+}
+
+void SyncConflictsModel::setConflictingSelected(bool value,
+                                                const QModelIndex &index,
+                                                int role)
+{
+    mConflictData[index.row()].mConflictSelected = value;
+    Q_EMIT dataChanged(index, index, {role});
+
+    if (!mConflictData[index.row()].mConflictSelected && mAllConflictingsSelected) {
+        mAllConflictingsSelected = false;
+        Q_EMIT allConflictingSelectedChanged();
+    } else if (mConflictData[index.row()].mConflictSelected && !mAllConflictingsSelected) {
+        auto allSelected = true;
+        for (const auto &singleConflict : qAsConst(mConflictData)) {
+            if (!singleConflict.mConflictSelected) {
+                allSelected = false;
+                break;
+            }
+        }
+        if (allSelected) {
+            mAllConflictingsSelected = true;
+            Q_EMIT allConflictingSelectedChanged();
+        }
+    }
+}
+
 }

src/gui/syncconflictsmodel.h

@@ -29,6 +29,10 @@ class SyncConflictsModel : public QAbstractListModel
 
     Q_PROPERTY(OCC::ActivityList conflictActivities READ conflictActivities WRITE setConflictActivities NOTIFY conflictActivitiesChanged)
 
+    Q_PROPERTY(bool allExistingsSelected READ allExistingsSelected NOTIFY allExistingsSelectedChanged)
+
+    Q_PROPERTY(bool allConflictingSelected READ allConflictingSelected NOTIFY allConflictingSelectedChanged)
+
     struct ConflictInfo {
         QString mExistingFileName;
         QString mExistingSize;
@@ -62,19 +66,43 @@ public:
 
     [[nodiscard]] QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
 
+    [[nodiscard]] bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole) override;
+
     [[nodiscard]] QHash<int,QByteArray> roleNames() const override;
 
+    [[nodiscard]] Qt::ItemFlags flags(const QModelIndex &index) const override;
+
     [[nodiscard]] OCC::ActivityList conflictActivities() const;
 
+    [[nodiscard]] bool allExistingsSelected() const;
+
+    [[nodiscard]] bool allConflictingSelected() const;
+
 public slots:
     void setConflictActivities(OCC::ActivityList conflicts);
 
+    void selectAllExisting(bool selected);
+
+    void selectAllConflicting(bool selected);
+
 signals:
     void conflictActivitiesChanged();
 
+    void allExistingsSelectedChanged();
+
+    void allConflictingSelectedChanged();
+
 private:
     void updateConflictsData();
 
+    void setExistingSelected(bool value,
+                             const QModelIndex &index,
+                             int role);
+
+    void setConflictingSelected(bool value,
+                                const QModelIndex &index,
+                                int role);
+
     OCC::ActivityList mData;
 
     QVector<ConflictInfo> mConflictData;
@@ -82,6 +110,10 @@ private:
     QMimeDatabase mMimeDb;
 
     QLocale mLocale;
+
+    bool mAllExistingsSelected = false;
+
+    bool mAllConflictingsSelected = false;
 };
 
 }