ShuriZma
/
dolphin
mirror of https://github.com/dolphin-emu/dolphin.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Automatic disc change for 2-disc games

This commit is contained in:
JosJuice 2018-11-05 19:20:45 +01:00
parent fc68b835e7
commit bd665aad5d
19 changed files with 306 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

67
Source/Core/Core/Boot/Boot.cpp
View File

@ -54,6 +54,12 @@
#include "DiscIO/Enums.h"
#include "DiscIO/Volume.h"
std::vector<std::string> ReadM3UFile(const std::string& path)
{
// TODO
return {};
}
BootParameters::BootParameters(Parameters&& parameters_,
const std::optional<std::string>& savestate_path_)
: parameters(std::move(parameters_)), savestate_path(savestate_path_)
@ -61,40 +67,68 @@ BootParameters::BootParameters(Parameters&& parameters_,
}
std::unique_ptr<BootParameters>
BootParameters::GenerateFromFile(const std::string& path,
BootParameters::GenerateFromFile(std::string boot_path,
const std::optional<std::string>& savestate_path)
{
const bool is_drive = Common::IsCDROMDevice(path);
return GenerateFromFile(std::vector<std::string>{std::move(boot_path)}, savestate_path);
}
std::unique_ptr<BootParameters>
BootParameters::GenerateFromFile(std::vector<std::string> paths,
const std::optional<std::string>& savestate_path)
{
ASSERT(!paths.empty());
const bool is_drive = Common::IsCDROMDevice(paths.front());
// Check if the file exist, we may have gotten it from a --elf command line
// that gave an incorrect file name
if (!is_drive && !File::Exists(path))
if (!is_drive && !File::Exists(paths.front()))
{
PanicAlertT("The specified file \"%s\" does not exist", path.c_str());
PanicAlertT("The specified file \"%s\" does not exist", paths.front().c_str());
return {};
}
std::string extension;
SplitPath(path, nullptr, nullptr, &extension);
SplitPath(paths.front(), nullptr, nullptr, &extension);
std::transform(extension.begin(), extension.end(), extension.begin(), ::tolower);
if (extension == ".m3u")
{
std::vector<std::string> new_paths = ReadM3UFile(paths.front());
if (!new_paths.empty())
{
paths = new_paths;
SplitPath(paths.front(), nullptr, nullptr, &extension);
std::transform(extension.begin(), extension.end(), extension.begin(), ::tolower);
}
}
const std::string path = paths.front();
if (paths.size() == 1)
paths.clear();
static const std::unordered_set<std::string> disc_image_extensions = {
{".gcm", ".iso", ".tgc", ".wbfs", ".ciso", ".gcz", ".dol", ".elf"}};
if (disc_image_extensions.find(extension) != disc_image_extensions.end() || is_drive)
{
std::unique_ptr<DiscIO::Volume> volume = DiscIO::CreateVolumeFromFilename(path);
if (volume)
return std::make_unique<BootParameters>(Disc{path, std::move(volume)}, savestate_path);
{
return std::make_unique<BootParameters>(Disc{std::move(path), std::move(volume), paths},
savestate_path);
}
if (extension == ".elf")
{
return std::make_unique<BootParameters>(Executable{path, std::make_unique<ElfReader>(path)},
savestate_path);
return std::make_unique<BootParameters>(
Executable{std::move(path), std::make_unique<ElfReader>(path)}, savestate_path);
}
if (extension == ".dol")
{
return std::make_unique<BootParameters>(Executable{path, std::make_unique<DolReader>(path)},
savestate_path);
return std::make_unique<BootParameters>(
Executable{std::move(path), std::make_unique<DolReader>(path)}, savestate_path);
}
if (is_drive)
@ -113,10 +147,10 @@ BootParameters::GenerateFromFile(const std::string& path,
}
if (extension == ".dff")
return std::make_unique<BootParameters>(DFF{path}, savestate_path);
return std::make_unique<BootParameters>(DFF{std::move(path)}, savestate_path);
if (extension == ".wad")
return std::make_unique<BootParameters>(DiscIO::WiiWAD{path}, savestate_path);
return std::make_unique<BootParameters>(DiscIO::WiiWAD{std::move(path)}, savestate_path);
PanicAlertT("Could not recognize file %s", path.c_str());
return {};
@ -136,10 +170,11 @@ BootParameters::IPL::IPL(DiscIO::Region region_, Disc&& disc_) : IPL(region_)
// Inserts a disc into the emulated disc drive and returns a pointer to it.
// The returned pointer must only be used while we are still booting,
// because DVDThread can do whatever it wants to the disc after that.
static const DiscIO::Volume* SetDisc(std::unique_ptr<DiscIO::Volume> volume)
static const DiscIO::Volume* SetDisc(std::unique_ptr<DiscIO::Volume> volume,
std::vector<std::string> auto_disc_change_paths = {})
{
const DiscIO::Volume* pointer = volume.get();
DVDInterface::SetDisc(std::move(volume));
DVDInterface::SetDisc(std::move(volume), auto_disc_change_paths);
return pointer;
}
@ -326,7 +361,7 @@ bool CBoot::BootUp(std::unique_ptr<BootParameters> boot)
bool operator()(BootParameters::Disc& disc) const
{
NOTICE_LOG(BOOT, "Booting from disc: %s", disc.path.c_str());
const DiscIO::Volume* volume = SetDisc(std::move(disc.volume));
const DiscIO::Volume* volume = SetDisc(std::move(disc.volume), disc.auto_disc_change_paths);
if (!volume)
return false;
@ -420,7 +455,7 @@ bool CBoot::BootUp(std::unique_ptr<BootParameters> boot)
if (ipl.disc)
{
NOTICE_LOG(BOOT, "Inserting disc: %s", ipl.disc->path.c_str());
SetDisc(DiscIO::CreateVolumeFromFilename(ipl.disc->path));
SetDisc(DiscIO::CreateVolumeFromFilename(ipl.disc->path), ipl.disc->auto_disc_change_paths);
}
if (LoadMapFromFilename())

5
Source/Core/Core/Boot/Boot.h
View File

@ -40,6 +40,7 @@ struct BootParameters
{
std::string path;
std::unique_ptr<DiscIO::Volume> volume;
std::vector<std::string> auto_disc_change_paths;
};
struct Executable
@ -69,7 +70,9 @@ struct BootParameters
};
static std::unique_ptr<BootParameters>
GenerateFromFile(const std::string& boot_path,
GenerateFromFile(std::string boot_path, const std::optional<std::string>& savestate_path = {});
static std::unique_ptr<BootParameters>
GenerateFromFile(std::vector<std::string> paths,
const std::optional<std::string>& savestate_path = {});
using Parameters = std::variant<Disc, Executable, DiscIO::WiiWAD, NANDTitle, IPL, DFF>;

1
Source/Core/Core/Config/MainSettings.cpp
View File

@ -104,6 +104,7 @@ const ConfigInfo<u32> MAIN_CUSTOM_RTC_VALUE{{System::Main, "Core", "CustomRTCVal
const ConfigInfo<bool> MAIN_ENABLE_SIGNATURE_CHECKS{{System::Main, "Core", "EnableSignatureChecks"},
true};
const ConfigInfo<bool> MAIN_REDUCE_POLLING_RATE{{System::Main, "Core", "ReducePollingRate"}, false};
const ConfigInfo<bool> MAIN_AUTO_DISC_CHANGE{{System::Main, "Core", "AutoDiscChange"}, false};
// Main.DSP

1
Source/Core/Core/Config/MainSettings.h
View File

@ -78,6 +78,7 @@ extern const ConfigInfo<bool> MAIN_CUSTOM_RTC_ENABLE;
extern const ConfigInfo<u32> MAIN_CUSTOM_RTC_VALUE;
extern const ConfigInfo<bool> MAIN_ENABLE_SIGNATURE_CHECKS;
extern const ConfigInfo<bool> MAIN_REDUCE_POLLING_RATE;
extern const ConfigInfo<bool> MAIN_AUTO_DISC_CHANGE;
// Main.DSP

1
Source/Core/Core/ConfigLoaders/IsSettingSaveable.cpp
View File

@ -31,6 +31,7 @@ bool IsSettingSaveable(const Config::ConfigLocation& config_location)
Config::MAIN_DEFAULT_ISO.location,
Config::MAIN_MEMCARD_A_PATH.location,
Config::MAIN_MEMCARD_B_PATH.location,
Config::MAIN_AUTO_DISC_CHANGE.location,
// Graphics.Hardware

68
Source/Core/Core/HW/DVD/DVDInterface.cpp
View File

@ -16,8 +16,10 @@
#include "Common/Align.h"
#include "Common/ChunkFile.h"
#include "Common/CommonTypes.h"
#include "Common/Config/Config.h"
#include "Common/Logging/Log.h"
#include "Core/Config/MainSettings.h"
#include "Core/ConfigManager.h"
#include "Core/CoreTiming.h"
#include "Core/HW/AudioInterface.h"
@ -36,6 +38,8 @@
#include "DiscIO/Volume.h"
#include "DiscIO/VolumeWii.h"
#include "VideoCommon/OnScreenDisplay.h"
// The minimum time it takes for the DVD drive to process a command (in
// microseconds)
constexpr u64 COMMAND_LATENCY_US = 300;
@ -231,6 +235,8 @@ static u64 s_read_buffer_end_offset;
// Disc changing
static std::string s_disc_path_to_insert;
static std::vector<std::string> s_auto_disc_change_paths;
static size_t s_auto_disc_change_index;
// Events
static CoreTiming::EventType* s_finish_executing_command;
@ -441,11 +447,21 @@ void Shutdown()
DVDThread::Stop();
}
void SetDisc(std::unique_ptr<DiscIO::Volume> disc)
void SetDisc(std::unique_ptr<DiscIO::Volume> disc,
std::optional<std::vector<std::string>> auto_disc_change_paths = {})
{
if (disc)
s_current_partition = disc->GetGamePartition();
if (auto_disc_change_paths)
{
ASSERT_MSG(DISCIO, (*auto_disc_change_paths).size() != 1,
"Cannot automatically change between one disc");
s_auto_disc_change_paths = *auto_disc_change_paths;
s_auto_disc_change_index = 0;
}
DVDThread::SetDisc(std::move(disc));
SetLidOpen();
}
@ -457,7 +473,7 @@ bool IsDiscInside()
static void EjectDiscCallback(u64 userdata, s64 cyclesLate)
{
SetDisc(nullptr);
SetDisc(nullptr, {});
}
static void InsertDiscCallback(u64 userdata, s64 cyclesLate)
@ -466,7 +482,7 @@ static void InsertDiscCallback(u64 userdata, s64 cyclesLate)
DiscIO::CreateVolumeFromFilename(s_disc_path_to_insert);
if (new_volume)
SetDisc(std::move(new_volume));
SetDisc(std::move(new_volume), {});
else
PanicAlertT("The disc that was about to be inserted couldn't be found.");
@ -479,6 +495,20 @@ void EjectDisc()
CoreTiming::ScheduleEvent(0, s_eject_disc);
}
// Must only be called on the CPU thread
void ChangeDisc(const std::vector<std::string>& paths)
{
ASSERT_MSG(DISCIO, !paths.empty(), "Trying to insert an empty list of discs");
if (paths.size() > 1)
{
s_auto_disc_change_paths = paths;
s_auto_disc_change_index = 0;
}
ChangeDisc(paths[0]);
}
// Must only be called on the CPU thread
void ChangeDisc(const std::string& new_path)
{
@ -493,6 +523,28 @@ void ChangeDisc(const std::string& new_path)
s_disc_path_to_insert = new_path;
CoreTiming::ScheduleEvent(SystemTimers::GetTicksPerSecond(), s_insert_disc);
Movie::SignalDiscChange(new_path);
for (size_t i = 0; i < s_auto_disc_change_paths.size(); ++i)
{
if (s_auto_disc_change_paths[i] == new_path)
{
s_auto_disc_change_index = i;
return;
}
}
s_auto_disc_change_paths.clear();
}
// Must only be called on the CPU thread
bool AutoChangeDisc()
{
if (s_auto_disc_change_paths.empty())
return false;
s_auto_disc_change_index = (s_auto_disc_change_index + 1) % s_auto_disc_change_paths.size();
ChangeDisc(s_auto_disc_change_paths[s_auto_disc_change_index]);
return true;
}
void SetLidOpen()
@ -983,12 +1035,20 @@ void ExecuteCommand(u32 command_0, u32 command_1, u32 command_2, u32 output_addr
break;
case DVDLowStopMotor:
{
INFO_LOG(DVDINTERFACE, "DVDLowStopMotor %s %s", command_1 ? "eject" : "",
command_2 ? "kill!" : "");
if (command_1 && !command_2)
bool auto_disc_change = Config::Get(Config::MAIN_AUTO_DISC_CHANGE) && !Movie::IsPlayingInput();
if (auto_disc_change)
auto_disc_change = AutoChangeDisc();
if (auto_disc_change)
OSD::AddMessage("Changing discs automatically...", OSD::Duration::NORMAL);
if (!auto_disc_change && command_1 && !command_2)
EjectDiscCallback(0, 0);
break;
}
// DVD Audio Enable/Disable (Immediate). GC uses this, and apparently Wii also does...?
case DVDLowAudioBufferConfig:

5
Source/Core/Core/HW/DVD/DVDInterface.h
View File

@ -111,10 +111,13 @@ void DoState(PointerWrap& p);
void RegisterMMIO(MMIO::Mapping* mmio, u32 base);
void SetDisc(std::unique_ptr<DiscIO::Volume> disc);
void SetDisc(std::unique_ptr<DiscIO::Volume> disc,
std::optional<std::vector<std::string>> auto_disc_change_paths);
bool IsDiscInside();
void EjectDisc(); // Must only be called on the CPU thread
void ChangeDisc(const std::vector<std::string>& paths); // Must only be called on the CPU thread
void ChangeDisc(const std::string& new_path); // Must only be called on the CPU thread
bool AutoChangeDisc(); // Must only be called on the CPU thread
// This function returns true and calls SConfig::SetRunningGameMetadata(Volume&, Partition&)
// if both of the following conditions are true:

22
Source/Core/Core/Movie.cpp
View File

@ -1176,29 +1176,13 @@ void PlayController(GCPadStatus* PadStatus, int controllerID)
PadStatus->button |= PAD_TRIGGER_R;
if (s_padState.disc)
{
// This implementation assumes the disc change will only happen once. Trying
// to change more than that will cause it to load the last disc every time.
// As far as I know, there are no 3+ disc games, so this should be fine.
bool found = false;
std::string path;
for (const std::string& iso_folder : SConfig::GetInstance().m_ISOFolder)
{
path = iso_folder + '/' + s_discChange;
if (File::Exists(path))
{
found = true;
break;
}
}
if (found)
{
Core::RunAsCPUThread([&path] { DVDInterface::ChangeDisc(path); });
}
else
Core::RunAsCPUThread([] {
if (!DVDInterface::AutoChangeDisc())
{
CPU::Break();
PanicAlertT("Change the disc to %s", s_discChange.c_str());
}
});
}
if (s_padState.reset)

5
Source/Core/DolphinNoGUI/MainNoGUI.cpp
View File

@ -368,7 +368,10 @@ int main(int argc, char* argv[])
std::unique_ptr<BootParameters> boot;
if (options.is_set("exec"))
{
boot = BootParameters::GenerateFromFile(static_cast<const char*>(options.get("exec")));
const std::list<std::string> paths_list = options.all("exec");
const std::vector<std::string> paths{std::make_move_iterator(std::begin(paths_list)),
std::make_move_iterator(std::end(paths_list))};
boot = BootParameters::GenerateFromFile(paths);
}
else if (options.is_set("nand_title"))
{

11
Source/Core/DolphinQt/GameList/GameList.cpp
View File

@ -737,6 +737,17 @@ bool GameList::HasMultipleSelected() const
m_grid->selectionModel()->selectedIndexes().size() > 1;
}
std::shared_ptr<const UICommon::GameFile> GameList::FindGame(const std::string& path) const
{
return m_model->FindGame(path);
}
std::shared_ptr<const UICommon::GameFile>
GameList::FindSecondDisc(const UICommon::GameFile& game) const
{
return m_model->FindSecondDisc(game);
}
void GameList::SetViewColumn(int col, bool view)
{
m_list->setColumnHidden(col, !view);

2
Source/Core/DolphinQt/GameList/GameList.h
View File

@ -30,6 +30,8 @@ public:
std::shared_ptr<const UICommon::GameFile> GetSelectedGame() const;
QList<std::shared_ptr<const UICommon::GameFile>> GetSelectedGames() const;
bool HasMultipleSelected() const;
std::shared_ptr<const UICommon::GameFile> FindGame(const std::string& path) const;
std::shared_ptr<const UICommon::GameFile> FindSecondDisc(const UICommon::GameFile& game) const;
void SetListView() { SetPreferredView(true); }
void SetGridView() { SetPreferredView(false); }

35
Source/Core/DolphinQt/GameList/GameListModel.cpp
View File

@ -278,7 +278,7 @@ void GameListModel::AddGame(const std::shared_ptr<const UICommon::GameFile>& gam
void GameListModel::UpdateGame(const std::shared_ptr<const UICommon::GameFile>& game)
{
int index = FindGame(game->GetFilePath());
int index = FindGameIndex(game->GetFilePath());
if (index < 0)
{
AddGame(game);
@ -292,7 +292,7 @@ void GameListModel::UpdateGame(const std::shared_ptr<const UICommon::GameFile>&
void GameListModel::RemoveGame(const std::string& path)
{
int entry = FindGame(path);
int entry = FindGameIndex(path);
if (entry < 0)
return;
@ -301,7 +301,13 @@ void GameListModel::RemoveGame(const std::string& path)
endRemoveRows();
}
int GameListModel::FindGame(const std::string& path) const
std::shared_ptr<const UICommon::GameFile> GameListModel::FindGame(const std::string& path) const
{
const int index = FindGameIndex(path);
return index < 0 ? nullptr : m_games[index];
}
int GameListModel::FindGameIndex(const std::string& path) const
{
for (int i = 0; i < m_games.size(); i++)
{
@ -311,6 +317,29 @@ int GameListModel::FindGame(const std::string& path) const
return -1;
}
std::shared_ptr<const UICommon::GameFile>
GameListModel::FindSecondDisc(const UICommon::GameFile& game) const
{
std::shared_ptr<const UICommon::GameFile> match_without_revision = nullptr;
if (DiscIO::IsDisc(game.GetPlatform()))
{
for (auto& other_game : m_games)
{
if (game.GetGameID() == other_game->GetGameID() &&
game.GetDiscNumber() != other_game->GetDiscNumber())
{
if (game.GetRevision() == other_game->GetRevision())
return other_game;
else
match_without_revision = other_game;
}
}
}
return match_without_revision;
}
void GameListModel::SetSearchTerm(const QString& term)
{
m_term = term;

5
Source/Core/DolphinQt/GameList/GameListModel.h
View File

@ -63,6 +63,9 @@ public:
void UpdateGame(const std::shared_ptr<const UICommon::GameFile>& game);
void RemoveGame(const std::string& path);
std::shared_ptr<const UICommon::GameFile> FindGame(const std::string& path) const;
std::shared_ptr<const UICommon::GameFile> FindSecondDisc(const UICommon::GameFile& game) const;
void SetScale(float scale);
float GetScale() const;
@ -79,7 +82,7 @@ public:
private:
// Index in m_games, or -1 if it isn't found
int FindGame(const std::string& path) const;
int FindGameIndex(const std::string& path) const;
QStringList m_tag_list;
QMap<QString, QVariant> m_game_tags;

5
Source/Core/DolphinQt/Main.cpp
View File

@ -147,7 +147,10 @@ int main(int argc, char* argv[])
std::unique_ptr<BootParameters> boot;
if (options.is_set("exec"))
{
boot = BootParameters::GenerateFromFile(static_cast<const char*>(options.get("exec")));
const std::list<std::string> paths_list = options.all("exec");
const std::vector<std::string> paths{std::make_move_iterator(std::begin(paths_list)),
std::make_move_iterator(std::end(paths_list))};
boot = BootParameters::GenerateFromFile(paths);
}
else if (options.is_set("nand_title"))
{

114
Source/Core/DolphinQt/MainWindow.cpp
View File

@ -168,6 +168,17 @@ static WindowSystemInfo GetWindowSystemInfo(QWindow* window)
return wsi;
}
static std::vector<std::string> StringListToStdVector(QStringList list)
{
std::vector<std::string> result;
result.reserve(list.size());
for (const QString& s : list)
result.push_back(s.toStdString());
return result;
}
MainWindow::MainWindow(std::unique_ptr<BootParameters> boot_parameters) : QMainWindow(nullptr)
{
setWindowTitle(QString::fromStdString(Common::scm_rev_str));
@ -387,7 +398,7 @@ void MainWindow::ConnectMenuBar()
connect(m_menu_bar, &MenuBar::EjectDisc, this, &MainWindow::EjectDisc);
connect(m_menu_bar, &MenuBar::ChangeDisc, this, &MainWindow::ChangeDisc);
connect(m_menu_bar, &MenuBar::BootDVDBackup, this,
[this](const QString& drive) { StartGame(drive); });
[this](const QString& drive) { StartGame(drive, ScanForSecondDisc::No); });
// Emulation
connect(m_menu_bar, &MenuBar::Pause, this, &MainWindow::Pause);
@ -610,30 +621,30 @@ void MainWindow::RefreshGameList()
Settings::Instance().RefreshGameList();
}
QString MainWindow::PromptFileName()
QStringList MainWindow::PromptFileNames()
{
auto& settings = Settings::Instance().GetQSettings();
QString path = QFileDialog::getOpenFileName(
QStringList paths = QFileDialog::getOpenFileNames(
this, tr("Select a File"),
settings.value(QStringLiteral("mainwindow/lastdir"), QStringLiteral("")).toString(),
tr("All GC/Wii files (*.elf *.dol *.gcm *.iso *.tgc *.wbfs *.ciso *.gcz *.wad *.dff);;"
"All Files (*)"));
if (!path.isEmpty())
if (!paths.isEmpty())
{
settings.setValue(QStringLiteral("mainwindow/lastdir"),
QFileInfo(path).absoluteDir().absolutePath());
QFileInfo(paths.front()).absoluteDir().absolutePath());
}
return path;
return paths;
}
void MainWindow::ChangeDisc()
{
QString file = PromptFileName();
std::vector<std::string> paths = StringListToStdVector(PromptFileNames());
if (!file.isEmpty())
Core::RunAsCPUThread([&file] { DVDInterface::ChangeDisc(file.toStdString()); });
if (!paths.empty())
Core::RunAsCPUThread([&paths] { DVDInterface::ChangeDisc(paths); });
}
void MainWindow::EjectDisc()
@ -643,9 +654,9 @@ void MainWindow::EjectDisc()
void MainWindow::Open()
{
QString file = PromptFileName();
if (!file.isEmpty())
StartGame(file);
QStringList files = PromptFileNames();
if (!files.isEmpty())
StartGame(StringListToStdVector(files));
}
void MainWindow::Play(const std::optional<std::string>& savestate_path)
@ -664,7 +675,7 @@ void MainWindow::Play(const std::optional<std::string>& savestate_path)
std::shared_ptr<const UICommon::GameFile> selection = m_game_list->GetSelectedGame();
if (selection)
{
StartGame(selection->GetFilePath(), savestate_path);
StartGame(selection->GetFilePath(), ScanForSecondDisc::Yes, savestate_path);
EnableScreenSaver(false);
}
else
@ -672,7 +683,7 @@ void MainWindow::Play(const std::optional<std::string>& savestate_path)
const QString default_path = QString::fromStdString(Config::Get(Config::MAIN_DEFAULT_ISO));
if (!default_path.isEmpty() && QFile::exists(default_path))
{
StartGame(default_path, savestate_path);
StartGame(default_path, ScanForSecondDisc::Yes, savestate_path);
EnableScreenSaver(false);
}
else
@ -833,17 +844,46 @@ void MainWindow::ScreenShot()
Core::SaveScreenShot();
}
void MainWindow::StartGame(const QString& path, const std::optional<std::string>& savestate_path)
{
StartGame(path.toStdString(), savestate_path);
}
void MainWindow::StartGame(const std::string& path,
void MainWindow::ScanForSecondDiscAndStartGame(const UICommon::GameFile& game,
const std::optional<std::string>& savestate_path)
{
auto second_game = m_game_list->FindSecondDisc(game);
std::vector<std::string> paths = {game.GetFilePath()};
if (second_game != nullptr)
paths.push_back(second_game->GetFilePath());
StartGame(paths, savestate_path);
}
void MainWindow::StartGame(const QString& path, ScanForSecondDisc scan,
const std::optional<std::string>& savestate_path)
{
StartGame(path.toStdString(), scan, savestate_path);
}
void MainWindow::StartGame(const std::string& path, ScanForSecondDisc scan,
const std::optional<std::string>& savestate_path)
{
if (scan == ScanForSecondDisc::Yes)
{
std::shared_ptr<const UICommon::GameFile> game = m_game_list->FindGame(path);
if (game != nullptr)
{
ScanForSecondDiscAndStartGame(*game, savestate_path);
return;
}
}
StartGame(BootParameters::GenerateFromFile(path, savestate_path));
}
void MainWindow::StartGame(const std::vector<std::string>& paths,
const std::optional<std::string>& savestate_path)
{
StartGame(BootParameters::GenerateFromFile(paths, savestate_path));
}
void MainWindow::StartGame(std::unique_ptr<BootParameters>&& parameters)
{
// If we're running, only start a new game once we've stopped the last.
@ -1075,7 +1115,7 @@ void MainWindow::ShowFIFOPlayer()
{
m_fifo_window = new FIFOPlayerWindow(this);
connect(m_fifo_window, &FIFOPlayerWindow::LoadFIFORequested, this,
[this](const QString& path) { StartGame(path); });
[this](const QString& path) { StartGame(path, ScanForSecondDisc::No); });
}
m_fifo_window->show();
@ -1170,7 +1210,7 @@ void MainWindow::NetPlayInit()
#endif
connect(m_netplay_dialog, &NetPlayDialog::Boot, this,
[this](const QString& path) { StartGame(path); });
[this](const QString& path) { StartGame(path, ScanForSecondDisc::Yes); });
connect(m_netplay_dialog, &NetPlayDialog::Stop, this, &MainWindow::ForceStop);
connect(m_netplay_dialog, &NetPlayDialog::rejected, this, &MainWindow::NetPlayQuit);
connect(m_netplay_setup_dialog, &NetPlaySetupDialog::Join, this, &MainWindow::NetPlayJoin);
@ -1346,14 +1386,17 @@ void MainWindow::dragEnterEvent(QDragEnterEvent* event)
void MainWindow::dropEvent(QDropEvent* event)
{
const auto& urls = event->mimeData()->urls();
const QList<QUrl>& urls = event->mimeData()->urls();
if (urls.empty())
return;
const auto& url = urls[0];
QFileInfo file_info(url.toLocalFile());
QStringList files;
QStringList folders;
auto path = file_info.filePath();
for (const QUrl& url : urls)
{
QFileInfo file_info(url.toLocalFile());
QString path = file_info.filePath();
if (!file_info.exists() || !file_info.isReadable())
{
@ -1361,23 +1404,30 @@ void MainWindow::dropEvent(QDropEvent* event)
return;
}
if (file_info.isFile())
(file_info.isFile() ? files : folders).append(path);
}
if (!files.isEmpty())
{
StartGame(path);
StartGame(StringListToStdVector(files));
}
else
{
auto& settings = Settings::Instance();
Settings& settings = Settings::Instance();
const bool show_confirm = settings.GetPaths().size() != 0;
if (settings.GetPaths().size() != 0)
for (const QString& folder : folders)
{
if (show_confirm)
{
if (QMessageBox::question(
this, tr("Confirm"),
tr("Do you want to add \"%1\" to the list of Game Paths?").arg(path)) !=
tr("Do you want to add \"%1\" to the list of Game Paths?").arg(folder)) !=
QMessageBox::Yes)
return;
}
settings.AddPath(path);
settings.AddPath(folder);
}
}
}

24
Source/Core/DolphinQt/MainWindow.h
View File

@ -5,6 +5,7 @@
#pragma once
#include <QMainWindow>
#include <QStringList>
#include <memory>
#include <optional>
@ -47,6 +48,11 @@ namespace DiscIO
enum class Region;
}
namespace UICommon
{
class GameFile;
}
namespace X11Utils
{
class XRRConfiguration;
@ -115,8 +121,20 @@ private:
void InitCoreCallbacks();
void StartGame(const QString& path, const std::optional<std::string>& savestate_path = {});
void StartGame(const std::string& path, const std::optional<std::string>& savestate_path = {});
enum class ScanForSecondDisc
{
Yes,
No,
};
void ScanForSecondDiscAndStartGame(const UICommon::GameFile& game,
const std::optional<std::string>& savestate_path = {});
void StartGame(const QString& path, ScanForSecondDisc scan,
const std::optional<std::string>& savestate_path = {});
void StartGame(const std::string& path, ScanForSecondDisc scan,
const std::optional<std::string>& savestate_path = {});
void StartGame(const std::vector<std::string>& paths,
const std::optional<std::string>& savestate_path = {});
void StartGame(std::unique_ptr<BootParameters>&& parameters);
void ShowRenderWidget();
void HideRenderWidget(bool reinit = true);
@ -155,7 +173,7 @@ private:
void ChangeDisc();
void EjectDisc();
QString PromptFileName();
QStringList PromptFileNames();
void EnableScreenSaver(bool enable);

6
Source/Core/DolphinQt/Settings/GeneralPane.cpp
View File

@ -96,6 +96,7 @@ void GeneralPane::ConnectLayout()
{
connect(m_checkbox_dualcore, &QCheckBox::toggled, this, &GeneralPane::OnSaveConfig);
connect(m_checkbox_cheats, &QCheckBox::toggled, this, &GeneralPane::OnSaveConfig);
connect(m_checkbox_auto_disc_change, &QCheckBox::toggled, this, &GeneralPane::OnSaveConfig);
#ifdef USE_DISCORD_PRESENCE
connect(m_checkbox_discord_presence, &QCheckBox::toggled, this, &GeneralPane::OnSaveConfig);
#endif
@ -137,6 +138,9 @@ void GeneralPane::CreateBasic()
m_checkbox_cheats = new QCheckBox(tr("Enable Cheats"));
basic_group_layout->addWidget(m_checkbox_cheats);
m_checkbox_auto_disc_change = new QCheckBox(tr("Change Discs Automatically"));
basic_group_layout->addWidget(m_checkbox_auto_disc_change);
#ifdef USE_DISCORD_PRESENCE
m_checkbox_discord_presence = new QCheckBox(tr("Show Current Game on Discord"));
basic_group_layout->addWidget(m_checkbox_discord_presence);
@ -236,6 +240,7 @@ void GeneralPane::LoadConfig()
#endif
m_checkbox_dualcore->setChecked(SConfig::GetInstance().bCPUThread);
m_checkbox_cheats->setChecked(Settings::Instance().GetCheatsEnabled());
m_checkbox_auto_disc_change->setChecked(Config::Get(Config::MAIN_AUTO_DISC_CHANGE));
#ifdef USE_DISCORD_PRESENCE
m_checkbox_discord_presence->setChecked(Config::Get(Config::MAIN_USE_DISCORD_PRESENCE));
#endif
@ -295,6 +300,7 @@ void GeneralPane::OnSaveConfig()
settings.bCPUThread = m_checkbox_dualcore->isChecked();
Config::SetBaseOrCurrent(Config::MAIN_CPU_THREAD, m_checkbox_dualcore->isChecked());
Settings::Instance().SetCheatsEnabled(m_checkbox_cheats->isChecked());
Config::SetBase(Config::MAIN_AUTO_DISC_CHANGE, m_checkbox_auto_disc_change->isChecked());
Config::SetBaseOrCurrent(Config::MAIN_ENABLE_CHEATS, m_checkbox_cheats->isChecked());
settings.m_EmulationSpeed = m_combobox_speedlimit->currentIndex() * 0.1f;

1
Source/Core/DolphinQt/Settings/GeneralPane.h
View File

@ -44,6 +44,7 @@ private:
QComboBox* m_combobox_update_track;
QCheckBox* m_checkbox_dualcore;
QCheckBox* m_checkbox_cheats;
QCheckBox* m_checkbox_auto_disc_change;
#ifdef USE_DISCORD_PRESENCE
QCheckBox* m_checkbox_discord_presence;
#endif

2
Source/Core/UICommon/CommandLineParse.cpp
View File

@ -75,7 +75,7 @@ std::unique_ptr<optparse::OptionParser> CreateParser(ParserOptions options)
parser->add_option("-u", "--user").action("store").help("User folder path");
parser->add_option("-m", "--movie").action("store").help("Play a movie file");
parser->add_option("-e", "--exec")
.action("store")
.action("append")
.metavar("<file>")
.type("string")
.help("Load the specified file");