#include "guis/GuiMenu.h"
#include "components/OptionListComponent.h"
#include "components/SliderComponent.h"
#include "components/SwitchComponent.h"
#include "guis/GuiCollectionSystemsOptions.h"
#include "guis/GuiDetectDevice.h"
#include "guis/GuiGeneralScreensaverOptions.h"
#include "guis/GuiMsgBox.h"
#include "guis/GuiScraperStart.h"
#include "guis/GuiPackageInstaller.h" //351elec
#include "guis/GuiDecorationOptions.h" //351elec
#include "guis/GuiHashStart.h"
#include "guis/GuiThemeInstaller.h" //batocera
#include "guis/GuiBezelInstaller.h" //batocera
#include "guis/GuiBatoceraStore.h" //batocera
#include "guis/GuiSettings.h"
#include "guis/GuiRetroAchievements.h" //batocera
#include "guis/GuiGamelistOptions.h"
#include "guis/GuiImageViewer.h"
#include "views/UIModeController.h"
#include "views/ViewController.h"
#include "CollectionSystemManager.h"
#include "EmulationStation.h"
#include "Scripting.h"
#include "SystemData.h"
#include "VolumeControl.h"
#include <SDL_events.h>
#include <algorithm>
#include "platform.h"
#include "SystemConf.h"
#include "ApiSystem.h"
#include "InputManager.h"
#include "AudioManager.h"
#include <LibretroRatio.h>
#include "guis/GuiUpdate.h"
#include "guis/GuiInstallStart.h"
#include "guis/GuiTextEditPopupKeyboard.h"
#include "guis/GuiBackupStart.h"
#include "guis/GuiTextEditPopup.h"
#include "guis/GuiWifi.h"
#include "guis/GuiBluetooth.h"
#include "scrapers/ThreadedScraper.h"
#include "FileSorts.h"
#include "ThreadedHasher.h"
#include "ThreadedBluetooth.h"
#include "views/gamelist/IGameListView.h"
#include "components/MultiLineMenuEntry.h"
#include "components/BatteryIndicatorComponent.h"
#include "GuiLoading.h"
#include "guis/GuiBios.h"
#include "guis/GuiKeyMappingEditor.h"
#include "Gamelist.h"
#include "TextToSpeech.h"
#if WIN32
#include "Win32ApiSystem.h"
#endif
#define fake_gettext_fade _("fade")
#define fake_gettext_slide _("slide")
#define fake_gettext_instant _("instant")
#define fake_gettext_fadeslide _("fade & slide")
// batocera-info
#define fake_gettext_system _("System")
#define fake_gettext_architecture _("Architecture")
#define fake_gettext_diskformat _("Disk format")
#define fake_gettext_temperature _("Temperature")
#define fake_gettext_avail_memory _("Available memory")
#define fake_gettext_battery _("Battery")
#define fake_gettext_model _("Model")
#define fake_gettext_cpu_model _("Cpu model")
#define fake_gettext_cpu_number _("Cpu number")
#define fake_gettext_cpu_frequency _("Cpu max frequency")
#define fake_gettext_cpu_feature _("Cpu feature")
#define fake_gettext_scanlines _("SCANLINES")
#define fake_gettext_retro _("RETRO")
#define fake_gettext_enhanced _("ENHANCED")
#define fake_gettext_curvature _("CURVATURE")
#define fake_gettext_zfast _("ZFAST")
#define fake_gettext_flatten_glow _("FLATTEN-GLOW")
#define fake_gettext_rgascaling _("RGA SCALING")
#define fake_gettext_glvendor _("VENDOR")
#define fake_gettext_glvrenderer _("RENDERER")
#define fake_gettext_glversion _("VERSION")
#define fake_gettext_glslversion _("SHADERS")
#define gettext_controllers_settings _("CONTROLLER SETTINGS")
#define gettext_controllers_and_bluetooth_settings _("CONTROLLER & BLUETOOTH SETTINGS")
// Windows build does not have bluetooth support, so affect the label for Windows
#if WIN32
#define controllers_settings_label gettext_controllers_settings
#else
#define controllers_settings_label gettext_controllers_and_bluetooth_settings
#endif
GuiMenu::GuiMenu(Window *window, bool animate) : GuiComponent(window), mMenu(window, _("MAIN MENU").c_str()), mVersion(window)
{
// MAIN MENU
bool isFullUI = UIModeController::getInstance()->isUIModeFull();
#ifdef _ENABLEEMUELEC
bool isKidUI = UIModeController::getInstance()->isUIModeKid();
#endif
// KODI >
// GAMES SETTINGS >
// CONTROLLER & BLUETOOTH >
// UI SETTINGS >
// SOUND SETTINGS >
// NETWORK >
// SCRAPER >
// SYSTEM SETTINGS >
// QUIT >
// KODI
#ifdef _ENABLE_KODI_
if (SystemConf::getInstance()->getBool("kodi.enabled", true) && ApiSystem::getInstance()->isScriptingSupported(ApiSystem::KODI))
addEntry(_("KODI MEDIA CENTER").c_str(), false, [this]
{
Window *window = mWindow;
delete this;
if (!ApiSystem::getInstance()->launchKodi(window))
LOG(LogWarning) << "Shutdown terminated with non-zero result!";
}, "iconKodi");
#endif
if (isFullUI)
{
#if !defined(WIN32) || defined(_DEBUG)
addEntry(_("GAME SETTINGS").c_str(), true, [this] { openGamesSettings_batocera(); }, "iconGames");
addEntry(_("GAME COLLECTION SETTINGS").c_str(), true, [this] { openCollectionSystemSettings(); }, "iconAdvanced");
if (ApiSystem::getInstance()->isScriptingSupported(ApiSystem::RETROACHIVEMENTS) &&
SystemConf::getInstance()->getBool("global.retroachievements") &&
Settings::getInstance()->getBool("RetroachievementsMenuitem") &&
SystemConf::getInstance()->get("global.retroachievements.username") != "")
addEntry(_("RETROACHIEVEMENTS").c_str(), true, [this] { GuiRetroAchievements::show(mWindow); }, "iconRetroachievements");
#ifdef _ENABLEEMUELEC
addEntry(_("SYSTEM SETTINGS").c_str(), true, [this] { openSystemSettings_batocera(); }, "iconSystem");
//addEntry(_("EMULATIONSTATION SETTINGS").c_str(), true, [this] { openEmuELECSettings(); }, "iconEmuelec");
#endif
addEntry(_("UI SETTINGS").c_str(), true, [this] { openUISettings(); }, "iconUI");
//addEntry(_("CONTROLLERS SETTINGS").c_str(), true, [this] { openControllersSettings_batocera(); }, "iconControllers");
addEntry(_("SOUND SETTINGS").c_str(), true, [this] { openSoundSettings(); }, "iconSound");
if (ApiSystem::getInstance()->isScriptingSupported(ApiSystem::WIFI))
addEntry(_("NETWORK SETTINGS").c_str(), true, [this] { openNetworkSettings_batocera(); }, "iconNetwork");
#else
if (ApiSystem::getInstance()->isScriptingSupported(ApiSystem::GAMESETTINGS))
addEntry(_("GAME SETTINGS").c_str(), true, [this] { openGamesSettings_batocera(); }, "iconGames");
addEntry(_("UI SETTINGS").c_str(), true, [this] { openUISettings(); }, "iconUI");
if (ApiSystem::getInstance()->isScriptingSupported(ApiSystem::GAMESETTINGS))
addEntry(controllers_settings_label.c_str(), true, [this] { openControllersSettings_batocera(); }, "iconControllers");
else
addEntry(_("CONFIGURE INPUT"), true, [this] { openConfigInput(); }, "iconControllers");
addEntry(_("SOUND SETTINGS").c_str(), true, [this] { openSoundSettings(); }, "iconSound");
addEntry(_("GAME COLLECTION SETTINGS").c_str(), true, [this] { openCollectionSystemSettings(); }, "iconAdvanced");
if (!ApiSystem::getInstance()->isScriptingSupported(ApiSystem::GAMESETTINGS))
{
for (auto system : SystemData::sSystemVector)
{
if (system->isCollection() || system->getEmulators().size() == 0 || (system->getEmulators().size() == 1 && system->getEmulators().begin()->cores.size() <= 1))
continue;
addEntry(_("EMULATOR SETTINGS"), true, [this] { openEmulatorSettings(); }, "iconGames");
break;
}
}
#endif
addEntry(_("SCRAPER").c_str(), true, [this] { openScraperSettings(); }, "iconScraper");
addEntry(_("UPDATES & DOWNLOADS"), true, [this] { openUpdatesSettings(); }, "iconUpdates");
}
else
{
if (ApiSystem::getInstance()->isScriptingSupported(ApiSystem::RETROACHIVEMENTS) &&
SystemConf::getInstance()->getBool("global.retroachievements") &&
Settings::getInstance()->getBool("RetroachievementsMenuitem") &&
SystemConf::getInstance()->get("global.retroachievements.username") != "")
addEntry(_("RETROACHIEVEMENTS").c_str(), true, [this] { GuiRetroAchievements::show(mWindow); }, "iconRetroachievements");
addEntry(_("INFORMATION").c_str(), true, [this] { openSystemInformations_batocera(); }, "iconSystem");
addEntry(_("UNLOCK UI MODE").c_str(), true, [this] { exitKidMode(); }, "iconAdvanced");
}
#ifdef WIN32
addEntry(_("QUIT").c_str(), !Settings::getInstance()->getBool("ShowOnlyExit"), [this] {openQuitMenu_batocera(); }, "iconQuit");
#else
#ifdef _ENABLEEMUELEC
if (!isKidUI) {
addEntry(_("QUIT").c_str(), true, [this] { openQuitMenu_batocera(); }, "iconQuit");
}
#else
addEntry(_("QUIT").c_str(), true, [this] { openQuitMenu_batocera(); }, "iconQuit");
#endif
#endif
addChild(&mMenu);
addVersionInfo(); // batocera
setSize(mMenu.getSize());
if (animate)
{
if (Renderer::isSmallScreen())
animateTo(Vector2f((Renderer::getScreenWidth() - getSize().x()) / 2, (Renderer::getScreenHeight() - getSize().y()) / 2));
else
animateTo(Vector2f((Renderer::getScreenWidth() - mSize.x()) / 2, Renderer::getScreenHeight() * 0.15f));
}
else
{
if (Renderer::isSmallScreen())
setPosition((Renderer::getScreenWidth() - mSize.x()) / 2, (Renderer::getScreenHeight() - mSize.y()) / 2);
else
setPosition((Renderer::getScreenWidth() - mSize.x()) / 2, Renderer::getScreenHeight() * 0.15f);
}
}
#ifdef _ENABLEEMUELEC
/* < emuelec */
void GuiMenu::openEmuELECSettings()
{
auto s = new GuiSettings(mWindow, "EmulationStation Settings");
Window* window = mWindow;
std::string a;
#if !defined(_ENABLEGAMEFORCE) && !defined(ODROIDGOA)
/*
auto emuelec_video_mode = std::make_shared< OptionListComponent<std::string> >(mWindow, "VIDEO MODE", false);
std::vector<std::string> videomode;
videomode.push_back("1080p60hz");
videomode.push_back("1080i60hz");
videomode.push_back("720p60hz");
videomode.push_back("720p50hz");
videomode.push_back("480p60hz");
videomode.push_back("480cvbs");
videomode.push_back("576p50hz");
videomode.push_back("1080p50hz");
videomode.push_back("1080i50hz");
videomode.push_back("576cvbs");
videomode.push_back("Custom");
videomode.push_back("-- AUTO-DETECTED RESOLUTIONS --");
for(std::stringstream ss(getShOutput(R"(/usr/bin/emuelec-utils resolutions)")); getline(ss, a, ','); ) {
videomode.push_back(a);
}
for (auto it = videomode.cbegin(); it != videomode.cend(); it++) {
emuelec_video_mode->add(*it, *it, SystemConf::getInstance()->get("ee_videomode") == *it); }
s->addWithLabel(_("VIDEO MODE"), emuelec_video_mode);
s->addSaveFunc([this, emuelec_video_mode, window] {
//bool v_need_reboot = false;
if (emuelec_video_mode->changed()) {
std::string selectedVideoMode = emuelec_video_mode->getSelected();
if (emuelec_video_mode->getSelected() != "-- AUTO-DETECTED RESOLUTIONS --") {
if (emuelec_video_mode->getSelected() != "Custom") {
std::string msg = _("You are about to set EmuELEC resolution to:") +"\n" + selectedVideoMode + "\n";
msg += _("Do you want to proceed ?");
window->pushGui(new GuiMsgBox(window, msg,
_("YES"), [selectedVideoMode] {
runSystemCommand("echo "+selectedVideoMode+" > /sys/class/display/mode", "", nullptr);
SystemConf::getInstance()->set("ee_videomode", selectedVideoMode);
LOG(LogInfo) << "Setting video to " << selectedVideoMode;
runSystemCommand("/usr/bin/setres.sh", "", nullptr);
SystemConf::getInstance()->saveSystemConf();
// v_need_reboot = true;
}, _("NO"),nullptr));
} else {
if(Utils::FileSystem::exists("/storage/.config/EE_VIDEO_MODE")) {
runSystemCommand("echo $(cat /storage/.config/EE_VIDEO_MODE) > /sys/class/display/mode", "", nullptr);
LOG(LogInfo) << "Setting custom video mode from /storage/.config/EE_VIDEO_MODE to " << runSystemCommand("cat /storage/.config/EE_VIDEO_MODE", "", nullptr);
SystemConf::getInstance()->set("ee_videomode", selectedVideoMode);
SystemConf::getInstance()->saveSystemConf();
//v_need_reboot = true;
} else {
if(Utils::FileSystem::exists("/flash/EE_VIDEO_MODE")) {
runSystemCommand("echo $(cat /flash/EE_VIDEO_MODE) > /sys/class/display/mode", "", nullptr);
LOG(LogInfo) << "Setting custom video mode from /flash/EE_VIDEO_MODE to " << runSystemCommand("cat /flash/EE_VIDEO_MODE", "", nullptr);
SystemConf::getInstance()->set("ee_videomode", selectedVideoMode);
SystemConf::getInstance()->saveSystemConf();
//v_need_reboot = true;
} else {
runSystemCommand("echo " + SystemConf::getInstance()->get("ee_videomode")+ " > /sys/class/display/mode", "", nullptr);
std::string msg = "/storage/.config/EE_VIDEO_MODE or /flash/EE_VIDEO_MODE not found";
window->pushGui(new GuiMsgBox(window, msg,
"OK", [selectedVideoMode] {
LOG(LogInfo) << "EE_VIDEO_MODE was not found! Setting video mode to " + SystemConf::getInstance()->get("ee_videomode");
}));
}
}
}
}
//if (v_need_reboot)
mWindow->displayNotificationMessage(_U("\uF011 ") + _("A REBOOT OF THE SYSTEM IS REQUIRED TO APPLY THE NEW CONFIGURATION"));
}
});
*/
#endif
#ifdef _ENABLEGAMEFORCE
auto emuelec_blrgboptions_def = std::make_shared< OptionListComponent<std::string> >(mWindow, "BUTTON LED COLOR", false);
std::vector<std::string> blrgboptions;
blrgboptions.push_back("off");
blrgboptions.push_back("red");
blrgboptions.push_back("green");
blrgboptions.push_back("blue");
blrgboptions.push_back("white");
blrgboptions.push_back("purple");
blrgboptions.push_back("yellow");
blrgboptions.push_back("cyan");
auto blrgboptionsS = SystemConf::getInstance()->get("bl_rgb");
if (blrgboptionsS.empty())
blrgboptionsS = "off";
for (auto it = blrgboptions.cbegin(); it != blrgboptions.cend(); it++)
emuelec_blrgboptions_def->add(*it, *it, blrgboptionsS == *it);
s->addWithLabel(_("BUTTON LED COLOR"), emuelec_blrgboptions_def);
s->addSaveFunc([emuelec_blrgboptions_def] {
if (emuelec_blrgboptions_def->changed()) {
std::string selectedblrgb = emuelec_blrgboptions_def->getSelected();
runSystemCommand("/usr/bin/odroidgoa_utils.sh bl " +selectedblrgb, "", nullptr);
SystemConf::getInstance()->set("bl_rgb", selectedblrgb);
SystemConf::getInstance()->saveSystemConf();
}
});
auto emuelec_powerled_def = std::make_shared< OptionListComponent<std::string> >(mWindow, "STATUS LED", false);
std::vector<std::string> powerledoptions;
powerledoptions.push_back("off");
powerledoptions.push_back("heartbeat");
powerledoptions.push_back("on");
auto powerledoptionsS = SystemConf::getInstance()->get("gf_statusled");
if (powerledoptionsS.empty())
powerledoptionsS = "heartbeat";
for (auto it = powerledoptions.cbegin(); it != powerledoptions.cend(); it++)
emuelec_powerled_def->add(*it, *it, powerledoptionsS == *it);
s->addWithLabel(_("STATUS LED"), emuelec_powerled_def);
s->addSaveFunc([emuelec_powerled_def] {
if (emuelec_powerled_def->changed()) {
std::string selectedpowerled = emuelec_powerled_def->getSelected();
runSystemCommand("/usr/bin/odroidgoa_utils.sh pl " +selectedpowerled, "", nullptr);
SystemConf::getInstance()->set("gf_statusled", selectedpowerled);
SystemConf::getInstance()->saveSystemConf();
}
});
#endif
#if !defined(_ENABLEGAMEFORCE) && !defined(ODROIDGOA)
auto emuelec_audiodev_def = std::make_shared< OptionListComponent<std::string> >(mWindow, "AUDIO DEVICE", false);
std::vector<std::string> Audiodevices;
Audiodevices.push_back("auto");
Audiodevices.push_back("0,0");
Audiodevices.push_back("0,1");
Audiodevices.push_back("1,0");
Audiodevices.push_back("1,1");
auto AudiodevicesS = SystemConf::getInstance()->get("ee_audio_device");
if (AudiodevicesS.empty())
AudiodevicesS = "auto";
for (auto it = Audiodevices.cbegin(); it != Audiodevices.cend(); it++)
emuelec_audiodev_def->add(*it, *it, AudiodevicesS == *it);
s->addWithLabel(_("AUDIO DEVICE"), emuelec_audiodev_def);
s->addSaveFunc([emuelec_audiodev_def] {
if (emuelec_audiodev_def->changed()) {
std::string selectedaudiodev = emuelec_audiodev_def->getSelected();
SystemConf::getInstance()->set("ee_audio_device", selectedaudiodev);
SystemConf::getInstance()->saveSystemConf();
}
});
#endif
auto bluetoothd_enabled = std::make_shared<SwitchComponent>(mWindow);
bool btbaseEnabled = SystemConf::getInstance()->get("ee_bluetooth.enabled") == "1";
bluetoothd_enabled->setState(btbaseEnabled);
s->addWithLabel(_("ENABLE BLUETOOTH"), bluetoothd_enabled);
s->addSaveFunc([bluetoothd_enabled] {
if (bluetoothd_enabled->changed()) {
if (bluetoothd_enabled->getState() == false) {
runSystemCommand("systemctl stop bluetooth", "", nullptr);
runSystemCommand("rm /storage/.cache/services/bluez.conf", "", nullptr);
} else {
runSystemCommand("mkdir -p /storage/.cache/services/", "", nullptr);
runSystemCommand("touch /storage/.cache/services/bluez.conf", "", nullptr);
runSystemCommand("systemctl start bluetooth", "", nullptr);
}
bool bluetoothenabled = bluetoothd_enabled->getState();
SystemConf::getInstance()->set("ee_bluetooth.enabled", bluetoothenabled ? "1" : "0");
SystemConf::getInstance()->saveSystemConf();
}
});
auto sshd_enabled = std::make_shared<SwitchComponent>(mWindow);
bool baseEnabled = SystemConf::getInstance()->get("ee_ssh.enabled") == "1";
sshd_enabled->setState(baseEnabled);
s->addWithLabel(_("ENABLE SSH"), sshd_enabled);
s->addSaveFunc([sshd_enabled] {
if (sshd_enabled->changed()) {
if (sshd_enabled->getState() == false) {
runSystemCommand("systemctl stop sshd", "", nullptr);
runSystemCommand("rm /storage/.cache/services/sshd.conf", "", nullptr);
} else {
runSystemCommand("mkdir -p /storage/.cache/services/", "", nullptr);
runSystemCommand("touch /storage/.cache/services/sshd.conf", "", nullptr);
runSystemCommand("systemctl start sshd", "", nullptr);
}
bool sshenabled = sshd_enabled->getState();
SystemConf::getInstance()->set("ee_ssh.enabled", sshenabled ? "1" : "0");
SystemConf::getInstance()->saveSystemConf();
}
});
auto emuelec_boot_def = std::make_shared< OptionListComponent<std::string> >(mWindow, "START AT BOOT", false);
std::vector<std::string> devices;
devices.push_back("Emulationstation");
devices.push_back("Retroarch");
for (auto it = devices.cbegin(); it != devices.cend(); it++)
emuelec_boot_def->add(*it, *it, SystemConf::getInstance()->get("ee_boot") == *it);
s->addWithLabel(_("START AT BOOT"), emuelec_boot_def);
s->addSaveFunc([emuelec_boot_def] {
if (emuelec_boot_def->changed()) {
std::string selectedBootMode = emuelec_boot_def->getSelected();
SystemConf::getInstance()->set("ee_boot", selectedBootMode);
SystemConf::getInstance()->saveSystemConf();
}
});
auto fps_enabled = std::make_shared<SwitchComponent>(mWindow);
bool fpsEnabled = SystemConf::getInstance()->get("global.showFPS") == "1";
fps_enabled->setState(fpsEnabled);
s->addWithLabel(_("SHOW RETROARCH FPS"), fps_enabled);
s->addSaveFunc([fps_enabled] {
bool fpsenabled = fps_enabled->getState();
SystemConf::getInstance()->set("global.showFPS", fpsenabled ? "1" : "0");
SystemConf::getInstance()->saveSystemConf();
});
/*
auto bezels_enabled = std::make_shared<SwitchComponent>(mWindow);
bool bezelsEnabled = SystemConf::getInstance()->get("global.bezel") == "1";
bezels_enabled->setState(bezelsEnabled);
s->addWithLabel(_("ENABLE RA BEZELS"), bezels_enabled);
s->addSaveFunc([bezels_enabled] {
bool bezelsenabled = bezels_enabled->getState();
SystemConf::getInstance()->set("global.bezel", bezelsenabled ? "1" : "0");
SystemConf::getInstance()->saveSystemConf();
});
*/
auto splash_enabled = std::make_shared<SwitchComponent>(mWindow);
bool splashEnabled = SystemConf::getInstance()->get("ee_splash.enabled") == "1";
splash_enabled->setState(splashEnabled);
s->addWithLabel(_("ENABLE RA SPLASH"), splash_enabled);
s->addSaveFunc([splash_enabled] {
bool splashenabled = splash_enabled->getState();
SystemConf::getInstance()->set("ee_splash.enabled", splashenabled ? "1" : "0");
SystemConf::getInstance()->saveSystemConf();
});
auto enable_bootvideo = std::make_shared<SwitchComponent>(mWindow);
bool bootEnabled = SystemConf::getInstance()->get("ee_bootvideo.enabled") == "1";
enable_bootvideo->setState(bootEnabled);
s->addWithLabel(_("ALWAYS SHOW BOOT VIDEO"), enable_bootvideo);
s->addSaveFunc([enable_bootvideo, window] {
bool bootvideoenabled = enable_bootvideo->getState();
SystemConf::getInstance()->set("ee_bootvideo.enabled", bootvideoenabled ? "1" : "0");
SystemConf::getInstance()->saveSystemConf();
});
auto enable_randombootvideo = std::make_shared<SwitchComponent>(mWindow);
bool randombootEnabled = SystemConf::getInstance()->get("ee_randombootvideo.enabled") == "1";
enable_randombootvideo->setState(randombootEnabled);
s->addWithLabel(_("RANDOMIZE BOOT VIDEO"), enable_randombootvideo);
s->addSaveFunc([enable_randombootvideo, window] {
bool randombootvideoenabled = enable_randombootvideo->getState();
SystemConf::getInstance()->set("ee_randombootvideo.enabled", randombootvideoenabled ? "1" : "0");
if (randombootvideoenabled)
SystemConf::getInstance()->set("ee_bootvideo.enabled", "1");
SystemConf::getInstance()->saveSystemConf();
});
s->addInputTextRow(_("DEFAULT YOUTUBE SEARCH WORD"), "youtube.searchword", false);
auto enable_advmamegp = std::make_shared<SwitchComponent>(mWindow);
bool advgpEnabled = SystemConf::getInstance()->get("advmame_auto_gamepad") == "1";
enable_advmamegp->setState(advgpEnabled);
s->addWithLabel(_("AUTO CONFIG ADVANCEMAME GAMEPAD"), enable_advmamegp);
s->addSaveFunc([enable_advmamegp, window] {
bool advmamegpenabled = enable_advmamegp->getState();
SystemConf::getInstance()->set("advmame_auto_gamepad", advmamegpenabled ? "1" : "0");
SystemConf::getInstance()->saveSystemConf();
});
auto emuelec_retroarch_menu_def = std::make_shared< OptionListComponent<std::string> >(mWindow, "RETROARCH MENU", false);
std::vector<std::string> ramenuoptions;
ramenuoptions.push_back("auto");
ramenuoptions.push_back("ozone");
ramenuoptions.push_back("xmb");
ramenuoptions.push_back("rgui");
auto ramenuoptionsS = SystemConf::getInstance()->get("global.retroarch.menu_driver");
if (ramenuoptionsS.empty())
ramenuoptionsS = "auto";
for (auto it = ramenuoptions.cbegin(); it != ramenuoptions.cend(); it++)
emuelec_retroarch_menu_def->add(*it, *it, ramenuoptionsS == *it);
s->addWithLabel(_("RETROARCH MENU"), emuelec_retroarch_menu_def);
s->addSaveFunc([emuelec_retroarch_menu_def] {
if (emuelec_retroarch_menu_def->changed()) {
std::string selectedretroarch_menu = emuelec_retroarch_menu_def->getSelected();
SystemConf::getInstance()->set("global.retroarch.menu_driver", selectedretroarch_menu);
SystemConf::getInstance()->saveSystemConf();
}
});
if (UIModeController::getInstance()->isUIModeFull())
{
//Danger zone options
s->addEntry(_("DANGER ZONE"), true, [this] { openDangerZone(mWindow, "global"); });
}
mWindow->pushGui(s);
}
void GuiMenu::openDangerZone(Window* mWindow, std::string configName)
{
GuiSettings* dangerZone = new GuiSettings(mWindow, _("DANGER ZONE").c_str());
#if defined(_ENABLEGAMEFORCE) || defined(ODROIDGOA)
// OG OC
auto emuelec_oga_overclock = std::make_shared<OptionListComponent<std::string>>(mWindow, _("OVERCLOCK"));
emuelec_oga_overclock->addRange({ { _("Off"), "Off" }, { _("1.4ghz"), "1.4ghz" }, { "1.5ghz", "1.5ghz" } }, SystemConf::getInstance()->get("ee_oga_oc"));
dangerZone->addWithLabel(_("OVERCLOCK"), emuelec_oga_overclock);
dangerZone->addSaveFunc([configName, emuelec_oga_overclock, mWindow] {
auto setOverclock = [emuelec_oga_overclock](const std::string& value)
{
LOG(LogInfo) << "Setting OGA_OC to " + value;
runSystemCommand("/usr/bin/odroidgoa_utils.sh oga_oc " + value, "", nullptr);
SystemConf::getInstance()->set("ee_oga_oc", value);
SystemConf::getInstance()->saveSystemConf();
};
std::string selectedoc = emuelec_oga_overclock->getSelected();
if (emuelec_oga_overclock && emuelec_oga_overclock->changed())
{
if (selectedoc != "Off")
{
std::string msg = _("OGA OC is HIGHLY experimental, you may encounter random lockups or your device might not boot anymore. \n");
msg += _("In case you cannot boot anymore, create an empty file called \"no_oc.oga\" on the boot (EMUELEC) partition.\n\n");
msg += _("There is also the posibility of SD card file corruption!!! Only enable OC if you agree to the risks!\n\n");
msg += _("Do you want to proceed ?");
mWindow->pushGui(new GuiMsgBox(mWindow, msg, _("YES"), [selectedoc, setOverclock]() { setOverclock(selectedoc); }, _("NO"), nullptr));
}
else
setOverclock(selectedoc);
}
});
#endif
dangerZone->addEntry(_("BACKUP CONFIGURATIONS"), true, [mWindow] {
mWindow->pushGui(new GuiMsgBox(mWindow, _("WARNING THIS WILL RESTART EMULATIONSTATION!\n\nAFTER THE SCRIPT IS DONE REMEMBER TO COPY THE FILE /storage/roms/backup/351ELEC_BACKUP.zip TO SOME PLACE SAFE OR IT WILL BE DELETED ON NEXT REBOOT!\n\nBACKUP CURRENT CONFIG AND RESTART?"), _("YES"),
[] {
runSystemCommand("systemd-run /usr/bin/emuelec-utils ee_backup backup", "", nullptr);
}, _("NO"), nullptr));
});
dangerZone->addEntry(_("BACKUP IDENTITY"), true, [mWindow] {
mWindow->pushGui(new GuiMsgBox(mWindow, _("THIS SCRIPT WILL BACK UP THE DEVICE AND USER IDENTITY DATA (PASSWORDS, ETC) SO IT CAN BE RESTORED AFTER FLASHING OR RESTORED ON ANOTHER DEVICE. MOVE /storage/roms/backup/identity.tar.gz SOME PLACE SAFE.\n\nBACKUP DEVICE AND USER IDENTITY?"), _("YES"),
[] {
runSystemCommand("systemd-run /usr/bin/emuelec-utils identity_backup", "", nullptr);
}, _("NO"), nullptr));
});
dangerZone->addEntry(_("RESTORE FROM BACKUP"), true, [mWindow] {
mWindow->pushGui(new GuiMsgBox(mWindow, _("WARNING THIS WILL RESTART EMULATIONSTATION AND REBOOT!\n\nYOUR EXISTING CONFIGURATION WILL BE OVERWRITTEN!\n\nRESTORE FROM BACKUP AND RESTART?"), _("YES"),
[] {
runSystemCommand("systemd-run /usr/bin/emuelec-utils ee_backup restore", "", nullptr);
}, _("NO"), nullptr));
});
dangerZone->addEntry(_("RESET RETROARCH CONFIG TO DEFAULT"), true, [mWindow] {
mWindow->pushGui(new GuiMsgBox(mWindow, _("WARNING: RETROARCH CONFIG WILL RESET TO DEFAULT\n\nPER-CORE CONFIGURATIONS WILL NOT BE AFFECTED BUT NO BACKUP WILL BE CREATED!\n\nRESET RETROARCH CONFIG TO DEFAULT?"), _("YES"),
[] {
runSystemCommand("systemd-run /usr/bin/emuelec-utils clearconfig retroarch", "", nullptr);
}, _("NO"), nullptr));
});
dangerZone->addEntry(_("FACTORY RESET"), true, [mWindow] {
mWindow->pushGui(new GuiMsgBox(mWindow, _("WARNING: RESETTING WILL PRESERVE YOUR PASSWORDS AND NETWORK CONFIGURATION HOWEVER YOUR REMAINING DATA AND ALL OTHER CONFIGURATIONS WILL BE RESET TO DEFAULTS!\n\nIF YOU WANT TO KEEP YOUR SETTINGS MAKE A BACKUP AND SAVE IT ON AN EXTERNAL DRIVE BEFORE RUNING THIS OPTION!\n\nRESET SYSTEM AND RESTART?"), _("YES"),
[] {
runSystemCommand("systemd-run /usr/bin/emuelec-utils clearconfig ALL", "", nullptr);
}, _("NO"), nullptr));
});
/*
dangerZone->addEntry(_("FORCE UPDATE"), true, [mWindow] {
if (ApiSystem::getInstance()->getIpAdress() == "NOT CONNECTED")
{
mWindow->pushGui(new GuiMsgBox(mWindow, _("YOU ARE NOT CONNECTED TO A NETWORK"), _("OK"), nullptr));
return;
}
mWindow->pushGui(new GuiMsgBox(mWindow, _("WARNING: A FORCE UPDATE WILL DOWNLOAD WHATEVER VERSION IS AVAILABLE FOR UPDATE REGARDLESS OF VERSION BASED ON THE TYPE YOU HAVE SELECTED IN THE UPDATE & DOWNLOADS (beta or stable)\n\nSYSTEM WILL RESET SCRIPTS AND BINARIES !\nDOWNLOADS, THEMES, BLUETOOTH PAIRINGS AND ROMS FOLDER WILL NOT BE AFFECTED.\n\nCONTINUE WITH FORCE UPDATE?"), _("YES"),
[] {
runSystemCommand("systemd-run /usr/bin/updatecheck.sh forceupdate", "", nullptr);
}, _("NO"), nullptr));
});
*/
mWindow->pushGui(dangerZone);
}
/* emuelec >*/
#endif
void GuiMenu::openScraperSettings()
{
// scrape now
ComponentListRow row;
auto openScrapeNow = [this]
{
if (!checkNetwork())
return;
if (ThreadedScraper::isRunning())
{
mWindow->pushGui(new GuiMsgBox(mWindow, _("SCRAPER IS RUNNING. DO YOU WANT TO STOP IT?"), _("YES"), [this]
{
ThreadedScraper::stop();
}, _("NO"), nullptr));
return;
}
mWindow->pushGui(new GuiScraperStart(mWindow));
};
auto s = new GuiSettings(mWindow,
_("SCRAPER"),
_("NEXT"), [openScrapeNow](GuiSettings* settings)
{
settings->save();
openScrapeNow();
});
std::string scraper = Settings::getInstance()->getString("Scraper");
// scrape from
auto scraper_list = std::make_shared< OptionListComponent< std::string > >(mWindow, _("SCRAPING DATABASE"), false);
std::vector<std::string> scrapers = Scraper::getScraperList();
// Select either the first entry of the one read from the settings, just in case the scraper from settings has vanished.
for(auto it = scrapers.cbegin(); it != scrapers.cend(); it++)
scraper_list->add(*it, *it, *it == scraper);
s->addWithLabel(_("SCRAPING DATABASE"), scraper_list); // batocera
s->addSaveFunc([scraper_list] { Settings::getInstance()->setString("Scraper", scraper_list->getSelected()); });
if (!scraper_list->hasSelection())
{
scraper_list->selectFirstItem();
scraper = scraper_list->getSelected();
}
if (scraper == "ScreenScraper")
{
// Image source : <image> tag
std::string imageSourceName = Settings::getInstance()->getString("ScrapperImageSrc");
auto imageSource = std::make_shared< OptionListComponent<std::string> >(mWindow, _("IMAGE SOURCE"), false);
imageSource->add(_("SCREENSHOT"), "ss", imageSourceName == "ss");
imageSource->add(_("TITLE SCREENSHOT"), "sstitle", imageSourceName == "sstitle");
imageSource->add(_("MIX V1"), "mixrbv1", imageSourceName == "mixrbv1");
imageSource->add(_("MIX V2"), "mixrbv2", imageSourceName == "mixrbv2");
imageSource->add(_("BOX 2D"), "box-2D", imageSourceName == "box-2D");
imageSource->add(_("BOX 3D"), "box-3D", imageSourceName == "box-3D");
imageSource->add(_("FAN ART"), "fanart", imageSourceName == "fanart");
imageSource->add(_("NONE"), "", imageSourceName.empty());
if (!imageSource->hasSelection())
imageSource->selectFirstItem();
s->addWithLabel(_("IMAGE SOURCE"), imageSource);
s->addSaveFunc([imageSource] { Settings::getInstance()->setString("ScrapperImageSrc", imageSource->getSelected()); });
// Box source : <thumbnail> tag
std::string thumbSourceName = Settings::getInstance()->getString("ScrapperThumbSrc");
auto thumbSource = std::make_shared< OptionListComponent<std::string> >(mWindow, _("BOX SOURCE"), false);
thumbSource->add(_("NONE"), "", thumbSourceName.empty());
thumbSource->add(_("BOX 2D"), "box-2D", thumbSourceName == "box-2D");
thumbSource->add(_("BOX 3D"), "box-3D", thumbSourceName == "box-3D");
if (!thumbSource->hasSelection())
thumbSource->selectFirstItem();
s->addWithLabel(_("BOX SOURCE"), thumbSource);
s->addSaveFunc([thumbSource] { Settings::getInstance()->setString("ScrapperThumbSrc", thumbSource->getSelected()); });
imageSource->setSelectedChangedCallback([this, thumbSource](std::string value)
{
if (value == "box-2D")
thumbSource->remove(_("BOX 2D"));
else
thumbSource->add(_("BOX 2D"), "box-2D", false);
if (value == "box-3D")
thumbSource->remove(_("BOX 3D"));
else
thumbSource->add(_("BOX 3D"), "box-3D", false);
});
// Logo source : <marquee> tag
std::string logoSourceName = Settings::getInstance()->getString("ScrapperLogoSrc");
auto logoSource = std::make_shared< OptionListComponent<std::string> >(mWindow, _("LOGO SOURCE"), false);
logoSource->add(_("NONE"), "", logoSourceName.empty());
logoSource->add(_("WHEEL"), "wheel", logoSourceName == "wheel");
logoSource->add(_("MARQUEE"), "marquee", logoSourceName == "marquee");
if (!logoSource->hasSelection())
logoSource->selectFirstItem();
s->addWithLabel(_("LOGO SOURCE"), logoSource);
s->addSaveFunc([logoSource] { Settings::getInstance()->setString("ScrapperLogoSrc", logoSource->getSelected()); });
// scrape ratings
auto scrape_ratings = std::make_shared<SwitchComponent>(mWindow);
scrape_ratings->setState(Settings::getInstance()->getBool("ScrapeRatings"));
s->addWithLabel(_("SCRAPE RATINGS"), scrape_ratings); // batocera
s->addSaveFunc([scrape_ratings] { Settings::getInstance()->setBool("ScrapeRatings", scrape_ratings->getState()); });
// scrape video
auto scrape_video = std::make_shared<SwitchComponent>(mWindow);
scrape_video->setState(Settings::getInstance()->getBool("ScrapeVideos"));
s->addWithLabel(_("SCRAPE VIDEOS"), scrape_video);
s->addSaveFunc([scrape_video] { Settings::getInstance()->setBool("ScrapeVideos", scrape_video->getState()); });
// SCRAPE FANART
auto scrape_fanart = std::make_shared<SwitchComponent>(mWindow);
scrape_fanart->setState(Settings::getInstance()->getBool("ScrapeFanart"));
s->addWithLabel(_("SCRAPE FANART"), scrape_fanart);
s->addSaveFunc([scrape_fanart] { Settings::getInstance()->setBool("ScrapeFanart", scrape_fanart->getState()); });
// SCRAPE BOX BACKSIDE
auto scrape_boxBack = std::make_shared<SwitchComponent>(mWindow);
scrape_boxBack->setState(Settings::getInstance()->getBool("ScrapeBoxBack"));
s->addWithLabel(_("SCRAPE BOX BACKSIDE"), scrape_boxBack);
s->addSaveFunc([scrape_boxBack] { Settings::getInstance()->setBool("ScrapeBoxBack", scrape_boxBack->getState()); });
// SCRAPE MAP
auto scrape_map = std::make_shared<SwitchComponent>(mWindow);
scrape_map->setState(Settings::getInstance()->getBool("ScrapeMap"));
s->addWithLabel(_("SCRAPE MAP"), scrape_map);
s->addSaveFunc([scrape_map] { Settings::getInstance()->setBool("ScrapeMap", scrape_map->getState()); });
// SCRAPE TITLESHOT
auto scrape_titleshot = std::make_shared<SwitchComponent>(mWindow);
scrape_titleshot->setState(Settings::getInstance()->getBool("ScrapeTitleShot"));
s->addWithLabel(_("SCRAPE TITLESHOT"), scrape_titleshot);
s->addSaveFunc([scrape_titleshot] { Settings::getInstance()->setBool("ScrapeTitleShot", scrape_titleshot->getState()); });
// SCRAPE CARTRIDGE
auto scrape_cartridge = std::make_shared<SwitchComponent>(mWindow);
scrape_cartridge->setState(Settings::getInstance()->getBool("ScrapeCartridge"));
s->addWithLabel(_("SCRAPE CARTRIDGE"), scrape_cartridge);
s->addSaveFunc([scrape_cartridge] { Settings::getInstance()->setBool("ScrapeCartridge", scrape_cartridge->getState()); });
// SCRAPE MANUAL
auto scrape_manual = std::make_shared<SwitchComponent>(mWindow);
scrape_manual->setState(Settings::getInstance()->getBool("ScrapeManual"));
s->addWithLabel(_("SCRAPE MANUAL"), scrape_manual);
s->addSaveFunc([scrape_manual] { Settings::getInstance()->setBool("ScrapeManual", scrape_manual->getState()); });
// SCRAPE PAD TO KEYBOARD
//auto scrapePadToKey = std::make_shared<SwitchComponent>(mWindow);
//scrapePadToKey->setState(Settings::getInstance()->getBool("ScrapePadToKey"));
//s->addWithLabel(_("SCRAPE PADTOKEY SETTINGS"), scrapePadToKey);
//s->addSaveFunc([scrapePadToKey] { Settings::getInstance()->setBool("ScrapePadToKey", scrapePadToKey->getState()); });
// Account
s->addInputTextRow(_("USERNAME"), "ScreenScraperUser", false, true);
s->addInputTextRow(_("PASSWORD"), "ScreenScraperPass", true, true);
}
else
{
std::string imageSourceName = Settings::getInstance()->getString("ScrapperImageSrc");
auto imageSource = std::make_shared< OptionListComponent<std::string> >(mWindow, _("IMAGE SOURCE"), false);
// Image source : <image> tag
imageSource->add(_("SCREENSHOT"), "ss", imageSourceName == "ss");
imageSource->add(_("TITLE SCREENSHOT"), "sstitle", imageSourceName == "sstitle");
imageSource->add(_("BOX 2D"), "box-2D", imageSourceName == "box-2D");
imageSource->add(_("FAN ART"), "fanart", imageSourceName == "fanart");
if (!imageSource->hasSelection())
imageSource->selectFirstItem();
s->addWithLabel(_("IMAGE SOURCE"), imageSource);
s->addSaveFunc([imageSource] { Settings::getInstance()->setString("ScrapperImageSrc", imageSource->getSelected()); });
// Box source : <thumbnail> tag
std::string thumbSourceName = Settings::getInstance()->getString("ScrapperThumbSrc");
auto thumbSource = std::make_shared< OptionListComponent<std::string> >(mWindow, _("BOX SOURCE"), false);
thumbSource->add(_("NONE"), "", thumbSourceName.empty());
thumbSource->add(_("BOX 2D"), "box-2D", thumbSourceName == "box-2D");
if (scraper == "HfsDB")
thumbSource->add(_("BOX 3D"), "box-3D", thumbSourceName == "box-3D");
if (!thumbSource->hasSelection())
thumbSource->selectFirstItem();
s->addWithLabel(_("BOX SOURCE"), thumbSource);
s->addSaveFunc([thumbSource] { Settings::getInstance()->setString("ScrapperThumbSrc", thumbSource->getSelected()); });
imageSource->setSelectedChangedCallback([this, thumbSource](std::string value)
{
if (value == "box-2D")
thumbSource->remove(_("BOX 2D"));
else
thumbSource->add(_("BOX 2D"), "box-2D", false);
});
// Logo source : <marquee> tag
std::string logoSourceName = Settings::getInstance()->getString("ScrapperLogoSrc");
auto logoSource = std::make_shared< OptionListComponent<std::string> >(mWindow, _("LOGO SOURCE"), false);
logoSource->add(_("NONE"), "", logoSourceName.empty());
logoSource->add(_("WHEEL"), "wheel", logoSourceName == "wheel");
if (scraper == "HfsDB")
logoSource->add(_("MARQUEE"), "marquee", logoSourceName == "marquee");
if (!logoSource->hasSelection())
logoSource->selectFirstItem();
s->addWithLabel(_("LOGO SOURCE"), logoSource);
s->addSaveFunc([logoSource] { Settings::getInstance()->setString("ScrapperLogoSrc", logoSource->getSelected()); });
if (scraper == "TheGamesDB")
{
// SCRAPE FANART
auto scrape_fanart = std::make_shared<SwitchComponent>(mWindow);
scrape_fanart->setState(Settings::getInstance()->getBool("ScrapeFanart"));
s->addWithLabel(_("SCRAPE FANART"), scrape_fanart);
s->addSaveFunc([scrape_fanart] { Settings::getInstance()->setBool("ScrapeFanart", scrape_fanart->getState()); });
// SCRAPE BOX BACKSIDE
auto scrape_boxBack = std::make_shared<SwitchComponent>(mWindow);
scrape_boxBack->setState(Settings::getInstance()->getBool("ScrapeBoxBack"));
s->addWithLabel(_("SCRAPE BOX BACKSIDE"), scrape_boxBack);
s->addSaveFunc([scrape_boxBack] { Settings::getInstance()->setBool("ScrapeBoxBack", scrape_boxBack->getState()); });
}
else if (scraper == "HfsDB")
{
// SCRAPE FANART
auto scrape_fanart = std::make_shared<SwitchComponent>(mWindow);
scrape_fanart->setState(Settings::getInstance()->getBool("ScrapeFanart"));
s->addWithLabel(_("SCRAPE FANART"), scrape_fanart);
s->addSaveFunc([scrape_fanart] { Settings::getInstance()->setBool("ScrapeFanart", scrape_fanart->getState()); });
// scrape video
auto scrape_video = std::make_shared<SwitchComponent>(mWindow);
scrape_video->setState(Settings::getInstance()->getBool("ScrapeVideos"));
s->addWithLabel(_("SCRAPE VIDEOS"), scrape_video);
s->addSaveFunc([scrape_video] { Settings::getInstance()->setBool("ScrapeVideos", scrape_video->getState()); });
// SCRAPE BOX BACKSIDE
auto scrape_boxBack = std::make_shared<SwitchComponent>(mWindow);
scrape_boxBack->setState(Settings::getInstance()->getBool("ScrapeBoxBack"));
s->addWithLabel(_("SCRAPE BOX BACKSIDE"), scrape_boxBack);
s->addSaveFunc([scrape_boxBack] { Settings::getInstance()->setBool("ScrapeBoxBack", scrape_boxBack->getState()); });
// SCRAPE MANUAL
auto scrape_manual = std::make_shared<SwitchComponent>(mWindow);
scrape_manual->setState(Settings::getInstance()->getBool("ScrapeManual"));
s->addWithLabel(_("SCRAPE MANUAL"), scrape_manual);
s->addSaveFunc([scrape_manual] { Settings::getInstance()->setBool("ScrapeManual", scrape_manual->getState()); });
}
else
{ // scrape video
auto scrape_video = std::make_shared<SwitchComponent>(mWindow);
scrape_video->setState(Settings::getInstance()->getBool("ScrapeVideos"));
s->addWithLabel(_("SCRAPE VIDEOS"), scrape_video);
s->addSaveFunc([scrape_video] { Settings::getInstance()->setBool("ScrapeVideos", scrape_video->getState()); });
}
}
scraper_list->setSelectedChangedCallback([this, s, scraper, scraper_list](std::string value)
{
if (value != scraper)
{
Settings::getInstance()->setString("Scraper", value);
delete s;
openScraperSettings();
}
});
mWindow->pushGui(s);
}
void GuiMenu::openConfigInput()
{
Window* window = mWindow;
window->pushGui(new GuiMsgBox(window, _("ARE YOU SURE YOU WANT TO CONFIGURE THE INPUT?"),
_("YES"), [window] { window->pushGui(new GuiDetectDevice(window, false, nullptr)); },
_("NO"), nullptr)
);
}
void GuiMenu::addVersionInfo()
{
std::string buildDate = (Settings::getInstance()->getBool("Debug") ? std::string( " (" + Utils::String::toUpper(PROGRAM_BUILT_STRING) + ")") : (""));
auto theme = ThemeData::getMenuTheme();
mVersion.setFont(theme->Footer.font);
mVersion.setColor(theme->Footer.color);
mVersion.setLineSpacing(0);
if (!ApiSystem::getInstance()->getVersion().empty())
{
#if WIN32
std::string aboutInfo = ApiSystem::getInstance()->getApplicationName()+ " V"+ ApiSystem::getInstance()->getVersion();
if (!aboutInfo.empty())
mVersion.setText(aboutInfo + buildDate);
else
#endif
mVersion.setText(ApiSystem::getInstance()->getApplicationName());
}
mVersion.setHorizontalAlignment(ALIGN_CENTER);
mVersion.setVerticalAlignment(ALIGN_CENTER);
addChild(&mVersion);
}
void GuiMenu::openScreensaverOptions()
{
mWindow->pushGui(new GuiGeneralScreensaverOptions(mWindow));
}
void GuiMenu::openCollectionSystemSettings()
{
if (ThreadedScraper::isRunning() || ThreadedHasher::isRunning())
{
mWindow->pushGui(new GuiMsgBox(mWindow, _("THIS FUNCTION IS DISABLED WHILE THE SCRAPER IS RUNNING")));
return;
}
mWindow->pushGui(new GuiCollectionSystemsOptions(mWindow));
}
void GuiMenu::onSizeChanged()
{
float h = mMenu.getButtonGridHeight();
mVersion.setSize(mSize.x(), h);
mVersion.setPosition(0, mSize.y() - h); // mVersion.getSize().y()
}
void GuiMenu::addEntry(std::string name, bool add_arrow, const std::function<void()>& func, const std::string iconName)
{
auto theme = ThemeData::getMenuTheme();
std::shared_ptr<Font> font = theme->Text.font;
unsigned int color = theme->Text.color;
// populate the list
ComponentListRow row;
if (!iconName.empty())
{
std::string iconPath = theme->getMenuIcon(iconName);
if (!iconPath.empty())
{
// icon
auto icon = std::make_shared<ImageComponent>(mWindow, true);
icon->setImage(iconPath);
icon->setColorShift(theme->Text.color);
icon->setResize(0, theme->Text.font->getLetterHeight() * 1.25f);
row.addElement(icon, false);
// spacer between icon and text
auto spacer = std::make_shared<GuiComponent>(mWindow);
spacer->setSize(10, 0);
row.addElement(spacer, false);
}
}
auto text = std::make_shared<TextComponent>(mWindow, name, font, color);
row.addElement(text, true);
if (EsLocale::isRTL())
text->setHorizontalAlignment(Alignment::ALIGN_RIGHT);
if (add_arrow)
{
std::shared_ptr<ImageComponent> bracket = makeArrow(mWindow);
if (EsLocale::isRTL())
bracket->setFlipX(true);
row.addElement(bracket, false);
}
row.makeAcceptInputHandler(func);
mMenu.addRow(row);
}
bool GuiMenu::input(InputConfig* config, Input input)
{
if(GuiComponent::input(config, input))
return true;
if((config->isMappedTo(BUTTON_BACK, input) || config->isMappedTo("start", input)) && input.value != 0)
{
delete this;
return true;
}
return false;
}
std::vector<HelpPrompt> GuiMenu::getHelpPrompts()
{
std::vector<HelpPrompt> prompts;
prompts.push_back(HelpPrompt("up/down", _("CHOOSE"))); // batocera
prompts.push_back(HelpPrompt(BUTTON_OK, _("SELECT"))); // batocera
prompts.push_back(HelpPrompt("start", _("CLOSE"))); // batocera
return prompts;
}
class ExitKidModeMsgBox : public GuiSettings
{
public: ExitKidModeMsgBox(Window* window, const std::string& title, const std::string& text) : GuiSettings(window, title) { addEntry(text); }
bool input(InputConfig* config, Input input) override
{
if (UIModeController::getInstance()->listen(config, input))
{
mWindow->pushGui(new GuiMsgBox(mWindow, _("THE UI MODE IS NOW UNLOCKED"),
_("OK"), [this]
{
Window* window = mWindow;
while (window->peekGui() && window->peekGui() != ViewController::get())
delete window->peekGui();
}));
return true;
}
return GuiComponent::input(config, input);
}
};
void GuiMenu::exitKidMode()
{
mWindow->pushGui(new ExitKidModeMsgBox(mWindow, _("UNLOCK UI MODE"), _("ENTER THE CODE TO UNLOCK THE CURRENT UI MODE")));
}
void GuiMenu::openSystemInformations_batocera()
{
auto theme = ThemeData::getMenuTheme();
std::shared_ptr<Font> font = theme->Text.font;
unsigned int color = theme->Text.color;
Window *window = mWindow;
bool isFullUI = UIModeController::getInstance()->isUIModeFull();
GuiSettings *informationsGui = new GuiSettings(window, _("INFORMATION").c_str());
informationsGui->addGroup(_("INFORMATION"));
auto version = std::make_shared<TextComponent>(window, ApiSystem::getInstance()->getVersion(), font, color);
informationsGui->addWithLabel(_("VERSION"), version);
bool warning = ApiSystem::getInstance()->isFreeSpaceLimit();
auto userspace = std::make_shared<TextComponent>(window,
ApiSystem::getInstance()->getFreeSpaceUserInfo(),
font,
warning ? 0xFF0000FF : color);
informationsGui->addWithLabel(_("USER DISK USAGE"), userspace);
auto systemspace = std::make_shared<TextComponent>(window,
ApiSystem::getInstance()->getFreeSpaceSystemInfo(),
font,
color);
informationsGui->addWithLabel(_("SYSTEM DISK USAGE"), systemspace);
informationsGui->addGroup(_("SYSTEM"));
// various informations
std::vector<std::string> infos = ApiSystem::getInstance()->getSystemInformations();
for (auto it = infos.begin(); it != infos.end(); it++) {
std::vector<std::string> tokens = Utils::String::split(*it, ':');
if (tokens.size() >= 2) {
// concatenat the ending words
std::string vname = "";
for (unsigned int i = 1; i < tokens.size(); i++) {
if (i > 1) vname += " ";
vname += tokens.at(i);
}
auto space = std::make_shared<TextComponent>(window,
vname,
font,
color);
informationsGui->addWithLabel(_(tokens.at(0).c_str()), space);
}
}
informationsGui->addGroup(_("VIDEO DRIVER"));
for (auto info : Renderer::getDriverInformation())
{
auto glversion = std::make_shared<TextComponent>(window, info.second, font, color);
informationsGui->addWithLabel(_(info.first.c_str()), glversion);
}
window->pushGui(informationsGui);
}
void GuiMenu::openDecorationConfiguration(Window *mWindow, std::string configName, std::vector<DecorationSetInfo> sets)
{
//Using a shared pointer to ensure the memory doesn't cause issues in the other class
std::map<std::string, std::string> decorationSetNameToPath;
for (auto set : sets)
{
decorationSetNameToPath.insert(std::make_pair(set.name, set.path));
}
auto decorationOptions = new GuiDecorationOptions(mWindow, configName, decorationSetNameToPath);
mWindow->pushGui(decorationOptions);
}
void GuiMenu::openDeveloperSettings()
{
Window *window = mWindow;
auto s = new GuiSettings(mWindow, _("DEVELOPER").c_str());
s->addGroup(_("VIDEO OPTIONS"));
// maximum vram
auto max_vram = std::make_shared<SliderComponent>(mWindow, 40.f, 1000.f, 10.f, "Mb");
max_vram->setValue((float)(Settings::getInstance()->getInt("MaxVRAM")));
s->addWithLabel(_("VRAM LIMIT"), max_vram);
s->addSaveFunc([max_vram] { Settings::getInstance()->setInt("MaxVRAM", (int)round(max_vram->getValue())); });
// framerate
auto framerate = std::make_shared<SwitchComponent>(mWindow);
framerate->setState(Settings::getInstance()->getBool("DrawFramerate"));
s->addWithLabel(_("SHOW FRAMERATE"), framerate);
s->addSaveFunc([framerate] { Settings::getInstance()->setBool("DrawFramerate", framerate->getState()); });
// vsync
auto vsync = std::make_shared<SwitchComponent>(mWindow);
vsync->setState(Settings::getInstance()->getBool("VSync"));
s->addWithLabel(_("VSYNC"), vsync);
s->addSaveFunc([vsync] { if (Settings::getInstance()->setBool("VSync", vsync->getState())) Renderer::setSwapInterval(); });
#if !defined(WIN32) && !defined _ENABLEEMUELEC || defined(_DEBUG)
// overscan
auto overscan_enabled = std::make_shared<SwitchComponent>(mWindow);
overscan_enabled->setState(Settings::getInstance()->getBool("Overscan"));
s->addWithLabel(_("OVERSCAN"), overscan_enabled);
s->addSaveFunc([overscan_enabled] {
if (Settings::getInstance()->getBool("Overscan") != overscan_enabled->getState()) {
Settings::getInstance()->setBool("Overscan", overscan_enabled->getState());
ApiSystem::getInstance()->setOverscan(overscan_enabled->getState());
}
});
#endif
#ifdef _RPI_
// Video Player - VideoOmxPlayer
auto omx_player = std::make_shared<SwitchComponent>(mWindow);
omx_player->setState(Settings::getInstance()->getBool("VideoOmxPlayer"));
s->addWithLabel(_("USE OMX PLAYER (HARDWARE ACCELERATED)"), omx_player);
s->addSaveFunc([omx_player, window]
{
// need to reload all views to re-create the right video components
bool needReload = false;
if (Settings::getInstance()->getBool("VideoOmxPlayer") != omx_player->getState())
needReload = true;
Settings::getInstance()->setBool("VideoOmxPlayer", omx_player->getState());
if (needReload)
{
ViewController::get()->reloadAll(window);
window->closeSplashScreen();
}
});
#endif
s->addGroup(_("TOOLS"));
// GAME AT STARTUP
/*if (!SystemConf::getInstance()->get("global.bootgame.path").empty())
{
std::string gamelabel = SystemConf::getInstance()->get("global.bootgame.path");
gamelabel = Utils::FileSystem::getStem(gamelabel) + " [" + Utils::FileSystem::getStem(Utils::FileSystem::getParent(gamelabel)) + "]";
s->addWithDescription(_("STOP LAUNCHING THIS GAME AT STARTUP"), gamelabel, nullptr, [s]
{
SystemConf::getInstance()->set("global.bootgame.path", "");
SystemConf::getInstance()->set("global.bootgame.cmd", "");
s->close();
});
}*/
#ifndef _ENABLEEMUELEC
// WEB ACCESS
auto hostName = Utils::String::toLower(ApiSystem::getInstance()->getHostsName());
auto webAccess = std::make_shared<SwitchComponent>(mWindow);
webAccess->setState(Settings::getInstance()->getBool("PublicWebAccess"));
s->addWithDescription(_("ENABLE PUBLIC WEB ACCESS"), Utils::String::format(_("Allow public web access API using %s").c_str(), std::string("http://" + hostName + ":1234").c_str()), webAccess);
s->addSaveFunc([webAccess, window]
{
if (Settings::getInstance()->setBool("PublicWebAccess", webAccess->getState())) {
window->displayNotificationMessage(_U("\uF011 ") + _("REBOOT REQUIRED TO APPLY THE NEW CONFIGURATION"));
if (Settings::getInstance()->getBool("ExitOnRebootRequired")) {
quitES(QuitMode::QUIT);
}
}
});
#endif
// log level
auto logLevel = std::make_shared< OptionListComponent<std::string> >(mWindow, _("LOG LEVEL"), false);
std::vector<std::string> modes;
modes.push_back("default");
#ifdef _ENABLEEMUELEC
modes.push_back("minimal");
#else
modes.push_back("disabled");
#endif
modes.push_back("warning");
modes.push_back("error");
modes.push_back("debug");
auto level = Settings::getInstance()->getString("LogLevel");
if (level.empty())
level = "default";
for (auto it = modes.cbegin(); it != modes.cend(); it++)
logLevel->add(_(it->c_str()), *it, level == *it);
s->addWithLabel(_("LOG LEVEL"), logLevel);
s->addSaveFunc([this, logLevel]
{
if (Settings::getInstance()->setString("LogLevel", logLevel->getSelected() == "default" ? "" : logLevel->getSelected()))
{
Log::setupReportingLevel();
Log::init();
}
});
#if !defined(WIN32) && !defined _ENABLEEMUELEC || defined(_DEBUG)
// support
s->addEntry(_("CREATE A SUPPORT FILE"), true, [window] {
window->pushGui(new GuiMsgBox(window, _("CREATE A SUPPORT FILE?"), _("YES"),
[window] {
if (ApiSystem::getInstance()->generateSupportFile()) {
window->pushGui(new GuiMsgBox(window, _("SUPPORT FILE CREATED IN SAVES FOLDER"), _("OK")));
}
else {
window->pushGui(new GuiMsgBox(window, _("SUPPORT FILE CREATION FAILED"), _("OK")));
}
}, _("NO"), nullptr));
});
#endif
if (ApiSystem::getInstance()->isScriptingSupported(ApiSystem::DISKFORMAT))
s->addEntry(_("FORMAT A DISK"), true, [this] { openFormatDriveSettings(); });
s->addEntry(_("CLEAN GAMELISTS & REMOVE UNUSED MEDIA"), true, [this, s]
{
mWindow->pushGui(new GuiMsgBox(mWindow, _("ARE YOU SURE?"), _("YES"), [&]
{
int idx = 0;
for (auto system : SystemData::sSystemVector)
{
mWindow->renderSplashScreen(_("Cleaning") + ": " + system->getFullName(), (float)idx / (float)SystemData::sSystemVector.size());
cleanupGamelist(system);
idx++;
}
mWindow->closeSplashScreen();
}, _("NO"), nullptr));
});
s->addEntry(_("CLEAR CACHES"), true, [this, s]
{
ImageIO::clearImageCache();
auto rootPath = Utils::FileSystem::getGenericPath(Utils::FileSystem::getEsConfigPath());
Utils::FileSystem::deleteDirectoryFiles(rootPath + "/tmp/");
Utils::FileSystem::deleteDirectoryFiles(Utils::FileSystem::getTempPath());
Utils::FileSystem::deleteDirectoryFiles(Utils::FileSystem::getPdfTempPath());
ViewController::reloadAllGames(mWindow, false);
});
s->addEntry(_("BUILD IMAGE CACHE"), true, [this, s]
{
unsigned int x;
unsigned int y;
int idx = 0;
for (auto sys : SystemData::sSystemVector)
{
if (sys->isCollection())
{
idx++;
continue;
}
mWindow->renderSplashScreen(_("Building image cache") + ": " + sys->getFullName(), (float)idx / (float)SystemData::sSystemVector.size());
for (auto file : sys->getRootFolder()->getFilesRecursive(GAME))
{
for (auto mdd : MetaDataList::getMDD())
{
if (mdd.id != MetaDataId::Image && mdd.id != MetaDataId::Thumbnail)
continue;
auto value = file->getMetadata(mdd.id);
if (value.empty())
continue;
auto ext = Utils::String::toLower(Utils::FileSystem::getExtension(value));
if (ext == ".jpg" || ext == ".png")
ImageIO::loadImageSize(value.c_str(), &x, &y);
}
}
idx++;
}
mWindow->closeSplashScreen();
});
s->addEntry(_("RESET FILE EXTENSIONS"), false, [this, s]
{
for (auto system : SystemData::sSystemVector)
Settings::getInstance()->setString(system->getName() + ".HiddenExt", "");
Settings::getInstance()->saveFile();
ViewController::reloadAllGames(mWindow, false);
});
s->addEntry(_("REDETECT ALL GAMES' LANG/REGION"), false, [this]
{
Window* window = mWindow;
window->pushGui(new GuiLoading<int>(window, _("PLEASE WAIT"), []
{
for (auto system : SystemData::sSystemVector)
{
if (system->isCollection() || !system->isGameSystem())
continue;
for (auto game : system->getRootFolder()->getFilesRecursive(GAME))
game->detectLanguageAndRegion(true);
}
return 0;
}));
});
s->addEntry(_("FIND ALL GAMES WITH NETPLAY/ACHIEVEMENTS"), false, [this] { ThreadedHasher::start(mWindow, ThreadedHasher::HASH_ALL , true); });
s->addGroup(_("DATA MANAGEMENT"));
// ExcludeMultiDiskContent
auto excludeMultiDiskContent = std::make_shared<SwitchComponent>(mWindow);
excludeMultiDiskContent->setState(Settings::getInstance()->getBool("RemoveMultiDiskContent"));
s->addWithLabel(_("IGNORE MULTI-FILE DISK CONTENT (CUE/GDI/CCD/M3U)"), excludeMultiDiskContent);
s->addSaveFunc([excludeMultiDiskContent] { Settings::getInstance()->setBool("RemoveMultiDiskContent", excludeMultiDiskContent->getState()); });
// enable filters (ForceDisableFilters)
auto enable_filter = std::make_shared<SwitchComponent>(mWindow);
enable_filter->setState(!Settings::getInstance()->getBool("ForceDisableFilters"));
s->addWithLabel(_("ENABLE FILTERS"), enable_filter);
s->addSaveFunc([this, enable_filter]
{
Settings::getInstance()->setBool("ForceDisableFilters", !enable_filter->getState());
});
// gamelist saving
auto save_gamelists = std::make_shared<SwitchComponent>(mWindow);
save_gamelists->setState(Settings::getInstance()->getBool("SaveGamelistsOnExit"));
s->addWithLabel(_("SAVE METADATA ON EXIT"), save_gamelists);
s->addSaveFunc([save_gamelists] { Settings::getInstance()->setBool("SaveGamelistsOnExit", save_gamelists->getState()); });
// gamelist
auto parse_gamelists = std::make_shared<SwitchComponent>(mWindow);
parse_gamelists->setState(Settings::getInstance()->getBool("ParseGamelistOnly"));
s->addWithLabel(_("PARSE GAMESLISTS ONLY"), parse_gamelists);
s->addSaveFunc([parse_gamelists] { Settings::getInstance()->setBool("ParseGamelistOnly", parse_gamelists->getState()); });
// Local Art
auto local_art = std::make_shared<SwitchComponent>(mWindow);
local_art->setState(Settings::getInstance()->getBool("LocalArt"));
s->addWithLabel(_("SEARCH FOR LOCAL ART"), local_art);
s->addSaveFunc([local_art] { Settings::getInstance()->setBool("LocalArt", local_art->getState()); });
s->addGroup(_("UI"));
// carousel transition option
auto move_carousel = std::make_shared<SwitchComponent>(mWindow);
move_carousel->setState(Settings::getInstance()->getBool("MoveCarousel"));
s->addWithLabel(_("CAROUSEL TRANSITIONS"), move_carousel);
s->addSaveFunc([move_carousel] { Settings::getInstance()->setBool("MoveCarousel", move_carousel->getState()); });
// quick system select (left/right in game list view)
auto quick_sys_select = std::make_shared<SwitchComponent>(mWindow);
quick_sys_select->setState(Settings::getInstance()->getBool("QuickSystemSelect"));
s->addWithLabel(_("QUICK SYSTEM SELECT"), quick_sys_select);
s->addSaveFunc([quick_sys_select] { Settings::getInstance()->setBool("QuickSystemSelect", quick_sys_select->getState()); });
// Enable OSK (On-Screen-Keyboard)
auto osk_enable = std::make_shared<SwitchComponent>(mWindow);
osk_enable->setState(Settings::getInstance()->getBool("UseOSK"));
s->addWithLabel(_("ON-SCREEN KEYBOARD"), osk_enable);
s->addSaveFunc([osk_enable] { Settings::getInstance()->setBool("UseOSK", osk_enable->getState()); });
#if defined(_WIN32) || defined(X86) || defined(X86_64)
// Hide EmulationStation Window when running a game ( windows only )
auto hideWindowScreen = std::make_shared<SwitchComponent>(mWindow);
hideWindowScreen->setState(Settings::getInstance()->getBool("HideWindow"));
s->addWithLabel(_("HIDE EMULATIONSTATION WHEN RUNNING A GAME"), hideWindowScreen);
s->addSaveFunc([hideWindowScreen] { Settings::getInstance()->setBool("HideWindow", hideWindowScreen->getState()); });
#endif
#if defined(WIN32) && !defined(_DEBUG)
// full exit
auto fullExitMenu = std::make_shared<SwitchComponent>(mWindow);
fullExitMenu->setState(!Settings::getInstance()->getBool("ShowOnlyExit"));
s->addWithLabel(_("COMPLETE QUIT MENU"), fullExitMenu);
s->addSaveFunc([fullExitMenu] { Settings::getInstance()->setBool("ShowOnlyExit", !fullExitMenu->getState()); });
#endif
if (ApiSystem::getInstance()->isScriptingSupported(ApiSystem::GAMESETTINGS))
{
/*
auto retroarchRgui = std::make_shared< OptionListComponent<std::string> >(mWindow, _("RETROARCH MENU DRIVER"), false);
retroarchRgui->addRange({ { _("AUTO"), "" },{ "rgui", "rgui" },{ "xmb", "xmb" },{ "ozone", "ozone" },{ "glui", "glui" } }, SystemConf::getInstance()->get("global.retroarch.menu_driver"));
s->addWithLabel(_("RETROARCH MENU DRIVER"), retroarchRgui);
s->addSaveFunc([retroarchRgui] { SystemConf::getInstance()->set("global.retroarch.menu_driver", retroarchRgui->getSelected()); });
*/
/*
auto retroarchRgui = std::make_shared<SwitchComponent>(mWindow);
retroarchRgui->setState(SystemConf::getInstance()->get("global.retroarch.menu_driver") == "rgui");
s->addWithLabel(_("USE RETROARCH RGUI MENU"), retroarchRgui);
s->addSaveFunc([retroarchRgui]
{
SystemConf::getInstance()->set("global.retroarch.menu_driver", retroarchRgui->getState() ? "rgui" : "");
});
*/
#if defined(WIN32)
auto autoControllers = std::make_shared<SwitchComponent>(mWindow);
autoControllers->setState(SystemConf::getInstance()->get("global.disableautocontrollers") != "1");
s->addWithLabel(_("AUTOCONFIGURE EMULATORS CONTROLLERS"), autoControllers);
s->addSaveFunc([autoControllers] { SystemConf::getInstance()->set("global.disableautocontrollers", autoControllers->getState() ? "" : "1"); });
#endif
}
auto invertJoy = std::make_shared<SwitchComponent>(mWindow);
invertJoy->setState(Settings::getInstance()->getBool("InvertButtons"));
s->addWithLabel(_("SWITCH A & B BUTTONS IN EMULATIONSTATION"), invertJoy);
s->addSaveFunc([this, s, invertJoy]
{
if (Settings::getInstance()->setBool("InvertButtons", invertJoy->getState()))
{
InputConfig::AssignActionButtons();
s->setVariable("reloadAll", true);
}
});
auto invertLongPress = std::make_shared<SwitchComponent>(mWindow);
invertLongPress->setState(Settings::getInstance()->getBool("GameOptionsAtNorth"));
s->addWithDescription(_("ACCESS GAME OPTIONS WITH NORTH BUTTON"), _("Switches to short-press North for Savestates & long-press South button for Game Options"), invertLongPress);
s->addSaveFunc([this, s, invertLongPress]
{
if (Settings::getInstance()->setBool("GameOptionsAtNorth", invertLongPress->getState()))
s->setVariable("reloadAll", true);
});
auto firstJoystickOnly = std::make_shared<SwitchComponent>(mWindow);
firstJoystickOnly->setState(Settings::getInstance()->getBool("FirstJoystickOnly"));
s->addWithLabel(_("CONTROL EMULATIONSTATION WITH FIRST JOYSTICK ONLY"), firstJoystickOnly);
s->addSaveFunc([this, firstJoystickOnly] { Settings::getInstance()->setBool("FirstJoystickOnly", firstJoystickOnly->getState()); });
#if defined(WIN32)
// Network Indicator
auto networkIndicator = std::make_shared<SwitchComponent>(mWindow);
networkIndicator->setState(Settings::getInstance()->getBool("ShowNetworkIndicator"));
s->addWithLabel(_("SHOW NETWORK INDICATOR"), networkIndicator);
s->addSaveFunc([networkIndicator] { Settings::getInstance()->setBool("ShowNetworkIndicator", networkIndicator->getState()); });
#endif
s->addGroup(_("OPTIMIZATIONS"));
// preload UI
auto preloadUI = std::make_shared<SwitchComponent>(mWindow);
preloadUI->setState(Settings::getInstance()->getBool("PreloadUI"));
s->addWithDescription(_("PRELOAD UI ELEMENTS"), _("Reduce overall menu lag at the cost of storage space"), preloadUI);
s->addSaveFunc([preloadUI] { Settings::getInstance()->setBool("PreloadUI", preloadUI->getState()); });
// preload Medias
auto preloadMedias = std::make_shared<SwitchComponent>(mWindow);
preloadMedias->setState(Settings::getInstance()->getBool("PreloadMedias"));
s->addWithDescription(_("PRELOAD METADATA MEDIA"), _("Reduce gamelist lag at the cost of storage space"), preloadMedias);
s->addSaveFunc([preloadMedias] { Settings::setPreloadMedias(preloadMedias->getState()); });
// threaded loading
auto threadedLoading = std::make_shared<SwitchComponent>(mWindow);
threadedLoading->setState(Settings::getInstance()->getBool("ThreadedLoading"));
s->addWithLabel(_("THREADED LOADING"), threadedLoading);
s->addSaveFunc([threadedLoading] { Settings::getInstance()->setBool("ThreadedLoading", threadedLoading->getState()); });
// async images
auto asyncImages = std::make_shared<SwitchComponent>(mWindow);
asyncImages->setState(Settings::getInstance()->getBool("AsyncImages"));
s->addWithLabel(_("ASYNC IMAGE LOADING"), asyncImages);
s->addSaveFunc([asyncImages] { Settings::getInstance()->setBool("AsyncImages", asyncImages->getState()); });
// optimizeVram
auto optimizeVram = std::make_shared<SwitchComponent>(mWindow);
optimizeVram->setState(Settings::getInstance()->getBool("OptimizeVRAM"));
s->addWithLabel(_("OPTIMIZE IMAGES VRAM USE"), optimizeVram);
s->addSaveFunc([optimizeVram] { Settings::getInstance()->setBool("OptimizeVRAM", optimizeVram->getState()); });
// optimizeVideo
auto optimizeVideo = std::make_shared<SwitchComponent>(mWindow);
optimizeVideo->setState(Settings::getInstance()->getBool("OptimizeVideo"));
s->addWithLabel(_("OPTIMIZE VIDEO VRAM USAGE"), optimizeVideo);
s->addSaveFunc([optimizeVideo] { Settings::getInstance()->setBool("OptimizeVideo", optimizeVideo->getState()); });
s->addGroup(_("UPDATES"));
// Allow customizing the github org and repo used to update from
// This allows using a different fork/repository to download releases for testing
s->addInputTextRow(_("GITHUB ORG"), "updates.github.org", false);
s->addInputTextRow(_("GITHUB REPO"), "updates.github.repo", false);
//Force updates will tell the check script and the update script to always
//use an update regardless of the current version on the device.
auto forceUpdates = std::make_shared<SwitchComponent>(mWindow);
forceUpdates->setState(SystemConf::getInstance()->getBool("updates.force"));
s->addWithLabel(_("FORCE UPDATES"), forceUpdates);
s->addSaveFunc([forceUpdates]
{
SystemConf::getInstance()->setBool("updates.force", forceUpdates->getState());
});
s->onFinalize([s, window]
{
if (s->getVariable("reloadAll"))
{
ViewController::get()->reloadAll(window);
window->closeSplashScreen();
}
});
mWindow->pushGui(s);
}
void GuiMenu::openUpdatesSettings()
{
GuiSettings *updateGui = new GuiSettings(mWindow, _("UPDATES & DOWNLOADS").c_str());
updateGui->addGroup(_("DOWNLOADS"));
// Batocera integration with Batocera Store
if (ApiSystem::getInstance()->isScriptingSupported(ApiSystem::BATOCERASTORE))
{
updateGui->addEntry(_("CONTENT DOWNLOADER"), true, [this]
{
if (!checkNetwork())
return;
mWindow->pushGui(new GuiBatoceraStore(mWindow));
});
}
// Batocera themes installer/browser
if (ApiSystem::getInstance()->isScriptingSupported(ApiSystem::THEMESDOWNLOADER))
{
updateGui->addEntry(_("THEMES"), true, [this]
{
if (!checkNetwork())
return;
mWindow->pushGui(new GuiThemeInstaller(mWindow));
});
}
// Community package installer/browser
updateGui->addEntry(_("PACKAGES"), true, [this]
{
if (!checkNetwork())
return;
mWindow->pushGui(new GuiPackageInstallStart(mWindow));
});
// Batocera integration with theBezelProject
//if (ApiSystem::getInstance()->isScriptingSupported(ApiSystem::DECORATIONS) && ApiSystem::getInstance()->isScriptingSupported(ApiSystem::THEBEZELPROJECT))
//{
// updateGui->addEntry(_("THE BEZEL PROJECT"), true, [this]
// {
// if (!checkNetwork())
// return;
// mWindow->pushGui(new GuiBezelInstallStart(mWindow));
// });
//}
updateGui->addGroup(_("SOFTWARE UPDATES"));
// Enable updates
auto updates_enabled = std::make_shared<SwitchComponent>(mWindow);
updates_enabled->setState(SystemConf::getInstance()->getBool("updates.enabled"));
updateGui->addWithLabel(_("CHECK FOR UPDATES"), updates_enabled);
updateGui->addSaveFunc([updates_enabled]
{
SystemConf::getInstance()->setBool("updates.enabled", updates_enabled->getState());
});
// Update Bands
auto updatesTypeList = std::make_shared<OptionListComponent<std::string> >(mWindow, _("UPDATE CHANNEL"), false);
std::string updatesType = SystemConf::getInstance()->get("updates.type");
//old default was 'daily' - so update to release if they have 'daily' set.
if (updatesType.empty() || updatesType == "daily")
{
updatesType = "release";
}
// 'prerelease' is the new 'beta'
else if (updatesType == "beta")
{
updatesType = "prerelease";
}
//immediately save if we are setting value
SystemConf::getInstance()->saveSystemConf();
updatesTypeList->add("release", "release", updatesType == "release");
updatesTypeList->add("prerelease", "prerelease", updatesType == "prerelease");
updateGui->addWithLabel(_("UPDATE CHANNEL"), updatesTypeList);
updatesTypeList->setSelectedChangedCallback([](std::string name)
{
if (SystemConf::getInstance()->set("updates.type", name))
SystemConf::getInstance()->saveSystemConf();
});
// Start update
updateGui->addEntry(GuiUpdate::state == GuiUpdateState::State::UPDATE_READY ? _("APPLY UPDATE") : _("START UPDATE"), true, [this]
{
if (GuiUpdate::state == GuiUpdateState::State::UPDATE_READY)
quitES(QuitMode::RESTART);
else if (GuiUpdate::state == GuiUpdateState::State::UPDATER_RUNNING)
mWindow->pushGui(new GuiMsgBox(mWindow, _("UPDATER IS ALREADY RUNNING")));
else
{
if (!checkNetwork())
return;
mWindow->pushGui(new GuiUpdate(mWindow));
}
});
mWindow->pushGui(updateGui);
}
bool GuiMenu::checkNetwork()
{
if (ApiSystem::getInstance()->getIpAdress() == "NOT CONNECTED")
{
mWindow->pushGui(new GuiMsgBox(mWindow, _("YOU ARE NOT CONNECTED TO A NETWORK"), _("OK"), nullptr));
return false;
}
return true;
}
void GuiMenu::openSystemSettings_batocera()
{
Window *window = mWindow;
auto s = new GuiSettings(mWindow, _("SYSTEM SETTINGS").c_str());
bool isFullUI = UIModeController::getInstance()->isUIModeFull();
s->addGroup(_("SYSTEM"));
// System informations
s->addEntry(_("INFORMATION"), true, [this] { openSystemInformations_batocera(); });
auto emuelec_timezones = std::make_shared<OptionListComponent<std::string> >(mWindow, _("TIMEZONE"), false);
std::string currentTimezone = SystemConf::getInstance()->get("system.timezone");
if (currentTimezone.empty())
currentTimezone = std::string(getShOutput(R"(/usr/bin/emuelec-utils current_timezone)"));
std::string a;
for(std::stringstream ss(getShOutput(R"(/usr/bin/emuelec-utils timezones)")); getline(ss, a, ','); ) {
emuelec_timezones->add(a, a, currentTimezone == a); // emuelec
}
s->addWithLabel(_("TIMEZONE"), emuelec_timezones);
s->addSaveFunc([emuelec_timezones] {
if (emuelec_timezones->changed()) {
std::string selectedTimezone = emuelec_timezones->getSelected();
runSystemCommand("ln -sf /usr/share/zoneinfo/" + selectedTimezone + " $(readlink /etc/localtime)", "", nullptr);
}
SystemConf::getInstance()->set("system.timezone", emuelec_timezones->getSelected());
});
// language choice
/*
auto language_choice = std::make_shared<OptionListComponent<std::string> >(window, _("LANGUAGE"), false);
std::string language = SystemConf::getInstance()->get("system.language");
if (language.empty())
language = "en_US";
language_choice->add("ARABIC", "ar_YE", language == "ar_YE");
language_choice->add("CATALÀ", "ca_ES", language == "ca_ES");
language_choice->add("CYMRAEG", "cy_GB", language == "cy_GB");
language_choice->add("DEUTSCH", "de_DE", language == "de_DE");
language_choice->add("GREEK", "el_GR", language == "el_GR");
language_choice->add("ENGLISH", "en_US", language == "en_US" || language == "en");
language_choice->add("ESPAÑOL", "es_ES", language == "es_ES" || language == "es");
language_choice->add("ESPAÑOL MEXICANO", "es_MX", language == "es_MX");
language_choice->add("BASQUE", "eu_ES", language == "eu_ES");
language_choice->add("FRANÇAIS", "fr_FR", language == "fr_FR" || language == "fr");
language_choice->add("עברית", "he_IL", language == "he_IL");
language_choice->add("HUNGARIAN", "hu_HU", language == "hu_HU");
language_choice->add("ITALIANO", "it_IT", language == "it_IT");
language_choice->add("JAPANESE", "ja_JP", language == "ja_JP");
language_choice->add("KOREAN", "ko_KR", language == "ko_KR" || language == "ko");
language_choice->add("NORWEGIAN BOKMAL", "nb_NO", language == "nb_NO");
language_choice->add("DUTCH", "nl_NL", language == "nl_NL");
language_choice->add("NORWEGIAN", "nn_NO", language == "nn_NO");
language_choice->add("OCCITAN", "oc_FR", language == "oc_FR");
language_choice->add("POLISH", "pl_PL", language == "pl_PL");
language_choice->add("PORTUGUES BRASILEIRO", "pt_BR", language == "pt_BR");
language_choice->add("PORTUGUES PORTUGAL", "pt_PT", language == "pt_PT");
language_choice->add("РУССКИЙ", "ru_RU", language == "ru_RU");
language_choice->add("SVENSKA", "sv_SE", language == "sv_SE");
language_choice->add("TÜRKÇE", "tr_TR", language == "tr_TR");
language_choice->add("Українська", "uk_UA", language == "uk_UA");
language_choice->add("简体中文", "zh_CN", language == "zh_CN");
language_choice->add("正體中文", "zh_TW", language == "zh_TW");
s->addWithLabel(_("LANGUAGE"), language_choice);
*/
#if !defined(_ENABLEEMUELEC)
// Timezone
#if !defined(WIN32) || defined(_DEBUG)
auto availableTimezones = ApiSystem::getInstance()->getTimezones();
if (availableTimezones.size() > 0)
{
std::string currentTZ = ApiSystem::getInstance()->getCurrentTimezone();
bool valid_tz = false;
for (auto list_tz : availableTimezones){
if (currentTZ == list_tz) {
valid_tz = true;
}
}
if (!valid_tz)
currentTZ = "Europe/Paris";
auto tzChoices= std::make_shared<OptionListComponent<std::string> >(mWindow, _("SELECT YOUR TIME ZONE"), false);
for (auto tz : availableTimezones)
tzChoices->add(_(Utils::String::toUpper(tz).c_str()), tz, currentTZ == tz);
s->addWithLabel(_("TIME ZONE"), tzChoices);
s->addSaveFunc([tzChoices] {
SystemConf::getInstance()->set("system.timezone", tzChoices->getSelected());
ApiSystem::getInstance()->setTimezone(tzChoices->getSelected());
});
}
#endif
#endif
// Clock time format (14:42 or 2:42 pm)
auto tmFormat = std::make_shared<SwitchComponent>(mWindow);
tmFormat->setState(Settings::getInstance()->getBool("ClockMode12"));
s->addWithLabel(_("SHOW CLOCK IN 12-HOUR FORMAT"), tmFormat);
s->addSaveFunc([tmFormat] { Settings::getInstance()->setBool("ClockMode12", tmFormat->getState()); });
// power saver
/*
auto power_saver = std::make_shared< OptionListComponent<std::string> >(mWindow, _("POWER SAVER MODES"), false);
power_saver->addRange({ { _("DISABLED"), "disabled" }, { _("DEFAULT"), "default" }, { _("ENHANCED"), "enhanced" }, { _("INSTANT"), "instant" }, }, Settings::PowerSaverMode());
s->addWithLabel(_("POWER SAVER MODES"), power_saver);
s->addSaveFunc([this, power_saver]
{
if (Settings::PowerSaverMode() != "instant" && power_saver->getSelected() == "instant")
Settings::getInstance()->setBool("EnableSounds", false);
Settings::setPowerSaverMode(power_saver->getSelected());
PowerSaver::init();
});
*/
#if defined(_ENABLE_TTS_) || defined(WIN32)
if (TextToSpeech::getInstance()->isAvailable())
{
// tts
auto tts = std::make_shared<SwitchComponent>(mWindow);
tts->setState(Settings::getInstance()->getBool("TTS"));
s->addWithLabel(_("SCREEN READER (TEXT TO SPEECH)"), tts);
s->addSaveFunc([tts] {
if(TextToSpeech::getInstance()->isEnabled() != tts->getState()) {
TextToSpeech::getInstance()->enable(tts->getState());
Settings::getInstance()->setBool("TTS", tts->getState());
}});
}
#endif
// UI RESTRICTIONS
/*
auto UImodeSelection = std::make_shared< OptionListComponent<std::string> >(mWindow, _("UI MODE"), false);
std::vector<std::string> UImodes = UIModeController::getInstance()->getUIModes();
for (auto it = UImodes.cbegin(); it != UImodes.cend(); it++)
UImodeSelection->add(_(it->c_str()), *it, Settings::getInstance()->getString("UIMode") == *it);
s->addWithLabel(_("UI MODE"), UImodeSelection);
s->addSaveFunc([UImodeSelection, window]
{
std::string selectedMode = UImodeSelection->getSelected();
if (selectedMode != "Full")
{
std::string msg = _("You are changing the UI to a restricted mode:\nThis will hide most menu options to prevent changes to the system.\nTo unlock and return to the full UI, enter this code:") + "\n";
msg += "\"" + UIModeController::getInstance()->getFormattedPassKeyStr() + "\"\n\n";
msg += _("Do you want to proceed?");
window->pushGui(new GuiMsgBox(window, msg,
_("YES"), [selectedMode] {
LOG(LogDebug) << "Setting UI mode to " << selectedMode;
Settings::getInstance()->setString("UIMode", selectedMode);
Settings::getInstance()->saveFile();
}, _("NO"), nullptr));
}
});
*/
// KODI SETTINGS
#ifdef _ENABLE_KODI_
if (ApiSystem::getInstance()->isScriptingSupported(ApiSystem::KODI))
{
s->addEntry(_("KODI SETTINGS"), true, [this]
{
GuiSettings* kodiGui = new GuiSettings(mWindow, _("KODI SETTINGS").c_str());
auto kodiEnabled = std::make_shared<SwitchComponent>(mWindow);
kodiEnabled->setState(SystemConf::getInstance()->getBool("kodi.enabled", true));
kodiGui->addWithLabel(_("ENABLE KODI"), kodiEnabled);
auto kodiAtStart = std::make_shared<SwitchComponent>(mWindow);
kodiAtStart->setState(SystemConf::getInstance()->getBool("kodi.atstartup"));
kodiGui->addWithLabel(_("LAUNCH KODI AT BOOT"), kodiAtStart);
kodiGui->addSaveFunc([kodiEnabled, kodiAtStart]
{
SystemConf::getInstance()->setBool("kodi.enabled", kodiEnabled->getState());
SystemConf::getInstance()->setBool("kodi.atstartup", kodiAtStart->getState());
});
mWindow->pushGui(kodiGui);
});
}
#endif
#if !defined(WIN32) || defined(_DEBUG)
s->addGroup(_("HARDWARE"));
// brightness
int brightness;
if (ApiSystem::getInstance()->getBrightness(brightness))
{
auto brightnessComponent = std::make_shared<SliderComponent>(mWindow, 1.f, 100.f, 1.f, "%");
brightnessComponent->setValue(brightness);
brightnessComponent->setOnValueChanged([](const float &newVal)
{
ApiSystem::getInstance()->setBrightness((int)Math::round(newVal));
});
s->addSaveFunc([this, brightnessComponent] {
SystemConf::getInstance()->set("brightness.level", std::to_string((int)Math::round(brightnessComponent->getValue())));
});
s->addWithLabel(_("BRIGHTNESS"), brightnessComponent);
}
#endif
#if !defined(WIN32) && !defined(_ENABLEEMUELEC)
// video device
/*
auto optionsVideo = std::make_shared<OptionListComponent<std::string> >(mWindow, _("VIDEO OUTPUT"), false);
std::string currentDevice = SystemConf::getInstance()->get("global.videooutput");
if (currentDevice.empty()) currentDevice = "auto";
std::vector<std::string> availableVideo = ApiSystem::getInstance()->getAvailableVideoOutputDevices();
bool vfound = false;
for (auto it = availableVideo.begin(); it != availableVideo.end(); it++)
{
optionsVideo->add((*it), (*it), currentDevice == (*it));
if (currentDevice == (*it))
vfound = true;
}
if (!vfound)
optionsVideo->add(currentDevice, currentDevice, true);
s->addWithLabel(_("VIDEO OUTPUT"), optionsVideo);
s->addSaveFunc([this, optionsVideo, currentDevice] {
if (optionsVideo->changed()) {
SystemConf::getInstance()->set("global.videooutput", optionsVideo->getSelected());
SystemConf::getInstance()->saveSystemConf();
mWindow->displayNotificationMessage(_U("\uF011 ") + _("REBOOT REQUIRED TO APPLY THE NEW CONFIGURATION"));
if (Settings::getInstance()->getBool("ExitOnRebootRequired")) {
quitES(QuitMode::QUIT);
}
}
});
*/
// audio device
/*
auto optionsAudio = std::make_shared<OptionListComponent<std::string> >(mWindow, _("AUDIO OUTPUT"), false);
std::vector<std::string> availableAudio = ApiSystem::getInstance()->getAvailableAudioOutputDevices();
std::string selectedAudio = ApiSystem::getInstance()->getCurrentAudioOutputDevice();
if (selectedAudio.empty())
selectedAudio = "auto";
if (SystemConf::getInstance()->get("system.es.menu") != "bartop")
{
bool vfound = false;
for (auto it = availableAudio.begin(); it != availableAudio.end(); it++)
{
std::vector<std::string> tokens = Utils::String::split(*it, ' ');
if (selectedAudio == tokens.at(0))
vfound = true;
if (tokens.size() >= 2)
{
// concatenat the ending words
std::string vname = "";
for (unsigned int i = 1; i < tokens.size(); i++)
{
if (i > 2) vname += " ";
vname += tokens.at(i);
}
optionsAudio->add(vname, tokens.at(0), selectedAudio == tokens.at(0));
}
else
optionsAudio->add((*it), (*it), selectedAudio == tokens.at(0));
}
if (vfound == false)
optionsAudio->add(selectedAudio, selectedAudio, true);
s->addWithLabel(_("AUDIO OUTPUT"), optionsAudio);
}
s->addSaveFunc([this, optionsAudio, selectedAudio]
{
if (optionsAudio->changed()) {
SystemConf::getInstance()->set("audio.device", optionsAudio->getSelected());
ApiSystem::getInstance()->setAudioOutputDevice(optionsAudio->getSelected());
}
SystemConf::getInstance()->saveSystemConf();
});
*/
#endif
#ifndef _ENABLEEMUELEC
// audio profile
auto optionsAudioProfile = std::make_shared<OptionListComponent<std::string> >(mWindow, _("AUDIO PROFILE"), false);
std::vector<std::string> availableAudioProfiles = ApiSystem::getInstance()->getAvailableAudioOutputProfiles();
std::string selectedAudioProfile = ApiSystem::getInstance()->getCurrentAudioOutputProfile();
if (selectedAudioProfile.empty())
selectedAudioProfile = "auto";
if (SystemConf::getInstance()->get("system.es.menu") != "bartop")
{
bool vfound = false;
for (auto it = availableAudioProfiles.begin(); it != availableAudioProfiles.end(); it++)
{
std::vector<std::string> tokens = Utils::String::split(*it, ' ');
if (selectedAudioProfile == tokens.at(0))
vfound = true;
if (tokens.size() >= 2)
{
// concatenat the ending words
std::string vname = "";
for (unsigned int i = 1; i < tokens.size(); i++)
{
if (i > 2) vname += " ";
vname += tokens.at(i);
}
optionsAudioProfile->add(vname, tokens.at(0), selectedAudioProfile == tokens.at(0));
}
else
optionsAudioProfile->add((*it), (*it), selectedAudioProfile == tokens.at(0));
}
if (vfound == false)
optionsAudioProfile->add(selectedAudioProfile, selectedAudioProfile, true);
s->addWithLabel(_("AUDIO PROFILE"), optionsAudioProfile);
}
s->addSaveFunc([this, optionsAudioProfile, selectedAudioProfile]
{
if (optionsAudioProfile->changed()) {
SystemConf::getInstance()->set("audio.profile", optionsAudioProfile->getSelected());
ApiSystem::getInstance()->setAudioOutputProfile(optionsAudioProfile->getSelected());
}
SystemConf::getInstance()->saveSystemConf();
});
// video rotation
auto optionsRotation = std::make_shared<OptionListComponent<std::string> >(mWindow, _("SCREEN ROTATION"), false);
std::string selectedRotation = SystemConf::getInstance()->get("display.rotate");
if (selectedRotation.empty())
selectedRotation = "auto";
optionsRotation->add(_("0 DEGREES (AUTO)"), "auto", selectedRotation == "auto");
optionsRotation->add(_("90 DEGREES"), "1", selectedRotation == "1");
optionsRotation->add(_("180 DEGREES"), "2", selectedRotation == "2");
optionsRotation->add(_("270 DEGREES"), "3", selectedRotation == "3");
s->addWithLabel(_("SCREEN ROTATION"), optionsRotation);
s->addSaveFunc([this, optionsRotation, selectedRotation]
{
if (optionsRotation->changed()) {
SystemConf::getInstance()->set("display.rotate", optionsRotation->getSelected());
SystemConf::getInstance()->saveSystemConf();
mWindow->displayNotificationMessage(_U("\uF011 ") + _("REBOOT REQUIRED TO APPLY THE NEW CONFIGURATION"));
if (Settings::getInstance()->getBool("ExitOnRebootRequired")) {
quitES(QuitMode::QUIT);
}
}
});
// splash
auto optionsSplash = std::make_shared<OptionListComponent<std::string> >(mWindow, _("BOOT SPLASH"), false);
std::string enabledSplash = SystemConf::getInstance()->get("splash.screen.enabled");
std::string soundSplash = SystemConf::getInstance()->get("splash.screen.sound");
std::string selectedSplash = "auto";
if(enabledSplash == "0") selectedSplash = "nosplash";
else if(soundSplash == "0") selectedSplash = "silentsplash";
optionsSplash->add(_("DEFAULT VIDEO/USER SET SPLASH"), "auto", selectedSplash == "auto");
optionsSplash->add(_("SILENT VIDEO/USER SET SPLASH"), "silentsplash", selectedSplash == "silentsplash");
optionsSplash->add(_("BATOCERA SPLASH IMAGE"), "nosplash", selectedSplash == "nosplash");
s->addWithLabel(_("SPLASH SETTING"), optionsSplash);
s->addSaveFunc([this, optionsSplash, selectedSplash]
{
if (optionsSplash->changed()) {
if(optionsSplash->getSelected() == "nosplash") {
SystemConf::getInstance()->set("splash.screen.enabled", "0");
} else {
SystemConf::getInstance()->set("splash.screen.enabled", "1");
if(optionsSplash->getSelected() == "silentsplash") {
SystemConf::getInstance()->set("splash.screen.sound", "0");
} else {
SystemConf::getInstance()->set("splash.screen.sound", "1");
}
}
SystemConf::getInstance()->saveSystemConf();
}
});
#endif
#ifndef RG552
auto oc_enabled = std::make_shared<SwitchComponent>(mWindow);
bool baseEnabled = SystemConf::getInstance()->get("overclock") == "1";
oc_enabled->setState(baseEnabled);
s->addWithLabel(_("ENABLE OVERCLOCK"), oc_enabled);
s->addSaveFunc([this, oc_enabled] {
bool oc_need_reboot = false;
if (oc_enabled->changed()) {
if (oc_enabled->getState() == false) {
runSystemCommand("351elec-overclock off", "", nullptr);
} else {
runSystemCommand("351elec-overclock on", "", nullptr);
}
oc_need_reboot = true;
}
bool ocenabled = oc_enabled->getState();
SystemConf::getInstance()->set("overclock", ocenabled ? "1" : "0");
SystemConf::getInstance()->saveSystemConf();
if (oc_need_reboot) {
mWindow->displayNotificationMessage(_U("\uF011 ") + _("A REBOOT OF THE SYSTEM IS REQUIRED TO APPLY THE NEW CONFIGURATION"));
}
});
#endif
#ifdef RG552
auto optionsFanProfile = std::make_shared<OptionListComponent<std::string> >(mWindow, _("FAN PROFILE"), false);
std::string selectedFanProfile = SystemConf::getInstance()->get("fan.profile");
if (selectedFanProfile.empty())
selectedFanProfile = "default";
optionsFanProfile->add(_("DEFAULT"), "default", selectedFanProfile == "default");
optionsFanProfile->add(_("PERFORMANCE"),"performance", selectedFanProfile == "performance");
optionsFanProfile->add(_("QUIET"), "quiet", selectedFanProfile == "quiet");
s->addWithLabel(_("FAN PROFILE"), optionsFanProfile);
s->addSaveFunc([this, optionsFanProfile, selectedFanProfile]
{
if (optionsFanProfile->changed()) {
SystemConf::getInstance()->set("fan.profile", optionsFanProfile->getSelected());
SystemConf::getInstance()->saveSystemConf();
}
});
#endif
if (!ApiSystem::getInstance()->isScriptingSupported(ApiSystem::GAMESETTINGS))
{
// Retroachievements
if (ApiSystem::getInstance()->isScriptingSupported(ApiSystem::RETROACHIVEMENTS))
s->addEntry(_("RETROACHIEVEMENT SETTINGS"), true, [this] { openRetroachievementsSettings(); });
if (SystemData::isNetplayActivated() && ApiSystem::getInstance()->isScriptingSupported(ApiSystem::NETPLAY))
s->addEntry(_("NETPLAY SETTINGS"), true, [this] { openNetplaySettings(); }, "iconNetplay");
if (ApiSystem::getInstance()->isScriptingSupported(ApiSystem::BIOSINFORMATION))
{
s->addEntry(_("MISSING BIOS CHECK"), true, [this, s] { openMissingBiosSettings(); });
#ifndef _ENABLEEMUELEC
auto checkBiosesAtLaunch = std::make_shared<SwitchComponent>(mWindow);
checkBiosesAtLaunch->setState(Settings::getInstance()->getBool("CheckBiosesAtLaunch"));
s->addWithLabel(_("CHECK BIOS FILES BEFORE RUNNING A GAME"), checkBiosesAtLaunch);
s->addSaveFunc([checkBiosesAtLaunch] { Settings::getInstance()->setBool("CheckBiosesAtLaunch", checkBiosesAtLaunch->getState()); });
#endif
}
}
std::shared_ptr<OptionListComponent<std::string>> overclock_choice;
#if defined(ODROIDGOA) && !defined(_ENABLEEMUELEC)
// multimedia keys
auto multimediakeys_enabled = std::make_shared<OptionListComponent<std::string>>(mWindow, _("MULTIMEDIA KEYS"));
multimediakeys_enabled->add(_("AUTO"), "auto", SystemConf::getInstance()->get("system.multimediakeys.enabled") != "0" && SystemConf::getInstance()->get("system.multimediakeys.enabled") != "1");
multimediakeys_enabled->add(_("ON"), "1", SystemConf::getInstance()->get("system.multimediakeys.enabled") == "1");
multimediakeys_enabled->add(_("OFF"), "0", SystemConf::getInstance()->get("system.multimediakeys.enabled") == "0");
s->addWithLabel(_("MULTIMEDIA KEYS"), multimediakeys_enabled);
s->addSaveFunc([this, multimediakeys_enabled]
{
if (multimediakeys_enabled->changed()) {
SystemConf::getInstance()->set("system.multimediakeys.enabled", multimediakeys_enabled->getSelected());
this->mWindow->displayNotificationMessage(_U("\uF011 ") + _("REBOOT REQUIRED TO APPLY THE NEW CONFIGURATION"));
}
});
#endif
#ifdef GAMEFORCE
auto buttonColor_GameForce = std::make_shared< OptionListComponent<std::string> >(mWindow, _("BUTTON LED COLOR"));
buttonColor_GameForce->add(_("off"), "off", SystemConf::getInstance()->get("color_rgb") == "off" || SystemConf::getInstance()->get("color_rgb") == "");
buttonColor_GameForce->add(_("red"), "red", SystemConf::getInstance()->get("color_rgb") == "red");
buttonColor_GameForce->add(_("green"), "green", SystemConf::getInstance()->get("color_rgb") == "green");
buttonColor_GameForce->add(_("blue"), "blue", SystemConf::getInstance()->get("color_rgb") == "blue");
buttonColor_GameForce->add(_("white"), "white", SystemConf::getInstance()->get("color_rgb") == "white");
buttonColor_GameForce->add(_("purple"), "purple", SystemConf::getInstance()->get("color_rgb") == "purple");
buttonColor_GameForce->add(_("yellow"), "yellow", SystemConf::getInstance()->get("color_rgb") == "yellow");
buttonColor_GameForce->add(_("cyan"), "cyan", SystemConf::getInstance()->get("color_rgb") == "cyan");
s->addWithLabel(_("BUTTON LED COLOR"), buttonColor_GameForce);
s->addSaveFunc([buttonColor_GameForce]
{
if (buttonColor_GameForce->changed()) {
ApiSystem::getInstance()->setButtonColorGameForce(buttonColor_GameForce->getSelected());
SystemConf::getInstance()->set("color_rgb", buttonColor_GameForce->getSelected());
}
});
auto powerled_GameForce = std::make_shared< OptionListComponent<std::string> >(mWindow, _("POWER LED COLOR"));
powerled_GameForce->add(_("heartbeat"), "heartbeat", SystemConf::getInstance()->get("option_powerled") == "heartbeat" || SystemConf::getInstance()->get("option_powerled") == "");
powerled_GameForce->add(_("off"), "off", SystemConf::getInstance()->get("option_powerled") == "off");
powerled_GameForce->add(_("on"), "on", SystemConf::getInstance()->get("option_powerled") == "on");
s->addWithLabel(_("POWER LED COLOR"), powerled_GameForce);
s->addSaveFunc([powerled_GameForce]
{
if (powerled_GameForce->changed()) {
ApiSystem::getInstance()->setPowerLedGameForce(powerled_GameForce->getSelected());
SystemConf::getInstance()->set("option_powerled", powerled_GameForce->getSelected());
}
});
#endif
// Overclock choice
if (ApiSystem::getInstance()->isScriptingSupported(ApiSystem::OVERCLOCK))
{
overclock_choice = std::make_shared<OptionListComponent<std::string> >(window, _("OVERCLOCK"), false);
std::string currentOverclock = Settings::getInstance()->getString("Overclock");
if (currentOverclock == "")
currentOverclock = "none";
std::vector<std::string> availableOverclocking = ApiSystem::getInstance()->getAvailableOverclocking();
// Overclocking device
bool isOneSet = false;
for (auto it = availableOverclocking.begin(); it != availableOverclocking.end(); it++)
{
std::vector<std::string> tokens = Utils::String::split(*it, ' ');
if (tokens.size() >= 2)
{
// concatenat the ending words
std::string vname;
for (unsigned int i = 1; i < tokens.size(); i++)
{
if (i > 1) vname += " ";
vname += tokens.at(i);
}
bool isSet = currentOverclock == std::string(tokens.at(0));
if (isSet)
isOneSet = true;
if (vname == "NONE" || vname == "none")
vname = _("NONE");
overclock_choice->add(vname, tokens.at(0), isSet);
}
}
if (isOneSet == false)
{
if (currentOverclock == "none")
overclock_choice->add(_("NONE"), currentOverclock, true);
else
overclock_choice->add(currentOverclock, currentOverclock, true);
}
// overclocking
s->addWithLabel(_("OVERCLOCK"), overclock_choice);
}
#if !defined(WIN32) && !defined _ENABLEEMUELEC || defined(_DEBUG)
s->addGroup(_("STORAGE"));
#endif
// Storage device
std::vector<std::string> availableStorage = ApiSystem::getInstance()->getAvailableStorageDevices();
std::string selectedStorage = ApiSystem::getInstance()->getCurrentStorage();
auto optionsStorage = std::make_shared<OptionListComponent<std::string> >(window, _("STORAGE DEVICE"), false);
for (auto it = availableStorage.begin(); it != availableStorage.end(); it++)
{
if ((*it) != "RAM")
{
if (Utils::String::startsWith(*it, "DEV"))
{
std::vector<std::string> tokens = Utils::String::split(*it, ' ');
if (tokens.size() >= 3) {
// concatenat the ending words
std::string vname = "";
for (unsigned int i = 2; i < tokens.size(); i++) {
if (i > 2) vname += " ";
vname += tokens.at(i);
}
optionsStorage->add(vname, (*it), selectedStorage == std::string("DEV " + tokens.at(1)));
}
}
else {
optionsStorage->add((*it), (*it), selectedStorage == (*it));
}
}
}
#if !defined(WIN32) && !defined _ENABLEEMUELEC || defined(_DEBUG)
s->addWithLabel(_("STORAGE DEVICE"), optionsStorage);
#endif
#if !defined(WIN32) && !defined _ENABLEEMUELEC || defined(_DEBUG)
// backup
s->addEntry(_("BACKUP USER DATA"), true, [this] { mWindow->pushGui(new GuiBackupStart(mWindow)); });
#endif
#if !defined(WIN32) && !defined _ENABLEEMUELEC || defined(_DEBUG)
// Install
s->addEntry(_("INSTALL BATOCERA ON A NEW DISK"), true, [this] { mWindow->pushGui(new GuiInstallStart(mWindow)); });
s->addGroup(_("ADVANCED"));
// Security
s->addEntry(_("SECURITY"), true, [this] {
GuiSettings *securityGui = new GuiSettings(mWindow, _("SECURITY").c_str());
auto securityEnabled = std::make_shared<SwitchComponent>(mWindow);
securityEnabled->setState(SystemConf::getInstance()->get("system.security.enabled") == "1");
securityGui->addWithLabel(_("ENFORCE SECURITY"), securityEnabled);
auto rootpassword = std::make_shared<TextComponent>(mWindow,
ApiSystem::getInstance()->getRootPassword(),
ThemeData::getMenuTheme()->Text.font, ThemeData::getMenuTheme()->Text.color);
securityGui->addWithLabel(_("ROOT PASSWORD"), rootpassword);
securityGui->addSaveFunc([this, securityEnabled] {
Window* window = this->mWindow;
bool reboot = false;
if (securityEnabled->changed()) {
SystemConf::getInstance()->set("system.security.enabled",
securityEnabled->getState() ? "1" : "0");
SystemConf::getInstance()->saveSystemConf();
reboot = true;
}
if (reboot) {
window->displayNotificationMessage(_U("\uF011 ") + _("REBOOT REQUIRED TO APPLY THE NEW CONFIGURATION"));
}
});
mWindow->pushGui(securityGui);
});
#else
if (isFullUI)
s->addGroup(_("ADVANCED"));
#endif
s->addSaveFunc([overclock_choice, window, optionsStorage, selectedStorage, s]
{
bool reboot = false;
if (optionsStorage->changed())
{
ApiSystem::getInstance()->setStorage(optionsStorage->getSelected());
reboot = true;
}
if (overclock_choice && overclock_choice->changed() && Settings::getInstance()->setString("Overclock", overclock_choice->getSelected()))
{
ApiSystem::getInstance()->setOverclock(overclock_choice->getSelected());
reboot = true;
}
/*
if (language_choice->changed())
{
#ifdef _ENABLEEMUELEC
std::string selectedLanguage = language_choice->getSelected();
std::string msg = _("You are about to set EmuELEC Language to:") +"\n" + selectedLanguage + "\n";
msg += _("Emulationstation will restart")+"\n";
msg += _("Do you want to proceed ?");
window->pushGui(new GuiMsgBox(window, msg, _("YES"), [selectedLanguage] {
SystemConf::getInstance()->set("system.language", selectedLanguage);
SystemConf::getInstance()->saveSystemConf();
runSystemCommand("systemctl restart emustation", "", nullptr);
}, "NO",nullptr));
#else
if (SystemConf::getInstance()->set("system.language", language_choice->getSelected()))
{
FileSorts::reset();
MetaDataList::initMetadata();
s->setVariable("reloadGuiMenu", true);
#ifdef HAVE_INTL
reboot = true;
rebootForLanguage = true;
#endif
}
#endif
}
if (reboot) {
window->displayNotificationMessage(_U("\uF011 ") + _("REBOOT REQUIRED TO APPLY THE NEW CONFIGURATION"));
/*
if(rebootForLanguage) {
if (Settings::getInstance()->getBool("ExitOnRebootRequired")) {
quitES(QuitMode::QUIT);
}
}
*/
});
if (isFullUI){
// Developer options
s->addEntry(_("DEVELOPER"), true, [this] { openDeveloperSettings(); });
//Danger zone options
s->addEntry(_("DANGER ZONE"), true, [this] { openDangerZone(mWindow, "global"); });
}
auto pthis = this;
s->onFinalize([s, pthis, window]
{
if (s->getVariable("reloadGuiMenu"))
{
delete pthis;
window->pushGui(new GuiMenu(window, false));
}
});
mWindow->pushGui(s);
}
void GuiMenu::openLatencyReductionConfiguration(Window* mWindow, std::string configName)
{
GuiSettings* guiLatency = new GuiSettings(mWindow, _("LATENCY REDUCTION").c_str());
// run-ahead
auto runahead_enabled = std::make_shared<OptionListComponent<std::string>>(mWindow, _("RUN-AHEAD FRAMES"));
runahead_enabled->addRange({ { _("AUTO"), "" }, { _("NONE"), "0" }, { "1", "1" }, { "2", "2" }, { "3", "3" }, { "4", "4" }, { "5", "5" }, { "6", "6" } }, SystemConf::getInstance()->get(configName + ".runahead"));
guiLatency->addWithLabel(_("USE RUN-AHEAD FRAMES"), runahead_enabled);
guiLatency->addSaveFunc([configName, runahead_enabled] { SystemConf::getInstance()->set(configName + ".runahead", runahead_enabled->getSelected()); });
// second instance
auto secondinstance = std::make_shared<OptionListComponent<std::string>>(mWindow, _("RUN-AHEAD USE SECOND INSTANCE"));
secondinstance->addRange({ { _("AUTO"), "" }, { _("ON"), "1" }, { _("OFF"), "0" } }, SystemConf::getInstance()->get(configName + ".secondinstance"));
guiLatency->addWithLabel(_("RUN-AHEAD USE SECOND INSTANCE"), secondinstance);
guiLatency->addSaveFunc([configName, secondinstance] { SystemConf::getInstance()->set(configName + ".secondinstance", secondinstance->getSelected()); });
mWindow->pushGui(guiLatency);
}
void GuiMenu::openRetroachievementsSettings()
{
Window* window = mWindow;
GuiSettings* retroachievements = new GuiSettings(mWindow, _("RETROACHIEVEMENT SETTINGS").c_str());
retroachievements->addGroup(_("SETTINGS"));
bool retroachievementsEnabled = SystemConf::getInstance()->getBool("global.retroachievements");
std::string username = SystemConf::getInstance()->get("global.retroachievements.username");
std::string password = SystemConf::getInstance()->get("global.retroachievements.password");
// retroachievements_enable
auto retroachievements_enabled = std::make_shared<SwitchComponent>(mWindow);
retroachievements_enabled->setState(retroachievementsEnabled);
retroachievements->addWithLabel(_("RETROACHIEVEMENTS"), retroachievements_enabled);
// retroachievements_hardcore_mode
auto retroachievements_hardcore_enabled = std::make_shared<SwitchComponent>(mWindow);
retroachievements_hardcore_enabled->setState(SystemConf::getInstance()->getBool("global.retroachievements.hardcore"));
retroachievements->addWithLabel(_("HARDCORE MODE"), retroachievements_hardcore_enabled);
retroachievements->addSaveFunc([retroachievements_hardcore_enabled] { SystemConf::getInstance()->setBool("global.retroachievements.hardcore", retroachievements_hardcore_enabled->getState()); });
//// retroachievements_leaderboards
//auto retroachievements_leaderboards_enabled = std::make_shared<SwitchComponent>(mWindow);
//retroachievements_leaderboards_enabled->setState(SystemConf::getInstance()->getBool("global.retroachievements.leaderboards"));
//retroachievements->addWithLabel(_("LEADERBOARDS"), retroachievements_leaderboards_enabled);
//retroachievements->addSaveFunc([retroachievements_leaderboards_enabled] { SystemConf::getInstance()->setBool("global.retroachievements.///leaderboards", retroachievements_leaderboards_enabled->getState()); });
// retroachievements_leaderboards list
auto retroachievements_leaderboards_list = std::make_shared< OptionListComponent<std::string> >(mWindow, _("LEADERBOARDS"), false);
std::vector<std::string> leader;
leader.push_back("disabled");
leader.push_back("enabled");
leader.push_back("trackers only");
leader.push_back("notifications only");
auto currentLeader = SystemConf::getInstance()->get("global.retroachievements.leaderboards");
if (currentLeader.empty())
currentLeader = "disabled";
for (auto it = leader.cbegin(); it != leader.cend(); it++)
retroachievements_leaderboards_list->add(_(it->c_str()), *it, currentLeader == *it);
retroachievements->addWithLabel(_("LEADERBOARDS"), retroachievements_leaderboards_list);
retroachievements->addSaveFunc([retroachievements_leaderboards_list]
{
SystemConf::getInstance()->set("global.retroachievements.leaderboards", retroachievements_leaderboards_list->getSelected());
SystemConf::getInstance()->saveSystemConf();
});
// retroachievements_challenge_indicators
auto retroachievements_challenge_indicators = std::make_shared<SwitchComponent>(mWindow);
retroachievements_challenge_indicators->setState(SystemConf::getInstance()->getBool("global.retroachievements.challengeindicators"));
retroachievements->addWithLabel(_("CHALLENGE INDICATORS"), retroachievements_challenge_indicators);
retroachievements->addSaveFunc([retroachievements_challenge_indicators] { SystemConf::getInstance()->setBool("global.retroachievements.challengeindicators", retroachievements_challenge_indicators->getState()); });
// retroachievements_richpresence_enable
auto retroachievements_richpresence_enable = std::make_shared<SwitchComponent>(mWindow);
retroachievements_richpresence_enable->setState(SystemConf::getInstance()->getBool("global.retroachievements.richpresence"));
retroachievements->addWithLabel(_("RICH PRESENCE"), retroachievements_richpresence_enable);
retroachievements->addSaveFunc([retroachievements_richpresence_enable] { SystemConf::getInstance()->setBool("global.retroachievements.richpresence", retroachievements_richpresence_enable->getState()); });
// retroachievements_badges_enable
auto retroachievements_badges_enable = std::make_shared<SwitchComponent>(mWindow);
retroachievements_badges_enable->setState(SystemConf::getInstance()->getBool("global.retroachievements.badges"));
retroachievements->addWithLabel(_("BADGES"), retroachievements_badges_enable);
retroachievements->addSaveFunc([retroachievements_badges_enable] { SystemConf::getInstance()->setBool("global.retroachievements.badges", retroachievements_badges_enable->getState()); });
// retroachievements_test_unofficial
auto retroachievements_test_unofficial = std::make_shared<SwitchComponent>(mWindow);
retroachievements_test_unofficial->setState(SystemConf::getInstance()->getBool("global.retroachievements.testunofficial"));
retroachievements->addWithLabel(_("TEST UNOFFICIAL ACHIEVEMENTS"), retroachievements_test_unofficial);
retroachievements->addSaveFunc([retroachievements_test_unofficial] { SystemConf::getInstance()->setBool("global.retroachievements.testunofficial", retroachievements_test_unofficial->getState()); });
// retroachievements_unlock_sound_enable
auto retroachievements_unlock_sound_enable = std::make_shared<SwitchComponent>(mWindow);
retroachievements_unlock_sound_enable->setState(SystemConf::getInstance()->getBool("global.retroachievements.soundenable"));
retroachievements->addWithLabel(_("UNLOCK SOUND"), retroachievements_unlock_sound_enable);
retroachievements->addSaveFunc([retroachievements_unlock_sound_enable] { SystemConf::getInstance()->setBool("global.retroachievements.soundenable", retroachievements_unlock_sound_enable->getState()); });
// retroachievements_verbose_mode
auto retroachievements_verbose_enabled = std::make_shared<SwitchComponent>(mWindow);
retroachievements_verbose_enabled->setState(SystemConf::getInstance()->getBool("global.retroachievements.verbose"));
retroachievements->addWithLabel(_("VERBOSE MODE"), retroachievements_verbose_enabled);
retroachievements->addSaveFunc([retroachievements_verbose_enabled] { SystemConf::getInstance()->setBool("global.retroachievements.verbose", retroachievements_verbose_enabled->getState()); });
// retroachievements_automatic_screenshot
auto retroachievements_screenshot_enabled = std::make_shared<SwitchComponent>(mWindow);
retroachievements_screenshot_enabled->setState(SystemConf::getInstance()->getBool("global.retroachievements.screenshot"));
retroachievements->addWithLabel(_("AUTOMATIC SCREENSHOT"), retroachievements_screenshot_enabled);
retroachievements->addSaveFunc([retroachievements_screenshot_enabled] { SystemConf::getInstance()->setBool("global.retroachievements.screenshot", retroachievements_screenshot_enabled->getState()); });
// retroachievements_start_active
auto retroachievements_start_active = std::make_shared<SwitchComponent>(mWindow);
retroachievements_start_active->setState(SystemConf::getInstance()->getBool("global.retroachievements.active"));
retroachievements->addWithLabel(_("ENCORE MODE (LOCAL RESET OF ACHIEVEMENTS)"), retroachievements_start_active);
retroachievements->addSaveFunc([retroachievements_start_active] { SystemConf::getInstance()->setBool("global.retroachievements.active", retroachievements_start_active->getState()); });
// Unlock sound
auto installedRSounds = ApiSystem::getInstance()->getRetroachievementsSoundsList();
if (installedRSounds.size() > 0)
{
std::string currentSound = SystemConf::getInstance()->get("global.retroachievements.sound");
auto rsounds_choices = std::make_shared<OptionListComponent<std::string> >(mWindow, _("RETROACHIEVEMENT UNLOCK SOUND"), false);
rsounds_choices->add(_("none"), "none", currentSound.empty() || currentSound == "none");
for (auto snd : installedRSounds)
rsounds_choices->add(_(Utils::String::toUpper(snd).c_str()), snd, currentSound == snd);
if (!rsounds_choices->hasSelection())
rsounds_choices->selectFirstItem();
retroachievements->addWithLabel(_("UNLOCK SOUND"), rsounds_choices);
retroachievements->addSaveFunc([rsounds_choices] { SystemConf::getInstance()->set("global.retroachievements.sound", rsounds_choices->getSelected()); });
}
// retroachievements, username, password
retroachievements->addInputTextRow(_("USERNAME"), "global.retroachievements.username", false);
retroachievements->addInputTextRow(_("PASSWORD"), "global.retroachievements.password", true);
// retroachievements_hardcore_mode
auto retroachievements_menuitem = std::make_shared<SwitchComponent>(mWindow);
retroachievements_menuitem->setState(Settings::getInstance()->getBool("RetroachievementsMenuitem"));
retroachievements->addWithLabel(_("SHOW RETROACHIEVEMENTS ENTRY IN MAIN MENU"), retroachievements_menuitem);
retroachievements->addSaveFunc([retroachievements_menuitem] { Settings::getInstance()->setBool("RetroachievementsMenuitem", retroachievements_menuitem->getState()); });
retroachievements->addGroup(_("GAME INDEXES"));
// CheckOnStart
auto checkOnStart = std::make_shared<SwitchComponent>(mWindow);
checkOnStart->setState(Settings::getInstance()->getBool("CheevosCheckIndexesAtStart"));
retroachievements->addWithLabel(_("INDEX NEW GAMES AT STARTUP"), checkOnStart);
retroachievements->addSaveFunc([checkOnStart] { Settings::getInstance()->setBool("CheevosCheckIndexesAtStart", checkOnStart->getState()); });
// Index games
retroachievements->addEntry(_("INDEX GAMES"), true, [this]
{
if (ThreadedHasher::checkCloseIfRunning(mWindow))
mWindow->pushGui(new GuiHashStart(mWindow, ThreadedHasher::HASH_CHEEVOS_MD5));
});
//retroachievements->addEntry(_("FIND ALL GAMES"), false, [this] { ThreadedHasher::start(mWindow, ThreadedHasher::HASH_CHEEVOS_MD5, true); });
//retroachievements->addEntry(_("FIND NEW GAMES"), false, [this] { ThreadedHasher::start(mWindow, ThreadedHasher::HASH_CHEEVOS_MD5); });
retroachievements->addSaveFunc([retroachievementsEnabled, retroachievements_enabled, username, password, window]
{
bool newState = retroachievements_enabled->getState();
std::string newUsername = SystemConf::getInstance()->get("global.retroachievements.username");
std::string newPassword = SystemConf::getInstance()->get("global.retroachievements.password");
if (newState && (!retroachievementsEnabled || username != newUsername || password != newPassword))
{
std::string error;
if (!RetroAchievements::testAccount(newUsername, newPassword, error))
{
window->pushGui(new GuiMsgBox(window, _("UNABLE TO ACTIVATE RETROACHIEVEMENTS:") + "\n" + error, _("OK"), nullptr, GuiMsgBoxIcon::ICON_ERROR));
retroachievements_enabled->setState(false);
newState = false;
}
}
if (SystemConf::getInstance()->setBool("global.retroachievements", newState))
if (!ThreadedHasher::isRunning() && newState)
ThreadedHasher::start(window, ThreadedHasher::HASH_CHEEVOS_MD5, false, true);
});
mWindow->pushGui(retroachievements);
}
template <typename StructType, typename FieldSelectorUnaryFn>
static auto groupBy(const std::vector<StructType>& instances, const FieldSelectorUnaryFn& fieldChooser) // -> std::map<decltype(forward<FieldSelectorUnaryFn>(fieldChooser)), std::vector<StructType>>
{
StructType _;
using FieldType = decltype(fieldChooser(_));
std::map<FieldType, std::vector<StructType>> instancesByField;
for (auto& instance : instances)
{
instancesByField[fieldChooser(instance)].push_back(instance);
}
return instancesByField;
}
void GuiMenu::openNetplaySettings()
{
GuiSettings* settings = new GuiSettings(mWindow, _("NETPLAY SETTINGS").c_str());
settings->addGroup(_("SETTINGS"));
// Enable
auto enableNetplay = std::make_shared<SwitchComponent>(mWindow);
enableNetplay->setState(SystemConf::getInstance()->getBool("global.netplay"));
settings->addWithLabel(_("ENABLE NETPLAY"), enableNetplay);
std::string port = SystemConf::getInstance()->get("global.netplay.port");
if (port.empty())
SystemConf::getInstance()->set("global.netplay.port", "55435");
settings->addInputTextRow(_("NICKNAME"), "global.netplay.nickname", false);
settings->addInputTextRow(_("PORT"), "global.netplay.port", false);
// RELAY SERVER
std::string mitm = SystemConf::getInstance()->get("global.netplay.relay");
auto mitms = std::make_shared<OptionListComponent<std::string> >(mWindow, _("USE RELAY SERVER"), false);
mitms->add(_("NONE"), "", mitm.empty() || mitm == "none");
mitms->add("NEW YORK", "nyc", mitm == "nyc");
mitms->add("MADRID", "madrid", mitm == "madrid");
mitms->add("MONTREAL", "montreal", mitm == "montreal");
mitms->add("SAO PAULO", "saopaulo", mitm == "saopaulo");
if (!mitms->hasSelection())
mitms->selectFirstItem();
settings->addWithLabel(_("USE RELAY SERVER"), mitms);
settings->addGroup(_("GAME INDEXES"));
// CheckOnStart
auto checkOnStart = std::make_shared<SwitchComponent>(mWindow);
checkOnStart->setState(Settings::getInstance()->getBool("NetPlayCheckIndexesAtStart"));
settings->addWithLabel(_("INDEX NEW GAMES AT STARTUP"), checkOnStart);
Window* window = mWindow;
settings->addSaveFunc([enableNetplay, checkOnStart, mitms, window]
{
Settings::getInstance()->setBool("NetPlayCheckIndexesAtStart", checkOnStart->getState());
SystemConf::getInstance()->set("global.netplay.relay", mitms->getSelected());
if (SystemConf::getInstance()->setBool("global.netplay", enableNetplay->getState()))
{
if (!ThreadedHasher::isRunning() && enableNetplay->getState())
{
ThreadedHasher::start(window, ThreadedHasher::HASH_NETPLAY_CRC, false, true);
}
}
});
settings->addEntry(_("INDEX GAMES"), true, [this]
{
if (ThreadedHasher::checkCloseIfRunning(mWindow))
mWindow->pushGui(new GuiHashStart(mWindow, ThreadedHasher::HASH_NETPLAY_CRC));
});
//settings->addEntry(_("FIND ALL GAMES"), false, [this] { ThreadedHasher::start(mWindow, ThreadedHasher::HASH_NETPLAY_CRC, true); });
//settings->addEntry(_("FIND NEW GAMES"), false, [this] { ThreadedHasher::start(mWindow, ThreadedHasher::HASH_NETPLAY_CRC); });
mWindow->pushGui(settings);
}
void GuiMenu::addDecorationSetOptionListComponent(Window* window, GuiSettings* parentWindow, const std::vector<DecorationSetInfo>& sets, const std::string& configName)
{
auto decorations = std::make_shared<OptionListComponent<std::string> >(window, _("DECORATION SET"), false);
decorations->setRowTemplate([window, sets](std::string data, ComponentListRow& row) { createDecorationItemTemplate(window, sets, data, row); });
std::vector<std::string> items = { _("AUTO"), _("NONE") };
for (auto set : sets)
items.push_back(set.name);
std::string bezel = SystemConf::getInstance()->get(configName + ".bezel");
for (auto item : items)
decorations->add(item, item, (bezel == item) || (bezel == "none" && item == _("NONE")) || (bezel == "" && item == _("AUTO")));
if (!decorations->hasSelection())
decorations->selectFirstItem();
parentWindow->addWithLabel(_("DECORATION SET"), decorations);
parentWindow->addSaveFunc([decorations, configName]
{
SystemConf::getInstance()->set(configName + ".bezel", decorations->getSelected() == _("NONE") ? "none" : decorations->getSelected() == _("AUTO") ? "" : decorations->getSelected());
});
};
void GuiMenu::openGamesSettings_batocera()
{
Window* window = mWindow;
auto s = new GuiSettings(mWindow, _("GAME SETTINGS").c_str());
if (SystemConf::getInstance()->get("system.es.menu") != "bartop")
{
s->addGroup(_("TOOLS"));
// Game List Update
s->addEntry(_("UPDATE GAMELISTS"), false, [this, window] { updateGameLists(window); });
if (SystemConf::getInstance()->getBool("global.retroachievements") &&
!Settings::getInstance()->getBool("RetroachievementsMenuitem") &&
SystemConf::getInstance()->get("global.retroachievements.username") != "")
{
s->addEntry(_("RETROACHIEVEMENTS").c_str(), true, [this]
{
if (!checkNetwork())
return;
GuiRetroAchievements::show(mWindow);
}/*, "iconRetroachievements"*/);
}
}
s->addGroup(_("DEFAULT GLOBAL SETTINGS"));
// Screen ratio choice
if (SystemConf::getInstance()->get("system.es.menu") != "bartop")
{
auto ratio_choice = createRatioOptionList(mWindow, "global");
s->addWithLabel(_("GAME ASPECT RATIO"), ratio_choice);
s->addSaveFunc([ratio_choice] { SystemConf::getInstance()->set("global.ratio", ratio_choice->getSelected()); });
}
#ifndef _ENABLEEMUELEC
// video resolution mode
if (ApiSystem::getInstance()->isScriptingSupported(ApiSystem::RESOLUTION))
{
auto videoModeOptionList = createVideoResolutionModeOptionList(mWindow, "global");
s->addWithLabel(_("VIDEO MODE"), videoModeOptionList);
s->addSaveFunc([this, videoModeOptionList] { SystemConf::getInstance()->set("global.videomode", videoModeOptionList->getSelected()); });
}
#endif
// bilinear filtering
auto smoothing_enabled = std::make_shared<OptionListComponent<std::string>>(mWindow, _("BILINEAR FILTERING"));
smoothing_enabled->addRange({ { _("AUTO"), "auto" },{ _("ON") , "1" },{ _("OFF") , "0" } }, SystemConf::getInstance()->get("global.smooth"));
s->addWithLabel(_("BILINEAR FILTERING"), smoothing_enabled);
s->addSaveFunc([smoothing_enabled] { SystemConf::getInstance()->set("global.smooth", smoothing_enabled->getSelected()); });
#ifdef _ENABLEEMUELEC
// bezel
/*
auto bezel_enabled = std::make_shared<OptionListComponent<std::string>>(mWindow, _("ENABLE RA BEZELS"));
bezel_enabled->add(_("AUTO"), "auto", SystemConf::getInstance()->get("global.bezel") != "0" && SystemConf::getInstance()->get("global.bezel") != "1");
bezel_enabled->add(_("ON"), "1", SystemConf::getInstance()->get("global.bezel") == "1");
bezel_enabled->add(_("OFF"), "0", SystemConf::getInstance()->get("global.bezel") == "0");
s->addWithLabel(_("ENABLE RA BEZELS"), bezel_enabled);
s->addSaveFunc([bezel_enabled] { SystemConf::getInstance()->set("global.bezel", bezel_enabled->getSelected()); });
*/
//maxperf
auto maxperf_enabled = std::make_shared<OptionListComponent<std::string>>(mWindow, _("ENABLE MAX PERFORMANCE"));
maxperf_enabled->add(_("ON"), "1", SystemConf::getInstance()->get("global.maxperf") == "1" || SystemConf::getInstance()->get("global.maxperf") != "0");
maxperf_enabled->add(_("OFF"), "0", SystemConf::getInstance()->get("global.maxperf") == "0");
s->addWithLabel(_("ENABLE MAX PERFORMANCE"), maxperf_enabled);
s->addSaveFunc([maxperf_enabled] { SystemConf::getInstance()->set("global.maxperf", maxperf_enabled->getSelected()); });
#endif
// rewind
auto rewind_enabled = std::make_shared<OptionListComponent<std::string>>(mWindow, _("REWIND"));
rewind_enabled->addRange({ { _("AUTO"), "auto" },{ _("ON") , "1" },{ _("OFF") , "0" } }, SystemConf::getInstance()->get("global.rewind"));
s->addWithLabel(_("REWIND"), rewind_enabled);
s->addSaveFunc([rewind_enabled] { SystemConf::getInstance()->set("global.rewind", rewind_enabled->getSelected()); });
// Integer scale
auto integerscale_enabled = std::make_shared<OptionListComponent<std::string>>(mWindow, _("INTEGER SCALING (PIXEL PERFECT)"));
integerscale_enabled->addRange({ { _("AUTO"), "auto" },{ _("ON") , "1" },{ _("OFF") , "0" } }, SystemConf::getInstance()->get("global.integerscale"));
s->addWithLabel(_("INTEGER SCALING (PIXEL PERFECT)"), integerscale_enabled);
s->addSaveFunc([integerscale_enabled] { SystemConf::getInstance()->set("global.integerscale", integerscale_enabled->getSelected()); });
// Integer scale overscale
auto integerscaleoverscale_enabled = std::make_shared<OptionListComponent<std::string>>(mWindow, _("INTEGER SCALE OVERSCALE"));
integerscaleoverscale_enabled->addRange({ { _("AUTO"), "auto" },{ _("ON") , "1" },{ _("OFF") , "0" } }, SystemConf::getInstance()->get("global.integerscaleoverscale"));
s->addWithLabel(_("INTEGER SCALE OVERSCALE"), integerscaleoverscale_enabled);
s->addSaveFunc([integerscaleoverscale_enabled] { SystemConf::getInstance()->set("global.integerscaleoverscale", integerscaleoverscale_enabled->getSelected()); });
// RGA scale
auto rgascale_enabled = std::make_shared<OptionListComponent<std::string>>(mWindow, _("RGA SCALE"));
rgascale_enabled->addRange({ { _("AUTO"), "auto" },{ _("ON") , "1" },{ _("OFF") , "0" } }, SystemConf::getInstance()->get("global.rgascale"));
s->addWithLabel(_("RGA SCALE"), rgascale_enabled);
s->addSaveFunc([rgascale_enabled] { SystemConf::getInstance()->set("global.rgascale", rgascale_enabled->getSelected()); });
// autosave/load
auto autosave_enabled = std::make_shared<OptionListComponent<std::string>>(mWindow, _("AUTO SAVE/LOAD ON GAME LAUNCH"));
autosave_enabled->addRange({ { _("OFF"), "auto" },{ _("ON") , "1" },{ _("SHOW SAVE STATES") , "2" },{ _("SHOW SAVE STATES IF NOT EMPTY") , "3" } }, SystemConf::getInstance()->get("global.autosave"));
s->addWithLabel(_("AUTO SAVE/LOAD ON GAME LAUNCH"), autosave_enabled);
s->addSaveFunc([autosave_enabled] { SystemConf::getInstance()->set("global.autosave", autosave_enabled->getSelected()); });
// Incremental savestates
auto incrementalSaveStates = std::make_shared<SwitchComponent>(mWindow);
incrementalSaveStates->setState(SystemConf::getInstance()->get("global.incrementalsavestates") == "1");
s->addWithLabel(_("INCREMENTAL SAVESTATES"), incrementalSaveStates);
s->addSaveFunc([incrementalSaveStates] { SystemConf::getInstance()->set("global.incrementalsavestates", incrementalSaveStates->getState() ? "1" : "0"); });
// Shaders preset
#ifndef _ENABLEEMUELEC
if (ApiSystem::getInstance()->isScriptingSupported(ApiSystem::SHADERS))
{
auto installedShaders = ApiSystem::getInstance()->getShaderList();
if (installedShaders.size() > 0)
{
#endif
std::string currentShader = SystemConf::getInstance()->get("global.shaderset");
auto shaders_choices = std::make_shared<OptionListComponent<std::string> >(mWindow, _("SHADER SET"), false);
shaders_choices->add(_("AUTO"), "auto", currentShader.empty() || currentShader == "auto");
shaders_choices->add(_("NONE"), "none", currentShader == "none");
#ifdef _ENABLEEMUELEC
std::string a;
for(std::stringstream ss(getShOutput(R"(/usr/bin/emuelec-utils getshaders)")); getline(ss, a, ','); )
shaders_choices->add(a, a, currentShader == a); // emuelec
#else
for (auto shader : installedShaders)
shaders_choices->add(_(Utils::String::toUpper(shader).c_str()), shader, currentShader == shader);
if (!shaders_choices->hasSelection())
shaders_choices->selectFirstItem();
#endif
s->addWithLabel(_("SHADER SET"), shaders_choices);
s->addSaveFunc([shaders_choices] { SystemConf::getInstance()->set("global.shaderset", shaders_choices->getSelected()); });
#ifndef _ENABLEEMUELEC
}
}
#endif
// Filters preset
std::string currentFilter = SystemConf::getInstance()->get("global.filterset");
auto filters_choices = std::make_shared<OptionListComponent<std::string> >(mWindow, _("FILTER SET"), false);
filters_choices->add(_("AUTO"), "auto", currentFilter.empty() || currentFilter == "auto");
filters_choices->add(_("NONE"), "none", currentFilter == "none");
std::string filterList;
for(std::stringstream ss(getShOutput(R"(/usr/bin/emuelec-utils getfilters)")); getline(ss, filterList, ','); )
filters_choices->add(filterList, filterList, currentFilter == filterList); // emuelec
s->addWithLabel(_("FILTER SET"), filters_choices);
s->addSaveFunc([filters_choices] { SystemConf::getInstance()->set("global.filterset", filters_choices->getSelected()); });
// decorations
if (ApiSystem::getInstance()->isScriptingSupported(ApiSystem::DECORATIONS))
{
auto sets = GuiMenu::getDecorationsSets(ViewController::get()->getState().getSystem());
if (sets.size() > 0)
{
auto decorations = std::make_shared<OptionListComponent<std::string> >(mWindow, _("DECORATION SET"), false);
decorations->setRowTemplate([window, sets](std::string data, ComponentListRow& row)
{
createDecorationItemTemplate(window, sets, data, row);
});
std::vector<std::string> decorations_item;
decorations_item.push_back(_("AUTO"));
decorations_item.push_back(_("NONE"));
for (auto set : sets)
decorations_item.push_back(set.name);
for (auto it = decorations_item.begin(); it != decorations_item.end(); it++)
decorations->add(*it, *it,
(SystemConf::getInstance()->get("global.bezel") == *it) ||
(SystemConf::getInstance()->get("global.bezel") == "none" && *it == _("NONE")) ||
(SystemConf::getInstance()->get("global.bezel") == "" && *it == _("AUTO")));
s->addWithLabel(_("DECORATION SET"), decorations);
decorations->setSelectedChangedCallback([decorations](std::string value)
{
if (Utils::String::toLower(value) == "auto") {
value = "";
}
LOG(LogDebug) << "Setting bezel on change to: " << value;
SystemConf::getInstance()->set("global.bezel", value);
});
if (decorations->getSelectedName() == "")
{
decorations->selectFirstItem();
}
#ifndef _ENABLEEMUELEC
// stretch bezels
auto bezel_stretch_enabled = std::make_shared<OptionListComponent<std::string>>(mWindow, _("STRETCH BEZELS (4K & ULTRAWIDE)"));
bezel_stretch_enabled->add(_("AUTO"), "auto", SystemConf::getInstance()->get("global.bezel_stretch") != "0" && SystemConf::getInstance()->get("global.bezel_stretch") != "1");
bezel_stretch_enabled->add(_("ON"), "1", SystemConf::getInstance()->get("global.bezel_stretch") == "1");
bezel_stretch_enabled->add(_("OFF"), "0", SystemConf::getInstance()->get("global.bezel_stretch") == "0");
decorations_window->addWithLabel(_("STRETCH BEZELS (4K & ULTRAWIDE)"), bezel_stretch_enabled);
decorations_window->addSaveFunc([bezel_stretch_enabled] {
if (bezel_stretch_enabled->changed()) {
SystemConf::getInstance()->set("global.bezel_stretch", bezel_stretch_enabled->getSelected());
SystemConf::getInstance()->saveSystemConf();
}
});
// tattoo and controller overlays
auto bezel_tattoo = std::make_shared<OptionListComponent<std::string>>(mWindow, _("SHOW CONTROLLER OVERLAYS"));
bezel_tattoo->add(_("AUTO"), "auto", SystemConf::getInstance()->get("global.bezel.tattoo") != "0"
&& SystemConf::getInstance()->get("global.bezel.tattoo") != "system"
&& SystemConf::getInstance()->get("global.bezel.tattoo") != "custom");
bezel_tattoo->add(_("NO"), "0", SystemConf::getInstance()->get("global.bezel.tattoo") == "0");
bezel_tattoo->add(_("SYSTEM CONTROLLERS"), "system", SystemConf::getInstance()->get("global.bezel.tattoo") == "system");
bezel_tattoo->add(_("CUSTOM .PNG IMAGE"), "custom", SystemConf::getInstance()->get("global.bezel.tattoo") == "custom");
decorations_window->addWithLabel(_("SHOW CONTROLLER OVERLAYS"), bezel_tattoo);
decorations_window->addSaveFunc([bezel_tattoo] {
if (bezel_tattoo->changed()) {
SystemConf::getInstance()->set("global.bezel.tattoo", bezel_tattoo->getSelected());
SystemConf::getInstance()->saveSystemConf();
}
});
auto bezel_tattoo_corner = std::make_shared<OptionListComponent<std::string>>(mWindow, _("OVERLAY CORNER"));
bezel_tattoo_corner->add(_("AUTO"), "auto", SystemConf::getInstance()->get("global.bezel.tattoo_corner") != "NW"
&& SystemConf::getInstance()->get("global.bezel.tattoo_corner") != "NE"
&& SystemConf::getInstance()->get("global.bezel.tattoo_corner") != "SE"
&& SystemConf::getInstance()->get("global.bezel.tattoo_corner") != "SW");
bezel_tattoo_corner->add(_("NORTH WEST"), "NW", SystemConf::getInstance()->get("global.bezel.tattoo_corner") == "NW");
bezel_tattoo_corner->add(_("NORTH EAST"), "NE", SystemConf::getInstance()->get("global.bezel.tattoo_corner") == "NE");
bezel_tattoo_corner->add(_("SOUTH EAST"), "SE", SystemConf::getInstance()->get("global.bezel.tattoo_corner") == "SE");
bezel_tattoo_corner->add(_("SOUTH WEST"), "SW", SystemConf::getInstance()->get("global.bezel.tattoo_corner") == "SW");
decorations_window->addWithLabel(_("OVERLAY CORNER"), bezel_tattoo_corner);
decorations_window->addSaveFunc([bezel_tattoo_corner] {
if (bezel_tattoo_corner->changed()) {
SystemConf::getInstance()->set("global.bezel.tattoo_corner", bezel_tattoo_corner->getSelected());
SystemConf::getInstance()->saveSystemConf();
}
});
decorations_window->addInputTextRow(_("CUSTOM .PNG IMAGE PATH"), "global.bezel.tattoo_file", false);
mWindow->pushGui(decorations_window);
});
#endif
}
}
// latency reduction
s->addEntry(_("LATENCY REDUCTION"), true, [this] { openLatencyReductionConfiguration(mWindow, "global"); });
//AI-enabled translations
s->addEntry(_("AI GAME TRANSLATION"), true, [this]
{
GuiSettings *ai_service = new GuiSettings(mWindow, _("AI GAME TRANSLATION").c_str());
// AI service enabled?
auto ai_service_enabled = std::make_shared<SwitchComponent>(mWindow);
ai_service_enabled->setState(
SystemConf::getInstance()->get("global.ai_service_enabled") == "1");
ai_service->addWithLabel(_("ENABLE AI TRANSLATION SERVICE"), ai_service_enabled);
// Target language - order is: popular languages in the Batocera community first
// then alphabetical order of the 2-char lang code (because the strings are localized)
auto lang_choices = std::make_shared<OptionListComponent<std::string> >(mWindow,
_("TARGET LANGUAGE"), false);
std::string currentLang = SystemConf::getInstance()->get("global.ai_target_lang");
if (currentLang.empty())
currentLang = std::string("En");
lang_choices->add("ENGLISH", "En", currentLang == "En");
lang_choices->add("FRANÇAIS", "Fr", currentLang == "Fr");
lang_choices->add("PORTUGUES", "Pt", currentLang == "Pt");
lang_choices->add("DEUTSCH", "De", currentLang == "De");
lang_choices->add("GREEK", "El", currentLang == "El");
lang_choices->add("ESPAÑOL", "Es", currentLang == "Es");
lang_choices->add("CZECH", "Cs", currentLang == "Cs");
lang_choices->add("DANISH", "Da", currentLang == "Da");
lang_choices->add("CROATIAN", "Hr", currentLang == "Hr");
lang_choices->add("HUNGARIAN", "Hu", currentLang == "Hu");
lang_choices->add("ITALIANO", "It", currentLang == "It");
lang_choices->add("JAPANESE", "Ja", currentLang == "Ja");
lang_choices->add("KOREAN", "Ko", currentLang == "Ko");
lang_choices->add("DUTCH", "Nl", currentLang == "Nl");
lang_choices->add("NORWEGIAN", "Nn", currentLang == "Nn");
lang_choices->add("POLISH", "Po", currentLang == "Po");
lang_choices->add("ROMANIAN", "Ro", currentLang == "Ro");
lang_choices->add("РУССКИЙ", "Ru", currentLang == "Ru");
lang_choices->add("SVENSKA", "Sv", currentLang == "Sv");
lang_choices->add("TÜRKÇE", "Tr", currentLang == "Tr");
lang_choices->add("简体中文", "Zh", currentLang == "Zh");
ai_service->addWithLabel(_("TARGET LANGUAGE"), lang_choices);
// Service URL
ai_service->addInputTextRow(_("AI TRANSLATION SERVICE URL"), "global.ai_service_url", false);
// Pause game for translation?
auto ai_service_pause = std::make_shared<SwitchComponent>(mWindow);
ai_service_pause->setState(
SystemConf::getInstance()->get("global.ai_service_pause") == "1");
ai_service->addWithLabel(_("PAUSE ON TRANSLATED SCREEN"), ai_service_pause);
ai_service->addSaveFunc([ai_service_enabled, lang_choices, ai_service_pause] {
if (ai_service_enabled->changed())
SystemConf::getInstance()->set("global.ai_service_enabled",
ai_service_enabled->getState() ? "1" : "0");
if (lang_choices->changed())
SystemConf::getInstance()->set("global.ai_target_lang",
lang_choices->getSelected());
if (ai_service_pause->changed())
SystemConf::getInstance()->set("global.ai_service_pause",
ai_service_pause->getState() ? "1" : "0");
SystemConf::getInstance()->saveSystemConf();
});
mWindow->pushGui(ai_service);
});
auto groups = groupBy(SystemData::mGlobalFeatures, [](const CustomFeature& item) { return item.submenu; });
for (auto group : groups)
{
if (!group.first.empty())
{
s->addEntry(group.first, true, [this, group]
{
GuiSettings* groupSettings = new GuiSettings(mWindow, _(group.first.c_str()));
for (auto feat : group.second)
{
std::string storageName = "global." + feat.value;
std::string storedValue = SystemConf::getInstance()->get(storageName);
auto cf = std::make_shared<OptionListComponent<std::string>>(mWindow, _(feat.name.c_str()));
cf->add(_("AUTO"), "", storedValue.empty() || storedValue == "auto");
for (auto fval : feat.choices)
cf->add(_(fval.name.c_str()), fval.value, storedValue == fval.value);
if (!cf->hasSelection())
cf->selectFirstItem();
if (!feat.description.empty())
groupSettings->addWithDescription(_(feat.name.c_str()), _(feat.description.c_str()), cf);
else
groupSettings->addWithLabel(_(feat.name.c_str()), cf);
groupSettings->addSaveFunc([cf, storageName] { SystemConf::getInstance()->set(storageName, cf->getSelected()); });
}
mWindow->pushGui(groupSettings);
});
}
else
{
// Load global custom features
for (auto feat : group.second)
{
std::string storageName = "global." + feat.value;
std::string storedValue = SystemConf::getInstance()->get(storageName);
auto cf = std::make_shared<OptionListComponent<std::string>>(mWindow, _(feat.name.c_str()));
cf->add(_("AUTO"), "", storedValue.empty() || storedValue == "auto");
for (auto fval : feat.choices)
cf->add(_(fval.name.c_str()), fval.value, storedValue == fval.value);
if (!cf->hasSelection())
cf->selectFirstItem();
if (!feat.description.empty())
s->addWithDescription(_(feat.name.c_str()), _(feat.description.c_str()), cf);
else
s->addWithLabel(_(feat.name.c_str()), cf);
s->addSaveFunc([cf, storageName] { SystemConf::getInstance()->set(storageName, cf->getSelected()); });
}
}
}
// Custom config for systems
s->addGroup(_("SETTINGS"));
s->addEntry(_("PER SYSTEM ADVANCED CONFIGURATION"), true, [this, s, window]
{
s->save();
GuiSettings* configuration = new GuiSettings(window, _("PER SYSTEM ADVANCED CONFIGURATION").c_str());
// For each activated system
std::vector<SystemData *> systems = SystemData::sSystemVector;
for (auto system : systems)
{
if (system->isCollection() || !system->isGameSystem())
continue;
if (system->hasPlatformId(PlatformIds::PLATFORM_IGNORE))
continue;
if (!system->hasFeatures() && !system->hasEmulatorSelection())
continue;
configuration->addEntry(system->getFullName(), true, [this, system, window] {
popSystemConfigurationGui(window, system);
});
}
window->pushGui(configuration);
});
if (SystemConf::getInstance()->get("system.es.menu") != "bartop")
{
s->addGroup(_("SYSTEM SETTINGS"));
// Retroachievements
if (ApiSystem::getInstance()->isScriptingSupported(ApiSystem::RETROACHIVEMENTS))
{
/*
if (SystemConf::getInstance()->getBool("global.retroachievements") &&
!Settings::getInstance()->getBool("RetroachievementsMenuitem") &&
SystemConf::getInstance()->get("global.retroachievements.username") != "")
s->addEntry(_("RETROACHIEVEMENTS").c_str(), true, [this] { GuiRetroAchievements::show(mWindow); }, "iconRetroachievements");
*/
s->addEntry(_("RETROACHIEVEMENT SETTINGS"), true, [this] { openRetroachievementsSettings(); });
}
// Netplay
if (SystemData::isNetplayActivated() && ApiSystem::getInstance()->isScriptingSupported(ApiSystem::NETPLAY))
s->addEntry(_("NETPLAY SETTINGS"), true, [this] { openNetplaySettings(); }, "iconNetplay");
// Missing Bios
if (ApiSystem::getInstance()->isScriptingSupported(ApiSystem::BIOSINFORMATION))
{
s->addEntry(_("MISSING BIOS CHECK"), true, [this, s] { openMissingBiosSettings(); });
#ifndef _ENABLEEMUELEC
auto checkBiosesAtLaunch = std::make_shared<SwitchComponent>(mWindow);
checkBiosesAtLaunch->setState(Settings::getInstance()->getBool("CheckBiosesAtLaunch"));
s->addWithLabel(_("CHECK BIOS FILES BEFORE RUNNING A GAME"), checkBiosesAtLaunch);
s->addSaveFunc([checkBiosesAtLaunch] { Settings::getInstance()->setBool("CheckBiosesAtLaunch", checkBiosesAtLaunch->getState()); });
#endif
}
// Game List Update
// s->addEntry(_("UPDATE GAME LISTS"), false, [this, window] { updateGameLists(window); });
}
mWindow->pushGui(s);
}
void GuiMenu::openMissingBiosSettings()
{
GuiBios::show(mWindow);
}
void GuiMenu::updateGameLists(Window* window, bool confirm)
{
if (ThreadedScraper::isRunning())
{
window->pushGui(new GuiMsgBox(window, _("SCRAPER IS RUNNING. DO YOU WANT TO STOP IT?"),
_("YES"), [] { ThreadedScraper::stop(); },
_("NO"), nullptr));
return;
}
if (ThreadedHasher::isRunning())
{
window->pushGui(new GuiMsgBox(window, _("GAME HASHING IS RUNNING. DO YOU WANT TO STOP IT?"),
_("YES"), [] { ThreadedHasher::stop(); },
_("NO"), nullptr));
return;
}
if (!confirm)
{
ViewController::reloadAllGames(window, true, true);
return;
}
window->pushGui(new GuiMsgBox(window, _("REALLY UPDATE GAMELISTS?"), _("YES"), [window]
{
ViewController::reloadAllGames(window, true, true);
},
_("NO"), nullptr));
}
void GuiMenu::openSystemEmulatorSettings(SystemData* system)
{
auto theme = ThemeData::getMenuTheme();
GuiSettings* s = new GuiSettings(mWindow, system->getFullName().c_str());
auto emul_choice = std::make_shared<OptionListComponent<std::string>>(mWindow, _("Emulator"), false);
auto core_choice = std::make_shared<OptionListComponent<std::string>>(mWindow, _("Core"), false);
std::string currentEmul = system->getEmulator(false);
std::string defaultEmul = system->getDefaultEmulator();
emul_choice->add(_("AUTO"), "", false);
bool found = false;
for (auto emul : system->getEmulators())
{
if (emul.name == currentEmul)
found = true;
emul_choice->add(emul.name, emul.name, emul.name == currentEmul);
}
if (!found)
emul_choice->selectFirstItem();
ComponentListRow row;
row.addElement(std::make_shared<TextComponent>(mWindow, Utils::String::toUpper(_("Emulator")), theme->Text.font, theme->Text.color), true);
row.addElement(emul_choice, false);
s->addRow(row);
emul_choice->setSelectedChangedCallback([this, system, core_choice](std::string emulatorName)
{
std::string currentCore = system->getCore(false);
std::string defaultCore = system->getDefaultCore(emulatorName);
core_choice->clear();
core_choice->add(_("AUTO"), "", false);
bool found = false;
for (auto& emulator : system->getEmulators())
{
if (emulatorName != emulator.name)
continue;
for (auto core : emulator.cores)
{
core_choice->add(core.name, core.name, currentCore == core.name);
if (currentCore == core.name)
found = true;
}
}
if (!found)
core_choice->selectFirstItem();
else
core_choice->invalidate();
});
row.elements.clear();
row.addElement(std::make_shared<TextComponent>(mWindow, Utils::String::toUpper(_("Core")), theme->Text.font, theme->Text.color), true);
row.addElement(core_choice, false);
s->addRow(row);
// force change event to load core list
emul_choice->invalidate();
s->addSaveFunc([system, emul_choice, core_choice]
{
Settings::getInstance()->setString(system->getName() + ".emulator", emul_choice->getSelected());
Settings::getInstance()->setString(system->getName() + ".core", core_choice->getSelected());
});
mWindow->pushGui(s);
}
void GuiMenu::openEmulatorSettings()
{
GuiSettings* configuration = new GuiSettings(mWindow, _("EMULATOR SETTINGS").c_str());
Window* window = mWindow;
// For each activated system
for (auto system : SystemData::sSystemVector)
{
if (system->isCollection())
continue;
if (system->getEmulators().size() == 0)
continue;
if (system->getEmulators().size() == 1 && system->getEmulators().cbegin()->cores.size() <= 1)
continue;
configuration->addEntry(system->getFullName(), true, [this, system] { openSystemEmulatorSettings(system); });
}
window->pushGui(configuration);
}
void GuiMenu::openControllersSettings_batocera(int autoSel)
{
GuiSettings* s = new GuiSettings(mWindow, controllers_settings_label.c_str());
Window *window = mWindow;
// CONTROLLER CONFIGURATION
s->addEntry(_("CONTROLLER MAPPING"), false, [window, this, s]
{
window->pushGui(new GuiMsgBox(window,
_("YOU ARE GOING TO MAP A CONTROLLER. MAP BASED ON THE BUTTON'S POSITION "
"RELATIVE TO ITS EQUIVALENT ON A SNES CONTROLLER, NOT ITS PHYSICAL LABEL. "
"IF YOU DO NOT HAVE A SPECIAL KEY FOR HOTKEY, USE THE SELECT BUTTON. SKIP "
"ALL BUTTONS/STICKS YOU DO NOT HAVE BY HOLDING ANY KEY. PRESS THE "
"SOUTH BUTTON TO CONFIRM WHEN DONE."), _("OK"),
[window, this, s] {
window->pushGui(new GuiDetectDevice(window, false, [this, s] {
s->setSave(false);
delete s;
this->openControllersSettings_batocera();
}));
}));
});
if (ApiSystem::getInstance()->isScriptingSupported(ApiSystem::BLUETOOTH))
{
// PAIR A BLUETOOTH CONTROLLER OR BT AUDIO DEVICE
s->addEntry(_("PAIR A BLUETOOTH DEVICE"), false, [window] { ThreadedBluetooth::start(window); });
// FORGET BLUETOOTH CONTROLLERS OR BT AUDIO DEVICES
s->addEntry(_("FORGET A BLUETOOTH DEVICE"), false, [window, this, s]
{
window->pushGui(new GuiBluetooth(window));
});
}
ComponentListRow row;
// Here we go; for each player
std::list<int> alreadyTaken = std::list<int>();
// clear the current loaded inputs
clearLoadedInput();
std::vector<std::shared_ptr<OptionListComponent<StrInputConfig *>>> options;
//char strbuf[256];
auto configList = InputManager::getInstance()->getInputConfigs();
for (int player = 0; player < MAX_PLAYERS; player++)
{
std::string label = Utils::String::format(_("P%i'S CONTROLLER").c_str(), player + 1);
std::string confName = Utils::String::format("INPUT P%iNAME", player + 1);
std::string confGuid = Utils::String::format("INPUT P%iGUID", player + 1);
LOG(LogInfo) << player + 1 << " " << confName << " " << confGuid;
auto inputOptionList = std::make_shared<OptionListComponent<StrInputConfig *> >(mWindow, label, false);
inputOptionList->add(_("default"), nullptr, false);
options.push_back(inputOptionList);
// Checking if a setting has been saved, else setting to default
std::string configuratedName = Settings::getInstance()->getString(confName);
std::string configuratedGuid = Settings::getInstance()->getString(confGuid);
bool found = false;
// For each available and configured input
for (auto config : configList)
{
// create name
std::stringstream dispNameSS;
dispNameSS << "#" << config->getDeviceIndex() << " ";
std::string deviceName = config->getDeviceName();
if (deviceName.size() > 25)
dispNameSS << deviceName.substr(0, 16) << "..." << deviceName.substr(deviceName.size() - 5, deviceName.size() - 1);
else
dispNameSS << deviceName;
std::string displayName = dispNameSS.str();
bool foundFromConfig = configuratedName == config->getDeviceName() && configuratedGuid == config->getDeviceGUIDString();
int deviceID = config->getDeviceId();
// Si la manette est configurée, qu'elle correspond a la configuration, et qu'elle n'est pas
// deja selectionnée on l'ajoute en séléctionnée
StrInputConfig* newInputConfig = new StrInputConfig(config->getDeviceName(), config->getDeviceGUIDString());
mLoadedInput.push_back(newInputConfig);
if (foundFromConfig && std::find(alreadyTaken.begin(), alreadyTaken.end(), deviceID) == alreadyTaken.end() && !found)
{
found = true;
alreadyTaken.push_back(deviceID);
LOG(LogWarning) << "adding entry for player" << player << " (selected): " << config->getDeviceName() << " " << config->getDeviceGUIDString();
inputOptionList->add(displayName, newInputConfig, true);
}
else
{
LOG(LogInfo) << "adding entry for player" << player << " (not selected): " << config->getDeviceName() << " " << config->getDeviceGUIDString();
inputOptionList->add(displayName, newInputConfig, false);
}
}
if (!inputOptionList->hasSelection())
inputOptionList->selectFirstItem();
// Populate controllers list
s->addWithLabel(label, inputOptionList);
}
s->addSaveFunc([this, options, window]
{
bool changed = false;
for (int player = 0; player < MAX_PLAYERS; player++)
{
std::stringstream sstm;
sstm << "INPUT P" << player + 1;
std::string confName = sstm.str() + "NAME";
std::string confGuid = sstm.str() + "GUID";
auto input = options.at(player);
StrInputConfig* selected = input->getSelected();
if (selected == nullptr)
{
changed |= Settings::getInstance()->setString(confName, "DEFAULT");
changed |= Settings::getInstance()->setString(confGuid, "");
}
else if (input->changed())
{
LOG(LogWarning) << "Found the selected controller ! : name in list = " << input->getSelectedName();
LOG(LogWarning) << "Found the selected controller ! : guid = " << selected->deviceGUIDString;
changed |= Settings::getInstance()->setString(confName, selected->deviceName);
changed |= Settings::getInstance()->setString(confGuid, selected->deviceGUIDString);
}
}
if (changed)
Settings::getInstance()->saveFile();
// this is dependant of this configuration, thus update it
InputManager::getInstance()->computeLastKnownPlayersDeviceIndexes();
});
// CONTROLLER ACTIVITY
auto activity = std::make_shared<SwitchComponent>(mWindow);
activity->setState(Settings::getInstance()->getBool("ShowControllerActivity"));
s->addWithLabel(_("SHOW CONTROLLER ACTIVITY"), activity, autoSel == 1);
activity->setOnChangedCallback([this, s, activity]
{
if (Settings::getInstance()->setBool("ShowControllerActivity", activity->getState()))
{
delete s;
openControllersSettings_batocera(1);
}
});
if (Settings::getInstance()->getBool("ShowControllerActivity"))
{
// CONTROLLER BATTERY
auto battery = std::make_shared<SwitchComponent>(mWindow);
battery->setState(Settings::getInstance()->getBool("ShowControllerBattery"));
s->addWithLabel(_("SHOW CONTROLLER BATTERY LEVEL"), battery);
s->addSaveFunc([battery] { Settings::getInstance()->setBool("ShowControllerBattery", battery->getState()); });
}
window->pushGui(s);
}
struct ThemeConfigOption
{
std::string defaultSettingName;
std::string subset;
std::shared_ptr<OptionListComponent<std::string>> component;
};
void GuiMenu::openThemeConfiguration(Window* mWindow, GuiComponent* s, std::shared_ptr<OptionListComponent<std::string>> theme_set, const std::string systemTheme)
{
if (theme_set != nullptr && Settings::getInstance()->getString("ThemeSet") != theme_set->getSelected())
{
mWindow->pushGui(new GuiMsgBox(mWindow, _("YOU MUST APPLY THE THEME BEFORE EDITING ITS CONFIGURATION"), _("OK")));
return;
}
Window* window = mWindow;
auto system = ViewController::get()->getState().getSystem();
auto theme = system->getTheme();
auto themeconfig = new GuiSettings(mWindow, (systemTheme.empty() ? _("THEME CONFIGURATION") : _("VIEW CUSTOMIZATION")).c_str());
auto themeSubSets = theme->getSubSets();
std::string viewName;
bool showGridFeatures = true;
if (!systemTheme.empty())
{
auto glv = ViewController::get()->getGameListView(system);
viewName = glv->getName();
std::string baseType = theme->getCustomViewBaseType(viewName);
showGridFeatures = (viewName == "grid" || baseType == "grid");
}
// gamelist_style
std::shared_ptr<OptionListComponent<std::string>> gamelist_style = nullptr;
if (systemTheme.empty() || showGridFeatures && system != NULL && theme->hasView("grid"))
themeconfig->addGroup(_("GAMELIST STYLE"));
if (systemTheme.empty())
{
gamelist_style = std::make_shared< OptionListComponent<std::string> >(mWindow, _("GAMELIST VIEW STYLE"), false);
std::vector<std::pair<std::string, std::string>> styles;
styles.push_back(std::pair<std::string, std::string>("automatic", _("automatic")));
bool showViewStyle = true;
if (system != NULL)
{
auto mViews = theme->getViewsOfTheme();
showViewStyle = mViews.size() > 1;
for (auto it = mViews.cbegin(); it != mViews.cend(); ++it)
{
if (it->first == "basic" || it->first == "detailed" || it->first == "grid" || it->first == "video" || it->first == "gamecarousel")
styles.push_back(std::pair<std::string, std::string>(it->first, _(it->first.c_str())));
else
styles.push_back(*it);
}
}
else
{
styles.push_back(std::pair<std::string, std::string>("basic", _("basic")));
styles.push_back(std::pair<std::string, std::string>("detailed", _("detailed")));
}
auto viewPreference = systemTheme.empty() ? Settings::getInstance()->getString("GamelistViewStyle") : system->getSystemViewMode();
if (!theme->hasView(viewPreference))
viewPreference = "automatic";
for (auto it = styles.cbegin(); it != styles.cend(); it++)
gamelist_style->add(it->second, it->first, viewPreference == it->first);
if (!gamelist_style->hasSelection())
gamelist_style->selectFirstItem();
if (showViewStyle)
themeconfig->addWithLabel(_("GAMELIST VIEW STYLE"), gamelist_style);
}
// Default grid size
std::shared_ptr<OptionListComponent<std::string>> mGridSize = nullptr;
if (showGridFeatures && system != NULL && theme->hasView("grid"))
{
Vector2f gridOverride =
systemTheme.empty() ? Vector2f::parseString(Settings::getInstance()->getString("DefaultGridSize")) :
system->getGridSizeOverride();
auto ovv = std::to_string((int)gridOverride.x()) + "x" + std::to_string((int)gridOverride.y());
mGridSize = std::make_shared<OptionListComponent<std::string>>(mWindow, _("DEFAULT GRID SIZE"), false);
bool found = false;
for (auto it = GuiGamelistOptions::gridSizes.cbegin(); it != GuiGamelistOptions::gridSizes.cend(); it++)
{
bool sel = (gridOverride == Vector2f(0, 0) && *it == "automatic") || ovv == *it;
if (sel)
found = true;
mGridSize->add(_(it->c_str()), *it, sel);
}
if (!found)
mGridSize->selectFirstItem();
themeconfig->addWithLabel(_("DEFAULT GRID SIZE"), mGridSize);
}
std::map<std::string, ThemeConfigOption> options;
Utils::String::stringVector subsetNames = theme->getSubSetNames(viewName);
// push appliesTo at end of list
std::sort(subsetNames.begin(), subsetNames.end(), [themeSubSets](const std::string& a, const std::string& b) -> bool
{
auto sa = ThemeData::getSubSet(themeSubSets, a);
auto sb = ThemeData::getSubSet(themeSubSets, b);
bool aHasApplies = sa.size() > 0 && !sa.cbegin()->appliesTo.empty();
bool bHasApplies = sb.size() > 0 && !sb.cbegin()->appliesTo.empty();
return aHasApplies < bHasApplies;
});
bool hasThemeOptionGroup = false;
bool hasApplyToGroup = false;
for (std::string subset : subsetNames) // theme->getSubSetNames(viewName)
{
std::string settingName = "subset." + subset;
std::string perSystemSettingName = systemTheme.empty() ? "" : "subset." + systemTheme + "." + subset;
if (subset == "colorset") settingName = "ThemeColorSet";
else if (subset == "iconset") settingName = "ThemeIconSet";
else if (subset == "menu") settingName = "ThemeMenu";
else if (subset == "systemview") settingName = "ThemeSystemView";
else if (subset == "gamelistview") settingName = "ThemeGamelistView";
else if (subset == "region") settingName = "ThemeRegionName";
auto themeColorSets = ThemeData::getSubSet(themeSubSets, subset);
if (themeColorSets.size() > 0)
{
auto selectedColorSet = themeColorSets.end();
auto selectedName = !perSystemSettingName.empty() ? Settings::getInstance()->getString(perSystemSettingName) : Settings::getInstance()->getString(settingName);
if (!perSystemSettingName.empty() && selectedName.empty())
selectedName = Settings::getInstance()->getString(settingName);
for (auto it = themeColorSets.begin(); it != themeColorSets.end() && selectedColorSet == themeColorSets.end(); it++)
if (it->name == selectedName)
selectedColorSet = it;
std::shared_ptr<OptionListComponent<std::string>> item = std::make_shared<OptionListComponent<std::string> >(mWindow, _(("THEME " + Utils::String::toUpper(subset)).c_str()), false);
item->setTag(!perSystemSettingName.empty() ? perSystemSettingName : settingName);
std::string defaultName;
for (auto it = themeColorSets.begin(); it != themeColorSets.end(); it++)
{
std::string displayName = it->displayName;
if (!systemTheme.empty())
{
std::string defaultValue = Settings::getInstance()->getString(settingName);
if (defaultValue.empty())
defaultValue = system->getTheme()->getDefaultSubSetValue(subset);
if (it->name == defaultValue)
{
defaultName = Utils::String::toUpper(displayName);
// displayName = displayName + " (" + _("DEFAULT") + ")";
}
}
item->add(displayName, it->name, it == selectedColorSet);
}
if (selectedColorSet == themeColorSets.end())
item->selectFirstItem();
if (!themeColorSets.empty())
{
std::string displayName = themeColorSets.cbegin()->subSetDisplayName;
if (!displayName.empty())
{
bool hasApplyToSubset = themeColorSets.cbegin()->appliesTo.size() > 0;
std::string prefix;
if (systemTheme.empty())
{
for (auto subsetName : themeColorSets.cbegin()->appliesTo)
{
std::string pfx = theme->getViewDisplayName(subsetName);
if (!pfx.empty())
{
if (prefix.empty())
prefix = pfx;
else
prefix = prefix + ", " + pfx;
}
}
prefix = Utils::String::toUpper(prefix);
}
if (hasApplyToSubset && !hasApplyToGroup)
{
hasApplyToGroup = true;
themeconfig->addGroup(_("GAMELIST THEME OPTIONS"));
}
else if (!hasApplyToSubset && !hasThemeOptionGroup)
{
hasThemeOptionGroup = true;
themeconfig->addGroup(_("THEME OPTIONS"));
}
if (!prefix.empty())
themeconfig->addWithDescription(displayName, prefix, item);
else if (!defaultName.empty())
themeconfig->addWithDescription(displayName, _("DEFAULT VALUE") + " : " + defaultName, item);
else
themeconfig->addWithLabel(displayName + prefix, item);
}
else
{
if (!hasThemeOptionGroup)
{
hasThemeOptionGroup = true;
themeconfig->addGroup(_("THEME OPTIONS"));
}
themeconfig->addWithLabel(_(("THEME " + Utils::String::toUpper(subset)).c_str()), item);
}
}
ThemeConfigOption opt;
opt.component = item;
opt.subset = subset;
opt.defaultSettingName = settingName;
options[!perSystemSettingName.empty() ? perSystemSettingName : settingName] = opt;
}
else
{
ThemeConfigOption opt;
opt.component = nullptr;
options[!perSystemSettingName.empty() ? perSystemSettingName : settingName] = opt;
}
}
if (!systemTheme.empty())
{
themeconfig->addGroup(_("GAMELIST OPTIONS"));
// Show favorites first in gamelists
auto fav = Settings::getInstance()->getString(system->getName() + ".FavoritesFirst");
auto favoritesFirst = std::make_shared<OptionListComponent<std::string>>(mWindow, _("SHOW FAVORITES ON TOP"), false);
std::string defFav = Settings::getInstance()->getBool("FavoritesFirst") ? _("YES") : _("NO");
favoritesFirst->add(_("AUTO"), "", fav == "" || fav == "auto");
favoritesFirst->add(_("YES"), "1", fav == "1");
favoritesFirst->add(_("NO"), "0", fav == "0");
themeconfig->addWithDescription(_("SHOW FAVORITES ON TOP"), _("DEFAULT VALUE") + " : " + defFav, favoritesFirst);
themeconfig->addSaveFunc([themeconfig, favoritesFirst, system]
{
if (Settings::getInstance()->setString(system->getName() + ".FavoritesFirst", favoritesFirst->getSelected()))
themeconfig->setVariable("reloadAll", true);
});
// Show favorites first in gamelists
auto defHid = Settings::ShowHiddenFiles() ? _("YES") : _("NO");
auto curhid = Settings::getInstance()->getString(system->getName() + ".ShowHiddenFiles");
auto hiddenFiles = std::make_shared<OptionListComponent<std::string>>(mWindow, _("SHOW HIDDEN FILES"), false);
hiddenFiles->add(_("AUTO"), "", curhid == "" || curhid == "auto");
hiddenFiles->add(_("YES"), "1", curhid == "1");
hiddenFiles->add(_("NO"), "0", curhid == "0");
themeconfig->addWithDescription(_("SHOW HIDDEN FILES"), _("DEFAULT VALUE") + " : " + defHid, hiddenFiles);
themeconfig->addSaveFunc([themeconfig, hiddenFiles, system]
{
if (Settings::getInstance()->setString(system->getName() + ".ShowHiddenFiles", hiddenFiles->getSelected()))
themeconfig->setVariable("reloadAll", true);
});
// Folder View Mode
auto folderView = Settings::getInstance()->getString("FolderViewMode");
auto defFol = folderView.empty() ? "" : Utils::String::toUpper(_(folderView.c_str()));
auto curFol = Settings::getInstance()->getString(system->getName() + ".FolderViewMode");
auto foldersBehavior = std::make_shared<OptionListComponent<std::string>>(mWindow, _("SHOW FOLDERS"), false);
foldersBehavior->add(_("AUTO"), "", curFol == "" || curFol == "auto"); // + " (" + defFol + ")"
foldersBehavior->add(_("always"), "always", curFol == "always");
foldersBehavior->add(_("never"), "never", curFol == "never");
foldersBehavior->add(_("having multiple games"), "having multiple games", curFol == "having multiple games");
themeconfig->addWithDescription(_("SHOW FOLDERS"), _("DEFAULT VALUE") + " : " + defFol, foldersBehavior);
themeconfig->addSaveFunc([themeconfig, foldersBehavior, system]
{
if (Settings::getInstance()->setString(system->getName() + ".FolderViewMode", foldersBehavior->getSelected()))
themeconfig->setVariable("reloadAll", true);
});
// Show parent folder in gamelists
auto defPf = Settings::getInstance()->getBool("ShowParentFolder") ? _("YES") : _("NO");
auto curPf = Settings::getInstance()->getString(system->getName() + ".ShowParentFolder");
auto parentFolder = std::make_shared<OptionListComponent<std::string>>(mWindow, _("SHOW '..' PARENT FOLDER"), false);
parentFolder->add(_("AUTO"), "", curPf == "" || curPf == "auto");
parentFolder->add(_("YES"), "1", curPf == "1");
parentFolder->add(_("NO"), "0", curPf == "0");
themeconfig->addWithDescription(_("SHOW '..' PARENT FOLDER"), _("DEFAULT VALUE") + " : " + defPf, parentFolder);
themeconfig->addSaveFunc([themeconfig, parentFolder, system]
{
if (Settings::getInstance()->setString(system->getName() + ".ShowParentFolder", parentFolder->getSelected()))
themeconfig->setVariable("reloadAll", true);
});
// Show flags
auto defSF = Settings::getInstance()->getString("ShowFlags");
if (defSF == "1")
defSF = _("BEFORE NAME");
else if (defSF == "2")
defSF = _("AFTER NAME");
else
defSF = _("NO");
auto curSF = Settings::getInstance()->getString(system->getName() + ".ShowFlags");
auto showRegionFlags = std::make_shared<OptionListComponent<std::string>>(mWindow, _("SHOW REGION FLAG"), false);
showRegionFlags->addRange({
{ _("AUTO"), "auto" },
{ _("NO"), "0" },
{ _("BEFORE NAME") , "1" },
{ _("AFTER NAME"), "2" } },
curSF);
themeconfig->addWithDescription(_("SHOW REGION FLAG"), _("DEFAULT VALUE") + " : " + defSF, showRegionFlags);
themeconfig->addSaveFunc([themeconfig, showRegionFlags, system]
{
if (Settings::getInstance()->setString(system->getName() + ".ShowFlags", showRegionFlags->getSelected()))
themeconfig->setVariable("reloadAll", true);
});
// Show SaveStates
auto defSS = Settings::getInstance()->getBool("ShowSaveStates") ? _("YES") : _("NO");
auto curSS = Settings::getInstance()->getString(system->getName() + ".ShowSaveStates");
auto showSaveStates = std::make_shared<OptionListComponent<std::string>>(mWindow, _("SHOW SAVESTATE ICON"), false);
showSaveStates->add(_("AUTO"), "", curSS == "" || curSS == "auto");
showSaveStates->add(_("YES"), "1", curSS == "1");
showSaveStates->add(_("NO"), "0", curSS == "0");
themeconfig->addWithDescription(_("SHOW SAVESTATE ICON"), _("DEFAULT VALUE") + " : " + defSS, showSaveStates);
themeconfig->addSaveFunc([themeconfig, showSaveStates, system]
{
if (Settings::getInstance()->setString(system->getName() + ".ShowSaveStates", showSaveStates->getSelected()))
themeconfig->setVariable("reloadAll", true);
});
// Show Manual
auto defMM = Settings::getInstance()->getBool("ShowManualIcon") ? _("YES") : _("NO");
auto curMM = Settings::getInstance()->getString(system->getName() + ".ShowManualIcon");
auto showManual = std::make_shared<OptionListComponent<std::string>>(mWindow, _("SHOW MANUAL ICON"), false);
showManual->add(_("AUTO"), "", curMM == "" || curMM == "auto");
showManual->add(_("YES"), "1", curMM == "1");
showManual->add(_("NO"), "0", curMM == "0");
themeconfig->addWithDescription(_("SHOW MANUAL ICON"), _("DEFAULT VALUE") + " : " + defMM, showManual);
themeconfig->addSaveFunc([themeconfig, showManual, system]
{
if (Settings::getInstance()->setString(system->getName() + ".ShowManualIcon", showManual->getSelected()))
themeconfig->setVariable("reloadAll", true);
});
// Show filenames
auto defFn = Settings::getInstance()->getBool("ShowFilenames") ? _("YES") : _("NO");
auto curFn = Settings::getInstance()->getString(system->getName() + ".ShowFilenames");
auto showFilenames = std::make_shared<OptionListComponent<std::string>>(mWindow, _("SHOW FILENAMES INSTEAD"), false);
showFilenames->add(_("AUTO"), "", curFn == "");
showFilenames->add(_("YES"), "1", curFn == "1");
showFilenames->add(_("NO"), "0", curFn == "0");
themeconfig->addWithDescription(_("SHOW FILENAMES INSTEAD"), _("DEFAULT VALUE") + " : " + defFn, showFilenames);
themeconfig->addSaveFunc([themeconfig, showFilenames, system]
{
if (Settings::getInstance()->setString(system->getName() + ".ShowFilenames", showFilenames->getSelected()))
{
SystemData::resetSettings();
FileData::resetSettings();
// themeconfig->setVariable("reloadCollections", true);
themeconfig->setVariable("reloadAll", true);
}
});
// File extensions
if (!system->isCollection() && system->isGameSystem())
{
auto hiddenExts = Utils::String::split(Settings::getInstance()->getString(system->getName() + ".HiddenExt"), ';');
auto hiddenCtrl = std::make_shared<OptionListComponent<std::string>>(mWindow, _("FILE EXTENSIONS"), true);
for (auto ext : system->getExtensions())
{
std::string extid = Utils::String::toLower(Utils::String::replace(ext, ".", ""));
hiddenCtrl->add(ext, extid, std::find(hiddenExts.cbegin(), hiddenExts.cend(), extid) == hiddenExts.cend());
}
themeconfig->addWithLabel(_("FILE EXTENSIONS"), hiddenCtrl);
themeconfig->addSaveFunc([themeconfig, system, hiddenCtrl]
{
std::string hiddenSystems;
std::vector<std::string> sel = hiddenCtrl->getSelectedObjects();
for (auto ext : system->getExtensions())
{
std::string extid = Utils::String::toLower(Utils::String::replace(ext, ".", ""));
if (std::find(sel.cbegin(), sel.cend(), extid) == sel.cend())
{
if (hiddenSystems.empty())
hiddenSystems = extid;
else
hiddenSystems = hiddenSystems + ";" + extid;
}
}
if (Settings::getInstance()->setString(system->getName() + ".HiddenExt", hiddenSystems))
{
Settings::getInstance()->saveFile();
themeconfig->setVariable("reloadAll", true);
themeconfig->setVariable("forceReloadGames", true);
}
});
}
}
if (systemTheme.empty())
{
themeconfig->addGroup(_("TOOLS"));
themeconfig->addEntry(_("RESET CUSTOMIZATIONS"), false, [s, themeconfig, window]
{
themeconfig->setVariable("resetTheme", true);
themeconfig->setVariable("reloadAll", true);
themeconfig->close();
});
}
// theme_colorset, theme_iconset, theme_menu, theme_systemview, theme_gamelistview, theme_region,
themeconfig->addSaveFunc([systemTheme, system, themeconfig, options, gamelist_style, mGridSize, window]
{
bool reloadAll = false;
for (auto option : options)
{
ThemeConfigOption& opt = option.second;
std::string value;
if (opt.component != nullptr)
{
value = opt.component->getSelected();
if (!systemTheme.empty() && !value.empty())
{
std::string defaultValue = Settings::getInstance()->getString(opt.defaultSettingName);
if (defaultValue.empty())
defaultValue = system->getTheme()->getDefaultSubSetValue(opt.subset);
if (value == defaultValue)
value = "";
}
else if (systemTheme.empty() && value == system->getTheme()->getDefaultSubSetValue(opt.subset))
value = "";
}
if (value != Settings::getInstance()->getString(option.first))
reloadAll |= Settings::getInstance()->setString(option.first, value);
}
Vector2f gridSizeOverride(0, 0);
if (mGridSize != nullptr)
{
std::string str = mGridSize->getSelected();
std::string value = "";
size_t divider = str.find('x');
if (divider != std::string::npos)
{
std::string first = str.substr(0, divider);
std::string second = str.substr(divider + 1, std::string::npos);
gridSizeOverride = Vector2f((float)atof(first.c_str()), (float)atof(second.c_str()));
value = Utils::String::replace(Utils::String::replace(gridSizeOverride.toString(), ".000000", ""), "0 0", "");
}
if (systemTheme.empty())
reloadAll |= Settings::getInstance()->setString("DefaultGridSize", value);
}
else if (systemTheme.empty())
reloadAll |= Settings::getInstance()->setString("DefaultGridSize", "");
if (systemTheme.empty())
reloadAll |= Settings::getInstance()->setString("GamelistViewStyle", gamelist_style == nullptr ? "" : gamelist_style->getSelected());
else
{
std::string viewMode = gamelist_style == nullptr ? system->getSystemViewMode() : gamelist_style->getSelected();
reloadAll |= system->setSystemViewMode(viewMode, gridSizeOverride);
}
if (themeconfig->getVariable("resetTheme"))
{
Settings::getInstance()->setString("GamelistViewStyle", "");
Settings::getInstance()->setString("DefaultGridSize", "");
Settings::getInstance()->setString("ThemeRegionName", "");
Settings::getInstance()->setString("ThemeColorSet", "");
Settings::getInstance()->setString("ThemeIconSet", "");
Settings::getInstance()->setString("ThemeMenu", "");
Settings::getInstance()->setString("ThemeSystemView", "");
Settings::getInstance()->setString("ThemeGamelistView", "");
Settings::getInstance()->setString("GamelistViewStyle", "");
Settings::getInstance()->setString("DefaultGridSize", "");
for (auto sm : Settings::getInstance()->getStringMap())
if (Utils::String::startsWith(sm.first, "subset."))
Settings::getInstance()->setString(sm.first, "");
for (auto system : SystemData::sSystemVector)
{
system->setSystemViewMode("automatic", Vector2f(0, 0));
Settings::getInstance()->setString(system->getName() + ".FavoritesFirst", "");
Settings::getInstance()->setString(system->getName() + ".ShowHiddenFiles", "");
Settings::getInstance()->setString(system->getName() + ".FolderViewMode", "");
Settings::getInstance()->setString(system->getName() + ".ShowFilenames", "");
Settings::getInstance()->setString(system->getName() + ".ShowParentFolder", "");
}
Settings::getInstance()->saveFile();
std::string path = Utils::FileSystem::getEsConfigPath() + "/themesettings/" + Settings::getInstance()->getString("ThemeSet") + ".cfg";
if (Utils::FileSystem::exists(path))
Utils::FileSystem::removeFile(path);
}
if (reloadAll || themeconfig->getVariable("reloadAll"))
{
if (themeconfig->getVariable("forceReloadGames"))
{
ViewController::reloadAllGames(window, false);
}
else if (systemTheme.empty())
{
CollectionSystemManager::get()->updateSystemsList();
ViewController::get()->reloadAll(window);
window->closeSplashScreen();
}
else
{
system->loadTheme();
system->resetFilters();
ViewController::get()->reloadSystemListViewTheme(system);
ViewController::get()->reloadGameListView(system);
}
}
});
mWindow->pushGui(themeconfig);
}
void GuiMenu::openUISettings()
{
auto pthis = this;
Window* window = mWindow;
auto s = new GuiSettings(mWindow, _("UI SETTINGS").c_str());
// theme set
auto theme = ThemeData::getMenuTheme();
auto themeSets = ThemeData::getThemeSets();
auto system = ViewController::get()->getState().getSystem();
s->addGroup(_("APPEARANCE"));
if (system != nullptr && !themeSets.empty())
{
auto selectedSet = themeSets.find(Settings::getInstance()->getString("ThemeSet"));
if (selectedSet == themeSets.end())
selectedSet = themeSets.begin();
auto theme_set = std::make_shared<OptionListComponent<std::string> >(mWindow, _("THEME SET"), false);
std::vector<std::string> themeList;
for (auto it = themeSets.begin(); it != themeSets.end(); it++)
themeList.push_back(it->first);
std::sort(themeList.begin(), themeList.end(), [](const std::string& a, const std::string& b) -> bool { return Utils::String::toLower(a).compare(Utils::String::toLower(b)) < 0; });
for (auto themeName : themeList)
theme_set->add(themeName, themeName, themeName == selectedSet->first);
//for (auto it = themeSets.begin(); it != themeSets.end(); it++)
// theme_set->add(it->first, it->first, it == selectedSet);
s->addWithLabel(_("THEME SET"), theme_set);
s->addSaveFunc([s, theme_set, pthis, window, system]
{
std::string oldTheme = Settings::getInstance()->getString("ThemeSet");
if (oldTheme != theme_set->getSelected())
{
saveSubsetSettings();
Settings::getInstance()->setString("ThemeSet", theme_set->getSelected());
// theme changed without setting options, forcing options to avoid crash/blank theme
Settings::getInstance()->setString("ThemeRegionName", "");
Settings::getInstance()->setString("ThemeColorSet", "");
Settings::getInstance()->setString("ThemeIconSet", "");
Settings::getInstance()->setString("ThemeMenu", "");
Settings::getInstance()->setString("ThemeSystemView", "");
Settings::getInstance()->setString("ThemeGamelistView", "");
Settings::getInstance()->setString("GamelistViewStyle", "");
Settings::getInstance()->setString("DefaultGridSize", "");
for(auto sm : Settings::getInstance()->getStringMap())
if (Utils::String::startsWith(sm.first, "subset."))
Settings::getInstance()->setString(sm.first, "");
for (auto sysIt = SystemData::sSystemVector.cbegin(); sysIt != SystemData::sSystemVector.cend(); sysIt++)
(*sysIt)->setSystemViewMode("automatic", Vector2f(0,0));
loadSubsetSettings(theme_set->getSelected());
s->setVariable("reloadCollections", true);
s->setVariable("reloadAll", true);
s->setVariable("reloadGuiMenu", true);
Scripting::fireEvent("theme-changed", theme_set->getSelected(), oldTheme);
}
});
bool showThemeConfiguration = system->getTheme()->hasSubsets() || system->getTheme()->hasView("grid");
if (showThemeConfiguration)
{
s->addSubMenu(_("THEME CONFIGURATION"), [this, s, theme_set]() { openThemeConfiguration(mWindow, s, theme_set); });
}
else // GameList view style only, acts like Retropie for simple themes
{
auto gamelist_style = std::make_shared< OptionListComponent<std::string> >(mWindow, _("GAMELIST VIEW STYLE"), false);
std::vector<std::pair<std::string, std::string>> styles;
styles.push_back(std::pair<std::string, std::string>("automatic", _("automatic")));
auto system = ViewController::get()->getState().getSystem();
if (system != NULL)
{
auto mViews = system->getTheme()->getViewsOfTheme();
for (auto it = mViews.cbegin(); it != mViews.cend(); ++it)
styles.push_back(*it);
}
else
{
styles.push_back(std::pair<std::string, std::string>("basic", _("basic")));
styles.push_back(std::pair<std::string, std::string>("detailed", _("detailed")));
styles.push_back(std::pair<std::string, std::string>("video", _("video")));
styles.push_back(std::pair<std::string, std::string>("grid", _("grid")));
}
auto viewPreference = Settings::getInstance()->getString("GamelistViewStyle");
if (!system->getTheme()->hasView(viewPreference))
viewPreference = "automatic";
for (auto it = styles.cbegin(); it != styles.cend(); it++)
gamelist_style->add(it->second, it->first, viewPreference == it->first);
s->addWithLabel(_("GAMELIST VIEW STYLE"), gamelist_style);
s->addSaveFunc([s, gamelist_style, window] {
if (Settings::getInstance()->setString("GamelistViewStyle", gamelist_style->getSelected()))
{
s->setVariable("reloadAll", true);
s->setVariable("reloadGuiMenu", true);
}
});
}
}
// language choice
auto language_choice = std::make_shared<OptionListComponent<std::string> >(window, _("LANGUAGE"), false);
std::string language = SystemConf::getInstance()->get("system.language");
if (language.empty())
language = "en_US";
language_choice->add("ARABIC", "ar_YE", language == "ar_YE");
language_choice->add("CATALÀ", "ca_ES", language == "ca_ES");
language_choice->add("CYMRAEG", "cy_GB", language == "cy_GB");
language_choice->add("DEUTSCH", "de_DE", language == "de_DE");
language_choice->add("GREEK", "el_GR", language == "el_GR");
language_choice->add("ENGLISH", "en_US", language == "en_US" || language == "en");
language_choice->add("ESPAÑOL", "es_ES", language == "es_ES" || language == "es");
language_choice->add("ESPAÑOL MEXICANO", "es_MX", language == "es_MX");
language_choice->add("BASQUE", "eu_ES", language == "eu_ES");
language_choice->add("FRANÇAIS", "fr_FR", language == "fr_FR" || language == "fr");
language_choice->add("עברית", "he_IL", language == "he_IL");
language_choice->add("HUNGARIAN", "hu_HU", language == "hu_HU");
language_choice->add("ITALIANO", "it_IT", language == "it_IT");
language_choice->add("JAPANESE", "ja_JP", language == "ja_JP");
language_choice->add("KOREAN", "ko_KR", language == "ko_KR" || language == "ko");
language_choice->add("NORWEGIAN BOKMAL", "nb_NO", language == "nb_NO");
language_choice->add("DUTCH", "nl_NL", language == "nl_NL");
language_choice->add("NORWEGIAN", "nn_NO", language == "nn_NO");
language_choice->add("OCCITAN", "oc_FR", language == "oc_FR");
language_choice->add("POLISH", "pl_PL", language == "pl_PL");
language_choice->add("PORTUGUES BRASILEIRO", "pt_BR", language == "pt_BR");
language_choice->add("PORTUGUES PORTUGAL", "pt_PT", language == "pt_PT");
language_choice->add("РУССКИЙ", "ru_RU", language == "ru_RU");
language_choice->add("SVENSKA", "sv_SE", language == "sv_SE");
language_choice->add("TÜRKÇE", "tr_TR", language == "tr_TR");
language_choice->add("Українська", "uk_UA", language == "uk_UA");
language_choice->add("简体中文", "zh_CN", language == "zh_CN");
language_choice->add("正體中文", "zh_TW", language == "zh_TW");
s->addWithLabel(_("LANGUAGE"), language_choice);
s->addSaveFunc([window, language_choice, language, s]
{
bool reboot = false;
if (language_choice->changed())
{
#ifdef _ENABLEEMUELEC
std::string selectedLanguage = language_choice->getSelected();
std::string msg = _("You are about to set 351ELEC Language to:") +"\n" + selectedLanguage + "\n";
msg += _("Emulationstation will restart")+"\n";
msg += _("Do you want to proceed ?");
window->pushGui(new GuiMsgBox(window, msg, _("YES"), [selectedLanguage] {
SystemConf::getInstance()->set("system.language", selectedLanguage);
SystemConf::getInstance()->saveSystemConf();
runSystemCommand("systemctl restart emustation", "", nullptr);
}, "NO",nullptr));
#else
if (SystemConf::getInstance()->set("system.language", language_choice->getSelected()))
{
FileSorts::reset();
MetaDataList::initMetadata();
s->setVariable("reloadGuiMenu", true);
#ifdef HAVE_INTL
reboot = true;
#endif
}
#endif
}
if (reboot)
window->displayNotificationMessage(_U("\uF011 ") + _("A REBOOT OF THE SYSTEM IS REQUIRED TO APPLY THE NEW CONFIGURATION"));
});
// UI RESTRICTIONS
auto UImodeSelection = std::make_shared< OptionListComponent<std::string> >(mWindow, _("UI MODE"), false);
std::vector<std::string> UImodes = UIModeController::getInstance()->getUIModes();
for (auto it = UImodes.cbegin(); it != UImodes.cend(); it++)
UImodeSelection->add(_(it->c_str()), *it, Settings::getInstance()->getString("UIMode") == *it);
s->addWithLabel(_("UI MODE"), UImodeSelection);
s->addSaveFunc([UImodeSelection, window]
{
std::string selectedMode = UImodeSelection->getSelected();
if (selectedMode != "Full")
{
std::string msg = _("You are changing the UI to a restricted mode:\nThis will hide most menu-options to prevent changes to the system.\nTo unlock and return to the full UI, enter this code:") + "\n";
msg += "\"" + UIModeController::getInstance()->getFormattedPassKeyStr() + "\"\n\n";
msg += _("Do you want to proceed ?");
window->pushGui(new GuiMsgBox(window, msg,
_("YES"), [selectedMode] {
LOG(LogDebug) << "Setting UI mode to " << selectedMode;
Settings::getInstance()->setString("UIMode", selectedMode);
Settings::getInstance()->saveFile();
}, _("NO"), nullptr));
}
});
// retroarch.menu_driver choose from 'auto' (default), 'xmb', 'rgui', 'ozone', 'glui'
auto retroarchRgui = std::make_shared< OptionListComponent<std::string> >(mWindow, _("RETROARCH MENU DRIVER"), false);
std::vector<std::string> driver;
driver.push_back("auto");
driver.push_back("xmb");
driver.push_back("rgui");
driver.push_back("ozone");
driver.push_back("glui");
auto currentDriver = SystemConf::getInstance()->get("global.retroarch.menu_driver");
if (currentDriver.empty())
currentDriver = "auto";
for (auto it = driver.cbegin(); it != driver.cend(); it++)
retroarchRgui->add(_(it->c_str()), *it, currentDriver == *it);
s->addWithLabel(_("RETROARCH MENU DRIVER"), retroarchRgui);
s->addSaveFunc([retroarchRgui]
{
SystemConf::getInstance()->set("global.retroarch.menu_driver", retroarchRgui->getSelected());
SystemConf::getInstance()->saveSystemConf();
});
auto fps_enabled = std::make_shared<SwitchComponent>(mWindow);
bool fpsEnabled = SystemConf::getInstance()->get("global.showFPS") == "1";
fps_enabled->setState(fpsEnabled);
s->addWithLabel(_("SHOW RETROARCH FPS"), fps_enabled);
s->addSaveFunc([fps_enabled] {
bool fpsenabled = fps_enabled->getState();
SystemConf::getInstance()->set("global.showFPS", fpsenabled ? "1" : "0");
SystemConf::getInstance()->saveSystemConf();
});
/*
auto splash_enabled = std::make_shared<SwitchComponent>(mWindow);
bool splashEnabled = SystemConf::getInstance()->get("ee_splash.enabled") == "1";
splash_enabled->setState(splashEnabled);
s->addWithLabel(_("ENABLE GAME SPLASH"), splash_enabled);
s->addSaveFunc([splash_enabled] {
bool splashenabled = splash_enabled->getState();
SystemConf::getInstance()->set("ee_splash.enabled", splashenabled ? "1" : "0");
SystemConf::getInstance()->saveSystemConf();
});
*/
s->addGroup(_("DISPLAY OPTIONS"));
s->addEntry(_("SCREENSAVER SETTINGS"), true, std::bind(&GuiMenu::openScreensaverOptions, this));
// transition style
auto transition_style = std::make_shared<OptionListComponent<std::string> >(mWindow, _("LIST TRANSITION STYLE"), false);
transition_style->addRange({ "auto", "fade", "slide", "fade & slide", "instant" }, Settings::TransitionStyle());
s->addWithLabel(_("LIST TRANSITION STYLE"), transition_style);
s->addSaveFunc([transition_style] { Settings::setTransitionStyle(transition_style->getSelected()); });
// game transition style
auto transitionOfGames_style = std::make_shared< OptionListComponent<std::string> >(mWindow, _("GAME LAUNCH TRANSITION"), false);
transitionOfGames_style->addRange({ "auto", "fade", "slide", "instant" }, Settings::GameTransitionStyle());
s->addWithLabel(_("GAME LAUNCH TRANSITION"), transitionOfGames_style);
s->addSaveFunc([transitionOfGames_style] { Settings::setGameTransitionStyle(transitionOfGames_style->getSelected()); });
// clock
auto clock = std::make_shared<SwitchComponent>(mWindow);
clock->setState(Settings::getInstance()->getBool("DrawClock"));
s->addWithLabel(_("SHOW CLOCK"), clock);
s->addSaveFunc(
[clock] { Settings::getInstance()->setBool("DrawClock", clock->getState()); });
// show help
auto show_help = std::make_shared<SwitchComponent>(mWindow);
show_help->setState(Settings::getInstance()->getBool("ShowHelpPrompts"));
s->addWithLabel(_("ON-SCREEN HELP"), show_help);
s->addSaveFunc([s, show_help]
{
if (Settings::getInstance()->setBool("ShowHelpPrompts", show_help->getState()))
s->setVariable("reloadAll", true);
});
// Battery indicator
if (queryBatteryInformation().hasBattery)
{
auto batteryStatus = std::make_shared<OptionListComponent<std::string> >(mWindow, _("SHOW BATTERY STATUS"), false);
batteryStatus->addRange({ { _("NO"), "" },{ _("ICON"), "icon" },{ _("ICON AND TEXT"), "text" } }, Settings::getInstance()->getString("ShowBattery"));
s->addWithLabel(_("SHOW BATTERY STATUS"), batteryStatus);
s->addSaveFunc([batteryStatus] { Settings::getInstance()->setString("ShowBattery", batteryStatus->getSelected()); });
}
s->addGroup(_("GAMELIST OPTIONS"));
// Show favorites first in gamelists
auto favoritesFirstSwitch = std::make_shared<SwitchComponent>(mWindow);
favoritesFirstSwitch->setState(Settings::getInstance()->getBool("FavoritesFirst"));
s->addWithLabel(_("SHOW FAVORITES ON TOP"), favoritesFirstSwitch);
s->addSaveFunc([s, favoritesFirstSwitch]
{
if (Settings::getInstance()->setBool("FavoritesFirst", favoritesFirstSwitch->getState()))
s->setVariable("reloadAll", true);
});
// hidden files
auto hidden_files = std::make_shared<SwitchComponent>(mWindow);
hidden_files->setState(Settings::ShowHiddenFiles());
s->addWithLabel(_("SHOW HIDDEN FILES"), hidden_files);
s->addSaveFunc([s, hidden_files]
{
if (Settings::setShowHiddenFiles(hidden_files->getState()))
s->setVariable("reloadAll", true);
});
// Folder View Mode
auto foldersBehavior = std::make_shared< OptionListComponent<std::string> >(mWindow, _("SHOW FOLDERS"), false);
foldersBehavior->add(_("always"), "always", Settings::getInstance()->getString("FolderViewMode") == "always");
foldersBehavior->add(_("never"), "never", Settings::getInstance()->getString("FolderViewMode") == "never");
foldersBehavior->add(_("having multiple games"), "having multiple games", Settings::getInstance()->getString("FolderViewMode") == "having multiple games");
s->addWithLabel(_("SHOW FOLDERS"), foldersBehavior);
s->addSaveFunc([s, foldersBehavior]
{
if (Settings::getInstance()->setString("FolderViewMode", foldersBehavior->getSelected()))
s->setVariable("reloadAll", true);
});
// Show parent folder
auto parentFolder = std::make_shared<SwitchComponent>(mWindow);
parentFolder->setState(Settings::getInstance()->getBool("ShowParentFolder"));
s->addWithLabel(_("SHOW '..' PARENT FOLDER"), parentFolder);
s->addSaveFunc([s, parentFolder]
{
if (Settings::getInstance()->setBool("ShowParentFolder", parentFolder->getState()))
s->setVariable("reloadAll", true);
});
// Show flags
auto showRegionFlags = std::make_shared<OptionListComponent<std::string>>(mWindow, _("SHOW REGION FLAG"), false);
showRegionFlags->addRange({ { _("NO"), "auto" },{ _("BEFORE NAME") , "1" },{ _("AFTER NAME"), "2" } }, Settings::getInstance()->getString("ShowFlags"));
s->addWithLabel(_("SHOW REGION FLAG"), showRegionFlags);
s->addSaveFunc([s, showRegionFlags]
{
if (Settings::getInstance()->setString("ShowFlags", showRegionFlags->getSelected()))
s->setVariable("reloadAll", true);
});
// Show SaveStates
auto showSaveStates = std::make_shared<SwitchComponent>(mWindow);
showSaveStates->setState(Settings::getInstance()->getBool("ShowSaveStates"));
s->addWithLabel(_("SHOW SAVESTATE ICON"), showSaveStates);
s->addSaveFunc([s, showSaveStates]
{
if (Settings::getInstance()->setBool("ShowSaveStates", showSaveStates->getState()))
s->setVariable("reloadAll", true);
});
// Show Manual
auto showManual = std::make_shared<SwitchComponent>(mWindow);
showManual->setState(Settings::getInstance()->getBool("ShowManualIcon"));
s->addWithLabel(_("SHOW MANUAL ICON"), showManual);
s->addSaveFunc([s, showManual]
{
if (Settings::getInstance()->setBool("ShowManualIcon", showManual->getState()))
s->setVariable("reloadAll", true);
});
// filenames
auto showFilesnames = std::make_shared<SwitchComponent>(mWindow);
showFilesnames->setState(Settings::getInstance()->getBool("ShowFilenames"));
s->addWithLabel(_("SHOW FILENAMES INSTEAD"), showFilesnames);
s->addSaveFunc([showFilesnames, s]
{
if (Settings::getInstance()->setBool("ShowFilenames", showFilesnames->getState()))
{
SystemData::resetSettings();
FileData::resetSettings();
s->setVariable("reloadCollections", true);
s->setVariable("reloadAll", true);
}
});
auto ignoreArticles = std::make_shared<SwitchComponent>(mWindow);
ignoreArticles->setState(Settings::getInstance()->getBool("IgnoreLeadingArticles"));
s->addWithLabel(_("IGNORE LEADING ARTICLES WHEN SORTING"), ignoreArticles);
s->addSaveFunc([s, ignoreArticles]
{
if (Settings::getInstance()->setBool("IgnoreLeadingArticles", ignoreArticles->getState()))
{
s->setVariable("reloadAll", true);
}
});
s->onFinalize([s, pthis, window]
{
if (s->getVariable("reloadCollections"))
CollectionSystemManager::get()->updateSystemsList();
if (s->getVariable("reloadAll"))
{
ViewController::get()->reloadAll(window);
window->closeSplashScreen();
}
if (s->getVariable("reloadGuiMenu"))
{
delete pthis;
window->pushGui(new GuiMenu(window));
}
});
mWindow->pushGui(s);
}
void GuiMenu::openSoundSettings()
{
auto s = new GuiSettings(mWindow, _("SOUND SETTINGS").c_str());
if (VolumeControl::getInstance()->isAvailable())
{
s->addGroup(_("VOLUME"));
// volume
auto volume = std::make_shared<SliderComponent>(mWindow, 0.f, 100.f, 1.f, "%");
volume->setValue((float)VolumeControl::getInstance()->getVolume());
volume->setOnValueChanged([](const float &newVal) { VolumeControl::getInstance()->setVolume((int)Math::round(newVal)); });
s->addWithLabel(_("SYSTEM VOLUME"), volume);
s->addSaveFunc([this, volume]
{
VolumeControl::getInstance()->setVolume((int)Math::round(volume->getValue()));
#if !WIN32
SystemConf::getInstance()->set("audio.volume", std::to_string((int)round(volume->getValue())));
#endif
});
// Music Volume
auto musicVolume = std::make_shared<SliderComponent>(mWindow, 0.f, 100.f, 1.f, "%");
musicVolume->setValue(Settings::getInstance()->getInt("MusicVolume"));
musicVolume->setOnValueChanged([](const float &newVal) { Settings::getInstance()->setInt("MusicVolume", (int)round(newVal)); });
s->addWithLabel(_("MUSIC VOLUME"), musicVolume);
//s->addSaveFunc([this, musicVolume] { Settings::getInstance()->setInt("MusicVolume", (int)round(musicVolume->getValue())); });
auto volumePopup = std::make_shared<SwitchComponent>(mWindow);
volumePopup->setState(Settings::getInstance()->getBool("VolumePopup"));
s->addWithLabel(_("SHOW OVERLAY WHEN VOLUME CHANGES"), volumePopup);
s->addSaveFunc([volumePopup] { Settings::getInstance()->setBool("VolumePopup", volumePopup->getState()); });
}
s->addGroup(_("MUSIC"));
// disable sounds
auto music_enabled = std::make_shared<SwitchComponent>(mWindow);
music_enabled->setState(Settings::getInstance()->getBool("audio.bgmusic"));
s->addWithLabel(_("FRONTEND MUSIC"), music_enabled);
s->addSaveFunc([music_enabled]
{
if (Settings::getInstance()->setBool("audio.bgmusic", music_enabled->getState()))
{
if (music_enabled->getState())
AudioManager::getInstance()->playRandomMusic();
else
AudioManager::getInstance()->stopMusic();
}
});
// batocera - display music titles
auto display_titles = std::make_shared<SwitchComponent>(mWindow);
display_titles->setState(Settings::getInstance()->getBool("audio.display_titles"));
s->addWithLabel(_("DISPLAY SONG TITLES"), display_titles);
s->addSaveFunc([display_titles] {
Settings::getInstance()->setBool("audio.display_titles", display_titles->getState());
});
// batocera - how long to display the song titles?
auto titles_time = std::make_shared<SliderComponent>(mWindow, 2.f, 120.f, 2.f, "s");
titles_time->setValue(Settings::getInstance()->getInt("audio.display_titles_time"));
s->addWithLabel(_("SONG TITLE DISPLAY DURATION"), titles_time);
s->addSaveFunc([titles_time] {
Settings::getInstance()->setInt("audio.display_titles_time", (int)Math::round(titles_time->getValue()));
});
// batocera - music per system
auto music_per_system = std::make_shared<SwitchComponent>(mWindow);
music_per_system->setState(Settings::getInstance()->getBool("audio.persystem"));
s->addWithLabel(_("ONLY PLAY SYSTEM-SPECIFIC MUSIC FOLDER"), music_per_system);
s->addSaveFunc([music_per_system] {
if (Settings::getInstance()->setBool("audio.persystem", music_per_system->getState()))
AudioManager::getInstance()->changePlaylist(ViewController::get()->getState().getSystem()->getTheme(), true);
});
// batocera - music per system
auto enableThemeMusics = std::make_shared<SwitchComponent>(mWindow);
enableThemeMusics->setState(Settings::getInstance()->getBool("audio.thememusics"));
s->addWithLabel(_("PLAY SYSTEM-SPECIFIC MUSIC"), enableThemeMusics);
s->addSaveFunc([enableThemeMusics] {
if (Settings::getInstance()->setBool("audio.thememusics", enableThemeMusics->getState()))
AudioManager::getInstance()->changePlaylist(ViewController::get()->getState().getSystem()->getTheme(), true);
});
auto videolowermusic = std::make_shared<SwitchComponent>(mWindow);
videolowermusic->setState(Settings::getInstance()->getBool("VideoLowersMusic"));
s->addWithLabel(_("LOWER MUSIC WHEN PLAYING VIDEO"), videolowermusic);
s->addSaveFunc([videolowermusic] { Settings::getInstance()->setBool("VideoLowersMusic", videolowermusic->getState()); });
s->addGroup(_("SOUNDS"));
// disable sounds
auto sounds_enabled = std::make_shared<SwitchComponent>(mWindow);
sounds_enabled->setState(Settings::getInstance()->getBool("EnableSounds"));
s->addWithLabel(_("ENABLE NAVIGATION SOUNDS"), sounds_enabled);
s->addSaveFunc([sounds_enabled]
{
if (sounds_enabled->getState() && !Settings::getInstance()->getBool("EnableSounds") && PowerSaver::getMode() == PowerSaver::INSTANT)
{
Settings::getInstance()->setPowerSaverMode("default");
PowerSaver::init();
}
Settings::getInstance()->setBool("EnableSounds", sounds_enabled->getState());
});
auto video_audio = std::make_shared<SwitchComponent>(mWindow);
video_audio->setState(Settings::getInstance()->getBool("VideoAudio"));
s->addWithLabel(_("ENABLE VIDEO PREVIEW AUDIO"), video_audio);
s->addSaveFunc([video_audio] { Settings::getInstance()->setBool("VideoAudio", video_audio->getState()); });
mWindow->pushGui(s);
}
void GuiMenu::openWifiSettings(Window* win, std::string title, std::string data, const std::function<void(std::string)>& onsave)
{
win->pushGui(new GuiWifi(win, title, data, onsave));
}
void GuiMenu::openNetworkSettings_batocera(bool selectWifiEnable)
{
bool baseWifiEnabled = SystemConf::getInstance()->getBool("wifi.enabled");
auto theme = ThemeData::getMenuTheme();
std::shared_ptr<Font> font = theme->Text.font;
unsigned int color = theme->Text.color;
Window *window = mWindow;
auto s = new GuiSettings(mWindow, _("NETWORK SETTINGS").c_str());
s->addGroup(_("INFORMATION"));
auto ip = std::make_shared<TextComponent>(mWindow, ApiSystem::getInstance()->getIpAdress(), font, color);
s->addWithLabel(_("IP ADDRESS"), ip);
auto status = std::make_shared<TextComponent>(mWindow, ApiSystem::getInstance()->ping() ? _("CONNECTED") : _("NOT CONNECTED"), font, color);
s->addWithLabel(_("INTERNET STATUS"), status);
// Network Indicator
auto networkIndicator = std::make_shared<SwitchComponent>(mWindow);
networkIndicator->setState(Settings::getInstance()->getBool("ShowNetworkIndicator"));
s->addWithLabel(_("SHOW NETWORK INDICATOR"), networkIndicator);
s->addSaveFunc([networkIndicator] { Settings::getInstance()->setBool("ShowNetworkIndicator", networkIndicator->getState()); });
s->addGroup(_("SETTINGS"));
#if !WIN32
// Hostname
s->addInputTextRow(_("HOSTNAME"), "system.hostname", false);
#endif
auto sshd_enabled = std::make_shared<SwitchComponent>(mWindow);
bool sshbaseEnabled = SystemConf::getInstance()->get("ee_ssh.enabled") == "1";
sshd_enabled->setState(sshbaseEnabled);
s->addWithLabel(_("ENABLE SSH"), sshd_enabled);
s->addSaveFunc([sshd_enabled] {
if (sshd_enabled->getState() == false) {
runSystemCommand("systemctl stop sshd", "", nullptr);
runSystemCommand("systemctl disable sshd", "", nullptr);
runSystemCommand("rm /storage/.cache/services/sshd.conf", "", nullptr);
} else {
runSystemCommand("mkdir -p /storage/.cache/services/", "", nullptr);
runSystemCommand("touch /storage/.cache/services/sshd.conf", "", nullptr);
runSystemCommand("systemctl enable sshd", "", nullptr);
runSystemCommand("systemctl start sshd", "", nullptr);
}
bool sshenabled = sshd_enabled->getState();
SystemConf::getInstance()->set("ee_ssh.enabled", sshenabled ? "1" : "0");
SystemConf::getInstance()->saveSystemConf();
});
auto samba_enabled = std::make_shared<SwitchComponent>(mWindow);
bool smbbaseEnabled = SystemConf::getInstance()->get("ee_samba.enabled") == "1";
samba_enabled->setState(smbbaseEnabled);
s->addWithLabel(_("ENABLE SAMBA"), samba_enabled);
s->addSaveFunc([samba_enabled] {
if (samba_enabled->getState() == false) {
runSystemCommand("systemctl stop nmbd", "", nullptr);
runSystemCommand("systemctl disable nmbd", "", nullptr);
runSystemCommand("systemctl stop smbd", "", nullptr);
runSystemCommand("systemctl disable smbd", "", nullptr);
runSystemCommand("rm /storage/.cache/services/smb.conf", "", nullptr);
} else {
runSystemCommand("mkdir -p /storage/.cache/services/", "", nullptr);
runSystemCommand("touch /storage/.cache/services/smb.conf", "", nullptr);
runSystemCommand("systemctl enable nmbd", "", nullptr);
runSystemCommand("systemctl start nmbd", "", nullptr);
runSystemCommand("systemctl enable smbd", "", nullptr);
runSystemCommand("systemctl start smbd", "", nullptr);
}
bool sambaenabled = samba_enabled->getState();
SystemConf::getInstance()->set("ee_samba.enabled", sambaenabled ? "1" : "0");
SystemConf::getInstance()->saveSystemConf();
});
//Right now limit webui to RG552
#ifdef RG552
auto webui_enabled = std::make_shared<SwitchComponent>(mWindow);
bool webuibaseEnabled = SystemConf::getInstance()->get("ee_webui.enabled") == "1";
webui_enabled->setState(webuibaseEnabled);
auto web_ui_location = "http://"+ApiSystem::getInstance()->getIpAdress()+" or http://"+ApiSystem::getInstance()->getHostsName();
s->addWithDescription(_("ENABLE WEB UI"),_(web_ui_location.c_str()), webui_enabled);
s->addSaveFunc([webui_enabled] {
if (webui_enabled->getState() == false) {
runSystemCommand("systemctl stop webui", "", nullptr);
runSystemCommand("systemctl disable webui", "", nullptr);
runSystemCommand("systemctl stop webui", "", nullptr);
runSystemCommand("systemctl disable webui", "", nullptr);
runSystemCommand("rm /storage/.cache/services/webui.conf", "", nullptr);
} else {
runSystemCommand("mkdir -p /storage/.cache/services/", "", nullptr);
runSystemCommand("touch /storage/.cache/services/webui.conf", "", nullptr);
runSystemCommand("systemctl enable webui", "", nullptr);
runSystemCommand("systemctl start webui", "", nullptr);
runSystemCommand("systemctl enable webui", "", nullptr);
runSystemCommand("systemctl start webui", "", nullptr);
}
bool webuienabled = webui_enabled->getState();
SystemConf::getInstance()->set("ee_webui.enabled", webuienabled ? "1" : "0");
SystemConf::getInstance()->saveSystemConf();
});
#endif
// Wifi enable
auto enable_wifi = std::make_shared<SwitchComponent>(mWindow);
enable_wifi->setState(baseWifiEnabled);
s->addWithLabel(_("ENABLE WIFI"), enable_wifi, selectWifiEnable);
// window, title, settingstring,
const std::string baseSSID = SystemConf::getInstance()->get("wifi.ssid");
const std::string baseKEY = SystemConf::getInstance()->get("wifi.key");
if (baseWifiEnabled)
{
s->addInputTextRow(_("WIFI SSID"), "wifi.ssid", false, false, &openWifiSettings);
s->addInputTextRow(_("WIFI KEY"), "wifi.key", true);
}
s->addSaveFunc([baseWifiEnabled, baseSSID, baseKEY, enable_wifi, window]
{
bool wifienabled = enable_wifi->getState();
SystemConf::getInstance()->setBool("wifi.enabled", wifienabled);
if (wifienabled)
{
std::string newSSID = SystemConf::getInstance()->get("wifi.ssid");
std::string newKey = SystemConf::getInstance()->get("wifi.key");
if (baseSSID != newSSID || baseKEY != newKey || !baseWifiEnabled)
{
if (ApiSystem::getInstance()->enableWifi(newSSID, newKey))
window->pushGui(new GuiMsgBox(window, _("WIFI ENABLED")));
else
window->pushGui(new GuiMsgBox(window, _("WIFI CONFIGURATION ERROR")));
}
}
else if (baseWifiEnabled)
ApiSystem::getInstance()->disableWifi();
});
enable_wifi->setOnChangedCallback([this, s, baseWifiEnabled, enable_wifi]()
{
bool wifienabled = enable_wifi->getState();
if (baseWifiEnabled != wifienabled)
{
SystemConf::getInstance()->setBool("wifi.enabled", wifienabled);
if (wifienabled)
ApiSystem::getInstance()->enableWifi(SystemConf::getInstance()->get("wifi.ssid"), SystemConf::getInstance()->get("wifi.key"));
else
ApiSystem::getInstance()->disableWifi();
delete s;
openNetworkSettings_batocera(true);
}
});
mWindow->pushGui(s);
}
void GuiMenu::openQuitMenu_batocera()
{
GuiMenu::openQuitMenu_batocera_static(mWindow);
}
void GuiMenu::openQuitMenu_batocera_static(Window *window, bool quickAccessMenu, bool animate)
{
#ifdef WIN32
if (!quickAccessMenu && Settings::getInstance()->getBool("ShowOnlyExit"))
{
quitES(QuitMode::QUIT);
return;
}
#endif
auto s = new GuiSettings(window, (quickAccessMenu ? _("QUICK ACCESS") : _("QUIT")).c_str());
s->setCloseButton("select");
if (quickAccessMenu)
{
s->addGroup(_("QUICK ACCESS"));
// Don't like one of the songs? Press next
if (AudioManager::getInstance()->isSongPlaying())
{
auto sname = AudioManager::getInstance()->getSongName();
if (!sname.empty())
{
s->addWithDescription(_("SKIP TO NEXT SONG"), _("LISTENING NOW") + " : " + sname, nullptr, [s, window]
{
Window* w = window;
AudioManager::getInstance()->playRandomMusic(false);
delete s;
openQuitMenu_batocera_static(w, true, false);
}, "iconSound");
}
}
s->addEntry(_("LAUNCH SCREENSAVER"), false, [s, window]
{
Window* w = window;
window->postToUiThread([w]()
{
w->startScreenSaver();
w->renderScreenSaver();
});
delete s;
}, "iconScraper", true);
#if WIN32
#define BATOCERA_MANUAL_FILE Utils::FileSystem::getEsConfigPath() + "/notice.pdf"
#else
#define BATOCERA_MANUAL_FILE "/usr/share/batocera/doc/notice.pdf"
#endif
if (ApiSystem::getInstance()->isScriptingSupported(ApiSystem::ScriptId::PDFEXTRACTION) && Utils::FileSystem::exists(BATOCERA_MANUAL_FILE))
{
#if defined(WIN32)
s->addEntry(_("VIEW USER'S MANUAL"), false, [s, window]
#else
s->addEntry(_("VIEW BATOCERA MANUAL"), false, [s, window]
#endif
{
GuiImageViewer::showPdf(window, BATOCERA_MANUAL_FILE);
delete s;
}, "iconManual");
}
}
if (quickAccessMenu)
s->addGroup(_("QUIT"));
#ifdef _ENABLEEMUELEC
s->addEntry(_("RESTART EMULATIONSTATION"), false, [window] {
window->pushGui(new GuiMsgBox(window, _("REALLY RESTART EMULATIONSTATION?"), _("YES"),
[] {
/*runSystemCommand("systemctl restart emustation.service", "", nullptr);*/
Scripting::fireEvent("quit", "restart");
quitES(QuitMode::QUIT);
}, _("NO"), nullptr));
}, "iconRestart");
/*
s->addEntry(_("START RETROARCH"), false, [window] {
window->pushGui(new GuiMsgBox(window, _("REALLY START RETROARCH?"), _("YES"),
[] {
remove("/var/lock/start.games");
runSystemCommand("touch /var/lock/start.retro", "", nullptr);
runSystemCommand("systemctl start retroarch.service", "", nullptr);
Scripting::fireEvent("quit", "retroarch");
quitES(QuitMode::QUIT);
}, _("NO"), nullptr));
}, "iconControllers");
s->addEntry(_("REBOOT FROM NAND"), false, [window] {
window->pushGui(new GuiMsgBox(window, _("REALLY REBOOT FROM NAND?"), _("YES"),
[] {
Scripting::fireEvent("quit", "nand");
runSystemCommand("rebootfromnand", "", nullptr);
runSystemCommand("sync", "", nullptr);
runSystemCommand("systemctl reboot", "", nullptr);
quitES(QuitMode::QUIT);
}, _("NO"), nullptr));
}, "iconAdvanced");
*/
#endif
s->addEntry(_("RESTART SYSTEM"), false, [window] {
window->pushGui(new GuiMsgBox(window, _("REALLY RESTART?"),
_("YES"), [] { quitES(QuitMode::REBOOT); },
_("NO"), nullptr));
}, "iconRestart");
s->addEntry(_("SHUTDOWN SYSTEM"), false, [window] {
window->pushGui(new GuiMsgBox(window, _("REALLY SHUTDOWN?"),
_("YES"), [] { quitES(QuitMode::SHUTDOWN); },
_("NO"), nullptr));
}, "iconShutdown");
#ifndef _ENABLEEMUELEC
s->addEntry(_("FAST SHUTDOWN SYSTEM"), false, [window] {
window->pushGui(new GuiMsgBox(window, _("REALLY SHUTDOWN WITHOUT SAVING METADATA?"),
_("YES"), [] { quitES(QuitMode::FAST_SHUTDOWN); },
_("NO"), nullptr));
}, "iconFastShutdown");
#endif
//#ifdef WIN32
if (Settings::getInstance()->getBool("ShowExit"))
{
s->addEntry(_("QUIT EMULATIONSTATION"), false, [window] {
window->pushGui(new GuiMsgBox(window, _("REALLY QUIT?"),
_("YES"), [] { quitES(QuitMode::QUIT); },
_("NO"), nullptr));
}, "iconQuit");
}
//#endif
if (quickAccessMenu && animate)
s->getMenu().animateTo(Vector2f((Renderer::getScreenWidth() - s->getMenu().getSize().x()) / 2, (Renderer::getScreenHeight() - s->getMenu().getSize().y()) / 2));
else if (quickAccessMenu)
s->getMenu().setPosition((Renderer::getScreenWidth() - s->getMenu().getSize().x()) / 2, (Renderer::getScreenHeight() - s->getMenu().getSize().y()) / 2);
window->pushGui(s);
}
void GuiMenu::createDecorationItemTemplate(Window* window, std::vector<DecorationSetInfo> sets, std::string data, ComponentListRow& row)
{
Vector2f maxSize(Renderer::getScreenWidth() * 0.14, Renderer::getScreenHeight() * 0.14);
int IMGPADDING = Renderer::getScreenHeight()*0.01f;
auto theme = ThemeData::getMenuTheme();
std::shared_ptr<Font> font = theme->Text.font;
unsigned int color = theme->Text.color;
// spacer between icon and text
auto spacer = std::make_shared<GuiComponent>(window);
spacer->setSize(IMGPADDING, 0);
row.addElement(spacer, false);
row.addElement(std::make_shared<TextComponent>(window, Utils::String::toUpper(Utils::String::replace(data, "_", " ")), font, color, ALIGN_LEFT), true, true);
std::string imageUrl;
for (auto set : sets)
if (set.name == data)
imageUrl = set.imageUrl;
// image
if (!imageUrl.empty())
{
auto icon = std::make_shared<ImageComponent>(window);
icon->setImage(imageUrl, false, maxSize);
icon->setMaxSize(maxSize);
icon->setColorShift(theme->Text.color);
icon->setPadding(IMGPADDING);
row.addElement(icon, false);
}
}
void GuiMenu::popSystemConfigurationGui(Window* mWindow, SystemData* systemData)
{
popSpecificConfigurationGui(mWindow,
systemData->getFullName(),
systemData->getName(),
systemData,
nullptr);
}
void GuiMenu::popGameConfigurationGui(Window* mWindow, FileData* fileData)
{
popSpecificConfigurationGui(mWindow,
fileData->getName(),
fileData->getConfigurationName(),
fileData->getSourceFileData()->getSystem(),
fileData);
}
void GuiMenu::popSpecificConfigurationGui(Window* mWindow, std::string title, std::string configName, SystemData *systemData, FileData* fileData, bool selectCoreLine)
{
// The system configuration
GuiSettings* systemConfiguration = new GuiSettings(mWindow, title.c_str());
if (fileData != nullptr)
systemConfiguration->setSubTitle(systemData->getFullName());
std::string currentEmulator = fileData != nullptr ? fileData->getEmulator(false) : systemData->getEmulator(false);
std::string currentCore = fileData != nullptr ? fileData->getCore(false) : systemData->getCore(false);
if (systemData->hasEmulatorSelection())
{
auto emulChoice = std::make_shared<OptionListComponent<std::string>>(mWindow, _("Emulator"), false);
emulChoice->add(_("AUTO"), "", false);
for (auto& emul : systemData->getEmulators())
{
if (emul.cores.size() == 0)
emulChoice->add(emul.name, emul.name, emul.name == currentEmulator);
else
{
for (auto& core : emul.cores)
{
bool selected = (emul.name == currentEmulator && core.name == currentCore);
if (emul.name == core.name)
emulChoice->add(emul.name, emul.name + "/" + core.name, selected);
else
emulChoice->add(emul.name + ": " + Utils::String::replace(core.name, "_", " "), emul.name + "/" + core.name, selected);
}
}
}
if (!emulChoice->hasSelection())
emulChoice->selectFirstItem();
emulChoice->setSelectedChangedCallback([mWindow, title, systemConfiguration, systemData, fileData, configName, emulChoice](std::string s)
{
std::string newEmul;
std::string newCore;
auto values = Utils::String::split(emulChoice->getSelected(), '/');
if (values.size() > 0)
newEmul = values[0];
if (values.size() > 1)
newCore = values[1];
if (fileData != nullptr)
{
fileData->setEmulator(newEmul);
fileData->setCore(newCore);
}
else
{
SystemConf::getInstance()->set(configName + ".emulator", newEmul);
SystemConf::getInstance()->set(configName + ".core", newCore);
}
popSpecificConfigurationGui(mWindow, title, configName, systemData, fileData);
delete systemConfiguration;
});
systemConfiguration->addWithLabel(_("Emulator"), emulChoice);
}
#ifdef _ENABLEEMUELEC
/*
if (systemData->isFeatureSupported(currentEmulator, currentCore, EmulatorFeatures::nativevideo))
{
auto videoNativeResolutionMode_choice = createNativeVideoResolutionModeOptionList(mWindow, configName);
systemConfiguration->addWithLabel(_("NATIVE VIDEO"), videoNativeResolutionMode_choice);
systemConfiguration->addSaveFunc([configName, videoNativeResolutionMode_choice] {
SystemConf::getInstance()->set(configName + ".nativevideo", videoNativeResolutionMode_choice->getSelected());
SystemConf::getInstance()->saveSystemConf();
});
}
*/
#endif
// Screen ratio choice
if (systemData->isFeatureSupported(currentEmulator, currentCore, EmulatorFeatures::ratio))
{
auto ratio_choice = createRatioOptionList(mWindow, configName);
systemConfiguration->addWithLabel(_("GAME ASPECT RATIO"), ratio_choice);
systemConfiguration->addSaveFunc([configName, ratio_choice] { SystemConf::getInstance()->set(configName + ".ratio", ratio_choice->getSelected()); });
}
// video resolution mode
if (systemData->isFeatureSupported(currentEmulator, currentCore, EmulatorFeatures::videomode))
{
auto videoResolutionMode_choice = createVideoResolutionModeOptionList(mWindow, configName);
systemConfiguration->addWithLabel(_("VIDEO MODE"), videoResolutionMode_choice);
systemConfiguration->addSaveFunc([configName, videoResolutionMode_choice] { SystemConf::getInstance()->set(configName + ".videomode", videoResolutionMode_choice->getSelected()); });
}
// smoothing
if (systemData->isFeatureSupported(currentEmulator, currentCore, EmulatorFeatures::smooth))
{
auto smoothing_enabled = std::make_shared<OptionListComponent<std::string>>(mWindow, _("BILINEAR FILTERING"));
smoothing_enabled->addRange({ { _("AUTO"), "auto" },{ _("ON") , "1" },{ _("OFF"), "0" } }, SystemConf::getInstance()->get(configName + ".smooth"));
systemConfiguration->addWithLabel(_("BILINEAR FILTERING"), smoothing_enabled);
systemConfiguration->addSaveFunc([configName, smoothing_enabled] { SystemConf::getInstance()->set(configName + ".smooth", smoothing_enabled->getSelected()); });
}
// rewind
if (systemData->isFeatureSupported(currentEmulator, currentCore, EmulatorFeatures::rewind))
{
auto rewind_enabled = std::make_shared<OptionListComponent<std::string>>(mWindow, _("REWIND"));
rewind_enabled->addRange({ { _("AUTO"), "auto" }, { _("ON") , "1" }, { _("OFF"), "0" } }, SystemConf::getInstance()->get(configName + ".rewind"));
systemConfiguration->addWithLabel(_("REWIND"), rewind_enabled);
systemConfiguration->addSaveFunc([configName, rewind_enabled] { SystemConf::getInstance()->set(configName + ".rewind", rewind_enabled->getSelected()); });
}
// autosave
if (systemData->isFeatureSupported(currentEmulator, currentCore, EmulatorFeatures::autosave))
{
auto autosave_enabled = std::make_shared<OptionListComponent<std::string>>(mWindow, _("AUTO SAVE/LOAD ON GAME LAUNCH"));
autosave_enabled->addRange({ { _("AUTO"), "auto" }, { _("ON") , "1" }, { _("OFF"), "0" }, { _("SHOW SAVE STATES") , "2" }, { _("SHOW SAVE STATES IF NOT EMPTY") , "3" } }, SystemConf::getInstance()->get(configName + ".autosave"));
systemConfiguration->addWithLabel(_("AUTO SAVE/LOAD ON GAME LAUNCH"), autosave_enabled);
systemConfiguration->addSaveFunc([configName, autosave_enabled] { SystemConf::getInstance()->set(configName + ".autosave", autosave_enabled->getSelected()); });
}
#ifdef _ENABLEEMUELEC
// Shaders preset
if (ApiSystem::getInstance()->isScriptingSupported(ApiSystem::SHADERS) &&
systemData->isFeatureSupported(currentEmulator, currentCore, EmulatorFeatures::shaders))
{
std::string a;
auto shaders_choices = std::make_shared<OptionListComponent<std::string> >(mWindow, _("SHADER SET"),false);
std::string currentShader = SystemConf::getInstance()->get(configName + ".shaderset");
if (currentShader.empty()) {
currentShader = std::string("auto");
}
shaders_choices->add(_("AUTO"), "auto", currentShader == "auto");
shaders_choices->add(_("NONE"), "none", currentShader == "none");
for(std::stringstream ss(getShOutput(R"(/usr/bin/emuelec-utils getshaders)")); getline(ss, a, ','); )
shaders_choices->add(a, a, currentShader == a); // emuelec
systemConfiguration->addWithLabel(_("SHADER SET"), shaders_choices);
systemConfiguration->addSaveFunc([shaders_choices, configName] { SystemConf::getInstance()->set(configName + ".shaderset", shaders_choices->getSelected()); });
}
// Filters preset
if (ApiSystem::getInstance()->isScriptingSupported(ApiSystem::SHADERS) &&
systemData->isFeatureSupported(currentEmulator, currentCore, EmulatorFeatures::shaders))
{
std::string a;
auto filters_choices = std::make_shared<OptionListComponent<std::string> >(mWindow, _("FILTER SET"),false);
std::string currentFilter = SystemConf::getInstance()->get(configName + ".filterset");
if (currentFilter.empty()) {
currentFilter = std::string("auto");
}
filters_choices->add(_("AUTO"), "auto", currentFilter == "auto");
filters_choices->add(_("NONE"), "none", currentFilter == "none");
for(std::stringstream ss(getShOutput(R"(/usr/bin/emuelec-utils getfilters)")); getline(ss, a, ','); )
filters_choices->add(a, a, currentFilter == a); // emuelec
systemConfiguration->addWithLabel(_("FILTER SET"), filters_choices);
systemConfiguration->addSaveFunc([filters_choices, configName] { SystemConf::getInstance()->set(configName + ".filterset", filters_choices->getSelected()); });
}
#if defined(ODROIDGOA) || defined(_ENABLEGAMEFORCE)
// RGA SCALING
auto rgascale_enabled = std::make_shared<OptionListComponent<std::string>>(mWindow, _("RGA SCALING"));
rgascale_enabled->add(_("AUTO"), "auto", SystemConf::getInstance()->get(configName + ".rgascale") != "0" && SystemConf::getInstance()->get(configName + ".rgascale") != "1");
rgascale_enabled->add(_("ON"), "1", SystemConf::getInstance()->get(configName + ".rgascale") == "1");
rgascale_enabled->add(_("OFF"), "0", SystemConf::getInstance()->get(configName + ".rgascale") == "0");
systemConfiguration->addWithLabel(_("RGA SCALING"), rgascale_enabled);
systemConfiguration->addSaveFunc([configName, rgascale_enabled] { SystemConf::getInstance()->set(configName + ".rgascale", rgascale_enabled->getSelected()); });
#endif
// Vertical Game
if (systemData->isFeatureSupported(currentEmulator, currentCore, EmulatorFeatures::vertical))
{
auto vertical_enabled = std::make_shared<OptionListComponent<std::string>>(mWindow, _("ENABLE VERTICAL"));
vertical_enabled->add(_("OFF"), "auto", SystemConf::getInstance()->get(configName + ".vertical") != "1");
vertical_enabled->add(_("ON"), "1", SystemConf::getInstance()->get(configName + ".vertical") == "1");
systemConfiguration->addWithLabel(_("ENABLE VERTICAL"), vertical_enabled);
systemConfiguration->addSaveFunc([configName, vertical_enabled] { SystemConf::getInstance()->set(configName + ".vertical", vertical_enabled->getSelected()); });
auto vert_aspect_enabled = std::make_shared<OptionListComponent<std::string>>(mWindow, _("VERTICAL ASPECT RATIO"));
vert_aspect_enabled->addRange({ { _("16:9") , "1" }, { _("3:2") , "7" }, { _("21:9"), "4" }, { _("4:3") , "0" } }, SystemConf::getInstance()->get(configName + ".vert_aspect"));
systemConfiguration->addWithLabel(_("VERTICAL ASPECT RATIO"), vert_aspect_enabled);
systemConfiguration->addSaveFunc([configName, vert_aspect_enabled] { SystemConf::getInstance()->set(configName + ".vert_aspect", vert_aspect_enabled->getSelected()); });
}
#else
// Shaders preset
if (ApiSystem::getInstance()->isScriptingSupported(ApiSystem::SHADERS) &&
systemData->isFeatureSupported(currentEmulator, currentCore, EmulatorFeatures::shaders))
{
auto installedShaders = ApiSystem::getInstance()->getShaderList(systemData->getName());
if (installedShaders.size() > 0)
{
std::string currentShader = SystemConf::getInstance()->get(configName + ".shaderset");
auto shaders_choices = std::make_shared<OptionListComponent<std::string> >(mWindow, _("SHADER SET"), false);
shaders_choices->add(_("AUTO"), "auto", currentShader.empty() || currentShader == "auto");
shaders_choices->add(_("NONE"), "none", currentShader == "none");
for (auto shader : installedShaders)
shaders_choices->add(_(Utils::String::toUpper(shader).c_str()), shader, currentShader == shader);
if (!shaders_choices->hasSelection())
shaders_choices->selectFirstItem();
systemConfiguration->addWithLabel(_("SHADER SET"), shaders_choices);
systemConfiguration->addSaveFunc([configName, shaders_choices] { SystemConf::getInstance()->set(configName + ".shaderset", shaders_choices->getSelected()); });
}
}
#endif
// Integer scale & Integer scale overscale
if (systemData->isFeatureSupported(currentEmulator, currentCore, EmulatorFeatures::pixel_perfect))
{
auto integerscale_enabled = std::make_shared<OptionListComponent<std::string>>(mWindow, _("INTEGER SCALING (PIXEL PERFECT)"));
integerscale_enabled->addRange({ { _("AUTO"), "auto" },{ _("ON") , "1" },{ _("OFF"), "0" } }, SystemConf::getInstance()->get(configName + ".integerscale"));
systemConfiguration->addWithLabel(_("INTEGER SCALING (PIXEL PERFECT)"), integerscale_enabled);
systemConfiguration->addSaveFunc([integerscale_enabled, configName] { SystemConf::getInstance()->set(configName + ".integerscale", integerscale_enabled->getSelected()); });
auto integerscaleoverscale_enabled = std::make_shared<OptionListComponent<std::string>>(mWindow, _("INTEGER SCALE OVERSCALE"));
integerscaleoverscale_enabled->addRange({ { _("AUTO"), "auto" },{ _("ON") , "1" },{ _("OFF"), "0" } }, SystemConf::getInstance()->get(configName + ".integerscaleoverscale"));
systemConfiguration->addWithLabel(_("INTEGER SCALE OVERSCALE)"), integerscaleoverscale_enabled);
systemConfiguration->addSaveFunc([integerscaleoverscale_enabled, configName] { SystemConf::getInstance()->set(configName + ".integerscaleoverscale", integerscaleoverscale_enabled->getSelected()); });
}
#ifdef _ENABLEEMUELEC
// bezel
/*
if (systemData->isFeatureSupported(currentEmulator, currentCore, EmulatorFeatures::decoration))
{
auto bezel_enabled = std::make_shared<OptionListComponent<std::string>>(mWindow, _("BEZEL"));
bezel_enabled->add(_("AUTO"), "auto", SystemConf::getInstance()->get(configName + ".bezel") != "0" && SystemConf::getInstance()->get(configName + ".bezel") != "1");
bezel_enabled->add(_("YES"), "1", SystemConf::getInstance()->get(configName + ".bezel") == "1");
bezel_enabled->add(_("NO"), "0", SystemConf::getInstance()->get(configName + ".bezel") == "0");
systemConfiguration->addWithLabel(_("BEZEL"), bezel_enabled);
systemConfiguration->addSaveFunc([bezel_enabled, configName] { SystemConf::getInstance()->set(configName + ".bezel", bezel_enabled->getSelected()); });
}
*/
// RGA scale
if (systemData->isFeatureSupported(currentEmulator, currentCore, EmulatorFeatures::pixel_perfect))
{
auto rgascale_enabled = std::make_shared<OptionListComponent<std::string>>(mWindow, _("RGA SCALE"));
rgascale_enabled->add(_("AUTO"), "auto", SystemConf::getInstance()->get(configName + ".rgascale") != "0" && SystemConf::getInstance()->get(configName + ".rgascale") != "1");
rgascale_enabled->add(_("ON"), "1", SystemConf::getInstance()->get(configName + ".rgascale") == "1");
rgascale_enabled->add(_("OFF"), "0", SystemConf::getInstance()->get(configName + ".rgascale") == "0");
systemConfiguration->addWithLabel(_("RGA SCALE"), rgascale_enabled);
systemConfiguration->addSaveFunc([rgascale_enabled, configName] { SystemConf::getInstance()->set(configName + ".rgascale", rgascale_enabled->getSelected()); });
}
// maxperf
auto maxperf_enabled = std::make_shared<OptionListComponent<std::string>>(mWindow, _("ENABLE MAX PERFORMANCE"));
maxperf_enabled->add(_("AUTO"), "auto", SystemConf::getInstance()->get(configName + ".maxperf") != "0" && SystemConf::getInstance()->get(configName + ".maxperf") != "1");
maxperf_enabled->add(_("YES"), "1", SystemConf::getInstance()->get(configName + ".maxperf") == "1");
maxperf_enabled->add(_("NO"), "0", SystemConf::getInstance()->get(configName + ".maxperf") == "0");
systemConfiguration->addWithLabel(_("ENABLE MAX PERFORMANCE"), maxperf_enabled);
systemConfiguration->addSaveFunc([maxperf_enabled, configName] { SystemConf::getInstance()->set(configName + ".maxperf", maxperf_enabled->getSelected()); });
// Enable Decorations for 351ELEC
// decorations
if (ApiSystem::getInstance()->isScriptingSupported(ApiSystem::DECORATIONS) && systemData->isFeatureSupported(currentEmulator, currentCore, EmulatorFeatures::decoration))
{
Window* window = mWindow;
auto sets = GuiMenu::getDecorationsSets(systemData);
if (sets.size() > 0)
{
auto decorations = std::make_shared<OptionListComponent<std::string> >(mWindow, _("DECORATION SET"), false);
decorations->setRowTemplate([window, sets](std::string data, ComponentListRow& row)
{
createDecorationItemTemplate(window, sets, data, row);
});
std::vector<std::string> decorations_item;
decorations_item.push_back(_("AUTO"));
decorations_item.push_back(_("NONE"));
for (auto set : sets)
decorations_item.push_back(set.name);
for (auto it = decorations_item.begin(); it != decorations_item.end(); it++) {
decorations->add(*it, *it,
(SystemConf::getInstance()->get(configName + ".bezel") == *it)
||
(SystemConf::getInstance()->get(configName + ".bezel") == "none" && *it == _("NONE"))
||
(SystemConf::getInstance()->get(configName + ".bezel") == "" && *it == _("AUTO"))
);
}
systemConfiguration->addWithLabel(_("DECORATION SET"), decorations);
//351elec - set decoration on change so it's update for decoration options without exiting screen
decorations->setSelectedChangedCallback([decorations, configName](std::string value)
{
LOG(LogDebug) << "Setting bezel on change: " << configName << " to: " << value;
if (Utils::String::toLower(value) == "auto") {
value = "";
}
SystemConf::getInstance()->set(configName + ".bezel", value);
});
if (decorations->getSelectedName() == "")
{
decorations->selectFirstItem();
}
systemConfiguration->addEntry(_("DECORATION OPTIONS"), true, [mWindow, configName, sets]
{ openDecorationConfiguration(mWindow, configName, sets); });
#if !defined(WIN32) || defined(_DEBUG)
// stretch bezels
/*
auto bezel_stretch_enabled = std::make_shared<OptionListComponent<std::string>>(mWindow, _("STRETCH BEZELS (4K & ULTRAWIDE)"));
bezel_stretch_enabled->add(_("AUTO"), "auto", SystemConf::getInstance()->get(configName + ".bezel_stretch") != "0" && SystemConf::getInstance()->get(configName + ".bezel_stretch") != "1");
bezel_stretch_enabled->add(_("ON"), "1", SystemConf::getInstance()->get(configName + ".bezel_stretch") == "1");
bezel_stretch_enabled->add(_("OFF"), "0", SystemConf::getInstance()->get(configName + ".bezel_stretch") == "0");
decorations_window->addWithLabel(_("STRETCH BEZELS (4K & ULTRAWIDE)"), bezel_stretch_enabled);
decorations_window->addSaveFunc([bezel_stretch_enabled, configName] {
if (bezel_stretch_enabled->changed()) {
SystemConf::getInstance()->set(configName + ".bezel_stretch", bezel_stretch_enabled->getSelected());
SystemConf::getInstance()->saveSystemConf();
}
});
// tattoo and controller overlays
auto bezel_tattoo = std::make_shared<OptionListComponent<std::string>>(mWindow, _("SHOW CONTROLLER OVERLAYS"));
bezel_tattoo->add(_("AUTO"), "auto", SystemConf::getInstance()->get(configName + ".bezel.tattoo") != "0"
&& SystemConf::getInstance()->get(configName + ".bezel.tattoo") != "system"
&& SystemConf::getInstance()->get(configName + ".bezel.tattoo") != "custom");
bezel_tattoo->add(_("NO"), "0", SystemConf::getInstance()->get(configName + ".bezel.tattoo") == "0");
bezel_tattoo->add(_("SYSTEM CONTROLLERS"), "system", SystemConf::getInstance()->get(configName + ".bezel.tattoo") == "system");
bezel_tattoo->add(_("CUSTOM .PNG IMAGE"), "custom", SystemConf::getInstance()->get(configName + ".bezel.tattoo") == "custom");
decorations_window->addWithLabel(_("SHOW CONTROLLER OVERLAYS"), bezel_tattoo);
decorations_window->addSaveFunc([bezel_tattoo, configName] {
if (bezel_tattoo->changed()) {
SystemConf::getInstance()->set(configName + ".bezel.tattoo", bezel_tattoo->getSelected());
SystemConf::getInstance()->saveSystemConf();
}
});
auto bezel_tattoo_corner = std::make_shared<OptionListComponent<std::string>>(mWindow, _("OVERLAY CORNER"));
bezel_tattoo_corner->add(_("AUTO"), "auto", SystemConf::getInstance()->get(configName + ".bezel.tattoo_corner") != "NW"
&& SystemConf::getInstance()->get(configName + ".bezel.tattoo_corner") != "NE"
&& SystemConf::getInstance()->get(configName + ".bezel.tattoo_corner") != "SE"
&& SystemConf::getInstance()->get(configName + ".bezel.tattoo_corner") != "SW");
bezel_tattoo_corner->add(_("NORTH WEST"), "NW", SystemConf::getInstance()->get(configName + ".bezel.tattoo_corner") == "NW");
bezel_tattoo_corner->add(_("NORTH EAST"), "NE", SystemConf::getInstance()->get(configName + ".bezel.tattoo_corner") == "NE");
bezel_tattoo_corner->add(_("SOUTH EAST"), "SE", SystemConf::getInstance()->get(configName + ".bezel.tattoo_corner") == "SE");
bezel_tattoo_corner->add(_("SOUTH WEST"), "SW", SystemConf::getInstance()->get(configName + ".bezel.tattoo_corner") == "SW");
decorations_window->addWithLabel(_("OVERLAY CORNER"), bezel_tattoo_corner);
decorations_window->addSaveFunc([bezel_tattoo_corner, configName] {
if (bezel_tattoo_corner->changed()) {
SystemConf::getInstance()->set(configName + ".bezel.tattoo_corner", bezel_tattoo_corner->getSelected());
SystemConf::getInstance()->saveSystemConf();
}
});
std::string tatpath = configName + ".bezel.tattoo_file";
const char *bezelpath = const_cast<char*>(tatpath.data());
decorations_window->addInputTextRow(_("CUSTOM .PNG IMAGE PATH"), bezelpath, false);
mWindow->pushGui(decorations_window);
});*/
#endif
}
}
#endif
if (systemData->isFeatureSupported(currentEmulator, currentCore, EmulatorFeatures::latency_reduction))
systemConfiguration->addEntry(_("LATENCY REDUCTION"), true, [mWindow, configName] { openLatencyReductionConfiguration(mWindow, configName); });
if (systemData->isFeatureSupported(currentEmulator, currentCore, EmulatorFeatures::colorization))
{
// gameboy colorize
auto colorizations_choices = std::make_shared<OptionListComponent<std::string> >(mWindow, _("COLORIZATION"), false);
std::string currentColorization = SystemConf::getInstance()->get(configName + ".renderer.colorization");
if (currentColorization.empty())
currentColorization = std::string("auto");
colorizations_choices->add(_("AUTO"), "auto", currentColorization == "auto");
colorizations_choices->add(_("NONE"), "none", currentColorization == "none");
#ifdef _ENABLEEMUELEC
colorizations_choices->add(_("GBC"), "GBC", currentColorization == "GBC");
colorizations_choices->add(_("SGB"), "SGB", currentColorization == "SGB");
#endif
colorizations_choices->add(_("Best Guess"), "Best Guess", currentColorization == "Best Guess");
const char* all_gambate_gc_colors_modes[] = { "GB - DMG",
"GB - Light",
"GB - Pocket",
"GBC - Blue",
"GBC - Brown",
"GBC - Dark Blue",
"GBC - Dark Brown",
"GBC - Dark Green",
"GBC - Grayscale",
"GBC - Green",
"GBC - Inverted",
"GBC - Orange",
"GBC - Pastel Mix",
"GBC - Red",
"GBC - Yellow",
"SGB - 1A",
"SGB - 1B",
"SGB - 1C",
"SGB - 1D",
"SGB - 1E",
"SGB - 1F",
"SGB - 1G",
"SGB - 1H",
"SGB - 2A",
"SGB - 2B",
"SGB - 2C",
"SGB - 2D",
"SGB - 2E",
"SGB - 2F",
"SGB - 2G",
"SGB - 2H",
"SGB - 3A",
"SGB - 3B",
"SGB - 3C",
"SGB - 3D",
"SGB - 3E",
"SGB - 3F",
"SGB - 3G",
"SGB - 3H",
"SGB - 4A",
"SGB - 4B",
"SGB - 4C",
"SGB - 4D",
"SGB - 4E",
"SGB - 4F",
"SGB - 4G",
"SGB - 4H",
"Special 1",
"Special 2",
"Special 3",
"TWB01 - 756 Production",
"TWB02 - AKB48 Pink",
"TWB03 - Angry Volcano",
"TWB04 - Anime Expo",
"TWB05 - Aqours Blue",
"TWB06 - Aquatic Iro",
"TWB07 - Bandai Namco",
"TWB08 - Blossom Pink",
"TWB09 - Bubbles Blue",
"TWB10 - Builder Yellow",
"TWB11 - Buttercup Green",
"TWB12 - Camouflage",
"TWB13 - Cardcaptor Pink",
"TWB14 - Christmas",
"TWB15 - Crunchyroll Orange",
"TWB16 - Digivice",
"TWB17 - Do The Dew",
"TWB18 - Eevee Brown",
"TWB19 - Fruity Orange",
"TWB20 - Game.com",
"TWB21 - Game Grump Orange",
"TWB22 - GameKing",
"TWB23 - Game Master",
"TWB24 - Ghostly Aoi",
"TWB25 - Golden Wild",
"TWB26 - Green Banana",
"TWB27 - Greenscale",
"TWB28 - Halloween",
"TWB29 - Hero Yellow",
"TWB30 - Hokage Orange",
"TWB31 - Labo Fawn",
"TWB32 - Legendary Super Saiyan",
"TWB33 - Lemon Lime Green",
"TWB34 - Lime Midori",
"TWB35 - Mania Plus Green",
"TWB36 - Microvision",
"TWB37 - Million Live Gold",
"TWB38 - Miraitowa Blue",
"TWB39 - NASCAR",
"TWB40 - Neo Geo Pocket",
"TWB41 - Neon Blue",
"TWB42 - Neon Green",
"TWB43 - Neon Pink",
"TWB44 - Neon Red",
"TWB45 - Neon Yellow",
"TWB46 - Nick Orange",
"TWB47 - Nijigasaki Orange",
"TWB48 - Odyssey Gold",
"TWB49 - Patrick Star Pink",
"TWB50 - Pikachu Yellow",
"TWB51 - Pocket Tales",
"TWB52 - Pokemon mini",
"TWB53 - Pretty Guardian Gold",
"TWB54 - S.E.E.S. Blue",
"TWB55 - Saint Snow Red",
"TWB56 - Scooby-Doo Mystery",
"TWB57 - Shiny Sky Blue",
"TWB58 - Sidem Green",
"TWB59 - Slime Blue",
"TWB60 - Spongebob Yellow",
"TWB61 - Stone Orange",
"TWB62 - Straw Hat Red",
"TWB63 - Superball Ivory",
"TWB64 - Super Saiyan Blue",
"TWB65 - Super Saiyan Rose",
"TWB66 - Supervision",
"TWB67 - Survey Corps Brown",
"TWB68 - Tea Midori",
"TWB69 - TI-83",
"TWB70 - Tokyo Midtown",
"TWB71 - Travel Wood",
"TWB72 - Virtual Boy",
"TWB73 - VMU",
"TWB74 - Wisteria Murasaki",
"TWB75 - WonderSwan",
"TWB76 - Yellow Banana" };
int n_all_gambate_gc_colors_modes = 126;
for (int i = 0; i < n_all_gambate_gc_colors_modes; i++)
colorizations_choices->add(all_gambate_gc_colors_modes[i], all_gambate_gc_colors_modes[i], currentColorization == std::string(all_gambate_gc_colors_modes[i]));
#ifdef _ENABLEEMUELEC
if (SystemData::es_features_loaded || (!SystemData::es_features_loaded && (systemData->getName() == "gb" || systemData->getName() == "gbc" || systemData->getName() == "gb2players" || systemData->getName() == "gbc2players" || systemData->getName() == "gbh" || systemData->getName() == "gbch"))) // only for gb, gbc and gb2players gbh gbch
#else
if (SystemData::es_features_loaded || (!SystemData::es_features_loaded && (systemData->getName() == "gb" || systemData->getName() == "gbc" || systemData->getName() == "gb2players" || systemData->getName() == "gbc2players"))) // only for gb, gbc and gb2players
#endif
{
systemConfiguration->addWithLabel(_("COLORIZATION"), colorizations_choices);
systemConfiguration->addSaveFunc([colorizations_choices, configName] { SystemConf::getInstance()->set(configName + ".renderer.colorization", colorizations_choices->getSelected()); });
}
}
#ifndef _ENABLEEMUELEC
// ps2 full boot
if (systemData->isFeatureSupported(currentEmulator, currentCore, EmulatorFeatures::fullboot))
{
if (SystemData::es_features_loaded || (!SystemData::es_features_loaded && systemData->getName() == "ps2")) // only for ps2
{
auto fullboot_enabled = std::make_shared<OptionListComponent<std::string>>(mWindow, _("FULL BOOT"));
fullboot_enabled->addRange({ { _("AUTO"), "auto" },{ _("ON") , "1" },{ _("OFF"), "0" } }, SystemConf::getInstance()->get(configName + ".fullboot"));
systemConfiguration->addWithLabel(_("FULL BOOT"), fullboot_enabled);
systemConfiguration->addSaveFunc([fullboot_enabled, configName] { SystemConf::getInstance()->set(configName + ".fullboot", fullboot_enabled->getSelected()); });
}
}
// wii emulated wiimotes
if (systemData->isFeatureSupported(currentEmulator, currentCore, EmulatorFeatures::emulated_wiimotes))
{
if (SystemData::es_features_loaded || (!SystemData::es_features_loaded && systemData->getName() == "wii")) // only for wii
{
auto emulatedwiimotes_enabled = std::make_shared<OptionListComponent<std::string>>(mWindow, _("EMULATED WIIMOTES"));
emulatedwiimotes_enabled->addRange({ { _("AUTO"), "auto" },{ _("ON") , "1" },{ _("OFF"), "0" } }, SystemConf::getInstance()->get(configName + ".emulatedwiimotes"));
systemConfiguration->addWithLabel(_("EMULATED WIIMOTES"), emulatedwiimotes_enabled);
systemConfiguration->addSaveFunc([emulatedwiimotes_enabled, configName] { SystemConf::getInstance()->set(configName + ".emulatedwiimotes", emulatedwiimotes_enabled->getSelected()); });
}
}
// citra change screen layout
if (systemData->isFeatureSupported(currentEmulator, currentCore, EmulatorFeatures::screen_layout))
{
if (SystemData::es_features_loaded || (!SystemData::es_features_loaded && systemData->getName() == "3ds")) // only for 3ds
{
auto changescreen_layout = std::make_shared<OptionListComponent<std::string>>(mWindow, _("CHANGE SCREEN LAYOUT"));
changescreen_layout->addRange({ { _("AUTO"), "auto" },{ _("LARGE SCREEN") , "2" },{ _("SIDE BY SIDE"), "3" } }, SystemConf::getInstance()->get(configName + ".layout_option"));
systemConfiguration->addWithLabel(_("CHANGE SCREEN LAYOUT"), changescreen_layout);
systemConfiguration->addSaveFunc([changescreen_layout, configName] { SystemConf::getInstance()->set(configName + ".layout_option", changescreen_layout->getSelected()); });
}
}
// psp internal resolution
if (systemData->isFeatureSupported(currentEmulator, currentCore, EmulatorFeatures::internal_resolution))
{
std::string curResol = SystemConf::getInstance()->get(configName + ".internalresolution");
auto internalresolution = std::make_shared<OptionListComponent<std::string>>(mWindow, _("INTERNAL RESOLUTION"));
internalresolution->add(_("AUTO"), "auto", curResol.empty() || curResol == "auto");
internalresolution->add("1:1", "0", curResol == "0");
internalresolution->add("x1", "1", curResol == "1");
internalresolution->add("x2", "2", curResol == "2");
internalresolution->add("x3", "3", curResol == "3");
internalresolution->add("x4", "4", curResol == "4");
internalresolution->add("x5", "5", curResol == "5");
internalresolution->add("x8", "8", curResol == "8");
internalresolution->add("x10", "10", curResol == "10");
if (!internalresolution->hasSelection())
internalresolution->selectFirstItem();
if (SystemData::es_features_loaded || (!SystemData::es_features_loaded && (systemData->getName() == "psp" || systemData->getName() == "wii" || systemData->getName() == "gamecube"))) // only for psp, wii, gamecube
{
systemConfiguration->addWithLabel(_("INTERNAL RESOLUTION"), internalresolution);
systemConfiguration->addSaveFunc([internalresolution, configName] { SystemConf::getInstance()->set(configName + ".internalresolution", internalresolution->getSelected()); });
}
}
#endif
// Load per-game / per-emulator / per-system custom features
std::vector<CustomFeature> customFeatures = systemData->getCustomFeatures(currentEmulator, currentCore);
auto groups = groupBy(customFeatures, [](const CustomFeature& item) { return item.submenu; });
for (auto group : groups)
{
if (!group.first.empty())
{
systemConfiguration->addEntry(group.first, true, [configName, mWindow, group]
{
GuiSettings* groupSettings = new GuiSettings(mWindow, _(group.first.c_str()));
for (auto feat : group.second)
{
std::string storageName = configName + "." + feat.value;
std::string storedValue = SystemConf::getInstance()->get(storageName);
auto cf = std::make_shared<OptionListComponent<std::string>>(mWindow, _(feat.name.c_str()));
cf->add(_("AUTO"), "", storedValue.empty() || storedValue == "auto");
for (auto fval : feat.choices)
cf->add(_(fval.name.c_str()), fval.value, storedValue == fval.value);
if (!cf->hasSelection())
cf->selectFirstItem();
if (!feat.description.empty())
groupSettings->addWithDescription(_(feat.name.c_str()), _(feat.description.c_str()), cf);
else
groupSettings->addWithLabel(_(feat.name.c_str()), cf);
groupSettings->addSaveFunc([cf, storageName]
{
SystemConf::getInstance()->set(storageName, cf->getSelected());
});
}
mWindow->pushGui(groupSettings);
});
}
else
{
for (auto feat : group.second)
{
std::string storageName = configName + "." + feat.value;
std::string storedValue = SystemConf::getInstance()->get(storageName);
auto cf = std::make_shared<OptionListComponent<std::string>>(mWindow, _(feat.name.c_str()));
cf->add(_("AUTO"), "", storedValue.empty() || storedValue == "auto");
for (auto fval : feat.choices)
cf->add(_(fval.name.c_str()), fval.value, storedValue == fval.value);
if (!cf->hasSelection())
cf->selectFirstItem();
if (!feat.description.empty())
systemConfiguration->addWithDescription(_(feat.name.c_str()), _(feat.description.c_str()), cf);
else
systemConfiguration->addWithLabel(_(feat.name.c_str()), cf);
systemConfiguration->addSaveFunc([cf, storageName]
{
SystemConf::getInstance()->set(storageName, cf->getSelected());
});
}
}
}
// automatic controller configuration
if (systemData->isFeatureSupported(currentEmulator, currentCore, EmulatorFeatures::autocontrollers))
{
auto autoControllers = std::make_shared<OptionListComponent<std::string>>(mWindow, _("AUTOCONFIGURE CONTROLLERS"));
autoControllers->addRange({ { _("AUTO"), "" },{ _("ON"), "0" },{ _("OFF"), "1" } }, SystemConf::getInstance()->get(configName + ".disableautocontrollers"));
systemConfiguration->addWithLabel(_("AUTOCONFIGURE CONTROLLERS"), autoControllers);
systemConfiguration->addSaveFunc([configName, autoControllers] { SystemConf::getInstance()->set(configName + ".disableautocontrollers", autoControllers->getSelected()); });
}
if (fileData == nullptr && ApiSystem::getInstance()->isScriptingSupported(ApiSystem::ScriptId::EVMAPY) && systemData->isCurrentFeatureSupported(EmulatorFeatures::Features::padTokeyboard))
{
if (systemData->hasKeyboardMapping())
systemConfiguration->addEntry(_("EDIT PADTOKEY PROFILE"), true, [mWindow, systemData] { editKeyboardMappings(mWindow, systemData, true); });
else
systemConfiguration->addEntry(_("CREATE PADTOKEY PROFILE"), true, [mWindow, systemData] { editKeyboardMappings(mWindow, systemData, true); });
}
// Set as boot game
/*
if (fileData != nullptr)
{
std::string gamePath = fileData->getFullPath();
auto bootgame = std::make_shared<SwitchComponent>(mWindow);
bootgame->setState(SystemConf::getInstance()->get("global.bootgame.path") == gamePath);
systemConfiguration->addWithLabel(_("LAUNCH THIS GAME AT STARTUP"), bootgame);
systemConfiguration->addSaveFunc([bootgame, fileData, gamePath]
{
if (bootgame->changed())
{
SystemConf::getInstance()->set("global.bootgame.path", bootgame->getState() ? gamePath : "");
SystemConf::getInstance()->set("global.bootgame.cmd", bootgame->getState() ? fileData->getlaunchCommand(false) : "");
}
});
}
*/
mWindow->pushGui(systemConfiguration);
}
std::shared_ptr<OptionListComponent<std::string>> GuiMenu::createRatioOptionList(Window *window, std::string configname)
{
auto ratio_choice = std::make_shared<OptionListComponent<std::string> >(window, _("GAME ASPECT RATIO"), false);
std::string currentRatio = SystemConf::getInstance()->get(configname + ".ratio");
if (currentRatio.empty())
currentRatio = std::string("auto");
std::map<std::string, std::string> *ratioMap = LibretroRatio::getInstance()->getRatio();
for (auto ratio = ratioMap->begin(); ratio != ratioMap->end(); ratio++)
ratio_choice->add(_(ratio->first.c_str()), ratio->second, currentRatio == ratio->second);
if (!ratio_choice->hasSelection())
ratio_choice->selectFirstItem();
return ratio_choice;
}
/*
#ifdef _ENABLEEMUELEC
int getResWidth (std::string res)
{
std::string tmp = "";
std::size_t pos = res.find("x");
if (pos != std::string::npos) {
tmp = res.substr(0, pos);
return atoi( tmp.c_str() );
}
pos = res.find("p");
if (pos != std::string::npos) {
tmp = res.substr(0, pos);
int resv = atoi(tmp.c_str());
return std::ceil(( (float)16 / 9 * resv));
}
pos = res.find("i");
if (pos != std::string::npos) {
tmp = res.substr(0, pos);
int resv = atoi(tmp.c_str());
return std::ceil(( (float)16 / 9 * resv));
}
return 0;
}
int getHzFromRes(std::string res)
{
int tmp = atoi(res.substr(res.length()-4, 2).c_str());
if (tmp > 0) return tmp;
return 60;
}
bool sortResolutions (std::string a, std::string b) {
int ia = getResWidth(a);
int ib = getResWidth(b);
if (ia == ib) return (getHzFromRes(a) < getHzFromRes(b));
return (ia < ib);
}
std::shared_ptr<OptionListComponent<std::string>> GuiMenu::createNativeVideoResolutionModeOptionList(Window *window, std::string configname)
{
auto emuelec_video_mode = std::make_shared< OptionListComponent<std::string> >(window, "NATIVE VIDEO", false);
std::vector<std::string> videomode;
videomode.push_back("640x480p60hz");
videomode.push_back("480p60hz");
videomode.push_back("576p50hz");
videomode.push_back("576p60hz");
videomode.push_back("720p50hz");
videomode.push_back("720p60hz");
videomode.push_back("1080i50hz");
videomode.push_back("1080p50hz");
videomode.push_back("1080i60hz");
videomode.push_back("1080p60hz");
std::string def_video;
for(std::stringstream ss(getShOutput(R"(/usr/bin/emuelec-utils resolutions)")); getline(ss, def_video, ','); ) {
if (!std::count(videomode.begin(), videomode.end(), def_video)) {
videomode.push_back(def_video);
}
}
std::sort(videomode.begin(), videomode.end(), sortResolutions);
std::string index = SystemConf::getInstance()->get(configname + ".nativevideo");
if (index.empty())
index = SystemConf::getInstance()->get("global.videomode");
if (index.empty())
index = SystemConf::getInstance()->get("ee_videomode");
if (index.empty())
index = "auto";
emuelec_video_mode->add(_("AUTO"), "auto", index == "auto");
for (auto it = videomode.cbegin(); it != videomode.cend(); it++) {
emuelec_video_mode->add(*it, *it, index == *it);
}
return emuelec_video_mode;
}
#endif
*/
std::shared_ptr<OptionListComponent<std::string>> GuiMenu::createVideoResolutionModeOptionList(Window *window, std::string configname)
{
auto videoResolutionMode_choice = std::make_shared<OptionListComponent<std::string> >(window, _("VIDEO MODE"), false);
std::string currentVideoMode = SystemConf::getInstance()->get(configname + ".videomode");
if (currentVideoMode.empty())
currentVideoMode = std::string("auto");
std::vector<std::string> videoResolutionModeMap = ApiSystem::getInstance()->getVideoModes();
videoResolutionMode_choice->add(_("AUTO"), "auto", currentVideoMode == "auto");
for (auto videoMode = videoResolutionModeMap.begin(); videoMode != videoResolutionModeMap.end(); videoMode++)
{
std::vector<std::string> tokens = Utils::String::split(*videoMode, ':');
// concatenat the ending words
std::string vname;
for (unsigned int i = 1; i < tokens.size(); i++)
{
if (i > 1)
vname += ":";
vname += tokens.at(i);
}
videoResolutionMode_choice->add(vname, tokens.at(0), currentVideoMode == tokens.at(0));
}
if (!videoResolutionMode_choice->hasSelection())
videoResolutionMode_choice->selectFirstItem();
return videoResolutionMode_choice;
}
void GuiMenu::clearLoadedInput() {
for(int i=0; i<mLoadedInput.size(); i++) {
delete mLoadedInput[i];
}
mLoadedInput.clear();
}
GuiMenu::~GuiMenu() {
clearLoadedInput();
}
std::vector<DecorationSetInfo> GuiMenu::getDecorationsSets(SystemData* system)
{
std::vector<DecorationSetInfo> sets;
if (system == nullptr)
return sets;
static const size_t pathCount = 3;
#if WIN32
std::vector<std::string> paths =
{
Utils::FileSystem::getEsConfigPath() + "/decorations" // for win32 testings
};
std::string win32path = Win32ApiSystem::getEmulatorLauncherPath("system.decorations");
if (!win32path.empty())
paths[0] = win32path;
win32path = Win32ApiSystem::getEmulatorLauncherPath("decorations");
if (!win32path.empty())
paths.push_back(win32path);
#else
std::vector<std::string> paths = {
"/storage/roms/bezels",
"/tmp/overlays/bezels"
};
#endif
Utils::FileSystem::stringList dirContent;
std::string folder;
for (auto path : paths)
{
if (!Utils::FileSystem::isDirectory(path))
continue;
dirContent = Utils::FileSystem::getDirContent(path);
for (Utils::FileSystem::stringList::const_iterator it = dirContent.cbegin(); it != dirContent.cend(); ++it)
{
if (Utils::FileSystem::isDirectory(*it))
{
folder = *it;
DecorationSetInfo info;
info.name = folder.substr(path.size() + 1);
info.path = folder;
if (system != nullptr && Utils::String::startsWith(info.name, "default"))
{
std::string systemImg = path + "/"+ info.name +"/systems/" + system->getName() + ".png";
if (Utils::FileSystem::exists(systemImg))
info.imageUrl = systemImg;
}
if (info.imageUrl.empty())
{
std::string img = folder + "/default.png";
if (Utils::FileSystem::exists(img))
info.imageUrl = img;
}
sets.push_back(info);
}
}
}
struct { bool operator()(DecorationSetInfo& a, DecorationSetInfo& b) const { return a.name < b.name; } } compareByName;
struct { bool operator()(DecorationSetInfo& a, DecorationSetInfo& b) const { return a.name == b.name; } } nameEquals;
// sort and remove duplicates
std::sort(sets.begin(), sets.end(), compareByName);
sets.erase(std::unique(sets.begin(), sets.end(), nameEquals), sets.end());
return sets;
}
void GuiMenu::openFormatDriveSettings()
{
Window *window = mWindow;
auto s = new GuiSettings(mWindow, _("FORMAT DEVICE").c_str());
// Drive
auto optionsStorage = std::make_shared<OptionListComponent<std::string> >(window, _("DEVICE TO FORMAT"), false);
std::vector<std::string> disks = ApiSystem::getInstance()->getFormatDiskList();
if (disks.size() == 0)
optionsStorage->add(_("NONE"), "", false);
else
{
for (auto disk : disks)
{
auto idx = disk.find(" ");
if (idx != std::string::npos)
optionsStorage->add(disk.substr(idx + 1), disk.substr(0, idx), false);
}
}
optionsStorage->selectFirstItem();
s->addWithLabel(_("DEVICE TO FORMAT"), optionsStorage);
// File system
auto fileSystem = std::make_shared<OptionListComponent<std::string> >(window, _("FILE SYSTEM"), false);
std::vector<std::string> fileSystems = ApiSystem::getInstance()->getFormatFileSystems();
if (fileSystems.size() == 0)
fileSystem->add(_("NONE"), "", false);
else
{
for (auto fs : fileSystems)
fileSystem->add(fs, fs, false);
}
fileSystem->selectFirstItem();
s->addWithLabel(_("FILE SYSTEM"), fileSystem);
s->addEntry(_("FORMAT NOW"), false, [s, optionsStorage, fileSystem, window]
{
std::string disk = optionsStorage->getSelected();
std::string fs = fileSystem->getSelected();
if (disk.empty() || fs.empty())
{
window->pushGui(new GuiMsgBox(window, _("SELECTED OPTIONS ARE INVALID")));
return;
}
window->pushGui(new GuiMsgBox(window, _("ARE YOU SURE YOU WANT TO FORMAT THIS DRIVE?"), _("YES"), [s, window, disk, fs]
{
ThreadedFormatter::start(window, disk, fs);
s->close();
}, _("NO"), nullptr));
});
mWindow->pushGui(s);
}
void GuiMenu::saveSubsetSettings()
{
auto currentSystem = ViewController::get()->getState().getSystem();
if (currentSystem == nullptr || currentSystem->getTheme() == nullptr)
return;
std::string fileData;
auto subsets = currentSystem->getTheme()->getSubSetNames();
for (auto subset : subsets)
{
std::string name = subset;
std::string value;
if (name == "colorset")
value = Settings::getInstance()->getString("ThemeColorSet");
else if (name == "iconset")
value = Settings::getInstance()->getString("ThemeIconSet");
else if (name == "menu")
value = Settings::getInstance()->getString("ThemeMenu");
else if (name == "systemview")
value = Settings::getInstance()->getString("ThemeSystemView");
else if (name == "gamelistview")
value = Settings::getInstance()->getString("ThemeGamelistView");
else if (name == "region")
value = Settings::getInstance()->getString("ThemeRegionName");
else
{
value = Settings::getInstance()->getString("subset." + name);
name = "subset." + name;
}
if (!value.empty())
fileData += name + "=" + value + "\r";
for (auto system : SystemData::sSystemVector)
{
value = Settings::getInstance()->getString("subset." + system->getThemeFolder() + "." + subset);
if (!value.empty())
fileData += "subset." + system->getThemeFolder() + "." + subset + "=" + value + "\r";
}
}
if (!Settings::getInstance()->getString("GamelistViewStyle").empty() && Settings::getInstance()->getString("GamelistViewStyle") != "automatic")
fileData += "GamelistViewStyle=" + Settings::getInstance()->getString("GamelistViewStyle") + "\r";
if (!Settings::getInstance()->getString("DefaultGridSize").empty())
fileData += "DefaultGridSize=" + Settings::getInstance()->getString("DefaultGridSize") + "\r";
for (auto system : SystemData::sSystemVector)
{
auto defaultView = Settings::getInstance()->getString(system->getName() + ".defaultView");
if (!defaultView.empty())
fileData += system->getName() + ".defaultView=" + defaultView + "\r";
auto gridSizeOverride = Settings::getInstance()->getString(system->getName() + ".gridSize");
if (!gridSizeOverride.empty())
fileData += system->getName() + ".gridSize=" + gridSizeOverride + "\r";
}
std::string path = Utils::FileSystem::getEsConfigPath() + "/themesettings";
if (!Utils::FileSystem::exists(path))
Utils::FileSystem::createDirectory(path);
std::string themeSet = Settings::getInstance()->getString("ThemeSet");
std::string fileName = path + "/" + themeSet + ".cfg";
if (fileData.empty())
{
if (Utils::FileSystem::exists(fileName))
Utils::FileSystem::removeFile(fileName);
}
else
Utils::FileSystem::writeAllText(fileName, fileData);
}
void GuiMenu::loadSubsetSettings(const std::string themeName)
{
std::string path = Utils::FileSystem::getEsConfigPath() + "/themesettings";
if (!Utils::FileSystem::exists(path))
Utils::FileSystem::createDirectory(path);
std::string fileName = path + "/" + themeName + ".cfg";
if (!Utils::FileSystem::exists(fileName))
return;
std::string line;
std::ifstream systemConf(fileName);
if (systemConf && systemConf.is_open())
{
while (std::getline(systemConf, line, '\r'))
{
int idx = line.find("=");
if (idx == std::string::npos || line.find("#") == 0 || line.find(";") == 0)
continue;
std::string name = line.substr(0, idx);
std::string value = line.substr(idx + 1);
if (!name.empty() && !value.empty())
{
if (name == "colorset")
Settings::getInstance()->setString("ThemeColorSet", value);
else if (name == "iconset")
Settings::getInstance()->setString("ThemeIconSet", value);
else if (name == "menu")
Settings::getInstance()->setString("ThemeMenu", value);
else if (name == "systemview")
Settings::getInstance()->setString("ThemeSystemView", value);
else if (name == "gamelistview")
Settings::getInstance()->setString("ThemeGamelistView", value);
else if (name == "region")
Settings::getInstance()->setString("ThemeRegionName", value);
else if (name == "GamelistViewStyle")
Settings::getInstance()->setString("GamelistViewStyle", value);
else if (name == "DefaultGridSize")
Settings::getInstance()->setString("DefaultGridSize", value);
else if (name.find(".defaultView") != std::string::npos)
Settings::getInstance()->setString(name, value);
else if (name.find(".gridSize") != std::string::npos)
Settings::getInstance()->setString(name, value);
else if (Utils::String::startsWith(name, "subset."))
Settings::getInstance()->setString(name, value);
}
}
systemConf.close();
for (auto system : SystemData::sSystemVector)
{
auto defaultView = Settings::getInstance()->getString(system->getName() + ".defaultView");
auto gridSizeOverride = Vector2f::parseString(Settings::getInstance()->getString(system->getName() + ".gridSize"));
system->setSystemViewMode(defaultView, gridSizeOverride, false);
}
}
else
LOG(LogError) << "Unable to open " << fileName;
}
void GuiMenu::editKeyboardMappings(Window *window, IKeyboardMapContainer* mapping, bool editable)
{
window->pushGui(new GuiKeyMappingEditor(window, mapping, editable));
}