0ct0pu5/wesnoth
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

dependency cleanup: split preferences.* into preferences_display.*,

Browse source 
...so that modules which only need to query a prefs value do not
depend on the whole graphics system
This commit is contained in:
Yann Dirson 2005-10-30 23:46:28 +00:00
parent 97132d320b
commit 22cce91ff6
15 changed files with 842 additions and 738 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
graphincludes/project/wesnoth.pm
View file

@ -83,7 +83,6 @@ sub defaultcolors {
sub ignored_deps {
return {
'src/video.cpp' => {'src/font.hpp' => 'split out floating labels from video' },
'src/language.cpp' => {'src/preferences.hpp' => 'split out graph. stuff from preferences'},
};
}

4
src/Makefile.am
View file

@ -83,6 +83,7 @@ wesnoth_SOURCES = \
playlevel.cpp \
playturn.cpp \
preferences.cpp \
preferences_display.cpp \
publish_campaign.cpp \
race.cpp \
random.cpp \
@ -181,6 +182,7 @@ wesnoth_SOURCES = \
playlevel.hpp \
playturn.hpp \
preferences.hpp \
preferences_display.hpp \
publish_campaign.hpp \
race.hpp \
random.hpp \
@ -280,6 +282,7 @@ wesnoth_editor_SOURCES = \
pathfind.cpp \
playturn.cpp \
preferences.cpp \
preferences_display.cpp \
race.cpp \
random.cpp \
replay.cpp \
@ -368,6 +371,7 @@ wesnoth_editor_SOURCES = \
playlevel.hpp \
playturn.hpp \
preferences.hpp \
preferences_display.hpp \
race.hpp \
random.hpp \
replay.hpp \

2
src/editor/editor.hpp
View file

@ -20,7 +20,7 @@
#include "../events.hpp"
#include "../font.hpp"
#include "../hotkeys.hpp"
#include "../preferences.hpp"
#include "../preferences_display.hpp"
#include "../theme.hpp"
#include "../tooltips.hpp"

4
src/editor/editor_dialogs.cpp
View file

@ -27,9 +27,9 @@
#include "../marked-up_text.hpp"
#include "../show_dialog.hpp"
#include "../util.hpp"
#include "../widgets/slider.hpp"
#include "../preferences.hpp"
#include "../preferences_display.hpp"
#include "../video.hpp"
#include "../widgets/slider.hpp"
#include "editor_dialogs.hpp"

2
src/events.cpp
View file

@ -17,7 +17,7 @@
#include "cursor.hpp"
#include "events.hpp"
#include "mouse.hpp"
#include "preferences.hpp"
#include "preferences_display.hpp"
#include "video.hpp"
#include "wassert.hpp"

2
src/game.cpp
View file

@ -40,7 +40,7 @@
#include "network.hpp"
#include "pathfind.hpp"
#include "playcampaign.hpp"
#include "preferences.hpp"
#include "preferences_display.hpp"
#include "publish_campaign.hpp"
#include "replay.hpp"
#include "show_dialog.hpp"

2
src/hotkeys.cpp
View file

@ -21,7 +21,7 @@
#include "hotkeys.hpp"
#include "gettext.hpp"
#include "playlevel.hpp"
#include "preferences.hpp"
#include "preferences_display.hpp"
#include "show_dialog.hpp"
#include "util.hpp"
#include "video.hpp"

2
src/multiplayer_ui.hpp
View file

@ -16,7 +16,7 @@
#include "config.hpp"
#include "hotkeys.hpp"
#include "network.hpp"
#include "preferences.hpp"
#include "preferences_display.hpp"
#include "widgets/label.hpp"
#include "widgets/button.hpp"
#include "widgets/menu.hpp"

2
src/playlevel.cpp
View file

@ -33,7 +33,7 @@
#include "network.hpp"
#include "playlevel.hpp"
#include "playturn.hpp"
#include "preferences.hpp"
#include "preferences_display.hpp"
#include "random.hpp"
#include "replay.hpp"
#include "scoped_resource.hpp"

2
src/playturn.cpp
View file

@ -30,7 +30,7 @@
#include "network.hpp"
#include "playlevel.hpp"
#include "playturn.hpp"
#include "preferences.hpp"
#include "preferences_display.hpp"
#include "replay.hpp"
#include "sound.hpp"
#include "statistics.hpp"

730
src/preferences.cpp
View file

@ -15,27 +15,19 @@
#define GETTEXT_DOMAIN "wesnoth-lib"
#include "config.hpp"
#include "cursor.hpp"
#include "display.hpp"
#include "events.hpp"
#include "filesystem.hpp"
#include "gettext.hpp"
#include "hotkeys.hpp"
#include "log.hpp"
#include "marked-up_text.hpp"
#include "preferences.hpp"
#include "show_dialog.hpp"
#include "sound.hpp"
#include "util.hpp"
#include "video.hpp"
#include "video.hpp" // non_interactive()
#include "wesconfig.h"
#include "wml_separators.hpp"
#include "serialization/parser.hpp"
#include "serialization/string_utils.hpp"
#include "widgets/button.hpp"
#include "widgets/label.hpp"
#include "widgets/menu.hpp"
#include "widgets/slider.hpp"
#include <cstdlib>
#include <iostream>
@ -46,8 +38,6 @@ namespace {
config prefs;
display* disp = NULL;
bool muted_ = false;
bool colour_cursors = false;
@ -105,21 +95,12 @@ manager::~manager()
}
}
display_manager::display_manager(display* d)
{
disp = d;
hotkey::load_hotkeys(prefs);
set_grid(grid());
set_turbo(turbo());
set_fullscreen(fullscreen());
set_gamma(gamma());
void set(const std::string key, std::string value) {
prefs[key] = value;
}
display_manager::~display_manager()
{
disp = NULL;
std::string get(const std::string key) {
return prefs[key];
}
namespace {
@ -138,28 +119,10 @@ bool fullscreen()
return is_fullscreen;
}
void set_fullscreen(bool ison)
void _set_fullscreen(bool ison)
{
is_fullscreen = ison;
prefs["fullscreen"] = (ison ? "true" : "false");
if(disp != NULL) {
const std::pair<int,int>& res = resolution();
CVideo& video = disp->video();
if(video.isFullScreen() != ison) {
const int flags = ison ? FULL_SCREEN : 0;
const int bpp = video.modePossible(res.first,res.second,16,flags);
if(bpp > 0) {
video.setMode(res.first,res.second,bpp,flags);
disp->redraw_everything();
} else if(video.modePossible(1024,768,16,flags)) {
set_resolution(std::pair<int,int>(1024,768));
} else {
gui::show_dialog(*disp,NULL,"",_("The video mode could not be changed. Your window manager must be set to 16 bits per pixel to run the game in windowed mode. Your display must support 1024x768x16 to run the game full screen."),
gui::MESSAGE);
}
}
}
}
std::pair<int,int> resolution()
@ -180,43 +143,6 @@ std::pair<int,int> resolution()
return std::pair<int,int>(1024,768);
}
}
void set_resolution(const std::pair<int,int>& resolution)
{
std::pair<int,int> res = resolution;
// - Ayin: disabled the following code. Why would one want to enforce that?
// Some 16:9, or laptop screens, may have resolutions which do not
// comply to this rule (see bug 10630). I'm commenting this until it
// proves absolutely necessary.
//
//make sure resolutions are always divisible by 4
//res.first &= ~3;
//res.second &= ~3;
bool write_resolution = true;
if(disp != NULL) {
CVideo& video = disp->video();
const int flags = fullscreen() ? FULL_SCREEN : 0;
const int bpp = video.modePossible(res.first,res.second,16,flags);
if(bpp != 0) {
video.setMode(res.first,res.second,bpp,flags);
disp->redraw_everything();
} else {
write_resolution = false;
gui::show_dialog(*disp,NULL,"",_("The video mode could not be changed. Your window manager must be set to 16 bits per pixel to run the game in windowed mode. Your display must support 1024x768x16 to run the game full screen."),gui::MESSAGE);
}
}
if(write_resolution) {
const std::string postfix = fullscreen() ? "resolution" : "windowsize";
prefs['x' + postfix] = lexical_cast<std::string>(res.first);
prefs['y' + postfix] = lexical_cast<std::string>(res.second);
}
}
bool turbo()
{
if(non_interactive())
@ -226,13 +152,9 @@ bool turbo()
return turbo != prefs.values.end() && turbo->second == "true";
}
void set_turbo(bool ison)
void _set_turbo(bool ison)
{
prefs["turbo"] = (ison ? "true" : "false");
if(disp != NULL) {
disp->set_turbo(ison);
}
}
const std::string& language()
@ -279,14 +201,8 @@ bool adjust_gamma()
return prefs["adjust_gamma"] == "yes";
}
void set_adjust_gamma(bool val)
void _set_adjust_gamma(bool val)
{
//if we are turning gamma adjustment off, then set it to '1.0'
if(val == false && adjust_gamma()) {
CVideo& video = disp->video();
video.setGamma(1.0);
}
prefs["adjust_gamma"] = val ? "yes" : "no";
}
@ -300,16 +216,11 @@ int gamma()
return default_value;
}
void set_gamma(int gamma)
void _set_gamma(int gamma)
{
std::stringstream stream;
stream << gamma;
prefs["gamma"] = stream.str();
if(adjust_gamma()) {
CVideo& video = disp->video();
video.setGamma((float)gamma / 100);
}
}
bool is_muted()
@ -323,13 +234,9 @@ bool grid()
return turbo != prefs.values.end() && turbo->second == "true";
}
void set_grid(bool ison)
void _set_grid(bool ison)
{
prefs["grid"] = (ison ? "true" : "false");
if(disp != NULL) {
disp->set_grid(ison);
}
}
const std::string& official_network_host()
@ -836,618 +743,11 @@ void set_cache_saves(CACHE_SAVES_METHOD method)
}
}
namespace {
class preferences_dialog : public gui::preview_pane
{
public:
preferences_dialog(display& disp, const config& game_cfg);
struct video_mode_change_exception
{
enum TYPE { CHANGE_RESOLUTION, MAKE_FULLSCREEN, MAKE_WINDOWED };
video_mode_change_exception(TYPE type) : type(type)
{}
TYPE type;
};
private:
void process_event();
bool left_side() const { return false; }
void set_selection(int index);
void update_location(SDL_Rect const &rect);
const config* get_advanced_pref() const;
void set_advanced_menu();
gui::slider music_slider_, sound_slider_, scroll_slider_, gamma_slider_;
gui::button fullscreen_button_, turbo_button_, show_ai_moves_button_,
show_grid_button_, show_floating_labels_button_, turn_dialog_button_,
turn_bell_button_, show_team_colours_button_, show_colour_cursors_button_,
show_haloing_button_, video_mode_button_, hotkeys_button_, gamma_button_,
flip_time_button_, advanced_button_, sound_button_, music_button_;
gui::label music_label_, sound_label_, scroll_label_, gamma_label_;
unsigned slider_label_width_;
gui::menu advanced_;
int advanced_selection_;
enum TAB { GENERAL_TAB, DISPLAY_TAB, SOUND_TAB, ADVANCED_TAB };
TAB tab_;
display &disp_;
const config& game_cfg_;
};
preferences_dialog::preferences_dialog(display& disp, const config& game_cfg)
: gui::preview_pane(disp.video()),
music_slider_(disp.video()), sound_slider_(disp.video()),
scroll_slider_(disp.video()), gamma_slider_(disp.video()),
fullscreen_button_(disp.video(), _("Toggle Full Screen"), gui::button::TYPE_CHECK),
turbo_button_(disp.video(), _("Accelerated Speed"), gui::button::TYPE_CHECK),
show_ai_moves_button_(disp.video(), _("Skip AI Moves"), gui::button::TYPE_CHECK),
show_grid_button_(disp.video(), _("Show Grid"), gui::button::TYPE_CHECK),
show_floating_labels_button_(disp.video(), _("Show Floating Labels"), gui::button::TYPE_CHECK),
turn_dialog_button_(disp.video(), _("Turn Dialog"), gui::button::TYPE_CHECK),
turn_bell_button_(disp.video(), _("Turn Bell"), gui::button::TYPE_CHECK),
show_team_colours_button_(disp.video(), _("Show Team Colors"), gui::button::TYPE_CHECK),
show_colour_cursors_button_(disp.video(), _("Show Color Cursors"), gui::button::TYPE_CHECK),
show_haloing_button_(disp.video(), _("Show Haloing Effects"), gui::button::TYPE_CHECK),
video_mode_button_(disp.video(), _("Video Mode")),
hotkeys_button_(disp.video(), _("Hotkeys")),
gamma_button_(disp.video(), _("Adjust Gamma"), gui::button::TYPE_CHECK),
flip_time_button_(disp.video(), _("Reverse Time Graphics"), gui::button::TYPE_CHECK),
sound_button_(disp.video(), _("Sound effects"), gui::button::TYPE_CHECK),
music_button_(disp.video(), _("Music"), gui::button::TYPE_CHECK),
advanced_button_(disp.video(), "", gui::button::TYPE_CHECK),
music_label_(disp.video(), _("Music Volume:")), sound_label_(disp.video(), _("SFX Volume:")),
scroll_label_(disp.video(), _("Scroll Speed:")), gamma_label_(disp.video(), _("Gamma:")),
slider_label_width_(0), advanced_(disp.video(),std::vector<std::string>()), advanced_selection_(-1),
tab_(GENERAL_TAB), disp_(disp), game_cfg_(game_cfg)
{
// FIXME: this box should be vertically centered on the screen, but is not
#if USE_TINY_GUI
set_measurements(260, 220); // FIXME: should compute this, but using what data ?
#else
set_measurements(400, 400);
#endif
sound_button_.set_check(sound_on());
sound_button_.set_help_string(_("Sound effects on/off"));
sound_slider_.set_min(0);
sound_slider_.set_max(128);
sound_slider_.set_value(sound_volume());
sound_slider_.set_help_string(_("Change the sound effects volume"));
music_button_.set_check(music_on());
music_button_.set_help_string(_("Music on/off"));
music_slider_.set_min(0);
music_slider_.set_max(128);
music_slider_.set_value(music_volume());
music_slider_.set_help_string(_("Change the music volume"));
scroll_slider_.set_min(1);
scroll_slider_.set_max(100);
scroll_slider_.set_value(scroll_speed());
scroll_slider_.set_help_string(_("Change the speed of scrolling around the map"));
gamma_button_.set_check(adjust_gamma());
gamma_button_.set_help_string(_("Change the brightness of the display"));
gamma_slider_.set_min(50);
gamma_slider_.set_max(200);
gamma_slider_.set_value(gamma());
gamma_slider_.set_help_string(_("Change the brightness of the display"));
fullscreen_button_.set_check(fullscreen());
fullscreen_button_.set_help_string(_("Choose whether the game should run full screen or in a window"));
turbo_button_.set_check(turbo());
turbo_button_.set_help_string(_("Make units move and fight faster"));
show_ai_moves_button_.set_check(!show_ai_moves());
show_ai_moves_button_.set_help_string(_("Do not animate AI units moving"));
show_grid_button_.set_check(grid());
show_grid_button_.set_help_string(_("Overlay a grid onto the map"));
show_floating_labels_button_.set_check(show_floating_labels());
show_floating_labels_button_.set_help_string(_("Show text above a unit when it is hit to display damage inflicted"));
video_mode_button_.set_help_string(_("Change the resolution the game runs at"));
turn_dialog_button_.set_check(turn_dialog());
turn_dialog_button_.set_help_string(_("Display a dialog at the beginning of your turn"));
turn_bell_button_.set_check(turn_bell());
turn_bell_button_.set_help_string(_("Play a bell sound at the beginning of your turn"));
show_team_colours_button_.set_check(show_side_colours());
show_team_colours_button_.set_help_string(_("Show a colored circle around the base of each unit to show which side it is on"));
flip_time_button_.set_check(flip_time());
flip_time_button_.set_help_string(_("Choose whether the sun moves left-to-right or right-to-left"));
show_colour_cursors_button_.set_check(use_colour_cursors());
show_colour_cursors_button_.set_help_string(_("Use colored mouse cursors (may be slower)"));
show_haloing_button_.set_check(show_haloes());
show_haloing_button_.set_help_string(_("Use graphical special effects (may be slower)"));
hotkeys_button_.set_help_string(_("View and configure keyboard shortcuts"));
set_advanced_menu();
}
void preferences_dialog::update_location(SDL_Rect const &rect)
{
bg_register(rect);
const int border = font::relative_size(10);
#if USE_TINY_GUI
const int item_interline = 20;
#else
const int item_interline = 50;
#endif
// General tab
int ypos = rect.y;
scroll_label_.set_location(rect.x, ypos);
SDL_Rect scroll_rect = { rect.x + scroll_label_.width(), ypos,
rect.w - scroll_label_.width() - border, 0 };
scroll_slider_.set_location(scroll_rect);
ypos += item_interline; turbo_button_.set_location(rect.x, ypos);
ypos += item_interline; show_ai_moves_button_.set_location(rect.x, ypos);
ypos += item_interline; turn_dialog_button_.set_location(rect.x, ypos);
ypos += item_interline; turn_bell_button_.set_location(rect.x, ypos);
ypos += item_interline; show_team_colours_button_.set_location(rect.x, ypos);
ypos += item_interline; show_grid_button_.set_location(rect.x, ypos);
ypos += item_interline; hotkeys_button_.set_location(rect.x, ypos);
// Display tab
ypos = rect.y;
gamma_button_.set_location(rect.x, ypos);
ypos += item_interline;
gamma_label_.set_location(rect.x, ypos);
SDL_Rect gamma_rect = { rect.x + gamma_label_.width(), ypos,
rect.w - gamma_label_.width() - border, 0 };
gamma_slider_.set_location(gamma_rect);
ypos += item_interline; flip_time_button_.set_location(rect.x,ypos);
ypos += item_interline; show_floating_labels_button_.set_location(rect.x, ypos);
ypos += item_interline; show_colour_cursors_button_.set_location(rect.x, ypos);
ypos += item_interline; show_haloing_button_.set_location(rect.x, ypos);
ypos += item_interline; fullscreen_button_.set_location(rect.x, ypos);
ypos += item_interline; video_mode_button_.set_location(rect.x, ypos);
// Sound tab
slider_label_width_ = maximum<unsigned>(music_label_.width(), sound_label_.width());
ypos = rect.y;
sound_button_.set_location(rect.x, ypos);
ypos += item_interline;
sound_label_.set_location(rect.x, ypos);
const SDL_Rect sound_rect = { rect.x + slider_label_width_, ypos,
rect.w - slider_label_width_ - border, 0 };
sound_slider_.set_location(sound_rect);
ypos += item_interline;
music_button_.set_location(rect.x, ypos);
ypos += item_interline;
music_label_.set_location(rect.x, ypos);
const SDL_Rect music_rect = { rect.x + slider_label_width_, ypos,
rect.w - slider_label_width_ - border, 0 };
music_slider_.set_location(music_rect);
//Advanced tab
ypos = rect.y;
advanced_.set_location(rect.x,ypos);
advanced_.set_max_height(height()-100);
ypos += advanced_.height() + border;
advanced_button_.set_location(rect.x,ypos);
set_selection(tab_);
}
void preferences_dialog::process_event()
{
if (turbo_button_.pressed())
set_turbo(turbo_button_.checked());
if (show_ai_moves_button_.pressed())
set_show_ai_moves(!show_ai_moves_button_.checked());
if (show_grid_button_.pressed())
set_grid(show_grid_button_.checked());
if (show_floating_labels_button_.pressed())
set_show_floating_labels(show_floating_labels_button_.checked());
if (video_mode_button_.pressed())
throw video_mode_change_exception(video_mode_change_exception::CHANGE_RESOLUTION);
if (fullscreen_button_.pressed())
throw video_mode_change_exception(fullscreen_button_.checked()
? video_mode_change_exception::MAKE_FULLSCREEN
: video_mode_change_exception::MAKE_WINDOWED);
if (turn_bell_button_.pressed())
set_turn_bell(turn_bell_button_.checked());
if (turn_dialog_button_.pressed())
set_turn_dialog(turn_dialog_button_.checked());
if (show_team_colours_button_.pressed())
set_show_side_colours(show_team_colours_button_.checked());
if (hotkeys_button_.pressed())
show_hotkeys_dialog(disp_);
if (show_colour_cursors_button_.pressed())
set_colour_cursors(show_colour_cursors_button_.checked());
if (show_haloing_button_.pressed())
set_show_haloes(show_haloing_button_.checked());
if (gamma_button_.pressed()) {
set_adjust_gamma(gamma_button_.checked());
bool hide_gamma = !adjust_gamma();
gamma_slider_.hide(hide_gamma);
gamma_label_.hide(hide_gamma);
}
if (sound_button_.pressed()) {
if(!set_sound(sound_button_.checked()))
sound_button_.set_check(false);
}
set_sound_volume(sound_slider_.value());
if (music_button_.pressed()) {
if(!set_music(music_button_.checked()))
music_button_.set_check(false);
}
set_music_volume(music_slider_.value());
if (flip_time_button_.pressed())
set_flip_time(flip_time_button_.checked());
set_scroll_speed(scroll_slider_.value());
set_gamma(gamma_slider_.value());
if(advanced_.selection() != advanced_selection_) {
advanced_selection_ = advanced_.selection();
const config* const adv = get_advanced_pref();
if(adv != NULL) {
const config& pref = *adv;
advanced_button_.set_width(0);
advanced_button_.set_label(pref["name"]);
std::string value = prefs[pref["field"]];
if(value.empty()) {
value = pref["default"];
}
advanced_button_.set_check(value == "yes");
}
}
if(advanced_button_.pressed()) {
const config* const adv = get_advanced_pref();
if(adv != NULL) {
const config& pref = *adv;
prefs[pref["field"]] = advanced_button_.checked() ? "yes" : "no";
set_advanced_menu();
}
}
}
const config* preferences_dialog::get_advanced_pref() const
{
const config::child_list& adv = game_cfg_.get_children("advanced_preference");
if(advanced_selection_ >= 0 && advanced_selection_ < int(adv.size())) {
return adv[advanced_selection_];
} else {
return NULL;
}
}
void preferences_dialog::set_advanced_menu()
{
std::vector<std::string> advanced_items;
const config::child_list& adv = game_cfg_.get_children("advanced_preference");
for(config::child_list::const_iterator i = adv.begin(); i != adv.end(); ++i) {
std::ostringstream str;
std::string field = prefs[(**i)["field"]];
if(field.empty()) {
field = (**i)["default"];
}
if(field == "yes") {
field = _("yes");
} else if(field == "no") {
field = _("no");
}
str << (**i)["name"] << COLUMN_SEPARATOR << field;
advanced_items.push_back(str.str());
}
advanced_.set_items(advanced_items,true,true);
}
void preferences_dialog::set_selection(int index)
{
tab_ = TAB(index);
set_dirty();
bg_restore();
const bool hide_general = tab_ != GENERAL_TAB;
scroll_label_.hide(hide_general);
scroll_slider_.hide(hide_general);
turbo_button_.hide(hide_general);
show_ai_moves_button_.hide(hide_general);
turn_dialog_button_.hide(hide_general);
turn_bell_button_.hide(hide_general);
hotkeys_button_.hide(hide_general);
show_team_colours_button_.hide(hide_general);
show_grid_button_.hide(hide_general);
const bool hide_display = tab_ != DISPLAY_TAB, hide_gamma = hide_display || !adjust_gamma();
gamma_label_.hide(hide_gamma);
gamma_slider_.hide(hide_gamma);
gamma_button_.hide(hide_display);
show_floating_labels_button_.hide(hide_display);
show_colour_cursors_button_.hide(hide_display);
show_haloing_button_.hide(hide_display);
fullscreen_button_.hide(hide_display);
video_mode_button_.hide(hide_display);
flip_time_button_.hide(hide_display);
const bool hide_sound = tab_ != SOUND_TAB;
music_button_.hide(hide_sound);
music_label_.hide(hide_sound);
music_slider_.hide(hide_sound);
sound_button_.hide(hide_sound);
sound_label_.hide(hide_sound);
sound_slider_.hide(hide_sound);
const bool hide_advanced = tab_ != ADVANCED_TAB;
advanced_.hide(hide_advanced);
advanced_button_.hide(hide_advanced);
}
}
void show_preferences_dialog(display& disp, const config& game_cfg)
{
std::vector<std::string> items;
std::string const pre = IMAGE_PREFIX + std::string("icons/icon-");
char const sep = COLUMN_SEPARATOR;
items.push_back(pre + "general.png" + sep + sgettext("Prefs section^General"));
items.push_back(pre + "display.png" + sep + sgettext("Prefs section^Display"));
items.push_back(pre + "music.png" + sep + sgettext("Prefs section^Sound"));
items.push_back(pre + "advanced.png" + sep + sgettext("Advanced section^Advanced"));
for(;;) {
try {
const events::event_context dialog_events_context;
preferences_dialog dialog(disp,game_cfg);
std::vector<gui::preview_pane*> panes;
panes.push_back(&dialog);
gui::show_dialog(disp,NULL,_("Preferences"),"",gui::CLOSE_ONLY,&items,&panes);
return;
} catch(preferences_dialog::video_mode_change_exception& e) {
switch(e.type) {
case preferences_dialog::video_mode_change_exception::CHANGE_RESOLUTION:
show_video_mode_dialog(disp);
break;
case preferences_dialog::video_mode_change_exception::MAKE_FULLSCREEN:
set_fullscreen(true);
break;
case preferences_dialog::video_mode_change_exception::MAKE_WINDOWED:
set_fullscreen(false);
break;
}
if(items[1].empty() || items[1][0] != '*') {
items[1] = "*" + items[1];
}
}
}
}
bool compare_resolutions(const std::pair<int,int>& lhs, const std::pair<int,int>& rhs)
{
return lhs.first*lhs.second < rhs.first*rhs.second;
}
bool show_video_mode_dialog(display& disp)
{
const events::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 * const modes = SDL_ListModes(&format,FULL_SCREEN);
//the SDL documentation says that a return value of -1 if no dimension
//is available.
if(modes == reinterpret_cast<SDL_Rect**>(-1) || modes == NULL) {
if(modes != NULL)
std::cerr << "Can support any video mode\n";
else
std::cerr << "No modes supported\n";
gui::show_dialog(disp,NULL,"",_("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;
for(std::vector<std::pair<int,int> >::const_iterator j = resolutions.begin(); j != resolutions.end(); ++j) {
std::ostringstream option;
if (*j == current_res)
option << DEFAULT_ITEM;
option << j->first << "x" << j->second;
options.push_back(option.str());
}
const int result = gui::show_dialog(disp,NULL,"",
_("Choose Resolution"),
gui::OK_CANCEL,&options);
if(size_t(result) < resolutions.size() && resolutions[result] != current_res) {
set_resolution(resolutions[result]);
return true;
} else {
return false;
}
}
void show_hotkeys_dialog (display & disp, config *save_config)
{
log_scope ("show_hotkeys_dialog");
const events::event_context dialog_events_context;
const int centerx = disp.x()/2;
const int centery = disp.y()/2;
#ifdef USE_TINY_GUI
const int width = 300; // FIXME: should compute this, but using what data ?
const int height = 220;
#else
const int width = 700;
const int height = 500;
#endif
const int xpos = centerx - width/2;
const int ypos = centery - height/2;
gui::button close_button (disp.video(), _("Close Window"));
std::vector<gui::button*> buttons;
buttons.push_back(&close_button);
surface_restorer restorer;
gui::draw_dialog(xpos,ypos,width,height,disp.video(),_("Hotkey Settings"),NULL,&buttons,&restorer);
SDL_Rect clip_rect = { 0, 0, disp.x (), disp.y () };
SDL_Rect text_size = font::draw_text(NULL, clip_rect, font::SIZE_PLUS,
font::NORMAL_COLOUR,_("Press desired HotKey"),
0, 0);
std::vector<std::string> menu_items;
std::vector<hotkey::hotkey_item>& hotkeys = hotkey::get_hotkeys();
for(std::vector<hotkey::hotkey_item>::iterator i = hotkeys.begin(); i != hotkeys.end(); ++i) {
if(i->hidden())
continue;
std::stringstream str,name;
name << i->get_description();
str << name.str();
str << COLUMN_SEPARATOR;
str << i->get_name();
menu_items.push_back(str.str());
}
std::ostringstream heading;
heading << HEADING_PREFIX << _("Action") << COLUMN_SEPARATOR << _("Binding");
menu_items.push_back(heading.str());
gui::menu::basic_sorter sorter;
sorter.set_alpha_sort(0).set_alpha_sort(1);
gui::menu menu_(disp.video(), menu_items, false, height, -1, &sorter);
menu_.sort_by(0);
menu_.reset_selection();
menu_.set_width(font::relative_size(400));
menu_.set_location(xpos + font::relative_size(20), ypos);
gui::button change_button (disp.video(), _("Change Hotkey"));
change_button.set_location(xpos + width - change_button.width () - font::relative_size(30),ypos + font::relative_size(80));
gui::button save_button (disp.video(), _("Save Hotkeys"));
save_button.set_location(xpos + width - save_button.width () - font::relative_size(30),ypos + font::relative_size(130));
for(;;) {
if (close_button.pressed())
break;
if (change_button.pressed ()) {
// Lets change this hotkey......
SDL_Rect dlgr = {centerx-text_size.w/2 - 30,
centery-text_size.h/2 - 16,
text_size.w+60,
text_size.h+32};
surface_restorer restorer(&disp.video(),dlgr);
gui::draw_dialog_frame (centerx-text_size.w/2 - 20,
centery-text_size.h/2 - 6,
text_size.w+40,
text_size.h+12,disp.video());
font::draw_text (&disp.video(), clip_rect, font::SIZE_LARGE,font::NORMAL_COLOUR,
_("Press desired HotKey"),centerx-text_size.w/2-10,
centery-text_size.h/2-3);
disp.update_display();
SDL_Event event;
event.type = 0;
int key=0; //just to avoid warning
int mod=0;
while (event.type!=SDL_KEYDOWN) SDL_PollEvent(&event);
do {
if (event.type==SDL_KEYDOWN)
{
key=event.key.keysym.sym;
mod=event.key.keysym.mod;
};
SDL_PollEvent(&event);
disp.flip();
SDL_Delay(10);
} while (event.type!=SDL_KEYUP);
restorer.restore();
disp.update_display();
const hotkey::hotkey_item& oldhk = hotkey::get_hotkey(key, (mod & KMOD_SHIFT) != 0,
(mod & KMOD_CTRL) != 0, (mod & KMOD_ALT) != 0, (mod & KMOD_LMETA) != 0);
hotkey::hotkey_item& newhk = hotkey::get_visible_hotkey(menu_.selection());
if(oldhk.get_id() != newhk.get_id() && !oldhk.null()) {
gui::show_dialog(disp,NULL,"",_("This HotKey is already in use."),gui::MESSAGE);
} else {
newhk.set_key(key, (mod & KMOD_SHIFT) != 0,
(mod & KMOD_CTRL) != 0, (mod & KMOD_ALT) != 0, (mod & KMOD_LMETA) != 0);
menu_.change_item(menu_.selection(), 1, newhk.get_name());
};
}
if (save_button.pressed()) {
if (save_config == NULL) {
hotkey::save_hotkeys(prefs);
} else {
hotkey::save_hotkeys(*save_config);
}
}
menu_.process();
events::pump();
events::raise_process_event();
events::raise_draw_event();
disp.update_display();
SDL_Delay(10);
}
}
bool green_confirm()
{
std::string confirmation = prefs["confirm_end_turn"];
@ -1469,4 +769,12 @@ bool confirm_no_moves()
return confirmation == "no_moves" || confirmation.empty();
}
void load_hotkeys() {
hotkey::load_hotkeys(prefs);
}
void save_hotkeys() {
hotkey::save_hotkeys(prefs);
}
}

30
src/preferences.hpp
View file

@ -37,20 +37,18 @@ namespace preferences {
~manager();
};
struct display_manager
{
display_manager(display* disp);
~display_manager();
};
// low-level, should be seen only by preferences_display ?
void set(std::string key, std::string value);
std::string get(const std::string key);
bool fullscreen();
void set_fullscreen(bool ison);
void _set_fullscreen(bool ison);
std::pair<int,int> resolution();
void set_resolution(const std::pair<int,int>& res);
void _set_resolution(const std::pair<int,int>& res);
bool turbo();
void set_turbo(bool ison);
void _set_turbo(bool ison);
const std::string& language();
void set_language(const std::string& s);
@ -73,13 +71,13 @@ namespace preferences {
bool is_muted();
bool adjust_gamma();
void set_adjust_gamma(bool val);
void _set_adjust_gamma(bool val);
int gamma();
void set_gamma(int gamma);
void _set_gamma(int gamma);
bool grid();
void set_grid(bool ison);
void _set_grid(bool ison);
const std::string& official_network_host();
@ -182,16 +180,16 @@ namespace preferences {
void set_theme(const std::string& theme);
const std::string& theme();
void show_preferences_dialog(display& disp, const config& game_cfg);
bool show_video_mode_dialog(display& disp);
// If prefs is non-null, save the hotkeys in that config instead of
// the default.
void show_hotkeys_dialog (display & disp, config *prefs=NULL);
bool compare_resolutions(const std::pair<int,int>& lhs, const std::pair<int,int>& rhs);
// Ask for end turn confirmation
bool yellow_confirm();
bool green_confirm();
bool confirm_no_moves();
// proxies for preferences_dialog
void load_hotkeys();
void save_hotkeys();
}
#endif

755
src/preferences_display.cpp Normal file
View file

@ -0,0 +1,755 @@
/* $Id$ */
/*
Copyright (C) 2003-5 by David White <davidnwhite@verizon.net>
Part of the Battle for Wesnoth Project http://www.wesnoth.org/
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY.
See the COPYING file for more details.
*/
#include "global.hpp"
#include "display.hpp"
#include "gettext.hpp"
#include "hotkeys.hpp"
#include "marked-up_text.hpp"
#include "preferences_display.hpp"
#include "show_dialog.hpp"
#include "video.hpp"
#include "wml_separators.hpp"
#include "widgets/button.hpp"
#include "widgets/label.hpp"
#include "widgets/menu.hpp"
#include "widgets/slider.hpp"
namespace preferences {
display* disp = NULL;
display_manager::display_manager(display* d)
{
disp = d;
load_hotkeys();
set_grid(grid());
set_turbo(turbo());
set_fullscreen(fullscreen());
set_gamma(gamma());
}
display_manager::~display_manager()
{
disp = NULL;
}
void set_fullscreen(bool ison)
{
_set_fullscreen(ison);
if(disp != NULL) {
const std::pair<int,int>& res = resolution();
CVideo& video = disp->video();
if(video.isFullScreen() != ison) {
const int flags = ison ? FULL_SCREEN : 0;
const int bpp = video.modePossible(res.first,res.second,16,flags);
if(bpp > 0) {
video.setMode(res.first,res.second,bpp,flags);
disp->redraw_everything();
} else if(video.modePossible(1024,768,16,flags)) {
set_resolution(std::pair<int,int>(1024,768));
} else {
gui::show_dialog(*disp,NULL,"",_("The video mode could not be changed. Your window manager must be set to 16 bits per pixel to run the game in windowed mode. Your display must support 1024x768x16 to run the game full screen."),
gui::MESSAGE);
}
}
}
}
void set_resolution(const std::pair<int,int>& resolution)
{
std::pair<int,int> res = resolution;
// - Ayin: disabled the following code. Why would one want to enforce that?
// Some 16:9, or laptop screens, may have resolutions which do not
// comply to this rule (see bug 10630). I'm commenting this until it
// proves absolutely necessary.
//
//make sure resolutions are always divisible by 4
//res.first &= ~3;
//res.second &= ~3;
bool write_resolution = true;
if(disp != NULL) {
CVideo& video = disp->video();
const int flags = fullscreen() ? FULL_SCREEN : 0;
const int bpp = video.modePossible(res.first,res.second,16,flags);
if(bpp != 0) {
video.setMode(res.first,res.second,bpp,flags);
disp->redraw_everything();
} else {
write_resolution = false;
gui::show_dialog(*disp,NULL,"",_("The video mode could not be changed. Your window manager must be set to 16 bits per pixel to run the game in windowed mode. Your display must support 1024x768x16 to run the game full screen."),gui::MESSAGE);
}
}
if(write_resolution) {
const std::string postfix = fullscreen() ? "resolution" : "windowsize";
preferences::set('x' + postfix, lexical_cast<std::string>(res.first));
preferences::set('y' + postfix, lexical_cast<std::string>(res.second));
}
}
void set_turbo(bool ison)
{
_set_turbo(ison);
if(disp != NULL) {
disp->set_turbo(ison);
}
}
void set_adjust_gamma(bool val)
{
//if we are turning gamma adjustment off, then set it to '1.0'
if(val == false && adjust_gamma()) {
CVideo& video = disp->video();
video.setGamma(1.0);
}
_set_adjust_gamma(val);
}
void set_gamma(int gamma)
{
_set_gamma(gamma);
if(adjust_gamma()) {
CVideo& video = disp->video();
video.setGamma((float)gamma / 100);
}
}
void set_grid(bool ison)
{
_set_grid(ison);
if(disp != NULL) {
disp->set_grid(ison);
}
}
namespace {
class preferences_dialog : public gui::preview_pane
{
public:
preferences_dialog(display& disp, const config& game_cfg);
struct video_mode_change_exception
{
enum TYPE { CHANGE_RESOLUTION, MAKE_FULLSCREEN, MAKE_WINDOWED };
video_mode_change_exception(TYPE type) : type(type)
{}
TYPE type;
};
private:
void process_event();
bool left_side() const { return false; }
void set_selection(int index);
void update_location(SDL_Rect const &rect);
const config* get_advanced_pref() const;
void set_advanced_menu();
gui::slider music_slider_, sound_slider_, scroll_slider_, gamma_slider_;
gui::button fullscreen_button_, turbo_button_, show_ai_moves_button_,
show_grid_button_, show_floating_labels_button_, turn_dialog_button_,
turn_bell_button_, show_team_colours_button_, show_colour_cursors_button_,
show_haloing_button_, video_mode_button_, hotkeys_button_, gamma_button_,
flip_time_button_, advanced_button_, sound_button_, music_button_;
gui::label music_label_, sound_label_, scroll_label_, gamma_label_;
unsigned slider_label_width_;
gui::menu advanced_;
int advanced_selection_;
enum TAB { GENERAL_TAB, DISPLAY_TAB, SOUND_TAB, ADVANCED_TAB };
TAB tab_;
display &disp_;
const config& game_cfg_;
};
preferences_dialog::preferences_dialog(display& disp, const config& game_cfg)
: gui::preview_pane(disp.video()),
music_slider_(disp.video()), sound_slider_(disp.video()),
scroll_slider_(disp.video()), gamma_slider_(disp.video()),
fullscreen_button_(disp.video(), _("Toggle Full Screen"), gui::button::TYPE_CHECK),
turbo_button_(disp.video(), _("Accelerated Speed"), gui::button::TYPE_CHECK),
show_ai_moves_button_(disp.video(), _("Skip AI Moves"), gui::button::TYPE_CHECK),
show_grid_button_(disp.video(), _("Show Grid"), gui::button::TYPE_CHECK),
show_floating_labels_button_(disp.video(), _("Show Floating Labels"), gui::button::TYPE_CHECK),
turn_dialog_button_(disp.video(), _("Turn Dialog"), gui::button::TYPE_CHECK),
turn_bell_button_(disp.video(), _("Turn Bell"), gui::button::TYPE_CHECK),
show_team_colours_button_(disp.video(), _("Show Team Colors"), gui::button::TYPE_CHECK),
show_colour_cursors_button_(disp.video(), _("Show Color Cursors"), gui::button::TYPE_CHECK),
show_haloing_button_(disp.video(), _("Show Haloing Effects"), gui::button::TYPE_CHECK),
video_mode_button_(disp.video(), _("Video Mode")),
hotkeys_button_(disp.video(), _("Hotkeys")),
gamma_button_(disp.video(), _("Adjust Gamma"), gui::button::TYPE_CHECK),
flip_time_button_(disp.video(), _("Reverse Time Graphics"), gui::button::TYPE_CHECK),
sound_button_(disp.video(), _("Sound effects"), gui::button::TYPE_CHECK),
music_button_(disp.video(), _("Music"), gui::button::TYPE_CHECK),
advanced_button_(disp.video(), "", gui::button::TYPE_CHECK),
music_label_(disp.video(), _("Music Volume:")), sound_label_(disp.video(), _("SFX Volume:")),
scroll_label_(disp.video(), _("Scroll Speed:")), gamma_label_(disp.video(), _("Gamma:")),
slider_label_width_(0), advanced_(disp.video(),std::vector<std::string>()), advanced_selection_(-1),
tab_(GENERAL_TAB), disp_(disp), game_cfg_(game_cfg)
{
// FIXME: this box should be vertically centered on the screen, but is not
#if USE_TINY_GUI
set_measurements(260, 220); // FIXME: should compute this, but using what data ?
#else
set_measurements(400, 400);
#endif
sound_button_.set_check(sound_on());
sound_button_.set_help_string(_("Sound effects on/off"));
sound_slider_.set_min(0);
sound_slider_.set_max(128);
sound_slider_.set_value(sound_volume());
sound_slider_.set_help_string(_("Change the sound effects volume"));
music_button_.set_check(music_on());
music_button_.set_help_string(_("Music on/off"));
music_slider_.set_min(0);
music_slider_.set_max(128);
music_slider_.set_value(music_volume());
music_slider_.set_help_string(_("Change the music volume"));
scroll_slider_.set_min(1);
scroll_slider_.set_max(100);
scroll_slider_.set_value(scroll_speed());
scroll_slider_.set_help_string(_("Change the speed of scrolling around the map"));
gamma_button_.set_check(adjust_gamma());
gamma_button_.set_help_string(_("Change the brightness of the display"));
gamma_slider_.set_min(50);
gamma_slider_.set_max(200);
gamma_slider_.set_value(gamma());
gamma_slider_.set_help_string(_("Change the brightness of the display"));
fullscreen_button_.set_check(fullscreen());
fullscreen_button_.set_help_string(_("Choose whether the game should run full screen or in a window"));
turbo_button_.set_check(turbo());
turbo_button_.set_help_string(_("Make units move and fight faster"));
show_ai_moves_button_.set_check(!show_ai_moves());
show_ai_moves_button_.set_help_string(_("Do not animate AI units moving"));
show_grid_button_.set_check(grid());
show_grid_button_.set_help_string(_("Overlay a grid onto the map"));
show_floating_labels_button_.set_check(show_floating_labels());
show_floating_labels_button_.set_help_string(_("Show text above a unit when it is hit to display damage inflicted"));
video_mode_button_.set_help_string(_("Change the resolution the game runs at"));
turn_dialog_button_.set_check(turn_dialog());
turn_dialog_button_.set_help_string(_("Display a dialog at the beginning of your turn"));
turn_bell_button_.set_check(turn_bell());
turn_bell_button_.set_help_string(_("Play a bell sound at the beginning of your turn"));
show_team_colours_button_.set_check(show_side_colours());
show_team_colours_button_.set_help_string(_("Show a colored circle around the base of each unit to show which side it is on"));
flip_time_button_.set_check(flip_time());
flip_time_button_.set_help_string(_("Choose whether the sun moves left-to-right or right-to-left"));
show_colour_cursors_button_.set_check(use_colour_cursors());
show_colour_cursors_button_.set_help_string(_("Use colored mouse cursors (may be slower)"));
show_haloing_button_.set_check(show_haloes());
show_haloing_button_.set_help_string(_("Use graphical special effects (may be slower)"));
hotkeys_button_.set_help_string(_("View and configure keyboard shortcuts"));
set_advanced_menu();
}
void preferences_dialog::update_location(SDL_Rect const &rect)
{
bg_register(rect);
const int border = font::relative_size(10);
#if USE_TINY_GUI
const int item_interline = 20;
#else
const int item_interline = 50;
#endif
// General tab
int ypos = rect.y;
scroll_label_.set_location(rect.x, ypos);
SDL_Rect scroll_rect = { rect.x + scroll_label_.width(), ypos,
rect.w - scroll_label_.width() - border, 0 };
scroll_slider_.set_location(scroll_rect);
ypos += item_interline; turbo_button_.set_location(rect.x, ypos);
ypos += item_interline; show_ai_moves_button_.set_location(rect.x, ypos);
ypos += item_interline; turn_dialog_button_.set_location(rect.x, ypos);
ypos += item_interline; turn_bell_button_.set_location(rect.x, ypos);
ypos += item_interline; show_team_colours_button_.set_location(rect.x, ypos);
ypos += item_interline; show_grid_button_.set_location(rect.x, ypos);
ypos += item_interline; hotkeys_button_.set_location(rect.x, ypos);
// Display tab
ypos = rect.y;
gamma_button_.set_location(rect.x, ypos);
ypos += item_interline;
gamma_label_.set_location(rect.x, ypos);
SDL_Rect gamma_rect = { rect.x + gamma_label_.width(), ypos,
rect.w - gamma_label_.width() - border, 0 };
gamma_slider_.set_location(gamma_rect);
ypos += item_interline; flip_time_button_.set_location(rect.x,ypos);
ypos += item_interline; show_floating_labels_button_.set_location(rect.x, ypos);
ypos += item_interline; show_colour_cursors_button_.set_location(rect.x, ypos);
ypos += item_interline; show_haloing_button_.set_location(rect.x, ypos);
ypos += item_interline; fullscreen_button_.set_location(rect.x, ypos);
ypos += item_interline; video_mode_button_.set_location(rect.x, ypos);
// Sound tab
slider_label_width_ = maximum<unsigned>(music_label_.width(), sound_label_.width());
ypos = rect.y;
sound_button_.set_location(rect.x, ypos);
ypos += item_interline;
sound_label_.set_location(rect.x, ypos);
const SDL_Rect sound_rect = { rect.x + slider_label_width_, ypos,
rect.w - slider_label_width_ - border, 0 };
sound_slider_.set_location(sound_rect);
ypos += item_interline;
music_button_.set_location(rect.x, ypos);
ypos += item_interline;
music_label_.set_location(rect.x, ypos);
const SDL_Rect music_rect = { rect.x + slider_label_width_, ypos,
rect.w - slider_label_width_ - border, 0 };
music_slider_.set_location(music_rect);
//Advanced tab
ypos = rect.y;
advanced_.set_location(rect.x,ypos);
advanced_.set_max_height(height()-100);
ypos += advanced_.height() + border;
advanced_button_.set_location(rect.x,ypos);
set_selection(tab_);
}
void preferences_dialog::process_event()
{
if (turbo_button_.pressed())
set_turbo(turbo_button_.checked());
if (show_ai_moves_button_.pressed())
set_show_ai_moves(!show_ai_moves_button_.checked());
if (show_grid_button_.pressed())
set_grid(show_grid_button_.checked());
if (show_floating_labels_button_.pressed())
set_show_floating_labels(show_floating_labels_button_.checked());
if (video_mode_button_.pressed())
throw video_mode_change_exception(video_mode_change_exception::CHANGE_RESOLUTION);
if (fullscreen_button_.pressed())
throw video_mode_change_exception(fullscreen_button_.checked()
? video_mode_change_exception::MAKE_FULLSCREEN
: video_mode_change_exception::MAKE_WINDOWED);
if (turn_bell_button_.pressed())
set_turn_bell(turn_bell_button_.checked());
if (turn_dialog_button_.pressed())
set_turn_dialog(turn_dialog_button_.checked());
if (show_team_colours_button_.pressed())
set_show_side_colours(show_team_colours_button_.checked());
if (hotkeys_button_.pressed())
show_hotkeys_dialog(disp_);
if (show_colour_cursors_button_.pressed())
set_colour_cursors(show_colour_cursors_button_.checked());
if (show_haloing_button_.pressed())
set_show_haloes(show_haloing_button_.checked());
if (gamma_button_.pressed()) {
set_adjust_gamma(gamma_button_.checked());
bool hide_gamma = !adjust_gamma();
gamma_slider_.hide(hide_gamma);
gamma_label_.hide(hide_gamma);
}
if (sound_button_.pressed()) {
if(!set_sound(sound_button_.checked()))
sound_button_.set_check(false);
}
set_sound_volume(sound_slider_.value());
if (music_button_.pressed()) {
if(!set_music(music_button_.checked()))
music_button_.set_check(false);
}
set_music_volume(music_slider_.value());
if (flip_time_button_.pressed())
set_flip_time(flip_time_button_.checked());
set_scroll_speed(scroll_slider_.value());
set_gamma(gamma_slider_.value());
if(advanced_.selection() != advanced_selection_) {
advanced_selection_ = advanced_.selection();
const config* const adv = get_advanced_pref();
if(adv != NULL) {
const config& pref = *adv;
advanced_button_.set_width(0);
advanced_button_.set_label(pref["name"]);
std::string value = preferences::get(pref["field"]);
if(value.empty()) {
value = pref["default"];
}
advanced_button_.set_check(value == "yes");
}
}
if(advanced_button_.pressed()) {
const config* const adv = get_advanced_pref();
if(adv != NULL) {
const config& pref = *adv;
preferences::set(pref["field"],
advanced_button_.checked() ? "yes" : "no");
set_advanced_menu();
}
}
}
const config* preferences_dialog::get_advanced_pref() const
{
const config::child_list& adv = game_cfg_.get_children("advanced_preference");
if(advanced_selection_ >= 0 && advanced_selection_ < int(adv.size())) {
return adv[advanced_selection_];
} else {
return NULL;
}
}
void preferences_dialog::set_advanced_menu()
{
std::vector<std::string> advanced_items;
const config::child_list& adv = game_cfg_.get_children("advanced_preference");
for(config::child_list::const_iterator i = adv.begin(); i != adv.end(); ++i) {
std::ostringstream str;
std::string field = preferences::get((**i)["field"]);
if(field.empty()) {
field = (**i)["default"];
}
if(field == "yes") {
field = _("yes");
} else if(field == "no") {
field = _("no");
}
str << (**i)["name"] << COLUMN_SEPARATOR << field;
advanced_items.push_back(str.str());
}
advanced_.set_items(advanced_items,true,true);
}
void preferences_dialog::set_selection(int index)
{
tab_ = TAB(index);
set_dirty();
bg_restore();
const bool hide_general = tab_ != GENERAL_TAB;
scroll_label_.hide(hide_general);
scroll_slider_.hide(hide_general);
turbo_button_.hide(hide_general);
show_ai_moves_button_.hide(hide_general);
turn_dialog_button_.hide(hide_general);
turn_bell_button_.hide(hide_general);
hotkeys_button_.hide(hide_general);
show_team_colours_button_.hide(hide_general);
show_grid_button_.hide(hide_general);
const bool hide_display = tab_ != DISPLAY_TAB, hide_gamma = hide_display || !adjust_gamma();
gamma_label_.hide(hide_gamma);
gamma_slider_.hide(hide_gamma);
gamma_button_.hide(hide_display);
show_floating_labels_button_.hide(hide_display);
show_colour_cursors_button_.hide(hide_display);
show_haloing_button_.hide(hide_display);
fullscreen_button_.hide(hide_display);
video_mode_button_.hide(hide_display);
flip_time_button_.hide(hide_display);
const bool hide_sound = tab_ != SOUND_TAB;
music_button_.hide(hide_sound);
music_label_.hide(hide_sound);
music_slider_.hide(hide_sound);
sound_button_.hide(hide_sound);
sound_label_.hide(hide_sound);
sound_slider_.hide(hide_sound);
const bool hide_advanced = tab_ != ADVANCED_TAB;
advanced_.hide(hide_advanced);
advanced_button_.hide(hide_advanced);
}
}
void show_preferences_dialog(display& disp, const config& game_cfg)
{
std::vector<std::string> items;
std::string const pre = IMAGE_PREFIX + std::string("icons/icon-");
char const sep = COLUMN_SEPARATOR;
items.push_back(pre + "general.png" + sep + sgettext("Prefs section^General"));
items.push_back(pre + "display.png" + sep + sgettext("Prefs section^Display"));
items.push_back(pre + "music.png" + sep + sgettext("Prefs section^Sound"));
items.push_back(pre + "advanced.png" + sep + sgettext("Advanced section^Advanced"));
for(;;) {
try {
const events::event_context dialog_events_context;
preferences_dialog dialog(disp,game_cfg);
std::vector<gui::preview_pane*> panes;
panes.push_back(&dialog);
gui::show_dialog(disp,NULL,_("Preferences"),"",gui::CLOSE_ONLY,&items,&panes);
return;
} catch(preferences_dialog::video_mode_change_exception& e) {
switch(e.type) {
case preferences_dialog::video_mode_change_exception::CHANGE_RESOLUTION:
show_video_mode_dialog(disp);
break;
case preferences_dialog::video_mode_change_exception::MAKE_FULLSCREEN:
set_fullscreen(true);
break;
case preferences_dialog::video_mode_change_exception::MAKE_WINDOWED:
set_fullscreen(false);
break;
}
if(items[1].empty() || items[1][0] != '*') {
items[1] = "*" + items[1];
}
}
}
}
bool show_video_mode_dialog(display& disp)
{
const events::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 * const modes = SDL_ListModes(&format,FULL_SCREEN);
//the SDL documentation says that a return value of -1 if no dimension
//is available.
if(modes == reinterpret_cast<SDL_Rect**>(-1) || modes == NULL) {
if(modes != NULL)
std::cerr << "Can support any video mode\n";
else
std::cerr << "No modes supported\n";
gui::show_dialog(disp,NULL,"",_("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;
for(std::vector<std::pair<int,int> >::const_iterator j = resolutions.begin(); j != resolutions.end(); ++j) {
std::ostringstream option;
if (*j == current_res)
option << DEFAULT_ITEM;
option << j->first << "x" << j->second;
options.push_back(option.str());
}
const int result = gui::show_dialog(disp,NULL,"",
_("Choose Resolution"),
gui::OK_CANCEL,&options);
if(size_t(result) < resolutions.size() && resolutions[result] != current_res) {
set_resolution(resolutions[result]);
return true;
} else {
return false;
}
}
void show_hotkeys_dialog (display & disp, config *save_config)
{
log_scope ("show_hotkeys_dialog");
const events::event_context dialog_events_context;
const int centerx = disp.x()/2;
const int centery = disp.y()/2;
#ifdef USE_TINY_GUI
const int width = 300; // FIXME: should compute this, but using what data ?
const int height = 220;
#else
const int width = 700;
const int height = 500;
#endif
const int xpos = centerx - width/2;
const int ypos = centery - height/2;
gui::button close_button (disp.video(), _("Close Window"));
std::vector<gui::button*> buttons;
buttons.push_back(&close_button);
surface_restorer restorer;
gui::draw_dialog(xpos,ypos,width,height,disp.video(),_("Hotkey Settings"),NULL,&buttons,&restorer);
SDL_Rect clip_rect = { 0, 0, disp.x (), disp.y () };
SDL_Rect text_size = font::draw_text(NULL, clip_rect, font::SIZE_PLUS,
font::NORMAL_COLOUR,_("Press desired HotKey"),
0, 0);
std::vector<std::string> menu_items;
std::vector<hotkey::hotkey_item>& hotkeys = hotkey::get_hotkeys();
for(std::vector<hotkey::hotkey_item>::iterator i = hotkeys.begin(); i != hotkeys.end(); ++i) {
if(i->hidden())
continue;
std::stringstream str,name;
name << i->get_description();
str << name.str();
str << COLUMN_SEPARATOR;
str << i->get_name();
menu_items.push_back(str.str());
}
std::ostringstream heading;
heading << HEADING_PREFIX << _("Action") << COLUMN_SEPARATOR << _("Binding");
menu_items.push_back(heading.str());
gui::menu::basic_sorter sorter;
sorter.set_alpha_sort(0).set_alpha_sort(1);
gui::menu menu_(disp.video(), menu_items, false, height, -1, &sorter);
menu_.sort_by(0);
menu_.reset_selection();
menu_.set_width(font::relative_size(400));
menu_.set_location(xpos + font::relative_size(20), ypos);
gui::button change_button (disp.video(), _("Change Hotkey"));
change_button.set_location(xpos + width - change_button.width () - font::relative_size(30),ypos + font::relative_size(80));
gui::button save_button (disp.video(), _("Save Hotkeys"));
save_button.set_location(xpos + width - save_button.width () - font::relative_size(30),ypos + font::relative_size(130));
for(;;) {
if (close_button.pressed())
break;
if (change_button.pressed ()) {
// Lets change this hotkey......
SDL_Rect dlgr = {centerx-text_size.w/2 - 30,
centery-text_size.h/2 - 16,
text_size.w+60,
text_size.h+32};
surface_restorer restorer(&disp.video(),dlgr);
gui::draw_dialog_frame (centerx-text_size.w/2 - 20,
centery-text_size.h/2 - 6,
text_size.w+40,
text_size.h+12,disp.video());
font::draw_text (&disp.video(), clip_rect, font::SIZE_LARGE,font::NORMAL_COLOUR,
_("Press desired HotKey"),centerx-text_size.w/2-10,
centery-text_size.h/2-3);
disp.update_display();
SDL_Event event;
event.type = 0;
int key=0; //just to avoid warning
int mod=0;
while (event.type!=SDL_KEYDOWN) SDL_PollEvent(&event);
do {
if (event.type==SDL_KEYDOWN)
{
key=event.key.keysym.sym;
mod=event.key.keysym.mod;
};
SDL_PollEvent(&event);
disp.flip();
SDL_Delay(10);
} while (event.type!=SDL_KEYUP);
restorer.restore();
disp.update_display();
const hotkey::hotkey_item& oldhk = hotkey::get_hotkey(key, (mod & KMOD_SHIFT) != 0,
(mod & KMOD_CTRL) != 0, (mod & KMOD_ALT) != 0, (mod & KMOD_LMETA) != 0);
hotkey::hotkey_item& newhk = hotkey::get_visible_hotkey(menu_.selection());
if(oldhk.get_id() != newhk.get_id() && !oldhk.null()) {
gui::show_dialog(disp,NULL,"",_("This HotKey is already in use."),gui::MESSAGE);
} else {
newhk.set_key(key, (mod & KMOD_SHIFT) != 0,
(mod & KMOD_CTRL) != 0, (mod & KMOD_ALT) != 0, (mod & KMOD_LMETA) != 0);
menu_.change_item(menu_.selection(), 1, newhk.get_name());
};
}
if (save_button.pressed()) {
if (save_config == NULL) {
save_hotkeys();
} else {
hotkey::save_hotkeys(*save_config);
}
}
menu_.process();
events::pump();
events::raise_process_event();
events::raise_draw_event();
disp.update_display();
SDL_Delay(10);
}
}
}

40
src/preferences_display.hpp Normal file
View file

@ -0,0 +1,40 @@
/* $Id$ */
/*
Copyright (C) 2003-5 by David White <davidnwhite@verizon.net>
Part of the Battle for Wesnoth Project http://www.wesnoth.org/
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY.
See the COPYING file for more details.
*/
#ifndef PREFERENCES_DISPLAY_HPP_INCLUDED
#define PREFERENCES_DISPLAY_HPP_INCLUDED
#include "preferences.hpp"
namespace preferences {
struct display_manager
{
display_manager(display* disp);
~display_manager();
};
void set_fullscreen(bool ison);
void set_resolution(const std::pair<int,int>& res);
void set_turbo(bool ison);
void set_adjust_gamma(bool val);
void set_gamma(int gamma);
void set_grid(bool ison);
void show_preferences_dialog(display& disp, const config& game_cfg);
bool show_video_mode_dialog(display& disp);
// If prefs is non-null, save the hotkeys in that config instead of
// the default.
void show_hotkeys_dialog (display & disp, config *prefs=NULL);
}
#endif

2
src/titlescreen.cpp
View file

@ -24,7 +24,7 @@
#include "gettext.hpp"
#include "log.hpp"
#include "marked-up_text.hpp"
#include "preferences.hpp"
#include "preferences_display.hpp"
#include "sdl_utils.hpp"
#include "show_dialog.hpp"
#include "titlescreen.hpp"