2015-02-03 03:55:30 +05:30
|
|
|
/* Copyright 2013-2015 MultiMC Contributors
|
2013-11-04 07:23:05 +05:30
|
|
|
*
|
|
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
* you may not use this file except in compliance with the License.
|
|
|
|
* You may obtain a copy of the License at
|
|
|
|
*
|
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
*
|
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
* See the License for the specific language governing permissions and
|
|
|
|
* limitations under the License.
|
|
|
|
*/
|
|
|
|
|
2014-02-01 19:22:21 +05:30
|
|
|
#include <QFile>
|
2016-03-13 04:53:45 +05:30
|
|
|
#include <Version.h>
|
2014-03-15 00:21:56 +05:30
|
|
|
#include <QDir>
|
2014-05-19 05:52:09 +05:30
|
|
|
#include <QJsonDocument>
|
|
|
|
#include <QJsonArray>
|
2015-05-28 23:08:29 +05:30
|
|
|
#include <QDebug>
|
2013-09-22 07:51:36 +05:30
|
|
|
|
2015-02-09 06:21:14 +05:30
|
|
|
#include "minecraft/MinecraftProfile.h"
|
2015-01-28 03:01:07 +05:30
|
|
|
#include "ProfileUtils.h"
|
|
|
|
#include "NullProfileStrategy.h"
|
2015-05-28 23:08:29 +05:30
|
|
|
#include "Exception.h"
|
2014-05-09 00:50:10 +05:30
|
|
|
|
2015-01-28 03:01:07 +05:30
|
|
|
MinecraftProfile::MinecraftProfile(ProfileStrategy *strategy)
|
|
|
|
: QAbstractListModel()
|
2014-01-24 22:42:02 +05:30
|
|
|
{
|
2015-01-28 03:01:07 +05:30
|
|
|
setStrategy(strategy);
|
2014-01-24 22:42:02 +05:30
|
|
|
clear();
|
2013-09-22 07:51:36 +05:30
|
|
|
}
|
|
|
|
|
2015-01-28 03:01:07 +05:30
|
|
|
void MinecraftProfile::setStrategy(ProfileStrategy* strategy)
|
|
|
|
{
|
|
|
|
Q_ASSERT(strategy != nullptr);
|
|
|
|
|
|
|
|
if(m_strategy != nullptr)
|
|
|
|
{
|
|
|
|
delete m_strategy;
|
|
|
|
m_strategy = nullptr;
|
|
|
|
}
|
|
|
|
m_strategy = strategy;
|
|
|
|
m_strategy->profile = this;
|
|
|
|
}
|
|
|
|
|
|
|
|
ProfileStrategy* MinecraftProfile::strategy()
|
|
|
|
{
|
|
|
|
return m_strategy;
|
|
|
|
}
|
|
|
|
|
|
|
|
void MinecraftProfile::reload()
|
2013-09-22 07:51:36 +05:30
|
|
|
{
|
2014-01-28 00:47:29 +05:30
|
|
|
beginResetModel();
|
2015-01-28 03:01:07 +05:30
|
|
|
m_strategy->load();
|
2015-05-31 23:29:07 +05:30
|
|
|
reapplySafe();
|
2014-01-28 00:47:29 +05:30
|
|
|
endResetModel();
|
2013-09-22 07:51:36 +05:30
|
|
|
}
|
|
|
|
|
2015-01-28 03:01:07 +05:30
|
|
|
void MinecraftProfile::clear()
|
2013-09-22 07:51:36 +05:30
|
|
|
{
|
2014-01-24 22:42:02 +05:30
|
|
|
id.clear();
|
|
|
|
type.clear();
|
|
|
|
assets.clear();
|
|
|
|
minecraftArguments.clear();
|
|
|
|
mainClass.clear();
|
2014-05-08 22:35:07 +05:30
|
|
|
appletClass.clear();
|
2014-01-24 22:42:02 +05:30
|
|
|
libraries.clear();
|
2014-01-27 23:50:07 +05:30
|
|
|
tweakers.clear();
|
2014-04-23 05:57:40 +05:30
|
|
|
jarMods.clear();
|
|
|
|
traits.clear();
|
2013-09-22 07:51:36 +05:30
|
|
|
}
|
|
|
|
|
2015-01-28 03:01:07 +05:30
|
|
|
void MinecraftProfile::clearPatches()
|
2014-02-01 19:22:21 +05:30
|
|
|
{
|
2015-01-28 03:01:07 +05:30
|
|
|
beginResetModel();
|
|
|
|
VersionPatches.clear();
|
|
|
|
endResetModel();
|
2014-02-01 19:22:21 +05:30
|
|
|
}
|
2014-03-31 03:49:43 +05:30
|
|
|
|
2015-01-28 03:01:07 +05:30
|
|
|
void MinecraftProfile::appendPatch(ProfilePatchPtr patch)
|
2014-05-05 03:40:59 +05:30
|
|
|
{
|
2015-01-28 03:01:07 +05:30
|
|
|
int index = VersionPatches.size();
|
|
|
|
beginInsertRows(QModelIndex(), index, index);
|
|
|
|
VersionPatches.append(patch);
|
|
|
|
endInsertRows();
|
2014-05-05 03:40:59 +05:30
|
|
|
}
|
|
|
|
|
2015-01-28 03:01:07 +05:30
|
|
|
bool MinecraftProfile::remove(const int index)
|
2014-03-15 00:21:56 +05:30
|
|
|
{
|
2015-05-18 03:08:28 +05:30
|
|
|
auto patch = versionPatch(index);
|
|
|
|
if (!patch->isRemovable())
|
2015-04-14 02:56:52 +05:30
|
|
|
{
|
2016-03-13 04:53:45 +05:30
|
|
|
qDebug() << "Patch" << patch->getID() << "is non-removable";
|
2014-05-05 03:40:59 +05:30
|
|
|
return false;
|
2015-04-14 02:56:52 +05:30
|
|
|
}
|
2015-01-28 03:01:07 +05:30
|
|
|
|
2015-05-18 03:08:28 +05:30
|
|
|
if(!m_strategy->removePatch(patch))
|
2014-03-15 00:21:56 +05:30
|
|
|
{
|
2016-03-13 04:53:45 +05:30
|
|
|
qCritical() << "Patch" << patch->getID() << "could not be removed";
|
2014-05-05 03:40:59 +05:30
|
|
|
return false;
|
2014-03-15 00:21:56 +05:30
|
|
|
}
|
2015-01-28 03:01:07 +05:30
|
|
|
|
2014-05-20 04:47:54 +05:30
|
|
|
beginRemoveRows(QModelIndex(), index, index);
|
2014-05-10 05:23:32 +05:30
|
|
|
VersionPatches.removeAt(index);
|
2014-05-20 04:47:54 +05:30
|
|
|
endRemoveRows();
|
2015-05-31 23:29:07 +05:30
|
|
|
reapplySafe();
|
2014-05-20 04:47:54 +05:30
|
|
|
saveCurrentOrder();
|
2014-05-05 03:40:59 +05:30
|
|
|
return true;
|
2014-03-15 00:21:56 +05:30
|
|
|
}
|
2014-02-01 19:22:21 +05:30
|
|
|
|
2015-01-28 03:01:07 +05:30
|
|
|
bool MinecraftProfile::remove(const QString id)
|
2014-03-31 03:49:43 +05:30
|
|
|
{
|
|
|
|
int i = 0;
|
2014-05-10 05:23:32 +05:30
|
|
|
for (auto patch : VersionPatches)
|
2014-03-31 03:49:43 +05:30
|
|
|
{
|
2016-03-13 04:53:45 +05:30
|
|
|
if (patch->getID() == id)
|
2014-03-31 03:49:43 +05:30
|
|
|
{
|
|
|
|
return remove(i);
|
|
|
|
}
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2015-05-18 03:08:28 +05:30
|
|
|
bool MinecraftProfile::customize(int index)
|
|
|
|
{
|
|
|
|
auto patch = versionPatch(index);
|
|
|
|
if (!patch->isCustomizable())
|
|
|
|
{
|
2016-03-13 04:53:45 +05:30
|
|
|
qDebug() << "Patch" << patch->getID() << "is not customizable";
|
2015-05-18 03:08:28 +05:30
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if(!m_strategy->customizePatch(patch))
|
|
|
|
{
|
2016-03-13 04:53:45 +05:30
|
|
|
qCritical() << "Patch" << patch->getID() << "could not be customized";
|
2015-05-18 03:08:28 +05:30
|
|
|
return false;
|
|
|
|
}
|
2015-05-31 23:29:07 +05:30
|
|
|
reapplySafe();
|
2015-05-18 03:08:28 +05:30
|
|
|
saveCurrentOrder();
|
|
|
|
// FIXME: maybe later in unstable
|
|
|
|
// emit dataChanged(createIndex(index, 0), createIndex(index, columnCount(QModelIndex()) - 1));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-09-26 07:34:09 +05:30
|
|
|
bool MinecraftProfile::revertToBase(int index)
|
2015-05-18 03:08:28 +05:30
|
|
|
{
|
|
|
|
auto patch = versionPatch(index);
|
|
|
|
if (!patch->isRevertible())
|
|
|
|
{
|
2016-03-13 04:53:45 +05:30
|
|
|
qDebug() << "Patch" << patch->getID() << "is not revertible";
|
2015-05-18 03:08:28 +05:30
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if(!m_strategy->revertPatch(patch))
|
|
|
|
{
|
2016-03-13 04:53:45 +05:30
|
|
|
qCritical() << "Patch" << patch->getID() << "could not be reverted";
|
2015-05-18 03:08:28 +05:30
|
|
|
return false;
|
|
|
|
}
|
2015-05-31 23:29:07 +05:30
|
|
|
reapplySafe();
|
2015-05-18 03:08:28 +05:30
|
|
|
saveCurrentOrder();
|
|
|
|
// FIXME: maybe later in unstable
|
|
|
|
// emit dataChanged(createIndex(index, 0), createIndex(index, columnCount(QModelIndex()) - 1));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-01-28 03:01:07 +05:30
|
|
|
QString MinecraftProfile::versionFileId(const int index) const
|
2014-02-08 21:52:26 +05:30
|
|
|
{
|
2014-05-10 05:23:32 +05:30
|
|
|
if (index < 0 || index >= VersionPatches.size())
|
2014-02-08 21:52:26 +05:30
|
|
|
{
|
|
|
|
return QString();
|
|
|
|
}
|
2016-03-13 04:53:45 +05:30
|
|
|
return VersionPatches.at(index)->getID();
|
2014-02-08 21:52:26 +05:30
|
|
|
}
|
2014-03-31 03:49:43 +05:30
|
|
|
|
2015-01-28 03:01:07 +05:30
|
|
|
ProfilePatchPtr MinecraftProfile::versionPatch(const QString &id)
|
2014-02-01 19:22:21 +05:30
|
|
|
{
|
2014-05-10 05:23:32 +05:30
|
|
|
for (auto file : VersionPatches)
|
2014-02-01 19:22:21 +05:30
|
|
|
{
|
2016-03-13 04:53:45 +05:30
|
|
|
if (file->getID() == id)
|
2014-03-15 00:21:56 +05:30
|
|
|
{
|
|
|
|
return file;
|
|
|
|
}
|
2014-02-01 19:22:21 +05:30
|
|
|
}
|
2015-05-18 03:08:28 +05:30
|
|
|
return nullptr;
|
2014-02-01 19:22:21 +05:30
|
|
|
}
|
|
|
|
|
2015-01-28 03:01:07 +05:30
|
|
|
ProfilePatchPtr MinecraftProfile::versionPatch(int index)
|
2014-05-10 05:23:32 +05:30
|
|
|
{
|
|
|
|
if(index < 0 || index >= VersionPatches.size())
|
2015-05-18 03:08:28 +05:30
|
|
|
return nullptr;
|
2014-05-10 05:23:32 +05:30
|
|
|
return VersionPatches[index];
|
|
|
|
}
|
|
|
|
|
2015-01-28 03:01:07 +05:30
|
|
|
bool MinecraftProfile::isVanilla()
|
2014-03-31 03:49:43 +05:30
|
|
|
{
|
2014-08-11 05:47:48 +05:30
|
|
|
for(auto patchptr: VersionPatches)
|
|
|
|
{
|
|
|
|
if(patchptr->isCustom())
|
|
|
|
return false;
|
|
|
|
}
|
2014-05-05 03:40:59 +05:30
|
|
|
return true;
|
2014-04-23 05:57:40 +05:30
|
|
|
}
|
|
|
|
|
2015-01-28 03:01:07 +05:30
|
|
|
bool MinecraftProfile::revertToVanilla()
|
2014-04-23 05:57:40 +05:30
|
|
|
{
|
2014-06-09 00:56:48 +05:30
|
|
|
// remove patches, if present
|
2015-05-18 03:08:28 +05:30
|
|
|
auto VersionPatchesCopy = VersionPatches;
|
|
|
|
for(auto & it: VersionPatchesCopy)
|
2014-04-23 05:57:40 +05:30
|
|
|
{
|
2015-05-18 03:08:28 +05:30
|
|
|
if (!it->isCustom())
|
2014-04-23 05:57:40 +05:30
|
|
|
{
|
2015-05-18 03:08:28 +05:30
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if(it->isRevertible() || it->isRemovable())
|
|
|
|
{
|
2016-03-13 04:53:45 +05:30
|
|
|
if(!remove(it->getID()))
|
2014-05-05 03:40:59 +05:30
|
|
|
{
|
2016-03-13 04:53:45 +05:30
|
|
|
qWarning() << "Couldn't remove" << it->getID() << "from profile!";
|
2015-05-31 23:29:07 +05:30
|
|
|
reapplySafe();
|
2014-05-20 04:47:54 +05:30
|
|
|
saveCurrentOrder();
|
2014-05-05 03:40:59 +05:30
|
|
|
return false;
|
|
|
|
}
|
2014-04-23 05:57:40 +05:30
|
|
|
}
|
|
|
|
}
|
2015-05-31 23:29:07 +05:30
|
|
|
reapplySafe();
|
2014-05-20 04:47:54 +05:30
|
|
|
saveCurrentOrder();
|
2014-04-23 05:57:40 +05:30
|
|
|
return true;
|
2014-06-09 00:56:48 +05:30
|
|
|
}
|
|
|
|
|
2016-03-13 04:53:45 +05:30
|
|
|
QList<std::shared_ptr<Library> > MinecraftProfile::getActiveNormalLibs() const
|
2013-09-22 07:51:36 +05:30
|
|
|
{
|
2016-03-07 06:31:28 +05:30
|
|
|
QList<std::shared_ptr<Library> > output;
|
2013-09-22 07:51:36 +05:30
|
|
|
for (auto lib : libraries)
|
2013-07-29 04:29:35 +05:30
|
|
|
{
|
2013-08-05 06:59:50 +05:30
|
|
|
if (lib->isActive() && !lib->isNative())
|
2013-07-29 04:29:35 +05:30
|
|
|
{
|
2014-09-06 21:46:56 +05:30
|
|
|
for (auto other : output)
|
|
|
|
{
|
|
|
|
if (other->rawName() == lib->rawName())
|
|
|
|
{
|
2015-02-02 06:44:14 +05:30
|
|
|
qWarning() << "Multiple libraries with name" << lib->rawName() << "in library list!";
|
2014-09-06 21:46:56 +05:30
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
2013-07-29 04:29:35 +05:30
|
|
|
output.append(lib);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return output;
|
|
|
|
}
|
2015-01-28 03:01:07 +05:30
|
|
|
|
2016-03-13 04:53:45 +05:30
|
|
|
QList<std::shared_ptr<Library> > MinecraftProfile::getActiveNativeLibs() const
|
2013-07-29 04:29:35 +05:30
|
|
|
{
|
2016-03-07 06:31:28 +05:30
|
|
|
QList<std::shared_ptr<Library> > output;
|
2013-09-22 07:51:36 +05:30
|
|
|
for (auto lib : libraries)
|
2013-07-29 04:29:35 +05:30
|
|
|
{
|
2013-08-05 06:59:50 +05:30
|
|
|
if (lib->isActive() && lib->isNative())
|
2013-07-29 04:29:35 +05:30
|
|
|
{
|
|
|
|
output.append(lib);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return output;
|
|
|
|
}
|
2013-08-05 06:59:50 +05:30
|
|
|
|
2015-01-28 03:01:07 +05:30
|
|
|
QVariant MinecraftProfile::data(const QModelIndex &index, int role) const
|
2013-09-16 04:24:39 +05:30
|
|
|
{
|
2013-09-22 07:51:36 +05:30
|
|
|
if (!index.isValid())
|
2013-09-16 04:24:39 +05:30
|
|
|
return QVariant();
|
2013-09-22 07:51:36 +05:30
|
|
|
|
2013-09-16 04:24:39 +05:30
|
|
|
int row = index.row();
|
|
|
|
int column = index.column();
|
2013-09-22 07:51:36 +05:30
|
|
|
|
2014-05-10 05:23:32 +05:30
|
|
|
if (row < 0 || row >= VersionPatches.size())
|
2013-09-16 04:24:39 +05:30
|
|
|
return QVariant();
|
2013-09-22 07:51:36 +05:30
|
|
|
|
2016-02-21 06:14:27 +05:30
|
|
|
auto patch = VersionPatches.at(row);
|
|
|
|
|
2013-09-22 07:51:36 +05:30
|
|
|
if (role == Qt::DisplayRole)
|
2013-09-16 04:24:39 +05:30
|
|
|
{
|
2014-02-01 19:22:21 +05:30
|
|
|
switch (column)
|
|
|
|
{
|
|
|
|
case 0:
|
2016-03-13 04:53:45 +05:30
|
|
|
return VersionPatches.at(row)->getName();
|
2014-02-01 19:22:21 +05:30
|
|
|
case 1:
|
2015-05-15 04:40:08 +05:30
|
|
|
{
|
|
|
|
if(patch->isCustom())
|
|
|
|
{
|
2016-03-13 04:53:45 +05:30
|
|
|
return QString("%1 (Custom)").arg(patch->getVersion());
|
2015-05-15 04:40:08 +05:30
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2016-03-13 04:53:45 +05:30
|
|
|
return patch->getVersion();
|
2015-05-15 04:40:08 +05:30
|
|
|
}
|
|
|
|
}
|
2014-02-01 19:22:21 +05:30
|
|
|
default:
|
|
|
|
return QVariant();
|
|
|
|
}
|
|
|
|
}
|
2016-02-21 06:14:27 +05:30
|
|
|
if(role == Qt::DecorationRole)
|
|
|
|
{
|
|
|
|
switch(column)
|
|
|
|
{
|
|
|
|
case 0:
|
|
|
|
{
|
|
|
|
auto severity = patch->getProblemSeverity();
|
|
|
|
switch (severity)
|
|
|
|
{
|
|
|
|
case PROBLEM_WARNING:
|
|
|
|
return "warning";
|
|
|
|
case PROBLEM_ERROR:
|
|
|
|
return "error";
|
|
|
|
default:
|
|
|
|
return QVariant();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
{
|
|
|
|
return QVariant();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2014-02-01 19:22:21 +05:30
|
|
|
return QVariant();
|
|
|
|
}
|
2015-01-28 03:01:07 +05:30
|
|
|
QVariant MinecraftProfile::headerData(int section, Qt::Orientation orientation, int role) const
|
2014-02-01 19:22:21 +05:30
|
|
|
{
|
|
|
|
if (orientation == Qt::Horizontal)
|
|
|
|
{
|
|
|
|
if (role == Qt::DisplayRole)
|
2013-09-16 04:24:39 +05:30
|
|
|
{
|
2014-02-01 19:22:21 +05:30
|
|
|
switch (section)
|
|
|
|
{
|
|
|
|
case 0:
|
|
|
|
return tr("Name");
|
|
|
|
case 1:
|
|
|
|
return tr("Version");
|
|
|
|
default:
|
|
|
|
return QVariant();
|
|
|
|
}
|
2013-09-16 04:24:39 +05:30
|
|
|
}
|
|
|
|
}
|
|
|
|
return QVariant();
|
|
|
|
}
|
2015-01-28 03:01:07 +05:30
|
|
|
Qt::ItemFlags MinecraftProfile::flags(const QModelIndex &index) const
|
2013-09-16 04:24:39 +05:30
|
|
|
{
|
2013-09-22 07:51:36 +05:30
|
|
|
if (!index.isValid())
|
2013-09-16 04:24:39 +05:30
|
|
|
return Qt::NoItemFlags;
|
2014-01-28 00:47:29 +05:30
|
|
|
return Qt::ItemIsSelectable | Qt::ItemIsEnabled;
|
2013-09-16 04:24:39 +05:30
|
|
|
}
|
|
|
|
|
2015-01-28 03:01:07 +05:30
|
|
|
int MinecraftProfile::rowCount(const QModelIndex &parent) const
|
2013-09-16 04:24:39 +05:30
|
|
|
{
|
2014-05-10 05:23:32 +05:30
|
|
|
return VersionPatches.size();
|
2013-09-16 04:24:39 +05:30
|
|
|
}
|
|
|
|
|
2015-01-28 03:01:07 +05:30
|
|
|
int MinecraftProfile::columnCount(const QModelIndex &parent) const
|
2013-09-16 04:24:39 +05:30
|
|
|
{
|
2014-02-01 19:22:21 +05:30
|
|
|
return 2;
|
2013-09-16 04:24:39 +05:30
|
|
|
}
|
2014-03-15 00:21:56 +05:30
|
|
|
|
2015-01-28 03:01:07 +05:30
|
|
|
void MinecraftProfile::saveCurrentOrder() const
|
2014-03-15 00:21:56 +05:30
|
|
|
{
|
2015-01-28 03:01:07 +05:30
|
|
|
ProfileUtils::PatchOrder order;
|
2014-05-19 05:52:09 +05:30
|
|
|
for(auto item: VersionPatches)
|
|
|
|
{
|
|
|
|
if(!item->isMoveable())
|
|
|
|
continue;
|
2016-03-13 04:53:45 +05:30
|
|
|
order.append(item->getID());
|
2014-05-19 05:52:09 +05:30
|
|
|
}
|
2015-01-28 03:01:07 +05:30
|
|
|
m_strategy->saveOrder(order);
|
2014-03-15 00:21:56 +05:30
|
|
|
}
|
|
|
|
|
2015-01-28 03:01:07 +05:30
|
|
|
void MinecraftProfile::move(const int index, const MoveDirection direction)
|
2014-03-15 00:21:56 +05:30
|
|
|
{
|
|
|
|
int theirIndex;
|
|
|
|
if (direction == MoveUp)
|
|
|
|
{
|
2014-05-19 05:52:09 +05:30
|
|
|
theirIndex = index - 1;
|
2014-03-15 00:21:56 +05:30
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
theirIndex = index + 1;
|
|
|
|
}
|
2015-01-28 03:01:07 +05:30
|
|
|
|
2014-05-19 05:52:09 +05:30
|
|
|
if (index < 0 || index >= VersionPatches.size())
|
|
|
|
return;
|
|
|
|
if (theirIndex >= rowCount())
|
|
|
|
theirIndex = rowCount() - 1;
|
|
|
|
if (theirIndex == -1)
|
|
|
|
theirIndex = rowCount() - 1;
|
|
|
|
if (index == theirIndex)
|
|
|
|
return;
|
|
|
|
int togap = theirIndex > index ? theirIndex + 1 : theirIndex;
|
|
|
|
|
2014-05-10 05:23:32 +05:30
|
|
|
auto from = versionPatch(index);
|
|
|
|
auto to = versionPatch(theirIndex);
|
2015-01-28 03:01:07 +05:30
|
|
|
|
2014-05-19 05:52:09 +05:30
|
|
|
if (!from || !to || !to->isMoveable() || !from->isMoveable())
|
2014-03-15 00:21:56 +05:30
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
2014-05-19 05:52:09 +05:30
|
|
|
beginMoveRows(QModelIndex(), index, index, QModelIndex(), togap);
|
2014-05-10 05:23:32 +05:30
|
|
|
VersionPatches.swap(index, theirIndex);
|
2014-03-15 00:21:56 +05:30
|
|
|
endMoveRows();
|
2015-05-31 23:29:07 +05:30
|
|
|
reapplySafe();
|
2014-05-20 04:47:54 +05:30
|
|
|
saveCurrentOrder();
|
2014-03-15 00:21:56 +05:30
|
|
|
}
|
2015-01-28 03:01:07 +05:30
|
|
|
void MinecraftProfile::resetOrder()
|
2014-03-15 00:21:56 +05:30
|
|
|
{
|
2015-01-28 03:01:07 +05:30
|
|
|
m_strategy->resetOrder();
|
|
|
|
reload();
|
2014-03-15 00:21:56 +05:30
|
|
|
}
|
|
|
|
|
2015-01-28 03:01:07 +05:30
|
|
|
void MinecraftProfile::reapply()
|
2014-03-15 00:21:56 +05:30
|
|
|
{
|
|
|
|
clear();
|
2014-05-19 05:52:09 +05:30
|
|
|
for(auto file: VersionPatches)
|
2014-03-15 00:21:56 +05:30
|
|
|
{
|
|
|
|
file->applyTo(this);
|
|
|
|
}
|
|
|
|
}
|
2014-03-20 03:53:59 +05:30
|
|
|
|
2015-05-31 23:29:07 +05:30
|
|
|
bool MinecraftProfile::reapplySafe()
|
|
|
|
{
|
|
|
|
try
|
|
|
|
{
|
|
|
|
reapply();
|
|
|
|
}
|
2015-05-28 23:08:29 +05:30
|
|
|
catch (Exception & error)
|
2015-05-31 23:29:07 +05:30
|
|
|
{
|
|
|
|
clear();
|
|
|
|
qWarning() << "Couldn't apply profile patches because: " << error.cause();
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-03-13 04:53:45 +05:30
|
|
|
static void applyString(const QString & from, QString & to)
|
2014-03-20 03:53:59 +05:30
|
|
|
{
|
2016-03-13 04:53:45 +05:30
|
|
|
if(from.isEmpty())
|
|
|
|
return;
|
|
|
|
to = from;
|
|
|
|
}
|
|
|
|
|
|
|
|
void MinecraftProfile::applyMinecraftVersion(const QString& id)
|
|
|
|
{
|
|
|
|
applyString(id, this->id);
|
|
|
|
}
|
|
|
|
|
|
|
|
void MinecraftProfile::applyAppletClass(const QString& appletClass)
|
|
|
|
{
|
|
|
|
applyString(appletClass, this->appletClass);
|
|
|
|
}
|
|
|
|
|
|
|
|
void MinecraftProfile::applyMainClass(const QString& mainClass)
|
|
|
|
{
|
|
|
|
applyString(mainClass, this->mainClass);
|
|
|
|
}
|
|
|
|
|
|
|
|
void MinecraftProfile::applyMinecraftArguments(const QString& minecraftArguments, bool isMinecraft)
|
|
|
|
{
|
|
|
|
applyString(minecraftArguments, this->minecraftArguments);
|
|
|
|
if(isMinecraft)
|
2014-04-02 02:03:15 +05:30
|
|
|
{
|
2016-03-13 04:53:45 +05:30
|
|
|
applyString(minecraftArguments, this->vanillaMinecraftArguments);
|
2014-04-02 02:03:15 +05:30
|
|
|
}
|
2016-03-13 04:53:45 +05:30
|
|
|
}
|
|
|
|
|
|
|
|
void MinecraftProfile::applyMinecraftVersionType(const QString& type)
|
|
|
|
{
|
|
|
|
applyString(type, this->type);
|
|
|
|
}
|
|
|
|
|
|
|
|
void MinecraftProfile::applyMinecraftAssets(const QString& assets)
|
|
|
|
{
|
|
|
|
applyString(assets, this->assets);
|
|
|
|
}
|
|
|
|
|
|
|
|
void MinecraftProfile::applyTraits(const QSet<QString>& traits)
|
|
|
|
{
|
|
|
|
this->traits.unite(traits);
|
|
|
|
}
|
|
|
|
|
|
|
|
void MinecraftProfile::applyTweakers(const QStringList& tweakers)
|
|
|
|
{
|
|
|
|
// FIXME: check for dupes?
|
|
|
|
// FIXME: does order matter?
|
|
|
|
for (auto tweaker : tweakers)
|
2014-03-20 03:53:59 +05:30
|
|
|
{
|
2016-03-13 04:53:45 +05:30
|
|
|
this->tweakers += tweaker;
|
2014-03-20 03:53:59 +05:30
|
|
|
}
|
2016-03-13 04:53:45 +05:30
|
|
|
}
|
|
|
|
|
|
|
|
void MinecraftProfile::applyJarMods(const QList<JarmodPtr>& jarMods)
|
|
|
|
{
|
|
|
|
this->jarMods.append(jarMods);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int findLibraryByName(QList<LibraryPtr> haystack, const GradleSpecifier &needle)
|
|
|
|
{
|
|
|
|
int retval = -1;
|
|
|
|
for (int i = 0; i < haystack.size(); ++i)
|
2014-03-20 03:53:59 +05:30
|
|
|
{
|
2016-03-13 04:53:45 +05:30
|
|
|
if (haystack.at(i)->rawName().matchName(needle))
|
2014-03-20 03:53:59 +05:30
|
|
|
{
|
2016-03-13 04:53:45 +05:30
|
|
|
// only one is allowed.
|
|
|
|
if (retval != -1)
|
|
|
|
return -1;
|
|
|
|
retval = i;
|
2014-03-20 03:53:59 +05:30
|
|
|
}
|
2016-03-13 04:53:45 +05:30
|
|
|
}
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
void MinecraftProfile::applyLibrary(LibraryPtr library, bool isMinecraft)
|
|
|
|
{
|
|
|
|
auto insert = [&](QList<LibraryPtr> & into)
|
|
|
|
{
|
|
|
|
// find the library by name.
|
|
|
|
const int index = findLibraryByName(into, library->rawName());
|
|
|
|
// library not found? just add it.
|
|
|
|
if (index < 0)
|
2014-03-20 03:53:59 +05:30
|
|
|
{
|
2016-03-13 04:53:45 +05:30
|
|
|
into.append(Library::limitedCopy(library));
|
|
|
|
return;
|
2014-03-20 03:53:59 +05:30
|
|
|
}
|
2016-03-13 04:53:45 +05:30
|
|
|
auto existingLibrary = into.at(index);
|
|
|
|
// if we are higher it means we should update
|
|
|
|
if (Version(library->version()) > Version(existingLibrary->version()))
|
2014-03-20 03:53:59 +05:30
|
|
|
{
|
2016-03-13 04:53:45 +05:30
|
|
|
auto libraryCopy = Library::limitedCopy(library);
|
|
|
|
into.replace(index, libraryCopy);
|
2014-03-20 03:53:59 +05:30
|
|
|
}
|
2014-04-23 05:57:40 +05:30
|
|
|
};
|
2016-03-13 04:53:45 +05:30
|
|
|
insert(libraries);
|
|
|
|
if(isMinecraft)
|
|
|
|
{
|
|
|
|
insert(vanillaLibraries);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QString MinecraftProfile::getMinecraftVersion() const
|
|
|
|
{
|
|
|
|
return id;
|
|
|
|
}
|
|
|
|
|
|
|
|
QString MinecraftProfile::getAppletClass() const
|
|
|
|
{
|
|
|
|
return appletClass;
|
|
|
|
}
|
|
|
|
|
|
|
|
QString MinecraftProfile::getMainClass() const
|
|
|
|
{
|
|
|
|
return mainClass;
|
|
|
|
}
|
|
|
|
|
|
|
|
const QSet<QString> &MinecraftProfile::getTraits() const
|
|
|
|
{
|
|
|
|
return traits;
|
|
|
|
}
|
|
|
|
|
|
|
|
const QStringList & MinecraftProfile::getTweakers() const
|
|
|
|
{
|
|
|
|
return tweakers;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool MinecraftProfile::hasTrait(const QString& trait) const
|
|
|
|
{
|
|
|
|
return traits.contains(trait);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QString MinecraftProfile::getMinecraftVersionType() const
|
|
|
|
{
|
|
|
|
return type;
|
|
|
|
}
|
|
|
|
|
|
|
|
QString MinecraftProfile::getMinecraftAssets() const
|
|
|
|
{
|
|
|
|
// HACK: deny april fools. my head hurts enough already.
|
|
|
|
QDate now = QDate::currentDate();
|
|
|
|
bool isAprilFools = now.month() == 4 && now.day() == 1;
|
|
|
|
if (assets.endsWith("_af") && !isAprilFools)
|
|
|
|
{
|
|
|
|
return assets.left(assets.length() - 3);
|
|
|
|
}
|
|
|
|
if (assets.isEmpty())
|
|
|
|
{
|
|
|
|
return QLatin1Literal("legacy");
|
|
|
|
}
|
|
|
|
return assets;
|
|
|
|
}
|
|
|
|
|
|
|
|
QString MinecraftProfile::getMinecraftArguments() const
|
|
|
|
{
|
|
|
|
return minecraftArguments;
|
|
|
|
}
|
|
|
|
|
|
|
|
QString MinecraftProfile::getVanillaMinecraftArguments() const
|
|
|
|
{
|
|
|
|
return vanillaMinecraftArguments;
|
|
|
|
}
|
|
|
|
|
|
|
|
const QList<JarmodPtr> & MinecraftProfile::getJarMods() const
|
|
|
|
{
|
|
|
|
return jarMods;
|
|
|
|
}
|
|
|
|
|
|
|
|
const QList<LibraryPtr> & MinecraftProfile::getLibraries() const
|
|
|
|
{
|
|
|
|
return libraries;
|
|
|
|
}
|
|
|
|
|
|
|
|
const QList<LibraryPtr> & MinecraftProfile::getVanillaLibraries() const
|
|
|
|
{
|
|
|
|
return vanillaLibraries;
|
2014-03-20 03:53:59 +05:30
|
|
|
}
|
2014-04-23 05:57:40 +05:30
|
|
|
|
2015-01-28 03:01:07 +05:30
|
|
|
void MinecraftProfile::installJarMods(QStringList selectedFiles)
|
2014-05-19 05:52:09 +05:30
|
|
|
{
|
2015-01-28 03:01:07 +05:30
|
|
|
m_strategy->installJarMods(selectedFiles);
|
2014-05-19 05:52:09 +05:30
|
|
|
}
|
|
|
|
|
2015-01-28 03:01:07 +05:30
|
|
|
/*
|
|
|
|
* TODO: get rid of this. Get rid of all order numbers.
|
|
|
|
*/
|
|
|
|
int MinecraftProfile::getFreeOrderNumber()
|
2014-05-19 05:52:09 +05:30
|
|
|
{
|
|
|
|
int largest = 100;
|
|
|
|
// yes, I do realize this is dumb. The order thing itself is dumb. and to be removed next.
|
|
|
|
for(auto thing: VersionPatches)
|
|
|
|
{
|
|
|
|
int order = thing->getOrder();
|
|
|
|
if(order > largest)
|
|
|
|
largest = order;
|
|
|
|
}
|
|
|
|
return largest + 1;
|
|
|
|
}
|