std::pair<int,int> resolution()
{
const std::string postfix = fullscreen() ? "resolution" : "windowsize";
std::string x = prefs['x' + postfix], y = prefs['y' + postfix];
if (!x.empty() && !y.empty()) {
return std::make_pair(
std::max(atoi(x.c_str()), min_allowed_width()),
std::max(atoi(y.c_str()), min_allowed_height()));
} else {
return std::pair<int,int>(1024,768);
}
}
std::pair<int,int> resolution()
{
const std::string& x = prefs["xresolution"], y = prefs["yresolution"];
if (!x.empty() && !y.empty()) {
try {
return std::make_pair(
std::max(std::stoi(x), min_allowed_width()),
std::max(std::stoi(y), min_allowed_height()));
} catch(std::invalid_argument) {}
}
return std::pair<int,int>(1024,768);
}
std::pair<int,int> resolution()
{
const std::string postfix = fullscreen() ? "resolution" : "windowsize";
std::string x = prefs['x' + postfix], y = prefs['y' + postfix];
if (!x.empty() && !y.empty()) {
std::pair<int,int> res(std::max(atoi(x.c_str()), min_allowed_width()),
std::max(atoi(y.c_str()), min_allowed_height()));
// Make sure resolutions are always divisible by 4
//res.first &= ~3;
//res.second &= ~3;
return res;
} else {
return std::pair<int,int>(1024,768);
}
}
std::pair<int,int> resolution()
{
const std::string postfix = fullscreen() ? "resolution" : "windowsize";
std::string x = prefs['x' + postfix], y = prefs['y' + postfix];
if (!x.empty() && !y.empty()) {
std::pair<int,int> res(std::max(atoi(x.c_str()), min_allowed_width()),
std::max(atoi(y.c_str()), min_allowed_height()));
// Make sure resolutions are always divisible by 4
//res.first &= ~3;
//res.second &= ~3;
return res;
} else {
#if defined(__APPLE__) && TARGET_OS_IPHONE
return std::pair<int, int>(480, 320);
#else
// return std::pair<int, int>(1024, 768);
return std::pair<int, int>(800, 600);
#endif
}
}
bool show_video_mode_dialog(display& disp)
{
CVideo& video = disp.video();
SDL_PixelFormat format = *video.getSurface()->format;
format.BitsPerPixel = video.getBpp();
bool fullScreen = fullscreen();
std::vector<std::pair<int,int> > resolutions;
int display = SDL_GetWindowDisplayIndex(disp.video().getWindow());
int modes = SDL_GetNumDisplayModes(display);
SDL_DisplayMode mode = {SDL_PIXELFORMAT_UNKNOWN, 0, 0, 0, 0 };
SDL_Rect screen_rect = disp.video().bound();
for (int n = 0; n < modes; n ++) {
SDL_GetDisplayMode(display, n, &mode);
if (SDL_BYTESPERPIXEL(mode.format) != SDL_BYTESPERPIXEL(video.getformat())) {
continue;
}
#if defined(_WIN32)
if (!fullScreen && (mode.w >= screen_rect.w || mode.h >= screen_rect.h)) {
continue;
}
#endif
if (mode.w >= min_allowed_width() && mode.h >= min_allowed_height()) {
resolutions.push_back(std::pair<int, int>(mode.w, mode.h));
}
}
if (resolutions.empty()) {
gui2::show_transient_message(disp.video(), "", _("There are no alternative video modes available"));
return false;
}
const std::pair<int,int> current_res(video.getSurface()->w, video.getSurface()->h);
resolutions.push_back(current_res);
if (!fullScreen) {
resolutions.push_back(std::make_pair(480, 320));
resolutions.push_back(std::make_pair(568, 320));
resolutions.push_back(std::make_pair(800, 480));
resolutions.push_back(std::make_pair(854, 480));
resolutions.push_back(std::make_pair(1280, 720));
resolutions.push_back(std::make_pair(1280, 800));
}
std::sort(resolutions.begin(),resolutions.end(),compare_resolutions);
resolutions.erase(std::unique(resolutions.begin(),resolutions.end()),resolutions.end());
std::vector<std::string> options;
unsigned current_choice = 0;
for(size_t k = 0; k < resolutions.size(); ++k) {
std::pair<int, int> const& res = resolutions[k];
std::ostringstream option;
if (res == current_res) {
current_choice = static_cast<unsigned>(k);
}
option << res.first << "x" << res.second;
// widescreen threshold is 16:10
if ((double)res.first/res.second >= 16.0/10.0) {
option << _(" (widescreen)");
}
options.push_back(option.str());
}
gui2::tsimple_item_selector dlg(_("Choose Resolution"), "", options);
dlg.set_selected_index(current_choice);
dlg.show(disp.video());
int choice = dlg.selected_index();
if (choice == -1 || resolutions[static_cast<size_t>(choice)] == current_res) {
return false;
}
std::pair<int, int>& res = resolutions[static_cast<size_t>(choice)];
set_resolution(disp, res.first, res.second);
return true;
}
bool show_video_mode_dialog(display& disp)
{
const resize_lock prevent_resizing;
const events::event_context dialog_events_context;
CVideo& video = disp.video();
SDL_PixelFormat format = *video.getSurface()->format;
format.BitsPerPixel = video.getBpp();
const SDL_Rect* const * modes = SDL_ListModes(&format,FULL_SCREEN);
// The SDL documentation says that a return value of -1
// means that all dimensions are supported/possible.
if(modes == reinterpret_cast<SDL_Rect**>(-1)) {
std::cerr << "Can support any video mode\n";
// SDL says that all modes are possible, so it's OK to use a
// hardcoded list here. Include tiny and small gui since they
// will be filtered out later if not needed.
static const SDL_Rect scr_modes[] = {
{ 0, 0, 320, 240 },
{ 0, 0, 640, 480 },
{ 0, 0, 800, 480 }, // small-gui (EeePC resolution)
{ 0, 0, 800, 600 },
{ 0, 0, 1024, 600 }, // used on many netbooks
{ 0, 0, 1024, 768 },
{ 0, 0, 1280, 960 },
{ 0, 0, 1280, 1024 },
{ 0, 0, 1366, 768 }, // 16:9 notebooks
{ 0, 0, 1440, 900 },
{ 0, 0, 1440, 1200 },
{ 0, 0, 1600, 1200 },
{ 0, 0, 1680, 1050 },
{ 0, 0, 1920, 1080 },
{ 0, 0, 1920, 1200 },
{ 0, 0, 2560, 1600 }
};
static const SDL_Rect * const scr_modes_list[] = {
&scr_modes[0],
&scr_modes[1],
&scr_modes[2],
&scr_modes[3],
&scr_modes[4],
&scr_modes[5],
&scr_modes[6],
&scr_modes[7],
&scr_modes[8],
&scr_modes[9],
&scr_modes[10],
&scr_modes[11],
&scr_modes[12],
&scr_modes[13],
&scr_modes[14],
&scr_modes[15],
NULL
};
modes = scr_modes_list;
} else if(modes == NULL) {
std::cerr << "No modes supported\n";
gui2::show_transient_message(disp.video(),"",_("There are no alternative video modes available"));
return false;
}
std::vector<std::pair<int,int> > resolutions;
for(int i = 0; modes[i] != NULL; ++i) {
if(modes[i]->w >= min_allowed_width() && modes[i]->h >= min_allowed_height()) {
resolutions.push_back(std::pair<int,int>(modes[i]->w,modes[i]->h));
}
}
const std::pair<int,int> current_res(video.getSurface()->w,video.getSurface()->h);
resolutions.push_back(current_res);
std::sort(resolutions.begin(),resolutions.end(),compare_resolutions);
resolutions.erase(std::unique(resolutions.begin(),resolutions.end()),resolutions.end());
std::vector<std::string> options;
unsigned current_choice = 0;
for(size_t k = 0; k < resolutions.size(); ++k) {
std::pair<int, int> const& res = resolutions[k];
std::ostringstream option;
if (res == current_res)
current_choice = static_cast<unsigned>(k);
option << res.first << utils::unicode_multiplication_sign << res.second;
/*widescreen threshold is 16:10*/
if (static_cast<double>(res.first)/res.second >= 16.0/10.0)
option << _(" (widescreen)");
options.push_back(option.str());
}
gui2::tsimple_item_selector dlg(_("Choose Resolution"), "", options);
dlg.set_selected_index(current_choice);
dlg.show(disp.video());
int choice = dlg.selected_index();
if(choice == -1 || resolutions[static_cast<size_t>(choice)] == current_res) {
return false;
}
set_resolution(resolutions[static_cast<size_t>(choice)]);
return true;
}
