- bugfix: endless loop in detection of mod order problems

- mod list will now be highlighted when grouping is active is active
- download tooltip now supports bbcode markup in the description
- bbcode translator will now translate some named colors
- algorithm for detection of mod order problems is now more sophisticated
- exposed more functionality to python plugins
- updated to qt 4.8.6 dlls
- bugfix: plugin list wasn't
- bugfix: state changes in mod list wasn't always reported
- bugfix: loot client will now create necessary directory
- bugfix: NCC sometimes used wrong source path for extracting
- bugfix: removed noisy debug message

src/diagnoseBasic.pro

@@ -4,24 +4,29 @@
 #
 #-------------------------------------------------
 
-QT       -= gui
-
 TARGET = diagnoseBasic
 TEMPLATE = lib
 
 CONFIG += plugins
 CONFIG += dll
 
+contains(QT_VERSION, "^5.*") {
+	QT += widgets
+}
+
 DEFINES += DIAGNOSEBASIC_LIBRARY
 DEFINES += NOMINMAX
 
+# suppress a few warnings caused by boost vs vc++ paranoia
+DEFINES += _SCL_SECURE_NO_WARNINGS
+
 SOURCES += diagnosebasic.cpp
 
 HEADERS += diagnosebasic.h
 
 include(../plugin_template.pri)
 
-INCLUDEPATH +=  "$(BOOSTPATH)"
+INCLUDEPATH += "$(BOOSTPATH)"
 
 #CONFIG += dll
 

src/diagnosebasic.cpp

@@ -1,3 +1,22 @@
+/*
+ * Copyright (C) 2013 Sebastian Herbord. All rights reserved.
+ *
+ * This file is part of the basic diagnosis plugin for Mod Organizer
+ *
+ * This plugin is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This plugin is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this plugin.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
 #include "diagnosebasic.h"
 #include <report.h>
 #include <utility.h>
@@ -5,8 +24,20 @@
 #include <QFile>
 #include <QDir>
 #include <QCoreApplication>
+#include <QMessageBox>
+#include <QDateTime>
 #include <regex>
+#include <functional>
+#include <vector>
+#include <algorithm>
+
+#pragma warning( push, 2 )
 #include <boost/assign.hpp>
+#include <boost/graph/graph_traits.hpp>
+#include <boost/graph/adjacency_list.hpp>
+#include <boost/graph/topological_sort.hpp>
+#include <boost/graph/connected_components.hpp>
+#pragma warning( pop )
 
 
 using namespace MOBase;
@@ -19,6 +50,12 @@ DiagnoseBasic::DiagnoseBasic()
 bool DiagnoseBasic::init(IOrganizer *moInfo)
 {
   m_MOInfo = moInfo;
+
+  m_MOInfo->modList()->onModStateChanged([&] (const QString &modName, IModList::ModStates) {
+                                           if (modName == "Overwrite") invalidate();
+                                         });
+  m_MOInfo->pluginList()->onRefreshed([&] () { this->invalidate(); });
+
   return true;
 }
 
@@ -39,7 +76,7 @@ QString DiagnoseBasic::description() const
 
 VersionInfo DiagnoseBasic::version() const
 {
-  return VersionInfo(1, 0, 0, VersionInfo::RELEASE_FINAL);
+  return VersionInfo(1, 1, 0, VersionInfo::RELEASE_FINAL);
 }
 
 bool DiagnoseBasic::isActive() const
@@ -105,15 +142,222 @@ bool DiagnoseBasic::errorReported() const
 bool DiagnoseBasic::overwriteFiles() const
 {
   QDir dir(QCoreApplication::applicationDirPath() + "/overwrite");
+
   return dir.count() != 2; // account for . and ..
 }
 
 bool DiagnoseBasic::nitpickInstalled() const
 {
   QString path = m_MOInfo->resolvePath("skse/plugins/nitpick.dll");
+
   return !path.isEmpty();
 }
 
+
+/// unused code to remove duplicates from a vector
+template<typename T>
+void makeUnique(std::vector<T> &vector)
+{
+  std::set<T> done;
+
+  auto read = vector.begin();
+  auto write = vector.begin();
+
+  for (; read != vector.end(); ++read) {
+    if (done.insert(*read).second) {
+      *write = *read;
+      ++write;
+    }
+  }
+
+  vector.erase(write, vector.end());
+}
+
+bool operator<(const DiagnoseBasic::Move &lhs, const DiagnoseBasic::Move &rhs)
+{
+  if (lhs.item.modName != rhs.item.modName) return lhs.item.modName < rhs.item.modName;
+  else return lhs.reference.modName < rhs.reference.modName;
+}
+
+
+void DiagnoseBasic::topoSort(std::vector<DiagnoseBasic::ListElement> &list) const
+{
+  typedef std::pair<int, int> Edge;
+  std::vector<Edge> before;
+
+  // create a graph with edges where each edge tells us that mod a has to come before mod b
+  // this takes into account only pairs of mods that actually have conflicting scripts
+  for (unsigned i = 0; i < list.size(); ++i) {
+    for (unsigned j = i + 1; j < list.size(); ++j) {
+      if (!(list[i].relevantScripts & list[j].relevantScripts).empty()) {
+        before.push_back(Edge(i, j));
+      }
+    }
+  }
+
+  {
+    typedef boost::adjacency_list<boost::vecS,boost::vecS, boost::bidirectionalS, boost::property<boost::vertex_color_t, boost::default_color_type>> Graph;
+    using namespace boost;
+    Graph graph(before.begin(), before.end(), list.size());
+    typedef graph_traits<Graph>::vertex_descriptor Vertex;
+    typedef std::list<Vertex> Order;
+
+    // figure out unconnected components of the graph.
+    std::vector<int> component(num_vertices(graph));
+    connected_components(graph, &component[0]);
+
+    for (int i = 0; i != component.size(); ++i) {
+      list[i].sortGroup = component[i];
+    }
+
+    Order order;
+    // do the actual sorting. This sorts the graph in full though the order between unconnected components doesn't
+    // really matter to us
+    boost::topological_sort(graph, std::front_inserter(order));
+  }
+}
+
+
+void DiagnoseBasic::Sorter::sortGroup(std::vector<ListElement> modList)
+{
+  std::vector<ListElement> sorted;
+  {
+    auto maxSeqBegin = modList.end();
+    auto maxSeqEnd = modList.end();
+
+    // first, determine the longest sequence of correctly sorted mods
+    auto curSeqBegin = modList.begin();
+    auto curSeqEnd = modList.begin();
+
+    auto iter = modList.begin() + 1;
+    for (; iter != modList.end(); ++iter) {
+      if (iter->modPriority < curSeqEnd->modPriority) {
+        // sequence ends
+        if ((maxSeqBegin == modList.end()) || ((curSeqEnd - curSeqBegin) > (maxSeqEnd - maxSeqBegin))) {
+          maxSeqBegin = curSeqBegin;
+          maxSeqEnd = iter;
+        }
+        curSeqBegin = curSeqEnd = iter;
+      } else {
+        curSeqEnd = iter;
+      }
+    }
+
+    if ((maxSeqBegin == modList.end()) || ((curSeqEnd - curSeqBegin) > (maxSeqEnd - maxSeqBegin))) {
+      maxSeqBegin = curSeqBegin;
+      maxSeqEnd = modList.end();
+    }
+    sorted = std::vector<ListElement>(maxSeqBegin, maxSeqEnd);
+    modList.erase(maxSeqBegin, maxSeqEnd);
+  }
+
+  // now move the elements NOT in this sequence to the correct location within
+  while (modList.begin() != modList.end()) {
+    auto iter = modList.begin();
+    bool found = false;
+    auto targetIter = sorted.begin();
+    for (; targetIter != sorted.end(); ++targetIter) {
+      if (targetIter->pluginPriority > iter->pluginPriority) {
+        moves.push_back(Move(*iter, *targetIter, Move::BEFORE));
+        found = true;
+        break;
+      }
+    }
+    if (!found) {
+      // add to end!
+      moves.push_back(Move(*iter, *sorted.rbegin(), Move::AFTER));
+    }
+    sorted.insert(targetIter, *iter);
+    modList.erase(iter);
+  }
+}
+
+void DiagnoseBasic::Sorter::operator()(std::vector<ListElement> modList)
+{
+  if (modList.size() == 0) {
+    return;
+  }
+
+  int currentGroup = 0;
+  while (true) {
+    std::vector<ListElement> filtered;
+    std::copy_if(modList.begin(), modList.end(), std::back_inserter(filtered),
+                 [currentGroup] (const ListElement &ele) -> bool { return ele.sortGroup == currentGroup; });
+    ++currentGroup;
+    if (filtered.size() == 0) {
+      break;
+    } else if (filtered.size() == 1) {
+      // skip if there is only one element, there can't be a necessary move
+      continue;
+    }
+    sortGroup(filtered);
+  }
+}
+
+bool DiagnoseBasic::assetOrder() const
+{
+  Sorter minSorter;
+
+  std::vector<ListElement> modList;
+
+  // list of mods containing conflicted scripts. We care only for those
+  std::map<QString, QSet<QString>> scriptMods;
+  foreach (const IOrganizer::FileInfo & pex, m_MOInfo->findFileInfos("scripts",
+        [] (const IOrganizer::FileInfo &file) -> bool { return file.filePath.endsWith(".pex", Qt::CaseInsensitive); })) {
+    QStringList origins = pex.origins;
+    origins.removeAll("data"); // ignore files in base directory
+    if (origins.size() > 1) {
+      foreach(const QString &origin, origins) {
+        scriptMods[origin].insert(pex.filePath);
+      }
+    }
+  }
+
+  // produce a list with the information we need: plugin, mod and the priority for each
+  QStringList esps = m_MOInfo->findFiles("", [] (const QString &fileName) -> bool { return fileName.endsWith(".esp", Qt::CaseInsensitive); });
+  foreach (const QString &esp, esps) {
+    ListElement ele;
+
+    ele.espName = QFileInfo(esp).fileName();
+    ele.modName = m_MOInfo->pluginList()->origin(ele.espName);
+    ele.pluginPriority = m_MOInfo->pluginList()->priority(ele.espName);
+    ele.modPriority = m_MOInfo->modList()->priority(ele.modName);
+    IModList::ModStates state = m_MOInfo->modList()->state(ele.modName);
+    auto iter = scriptMods.find(ele.modName);
+    if (state.testFlag(IModList::STATE_EXISTS) && !state.testFlag(IModList::STATE_ESSENTIAL) &&
+        (iter != scriptMods.end())) {
+      ele.relevantScripts = iter->second;
+      modList.push_back(ele);
+    }
+  }
+
+  // generate a copy of list that contains each mod only once, otherwise
+  // strange things happen if a mod contains multiple esps that are mixed
+  // with esps from other mods
+  std::vector<ListElement> distinctModList;
+  {
+    std::set<QString> includedMods;
+    foreach(const ListElement &ele, modList) {
+      if (includedMods.find(ele.modName) == includedMods.end()) {
+        distinctModList.push_back(ele);
+        includedMods.insert(ele.modName);
+      }
+    }
+  }
+
+  // sort the list by plugin priority
+  std::sort(distinctModList.begin(), distinctModList.end(),
+            [] (const ListElement &lhs, const ListElement &rhs) -> bool { return lhs.pluginPriority < rhs.pluginPriority; });
+
+  topoSort(distinctModList);
+
+  // now determine the moves necessary to bring the mod list into this order
+  minSorter(distinctModList);
+  m_SuggestedMoves = minSorter.moves;
+
+  return m_SuggestedMoves.size() > 0;
+}
+
 bool DiagnoseBasic::invalidFontConfig() const
 {
   if (m_MOInfo->gameInfo().type() != IGameInfo::TYPE_SKYRIM) {
@@ -123,7 +367,7 @@ bool DiagnoseBasic::invalidFontConfig() const
 
   // files from skyrim_interface.bsa
   static std::vector<QString> defaultFonts = boost::assign::list_of("interface\\fonts_console.swf")
-                                                                   ("interface\\fonts_en.swf");
+                                               ("interface\\fonts_en.swf");
 
   QString configPath = m_MOInfo->resolvePath("interface/fontconfig.txt");
   if (configPath.isEmpty()) {
@@ -143,7 +387,7 @@ bool DiagnoseBasic::invalidFontConfig() const
       std::string temp = match[1];
       QString path(temp.c_str());
       bool isDefault = false;
-      foreach (const QString &def, defaultFonts) {
+      foreach(const QString &def, defaultFonts) {
         if (QString::compare(def, path, Qt::CaseInsensitive) == 0) {
           isDefault = true;
           break;
@@ -175,6 +419,18 @@ std::vector<unsigned int> DiagnoseBasic::activeProblems() const
   if (nitpickInstalled()) {
     result.push_back(PROBLEM_NITPICKINSTALLED);
   }
+  if (assetOrder()) {
+    result.push_back(PROBLEM_ASSETORDER);
+  }
+  QStringList backups = QDir(m_MOInfo->profilePath()).entryList(QStringList() << "modlist.txt_backup_*");
+  if (backups.size() > 0) {
+    m_NewestModlistBackup = backups.last();
+    result.push_back(PROBLEM_MODLISTBACKUP);
+  }
+
+  if (QFile::exists(m_MOInfo->profilePath() + "/profile_tweaks.ini")) {
+    result.push_back(PROBLEM_PROFILETWEAKS);
+  }
 
   return result;
 }
@@ -190,6 +446,12 @@ QString DiagnoseBasic::shortDescription(unsigned int key) const
       return tr("Your font configuration may be broken");
     case PROBLEM_NITPICKINSTALLED:
       return tr("Nitpick installed");
+    case PROBLEM_ASSETORDER:
+      return tr("Potential Mod order problem");
+    case PROBLEM_MODLISTBACKUP:
+      return tr("Modlist backup exists");
+    case PROBLEM_PROFILETWEAKS:
+      return tr("Ini Tweaks overwritten");
     default:
       throw MyException(tr("invalid problem key %1").arg(key));
   }
@@ -214,21 +476,95 @@ QString DiagnoseBasic::fullDescription(unsigned int key) const
     case PROBLEM_NITPICKINSTALLED:
       return tr("You have the nitpick skse plugin installed. This plugin is not needed with Mod Organizer because MO already offers the same functionality. "
                 "Worse: The two solutions may conflict so it's strongly suggested you remove this plugin.");
+    case PROBLEM_ASSETORDER: {
+      QString res = tr("The conflict resolution order for some mods containing scripts differs from that of the corresponding esp.<br>"
+                       "This may lead to subtle, hard to locate bugs. You should re-order the affected mods (left list!).<br>"
+                       "There is no way to reliably know if these changes are necessary but its definitively safer.<br>"
+                       "If someone suggested you ignore this message, please give them a proper slapping from me. <b>Do not ignore this warning</b><br>"
+                       "The following changes should fix the issue:") + "<ul>";
+      foreach(const Move &op, m_SuggestedMoves) {
+        if (op.type == Move::BEFORE) {
+          res += "<li>" + tr("Move %1 before %2").arg(op.item.modName).arg(op.reference.modName) + "</li>";
+        } else {
+          res += "<li>" + tr("Move %1 after %2").arg(op.item.modName).arg(op.reference.modName) + "</li>";
+        }
+      }
+      res += "</ul>";
+      return res;
+    } break;
+    case PROBLEM_MODLISTBACKUP: {
+      uint timestamp = m_NewestModlistBackup.right(10).toULong();
+      QDateTime time;
+      time.setTime_t(timestamp);
+      return tr("A previous operation created a backup of your mod list on %1.<br>"
+                "This backup contains both the info which mods are enabled and the ordering.<br>"
+                "You can restore that backup here.").arg(time.toString());
+    } break;
+    case PROBLEM_PROFILETWEAKS: {
+      QString fileContent = readFileText(m_MOInfo->profilePath() + "/profile_tweaks.ini");
+      return tr("Settings provided in ini tweaks have been overwritten in-game or in an applications.<br>"
+                "These overwrites are stored in a separate file (<i>profile_tweaks.ini</i> within the profile directory)<br>"
+                "to keep ini-tweaks in their original state but you should really get rid of this file as there is<br>"
+                "no tool support in MO to work on it. <br>"
+                "Advice: Copy settings you want to keep to an appropriate ini tweak, then delete <i>profile_tweaks.ini</i>.<br>"
+                "Hitting the <i>Fix</i> button will delete that file")
+             + "<hr><i>profile_tweaks.ini:</i><pre>" + fileContent + "</pre>";
+    } break;
     default:
       throw MyException(tr("invalid problem key %1").arg(key));
   }
 }
 
-bool DiagnoseBasic::hasGuidedFix(unsigned int) const
+bool DiagnoseBasic::hasGuidedFix(unsigned int key) const
 {
-  return false;
+  return /*(key == PROBLEM_ASSETORDER) || */ (key == PROBLEM_MODLISTBACKUP) || (key == PROBLEM_PROFILETWEAKS);
 }
 
 void DiagnoseBasic::startGuidedFix(unsigned int key) const
 {
-  throw MyException(tr("invalid problem key %1").arg(key));
+  switch (key) {
+/*    case PROBLEM_ASSETORDER: {
+ *    if (QMessageBox::warning(NULL, tr("Continue?"), tr("This <b>BETA</b> feature will rearrange your mods to eliminate all "
+ *            "possible ordering conflicts. A backup of your mod list will be created. Proceed?"), QMessageBox::Yes | QMessageBox::No) == QMessageBox::Yes) {
+ *      shellCopy(QStringList(m_MOInfo->profilePath() + "/modlist.txt"),
+ *                QStringList(m_MOInfo->profilePath() + "/modlist.txt_backup_" + QString("%1").arg(QDateTime::currentDateTime().toTime_t())));
+ *      foreach (const Move &op, m_SuggestedMoves) {
+ *        int oldPriority = m_MOInfo->modList()->priority(op.item.modName);
+ *        int targetPriority = -1;
+ *        if (op.type == Move::BEFORE) {
+ *          targetPriority = m_MOInfo->modList()->priority(op.reference.modName);
+ *        } else {
+ *          targetPriority = m_MOInfo->modList()->priority(op.reference.modName) + 1;
+ *        }
+ *        if (oldPriority < targetPriority) {
+ *          --targetPriority;
+ *        }
+ *        m_MOInfo->modList()->setPriority(op.item.modName, targetPriority);
+ *      }
+ *    }
+ *  } break;*/
+    case PROBLEM_MODLISTBACKUP: {
+      QMessageBox question(QMessageBox::Question, tr("Restore backup?"),
+                           tr("Do you want to restore this backup or delete it?"),
+                           QMessageBox::Yes | QMessageBox::No | QMessageBox::Cancel);
+      question.setButtonText(QMessageBox::Yes, tr("Restore"));
+      question.setButtonText(QMessageBox::No, tr("Delete"));
+
+      question.exec();
+      if (question.result() == QMessageBox::Yes) {
+        shellMove(QStringList(m_MOInfo->profilePath() + "/" + m_NewestModlistBackup), QStringList(m_MOInfo->profilePath() + "/modlist.txt"));
+        m_MOInfo->refreshModList(false);
+      } else if (question.result() == QMessageBox::No) {
+        shellDelete(QStringList(m_MOInfo->profilePath() + "/" + m_NewestModlistBackup));
+      }
+    } break;
+    case PROBLEM_PROFILETWEAKS: {
+      shellDeleteQuiet(m_MOInfo->profilePath() + "/profile_tweaks.ini");
+    } break;
+    default: throw MyException(tr("invalid problem key %1").arg(key));
+  }
 }
 
-#if QT_VERSION < QT_VERSION_CHECK(5,0,0)
+#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
 Q_EXPORT_PLUGIN2(diagnosebasic, DiagnoseBasic)
 #endif

src/diagnosebasic.h

@@ -1,3 +1,22 @@
+/*
+Copyright (C) 2013 Sebastian Herbord. All rights reserved.
+
+This file is part of basic diagnosis plugin for MO
+
+This plugin is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This plugin is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this plugin.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
 #ifndef DIAGNOSEBASIC_H
 #define DIAGNOSEBASIC_H
 
@@ -5,6 +24,9 @@
 #include <iplugin.h>
 #include <iplugindiagnose.h>
 #include <imoinfo.h>
+#include <imodlist.h>
+#include <QString>
+#include <QSet>
 
 
 class DiagnoseBasic : public QObject, MOBase::IPlugin, MOBase::IPluginDiagnose
@@ -43,6 +65,7 @@ private:
   bool overwriteFiles() const;
   bool invalidFontConfig() const;
   bool nitpickInstalled() const;
+  bool assetOrder() const;
 
 private:
 
@@ -50,13 +73,63 @@ private:
   static const unsigned int PROBLEM_OVERWRITE = 2;
   static const unsigned int PROBLEM_INVALIDFONT = 3;
   static const unsigned int PROBLEM_NITPICKINSTALLED = 4;
+  static const unsigned int PROBLEM_ASSETORDER = 5;
+  static const unsigned int PROBLEM_MODLISTBACKUP = 6;
+  static const unsigned int PROBLEM_PROFILETWEAKS = 7;
 
   static const unsigned int NUM_CONTEXT_ROWS = 5;
 
 private:
 
-  const MOBase::IOrganizer *m_MOInfo;
+  struct ListElement {
+    QString espName;
+    QString modName;
+    int pluginPriority;
+    int modPriority;
+    int sortPriority;
+    int sortGroup;
+    QSet<QString> relevantScripts;
+  };
+
+  struct Move {
+    ListElement item;
+    ListElement reference;
+    enum EType {
+      BEFORE,
+      AFTER
+    } type;
+    Move(const ListElement &initItem, const ListElement &initReference, EType initType)
+      : item(initItem), reference(initReference), type(initType) {}
+  };
+
+  struct Sorter {
+    struct {
+      int operator()(const ListElement &lhs, const ListElement &rhs)
+      {
+        return lhs.modPriority < rhs.modPriority;
+      }
+    } minMod;
+
+    std::vector<Move> moves;
+
+    void operator()(std::vector<ListElement> modList);
+  private:
+    void sortGroup(std::vector<ListElement> modList);
+  };
+
+
+  friend bool operator<(const Move &lhs, const Move &rhs);
+
+private:
+
+  void topoSort(std::vector<ListElement> &list) const;
+
+private:
+
+  MOBase::IOrganizer *m_MOInfo;
   mutable QString m_ErrorMessage;
+  mutable std::vector <Move> m_SuggestedMoves;
+  mutable QString m_NewestModlistBackup;
 
 };