mirrors/Cemu
0
0
Fork 0
mirror of https://github.com/cemu-project/Cemu.git synced 2025-12-25 04:37:01 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Windows default to non-portable + Reworked MLC handling and related UI (#1252)

Browse source
This commit is contained in:
Exzap 2024-07-23 03:13:36 +02:00 • committed by GitHub
parent 7522c8470e
commit 64232ffdbd
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
18 changed files with 515 additions and 651 deletions
Download patch file Download diff file Expand all files Collapse all files

407
src/gui/CemuApp.cpp
View file

@ -3,11 +3,11 @@
#include "gui/wxgui.h"
#include "config/CemuConfig.h"
#include "Cafe/HW/Latte/Renderer/Vulkan/VulkanAPI.h"
#include "Cafe/HW/Latte/Core/LatteOverlay.h"
#include "gui/guiWrapper.h"
#include "config/ActiveSettings.h"
#include "config/LaunchSettings.h"
#include "gui/GettingStartedDialog.h"
#include "config/PermanentConfig.h"
#include "config/PermanentStorage.h"
#include "input/InputManager.h"
#include "gui/helpers/wxHelpers.h"
#include "Cemu/ncrypto/ncrypto.h"
@ -30,7 +30,10 @@ wxIMPLEMENT_APP_NO_MAIN(CemuApp);
extern WindowInfo g_window_info;
extern std::shared_mutex g_mutex;
int mainEmulatorHLE();
// forward declarations from main.cpp
void UnitTests();
void CemuCommonInit();
void HandlePostUpdate();
// Translation strings to extract for gettext:
void unused_translation_dummy()
@ -54,34 +57,86 @@ void unused_translation_dummy()
void(_("unknown"));
}
bool CemuApp::OnInit()
#if BOOST_OS_WINDOWS
#include <shlobj_core.h>
fs::path GetAppDataRoamingPath()
{
PWSTR path = nullptr;
HRESULT result = SHGetKnownFolderPath(FOLDERID_RoamingAppData, 0, nullptr, &path);
if (result != S_OK || !path)
{
if (path)
CoTaskMemFree(path);
return {};
}
std::string appDataPath = boost::nowide::narrow(path);
CoTaskMemFree(path);
return _utf8ToPath(appDataPath);
}
#endif
#if BOOST_OS_WINDOWS
void CemuApp::DeterminePaths(std::set<fs::path>& failedWriteAccess) // for Windows
{
std::error_code ec;
bool isPortable = false;
fs::path user_data_path, config_path, cache_path, data_path;
auto standardPaths = wxStandardPaths::Get();
fs::path exePath(wxHelper::MakeFSPath(standardPaths.GetExecutablePath()));
fs::path portablePath = exePath.parent_path() / "portable";
data_path = exePath.parent_path(); // the data path is always the same as the exe path
if (fs::exists(portablePath, ec))
{
isPortable = true;
user_data_path = config_path = cache_path = portablePath;
}
else
{
fs::path roamingPath = GetAppDataRoamingPath() / "Cemu";
user_data_path = config_path = cache_path = roamingPath;
}
// on Windows Cemu used to be portable by default prior to 2.0-89
// to remain backwards compatible with old installations we check for settings.xml in the Cemu directory
// if it exists, we use the exe path as the portable directory
if(!isPortable) // lower priority than portable directory
{
if (fs::exists(exePath.parent_path() / "settings.xml", ec))
{
isPortable = true;
user_data_path = config_path = cache_path = exePath.parent_path();
}
}
ActiveSettings::SetPaths(isPortable, exePath, user_data_path, config_path, cache_path, data_path, failedWriteAccess);
}
#endif
#if BOOST_OS_LINUX
void CemuApp::DeterminePaths(std::set<fs::path>& failedWriteAccess) // for Linux
{
std::error_code ec;
bool isPortable = false;
fs::path user_data_path, config_path, cache_path, data_path;
auto standardPaths = wxStandardPaths::Get();
fs::path exePath(wxHelper::MakeFSPath(standardPaths.GetExecutablePath()));
fs::path portablePath = exePath.parent_path() / "portable";
// GetExecutablePath returns the AppImage's temporary mount location
wxString appImagePath;
if (wxGetEnv(("APPIMAGE"), &appImagePath))
exePath = wxHelper::MakeFSPath(appImagePath);
#endif
// Try a portable path first, if it exists.
user_data_path = config_path = cache_path = data_path = exePath.parent_path() / "portable";
#if BOOST_OS_MACOS
// If run from an app bundle, use its parent directory.
fs::path appPath = exePath.parent_path().parent_path().parent_path();
if (appPath.extension() == ".app")
user_data_path = config_path = cache_path = data_path = appPath.parent_path() / "portable";
#endif
if (!fs::exists(user_data_path))
{
#if BOOST_OS_WINDOWS
user_data_path = config_path = cache_path = data_path = exePath.parent_path();
#else
exePath = wxHelper::MakeFSPath(appImagePath);
portablePath = exePath.parent_path() / "portable";
}
if (fs::exists(portablePath, ec))
{
isPortable = true;
user_data_path = config_path = cache_path = portablePath;
// in portable mode assume the data directories (resources, gameProfiles/default/) are next to the executable
data_path = exePath.parent_path();
}
else
{
SetAppName("Cemu");
wxString appName=GetAppName();
#if BOOST_OS_LINUX
wxString appName = GetAppName();
standardPaths.SetFileLayout(wxStandardPaths::FileLayout::FileLayout_XDG);
auto getEnvDir = [&](const wxString& varName, const wxString& defaultValue)
{
@ -90,33 +145,151 @@ bool CemuApp::OnInit()
return defaultValue;
return dir;
};
wxString homeDir=wxFileName::GetHomeDir();
wxString homeDir = wxFileName::GetHomeDir();
user_data_path = (getEnvDir(wxS("XDG_DATA_HOME"), homeDir + wxS("/.local/share")) + "/" + appName).ToStdString();
config_path = (getEnvDir(wxS("XDG_CONFIG_HOME"), homeDir + wxS("/.config")) + "/" + appName).ToStdString();
#else
user_data_path = config_path = standardPaths.GetUserDataDir().ToStdString();
#endif
data_path = standardPaths.GetDataDir().ToStdString();
cache_path = standardPaths.GetUserDir(wxStandardPaths::Dir::Dir_Cache).ToStdString();
cache_path /= appName.ToStdString();
#endif
}
ActiveSettings::SetPaths(isPortable, exePath, user_data_path, config_path, cache_path, data_path, failedWriteAccess);
}
#endif
auto failed_write_access = ActiveSettings::LoadOnce(exePath, user_data_path, config_path, cache_path, data_path);
for (auto&& path : failed_write_access)
wxMessageBox(formatWxString(_("Cemu can't write to {}!"), wxString::FromUTF8(_pathToUtf8(path))),
_("Warning"), wxOK | wxCENTRE | wxICON_EXCLAMATION, nullptr);
#if BOOST_OS_MACOS
void CemuApp::DeterminePaths(std::set<fs::path>& failedWriteAccess) // for MacOS
{
std::error_code ec;
bool isPortable = false;
fs::path user_data_path, config_path, cache_path, data_path;
auto standardPaths = wxStandardPaths::Get();
fs::path exePath(wxHelper::MakeFSPath(standardPaths.GetExecutablePath()));
// If run from an app bundle, use its parent directory
fs::path appPath = exePath.parent_path().parent_path().parent_path();
fs::path portablePath = appPath.extension() == ".app" ? appPath.parent_path() / "portable" : exePath.parent_path() / "portable";
if (fs::exists(portablePath, ec))
{
isPortable = true;
user_data_path = config_path = cache_path = portablePath;
data_path = exePath.parent_path();
}
else
{
SetAppName("Cemu");
wxString appName = GetAppName();
user_data_path = config_path = standardPaths.GetUserDataDir().ToStdString();
data_path = standardPaths.GetDataDir().ToStdString();
cache_path = standardPaths.GetUserDir(wxStandardPaths::Dir::Dir_Cache).ToStdString();
cache_path /= appName.ToStdString();
}
ActiveSettings::SetPaths(isPortable, exePath, user_data_path, config_path, cache_path, data_path, failedWriteAccess);
}
#endif
// create default MLC files or quit if it fails
void CemuApp::InitializeNewMLCOrFail(fs::path mlc)
{
if( CemuApp::CreateDefaultMLCFiles(mlc) )
return; // all good
cemu_assert_debug(!ActiveSettings::IsCustomMlcPath()); // should not be possible?
if(ActiveSettings::IsCommandLineMlcPath() || ActiveSettings::IsCustomMlcPath())
{
// tell user that the custom path is not writable
wxMessageBox(formatWxString(_("Cemu failed to write to the custom mlc directory.\nThe path is:\n{}"), wxHelper::FromPath(mlc)), _("Error"), wxOK | wxCENTRE | wxICON_ERROR);
exit(0);
}
wxMessageBox(formatWxString(_("Cemu failed to write to the mlc directory.\nThe path is:\n{}"), wxHelper::FromPath(mlc)), _("Error"), wxOK | wxCENTRE | wxICON_ERROR);
exit(0);
}
void CemuApp::InitializeExistingMLCOrFail(fs::path mlc)
{
if(CreateDefaultMLCFiles(mlc))
return; // all good
// failed to write mlc files
if(ActiveSettings::IsCommandLineMlcPath() || ActiveSettings::IsCustomMlcPath())
{
// tell user that the custom path is not writable
// if it's a command line path then just quit. Otherwise ask if user wants to reset the path
if(ActiveSettings::IsCommandLineMlcPath())
{
wxMessageBox(formatWxString(_("Cemu failed to write to the custom mlc directory.\nThe path is:\n{}"), wxHelper::FromPath(mlc)), _("Error"), wxOK | wxCENTRE | wxICON_ERROR);
exit(0);
}
// ask user if they want to reset the path
const wxString message = formatWxString(_("Cemu failed to write to the custom mlc directory.\n\nThe path is:\n{}\n\nCemu cannot start without a valid mlc path. Do you want to reset the path? You can later change it again in the General Settings."),
_pathToUtf8(mlc));
wxMessageDialog dialog(nullptr, message, _("Error"), wxCENTRE | wxYES_NO | wxICON_WARNING);
dialog.SetYesNoLabels(_("Reset path"), _("Exit"));
const auto dialogResult = dialog.ShowModal();
if (dialogResult == wxID_NO)
exit(0);
else // reset path
{
GetConfig().mlc_path = "";
g_config.Save();
}
}
}
bool CemuApp::OnInit()
{
std::set<fs::path> failedWriteAccess;
DeterminePaths(failedWriteAccess);
// make sure default cemu directories exist
CreateDefaultCemuFiles();
g_config.SetFilename(ActiveSettings::GetConfigPath("settings.xml").generic_wstring());
std::error_code ec;
bool isFirstStart = !fs::exists(ActiveSettings::GetConfigPath("settings.xml"), ec);
NetworkConfig::LoadOnce();
g_config.Load();
if(!isFirstStart)
{
g_config.Load();
LocalizeUI(static_cast<wxLanguage>(GetConfig().language == wxLANGUAGE_DEFAULT ? wxLocale::GetSystemLanguage() : GetConfig().language.GetValue()));
}
else
{
LocalizeUI(static_cast<wxLanguage>(wxLocale::GetSystemLanguage()));
}
for (auto&& path : failedWriteAccess)
{
wxMessageBox(formatWxString(_("Cemu can't write to {}!"), wxString::FromUTF8(_pathToUtf8(path))),
_("Warning"), wxOK | wxCENTRE | wxICON_EXCLAMATION, nullptr);
}
if (isFirstStart)
{
// show the getting started dialog
GettingStartedDialog dia(nullptr);
dia.ShowModal();
// make sure config is created. Gfx pack UI and input UI may create it earlier already, but we still want to update it
g_config.Save();
// create mlc, on failure the user can quit here. So do this after the Getting Started dialog
InitializeNewMLCOrFail(ActiveSettings::GetMlcPath());
}
else
{
// check if mlc is valid and recreate default files
InitializeExistingMLCOrFail(ActiveSettings::GetMlcPath());
}
ActiveSettings::Init(); // this is a bit of a misnomer, right now this call only loads certs for online play. In the future we should move the logic to a more appropriate place
HandlePostUpdate();
mainEmulatorHLE();
LatteOverlay_init();
// run a couple of tests if in non-release mode
#ifdef CEMU_DEBUG_ASSERT
UnitTests();
#endif
CemuCommonInit();
wxInitAllImageHandlers();
LocalizeUI();
// fill colour db
wxTheColourDatabase->AddColour("ERROR", wxColour(0xCC, 0, 0));
wxTheColourDatabase->AddColour("SUCCESS", wxColour(0, 0xbb, 0));
@ -135,15 +308,8 @@ bool CemuApp::OnInit()
Bind(wxEVT_ACTIVATE_APP, &CemuApp::ActivateApp, this);
auto& config = GetConfig();
const bool first_start = !config.did_show_graphic_pack_download;
CreateDefaultFiles(first_start);
m_mainFrame = new MainWindow();
if (first_start)
m_mainFrame->ShowGettingStartedDialog();
std::unique_lock lock(g_mutex);
g_window_info.app_active = true;
@ -230,22 +396,22 @@ std::vector<const wxLanguageInfo *> CemuApp::GetLanguages() const {
return availableLanguages;
}
void CemuApp::LocalizeUI()
void CemuApp::LocalizeUI(wxLanguage languageToUse)
{
std::unique_ptr<wxTranslations> translationsMgr(new wxTranslations());
m_availableTranslations = GetAvailableTranslationLanguages(translationsMgr.get());
const sint32 configuredLanguage = GetConfig().language;
bool isTranslationAvailable = std::any_of(m_availableTranslations.begin(), m_availableTranslations.end(),
[configuredLanguage](const wxLanguageInfo* info) { return info->Language == configuredLanguage; });
if (configuredLanguage == wxLANGUAGE_DEFAULT || isTranslationAvailable)
[languageToUse](const wxLanguageInfo* info) { return info->Language == languageToUse; });
if (languageToUse == wxLANGUAGE_DEFAULT || isTranslationAvailable)
{
translationsMgr->SetLanguage(static_cast<wxLanguage>(configuredLanguage));
translationsMgr->SetLanguage(static_cast<wxLanguage>(languageToUse));
translationsMgr->AddCatalog("cemu");
if (translationsMgr->IsLoaded("cemu") && wxLocale::IsAvailable(configuredLanguage))
m_locale.Init(configuredLanguage);
if (translationsMgr->IsLoaded("cemu") && wxLocale::IsAvailable(languageToUse))
{
m_locale.Init(languageToUse);
}
// This must be run after wxLocale::Init, as the latter sets up its own wxTranslations instance which we want to override
wxTranslations::Set(translationsMgr.release());
}
@ -264,55 +430,47 @@ std::vector<const wxLanguageInfo*> CemuApp::GetAvailableTranslationLanguages(wxT
return languages;
}
void CemuApp::CreateDefaultFiles(bool first_start)
bool CemuApp::CheckMLCPath(const fs::path& mlc)
{
std::error_code ec;
fs::path mlc = ActiveSettings::GetMlcPath();
// check for mlc01 folder missing if custom path has been set
if (!fs::exists(mlc, ec) && !first_start)
{
const wxString message = formatWxString(_("Your mlc01 folder seems to be missing.\n\nThis is where Cemu stores save files, game updates and other Wii U files.\n\nThe expected path is:\n{}\n\nDo you want to create the folder at the expected path?"),
_pathToUtf8(mlc));
wxMessageDialog dialog(nullptr, message, _("Error"), wxCENTRE | wxYES_NO | wxCANCEL| wxICON_WARNING);
dialog.SetYesNoCancelLabels(_("Yes"), _("No"), _("Select a custom path"));
const auto dialogResult = dialog.ShowModal();
if (dialogResult == wxID_NO)
exit(0);
else if(dialogResult == wxID_CANCEL)
{
if (!SelectMLCPath())
return;
mlc = ActiveSettings::GetMlcPath();
}
else
{
GetConfig().mlc_path = "";
g_config.Save();
}
}
if (!fs::exists(mlc, ec))
return false;
if (!fs::exists(mlc / "usr", ec) || !fs::exists(mlc / "sys", ec))
return false;
return true;
}
bool CemuApp::CreateDefaultMLCFiles(const fs::path& mlc)
{
auto CreateDirectoriesIfNotExist = [](const fs::path& path)
{
std::error_code ec;
if (!fs::exists(path, ec))
return fs::create_directories(path, ec);
return true;
};
// list of directories to create
const fs::path directories[] = {
mlc,
mlc / "sys",
mlc / "usr",
mlc / "usr/title/00050000", // base
mlc / "usr/title/0005000c", // dlc
mlc / "usr/title/0005000e", // update
mlc / "usr/save/00050010/1004a000/user/common/db", // Mii Maker save folders {0x500101004A000, 0x500101004A100, 0x500101004A200}
mlc / "usr/save/00050010/1004a100/user/common/db",
mlc / "usr/save/00050010/1004a200/user/common/db",
mlc / "sys/title/0005001b/1005c000/content" // lang files
};
for(auto& path : directories)
{
if(!CreateDirectoriesIfNotExist(path))
return false;
}
// create sys/usr folder in mlc01
try
{
const auto sysFolder = fs::path(mlc).append("sys");
fs::create_directories(sysFolder);
const auto usrFolder = fs::path(mlc).append("usr");
fs::create_directories(usrFolder);
fs::create_directories(fs::path(usrFolder).append("title/00050000")); // base
fs::create_directories(fs::path(usrFolder).append("title/0005000c")); // dlc
fs::create_directories(fs::path(usrFolder).append("title/0005000e")); // update
// Mii Maker save folders {0x500101004A000, 0x500101004A100, 0x500101004A200},
fs::create_directories(fs::path(mlc).append("usr/save/00050010/1004a000/user/common/db"));
fs::create_directories(fs::path(mlc).append("usr/save/00050010/1004a100/user/common/db"));
fs::create_directories(fs::path(mlc).append("usr/save/00050010/1004a200/user/common/db"));
// lang files
const auto langDir = fs::path(mlc).append("sys/title/0005001b/1005c000/content");
fs::create_directories(langDir);
auto langFile = fs::path(langDir).append("language.txt");
if (!fs::exists(langFile))
{
@ -346,18 +504,13 @@ void CemuApp::CreateDefaultFiles(bool first_start)
}
catch (const std::exception& ex)
{
wxString errorMsg = formatWxString(_("Couldn't create a required mlc01 subfolder or file!\n\nError: {0}\nTarget path:\n{1}"), ex.what(), _pathToUtf8(mlc));
#if BOOST_OS_WINDOWS
const DWORD lastError = GetLastError();
if (lastError != ERROR_SUCCESS)
errorMsg << fmt::format("\n\n{}", GetSystemErrorMessage(lastError));
#endif
wxMessageBox(errorMsg, _("Error"), wxOK | wxCENTRE | wxICON_ERROR);
exit(0);
return false;
}
return true;
}
void CemuApp::CreateDefaultCemuFiles()
{
// cemu directories
try
{
@ -384,58 +537,6 @@ void CemuApp::CreateDefaultFiles(bool first_start)
}
}
bool CemuApp::TrySelectMLCPath(fs::path path)
{
if (path.empty())
path = ActiveSettings::GetDefaultMLCPath();
if (!TestWriteAccess(path))
return false;
GetConfig().SetMLCPath(path);
CemuApp::CreateDefaultFiles();
// update TitleList and SaveList scanner with new MLC path
CafeTitleList::SetMLCPath(path);
CafeTitleList::Refresh();
CafeSaveList::SetMLCPath(path);
CafeSaveList::Refresh();
return true;
}
bool CemuApp::SelectMLCPath(wxWindow* parent)
{
auto& config = GetConfig();
fs::path default_path;
if (fs::exists(_utf8ToPath(config.mlc_path.GetValue())))
default_path = _utf8ToPath(config.mlc_path.GetValue());
// try until users selects a valid path or aborts
while(true)
{
wxDirDialog path_dialog(parent, _("Select a mlc directory"), wxHelper::FromPath(default_path), wxDD_DEFAULT_STYLE | wxDD_DIR_MUST_EXIST);
if (path_dialog.ShowModal() != wxID_OK || path_dialog.GetPath().empty())
return false;
const auto path = path_dialog.GetPath().ToStdWstring();
if (!TrySelectMLCPath(path))
{
const auto result = wxMessageBox(_("Cemu can't write to the selected mlc path!\nDo you want to select another path?"), _("Error"), wxYES_NO | wxCENTRE | wxICON_ERROR);
if (result == wxYES)
continue;
break;
}
return true;
}
return false;
}
void CemuApp::ActivateApp(wxActivateEvent& event)
{
g_window_info.app_active = event.GetActive();

13
src/gui/CemuApp.h
View file

@ -15,13 +15,18 @@ public:
std::vector<const wxLanguageInfo*> GetLanguages() const;
static void CreateDefaultFiles(bool first_start = false);
static bool TrySelectMLCPath(fs::path path);
static bool SelectMLCPath(wxWindow* parent = nullptr);
static bool CheckMLCPath(const fs::path& mlc);
static bool CreateDefaultMLCFiles(const fs::path& mlc);
static void CreateDefaultCemuFiles();
static void InitializeNewMLCOrFail(fs::path mlc);
static void InitializeExistingMLCOrFail(fs::path mlc);
private:
void LocalizeUI(wxLanguage languageToUse);
void DeterminePaths(std::set<fs::path>& failedWriteAccess);
void ActivateApp(wxActivateEvent& event);
void LocalizeUI();
static std::vector<const wxLanguageInfo*> GetAvailableTranslationLanguages(wxTranslations* translationsMgr);
MainWindow* m_mainFrame = nullptr;

154
src/gui/GeneralSettings2.cpp
View file

@ -32,7 +32,6 @@
#include <boost/tokenizer.hpp>
#include "util/helpers/SystemException.h"
#include "gui/dialogs/CreateAccount/wxCreateAccountDialog.h"
#include "config/PermanentStorage.h"
#if BOOST_OS_WINDOWS
#include <VersionHelpers.h>
@ -176,19 +175,15 @@ wxPanel* GeneralSettings2::AddGeneralPage(wxNotebook* notebook)
m_save_screenshot->SetToolTip(_("Pressing the screenshot key (F12) will save a screenshot directly to the screenshots folder"));
second_row->Add(m_save_screenshot, 0, botflag, 5);
m_permanent_storage = new wxCheckBox(box, wxID_ANY, _("Use permanent storage"));
m_permanent_storage->SetToolTip(_("Cemu will remember your custom mlc path in %LOCALAPPDATA%/Cemu for new installations."));
second_row->Add(m_permanent_storage, 0, botflag, 5);
second_row->AddSpacer(10);
m_disable_screensaver = new wxCheckBox(box, wxID_ANY, _("Disable screen saver"));
m_disable_screensaver->SetToolTip(_("Prevents the system from activating the screen saver or going to sleep while running a game."));
second_row->Add(m_disable_screensaver, 0, botflag, 5);
// Enable/disable feral interactive gamemode
// Enable/disable feral interactive gamemode
#if BOOST_OS_LINUX && defined(ENABLE_FERAL_GAMEMODE)
m_feral_gamemode = new wxCheckBox(box, wxID_ANY, _("Enable Feral GameMode"));
m_feral_gamemode->SetToolTip(_("Use FeralInteractive GameMode if installed."));
second_row->Add(m_feral_gamemode, 0, botflag, 5);
m_feral_gamemode = new wxCheckBox(box, wxID_ANY, _("Enable Feral GameMode"));
m_feral_gamemode->SetToolTip(_("Use FeralInteractive GameMode if installed."));
second_row->Add(m_feral_gamemode, 0, botflag, 5);
#endif
// temporary workaround because feature crashes on macOS
@ -203,23 +198,33 @@ wxPanel* GeneralSettings2::AddGeneralPage(wxNotebook* notebook)
}
{
auto* box = new wxStaticBox(panel, wxID_ANY, _("MLC Path"));
auto* box_sizer = new wxStaticBoxSizer(box, wxHORIZONTAL);
auto* outerMlcBox = new wxStaticBox(panel, wxID_ANY, _("Custom MLC path"));
m_mlc_path = new wxTextCtrl(box, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY);
auto* box_sizer_mlc = new wxStaticBoxSizer(outerMlcBox, wxVERTICAL);
box_sizer_mlc->Add(new wxStaticText(box_sizer_mlc->GetStaticBox(), wxID_ANY, _("You can configure a custom path for the emulated internal Wii U storage (MLC).\nThis is where Cemu stores saves, accounts and other Wii U system files."), wxDefaultPosition, wxDefaultSize, 0), 0, wxALL, 5);
auto* mlcPathLineSizer = new wxBoxSizer(wxHORIZONTAL);
m_mlc_path = new wxTextCtrl(outerMlcBox, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY);
m_mlc_path->SetMinSize(wxSize(150, -1));
m_mlc_path->Bind(wxEVT_CHAR, &GeneralSettings2::OnMLCPathChar, this);
m_mlc_path->SetToolTip(_("The mlc directory contains your save games and installed game update/dlc data"));
box_sizer->Add(m_mlc_path, 1, wxALL | wxEXPAND, 5);
mlcPathLineSizer->Add(m_mlc_path, 1, wxALL | wxEXPAND, 5);
auto* change_path = new wxButton(box, wxID_ANY, "...");
change_path->Bind(wxEVT_BUTTON, &GeneralSettings2::OnMLCPathSelect, this);
change_path->SetToolTip(_("Select a custom mlc path\nThe mlc path is used to store Wii U related files like save games, game updates and dlc data"));
box_sizer->Add(change_path, 0, wxALL, 5);
auto* changePath = new wxButton(outerMlcBox, wxID_ANY, "Change");
changePath->Bind(wxEVT_BUTTON, &GeneralSettings2::OnMLCPathSelect, this);
mlcPathLineSizer->Add(changePath, 0, wxALL, 5);
if (LaunchSettings::GetMLCPath().has_value())
change_path->Disable();
general_panel_sizer->Add(box_sizer, 0, wxEXPAND | wxALL, 5);
changePath->Disable();
auto* clearPath = new wxButton(outerMlcBox, wxID_ANY, "Clear custom path");
clearPath->Bind(wxEVT_BUTTON, &GeneralSettings2::OnMLCPathClear, this);
mlcPathLineSizer->Add(clearPath, 0, wxALL, 5);
if (LaunchSettings::GetMLCPath().has_value() || !ActiveSettings::IsCustomMlcPath())
clearPath->Disable();
box_sizer_mlc->Add(mlcPathLineSizer, 0, wxEXPAND, 5);
general_panel_sizer->Add(box_sizer_mlc, 0, wxEXPAND | wxALL, 5);
}
{
@ -897,39 +902,12 @@ void GeneralSettings2::StoreConfig()
#if BOOST_OS_LINUX && defined(ENABLE_FERAL_GAMEMODE)
config.feral_gamemode = m_feral_gamemode->IsChecked();
#endif
const bool use_ps = m_permanent_storage->IsChecked();
if(use_ps)
{
config.permanent_storage = use_ps;
try
{
PermanentStorage storage;
storage.RemoveStorage();
}
catch (...) {}
}
else
{
try
{
// delete permanent storage
PermanentStorage storage;
storage.RemoveStorage();
}
catch (...) {}
config.permanent_storage = use_ps;
}
config.disable_screensaver = m_disable_screensaver->IsChecked();
// Toggle while a game is running
if (CafeSystem::IsTitleRunning())
{
ScreenSaver::SetInhibit(config.disable_screensaver);
}
if (!LaunchSettings::GetMLCPath().has_value())
config.SetMLCPath(wxHelper::MakeFSPath(m_mlc_path->GetValue()), false);
// -1 is default wx widget value -> set to dummy 0 so mainwindow and padwindow will update it
config.window_position = m_save_window_position_size->IsChecked() ? Vector2i{ 0,0 } : Vector2i{-1,-1};
@ -1560,7 +1538,6 @@ void GeneralSettings2::ApplyConfig()
m_auto_update->SetValue(config.check_update);
m_save_screenshot->SetValue(config.save_screenshot);
m_permanent_storage->SetValue(config.permanent_storage);
m_disable_screensaver->SetValue(config.disable_screensaver);
#if BOOST_OS_LINUX && defined(ENABLE_FERAL_GAMEMODE)
m_feral_gamemode->SetValue(config.feral_gamemode);
@ -1570,6 +1547,7 @@ void GeneralSettings2::ApplyConfig()
m_disable_screensaver->SetValue(false);
#endif
m_game_paths->Clear();
for (auto& path : config.game_paths)
{
m_game_paths->Append(to_wxString(path));
@ -1985,34 +1963,70 @@ void GeneralSettings2::OnAccountServiceChanged(wxCommandEvent& event)
void GeneralSettings2::OnMLCPathSelect(wxCommandEvent& event)
{
if (!CemuApp::SelectMLCPath(this))
if(CafeSystem::IsTitleRunning())
{
wxMessageBox(_("Can't change MLC path while a game is running!"), _("Error"), wxOK | wxCENTRE | wxICON_ERROR, this);
return;
m_mlc_path->SetValue(wxHelper::FromPath(ActiveSettings::GetMlcPath()));
m_reload_gamelist = true;
m_mlc_modified = true;
}
// show directory dialog
wxDirDialog path_dialog(this, _("Select MLC directory"), wxEmptyString, wxDD_DEFAULT_STYLE | wxDD_DIR_MUST_EXIST);
if (path_dialog.ShowModal() != wxID_OK || path_dialog.GetPath().empty())
return;
// check if the choosen MLC path is an already initialized MLC location
fs::path newMlc = wxHelper::MakeFSPath(path_dialog.GetPath());
if(CemuApp::CheckMLCPath(newMlc))
{
// ask user if they are sure they want to use this folder and let them know that accounts and saves wont transfer
wxString message = _("Note that changing the MLC location will not transfer any accounts or save files. Are you sure you want to change the path?");
wxMessageDialog dialog(this, message, _("Warning"), wxYES_NO | wxCENTRE | wxICON_WARNING);
if(dialog.ShowModal() == wxID_NO)
return;
if( !CemuApp::CreateDefaultMLCFiles(newMlc) ) // creating also acts as a check for read+write access
{
wxMessageBox(_("Failed to create default MLC files in the selected directory. The MLC path has not been changed"), _("Error"), wxOK | wxCENTRE | wxICON_ERROR, this);
return;
}
}
else
{
// ask user if they want to create a new mlc structure at the choosen location
wxString message = _("The selected directory does not contain the expected MLC structure. Do you want to create a new MLC structure in this directory?\nNote that changing the MLC location will not transfer any accounts or save files.");
wxMessageDialog dialog(this, message, _("Warning"), wxYES_NO | wxCENTRE | wxICON_WARNING);
if( !CemuApp::CreateDefaultMLCFiles(newMlc) )
{
wxMessageBox(_("Failed to create default MLC files in the selected directory. The MLC path has not been changed"), _("Error"), wxOK | wxCENTRE | wxICON_ERROR, this);
return;
}
}
// update MLC path and store any other modified settings
GetConfig().SetMLCPath(newMlc);
StoreConfig();
wxMessageBox(_("Cemu needs to be restarted for the changes to take effect."), _("Information"), wxOK | wxCENTRE | wxICON_INFORMATION, this);
// close settings and then cemu
wxCloseEvent closeEvent(wxEVT_CLOSE_WINDOW);
wxPostEvent(this, closeEvent);
wxPostEvent(GetParent(), closeEvent);
}
void GeneralSettings2::OnMLCPathChar(wxKeyEvent& event)
void GeneralSettings2::OnMLCPathClear(wxCommandEvent& event)
{
if (LaunchSettings::GetMLCPath().has_value())
return;
if(event.GetKeyCode() == WXK_DELETE || event.GetKeyCode() == WXK_BACK)
if(CafeSystem::IsTitleRunning())
{
fs::path newPath = "";
if(!CemuApp::TrySelectMLCPath(newPath))
{
const auto res = wxMessageBox(_("The default MLC path is inaccessible.\nDo you want to select a different path?"), _("Error"), wxYES_NO | wxCENTRE | wxICON_ERROR);
if (res == wxYES && CemuApp::SelectMLCPath(this))
newPath = ActiveSettings::GetMlcPath();
else
return;
}
m_mlc_path->SetValue(wxHelper::FromPath(newPath));
m_reload_gamelist = true;
m_mlc_modified = true;
wxMessageBox(_("Can't change MLC path while a game is running!"), _("Error"), wxOK | wxCENTRE | wxICON_ERROR, this);
return;
}
wxString message = _("Note that changing the MLC location will not transfer any accounts or save files. Are you sure you want to change the path?");
wxMessageDialog dialog(this, message, _("Warning"), wxYES_NO | wxCENTRE | wxICON_WARNING);
if(dialog.ShowModal() == wxID_NO)
return;
GetConfig().SetMLCPath("");
StoreConfig();
g_config.Save();
wxMessageBox(_("Cemu needs to be restarted for the changes to take effect."), _("Information"), wxOK | wxCENTRE | wxICON_INFORMATION, this);
// close settings and then cemu
wxCloseEvent closeEvent(wxEVT_CLOSE_WINDOW);
wxPostEvent(this, closeEvent);
wxPostEvent(GetParent(), closeEvent);
}
void GeneralSettings2::OnShowOnlineValidator(wxCommandEvent& event)

3
src/gui/GeneralSettings2.h
View file

@ -42,7 +42,6 @@ private:
wxCheckBox* m_save_padwindow_position_size;
wxCheckBox* m_discord_presence, *m_fullscreen_menubar;
wxCheckBox* m_auto_update, *m_save_screenshot;
wxCheckBox* m_permanent_storage;
wxCheckBox* m_disable_screensaver;
#if BOOST_OS_LINUX && defined(ENABLE_FERAL_GAMEMODE)
wxCheckBox* m_feral_gamemode;
@ -96,7 +95,7 @@ private:
void OnRemovePathClicked(wxCommandEvent& event);
void OnActiveAccountChanged(wxCommandEvent& event);
void OnMLCPathSelect(wxCommandEvent& event);
void OnMLCPathChar(wxKeyEvent& event);
void OnMLCPathClear(wxCommandEvent& event);
void OnShowOnlineValidator(wxCommandEvent& event);
void OnAccountServiceChanged(wxCommandEvent& event);
static wxString GetOnlineAccountErrorMessage(OnlineAccountError error);

224
src/gui/GettingStartedDialog.cpp
View file

@ -4,6 +4,7 @@
#include <wx/filepicker.h>
#include <wx/statbox.h>
#include <wx/msgdlg.h>
#include <wx/radiobox.h>
#include "config/ActiveSettings.h"
#include "gui/CemuApp.h"
@ -11,7 +12,6 @@
#include "gui/GraphicPacksWindow2.h"
#include "gui/input/InputSettings2.h"
#include "config/CemuConfig.h"
#include "config/PermanentConfig.h"
#include "Cafe/TitleList/TitleList.h"
@ -21,75 +21,100 @@
#include "wxHelper.h"
wxDEFINE_EVENT(EVT_REFRESH_FIRST_PAGE, wxCommandEvent); // used to refresh the first page after the language change
wxPanel* GettingStartedDialog::CreatePage1()
{
auto* result = new wxPanel(m_notebook, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL);
auto* mainPanel = new wxPanel(m_notebook, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL);
auto* page1_sizer = new wxBoxSizer(wxVERTICAL);
{
auto* sizer = new wxBoxSizer(wxHORIZONTAL);
sizer->Add(new wxStaticBitmap(result, wxID_ANY, wxICON(M_WND_ICON128)), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
auto* m_staticText11 = new wxStaticText(result, wxID_ANY, _("It looks like you're starting Cemu for the first time.\nThis quick setup assistant will help you get the best experience"), wxDefaultPosition, wxDefaultSize, 0);
m_staticText11->Wrap(-1);
sizer->Add(m_staticText11, 0, wxALL, 5);
sizer->Add(new wxStaticBitmap(mainPanel, wxID_ANY, wxICON(M_WND_ICON128)), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
m_page1.staticText11 = new wxStaticText(mainPanel, wxID_ANY, _("It looks like you're starting Cemu for the first time.\nThis quick setup assistant will help you get the best experience"), wxDefaultPosition, wxDefaultSize, 0);
m_page1.staticText11->Wrap(-1);
sizer->Add(m_page1.staticText11, 0, wxALL, 5);
page1_sizer->Add(sizer, 0, wxALL | wxEXPAND, 5);
}
if(ActiveSettings::IsPortableMode())
{
m_mlc_box_sizer = new wxStaticBoxSizer(wxVERTICAL, result, _("mlc01 path"));
m_mlc_box_sizer->Add(new wxStaticText(m_mlc_box_sizer->GetStaticBox(), wxID_ANY, _("The mlc path is the root folder of the emulated Wii U internal flash storage. It contains all your saves, installed updates and DLCs.\nIt is strongly recommend that you create a dedicated folder for it (example: C:\\wiiu\\mlc\\) \nIf left empty, the mlc folder will be created inside the Cemu folder.")), 0, wxALL, 5);
m_page1.portableModeInfoText = new wxStaticText(mainPanel, wxID_ANY, _("Cemu is running in portable mode"));
m_page1.portableModeInfoText->Show(true);
page1_sizer->Add(m_page1.portableModeInfoText, 0, wxALL, 5);
m_prev_mlc_warning = new wxStaticText(m_mlc_box_sizer->GetStaticBox(), wxID_ANY, _("A custom mlc path from a previous Cemu installation has been found and filled in."));
m_prev_mlc_warning->SetForegroundColour(*wxRED);
m_prev_mlc_warning->Show(false);
m_mlc_box_sizer->Add(m_prev_mlc_warning, 0, wxALL, 5);
auto* mlc_path_sizer = new wxBoxSizer(wxHORIZONTAL);
mlc_path_sizer->Add(new wxStaticText(m_mlc_box_sizer->GetStaticBox(), wxID_ANY, _("Custom mlc01 path")), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
// workaround since we can't specify our own browse label? >> _("Browse")
m_mlc_folder = new wxDirPickerCtrl(m_mlc_box_sizer->GetStaticBox(), wxID_ANY, wxEmptyString, _("Select a folder"), wxDefaultPosition, wxDefaultSize, wxDIRP_DEFAULT_STYLE);
auto tTest1 = m_mlc_folder->GetTextCtrl();
if(m_mlc_folder->HasTextCtrl())
{
m_mlc_folder->GetTextCtrl()->SetEditable(false);
m_mlc_folder->GetTextCtrl()->Bind(wxEVT_CHAR, &GettingStartedDialog::OnMLCPathChar, this);
}
mlc_path_sizer->Add(m_mlc_folder, 1, wxALL, 5);
mlc_path_sizer->Add(new wxStaticText(m_mlc_box_sizer->GetStaticBox(), wxID_ANY, _("(optional)")), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
m_mlc_box_sizer->Add(mlc_path_sizer, 0, wxEXPAND, 5);
page1_sizer->Add(m_mlc_box_sizer, 0, wxALL | wxEXPAND, 5);
}
// language selection
#if 0
{
auto* sizer = new wxStaticBoxSizer(wxVERTICAL, result, _("Game paths"));
m_page1.languageBoxSizer = new wxStaticBoxSizer(wxVERTICAL, mainPanel, _("Language"));
m_page1.languageText = new wxStaticText(m_page1.languageBoxSizer->GetStaticBox(), wxID_ANY, _("Select the language you want to use in Cemu"));
m_page1.languageBoxSizer->Add(m_page1.languageText, 0, wxALL, 5);
sizer->Add(new wxStaticText(sizer->GetStaticBox(), wxID_ANY, _("The game path is scanned by Cemu to locate your games. We recommend creating a dedicated directory in which\nyou place all your Wii U games. (example: C:\\wiiu\\games\\)\n\nYou can also set additional paths in the general settings of Cemu.")), 0, wxALL, 5);
wxString language_choices[] = { _("Default") };
wxChoice* m_language = new wxChoice(m_page1.languageBoxSizer->GetStaticBox(), wxID_ANY, wxDefaultPosition, wxDefaultSize, std::size(language_choices), language_choices);
m_language->SetSelection(0);
for (const auto& language : wxGetApp().GetLanguages())
{
m_language->Append(language->DescriptionNative);
}
m_language->SetSelection(0);
m_page1.languageBoxSizer->Add(m_language, 0, wxALL | wxEXPAND, 5);
page1_sizer->Add(m_page1.languageBoxSizer, 0, wxALL | wxEXPAND, 5);
m_language->Bind(wxEVT_CHOICE, [this, m_language](const auto&)
{
const auto language = m_language->GetStringSelection();
auto selection = m_language->GetSelection();
if (selection == 0)
GetConfig().language = wxLANGUAGE_DEFAULT;
else
{
auto* app = (CemuApp*)wxTheApp;
const auto language = m_language->GetStringSelection();
for (const auto& lang : app->GetLanguages())
{
if (lang->DescriptionNative == language)
{
app->LocalizeUI(static_cast<wxLanguage>(lang->Language));
wxCommandEvent event(EVT_REFRESH_FIRST_PAGE);
wxPostEvent(this, event);
break;
}
}
}
});
}
#endif
{
m_page1.gamePathBoxSizer = new wxStaticBoxSizer(wxVERTICAL, mainPanel, _("Game paths"));
m_page1.gamePathText = new wxStaticText(m_page1.gamePathBoxSizer->GetStaticBox(), wxID_ANY, _("The game path is scanned by Cemu to automatically locate your games, game updates and DLCs. We recommend creating a dedicated directory in which\nyou place all your Wii U game files. Additional paths can be set later in Cemu's general settings. All common Wii U game formats are supported by Cemu."));
m_page1.gamePathBoxSizer->Add(m_page1.gamePathText, 0, wxALL, 5);
auto* game_path_sizer = new wxBoxSizer(wxHORIZONTAL);
game_path_sizer->Add(new wxStaticText(sizer->GetStaticBox(), wxID_ANY, _("Game path")), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
m_page1.gamePathText2 = new wxStaticText(m_page1.gamePathBoxSizer->GetStaticBox(), wxID_ANY, _("Game path"));
game_path_sizer->Add(m_page1.gamePathText2, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
m_game_path = new wxDirPickerCtrl(sizer->GetStaticBox(), wxID_ANY, wxEmptyString, _("Select a folder"));
game_path_sizer->Add(m_game_path, 1, wxALL, 5);
m_page1.gamePathPicker = new wxDirPickerCtrl(m_page1.gamePathBoxSizer->GetStaticBox(), wxID_ANY, wxEmptyString, _("Select a folder"));
game_path_sizer->Add(m_page1.gamePathPicker, 1, wxALL, 5);
sizer->Add(game_path_sizer, 0, wxEXPAND, 5);
m_page1.gamePathBoxSizer->Add(game_path_sizer, 0, wxEXPAND, 5);
page1_sizer->Add(sizer, 0, wxALL | wxEXPAND, 5);
page1_sizer->Add(m_page1.gamePathBoxSizer, 0, wxALL | wxEXPAND, 5);
}
{
auto* sizer = new wxStaticBoxSizer(wxVERTICAL, result, _("Graphic packs"));
auto* sizer = new wxStaticBoxSizer(wxVERTICAL, mainPanel, _("Graphic packs && mods"));
sizer->Add(new wxStaticText(sizer->GetStaticBox(), wxID_ANY, _("Graphic packs improve games by offering the possibility to change resolution, tweak FPS or add other visual or gameplay modifications.\nDownload the community graphic packs to get started.\n")), 0, wxALL, 5);
sizer->Add(new wxStaticText(sizer->GetStaticBox(), wxID_ANY, _("Graphic packs improve games by offering the ability to change resolution, increase FPS, tweak visuals or add gameplay modifications.\nGet started by opening the graphic packs configuration window.\n")), 0, wxALL, 5);
auto* download_gp = new wxButton(sizer->GetStaticBox(), wxID_ANY, _("Download community graphic packs"));
download_gp->Bind(wxEVT_BUTTON, &GettingStartedDialog::OnDownloadGPs, this);
auto* download_gp = new wxButton(sizer->GetStaticBox(), wxID_ANY, _("Download and configure graphic packs"));
download_gp->Bind(wxEVT_BUTTON, &GettingStartedDialog::OnConfigureGPs, this);
sizer->Add(download_gp, 0, wxALIGN_CENTER | wxALL, 5);
page1_sizer->Add(sizer, 0, wxALL | wxEXPAND, 5);
@ -102,16 +127,15 @@ wxPanel* GettingStartedDialog::CreatePage1()
sizer->SetFlexibleDirection(wxBOTH);
sizer->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_ALL);
auto* next = new wxButton(result, wxID_ANY, _("Next"), wxDefaultPosition, wxDefaultSize, 0);
auto* next = new wxButton(mainPanel, wxID_ANY, _("Next"), wxDefaultPosition, wxDefaultSize, 0);
next->Bind(wxEVT_BUTTON, [this](const auto&){m_notebook->SetSelection(1); });
sizer->Add(next, 0, wxALIGN_BOTTOM | wxALIGN_RIGHT | wxALL, 5);
page1_sizer->Add(sizer, 1, wxEXPAND, 5);
}
result->SetSizer(page1_sizer);
return result;
mainPanel->SetSizer(page1_sizer);
return mainPanel;
}
wxPanel* GettingStartedDialog::CreatePage2()
@ -138,17 +162,17 @@ wxPanel* GettingStartedDialog::CreatePage2()
option_sizer->SetFlexibleDirection(wxBOTH);
option_sizer->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_SPECIFIED);
m_fullscreen = new wxCheckBox(sizer->GetStaticBox(), wxID_ANY, _("Start games with fullscreen"));
option_sizer->Add(m_fullscreen, 0, wxALL, 5);
m_page2.fullscreenCheckbox = new wxCheckBox(sizer->GetStaticBox(), wxID_ANY, _("Start games with fullscreen"));
option_sizer->Add(m_page2.fullscreenCheckbox, 0, wxALL, 5);
m_separate = new wxCheckBox(sizer->GetStaticBox(), wxID_ANY, _("Open separate pad screen"));
option_sizer->Add(m_separate, 0, wxALL, 5);
m_page2.separateCheckbox = new wxCheckBox(sizer->GetStaticBox(), wxID_ANY, _("Open separate pad screen"));
option_sizer->Add(m_page2.separateCheckbox, 0, wxALL, 5);
m_update = new wxCheckBox(sizer->GetStaticBox(), wxID_ANY, _("Automatically check for updates"));
option_sizer->Add(m_update, 0, wxALL, 5);
m_page2.updateCheckbox = new wxCheckBox(sizer->GetStaticBox(), wxID_ANY, _("Automatically check for updates"));
option_sizer->Add(m_page2.updateCheckbox, 0, wxALL, 5);
#if BOOST_OS_LINUX
if (!std::getenv("APPIMAGE")) {
m_update->Disable();
m_page2.updateCheckbox->Disable();
}
#endif
sizer->Add(option_sizer, 1, wxEXPAND, 5);
@ -162,10 +186,6 @@ wxPanel* GettingStartedDialog::CreatePage2()
sizer->SetFlexibleDirection(wxBOTH);
sizer->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_ALL);
m_dont_show = new wxCheckBox(result, wxID_ANY, _("Don't show this again"));
m_dont_show->SetValue(true);
sizer->Add(m_dont_show, 0, wxALIGN_BOTTOM | wxALL, 5);
auto* previous = new wxButton(result, wxID_ANY, _("Previous"));
previous->Bind(wxEVT_BUTTON, [this](const auto&) {m_notebook->SetSelection(0); });
sizer->Add(previous, 0, wxALIGN_BOTTOM | wxALIGN_RIGHT | wxALL, 5);
@ -184,23 +204,9 @@ wxPanel* GettingStartedDialog::CreatePage2()
void GettingStartedDialog::ApplySettings()
{
auto& config = GetConfig();
m_fullscreen->SetValue(config.fullscreen.GetValue());
m_update->SetValue(config.check_update.GetValue());
m_separate->SetValue(config.pad_open.GetValue());
m_dont_show->SetValue(true); // we want it always enabled by default
m_mlc_folder->SetPath(config.mlc_path.GetValue());
try
{
const auto pconfig = PermanentConfig::Load();
if(!pconfig.custom_mlc_path.empty())
{
m_mlc_folder->SetPath(wxString::FromUTF8(pconfig.custom_mlc_path));
m_prev_mlc_warning->Show(true);
}
}
catch (const PSDisabledException&) {}
catch (...) {}
m_page2.fullscreenCheckbox->SetValue(config.fullscreen.GetValue());
m_page2.updateCheckbox->SetValue(config.check_update.GetValue());
m_page2.separateCheckbox->SetValue(config.pad_open.GetValue());
}
void GettingStartedDialog::UpdateWindowSize()
@ -219,46 +225,25 @@ void GettingStartedDialog::OnClose(wxCloseEvent& event)
event.Skip();
auto& config = GetConfig();
config.fullscreen = m_fullscreen->GetValue();
config.check_update = m_update->GetValue();
config.pad_open = m_separate->GetValue();
config.did_show_graphic_pack_download = m_dont_show->GetValue();
config.fullscreen = m_page2.fullscreenCheckbox->GetValue();
config.check_update = m_page2.updateCheckbox->GetValue();
config.pad_open = m_page2.separateCheckbox->GetValue();
const fs::path gamePath = wxHelper::MakeFSPath(m_game_path->GetPath());
if (!gamePath.empty() && fs::exists(gamePath))
const fs::path gamePath = wxHelper::MakeFSPath(m_page1.gamePathPicker->GetPath());
std::error_code ec;
if (!gamePath.empty() && fs::exists(gamePath, ec))
{
const auto it = std::find(config.game_paths.cbegin(), config.game_paths.cend(), gamePath);
if (it == config.game_paths.cend())
{
config.game_paths.emplace_back(_pathToUtf8(gamePath));
m_game_path_changed = true;
}
}
const fs::path mlcPath = wxHelper::MakeFSPath(m_mlc_folder->GetPath());
if(config.mlc_path.GetValue() != mlcPath && (mlcPath.empty() || fs::exists(mlcPath)))
{
config.SetMLCPath(mlcPath, false);
m_mlc_changed = true;
}
g_config.Save();
if(m_mlc_changed)
CemuApp::CreateDefaultFiles();
CafeTitleList::ClearScanPaths();
for (auto& it : GetConfig().game_paths)
CafeTitleList::AddScanPath(_utf8ToPath(it));
CafeTitleList::Refresh();
}
GettingStartedDialog::GettingStartedDialog(wxWindow* parent)
: wxDialog(parent, wxID_ANY, _("Getting started"), wxDefaultPosition, { 740,530 }, wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER)
{
//this->SetSizeHints(wxDefaultSize, { 740,530 });
auto* sizer = new wxBoxSizer(wxVERTICAL);
m_notebook = new wxSimplebook(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, 0);
@ -274,24 +259,18 @@ GettingStartedDialog::GettingStartedDialog(wxWindow* parent)
this->SetSizer(sizer);
this->Centre(wxBOTH);
this->Bind(wxEVT_CLOSE_WINDOW, &GettingStartedDialog::OnClose, this);
ApplySettings();
UpdateWindowSize();
}
void GettingStartedDialog::OnDownloadGPs(wxCommandEvent& event)
void GettingStartedDialog::OnConfigureGPs(wxCommandEvent& event)
{
DownloadGraphicPacksWindow dialog(this);
dialog.ShowModal();
GraphicPacksWindow2::RefreshGraphicPacks();
wxMessageDialog ask_dialog(this, _("Do you want to view the downloaded graphic packs?"), _("Graphic packs"), wxCENTRE | wxYES_NO);
if (ask_dialog.ShowModal() == wxID_YES)
{
GraphicPacksWindow2 window(this, 0);
window.ShowModal();
}
GraphicPacksWindow2 window(this, 0);
window.ShowModal();
}
void GettingStartedDialog::OnInputSettings(wxCommandEvent& event)
@ -299,20 +278,3 @@ void GettingStartedDialog::OnInputSettings(wxCommandEvent& event)
InputSettings2 dialog(this);
dialog.ShowModal();
}
void GettingStartedDialog::OnMLCPathChar(wxKeyEvent& event)
{
//if (LaunchSettings::GetMLCPath().has_value())
// return;
if (event.GetKeyCode() == WXK_DELETE || event.GetKeyCode() == WXK_BACK)
{
m_mlc_folder->GetTextCtrl()->SetValue(wxEmptyString);
if(m_prev_mlc_warning->IsShown())
{
m_prev_mlc_warning->Show(false);
UpdateWindowSize();
}
}
}

34
src/gui/GettingStartedDialog.h
View file

@ -13,9 +13,6 @@ class GettingStartedDialog : public wxDialog
public:
GettingStartedDialog(wxWindow* parent = nullptr);
[[nodiscard]] bool HasGamePathChanged() const { return m_game_path_changed; }
[[nodiscard]] bool HasMLCChanged() const { return m_mlc_changed; }
private:
wxPanel* CreatePage1();
wxPanel* CreatePage2();
@ -23,22 +20,29 @@ private:
void UpdateWindowSize();
void OnClose(wxCloseEvent& event);
void OnDownloadGPs(wxCommandEvent& event);
void OnConfigureGPs(wxCommandEvent& event);
void OnInputSettings(wxCommandEvent& event);
void OnMLCPathChar(wxKeyEvent& event);
wxSimplebook* m_notebook;
wxCheckBox* m_fullscreen;
wxCheckBox* m_separate;
wxCheckBox* m_update;
wxCheckBox* m_dont_show;
wxStaticBoxSizer* m_mlc_box_sizer;
wxStaticText* m_prev_mlc_warning;
wxDirPickerCtrl* m_mlc_folder;
wxDirPickerCtrl* m_game_path;
struct
{
// header
wxStaticText* staticText11{};
wxStaticText* portableModeInfoText{};
bool m_game_path_changed = false;
bool m_mlc_changed = false;
// game path box
wxStaticBoxSizer* gamePathBoxSizer{};
wxStaticText* gamePathText{};
wxStaticText* gamePathText2{};
wxDirPickerCtrl* gamePathPicker{};
}m_page1;
struct
{
wxCheckBox* fullscreenCheckbox;
wxCheckBox* separateCheckbox;
wxCheckBox* updateCheckbox;
}m_page2;
};

30
src/gui/MainWindow.cpp
View file

@ -149,8 +149,6 @@ enum
// help
MAINFRAME_MENU_ID_HELP_ABOUT = 21700,
MAINFRAME_MENU_ID_HELP_UPDATE,
MAINFRAME_MENU_ID_HELP_GETTING_STARTED,
// custom
MAINFRAME_ID_TIMER1 = 21800,
};
@ -225,7 +223,6 @@ EVT_MENU(MAINFRAME_MENU_ID_DEBUG_VIEW_TEXTURE_RELATIONS, MainWindow::OnDebugView
// help menu
EVT_MENU(MAINFRAME_MENU_ID_HELP_ABOUT, MainWindow::OnHelpAbout)
EVT_MENU(MAINFRAME_MENU_ID_HELP_UPDATE, MainWindow::OnHelpUpdate)
EVT_MENU(MAINFRAME_MENU_ID_HELP_GETTING_STARTED, MainWindow::OnHelpGettingStarted)
// misc
EVT_COMMAND(wxID_ANY, wxEVT_REQUEST_GAMELIST_REFRESH, MainWindow::OnRequestGameListRefresh)
@ -418,25 +415,6 @@ wxString MainWindow::GetInitialWindowTitle()
return BUILD_VERSION_WITH_NAME_STRING;
}
void MainWindow::ShowGettingStartedDialog()
{
GettingStartedDialog dia(this);
dia.ShowModal();
if (dia.HasGamePathChanged() || dia.HasMLCChanged())
m_game_list->ReloadGameEntries();
TogglePadView();
auto& config = GetConfig();
m_padViewMenuItem->Check(config.pad_open.GetValue());
m_fullscreenMenuItem->Check(config.fullscreen.GetValue());
}
namespace coreinit
{
void OSSchedulerEnd();
};
void MainWindow::OnClose(wxCloseEvent& event)
{
wxTheClipboard->Flush();
@ -2075,11 +2053,6 @@ void MainWindow::OnHelpUpdate(wxCommandEvent& event)
test.ShowModal();
}
void MainWindow::OnHelpGettingStarted(wxCommandEvent& event)
{
ShowGettingStartedDialog();
}
void MainWindow::RecreateMenu()
{
if (m_menuBar)
@ -2303,8 +2276,7 @@ void MainWindow::RecreateMenu()
if (!std::getenv("APPIMAGE")) {
m_check_update_menu->Enable(false);
}
#endif
helpMenu->Append(MAINFRAME_MENU_ID_HELP_GETTING_STARTED, _("&Getting started"));
#endif
helpMenu->AppendSeparator();
helpMenu->Append(MAINFRAME_MENU_ID_HELP_ABOUT, _("&About Cemu"));

2
src/gui/MainWindow.h
View file

@ -103,7 +103,6 @@ public:
void OnAccountSelect(wxCommandEvent& event);
void OnConsoleLanguage(wxCommandEvent& event);
void OnHelpAbout(wxCommandEvent& event);
void OnHelpGettingStarted(wxCommandEvent& event);
void OnHelpUpdate(wxCommandEvent& event);
void OnDebugSetting(wxCommandEvent& event);
void OnDebugLoggingToggleFlagGeneric(wxCommandEvent& event);
@ -150,7 +149,6 @@ private:
void RecreateMenu();
void UpdateChildWindowTitleRunningState();
static wxString GetInitialWindowTitle();
void ShowGettingStartedDialog();
bool InstallUpdate(const fs::path& metaFilePath);