NOISSUE Flatten gui and logic libraries into MultiMC

1 files changed, 447 insertions, 0 deletions

diff --git a/launcher/VersionProxyModel.cpp b/launcher/VersionProxyModel.cpp
new file mode 100644
index 00000000..5587136f
--- /dev/null
+++ b/launcher/VersionProxyModel.cpp
@@ -0,0 +1,447 @@
+#include "VersionProxyModel.h"
+#include "MultiMC.h"
+#include <QSortFilterProxyModel>
+#include <QPixmapCache>
+#include <Version.h>
+#include <meta/VersionList.h>
+
+class VersionFilterModel : public QSortFilterProxyModel
+{
+    Q_OBJECT
+public:
+    VersionFilterModel(VersionProxyModel *parent) : QSortFilterProxyModel(parent)
+    {
+        m_parent = parent;
+        setSortRole(BaseVersionList::SortRole);
+        sort(0, Qt::DescendingOrder);
+    }
+
+    bool filterAcceptsRow(int source_row, const QModelIndex &source_parent) const
+    {
+        const auto &filters = m_parent->filters();
+        for (auto it = filters.begin(); it != filters.end(); ++it)
+        {
+            auto idx = sourceModel()->index(source_row, 0, source_parent);
+            auto data = sourceModel()->data(idx, it.key());
+            auto match = data.toString();
+            if(!it.value()->accepts(match))
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    void filterChanged()
+    {
+        invalidateFilter();
+    }
+private:
+    VersionProxyModel *m_parent;
+};
+
+VersionProxyModel::VersionProxyModel(QObject *parent) : QAbstractProxyModel(parent)
+{
+    filterModel = new VersionFilterModel(this);
+    connect(filterModel, &QAbstractItemModel::dataChanged, this, &VersionProxyModel::sourceDataChanged);
+    connect(filterModel, &QAbstractItemModel::rowsAboutToBeInserted, this, &VersionProxyModel::sourceRowsAboutToBeInserted);
+    connect(filterModel, &QAbstractItemModel::rowsInserted, this, &VersionProxyModel::sourceRowsInserted);
+    connect(filterModel, &QAbstractItemModel::rowsAboutToBeRemoved, this, &VersionProxyModel::sourceRowsAboutToBeRemoved);
+    connect(filterModel, &QAbstractItemModel::rowsRemoved, this, &VersionProxyModel::sourceRowsRemoved);
+    // FIXME: implement when needed
+    /*
+    connect(replacing, &QAbstractItemModel::rowsAboutToBeMoved, this, &VersionProxyModel::sourceRowsAboutToBeMoved);
+    connect(replacing, &QAbstractItemModel::rowsMoved, this, &VersionProxyModel::sourceRowsMoved);
+    connect(replacing, &QAbstractItemModel::layoutAboutToBeChanged, this, &VersionProxyModel::sourceLayoutAboutToBeChanged);
+    connect(replacing, &QAbstractItemModel::layoutChanged, this, &VersionProxyModel::sourceLayoutChanged);
+    */
+    connect(filterModel, &QAbstractItemModel::modelAboutToBeReset, this, &VersionProxyModel::sourceAboutToBeReset);
+    connect(filterModel, &QAbstractItemModel::modelReset, this, &VersionProxyModel::sourceReset);
+
+    QAbstractProxyModel::setSourceModel(filterModel);
+}
+
+QVariant VersionProxyModel::headerData(int section, Qt::Orientation orientation, int role) const
+{
+    if(section < 0 || section >= m_columns.size())
+        return QVariant();
+    if(orientation != Qt::Horizontal)
+        return QVariant();
+    auto column = m_columns[section];
+    if(role == Qt::DisplayRole)
+    {
+        switch(column)
+        {
+            case Name:
+                return tr("Version");
+            case ParentVersion:
+                return tr("Minecraft"); //FIXME: this should come from metadata
+            case Branch:
+                return tr("Branch");
+            case Type:
+                return tr("Type");
+            case Architecture:
+                return tr("Architecture");
+            case Path:
+                return tr("Path");
+            case Time:
+                return tr("Released");
+        }
+    }
+    else if(role == Qt::ToolTipRole)
+    {
+        switch(column)
+        {
+            case Name:
+                return tr("The name of the version.");
+            case ParentVersion:
+                return tr("Minecraft version"); //FIXME: this should come from metadata
+            case Branch:
+                return tr("The version's branch");
+            case Type:
+                return tr("The version's type");
+            case Architecture:
+                return tr("CPU Architecture");
+            case Path:
+                return tr("Filesystem path to this version");
+            case Time:
+                return tr("Release date of this version");
+        }
+    }
+    return QVariant();
+}
+
+QVariant VersionProxyModel::data(const QModelIndex &index, int role) const
+{
+    if(!index.isValid())
+    {
+        return QVariant();
+    }
+    auto column = m_columns[index.column()];
+    auto parentIndex = mapToSource(index);
+    switch(role)
+    {
+        case Qt::DisplayRole:
+        {
+            switch(column)
+            {
+                case Name:
+                {
+                    QString version = sourceModel()->data(parentIndex, BaseVersionList::VersionRole).toString();
+                    if(version == m_currentVersion)
+                    {
+                        return tr("%1 (installed)").arg(version);
+                    }
+                    return version;
+                }
+                case ParentVersion:
+                    return sourceModel()->data(parentIndex, BaseVersionList::ParentVersionRole);
+                case Branch:
+                    return sourceModel()->data(parentIndex, BaseVersionList::BranchRole);
+                case Type:
+                    return sourceModel()->data(parentIndex, BaseVersionList::TypeRole);
+                case Architecture:
+                    return sourceModel()->data(parentIndex, BaseVersionList::ArchitectureRole);
+                case Path:
+                    return sourceModel()->data(parentIndex, BaseVersionList::PathRole);
+                case Time:
+                    return sourceModel()->data(parentIndex, Meta::VersionList::TimeRole).toDate();
+                default:
+                    return QVariant();
+            }
+        }
+        case Qt::ToolTipRole:
+        {
+            switch(column)
+            {
+                case Name:
+                {
+                    if(hasRecommended)
+                    {
+                        auto value = sourceModel()->data(parentIndex, BaseVersionList::RecommendedRole);
+                        if(value.toBool())
+                        {
+                            return tr("Recommended");
+                        }
+                        else if(hasLatest)
+                        {
+                            auto value = sourceModel()->data(parentIndex, BaseVersionList::LatestRole);
+                            if(value.toBool())
+                            {
+                                return tr("Latest");
+                            }
+                        }
+                        else if(index.row() == 0)
+                        {
+                            return tr("Latest");
+                        }
+                    }
+                }
+                default:
+                {
+                    return sourceModel()->data(parentIndex, BaseVersionList::VersionIdRole);
+                }
+            }
+        }
+        case Qt::DecorationRole:
+        {
+            switch(column)
+            {
+                case Name:
+                {
+                    if(hasRecommended)
+                    {
+                        auto value = sourceModel()->data(parentIndex, BaseVersionList::RecommendedRole);
+                        if(value.toBool())
+                        {
+                            return MMC->getThemedIcon("star");
+                        }
+                        else if(hasLatest)
+                        {
+                            auto value = sourceModel()->data(parentIndex, BaseVersionList::LatestRole);
+                            if(value.toBool())
+                            {
+                                return MMC->getThemedIcon("bug");
+                            }
+                        }
+                        else if(index.row() == 0)
+                        {
+                            return MMC->getThemedIcon("bug");
+                        }
+                        auto pixmap = QPixmapCache::find("placeholder");
+                        if(!pixmap)
+                        {
+                            QPixmap px(16,16);
+                            px.fill(Qt::transparent);
+                            QPixmapCache::insert("placeholder", px);
+                            return px;
+                        }
+                        return *pixmap;
+                    }
+                }
+                default:
+                {
+                    return QVariant();
+                }
+            }
+        }
+        default:
+        {
+            if(roles.contains((BaseVersionList::ModelRoles)role))
+            {
+                return sourceModel()->data(parentIndex, role);
+            }
+            return QVariant();
+        }
+    }
+}
+
+QModelIndex VersionProxyModel::parent(const QModelIndex &child) const
+{
+    return QModelIndex();
+}
+
+QModelIndex VersionProxyModel::mapFromSource(const QModelIndex &sourceIndex) const
+{
+    if(sourceIndex.isValid())
+    {
+        return index(sourceIndex.row(), 0);
+    }
+    return QModelIndex();
+}
+
+QModelIndex VersionProxyModel::mapToSource(const QModelIndex &proxyIndex) const
+{
+    if(proxyIndex.isValid())
+    {
+        return sourceModel()->index(proxyIndex.row(), 0);
+    }
+    return QModelIndex();
+}
+
+QModelIndex VersionProxyModel::index(int row, int column, const QModelIndex &parent) const
+{
+    // no trees here... shoo
+    if(parent.isValid())
+    {
+        return QModelIndex();
+    }
+    if(row < 0 || row >= sourceModel()->rowCount())
+        return QModelIndex();
+    if(column < 0 || column >= columnCount())
+        return QModelIndex();
+    return QAbstractItemModel::createIndex(row, column);
+}
+
+int VersionProxyModel::columnCount(const QModelIndex &parent) const
+{
+    return m_columns.size();
+}
+
+int VersionProxyModel::rowCount(const QModelIndex &parent) const
+{
+    if(sourceModel())
+    {
+        return sourceModel()->rowCount();
+    }
+    return 0;
+}
+
+void VersionProxyModel::sourceDataChanged(const QModelIndex &source_top_left,
+                                          const QModelIndex &source_bottom_right)
+{
+    if(source_top_left.parent() != source_bottom_right.parent())
+        return;
+
+    // whole row is getting changed
+    auto topLeft = createIndex(source_top_left.row(), 0);
+    auto bottomRight = createIndex(source_bottom_right.row(), columnCount() - 1);
+    emit dataChanged(topLeft, bottomRight);
+}
+
+void VersionProxyModel::setSourceModel(QAbstractItemModel *replacingRaw)
+{
+    auto replacing = dynamic_cast<BaseVersionList *>(replacingRaw);
+    beginResetModel();
+
+    m_columns.clear();
+    if(!replacing)
+    {
+        roles.clear();
+        filterModel->setSourceModel(replacing);
+        return;
+    }
+
+    roles = replacing->providesRoles();
+    if(roles.contains(BaseVersionList::VersionRole))
+    {
+        m_columns.push_back(Name);
+    }
+    /*
+    if(roles.contains(BaseVersionList::ParentVersionRole))
+    {
+        m_columns.push_back(ParentVersion);
+    }
+    */
+    if(roles.contains(BaseVersionList::ArchitectureRole))
+    {
+        m_columns.push_back(Architecture);
+    }
+    if(roles.contains(BaseVersionList::PathRole))
+    {
+        m_columns.push_back(Path);
+    }
+    if(roles.contains(Meta::VersionList::TimeRole))
+    {
+        m_columns.push_back(Time);
+    }
+    if(roles.contains(BaseVersionList::BranchRole))
+    {
+        m_columns.push_back(Branch);
+    }
+    if(roles.contains(BaseVersionList::TypeRole))
+    {
+        m_columns.push_back(Type);
+    }
+    if(roles.contains(BaseVersionList::RecommendedRole))
+    {
+        hasRecommended = true;
+    }
+    if(roles.contains(BaseVersionList::LatestRole))
+    {
+        hasLatest = true;
+    }
+    filterModel->setSourceModel(replacing);
+
+    endResetModel();
+}
+
+QModelIndex VersionProxyModel::getRecommended() const
+{
+    if(!roles.contains(BaseVersionList::RecommendedRole))
+    {
+        return index(0, 0);
+    }
+    int recommended = 0;
+    for (int i = 0; i < rowCount(); i++)
+    {
+        auto value = sourceModel()->data(mapToSource(index(i, 0)), BaseVersionList::RecommendedRole);
+        if (value.toBool())
+        {
+            recommended = i;
+        }
+    }
+    return index(recommended, 0);
+}
+
+QModelIndex VersionProxyModel::getVersion(const QString& version) const
+{
+    int found = -1;
+    for (int i = 0; i < rowCount(); i++)
+    {
+        auto value = sourceModel()->data(mapToSource(index(i, 0)), BaseVersionList::VersionRole);
+        if (value.toString() == version)
+        {
+            found = i;
+        }
+    }
+    if(found == -1)
+    {
+        return QModelIndex();
+    }
+    return index(found, 0);
+}
+
+void VersionProxyModel::clearFilters()
+{
+    m_filters.clear();
+    filterModel->filterChanged();
+}
+
+void VersionProxyModel::setFilter(const BaseVersionList::ModelRoles column, Filter * f)
+{
+    m_filters[column].reset(f);
+    filterModel->filterChanged();
+}
+
+const VersionProxyModel::FilterMap &VersionProxyModel::filters() const
+{
+    return m_filters;
+}
+
+void VersionProxyModel::sourceAboutToBeReset()
+{
+    beginResetModel();
+}
+
+void VersionProxyModel::sourceReset()
+{
+    endResetModel();
+}
+
+void VersionProxyModel::sourceRowsAboutToBeInserted(const QModelIndex& parent, int first, int last)
+{
+    beginInsertRows(parent, first, last);
+}
+
+void VersionProxyModel::sourceRowsInserted(const QModelIndex& parent, int first, int last)
+{
+    endInsertRows();
+}
+
+void VersionProxyModel::sourceRowsAboutToBeRemoved(const QModelIndex& parent, int first, int last)
+{
+    beginRemoveRows(parent, first, last);
+}
+
+void VersionProxyModel::sourceRowsRemoved(const QModelIndex& parent, int first, int last)
+{
+    endRemoveRows();
+}
+
+void VersionProxyModel::setCurrentVersion(const QString &version)
+{
+    m_currentVersion = version;
+}
+
+#include "VersionProxyModel.moc"