ONIMAI-SMP/ShatteredPrism
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Cleaned some code

Browse Source 
Signed-off-by: Trial97 <alexandru.tripon97@gmail.com>
This commit is contained in:
Trial97 2024-01-31 18:07:28 +02:00
parent 5afe75e821
commit 6c5bb3817b
No known key found for this signature in database
GPG Key ID: 55EF5DA53DB36318
6 changed files with 85 additions and 162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
launcher/java/JavaRuntime.cpp
View File

@ -21,6 +21,7 @@
#include <memory>
#include "Json.h"
#include "StringUtils.h"
#include "java/JavaVersion.h"
#include "minecraft/ParseUtils.h"
@ -47,7 +48,7 @@ MetaPtr parseJavaMeta(const QJsonObject& in)
{
auto meta = std::make_shared<Meta>();
meta->name = Json::ensureString(in, "name", "");
meta->m_name = Json::ensureString(in, "name", "");
meta->vendor = Json::ensureString(in, "vendor", "");
meta->url = Json::ensureString(in, "url", "");
meta->releaseTime = timeFromS3Time(Json::ensureString(in, "releaseTime", ""));
@ -72,4 +73,45 @@ MetaPtr parseJavaMeta(const QJsonObject& in)
}
return meta;
}
bool Meta::operator<(const Meta& rhs)
{
auto id = version;
if (id < rhs.version) {
return true;
}
if (id > rhs.version) {
return false;
}
return StringUtils::naturalCompare(m_name, rhs.m_name, Qt::CaseInsensitive) < 0;
}
bool Meta::operator==(const Meta& rhs)
{
return version == rhs.version && m_name == rhs.m_name;
}
bool Meta::operator>(const Meta& rhs)
{
return (!operator<(rhs)) && (!operator==(rhs));
}
bool Meta::operator<(BaseVersion& a)
{
try {
return operator<(dynamic_cast<Meta&>(a));
} catch (const std::bad_cast& e) {
return BaseVersion::operator<(a);
}
}
bool Meta::operator>(BaseVersion& a)
{
try {
return operator>(dynamic_cast<Meta&>(a));
} catch (const std::bad_cast& e) {
return BaseVersion::operator>(a);
}
}
} // namespace JavaRuntime

18
launcher/java/JavaRuntime.h
View File

@ -23,14 +23,28 @@
#include <memory>
#include "BaseVersion.h"
#include "java/JavaVersion.h"
namespace JavaRuntime {
enum class DownloadType { Manifest, Archive };
struct Meta {
QString name;
class Meta : public BaseVersion {
public:
virtual QString descriptor() override { return version.toString(); }
virtual QString name() override { return m_name; }
virtual QString typeString() const override { return vendor; }
virtual bool operator<(BaseVersion& a) override;
virtual bool operator>(BaseVersion& a) override;
bool operator<(const Meta& rhs);
bool operator==(const Meta& rhs);
bool operator>(const Meta& rhs);
QString m_name;
QString vendor;
QString url;
QDateTime releaseTime;

35
launcher/ui/java/JavaDownload.cpp
View File

@ -17,21 +17,23 @@
*/
#include "JavaDownload.h"
#include <qdialogbuttonbox.h>
#include <qlogging.h>
#include <qmessagebox.h>
#include <qpushbutton.h>
#include <QPushButton>
#include <memory>
#include "Application.h"
#include "BaseVersionList.h"
#include "FileSystem.h"
#include "QObjectPtr.h"
#include "SysInfo.h"
#include "java/JavaInstallList.h"
#include "java/JavaRuntime.h"
#include "java/download/ArchiveJavaDownloader.h"
#include "java/download/ManifestJavaDownloader.h"
#include "meta/Index.h"
#include "meta/Version.h"
#include "ui/dialogs/ProgressDialog.h"
#include "ui/java/ListModel.h"
#include "ui_JavaDownload.h"
@ -44,7 +46,6 @@ JavaDownload::JavaDownload(QWidget* parent) : QDialog(parent), ui(new Ui::JavaDo
connect(ui->widget, &VersionSelectWidget::selectedVersionChanged, this, &JavaDownload::setSelectedVersion);
auto reset = ui->buttonBox->button(QDialogButtonBox::Reset);
connect(reset, &QPushButton::clicked, this, &JavaDownload::refresh);
connect(ui->widget_2, &VersionSelectWidget::selectedVersionChanged, this, &JavaDownload::setSelectedVersion2);
}
JavaDownload::~JavaDownload()
@ -54,8 +55,6 @@ JavaDownload::~JavaDownload()
void JavaDownload::setSelectedVersion(BaseVersion::Ptr version)
{
if (!version)
return;
auto dcast = std::dynamic_pointer_cast<Meta::Version>(version);
if (!dcast) {
return;
@ -64,26 +63,14 @@ void JavaDownload::setSelectedVersion(BaseVersion::Ptr version)
ui->widget_2->selectCurrent();
}
void JavaDownload::setSelectedVersion2(BaseVersion::Ptr version)
{
if (!version)
return;
m_selectedVersion = std::dynamic_pointer_cast<Java::JavaRuntime2>(ui->widget_2->selectedVersion());
}
void JavaDownload::accept()
{
if (!m_selectedVersion) {
m_selectedVersion = std::dynamic_pointer_cast<Java::JavaRuntime2>(ui->widget_2->selectedVersion());
qDebug() << "=========?" << (ui->widget_2->selectedVersion() != nullptr);
}
if (!m_selectedVersion) {
qDebug() << "faillllllllllllllllllllllllllll";
auto meta = std::dynamic_pointer_cast<JavaRuntime::Meta>(ui->widget_2->selectedVersion());
if (!meta) {
return;
}
auto meta = m_selectedVersion->meta;
Task::Ptr task;
auto final_path = FS::PathCombine(APPLICATION->dataRoot(), "java", meta->name);
qDebug() << "===============>>=>>" << meta->checksumType << meta->checksumHash;
auto final_path = FS::PathCombine(APPLICATION->dataRoot(), "java", meta->m_name);
switch (meta->downloadType) {
case JavaRuntime::DownloadType::Manifest:
task = makeShared<ManifestJavaDownloader>(meta->url, final_path, meta->checksumType, meta->checksumHash);

3
launcher/ui/java/JavaDownload.h
View File

@ -20,7 +20,6 @@
#include <QDialog>
#include "BaseVersion.h"
#include "ui/java/ListModel.h"
namespace Ui {
class JavaDownload;
@ -40,9 +39,7 @@ class JavaDownload : public QDialog {
protected slots:
void setSelectedVersion(BaseVersion::Ptr version);
void setSelectedVersion2(BaseVersion::Ptr version);
private:
Ui::JavaDownload* ui;
Java::JavaRuntimePtr m_selectedVersion;
};

69
launcher/ui/java/ListModel.cpp
View File

@ -17,11 +17,12 @@
*/
#include "ListModel.h"
#include <qlogging.h>
#include <memory>
#include "BaseVersionList.h"
#include "StringUtils.h"
#include "SysInfo.h"
#include "java/JavaRuntime.h"
namespace Java {
@ -71,13 +72,13 @@ QVariant InstallList::data(const QModelIndex& index, int role) const
case VersionIdRole:
return version->descriptor();
case VersionRole:
return version->meta->version.toString();
return version->version.toString();
case RecommendedRole:
return version->meta->recommended;
return version->recommended;
case AliasRole:
return version->meta->name;
return version->name();
case ArchitectureRole:
return version->meta->vendor;
return version->vendor;
default:
return QVariant();
}
@ -90,8 +91,8 @@ BaseVersionList::RoleList InstallList::providesRoles() const
bool sortJavas(BaseVersion::Ptr left, BaseVersion::Ptr right)
{
auto rleft = std::dynamic_pointer_cast<JavaRuntime2>(right);
auto rright = std::dynamic_pointer_cast<JavaRuntime2>(left);
auto rleft = std::dynamic_pointer_cast<JavaRuntime::Meta>(right);
auto rright = std::dynamic_pointer_cast<JavaRuntime::Meta>(left);
return (*rleft) > (*rright);
}
@ -100,55 +101,13 @@ void InstallList::sortVersions()
QString versionStr = SysInfo::getSupportedJavaArchitecture();
beginResetModel();
auto runtimes = m_version->data()->runtimes;
if (versionStr.isEmpty() || !runtimes.contains(versionStr)) {
return;
if (!versionStr.isEmpty() && runtimes.contains(versionStr)) {
m_vlist = runtimes.value(versionStr);
std::sort(m_vlist.begin(), m_vlist.end(), sortJavas);
} else {
m_vlist = {};
}
auto javaruntimes = runtimes.value(versionStr);
for (auto v : javaruntimes) {
m_vlist.append(std::make_shared<JavaRuntime2>(v));
}
std::sort(m_vlist.begin(), m_vlist.end(), sortJavas);
endResetModel();
}
bool JavaRuntime2::operator<(const JavaRuntime2& rhs)
{
auto id = meta->version;
if (id < rhs.meta->version) {
return true;
}
if (id > rhs.meta->version) {
return false;
}
return StringUtils::naturalCompare(meta->name, rhs.meta->name, Qt::CaseInsensitive) < 0;
}
bool JavaRuntime2::operator==(const JavaRuntime2& rhs)
{
return meta->version == rhs.meta->version && meta->name == rhs.meta->name;
}
bool JavaRuntime2::operator>(const JavaRuntime2& rhs)
{
return (!operator<(rhs)) && (!operator==(rhs));
}
bool JavaRuntime2::operator<(BaseVersion& a)
{
try {
return operator<(dynamic_cast<JavaRuntime2&>(a));
} catch (const std::bad_cast& e) {
return BaseVersion::operator<(a);
}
}
bool JavaRuntime2::operator>(BaseVersion& a)
{
try {
return operator>(dynamic_cast<JavaRuntime2&>(a));
} catch (const std::bad_cast& e) {
return BaseVersion::operator>(a);
}
}
} // namespace Java

78
launcher/ui/java/ListModel.h
View File

@ -18,9 +18,6 @@
#pragma once
#include <qtmetamacros.h>
#include <QAbstractListModel>
#include <QSortFilterProxyModel>
#include "java/JavaRuntime.h"
#include "meta/VersionList.h"
@ -33,26 +30,6 @@ class JavaBaseVersionList : public Meta::VersionList {
BaseVersionList::RoleList providesRoles() const { return { VersionRole, RecommendedRole, VersionPointerRole }; }
};
struct JavaRuntime2 : public BaseVersion {
JavaRuntime2() {}
JavaRuntime2(JavaRuntime::MetaPtr m) : meta(m) {}
virtual QString descriptor() override { return meta->version.toString(); }
virtual QString name() override { return meta->name; }
virtual QString typeString() const override { return meta->vendor; }
virtual bool operator<(BaseVersion& a) override;
virtual bool operator>(BaseVersion& a) override;
bool operator<(const JavaRuntime2& rhs);
bool operator==(const JavaRuntime2& rhs);
bool operator>(const JavaRuntime2& rhs);
JavaRuntime::MetaPtr meta;
};
using JavaRuntimePtr = std::shared_ptr<JavaRuntime2>;
class InstallList : public BaseVersionList {
Q_OBJECT
@ -73,60 +50,7 @@ class InstallList : public BaseVersionList {
protected:
Meta::Version::Ptr m_version;
QList<JavaRuntimePtr> m_vlist;
QList<JavaRuntime::MetaPtr> m_vlist;
};
} // namespace Java
// class FilterModel : public QSortFilterProxyModel {
// Q_OBJECT
// public:
// FilterModel(QObject* parent = Q_NULLPTR);
// enum Sorting { ByName, ByGameVersion };
// const QMap<QString, Sorting> getAvailableSortings();
// QString translateCurrentSorting();
// void setSorting(Sorting sorting);
// Sorting getCurrentSorting();
// void setSearchTerm(QString term);
// protected:
// bool filterAcceptsRow(int sourceRow, const QModelIndex& sourceParent) const override;
// bool lessThan(const QModelIndex& left, const QModelIndex& right) const override;
// private:
// QMap<QString, Sorting> sortings;
// Sorting currentSorting;
// QString searchTerm;
// };
// class ListModel : public QAbstractListModel {
// Q_OBJECT
// private:
// ModpackList modpacks;
// QStringList m_failedLogos;
// QStringList m_loadingLogos;
// FTBLogoMap m_logoMap;
// QMap<QString, LogoCallback> waitingCallbacks;
// void requestLogo(QString file);
// QString translatePackType(PackType type) const;
// private slots:
// void logoFailed(QString logo);
// void logoLoaded(QString logo, QIcon out);
// public:
// ListModel(QObject* parent);
// ~ListModel();
// int rowCount(const QModelIndex& parent) const override;
// int columnCount(const QModelIndex& parent) const override;
// QVariant data(const QModelIndex& index, int role) const override;
// Qt::ItemFlags flags(const QModelIndex& index) const override;
// void fill(ModpackList modpacks);
// void addPack(Modpack modpack);
// void clear();
// void remove(int row);
// Modpack at(int row);
// void getLogo(const QString& logo, LogoCallback callback);
// };