mirror of
https://github.com/RPCSX/rpcsx.git
synced 2025-12-06 07:12:14 +01:00
267 lines
7.5 KiB
C++
267 lines
7.5 KiB
C++
#include "core_tab.h"
|
|
|
|
#include "stdafx.h"
|
|
#include "Emu/System.h"
|
|
#include "Crypto/unself.h"
|
|
|
|
#include "rpcs3qt/emu_settings.h"
|
|
|
|
#include <QCheckBox>
|
|
#include <QGroupBox>
|
|
#include <QRadioButton>
|
|
#include <QButtonGroup>
|
|
#include <QVBoxLayout>
|
|
#include <QHBoxLayout>
|
|
|
|
#include <unordered_set>
|
|
|
|
inline std::string sstr(const QString& _in) { return _in.toUtf8().toStdString(); }
|
|
|
|
core_tab::core_tab(std::shared_ptr<emu_settings> settings, QWidget *parent) : QWidget(parent), xemu_settings(settings)
|
|
{
|
|
// PPU Decoder
|
|
QGroupBox *ppuDecoder = new QGroupBox(tr("PPU Decoder"));
|
|
QVBoxLayout *ppuVbox = new QVBoxLayout;
|
|
|
|
{ // PPU Stuff : I could make a lambda/special getter in emu_settings, but it's only used three times like this, and two times they're done slighly differently (one setting is disabled).
|
|
std::string selectedPPU = settings->GetSetting(emu_settings::PPUDecoder);
|
|
for (QString settingType : settings->GetSettingOptions(emu_settings::PPUDecoder))
|
|
{
|
|
std::string curr = sstr(settingType);
|
|
QRadioButton* butt = new QRadioButton(tr(curr.c_str()), this);
|
|
butt->setCheckable(true);
|
|
ppuVbox->addWidget(butt);
|
|
if (curr == selectedPPU)
|
|
{
|
|
butt->setChecked(true);
|
|
}
|
|
#ifndef LLVM_AVAILABLE
|
|
if (curr == "Recompiler (LLVM)")
|
|
{
|
|
butt->setEnabled(false);
|
|
butt->setToolTip(tr("This version of RPCS3 wasn't compiled with LLVM support."));
|
|
}
|
|
#endif
|
|
connect(butt, &QAbstractButton::pressed, [=]() {settings->SetSetting(emu_settings::PPUDecoder, curr); });
|
|
}
|
|
}
|
|
ppuDecoder->setLayout(ppuVbox);
|
|
|
|
// SPU Decoder
|
|
QGroupBox *spuDecoder = new QGroupBox(tr("SPU Decoder"));
|
|
QVBoxLayout *spuVbox = new QVBoxLayout;
|
|
|
|
{ // Spu stuff
|
|
std::string selectedSPU = settings->GetSetting(emu_settings::SPUDecoder);
|
|
for (QString settingType : settings->GetSettingOptions(emu_settings::SPUDecoder))
|
|
{
|
|
std::string curr = sstr(settingType);
|
|
QRadioButton* butt = new QRadioButton(tr(curr.c_str()), this);
|
|
if (curr == "Recompiler (LLVM)")
|
|
{
|
|
butt->setEnabled(false);
|
|
}
|
|
butt->setCheckable(true);
|
|
spuVbox->addWidget(butt);
|
|
if (curr == selectedSPU)
|
|
{
|
|
butt->setChecked(true);
|
|
}
|
|
connect(butt, &QAbstractButton::pressed, [=]() {settings->SetSetting(emu_settings::SPUDecoder, curr); });
|
|
}
|
|
}
|
|
spuDecoder->setLayout(spuVbox);
|
|
|
|
// Checkboxes
|
|
QCheckBox *hookStFunc = settings->CreateEnhancedCheckBox(emu_settings::HookStaticFuncs, this);
|
|
QCheckBox *bindSPUThreads = settings->CreateEnhancedCheckBox(emu_settings::BindSPUThreads, this);
|
|
QCheckBox *lowerSPUThrPrio = settings->CreateEnhancedCheckBox(emu_settings::LowerSPUThreadPrio, this);
|
|
|
|
// Load libraries
|
|
QGroupBox *lle = new QGroupBox(tr("Load libraries"));
|
|
QButtonGroup *libModeBG = new QButtonGroup(this);
|
|
QVBoxLayout *lleVbox = new QVBoxLayout;
|
|
|
|
|
|
{// Handle lib loading options
|
|
std::string selectedLib = settings->GetSetting(emu_settings::LibLoadOptions);
|
|
for (QString settingType : settings->GetSettingOptions(emu_settings::LibLoadOptions))
|
|
{
|
|
std::string curr = sstr(settingType);
|
|
QRadioButton* butt = new QRadioButton(tr(curr.c_str()), lle);
|
|
butt->setCheckable(true);
|
|
libModeBG->addButton(butt);
|
|
lleVbox->addWidget(butt);
|
|
if (curr == selectedLib)
|
|
{
|
|
butt->setChecked(true);
|
|
}
|
|
connect(butt, &QAbstractButton::pressed, [=]() {settings->SetSetting(emu_settings::LibLoadOptions, curr); });
|
|
}
|
|
}
|
|
lleList = new QListWidget;
|
|
lleList->setSelectionMode(QAbstractItemView::MultiSelection);
|
|
searchBox = new QLineEdit;
|
|
|
|
// Sort string vector alphabetically
|
|
static const auto sort_string_vector = [](std::vector<std::string>& vec)
|
|
{
|
|
std::sort(vec.begin(), vec.end(), [](const std::string &str1, const std::string &str2) { return str1 < str2; });
|
|
};
|
|
|
|
std::vector<std::string> loadedLibs = xemu_settings->GetLoadedLibraries();
|
|
|
|
sort_string_vector(loadedLibs);
|
|
|
|
for (auto lib : loadedLibs)
|
|
{
|
|
QListWidgetItem* item = new QListWidgetItem(qstr(lib), lleList);
|
|
item->setFlags(item->flags() | Qt::ItemIsUserCheckable); // set checkable flag
|
|
item->setCheckState(Qt::Checked); // AND initialize check state
|
|
lleList->addItem(item);
|
|
}
|
|
const std::string& lle_dir = Emu.GetLibDir(); // TODO
|
|
|
|
std::unordered_set<std::string> set(loadedLibs.begin(), loadedLibs.end());
|
|
std::vector<std::string> lle_module_list_unselected;
|
|
|
|
for (const auto& prxf : fs::dir(lle_dir))
|
|
{
|
|
// List found unselected modules
|
|
if (prxf.is_directory || (prxf.name.substr(std::max<size_t>(size_t(3), prxf.name.length()) - 3)) != "prx")
|
|
continue;
|
|
if (verify_npdrm_self_headers(fs::file(lle_dir + prxf.name)) && !set.count(prxf.name))
|
|
{
|
|
lle_module_list_unselected.push_back(prxf.name);
|
|
}
|
|
|
|
}
|
|
|
|
sort_string_vector(lle_module_list_unselected);
|
|
|
|
for (auto lib : lle_module_list_unselected)
|
|
{
|
|
QListWidgetItem* item = new QListWidgetItem(qstr(lib), lleList);
|
|
item->setFlags(item->flags() | Qt::ItemIsUserCheckable); // set checkable flag
|
|
item->setCheckState(Qt::Unchecked); // AND initialize check state
|
|
lleList->addItem(item);
|
|
}
|
|
|
|
|
|
// lleVbox
|
|
lleVbox->addSpacing(5);
|
|
lleVbox->addWidget(lleList);
|
|
lleVbox->addWidget(searchBox);
|
|
lle->setLayout(lleVbox);
|
|
|
|
// Main layout
|
|
QVBoxLayout *vbox = new QVBoxLayout;
|
|
vbox->addWidget(ppuDecoder);
|
|
vbox->addWidget(spuDecoder);
|
|
vbox->addWidget(hookStFunc);
|
|
vbox->addWidget(bindSPUThreads);
|
|
vbox->addWidget(lowerSPUThrPrio);
|
|
vbox->addStretch();
|
|
|
|
QHBoxLayout *hbox = new QHBoxLayout;
|
|
hbox->addLayout(vbox);
|
|
hbox->addWidget(lle);
|
|
setLayout(hbox);
|
|
|
|
auto l_OnLibButtonClicked = [=](int ind)
|
|
{
|
|
if (ind == -3 || ind == -4)
|
|
{
|
|
shouldSaveLibs = true;
|
|
searchBox->setEnabled(true);
|
|
lleList->setEnabled(true);
|
|
}
|
|
else
|
|
{
|
|
shouldSaveLibs = false;
|
|
searchBox->setEnabled(false);
|
|
lleList->setEnabled(false);
|
|
}
|
|
};
|
|
|
|
auto l_OnSearchBoxTextChanged = [=](QString text)
|
|
{
|
|
QString searchTerm = text.toLower();
|
|
QList<QListWidgetItem*> checked_Libs;
|
|
QList<QListWidgetItem*> unchecked_Libs;
|
|
|
|
// create sublists. we need clones to preserve checkstates
|
|
for (int i = 0; i < lleList->count(); ++i)
|
|
{
|
|
if (lleList->item(i)->checkState() == Qt::Checked)
|
|
{
|
|
checked_Libs.append(lleList->item(i)->clone());
|
|
}
|
|
else
|
|
{
|
|
unchecked_Libs.append(lleList->item(i)->clone());
|
|
}
|
|
}
|
|
|
|
// sort sublists
|
|
auto qLessThan = [](QListWidgetItem *i1, QListWidgetItem *i2) { return i1->text() < i2->text(); };
|
|
qSort(checked_Libs.begin(), checked_Libs.end(), qLessThan);
|
|
qSort(unchecked_Libs.begin(), unchecked_Libs.end(), qLessThan);
|
|
|
|
// refill library list
|
|
lleList->clear();
|
|
|
|
for (auto lib : checked_Libs)
|
|
{
|
|
lleList->addItem(lib);
|
|
}
|
|
for (auto lib : unchecked_Libs)
|
|
{
|
|
lleList->addItem(lib);
|
|
}
|
|
|
|
// only show items filtered for search text
|
|
for (int i = 0; i < lleList->count(); i++)
|
|
{
|
|
if (lleList->item(i)->text().contains(searchTerm))
|
|
{
|
|
lleList->setRowHidden(i, false);
|
|
}
|
|
else
|
|
{
|
|
lleList->setRowHidden(i, true);
|
|
}
|
|
}
|
|
};
|
|
|
|
// Events
|
|
connect(libModeBG, static_cast<void(QButtonGroup::*)(int)>(&QButtonGroup::buttonClicked), l_OnLibButtonClicked);
|
|
connect(searchBox, &QLineEdit::textChanged, l_OnSearchBoxTextChanged);
|
|
|
|
int buttid = libModeBG->checkedId();
|
|
if (buttid != -1)
|
|
{
|
|
l_OnLibButtonClicked(buttid);
|
|
}
|
|
}
|
|
|
|
void core_tab::SaveSelectedLibraries()
|
|
{
|
|
if (shouldSaveLibs)
|
|
{
|
|
std::set<std::string> selectedlle;
|
|
for (int i =0; i<lleList->count(); ++i)
|
|
{
|
|
auto item = lleList->item(i);
|
|
if (item->checkState() != Qt::CheckState::Unchecked)
|
|
{
|
|
std::string lib = sstr(item->text());
|
|
selectedlle.emplace(lib);
|
|
}
|
|
}
|
|
|
|
std::vector<std::string> selected_ls = std::vector<std::string>(selectedlle.begin(), selectedlle.end());
|
|
xemu_settings->SaveSelectedLibraries(selected_ls);
|
|
}
|
|
}
|