From be0d6aef00891286f33242073627611413ad79c4 Mon Sep 17 00:00:00 2001
From: Mikaël Capelle <capelle.mikael@gmail.com>
Date: Sat, 26 Dec 2020 20:48:38 +0100
Subject: Start working on collapsible separators.

---
 src/modlistbypriorityproxy.cpp | 214 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 214 insertions(+)
 create mode 100644 src/modlistbypriorityproxy.cpp

(limited to 'src/modlistbypriorityproxy.cpp')

diff --git a/src/modlistbypriorityproxy.cpp b/src/modlistbypriorityproxy.cpp
new file mode 100644
index 00000000..69c6ff88
--- /dev/null
+++ b/src/modlistbypriorityproxy.cpp
@@ -0,0 +1,214 @@
+#include "modlistbypriorityproxy.h"
+
+#include "modinfo.h"
+#include "modlist.h"
+
+ModListByPriorityProxy::ModListByPriorityProxy(ModList* modList, QObject* parent) :
+  QAbstractProxyModel(parent), m_ModList(modList)
+{
+  setSourceModel(modList);
+}
+
+ModListByPriorityProxy::~ModListByPriorityProxy()
+{
+}
+
+void ModListByPriorityProxy::setSourceModel(QAbstractItemModel* model)
+{
+  QAbstractProxyModel::setSourceModel(model);
+  // connect(sourceModel(), &QAbstractItemModel::layoutChanged, this, &ModListByPriorityProxy::buildTree);
+}
+
+void ModListByPriorityProxy::buildTree()
+{
+  if (!sourceModel()) return;
+
+  beginResetModel();
+
+  endResetModel();
+
+}
+
+std::vector<ModListByPriorityProxy::ModInfoWithPriority> ModListByPriorityProxy::topLevelItems() const
+{
+  std::vector<ModListByPriorityProxy::ModInfoWithPriority> items;
+  bool separator = false;
+  for (auto& [priority, index] : m_ModList->m_Profile->getAllIndexesByPriority()) {
+    ModInfo::Ptr modInfo = ModInfo::getByIndex(index);
+    if (modInfo->isSeparator()) {
+      items.emplace_back(modInfo, priority);
+      separator = true;
+    }
+    else if (modInfo->isOverwrite() || !separator) {
+      items.emplace_back(modInfo, priority);
+    }
+  }
+
+  return items;
+}
+
+std::vector<ModListByPriorityProxy::ModInfoWithPriority> ModListByPriorityProxy::childItems(int priority) const
+{
+  std::vector<ModListByPriorityProxy::ModInfoWithPriority> children;
+  for (auto& [p, index] : m_ModList->m_Profile->getAllIndexesByPriority()) {
+    if (p > priority) {
+      ModInfo::Ptr modInfo = ModInfo::getByIndex(index);
+      if (modInfo->isSeparator()) {
+        break;
+      }
+      children.emplace_back(modInfo, p);
+    }
+  }
+  return children;
+}
+
+std::optional<ModListByPriorityProxy::ModInfoWithPriority> ModListByPriorityProxy::separator(int priority) const
+{
+  // overwrites
+  if (priority == ULONG_MAX) {
+    return {};
+  }
+
+  auto& indexByPriority = m_ModList->m_Profile->getAllIndexesByPriority();
+
+  auto it = indexByPriority.find(priority);
+  if (it == std::end(indexByPriority)) {
+    return {};
+  }
+
+  {
+    ModInfo::Ptr modInfo = ModInfo::getByIndex(it->second);
+    if (modInfo->isSeparator() || modInfo->isOverwrite()) {
+      return {};
+    }
+  }
+
+  auto rit = std::reverse_iterator{ it };
+  for (; rit != std::rend(indexByPriority); ++rit) {
+    ModInfo::Ptr modInfo = ModInfo::getByIndex(rit->second);
+    if (modInfo->isSeparator()) {
+      return ModInfoWithPriority{ modInfo, rit->first };
+    }
+  }
+
+  return {};
+}
+
+QModelIndex ModListByPriorityProxy::mapFromSource(const QModelIndex& sourceIndex) const
+{
+  if (!sourceIndex.isValid()) {
+    return QModelIndex();
+  }
+
+  auto topItems = topLevelItems();
+  ModInfo::Ptr modInfo = ModInfo::getByIndex(sourceIndex.row());
+
+  for (std::size_t i = 0; i < topItems.size(); ++i) {
+    if (topItems[i].mod == modInfo) {
+      return createIndex(i, sourceIndex.column(), modInfo.get());
+    }
+  }
+
+  auto sep = separator(m_ModList->priority(modInfo->name()));
+  auto children = childItems(sep->priority);
+  for (std::size_t i = 0; i < children.size(); ++i) {
+    if (children[i].mod == modInfo) {
+      return createIndex(i, sourceIndex.column(), modInfo.get());
+    }
+  }
+
+  return QModelIndex();
+}
+
+QModelIndex ModListByPriorityProxy::mapToSource(const QModelIndex& proxyIndex) const
+{
+  if (!proxyIndex.isValid()) {
+    return QModelIndex();
+  }
+  auto topItems = topLevelItems();
+  ModInfo::Ptr modInfo;
+  if (proxyIndex.parent().isValid()) {
+    ModInfo::Ptr parentInfo = topItems[proxyIndex.parent().row()].mod;
+    modInfo = childItems(m_ModList->priority(parentInfo->name()))[proxyIndex.row()].mod;
+  }
+  else {
+    modInfo = topItems[proxyIndex.row()].mod;
+  }
+  return sourceModel()->index(ModInfo::getIndex(modInfo->name()), proxyIndex.column(), mapToSource(proxyIndex.parent()));
+}
+
+int ModListByPriorityProxy::rowCount(const QModelIndex& parent) const
+{
+  auto topItems = topLevelItems();
+  if (!parent.isValid()) {
+    return topItems.size();
+  }
+
+  ModInfo::Ptr modInfo = topItems[parent.row()].mod;
+  if (!modInfo->isSeparator()) {
+    return 0;
+  }
+
+  auto priority = m_ModList->priority(modInfo->name());
+  return childItems(priority).size();
+}
+
+int ModListByPriorityProxy::columnCount(const QModelIndex& index) const
+{
+  return sourceModel()->columnCount(mapToSource(index));
+}
+
+
+QModelIndex ModListByPriorityProxy::parent(const QModelIndex& child) const
+{
+
+  auto topItems = topLevelItems();
+  ModInfo::Ptr modInfo;
+  if (child.parent().isValid()) {
+    ModInfo::Ptr parentInfo = topItems[child.parent().row()].mod;
+    modInfo = childItems(m_ModList->priority(parentInfo->name()))[child.row()].mod;
+  }
+  else {
+    modInfo = topItems[child.row()].mod;
+  }
+
+  auto sep = separator(m_ModList->priority(modInfo->name()));
+
+  if (!sep) {
+    return QModelIndex();
+  }
+
+  for (std::size_t i = 0; i < topItems.size(); ++i) {
+    if (topItems[i].mod == sep->mod) {
+      return createIndex(i, child.column(), sep->mod.get());
+    }
+  }
+
+  return QModelIndex();
+}
+
+bool ModListByPriorityProxy::hasChildren(const QModelIndex& parent) const
+{
+  if (!parent.isValid()) {
+    return false;
+  }
+  ModInfo* modInfo = static_cast<ModInfo*>(parent.internalPointer());
+  for (auto& item : topLevelItems()) {
+    if (modInfo == item.mod) {
+      return modInfo->isSeparator() && !childItems(item.priority).empty();
+    }
+  }
+  return false;
+}
+
+QModelIndex ModListByPriorityProxy::index(int row, int column, const QModelIndex& parent) const
+{
+  auto topItems = topLevelItems();
+  if (!parent.isValid()) {
+    return createIndex(row, column, topItems[row].mod.get());
+  }
+  else {
+    auto children = childItems(topItems[parent.row()].priority);
+    return createIndex(row, column, children[row].mod.get());
+  }
+}
-- 
cgit v1.3.1


From d0512da75805be194d949a6d6bac8184314da0e6 Mon Sep 17 00:00:00 2001
From: Mikaël Capelle <capelle.mikael@gmail.com>
Date: Sun, 27 Dec 2020 14:55:20 +0100
Subject: Use an intermediate structure to store the separator tree.

---
 src/mainwindow.cpp             |  29 ++---
 src/mainwindow.h               |   2 +
 src/modinfo.h                  |  10 +-
 src/modinfoseparator.h         |   2 +-
 src/modlist.cpp                |   2 +-
 src/modlistbypriorityproxy.cpp | 236 ++++++++++++++++++++---------------------
 src/modlistbypriorityproxy.h   |  51 +++++++--
 7 files changed, 179 insertions(+), 153 deletions(-)

(limited to 'src/modlistbypriorityproxy.cpp')

diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index ddde1d9b..be879dc6 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -544,14 +544,22 @@ MainWindow::MainWindow(Settings &settings
   processUpdates();
 
   ui->statusBar->updateNormalMessage(m_OrganizerCore);
-
-  on_groupCombo_currentIndexChanged(0);
 }
 
 void MainWindow::setupModList()
 {
-  m_ModListSortProxy = m_OrganizerCore.createModListProxyModel();
+  m_ModListByPriorityProxy = new ModListByPriorityProxy(m_OrganizerCore.currentProfile(), &m_OrganizerCore);
+  connect(ui->modList, SIGNAL(expanded(QModelIndex)), m_ModListByPriorityProxy, SLOT(expanded(QModelIndex)));
+  connect(ui->modList, SIGNAL(collapsed(QModelIndex)), m_ModListByPriorityProxy, SLOT(collapsed(QModelIndex)));
+  connect(m_ModListByPriorityProxy, SIGNAL(expandItem(QModelIndex)), this, SLOT(expandModList(QModelIndex)));
+
+  m_ModListSortProxy = new ModListSortProxy(m_OrganizerCore.currentProfile(), &m_OrganizerCore);
   ui->modList->setModel(m_ModListSortProxy);
+
+  m_ModListByPriorityProxy->setSourceModel(m_OrganizerCore.modList());
+  m_ModListSortProxy->setSourceModel(m_ModListByPriorityProxy);
+  emit m_OrganizerCore.modList()->layoutChanged();
+
   ui->modList->sortByColumn(ModList::COL_PRIORITY, Qt::AscendingOrder);
 
 
@@ -1267,15 +1275,7 @@ void MainWindow::espFilterChanged(const QString &filter)
 
 void MainWindow::expandModList(const QModelIndex &index)
 {
-  QAbstractItemModel *model = ui->modList->model();
-
-  for (int i = 0; i < model->rowCount(); ++i) {
-    QModelIndex targetIdx = model->index(i, 0);
-    if (model->data(targetIdx).toString() == index.data().toString()) {
-      ui->modList->expand(targetIdx);
-      break;
-    }
-  }
+  ui->modList->expand(m_ModListSortProxy->mapFromSource(index));
 }
 
 
@@ -1679,6 +1679,7 @@ void MainWindow::activateSelectedProfile()
   m_OrganizerCore.setCurrentProfile(ui->profileBox->currentText());
 
   m_ModListSortProxy->setProfile(m_OrganizerCore.currentProfile());
+  m_ModListByPriorityProxy->setProfile(m_OrganizerCore.currentProfile());
 
   m_SavesTab->refreshSaveList();
   m_OrganizerCore.refresh();
@@ -5951,8 +5952,8 @@ void MainWindow::on_groupCombo_currentIndexChanged(int index)
     connect(ui->modList, SIGNAL(collapsed(QModelIndex)), newModel, SLOT(collapsed(QModelIndex)));
     connect(newModel, SIGNAL(expandItem(QModelIndex)), this, SLOT(expandModList(QModelIndex)));
   } else {
-    m_ModListSortProxy->setSourceModel(new ModListByPriorityProxy(m_OrganizerCore.modList(), this));
-    // m_ModListSortProxy->setSourceModel(m_OrganizerCore.modList());
+    m_ModListSortProxy->setSourceModel(m_ModListByPriorityProxy);
+    emit m_OrganizerCore.modList()->layoutChanged();
   }
   modFilterActive(m_ModListSortProxy->isFilterActive());
 }
diff --git a/src/mainwindow.h b/src/mainwindow.h
index f8910361..19a1b179 100644
--- a/src/mainwindow.h
+++ b/src/mainwindow.h
@@ -26,6 +26,7 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 #include "imoinfo.h"
 #include "iuserinterface.h"
 #include "modinfo.h"
+#include "modlistbypriorityproxy.h"
 #include "modlistsortproxy.h"
 #include "tutorialcontrol.h"
 #include "plugincontainer.h" //class PluginContainer;
@@ -297,6 +298,7 @@ private:
   QStringList m_DefaultArchives;
 
   ModListSortProxy *m_ModListSortProxy;
+  ModListByPriorityProxy *m_ModListByPriorityProxy;
 
   PluginListSortProxy *m_PluginListSortProxy;
 
diff --git a/src/modinfo.h b/src/modinfo.h
index 42abe51e..d04f6657 100644
--- a/src/modinfo.h
+++ b/src/modinfo.h
@@ -378,6 +378,11 @@ public: // IModInterface implementations / Re-declaration
    */
   virtual std::shared_ptr<const MOBase::IFileTree> fileTree() const = 0;
 
+  /**
+   * @return true if this object represents a regular mod.
+   */
+  virtual bool isRegular() const { return false; }
+
   /**
    * @return true if this object represents the overwrite mod.
    */
@@ -491,11 +496,6 @@ public: // Mutable operations:
 
 public: // Methods after this do not come from IModInterface:
 
-  /**
-   * @return true if this mod is a regular mod, false otherwise.
-   */
-  virtual bool isRegular() const { return false; }
-
   /**
    * @return true if this mod is empty, false otherwise.
    */
diff --git a/src/modinfoseparator.h b/src/modinfoseparator.h
index 88262f37..c7df7184 100644
--- a/src/modinfoseparator.h
+++ b/src/modinfoseparator.h
@@ -55,7 +55,7 @@ protected:
 private:
 
   ModInfoSeparator(
-    PluginContainer* pluginContainer, 
+    PluginContainer* pluginContainer,
     const MOBase::IPluginGame* game, const QDir& path,
     MOShared::DirectoryEntry** directoryStructure);
 };
diff --git a/src/modlist.cpp b/src/modlist.cpp
index c8056140..4191e2db 100644
--- a/src/modlist.cpp
+++ b/src/modlist.cpp
@@ -1236,8 +1236,8 @@ void ModList::removeRowForce(int row, const QModelIndex &parent)
   m_Profile->cancelModlistWrite();
   beginRemoveRows(parent, row, row);
   ModInfo::removeMod(row);
-  endRemoveRows();
   m_Profile->refreshModStatus();  // removes the mod from the status list
+  endRemoveRows();
   m_Profile->writeModlist(); // this ensures the modified list gets written back before new mods can be installed
 
   notifyModRemoved(modInfo->name());
diff --git a/src/modlistbypriorityproxy.cpp b/src/modlistbypriorityproxy.cpp
index 69c6ff88..77b7262a 100644
--- a/src/modlistbypriorityproxy.cpp
+++ b/src/modlistbypriorityproxy.cpp
@@ -1,12 +1,13 @@
 #include "modlistbypriorityproxy.h"
 
 #include "modinfo.h"
+#include "profile.h"
 #include "modlist.h"
+#include "log.h"
 
-ModListByPriorityProxy::ModListByPriorityProxy(ModList* modList, QObject* parent) :
-  QAbstractProxyModel(parent), m_ModList(modList)
+ModListByPriorityProxy::ModListByPriorityProxy(Profile* profile, QObject* parent) :
+  QAbstractProxyModel(parent), m_Profile(profile)
 {
-  setSourceModel(modList);
 }
 
 ModListByPriorityProxy::~ModListByPriorityProxy()
@@ -16,7 +17,14 @@ ModListByPriorityProxy::~ModListByPriorityProxy()
 void ModListByPriorityProxy::setSourceModel(QAbstractItemModel* model)
 {
   QAbstractProxyModel::setSourceModel(model);
-  // connect(sourceModel(), &QAbstractItemModel::layoutChanged, this, &ModListByPriorityProxy::buildTree);
+
+  if (sourceModel()) {
+    m_CollapsedItems.clear();
+    connect(sourceModel(), &QAbstractItemModel::layoutChanged, this, &ModListByPriorityProxy::buildTree, Qt::UniqueConnection);
+    connect(sourceModel(), &QAbstractItemModel::rowsRemoved, this, [this]() { buildTree(); }, Qt::UniqueConnection);
+    connect(sourceModel(), &QAbstractItemModel::modelReset, this, &ModListByPriorityProxy::buildTree, Qt::UniqueConnection);
+    buildTree();
+  }
 }
 
 void ModListByPriorityProxy::buildTree()
@@ -25,73 +33,48 @@ void ModListByPriorityProxy::buildTree()
 
   beginResetModel();
 
-  endResetModel();
-
-}
+  // reset the root
+  m_Root = { };
+  m_IndexToItem.clear();
 
-std::vector<ModListByPriorityProxy::ModInfoWithPriority> ModListByPriorityProxy::topLevelItems() const
-{
-  std::vector<ModListByPriorityProxy::ModInfoWithPriority> items;
-  bool separator = false;
-  for (auto& [priority, index] : m_ModList->m_Profile->getAllIndexesByPriority()) {
+  TreeItem* root = &m_Root;
+  for (auto& [priority, index] : m_Profile->getAllIndexesByPriority()) {
     ModInfo::Ptr modInfo = ModInfo::getByIndex(index);
+
+    TreeItem* item;
+
     if (modInfo->isSeparator()) {
-      items.emplace_back(modInfo, priority);
-      separator = true;
+      m_Root.children.push_back(std::make_unique<TreeItem>(modInfo, index, &m_Root));
+      item = m_Root.children.back().get();
+      root = item;
     }
-    else if (modInfo->isOverwrite() || !separator) {
-      items.emplace_back(modInfo, priority);
+    else if (modInfo->isOverwrite()) {
+      m_Root.children.push_back(std::make_unique<TreeItem>(modInfo, index, &m_Root));
+      item = m_Root.children.back().get();
     }
-  }
-
-  return items;
-}
-
-std::vector<ModListByPriorityProxy::ModInfoWithPriority> ModListByPriorityProxy::childItems(int priority) const
-{
-  std::vector<ModListByPriorityProxy::ModInfoWithPriority> children;
-  for (auto& [p, index] : m_ModList->m_Profile->getAllIndexesByPriority()) {
-    if (p > priority) {
-      ModInfo::Ptr modInfo = ModInfo::getByIndex(index);
-      if (modInfo->isSeparator()) {
-        break;
-      }
-      children.emplace_back(modInfo, p);
+    else {
+      root->children.push_back(std::make_unique<TreeItem>(modInfo, index, root));
+      item = root->children.back().get();
     }
-  }
-  return children;
-}
+    m_IndexToItem[index] = item;
 
-std::optional<ModListByPriorityProxy::ModInfoWithPriority> ModListByPriorityProxy::separator(int priority) const
-{
-  // overwrites
-  if (priority == ULONG_MAX) {
-    return {};
   }
 
-  auto& indexByPriority = m_ModList->m_Profile->getAllIndexesByPriority();
-
-  auto it = indexByPriority.find(priority);
-  if (it == std::end(indexByPriority)) {
-    return {};
-  }
+  endResetModel();
 
-  {
-    ModInfo::Ptr modInfo = ModInfo::getByIndex(it->second);
-    if (modInfo->isSeparator() || modInfo->isOverwrite()) {
-      return {};
-    }
-  }
+  // restore expand-state
+  expandItems(QModelIndex());
+}
 
-  auto rit = std::reverse_iterator{ it };
-  for (; rit != std::rend(indexByPriority); ++rit) {
-    ModInfo::Ptr modInfo = ModInfo::getByIndex(rit->second);
-    if (modInfo->isSeparator()) {
-      return ModInfoWithPriority{ modInfo, rit->first };
+void ModListByPriorityProxy::expandItems(const QModelIndex& index)
+{
+  for (int row = 0; row < rowCount(index); row++) {
+    QModelIndex idx = this->index(row, 0, QModelIndex());
+    if (!m_CollapsedItems.contains(idx.data(Qt::DisplayRole).toString())) {
+      emit expandItem(idx);
     }
+    expandItems(idx);
   }
-
-  return {};
 }
 
 QModelIndex ModListByPriorityProxy::mapFromSource(const QModelIndex& sourceIndex) const
@@ -100,24 +83,8 @@ QModelIndex ModListByPriorityProxy::mapFromSource(const QModelIndex& sourceIndex
     return QModelIndex();
   }
 
-  auto topItems = topLevelItems();
-  ModInfo::Ptr modInfo = ModInfo::getByIndex(sourceIndex.row());
-
-  for (std::size_t i = 0; i < topItems.size(); ++i) {
-    if (topItems[i].mod == modInfo) {
-      return createIndex(i, sourceIndex.column(), modInfo.get());
-    }
-  }
-
-  auto sep = separator(m_ModList->priority(modInfo->name()));
-  auto children = childItems(sep->priority);
-  for (std::size_t i = 0; i < children.size(); ++i) {
-    if (children[i].mod == modInfo) {
-      return createIndex(i, sourceIndex.column(), modInfo.get());
-    }
-  }
-
-  return QModelIndex();
+  auto* item = m_IndexToItem.at(sourceIndex.row());
+  return createIndex(item->parent->childIndex(item), sourceIndex.column(), item);
 }
 
 QModelIndex ModListByPriorityProxy::mapToSource(const QModelIndex& proxyIndex) const
@@ -125,32 +92,23 @@ QModelIndex ModListByPriorityProxy::mapToSource(const QModelIndex& proxyIndex) c
   if (!proxyIndex.isValid()) {
     return QModelIndex();
   }
-  auto topItems = topLevelItems();
-  ModInfo::Ptr modInfo;
-  if (proxyIndex.parent().isValid()) {
-    ModInfo::Ptr parentInfo = topItems[proxyIndex.parent().row()].mod;
-    modInfo = childItems(m_ModList->priority(parentInfo->name()))[proxyIndex.row()].mod;
-  }
-  else {
-    modInfo = topItems[proxyIndex.row()].mod;
-  }
-  return sourceModel()->index(ModInfo::getIndex(modInfo->name()), proxyIndex.column(), mapToSource(proxyIndex.parent()));
+  auto* item = static_cast<TreeItem*>(proxyIndex.internalPointer());
+  return sourceModel()->index(item->index, proxyIndex.column());
 }
 
 int ModListByPriorityProxy::rowCount(const QModelIndex& parent) const
 {
-  auto topItems = topLevelItems();
   if (!parent.isValid()) {
-    return topItems.size();
+    return m_Root.children.size();
   }
 
-  ModInfo::Ptr modInfo = topItems[parent.row()].mod;
-  if (!modInfo->isSeparator()) {
-    return 0;
+  auto* item = static_cast<TreeItem*>(parent.internalPointer());
+
+  if (item->mod->isSeparator()) {
+    return item->children.size();
   }
 
-  auto priority = m_ModList->priority(modInfo->name());
-  return childItems(priority).size();
+  return 0;
 }
 
 int ModListByPriorityProxy::columnCount(const QModelIndex& index) const
@@ -161,54 +119,90 @@ int ModListByPriorityProxy::columnCount(const QModelIndex& index) const
 
 QModelIndex ModListByPriorityProxy::parent(const QModelIndex& child) const
 {
-
-  auto topItems = topLevelItems();
-  ModInfo::Ptr modInfo;
-  if (child.parent().isValid()) {
-    ModInfo::Ptr parentInfo = topItems[child.parent().row()].mod;
-    modInfo = childItems(m_ModList->priority(parentInfo->name()))[child.row()].mod;
-  }
-  else {
-    modInfo = topItems[child.row()].mod;
+  if (!child.isValid()) {
+    return QModelIndex();
   }
 
-  auto sep = separator(m_ModList->priority(modInfo->name()));
+  auto* item = static_cast<TreeItem*>(child.internalPointer());
 
-  if (!sep) {
+  if (!item->parent || item->parent == &m_Root) {
     return QModelIndex();
   }
 
-  for (std::size_t i = 0; i < topItems.size(); ++i) {
-    if (topItems[i].mod == sep->mod) {
-      return createIndex(i, child.column(), sep->mod.get());
-    }
-  }
-
-  return QModelIndex();
+  return createIndex(item->parent->parent->childIndex(item->parent), 0, item->parent);
 }
 
 bool ModListByPriorityProxy::hasChildren(const QModelIndex& parent) const
 {
   if (!parent.isValid()) {
-    return false;
+    return m_Root.children.size() > 0;
   }
-  ModInfo* modInfo = static_cast<ModInfo*>(parent.internalPointer());
-  for (auto& item : topLevelItems()) {
-    if (modInfo == item.mod) {
-      return modInfo->isSeparator() && !childItems(item.priority).empty();
+  auto* item = static_cast<TreeItem*>(parent.internalPointer());
+  return item->children.size() > 0;
+}
+
+bool ModListByPriorityProxy::setData(const QModelIndex& index, const QVariant& value, int role)
+{
+  // only care about the "name" column
+  if (index.column() == 0 && role == Qt::EditRole) {
+    QString oldValue = data(index, role).toString();
+    if (m_CollapsedItems.contains(oldValue)) {
+      m_CollapsedItems.erase(oldValue);
+      m_CollapsedItems.insert(value.toString());
     }
   }
-  return false;
+  return QAbstractProxyModel::setData(index, value, role);
+}
+
+
+Qt::ItemFlags ModListByPriorityProxy::flags(const QModelIndex& idx) const
+{
+  if (!idx.isValid()) {
+    return sourceModel()->flags(QModelIndex());
+  }
+
+  // we check the flags of the root node and if drop is not enabled, it
+  // means we are dragging files.
+  Qt::ItemFlags rootFlags = sourceModel()->flags(QModelIndex());
+  if (!rootFlags.testFlag(Qt::ItemIsDropEnabled)) {
+    return sourceModel()->flags(mapToSource(idx));
+  }
+
+  auto flags = sourceModel()->flags(mapToSource(idx));
+  auto* item = static_cast<TreeItem*>(idx.internalPointer());
+
+  if (item->mod->isSeparator()) {
+    flags |= Qt::ItemIsDropEnabled;
+  }
+
+  return flags;
 }
 
 QModelIndex ModListByPriorityProxy::index(int row, int column, const QModelIndex& parent) const
 {
-  auto topItems = topLevelItems();
+  if (!hasIndex(row, column, parent)) {
+    return QModelIndex();
+  }
+
+  const TreeItem* parentItem;
   if (!parent.isValid()) {
-    return createIndex(row, column, topItems[row].mod.get());
+    parentItem = &m_Root;
   }
   else {
-    auto children = childItems(topItems[parent.row()].priority);
-    return createIndex(row, column, children[row].mod.get());
+    parentItem = static_cast<TreeItem*>(parent.internalPointer());
+  }
+  return createIndex(row, column, parentItem->children[row].get());
+}
+
+void ModListByPriorityProxy::expanded(const QModelIndex& index)
+{
+  auto it = m_CollapsedItems.find(index.data(Qt::DisplayRole).toString());
+  if (it != m_CollapsedItems.end()) {
+    m_CollapsedItems.erase(it);
   }
 }
+
+void ModListByPriorityProxy::collapsed(const QModelIndex& index)
+{
+  m_CollapsedItems.insert(index.data(Qt::DisplayRole).toString());
+}
diff --git a/src/modlistbypriorityproxy.h b/src/modlistbypriorityproxy.h
index 6ec04b9b..d5f59f4c 100644
--- a/src/modlistbypriorityproxy.h
+++ b/src/modlistbypriorityproxy.h
@@ -2,6 +2,7 @@
 #define MODLISBYPRIORITYPROXY_H
 
 #include <optional>
+#include <set>
 #include <vector>
 
 #include <QAbstractProxyModel>
@@ -14,43 +15,71 @@
 #include "modinfo.h"
 
 class ModList;
+class Profile;
 
 class ModListByPriorityProxy : public QAbstractProxyModel
 {
   Q_OBJECT
 
 public:
-  explicit ModListByPriorityProxy(ModList* modList, QObject* parent = nullptr);
+  explicit ModListByPriorityProxy(Profile* profile, QObject* parent = nullptr);
   ~ModListByPriorityProxy();
 
+  void setProfile(Profile* profile) { m_Profile = profile; }
+
   void setSourceModel(QAbstractItemModel* sourceModel) override;
 
   int rowCount(const QModelIndex& parent = QModelIndex()) const override;
   QModelIndex parent(const QModelIndex& child) const override;
+  Qt::ItemFlags flags(const QModelIndex& idx) const override;
   QModelIndex index(int row, int column, const QModelIndex& parent = QModelIndex()) const override;
   int columnCount(const QModelIndex& index) const override;
   bool hasChildren(const QModelIndex& parent) const override;
 
+  bool setData(const QModelIndex& index, const QVariant& value, int role) override;
+
   QModelIndex mapFromSource(const QModelIndex& sourceIndex) const override;
   QModelIndex mapToSource(const QModelIndex& proxyIndex) const override;
 
+signals:
+  void expandItem(const QModelIndex& index);
+
+public slots:
+
+  void expanded(const QModelIndex& index);
+  void collapsed(const QModelIndex& index);
+
 private:
 
   void buildTree();
-
-  struct ModInfoWithPriority {
-    const ModInfo::Ptr mod;
-    const int priority;
+  void expandItems(const QModelIndex& index);
+
+  struct TreeItem {
+    ModInfo::Ptr mod;
+    unsigned int index;
+    std::vector<std::unique_ptr<TreeItem>> children;
+    TreeItem* parent;
+
+    std::size_t childIndex(TreeItem* child) const {
+      for (std::size_t i = 0; i < children.size(); ++i) {
+        if (children[i].get() == child) {
+          return i;
+        }
+      }
+      return -1;
+    }
+
+    TreeItem() : TreeItem(nullptr, -1) { }
+    TreeItem(ModInfo::Ptr mod, unsigned int index, TreeItem* parent = nullptr) :
+      mod(mod), index(index), parent(parent) { }
   };
 
-  std::vector<ModInfoWithPriority> topLevelItems() const;
-  std::vector<ModInfoWithPriority> childItems(int priority) const;
-  std::optional<ModInfoWithPriority> separator(int priority) const;
+  TreeItem m_Root;
+  std::map<unsigned int, TreeItem*> m_IndexToItem;
+  std::set<QString> m_CollapsedItems;
 
 private:
-
-  ModList* m_ModList;
-
+  Profile* m_Profile;
 };
 
 #endif //GROUPINGPROXY_H
-- 
cgit v1.3.1


From d4e05894704544a37414a4cfafbb2613a6f570c1 Mon Sep 17 00:00:00 2001
From: Mikaël Capelle <capelle.mikael@gmail.com>
Date: Sun, 27 Dec 2020 17:10:43 +0100
Subject: Fix drag and drop of regular mods.

---
 src/modlistbypriorityproxy.cpp | 62 ++++++++++++++++++++++++++++++++++++++++--
 src/modlistbypriorityproxy.h   |  2 ++
 src/modlistsortproxy.cpp       |  5 +---
 3 files changed, 62 insertions(+), 7 deletions(-)

(limited to 'src/modlistbypriorityproxy.cpp')

diff --git a/src/modlistbypriorityproxy.cpp b/src/modlistbypriorityproxy.cpp
index 77b7262a..d69950db 100644
--- a/src/modlistbypriorityproxy.cpp
+++ b/src/modlistbypriorityproxy.cpp
@@ -38,6 +38,7 @@ void ModListByPriorityProxy::buildTree()
   m_IndexToItem.clear();
 
   TreeItem* root = &m_Root;
+  std::unique_ptr<TreeItem> overwrite;
   for (auto& [priority, index] : m_Profile->getAllIndexesByPriority()) {
     ModInfo::Ptr modInfo = ModInfo::getByIndex(index);
 
@@ -49,17 +50,20 @@ void ModListByPriorityProxy::buildTree()
       root = item;
     }
     else if (modInfo->isOverwrite()) {
-      m_Root.children.push_back(std::make_unique<TreeItem>(modInfo, index, &m_Root));
-      item = m_Root.children.back().get();
+      // do not push here, because the overwrite is usually not at the right position
+      overwrite = std::make_unique<TreeItem>(modInfo, index, &m_Root);
+      item = overwrite.get();
     }
     else {
       root->children.push_back(std::make_unique<TreeItem>(modInfo, index, root));
       item = root->children.back().get();
     }
-    m_IndexToItem[index] = item;
 
+    m_IndexToItem[index] = item;
   }
 
+  m_Root.children.push_back(std::move(overwrite));
+
   endResetModel();
 
   // restore expand-state
@@ -154,6 +158,58 @@ bool ModListByPriorityProxy::setData(const QModelIndex& index, const QVariant& v
   return QAbstractProxyModel::setData(index, value, role);
 }
 
+bool ModListByPriorityProxy::canDropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) const
+{
+  if (!parent.isValid()) {
+    // the row may be outside of the children list if we insert at the end
+    if (row >= m_Root.children.size()) {
+      return false;
+    }
+
+    if (row >= 0 && (m_Root.children[row]->mod->isSeparator() || m_Root.children[row]->mod->isOverwrite())) {
+      return false;
+    }
+  }
+
+  return QAbstractProxyModel::canDropMimeData(data, action, row, column, parent);
+}
+
+bool ModListByPriorityProxy::dropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent)
+{
+  // we need to fix the source row
+  int sourceRow = -1;
+
+  if (row >= 0) {
+    if (!parent.isValid()) {
+      if (row < m_Root.children.size()) {
+        sourceRow = m_Root.children[row]->index;
+      }
+      else {
+        sourceRow = ModInfo::getNumMods();
+      }
+    }
+    else {
+      auto* item = static_cast<TreeItem*>(parent.internalPointer());
+      QStringList what;
+      for (auto& child : item->children) {
+        what.append(QString::number(child->index));
+      }
+
+      if (row < item->children.size()) {
+        sourceRow = item->children[row]->index;
+      }
+      else if (parent.row() + 1 < m_Root.children.size()) {
+        sourceRow = m_Root.children[parent.row() + 1]->index;
+      }
+    }
+  }
+  else if (parent.isValid()) {
+    // this is a drop in a separator
+    sourceRow = m_Root.children[parent.row() + 1]->index;
+  }
+
+  return sourceModel()->dropMimeData(data, action, sourceRow, column, QModelIndex());
+}
 
 Qt::ItemFlags ModListByPriorityProxy::flags(const QModelIndex& idx) const
 {
diff --git a/src/modlistbypriorityproxy.h b/src/modlistbypriorityproxy.h
index d5f59f4c..fdf59182 100644
--- a/src/modlistbypriorityproxy.h
+++ b/src/modlistbypriorityproxy.h
@@ -37,6 +37,8 @@ public:
   bool hasChildren(const QModelIndex& parent) const override;
 
   bool setData(const QModelIndex& index, const QVariant& value, int role) override;
+  bool canDropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) const override;
+  bool dropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) override;
 
   QModelIndex mapFromSource(const QModelIndex& sourceIndex) const override;
   QModelIndex mapToSource(const QModelIndex& proxyIndex) const override;
diff --git a/src/modlistsortproxy.cpp b/src/modlistsortproxy.cpp
index f54f3b7a..e86c6f34 100644
--- a/src/modlistsortproxy.cpp
+++ b/src/modlistsortproxy.cpp
@@ -636,10 +636,7 @@ bool ModListSortProxy::dropMimeData(const QMimeData *data, Qt::DropAction action
     --row;
   }
 
-  QModelIndex proxyIndex = index(row, column, parent);
-  QModelIndex sourceIndex = mapToSource(proxyIndex);
-  return this->sourceModel()->dropMimeData(data, action, sourceIndex.row(), sourceIndex.column(),
-                                           sourceIndex.parent());
+  return QSortFilterProxyModel::dropMimeData(data, action, row, column, parent);
 }
 
 void ModListSortProxy::setSourceModel(QAbstractItemModel *sourceModel)
-- 
cgit v1.3.1


From 604da06bd82e012c4e38ac6c780505ee3de24903 Mon Sep 17 00:00:00 2001
From: Mikaël Capelle <capelle.mikael@gmail.com>
Date: Sun, 27 Dec 2020 17:22:54 +0100
Subject: Fix expansion of items when building tree.

---
 src/modlistbypriorityproxy.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/modlistbypriorityproxy.cpp')

diff --git a/src/modlistbypriorityproxy.cpp b/src/modlistbypriorityproxy.cpp
index d69950db..f07142b4 100644
--- a/src/modlistbypriorityproxy.cpp
+++ b/src/modlistbypriorityproxy.cpp
@@ -73,7 +73,7 @@ void ModListByPriorityProxy::buildTree()
 void ModListByPriorityProxy::expandItems(const QModelIndex& index)
 {
   for (int row = 0; row < rowCount(index); row++) {
-    QModelIndex idx = this->index(row, 0, QModelIndex());
+    QModelIndex idx = this->index(row, 0, index);
     if (!m_CollapsedItems.contains(idx.data(Qt::DisplayRole).toString())) {
       emit expandItem(idx);
     }
-- 
cgit v1.3.1


From 6e3476586681e9897570cf2ea1ef5ed7b701bc19 Mon Sep 17 00:00:00 2001
From: Mikaël Capelle <capelle.mikael@gmail.com>
Date: Sun, 27 Dec 2020 17:45:57 +0100
Subject: Allow drop before first separator.

---
 src/modlistbypriorityproxy.cpp | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

(limited to 'src/modlistbypriorityproxy.cpp')

diff --git a/src/modlistbypriorityproxy.cpp b/src/modlistbypriorityproxy.cpp
index f07142b4..465c6342 100644
--- a/src/modlistbypriorityproxy.cpp
+++ b/src/modlistbypriorityproxy.cpp
@@ -160,14 +160,17 @@ bool ModListByPriorityProxy::setData(const QModelIndex& index, const QVariant& v
 
 bool ModListByPriorityProxy::canDropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) const
 {
-  if (!parent.isValid()) {
+  if (!parent.isValid() && row >= 0) {
+
     // the row may be outside of the children list if we insert at the end
     if (row >= m_Root.children.size()) {
       return false;
     }
 
-    if (row >= 0 && (m_Root.children[row]->mod->isSeparator() || m_Root.children[row]->mod->isOverwrite())) {
-      return false;
+    if (row > 0 && m_Root.children[row - 1]->mod->isSeparator()) {
+      if (m_Root.children[row]->mod->isSeparator() || m_Root.children[row]->mod->isOverwrite()) {
+        return false;
+      }
     }
   }
 
-- 
cgit v1.3.1


From 6444dd7f5c3596181a50fb408c012e3ed71fc283 Mon Sep 17 00:00:00 2001
From: Mikaël Capelle <capelle.mikael@gmail.com>
Date: Sun, 27 Dec 2020 18:22:36 +0100
Subject: Fix drag-and-drop of separators.

---
 src/modlistbypriorityproxy.cpp | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

(limited to 'src/modlistbypriorityproxy.cpp')

diff --git a/src/modlistbypriorityproxy.cpp b/src/modlistbypriorityproxy.cpp
index 465c6342..1bbf9459 100644
--- a/src/modlistbypriorityproxy.cpp
+++ b/src/modlistbypriorityproxy.cpp
@@ -160,6 +160,37 @@ bool ModListByPriorityProxy::setData(const QModelIndex& index, const QVariant& v
 
 bool ModListByPriorityProxy::canDropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) const
 {
+  bool firstRowSeparator = false;
+  try {
+    QByteArray encoded = data->data("application/x-qabstractitemmodeldatalist");
+    QDataStream stream(&encoded, QIODevice::ReadOnly);
+
+    int firstRowPriority = INT_MAX;
+    unsigned int firstRowIndex = -1;
+
+    while (!stream.atEnd()) {
+      int sourceRow, col;
+      QMap<int, QVariant> roleDataMap;
+      stream >> sourceRow >> col >> roleDataMap;
+      if (col == 0) {
+        if (m_Profile->getModPriority(sourceRow) < firstRowPriority) {
+          firstRowIndex = sourceRow;
+          firstRowPriority = m_Profile->getModPriority(sourceRow);
+        }
+      }
+    }
+
+    firstRowSeparator = firstRowIndex != -1 && ModInfo::getByIndex(firstRowIndex)->isSeparator();
+  }
+  catch (std::exception const&) {
+
+  }
+
+  // first row is a separator, we can drop it anywhere
+  if (firstRowSeparator) {
+    return QAbstractProxyModel::canDropMimeData(data, action, row, column, parent);
+  }
+
   if (!parent.isValid() && row >= 0) {
 
     // the row may be outside of the children list if we insert at the end
-- 
cgit v1.3.1


From addb38645b41507ae8e0536bb83d3b99d365f664 Mon Sep 17 00:00:00 2001
From: Mikaël Capelle <capelle.mikael@gmail.com>
Date: Mon, 28 Dec 2020 13:44:26 +0100
Subject: Clean drag&drop of URLs and mods/archives.

---
 src/mainwindow.cpp             |   4 -
 src/modinfo.cpp                |  15 ++--
 src/modinfo.h                  |   8 +-
 src/modlist.cpp                | 172 +++++++++++++++++++++++------------------
 src/modlist.h                  |  26 ++++---
 src/modlistbypriorityproxy.cpp |  72 +++++++----------
 src/modlistbypriorityproxy.h   |   1 -
 src/modlistview.cpp            |  38 ---------
 src/modlistview.h              |   6 --
 9 files changed, 156 insertions(+), 186 deletions(-)

(limited to 'src/modlistbypriorityproxy.cpp')

diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index ea7d5967..df571a2d 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -578,10 +578,6 @@ void MainWindow::setupModList()
 
   ui->modList->sortByColumn(ModList::COL_PRIORITY, Qt::AscendingOrder);
 
-  connect(
-    ui->modList, SIGNAL(dropModeUpdate(bool)),
-    m_OrganizerCore.modList(), SLOT(dropModeUpdate(bool)));
-
   connect(
     ui->modList->header(), SIGNAL(sortIndicatorChanged(int,Qt::SortOrder)),
     this, SLOT(modListSortIndicatorChanged(int,Qt::SortOrder)));
diff --git a/src/modinfo.cpp b/src/modinfo.cpp
index a0382fe8..509c3837 100644
--- a/src/modinfo.cpp
+++ b/src/modinfo.cpp
@@ -47,6 +47,7 @@ using namespace MOShared;
 
 
 std::vector<ModInfo::Ptr> ModInfo::s_Collection;
+ModInfo::Ptr ModInfo::s_Overwrite;
 std::map<QString, unsigned int> ModInfo::s_ModsByName;
 std::map<std::pair<QString, int>, std::vector<unsigned int>> ModInfo::s_ModsByModID;
 int ModInfo::s_NextID;
@@ -108,13 +109,14 @@ ModInfo::Ptr ModInfo::createFromPlugin(const QString &modName,
   return result;
 }
 
-void ModInfo::createFromOverwrite(PluginContainer *pluginContainer,
-                                  const MOBase::IPluginGame* game,
-                                  MOShared::DirectoryEntry **directoryStructure)
+ModInfo::Ptr ModInfo::createFromOverwrite(
+  PluginContainer *pluginContainer, const MOBase::IPluginGame* game,
+  MOShared::DirectoryEntry **directoryStructure)
 {
   QMutexLocker locker(&s_Mutex);
-
-  s_Collection.push_back(ModInfo::Ptr(new ModInfoOverwrite(pluginContainer, game, directoryStructure)));
+  ModInfo::Ptr overwrite = ModInfo::Ptr(new ModInfoOverwrite(pluginContainer, game, directoryStructure));
+  s_Collection.push_back(overwrite);
+  return overwrite;
 }
 
 unsigned int ModInfo::getNumMods()
@@ -237,6 +239,7 @@ void ModInfo::updateFromDisc(const QString &modDirectory,
   QMutexLocker lock(&s_Mutex);
   s_Collection.clear();
   s_NextID = 0;
+  s_Overwrite = nullptr;
 
   { // list all directories in the mod directory and make a mod out of each
     QDir mods(QDir::fromNativeSeparators(modDirectory));
@@ -263,7 +266,7 @@ void ModInfo::updateFromDisc(const QString &modDirectory,
     }
   }
 
-  createFromOverwrite(pluginContainer, game, directoryStructure);
+  s_Overwrite = createFromOverwrite(pluginContainer, game, directoryStructure);
 
   std::sort(s_Collection.begin(), s_Collection.end(), ModInfo::ByName);
 
diff --git a/src/modinfo.h b/src/modinfo.h
index d04f6657..3981be18 100644
--- a/src/modinfo.h
+++ b/src/modinfo.h
@@ -177,6 +177,11 @@ public: // Static functions:
    */
   static unsigned int getIndex(const QString &name);
 
+  /**
+   * @brief Retrieve the overwrite mod.
+   */
+  static ModInfo::Ptr getOverwrite() { return s_Overwrite; }
+
   /**
    * @brief Find the first mod that fulfills the filter function (after no particular order).
    *
@@ -981,6 +986,7 @@ protected:
 protected:
 
   static std::vector<ModInfo::Ptr> s_Collection;
+  static ModInfo::Ptr s_Overwrite;
   static std::map<QString, unsigned int> s_ModsByName;
 
   int m_PrimaryCategory;
@@ -992,7 +998,7 @@ protected:
 
 private:
 
-  static void createFromOverwrite(PluginContainer* pluginContainer,
+  static ModInfo::Ptr createFromOverwrite(PluginContainer* pluginContainer,
     const MOBase::IPluginGame* game,
     MOShared::DirectoryEntry** directoryStructure);
 
diff --git a/src/modlist.cpp b/src/modlist.cpp
index ca4741e6..b79f0b0e 100644
--- a/src/modlist.cpp
+++ b/src/modlist.cpp
@@ -69,7 +69,6 @@ ModList::ModList(PluginContainer *pluginContainer, OrganizerCore *organizer)
   , m_Modified(false)
   , m_InNotifyChange(false)
   , m_FontMetrics(QFont())
-  , m_DropOnItems(false)
   , m_PluginContainer(pluginContainer)
 {
   m_LastCheck.start();
@@ -689,14 +688,10 @@ Qt::ItemFlags ModList::flags(const QModelIndex &modelIndex) const
         result |= Qt::ItemIsEditable;
       }
     }
-    if (m_DropOnItems
-        && (std::find(flags.begin(), flags.end(), ModInfo::FLAG_OVERWRITE) == flags.end())) {
-      result |= Qt::ItemIsDropEnabled;
-    }
-  } else {
-    if (!m_DropOnItems) result |= Qt::ItemIsDropEnabled;
   }
-  return result;
+
+  // drop check is handled by canDropMimeData
+  return result | Qt::ItemIsDropEnabled;
 }
 
 
@@ -1113,6 +1108,52 @@ int ModList::dropPriority(int row, const QModelIndex& parent) const
   return newPriority;
 }
 
+std::vector<int> ModList::sourceRows(const QMimeData* mimeData) const
+{
+  QByteArray encoded = mimeData->data("application/x-qabstractitemmodeldatalist");
+  QDataStream stream(&encoded, QIODevice::ReadOnly);
+  std::vector<int> sourceRows;
+
+  while (!stream.atEnd()) {
+    int sourceRow, col;
+    QMap<int, QVariant> roleDataMap;
+    stream >> sourceRow >> col >> roleDataMap;
+    if (col == 0) {
+      sourceRows.push_back(sourceRow);
+    }
+  }
+  return sourceRows;
+}
+
+std::optional<std::pair<QString, QString>> ModList::relativeUrl(const QUrl& url) const
+{
+  if (!url.isLocalFile()) {
+    return {};
+  }
+
+  QDir allModsDir(Settings::instance().paths().mods());
+  QDir overwriteDir(Settings::instance().paths().overwrite());
+
+  QFileInfo sourceInfo(url.toLocalFile());
+  QString sourceFile = sourceInfo.canonicalFilePath();
+
+  QString relativePath;
+  QString originName;
+
+  if (sourceFile.startsWith(allModsDir.canonicalPath())) {
+    QDir relativeDir(allModsDir.relativeFilePath(sourceFile));
+    QStringList splitPath = relativeDir.path().split("/");
+    originName = splitPath[0];
+    splitPath.pop_front();
+    return { { splitPath.join("/"), originName } };
+  }
+  else if (sourceFile.startsWith(overwriteDir.canonicalPath())) {
+    return { { overwriteDir.relativeFilePath(sourceFile), ModInfo::getOverwrite()->name() } };
+  }
+
+  return {};
+}
+
 bool ModList::dropURLs(const QMimeData *mimeData, int row, const QModelIndex &parent)
 {
   if (row == -1) {
@@ -1121,45 +1162,23 @@ bool ModList::dropURLs(const QMimeData *mimeData, int row, const QModelIndex &pa
   ModInfo::Ptr modInfo = ModInfo::getByIndex(row);
   QDir modDir = QDir(modInfo->absolutePath());
 
-  QDir allModsDir(Settings::instance().paths().mods());
-  QDir overwriteDir(Settings::instance().paths().overwrite());
-
   QStringList sourceList;
   QStringList targetList;
   QList<QPair<QString,QString>> relativePathList;
 
-  unsigned int overwriteIndex = ModInfo::findMod([] (ModInfo::Ptr mod) -> bool {
-    std::vector<ModInfo::EFlag> flags = mod->getFlags();
-    return std::find(flags.begin(), flags.end(), ModInfo::FLAG_OVERWRITE) != flags.end(); });
-
-  QString overwriteName = ModInfo::getByIndex(overwriteIndex)->name();
-
   for (auto url : mimeData->urls()) {
-    if (!url.isLocalFile()) {
-      log::debug("URL drop ignored: \"{}\" is not a local file", url.url());
+    auto p = relativeUrl(url);
+
+    if (!p) {
+      log::debug("URL drop ignored: \"{}\" is not a local file or not a known file to MO", url.url());
       continue;
     }
 
+    auto [relativePath, originName] = *p;
+
     QFileInfo sourceInfo(url.toLocalFile());
     QString sourceFile = sourceInfo.canonicalFilePath();
 
-    QString relativePath;
-    QString originName;
-
-    if (sourceFile.startsWith(allModsDir.canonicalPath())) {
-      QDir relativeDir(allModsDir.relativeFilePath(sourceFile));
-      QStringList splitPath = relativeDir.path().split("/");
-      originName = splitPath[0];
-      splitPath.pop_front();
-      relativePath = splitPath.join("/");
-    } else if (sourceFile.startsWith(overwriteDir.canonicalPath())) {
-      originName = overwriteName;
-      relativePath = overwriteDir.relativeFilePath(sourceFile);
-    } else {
-      log::debug("URL drop ignored: \"{}\" is not a known file to MO", sourceFile);
-      continue;
-    }
-
     QFileInfo targetInfo(modDir.absoluteFilePath(relativePath));
     sourceList << sourceFile;
     targetList << targetInfo.absoluteFilePath();
@@ -1186,24 +1205,13 @@ bool ModList::dropURLs(const QMimeData *mimeData, int row, const QModelIndex &pa
 
 bool ModList::dropMod(const QMimeData *mimeData, int row, const QModelIndex &parent)
 {
-  try {
-    QByteArray encoded = mimeData->data("application/x-qabstractitemmodeldatalist");
-    QDataStream stream(&encoded, QIODevice::ReadOnly);
-    std::vector<int> sourceRows;
-
-    while (!stream.atEnd()) {
-      int sourceRow, col;
-      QMap<int,  QVariant> roleDataMap;
-      stream >> sourceRow >> col >> roleDataMap;
-      if (col == 0) {
-        sourceRows.push_back(sourceRow);
-      }
-    }
+  int newPriority = dropPriority(row, parent);
+  if (newPriority == -1) {
+    return false;
+  }
 
-    int newPriority = dropPriority(row, parent);
-    if (newPriority == -1) {
-      return false;
-    }
+  try {
+    std::vector<int> sourceRows = this->sourceRows(mimeData);
     changeModPriority(sourceRows, newPriority);
 
   } catch (const std::exception &e) {
@@ -1221,19 +1229,7 @@ bool ModList::dropArchive(const QMimeData* mimeData, int row, const QModelIndex&
   }
 
   try {
-    QByteArray encoded = mimeData->data("application/x-qabstractitemmodeldatalist");
-    QDataStream stream(&encoded, QIODevice::ReadOnly);
-    std::vector<int> sourceRows;
-
-    while (!stream.atEnd()) {
-      int sourceRow, col;
-      QMap<int, QVariant> roleDataMap;
-      stream >> sourceRow >> col >> roleDataMap;
-      if (col == 0) {
-        sourceRows.push_back(sourceRow);
-      }
-    }
-
+    std::vector<int> sourceRows = this->sourceRows(mimeData);
     if (sourceRows.size() == 1) {
       emit downloadArchiveDropped(sourceRows[0], priority);
     }
@@ -1245,6 +1241,41 @@ bool ModList::dropArchive(const QMimeData* mimeData, int row, const QModelIndex&
   return false;
 }
 
+bool ModList::canDropMimeData(const QMimeData* mimeData, Qt::DropAction action, int row, int column, const QModelIndex& parent) const
+{
+  if (action == Qt::IgnoreAction) {
+    return false;
+  }
+
+  if (mimeData->hasUrls()) {
+    for (auto& url : mimeData->urls()) {
+      if (!relativeUrl(url)) {
+        return false;
+      }
+    }
+    if (row == -1 && parent.isValid()) {
+      ModInfo::Ptr modInfo = ModInfo::getByIndex(parent.row());
+      return modInfo->isRegular() && !modInfo->isSeparator();
+    }
+  }
+  else if (mimeData->hasText()) {
+    // drop on item
+    if (row == -1 && parent.isValid()) {
+      ModInfo::Ptr modInfo = ModInfo::getByIndex(parent.row());
+      return modInfo->isSeparator();
+    }
+    else if (hasIndex(row, column, parent)) {
+      ModInfo::Ptr modInfo = ModInfo::getByIndex(row);
+      return modInfo->isSeparator() || !parent.isValid();
+    }
+    else {
+      return true;
+    }
+  }
+
+  return false;
+}
+
 bool ModList::dropMimeData(const QMimeData *mimeData, Qt::DropAction action, int row, int, const QModelIndex &parent)
 {
   if (action == Qt::IgnoreAction) {
@@ -1407,15 +1438,6 @@ QMap<int, QVariant> ModList::itemData(const QModelIndex &index) const
   return result;
 }
 
-
-void ModList::dropModeUpdate(bool dropOnItems)
-{
-  if (m_DropOnItems != dropOnItems) {
-    m_DropOnItems = dropOnItems;
-  }
-}
-
-
 QString ModList::getColumnName(int column)
 {
   switch (column) {
diff --git a/src/modlist.h b/src/modlist.h
index 2ca2fff1..b2eb6be6 100644
--- a/src/modlist.h
+++ b/src/modlist.h
@@ -199,11 +199,13 @@ public: // implementation of virtual functions of QAbstractItemModel
   virtual bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole);
   virtual QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const;
   virtual Qt::ItemFlags flags(const QModelIndex &modelIndex) const;
-  virtual Qt::DropActions supportedDropActions() const { return Qt::MoveAction | Qt::CopyAction; }
-  virtual QStringList mimeTypes() const;
-  virtual QMimeData *mimeData(const QModelIndexList &indexes) const;
-  virtual bool dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent);
-  virtual bool removeRows(int row, int count, const QModelIndex &parent);
+  virtual bool removeRows(int row, int count, const QModelIndex& parent);
+
+  Qt::DropActions supportedDropActions() const override { return Qt::MoveAction | Qt::CopyAction; }
+  QStringList mimeTypes() const override;
+  QMimeData *mimeData(const QModelIndexList &indexes) const override;
+  bool canDropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) const override;
+  bool dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent) override;
 
   virtual QModelIndex index(int row, int column,
                             const QModelIndex &parent = QModelIndex()) const;
@@ -213,10 +215,8 @@ public: // implementation of virtual functions of QAbstractItemModel
 
 public slots:
 
-  void dropModeUpdate(bool dropOnItems);
 
   void enableSelected(const QItemSelectionModel *selectionModel);
-
   void disableSelected(const QItemSelectionModel *selectionModel);
 
 signals:
@@ -369,6 +369,16 @@ private:
 
 private:
 
+  // retrieve the relative path of file and its origin given a URL from Mime data
+  // returns an empty optional if the URL is not a valid file for dropping
+  //
+  std::optional<std::pair<QString, QString>> relativeUrl(const QUrl&) const;
+
+  // return the source rows from the given mime data for drag&drop of mods or
+  // installation archives
+  //
+  std::vector<int> sourceRows(const QMimeData* mimeData) const;
+
   bool dropURLs(const QMimeData* mimeData, int row, const QModelIndex& parent);
   bool dropMod(const QMimeData* mimeData, int row, const QModelIndex& parent);
   bool dropArchive(const QMimeData* mimeData, int row, const QModelIndex& parent);
@@ -392,8 +402,6 @@ private:
 
   QFontMetrics m_FontMetrics;
 
-  bool m_DropOnItems;
-
   std::set<unsigned int> m_Overwrite;
   std::set<unsigned int> m_Overwritten;
   std::set<unsigned int> m_ArchiveOverwrite;
diff --git a/src/modlistbypriorityproxy.cpp b/src/modlistbypriorityproxy.cpp
index 1bbf9459..dc51617e 100644
--- a/src/modlistbypriorityproxy.cpp
+++ b/src/modlistbypriorityproxy.cpp
@@ -210,64 +210,44 @@ bool ModListByPriorityProxy::canDropMimeData(const QMimeData* data, Qt::DropActi
 
 bool ModListByPriorityProxy::dropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent)
 {
-  // we need to fix the source row
+  // we need to fix the source model row
   int sourceRow = -1;
 
-  if (row >= 0) {
-    if (!parent.isValid()) {
-      if (row < m_Root.children.size()) {
-        sourceRow = m_Root.children[row]->index;
-      }
-      else {
-        sourceRow = ModInfo::getNumMods();
-      }
+  if (data->hasUrls()) {
+    if (parent.isValid()) {
+      sourceRow = static_cast<TreeItem*>(parent.internalPointer())->index;
     }
-    else {
-      auto* item = static_cast<TreeItem*>(parent.internalPointer());
-      QStringList what;
-      for (auto& child : item->children) {
-        what.append(QString::number(child->index));
+  }
+  else {
+    if (row >= 0) {
+      if (!parent.isValid()) {
+        if (row < m_Root.children.size()) {
+          sourceRow = m_Root.children[row]->index;
+        }
+        else {
+          sourceRow = ModInfo::getNumMods();
+        }
       }
+      else {
+        auto* item = static_cast<TreeItem*>(parent.internalPointer());
 
-      if (row < item->children.size()) {
-        sourceRow = item->children[row]->index;
-      }
-      else if (parent.row() + 1 < m_Root.children.size()) {
-        sourceRow = m_Root.children[parent.row() + 1]->index;
+        if (row < item->children.size()) {
+          sourceRow = item->children[row]->index;
+        }
+        else if (parent.row() + 1 < m_Root.children.size()) {
+          sourceRow = m_Root.children[parent.row() + 1]->index;
+        }
       }
     }
-  }
-  else if (parent.isValid()) {
-    // this is a drop in a separator
-    sourceRow = m_Root.children[parent.row() + 1]->index;
+    else if (parent.isValid()) {
+      // this is a drop in a separator
+      sourceRow = m_Root.children[parent.row() + 1]->index;
+    }
   }
 
   return sourceModel()->dropMimeData(data, action, sourceRow, column, QModelIndex());
 }
 
-Qt::ItemFlags ModListByPriorityProxy::flags(const QModelIndex& idx) const
-{
-  if (!idx.isValid()) {
-    return sourceModel()->flags(QModelIndex());
-  }
-
-  // we check the flags of the root node and if drop is not enabled, it
-  // means we are dragging files.
-  Qt::ItemFlags rootFlags = sourceModel()->flags(QModelIndex());
-  if (!rootFlags.testFlag(Qt::ItemIsDropEnabled)) {
-    return sourceModel()->flags(mapToSource(idx));
-  }
-
-  auto flags = sourceModel()->flags(mapToSource(idx));
-  auto* item = static_cast<TreeItem*>(idx.internalPointer());
-
-  if (item->mod->isSeparator()) {
-    flags |= Qt::ItemIsDropEnabled;
-  }
-
-  return flags;
-}
-
 QModelIndex ModListByPriorityProxy::index(int row, int column, const QModelIndex& parent) const
 {
   if (!hasIndex(row, column, parent)) {
diff --git a/src/modlistbypriorityproxy.h b/src/modlistbypriorityproxy.h
index fdf59182..725a3242 100644
--- a/src/modlistbypriorityproxy.h
+++ b/src/modlistbypriorityproxy.h
@@ -31,7 +31,6 @@ public:
 
   int rowCount(const QModelIndex& parent = QModelIndex()) const override;
   QModelIndex parent(const QModelIndex& child) const override;
-  Qt::ItemFlags flags(const QModelIndex& idx) const override;
   QModelIndex index(int row, int column, const QModelIndex& parent = QModelIndex()) const override;
   int columnCount(const QModelIndex& index) const override;
   bool hasChildren(const QModelIndex& parent) const override;
diff --git a/src/modlistview.cpp b/src/modlistview.cpp
index fcf34749..27e23417 100644
--- a/src/modlistview.cpp
+++ b/src/modlistview.cpp
@@ -2,37 +2,6 @@
 #include <widgetutility.h>
 #include <QUrl>
 #include <QMimeData>
-#include <QProxyStyle>
-
-class ModListViewStyle: public QProxyStyle {
-public:
-  ModListViewStyle(QStyle *style, int indentation);
-
-  void drawPrimitive (PrimitiveElement element, const QStyleOption *option,
-                      QPainter *painter, const QWidget *widget = 0) const;
-private:
-  int m_Indentation;
-};
-
-ModListViewStyle::ModListViewStyle(QStyle *style, int indentation)
-  : QProxyStyle(style), m_Indentation(indentation)
-{
-}
-
-void ModListViewStyle::drawPrimitive(PrimitiveElement element, const QStyleOption *option,
-                                     QPainter *painter, const QWidget *widget) const
-{
-  if (element == QStyle::PE_IndicatorItemViewItemDrop && !option->rect.isNull()) {
-    QStyleOption opt(*option);
-    opt.rect.setLeft(m_Indentation);
-    if (widget) {
-      opt.rect.setRight(widget->width() - 5); // 5 is an arbitrary value that seems to work ok
-    }
-    QProxyStyle::drawPrimitive(element, &opt, painter, widget);
-  } else {
-    QProxyStyle::drawPrimitive(element, option, painter, widget);
-  }
-}
 
 ModListView::ModListView(QWidget *parent)
   : QTreeView(parent)
@@ -43,13 +12,6 @@ ModListView::ModListView(QWidget *parent)
   setAutoExpandDelay(500);
 }
 
-void ModListView::dragEnterEvent(QDragEnterEvent *event)
-{
-  emit dropModeUpdate(event->mimeData()->hasUrls());
-
-  QTreeView::dragEnterEvent(event);
-}
-
 void ModListView::setModel(QAbstractItemModel *model)
 {
   QTreeView::setModel(model);
diff --git a/src/modlistview.h b/src/modlistview.h
index 982591a3..bc5654ce 100644
--- a/src/modlistview.h
+++ b/src/modlistview.h
@@ -12,11 +12,6 @@ public:
   explicit ModListView(QWidget *parent = 0);
   void setModel(QAbstractItemModel *model) override;
 
-signals:
-  void dropModeUpdate(bool dropOnRows);
-
-public slots:
-
 protected:
 
   // replace the auto-expand timer from QTreeView to avoid
@@ -25,7 +20,6 @@ protected:
 
   void timerEvent(QTimerEvent* event) override;
   void dragMoveEvent(QDragMoveEvent* event) override;
-  void dragEnterEvent(QDragEnterEvent* event) override;
 
 private:
 
-- 
cgit v1.3.1


From 4636d7bd5d092ff47146248232cd73c8d0254d7a Mon Sep 17 00:00:00 2001
From: Mikaël Capelle <capelle.mikael@gmail.com>
Date: Mon, 28 Dec 2020 13:50:43 +0100
Subject: Small refactoring to avoid duplicated code.

---
 src/modlist.cpp                |  8 ++++----
 src/modlist.h                  |  4 ++--
 src/modlistbypriorityproxy.cpp | 37 ++++++++++++++++---------------------
 3 files changed, 22 insertions(+), 27 deletions(-)

(limited to 'src/modlistbypriorityproxy.cpp')

diff --git a/src/modlist.cpp b/src/modlist.cpp
index b79f0b0e..a058e71c 100644
--- a/src/modlist.cpp
+++ b/src/modlist.cpp
@@ -1108,7 +1108,7 @@ int ModList::dropPriority(int row, const QModelIndex& parent) const
   return newPriority;
 }
 
-std::vector<int> ModList::sourceRows(const QMimeData* mimeData) const
+std::vector<int> ModList::sourceRows(const QMimeData* mimeData)
 {
   QByteArray encoded = mimeData->data("application/x-qabstractitemmodeldatalist");
   QDataStream stream(&encoded, QIODevice::ReadOnly);
@@ -1125,7 +1125,7 @@ std::vector<int> ModList::sourceRows(const QMimeData* mimeData) const
   return sourceRows;
 }
 
-std::optional<std::pair<QString, QString>> ModList::relativeUrl(const QUrl& url) const
+std::optional<std::pair<QString, QString>> ModList::relativeUrl(const QUrl& url)
 {
   if (!url.isLocalFile()) {
     return {};
@@ -1211,7 +1211,7 @@ bool ModList::dropMod(const QMimeData *mimeData, int row, const QModelIndex &par
   }
 
   try {
-    std::vector<int> sourceRows = this->sourceRows(mimeData);
+    std::vector<int> sourceRows = ModList::sourceRows(mimeData);
     changeModPriority(sourceRows, newPriority);
 
   } catch (const std::exception &e) {
@@ -1229,7 +1229,7 @@ bool ModList::dropArchive(const QMimeData* mimeData, int row, const QModelIndex&
   }
 
   try {
-    std::vector<int> sourceRows = this->sourceRows(mimeData);
+    std::vector<int> sourceRows = ModList::sourceRows(mimeData);
     if (sourceRows.size() == 1) {
       emit downloadArchiveDropped(sourceRows[0], priority);
     }
diff --git a/src/modlist.h b/src/modlist.h
index b2eb6be6..eebb1105 100644
--- a/src/modlist.h
+++ b/src/modlist.h
@@ -372,12 +372,12 @@ private:
   // retrieve the relative path of file and its origin given a URL from Mime data
   // returns an empty optional if the URL is not a valid file for dropping
   //
-  std::optional<std::pair<QString, QString>> relativeUrl(const QUrl&) const;
+  static std::optional<std::pair<QString, QString>> relativeUrl(const QUrl&);
 
   // return the source rows from the given mime data for drag&drop of mods or
   // installation archives
   //
-  std::vector<int> sourceRows(const QMimeData* mimeData) const;
+  static std::vector<int> sourceRows(const QMimeData* mimeData);
 
   bool dropURLs(const QMimeData* mimeData, int row, const QModelIndex& parent);
   bool dropMod(const QMimeData* mimeData, int row, const QModelIndex& parent);
diff --git a/src/modlistbypriorityproxy.cpp b/src/modlistbypriorityproxy.cpp
index dc51617e..eb931aa9 100644
--- a/src/modlistbypriorityproxy.cpp
+++ b/src/modlistbypriorityproxy.cpp
@@ -160,35 +160,30 @@ bool ModListByPriorityProxy::setData(const QModelIndex& index, const QVariant& v
 
 bool ModListByPriorityProxy::canDropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) const
 {
-  bool firstRowSeparator = false;
-  try {
-    QByteArray encoded = data->data("application/x-qabstractitemmodeldatalist");
-    QDataStream stream(&encoded, QIODevice::ReadOnly);
-
-    int firstRowPriority = INT_MAX;
-    unsigned int firstRowIndex = -1;
-
-    while (!stream.atEnd()) {
-      int sourceRow, col;
-      QMap<int, QVariant> roleDataMap;
-      stream >> sourceRow >> col >> roleDataMap;
-      if (col == 0) {
+  if (data->hasText()) {
+    bool firstRowSeparator = false;
+
+    try {
+      int firstRowPriority = INT_MAX;
+      unsigned int firstRowIndex = -1;
+
+      for (auto sourceRow : ModList::sourceRows(data)) {
         if (m_Profile->getModPriority(sourceRow) < firstRowPriority) {
           firstRowIndex = sourceRow;
           firstRowPriority = m_Profile->getModPriority(sourceRow);
         }
       }
-    }
 
-    firstRowSeparator = firstRowIndex != -1 && ModInfo::getByIndex(firstRowIndex)->isSeparator();
-  }
-  catch (std::exception const&) {
+      firstRowSeparator = firstRowIndex != -1 && ModInfo::getByIndex(firstRowIndex)->isSeparator();
+    }
+    catch (std::exception const&) {
 
-  }
+    }
 
-  // first row is a separator, we can drop it anywhere
-  if (firstRowSeparator) {
-    return QAbstractProxyModel::canDropMimeData(data, action, row, column, parent);
+    // first row is a separator, we can drop it anywhere
+    if (firstRowSeparator) {
+      return QAbstractProxyModel::canDropMimeData(data, action, row, column, parent);
+    }
   }
 
   if (!parent.isValid() && row >= 0) {
-- 
cgit v1.3.1


From b340c564cfd151540bf5b03f3f878153b8f120ee Mon Sep 17 00:00:00 2001
From: Mikaël Capelle <capelle.mikael@gmail.com>
Date: Mon, 28 Dec 2020 17:15:22 +0100
Subject: Fix keyboard move selection.

---
 src/mainwindow.cpp             | 115 +++++++++++++++++++++++++++++++----------
 src/mainwindow.h               |   7 ++-
 src/modlist.cpp                |  29 +++++------
 src/modlist.h                  |  15 +++---
 src/modlistbypriorityproxy.cpp |  10 ++--
 src/modlistbypriorityproxy.h   |   1 +
 src/organizercore.cpp          |   2 -
 7 files changed, 125 insertions(+), 54 deletions(-)

(limited to 'src/modlistbypriorityproxy.cpp')

diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index 48a935ae..61d0e5bb 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -548,9 +548,12 @@ MainWindow::MainWindow(Settings &settings
 
 void MainWindow::updateModListByPriorityProxy()
 {
+  if (ui->groupCombo->currentIndex() != 0) {
+    return;
+  }
   if (m_ModListSortProxy->sortColumn() == ModList::COL_PRIORITY && m_ModListSortProxy->sortOrder() == Qt::AscendingOrder) {
     m_ModListSortProxy->setSourceModel(m_ModListByPriorityProxy);
-    emit m_OrganizerCore.modList()->layoutChanged();
+    m_ModListByPriorityProxy->refresh();
   }
   else {
     m_ModListSortProxy->setSourceModel(m_OrganizerCore.modList());
@@ -579,6 +582,7 @@ void MainWindow::setupModList()
   ui->modList->sortByColumn(ModList::COL_PRIORITY, Qt::AscendingOrder);
 
   connect(ui->modList, &ModListView::dragEntered, m_OrganizerCore.modList(), &ModList::onDragEnter);
+  connect(m_OrganizerCore.modList(), &ModList::modPrioritiesChanged, this, &MainWindow::onModPrioritiesChanged);
 
   connect(
     ui->modList->header(), SIGNAL(sortIndicatorChanged(int,Qt::SortOrder)),
@@ -2435,8 +2439,58 @@ void MainWindow::esplist_changed()
   updatePluginCount();
 }
 
-void MainWindow::modorder_changed()
+QModelIndex MainWindow::modViewIndexToModel(const QModelIndex& index) const
+{
+  auto sindex = index;
+
+  // remove the sort proxy.
+  sindex = m_ModListSortProxy->mapToSource(index);
+
+  // if there is another proxy
+  if (auto* proxy = qobject_cast<QAbstractProxyModel*>(m_ModListSortProxy->sourceModel())) {
+    sindex = proxy->mapToSource(sindex);
+  }
+
+  return sindex;
+}
+
+QModelIndex MainWindow::modModelIndexToView(const QModelIndex& index) const
+{
+  auto dindex = index;
+
+  // if there is another proxy than the sort
+  if (auto* proxy = qobject_cast<QAbstractProxyModel*>(m_ModListSortProxy->sourceModel())) {
+    dindex = proxy->mapFromSource(dindex);
+  }
+
+  // add the sort proxy
+  dindex = m_ModListSortProxy->mapFromSource(dindex);
+
+  return dindex;
+
+}
+
+void MainWindow::onModPrioritiesChanged(std::vector<int> const& indices)
 {
+  // if we have collapsible separators, we need to refresh, expand if necessary,
+  // and recreate the selection
+  if (m_ModListSortProxy->sourceModel() == m_ModListByPriorityProxy) {
+
+    // manually retain the selection and restore it after
+    QModelIndex current = modViewIndexToModel(ui->modList->currentIndex());
+    std::vector<QModelIndex> selected;
+    for (const auto& idx : ui->modList->selectionModel()->selectedRows()) {
+      selected.push_back(modViewIndexToModel(idx));
+    }
+
+    m_ModListByPriorityProxy->refresh();
+
+    ui->modList->setCurrentIndex(modModelIndexToView(current));
+    for (auto idx : selected) {
+      ui->modList->selectionModel()->select(modModelIndexToView(idx), QItemSelectionModel::Select | QItemSelectionModel::Rows);
+    }
+  }
+
   for (unsigned int i = 0; i < m_OrganizerCore.currentProfile()->numMods(); ++i) {
     int priority = m_OrganizerCore.currentProfile()->getModPriority(i);
     if (m_OrganizerCore.currentProfile()->modEnabled(i)) {
@@ -2453,7 +2507,7 @@ void MainWindow::modorder_changed()
   { // refresh selection
     QModelIndex current = ui->modList->currentIndex();
     if (current.isValid()) {
-      ModInfo::Ptr modInfo = ModInfo::getByIndex(current.data(Qt::UserRole + 1).toInt());
+      ModInfo::Ptr modInfo = ModInfo::getByIndex(current.data(ModList::IndexRole).toInt());
       // clear caches on all mods conflicting with the moved mod
       for (int i :  modInfo->getModOverwrite()) {
         ModInfo::getByIndex(i)->clearCaches();
@@ -2478,8 +2532,9 @@ void MainWindow::modorder_changed()
       m_OrganizerCore.modList()->setOverwriteMarkers(modInfo->getModOverwrite(), modInfo->getModOverwritten());
       m_OrganizerCore.modList()->setArchiveOverwriteMarkers(modInfo->getModArchiveOverwrite(), modInfo->getModArchiveOverwritten());
       m_OrganizerCore.modList()->setArchiveLooseOverwriteMarkers(modInfo->getModArchiveLooseOverwrite(), modInfo->getModArchiveLooseOverwritten());
-      if (m_ModListSortProxy != nullptr)
+      if (m_ModListSortProxy != nullptr) {
         m_ModListSortProxy->invalidate();
+      }
       ui->modList->verticalScrollBar()->repaint();
     }
   }
@@ -2624,7 +2679,7 @@ void MainWindow::modlistSelectionsChanged(const QItemSelection &selected)
   if (selected.count()) {
     auto selection = selected.last();
     auto index = selection.indexes().last();
-    ModInfo::Ptr selectedMod = ModInfo::getByIndex(index.data(Qt::UserRole + 1).toInt());
+    ModInfo::Ptr selectedMod = ModInfo::getByIndex(index.data(ModList::IndexRole).toInt());
     m_OrganizerCore.modList()->setOverwriteMarkers(selectedMod->getModOverwrite(), selectedMod->getModOverwritten());
     m_OrganizerCore.modList()->setArchiveOverwriteMarkers(selectedMod->getModArchiveOverwrite(), selectedMod->getModArchiveOverwritten());
     m_OrganizerCore.modList()->setArchiveLooseOverwriteMarkers(selectedMod->getModArchiveLooseOverwrite(), selectedMod->getModArchiveLooseOverwritten());
@@ -2669,7 +2724,7 @@ void MainWindow::removeMod_clicked()
       int i = 0;
       for (QModelIndex idx : selection->selectedRows()) {
         QString name = idx.data().toString();
-        if (!ModInfo::getByIndex(idx.data(Qt::UserRole + 1).toInt())->isRegular()) {
+        if (!ModInfo::getByIndex(idx.data(ModList::IndexRole).toInt())->isRegular()) {
           continue;
         }
 
@@ -2684,7 +2739,7 @@ void MainWindow::removeMod_clicked()
           mods += "<li>...</li>";
         }
 
-        modNames.append(ModInfo::getByIndex(idx.data(Qt::UserRole + 1).toInt())->name());
+        modNames.append(ModInfo::getByIndex(idx.data(ModList::IndexRole).toInt())->name());
         ++i;
       }
       if (QMessageBox::question(this, tr("Confirm"),
@@ -2776,7 +2831,7 @@ void MainWindow::endorse_clicked()
     }
 
     for (QModelIndex idx : selection->selectedRows()) {
-      ModInfo::getByIndex(idx.data(Qt::UserRole + 1).toInt())->endorse(true);
+      ModInfo::getByIndex(idx.data(ModList::IndexRole).toInt())->endorse(true);
     }
   });
 }
@@ -2786,7 +2841,7 @@ void MainWindow::dontendorse_clicked()
   QItemSelectionModel *selection = ui->modList->selectionModel();
   if (selection->hasSelection() && selection->selectedRows().count() > 1) {
     for (QModelIndex idx : selection->selectedRows()) {
-      ModInfo::getByIndex(idx.data(Qt::UserRole + 1).toInt())->setNeverEndorse();
+      ModInfo::getByIndex(idx.data(ModList::IndexRole).toInt())->setNeverEndorse();
     }
   }
   else {
@@ -2812,7 +2867,7 @@ void MainWindow::unendorse_clicked()
     }
 
     for (QModelIndex idx : selection->selectedRows()) {
-      ModInfo::getByIndex(idx.data(Qt::UserRole + 1).toInt())->endorse(false);
+      ModInfo::getByIndex(idx.data(ModList::IndexRole).toInt())->endorse(false);
     }
   });
 }
@@ -2831,7 +2886,7 @@ void MainWindow::track_clicked()
   m_OrganizerCore.loggedInAction(this, [this] {
     QItemSelectionModel *selection = ui->modList->selectionModel();
     for (auto idx : selection->selectedRows()) {
-      ModInfo::getByIndex(idx.data(Qt::UserRole + 1).toInt())->track(true);
+      ModInfo::getByIndex(idx.data(ModList::IndexRole).toInt())->track(true);
     }
   });
 }
@@ -2841,7 +2896,7 @@ void MainWindow::untrack_clicked()
   m_OrganizerCore.loggedInAction(this, [this] {
     QItemSelectionModel *selection = ui->modList->selectionModel();
     for (auto idx : selection->selectedRows()) {
-      ModInfo::getByIndex(idx.data(Qt::UserRole + 1).toInt())->track(false);
+      ModInfo::getByIndex(idx.data(ModList::IndexRole).toInt())->track(false);
     }
   });
 }
@@ -3033,7 +3088,7 @@ void MainWindow::ignoreMissingData_clicked()
     std::vector<ModInfo::Ptr> changed;
 
     for (QModelIndex idx : rows) {
-      int row_idx = idx.data(Qt::UserRole + 1).toInt();
+      int row_idx = idx.data(ModList::IndexRole).toInt();
       ModInfo::Ptr info = ModInfo::getByIndex(row_idx);
       info->markValidated(true);
       changed.push_back(info);
@@ -3058,7 +3113,7 @@ void MainWindow::markConverted_clicked()
     std::vector<ModInfo::Ptr> changed;
 
     for (QModelIndex idx : rows) {
-      int row_idx = idx.data(Qt::UserRole + 1).toInt();
+      int row_idx = idx.data(ModList::IndexRole).toInt();
       ModInfo::Ptr info = ModInfo::getByIndex(row_idx);
       info->markConverted(true);
       changed.push_back(info);
@@ -3097,7 +3152,7 @@ void MainWindow::restoreHiddenFiles_clicked()
     for (QModelIndex idx : selection->selectedRows()) {
 
       QString name = idx.data().toString();
-      int row_idx = idx.data(Qt::UserRole + 1).toInt();
+      int row_idx = idx.data(ModList::IndexRole).toInt();
       ModInfo::Ptr modInfo = ModInfo::getByIndex(row_idx);
       const auto flags = modInfo->getFlags();
 
@@ -3116,7 +3171,7 @@ void MainWindow::restoreHiddenFiles_clicked()
         mods += "<li>...</li>";
       }
 
-      modNames.append(ModInfo::getByIndex(idx.data(Qt::UserRole + 1).toInt())->name());
+      modNames.append(ModInfo::getByIndex(idx.data(ModList::IndexRole).toInt())->name());
       ++i;
     }
     if (QMessageBox::question(this, tr("Confirm"),
@@ -3125,7 +3180,7 @@ void MainWindow::restoreHiddenFiles_clicked()
 
       for (QModelIndex idx : selection->selectedRows()) {
 
-        int row_idx = idx.data(Qt::UserRole + 1).toInt();
+        int row_idx = idx.data(ModList::IndexRole).toInt();
         ModInfo::Ptr modInfo = ModInfo::getByIndex(row_idx);
 
         const auto flags = modInfo->getFlags();
@@ -3186,7 +3241,7 @@ void MainWindow::visitOnNexus_clicked()
     QString gameName;
 
     for (QModelIndex idx : selection->selectedRows()) {
-      row_idx = idx.data(Qt::UserRole + 1).toInt();
+      row_idx = idx.data(ModList::IndexRole).toInt();
       info = ModInfo::getByIndex(row_idx);
       int modID = info->nexusId();
       gameName = info->gameName();
@@ -3224,7 +3279,7 @@ void MainWindow::visitWebPage_clicked()
     ModInfo::Ptr info;
     QString gameName;
     for (QModelIndex idx : selection->selectedRows()) {
-      row_idx = idx.data(Qt::UserRole + 1).toInt();
+      row_idx = idx.data(ModList::IndexRole).toInt();
       info = ModInfo::getByIndex(row_idx);
 
       const auto url = info->parseCustomURL();
@@ -3245,7 +3300,7 @@ void MainWindow::visitWebPage_clicked()
 
 void MainWindow::visitNexusOrWebPage(const QModelIndex& idx)
 {
-  int row_idx = idx.data(Qt::UserRole + 1).toInt();
+  int row_idx = idx.data(ModList::IndexRole).toInt();
 
   ModInfo::Ptr info = ModInfo::getByIndex(row_idx);
   if (!info) {
@@ -3293,7 +3348,7 @@ void MainWindow::openExplorer_clicked()
   QItemSelectionModel *selection = ui->modList->selectionModel();
   if (selection->hasSelection() && selection->selectedRows().count() > 1) {
     for (QModelIndex idx : selection->selectedRows()) {
-      ModInfo::Ptr info = ModInfo::getByIndex(idx.data(Qt::UserRole + 1).toInt());
+      ModInfo::Ptr info = ModInfo::getByIndex(idx.data(ModList::IndexRole).toInt());
       shell::Explore(info->absolutePath());
     }
   }
@@ -3332,7 +3387,7 @@ void MainWindow::openExplorer_activated()
 		if (selection->hasSelection() && selection->selectedRows().count() == 1 ) {
 
 			QModelIndex idx = selection->currentIndex();
-			ModInfo::Ptr modInfo = ModInfo::getByIndex(idx.data(Qt::UserRole + 1).toInt());
+			ModInfo::Ptr modInfo = ModInfo::getByIndex(idx.data(ModList::IndexRole).toInt());
 			std::vector<ModInfo::EFlag> flags = modInfo->getFlags();
 
 			if (modInfo->isRegular() || (std::find(flags.begin(), flags.end(), ModInfo::FLAG_OVERWRITE) != flags.end())) {
@@ -3621,7 +3676,7 @@ void MainWindow::setColor_clicked()
   QItemSelectionModel *selection = ui->modList->selectionModel();
   if (selection->hasSelection() && selection->selectedRows().count() > 1) {
     for (QModelIndex idx : selection->selectedRows()) {
-      ModInfo::Ptr info = ModInfo::getByIndex(idx.data(Qt::UserRole + 1).toInt());
+      ModInfo::Ptr info = ModInfo::getByIndex(idx.data(ModList::IndexRole).toInt());
        info->setColor(currentColor);
     }
   }
@@ -3637,7 +3692,7 @@ void MainWindow::resetColor_clicked()
   QItemSelectionModel *selection = ui->modList->selectionModel();
   if (selection->hasSelection() && selection->selectedRows().count() > 1) {
     for (QModelIndex idx : selection->selectedRows()) {
-      ModInfo::Ptr info = ModInfo::getByIndex(idx.data(Qt::UserRole + 1).toInt());
+      ModInfo::Ptr info = ModInfo::getByIndex(idx.data(ModList::IndexRole).toInt());
        info->setColor(color);
     }
   }
@@ -4196,7 +4251,7 @@ void MainWindow::ignoreUpdate() {
   QItemSelectionModel *selection = ui->modList->selectionModel();
   if (selection->hasSelection() && selection->selectedRows().count() > 1) {
     for (QModelIndex idx : selection->selectedRows()) {
-      ModInfo::Ptr info = ModInfo::getByIndex(idx.data(Qt::UserRole + 1).toInt());
+      ModInfo::Ptr info = ModInfo::getByIndex(idx.data(ModList::IndexRole).toInt());
       info->ignoreUpdate(true);
     }
   }
@@ -4214,7 +4269,7 @@ void MainWindow::checkModUpdates_clicked()
   QItemSelectionModel *selection = ui->modList->selectionModel();
   if (selection->hasSelection() && selection->selectedRows().count() > 1) {
     for (QModelIndex idx : selection->selectedRows()) {
-      ModInfo::Ptr info = ModInfo::getByIndex(idx.data(Qt::UserRole + 1).toInt());
+      ModInfo::Ptr info = ModInfo::getByIndex(idx.data(ModList::IndexRole).toInt());
       IDs.insert(std::make_pair<QString, int>(info->gameName(), info->nexusId()));
     }
   } else {
@@ -4229,7 +4284,7 @@ void MainWindow::unignoreUpdate()
   QItemSelectionModel *selection = ui->modList->selectionModel();
   if (selection->hasSelection() && selection->selectedRows().count() > 1) {
     for (QModelIndex idx : selection->selectedRows()) {
-      ModInfo::Ptr info = ModInfo::getByIndex(idx.data(Qt::UserRole + 1).toInt());
+      ModInfo::Ptr info = ModInfo::getByIndex(idx.data(ModList::IndexRole).toInt());
       info->ignoreUpdate(false);
     }
   }
@@ -4640,6 +4695,12 @@ void MainWindow::on_modList_customContextMenuRequested(const QPoint &pos)
       initModListContextMenu(allMods);
       allMods->setTitle(tr("All Mods"));
       menu.addMenu(allMods);
+
+      if (m_ModListSortProxy->sourceModel() == m_ModListByPriorityProxy) {
+        menu.addAction(tr("Collapse all"), ui->modList, &QTreeView::collapseAll);
+        menu.addAction(tr("Expand all"), ui->modList, &QTreeView::expandAll);
+      }
+
       menu.addSeparator();
 
       ModInfo::Ptr info = ModInfo::getByIndex(m_ContextRow);
diff --git a/src/mainwindow.h b/src/mainwindow.h
index ccfd4881..61a8b5e3 100644
--- a/src/mainwindow.h
+++ b/src/mainwindow.h
@@ -148,7 +148,7 @@ public:
   ModInfo::Ptr previousModInList();
 
 public slots:
-  void modorder_changed();
+  void onModPrioritiesChanged(std::vector<int> const& indices);
   void esplist_changed();
   void refresherProgress(const DirectoryRefreshProgress* p);
 
@@ -607,8 +607,13 @@ private slots: // ui slots
 
   void storeSettings();
   void readSettings();
+
   void setupModList();
   void updateModListByPriorityProxy();
+
+  // map index from the modlist view to the modlist model, handling proxy
+  QModelIndex modViewIndexToModel(const QModelIndex& index) const;
+  QModelIndex modModelIndexToView(const QModelIndex& index) const;
 };
 
 #endif // MAINWINDOW_H
diff --git a/src/modlist.cpp b/src/modlist.cpp
index 79dbf815..a6286007 100644
--- a/src/modlist.cpp
+++ b/src/modlist.cpp
@@ -336,7 +336,7 @@ QVariant ModList::data(const QModelIndex &modelIndex, int role) const
     } else {
       return modInfo->nexusId();
     }
-  } else if (role == Qt::UserRole + 1) {
+  } else if (role == IndexRole) {
     return modIndex;
   } else if (role == Qt::UserRole + 2) {
     switch (column) {
@@ -592,8 +592,7 @@ bool ModList::setData(const QModelIndex &index, const QVariant &value, int role)
         }
         if (ok) {
           m_Profile->setModPriority(modID, newPriority);
-
-          emit modorder_changed();
+          emit modPrioritiesChanged({ modID });
           result = true;
         } else {
           result = false;
@@ -765,7 +764,7 @@ void ModList::changeModPriority(std::vector<int> sourceIndices, int newPriority)
 
   emit layoutChanged();
 
-  emit modorder_changed();
+  emit modPrioritiesChanged(sourceIndices);
 }
 
 
@@ -777,8 +776,7 @@ void ModList::changeModPriority(int sourceIndex, int newPriority)
   m_Profile->setModPriority(sourceIndex, newPriority);
 
   emit layoutChanged();
-
-  emit modorder_changed();
+  emit modPrioritiesChanged({ sourceIndex });
 }
 
 void ModList::setOverwriteMarkers(const std::set<unsigned int> &overwrite, const std::set<unsigned int> &overwritten)
@@ -1525,17 +1523,18 @@ bool ModList::moveSelection(QAbstractItemView *itemView, int direction)
       rows.swapItemsAt(i, rows.size() - i - 1);
     }
   }
+  std::vector<int> allIndex;
   for (QModelIndex idx : rows) {
-    if (filterModel != nullptr) {
-      idx = filterModel->mapToSource(idx);
-    }
-    int newPriority = m_Profile->getModPriority(idx.row()) + offset;
+    auto index = idx.data(IndexRole).toInt();
+    allIndex.push_back(index);
+    int newPriority = m_Profile->getModPriority(index) + offset;
     if ((newPriority >= 0) && (newPriority < static_cast<int>(m_Profile->numRegularMods()))) {
-      m_Profile->setModPriority(idx.row(), newPriority);
-      notifyChange(idx.row());
+      m_Profile->setModPriority(index, newPriority);
+      notifyChange(index);
     }
   }
-  emit modorder_changed();
+
+  emit modPrioritiesChanged(allIndex);
   return true;
 }
 
@@ -1547,7 +1546,7 @@ bool ModList::deleteSelection(QAbstractItemView *itemView)
   if (rows.count() > 1) {
     emit removeSelectedMods();
   } else if (rows.count() == 1) {
-    removeRow(rows[0].data(Qt::UserRole + 1).toInt(), QModelIndex());
+    removeRow(rows[0].data(IndexRole).toInt(), QModelIndex());
   }
   return true;
 }
@@ -1562,7 +1561,7 @@ bool ModList::toggleSelection(QAbstractItemView *itemView)
   QList<unsigned int> modsToDisable;
   QModelIndexList dirtyMods;
   for (QModelIndex idx : selectionModel->selectedRows()) {
-    int modId = idx.data(Qt::UserRole + 1).toInt();
+    int modId = idx.data(IndexRole).toInt();
     if (m_Profile->modEnabled(modId)) {
       modsToDisable.append(modId);
       dirtyMods.append(idx);
diff --git a/src/modlist.h b/src/modlist.h
index 4e50c959..83e8ec9c 100644
--- a/src/modlist.h
+++ b/src/modlist.h
@@ -55,6 +55,10 @@ class ModList : public QAbstractItemModel
 
 public:
 
+  // role of the index of the mod
+  //
+  constexpr static int IndexRole = Qt::UserRole + 1;
+
   enum EColumn {
     COL_NAME,
     COL_CONFLICTFLAGS,
@@ -70,8 +74,6 @@ public:
     COL_LASTCOLUMN = COL_NOTES,
   };
 
-  friend class ModListProxy;
-
   using SignalModInstalled = boost::signals2::signal<void(MOBase::IModInterface*)>;
   using SignalModRemoved = boost::signals2::signal<void(QString const&)>;
   using SignalModStateChanged = boost::signals2::signal<void (const std::map<QString, MOBase::IModList::ModStates>&)>;
@@ -222,12 +224,12 @@ public slots:
 signals:
 
   /**
-   * @brief emitted whenever the sorting in the list was changed by the user
+   * @brief Emitted whenever the priority of mods changes
    *
-   * the sorting of the list can only be manually changed if the list is sorted by priority
-   * in which case the move is intended to change the priority of a mod
+   * The sorting of the list can only be manually changed if the list is sorted by priority
+   * in which case the move is intended to change the priority of a mod.
    **/
-  void modorder_changed();
+  void modPrioritiesChanged(std::vector<int> const& index);
 
   /**
    * @brief emitted when the model wants a text to be displayed by the UI
@@ -389,6 +391,7 @@ private:
 
 private:
 
+  friend class ModListProxy;
   friend class ModListByPriorityProxy;
 
   OrganizerCore *m_Organizer;
diff --git a/src/modlistbypriorityproxy.cpp b/src/modlistbypriorityproxy.cpp
index eb931aa9..c4eb14b3 100644
--- a/src/modlistbypriorityproxy.cpp
+++ b/src/modlistbypriorityproxy.cpp
@@ -20,13 +20,17 @@ void ModListByPriorityProxy::setSourceModel(QAbstractItemModel* model)
 
   if (sourceModel()) {
     m_CollapsedItems.clear();
-    connect(sourceModel(), &QAbstractItemModel::layoutChanged, this, &ModListByPriorityProxy::buildTree, Qt::UniqueConnection);
     connect(sourceModel(), &QAbstractItemModel::rowsRemoved, this, [this]() { buildTree(); }, Qt::UniqueConnection);
-    connect(sourceModel(), &QAbstractItemModel::modelReset, this, &ModListByPriorityProxy::buildTree, Qt::UniqueConnection);
-    buildTree();
+    // connect(sourceModel(), &QAbstractItemModel::modelReset, this, &ModListByPriorityProxy::buildTree, Qt::UniqueConnection);
+    refresh();
   }
 }
 
+void ModListByPriorityProxy::refresh()
+{
+  buildTree();
+}
+
 void ModListByPriorityProxy::buildTree()
 {
   if (!sourceModel()) return;
diff --git a/src/modlistbypriorityproxy.h b/src/modlistbypriorityproxy.h
index 725a3242..19d79f7f 100644
--- a/src/modlistbypriorityproxy.h
+++ b/src/modlistbypriorityproxy.h
@@ -26,6 +26,7 @@ public:
   ~ModListByPriorityProxy();
 
   void setProfile(Profile* profile) { m_Profile = profile; }
+  void refresh();
 
   void setSourceModel(QAbstractItemModel* sourceModel) override;
 
diff --git a/src/organizercore.cpp b/src/organizercore.cpp
index 454247b6..159296b7 100644
--- a/src/organizercore.cpp
+++ b/src/organizercore.cpp
@@ -255,8 +255,6 @@ void OrganizerCore::setUserInterface(IUserInterface* ui)
       SLOT(clearOverwrite()));
     connect(&m_ModList, SIGNAL(fileMoved(QString, QString, QString)), w,
             SLOT(fileMoved(QString, QString, QString)));
-    connect(&m_ModList, SIGNAL(modorder_changed()), w,
-            SLOT(modorder_changed()));
     connect(&m_PluginList, SIGNAL(writePluginsList()), w,
       SLOT(esplist_changed()));
     connect(&m_PluginList, SIGNAL(esplist_changed()), w,
-- 
cgit v1.3.1


From a7131a761e56cf92363e6e1412eccc8b200d002c Mon Sep 17 00:00:00 2001
From: Mikaël Capelle <capelle.mikael@gmail.com>
Date: Mon, 28 Dec 2020 19:06:18 +0100
Subject: Prevent dropping separators onto separators.

---
 src/modlistbypriorityproxy.cpp | 20 +++++++++++++++-----
 1 file changed, 15 insertions(+), 5 deletions(-)

(limited to 'src/modlistbypriorityproxy.cpp')

diff --git a/src/modlistbypriorityproxy.cpp b/src/modlistbypriorityproxy.cpp
index c4eb14b3..addefb6f 100644
--- a/src/modlistbypriorityproxy.cpp
+++ b/src/modlistbypriorityproxy.cpp
@@ -164,14 +164,17 @@ bool ModListByPriorityProxy::setData(const QModelIndex& index, const QVariant& v
 
 bool ModListByPriorityProxy::canDropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) const
 {
+  bool hasSeparator = false;
+  bool firstRowSeparator = false;
+
   if (data->hasText()) {
-    bool firstRowSeparator = false;
 
     try {
       int firstRowPriority = INT_MAX;
       unsigned int firstRowIndex = -1;
 
       for (auto sourceRow : ModList::sourceRows(data)) {
+        hasSeparator = hasSeparator || ModInfo::getByIndex(sourceRow)->isSeparator();
         if (m_Profile->getModPriority(sourceRow) < firstRowPriority) {
           firstRowIndex = sourceRow;
           firstRowPriority = m_Profile->getModPriority(sourceRow);
@@ -183,13 +186,20 @@ bool ModListByPriorityProxy::canDropMimeData(const QMimeData* data, Qt::DropActi
     catch (std::exception const&) {
 
     }
+  }
 
-    // first row is a separator, we can drop it anywhere
-    if (firstRowSeparator) {
-      return QAbstractProxyModel::canDropMimeData(data, action, row, column, parent);
-    }
+  // row = -1 and invalid parent means we're dropping onto an item, we don't want to drop
+  // separators onto items
+  if (hasSeparator && row == -1 && parent.isValid()) {
+    return !static_cast<TreeItem*>(parent.internalPointer())->mod->isSeparator();
+  }
+
+  // first row is a separator, we can drop it anywhere
+  if (firstRowSeparator) {
+    return QAbstractProxyModel::canDropMimeData(data, action, row, column, parent);
   }
 
+  // top-level drop is disabled unless it's before the first separator
   if (!parent.isValid() && row >= 0) {
 
     // the row may be outside of the children list if we insert at the end
-- 
cgit v1.3.1


From 54ea4445b00301fe30eb346eb10f83e55e6d0ea0 Mon Sep 17 00:00:00 2001
From: Mikaël Capelle <capelle.mikael@gmail.com>
Date: Tue, 29 Dec 2020 01:01:12 +0100
Subject: Fix sorting of backups when using collapsible separators.

---
 src/modlistbypriorityproxy.cpp | 12 ++++++++++--
 src/modlistsortproxy.cpp       | 11 ++++++++---
 2 files changed, 18 insertions(+), 5 deletions(-)

(limited to 'src/modlistbypriorityproxy.cpp')

diff --git a/src/modlistbypriorityproxy.cpp b/src/modlistbypriorityproxy.cpp
index addefb6f..a5f8667f 100644
--- a/src/modlistbypriorityproxy.cpp
+++ b/src/modlistbypriorityproxy.cpp
@@ -43,6 +43,7 @@ void ModListByPriorityProxy::buildTree()
 
   TreeItem* root = &m_Root;
   std::unique_ptr<TreeItem> overwrite;
+  std::vector<std::unique_ptr<TreeItem>> backups;
   for (auto& [priority, index] : m_Profile->getAllIndexesByPriority()) {
     ModInfo::Ptr modInfo = ModInfo::getByIndex(index);
 
@@ -58,6 +59,10 @@ void ModListByPriorityProxy::buildTree()
       overwrite = std::make_unique<TreeItem>(modInfo, index, &m_Root);
       item = overwrite.get();
     }
+    else if (modInfo->isBackup()) {
+      backups.push_back(std::make_unique<TreeItem>(modInfo, index, &m_Root));
+      item = backups.back().get();
+    }
     else {
       root->children.push_back(std::make_unique<TreeItem>(modInfo, index, root));
       item = root->children.back().get();
@@ -66,6 +71,8 @@ void ModListByPriorityProxy::buildTree()
     m_IndexToItem[index] = item;
   }
 
+  m_Root.children.insert(m_Root.children.begin(),
+    std::make_move_iterator(backups.begin()), std::make_move_iterator(backups.end()));
   m_Root.children.push_back(std::move(overwrite));
 
   endResetModel();
@@ -101,6 +108,7 @@ QModelIndex ModListByPriorityProxy::mapToSource(const QModelIndex& proxyIndex) c
     return QModelIndex();
   }
   auto* item = static_cast<TreeItem*>(proxyIndex.internalPointer());
+
   return sourceModel()->index(item->index, proxyIndex.column());
 }
 
@@ -124,7 +132,6 @@ int ModListByPriorityProxy::columnCount(const QModelIndex& index) const
   return sourceModel()->columnCount(mapToSource(index));
 }
 
-
 QModelIndex ModListByPriorityProxy::parent(const QModelIndex& child) const
 {
   if (!child.isValid()) {
@@ -137,7 +144,7 @@ QModelIndex ModListByPriorityProxy::parent(const QModelIndex& child) const
     return QModelIndex();
   }
 
-  return createIndex(item->parent->parent->childIndex(item->parent), 0, item->parent);
+  return createIndex(item->parent->parent->childIndex(item->parent), child.column(), item->parent);
 }
 
 bool ModListByPriorityProxy::hasChildren(const QModelIndex& parent) const
@@ -270,6 +277,7 @@ QModelIndex ModListByPriorityProxy::index(int row, int column, const QModelIndex
   else {
     parentItem = static_cast<TreeItem*>(parent.internalPointer());
   }
+
   return createIndex(row, column, parentItem->children[row].get());
 }
 
diff --git a/src/modlistsortproxy.cpp b/src/modlistsortproxy.cpp
index cf82ca74..422fa044 100644
--- a/src/modlistsortproxy.cpp
+++ b/src/modlistsortproxy.cpp
@@ -133,12 +133,17 @@ bool ModListSortProxy::lessThan(const QModelIndex &left,
                                 const QModelIndex &right) const
 {
   if (sourceModel()->hasChildren(left) || sourceModel()->hasChildren(right)) {
-    return QSortFilterProxyModel::lessThan(left, right);
+    // when sorting by priority, we do not want to use the parent lessThan because
+    // it uses the display role which can be inconsistent (e.g. for backups)
+    if (sortColumn() != ModList::COL_PRIORITY) {
+      return QSortFilterProxyModel::lessThan(left, right);
+    }
   }
 
   bool lOk, rOk;
-  int leftIndex  = left.data(Qt::UserRole + 1).toInt(&lOk);
-  int rightIndex = right.data(Qt::UserRole + 1).toInt(&rOk);
+  int leftIndex  = left.data(ModList::IndexRole).toInt(&lOk);
+  int rightIndex = right.data(ModList::IndexRole).toInt(&rOk);
+
   if (!lOk || !rOk) {
     return false;
   }
-- 
cgit v1.3.1


From d979e60aed14b368ac9badf0b88c06f61c17893b Mon Sep 17 00:00:00 2001
From: Mikaël Capelle <capelle.mikael@gmail.com>
Date: Tue, 29 Dec 2020 01:35:02 +0100
Subject: Fix automatic refresh of the collapsible separator proxy.

---
 src/mainwindow.cpp             | 50 ------------------------------------------
 src/mainwindow.h               |  4 ----
 src/modlist.cpp                | 30 +++++++++++++++++++++++++
 src/modlist.h                  |  5 +++++
 src/modlistbypriorityproxy.cpp |  3 ++-
 5 files changed, 37 insertions(+), 55 deletions(-)

(limited to 'src/modlistbypriorityproxy.cpp')

diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index 9ca7e534..1891e496 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -2439,58 +2439,8 @@ void MainWindow::esplist_changed()
   updatePluginCount();
 }
 
-QModelIndex MainWindow::modViewIndexToModel(const QModelIndex& index) const
-{
-  auto sindex = index;
-
-  // remove the sort proxy.
-  sindex = m_ModListSortProxy->mapToSource(index);
-
-  // if there is another proxy
-  if (auto* proxy = qobject_cast<QAbstractProxyModel*>(m_ModListSortProxy->sourceModel())) {
-    sindex = proxy->mapToSource(sindex);
-  }
-
-  return sindex;
-}
-
-QModelIndex MainWindow::modModelIndexToView(const QModelIndex& index) const
-{
-  auto dindex = index;
-
-  // if there is another proxy than the sort
-  if (auto* proxy = qobject_cast<QAbstractProxyModel*>(m_ModListSortProxy->sourceModel())) {
-    dindex = proxy->mapFromSource(dindex);
-  }
-
-  // add the sort proxy
-  dindex = m_ModListSortProxy->mapFromSource(dindex);
-
-  return dindex;
-
-}
-
 void MainWindow::onModPrioritiesChanged(std::vector<int> const& indices)
 {
-  // if we have collapsible separators, we need to refresh, expand if necessary,
-  // and recreate the selection
-  if (m_ModListSortProxy->sourceModel() == m_ModListByPriorityProxy) {
-
-    // manually retain the selection and restore it after
-    QModelIndex current = modViewIndexToModel(ui->modList->currentIndex());
-    std::vector<QModelIndex> selected;
-    for (const auto& idx : ui->modList->selectionModel()->selectedRows()) {
-      selected.push_back(modViewIndexToModel(idx));
-    }
-
-    m_ModListByPriorityProxy->refresh();
-
-    ui->modList->setCurrentIndex(modModelIndexToView(current));
-    for (auto idx : selected) {
-      ui->modList->selectionModel()->select(modModelIndexToView(idx), QItemSelectionModel::Select | QItemSelectionModel::Rows);
-    }
-  }
-
   for (unsigned int i = 0; i < m_OrganizerCore.currentProfile()->numMods(); ++i) {
     int priority = m_OrganizerCore.currentProfile()->getModPriority(i);
     if (m_OrganizerCore.currentProfile()->modEnabled(i)) {
diff --git a/src/mainwindow.h b/src/mainwindow.h
index 61a8b5e3..8dd72174 100644
--- a/src/mainwindow.h
+++ b/src/mainwindow.h
@@ -610,10 +610,6 @@ private slots: // ui slots
 
   void setupModList();
   void updateModListByPriorityProxy();
-
-  // map index from the modlist view to the modlist model, handling proxy
-  QModelIndex modViewIndexToModel(const QModelIndex& index) const;
-  QModelIndex modModelIndexToView(const QModelIndex& index) const;
 };
 
 #endif // MAINWINDOW_H
diff --git a/src/modlist.cpp b/src/modlist.cpp
index 8c14d509..1f2f1171 100644
--- a/src/modlist.cpp
+++ b/src/modlist.cpp
@@ -1493,14 +1493,33 @@ QString ModList::getColumnToolTip(int column) const
   }
 }
 
+QModelIndex ModList::indexToProxy(QAbstractItemModel* proxyModel, const QModelIndex& index)
+{
+  if (!proxyModel) {
+    return QModelIndex();
+  }
+
+  if (proxyModel == this) {
+    return index;
+  }
+
+  if (auto* proxy = qobject_cast<QAbstractProxyModel*>(proxyModel)) {
+    return proxy->mapFromSource(indexToProxy(proxy->sourceModel(), index));
+  }
+
+  return QModelIndex();
+}
 
 bool ModList::moveSelection(QAbstractItemView *itemView, int direction)
 {
   QItemSelectionModel *selectionModel = itemView->selectionModel();
+  int currentIndex = itemView->currentIndex().data(IndexRole).toInt();
 
   const QAbstractProxyModel *proxyModel = qobject_cast<const QAbstractProxyModel*>(selectionModel->model());
   const QSortFilterProxyModel *filterModel = nullptr;
 
+  emit layoutAboutToBeChanged();
+
   while ((filterModel == nullptr) && (proxyModel != nullptr)) {
     filterModel = qobject_cast<const QSortFilterProxyModel*>(proxyModel);
     if (filterModel == nullptr) {
@@ -1534,7 +1553,18 @@ bool ModList::moveSelection(QAbstractItemView *itemView, int direction)
     }
   }
 
+  emit layoutChanged();
+
   emit modPrioritiesChanged(allIndex);
+
+  // reset the selection and the index
+  itemView->setCurrentIndex(indexToProxy(itemView->model(), index(currentIndex, 0)));
+  for (auto idx : allIndex) {
+    itemView->selectionModel()->select(
+      indexToProxy(itemView->selectionModel()->model(), index(idx, 0)),
+      QItemSelectionModel::Select | QItemSelectionModel::Rows);
+  }
+
   return true;
 }
 
diff --git a/src/modlist.h b/src/modlist.h
index 83e8ec9c..edf7d53a 100644
--- a/src/modlist.h
+++ b/src/modlist.h
@@ -371,6 +371,11 @@ private:
 
 private:
 
+  // convert an index of the modlist to an index for the given model, assuming
+  // the given model is a proxy (of a proxy (of... )) the modlist
+  //
+  QModelIndex indexToProxy(QAbstractItemModel* proxyModel, const QModelIndex& index);
+
   // retrieve the relative path of file and its origin given a URL from Mime data
   // returns an empty optional if the URL is not a valid file for dropping
   //
diff --git a/src/modlistbypriorityproxy.cpp b/src/modlistbypriorityproxy.cpp
index a5f8667f..0b73ba78 100644
--- a/src/modlistbypriorityproxy.cpp
+++ b/src/modlistbypriorityproxy.cpp
@@ -20,8 +20,9 @@ void ModListByPriorityProxy::setSourceModel(QAbstractItemModel* model)
 
   if (sourceModel()) {
     m_CollapsedItems.clear();
+    connect(sourceModel(), &QAbstractItemModel::layoutChanged, this, [this]() { buildTree(); }, Qt::UniqueConnection);
     connect(sourceModel(), &QAbstractItemModel::rowsRemoved, this, [this]() { buildTree(); }, Qt::UniqueConnection);
-    // connect(sourceModel(), &QAbstractItemModel::modelReset, this, &ModListByPriorityProxy::buildTree, Qt::UniqueConnection);
+    connect(sourceModel(), &QAbstractItemModel::modelReset, this, &ModListByPriorityProxy::buildTree, Qt::UniqueConnection);
     refresh();
   }
 }
-- 
cgit v1.3.1


From e5744941aed23a160c7329be0f2cb79af7d3a928 Mon Sep 17 00:00:00 2001
From: Mikaël Capelle <capelle.mikael@gmail.com>
Date: Tue, 29 Dec 2020 12:18:40 +0100
Subject: Fix dropping below/above separators.

---
 src/mainwindow.cpp             |  1 +
 src/modlistbypriorityproxy.cpp | 18 +++++++++++++++++-
 src/modlistbypriorityproxy.h   |  3 +++
 src/modlistview.cpp            | 10 ++++++----
 src/modlistview.h              | 24 +++++++++++++++++++-----
 5 files changed, 46 insertions(+), 10 deletions(-)

(limited to 'src/modlistbypriorityproxy.cpp')

diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index d083330f..7c72f132 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -582,6 +582,7 @@ void MainWindow::setupModList()
   ui->modList->sortByColumn(ModList::COL_PRIORITY, Qt::AscendingOrder);
 
   connect(ui->modList, &ModListView::dragEntered, m_OrganizerCore.modList(), &ModList::onDragEnter);
+  connect(ui->modList, &ModListView::dropEntered, m_ModListByPriorityProxy, &ModListByPriorityProxy::onDropEnter);
   connect(m_OrganizerCore.modList(), &ModList::modPrioritiesChanged, this, &MainWindow::onModPrioritiesChanged);
 
   connect(
diff --git a/src/modlistbypriorityproxy.cpp b/src/modlistbypriorityproxy.cpp
index 0b73ba78..756d3bcf 100644
--- a/src/modlistbypriorityproxy.cpp
+++ b/src/modlistbypriorityproxy.cpp
@@ -215,8 +215,13 @@ bool ModListByPriorityProxy::canDropMimeData(const QMimeData* data, Qt::DropActi
       return false;
     }
 
+    // if the previous row is a collapsed separator, disable dropping
     if (row > 0 && m_Root.children[row - 1]->mod->isSeparator()) {
-      if (m_Root.children[row]->mod->isSeparator() || m_Root.children[row]->mod->isOverwrite()) {
+      // we cannot use the name of the mod directly because it does not exactly
+      // match the display value (e.g. for separators)
+      QString display = sourceModel()->index(m_Root.children[row - 1]->index, ModList::COL_NAME).data(Qt::DisplayRole).toString();
+      if (m_CollapsedItems.contains(display)
+        && (m_Root.children[row]->mod->isSeparator() || m_Root.children[row]->mod->isOverwrite())) {
         return false;
       }
     }
@@ -240,6 +245,12 @@ bool ModListByPriorityProxy::dropMimeData(const QMimeData* data, Qt::DropAction
       if (!parent.isValid()) {
         if (row < m_Root.children.size()) {
           sourceRow = m_Root.children[row]->index;
+          if (row > 0
+            && m_Root.children[row - 1]->mod->isSeparator()
+            && !m_Root.children[row - 1]->children.empty()
+            && m_DropPosition == ModListView::DropPosition::BelowItem) {
+            sourceRow = m_Root.children[row - 1]->children[0]->index;
+          }
         }
         else {
           sourceRow = ModInfo::getNumMods();
@@ -282,6 +293,11 @@ QModelIndex ModListByPriorityProxy::index(int row, int column, const QModelIndex
   return createIndex(row, column, parentItem->children[row].get());
 }
 
+void ModListByPriorityProxy::onDropEnter(const QMimeData*, ModListView::DropPosition dropPosition)
+{
+  m_DropPosition = dropPosition;
+}
+
 void ModListByPriorityProxy::expanded(const QModelIndex& index)
 {
   auto it = m_CollapsedItems.find(index.data(Qt::DisplayRole).toString());
diff --git a/src/modlistbypriorityproxy.h b/src/modlistbypriorityproxy.h
index 19d79f7f..cb50352f 100644
--- a/src/modlistbypriorityproxy.h
+++ b/src/modlistbypriorityproxy.h
@@ -13,6 +13,7 @@
 #include <QSet>
 
 #include "modinfo.h"
+#include "modlistview.h"
 
 class ModList;
 class Profile;
@@ -48,6 +49,7 @@ signals:
 
 public slots:
 
+  void onDropEnter(const QMimeData* data, ModListView::DropPosition dropPosition);
   void expanded(const QModelIndex& index);
   void collapsed(const QModelIndex& index);
 
@@ -82,6 +84,7 @@ private:
 
 private:
   Profile* m_Profile;
+  ModListView::DropPosition m_DropPosition = ModListView::DropPosition::OnItem;
 };
 
 #endif //GROUPINGPROXY_H
diff --git a/src/modlistview.cpp b/src/modlistview.cpp
index e966ce4e..b1cce82e 100644
--- a/src/modlistview.cpp
+++ b/src/modlistview.cpp
@@ -3,16 +3,16 @@
 #include <QUrl>
 #include <QMimeData>
 
-ModListView::ModListView(QWidget *parent)
+ModListView::ModListView(QWidget* parent)
   : QTreeView(parent)
-  , m_Scrollbar(new ViewMarkingScrollBar(this->model(), this))
+  , m_scrollbar(new ViewMarkingScrollBar(this->model(), this))
 {
-  setVerticalScrollBar(m_Scrollbar);
+  setVerticalScrollBar(m_scrollbar);
   MOBase::setCustomizableColumns(this);
   setAutoExpandDelay(500);
 }
 
-void ModListView::setModel(QAbstractItemModel *model)
+void ModListView::setModel(QAbstractItemModel* model)
 {
   QTreeView::setModel(model);
   setVerticalScrollBar(new ViewMarkingScrollBar(model, this));
@@ -38,6 +38,8 @@ void ModListView::dragMoveEvent(QDragMoveEvent* event)
 
 void ModListView::dropEvent(QDropEvent* event)
 {
+  emit dropEntered(event->mimeData(), static_cast<DropPosition>(dropIndicatorPosition()));
+
   m_inDragMoveEvent = true;
   QTreeView::dropEvent(event);
   m_inDragMoveEvent = false;
diff --git a/src/modlistview.h b/src/modlistview.h
index c6d42d2d..af608427 100644
--- a/src/modlistview.h
+++ b/src/modlistview.h
@@ -8,19 +8,32 @@
 class ModListView : public QTreeView
 {
   Q_OBJECT
+
 public:
-  explicit ModListView(QWidget *parent = 0);
-  void setModel(QAbstractItemModel *model) override;
 
-  QModelIndexList selectedIndexes() const;
+  // this is a public version of DropIndicatorPosition
+  enum DropPosition {
+    OnItem = DropIndicatorPosition::OnItem,
+    AboveItem = DropIndicatorPosition::AboveItem,
+    BelowItem = DropIndicatorPosition::BelowItem,
+    OnViewport = DropIndicatorPosition::OnViewport
+  };
+
+public:
+  explicit ModListView(QWidget* parent = 0);
+  void setModel(QAbstractItemModel* model) override;
 
 signals:
 
   void dragEntered(const QMimeData* mimeData);
+  void dropEntered(const QMimeData* mimeData, DropPosition position);
 
 protected:
 
-  bool m_inDragMoveEvent = false;
+  // re-implemented to fake the return value to allow drag-and-drop on
+  // itself for separators
+  //
+  QModelIndexList selectedIndexes() const;
 
   void dragEnterEvent(QDragEnterEvent* event) override;
   void dragMoveEvent(QDragMoveEvent* event) override;
@@ -28,7 +41,8 @@ protected:
 
 private:
 
-  ViewMarkingScrollBar *m_Scrollbar;
+  ViewMarkingScrollBar* m_scrollbar;
+  bool m_inDragMoveEvent = false;
 
 };
 
-- 
cgit v1.3.1


From f923de39e071b48bc1437fa4c79c22b3bc9b0583 Mon Sep 17 00:00:00 2001
From: Mikaël Capelle <capelle.mikael@gmail.com>
Date: Tue, 29 Dec 2020 13:27:29 +0100
Subject: Maintain selection while filtering.

---
 src/mainwindow.cpp             | 14 +++++++++-----
 src/modlistbypriorityproxy.cpp |  7 ++++++-
 src/modlistbypriorityproxy.h   |  9 +++++++--
 3 files changed, 22 insertions(+), 8 deletions(-)

(limited to 'src/modlistbypriorityproxy.cpp')

diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index 7c72f132..69e2d989 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -422,10 +422,6 @@ MainWindow::MainWindow(Settings &settings
 
   connect(&m_PluginContainer, SIGNAL(diagnosisUpdate()), this, SLOT(scheduleCheckForProblems()));
 
-  connect(m_ModListSortProxy, SIGNAL(filterActive(bool)), this, SLOT(modFilterActive(bool)));
-  connect(m_ModListSortProxy, SIGNAL(layoutChanged()), this, SLOT(updateModCount()));
-  connect(ui->modFilterEdit, SIGNAL(textChanged(QString)), m_ModListSortProxy, SLOT(updateFilter(QString)));
-
   connect(ui->espFilterEdit, SIGNAL(textChanged(QString)), m_PluginListSortProxy, SLOT(updateFilter(QString)));
   connect(ui->espFilterEdit, SIGNAL(textChanged(QString)), this, SLOT(espFilterChanged(QString)));
 
@@ -659,6 +655,15 @@ void MainWindow::setupModList()
   connect(m_OrganizerCore.modList(), &ModList::downloadArchiveDropped, this, [this](int row, int priority) {
     m_OrganizerCore.installDownload(row, priority);
   });
+
+  connect(m_ModListSortProxy, &ModListSortProxy::filterActive, this, &MainWindow::modFilterActive);
+  connect(ui->modFilterEdit, &QLineEdit::textChanged, m_ModListSortProxy, &ModListSortProxy::updateFilter);
+  connect(m_ModListSortProxy, &QAbstractItemModel::layoutChanged, this, &MainWindow::updateModCount);
+  connect(m_ModListSortProxy, &QAbstractItemModel::layoutChanged, this, [&]() {
+    if (m_ModListSortProxy->sourceModel() == m_ModListByPriorityProxy) {
+      m_ModListByPriorityProxy->refreshExpandedItems();
+    }
+  });
 }
 
 void MainWindow::resetActionIcons()
@@ -5835,7 +5840,6 @@ void MainWindow::onFiltersCriteria(const std::vector<ModListSortProxy::Criteria>
   }
 
   ui->currentCategoryLabel->setText(label);
-  ui->modList->reset();
 }
 
 void MainWindow::onFiltersOptions(
diff --git a/src/modlistbypriorityproxy.cpp b/src/modlistbypriorityproxy.cpp
index 756d3bcf..86664213 100644
--- a/src/modlistbypriorityproxy.cpp
+++ b/src/modlistbypriorityproxy.cpp
@@ -82,7 +82,7 @@ void ModListByPriorityProxy::buildTree()
   expandItems(QModelIndex());
 }
 
-void ModListByPriorityProxy::expandItems(const QModelIndex& index)
+void ModListByPriorityProxy::expandItems(const QModelIndex& index) const
 {
   for (int row = 0; row < rowCount(index); row++) {
     QModelIndex idx = this->index(row, 0, index);
@@ -298,6 +298,11 @@ void ModListByPriorityProxy::onDropEnter(const QMimeData*, ModListView::DropPosi
   m_DropPosition = dropPosition;
 }
 
+void ModListByPriorityProxy::refreshExpandedItems() const
+{
+  expandItems(QModelIndex());
+}
+
 void ModListByPriorityProxy::expanded(const QModelIndex& index)
 {
   auto it = m_CollapsedItems.find(index.data(Qt::DisplayRole).toString());
diff --git a/src/modlistbypriorityproxy.h b/src/modlistbypriorityproxy.h
index cb50352f..26f60bc7 100644
--- a/src/modlistbypriorityproxy.h
+++ b/src/modlistbypriorityproxy.h
@@ -44,8 +44,13 @@ public:
   QModelIndex mapFromSource(const QModelIndex& sourceIndex) const override;
   QModelIndex mapToSource(const QModelIndex& proxyIndex) const override;
 
+  // check the internal state for expanded/collapse items and emit a expandItem
+  // signal for each of the expanded item, useful to refresh the tree state after
+  // layout modification
+  void refreshExpandedItems() const;
+
 signals:
-  void expandItem(const QModelIndex& index);
+  void expandItem(const QModelIndex& index) const;
 
 public slots:
 
@@ -56,7 +61,7 @@ public slots:
 private:
 
   void buildTree();
-  void expandItems(const QModelIndex& index);
+  void expandItems(const QModelIndex& index) const;
 
   struct TreeItem {
     ModInfo::Ptr mod;
-- 
cgit v1.3.1


From 4ee3d2848e0fc2f32543f7d2aeaed22d77d937bd Mon Sep 17 00:00:00 2001
From: Mikaël Capelle <capelle.mikael@gmail.com>
Date: Tue, 29 Dec 2020 13:56:04 +0100
Subject: Prevent dropping mods into their current separator.

---
 src/modlistbypriorityproxy.cpp | 20 ++++++++++++++++----
 1 file changed, 16 insertions(+), 4 deletions(-)

(limited to 'src/modlistbypriorityproxy.cpp')

diff --git a/src/modlistbypriorityproxy.cpp b/src/modlistbypriorityproxy.cpp
index 86664213..f898b85b 100644
--- a/src/modlistbypriorityproxy.cpp
+++ b/src/modlistbypriorityproxy.cpp
@@ -172,6 +172,7 @@ bool ModListByPriorityProxy::setData(const QModelIndex& index, const QVariant& v
 
 bool ModListByPriorityProxy::canDropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) const
 {
+  std::vector<int> sourceRows;
   bool hasSeparator = false;
   bool firstRowSeparator = false;
 
@@ -181,7 +182,8 @@ bool ModListByPriorityProxy::canDropMimeData(const QMimeData* data, Qt::DropActi
       int firstRowPriority = INT_MAX;
       unsigned int firstRowIndex = -1;
 
-      for (auto sourceRow : ModList::sourceRows(data)) {
+      sourceRows = ModList::sourceRows(data);
+      for (auto sourceRow : sourceRows) {
         hasSeparator = hasSeparator || ModInfo::getByIndex(sourceRow)->isSeparator();
         if (m_Profile->getModPriority(sourceRow) < firstRowPriority) {
           firstRowIndex = sourceRow;
@@ -197,9 +199,19 @@ bool ModListByPriorityProxy::canDropMimeData(const QMimeData* data, Qt::DropActi
   }
 
   // row = -1 and invalid parent means we're dropping onto an item, we don't want to drop
-  // separators onto items
-  if (hasSeparator && row == -1 && parent.isValid()) {
-    return !static_cast<TreeItem*>(parent.internalPointer())->mod->isSeparator();
+  // separators onto items or items into their own separator
+  if (row == -1 && parent.isValid()) {
+    auto* parentItem = static_cast<TreeItem*>(parent.internalPointer());
+    if (hasSeparator) {
+      return !parentItem->mod->isSeparator();
+    }
+
+    for (auto row : sourceRows) {
+      auto it = m_IndexToItem.find(row);
+      if (it != m_IndexToItem.end() && it->second->parent == parentItem) {
+        return false;
+      }
+    }
   }
 
   // first row is a separator, we can drop it anywhere
-- 
cgit v1.3.1


From 373b659dcbcac5dfc081ca7fa5f78788166a4e39 Mon Sep 17 00:00:00 2001
From: Mikaël Capelle <capelle.mikael@gmail.com>
Date: Wed, 30 Dec 2020 00:28:48 +0100
Subject: Fix and move stuff around.

- Move selection-related code from ModList to ModListView.
- Fix move-selection for multi-selection.
- Fix refresh of mod list on toggle selection.
---
 src/mainwindow.cpp             |  52 +--------------
 src/mainwindow.h               |   1 -
 src/modlist.cpp                | 112 +++++++------------------------
 src/modlist.h                  |  19 +-----
 src/modlistbypriorityproxy.cpp |  17 +++++
 src/modlistbypriorityproxy.h   |   4 ++
 src/modlistsortproxy.cpp       |   7 --
 src/modlistsortproxy.h         |   2 -
 src/modlistview.cpp            | 145 +++++++++++++++++++++++++++++++++++++----
 src/modlistview.h              |  11 ++++
 src/organizercore.cpp          |   2 -
 11 files changed, 195 insertions(+), 177 deletions(-)

(limited to 'src/modlistbypriorityproxy.cpp')

diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index 63c9a8be..519799d2 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -540,9 +540,12 @@ void MainWindow::setupModList()
 {
   ui->modList->setup(m_OrganizerCore, ui);
 
+  connect(ui->modList, &ModListView::removeSelectedMods, [=]() { removeMod_clicked(-1); });
+
   // keep here for now
   connect(ui->modList->selectionModel(), &QItemSelectionModel::selectionChanged,
     this, &MainWindow::modlistSelectionsChanged);
+  connect(m_OrganizerCore.modList(), &ModList::modPrioritiesChanged, [&]() { m_ArchiveListWriter.write(); });
 }
 
 void MainWindow::resetActionIcons()
@@ -2280,54 +2283,6 @@ void MainWindow::esplist_changed()
   updatePluginCount();
 }
 
-void MainWindow::onModPrioritiesChanged(std::vector<int> const& indices)
-{
-  for (unsigned int i = 0; i < m_OrganizerCore.currentProfile()->numMods(); ++i) {
-    int priority = m_OrganizerCore.currentProfile()->getModPriority(i);
-    if (m_OrganizerCore.currentProfile()->modEnabled(i)) {
-      ModInfo::Ptr modInfo = ModInfo::getByIndex(i);
-      // priorities in the directory structure are one higher because data is 0
-      m_OrganizerCore.directoryStructure()->getOriginByName(ToWString(modInfo->internalName())).setPriority(priority + 1);
-    }
-  }
-  m_OrganizerCore.refreshBSAList();
-  m_OrganizerCore.currentProfile()->writeModlist();
-  m_ArchiveListWriter.write();
-  m_OrganizerCore.directoryStructure()->getFileRegister()->sortOrigins();
-
-  { // refresh selection
-    QModelIndex current = ui->modList->currentIndex();
-    if (current.isValid()) {
-      ModInfo::Ptr modInfo = ModInfo::getByIndex(current.data(ModList::IndexRole).toInt());
-      // clear caches on all mods conflicting with the moved mod
-      for (int i :  modInfo->getModOverwrite()) {
-        ModInfo::getByIndex(i)->clearCaches();
-      }
-      for (int i :  modInfo->getModOverwritten()) {
-        ModInfo::getByIndex(i)->clearCaches();
-      }
-      for (int i : modInfo->getModArchiveOverwrite()) {
-          ModInfo::getByIndex(i)->clearCaches();
-      }
-      for (int i : modInfo->getModArchiveOverwritten()) {
-          ModInfo::getByIndex(i)->clearCaches();
-      }
-      for (int i : modInfo->getModArchiveLooseOverwrite()) {
-        ModInfo::getByIndex(i)->clearCaches();
-      }
-      for (int i : modInfo->getModArchiveLooseOverwritten()) {
-        ModInfo::getByIndex(i)->clearCaches();
-      }
-      // update conflict check on the moved mod
-      modInfo->doConflictCheck();
-      m_OrganizerCore.modList()->setOverwriteMarkers(modInfo->getModOverwrite(), modInfo->getModOverwritten());
-      m_OrganizerCore.modList()->setArchiveOverwriteMarkers(modInfo->getModArchiveOverwrite(), modInfo->getModArchiveOverwritten());
-      m_OrganizerCore.modList()->setArchiveLooseOverwriteMarkers(modInfo->getModArchiveLooseOverwrite(), modInfo->getModArchiveLooseOverwritten());
-      ui->modList->verticalScrollBar()->repaint();
-    }
-  }
-}
-
 void MainWindow::modInstalled(const QString &modName)
 {
   unsigned int index = ModInfo::getIndex(modName);
@@ -2529,7 +2484,6 @@ void MainWindow::removeMod_clicked(int modIndex)
   }
 }
 
-
 void MainWindow::modRemoved(const QString &fileName)
 {
   if (!fileName.isEmpty() && !QFileInfo(fileName).isAbsolute()) {
diff --git a/src/mainwindow.h b/src/mainwindow.h
index 26355153..97bca68b 100644
--- a/src/mainwindow.h
+++ b/src/mainwindow.h
@@ -148,7 +148,6 @@ public:
   ModInfo::Ptr previousModInList(int modIndex);
 
 public slots:
-  void onModPrioritiesChanged(std::vector<int> const& indices);
   void esplist_changed();
   void refresherProgress(const DirectoryRefreshProgress* p);
 
diff --git a/src/modlist.cpp b/src/modlist.cpp
index 1f2f1171..a192390d 100644
--- a/src/modlist.cpp
+++ b/src/modlist.cpp
@@ -1510,100 +1510,58 @@ QModelIndex ModList::indexToProxy(QAbstractItemModel* proxyModel, const QModelIn
   return QModelIndex();
 }
 
-bool ModList::moveSelection(QAbstractItemView *itemView, int direction)
+void ModList::moveMods(const QModelIndexList& indices, int offset)
 {
-  QItemSelectionModel *selectionModel = itemView->selectionModel();
-  int currentIndex = itemView->currentIndex().data(IndexRole).toInt();
-
-  const QAbstractProxyModel *proxyModel = qobject_cast<const QAbstractProxyModel*>(selectionModel->model());
-  const QSortFilterProxyModel *filterModel = nullptr;
-
-  emit layoutAboutToBeChanged();
-
-  while ((filterModel == nullptr) && (proxyModel != nullptr)) {
-    filterModel = qobject_cast<const QSortFilterProxyModel*>(proxyModel);
-    if (filterModel == nullptr) {
-      proxyModel = qobject_cast<const QAbstractProxyModel*>(proxyModel->sourceModel());
-    }
-  }
-  if (filterModel == nullptr) {
-    return true;
-  }
-
-  int offset = -1;
-  if (((direction < 0) && (filterModel->sortOrder() == Qt::DescendingOrder)) ||
-      ((direction > 0) && (filterModel->sortOrder() == Qt::AscendingOrder))) {
-    offset = 1;
-  }
-
-  QModelIndexList rows = selectionModel->selectedRows();
-  if (direction > 0) {
-    for (int i = 0; i < rows.size() / 2; ++i) {
-      rows.swapItemsAt(i, rows.size() - i - 1);
-    }
-  }
+  // retrieve the mod index and sort them by priority to avoid issue
+  // when moving them
   std::vector<int> allIndex;
-  for (QModelIndex idx : rows) {
+  for (auto& idx : indices) {
     auto index = idx.data(IndexRole).toInt();
     allIndex.push_back(index);
+  }
+  std::sort(allIndex.begin(), allIndex.end(), [=](int lhs, int rhs) {
+    bool cmp = m_Profile->getModPriority(lhs) < m_Profile->getModPriority(rhs);
+    return offset > 0 ? !cmp : cmp;
+  });
+
+  emit layoutAboutToBeChanged();
+
+  std::vector<int> notify;
+  for (auto index : allIndex) {
     int newPriority = m_Profile->getModPriority(index) + offset;
     if ((newPriority >= 0) && (newPriority < static_cast<int>(m_Profile->numRegularMods()))) {
       m_Profile->setModPriority(index, newPriority);
-      notifyChange(index);
+      notify.push_back(index);
     }
   }
 
   emit layoutChanged();
 
-  emit modPrioritiesChanged(allIndex);
-
-  // reset the selection and the index
-  itemView->setCurrentIndex(indexToProxy(itemView->model(), index(currentIndex, 0)));
-  for (auto idx : allIndex) {
-    itemView->selectionModel()->select(
-      indexToProxy(itemView->selectionModel()->model(), index(idx, 0)),
-      QItemSelectionModel::Select | QItemSelectionModel::Rows);
+  for (auto index : notify) {
+    notifyChange(index);
   }
 
-  return true;
-}
-
-bool ModList::deleteSelection(QAbstractItemView *itemView)
-{
-  QItemSelectionModel *selectionModel = itemView->selectionModel();
-
-  QModelIndexList rows = selectionModel->selectedRows();
-  if (rows.count() > 1) {
-    emit removeSelectedMods();
-  } else if (rows.count() == 1) {
-    removeRow(rows[0].data(IndexRole).toInt(), QModelIndex());
-  }
-  return true;
+  emit modPrioritiesChanged(allIndex);
 }
 
-bool ModList::toggleSelection(QAbstractItemView *itemView)
+bool ModList::toggleState(const QModelIndexList& indices)
 {
   emit aboutToChangeData();
 
-  QItemSelectionModel *selectionModel = itemView->selectionModel();
-
   QList<unsigned int> modsToEnable;
   QList<unsigned int> modsToDisable;
-  QModelIndexList dirtyMods;
-  for (QModelIndex idx : selectionModel->selectedRows()) {
-    int modId = idx.data(IndexRole).toInt();
-    if (m_Profile->modEnabled(modId)) {
-      modsToDisable.append(modId);
-      dirtyMods.append(idx);
+  for (auto index : indices) {
+    auto idx = index.data(IndexRole).toInt();
+    if (m_Profile->modEnabled(idx)) {
+      modsToDisable.append(idx);
     } else {
-      modsToEnable.append(modId);
-      dirtyMods.append(idx);
+      modsToEnable.append(idx);
     }
   }
 
   m_Profile->setModsEnabled(modsToEnable, modsToDisable);
 
-  emit modlistChanged(dirtyMods, 0);
+  emit modlistChanged(indices, 0);
   emit tutorialModlistUpdate();
 
   m_Modified = true;
@@ -1616,26 +1574,6 @@ bool ModList::toggleSelection(QAbstractItemView *itemView)
   return true;
 }
 
-bool ModList::eventFilter(QObject *obj, QEvent *event)
-{
-  if ((event->type() == QEvent::KeyPress) && (m_Profile != nullptr)) {
-    QAbstractItemView *itemView = qobject_cast<QAbstractItemView*>(obj);
-    QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);
-
-    if ((itemView != nullptr)
-        && (keyEvent->modifiers() == Qt::ControlModifier)
-        && ((keyEvent->key() == Qt::Key_Up) || (keyEvent->key() == Qt::Key_Down))) {
-      return moveSelection(itemView, keyEvent->key() == Qt::Key_Up ? -1 : 1);
-    } else if (keyEvent->key() == Qt::Key_Delete) {
-      return deleteSelection(itemView);
-    } else if (keyEvent->key() == Qt::Key_Space) {
-      return toggleSelection(itemView);
-    }
-    return QAbstractItemModel::eventFilter(obj, event);
-  }
-  return QAbstractItemModel::eventFilter(obj, event);
-}
-
 //note: caller needs to make sure sort proxy is updated
 void ModList::enableSelected(const QItemSelectionModel *selectionModel)
 {
diff --git a/src/modlist.h b/src/modlist.h
index edf7d53a..778f1fee 100644
--- a/src/modlist.h
+++ b/src/modlist.h
@@ -221,6 +221,9 @@ public slots:
   void enableSelected(const QItemSelectionModel *selectionModel);
   void disableSelected(const QItemSelectionModel *selectionModel);
 
+  void moveMods(const QModelIndexList& indices, int offset);
+  bool toggleState(const QModelIndexList& indices);
+
 signals:
 
   /**
@@ -290,11 +293,6 @@ signals:
    */
   void tutorialModlistUpdate();
 
-  /**
-   * @brief emitted to have all selected mods deleted
-   */
-  void removeSelectedMods();
-
   /**
    * @brief fileMoved emitted when a file is moved from one mod to another
    * @param relativePath relative path of the file moved
@@ -316,11 +314,6 @@ signals:
   // download list
   void downloadArchiveDropped(int row, int priority);
 
-protected:
-
-  // event filter, handles event from the header and the tree view itself
-  bool eventFilter(QObject *obj, QEvent *event);
-
 private:
 
   QVariant getOverwriteData(int column, int role) const;
@@ -344,12 +337,6 @@ private:
 
   MOBase::IModList::ModStates state(unsigned int modIndex) const;
 
-  bool moveSelection(QAbstractItemView *itemView, int direction);
-
-  bool deleteSelection(QAbstractItemView *itemView);
-
-  bool toggleSelection(QAbstractItemView *itemView);
-
 private slots:
 
 private:
diff --git a/src/modlistbypriorityproxy.cpp b/src/modlistbypriorityproxy.cpp
index f898b85b..dc16d8ea 100644
--- a/src/modlistbypriorityproxy.cpp
+++ b/src/modlistbypriorityproxy.cpp
@@ -23,6 +23,7 @@ void ModListByPriorityProxy::setSourceModel(QAbstractItemModel* model)
     connect(sourceModel(), &QAbstractItemModel::layoutChanged, this, [this]() { buildTree(); }, Qt::UniqueConnection);
     connect(sourceModel(), &QAbstractItemModel::rowsRemoved, this, [this]() { buildTree(); }, Qt::UniqueConnection);
     connect(sourceModel(), &QAbstractItemModel::modelReset, this, &ModListByPriorityProxy::buildTree, Qt::UniqueConnection);
+    connect(sourceModel(), &QAbstractItemModel::dataChanged, this, &ModListByPriorityProxy::modelDataChanged, Qt::UniqueConnection);
     refresh();
   }
 }
@@ -93,6 +94,22 @@ void ModListByPriorityProxy::expandItems(const QModelIndex& index) const
   }
 }
 
+void ModListByPriorityProxy::modelDataChanged(const QModelIndex& topLeft, const QModelIndex& bottomRight, const QVector<int>& roles)
+{
+  QModelIndex proxyTopLeft = mapFromSource(topLeft);
+  if (!proxyTopLeft.isValid()) {
+    return;
+  }
+
+  if (topLeft == bottomRight) {
+    emit dataChanged(proxyTopLeft, proxyTopLeft);
+  }
+  else {
+    QModelIndex proxyBottomRight = mapFromSource(bottomRight);
+    emit dataChanged(proxyTopLeft, proxyBottomRight);
+  }
+}
+
 QModelIndex ModListByPriorityProxy::mapFromSource(const QModelIndex& sourceIndex) const
 {
   if (!sourceIndex.isValid()) {
diff --git a/src/modlistbypriorityproxy.h b/src/modlistbypriorityproxy.h
index 26f60bc7..00848e2a 100644
--- a/src/modlistbypriorityproxy.h
+++ b/src/modlistbypriorityproxy.h
@@ -58,6 +58,10 @@ public slots:
   void expanded(const QModelIndex& index);
   void collapsed(const QModelIndex& index);
 
+protected:
+
+  void modelDataChanged(const QModelIndex& topLeft, const QModelIndex& bottomRight, const QVector<int>& roles = QVector<int>());
+
 private:
 
   void buildTree();
diff --git a/src/modlistsortproxy.cpp b/src/modlistsortproxy.cpp
index a7d0b27a..ed752d7a 100644
--- a/src/modlistsortproxy.cpp
+++ b/src/modlistsortproxy.cpp
@@ -73,13 +73,6 @@ void ModListSortProxy::setCriteria(const std::vector<Criteria>& criteria)
   }
 }
 
-Qt::ItemFlags ModListSortProxy::flags(const QModelIndex &modelIndex) const
-{
-  Qt::ItemFlags flags = sourceModel()->flags(mapToSource(modelIndex));
-
-  return flags;
-}
-
 unsigned long ModListSortProxy::flagsId(const std::vector<ModInfo::EFlag> &flags) const
 {
   unsigned long result = 0;
diff --git a/src/modlistsortproxy.h b/src/modlistsortproxy.h
index 9a4140f6..fed05188 100644
--- a/src/modlistsortproxy.h
+++ b/src/modlistsortproxy.h
@@ -77,8 +77,6 @@ public:
 
   void setProfile(Profile *profile);
 
-
-  Qt::ItemFlags flags(const QModelIndex &modelIndex) const override;
   bool canDropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) const override;
   bool dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent) override;
 
diff --git a/src/modlistview.cpp b/src/modlistview.cpp
index dbd09884..bda7ac4d 100644
--- a/src/modlistview.cpp
+++ b/src/modlistview.cpp
@@ -5,6 +5,8 @@
 
 #include <widgetutility.h>
 
+#include <utility.h>
+
 #include "ui_mainwindow.h"
 
 #include "organizercore.h"
@@ -15,6 +17,8 @@
 #include "modflagicondelegate.h"
 #include "modconflicticondelegate.h"
 #include "genericicondelegate.h"
+#include "shared/directoryentry.h"
+#include "shared/filesorigin.h"
 
 class ModListProxyStyle : public QProxyStyle {
 public:
@@ -346,18 +350,63 @@ void ModListView::expandItem(const QModelIndex& index) {
 
 void ModListView::onModPrioritiesChanged(std::vector<int> const& indices)
 {
-  if (m_sortProxy != nullptr) {
     // expand separator whose priority has changed
-    if (hasCollapsibleSeparators()) {
-      for (auto index : indices) {
-        ModInfo::Ptr modInfo = ModInfo::getByIndex(index);
-        if (modInfo->isSeparator()) {
-          expand(indexModelToView(m_core->modList()->index(index, 0)));
-        }
+  if (hasCollapsibleSeparators()) {
+    for (auto index : indices) {
+      ModInfo::Ptr modInfo = ModInfo::getByIndex(index);
+      if (modInfo->isSeparator()) {
+        expand(indexModelToView(m_core->modList()->index(index, 0)));
       }
     }
+  }
+
+  for (unsigned int i = 0; i < m_core->currentProfile()->numMods(); ++i) {
+    int priority = m_core->currentProfile()->getModPriority(i);
+    if (m_core->currentProfile()->modEnabled(i)) {
+      ModInfo::Ptr modInfo = ModInfo::getByIndex(i);
+      // priorities in the directory structure are one higher because data is 0
+      m_core->directoryStructure()->getOriginByName(MOBase::ToWString(modInfo->internalName())).setPriority(priority + 1);
+    }
+  }
+  m_core->refreshBSAList();
+  m_core->currentProfile()->writeModlist();
+  m_core->directoryStructure()->getFileRegister()->sortOrigins();
+
+  if (m_sortProxy) {
     m_sortProxy->invalidate();
   }
+
+  { // refresh selection
+    QModelIndex current = currentIndex();
+    if (current.isValid()) {
+      ModInfo::Ptr modInfo = ModInfo::getByIndex(current.data(ModList::IndexRole).toInt());
+      // clear caches on all mods conflicting with the moved mod
+      for (int i : modInfo->getModOverwrite()) {
+        ModInfo::getByIndex(i)->clearCaches();
+      }
+      for (int i : modInfo->getModOverwritten()) {
+        ModInfo::getByIndex(i)->clearCaches();
+      }
+      for (int i : modInfo->getModArchiveOverwrite()) {
+        ModInfo::getByIndex(i)->clearCaches();
+      }
+      for (int i : modInfo->getModArchiveOverwritten()) {
+        ModInfo::getByIndex(i)->clearCaches();
+      }
+      for (int i : modInfo->getModArchiveLooseOverwrite()) {
+        ModInfo::getByIndex(i)->clearCaches();
+      }
+      for (int i : modInfo->getModArchiveLooseOverwritten()) {
+        ModInfo::getByIndex(i)->clearCaches();
+      }
+      // update conflict check on the moved mod
+      modInfo->doConflictCheck();
+      m_core->modList()->setOverwriteMarkers(modInfo->getModOverwrite(), modInfo->getModOverwritten());
+      m_core->modList()->setArchiveOverwriteMarkers(modInfo->getModArchiveOverwrite(), modInfo->getModArchiveOverwritten());
+      m_core->modList()->setArchiveLooseOverwriteMarkers(modInfo->getModArchiveLooseOverwrite(), modInfo->getModArchiveLooseOverwritten());
+      verticalScrollBar()->repaint();
+    }
+  }
 }
 
 void ModListView::onModInstalled(const QString& modName)
@@ -573,9 +622,6 @@ void ModListView::setup(OrganizerCore& core, Ui::MainWindow* mwui)
   setItemDelegateForColumn(ModList::COL_CONFLICTFLAGS, conflictFlagDelegate);
   setItemDelegateForColumn(ModList::COL_CONTENT, contentDelegate);
 
-  // TODO: Check if this is really useful.
-  header()->installEventFilter(m_core->modList());
-
   if (m_core->settings().geometry().restoreState(header())) {
     // hack: force the resize-signal to be triggered because restoreState doesn't seem to do that
     for (int column = 0; column <= ModList::COL_LASTCOLUMN; ++column) {
@@ -603,9 +649,6 @@ void ModListView::setup(OrganizerCore& core, Ui::MainWindow* mwui)
   // prevent the name-column from being hidden
   header()->setSectionHidden(ModList::COL_NAME, false);
 
-  // TODO: Move the event filter in ModListView.
-  installEventFilter(core.modList());
-
   connect(m_core->modList(), &ModList::downloadArchiveDropped, this, [this](int row, int priority) {
     m_core->installDownload(row, priority);
   });
@@ -684,3 +727,79 @@ void ModListView::timerEvent(QTimerEvent* event)
     QTreeView::timerEvent(event);
   }
 }
+
+bool ModListView::moveSelection(int key)
+{
+  QModelIndex cindex = indexViewToModel(currentIndex());
+  QModelIndexList sourceRows;
+  for (auto& index : selectionModel()->selectedRows()) {
+    sourceRows.append(indexViewToModel(index));
+  }
+
+  int offset = key == Qt::Key_Up ? -1 : 1;
+  if (m_sortProxy->sortOrder() == Qt::DescendingOrder) {
+    offset = -offset;
+  }
+
+  m_core->modList()->moveMods(sourceRows, offset);
+
+  // reset the selection and the index
+  setCurrentIndex(indexModelToView(cindex));
+  for (auto idx : sourceRows) {
+    selectionModel()->select(indexModelToView(idx), QItemSelectionModel::Select | QItemSelectionModel::Rows);
+  }
+
+  return true;
+}
+
+bool ModListView::removeSelection()
+{
+  if (selectionModel()->hasSelection()) {
+    QModelIndexList rows = selectionModel()->selectedRows();
+    if (rows.count() > 1) {
+      emit removeSelectedMods();
+    }
+    else if (rows.count() == 1) {
+      // this does not work, I don't know why
+      // model()->removeRow(rows[0].row(), rows[0].parent());
+      m_core->modList()->removeRow(indexViewToModel(rows[0]).row());
+    }
+  }
+  return true;
+}
+
+bool ModListView::toggleSelectionState()
+{
+  if (!selectionModel()->hasSelection()) {
+    return true;
+  }
+
+  QModelIndexList selected;
+  for (QModelIndex idx : selectionModel()->selectedRows()) {
+    selected.append(indexViewToModel(idx));
+  }
+
+  return m_core->modList()->toggleState(selected);
+}
+
+bool ModListView::event(QEvent* event)
+{
+  Profile* profile = m_core->currentProfile();
+  if (event->type() == QEvent::KeyPress && profile) {
+    QKeyEvent* keyEvent = static_cast<QKeyEvent*>(event);
+
+    if (keyEvent->modifiers() == Qt::ControlModifier
+      && sortColumn() == ModList::COL_PRIORITY
+      && (keyEvent->key() == Qt::Key_Up || keyEvent->key() == Qt::Key_Down)) {
+      return moveSelection(keyEvent->key());
+    }
+    else if (keyEvent->key() == Qt::Key_Delete) {
+      return removeSelection();
+    }
+    else if (keyEvent->key() == Qt::Key_Space) {
+      return toggleSelectionState();
+    }
+    return QTreeView::event(event);
+  }
+  return QTreeView::event(event);
+}
diff --git a/src/modlistview.h b/src/modlistview.h
index 2ea5891c..88028428 100644
--- a/src/modlistview.h
+++ b/src/modlistview.h
@@ -74,6 +74,10 @@ signals:
   void dragEntered(const QMimeData* mimeData);
   void dropEntered(const QMimeData* mimeData, DropPosition position);
 
+  // emitted when selected mods must be removed
+  //
+  void removeSelectedMods();
+
 public slots:
 
   // invalidate the top-level model
@@ -121,10 +125,17 @@ protected:
   //
   QModelIndexList selectedIndexes() const;
 
+  bool moveSelection(int key);
+  bool removeSelection();
+  bool toggleSelectionState();
+
   void timerEvent(QTimerEvent* event) override;
   void dragEnterEvent(QDragEnterEvent* event) override;
   void dragMoveEvent(QDragMoveEvent* event) override;
   void dropEvent(QDropEvent* event) override;
+  bool event(QEvent* event) override;
+
+protected slots:
 
 private:
 
diff --git a/src/organizercore.cpp b/src/organizercore.cpp
index ecd4b34e..334a02de 100644
--- a/src/organizercore.cpp
+++ b/src/organizercore.cpp
@@ -249,8 +249,6 @@ void OrganizerCore::setUserInterface(IUserInterface* ui)
             SLOT(modRemoved(QString)));
     connect(&m_InstallationManager, SIGNAL(modReplaced(QString)), w,
             SLOT(modRemoved(QString)));
-    connect(&m_ModList, SIGNAL(removeSelectedMods()), w,
-            SLOT(removeMod_clicked()));
     connect(&m_ModList, SIGNAL(clearOverwrite()), w,
       SLOT(clearOverwrite()));
     connect(&m_ModList, SIGNAL(fileMoved(QString, QString, QString)), w,
-- 
cgit v1.3.1


From eabf64fbc07b457b29aaf5e25fe6e1027b574976 Mon Sep 17 00:00:00 2001
From: Mikaël Capelle <capelle.mikael@gmail.com>
Date: Wed, 30 Dec 2020 16:53:55 +0100
Subject: Clean drag&drop code and add drop of external folder/archives.

---
 src/modlist.cpp                | 270 ++++++++++++++++++++++++-----------------
 src/modlist.h                  |  88 ++++++++++++--
 src/modlistbypriorityproxy.cpp |  90 +++++++-------
 src/modlistbypriorityproxy.h   |   9 +-
 src/modlistsortproxy.cpp       |  12 +-
 src/modlistview.cpp            |  69 +++++++++--
 src/modlistview.h              |   6 +
 src/organizercore.cpp          | 142 ++++++++++++----------
 src/organizercore.h            |   2 +
 9 files changed, 442 insertions(+), 246 deletions(-)

(limited to 'src/modlistbypriorityproxy.cpp')

diff --git a/src/modlist.cpp b/src/modlist.cpp
index dc80bb53..28e20917 100644
--- a/src/modlist.cpp
+++ b/src/modlist.cpp
@@ -61,6 +61,127 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 using namespace MOBase;
 
 
+ModList::DropInfo::DropInfo(const QMimeData* mimeData, OrganizerCore& core) :
+  m_rows{}, m_download{ -1 }, m_localUrls{}, m_url{}
+{
+  // this only check if the drop is valid, not if the content of the drop
+  // matches the target, a drop is valid if either
+  // 1. it contains items from another model (drag&drop in modlist or from download list)
+  // 2. it contains URLs from MO2 (overwrite or from another mod)
+  // 3. it contains a single URL to an external folder
+  // 4. it contains a single URL to a valid archive for MO2
+  try {
+    if (mimeData->hasUrls()) {
+      for (auto& url : mimeData->urls()) {
+        auto p = relativeUrl(url);
+        if (p) {
+          m_localUrls.push_back(*p);
+        }
+      }
+
+      // external drop
+      if (m_localUrls.empty() && mimeData->urls().size() == 1) {
+        auto url = mimeData->urls()[0];
+        if (url.isLocalFile() && !relativeUrl(url)) {
+          QFileInfo info(url.toLocalFile());
+          if (info.isDir()) {
+            m_url = url;
+          }
+          else if (core.installationManager()->getSupportedExtensions().contains(info.suffix(), Qt::CaseInsensitive)) {
+            m_url = url;
+          }
+        }
+      }
+
+    }
+    else if (mimeData->hasText()) {
+      QByteArray encoded = mimeData->data("application/x-qabstractitemmodeldatalist");
+      QDataStream stream(&encoded, QIODevice::ReadOnly);
+
+      while (!stream.atEnd()) {
+        int sourceRow, col;
+        QMap<int, QVariant> roleDataMap;
+        stream >> sourceRow >> col >> roleDataMap;
+        if (col == 0) {
+          m_rows.push_back(sourceRow);
+        }
+      }
+
+      if (mimeData->text() != "mod") {
+        if (mimeData->text() == "archive" && m_rows.size() == 1) {
+          m_download = m_rows[0];
+        }
+        m_rows = {};
+      }
+    }
+  }
+  catch (std::exception const&) {
+    m_rows = {};
+    m_download = -1;
+    m_localUrls.clear();
+    m_url = {};
+  }
+}
+
+std::optional<ModList::DropInfo::RelativeUrl> ModList::DropInfo::relativeUrl(const QUrl& url) const
+{
+  if (!url.isLocalFile()) {
+    return {};
+  }
+
+  QDir allModsDir(Settings::instance().paths().mods());
+  QDir overwriteDir(Settings::instance().paths().overwrite());
+
+  QFileInfo sourceInfo(url.toLocalFile());
+  QString sourceFile = sourceInfo.canonicalFilePath();
+
+  QString relativePath;
+  QString originName;
+
+  if (sourceFile.startsWith(allModsDir.canonicalPath())) {
+    QDir relativeDir(allModsDir.relativeFilePath(sourceFile));
+    QStringList splitPath = relativeDir.path().split("/");
+    originName = splitPath[0];
+    splitPath.pop_front();
+    return { { url, splitPath.join("/"), originName } };
+  }
+  else if (sourceFile.startsWith(overwriteDir.canonicalPath())) {
+    return { { url, overwriteDir.relativeFilePath(sourceFile), ModInfo::getOverwrite()->name() } };
+  }
+
+  return {};
+}
+
+bool ModList::DropInfo::isValid() const
+{
+  return isLocalFileDrop() || isModDrop() || isDownloadDrop() || m_url.isLocalFile();
+}
+
+bool ModList::DropInfo::isLocalFileDrop() const
+{
+  return !m_localUrls.empty();
+}
+
+bool ModList::DropInfo::isModDrop() const
+{
+  return !m_rows.empty();
+}
+
+bool ModList::DropInfo::isDownloadDrop() const
+{
+  return m_download != -1;
+}
+
+bool ModList::DropInfo::isExternalArchiveDrop() const
+{
+  return m_url.isLocalFile() && QFileInfo(m_url.toLocalFile()).isFile();
+}
+
+bool ModList::DropInfo::isExternalFolderDrop() const
+{
+  return m_url.isLocalFile() && QFileInfo(m_url.toLocalFile()).isDir();
+}
+
 ModList::ModList(PluginContainer *pluginContainer, OrganizerCore *organizer)
   : QAbstractItemModel(organizer)
   , m_Organizer(organizer)
@@ -1110,53 +1231,12 @@ int ModList::dropPriority(int row, const QModelIndex& parent) const
   return newPriority;
 }
 
-std::vector<int> ModList::sourceRows(const QMimeData* mimeData)
+ModList::DropInfo ModList::dropInfo(const QMimeData* mimeData) const
 {
-  QByteArray encoded = mimeData->data("application/x-qabstractitemmodeldatalist");
-  QDataStream stream(&encoded, QIODevice::ReadOnly);
-  std::vector<int> sourceRows;
-
-  while (!stream.atEnd()) {
-    int sourceRow, col;
-    QMap<int, QVariant> roleDataMap;
-    stream >> sourceRow >> col >> roleDataMap;
-    if (col == 0) {
-      sourceRows.push_back(sourceRow);
-    }
-  }
-  return sourceRows;
+  return DropInfo(mimeData, *m_Organizer);
 }
 
-std::optional<std::pair<QString, QString>> ModList::relativeUrl(const QUrl& url)
-{
-  if (!url.isLocalFile()) {
-    return {};
-  }
-
-  QDir allModsDir(Settings::instance().paths().mods());
-  QDir overwriteDir(Settings::instance().paths().overwrite());
-
-  QFileInfo sourceInfo(url.toLocalFile());
-  QString sourceFile = sourceInfo.canonicalFilePath();
-
-  QString relativePath;
-  QString originName;
-
-  if (sourceFile.startsWith(allModsDir.canonicalPath())) {
-    QDir relativeDir(allModsDir.relativeFilePath(sourceFile));
-    QStringList splitPath = relativeDir.path().split("/");
-    originName = splitPath[0];
-    splitPath.pop_front();
-    return { { splitPath.join("/"), originName } };
-  }
-  else if (sourceFile.startsWith(overwriteDir.canonicalPath())) {
-    return { { overwriteDir.relativeFilePath(sourceFile), ModInfo::getOverwrite()->name() } };
-  }
-
-  return {};
-}
-
-bool ModList::dropURLs(const QMimeData *mimeData, int row, const QModelIndex &parent)
+bool ModList::dropURLs(const DropInfo& dropInfo, int row, const QModelIndex &parent)
 {
   if (row == -1) {
     row = parent.row();
@@ -1168,23 +1248,15 @@ bool ModList::dropURLs(const QMimeData *mimeData, int row, const QModelIndex &pa
   QStringList targetList;
   QList<QPair<QString,QString>> relativePathList;
 
-  for (auto url : mimeData->urls()) {
-    auto p = relativeUrl(url);
+  for (auto localUrl : dropInfo.localUrls()) {
 
-    if (!p) {
-      log::debug("URL drop ignored: \"{}\" is not a local file or not a known file to MO", url.url());
-      continue;
-    }
-
-    auto [relativePath, originName] = *p;
-
-    QFileInfo sourceInfo(url.toLocalFile());
+    QFileInfo sourceInfo(localUrl.url.toLocalFile());
     QString sourceFile = sourceInfo.canonicalFilePath();
 
-    QFileInfo targetInfo(modDir.absoluteFilePath(relativePath));
+    QFileInfo targetInfo(modDir.absoluteFilePath(localUrl.relativePath));
     sourceList << sourceFile;
     targetList << targetInfo.absoluteFilePath();
-    relativePathList << QPair<QString,QString>(relativePath, originName);
+    relativePathList << QPair<QString,QString>(localUrl.relativePath, localUrl.originName);
   }
 
   if (sourceList.count()) {
@@ -1205,47 +1277,9 @@ bool ModList::dropURLs(const QMimeData *mimeData, int row, const QModelIndex &pa
   return true;
 }
 
-bool ModList::dropMod(const QMimeData *mimeData, int row, const QModelIndex &parent)
-{
-  int newPriority = dropPriority(row, parent);
-  if (newPriority == -1) {
-    return false;
-  }
-
-  try {
-    std::vector<int> sourceRows = ModList::sourceRows(mimeData);
-    changeModPriority(sourceRows, newPriority);
-
-  } catch (const std::exception &e) {
-    reportError(tr("drag&drop failed: %1").arg(e.what()));
-  }
-
-  return false;
-}
-
-bool ModList::dropArchive(const QMimeData* mimeData, int row, const QModelIndex& parent)
-{
-  int priority = dropPriority(row, parent);
-  if (priority == -1) {
-    return false;
-  }
-
-  try {
-    std::vector<int> sourceRows = ModList::sourceRows(mimeData);
-    if (sourceRows.size() == 1) {
-      emit downloadArchiveDropped(sourceRows[0], priority);
-    }
-  }
-  catch (const std::exception& e) {
-    reportError(tr("drag&drop failed: %1").arg(e.what()));
-  }
-
-  return false;
-}
-
 void ModList::onDragEnter(const QMimeData* mimeData)
 {
-  m_DropOnMod = mimeData->hasUrls();
+  m_DropOnMod = dropInfo(mimeData).isLocalFileDrop();
 }
 
 bool ModList::canDropMimeData(const QMimeData* mimeData, Qt::DropAction action, int row, int column, const QModelIndex& parent) const
@@ -1254,18 +1288,15 @@ bool ModList::canDropMimeData(const QMimeData* mimeData, Qt::DropAction action,
     return false;
   }
 
-  if (mimeData->hasUrls()) {
-    for (auto& url : mimeData->urls()) {
-      if (!relativeUrl(url)) {
-        return false;
-      }
-    }
+  DropInfo dropInfo(mimeData, *m_Organizer);
+
+  if (dropInfo.isLocalFileDrop()) {
     if (row == -1 && parent.isValid()) {
       ModInfo::Ptr modInfo = ModInfo::getByIndex(parent.row());
       return modInfo->isRegular() && !modInfo->isSeparator();
     }
   }
-  else if (mimeData->hasText()) {
+  else if (dropInfo.isValid()) {
     // drop on item
     if (row == -1 && parent.isValid()) {
       return true;
@@ -1288,16 +1319,35 @@ bool ModList::dropMimeData(const QMimeData *mimeData, Qt::DropAction action, int
     return true;
   }
 
-  if (m_Profile == nullptr) return false;
+  DropInfo dropInfo(mimeData, *m_Organizer);
 
-  if (mimeData->hasUrls()) {
-    return dropURLs(mimeData, row, parent);
-  } else if (mimeData->hasText()) {
-    if (mimeData->text() == "mod") {
-      return dropMod(mimeData, row, parent);
+  if (!m_Profile || !dropInfo.isValid()) {
+    return false;
+  }
+
+  int dropPriority = this->dropPriority(row, parent);
+  if (dropPriority == -1) {
+    return false;
+  }
+
+  if (dropInfo.isLocalFileDrop()) {
+    return dropURLs(dropInfo, row, parent);
+  }
+  else {
+    if (dropInfo.isModDrop()) {
+      changeModPriority(dropInfo.rows(), dropPriority);
+    }
+    else if (dropInfo.isDownloadDrop()) {
+      emit downloadArchiveDropped(dropInfo.download(), dropPriority);
     }
-    else if (mimeData->text() == "archive") {
-      return dropArchive(mimeData, row, parent);
+    else if (dropInfo.isExternalArchiveDrop()) {
+      emit externalArchiveDropped(dropInfo.externalUrl(), dropPriority);
+    }
+    else if (dropInfo.isExternalFolderDrop()) {
+      emit externalFolderDropped(dropInfo.externalUrl(), dropPriority);
+    }
+    else {
+      return false;
     }
   }
   return false;
diff --git a/src/modlist.h b/src/modlist.h
index 405d9e39..815024b9 100644
--- a/src/modlist.h
+++ b/src/modlist.h
@@ -319,8 +319,17 @@ signals:
 
   // emitted when an item is dropped from the download list, the row is from the
   // download list
+  //
   void downloadArchiveDropped(int row, int priority);
 
+  // emitted when an external archive is dropped on the mod list
+  //
+  void externalArchiveDropped(const QUrl& url, int priority);
+
+  // emitted when an external folder is dropped on the mod list
+  //
+  void externalFolderDropped(const QUrl& url, int priority);
+
 private:
 
   QVariant getOverwriteData(int column, int role) const;
@@ -365,19 +374,79 @@ private:
 
 private:
 
-  // retrieve the relative path of file and its origin given a URL from Mime data
-  // returns an empty optional if the URL is not a valid file for dropping
+  // small class that extract information from mimeData
   //
-  static std::optional<std::pair<QString, QString>> relativeUrl(const QUrl&);
+  class DropInfo {
+  public:
+
+    struct RelativeUrl {
+      const QUrl url;
+      const QString relativePath;
+      const QString originName;
+    };
+
+    // returns true if this drop is valid
+    //
+    bool isValid() const;
+
+    // returns true if these data corresponds to drag&drop
+    // of local files (e.g. from overwrite)
+    //
+    bool isLocalFileDrop() const;
+
+    // returns true if these data corresponds to drag&drop
+    // of mod in the list
+    //
+    bool isModDrop() const;
+
+    // returns true if these data corresponds to drag&drop
+    // from the download list
+    //
+    bool isDownloadDrop() const;
+
+    // returns true if these data corresponds to dropping
+    // an archive for installation
+    //
+    bool isExternalArchiveDrop() const;
+
+    // returns true if these data corresponds to dropping
+    // a folder for copy
+    //
+    bool isExternalFolderDrop() const;
+
+    const auto& rows() const { return m_rows; }
+    const auto& download() const { return m_download; }
+    const auto& localUrls() const { return m_localUrls; }
+    const auto& externalUrl() const { return m_url; }
+
+  private:
+
+    friend class ModList;
+
+    // retrieve the relative path of file and its origin given a URL from Mime data
+    // returns an empty optional if the URL is not a valid file for dropping
+    //
+    std::optional<RelativeUrl> relativeUrl(const QUrl&) const;
+
+  private:
+    DropInfo(const QMimeData* mimeData, OrganizerCore& core);
+
+    // rows for drag&drop between views
+    std::vector<int> m_rows;
+    int m_download; // -1 if invalid
+
+    // local URLs from the data (relative path + origin name)
+    std::vector<RelativeUrl> m_localUrls;
+
+    // external URL
+    QUrl m_url;
+  };
 
-  // return the source rows from the given mime data for drag&drop of mods or
-  // installation archives
+  // create a DropInfo object from the given data
   //
-  static std::vector<int> sourceRows(const QMimeData* mimeData);
+  DropInfo dropInfo(const QMimeData* mimeData) const;
 
-  bool dropURLs(const QMimeData* mimeData, int row, const QModelIndex& parent);
-  bool dropMod(const QMimeData* mimeData, int row, const QModelIndex& parent);
-  bool dropArchive(const QMimeData* mimeData, int row, const QModelIndex& parent);
+  bool dropURLs(const DropInfo& dropInfo, int row, const QModelIndex& parent);
 
   // return the priority of the mod for a drop event
   //
@@ -386,6 +455,7 @@ private:
 private:
 
   friend class ModListProxy;
+  friend class ModListSortProxy;
   friend class ModListByPriorityProxy;
 
   OrganizerCore *m_Organizer;
diff --git a/src/modlistbypriorityproxy.cpp b/src/modlistbypriorityproxy.cpp
index dc16d8ea..b1426422 100644
--- a/src/modlistbypriorityproxy.cpp
+++ b/src/modlistbypriorityproxy.cpp
@@ -2,11 +2,12 @@
 
 #include "modinfo.h"
 #include "profile.h"
+#include "organizercore.h"
 #include "modlist.h"
 #include "log.h"
 
-ModListByPriorityProxy::ModListByPriorityProxy(Profile* profile, QObject* parent) :
-  QAbstractProxyModel(parent), m_Profile(profile)
+ModListByPriorityProxy::ModListByPriorityProxy(Profile* profile, OrganizerCore& core, QObject* parent) :
+  QAbstractProxyModel(parent), m_core(core), m_profile(profile)
 {
 }
 
@@ -33,6 +34,11 @@ void ModListByPriorityProxy::refresh()
   buildTree();
 }
 
+void ModListByPriorityProxy::setProfile(Profile* profile)
+{
+  m_profile = profile;
+}
+
 void ModListByPriorityProxy::buildTree()
 {
   if (!sourceModel()) return;
@@ -46,7 +52,7 @@ void ModListByPriorityProxy::buildTree()
   TreeItem* root = &m_Root;
   std::unique_ptr<TreeItem> overwrite;
   std::vector<std::unique_ptr<TreeItem>> backups;
-  for (auto& [priority, index] : m_Profile->getAllIndexesByPriority()) {
+  for (auto& [priority, index] : m_profile->getAllIndexesByPriority()) {
     ModInfo::Ptr modInfo = ModInfo::getByIndex(index);
 
     TreeItem* item;
@@ -189,51 +195,48 @@ bool ModListByPriorityProxy::setData(const QModelIndex& index, const QVariant& v
 
 bool ModListByPriorityProxy::canDropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) const
 {
-  std::vector<int> sourceRows;
-  bool hasSeparator = false;
-  bool firstRowSeparator = false;
-
-  if (data->hasText()) {
-
-    try {
-      int firstRowPriority = INT_MAX;
-      unsigned int firstRowIndex = -1;
-
-      sourceRows = ModList::sourceRows(data);
-      for (auto sourceRow : sourceRows) {
-        hasSeparator = hasSeparator || ModInfo::getByIndex(sourceRow)->isSeparator();
-        if (m_Profile->getModPriority(sourceRow) < firstRowPriority) {
-          firstRowIndex = sourceRow;
-          firstRowPriority = m_Profile->getModPriority(sourceRow);
-        }
-      }
+  auto dropInfo = m_core.modList()->dropInfo(data);
 
-      firstRowSeparator = firstRowIndex != -1 && ModInfo::getByIndex(firstRowIndex)->isSeparator();
-    }
-    catch (std::exception const&) {
-
-    }
+  if (!dropInfo.isValid() || dropInfo.isLocalFileDrop()) {
+    return QAbstractProxyModel::canDropMimeData(data, action, row, column, parent);
   }
 
-  // row = -1 and invalid parent means we're dropping onto an item, we don't want to drop
-  // separators onto items or items into their own separator
-  if (row == -1 && parent.isValid()) {
-    auto* parentItem = static_cast<TreeItem*>(parent.internalPointer());
-    if (hasSeparator) {
-      return !parentItem->mod->isSeparator();
+  if (dropInfo.isModDrop()) {
+
+    bool hasSeparator = false;
+    unsigned int firstRowIndex = -1;
+
+    int firstRowPriority = INT_MAX;
+    for (auto sourceRow : dropInfo.rows()) {
+      hasSeparator = hasSeparator || ModInfo::getByIndex(sourceRow)->isSeparator();
+      if (m_profile->getModPriority(sourceRow) < firstRowPriority) {
+        firstRowIndex = sourceRow;
+        firstRowPriority = m_profile->getModPriority(sourceRow);
+      }
     }
 
-    for (auto row : sourceRows) {
-      auto it = m_IndexToItem.find(row);
-      if (it != m_IndexToItem.end() && it->second->parent == parentItem) {
-        return false;
+    bool firstRowSeparator = firstRowIndex != -1 && ModInfo::getByIndex(firstRowIndex)->isSeparator();
+
+    // row = -1 and invalid parent means we're dropping onto an item, we don't want to drop
+    // separators onto items or items into their own separator
+    if (row == -1 && parent.isValid()) {
+      auto* parentItem = static_cast<TreeItem*>(parent.internalPointer());
+      if (hasSeparator) {
+        return !parentItem->mod->isSeparator();
+      }
+
+      for (auto row : dropInfo.rows()) {
+        auto it = m_IndexToItem.find(row);
+        if (it != m_IndexToItem.end() && it->second->parent == parentItem) {
+          return false;
+        }
       }
     }
-  }
 
-  // first row is a separator, we can drop it anywhere
-  if (firstRowSeparator) {
-    return QAbstractProxyModel::canDropMimeData(data, action, row, column, parent);
+    // first row is a separator, we can drop it anywhere
+    if (firstRowSeparator) {
+      return QAbstractProxyModel::canDropMimeData(data, action, row, column, parent);
+    }
   }
 
   // top-level drop is disabled unless it's before the first separator
@@ -262,9 +265,10 @@ bool ModListByPriorityProxy::canDropMimeData(const QMimeData* data, Qt::DropActi
 bool ModListByPriorityProxy::dropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent)
 {
   // we need to fix the source model row
+  auto dropInfo = m_core.modList()->dropInfo(data);
   int sourceRow = -1;
 
-  if (data->hasUrls()) {
+  if (dropInfo.isLocalFileDrop()) {
     if (parent.isValid()) {
       sourceRow = static_cast<TreeItem*>(parent.internalPointer())->index;
     }
@@ -277,7 +281,7 @@ bool ModListByPriorityProxy::dropMimeData(const QMimeData* data, Qt::DropAction
           if (row > 0
             && m_Root.children[row - 1]->mod->isSeparator()
             && !m_Root.children[row - 1]->children.empty()
-            && m_DropPosition == ModListView::DropPosition::BelowItem) {
+            && m_dropPosition == ModListView::DropPosition::BelowItem) {
             sourceRow = m_Root.children[row - 1]->children[0]->index;
           }
         }
@@ -324,7 +328,7 @@ QModelIndex ModListByPriorityProxy::index(int row, int column, const QModelIndex
 
 void ModListByPriorityProxy::onDropEnter(const QMimeData*, ModListView::DropPosition dropPosition)
 {
-  m_DropPosition = dropPosition;
+  m_dropPosition = dropPosition;
 }
 
 void ModListByPriorityProxy::refreshExpandedItems() const
diff --git a/src/modlistbypriorityproxy.h b/src/modlistbypriorityproxy.h
index 00848e2a..e5a8adff 100644
--- a/src/modlistbypriorityproxy.h
+++ b/src/modlistbypriorityproxy.h
@@ -23,10 +23,10 @@ class ModListByPriorityProxy : public QAbstractProxyModel
   Q_OBJECT
 
 public:
-  explicit ModListByPriorityProxy(Profile* profile, QObject* parent = nullptr);
+  explicit ModListByPriorityProxy(Profile* profile, OrganizerCore& core, QObject* parent = nullptr);
   ~ModListByPriorityProxy();
 
-  void setProfile(Profile* profile) { m_Profile = profile; }
+  void setProfile(Profile* profile);
   void refresh();
 
   void setSourceModel(QAbstractItemModel* sourceModel) override;
@@ -92,8 +92,9 @@ private:
   std::set<QString> m_CollapsedItems;
 
 private:
-  Profile* m_Profile;
-  ModListView::DropPosition m_DropPosition = ModListView::DropPosition::OnItem;
+  OrganizerCore& m_core;
+  Profile* m_profile;
+  ModListView::DropPosition m_dropPosition = ModListView::DropPosition::OnItem;
 };
 
 #endif //GROUPINGPROXY_H
diff --git a/src/modlistsortproxy.cpp b/src/modlistsortproxy.cpp
index 93f97895..d1ca6d0c 100644
--- a/src/modlistsortproxy.cpp
+++ b/src/modlistsortproxy.cpp
@@ -611,11 +611,13 @@ bool ModListSortProxy::canDropMimeData(const QMimeData* data, Qt::DropAction act
     return false;
   }
 
+  auto dropInfo = m_Organizer->modList()->dropInfo(data);
+
   // disable drop install with group proxy, except the one for collapsible separator
   // - it would be nice to be able to "install to category" or something like that but
   //   it's a bit more complicated since the drop position is based on the category, so
   //   just disabling for now
-  if (data->hasText() && data->text() == "archive") {
+  if (dropInfo.isDownloadDrop()) {
     // maybe there is a cleaner way?
     if (qobject_cast<QtGroupingProxy*>(sourceModel())) {
       return false;
@@ -628,14 +630,18 @@ bool ModListSortProxy::canDropMimeData(const QMimeData* data, Qt::DropAction act
 bool ModListSortProxy::dropMimeData(const QMimeData *data, Qt::DropAction action,
                                     int row, int column, const QModelIndex &parent)
 {
-  if (!data->hasUrls() && (sortColumn() != ModList::COL_PRIORITY)) {
+  auto dropInfo = m_Organizer->modList()->dropInfo(data);
+
+  if (!dropInfo.isLocalFileDrop() && sortColumn() != ModList::COL_PRIORITY) {
     QWidget *wid = qApp->activeWindow()->findChild<QTreeView*>("modList");
     MessageDialog::showMessage(tr("Drag&Drop is only supported when sorting by priority"), wid);
     return false;
   }
-  if ((row == -1) && (column == -1)) {
+
+  if (row == -1 && column == -1) {
     return sourceModel()->dropMimeData(data, action, -1, -1, mapToSource(parent));
   }
+
   // in the regular model, when dropping between rows, the row-value passed to
   // the sourceModel is inconsistent between ascending and descending ordering.
   // This should fix that
diff --git a/src/modlistview.cpp b/src/modlistview.cpp
index c4641934..02b7384a 100644
--- a/src/modlistview.cpp
+++ b/src/modlistview.cpp
@@ -6,6 +6,7 @@
 #include <widgetutility.h>
 
 #include <utility.h>
+#include <report.h>
 
 #include "ui_mainwindow.h"
 
@@ -20,6 +21,8 @@
 #include "shared/directoryentry.h"
 #include "shared/filesorigin.h"
 
+using namespace MOBase;
+
 class ModListProxyStyle : public QProxyStyle {
 public:
 
@@ -70,6 +73,11 @@ public:
 
 ModListView::ModListView(QWidget* parent)
   : QTreeView(parent)
+  , m_core(nullptr)
+  , m_sortProxy(nullptr)
+  , m_byPriorityProxy(nullptr)
+  , m_byCategoryProxy(nullptr)
+  , m_byNexusIdProxy(nullptr)
   , m_scrollbar(new ViewMarkingScrollBar(this->model(), this))
 {
   setVerticalScrollBar(m_scrollbar);
@@ -547,7 +555,7 @@ void ModListView::setup(OrganizerCore& core, Ui::MainWindow* mwui)
   connect(m_core, &OrganizerCore::modInstalled, this, &ModListView::onModInstalled);
   connect(core.modList(), &ModList::modPrioritiesChanged, this, &ModListView::onModPrioritiesChanged);
 
-  m_byPriorityProxy = new ModListByPriorityProxy(core.currentProfile(), &core);
+  m_byPriorityProxy = new ModListByPriorityProxy(core.currentProfile(), core, this);
   m_byPriorityProxy->setSourceModel(core.modList());
   connect(this, &QTreeView::expanded, m_byPriorityProxy, &ModListByPriorityProxy::expanded);
   connect(this, &QTreeView::collapsed, m_byPriorityProxy, &ModListByPriorityProxy::collapsed);
@@ -629,9 +637,13 @@ void ModListView::setup(OrganizerCore& core, Ui::MainWindow* mwui)
   // prevent the name-column from being hidden
   header()->setSectionHidden(ModList::COL_NAME, false);
 
-  connect(m_core->modList(), &ModList::downloadArchiveDropped, this, [this](int row, int priority) {
+  connect(m_core->modList(), &ModList::downloadArchiveDropped, [=](int row, int priority) {
     m_core->installDownload(row, priority);
   });
+  connect(m_core->modList(), &ModList::externalArchiveDropped, [=](const QUrl& url, int priority) {
+    m_core->installArchive(url.toLocalFile(), priority, false, nullptr);
+  });
+  connect(m_core->modList(), &ModList::externalFolderDropped, this, &ModListView::onExternalFolderDropped);
 
   connect(m_sortProxy, &ModListSortProxy::filterActive, this, &ModListView::onModFilterActive);
   connect(ui.filter, &QLineEdit::textChanged, m_sortProxy, &ModListSortProxy::updateFilter);
@@ -710,13 +722,50 @@ void ModListView::timerEvent(QTimerEvent* event)
   }
 }
 
+void ModListView::onExternalFolderDropped(const QUrl& url, int priority)
+{
+  QFileInfo fileInfo(url.toLocalFile());
+
+  GuessedValue<QString> name;
+  name.setFilter(&fixDirectoryName);
+  name.update(fileInfo.fileName(), GUESS_PRESET);
+
+  do {
+    bool ok;
+    name.update(QInputDialog::getText(this, tr("Copy Folder..."),
+      tr("This will copy the content of %1 to a new mod.\n"
+        "Please enter the name:").arg(fileInfo.fileName()), QLineEdit::Normal, name, &ok),
+      GUESS_USER);
+    if (!ok) {
+      return;
+    }
+  } while (name->isEmpty());
+
+  if (m_core->modList()->getMod(name) != nullptr) {
+    reportError(tr("A mod with this name already exists."));
+    return;
+  }
+
+  IModInterface* newMod = m_core->createMod(name);
+  if (!newMod) {
+    return;
+  }
+
+  if (!copyDir(fileInfo.absoluteFilePath(), newMod->absolutePath(), true)) {
+    return;
+  }
+
+  m_core->refresh();
+
+  if (priority != -1) {
+    m_core->modList()->changeModPriority(ModInfo::getIndex(name), priority);
+  }
+}
+
 bool ModListView::moveSelection(int key)
 {
   QModelIndex cindex = indexViewToModel(currentIndex());
-  QModelIndexList sourceRows;
-  for (auto& index : selectionModel()->selectedRows()) {
-    sourceRows.append(indexViewToModel(index));
-  }
+  QModelIndexList sourceRows = indexViewToModel(selectionModel()->selectedRows());
 
   int offset = key == Qt::Key_Up ? -1 : 1;
   if (m_sortProxy->sortOrder() == Qt::DescendingOrder) {
@@ -755,13 +804,7 @@ bool ModListView::toggleSelectionState()
   if (!selectionModel()->hasSelection()) {
     return true;
   }
-
-  QModelIndexList selected;
-  for (QModelIndex idx : selectionModel()->selectedRows()) {
-    selected.append(indexViewToModel(idx));
-  }
-
-  return m_core->modList()->toggleState(selected);
+  return m_core->modList()->toggleState(indexViewToModel(selectionModel()->selectedRows()));
 }
 
 bool ModListView::event(QEvent* event)
diff --git a/src/modlistview.h b/src/modlistview.h
index 1d8a9b49..8e37161b 100644
--- a/src/modlistview.h
+++ b/src/modlistview.h
@@ -123,6 +123,12 @@ protected:
   //
   QModelIndexList selectedIndexes() const;
 
+  // drop from external folder
+  //
+  void onExternalFolderDropped(const QUrl& url, int priority);
+
+  // method to react to various key events
+  //
   bool moveSelection(int key);
   bool removeSelection();
   bool toggleSelectionState();
diff --git a/src/organizercore.cpp b/src/organizercore.cpp
index 334a02de..9e3528ef 100644
--- a/src/organizercore.cpp
+++ b/src/organizercore.cpp
@@ -756,74 +756,12 @@ QString OrganizerCore::pluginDataPath()
          + "/data";
 }
 
-MOBase::IModInterface *OrganizerCore::installMod(const QString &fileName,
+MOBase::IModInterface *OrganizerCore::installMod(const QString & archivePath,
                                                  bool reinstallation,
                                                  ModInfo::Ptr currentMod,
                                                  const QString &initModName)
 {
-  if (m_CurrentProfile == nullptr) {
-    return nullptr;
-  }
-
-  if (m_InstallationManager.isRunning()) {
-    QMessageBox::information(
-      qApp->activeWindow(), tr("Installation cancelled"),
-      tr("Another installation is currently in progress."), QMessageBox::Ok);
-    return nullptr;
-  }
-
-  bool hasIniTweaks = false;
-  GuessedValue<QString> modName;
-  if (!initModName.isEmpty()) {
-    modName.update(initModName, GUESS_USER);
-  }
-  m_CurrentProfile->writeModlistNow();
-  m_InstallationManager.setModsDirectory(m_Settings.paths().mods());
-  m_InstallationManager.notifyInstallationStart(fileName, reinstallation, currentMod);
-  auto result = m_InstallationManager.install(fileName, modName, hasIniTweaks);
-  if (result) {
-    MessageDialog::showMessage(tr("Installation successful"),
-                               qApp->activeWindow());
-    refresh();
-
-    int modIndex = ModInfo::getIndex(modName);
-    if (modIndex != UINT_MAX) {
-      ModInfo::Ptr modInfo = ModInfo::getByIndex(modIndex);
-      auto dlIdx = m_DownloadManager.indexByName(QFileInfo(fileName).fileName());
-      if (dlIdx != -1) {
-        int modId = m_DownloadManager.getModID(dlIdx);
-        int fileId = m_DownloadManager.getFileInfo(dlIdx)->fileID;
-        modInfo->addInstalledFile(modId, fileId);
-      }
-      if (hasIniTweaks && (m_UserInterface != nullptr)
-          && (QMessageBox::question(qApp->activeWindow(), tr("Configure Mod"),
-                                    tr("This mod contains ini tweaks. Do you "
-                                       "want to configure them now?"),
-                                    QMessageBox::Yes | QMessageBox::No)
-              == QMessageBox::Yes)) {
-        m_UserInterface->displayModInformation(
-          modInfo, modIndex, ModInfoTabIDs::IniFiles);
-      }
-      m_ModList.notifyModInstalled(modInfo.get());
-      m_DownloadManager.markInstalled(fileName);
-      m_InstallationManager.notifyInstallationEnd(result, modInfo);
-      emit modInstalled(modName);
-      return modInfo.data();
-    } else {
-      reportError(tr("mod not found: %1").arg(qUtf8Printable(modName)));
-    }
-  } else {
-    m_InstallationManager.notifyInstallationEnd(result, nullptr);
-    if (m_InstallationManager.wasCancelled()) {
-      QMessageBox::information(qApp->activeWindow(), tr("Extraction cancelled"),
-        tr("The installation was cancelled while extracting files. "
-          "If this was prior to a FOMOD setup, this warning may be ignored. "
-          "However, if this was during installation, the mod will likely be missing files."),
-        QMessageBox::Ok);
-      refresh();
-    }
-  }
-  return nullptr;
+  return installArchive(archivePath, -1, reinstallation, currentMod, initModName).get();
 }
 
 ModInfo::Ptr OrganizerCore::installDownload(int index, int priority)
@@ -915,6 +853,82 @@ ModInfo::Ptr OrganizerCore::installDownload(int index, int priority)
   return nullptr;
 }
 
+ModInfo::Ptr OrganizerCore::installArchive(
+  const QString& archivePath, int priority, bool reinstallation,
+  ModInfo::Ptr currentMod, const QString& initModName)
+{
+  if (m_CurrentProfile == nullptr) {
+    return nullptr;
+  }
+
+  if (m_InstallationManager.isRunning()) {
+    QMessageBox::information(
+      qApp->activeWindow(), tr("Installation cancelled"),
+      tr("Another installation is currently in progress."), QMessageBox::Ok);
+    return nullptr;
+  }
+
+  bool hasIniTweaks = false;
+  GuessedValue<QString> modName;
+  if (!initModName.isEmpty()) {
+    modName.update(initModName, GUESS_USER);
+  }
+  m_CurrentProfile->writeModlistNow();
+  m_InstallationManager.setModsDirectory(m_Settings.paths().mods());
+  m_InstallationManager.notifyInstallationStart(archivePath, reinstallation, currentMod);
+  auto result = m_InstallationManager.install(archivePath, modName, hasIniTweaks);
+  if (result) {
+    MessageDialog::showMessage(tr("Installation successful"),
+      qApp->activeWindow());
+    refresh();
+
+    int modIndex = ModInfo::getIndex(modName);
+    if (modIndex != UINT_MAX) {
+      ModInfo::Ptr modInfo = ModInfo::getByIndex(modIndex);
+      auto dlIdx = m_DownloadManager.indexByName(QFileInfo(archivePath).fileName());
+      if (dlIdx != -1) {
+        int modId = m_DownloadManager.getModID(dlIdx);
+        int fileId = m_DownloadManager.getFileInfo(dlIdx)->fileID;
+        modInfo->addInstalledFile(modId, fileId);
+      }
+
+      if (priority != -1 && !result.mergedOrReplaced()) {
+        m_ModList.changeModPriority(modIndex, priority);
+      }
+
+      if (hasIniTweaks && (m_UserInterface != nullptr)
+        && (QMessageBox::question(qApp->activeWindow(), tr("Configure Mod"),
+          tr("This mod contains ini tweaks. Do you "
+            "want to configure them now?"),
+          QMessageBox::Yes | QMessageBox::No)
+          == QMessageBox::Yes)) {
+        m_UserInterface->displayModInformation(
+          modInfo, modIndex, ModInfoTabIDs::IniFiles);
+      }
+      m_ModList.notifyModInstalled(modInfo.get());
+      m_DownloadManager.markInstalled(archivePath);
+      m_InstallationManager.notifyInstallationEnd(result, modInfo);
+      emit modInstalled(modName);
+      return modInfo;
+    }
+    else {
+      reportError(tr("mod not found: %1").arg(qUtf8Printable(modName)));
+    }
+  }
+  else {
+    m_InstallationManager.notifyInstallationEnd(result, nullptr);
+    if (m_InstallationManager.wasCancelled()) {
+      QMessageBox::information(qApp->activeWindow(), tr("Extraction cancelled"),
+        tr("The installation was cancelled while extracting files. "
+          "If this was prior to a FOMOD setup, this warning may be ignored. "
+          "However, if this was during installation, the mod will likely be missing files."),
+        QMessageBox::Ok);
+      refresh();
+    }
+  }
+  return nullptr;
+}
+
 QString OrganizerCore::resolvePath(const QString &fileName) const
 {
   if (m_DirectoryStructure == nullptr) {
diff --git a/src/organizercore.h b/src/organizercore.h
index cb577437..3fb4f20e 100644
--- a/src/organizercore.h
+++ b/src/organizercore.h
@@ -377,6 +377,8 @@ public slots:
   void refreshLists();
 
   ModInfo::Ptr installDownload(int downloadIndex, int priority = -1);
+  ModInfo::Ptr installArchive(const QString& archivePath, int priority = -1, bool reinstallation = false,
+    ModInfo::Ptr currentMod = nullptr, const QString& modName = QString());
 
   void modStatusChanged(unsigned int index);
   void modStatusChanged(QList<unsigned int> index);
-- 
cgit v1.3.1


From 89ff59da4613f06a05a633b4aa4387470831ce94 Mon Sep 17 00:00:00 2001
From: Mikaël Capelle <capelle.mikael@gmail.com>
Date: Wed, 30 Dec 2020 19:11:48 +0100
Subject: Add message for invalid drag. Split & clean code.

---
 src/CMakeLists.txt             |   1 +
 src/downloadlist.cpp           |   3 +-
 src/modlist.cpp                | 140 ++------------------------------
 src/modlist.h                  |  93 +++------------------
 src/modlistbypriorityproxy.cpp |   5 +-
 src/modlistdropinfo.cpp        | 124 ++++++++++++++++++++++++++++
 src/modlistdropinfo.h          |  92 +++++++++++++++++++++
 src/modlistsortproxy.cpp       |   5 +-
 src/modlistview.cpp            | 179 ++++++++++++++++++++++-------------------
 9 files changed, 335 insertions(+), 307 deletions(-)
 create mode 100644 src/modlistdropinfo.cpp
 create mode 100644 src/modlistdropinfo.h

(limited to 'src/modlistbypriorityproxy.cpp')

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 0a913649..93b9e768 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -134,6 +134,7 @@ add_filter(NAME src/modinfo/dialog GROUPS
 )
 add_filter(NAME src/modlist GROUPS
 	modlist
+	modlistdropinfo
 	modlistsortproxy
 	modlistbypriorityproxy
 	modlistview
diff --git a/src/downloadlist.cpp b/src/downloadlist.cpp
index 78e5fd24..93f8538c 100644
--- a/src/downloadlist.cpp
+++ b/src/downloadlist.cpp
@@ -19,6 +19,7 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 
 #include "downloadlist.h"
 #include "downloadmanager.h"
+#include "modlistdropinfo.h"
 #include <utility.h>
 #include <log.h>
 #include <QEvent>
@@ -98,7 +99,7 @@ Qt::ItemFlags DownloadList::flags(const QModelIndex& idx) const
 QMimeData* DownloadList::mimeData(const QModelIndexList& indexes) const
 {
   QMimeData* result = QAbstractItemModel::mimeData(indexes);
-  result->setData("text/plain", "archive");
+  result->setData("text/plain", ModListDropInfo::DOWNLOAD_TEXT);
   return result;
 }
 
diff --git a/src/modlist.cpp b/src/modlist.cpp
index 28e20917..7da6fe3b 100644
--- a/src/modlist.cpp
+++ b/src/modlist.cpp
@@ -28,6 +28,7 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 #include "settings.h"
 #include "organizercore.h"
 #include "modinforegular.h"
+#include "modlistdropinfo.h"
 #include "shared/directoryentry.h"
 #include "shared/fileentry.h"
 #include "shared/filesorigin.h"
@@ -60,128 +61,6 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 
 using namespace MOBase;
 
-
-ModList::DropInfo::DropInfo(const QMimeData* mimeData, OrganizerCore& core) :
-  m_rows{}, m_download{ -1 }, m_localUrls{}, m_url{}
-{
-  // this only check if the drop is valid, not if the content of the drop
-  // matches the target, a drop is valid if either
-  // 1. it contains items from another model (drag&drop in modlist or from download list)
-  // 2. it contains URLs from MO2 (overwrite or from another mod)
-  // 3. it contains a single URL to an external folder
-  // 4. it contains a single URL to a valid archive for MO2
-  try {
-    if (mimeData->hasUrls()) {
-      for (auto& url : mimeData->urls()) {
-        auto p = relativeUrl(url);
-        if (p) {
-          m_localUrls.push_back(*p);
-        }
-      }
-
-      // external drop
-      if (m_localUrls.empty() && mimeData->urls().size() == 1) {
-        auto url = mimeData->urls()[0];
-        if (url.isLocalFile() && !relativeUrl(url)) {
-          QFileInfo info(url.toLocalFile());
-          if (info.isDir()) {
-            m_url = url;
-          }
-          else if (core.installationManager()->getSupportedExtensions().contains(info.suffix(), Qt::CaseInsensitive)) {
-            m_url = url;
-          }
-        }
-      }
-
-    }
-    else if (mimeData->hasText()) {
-      QByteArray encoded = mimeData->data("application/x-qabstractitemmodeldatalist");
-      QDataStream stream(&encoded, QIODevice::ReadOnly);
-
-      while (!stream.atEnd()) {
-        int sourceRow, col;
-        QMap<int, QVariant> roleDataMap;
-        stream >> sourceRow >> col >> roleDataMap;
-        if (col == 0) {
-          m_rows.push_back(sourceRow);
-        }
-      }
-
-      if (mimeData->text() != "mod") {
-        if (mimeData->text() == "archive" && m_rows.size() == 1) {
-          m_download = m_rows[0];
-        }
-        m_rows = {};
-      }
-    }
-  }
-  catch (std::exception const&) {
-    m_rows = {};
-    m_download = -1;
-    m_localUrls.clear();
-    m_url = {};
-  }
-}
-
-std::optional<ModList::DropInfo::RelativeUrl> ModList::DropInfo::relativeUrl(const QUrl& url) const
-{
-  if (!url.isLocalFile()) {
-    return {};
-  }
-
-  QDir allModsDir(Settings::instance().paths().mods());
-  QDir overwriteDir(Settings::instance().paths().overwrite());
-
-  QFileInfo sourceInfo(url.toLocalFile());
-  QString sourceFile = sourceInfo.canonicalFilePath();
-
-  QString relativePath;
-  QString originName;
-
-  if (sourceFile.startsWith(allModsDir.canonicalPath())) {
-    QDir relativeDir(allModsDir.relativeFilePath(sourceFile));
-    QStringList splitPath = relativeDir.path().split("/");
-    originName = splitPath[0];
-    splitPath.pop_front();
-    return { { url, splitPath.join("/"), originName } };
-  }
-  else if (sourceFile.startsWith(overwriteDir.canonicalPath())) {
-    return { { url, overwriteDir.relativeFilePath(sourceFile), ModInfo::getOverwrite()->name() } };
-  }
-
-  return {};
-}
-
-bool ModList::DropInfo::isValid() const
-{
-  return isLocalFileDrop() || isModDrop() || isDownloadDrop() || m_url.isLocalFile();
-}
-
-bool ModList::DropInfo::isLocalFileDrop() const
-{
-  return !m_localUrls.empty();
-}
-
-bool ModList::DropInfo::isModDrop() const
-{
-  return !m_rows.empty();
-}
-
-bool ModList::DropInfo::isDownloadDrop() const
-{
-  return m_download != -1;
-}
-
-bool ModList::DropInfo::isExternalArchiveDrop() const
-{
-  return m_url.isLocalFile() && QFileInfo(m_url.toLocalFile()).isFile();
-}
-
-bool ModList::DropInfo::isExternalFolderDrop() const
-{
-  return m_url.isLocalFile() && QFileInfo(m_url.toLocalFile()).isDir();
-}
-
 ModList::ModList(PluginContainer *pluginContainer, OrganizerCore *organizer)
   : QAbstractItemModel(organizer)
   , m_Organizer(organizer)
@@ -829,7 +708,7 @@ QStringList ModList::mimeTypes() const
 QMimeData *ModList::mimeData(const QModelIndexList &indexes) const
 {
   QMimeData *result = QAbstractItemModel::mimeData(indexes);
-  result->setData("text/plain", "mod");
+  result->setData("text/plain", ModListDropInfo::MOD_TEXT);
   return result;
 }
 
@@ -1231,12 +1110,7 @@ int ModList::dropPriority(int row, const QModelIndex& parent) const
   return newPriority;
 }
 
-ModList::DropInfo ModList::dropInfo(const QMimeData* mimeData) const
-{
-  return DropInfo(mimeData, *m_Organizer);
-}
-
-bool ModList::dropURLs(const DropInfo& dropInfo, int row, const QModelIndex &parent)
+bool ModList::dropLocalFiles(const ModListDropInfo& dropInfo, int row, const QModelIndex &parent)
 {
   if (row == -1) {
     row = parent.row();
@@ -1279,7 +1153,7 @@ bool ModList::dropURLs(const DropInfo& dropInfo, int row, const QModelIndex &par
 
 void ModList::onDragEnter(const QMimeData* mimeData)
 {
-  m_DropOnMod = dropInfo(mimeData).isLocalFileDrop();
+  m_DropOnMod = ModListDropInfo(mimeData, *m_Organizer).isLocalFileDrop();
 }
 
 bool ModList::canDropMimeData(const QMimeData* mimeData, Qt::DropAction action, int row, int column, const QModelIndex& parent) const
@@ -1288,7 +1162,7 @@ bool ModList::canDropMimeData(const QMimeData* mimeData, Qt::DropAction action,
     return false;
   }
 
-  DropInfo dropInfo(mimeData, *m_Organizer);
+  ModListDropInfo dropInfo(mimeData, *m_Organizer);
 
   if (dropInfo.isLocalFileDrop()) {
     if (row == -1 && parent.isValid()) {
@@ -1319,7 +1193,7 @@ bool ModList::dropMimeData(const QMimeData *mimeData, Qt::DropAction action, int
     return true;
   }
 
-  DropInfo dropInfo(mimeData, *m_Organizer);
+  ModListDropInfo dropInfo(mimeData, *m_Organizer);
 
   if (!m_Profile || !dropInfo.isValid()) {
     return false;
@@ -1331,7 +1205,7 @@ bool ModList::dropMimeData(const QMimeData *mimeData, Qt::DropAction action, int
   }
 
   if (dropInfo.isLocalFileDrop()) {
-    return dropURLs(dropInfo, row, parent);
+    return dropLocalFiles(dropInfo, row, parent);
   }
   else {
     if (dropInfo.isModDrop()) {
diff --git a/src/modlist.h b/src/modlist.h
index 815024b9..870978f9 100644
--- a/src/modlist.h
+++ b/src/modlist.h
@@ -43,6 +43,7 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 class QSortFilterProxyModel;
 class PluginContainer;
 class OrganizerCore;
+class ModListDropInfo;
 
 /**
  * Model presenting an overview of the installed mod
@@ -353,6 +354,14 @@ private:
 
   MOBase::IModList::ModStates state(unsigned int modIndex) const;
 
+  // handle dropping of local URLs files
+  //
+  bool dropLocalFiles(const ModListDropInfo& dropInfo, int row, const QModelIndex& parent);
+
+  // return the priority of the mod for a drop event
+  //
+  int dropPriority(int row, const QModelIndex& parent) const;
+
 private slots:
 
 private:
@@ -374,90 +383,6 @@ private:
 
 private:
 
-  // small class that extract information from mimeData
-  //
-  class DropInfo {
-  public:
-
-    struct RelativeUrl {
-      const QUrl url;
-      const QString relativePath;
-      const QString originName;
-    };
-
-    // returns true if this drop is valid
-    //
-    bool isValid() const;
-
-    // returns true if these data corresponds to drag&drop
-    // of local files (e.g. from overwrite)
-    //
-    bool isLocalFileDrop() const;
-
-    // returns true if these data corresponds to drag&drop
-    // of mod in the list
-    //
-    bool isModDrop() const;
-
-    // returns true if these data corresponds to drag&drop
-    // from the download list
-    //
-    bool isDownloadDrop() const;
-
-    // returns true if these data corresponds to dropping
-    // an archive for installation
-    //
-    bool isExternalArchiveDrop() const;
-
-    // returns true if these data corresponds to dropping
-    // a folder for copy
-    //
-    bool isExternalFolderDrop() const;
-
-    const auto& rows() const { return m_rows; }
-    const auto& download() const { return m_download; }
-    const auto& localUrls() const { return m_localUrls; }
-    const auto& externalUrl() const { return m_url; }
-
-  private:
-
-    friend class ModList;
-
-    // retrieve the relative path of file and its origin given a URL from Mime data
-    // returns an empty optional if the URL is not a valid file for dropping
-    //
-    std::optional<RelativeUrl> relativeUrl(const QUrl&) const;
-
-  private:
-    DropInfo(const QMimeData* mimeData, OrganizerCore& core);
-
-    // rows for drag&drop between views
-    std::vector<int> m_rows;
-    int m_download; // -1 if invalid
-
-    // local URLs from the data (relative path + origin name)
-    std::vector<RelativeUrl> m_localUrls;
-
-    // external URL
-    QUrl m_url;
-  };
-
-  // create a DropInfo object from the given data
-  //
-  DropInfo dropInfo(const QMimeData* mimeData) const;
-
-  bool dropURLs(const DropInfo& dropInfo, int row, const QModelIndex& parent);
-
-  // return the priority of the mod for a drop event
-  //
-  int dropPriority(int row, const QModelIndex& parent) const;
-
-private:
-
-  friend class ModListProxy;
-  friend class ModListSortProxy;
-  friend class ModListByPriorityProxy;
-
   OrganizerCore *m_Organizer;
   Profile *m_Profile;
 
diff --git a/src/modlistbypriorityproxy.cpp b/src/modlistbypriorityproxy.cpp
index b1426422..749991d0 100644
--- a/src/modlistbypriorityproxy.cpp
+++ b/src/modlistbypriorityproxy.cpp
@@ -4,6 +4,7 @@
 #include "profile.h"
 #include "organizercore.h"
 #include "modlist.h"
+#include "modlistdropinfo.h"
 #include "log.h"
 
 ModListByPriorityProxy::ModListByPriorityProxy(Profile* profile, OrganizerCore& core, QObject* parent) :
@@ -195,7 +196,7 @@ bool ModListByPriorityProxy::setData(const QModelIndex& index, const QVariant& v
 
 bool ModListByPriorityProxy::canDropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) const
 {
-  auto dropInfo = m_core.modList()->dropInfo(data);
+  ModListDropInfo dropInfo(data, m_core);
 
   if (!dropInfo.isValid() || dropInfo.isLocalFileDrop()) {
     return QAbstractProxyModel::canDropMimeData(data, action, row, column, parent);
@@ -265,7 +266,7 @@ bool ModListByPriorityProxy::canDropMimeData(const QMimeData* data, Qt::DropActi
 bool ModListByPriorityProxy::dropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent)
 {
   // we need to fix the source model row
-  auto dropInfo = m_core.modList()->dropInfo(data);
+  ModListDropInfo dropInfo(data, m_core);
   int sourceRow = -1;
 
   if (dropInfo.isLocalFileDrop()) {
diff --git a/src/modlistdropinfo.cpp b/src/modlistdropinfo.cpp
new file mode 100644
index 00000000..62a103a4
--- /dev/null
+++ b/src/modlistdropinfo.cpp
@@ -0,0 +1,124 @@
+#include "modlistdropinfo.h"
+
+#include "organizercore.h"
+
+ModListDropInfo::ModListDropInfo(const QMimeData* mimeData, OrganizerCore& core) :
+  m_rows{}, m_download{ -1 }, m_localUrls{}, m_url{}
+{
+  // this only check if the drop is valid, not if the content of the drop
+  // matches the target, a drop is valid if either
+  // 1. it contains items from another model (drag&drop in modlist or from download list)
+  // 2. it contains URLs from MO2 (overwrite or from another mod)
+  // 3. it contains a single URL to an external folder
+  // 4. it contains a single URL to a valid archive for MO2
+  try {
+    if (mimeData->hasUrls()) {
+      for (auto& url : mimeData->urls()) {
+        auto p = relativeUrl(url);
+        if (p) {
+          m_localUrls.push_back(*p);
+        }
+      }
+
+      // external drop
+      if (m_localUrls.empty() && mimeData->urls().size() == 1) {
+        auto url = mimeData->urls()[0];
+        if (url.isLocalFile() && !relativeUrl(url)) {
+          QFileInfo info(url.toLocalFile());
+          if (info.isDir()) {
+            m_url = url;
+          }
+          else if (core.installationManager()->getSupportedExtensions().contains(info.suffix(), Qt::CaseInsensitive)) {
+            m_url = url;
+          }
+        }
+      }
+
+    }
+    else if (mimeData->hasText()) {
+      QByteArray encoded = mimeData->data("application/x-qabstractitemmodeldatalist");
+      QDataStream stream(&encoded, QIODevice::ReadOnly);
+
+      while (!stream.atEnd()) {
+        int sourceRow, col;
+        QMap<int, QVariant> roleDataMap;
+        stream >> sourceRow >> col >> roleDataMap;
+        if (col == 0) {
+          m_rows.push_back(sourceRow);
+        }
+      }
+
+      if (mimeData->text() != ModListDropInfo::MOD_TEXT) {
+        if (mimeData->text() == ModListDropInfo::DOWNLOAD_TEXT && m_rows.size() == 1) {
+          m_download = m_rows[0];
+        }
+        m_rows = {};
+      }
+    }
+  }
+  catch (std::exception const&) {
+    m_rows = {};
+    m_download = -1;
+    m_localUrls.clear();
+    m_url = {};
+  }
+}
+
+std::optional<ModListDropInfo::RelativeUrl> ModListDropInfo::relativeUrl(const QUrl& url) const
+{
+  if (!url.isLocalFile()) {
+    return {};
+  }
+
+  QDir allModsDir(Settings::instance().paths().mods());
+  QDir overwriteDir(Settings::instance().paths().overwrite());
+
+  QFileInfo sourceInfo(url.toLocalFile());
+  QString sourceFile = sourceInfo.canonicalFilePath();
+
+  QString relativePath;
+  QString originName;
+
+  if (sourceFile.startsWith(allModsDir.canonicalPath())) {
+    QDir relativeDir(allModsDir.relativeFilePath(sourceFile));
+    QStringList splitPath = relativeDir.path().split("/");
+    originName = splitPath[0];
+    splitPath.pop_front();
+    return { { url, splitPath.join("/"), originName } };
+  }
+  else if (sourceFile.startsWith(overwriteDir.canonicalPath())) {
+    return { { url, overwriteDir.relativeFilePath(sourceFile), ModInfo::getOverwrite()->name() } };
+  }
+
+  return {};
+}
+
+bool ModListDropInfo::isValid() const
+{
+  return isLocalFileDrop() || isModDrop() || isDownloadDrop() || m_url.isLocalFile();
+}
+
+bool ModListDropInfo::isLocalFileDrop() const
+{
+  return !m_localUrls.empty();
+}
+
+bool ModListDropInfo::isModDrop() const
+{
+  return !m_rows.empty();
+}
+
+bool ModListDropInfo::isDownloadDrop() const
+{
+  return m_download != -1;
+}
+
+bool ModListDropInfo::isExternalArchiveDrop() const
+{
+  return m_url.isLocalFile() && QFileInfo(m_url.toLocalFile()).isFile();
+}
+
+bool ModListDropInfo::isExternalFolderDrop() const
+{
+  return m_url.isLocalFile() && QFileInfo(m_url.toLocalFile()).isDir();
+}
diff --git a/src/modlistdropinfo.h b/src/modlistdropinfo.h
new file mode 100644
index 00000000..14a21691
--- /dev/null
+++ b/src/modlistdropinfo.h
@@ -0,0 +1,92 @@
+#ifndef MODLISTDROPINFO_H
+#define MODLISTDROPINFO_H
+
+#include <optional>
+#include <vector>
+
+#include <QMimeData>
+#include <QString>
+#include <QUrl>
+
+class OrganizerCore;
+
+// small class that extract information from mimeData
+//
+class ModListDropInfo {
+public:
+
+  // text value for the mime-data for the various possible
+  // origin (not for external drops)
+  //
+  static constexpr const char* MOD_TEXT = "mod";
+  static constexpr const char* DOWNLOAD_TEXT = "download";
+
+public:
+
+  struct RelativeUrl {
+    const QUrl url;
+    const QString relativePath;
+    const QString originName;
+  };
+
+public:
+
+  ModListDropInfo(const QMimeData* mimeData, OrganizerCore& core);
+
+  // returns true if this drop is valid
+  //
+  bool isValid() const;
+
+  // returns true if these data corresponds to drag&drop
+  // of local files (e.g. from overwrite)
+  //
+  bool isLocalFileDrop() const;
+
+  // returns true if these data corresponds to drag&drop
+  // of mod in the list
+  //
+  bool isModDrop() const;
+
+  // returns true if these data corresponds to drag&drop
+  // from the download list
+  //
+  bool isDownloadDrop() const;
+
+  // returns true if these data corresponds to dropping
+  // an archive for installation
+  //
+  bool isExternalArchiveDrop() const;
+
+  // returns true if these data corresponds to dropping
+  // a folder for copy
+  //
+  bool isExternalFolderDrop() const;
+
+  const auto& rows() const { return m_rows; }
+  const auto& download() const { return m_download; }
+  const auto& localUrls() const { return m_localUrls; }
+  const auto& externalUrl() const { return m_url; }
+
+private:
+
+  friend class ModList;
+
+  // retrieve the relative path of file and its origin given a URL from Mime data
+  // returns an empty optional if the URL is not a valid file for dropping
+  //
+  std::optional<RelativeUrl> relativeUrl(const QUrl&) const;
+
+private:
+
+  // rows for drag&drop between views
+  std::vector<int> m_rows;
+  int m_download; // -1 if invalid
+
+  // local URLs from the data (relative path + origin name)
+  std::vector<RelativeUrl> m_localUrls;
+
+  // external URL
+  QUrl m_url;
+};
+
+#endif
diff --git a/src/modlistsortproxy.cpp b/src/modlistsortproxy.cpp
index f9a32b26..0dc2be83 100644
--- a/src/modlistsortproxy.cpp
+++ b/src/modlistsortproxy.cpp
@@ -18,6 +18,7 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "modlistsortproxy.h"
+#include "modlistdropinfo.h"
 #include "modinfo.h"
 #include "profile.h"
 #include "messagedialog.h"
@@ -607,7 +608,7 @@ bool ModListSortProxy::filterAcceptsRow(int source_row, const QModelIndex &paren
 
 bool ModListSortProxy::canDropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) const
 {
-  auto dropInfo = m_Organizer->modList()->dropInfo(data);
+  ModListDropInfo dropInfo(data, *m_Organizer);
 
   if (!dropInfo.isLocalFileDrop() && sortColumn() != ModList::COL_PRIORITY) {
     return false;
@@ -630,7 +631,7 @@ bool ModListSortProxy::canDropMimeData(const QMimeData* data, Qt::DropAction act
 bool ModListSortProxy::dropMimeData(const QMimeData *data, Qt::DropAction action,
                                     int row, int column, const QModelIndex &parent)
 {
-  auto dropInfo = m_Organizer->modList()->dropInfo(data);
+  ModListDropInfo dropInfo(data, *m_Organizer);
 
   if (!dropInfo.isLocalFileDrop() && sortColumn() != ModList::COL_PRIORITY) {
     QWidget *wid = qApp->activeWindow()->findChild<QTreeView*>("modList");
diff --git a/src/modlistview.cpp b/src/modlistview.cpp
index 02b7384a..be173478 100644
--- a/src/modlistview.cpp
+++ b/src/modlistview.cpp
@@ -17,6 +17,7 @@
 #include "log.h"
 #include "modflagicondelegate.h"
 #include "modconflicticondelegate.h"
+#include "modlistdropinfo.h"
 #include "genericicondelegate.h"
 #include "shared/directoryentry.h"
 #include "shared/filesorigin.h"
@@ -516,6 +517,91 @@ void ModListView::updateModCount()
   );
 }
 
+void ModListView::onExternalFolderDropped(const QUrl& url, int priority)
+{
+  QFileInfo fileInfo(url.toLocalFile());
+
+  GuessedValue<QString> name;
+  name.setFilter(&fixDirectoryName);
+  name.update(fileInfo.fileName(), GUESS_PRESET);
+
+  do {
+    bool ok;
+    name.update(QInputDialog::getText(this, tr("Copy Folder..."),
+      tr("This will copy the content of %1 to a new mod.\n"
+        "Please enter the name:").arg(fileInfo.fileName()), QLineEdit::Normal, name, &ok),
+      GUESS_USER);
+    if (!ok) {
+      return;
+    }
+  } while (name->isEmpty());
+
+  if (m_core->modList()->getMod(name) != nullptr) {
+    reportError(tr("A mod with this name already exists."));
+    return;
+  }
+
+  IModInterface* newMod = m_core->createMod(name);
+  if (!newMod) {
+    return;
+  }
+
+  if (!copyDir(fileInfo.absoluteFilePath(), newMod->absolutePath(), true)) {
+    return;
+  }
+
+  m_core->refresh();
+
+  if (priority != -1) {
+    m_core->modList()->changeModPriority(ModInfo::getIndex(name), priority);
+  }
+}
+
+bool ModListView::moveSelection(int key)
+{
+  QModelIndex cindex = indexViewToModel(currentIndex());
+  QModelIndexList sourceRows = indexViewToModel(selectionModel()->selectedRows());
+
+  int offset = key == Qt::Key_Up ? -1 : 1;
+  if (m_sortProxy->sortOrder() == Qt::DescendingOrder) {
+    offset = -offset;
+  }
+
+  m_core->modList()->shiftMods(sourceRows, offset);
+
+  // reset the selection and the index
+  setCurrentIndex(indexModelToView(cindex));
+  for (auto idx : sourceRows) {
+    selectionModel()->select(indexModelToView(idx), QItemSelectionModel::Select | QItemSelectionModel::Rows);
+  }
+
+  return true;
+}
+
+bool ModListView::removeSelection()
+{
+  if (selectionModel()->hasSelection()) {
+    QModelIndexList rows = selectionModel()->selectedRows();
+    if (rows.count() > 1) {
+      emit removeSelectedMods();
+    }
+    else if (rows.count() == 1) {
+      // this does not work, I don't know why
+      // model()->removeRow(rows[0].row(), rows[0].parent());
+      m_core->modList()->removeRow(indexViewToModel(rows[0]).row());
+    }
+  }
+  return true;
+}
+
+bool ModListView::toggleSelectionState()
+{
+  if (!selectionModel()->hasSelection()) {
+    return true;
+  }
+  return m_core->modList()->toggleState(indexViewToModel(selectionModel()->selectedRows()));
+}
+
 void ModListView::updateGroupByProxy(int groupIndex)
 {
   // if the index is -1, we do not refresh unless we are grouping
@@ -683,6 +769,14 @@ void ModListView::dragEnterEvent(QDragEnterEvent* event)
 {
   emit dragEntered(event->mimeData());
   QTreeView::dragEnterEvent(event);
+
+
+  ModListDropInfo dropInfo(event->mimeData(), *m_core);
+
+  if (dropInfo.isValid() && !dropInfo.isLocalFileDrop()
+    && sortColumn() != ModList::COL_PRIORITY) {
+    log::warn("Drag&Drop is only supported when sorting by priority.");
+  }
 }
 
 void ModListView::dragMoveEvent(QDragMoveEvent* event)
@@ -722,91 +816,6 @@ void ModListView::timerEvent(QTimerEvent* event)
   }
 }
 
-void ModListView::onExternalFolderDropped(const QUrl& url, int priority)
-{
-  QFileInfo fileInfo(url.toLocalFile());
-
-  GuessedValue<QString> name;
-  name.setFilter(&fixDirectoryName);
-  name.update(fileInfo.fileName(), GUESS_PRESET);
-
-  do {
-    bool ok;
-    name.update(QInputDialog::getText(this, tr("Copy Folder..."),
-      tr("This will copy the content of %1 to a new mod.\n"
-        "Please enter the name:").arg(fileInfo.fileName()), QLineEdit::Normal, name, &ok),
-      GUESS_USER);
-    if (!ok) {
-      return;
-    }
-  } while (name->isEmpty());
-
-  if (m_core->modList()->getMod(name) != nullptr) {
-    reportError(tr("A mod with this name already exists."));
-    return;
-  }
-
-  IModInterface* newMod = m_core->createMod(name);
-  if (!newMod) {
-    return;
-  }
-
-  if (!copyDir(fileInfo.absoluteFilePath(), newMod->absolutePath(), true)) {
-    return;
-  }
-
-  m_core->refresh();
-
-  if (priority != -1) {
-    m_core->modList()->changeModPriority(ModInfo::getIndex(name), priority);
-  }
-}
-
-bool ModListView::moveSelection(int key)
-{
-  QModelIndex cindex = indexViewToModel(currentIndex());
-  QModelIndexList sourceRows = indexViewToModel(selectionModel()->selectedRows());
-
-  int offset = key == Qt::Key_Up ? -1 : 1;
-  if (m_sortProxy->sortOrder() == Qt::DescendingOrder) {
-    offset = -offset;
-  }
-
-  m_core->modList()->shiftMods(sourceRows, offset);
-
-  // reset the selection and the index
-  setCurrentIndex(indexModelToView(cindex));
-  for (auto idx : sourceRows) {
-    selectionModel()->select(indexModelToView(idx), QItemSelectionModel::Select | QItemSelectionModel::Rows);
-  }
-
-  return true;
-}
-
-bool ModListView::removeSelection()
-{
-  if (selectionModel()->hasSelection()) {
-    QModelIndexList rows = selectionModel()->selectedRows();
-    if (rows.count() > 1) {
-      emit removeSelectedMods();
-    }
-    else if (rows.count() == 1) {
-      // this does not work, I don't know why
-      // model()->removeRow(rows[0].row(), rows[0].parent());
-      m_core->modList()->removeRow(indexViewToModel(rows[0]).row());
-    }
-  }
-  return true;
-}
-
-bool ModListView::toggleSelectionState()
-{
-  if (!selectionModel()->hasSelection()) {
-    return true;
-  }
-  return m_core->modList()->toggleState(indexViewToModel(selectionModel()->selectedRows()));
-}
-
 bool ModListView::event(QEvent* event)
 {
   Profile* profile = m_core->currentProfile();
-- 
cgit v1.3.1


From e5f43788e874e638e1d4dbab20451c36e52df10d Mon Sep 17 00:00:00 2001
From: Mikaël Capelle <capelle.mikael@gmail.com>
Date: Fri, 1 Jan 2021 13:51:36 +0100
Subject: Visual fixes for the modlist.

- Fix invalid positions of markers in the scrollbar.
- Use color from children for collapsed elements (background and markers).
---
 src/icondelegate.cpp           |  9 +++++--
 src/modelutils.cpp             | 58 ++++++++++++++++++++++++++++++++++++++++++
 src/modelutils.h               | 12 +++++++++
 src/modlistbypriorityproxy.cpp | 46 +++++++++++++++++++++++++++++++++
 src/modlistbypriorityproxy.h   |  1 +
 src/modlistview.cpp            | 17 +++++++------
 src/modlistview.h              |  1 -
 src/pluginlistview.cpp         | 16 ++++--------
 src/pluginlistview.h           |  1 -
 src/settings.cpp               |  1 +
 src/viewmarkingscrollbar.cpp   | 30 +++++++++++++++-------
 src/viewmarkingscrollbar.h     |  6 ++---
 12 files changed, 163 insertions(+), 35 deletions(-)

(limited to 'src/modlistbypriorityproxy.cpp')

diff --git a/src/icondelegate.cpp b/src/icondelegate.cpp
index 03964263..901b5731 100644
--- a/src/icondelegate.cpp
+++ b/src/icondelegate.cpp
@@ -27,7 +27,7 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 
 using namespace MOBase;
 
-IconDelegate::IconDelegate(QObject *parent)
+IconDelegate::IconDelegate(QObject* parent)
   : QStyledItemDelegate(parent)
 {
 }
@@ -66,7 +66,12 @@ void IconDelegate::paintIcons(
 
 void IconDelegate::paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
-  QStyledItemDelegate::paint(painter, option, index);
+  if (auto* w = qobject_cast<QAbstractItemView*>(parent())) {
+    w->itemDelegate()->paint(painter, option, index);
+  }
+  else {
+    QStyledItemDelegate::paint(painter, option, index);
+  }
   paintIcons(painter, option, index, getIcons(index));
 }
 
diff --git a/src/modelutils.cpp b/src/modelutils.cpp
index d464bb91..7b54d258 100644
--- a/src/modelutils.cpp
+++ b/src/modelutils.cpp
@@ -2,6 +2,8 @@
 
 #include <QAbstractProxyModel>
 
+namespace MOShared {
+
 QModelIndexList flatIndex(
   const QAbstractItemModel* model, int column, const QModelIndex& parent)
 {
@@ -13,6 +15,26 @@ QModelIndexList flatIndex(
   return index;
 }
 
+static QModelIndexList visibleIndexImpl(QTreeView* view, int column, const QModelIndex& parent)
+{
+  if (parent.isValid() && !view->isExpanded(parent)) {
+    return {};
+  }
+
+  auto* model = view->model();
+  QModelIndexList index;
+  for (std::size_t i = 0; i < model->rowCount(parent); ++i) {
+    index.append(model->index(i, column, parent));
+    index.append(visibleIndexImpl(view, column, index.back()));
+  }
+  return index;
+}
+
+QModelIndexList visibleIndex(QTreeView* view, int column)
+{
+  return visibleIndexImpl(view, column, QModelIndex());
+}
+
 QModelIndex indexModelToView(const QModelIndex& index, const QAbstractItemView* view)
 {
   // we need to stack the proxy
@@ -67,3 +89,39 @@ QModelIndexList indexViewToModel(const QModelIndexList& index, const QAbstractIt
   }
   return result;
 }
+
+QColor childrenColor(const QModelIndex& index, QTreeView* view, int role)
+{
+  auto* model = view->model();
+  auto rowIndex = index.sibling(index.row(), 0);
+
+  if (model->hasChildren(rowIndex) && !view->isExpanded(rowIndex)) {
+
+    // this is a non-expanded item
+    std::vector<QColor> colors;
+    for (int i = 0; i < model->rowCount(rowIndex); ++i) {
+      auto childData = model->data(model->index(i, index.column(), rowIndex), role);
+      if (childData.isValid() && childData.canConvert<QColor>()) {
+        colors.push_back(childData.value<QColor>());
+      }
+    }
+
+    if (colors.empty()) {
+      return QColor();
+    }
+
+    int r = 0, g = 0, b = 0, a = 0;
+    for (auto& color : colors) {
+      r += color.red();
+      g += color.green();
+      b += color.blue();
+      a += color.alpha();
+    }
+
+    return QColor(r / colors.size(), g / colors.size(), b / colors.size(), a / colors.size());
+  }
+
+  return QColor();
+}
+
+}
diff --git a/src/modelutils.h b/src/modelutils.h
index b5becb6c..cb7c9394 100644
--- a/src/modelutils.h
+++ b/src/modelutils.h
@@ -3,16 +3,28 @@
 
 #include <QAbstractItemView>
 #include <QAbstractItemModel>
+#include <QColor>
+
+namespace MOShared {
 
 // retrieve all the row index under the given parent
 QModelIndexList flatIndex(
   const QAbstractItemModel* model, int column = 0, const QModelIndex& parent = QModelIndex());
 
+// retrieve all the visible index in the given view
+QModelIndexList visibleIndex(QTreeView* view, int column = 0);
+
 // convert back-and-forth through model proxies
 QModelIndex indexModelToView(const QModelIndex& index, const QAbstractItemView* view);
 QModelIndexList indexModelToView(const QModelIndexList& index, const QAbstractItemView* view);
 QModelIndex indexViewToModel(const QModelIndex& index, const QAbstractItemModel* model);
 QModelIndexList indexViewToModel(const QModelIndexList& index, const QAbstractItemModel* model);
 
+// retrieve the color of the children of the given index for the given, or an invalid
+// color if the item is expanded or the children do not have colors for the given role
+//
+QColor childrenColor(const QModelIndex& index, QTreeView* view, int role);
+
+}
 
 #endif
diff --git a/src/modlistbypriorityproxy.cpp b/src/modlistbypriorityproxy.cpp
index 749991d0..7ef540b0 100644
--- a/src/modlistbypriorityproxy.cpp
+++ b/src/modlistbypriorityproxy.cpp
@@ -181,6 +181,52 @@ bool ModListByPriorityProxy::hasChildren(const QModelIndex& parent) const
   return item->children.size() > 0;
 }
 
+QVariant ModListByPriorityProxy::data(const QModelIndex& index, int role) const
+{
+  auto sourceIndex = mapToSource(index);
+  if (!sourceIndex.isValid()) {
+    return QVariant();
+  }
+
+  auto sourceData = sourceModel()->data(sourceIndex, role);
+  if (role != Qt::BackgroundRole && role != ModList::ScrollMarkRole) {
+    return sourceData;
+  }
+
+  if (!hasChildren(index)) {
+    return sourceData;
+  }
+
+  bool expanded = !m_CollapsedItems.contains(index.sibling(index.row(), 0).data(Qt::DisplayRole).toString());
+
+  if (expanded) {
+    return sourceData;
+  }
+
+  // this is a non-expanded item
+  std::vector<QColor> colors;
+  for (int i = 0; i < rowCount(index); ++i) {
+    auto childData = sourceModel()->data(mapToSource(this->index(i, index.column(), index)), role);
+    if (childData.isValid() && childData.canConvert<QColor>()) {
+      colors.push_back(childData.value<QColor>());
+    }
+  }
+
+  if (true || colors.empty()) {
+    return sourceData;
+  }
+
+  int r = 0, g = 0, b = 0, a = 0;
+  for (auto& color : colors) {
+    r += color.red();
+    g += color.green();
+    b += color.blue();
+    a += color.alpha();
+  }
+
+  return QColor(r / colors.size(), g / colors.size(), b / colors.size(), a / colors.size());
+}
+
 bool ModListByPriorityProxy::setData(const QModelIndex& index, const QVariant& value, int role)
 {
   // only care about the "name" column
diff --git a/src/modlistbypriorityproxy.h b/src/modlistbypriorityproxy.h
index e5a8adff..5149b7a2 100644
--- a/src/modlistbypriorityproxy.h
+++ b/src/modlistbypriorityproxy.h
@@ -37,6 +37,7 @@ public:
   int columnCount(const QModelIndex& index) const override;
   bool hasChildren(const QModelIndex& parent) const override;
 
+  QVariant data(const QModelIndex& index, int role) const override;
   bool setData(const QModelIndex& index, const QVariant& value, int role) override;
   bool canDropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) const override;
   bool dropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) override;
diff --git a/src/modlistview.cpp b/src/modlistview.cpp
index 80aa6495..da4d79cf 100644
--- a/src/modlistview.cpp
+++ b/src/modlistview.cpp
@@ -28,6 +28,7 @@
 #include "modelutils.h"
 
 using namespace MOBase;
+using namespace MOShared;
 
 // delegate to remove indentation for mods when using collapsible
 // separator
@@ -57,6 +58,13 @@ public:
       }
     }
     QStyledItemDelegate::paint(painter, opt, index);
+
+    auto color = childrenColor(index, m_view, Qt::BackgroundRole);
+    if (color.isValid()) {
+      // int shift = 3 * opt.rect.height() / 4;
+      // opt.rect.adjust(0, shift, 0, 0);
+      painter->fillRect(opt.rect, color);
+    }
   }
 };
 
@@ -67,7 +75,7 @@ ModListView::ModListView(QWidget* parent)
   , m_byPriorityProxy(nullptr)
   , m_byCategoryProxy(nullptr)
   , m_byNexusIdProxy(nullptr)
-  , m_scrollbar(new ViewMarkingScrollBar(this->model(), ModList::ScrollMarkRole, this))
+  , m_scrollbar(new ViewMarkingScrollBar(this, ModList::ScrollMarkRole))
 {
   setVerticalScrollBar(m_scrollbar);
   MOBase::setCustomizableColumns(this);
@@ -79,13 +87,6 @@ ModListView::ModListView(QWidget* parent)
   connect(this, &ModListView::customContextMenuRequested, this, &ModListView::onCustomContextMenuRequested);
 }
 
-void ModListView::setModel(QAbstractItemModel* model)
-{
-  QTreeView::setModel(model);
-  setVerticalScrollBar(new ViewMarkingScrollBar(model, ModList::ScrollMarkRole, this));
-}
-
-
 void ModListView::refresh()
 {
   updateGroupByProxy(-1);
diff --git a/src/modlistview.h b/src/modlistview.h
index c0d96f3f..dac96822 100644
--- a/src/modlistview.h
+++ b/src/modlistview.h
@@ -38,7 +38,6 @@ public:
 
 public:
   explicit ModListView(QWidget* parent = 0);
-  void setModel(QAbstractItemModel* model) override;
 
   void setup(OrganizerCore& core, CategoryFactory& factory, MainWindow* mw, Ui::MainWindow* mwui);
 
diff --git a/src/pluginlistview.cpp b/src/pluginlistview.cpp
index 589c5737..d17b4a2f 100644
--- a/src/pluginlistview.cpp
+++ b/src/pluginlistview.cpp
@@ -21,19 +21,13 @@ using namespace MOBase;
 PluginListView::PluginListView(QWidget *parent)
   : QTreeView(parent)
   , m_sortProxy(nullptr)
-  , m_Scrollbar(new ViewMarkingScrollBar(this->model(), Qt::BackgroundRole, this))
+  , m_Scrollbar(new ViewMarkingScrollBar(this, Qt::BackgroundRole))
   , m_didUpdateMasterList(false)
 {
   setVerticalScrollBar(m_Scrollbar);
   MOBase::setCustomizableColumns(this);
 }
 
-void PluginListView::setModel(QAbstractItemModel *model)
-{
-  QTreeView::setModel(model);
-  setVerticalScrollBar(new ViewMarkingScrollBar(model, Qt::BackgroundRole, this));
-}
-
 int PluginListView::sortColumn() const
 {
   return m_sortProxy ? m_sortProxy->sortColumn() : -1;
@@ -41,22 +35,22 @@ int PluginListView::sortColumn() const
 
 QModelIndex PluginListView::indexModelToView(const QModelIndex& index) const
 {
-  return ::indexModelToView(index, this);
+  return MOShared::indexModelToView(index, this);
 }
 
 QModelIndexList PluginListView::indexModelToView(const QModelIndexList& index) const
 {
-  return ::indexModelToView(index, this);
+  return MOShared::indexModelToView(index, this);
 }
 
 QModelIndex PluginListView::indexViewToModel(const QModelIndex& index) const
 {
-  return ::indexViewToModel(index, m_core->pluginList());
+  return MOShared::indexViewToModel(index, m_core->pluginList());
 }
 
 QModelIndexList PluginListView::indexViewToModel(const QModelIndexList& index) const
 {
-  return ::indexViewToModel(index, m_core->pluginList());
+  return MOShared::indexViewToModel(index, m_core->pluginList());
 }
 
 void PluginListView::updatePluginCount()
diff --git a/src/pluginlistview.h b/src/pluginlistview.h
index e5dc15e7..6470ced9 100644
--- a/src/pluginlistview.h
+++ b/src/pluginlistview.h
@@ -19,7 +19,6 @@ class PluginListView : public QTreeView
   Q_OBJECT
 public:
   explicit PluginListView(QWidget* parent = nullptr);
-  void setModel(QAbstractItemModel* model) override;
 
   void setup(OrganizerCore& core, MainWindow* mw, Ui::MainWindow* mwui);
 
diff --git a/src/settings.cpp b/src/settings.cpp
index 0e2de9d7..e379a819 100644
--- a/src/settings.cpp
+++ b/src/settings.cpp
@@ -31,6 +31,7 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 #include <iplugingame.h>
 
 using namespace MOBase;
+using namespace MOShared;
 
 
 EndorsementState endorsementStateFromString(const QString& s)
diff --git a/src/viewmarkingscrollbar.cpp b/src/viewmarkingscrollbar.cpp
index 0991f171..fb165922 100644
--- a/src/viewmarkingscrollbar.cpp
+++ b/src/viewmarkingscrollbar.cpp
@@ -4,9 +4,11 @@
 #include <QStyleOptionSlider>
 #include <QPainter>
 
-ViewMarkingScrollBar::ViewMarkingScrollBar(QAbstractItemModel* model, int role, QWidget *parent)
-  : QScrollBar(parent)
-  , m_model(model)
+using namespace MOShared;
+
+ViewMarkingScrollBar::ViewMarkingScrollBar(QTreeView* view, int role)
+  : QScrollBar(view)
+  , m_view(view)
   , m_role(role)
 {
   // not implemented for horizontal sliders
@@ -15,7 +17,7 @@ ViewMarkingScrollBar::ViewMarkingScrollBar(QAbstractItemModel* model, int role,
 
 void ViewMarkingScrollBar::paintEvent(QPaintEvent* event)
 {
-  if (m_model == nullptr) {
+  if (m_view->model() == nullptr) {
     return;
   }
   QScrollBar::paintEvent(event);
@@ -28,17 +30,27 @@ void ViewMarkingScrollBar::paintEvent(QPaintEvent* event)
   QRect handleRect = style()->subControlRect(QStyle::CC_ScrollBar, &styleOption, QStyle::SC_ScrollBarSlider, this);
   QRect innerRect = style()->subControlRect(QStyle::CC_ScrollBar, &styleOption, QStyle::SC_ScrollBarGroove, this);
 
-  auto indices = flatIndex(m_model, 0, QModelIndex());
+  auto indices = visibleIndex(m_view, 0);
 
   painter.translate(innerRect.topLeft() + QPoint(0, 3));
   qreal scale = static_cast<qreal>(innerRect.height() - 3) / static_cast<qreal>(indices.size());
 
   for (int i = 0; i < indices.size(); ++i) {
     QVariant data = indices[i].data(m_role);
-    if (data.isValid()) {
-      QColor col = data.value<QColor>();
-      painter.setPen(col);
-      painter.setBrush(col);
+    QColor color;
+
+    if (data.canConvert<QColor>()) {
+      color = data.value<QColor>();
+    }
+
+    auto childrenColor = MOShared::childrenColor(indices[i], m_view, m_role);
+    if (childrenColor.isValid()) {
+      color = childrenColor;
+    }
+
+    if (color.isValid()) {
+      painter.setPen(color);
+      painter.setBrush(color);
       painter.drawRect(QRect(2, i * scale - 2, handleRect.width() - 5, 3));
     }
   }
diff --git a/src/viewmarkingscrollbar.h b/src/viewmarkingscrollbar.h
index 88d77039..6947a018 100644
--- a/src/viewmarkingscrollbar.h
+++ b/src/viewmarkingscrollbar.h
@@ -1,20 +1,20 @@
 #ifndef VIEWMARKINGSCROLLBAR_H
 #define VIEWMARKINGSCROLLBAR_H
 
-#include <QAbstractItemModel>
+#include <QTreeView>
 #include <QScrollBar>
 
 
 class ViewMarkingScrollBar : public QScrollBar
 {
 public:
-  ViewMarkingScrollBar(QAbstractItemModel *model, int role, QWidget* parent = nullptr);
+  ViewMarkingScrollBar(QTreeView* view, int role);
 
 protected:
   void paintEvent(QPaintEvent *event) override;
 
 private:
-  QAbstractItemModel* m_model;
+  QTreeView* m_view;
   int m_role;
 };
 
-- 
cgit v1.3.1


From 8de7b79a2b211805a4ba348e490a7ab8eac15eef Mon Sep 17 00:00:00 2001
From: Mikaël Capelle <capelle.mikael@gmail.com>
Date: Sat, 2 Jan 2021 20:26:39 +0100
Subject: Move markers management for overwrite/overwritten to ModListView.

---
 src/modelutils.cpp             |  34 ----------
 src/modelutils.h               |   5 --
 src/modlist.cpp                |  51 +--------------
 src/modlist.h                  |  11 ----
 src/modlistbypriorityproxy.cpp |  46 --------------
 src/modlistbypriorityproxy.h   |   1 -
 src/modlistview.cpp            | 140 +++++++++++++++++++++++++++++++++++++----
 src/modlistview.h              |  27 +++++++-
 src/viewmarkingscrollbar.cpp   |  22 +++----
 src/viewmarkingscrollbar.h     |   4 ++
 10 files changed, 168 insertions(+), 173 deletions(-)

(limited to 'src/modlistbypriorityproxy.cpp')

diff --git a/src/modelutils.cpp b/src/modelutils.cpp
index 7b54d258..83054806 100644
--- a/src/modelutils.cpp
+++ b/src/modelutils.cpp
@@ -90,38 +90,4 @@ QModelIndexList indexViewToModel(const QModelIndexList& index, const QAbstractIt
   return result;
 }
 
-QColor childrenColor(const QModelIndex& index, QTreeView* view, int role)
-{
-  auto* model = view->model();
-  auto rowIndex = index.sibling(index.row(), 0);
-
-  if (model->hasChildren(rowIndex) && !view->isExpanded(rowIndex)) {
-
-    // this is a non-expanded item
-    std::vector<QColor> colors;
-    for (int i = 0; i < model->rowCount(rowIndex); ++i) {
-      auto childData = model->data(model->index(i, index.column(), rowIndex), role);
-      if (childData.isValid() && childData.canConvert<QColor>()) {
-        colors.push_back(childData.value<QColor>());
-      }
-    }
-
-    if (colors.empty()) {
-      return QColor();
-    }
-
-    int r = 0, g = 0, b = 0, a = 0;
-    for (auto& color : colors) {
-      r += color.red();
-      g += color.green();
-      b += color.blue();
-      a += color.alpha();
-    }
-
-    return QColor(r / colors.size(), g / colors.size(), b / colors.size(), a / colors.size());
-  }
-
-  return QColor();
-}
-
 }
diff --git a/src/modelutils.h b/src/modelutils.h
index cb7c9394..e6510941 100644
--- a/src/modelutils.h
+++ b/src/modelutils.h
@@ -20,11 +20,6 @@ QModelIndexList indexModelToView(const QModelIndexList& index, const QAbstractIt
 QModelIndex indexViewToModel(const QModelIndex& index, const QAbstractItemModel* model);
 QModelIndexList indexViewToModel(const QModelIndexList& index, const QAbstractItemModel* model);
 
-// retrieve the color of the children of the given index for the given, or an invalid
-// color if the item is expanded or the children do not have colors for the given role
-//
-QColor childrenColor(const QModelIndex& index, QTreeView* view, int role);
-
 }
 
 #endif
diff --git a/src/modlist.cpp b/src/modlist.cpp
index a2e59b62..155a094f 100644
--- a/src/modlist.cpp
+++ b/src/modlist.cpp
@@ -464,33 +464,11 @@ QVariant ModList::data(const QModelIndex &modelIndex, int role) const
     return QVariant();
   }
   else if (role == Qt::BackgroundRole || role == ScrollMarkRole) {
-    bool overwrite = m_Overwrite.find(modIndex) != m_Overwrite.end();
-    bool archiveOverwrite = m_ArchiveOverwrite.find(modIndex) != m_ArchiveOverwrite.end();
-    bool archiveLooseOverwrite = m_ArchiveLooseOverwrite.find(modIndex) != m_ArchiveLooseOverwrite.end();
-    bool overwritten = m_Overwritten.find(modIndex) != m_Overwritten.end();
-    bool archiveOverwritten = m_ArchiveOverwritten.find(modIndex) != m_ArchiveOverwritten.end();
-    bool archiveLooseOverwritten = m_ArchiveLooseOverwritten.find(modIndex) != m_ArchiveLooseOverwritten.end();
     if (column == COL_NOTES && modInfo->color().isValid()) {
       return modInfo->color();
     }
-    else if (modInfo->getHighlight() & ModInfo::HIGHLIGHT_PLUGIN) {
-      return Settings::instance().colors().modlistContainsPlugin();
-    }
-    else if (overwritten || archiveLooseOverwritten) {
-      return Settings::instance().colors().modlistOverwritingLoose();
-    }
-    else if (overwrite || archiveLooseOverwrite) {
-      return Settings::instance().colors().modlistOverwrittenLoose();
-    }
-    else if (archiveOverwritten) {
-      return Settings::instance().colors().modlistOverwritingArchive();
-    }
-    else if (archiveOverwrite) {
-      return Settings::instance().colors().modlistOverwrittenArchive();
-    }
     else if (modInfo->isSeparator() && modInfo->color().isValid()
-               && (role != ScrollMarkRole
-                 || Settings::instance().colors().colorSeparatorScrollbar())) {
+               && (role != ScrollMarkRole || Settings::instance().colors().colorSeparatorScrollbar())) {
       return modInfo->color();
     }
     else {
@@ -851,27 +829,6 @@ void ModList::changeModPriority(int sourceIndex, int newPriority)
   emit modPrioritiesChanged({ index(sourceIndex, 0) });
 }
 
-void ModList::setOverwriteMarkers(const std::set<unsigned int> &overwrite, const std::set<unsigned int> &overwritten)
-{
-  m_Overwrite = overwrite;
-  m_Overwritten = overwritten;
-  notifyChange(0, rowCount() - 1);
-}
-
-void ModList::setArchiveOverwriteMarkers(const std::set<unsigned int> &overwrite, const std::set<unsigned int> &overwritten)
-{
-  m_ArchiveOverwrite = overwrite;
-  m_ArchiveOverwritten = overwritten;
-  notifyChange(0, rowCount() - 1);
-}
-
-void ModList::setArchiveLooseOverwriteMarkers(const std::set<unsigned int> &overwrite, const std::set<unsigned int> &overwritten)
-{
-  m_ArchiveLooseOverwrite = overwrite;
-  m_ArchiveLooseOverwritten = overwritten;
-  notifyChange(0, rowCount() - 1);
-}
-
 void ModList::setPluginContainer(PluginContainer *pluginContianer)
 {
   m_PluginContainer = pluginContianer;
@@ -1393,12 +1350,6 @@ void ModList::notifyChange(int rowStart, int rowEnd)
   Guard g([&]{ m_InNotifyChange = false; });
 
   if (rowStart < 0) {
-    m_Overwrite.clear();
-    m_Overwritten.clear();
-    m_ArchiveOverwrite.clear();
-    m_ArchiveOverwritten.clear();
-    m_ArchiveLooseOverwrite.clear();
-    m_ArchiveLooseOverwritten.clear();
     beginResetModel();
     endResetModel();
   } else {
diff --git a/src/modlist.h b/src/modlist.h
index 22703923..afbef7af 100644
--- a/src/modlist.h
+++ b/src/modlist.h
@@ -142,12 +142,8 @@ public:
   void changeModPriority(int sourceIndex, int newPriority);
   void changeModPriority(std::vector<int> sourceIndices, int newPriority);
 
-  void setOverwriteMarkers(const std::set<unsigned int> &overwrite, const std::set<unsigned int> &overwritten);
   void setPluginContainer(PluginContainer *pluginContainer);
 
-  void setArchiveOverwriteMarkers(const std::set<unsigned int> &overwrite, const std::set<unsigned int> &overwritten);
-  void setArchiveLooseOverwriteMarkers(const std::set<unsigned int> &overwrite, const std::set<unsigned int> &overwritten);
-
   bool modInfoAboutToChange(ModInfo::Ptr info);
   void modInfoChanged(ModInfo::Ptr info);
 
@@ -420,13 +416,6 @@ private:
 
   QFontMetrics m_FontMetrics;
 
-  std::set<unsigned int> m_Overwrite;
-  std::set<unsigned int> m_Overwritten;
-  std::set<unsigned int> m_ArchiveOverwrite;
-  std::set<unsigned int> m_ArchiveOverwritten;
-  std::set<unsigned int> m_ArchiveLooseOverwrite;
-  std::set<unsigned int> m_ArchiveLooseOverwritten;
-
   TModInfoChange m_ChangeInfo;
 
   SignalModInstalled m_ModInstalled;
diff --git a/src/modlistbypriorityproxy.cpp b/src/modlistbypriorityproxy.cpp
index 7ef540b0..749991d0 100644
--- a/src/modlistbypriorityproxy.cpp
+++ b/src/modlistbypriorityproxy.cpp
@@ -181,52 +181,6 @@ bool ModListByPriorityProxy::hasChildren(const QModelIndex& parent) const
   return item->children.size() > 0;
 }
 
-QVariant ModListByPriorityProxy::data(const QModelIndex& index, int role) const
-{
-  auto sourceIndex = mapToSource(index);
-  if (!sourceIndex.isValid()) {
-    return QVariant();
-  }
-
-  auto sourceData = sourceModel()->data(sourceIndex, role);
-  if (role != Qt::BackgroundRole && role != ModList::ScrollMarkRole) {
-    return sourceData;
-  }
-
-  if (!hasChildren(index)) {
-    return sourceData;
-  }
-
-  bool expanded = !m_CollapsedItems.contains(index.sibling(index.row(), 0).data(Qt::DisplayRole).toString());
-
-  if (expanded) {
-    return sourceData;
-  }
-
-  // this is a non-expanded item
-  std::vector<QColor> colors;
-  for (int i = 0; i < rowCount(index); ++i) {
-    auto childData = sourceModel()->data(mapToSource(this->index(i, index.column(), index)), role);
-    if (childData.isValid() && childData.canConvert<QColor>()) {
-      colors.push_back(childData.value<QColor>());
-    }
-  }
-
-  if (true || colors.empty()) {
-    return sourceData;
-  }
-
-  int r = 0, g = 0, b = 0, a = 0;
-  for (auto& color : colors) {
-    r += color.red();
-    g += color.green();
-    b += color.blue();
-    a += color.alpha();
-  }
-
-  return QColor(r / colors.size(), g / colors.size(), b / colors.size(), a / colors.size());
-}
-
 bool ModListByPriorityProxy::setData(const QModelIndex& index, const QVariant& value, int role)
 {
   // only care about the "name" column
diff --git a/src/modlistbypriorityproxy.h b/src/modlistbypriorityproxy.h
index 5149b7a2..e5a8adff 100644
--- a/src/modlistbypriorityproxy.h
+++ b/src/modlistbypriorityproxy.h
@@ -37,7 +37,6 @@ public:
   int columnCount(const QModelIndex& index) const override;
   bool hasChildren(const QModelIndex& parent) const override;
 
-  QVariant data(const QModelIndex& index, int role) const override;
   bool setData(const QModelIndex& index, const QVariant& value, int role) override;
   bool canDropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) const override;
   bool dropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) override;
diff --git a/src/modlistview.cpp b/src/modlistview.cpp
index a460e4a4..f7db64e6 100644
--- a/src/modlistview.cpp
+++ b/src/modlistview.cpp
@@ -75,7 +75,7 @@ public:
 
     // compute required color from children, otherwise fallback to the
     // color from the model, and draw the background here
-    auto color = childrenColor(index, m_view, Qt::BackgroundRole);
+    auto color = m_view->markerColor(index);
     if (!color.isValid()) {
       color = index.data(Qt::BackgroundRole).value<QColor>();
     }
@@ -98,6 +98,24 @@ public:
   }
 };
 
+class ModListViewMarkingScrollBar : public ViewMarkingScrollBar {
+  ModListView* m_view;
+public:
+  ModListViewMarkingScrollBar(ModListView* view) :
+    ViewMarkingScrollBar(view, ModList::ScrollMarkRole), m_view(view) { }
+
+
+  QColor color(const QModelIndex& index) const override
+  {
+    auto color = m_view->markerColor(index);
+    if (!color.isValid()) {
+      color = ViewMarkingScrollBar::color(index);
+    }
+    return color;
+  }
+
+};
+
 ModListView::ModListView(QWidget* parent)
   : QTreeView(parent)
   , m_core(nullptr)
@@ -105,7 +123,8 @@ ModListView::ModListView(QWidget* parent)
   , m_byPriorityProxy(nullptr)
   , m_byCategoryProxy(nullptr)
   , m_byNexusIdProxy(nullptr)
-  , m_scrollbar(new ViewMarkingScrollBar(this, ModList::ScrollMarkRole))
+  , m_overwrite{ {}, {}, {}, {}, {}, {} }
+  , m_scrollbar(new ModListViewMarkingScrollBar(this))
 {
   setVerticalScrollBar(m_scrollbar);
   MOBase::setCustomizableColumns(this);
@@ -386,10 +405,7 @@ void ModListView::onModPrioritiesChanged(const QModelIndexList& indices)
       }
       // update conflict check on the moved mod
       modInfo->doConflictCheck();
-      m_core->modList()->setOverwriteMarkers(modInfo->getModOverwrite(), modInfo->getModOverwritten());
-      m_core->modList()->setArchiveOverwriteMarkers(modInfo->getModArchiveOverwrite(), modInfo->getModArchiveOverwritten());
-      m_core->modList()->setArchiveLooseOverwriteMarkers(modInfo->getModArchiveLooseOverwrite(), modInfo->getModArchiveLooseOverwritten());
-      verticalScrollBar()->repaint();
+      setOverwriteMarkers(modInfo);
     }
   }
 }
@@ -681,6 +697,7 @@ void ModListView::setup(OrganizerCore& core, CategoryFactory& factory, MainWindo
   connect(core.modList(), &ModList::modPrioritiesChanged, [=](auto&& indices) { onModPrioritiesChanged(indices); });
   connect(core.modList(), &ModList::clearOverwrite, [=] { m_actions->clearOverwrite(); });
   connect(core.modList(), &ModList::modStatesChanged, [=] { updateModCount(); });
+  connect(core.modList(), &ModList::modelReset, [=] { clearOverwriteMarkers(); });
 
   m_byPriorityProxy = new ModListByPriorityProxy(core.currentProfile(), core, this);
   m_byPriorityProxy->setSourceModel(core.modList());
@@ -935,6 +952,108 @@ void ModListView::onDoubleClicked(const QModelIndex& index)
   closePersistentEditor(index);
 }
 
+void ModListView::clearOverwriteMarkers()
+{
+  m_overwrite.overwrite.clear();
+  m_overwrite.overwritten.clear();
+  m_overwrite.archiveOverwrite.clear();
+  m_overwrite.archiveOverwritten.clear();
+  m_overwrite.archiveLooseOverwrite.clear();
+  m_overwrite.archiveLooseOverwritten.clear();
+}
+
+void ModListView::setOverwriteMarkers(const std::set<unsigned int>& overwrite, const std::set<unsigned int>& overwritten)
+{
+  m_overwrite.overwrite = overwrite;
+  m_overwrite.overwritten = overwritten;
+}
+
+void ModListView::setArchiveOverwriteMarkers(const std::set<unsigned int>& overwrite, const std::set<unsigned int>& overwritten)
+{
+  m_overwrite.archiveOverwrite = overwrite;
+  m_overwrite.archiveOverwritten = overwritten;
+}
+
+void ModListView::setArchiveLooseOverwriteMarkers(const std::set<unsigned int>& overwrite, const std::set<unsigned int>& overwritten)
+{
+  m_overwrite.archiveLooseOverwrite = overwrite;
+  m_overwrite.archiveLooseOverwritten = overwritten;
+}
+
+void ModListView::setOverwriteMarkers(ModInfo::Ptr mod)
+{
+  if (mod) {
+    setOverwriteMarkers(mod->getModOverwrite(), mod->getModOverwritten());
+    setArchiveOverwriteMarkers(mod->getModArchiveOverwrite(), mod->getModArchiveOverwritten());
+    setArchiveLooseOverwriteMarkers(mod->getModArchiveLooseOverwrite(), mod->getModArchiveLooseOverwritten());
+  }
+  else {
+    setOverwriteMarkers({}, {});
+    setArchiveOverwriteMarkers({}, {});
+    setArchiveLooseOverwriteMarkers({}, {});
+  }
+  dataChanged(model()->index(0, 0), model()->index(model()->rowCount(), model()->columnCount()));
+  verticalScrollBar()->repaint();
+}
+
+QColor ModListView::markerColor(const QModelIndex& index) const
+{
+  unsigned int modIndex = index.data(ModList::IndexRole).toInt();
+  ModInfo::Ptr modInfo = ModInfo::getByIndex(modIndex);
+  bool overwrite = m_overwrite.overwrite.find(modIndex) != m_overwrite.overwrite.end();
+  bool archiveOverwrite = m_overwrite.archiveOverwrite.find(modIndex) != m_overwrite.archiveOverwrite.end();
+  bool archiveLooseOverwrite = m_overwrite.archiveOverwritten.find(modIndex) != m_overwrite.archiveOverwritten.end();
+  bool overwritten = m_overwrite.overwritten.find(modIndex) != m_overwrite.overwritten.end();
+  bool archiveOverwritten = m_overwrite.archiveOverwritten.find(modIndex) != m_overwrite.archiveOverwritten.end();
+  bool archiveLooseOverwritten = m_overwrite.archiveLooseOverwritten.find(modIndex) != m_overwrite.archiveLooseOverwritten.end();
+
+  // TODO: Move this here
+  if (modInfo->getHighlight() & ModInfo::HIGHLIGHT_PLUGIN) {
+    return Settings::instance().colors().modlistContainsPlugin();
+  }
+  else if (overwritten || archiveLooseOverwritten) {
+    return Settings::instance().colors().modlistOverwritingLoose();
+  }
+  else if (overwrite || archiveLooseOverwrite) {
+    return Settings::instance().colors().modlistOverwrittenLoose();
+  }
+  else if (archiveOverwritten) {
+    return Settings::instance().colors().modlistOverwritingArchive();
+  }
+  else if (archiveOverwrite) {
+    return Settings::instance().colors().modlistOverwrittenArchive();
+  }
+
+  // collapsed separator
+  auto rowIndex = index.sibling(index.row(), 0);
+  if (hasCollapsibleSeparators() && model()->hasChildren(rowIndex) && !isExpanded(rowIndex)) {
+
+    std::vector<QColor> colors;
+    for (int i = 0; i < model()->rowCount(rowIndex); ++i) {
+      auto childColor = markerColor(model()->index(i, index.column(), rowIndex));
+      if (childColor.isValid()) {
+        colors.push_back(childColor);
+      }
+    }
+
+    if (colors.empty()) {
+      return QColor();
+    }
+
+    int r = 0, g = 0, b = 0, a = 0;
+    for (auto& color : colors) {
+      r += color.red();
+      g += color.green();
+      b += color.blue();
+      a += color.alpha();
+    }
+
+    return QColor(r / colors.size(), g / colors.size(), b / colors.size(), a / colors.size());
+  }
+
+  return QColor();
+}
+
 void ModListView::onSelectionChanged(const QItemSelection& selected, const QItemSelection& deselected)
 {
   if (hasCollapsibleSeparators()) {
@@ -948,16 +1067,11 @@ void ModListView::onSelectionChanged(const QItemSelection& selected, const QItem
   if (selected.count()) {
     auto index = selected.indexes().last();
     ModInfo::Ptr selectedMod = ModInfo::getByIndex(index.data(ModList::IndexRole).toInt());
-    m_core->modList()->setOverwriteMarkers(selectedMod->getModOverwrite(), selectedMod->getModOverwritten());
-    m_core->modList()->setArchiveOverwriteMarkers(selectedMod->getModArchiveOverwrite(), selectedMod->getModArchiveOverwritten());
-    m_core->modList()->setArchiveLooseOverwriteMarkers(selectedMod->getModArchiveLooseOverwrite(), selectedMod->getModArchiveLooseOverwritten());
+    setOverwriteMarkers(selectedMod);
   }
   else {
-    m_core->modList()->setOverwriteMarkers({}, {});
-    m_core->modList()->setArchiveOverwriteMarkers({}, {});
-    m_core->modList()->setArchiveLooseOverwriteMarkers({}, {});
+    setOverwriteMarkers(nullptr);
   }
-  verticalScrollBar()->repaint();
 
 }
 
diff --git a/src/modlistview.h b/src/modlistview.h
index d67f2940..bf705573 100644
--- a/src/modlistview.h
+++ b/src/modlistview.h
@@ -166,10 +166,27 @@ protected slots:
 
 private:
 
+  friend class ModListStyledItemDelegated;
+  friend class ModListViewMarkingScrollBar;
+
   void onModPrioritiesChanged(const QModelIndexList& indices);
   void onModInstalled(const QString& modName);
   void onModFilterActive(bool filterActive);
 
+  // overwrite markers
+  void clearOverwriteMarkers();
+  void setOverwriteMarkers(const std::set<unsigned int>& overwrite, const std::set<unsigned int>& overwritten);
+  void setArchiveOverwriteMarkers(const std::set<unsigned int>& overwrite, const std::set<unsigned int>& overwritten);
+  void setArchiveLooseOverwriteMarkers(const std::set<unsigned int>& overwrite, const std::set<unsigned int>& overwritten);
+
+  // set overwrite markers from the mod and repaint (if mod is nullptr, clear overwrite and repaint)
+  //
+  void setOverwriteMarkers(ModInfo::Ptr mod);
+
+  // retrieve the marker color for the given index
+  //
+  QColor markerColor(const QModelIndex& index) const;
+
   // get/set the selected items on the view, this method return/take indices
   // from the mod list model, not the view, so it's safe to restore
   //
@@ -219,10 +236,18 @@ private:
 
   ModListSortProxy* m_sortProxy;
   ModListByPriorityProxy* m_byPriorityProxy;
-
   QtGroupingProxy* m_byCategoryProxy;
   QtGroupingProxy* m_byNexusIdProxy;
 
+  struct OverwriteInfo {
+    std::set<unsigned int> overwrite;
+    std::set<unsigned int> overwritten;
+    std::set<unsigned int> archiveOverwrite;
+    std::set<unsigned int> archiveOverwritten;
+    std::set<unsigned int> archiveLooseOverwrite;
+    std::set<unsigned int> archiveLooseOverwritten;
+  } m_overwrite;
+
   ViewMarkingScrollBar* m_scrollbar;
 
   bool m_inDragMoveEvent = false;
diff --git a/src/viewmarkingscrollbar.cpp b/src/viewmarkingscrollbar.cpp
index fb165922..56754237 100644
--- a/src/viewmarkingscrollbar.cpp
+++ b/src/viewmarkingscrollbar.cpp
@@ -15,6 +15,15 @@ ViewMarkingScrollBar::ViewMarkingScrollBar(QTreeView* view, int role)
   Q_ASSERT(this->orientation() == Qt::Vertical);
 }
 
+QColor ViewMarkingScrollBar::color(const QModelIndex& index) const
+{
+  auto data = index.data(m_role);
+  if (data.canConvert<QColor>()) {
+    return data.value<QColor>();
+  }
+  return QColor();
+}
+
 void ViewMarkingScrollBar::paintEvent(QPaintEvent* event)
 {
   if (m_view->model() == nullptr) {
@@ -36,18 +45,7 @@ void ViewMarkingScrollBar::paintEvent(QPaintEvent* event)
   qreal scale = static_cast<qreal>(innerRect.height() - 3) / static_cast<qreal>(indices.size());
 
   for (int i = 0; i < indices.size(); ++i) {
-    QVariant data = indices[i].data(m_role);
-    QColor color;
-
-    if (data.canConvert<QColor>()) {
-      color = data.value<QColor>();
-    }
-
-    auto childrenColor = MOShared::childrenColor(indices[i], m_view, m_role);
-    if (childrenColor.isValid()) {
-      color = childrenColor;
-    }
-
+    QColor color = this->color(indices[i]);
     if (color.isValid()) {
       painter.setPen(color);
       painter.setBrush(color);
diff --git a/src/viewmarkingscrollbar.h b/src/viewmarkingscrollbar.h
index 6947a018..01b5a8c0 100644
--- a/src/viewmarkingscrollbar.h
+++ b/src/viewmarkingscrollbar.h
@@ -13,6 +13,10 @@ public:
 protected:
   void paintEvent(QPaintEvent *event) override;
 
+  // retrieve the color of the marker for the given index
+  //
+  virtual QColor color(const QModelIndex& index) const;
+
 private:
   QTreeView* m_view;
   int m_role;
-- 
cgit v1.3.1


From 85cd33715723f294abeeb8a0f3f77c0de27f6a37 Mon Sep 17 00:00:00 2001
From: Mikaël Capelle <capelle.mikael@gmail.com>
Date: Mon, 4 Jan 2021 19:06:43 +0100
Subject: Disable proxies when they are not used.

---
 src/modlistbypriorityproxy.cpp |  9 +++--
 src/modlistsortproxy.cpp       |  6 ++--
 src/modlistview.cpp            | 53 ++++++++++++++++++------------
 src/qtgroupingproxy.cpp        | 74 +++++++++++++++++++++++++-----------------
 src/qtgroupingproxy.h          |  7 ++--
 5 files changed, 90 insertions(+), 59 deletions(-)

(limited to 'src/modlistbypriorityproxy.cpp')

diff --git a/src/modlistbypriorityproxy.cpp b/src/modlistbypriorityproxy.cpp
index 749991d0..bf3c2d09 100644
--- a/src/modlistbypriorityproxy.cpp
+++ b/src/modlistbypriorityproxy.cpp
@@ -18,12 +18,15 @@ ModListByPriorityProxy::~ModListByPriorityProxy()
 
 void ModListByPriorityProxy::setSourceModel(QAbstractItemModel* model)
 {
+  if (sourceModel()) {
+    disconnect(sourceModel(), nullptr, this, nullptr);
+  }
+
   QAbstractProxyModel::setSourceModel(model);
 
   if (sourceModel()) {
-    m_CollapsedItems.clear();
-    connect(sourceModel(), &QAbstractItemModel::layoutChanged, this, [this]() { buildTree(); }, Qt::UniqueConnection);
-    connect(sourceModel(), &QAbstractItemModel::rowsRemoved, this, [this]() { buildTree(); }, Qt::UniqueConnection);
+    connect(sourceModel(), &QAbstractItemModel::layoutChanged, this, &ModListByPriorityProxy::buildTree, Qt::UniqueConnection);
+    connect(sourceModel(), &QAbstractItemModel::rowsRemoved, this, &ModListByPriorityProxy::buildTree, Qt::UniqueConnection);
     connect(sourceModel(), &QAbstractItemModel::modelReset, this, &ModListByPriorityProxy::buildTree, Qt::UniqueConnection);
     connect(sourceModel(), &QAbstractItemModel::dataChanged, this, &ModListByPriorityProxy::modelDataChanged, Qt::UniqueConnection);
     refresh();
diff --git a/src/modlistsortproxy.cpp b/src/modlistsortproxy.cpp
index 054b980c..9ae37a43 100644
--- a/src/modlistsortproxy.cpp
+++ b/src/modlistsortproxy.cpp
@@ -652,8 +652,10 @@ void ModListSortProxy::setSourceModel(QAbstractItemModel *sourceModel)
   if (proxy != nullptr) {
     sourceModel = proxy->sourceModel();
   }
-  connect(sourceModel, SIGNAL(aboutToChangeData()), this, SLOT(aboutToChangeData()), Qt::UniqueConnection);
-  connect(sourceModel, SIGNAL(postDataChanged()), this, SLOT(postDataChanged()), Qt::UniqueConnection);
+  if (sourceModel) {
+    connect(sourceModel, SIGNAL(aboutToChangeData()), this, SLOT(aboutToChangeData()), Qt::UniqueConnection);
+    connect(sourceModel, SIGNAL(postDataChanged()), this, SLOT(postDataChanged()), Qt::UniqueConnection);
+  }
 }
 
 void ModListSortProxy::aboutToChangeData()
diff --git a/src/modlistview.cpp b/src/modlistview.cpp
index 2edcf56e..6399e910 100644
--- a/src/modlistview.cpp
+++ b/src/modlistview.cpp
@@ -631,6 +631,18 @@ bool ModListView::toggleSelectionState()
   return m_core->modList()->toggleState(indexViewToModel(selectionModel()->selectedRows()));
 }
 
+// helper function because QtGroupingProxy and ModListByPriorityProxy
+// have similar methods but do not share a common parent class
+template <class Proxy>
+void setProxy(OrganizerCore* core, QTreeView* view, ModListSortProxy* sortProxy, Proxy* proxy)
+{
+  proxy->setSourceModel(core->modList());
+  sortProxy->setSourceModel(proxy);
+  QObject::connect(view, &QTreeView::expanded, proxy, &Proxy::expanded);
+  QObject::connect(view, &QTreeView::collapsed, proxy, &Proxy::collapsed);
+  proxy->refreshExpandedItems();
+}
+
 void ModListView::updateGroupByProxy(int groupIndex)
 {
   // if the index is -1, we do not refresh unless we are grouping
@@ -642,18 +654,18 @@ void ModListView::updateGroupByProxy(int groupIndex)
     groupIndex = ui.groupBy->currentIndex();
   }
 
+  auto* previousModel = m_sortProxy->sourceModel();
+
   if (groupIndex == GroupBy::CATEGORY) {
-    m_byCategoryProxy->setGroupedColumn(ModList::COL_CATEGORY);
-    m_sortProxy->setSourceModel(m_byCategoryProxy);
+    setProxy(m_core, this, m_sortProxy, m_byCategoryProxy);
   }
   else if (groupIndex == GroupBy::NEXUS_ID) {
-    m_byNexusIdProxy->setGroupedColumn(ModList::COL_MODID);
-    m_sortProxy->setSourceModel(m_byNexusIdProxy);
+    setProxy(m_core, this, m_sortProxy, m_byNexusIdProxy);
   }
   else if (m_core->settings().interface().collapsibleSeparators()
     && m_sortProxy->sortColumn() == ModList::COL_PRIORITY
     && m_sortProxy->sortOrder() == Qt::AscendingOrder) {
-    m_sortProxy->setSourceModel(m_byPriorityProxy);
+    setProxy(m_core, this, m_sortProxy, m_byPriorityProxy);
   }
   else {
     m_sortProxy->setSourceModel(m_core->modList());
@@ -661,12 +673,21 @@ void ModListView::updateGroupByProxy(int groupIndex)
 
   if (hasCollapsibleSeparators()) {
     ui.filterSeparators->setCurrentIndex(ModListSortProxy::SeparatorFilter);
-    m_byPriorityProxy->refresh();
     ui.filterSeparators->setEnabled(false);
   }
   else {
     ui.filterSeparators->setEnabled(true);
   }
+
+  // reset the source model of the old proxy because we do not want to
+  // react to signals
+  //
+  // also stop notifying the old proxy when items are expanded
+  //
+  if (auto* proxy = qobject_cast<QAbstractProxyModel*>(previousModel)) {
+    proxy->setSourceModel(nullptr);
+    disconnect(this, nullptr, proxy, nullptr);
+  }
 }
 
 void ModListView::setup(OrganizerCore& core, CategoryFactory& factory, MainWindow* mw, Ui::MainWindow* mwui)
@@ -688,22 +709,12 @@ void ModListView::setup(OrganizerCore& core, CategoryFactory& factory, MainWindo
   connect(core.modList(), &ModList::modelReset, [=] { clearOverwriteMarkers(); });
 
   m_byPriorityProxy = new ModListByPriorityProxy(core.currentProfile(), core, this);
-  m_byPriorityProxy->setSourceModel(core.modList());
-  connect(this, &QTreeView::expanded, [=](auto&& name) { m_byPriorityProxy->expanded(name); });
-  connect(this, &QTreeView::collapsed, [=](auto&& name) { m_byPriorityProxy->collapsed(name); });
   connect(m_byPriorityProxy, &ModListByPriorityProxy::expandItem, [=](auto&& index) { expandItem(index); });
-
-  m_byCategoryProxy = new QtGroupingProxy(core.modList(), QModelIndex(), ModList::COL_CATEGORY,
-    ModList::GroupingRole, 0, ModList::AggrRole);
-  connect(this, &QTreeView::expanded, m_byCategoryProxy, &QtGroupingProxy::expanded);
-  connect(this, &QTreeView::collapsed, m_byCategoryProxy, &QtGroupingProxy::collapsed);
-  connect(m_byCategoryProxy, &QtGroupingProxy::expandItem, this, &ModListView::expandItem);
-  m_byNexusIdProxy = new QtGroupingProxy(core.modList(), QModelIndex(), ModList::COL_MODID,
-    ModList::GroupingRole, QtGroupingProxy::FLAG_NOGROUPNAME | QtGroupingProxy::FLAG_NOSINGLE,
-    ModList::AggrRole);
-  connect(this, &QTreeView::expanded, m_byNexusIdProxy, &QtGroupingProxy::expanded);
-  connect(this, &QTreeView::collapsed, m_byNexusIdProxy, &QtGroupingProxy::collapsed);
-  connect(m_byNexusIdProxy, &QtGroupingProxy::expandItem, this, &ModListView::expandItem);
+  m_byCategoryProxy = new QtGroupingProxy(QModelIndex(), ModList::COL_CATEGORY, ModList::GroupingRole, 0, ModList::AggrRole);
+  connect(m_byCategoryProxy, &QtGroupingProxy::expandItem, [=](auto&& index) { expandItem(index); });
+  m_byNexusIdProxy = new QtGroupingProxy(QModelIndex(), ModList::COL_MODID,
+    ModList::GroupingRole, QtGroupingProxy::FLAG_NOGROUPNAME | QtGroupingProxy::FLAG_NOSINGLE, ModList::AggrRole);
+  connect(m_byNexusIdProxy, &QtGroupingProxy::expandItem, [=](auto&& index) { expandItem(index); });
 
   m_sortProxy = new ModListSortProxy(core.currentProfile(), &core);
   setModel(m_sortProxy);
diff --git a/src/qtgroupingproxy.cpp b/src/qtgroupingproxy.cpp
index 2c997fe9..3daa66ba 100644
--- a/src/qtgroupingproxy.cpp
+++ b/src/qtgroupingproxy.cpp
@@ -34,42 +34,50 @@ using namespace MOBase;
     \ingroup model-view
 */
 
-QtGroupingProxy::QtGroupingProxy(QAbstractItemModel *model, QModelIndex rootNode, int groupedColumn, int groupedRole, unsigned int flags , int aggregateRole)
+QtGroupingProxy::QtGroupingProxy(QModelIndex rootNode, int groupedColumn, int groupedRole, unsigned int flags, int aggregateRole)
   : QAbstractProxyModel()
-  , m_rootNode( rootNode )
-  , m_groupedColumn( 0 )
-  , m_groupedRole( groupedRole )
-  , m_aggregateRole( aggregateRole )
-  , m_flags( flags )
+  , m_rootNode(rootNode)
+  , m_groupedColumn(0)
+  , m_groupedRole(groupedRole)
+  , m_aggregateRole(aggregateRole)
+  , m_flags(flags)
 {
-  setSourceModel( model );
-
-  // signal proxies
-  connect( sourceModel(),
-           SIGNAL( dataChanged( const QModelIndex&, const QModelIndex& ) ),
-           this, SLOT( modelDataChanged( const QModelIndex&, const QModelIndex& ) )
-           );
-  connect( sourceModel(), SIGNAL( rowsInserted( const QModelIndex&, int, int ) ),
-           SLOT( modelRowsInserted( const QModelIndex &, int, int ) ) );
-  connect( sourceModel(), SIGNAL(rowsAboutToBeInserted( const QModelIndex &, int ,int )),
-           SLOT(modelRowsAboutToBeInserted( const QModelIndex &, int ,int )));
-  connect( sourceModel(), SIGNAL( rowsRemoved( const QModelIndex&, int, int ) ),
-           SLOT( modelRowsRemoved( const QModelIndex&, int, int ) ) );
-  connect( sourceModel(), SIGNAL(rowsAboutToBeRemoved( const QModelIndex &, int ,int )),
-           SLOT(modelRowsAboutToBeRemoved(QModelIndex,int,int)) );
-  connect( sourceModel(), SIGNAL(layoutChanged()), SLOT(buildTree()) );
-  connect( sourceModel(), SIGNAL(dataChanged(QModelIndex,QModelIndex)),
-           SLOT(modelDataChanged(QModelIndex,QModelIndex)) );
-  connect( sourceModel(), SIGNAL(modelReset()), this, SLOT(resetModel()) );
-
-  if( groupedColumn != -1 )
-    setGroupedColumn( groupedColumn );
+  if (groupedColumn != -1) {
+    setGroupedColumn(groupedColumn);
+  }
 }
 
 QtGroupingProxy::~QtGroupingProxy()
 {
 }
 
+void QtGroupingProxy::setSourceModel(QAbstractItemModel* model)
+{
+  if (sourceModel()) {
+    disconnect(sourceModel(), nullptr, this, nullptr);
+  }
+
+  QAbstractProxyModel::setSourceModel(model);
+
+  if (sourceModel()) {
+    // signal proxies
+    connect(sourceModel(), SIGNAL(rowsInserted(const QModelIndex&, int, int)),
+      SLOT(modelRowsInserted(const QModelIndex&, int, int)));
+    connect(sourceModel(), SIGNAL(rowsAboutToBeInserted(const QModelIndex&, int, int)),
+      SLOT(modelRowsAboutToBeInserted(const QModelIndex&, int, int)));
+    connect(sourceModel(), SIGNAL(rowsRemoved(const QModelIndex&, int, int)),
+      SLOT(modelRowsRemoved(const QModelIndex&, int, int)));
+    connect(sourceModel(), SIGNAL(rowsAboutToBeRemoved(const QModelIndex&, int, int)),
+      SLOT(modelRowsAboutToBeRemoved(QModelIndex, int, int)));
+    connect(sourceModel(), SIGNAL(layoutChanged()), SLOT(buildTree()));
+    connect(sourceModel(), SIGNAL(dataChanged(QModelIndex, QModelIndex)),
+      SLOT(modelDataChanged(QModelIndex, QModelIndex)));
+    connect(sourceModel(), SIGNAL(modelReset()), this, SLOT(resetModel()));
+
+    buildTree();
+  }
+}
+
 void
 QtGroupingProxy::setGroupedColumn( int groupedColumn )
 {
@@ -205,9 +213,15 @@ QtGroupingProxy::buildTree()
   }
 
   endResetModel();
+
   // restore expand-state
-  for( int row = 0; row < rowCount(); row++ ) {
-    QModelIndex idx = index( row, 0, QModelIndex() );
+  refreshExpandedItems();
+}
+
+void QtGroupingProxy::refreshExpandedItems() const
+{
+  for (int row = 0; row < rowCount(); row++) {
+    QModelIndex idx = index(row, 0, QModelIndex());
     if (m_expandedItems.contains(idx.data(Qt::UserRole).toString())) {
       emit expandItem(idx);
     }
diff --git a/src/qtgroupingproxy.h b/src/qtgroupingproxy.h
index 6567cb0e..131f33dc 100644
--- a/src/qtgroupingproxy.h
+++ b/src/qtgroupingproxy.h
@@ -47,12 +47,13 @@ public:
   };
 
 public:
-  explicit QtGroupingProxy( QAbstractItemModel *model, QModelIndex rootNode = QModelIndex(),
+  explicit QtGroupingProxy( QModelIndex rootNode = QModelIndex(),
                             int groupedColumn = -1, int groupedRole = Qt::DisplayRole,
                             unsigned int flags = 0,
                             int aggregateRole = Qt::DisplayRole);
   ~QtGroupingProxy();
 
+  void setSourceModel(QAbstractItemModel* model) override;
   void setGroupedColumn( int groupedColumn );
 
   /* QAbstractProxyModel methods */
@@ -79,10 +80,10 @@ public:
   virtual QModelIndex addEmptyGroup( const RowData &data );
   virtual bool removeGroup( const QModelIndex &idx );
 
-  QStringList expandedState();
+  void refreshExpandedItems() const ;
 
 signals:
-  void expandItem(const QModelIndex &index);
+  void expandItem(const QModelIndex &index) const;
 
 public slots:
   /**
-- 
cgit v1.3.1


From b242394c0f9c24ca8f9bbced44076abbcd274fee Mon Sep 17 00:00:00 2001
From: Mikaël Capelle <capelle.mikael@gmail.com>
Date: Mon, 4 Jan 2021 19:37:20 +0100
Subject: Keep track of expanded items in the view instead of the models.

---
 src/modlistbypriorityproxy.cpp | 32 ---------------------
 src/modlistbypriorityproxy.h   | 13 +--------
 src/modlistview.cpp            | 63 +++++++++++++++++++++---------------------
 src/modlistview.h              | 11 ++++++--
 src/qtgroupingproxy.cpp        | 24 ----------------
 src/qtgroupingproxy.h          | 17 ------------
 6 files changed, 40 insertions(+), 120 deletions(-)

(limited to 'src/modlistbypriorityproxy.cpp')

diff --git a/src/modlistbypriorityproxy.cpp b/src/modlistbypriorityproxy.cpp
index bf3c2d09..6f549d91 100644
--- a/src/modlistbypriorityproxy.cpp
+++ b/src/modlistbypriorityproxy.cpp
@@ -88,20 +88,6 @@ void ModListByPriorityProxy::buildTree()
   m_Root.children.push_back(std::move(overwrite));
 
   endResetModel();
-
-  // restore expand-state
-  expandItems(QModelIndex());
-}
-
-void ModListByPriorityProxy::expandItems(const QModelIndex& index) const
-{
-  for (int row = 0; row < rowCount(index); row++) {
-    QModelIndex idx = this->index(row, 0, index);
-    if (!m_CollapsedItems.contains(idx.data(Qt::DisplayRole).toString())) {
-      emit expandItem(idx);
-    }
-    expandItems(idx);
-  }
 }
 
 void ModListByPriorityProxy::modelDataChanged(const QModelIndex& topLeft, const QModelIndex& bottomRight, const QVector<int>& roles)
@@ -334,21 +320,3 @@ void ModListByPriorityProxy::onDropEnter(const QMimeData*, ModListView::DropPosi
 {
   m_dropPosition = dropPosition;
 }
-
-void ModListByPriorityProxy::refreshExpandedItems() const
-{
-  expandItems(QModelIndex());
-}
-
-void ModListByPriorityProxy::expanded(const QModelIndex& index)
-{
-  auto it = m_CollapsedItems.find(index.data(Qt::DisplayRole).toString());
-  if (it != m_CollapsedItems.end()) {
-    m_CollapsedItems.erase(it);
-  }
-}
-
-void ModListByPriorityProxy::collapsed(const QModelIndex& index)
-{
-  m_CollapsedItems.insert(index.data(Qt::DisplayRole).toString());
-}
diff --git a/src/modlistbypriorityproxy.h b/src/modlistbypriorityproxy.h
index e5a8adff..6b48678a 100644
--- a/src/modlistbypriorityproxy.h
+++ b/src/modlistbypriorityproxy.h
@@ -44,28 +44,17 @@ public:
   QModelIndex mapFromSource(const QModelIndex& sourceIndex) const override;
   QModelIndex mapToSource(const QModelIndex& proxyIndex) const override;
 
-  // check the internal state for expanded/collapse items and emit a expandItem
-  // signal for each of the expanded item, useful to refresh the tree state after
-  // layout modification
-  void refreshExpandedItems() const;
-
-signals:
-  void expandItem(const QModelIndex& index) const;
-
 public slots:
 
   void onDropEnter(const QMimeData* data, ModListView::DropPosition dropPosition);
-  void expanded(const QModelIndex& index);
-  void collapsed(const QModelIndex& index);
 
-protected:
+protected slots:
 
   void modelDataChanged(const QModelIndex& topLeft, const QModelIndex& bottomRight, const QVector<int>& roles = QVector<int>());
 
 private:
 
   void buildTree();
-  void expandItems(const QModelIndex& index) const;
 
   struct TreeItem {
     ModInfo::Ptr mod;
diff --git a/src/modlistview.cpp b/src/modlistview.cpp
index 6399e910..67dc1c02 100644
--- a/src/modlistview.cpp
+++ b/src/modlistview.cpp
@@ -360,15 +360,14 @@ void ModListView::setSelected(const QModelIndex& current, const QModelIndexList&
   }
 }
 
-void ModListView::expandItem(const QModelIndex& index)
+void ModListView::refreshExpandedItems()
 {
-  // the group proxy (QtGroupingProxy and ModListByPriorityProxy) emit
-  // those with their own index, so we need to do this manually
-  if (index.model() == m_sortProxy->sourceModel()) {
-    setExpanded(m_sortProxy->mapFromSource(index), true);
-  }
-  else if (index.model() == model()) {
-    setExpanded(index, true);
+  auto* model = m_sortProxy->sourceModel();
+  for (auto i = 0; i < model->rowCount(); ++i) {
+    auto idx = model->index(i, 0);
+    if (!m_collapsed[model].contains(idx.data(Qt::DisplayRole).toString())) {
+      setExpanded(m_sortProxy->mapFromSource(idx), true);
+    }
   }
 }
 
@@ -631,18 +630,6 @@ bool ModListView::toggleSelectionState()
   return m_core->modList()->toggleState(indexViewToModel(selectionModel()->selectedRows()));
 }
 
-// helper function because QtGroupingProxy and ModListByPriorityProxy
-// have similar methods but do not share a common parent class
-template <class Proxy>
-void setProxy(OrganizerCore* core, QTreeView* view, ModListSortProxy* sortProxy, Proxy* proxy)
-{
-  proxy->setSourceModel(core->modList());
-  sortProxy->setSourceModel(proxy);
-  QObject::connect(view, &QTreeView::expanded, proxy, &Proxy::expanded);
-  QObject::connect(view, &QTreeView::collapsed, proxy, &Proxy::collapsed);
-  proxy->refreshExpandedItems();
-}
-
 void ModListView::updateGroupByProxy(int groupIndex)
 {
   // if the index is -1, we do not refresh unless we are grouping
@@ -655,21 +642,29 @@ void ModListView::updateGroupByProxy(int groupIndex)
   }
 
   auto* previousModel = m_sortProxy->sourceModel();
+  QAbstractProxyModel* nextProxy = nullptr;
 
   if (groupIndex == GroupBy::CATEGORY) {
-    setProxy(m_core, this, m_sortProxy, m_byCategoryProxy);
+    nextProxy = m_byCategoryProxy;
   }
   else if (groupIndex == GroupBy::NEXUS_ID) {
-    setProxy(m_core, this, m_sortProxy, m_byNexusIdProxy);
+    nextProxy = m_byNexusIdProxy;
   }
   else if (m_core->settings().interface().collapsibleSeparators()
     && m_sortProxy->sortColumn() == ModList::COL_PRIORITY
     && m_sortProxy->sortOrder() == Qt::AscendingOrder) {
-    setProxy(m_core, this, m_sortProxy, m_byPriorityProxy);
+    nextProxy = m_byPriorityProxy;
   }
-  else {
-    m_sortProxy->setSourceModel(m_core->modList());
+
+  QAbstractItemModel* nextModel = m_core->modList();
+  if (nextProxy) {
+    nextProxy->setSourceModel(m_core->modList());
+    nextModel = nextProxy;
   }
+  m_sortProxy->setSourceModel(nextModel);
+
+  // expand items previously expanded
+  refreshExpandedItems();
 
   if (hasCollapsibleSeparators()) {
     ui.filterSeparators->setCurrentIndex(ModListSortProxy::SeparatorFilter);
@@ -682,11 +677,8 @@ void ModListView::updateGroupByProxy(int groupIndex)
   // reset the source model of the old proxy because we do not want to
   // react to signals
   //
-  // also stop notifying the old proxy when items are expanded
-  //
   if (auto* proxy = qobject_cast<QAbstractProxyModel*>(previousModel)) {
     proxy->setSourceModel(nullptr);
-    disconnect(this, nullptr, proxy, nullptr);
   }
 }
 
@@ -709,12 +701,19 @@ void ModListView::setup(OrganizerCore& core, CategoryFactory& factory, MainWindo
   connect(core.modList(), &ModList::modelReset, [=] { clearOverwriteMarkers(); });
 
   m_byPriorityProxy = new ModListByPriorityProxy(core.currentProfile(), core, this);
-  connect(m_byPriorityProxy, &ModListByPriorityProxy::expandItem, [=](auto&& index) { expandItem(index); });
   m_byCategoryProxy = new QtGroupingProxy(QModelIndex(), ModList::COL_CATEGORY, ModList::GroupingRole, 0, ModList::AggrRole);
-  connect(m_byCategoryProxy, &QtGroupingProxy::expandItem, [=](auto&& index) { expandItem(index); });
   m_byNexusIdProxy = new QtGroupingProxy(QModelIndex(), ModList::COL_MODID,
     ModList::GroupingRole, QtGroupingProxy::FLAG_NOGROUPNAME | QtGroupingProxy::FLAG_NOSINGLE, ModList::AggrRole);
-  connect(m_byNexusIdProxy, &QtGroupingProxy::expandItem, [=](auto&& index) { expandItem(index); });
+
+  QObject::connect(this, &QTreeView::expanded, [=](const QModelIndex& index) {
+    auto it = m_collapsed[m_sortProxy->sourceModel()].find(index.data(Qt::DisplayRole).toString());
+    if (it != m_collapsed[m_sortProxy->sourceModel()].end()) {
+      m_collapsed[m_sortProxy->sourceModel()].erase(it);
+    }
+  });
+  QObject::connect(this, &QTreeView::collapsed, [=](const QModelIndex& index) {
+    m_collapsed[m_sortProxy->sourceModel()].insert(index.data(Qt::DisplayRole).toString());
+  });
 
   m_sortProxy = new ModListSortProxy(core.currentProfile(), &core);
   setModel(m_sortProxy);
@@ -810,7 +809,7 @@ void ModListView::setup(OrganizerCore& core, CategoryFactory& factory, MainWindo
     });
   connect(m_sortProxy, &ModListSortProxy::filterInvalidated, [=]() {
     if (hasCollapsibleSeparators()) {
-      m_byPriorityProxy->refreshExpandedItems();
+      refreshExpandedItems();
     }
   });
 }
diff --git a/src/modlistview.h b/src/modlistview.h
index faa33b6a..ed4ad2d0 100644
--- a/src/modlistview.h
+++ b/src/modlistview.h
@@ -1,6 +1,8 @@
 #ifndef MODLISTVIEW_H
 #define MODLISTVIEW_H
 
+#include <map>
+#include <set>
 #include <vector>
 
 #include <QLabel>
@@ -203,10 +205,9 @@ private:
   std::pair<QModelIndex, QModelIndexList> selected() const;
   void setSelected(const QModelIndex& current, const QModelIndexList& selected);
 
-  // call expand() after fixing the index if it comes from the source
-  // of the proxy
+  // refresh stored expanded items for the current intermediate proxy
   //
-  void expandItem(const QModelIndex& index);
+  void refreshExpandedItems();
 
   // refresh the group-by proxy, if the index is -1 will refresh the
   // current one (e.g. when changing the sort column)
@@ -249,6 +250,10 @@ private:
   QtGroupingProxy* m_byCategoryProxy;
   QtGroupingProxy* m_byNexusIdProxy;
 
+  // maintain collapsed items for each proxy to avoid
+  // losing them on model reset
+  std::map<QAbstractItemModel*, std::set<QString>> m_collapsed;
+
   struct MarkerInfos {
     // conflicts
     std::set<unsigned int> overwrite;
diff --git a/src/qtgroupingproxy.cpp b/src/qtgroupingproxy.cpp
index 3daa66ba..a8c7ce1d 100644
--- a/src/qtgroupingproxy.cpp
+++ b/src/qtgroupingproxy.cpp
@@ -213,19 +213,6 @@ QtGroupingProxy::buildTree()
   }
 
   endResetModel();
-
-  // restore expand-state
-  refreshExpandedItems();
-}
-
-void QtGroupingProxy::refreshExpandedItems() const
-{
-  for (int row = 0; row < rowCount(); row++) {
-    QModelIndex idx = index(row, 0, QModelIndex());
-    if (m_expandedItems.contains(idx.data(Qt::UserRole).toString())) {
-      emit expandItem(idx);
-    }
-  }
 }
 
 QList<int>
@@ -1049,14 +1036,3 @@ QtGroupingProxy::dumpGroups() const
 
   log::debug("{}", s);
 }
-
-
-void QtGroupingProxy::expanded(const QModelIndex &index)
-{
-  m_expandedItems.insert(index.data(Qt::UserRole).toString());
-}
-
-void QtGroupingProxy::collapsed(const QModelIndex &index)
-{
-  m_expandedItems.remove(index.data(Qt::UserRole).toString());
-}
diff --git a/src/qtgroupingproxy.h b/src/qtgroupingproxy.h
index 131f33dc..c4459297 100644
--- a/src/qtgroupingproxy.h
+++ b/src/qtgroupingproxy.h
@@ -80,22 +80,6 @@ public:
   virtual QModelIndex addEmptyGroup( const RowData &data );
   virtual bool removeGroup( const QModelIndex &idx );
 
-  void refreshExpandedItems() const ;
-
-signals:
-  void expandItem(const QModelIndex &index) const;
-
-public slots:
-  /**
-   * @brief update expanded state
-   * @param index index of the expanded/collapsed item (from the base model!)
-   */
-  void expanded(const QModelIndex &index);
-  /**
-   * @brief update expanded state
-   * @param index index of the expanded/collapsed item (from the base model!)
-   */
-  void collapsed(const QModelIndex &index);
 protected slots:
   virtual void buildTree();
 
@@ -159,7 +143,6 @@ protected:
   void dumpGroups() const;
 
 private:
-  QSet<QString> m_expandedItems;
   unsigned int m_flags;
   int m_groupedRole;
 
-- 
cgit v1.3.1