Logo Search packages:      
Sourcecode: wesnoth-1.7 version File versions  Download package

game_preferences_display.cpp

/* $Id: game_preferences_display.cpp 41038 2010-02-07 10:38:04Z noyga $ */
/*
   Copyright (C) 2003 - 2010 by David White <dave@whitevine.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 version 2
   or at your option any later version.
   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"

#define GETTEXT_DOMAIN "wesnoth-lib"

#include "display.hpp"
#include "filesystem.hpp"
#include "filechooser.hpp"
#include "foreach.hpp"
#include "gettext.hpp"
#include "gui/dialogs/transient_message.hpp"
#include "lobby_preferences.hpp"
#include "preferences_display.hpp"
#include "wml_separators.hpp"
#include "widgets/slider.hpp"
#include "formula_string_utils.hpp"


namespace preferences {

static void set_lobby_joins(int ison)
{
      _set_lobby_joins(ison);
}

static void set_sort_list(bool ison)
{
      _set_sort_list(ison);
}

static void set_iconize_list(bool ison)
{
      _set_iconize_list(ison);
}

namespace {

class preferences_parent_dialog : public gui::dialog
{
public:
      preferences_parent_dialog(display &disp) : dialog(disp, _("Preferences"),"",gui::CLOSE_ONLY),
            clear_buttons_(false) {}
      ~preferences_parent_dialog() {write_preferences();}
      void action(gui::dialog_process_info &info)
      {
            if(clear_buttons_) {
                  info.clear_buttons();
                  clear_buttons_ = false;
            }
      }
      void clear_buttons() { clear_buttons_ = true; }
private:
      bool clear_buttons_;
};

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;
      };

      virtual handler_vector handler_members();
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();
      void set_friends_menu();
      std::vector<std::string> friends_names_;

//
      // change
      gui::slider music_slider_, sound_slider_, UI_sound_slider_, bell_slider_,
                  scroll_slider_, chat_lines_slider_,
        buffer_size_slider_, idle_anim_slider_, autosavemax_slider_, advanced_slider_;
      gui::list_slider<double> turbo_slider_;
      gui::button fullscreen_button_, scroll_to_action_button_,turbo_button_, show_ai_moves_button_,
                  interrupt_when_ally_sighted_button_,
                  show_grid_button_, save_replays_button_, delete_saves_button_,
                  show_lobby_joins_button1_,
                  show_lobby_joins_button2_,
                  show_lobby_joins_button3_,
                  sort_list_by_group_button_, iconize_list_button_,
                  remember_pw_button_, mp_server_search_button_,
                  friends_list_button_, friends_back_button_,
                  friends_add_friend_button_, friends_add_ignore_button_,
                  friends_remove_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_,
                  theme_button_, hotkeys_button_,
                  flip_time_button_, advanced_button_, sound_button_,
                  music_button_, chat_timestamp_button_,
                  advanced_sound_button_, normal_sound_button_,
                  UI_sound_button_, sample_rate_button1_,
                  sample_rate_button2_, sample_rate_button3_,
                  confirm_sound_button_, idle_anim_button_;
      gui::label music_label_, sound_label_, UI_sound_label_, bell_label_,
                 scroll_label_, chat_lines_label_,
                 turbo_slider_label_, sample_rate_label_, buffer_size_label_,
                     idle_anim_slider_label_, autosavemax_slider_label_,
                     advanced_slider_label_;
      gui::textbox sample_rate_input_, friends_input_;

      unsigned slider_label_width_;

      gui::menu advanced_, friends_;
      int advanced_selection_, friends_selection_;

      enum TAB {  GENERAL_TAB, DISPLAY_TAB, SOUND_TAB, MULTIPLAYER_TAB, ADVANCED_TAB,
                        /*extra tab*/
                        ADVANCED_SOUND_TAB, FRIENDS_TAB};
      TAB tab_;
      display &disp_;
      const config& game_cfg_;
public:
      util::scoped_ptr<preferences_parent_dialog> parent;
};

//change
preferences_dialog::preferences_dialog(display& disp, const config& game_cfg)
      : gui::preview_pane(disp.video()),
        friends_names_(),
        music_slider_(disp.video()), sound_slider_(disp.video()),
        UI_sound_slider_(disp.video()), bell_slider_(disp.video()),
        scroll_slider_(disp.video()),
        chat_lines_slider_(disp.video()), buffer_size_slider_(disp.video()),
        idle_anim_slider_(disp.video()), autosavemax_slider_(disp.video()),
        advanced_slider_(disp.video()),
        turbo_slider_(disp.video()),


        fullscreen_button_(disp.video(), _("Full Screen"), gui::button::TYPE_CHECK),
        scroll_to_action_button_(disp.video(), _("Enable scroll tracking of unit actions"), 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),
        interrupt_when_ally_sighted_button_(disp.video(), _("Interrupt move when an ally is sighted"), gui::button::TYPE_CHECK),
        show_grid_button_(disp.video(), _("Show Grid"), gui::button::TYPE_CHECK),
        save_replays_button_(disp.video(), _("Save Replay on SP/MP Victory or MP Defeat"), gui::button::TYPE_CHECK),
        delete_saves_button_(disp.video(), _("Delete Auto-Saves on SP/MP Victory or MP Defeat"), gui::button::TYPE_CHECK),
        show_lobby_joins_button1_(disp.video(), _("Do Not Show Lobby Joins"), gui::button::TYPE_CHECK),
        show_lobby_joins_button2_(disp.video(), _("Show Lobby Joins Of Friends Only"), gui::button::TYPE_CHECK),
        show_lobby_joins_button3_(disp.video(), _("Show All Lobby Joins"), gui::button::TYPE_CHECK),
        sort_list_by_group_button_(disp.video(), _("Sort Lobby List"), gui::button::TYPE_CHECK),
        iconize_list_button_(disp.video(), _("Iconize Lobby List"), gui::button::TYPE_CHECK),
        remember_pw_button_(disp.video(), _("Save password to preferences (clear text)"), gui::button::TYPE_CHECK),
        mp_server_search_button_(disp.video(), _("Set path to wesnothd")),
        friends_list_button_(disp.video(), _("Friends List")),
        friends_back_button_(disp.video(), _("Multiplayer Options")),
        friends_add_friend_button_(disp.video(), _("Add As Friend")),
        friends_add_ignore_button_(disp.video(), _("Add As Ignore")),
        friends_remove_button_(disp.video(), _("Remove")),
        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(), _("Change Resolution")),
        theme_button_(disp.video(), _("Theme")),
        hotkeys_button_(disp.video(), _("Hotkeys")),
        flip_time_button_(disp.video(), _("Reverse Time Graphics"), gui::button::TYPE_CHECK),
        advanced_button_(disp.video(), "", gui::button::TYPE_CHECK),
        sound_button_(disp.video(), _("Sound effects"), gui::button::TYPE_CHECK),
        music_button_(disp.video(), _("Music"), gui::button::TYPE_CHECK),
        chat_timestamp_button_(disp.video(), _("Chat Timestamping"), gui::button::TYPE_CHECK),
        advanced_sound_button_(disp.video(), _("sound^Advanced Options")),
        normal_sound_button_(disp.video(), _("sound^Standard Options")),
        UI_sound_button_(disp.video(), _("User Interface Sounds"), gui::button::TYPE_CHECK),
        sample_rate_button1_(disp.video(), "22050", gui::button::TYPE_CHECK),
        sample_rate_button2_(disp.video(), "44100", gui::button::TYPE_CHECK),
        sample_rate_button3_(disp.video(), _("Custom"), gui::button::TYPE_CHECK),
        confirm_sound_button_(disp.video(), _("Apply")),
        idle_anim_button_(disp.video(), _("Show Unit Idle Animations"), gui::button::TYPE_CHECK),

        music_label_(disp.video(), _("Music Volume:")), sound_label_(disp.video(), _("SFX Volume:")),
        UI_sound_label_(disp.video(), _("UI Sound Volume:")),
        bell_label_(disp.video(), _("Bell Volume:")), scroll_label_(disp.video(), _("Scroll Speed:")),
        chat_lines_label_(disp.video(), ""),
        turbo_slider_label_(disp.video(), "", font::SIZE_SMALL ),
        sample_rate_label_(disp.video(), _("Sample Rate (Hz):")), buffer_size_label_(disp.video(), ""),
        idle_anim_slider_label_(disp.video(), _("Frequency:")),
        autosavemax_slider_label_(disp.video(), "", font::SIZE_SMALL),
        advanced_slider_label_(disp.video(), "", font::SIZE_SMALL),

        sample_rate_input_(disp.video(), 70),
        friends_input_(disp.video(), 170),

        slider_label_width_(0),
        advanced_(disp.video(),std::vector<std::string>(),false,-1,-1,NULL,&gui::menu::bluebg_style),
        friends_(disp.video(),std::vector<std::string>(),false,-1,-1,NULL,&gui::menu::bluebg_style),

        advanced_selection_(-1),
        friends_selection_(-1),

        tab_(GENERAL_TAB), disp_(disp), game_cfg_(game_cfg), parent(NULL)
{
      // FIXME: this box should be vertically centered on the screen, but is not
#ifdef USE_TINY_GUI
      set_measurements(180, 180);           // FIXME: should compute this, but using what data ?
#else
      set_measurements(465, 425);
#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"));

      // bell volume slider
      bell_slider_.set_min(0);
      bell_slider_.set_max(128);
      bell_slider_.set_value(bell_volume());
      bell_slider_.set_help_string(_("Change the bell volume"));

      UI_sound_button_.set_check(UI_sound_on());
      UI_sound_button_.set_help_string(_("Turn menu and button sounds on/off"));
      UI_sound_slider_.set_min(0);
      UI_sound_slider_.set_max(128);
      UI_sound_slider_.set_value(UI_volume());
      UI_sound_slider_.set_help_string(_("Change the sound volume for button clicks, etc."));

      sample_rate_label_.set_help_string(_("Change the sample rate"));
      std::string rate = lexical_cast<std::string>(sample_rate());
      if (rate == "22050")
            sample_rate_button1_.set_check(true);
      else if (rate == "44100")
            sample_rate_button2_.set_check(true);
      else
            sample_rate_button3_.set_check(true);
      sample_rate_input_.set_text(rate);
      sample_rate_input_.set_help_string(_("User defined sample rate"));
      confirm_sound_button_.enable(sample_rate_button3_.checked());

      buffer_size_slider_.set_min(0);
      buffer_size_slider_.set_max(3);
      int v = sound_buffer_size()/512 - 1;
      buffer_size_slider_.set_value(v);
      //avoid sound reset the first time we load advanced sound
      buffer_size_slider_.value_change();
      buffer_size_slider_.set_help_string(_("Change the buffer size"));
      std::stringstream buf;
      buf << _("Buffer Size: ") << sound_buffer_size();
      buffer_size_label_.set_text(buf.str());
      buffer_size_label_.set_help_string(_("Change the buffer size"));

      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"));

      chat_lines_slider_.set_min(1);
      chat_lines_slider_.set_max(20);
      chat_lines_slider_.set_value(chat_lines());
      chat_lines_slider_.set_help_string(_("Set the amount of chat lines shown"));
      // Have the tooltip appear over the static "Chat lines" label, too.
      chat_lines_label_.set_help_string(_("Set the amount of chat lines shown"));

      chat_timestamp_button_.set_check(chat_timestamping());
      chat_timestamp_button_.set_help_string(_("Add a timestamp to chat messages"));

      fullscreen_button_.set_check(fullscreen());
      fullscreen_button_.set_help_string(_("Choose whether the game should run full screen or in a window"));

      scroll_to_action_button_.set_check(scroll_to_action());
      scroll_to_action_button_.set_help_string(_("Should the map view scroll to a unit when an action or move is animated."));

      turbo_button_.set_check(turbo());
      turbo_button_.set_help_string(_("Make units move and fight faster"));

      //0.25 0.5 1 2 4 8 16
      std::vector< double > turbo_items;
      turbo_items.push_back(0.25);
      turbo_items.push_back(0.5);
      turbo_items.push_back(0.75);
      turbo_items.push_back(1);
      turbo_items.push_back(1.5);
      turbo_items.push_back(2);
      turbo_items.push_back(4);
      turbo_items.push_back(8);
      turbo_items.push_back(16);
      turbo_slider_.set_items(turbo_items);
      if(!turbo_slider_.select_item(turbo_speed())) {
            turbo_slider_.select_item(1);
      }
      turbo_slider_.set_help_string(_("Units move and fight speed"));

      idle_anim_button_.set_check(idle_anim());
      idle_anim_button_.set_help_string(_("Show unit idle animations"));

      // exponential scale (2^(n/10))
      idle_anim_slider_.set_min(-40);
      idle_anim_slider_.set_max(30);
      idle_anim_slider_.set_value(idle_anim_rate());
      idle_anim_slider_.set_help_string(_("Set the frequency of unit idle animations"));

      autosavemax_slider_.set_min(1); //at least one autosave is stored
      autosavemax_slider_.set_max(preferences::INFINITE_AUTO_SAVES);
      autosavemax_slider_.set_value(autosavemax());
      autosavemax_slider_.set_help_string(_("Set maximum number of automatic saves to be retained"));


      show_ai_moves_button_.set_check(!show_ai_moves());
      show_ai_moves_button_.set_help_string(_("Do not animate AI units moving"));

      interrupt_when_ally_sighted_button_.set_check(interrupt_when_ally_sighted());
      interrupt_when_ally_sighted_button_.set_help_string(("Sighting an allied unit interrupts your unit's movement"));

      save_replays_button_.set_check(save_replays());
      save_replays_button_.set_help_string(_("Save Replay on SP/MP Victory or MP Defeat"));

      delete_saves_button_.set_check(delete_saves());
      delete_saves_button_.set_help_string(_("Delete Auto-Saves on SP/MP Victory or MP Defeat"));
      show_grid_button_.set_check(grid());
      show_grid_button_.set_help_string(_("Overlay a grid onto the map"));

      sort_list_by_group_button_.set_check(sort_list());
      sort_list_by_group_button_.set_help_string(_("Sort the player list in the lobby by player groups"));

      iconize_list_button_.set_check(iconize_list());
      iconize_list_button_.set_help_string(_("Show icons in front of the player names in the lobby."));

      remember_pw_button_.set_check(remember_password());
      remember_pw_button_.set_help_string(_("Uncheck to delete the saved password (on exit)."));

      int lj = lobby_joins();
      show_lobby_joins_button1_.set_check(lj == SHOW_NONE);
      show_lobby_joins_button1_.set_help_string(_("Do not show messages about players joining the multiplayer lobby"));
      show_lobby_joins_button2_.set_check(lj == SHOW_FRIENDS);
      show_lobby_joins_button2_.set_help_string(_("Show messages about your friends joining the multiplayer lobby"));
      show_lobby_joins_button3_.set_check(lj == SHOW_ALL);
      show_lobby_joins_button3_.set_help_string(_("Show messages about all players joining the multiplayer lobby"));

      mp_server_search_button_.set_help_string(_("Find and set path to MP server to host LAN games."));
      friends_list_button_.set_help_string(_("View and edit your friends and ignores list"));
      friends_back_button_.set_help_string(_("Back to the multiplayer options"));
      friends_add_friend_button_.set_help_string(_("Add this username to your friends list"));
      friends_add_ignore_button_.set_help_string(_("Add this username to your ignores list"));
      friends_remove_button_.set_help_string(_("Remove this username from your list"));

      friends_input_.set_text("");
      friends_input_.set_help_string(_("Insert a username"));

      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"));
      theme_button_.set_help_string(_("Change the theme the game runs with"));

      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();
      set_friends_menu();
}

handler_vector preferences_dialog::handler_members()
{
      handler_vector h;
      h.push_back(&music_slider_);
      h.push_back(&sound_slider_);
      h.push_back(&bell_slider_);
      h.push_back(&UI_sound_slider_);
      h.push_back(&scroll_slider_);
      h.push_back(&chat_lines_slider_);
      h.push_back(&turbo_slider_);
      h.push_back(&idle_anim_slider_);
      h.push_back(&autosavemax_slider_);
      h.push_back(&buffer_size_slider_);
      h.push_back(&advanced_slider_);
      h.push_back(&fullscreen_button_);
      h.push_back(&scroll_to_action_button_);
      h.push_back(&turbo_button_);
      h.push_back(&idle_anim_button_);
      h.push_back(&show_ai_moves_button_);
      h.push_back(&interrupt_when_ally_sighted_button_);
      h.push_back(&save_replays_button_);
      h.push_back(&delete_saves_button_);
      h.push_back(&show_grid_button_);
      h.push_back(&sort_list_by_group_button_);
      h.push_back(&iconize_list_button_);
      h.push_back(&remember_pw_button_);
      h.push_back(&show_lobby_joins_button1_);
      h.push_back(&show_lobby_joins_button2_);
      h.push_back(&show_lobby_joins_button3_);
      h.push_back(&mp_server_search_button_);
      h.push_back(&friends_list_button_);
      h.push_back(&friends_back_button_);
      h.push_back(&friends_add_friend_button_);
      h.push_back(&friends_add_ignore_button_);
      h.push_back(&friends_remove_button_);
      h.push_back(&friends_input_);
      h.push_back(&show_floating_labels_button_);
      h.push_back(&turn_dialog_button_);
      h.push_back(&turn_bell_button_);
      h.push_back(&UI_sound_button_);
      h.push_back(&show_team_colours_button_);
      h.push_back(&show_colour_cursors_button_);
      h.push_back(&show_haloing_button_);
      h.push_back(&video_mode_button_);
      h.push_back(&theme_button_);
      h.push_back(&hotkeys_button_);
      h.push_back(&flip_time_button_);
      h.push_back(&advanced_button_);
      h.push_back(&sound_button_);
      h.push_back(&music_button_);
      h.push_back(&chat_timestamp_button_);
      h.push_back(&advanced_sound_button_);
      h.push_back(&normal_sound_button_);
      h.push_back(&sample_rate_button1_);
      h.push_back(&sample_rate_button2_);
      h.push_back(&sample_rate_button3_);
      h.push_back(&confirm_sound_button_);
      h.push_back(&music_label_);
      h.push_back(&sound_label_);
      h.push_back(&bell_label_);
      h.push_back(&UI_sound_label_);
      h.push_back(&scroll_label_);
      h.push_back(&turbo_slider_label_);
      h.push_back(&idle_anim_slider_label_);
      h.push_back(&autosavemax_slider_label_);
      h.push_back(&advanced_slider_label_);
      h.push_back(&chat_lines_label_);
      h.push_back(&sample_rate_label_);
      h.push_back(&buffer_size_label_);
      h.push_back(&sample_rate_input_);
      h.push_back(&advanced_);
      h.push_back(&friends_);
      return h;
}

void preferences_dialog::update_location(SDL_Rect const &rect)
{
      bg_register(rect);


      const int right_border = font::relative_size(10);
      const int horizontal_padding = 25;
#if USE_TINY_GUI
      const int top_border = 14;
      const int bottom_border = 0;
      const int short_interline = 20;
      const int item_interline = 20;
#else
      // please also check 800x600 resolution if you change these spacings
      const int top_border = 28;
      const int bottom_border = 10;
      const int short_interline = 21;
      const int item_interline = 40;
#endif
      const int bottom_row_y = rect.y + rect.h - bottom_border;

      // General tab
      int ypos = rect.y + top_border;
      scroll_label_.set_location(rect.x, ypos);
      SDL_Rect scroll_rect = { rect.x + scroll_label_.width(), ypos,
                                          rect.w - scroll_label_.width() - right_border, 0 };
      scroll_slider_.set_location(scroll_rect);
      ypos += item_interline; turbo_button_.set_location(rect.x, ypos);
      ypos += short_interline; turbo_slider_label_.set_location(rect.x + horizontal_padding, ypos);
      ypos += short_interline;
      SDL_Rect turbo_rect = { rect.x + horizontal_padding, ypos,
                                          rect.w - horizontal_padding - right_border, 0 };
      turbo_slider_.set_location(turbo_rect);
      ypos += item_interline; show_ai_moves_button_.set_location(rect.x, ypos);
      ypos += short_interline; turn_dialog_button_.set_location(rect.x, ypos);
      ypos += short_interline; interrupt_when_ally_sighted_button_.set_location(rect.x, ypos);
      ypos += item_interline; show_team_colours_button_.set_location(rect.x, ypos);
      ypos += short_interline; show_grid_button_.set_location(rect.x, ypos);
      ypos += item_interline; save_replays_button_.set_location(rect.x, ypos);
      ypos += short_interline; delete_saves_button_.set_location(rect.x, ypos);
      ypos += short_interline; autosavemax_slider_label_.set_location(rect.x, ypos);
      SDL_Rect autosavemax_rect = { rect.x, ypos+short_interline,
                          rect.w - right_border, 0};
      autosavemax_slider_.set_location(autosavemax_rect);
      hotkeys_button_.set_location(rect.x, bottom_row_y - hotkeys_button_.height());

      // Display tab
      ypos = rect.y + top_border;
      fullscreen_button_.set_location(rect.x, ypos);
      ypos += item_interline; scroll_to_action_button_.set_location(rect.x, ypos);
      ypos += item_interline; show_colour_cursors_button_.set_location(rect.x, ypos);
      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_haloing_button_.set_location(rect.x, ypos);
      ypos += item_interline; idle_anim_button_.set_location(rect.x, ypos);
      ypos += short_interline;
      idle_anim_slider_label_.set_location(rect.x, ypos);
      SDL_Rect idle_anim_rect = { rect.x + idle_anim_slider_label_.width(), ypos,
                                  rect.w - idle_anim_slider_label_.width() - right_border, 0 };
      idle_anim_slider_.set_location(idle_anim_rect);
      video_mode_button_.set_location(rect.x, bottom_row_y - video_mode_button_.height());
      theme_button_.set_location(rect.x + video_mode_button_.width() + 10,
                                 bottom_row_y - theme_button_.height());

      // Sound tab
      slider_label_width_ = std::max<unsigned>(music_label_.width(), sound_label_.width());
      slider_label_width_ = std::max<unsigned>(slider_label_width_, bell_label_.width());
      slider_label_width_ = std::max<unsigned>(slider_label_width_, UI_sound_label_.width());
      ypos = rect.y + top_border;
      sound_button_.set_location(rect.x, ypos);

      ypos += short_interline;
      sound_label_.set_location(rect.x, ypos);
      const SDL_Rect sound_rect = { rect.x + slider_label_width_, ypos,
                                                rect.w - slider_label_width_ - right_border, 0 };
      sound_slider_.set_location(sound_rect);

      ypos += item_interline;
      music_button_.set_location(rect.x, ypos);

      ypos += short_interline;
      music_label_.set_location(rect.x, ypos);
      const SDL_Rect music_rect = { rect.x + slider_label_width_, ypos,
                                                rect.w - slider_label_width_ - right_border, 0 };
      music_slider_.set_location(music_rect);

      ypos += item_interline; //Bell slider
      turn_bell_button_.set_location(rect.x, ypos);
      ypos += short_interline;
      bell_label_.set_location(rect.x, ypos);
      const SDL_Rect bell_rect = {rect.x + slider_label_width_, ypos,
                                                rect.w - slider_label_width_ - right_border, 0 };
      bell_slider_.set_location(bell_rect);

      ypos += item_interline; //UI sound slider
      UI_sound_button_.set_location(rect.x, ypos);
      ypos += short_interline;
      UI_sound_label_.set_location(rect.x, ypos);
      const SDL_Rect UI_sound_rect = {rect.x + slider_label_width_, ypos,
                                                rect.w - slider_label_width_ - right_border, 0 };
      UI_sound_slider_.set_location(UI_sound_rect);
      advanced_sound_button_.set_location(rect.x, bottom_row_y - advanced_sound_button_.height());


      //Advanced Sound tab
      ypos = rect.y + top_border;
      sample_rate_label_.set_location(rect.x, ypos);
      ypos += short_interline;
      int h_offset = rect.x + horizontal_padding;
      sample_rate_button1_.set_location(h_offset, ypos);
      ypos += short_interline;
      sample_rate_button2_.set_location(h_offset, ypos);
      ypos += short_interline;
      sample_rate_button3_.set_location(h_offset, ypos);
      h_offset += sample_rate_button3_.width() + 5;
      sample_rate_input_.set_location(h_offset, ypos);
      h_offset += sample_rate_input_.width() + 5;
      confirm_sound_button_.set_location(h_offset, ypos);

      ypos += item_interline;
      buffer_size_label_.set_location(rect.x, ypos);
      ypos += short_interline;
      SDL_Rect buffer_rect = {rect.x + horizontal_padding, ypos,
                                          rect.w - horizontal_padding - right_border, 0 };
      buffer_size_slider_.set_location(buffer_rect);
      ypos += item_interline;
      normal_sound_button_.set_location(rect.x, bottom_row_y - normal_sound_button_.height());


      // Multiplayer tab
      ypos = rect.y + top_border;
      chat_lines_label_.set_location(rect.x, ypos);
      ypos += short_interline;
      SDL_Rect chat_lines_rect = { rect.x + horizontal_padding, ypos,
                                                rect.w - horizontal_padding - right_border, 0 };
      chat_lines_slider_.set_location(chat_lines_rect);
      ypos += item_interline; chat_timestamp_button_.set_location(rect.x, ypos);
      ypos += item_interline; remember_pw_button_.set_location(rect.x, ypos);
      ypos += item_interline; sort_list_by_group_button_.set_location(rect.x, ypos);
      ypos += item_interline; iconize_list_button_.set_location(rect.x, ypos);

      ypos += item_interline; show_lobby_joins_button1_.set_location(rect.x, ypos);
      ypos += short_interline; show_lobby_joins_button2_.set_location(rect.x, ypos);
      ypos += short_interline; show_lobby_joins_button3_.set_location(rect.x, ypos);

      friends_list_button_.set_location(rect.x, bottom_row_y - friends_list_button_.height());

      mp_server_search_button_.set_location(rect.x + horizontal_padding + friends_list_button_.width(), bottom_row_y - mp_server_search_button_.height());

      //Friends tab
      ypos = rect.y + top_border;
      friends_input_.set_location(rect.x,ypos);

      friends_.set_location(rect.x,ypos + item_interline);
      friends_.set_max_height(height() - 100 - friends_back_button_.height());

      int friends_xpos;

      if (friends_.width() > friends_input_.width()) {
            friends_xpos = rect.x+  friends_.width() + 20;
      } else {
            friends_xpos = rect.x+  friends_input_.width() + 20;
      }
      friends_.set_max_width(friends_xpos - rect.x - 1);

      friends_add_friend_button_.set_location(friends_xpos,ypos);
      ypos += short_interline+3; friends_add_ignore_button_.set_location(friends_xpos,ypos);
      ypos += short_interline+3; friends_remove_button_.set_location(friends_xpos,ypos);
      friends_back_button_.set_location(rect.x, bottom_row_y - friends_back_button_.height());

      //Advanced tab
      ypos = rect.y + top_border;
      advanced_.set_location(rect.x,ypos);
      advanced_.set_max_height(height()-100);

      ypos += advanced_.height() + font::relative_size(14);

      advanced_button_.set_location(rect.x,ypos);
      advanced_slider_label_.set_location(rect.x,ypos);
      const SDL_Rect advanced_slider_rect = { rect.x, ypos+short_interline,
                        rect.w - right_border, 0};
      advanced_slider_.set_location(advanced_slider_rect);

      set_selection(tab_);
}

void preferences_dialog::process_event()
{
      if (tab_ == GENERAL_TAB) {
            if (turbo_button_.pressed()) {
                  set_turbo(turbo_button_.checked());
                  turbo_slider_.enable(turbo());
                  turbo_slider_label_.enable(turbo());
            }
            if (show_ai_moves_button_.pressed())
                  set_show_ai_moves(!show_ai_moves_button_.checked());
            if (interrupt_when_ally_sighted_button_.pressed())
                  set_interrupt_when_ally_sighted(interrupt_when_ally_sighted_button_.checked());
            if (show_grid_button_.pressed())
                  set_grid(show_grid_button_.checked());
            if (save_replays_button_.pressed())
                  set_save_replays(save_replays_button_.checked());
            if (delete_saves_button_.pressed())
                  set_delete_saves(delete_saves_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_);
                  parent->clear_buttons();
            }

            set_scroll_speed(scroll_slider_.value());
            set_autosavemax(autosavemax_slider_.value());
            set_turbo_speed(turbo_slider_.item_selected());

            std::stringstream buf;
            buf << _("Speed: ") << turbo_slider_.item_selected();
            turbo_slider_label_.set_text(buf.str());

            std::stringstream buf2;
            if (autosavemax_slider_.value() == preferences::INFINITE_AUTO_SAVES)
                  buf2 << _("Maximum Auto-Saves: ") << _("infinite");
            else
                  buf2 << _("Maximum Auto-Saves: ") << autosavemax_slider_.value();
            autosavemax_slider_label_.set_text(buf2.str());

            return;
      }

      if (tab_ == DISPLAY_TAB) {
            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 (theme_button_.pressed())
                  show_theme_dialog(disp_);
                  parent->clear_buttons();
            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 (scroll_to_action_button_.pressed())
                  set_scroll_to_action(scroll_to_action_button_.checked());
            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 (flip_time_button_.pressed())
                  set_flip_time(flip_time_button_.checked());
            if (idle_anim_button_.pressed()) {
                  const bool enable_idle_anim = idle_anim_button_.checked();
                  idle_anim_slider_label_.enable(enable_idle_anim);
                  idle_anim_slider_.enable(enable_idle_anim);
                  set_idle_anim(enable_idle_anim);
                  if (!enable_idle_anim)
                        idle_anim_slider_.set_value(0);
            }

            set_idle_anim_rate(idle_anim_slider_.value());

            return;
      }


      if (tab_ == SOUND_TAB) {
            if (turn_bell_button_.pressed()) {
                  if(!set_turn_bell(turn_bell_button_.checked()))
                        turn_bell_button_.set_check(false);
                  bell_slider_.enable(turn_bell());
                  bell_label_.enable(turn_bell());
            }
            if (sound_button_.pressed()) {
                  if(!set_sound(sound_button_.checked()))
                        sound_button_.set_check(false);
                  sound_slider_.enable(sound_on());
                  sound_label_.enable(sound_on());
            }
            if (UI_sound_button_.pressed()) {
                  if(!set_UI_sound(UI_sound_button_.checked()))
                        UI_sound_button_.set_check(false);
                  UI_sound_slider_.enable(UI_sound_on());
                  UI_sound_label_.enable(UI_sound_on());
            }
            set_sound_volume(sound_slider_.value());
            set_UI_volume(UI_sound_slider_.value());
            set_bell_volume(bell_slider_.value());

            if (music_button_.pressed()) {
                  if(!set_music(music_button_.checked()))
                        music_button_.set_check(false);
                  music_slider_.enable(music_on());
                  music_label_.enable(music_on());
            }
            set_music_volume(music_slider_.value());

            if (advanced_sound_button_.pressed())
                  set_selection(ADVANCED_SOUND_TAB);

            return;
      }

      if (tab_ == ADVANCED_SOUND_TAB) {
            bool apply = false;
            std::string rate;

            if (sample_rate_button1_.pressed()) {
                  if (sample_rate_button1_.checked()) {
                        sample_rate_button2_.set_check(false);
                        sample_rate_button3_.set_check(false);
                        confirm_sound_button_.enable(false);
                        apply = true;
                        rate = "22050";
                  } else
                        sample_rate_button1_.set_check(true);
            }
            if (sample_rate_button2_.pressed()) {
                  if (sample_rate_button2_.checked()) {
                        sample_rate_button1_.set_check(false);
                        sample_rate_button3_.set_check(false);
                        confirm_sound_button_.enable(false);
                        apply = true;
                        rate = "44100";
                  } else
                        sample_rate_button2_.set_check(true);
            }
            if (sample_rate_button3_.pressed()) {
                  if (sample_rate_button3_.checked()) {
                        sample_rate_button1_.set_check(false);
                        sample_rate_button2_.set_check(false);
                        confirm_sound_button_.enable(true);
                  } else
                        sample_rate_button3_.set_check(true);
            }
            if (confirm_sound_button_.pressed()) {
                  apply = true;
                  rate = sample_rate_input_.text();
            }

            if (apply)
                  try {
                  save_sample_rate(lexical_cast<unsigned int>(rate));
                  } catch (bad_lexical_cast&) {
                  }

            if (buffer_size_slider_.value_change()) {
                  const size_t buffer_size = 512 << buffer_size_slider_.value();
                  save_sound_buffer_size(buffer_size);
                  std::stringstream buf;
                  buf << _("Buffer Size: ") << buffer_size;
                  buffer_size_label_.set_text(buf.str());
            }

            if (normal_sound_button_.pressed())
                  set_selection(SOUND_TAB);

            return;
      }

      if (tab_ == MULTIPLAYER_TAB) {
            if (show_lobby_joins_button1_.pressed()) {
                  set_lobby_joins(SHOW_NONE);
                  show_lobby_joins_button1_.set_check(true);
                  show_lobby_joins_button2_.set_check(false);
                  show_lobby_joins_button3_.set_check(false);
            } else if (show_lobby_joins_button2_.pressed()) {
                  set_lobby_joins(SHOW_FRIENDS);
                  show_lobby_joins_button1_.set_check(false);
                  show_lobby_joins_button2_.set_check(true);
                  show_lobby_joins_button3_.set_check(false);
            } else if (show_lobby_joins_button3_.pressed()) {
                  set_lobby_joins(SHOW_ALL);
                  show_lobby_joins_button1_.set_check(false);
                  show_lobby_joins_button2_.set_check(false);
                  show_lobby_joins_button3_.set_check(true);
            }
            if (sort_list_by_group_button_.pressed())
                  set_sort_list(sort_list_by_group_button_.checked());
            if (iconize_list_button_.pressed())
                  set_iconize_list(iconize_list_button_.checked());
            if (remember_pw_button_.pressed())
                  set_remember_password(remember_pw_button_.checked());
            if (chat_timestamp_button_.pressed())
                  set_chat_timestamping(chat_timestamp_button_.checked());
            if (friends_list_button_.pressed())
                  set_selection(FRIENDS_TAB);

            if (mp_server_search_button_.pressed())
            {
                  std::string path = show_wesnothd_server_search(disp_);
                  if (!path.empty())
                  {
                        preferences::set_mp_server_program_name(path);
                  }
                  parent->clear_buttons();
            }

            set_chat_lines(chat_lines_slider_.value());

            //display currently select amount of chat lines
            std::stringstream buf;
            buf << _("Chat Lines: ") << chat_lines_slider_.value();
            chat_lines_label_.set_text(buf.str());

            return;
      }

      if (tab_ == FRIENDS_TAB) {
            if(friends_.double_clicked() || friends_.selection() != friends_selection_) {
                  friends_selection_ = friends_.selection();
                  std::stringstream ss;
                  ss << friends_names_[friends_.selection()];
                  if (ss.str() != "(empty list)") friends_input_.set_text(ss.str());
                  else friends_input_.set_text("");
            }
            if (friends_back_button_.pressed())
                  set_selection(MULTIPLAYER_TAB);

            if (friends_add_friend_button_.pressed()) {
                  if (preferences::add_friend(friends_input_.text())) {
                        friends_input_.clear();
                        set_friends_menu();
                  } else {
                        gui::dialog(disp_, "", _("Invalid username")).show();;
            }
        }
            if (friends_add_ignore_button_.pressed()) {
                  if (preferences::add_ignore(friends_input_.text())) {
                        friends_input_.clear();
                        set_friends_menu();
                  } else {
                        gui::dialog(disp_, "", _("Invalid username")).show();;
            }
        }
            if (friends_remove_button_.pressed()) {
                  std::string to_remove = friends_input_.text();
                  if(to_remove.empty() && friends_.selection() >= 0 && friends_names_[friends_.selection()] != "(empty list)") {
                        to_remove = friends_names_[friends_.selection()];
                  }
                  if(!to_remove.empty()) {
                        /** @todo Better to remove from a specific relation. */
                        preferences::remove_friend(to_remove);
                        preferences::remove_ignore(to_remove);
                        friends_input_.clear();
                        set_friends_menu();
            }
        }
            return;
      }

      if (tab_ == ADVANCED_TAB) {
            if(advanced_.selection() != advanced_selection_) {
                  advanced_selection_ = advanced_.selection();
                  const config* const adv = get_advanced_pref();
                  if(adv != NULL) {
                        const config& pref = *adv;
                        const std::string description = pref["description"];
                        std::string value = preferences::get(pref["field"]);
                        advanced_button_.hide(pref["type"] != "boolean");
                        const bool hide_int = pref["type"] != "int";
                        advanced_slider_.hide(hide_int);
                        advanced_slider_label_.hide(hide_int);
                        if(value.empty()) {
                              value = pref["default"];
                        }
                        if (pref["type"] == "boolean") {
                              advanced_button_.set_width(0);
                              advanced_button_.set_label(pref["name"]);
                              advanced_button_.set_check(value == "yes");
                              advanced_button_.set_help_string(description);
                        } else if (pref["type"] == "int") {
                              std::stringstream ss;
                              ss << pref["name"] << ": " << value;
                              advanced_slider_label_.set_text(ss.str());
                              advanced_slider_label_.set_help_string(description);
                              advanced_slider_.set_min(lexical_cast<int>(pref["min"]));
                              advanced_slider_.set_max(lexical_cast<int>(pref["max"]));
                              advanced_slider_.set_increment(lexical_cast_default<int>(pref["step"], 1));
                              advanced_slider_.set_value(lexical_cast<int>(value));
                              advanced_slider_.set_help_string(description);
                        }
                  }
            }

            const config* const adv = get_advanced_pref();
            if(advanced_button_.pressed()) {
                  if(adv != NULL) {
                        const config& pref = *adv;
                        preferences::set(pref["field"],
                                    advanced_button_.checked() ? "yes" : "no");
                        set_advanced_menu();
                  }
            }

            if(advanced_slider_.value_change()) {
                  if(adv != NULL) {
                        const config& pref = *adv;
                        preferences::set(pref["field"],
                                    str_cast(advanced_slider_.value()));
                        set_advanced_menu();
                        std::stringstream ss;
                        ss << pref["name"] << ": " << advanced_slider_.value();
                        advanced_slider_label_.set_text(ss.str());
                  }
            }

            return;
      }
}

const config* preferences_dialog::get_advanced_pref() const
{
      config::const_child_itors itors = game_cfg_.child_range("advanced_preference");
      int nb_prefs = std::distance(itors.first, itors.second);
      if (advanced_selection_ >= 0 && advanced_selection_ < nb_prefs) {
            std::advance(itors.first, advanced_selection_);
            return &*itors.first;
      } else {
            return NULL;
      }
}

void preferences_dialog::set_advanced_menu()
{
      std::vector<std::string> advanced_items;
      foreach (const config &adv, game_cfg_.child_range("advanced_preference"))
      {
            std::ostringstream str;
            std::string field = preferences::get(adv["field"]);
            if(field.empty()) {
                  field = adv["default"];
            }

            if(field == "yes") {
                  field = _("yes");
            } else if(field == "no") {
                  field = _("no");
            }

            str << adv["name"] << COLUMN_SEPARATOR << field;
            advanced_items.push_back(str.str());
      }

      advanced_.set_items(advanced_items,true,true);
}

void preferences_dialog::set_friends_menu()
{
      const std::set<std::string>& friends = preferences::get_friends();
      const std::set<std::string>& ignores = preferences::get_ignores();

      std::vector<std::string> friends_items;
      std::vector<std::string> friends_names;
      std::string const imgpre = IMAGE_PREFIX + std::string("misc/status-");

      std::set<std::string>::const_iterator i;
      for (i = friends.begin(); i != friends.end(); ++i)
      {
            friends_items.push_back(imgpre + "friend.png" + COLUMN_SEPARATOR
                        + *i + COLUMN_SEPARATOR + "friend");
            friends_names.push_back(*i);
      }
      for (i = ignores.begin(); i != ignores.end(); ++i)
      {
            friends_items.push_back(imgpre + "ignore.png" + COLUMN_SEPARATOR
                        + *i + COLUMN_SEPARATOR + "ignored");
            friends_names.push_back(*i);
      }
      if (friends_items.empty()) {
            friends_items.push_back(_("(empty list)"));
            friends_names.push_back("(empty list)");
      }
      friends_names_ = friends_names;
      friends_.set_items(friends_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);
      turbo_slider_label_.hide(hide_general);
      turbo_slider_.hide(hide_general);
      turbo_slider_label_.enable(turbo());
      turbo_slider_.enable(turbo());
      show_ai_moves_button_.hide(hide_general);
      turn_dialog_button_.hide(hide_general);
      interrupt_when_ally_sighted_button_.hide(hide_general);
      hotkeys_button_.hide(hide_general);
      show_team_colours_button_.hide(hide_general);
      show_grid_button_.hide(hide_general);
      save_replays_button_.hide(hide_general);
      delete_saves_button_.hide(hide_general);
      autosavemax_slider_label_.hide(hide_general);
      autosavemax_slider_label_.enable(!hide_general);
      autosavemax_slider_.hide(hide_general);
      autosavemax_slider_.enable(!hide_general);

      const bool hide_display = tab_ != DISPLAY_TAB;
      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);
      scroll_to_action_button_.hide(hide_display);
      idle_anim_button_.hide(hide_display);
      idle_anim_slider_label_.hide(hide_display);
      idle_anim_slider_label_.enable(idle_anim());
      idle_anim_slider_.hide(hide_display);
      idle_anim_slider_.enable(idle_anim());
      video_mode_button_.hide(hide_display);
      theme_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);
      UI_sound_button_.hide(hide_sound);
      UI_sound_label_.hide(hide_sound);
      UI_sound_slider_.hide(hide_sound);
      turn_bell_button_.hide(hide_sound);
      bell_label_.hide(hide_sound);
      bell_slider_.hide(hide_sound);
      music_slider_.enable(music_on());
      bell_slider_.enable(turn_bell());
      sound_slider_.enable(sound_on());
      UI_sound_slider_.enable(UI_sound_on());
      music_label_.enable(music_on());
      bell_label_.enable(turn_bell());
      sound_label_.enable(sound_on());
      UI_sound_label_.enable(UI_sound_on());
      advanced_sound_button_.hide(hide_sound);

      const bool hide_advanced_sound = tab_ != ADVANCED_SOUND_TAB;
      sample_rate_label_.hide(hide_advanced_sound);
      sample_rate_button1_.hide(hide_advanced_sound);
      sample_rate_button2_.hide(hide_advanced_sound);
      sample_rate_button3_.hide(hide_advanced_sound);
      sample_rate_input_.hide(hide_advanced_sound);
      confirm_sound_button_.hide(hide_advanced_sound);
      buffer_size_label_.hide(hide_advanced_sound);
      buffer_size_slider_.hide(hide_advanced_sound);
      normal_sound_button_.hide(hide_advanced_sound);

      const bool hide_multiplayer = tab_ != MULTIPLAYER_TAB;
      chat_lines_label_.hide(hide_multiplayer);
      chat_lines_slider_.hide(hide_multiplayer);
      chat_timestamp_button_.hide(hide_multiplayer);
      sort_list_by_group_button_.hide(hide_multiplayer);
      iconize_list_button_.hide(hide_multiplayer);
      remember_pw_button_.hide(hide_multiplayer);
      show_lobby_joins_button1_.hide(hide_multiplayer);
      show_lobby_joins_button2_.hide(hide_multiplayer);
      show_lobby_joins_button3_.hide(hide_multiplayer);
      friends_list_button_.hide(hide_multiplayer);
      mp_server_search_button_.hide(hide_multiplayer);

      const bool hide_friends = tab_ != FRIENDS_TAB;
      friends_.hide(hide_friends);
      friends_back_button_.hide(hide_friends);
      friends_add_friend_button_.hide(hide_friends);
      friends_add_ignore_button_.hide(hide_friends);
      friends_remove_button_.hide(hide_friends);
      friends_input_.hide(hide_friends);

      const bool hide_advanced = tab_ != ADVANCED_TAB;
      advanced_.hide(hide_advanced);
      const std::string adv_type = get_advanced_pref() != NULL ? (*get_advanced_pref())["type"] : "";
      const bool hide_advanced_bool = hide_advanced || adv_type != "boolean";
      const bool hide_advanced_int = hide_advanced || adv_type != "int";
      advanced_button_.hide(hide_advanced_bool);
      advanced_slider_label_.hide(hide_advanced_int);
      advanced_slider_.hide(hide_advanced_int);
}

}

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 + "multiplayer.png" + sep + sgettext("Prefs section^Multiplayer"));
      items.push_back(pre + "advanced.png" + sep + sgettext("Advanced section^Advanced"));

      for(;;) {
            try {
                  preferences_dialog dialog(disp,game_cfg);
                  dialog.parent.assign(new preferences_parent_dialog(disp));
                  dialog.parent->set_menu(items);
                  dialog.parent->add_pane(&dialog);
                  dialog.parent->show();
                  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_theme_dialog(display& disp)
{
      int action = 0;
      std::vector<std::string> options = disp.get_theme().get_known_themes();
      if(!options.empty()){
            std::string current_theme=_("Saved Theme Preference: ")+preferences::theme();
            action = gui::show_dialog(disp,NULL,"",current_theme,gui::OK_CANCEL,&options);
            if(action >= 0){
            preferences::set_theme(options[action]);
            //it would be preferable for the new theme to take effect
            //immediately, however, this will have to do for now.
            gui2::show_transient_message(disp.video(),"",_("New theme will take effect on next new or loaded game."));
            return(1);
            }
      }else{
            gui2::show_transient_message(disp.video(),"",_("No known themes. Try changing from within an existing game."));
      }
      return(0);
}

std::string show_wesnothd_server_search(display& disp)
{
      // Showing file_chooser so user can search the wesnothd
      std::string old_path = preferences::get_mp_server_program_name();
      size_t offset = old_path.rfind("/");
      if (offset != std::string::npos)
      {
            old_path = old_path.substr(0, offset);
      }
      else
      {
            old_path = "";
      }
#ifndef _WIN32

#ifndef WESNOTH_PREFIX
#define WESNOTH_PREFIX "/usr"
#endif
      const std::string filename = "wesnothd";
      std::string path = WESNOTH_PREFIX + std::string("/bin");
      if (!is_directory(path))
            path = get_cwd();

#else
      const std::string filename = "wesnothd.exe";
      std::string path = get_cwd();
#endif
      if (!old_path.empty()
                  && is_directory(old_path))
      {
            path = old_path;
      }

      utils::string_map symbols;

      symbols["filename"] = filename;

      const std::string title = utils::interpolate_variables_into_string(
                    _("Find $filename server binary to host networked games")
                  , &symbols);

      int res = dialogs::show_file_chooser_dialog(disp, path, title, false, filename);
      if (res == 0)
            return path;
      else
            return "";
}


}

Generated by  Doxygen 1.6.0   Back to index