From 93318a1474031035da5e61ad199171cad5803c2f Mon Sep 17 00:00:00 2001
From: isanae <14251494+isanae@users.noreply.github.com>
Date: Fri, 29 Nov 2019 23:50:33 -0500
Subject: moved all remaining filter stuff to FilterList renamed some widgets

---
 src/categories.cpp | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

(limited to 'src/categories.cpp')

diff --git a/src/categories.cpp b/src/categories.cpp
index 12b18998..082b4fbc 100644
--- a/src/categories.cpp
+++ b/src/categories.cpp
@@ -320,6 +320,40 @@ QString CategoryFactory::getCategoryName(unsigned int index) const
   return m_Categories[index].m_Name;
 }
 
+QString CategoryFactory::getSpecialCategoryName(int type) const
+{
+  switch (type)
+  {
+    case CATEGORY_SPECIAL_CHECKED:         return QObject::tr("<Checked>");
+    case CATEGORY_SPECIAL_UNCHECKED:       return QObject::tr("<Unchecked>");
+    case CATEGORY_SPECIAL_UPDATEAVAILABLE: return QObject::tr("<Update>");
+    case CATEGORY_SPECIAL_NOCATEGORY:      return QObject::tr("<Mod Backup>");
+    case CATEGORY_SPECIAL_CONFLICT:        return QObject::tr("<Managed by MO>");
+    case CATEGORY_SPECIAL_NOTENDORSED:     return QObject::tr("<Managed outside MO>");
+    case CATEGORY_SPECIAL_BACKUP:          return QObject::tr("<No category>");
+    case CATEGORY_SPECIAL_MANAGED:         return QObject::tr("<Conflicted>");
+    case CATEGORY_SPECIAL_UNMANAGED:       return QObject::tr("<Not Endorsed>");
+    case CATEGORY_SPECIAL_NOGAMEDATA:      return QObject::tr("<No Nexus ID>");
+    case CATEGORY_SPECIAL_NONEXUSID:       return QObject::tr("<No valid game data>");
+    default: return {};
+  }
+}
+
+QString CategoryFactory::getCategoryNameByID(int id) const
+{
+  auto itor = m_IDMap.find(id);
+
+  if (itor == m_IDMap.end()) {
+    return getSpecialCategoryName(id);
+  } else {
+    const auto index = itor->second;
+    if (index >= m_Categories.size()) {
+      return {};
+    }
+
+    return m_Categories[index].m_Name;
+  }
+}
 
 int CategoryFactory::getCategoryID(unsigned int index) const
 {
-- 
cgit v1.3.1


From ed14d5510d932362f8e232496b824729e096d3cf Mon Sep 17 00:00:00 2001
From: isanae <14251494+isanae@users.noreply.github.com>
Date: Sat, 30 Nov 2019 02:20:18 -0500
Subject: implemented not flag moved stuff to CriteriaItem fixed jumbled names
 in getSpecialCategoryName()

---
 src/categories.cpp       |  16 ++++----
 src/filterlist.cpp       | 102 +++++++++++++++++++++++++++++++++--------------
 src/filterlist.h         |   2 +
 src/modlistsortproxy.cpp |  23 +++++++++--
 4 files changed, 102 insertions(+), 41 deletions(-)

(limited to 'src/categories.cpp')

diff --git a/src/categories.cpp b/src/categories.cpp
index 082b4fbc..b75efefa 100644
--- a/src/categories.cpp
+++ b/src/categories.cpp
@@ -327,14 +327,14 @@ QString CategoryFactory::getSpecialCategoryName(int type) const
     case CATEGORY_SPECIAL_CHECKED:         return QObject::tr("<Checked>");
     case CATEGORY_SPECIAL_UNCHECKED:       return QObject::tr("<Unchecked>");
     case CATEGORY_SPECIAL_UPDATEAVAILABLE: return QObject::tr("<Update>");
-    case CATEGORY_SPECIAL_NOCATEGORY:      return QObject::tr("<Mod Backup>");
-    case CATEGORY_SPECIAL_CONFLICT:        return QObject::tr("<Managed by MO>");
-    case CATEGORY_SPECIAL_NOTENDORSED:     return QObject::tr("<Managed outside MO>");
-    case CATEGORY_SPECIAL_BACKUP:          return QObject::tr("<No category>");
-    case CATEGORY_SPECIAL_MANAGED:         return QObject::tr("<Conflicted>");
-    case CATEGORY_SPECIAL_UNMANAGED:       return QObject::tr("<Not Endorsed>");
-    case CATEGORY_SPECIAL_NOGAMEDATA:      return QObject::tr("<No Nexus ID>");
-    case CATEGORY_SPECIAL_NONEXUSID:       return QObject::tr("<No valid game data>");
+    case CATEGORY_SPECIAL_NOCATEGORY:      return QObject::tr("<No category>");
+    case CATEGORY_SPECIAL_CONFLICT:        return QObject::tr("<Conflicted>");
+    case CATEGORY_SPECIAL_NOTENDORSED:     return QObject::tr("<Not Endorsed>");
+    case CATEGORY_SPECIAL_BACKUP:          return QObject::tr("<Mod Backup>");
+    case CATEGORY_SPECIAL_MANAGED:         return QObject::tr("<Managed by MO>");
+    case CATEGORY_SPECIAL_UNMANAGED:       return QObject::tr("<Managed outside MO>");
+    case CATEGORY_SPECIAL_NOGAMEDATA:      return QObject::tr("<No valid game data>");
+    case CATEGORY_SPECIAL_NONEXUSID:       return QObject::tr("<No Nexus ID>");
     default: return {};
   }
 }
diff --git a/src/filterlist.cpp b/src/filterlist.cpp
index 9e5437b3..31783c88 100644
--- a/src/filterlist.cpp
+++ b/src/filterlist.cpp
@@ -5,9 +5,60 @@
 #include <utility.h>
 
 using namespace MOBase;
+using CriteriaType = ModListSortProxy::CriteriaType;
+using Criteria = ModListSortProxy::Criteria;
+
+class FilterList::CriteriaItem : public QTreeWidgetItem
+{
+public:
+  CriteriaItem(FilterList* list, QString name, CriteriaType type, int id)
+    : QTreeWidgetItem({name}), m_list(list), m_widget(nullptr), m_checkbox(nullptr)
+  {
+    setData(0, Qt::ToolTipRole, name);
+    setData(0, TypeRole, type);
+    setData(0, IDRole, id);
+
+    m_widget = new QWidget;
+    m_widget->setStyleSheet("background-color: rgba(0,0,0,0)");
+
+    auto* ly = new QVBoxLayout(m_widget);
+    ly->setAlignment(Qt::AlignCenter);
+    ly->setContentsMargins(0, 0, 0, 0);
+
+    m_checkbox = new QCheckBox;
+    QObject::connect(m_checkbox, &QCheckBox::toggled, [&]{ m_list->onSelection(); });
+    ly->addWidget(m_checkbox);
+  }
+
+  QWidget* widget()
+  {
+    return m_widget;
+  }
+
+  CriteriaType type() const
+  {
+    return static_cast<CriteriaType>(data(0, TypeRole).toInt());
+  }
+
+  int id() const
+  {
+    return data(0, IDRole).toInt();
+  }
+
+  bool inverse() const
+  {
+    return m_checkbox->isChecked();
+  }
+
+private:
+  const int IDRole = Qt::UserRole;
+  const int TypeRole = Qt::UserRole + 1;
+
+  FilterList* m_list;
+  QWidget* m_widget;
+  QCheckBox* m_checkbox;
+};
 
-const int CategoryIDRole = Qt::UserRole;
-const int CategoryTypeRole = Qt::UserRole + 1;
 
 FilterList::FilterList(Ui::MainWindow* ui, CategoryFactory& factory)
   : ui(ui), m_factory(factory)
@@ -42,13 +93,9 @@ FilterList::FilterList(Ui::MainWindow* ui, CategoryFactory& factory)
 
 QTreeWidgetItem* FilterList::addCriteriaItem(
   QTreeWidgetItem *root, const QString &name, int categoryID,
-  ModListSortProxy::CriteriaType type)
+  CriteriaType type)
 {
-  QTreeWidgetItem *item = new QTreeWidgetItem(QStringList(name));
-
-  item->setData(0, Qt::ToolTipRole, name);
-  item->setData(0, CategoryIDRole, categoryID);
-  item->setData(0, CategoryTypeRole, type);
+  auto* item = new CriteriaItem(this, name, type, categoryID);
 
   if (root != nullptr) {
     root->addChild(item);
@@ -56,18 +103,7 @@ QTreeWidgetItem* FilterList::addCriteriaItem(
     ui->filters->addTopLevelItem(item);
   }
 
-  auto* w = new QWidget;
-  w->setStyleSheet("background-color: rgba(0,0,0,0)");
-
-  auto* ly = new QVBoxLayout(w);
-  ly->setAlignment(Qt::AlignCenter);
-  ly->setContentsMargins(0, 0, 0, 0);
-
-  auto* cb = new QCheckBox;
-  connect(cb, &QCheckBox::toggled, [&]{ onSelection(); });
-  ly->addWidget(cb);
-
-  ui->filters->setItemWidget(item, 1, w);
+  ui->filters->setItemWidget(item, 1, item->widget());
 
   return item;
 }
@@ -163,7 +199,14 @@ void FilterList::refresh()
 void FilterList::setSelection(std::vector<int> categories)
 {
   for (int i = 0; i < ui->filters->topLevelItemCount(); ++i) {
-    if (ui->filters->topLevelItem(i)->data(0, CategoryIDRole) == CategoryFactory::CATEGORY_SPECIAL_UPDATEAVAILABLE) {
+    const auto* item = dynamic_cast<CriteriaItem*>(
+      ui->filters->topLevelItem(i));
+
+    if (!item) {
+      continue;
+    }
+
+    if (item->id() == CategoryFactory::CATEGORY_SPECIAL_UPDATEAVAILABLE) {
       ui->filters->setCurrentItem(ui->filters->topLevelItem(i));
       break;
     }
@@ -178,18 +221,17 @@ void FilterList::clearSelection()
 void FilterList::onSelection()
 {
   const QModelIndexList indices = ui->filters->selectionModel()->selectedRows();
-  std::vector<ModListSortProxy::Criteria> criteria;
+  std::vector<Criteria> criteria;
 
   for (auto* item: ui->filters->selectedItems()) {
-    const auto  type = static_cast<ModListSortProxy::CriteriaType>(
-      item->data(0, CategoryTypeRole).toInt());
-
-    const int id = item->data(0, CategoryIDRole).toInt();
-
-    auto* cb = static_cast<const QCheckBox*>(ui->filters->itemWidget(item, 1));
-    const bool inverse = cb->isChecked();
+    const auto* ci = dynamic_cast<CriteriaItem*>(item);
+    if (!ci) {
+      continue;
+    }
 
-    criteria.push_back({type, id, inverse});
+    criteria.push_back({
+      ci->type(), ci->id(), ci->inverse()
+    });
   }
 
   ui->filtersClear->setEnabled(!criteria.empty());
diff --git a/src/filterlist.h b/src/filterlist.h
index 418989e7..72fe3b5f 100644
--- a/src/filterlist.h
+++ b/src/filterlist.h
@@ -23,6 +23,8 @@ signals:
   void optionsChanged(ModListSortProxy::FilterMode mode, bool separators);
 
 private:
+  class CriteriaItem;
+
   Ui::MainWindow* ui;
   CategoryFactory& m_factory;
 
diff --git a/src/modlistsortproxy.cpp b/src/modlistsortproxy.cpp
index 646401b9..3bb02c0f 100644
--- a/src/modlistsortproxy.cpp
+++ b/src/modlistsortproxy.cpp
@@ -305,18 +305,35 @@ bool ModListSortProxy::filterMatchesModOr(ModInfo::Ptr info, bool enabled) const
 bool ModListSortProxy::criteriaMatchesMod(
   ModInfo::Ptr info, bool enabled, const Criteria& c) const
 {
+  bool b = false;
+
   switch (c.type)
   {
     case TYPE_SPECIAL:  // fall-through
     case TYPE_CATEGORY:
-      return categoryMatchesMod(info, enabled, c.id);
+    {
+      b = categoryMatchesMod(info, enabled, c.id);
+      break;
+    }
 
     case TYPE_CONTENT:
-      return contentMatchesMod(info, enabled, c.id);
+    {
+      b = contentMatchesMod(info, enabled, c.id);
+      break;
+    }
 
     default:
-      return false;
+    {
+      log::error("bad criteria type {}", c.type);
+      break;
+    }
   }
+
+  if (c.inverse) {
+    b = !b;
+  }
+
+  return b;
 }
 
 bool ModListSortProxy::categoryMatchesMod(
-- 
cgit v1.3.1


From a38d1723bffcd20bc7011c0fe635636b936aa78b Mon Sep 17 00:00:00 2001
From: isanae <14251494+isanae@users.noreply.github.com>
Date: Sat, 30 Nov 2019 03:21:23 -0500
Subject: removed redundant categories now that there's a not filter disabled
 collapsing for filter, there's already a button to hide it

---
 src/categories.cpp       | 24 +++++++++++-------------
 src/categories.h         | 31 +++++++++++++------------------
 src/filterlist.cpp       | 28 +++++++++++++++-------------
 src/mainwindow.cpp       |  4 ++--
 src/mainwindow.ui        |  3 +++
 src/modlistsortproxy.cpp | 32 ++++++++++----------------------
 6 files changed, 54 insertions(+), 68 deletions(-)

(limited to 'src/categories.cpp')

diff --git a/src/categories.cpp b/src/categories.cpp
index b75efefa..1bd56f7f 100644
--- a/src/categories.cpp
+++ b/src/categories.cpp
@@ -320,21 +320,19 @@ QString CategoryFactory::getCategoryName(unsigned int index) const
   return m_Categories[index].m_Name;
 }
 
-QString CategoryFactory::getSpecialCategoryName(int type) const
+QString CategoryFactory::getSpecialCategoryName(SpecialCategories type) const
 {
   switch (type)
   {
-    case CATEGORY_SPECIAL_CHECKED:         return QObject::tr("<Checked>");
-    case CATEGORY_SPECIAL_UNCHECKED:       return QObject::tr("<Unchecked>");
-    case CATEGORY_SPECIAL_UPDATEAVAILABLE: return QObject::tr("<Update>");
-    case CATEGORY_SPECIAL_NOCATEGORY:      return QObject::tr("<No category>");
-    case CATEGORY_SPECIAL_CONFLICT:        return QObject::tr("<Conflicted>");
-    case CATEGORY_SPECIAL_NOTENDORSED:     return QObject::tr("<Not Endorsed>");
-    case CATEGORY_SPECIAL_BACKUP:          return QObject::tr("<Mod Backup>");
-    case CATEGORY_SPECIAL_MANAGED:         return QObject::tr("<Managed by MO>");
-    case CATEGORY_SPECIAL_UNMANAGED:       return QObject::tr("<Managed outside MO>");
-    case CATEGORY_SPECIAL_NOGAMEDATA:      return QObject::tr("<No valid game data>");
-    case CATEGORY_SPECIAL_NONEXUSID:       return QObject::tr("<No Nexus ID>");
+    case Checked:         return QObject::tr("<Checked>");
+    case UpdateAvailable: return QObject::tr("<Update>");
+    case HasNoCategory:      return QObject::tr("<No category>");
+    case Conflict:        return QObject::tr("<Conflicted>");
+    case NotEndorsed:     return QObject::tr("<Not Endorsed>");
+    case Backup:          return QObject::tr("<Mod Backup>");
+    case Managed:         return QObject::tr("<Managed by MO>");
+    case NoGameData:      return QObject::tr("<No valid game data>");
+    case NoNexusID:       return QObject::tr("<No Nexus ID>");
     default: return {};
   }
 }
@@ -344,7 +342,7 @@ QString CategoryFactory::getCategoryNameByID(int id) const
   auto itor = m_IDMap.find(id);
 
   if (itor == m_IDMap.end()) {
-    return getSpecialCategoryName(id);
+    return getSpecialCategoryName(static_cast<SpecialCategories>(id));
   } else {
     const auto index = itor->second;
     if (index >= m_Categories.size()) {
diff --git a/src/categories.h b/src/categories.h
index 2041ce1f..296e7711 100644
--- a/src/categories.h
+++ b/src/categories.h
@@ -37,25 +37,20 @@ class CategoryFactory {
   friend class CategoriesDialog;
 
 public:
-
-  static const int CATEGORY_NONE = 0;
-
-  static const int CATEGORY_SPECIAL_FIRST = 10000;
-  static const int CATEGORY_SPECIAL_CHECKED = CATEGORY_SPECIAL_FIRST;
-  static const int CATEGORY_SPECIAL_UNCHECKED = 10001;
-  static const int CATEGORY_SPECIAL_UPDATEAVAILABLE = 10002;
-  static const int CATEGORY_SPECIAL_NOCATEGORY = 10003;
-  static const int CATEGORY_SPECIAL_CONFLICT = 10004;
-  static const int CATEGORY_SPECIAL_NOTENDORSED = 10005;
-  static const int CATEGORY_SPECIAL_BACKUP = 10006;
-  static const int CATEGORY_SPECIAL_MANAGED = 10007;
-  static const int CATEGORY_SPECIAL_UNMANAGED = 10008;
-  static const int CATEGORY_SPECIAL_NOGAMEDATA = 10009;
-  static const int CATEGORY_SPECIAL_NONEXUSID = 10010;
-
+  enum SpecialCategories
+  {
+    Checked = 10000,
+    UpdateAvailable,
+    HasNoCategory,
+    Conflict,
+    NotEndorsed,
+    Backup,
+    Managed,
+    NoGameData,
+    NoNexusID
+  };
 
 public:
-
   struct Category {
     Category(int sortValue, int id, const QString &name, const std::vector<int> &nexusIDs, int parentID)
       : m_SortValue(sortValue), m_ID(id), m_Name(name), m_HasChildren(false),
@@ -144,7 +139,7 @@ public:
    * @return QString name of the category
    **/
   QString getCategoryName(unsigned int index) const;
-  QString getSpecialCategoryName(int type) const;
+  QString getSpecialCategoryName(SpecialCategories type) const;
   QString getCategoryNameByID(int id) const;
 
   /**
diff --git a/src/filterlist.cpp b/src/filterlist.cpp
index 8f297af6..36cdacd0 100644
--- a/src/filterlist.cpp
+++ b/src/filterlist.cpp
@@ -94,6 +94,8 @@ FilterList::FilterList(Ui::MainWindow* ui, CategoryFactory& factory)
 
   ui->filters->header()->setSectionResizeMode(0, QHeaderView::Stretch);
   ui->filters->header()->resizeSection(1, 50);
+  ui->categoriesSplitter->setCollapsible(0, false);
+  ui->categoriesSplitter->setCollapsible(1, false);
 }
 
 QTreeWidgetItem* FilterList::addCriteriaItem(
@@ -142,8 +144,10 @@ void FilterList::addCategoryCriteria(QTreeWidgetItem *root, const std::set<int>
 
 void FilterList::addSpecialCriteria(int type)
 {
+  const auto sc = static_cast<CategoryFactory::SpecialCategories>(type);
+
   addCriteriaItem(
-    nullptr, m_factory.getSpecialCategoryName(type),
+    nullptr, m_factory.getSpecialCategoryName(sc),
     type, ModListSortProxy::TYPE_SPECIAL);
 }
 
@@ -157,17 +161,15 @@ void FilterList::refresh()
   ui->filters->clear();
 
   using F = CategoryFactory;
-  addSpecialCriteria(F::CATEGORY_SPECIAL_CHECKED);
-  addSpecialCriteria(F::CATEGORY_SPECIAL_UNCHECKED);
-  addSpecialCriteria(F::CATEGORY_SPECIAL_UPDATEAVAILABLE);
-  addSpecialCriteria(F::CATEGORY_SPECIAL_BACKUP);
-  addSpecialCriteria(F::CATEGORY_SPECIAL_MANAGED);
-  addSpecialCriteria(F::CATEGORY_SPECIAL_UNMANAGED);
-  addSpecialCriteria(F::CATEGORY_SPECIAL_NOCATEGORY);
-  addSpecialCriteria(F::CATEGORY_SPECIAL_CONFLICT);
-  addSpecialCriteria(F::CATEGORY_SPECIAL_NOTENDORSED);
-  addSpecialCriteria(F::CATEGORY_SPECIAL_NONEXUSID);
-  addSpecialCriteria(F::CATEGORY_SPECIAL_NOGAMEDATA);
+  addSpecialCriteria(F::Checked);
+  addSpecialCriteria(F::UpdateAvailable);
+  addSpecialCriteria(F::Backup);
+  addSpecialCriteria(F::Managed);
+  addSpecialCriteria(F::HasNoCategory);
+  addSpecialCriteria(F::Conflict);
+  addSpecialCriteria(F::NotEndorsed);
+  addSpecialCriteria(F::NoNexusID);
+  addSpecialCriteria(F::NoGameData);
 
   addContentCriteria();
 
@@ -211,7 +213,7 @@ void FilterList::setSelection(std::vector<int> categories)
       continue;
     }
 
-    if (item->id() == CategoryFactory::CATEGORY_SPECIAL_UPDATEAVAILABLE) {
+    if (item->id() == CategoryFactory::UpdateAvailable) {
       ui->filters->setCurrentItem(ui->filters->topLevelItem(i));
       break;
     }
diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index 03d61bc6..0ad57803 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -4126,11 +4126,11 @@ void MainWindow::checkModsForUpdates()
   if (updatesAvailable || checkingModsForUpdate) {
     m_ModListSortProxy->setCriteria({{
         ModListSortProxy::TYPE_SPECIAL,
-        CategoryFactory::CATEGORY_SPECIAL_UPDATEAVAILABLE,
+        CategoryFactory::UpdateAvailable,
         false}
     });
 
-    m_Filters->setSelection({CategoryFactory::CATEGORY_SPECIAL_UPDATEAVAILABLE});
+    m_Filters->setSelection({CategoryFactory::UpdateAvailable});
   }
 }
 
diff --git a/src/mainwindow.ui b/src/mainwindow.ui
index 7cc7dca4..6c35d239 100644
--- a/src/mainwindow.ui
+++ b/src/mainwindow.ui
@@ -39,6 +39,9 @@
       <property name="orientation">
        <enum>Qt::Horizontal</enum>
       </property>
+      <property name="childrenCollapsible">
+       <bool>false</bool>
+      </property>
       <widget class="QGroupBox" name="categoriesGroup">
        <property name="maximumSize">
         <size>
diff --git a/src/modlistsortproxy.cpp b/src/modlistsortproxy.cpp
index 3bb02c0f..36dcae59 100644
--- a/src/modlistsortproxy.cpp
+++ b/src/modlistsortproxy.cpp
@@ -61,7 +61,7 @@ void ModListSortProxy::setCriteria(const std::vector<Criteria>& criteria)
   const bool changed = (criteria != m_Criteria);
   const bool isForUpdates = (
     !criteria.empty() &&
-    criteria[0].id == CategoryFactory::CATEGORY_SPECIAL_UPDATEAVAILABLE);
+    criteria[0].id == CategoryFactory::UpdateAvailable);
 
   if (changed || isForUpdates) {
     m_Criteria = criteria;
@@ -343,68 +343,56 @@ bool ModListSortProxy::categoryMatchesMod(
 
   switch (category)
   {
-    case CategoryFactory::CATEGORY_SPECIAL_CHECKED:
+    case CategoryFactory::Checked:
     {
       b = (enabled || info->alwaysEnabled());
       break;
     }
 
-    case CategoryFactory::CATEGORY_SPECIAL_UNCHECKED:
-    {
-      b = (!enabled && !info->alwaysEnabled());
-      break;
-    }
-
-    case CategoryFactory::CATEGORY_SPECIAL_UPDATEAVAILABLE:
+    case CategoryFactory::UpdateAvailable:
     {
       b = (info->updateAvailable() || info->downgradeAvailable());
       break;
     }
 
-    case CategoryFactory::CATEGORY_SPECIAL_NOCATEGORY:
+    case CategoryFactory::HasNoCategory:
     {
       b = (info->getCategories().size() == 0);
       break;
     }
 
-    case CategoryFactory::CATEGORY_SPECIAL_CONFLICT:
+    case CategoryFactory::Conflict:
     {
       b = (hasConflictFlag(info->getFlags()));
       break;
     }
 
-    case CategoryFactory::CATEGORY_SPECIAL_NOTENDORSED:
+    case CategoryFactory::NotEndorsed:
     {
       ModInfo::EEndorsedState state = info->endorsedState();
       b = (state != ModInfo::ENDORSED_TRUE);
       break;
     }
 
-    case CategoryFactory::CATEGORY_SPECIAL_BACKUP:
+    case CategoryFactory::Backup:
     {
       b = (info->hasFlag(ModInfo::FLAG_BACKUP));
       break;
     }
 
-    case CategoryFactory::CATEGORY_SPECIAL_MANAGED:
+    case CategoryFactory::Managed:
     {
       b = (!info->hasFlag(ModInfo::FLAG_FOREIGN));
       break;
     }
 
-    case CategoryFactory::CATEGORY_SPECIAL_UNMANAGED:
-    {
-      b = (info->hasFlag(ModInfo::FLAG_FOREIGN));
-      break;
-    }
-
-    case CategoryFactory::CATEGORY_SPECIAL_NOGAMEDATA:
+    case CategoryFactory::NoGameData:
     {
       b = (info->hasFlag(ModInfo::FLAG_INVALID));
       break;
     }
 
-    case CategoryFactory::CATEGORY_SPECIAL_NONEXUSID:
+    case CategoryFactory::NoNexusID:
     {
       b = (
         info->getNexusID() == -1 &&
-- 
cgit v1.3.1


From d2073ef2bd62527034864fd0cacd5537aff33218 Mon Sep 17 00:00:00 2001
From: isanae <14251494+isanae@users.noreply.github.com>
Date: Sat, 30 Nov 2019 05:37:34 -0500
Subject: made all categories positive fixed context menu sometimes appearing

---
 src/categories.cpp       | 16 ++++++++--------
 src/categories.h         |  8 ++++----
 src/filterlist.cpp       | 10 +++++-----
 src/mainwindow.ui        |  3 +++
 src/modlistsortproxy.cpp | 29 ++++++++++++++++-------------
 5 files changed, 36 insertions(+), 30 deletions(-)

(limited to 'src/categories.cpp')

diff --git a/src/categories.cpp b/src/categories.cpp
index 1bd56f7f..5c9a4d55 100644
--- a/src/categories.cpp
+++ b/src/categories.cpp
@@ -324,15 +324,15 @@ QString CategoryFactory::getSpecialCategoryName(SpecialCategories type) const
 {
   switch (type)
   {
-    case Checked:         return QObject::tr("<Checked>");
-    case UpdateAvailable: return QObject::tr("<Update>");
-    case HasNoCategory:      return QObject::tr("<No category>");
+    case Checked:         return QObject::tr("<Active>");
+    case UpdateAvailable: return QObject::tr("<Update available>");
+    case HasCategory:     return QObject::tr("<Has category>");
     case Conflict:        return QObject::tr("<Conflicted>");
-    case NotEndorsed:     return QObject::tr("<Not Endorsed>");
-    case Backup:          return QObject::tr("<Mod Backup>");
-    case Managed:         return QObject::tr("<Managed by MO>");
-    case NoGameData:      return QObject::tr("<No valid game data>");
-    case NoNexusID:       return QObject::tr("<No Nexus ID>");
+    case Endorsed:        return QObject::tr("<Endorsed>");
+    case Backup:          return QObject::tr("<Has backup>");
+    case Managed:         return QObject::tr("<Managed>");
+    case HasGameData:     return QObject::tr("<Has valid game data>");
+    case HasNexusID:      return QObject::tr("<Has Nexus ID>");
     default: return {};
   }
 }
diff --git a/src/categories.h b/src/categories.h
index 296e7711..02695e4d 100644
--- a/src/categories.h
+++ b/src/categories.h
@@ -41,13 +41,13 @@ public:
   {
     Checked = 10000,
     UpdateAvailable,
-    HasNoCategory,
+    HasCategory,
     Conflict,
-    NotEndorsed,
+    Endorsed,
     Backup,
     Managed,
-    NoGameData,
-    NoNexusID
+    HasGameData,
+    HasNexusID
   };
 
 public:
diff --git a/src/filterlist.cpp b/src/filterlist.cpp
index 0dee8544..b65f0f4a 100644
--- a/src/filterlist.cpp
+++ b/src/filterlist.cpp
@@ -11,7 +11,7 @@ using Criteria = ModListSortProxy::Criteria;
 class FilterList::CriteriaItem : public QTreeWidgetItem
 {
 public:
-  enum States : int
+  enum States
   {
     FirstState = 0,
 
@@ -234,11 +234,11 @@ void FilterList::refresh()
   addSpecialCriteria(F::UpdateAvailable);
   addSpecialCriteria(F::Backup);
   addSpecialCriteria(F::Managed);
-  addSpecialCriteria(F::HasNoCategory);
+  addSpecialCriteria(F::HasCategory);
   addSpecialCriteria(F::Conflict);
-  addSpecialCriteria(F::NotEndorsed);
-  addSpecialCriteria(F::NoNexusID);
-  addSpecialCriteria(F::NoGameData);
+  addSpecialCriteria(F::Endorsed);
+  addSpecialCriteria(F::HasNexusID);
+  addSpecialCriteria(F::HasGameData);
 
   addContentCriteria();
 
diff --git a/src/mainwindow.ui b/src/mainwindow.ui
index 1a64dfdd..92a41c67 100644
--- a/src/mainwindow.ui
+++ b/src/mainwindow.ui
@@ -76,6 +76,9 @@
             <height>0</height>
            </size>
           </property>
+          <property name="contextMenuPolicy">
+           <enum>Qt::NoContextMenu</enum>
+          </property>
           <property name="selectionMode">
            <enum>QAbstractItemView::NoSelection</enum>
           </property>
diff --git a/src/modlistsortproxy.cpp b/src/modlistsortproxy.cpp
index e6bed49c..fd3dbc9e 100644
--- a/src/modlistsortproxy.cpp
+++ b/src/modlistsortproxy.cpp
@@ -371,9 +371,9 @@ bool ModListSortProxy::categoryMatchesMod(
       break;
     }
 
-    case CategoryFactory::HasNoCategory:
+    case CategoryFactory::HasCategory:
     {
-      b = (info->getCategories().size() == 0);
+      b = !info->getCategories().empty();
       break;
     }
 
@@ -383,10 +383,9 @@ bool ModListSortProxy::categoryMatchesMod(
       break;
     }
 
-    case CategoryFactory::NotEndorsed:
+    case CategoryFactory::Endorsed:
     {
-      ModInfo::EEndorsedState state = info->endorsedState();
-      b = (state != ModInfo::ENDORSED_TRUE);
+      b = (info->endorsedState() == ModInfo::ENDORSED_TRUE);
       break;
     }
 
@@ -402,20 +401,24 @@ bool ModListSortProxy::categoryMatchesMod(
       break;
     }
 
-    case CategoryFactory::NoGameData:
+    case CategoryFactory::HasGameData:
     {
-      b = (info->hasFlag(ModInfo::FLAG_INVALID));
+      b = !info->hasFlag(ModInfo::FLAG_INVALID);
       break;
     }
 
-    case CategoryFactory::NoNexusID:
+    case CategoryFactory::HasNexusID:
     {
-      b = (
-        info->getNexusID() == -1 &&
-        !info->hasFlag(ModInfo::FLAG_FOREIGN) &&
-        !info->hasFlag(ModInfo::FLAG_BACKUP) &&
-        !info->hasFlag(ModInfo::FLAG_OVERWRITE));
+      // never show these
+      if (
+        info->hasFlag(ModInfo::FLAG_FOREIGN) ||
+        info->hasFlag(ModInfo::FLAG_BACKUP) ||
+        info->hasFlag(ModInfo::FLAG_OVERWRITE))
+      {
+        return false;
+      }
 
+      b = (info->getNexusID() > 0);
       break;
     }
 
-- 
cgit v1.3.1