1
0
mirror of https://github.com/vcmi/vcmi.git synced 2024-12-16 10:19:47 +02:00
vcmi/client/windows/settings/GeneralOptionsTab.cpp
2023-02-18 17:49:43 +01:00

229 lines
7.4 KiB
C++

/*
* GeneralOptionsTab.cpp, part of VCMI engine
*
* Authors: listed in file AUTHORS in main folder
*
* License: GNU General Public License v2.0 or later
* Full text of license available in license.txt file, in main folder
*
*/
#include "StdInc.h"
#include "GeneralOptionsTab.h"
#include "../../../lib/CGeneralTextHandler.h"
#include "../../../lib/filesystem/ResourceID.h"
#include "../../gui/CGuiHandler.h"
#include "../../widgets/Buttons.h"
#include "../../widgets/TextControls.h"
#include "../../widgets/Images.h"
#include "CGameInfo.h"
#include "CMusicHandler.h"
#include "CPlayerInterface.h"
#include "windows/GUIClasses.h"
#include "CServerHandler.h"
#include "renderSDL/SDL_Extensions.h"
static void setIntSetting(std::string group, std::string field, int value)
{
Settings entry = settings.write[group][field];
entry->Float() = value;
}
static void setBoolSetting(std::string group, std::string field, bool value)
{
Settings fullscreen = settings.write[group][field];
fullscreen->Bool() = value;
}
static std::string resolutionToString(int w, int h)
{
return std::to_string(w) + 'x' + std::to_string(h);
}
GeneralOptionsTab::GeneralOptionsTab()
: InterfaceObjectConfigurable(),
onFullscreenChanged(settings.listen["video"]["fullscreen"])
{
OBJ_CONSTRUCTION_CAPTURING_ALL_NO_DISPOSE;
const JsonNode config(ResourceID("config/widgets/settings/generalOptionsTab.json"));
addCallback("spellbookAnimationChanged", [](bool value)
{
return setBoolSetting("video", "spellbookAnimation", value);
});
addCallback("setMusic", [this](int value)
{
setIntSetting("general", "music", value);
widget<CSlider>("musicSlider")->redraw();
});
addCallback("setVolume", [this](int value)
{
setIntSetting("general", "sound", value);
widget<CSlider>("soundVolumeSlider")->redraw();
});
//settings that do not belong to base game:
addCallback("fullscreenChanged", [this](bool value)
{
setFullscreenMode(value);
});
addCallback("setGameResolution", [this](int dummyValue)
{
selectGameResolution();
});
addCallback("framerateChanged", [](bool value)
{
setBoolSetting("general", "showfps", value);
});
//moved from "other" tab that is disabled for now to avoid excessible tabs with barely any content
addCallback("availableCreaturesAsDwellingLabelChanged", [](bool value)
{
setBoolSetting("gameTweaks", "availableCreaturesAsDwellingLabel", value);
});
addCallback("compactTownCreatureInfoChanged", [](bool value)
{
return setBoolSetting("gameTweaks", "compactTownCreatureInfo", value);
});
build(config);
std::shared_ptr<CLabel> resolutionLabel = widget<CLabel>("resolutionLabel");
const auto & currentResolution = settings["video"]["screenRes"];
resolutionLabel->setText(resolutionToString(currentResolution["width"].Integer(), currentResolution["height"].Integer()));
std::shared_ptr<CToggleButton> spellbookAnimationCheckbox = widget<CToggleButton>("spellbookAnimationCheckbox");
spellbookAnimationCheckbox->setSelected(settings["video"]["spellbookAnimation"].Bool());
std::shared_ptr<CToggleButton> fullscreenCheckbox = widget<CToggleButton>("fullscreenCheckbox");
fullscreenCheckbox->setSelected(settings["video"]["fullscreen"].Bool());
onFullscreenChanged([&](const JsonNode &newState) //used when pressing F4 etc. to change fullscreen checkbox state
{
widget<CToggleButton>("fullscreenCheckbox")->setSelected(newState.Bool());
});
std::shared_ptr<CToggleButton> framerateCheckbox = widget<CToggleButton>("framerateCheckbox");
framerateCheckbox->setSelected(settings["general"]["showfps"].Bool());
std::shared_ptr<CSlider> musicSlider = widget<CSlider>("musicSlider");
musicSlider->moveTo(CCS->musich->getVolume());
std::shared_ptr<CSlider> volumeSlider = widget<CSlider>("soundVolumeSlider");
volumeSlider->moveTo(CCS->soundh->getVolume());
std::shared_ptr<CToggleButton> availableCreaturesAsDwellingLabelCheckbox = widget<CToggleButton>("availableCreaturesAsDwellingLabelCheckbox");
availableCreaturesAsDwellingLabelCheckbox->setSelected(settings["gameTweaks"]["availableCreaturesAsDwellingLabel"].Bool());
std::shared_ptr<CToggleButton> compactTownCreatureInfo = widget<CToggleButton>("compactTownCreatureInfoCheckbox");
compactTownCreatureInfo->setSelected(settings["gameTweaks"]["compactTownCreatureInfo"].Bool());
}
bool GeneralOptionsTab::isResolutionSupported(const Point & resolution)
{
return isResolutionSupported( resolution, settings["video"]["fullscreen"].Bool());
}
bool GeneralOptionsTab::isResolutionSupported(const Point & resolution, bool fullscreen)
{
if (!fullscreen)
return true;
auto supportedList = CSDL_Ext::getSupportedResolutions();
return CSDL_Ext::isResolutionSupported(supportedList, resolution);
}
void GeneralOptionsTab::selectGameResolution()
{
fillSelectableResolutions();
std::vector<std::string> items;
size_t currentResolutionIndex = 0;
size_t i = 0;
for(const auto & it : selectableResolutions)
{
auto resolutionStr = resolutionToString(it.x, it.y);
if(widget<CLabel>("resolutionLabel")->getText() == resolutionStr)
currentResolutionIndex = i;
items.push_back(std::move(resolutionStr));
++i;
}
GH.pushIntT<CObjectListWindow>(items, nullptr,
CGI->generaltexth->translate("vcmi.systemOptions.resolutionMenu.hover"),
CGI->generaltexth->translate("vcmi.systemOptions.resolutionMenu.help"),
[this](int index)
{
setGameResolution(index);
},
currentResolutionIndex);
}
void GeneralOptionsTab::setGameResolution(int index)
{
assert(index >= 0 && index < selectableResolutions.size());
if ( index < 0 || index >= selectableResolutions.size() )
return;
Point resolution = selectableResolutions[index];
Settings gameRes = settings.write["video"]["screenRes"];
gameRes["width"].Float() = resolution.x;
gameRes["height"].Float() = resolution.y;
std::string resText;
resText += std::to_string(resolution.x);
resText += "x";
resText += std::to_string(resolution.y);
widget<CLabel>("resolutionLabel")->setText(resText);
}
void GeneralOptionsTab::setFullscreenMode(bool on)
{
fillSelectableResolutions();
const auto & screenRes = settings["video"]["screenRes"];
const Point desiredResolution(screenRes["width"].Integer(), screenRes["height"].Integer());
const Point currentResolution = GH.screenDimensions();
if (!isResolutionSupported(currentResolution, on))
{
widget<CToggleButton>("fullscreenCheckbox")->setSelected(!on);
LOCPLINT->showInfoDialog(CGI->generaltexth->translate("vcmi.systemOptions.fullscreenFailed"));
return;
}
setBoolSetting("video", "fullscreen", on);
if (!isResolutionSupported(desiredResolution, on))
{
// user changed his desired resolution and switched to fullscreen
// however resolution he selected before is not available in fullscreen
// so reset it back to currect resolution which is confirmed to be supported earlier
Settings gameRes = settings.write["video"]["screenRes"];
gameRes["width"].Float() = currentResolution.x;
gameRes["height"].Float() = currentResolution.y;
widget<CLabel>("resolutionLabel")->setText(resolutionToString(currentResolution.x, currentResolution.y));
}
}
void GeneralOptionsTab::fillSelectableResolutions()
{
selectableResolutions.clear();
for(const auto & it : conf.guiOptions)
{
const Point dimensions(it.first.first, it.first.second);
if(isResolutionSupported(dimensions))
selectableResolutions.push_back(dimensions);
}
boost::range::sort(selectableResolutions, [](const auto & left, const auto & right)
{
return left.x * left.y < right.x * right.y;
});
}