file_dialog::file_dialog(display &disp, const std::string& file_path,
const std::string& title, bool show_directory_buttons) :
gui::dialog(disp, title, file_path, gui::OK_CANCEL),
show_directory_buttons_(show_directory_buttons),
files_list_(NULL),
last_selection_(-1),
last_textbox_text_(),
chosen_file_(".."),
autocomplete_(true)
{
files_list_ = new gui::file_menu(disp.video(), file_path);
const unsigned file_list_height = (disp.h() / 2);
const unsigned file_list_width = std::min<unsigned>(files_list_->width(), (disp.w() / 4));
files_list_->set_measurements(file_list_width, file_list_height);
files_list_->set_max_height(file_list_height);
set_menu(files_list_);
get_message().set_text(format_dirname(files_list_->get_directory()));
set_textbox(_("File: "), format_filename(file_path), 100);
if (show_directory_buttons_)
{
add_button( new gui::dialog_button(disp.video(), _("Delete File"),
gui::button::TYPE_PRESS, gui::DELETE_ITEM), dialog::BUTTON_EXTRA);
add_button( new gui::dialog_button(disp.video(), _("New Folder"),
gui::button::TYPE_PRESS, gui::CREATE_ITEM), dialog::BUTTON_EXTRA_LEFT);
}
}
bool set_resolution(display& disp, const unsigned width, const unsigned height)
{
// - 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;
SDL_Rect rect;
SDL_GetClipRect(disp.video().getSurface(), &rect);
if (rect.w == width && rect.h == height) {
return true;
}
if (width < 480 || height < 320) {
return false;
}
CVideo& video = disp.video();
const int flags = fullscreen() ? SDL_WINDOW_FULLSCREEN : 0;
int bpp = video.modePossible(width, height, 32, flags);
VALIDATE(bpp > 0, "bpp must be large than 0!");
video.setMode(width, height, bpp, flags);
require_change_resolution = true;
const std::string postfix = fullscreen() ? "resolution" : "windowsize";
preferences::set('x' + postfix, lexical_cast<std::string>(width));
preferences::set('y' + postfix, lexical_cast<std::string>(height));
return true;
}
static void run_lobby_loop(display& disp, mp::ui& ui)
{
disp.video().modeChanged();
bool first = true;
font::cache_mode(font::CACHE_LOBBY);
while (ui.get_result() == mp::ui::CONTINUE) {
if (disp.video().modeChanged() || first) {
SDL_Rect lobby_pos = { 0, 0, disp.video().getx(), disp.video().gety() };
ui.set_location(lobby_pos);
first = false;
}
// process network data first so user actions can override the result
// or uptodate data can prevent invalid actions
// i.e. press cancel while you receive [start_game] or press start game while someone leaves
ui.process_network();
events::pump();
events::raise_process_event();
events::raise_draw_event();
disp.flip();
disp.delay(20);
}
font::cache_mode(font::CACHE_GAME);
}
leader_scroll_dialog(display &disp, const std::string &title,
std::vector<bool> &leader_bools, int selected,
gui::DIALOG_RESULT extra_result) :
dialog(disp, title, "", gui::NULL_DIALOG),
scroll_btn_(new gui::standard_dialog_button(disp.video(), _("Scroll To"), 0, false)),
leader_bools_(leader_bools),
extra_result_(extra_result)
{
scroll_btn_->enable(leader_bools[selected]);
add_button(scroll_btn_, gui::dialog::BUTTON_STANDARD);
add_button(new gui::standard_dialog_button(disp.video(),
_("Close"), 1, true), gui::dialog::BUTTON_STANDARD);
}
void play_replay(display& disp, game_state& gamestate, const config& game_config,
hero_map& heros, hero_map& heros_start, card_map& cards, CVideo& video)
{
std::string type = gamestate.classification().campaign_type;
if(type.empty())
type = "scenario";
// 'starting_pos' will contain the position we start the game from.
config starting_pos;
if (gamestate.starting_pos.empty()){
// Backwards compatibility code for 1.2 and 1.2.1
const config &scenario = game_config.find_child(type,"id",gamestate.classification().scenario);
assert(scenario);
gamestate.starting_pos = scenario;
}
starting_pos = gamestate.starting_pos;
//for replays, use the variables specified in starting_pos
if (const config &vars = starting_pos.child("variables")) {
gamestate.set_variables(vars);
}
try {
// Preserve old label eg. replay
if (gamestate.classification().label.empty())
gamestate.classification().label = starting_pos["name"].str();
//if (gamestate.abbrev.empty())
// gamestate.abbrev = (*scenario)["abbrev"];
play_replay_level(game_config, &starting_pos, video, gamestate, heros, heros_start, cards);
gamestate.snapshot = config();
recorder.clear();
gamestate.replay_data.clear();
gamestate.start_scenario_ss.str("");
// gamestate.start_hero_ss.str("");
gamestate.clear_start_hero_data();
} catch(game::load_game_failed& e) {
gui2::show_error_message(disp.video(), _("The game could not be loaded: ") + e.message);
} catch(game::game_error& e) {
gui2::show_error_message(disp.video(), _("Error while playing the game: ") + e.message);
} catch(incorrect_map_format_error& e) {
gui2::show_error_message(disp.video(), std::string(_("The game map could not be loaded: ")) + e.message);
} catch(twml_exception& e) {
e.show(disp);
}
}
static LEVEL_RESULT playmp_scenario(const config& game_config,
config const* level, display& disp, game_state& state_of_game, hero_map& heros, hero_map& heros_start,
card_map& cards,
const config::const_child_itors &story, bool skip_replay,
io_type_t& io_type, end_level_data &end_level)
{
const int ticks = SDL_GetTicks();
int num_turns = (*level)["turns"].to_int();
playmp_controller playcontroller(*level, state_of_game, heros, heros_start, cards,
ticks, num_turns, game_config, disp.video(), skip_replay, io_type == IO_SERVER);
LEVEL_RESULT res = playcontroller.play_scenario(story, skip_replay);
playcontroller.get_end_level_data().result = res;
end_level = playcontroller.get_end_level_data();
//Check if the player started as mp client and changed to host
if (io_type == IO_CLIENT && playcontroller.is_host())
io_type = IO_SERVER;
if (res == DEFEAT) {
if (resources::persist != NULL)
resources::persist->end_transaction();
gui2::show_transient_message(disp.video(),
_("Defeat"),
_("You have been defeated!")
);
}
if (res != QUIT) {
if (!end_level.linger_mode) {
if(!playcontroller.is_host()) {
// If we continue without lingering we need to
// make sure the host uploads the next scenario
// before we attempt to download it.
playcontroller.wait_for_upload();
}
} else {
try {
playcontroller.linger();
} catch(end_level_exception& e) {
if (e.result == QUIT) {
return QUIT;
}
}
}
}
return res;
}
terrain_palette::terrain_palette(display &gui, const size_specs &sizes,
const config& cfg,
t_translation::t_terrain& fore,
t_translation::t_terrain& back)
: gui::widget(gui.video())
, size_specs_(sizes)
, gui_(gui)
, tstart_(0)
, terrain_map_()
, terrains_()
, terrain_groups_()
, non_core_terrains_()
, checked_group_btn_(0)
, top_button_(gui.video(), "", gui::button::TYPE_PRESS, "uparrow-button")
, bot_button_(gui.video(), "", gui::button::TYPE_PRESS, "downarrow-button")
, button_x_()
, top_button_y_()
, bot_button_y_()
, nterrains_()
, nmax_terrains_()
, terrain_start_()
, selected_fg_terrain_(fore)
, selected_bg_terrain_(back)
{
// Get the available terrains temporary in terrains_
terrains_ = map().get_terrain_list();
//move "invalid" terrains to the end
std::stable_partition(terrains_.begin(), terrains_.end(), is_valid_terrain);
// Get the available groups and add them to the structure
std::set<std::string> group_names;
foreach (const config &g, cfg.child_range("editor_group"))
{
if (group_names.find(g["id"]) == group_names.end()) {
terrain_groups_.push_back(terrain_group(g, gui));
group_names.insert(terrain_groups_.back().id);
// By default the 'all'-button is pressed
if(terrain_groups_.back().id == "all") {
terrain_groups_.back().button.set_check(true);
checked_group_btn_ = &terrain_groups_.back().button;
}
}
}
std::map<std::string, terrain_group*> id_to_group;
foreach (terrain_group& tg, terrain_groups_) {
id_to_group.insert(std::make_pair(tg.id, &tg));
}
part_ui::part_ui(part &p, display &disp, gui::button &next_button,
gui::button &back_button, gui::button&play_button)
: events::sdl_handler(false)
, p_(p)
, disp_(disp)
, video_(disp.video())
, keys_()
, next_button_(next_button)
, back_button_(back_button)
, play_button_(play_button)
, dirty_(true)
, ret_(NEXT), skip_(false), last_key_(false)
, x_scale_factor_(1.0)
, y_scale_factor_(1.0)
, base_rect_()
#ifdef SDL_GPU
, background_images_()
, background_positions_()
#else
, background_(NULL)
#endif
, imgs_()
, has_background_(false)
, text_x_(200)
, text_y_(400)
, buttons_x_(0)
, buttons_y_(0)
{
}
void show_story(display& disp, const std::string& scenario_name, const config::const_child_itors& story)
{
const int total_segments = count_segments(story);
int segment_count = 0;
config::const_child_iterator itor = story.first;
// storyscreen::START_POSITION startpos = storyscreen::START_BEGINNING;
while (itor != story.second) {
gui2::tstory_screen dlg(*itor);
dlg.show(disp.video());
tstory_screen::legacy_result result = dlg.get_legacy_result();
switch (result) {
case tstory_screen::NEXT:
if (itor != story.second) {
++ itor;
++ segment_count;
// startpos = storyscreen::START_BEGINNING;
}
break;
case tstory_screen::BACK:
if (itor != story.first) {
-- itor;
-- segment_count;
// startpos = storyscreen::START_END;
}
break;
case tstory_screen::QUIT:
return;
}
}
}
part_ui::part_ui(part &p, display &disp, gui::button &next_button,
gui::button &back_button, gui::button&play_button)
: p_(p)
, disp_(disp)
, video_(disp.video())
, keys_()
, next_button_(next_button)
, back_button_(back_button)
, play_button_(play_button)
, ret_(NEXT), skip_(false), last_key_(false)
, x_scale_factor_(1.0)
, y_scale_factor_(1.0)
, base_rect_()
#ifdef SDL_GPU
, background_images_()
, background_positions_()
#else
, background_(NULL)
#endif
, imgs_()
, has_background_(false)
, text_x_(200)
, text_y_(400)
, buttons_x_(0)
, buttons_y_(0)
{
this->prepare_background();
this->prepare_geometry();
this->prepare_floating_images();
}
int recruit_dialog(display& disp, std::vector< const unit_type* >& units, const std::vector< std::string >& items, int side, const std::string& title_suffix)
{
dialogs::unit_types_preview_pane unit_preview(
units, NULL, side);
std::vector<gui::preview_pane*> preview_panes;
preview_panes.push_back(&unit_preview);
gui::menu::basic_sorter sorter;
sorter.set_alpha_sort(1);
gui::dialog rmenu(disp, _("Recruit") + title_suffix,
_("Select unit:") + std::string("\n"),
gui::OK_CANCEL,
gui::dialog::default_style);
rmenu.add_button(new help::help_button(disp, "recruit_and_recall"),
gui::dialog::BUTTON_HELP);
gui::menu::imgsel_style units_display_style(gui::menu::bluebg_style);
units_display_style.scale_images(font::relative_size(72), font::relative_size(72));
gui::menu* units_menu = new gui::menu(disp.video(), items, false, -1,
gui::dialog::max_menu_width, &sorter, &units_display_style, false);
units_menu->sort_by(1); // otherwise it's unsorted by default
rmenu.set_menu(units_menu);
rmenu.set_panes(preview_panes);
return rmenu.show();
}
void command_executor::show_menu(const std::vector<std::string>& items_arg, int xloc, int yloc, bool /*context_menu*/, display& gui)
{
std::vector<std::string> items = items_arg;
if (items.empty()) return;
std::vector<config> menu = get_menu_images(gui, items);
int res = -1;
{
SDL_Rect pos = {xloc, yloc, 1, 1};
gui2::tdrop_down_list mmenu(pos, menu, -1, false);
mmenu.show(gui.video());
if(mmenu.get_retval() == gui2::twindow::OK) {
res = mmenu.selected_item();
}
} // This will kill the dialog.
if (res < 0 || size_t(res) >= items.size()) return;
const theme::menu* submenu = gui.get_theme().get_menu_item(items[res]);
if (submenu) {
int y,x;
SDL_GetMouseState(&x,&y);
this->show_menu(submenu->items(), x, y, submenu->is_context(), gui);
} else {
const hotkey::hotkey_command& cmd = hotkey::get_hotkey_command(items[res]);
hotkey::execute_command(cmd,this,res);
set_button_state();
}
}
void command_executor::show_menu(const std::vector<std::string>& items_arg, int xloc, int yloc, bool /*context_menu*/, display& gui)
{
std::vector<std::string> items = items_arg;
if (items.empty()) return;
std::vector<std::string> menu = get_menu_images(gui, items);
int res = 0;
{
gui::dialog mmenu = gui::dialog(gui.video(),"","",
gui::MESSAGE, gui::dialog::hotkeys_style);
mmenu.set_menu(menu);
res = mmenu.show(xloc, yloc);
} // This will kill the dialog.
if (res < 0 || size_t(res) >= items.size()) return;
const theme::menu* submenu = gui.get_theme().get_menu_item(items[res]);
if (submenu) {
int y,x;
SDL_GetMouseState(&x,&y);
this->show_menu(submenu->items(), x, y, submenu->is_context(), gui);
} else {
const hotkey::hotkey_command& cmd = hotkey::get_hotkey_command(items[res]);
hotkey::execute_command(cmd,this,res);
set_button_state();
}
}
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);
}
help_browser::help_browser(display &disp, const section &toplevel) :
gui::widget(disp.video()),
disp_(disp),
menu_(disp.video(),
toplevel),
text_area_(disp.video(), toplevel), toplevel_(toplevel),
ref_cursor_(false),
back_topics_(),
forward_topics_(),
back_button_(disp.video(), _(" < Back"), gui::button::TYPE_PRESS),
forward_button_(disp.video(), _("Forward >"), gui::button::TYPE_PRESS),
shown_topic_(NULL)
{
// Hide the buttons at first since we do not have any forward or
// back topics at this point. They will be unhidden when history
// appears.
back_button_.hide(true);
forward_button_.hide(true);
// Set sizes to some default values.
set_measurements(font::relative_size(400), font::relative_size(500));
}
void lua_map_generator::user_config(display & disp)
{
lk_.set_video(&disp.video());
try {
lk_.user_config(user_config_.c_str(), generator_data_);
} catch (game::lua_error & e) {
std::string msg = "Error when running lua_map_generator user_config.\n";
msg += "The generator was: " + config_name_ + "\n";
msg += e.what();
throw mapgen_exception(msg);
}
}
void show_fail_tip(display& disp, const std::string& item)
{
std::stringstream err;
utils::string_map symbols;
symbols["mail"] = tintegrate::generate_format(game_config::service_email, "green");
symbols["date"] = tintegrate::generate_format(format_time_local2(time(NULL)), "yellow");
symbols["item"] = tintegrate::generate_format(item, "yellow");
symbols["username"] = tintegrate::generate_format(preferences::login(), "yellow");
err << vgettext2("Update database fail when execute In-App Purchase! In order to compensate data you should get, please send In-App Purchase information to $mail. In-App Purchase information include: date($date), item($item), username($username).", symbols);
gui2::show_message(disp.video(), "", err.str());
}
help_browser::help_browser(display &disp, const section &toplevel) :
gui::widget(disp.video()),
disp_(disp),
menu_(disp.video(),
toplevel),
text_area_(disp.video(), toplevel), toplevel_(toplevel),
ref_cursor_(false),
back_topics_(),
forward_topics_(),
back_button_(disp.video(), "", gui::button::TYPE_PRESS, "button_normal/button_small_H22", gui::button::DEFAULT_SPACE, true, "icons/arrows/long_arrow_ornate_left"),
forward_button_(disp.video(), "", gui::button::TYPE_PRESS, "button_normal/button_small_H22", gui::button::DEFAULT_SPACE, true, "icons/arrows/long_arrow_ornate_right"),
shown_topic_(NULL)
{
// Hide the buttons at first since we do not have any forward or
// back topics at this point. They will be unhidden when history
// appears.
back_button_.hide(true);
forward_button_.hide(true);
// Set sizes to some default values.
set_measurements(font::relative_size(400), font::relative_size(500));
}
void the_end(display &disp, std::string text, unsigned int duration)
{
//
// Some sane defaults.
//
if(text.empty())
text = _("The End");
if(!duration)
duration = 3500;
SDL_Rect area = screen_area();
CVideo &video = disp.video();
sdl_fill_rect(video.getSurface(),&area,0);
update_whole_screen();
disp.flip();
const size_t font_size = font::SIZE_XLARGE;
area = font::text_area(text,font_size);
area.x = screen_area().w/2 - area.w/2;
area.y = screen_area().h/2 - area.h/2;
for(size_t n = 0; n < 255; n += 5) {
if(n)
sdl_fill_rect(video.getSurface(),&area,0);
const SDL_Color col = create_color(n, n, n, n);
font::draw_text(&video,area,font_size,col,text,area.x,area.y);
update_rect(area);
events::pump();
events::raise_process_event();
events::raise_draw_event();
disp.flip();
disp.delay(10);
}
//
// Delay after the end of fading.
// Rounded to multiples of 10.
//
unsigned int count = duration/10;
while(count) {
events::pump();
events::raise_process_event();
events::raise_draw_event();
disp.flip();
disp.delay(10);
--count;
}
}
void twml_exception::show(display &disp)
{
std::ostringstream sstr;
// The extra spaces between the \n are needed, otherwise the dialog doesn't show
// an empty line.
sstr << _("An error due to possibly invalid WML occurred\nThe error message is :")
<< "\n" << user_message << "\n \n"
<< _("When reporting the bug please include the following error message :")
<< "\n" << dev_message;
gui2::show_error_message(disp.video(), sstr.str());
}
void key_event(display& disp, const SDL_KeyboardEvent& event, command_executor* executor)
{
if(event.keysym.sym == SDLK_ESCAPE && disp.in_game()) {
LOG_G << "escape pressed..showing quit\n";
const int res = gui2::show_message(disp.video(), _("Quit"), _("Do you really want to quit?"), gui2::tmessage::yes_no_buttons);
if(res != gui2::twindow::CANCEL) {
throw end_level_exception(QUIT);
} else {
return;
}
}
key_event_execute(disp,event,executor);
}
void set_fullscreen(display& disp, const bool ison)
{
_set_fullscreen(ison);
CVideo& video = disp.video();
const std::pair<int,int>& res = resolution();
if (video.isFullScreen() != ison) {
const int flags = ison ? SDL_WINDOW_FULLSCREEN: 0;
int bpp = video.modePossible(res.first, res.second, 32, flags);
VALIDATE(bpp > 0, "bpp must be large than 0!");
video.setMode(res.first, res.second,bpp, flags);
require_change_resolution = true;
}
}
static LEVEL_RESULT playsingle_scenario(const config& game_config,
const config* level, display& disp, game_state& state_of_game, hero_map& heros, hero_map& heros_start,
card_map& cards,
const config::const_child_itors &story,
bool skip_replay, end_level_data &end_level)
{
const int ticks = SDL_GetTicks();
int num_turns = (*level)["turns"].to_int();
playsingle_controller playcontroller(*level, state_of_game, heros, heros_start, cards, ticks, num_turns, game_config, disp.video(), skip_replay);
LEVEL_RESULT res = playcontroller.play_scenario(story, skip_replay);
playcontroller.get_end_level_data().result = res;
end_level = playcontroller.get_end_level_data();
if (res == DEFEAT) {
if (resources::persist != NULL) {
resources::persist->end_transaction();
}
gui2::show_transient_message(disp.video(),
_("Defeat"),
_("You have been defeated!")
);
}
if (res != QUIT && end_level.linger_mode)
{
try {
playcontroller.linger();
} catch(end_level_exception& e) {
if (e.result == QUIT) {
return QUIT;
}
}
}
return res;
}
terrain_group::terrain_group(const config& cfg, display& gui):
id(cfg["id"]), name(cfg["name"].t_str()),
button(gui.video(), "", gui::button::TYPE_CHECK, cfg["icon"]),
core(cfg["core"].to_bool())
{
}
void status_table(display& gui, int selected)
{
std::stringstream heading;
heading << HEADING_PREFIX << _("Leader") << COLUMN_SEPARATOR << ' ' << COLUMN_SEPARATOR
<< _("Team") << COLUMN_SEPARATOR
<< _("Gold") << COLUMN_SEPARATOR
<< _("Villages") << COLUMN_SEPARATOR
<< _("status^Units") << COLUMN_SEPARATOR
<< _("Upkeep") << COLUMN_SEPARATOR
<< _("Income");
gui::menu::basic_sorter sorter;
sorter.set_redirect_sort(0,1).set_alpha_sort(1).set_alpha_sort(2).set_numeric_sort(3)
.set_numeric_sort(4).set_numeric_sort(5).set_numeric_sort(6).set_numeric_sort(7);
std::vector<std::string> items;
std::vector<bool> leader_bools;
items.push_back(heading.str());
const gamemap& map = gui.get_map();
const unit_map& units = gui.get_units();
assert(&gui.get_teams() == resources::teams);
const std::vector<team>& teams = gui.get_teams();
const team& viewing_team = teams[gui.viewing_team()];
unsigned total_villages = 0;
// a variable to check if there are any teams to show in the table
bool status_table_empty = true;
//if the player is under shroud or fog, they don't get
//to see details about the other sides, only their own
//side, allied sides and a ??? is shown to demonstrate
//lack of information about the other sides But he see
//all names with in colors
for(size_t n = 0; n != teams.size(); ++n) {
if(teams[n].hidden()) {
continue;
}
status_table_empty=false;
const bool known = viewing_team.knows_about_team(n, network::nconnections() > 0);
const bool enemy = viewing_team.is_enemy(n+1);
std::stringstream str;
const team_data data = gui.get_disp_context().calculate_team_data(teams[n],n+1);
unit_map::const_iterator leader = units.find_leader(n + 1);
std::string leader_name;
//output the number of the side first, and this will
//cause it to be displayed in the correct color
if(leader != units.end()) {
const bool fogged = viewing_team.fogged(leader->get_location());
// Add leader image. If it's fogged
// show only a random leader image.
if (!fogged || known || game_config::debug) {
str << IMAGE_PREFIX << leader->absolute_image();
leader_bools.push_back(true);
leader_name = leader->name();
} else {
str << IMAGE_PREFIX << std::string("units/unknown-unit.png");
leader_bools.push_back(false);
leader_name = "Unknown";
}
// if (gamestate_.classification().campaign_type == game_classification::MULTIPLAYER)
// leader_name = teams[n].current_player();
#ifndef LOW_MEM
str << leader->image_mods();
#endif
} else {
leader_bools.push_back(false);
}
str << COLUMN_SEPARATOR << team::get_side_highlight(n)
<< leader_name << COLUMN_SEPARATOR
<< (data.teamname.empty() ? teams[n].team_name() : data.teamname)
<< COLUMN_SEPARATOR;
if(!known && !game_config::debug) {
// We don't spare more info (only name)
// so let's go on next side ...
items.push_back(str.str());
continue;
}
if(game_config::debug) {
str << utils::half_signed_value(data.gold) << COLUMN_SEPARATOR;
} else if(enemy && viewing_team.uses_fog()) {
str << ' ' << COLUMN_SEPARATOR;
} else {
str << utils::half_signed_value(data.gold) << COLUMN_SEPARATOR;
}
str << data.villages;
if(!(viewing_team.uses_fog() || viewing_team.uses_shroud())) {
str << "/" << map.villages().size();
}
str << COLUMN_SEPARATOR
<< data.units << COLUMN_SEPARATOR << data.upkeep << COLUMN_SEPARATOR
<< (data.net_income < 0 ? font::BAD_TEXT : font::NULL_MARKUP) << utils::signed_value(data.net_income);
total_villages += data.villages;
items.push_back(str.str());
}
if (total_villages > map.villages().size()) {
//TODO
// ERR_NG << "Logic error: map has " << map.villages().size()
// << " villages but status table shows " << total_villages << " owned in total\n";
}
if (status_table_empty)
{
// no sides to show - display empty table
std::stringstream str;
str << " ";
for (int i=0;i<7;++i)
str << COLUMN_SEPARATOR << " ";
leader_bools.push_back(false);
items.push_back(str.str());
}
int result = 0;
{
leader_scroll_dialog slist(gui, _("Current Status"), leader_bools, selected, gui::DIALOG_FORWARD);
slist.add_button(new gui::dialog_button(gui.video(), _("More >"),
gui::button::TYPE_PRESS, gui::DIALOG_FORWARD),
gui::dialog::BUTTON_EXTRA_LEFT);
slist.set_menu(items, &sorter);
slist.get_menu().move_selection(selected);
result = slist.show();
selected = slist.get_menu().selection();
} // this will kill the dialog before scrolling
if (result >= 0) {
//TODO
// gui.scroll_to_leader(units_, selected+1);
}
else if (result == gui::DIALOG_FORWARD)
scenario_settings_table(gui, selected);
}
void scenario_settings_table(display& gui, int selected)
{
std::stringstream heading;
heading << HEADING_PREFIX << _("scenario settings^Leader") << COLUMN_SEPARATOR
<< COLUMN_SEPARATOR
<< _("scenario settings^Side") << COLUMN_SEPARATOR
<< _("scenario settings^Start\nGold") << COLUMN_SEPARATOR
<< _("scenario settings^Base\nIncome") << COLUMN_SEPARATOR
<< _("scenario settings^Gold Per\nVillage") << COLUMN_SEPARATOR
<< _("scenario settings^Support Per\nVillage") << COLUMN_SEPARATOR
<< _("scenario settings^Fog") << COLUMN_SEPARATOR
<< _("scenario settings^Shroud");
gui::menu::basic_sorter sorter;
sorter.set_redirect_sort(0,1).set_alpha_sort(1).set_numeric_sort(2)
.set_numeric_sort(3).set_numeric_sort(4).set_numeric_sort(5)
.set_numeric_sort(6).set_alpha_sort(7).set_alpha_sort(8);
std::vector<std::string> items;
std::vector<bool> leader_bools;
items.push_back(heading.str());
//const gamemap& map = gui.get_map();
const unit_map& units = gui.get_units();
const std::vector<team>& teams = gui.get_teams();
const team& viewing_team = teams[gui.viewing_team()];
bool settings_table_empty = true;
bool fogged;
for(size_t n = 0; n != teams.size(); ++n) {
if(teams[n].hidden()) {
continue;
}
settings_table_empty = false;
std::stringstream str;
unit_map::const_iterator leader = units.find_leader(n + 1);
if(leader != units.end()) {
// Add leader image. If it's fogged
// show only a random leader image.
fogged=viewing_team.fogged(leader->get_location());
if (!fogged || viewing_team.knows_about_team(n, network::nconnections() > 0) || game_config::debug) {
str << IMAGE_PREFIX << leader->absolute_image();
leader_bools.push_back(true);
} else {
str << IMAGE_PREFIX << std::string("units/unknown-unit.png");
leader_bools.push_back(false);
}
#ifndef LOW_MEM
str << "~RC(" << leader->team_color() << '>'
<< team::get_side_color_index(n+1) << ")";
#endif
} else {
leader_bools.push_back(false);
}
str << COLUMN_SEPARATOR << team::get_side_highlight(n)
<< teams[n].current_player() << COLUMN_SEPARATOR
<< n + 1 << COLUMN_SEPARATOR
<< teams[n].start_gold() << COLUMN_SEPARATOR
<< teams[n].base_income() << COLUMN_SEPARATOR
<< teams[n].village_gold() << COLUMN_SEPARATOR
<< teams[n].village_support() << COLUMN_SEPARATOR
<< (teams[n].uses_fog() ? _("yes") : _("no")) << COLUMN_SEPARATOR
<< (teams[n].uses_shroud() ? _("yes") : _("no")) << COLUMN_SEPARATOR;
items.push_back(str.str());
}
if (settings_table_empty)
{
// no sides to show - display empty table
std::stringstream str;
for (int i=0;i<8;++i)
str << " " << COLUMN_SEPARATOR;
leader_bools.push_back(false);
items.push_back(str.str());
}
int result = 0;
{
leader_scroll_dialog slist(gui, _("Scenario Settings"), leader_bools, selected, gui::DIALOG_BACK);
slist.set_menu(items, &sorter);
slist.get_menu().move_selection(selected);
slist.add_button(new gui::dialog_button(gui.video(), _(" < Back"),
gui::button::TYPE_PRESS, gui::DIALOG_BACK),
gui::dialog::BUTTON_EXTRA_LEFT);
result = slist.show();
selected = slist.get_menu().selection();
} // this will kill the dialog before scrolling
if (result >= 0) {
//TODO
//gui_->scroll_to_leader(units_, selected+1);
}
else if (result == gui::DIALOG_BACK)
status_table(gui, selected);
}
int show_dialog(display& screen, surface image,
const std::string& caption, const std::string& message,
DIALOG_TYPE type,
const std::vector<std::string>* menu_items,
const std::vector<preview_pane*>* preview_panes,
const std::string& text_widget_label,
std::string* text_widget_text,
const int text_widget_max_chars,
std::vector<check_item>* options,
int xloc,
int yloc,
const dialog_frame::style* dialog_style,
std::vector<dialog_button_info>* action_buttons,
const menu::sorter* sorter,
menu::style* menu_style)
{
std::string title;
if (image.null()) title = caption;
const dialog::style& style = (dialog_style)? *dialog_style : dialog::default_style;
CVideo &disp = screen.video();
gui::dialog d(screen, title, message, type, style);
//add the components
if(!image.null()) {
d.set_image(image, caption);
}
if(menu_items) {
d.set_menu( new gui::menu(disp,*menu_items,type == MESSAGE,-1,dialog::max_menu_width,sorter,menu_style,false));
}
if(preview_panes) {
for(unsigned int i=0; i < preview_panes->size(); ++i) {
d.add_pane((*preview_panes)[i]);
}
}
if(text_widget_text) {
d.set_textbox(text_widget_label,*text_widget_text, text_widget_max_chars);
}
if(options) {
for(unsigned int i=0; i < options->size(); ++i) {
check_item& item = (*options)[i];
d.add_option(item.label, item.checked);
}
}
if(action_buttons) {
for(unsigned int i=0; i < action_buttons->size(); ++i) {
d.add_button((*action_buttons)[i]);
}
}
//enter the dialog loop
d.show(xloc, yloc);
//send back results
if(options) {
for(unsigned int i=0; i < options->size(); ++i)
{
(*options)[i].checked = d.option_checked(i);
}
}
if(text_widget_text) {
*text_widget_text = d.textbox_text();
}
return d.result();
}
void default_map_generator::user_config(display& disp)
{
const resize_lock prevent_resizing;
const events::event_context dialog_events_context;
CVideo& screen = disp.video();
const int width = 600;
const int height = 400;
const int xpos = screen.getx()/2 - width/2;
int ypos = screen.gety()/2 - height/2;
gui::button close_button(screen,_("Close"));
std::vector<gui::button*> buttons(1,&close_button);
gui::dialog_frame f(screen,_("Map Generator"),gui::dialog_frame::default_style,true,&buttons);
f.layout(xpos,ypos,width,height);
f.draw();
SDL_Rect dialog_rect = sdl::create_rect(xpos, ypos, width, height);
surface_restorer dialog_restorer(&screen,dialog_rect);
const std::string& players_label = _("Players:");
const std::string& width_label = _("Width:");
const std::string& height_label = _("Height:");
const std::string& iterations_label = _("Number of hills:");
const std::string& hillsize_label = _("Max hill size:");
const std::string& villages_label = _("Villages:");
const std::string& castlesize_label = _("Castle size:");
const std::string& landform_label = _("Landform:");
SDL_Rect players_rect = font::draw_text(NULL,screen_area(),font::SIZE_NORMAL,font::NORMAL_COLOR,players_label,0,0);
SDL_Rect width_rect = font::draw_text(NULL,screen_area(),font::SIZE_NORMAL,font::NORMAL_COLOR,width_label,0,0);
SDL_Rect height_rect = font::draw_text(NULL,screen_area(),font::SIZE_NORMAL,font::NORMAL_COLOR,height_label,0,0);
SDL_Rect iterations_rect = font::draw_text(NULL,screen_area(),font::SIZE_NORMAL,font::NORMAL_COLOR,iterations_label,0,0);
SDL_Rect hillsize_rect = font::draw_text(NULL,screen_area(),font::SIZE_NORMAL,font::NORMAL_COLOR,hillsize_label,0,0);
SDL_Rect villages_rect = font::draw_text(NULL,screen_area(),font::SIZE_NORMAL,font::NORMAL_COLOR,villages_label,0,0);
SDL_Rect castlesize_rect = font::draw_text(NULL,screen_area(),font::SIZE_NORMAL,font::NORMAL_COLOR,castlesize_label,0,0);
SDL_Rect landform_rect = font::draw_text(NULL,screen_area(),font::SIZE_NORMAL,font::NORMAL_COLOR,landform_label,0,0);
const int horz_margin = 15;
const int text_right = xpos + horz_margin +
std::max<int>(std::max<int>(std::max<int>(std::max<int>(std::max<int>(std::max<int>(
players_rect.w,width_rect.w),height_rect.w),iterations_rect.w),hillsize_rect.w),villages_rect.w),castlesize_rect.w);
players_rect.x = text_right - players_rect.w;
width_rect.x = text_right - width_rect.w;
height_rect.x = text_right - height_rect.w;
iterations_rect.x = text_right - iterations_rect.w;
hillsize_rect.x = text_right - hillsize_rect.w;
villages_rect.x = text_right - villages_rect.w;
castlesize_rect.x = text_right - castlesize_rect.w;
landform_rect.x = text_right - landform_rect.w;
const int vertical_margin = 20;
players_rect.y = ypos + vertical_margin*2;
width_rect.y = players_rect.y + players_rect.h + vertical_margin;
height_rect.y = width_rect.y + width_rect.h + vertical_margin;
iterations_rect.y = height_rect.y + height_rect.h + vertical_margin;
hillsize_rect.y = iterations_rect.y + iterations_rect.h + vertical_margin;
villages_rect.y = hillsize_rect.y + hillsize_rect.h + vertical_margin;
castlesize_rect.y = villages_rect.y + iterations_rect.h + vertical_margin;
landform_rect.y = castlesize_rect.y + villages_rect.h + vertical_margin;
const int right_space = 150;
const int slider_left = text_right + 10;
const int slider_right = xpos + width - horz_margin - right_space;
SDL_Rect slider_rect = sdl::create_rect(slider_left
, players_rect.y
, slider_right - slider_left
, players_rect.h);
gui::slider players_slider(screen);
players_slider.set_location(slider_rect);
players_slider.set_min(2);
players_slider.set_max(gamemap::MAX_PLAYERS);
players_slider.set_value(nplayers_);
const int min_width = 20;
const int max_width = 100;
const int max_height = 100;
const int extra_size_per_player = 2;
slider_rect.y = width_rect.y;
gui::slider width_slider(screen);
width_slider.set_location(slider_rect);
width_slider.set_min(min_width+(players_slider.value()-2)*extra_size_per_player);
width_slider.set_max(max_width);
width_slider.set_value(width_);
slider_rect.y = height_rect.y;
gui::slider height_slider(screen);
height_slider.set_location(slider_rect);
height_slider.set_min(min_width+(players_slider.value()-2)*extra_size_per_player);
height_slider.set_max(max_height);
height_slider.set_value(height_);
const int min_iterations = 10;
const int max_iterations = 3000;
slider_rect.y = iterations_rect.y;
gui::slider iterations_slider(screen);
iterations_slider.set_location(slider_rect);
iterations_slider.set_min(min_iterations);
iterations_slider.set_max(max_iterations);
iterations_slider.set_value(iterations_);
const int min_hillsize = 1;
const int max_hillsize = 50;
slider_rect.y = hillsize_rect.y;
gui::slider hillsize_slider(screen);
hillsize_slider.set_location(slider_rect);
hillsize_slider.set_min(min_hillsize);
hillsize_slider.set_max(max_hillsize);
hillsize_slider.set_value(hill_size_);
const int min_villages = 0;
const int max_villages = 50;
slider_rect.y = villages_rect.y;
gui::slider villages_slider(screen);
villages_slider.set_location(slider_rect);
villages_slider.set_min(min_villages);
villages_slider.set_max(max_villages);
villages_slider.set_value(nvillages_);
const int min_castlesize = 2;
const int max_castlesize = 14;
slider_rect.y = castlesize_rect.y;
gui::slider castlesize_slider(screen);
castlesize_slider.set_location(slider_rect);
castlesize_slider.set_min(min_castlesize);
castlesize_slider.set_max(max_castlesize);
castlesize_slider.set_value(castle_size_);
const int min_landform = 0;
const int max_landform = int(max_island);
slider_rect.y = landform_rect.y;
gui::slider landform_slider(screen);
landform_slider.set_location(slider_rect);
landform_slider.set_min(min_landform);
landform_slider.set_max(max_landform);
landform_slider.set_value(island_size_);
SDL_Rect link_rect = slider_rect;
link_rect.y = link_rect.y + link_rect.h + vertical_margin;
gui::button link_castles(screen,_("Roads between castles"),gui::button::TYPE_CHECK);
link_castles.set_check(link_castles_);
link_castles.set_location(link_rect);
SDL_Rect labels_rect = link_rect;
labels_rect.y = labels_rect.y + labels_rect.h + vertical_margin;
gui::button show_labels(screen,_("Show labels"),gui::button::TYPE_CHECK);
show_labels.set_check(show_labels_);
show_labels.set_location(labels_rect);
while(true) {
nplayers_ = players_slider.value();
width_ = width_slider.value();
height_ = height_slider.value();
iterations_ = iterations_slider.value();
hill_size_ = hillsize_slider.value();
nvillages_ = villages_slider.value();
castle_size_ = castlesize_slider.value();
island_size_ = landform_slider.value();
dialog_restorer.restore();
close_button.set_dirty(true);
if (close_button.pressed())
break;
players_slider.set_dirty();
width_slider.set_dirty();
height_slider.set_dirty();
iterations_slider.set_dirty();
hillsize_slider.set_dirty();
villages_slider.set_dirty();
castlesize_slider.set_dirty();
landform_slider.set_dirty();
link_castles.set_dirty();
show_labels.set_dirty();
width_slider.set_min(min_width+(players_slider.value()-2)*extra_size_per_player);
height_slider.set_min(min_width+(players_slider.value()-2)*extra_size_per_player);
events::raise_process_event();
events::raise_draw_event();
font::draw_text(&screen,screen_area(),font::SIZE_NORMAL,font::NORMAL_COLOR,players_label,players_rect.x,players_rect.y);
font::draw_text(&screen,screen_area(),font::SIZE_NORMAL,font::NORMAL_COLOR,width_label,width_rect.x,width_rect.y);
font::draw_text(&screen,screen_area(),font::SIZE_NORMAL,font::NORMAL_COLOR,height_label,height_rect.x,height_rect.y);
font::draw_text(&screen,screen_area(),font::SIZE_NORMAL,font::NORMAL_COLOR,iterations_label,iterations_rect.x,iterations_rect.y);
font::draw_text(&screen,screen_area(),font::SIZE_NORMAL,font::NORMAL_COLOR,hillsize_label,hillsize_rect.x,hillsize_rect.y);
font::draw_text(&screen,screen_area(),font::SIZE_NORMAL,font::NORMAL_COLOR,villages_label,villages_rect.x,villages_rect.y);
font::draw_text(&screen,screen_area(),font::SIZE_NORMAL,font::NORMAL_COLOR,castlesize_label,castlesize_rect.x,castlesize_rect.y);
font::draw_text(&screen,screen_area(),font::SIZE_NORMAL,font::NORMAL_COLOR,landform_label,landform_rect.x,landform_rect.y);
font::draw_text(&screen, screen_area(), font::SIZE_NORMAL,
font::NORMAL_COLOR, str_cast(nplayers_),
slider_right + horz_margin, players_rect.y);
font::draw_text(&screen, screen_area(), font::SIZE_NORMAL,
font::NORMAL_COLOR, str_cast(width_),
slider_right + horz_margin, width_rect.y);
font::draw_text(&screen, screen_area(), font::SIZE_NORMAL,
font::NORMAL_COLOR, str_cast(height_),
slider_right+horz_margin,height_rect.y);
std::stringstream villages_str;
villages_str << nvillages_ << _("/1000 tiles");
font::draw_text(&screen,screen_area(),font::SIZE_NORMAL,font::NORMAL_COLOR,villages_str.str(),
slider_right+horz_margin,villages_rect.y);
font::draw_text(&screen, screen_area(), font::SIZE_NORMAL,
font::NORMAL_COLOR, str_cast(castle_size_),
slider_right + horz_margin, castlesize_rect.y);
std::stringstream landform_str;
landform_str << gettext(island_size_ == 0 ? N_("Inland") : (island_size_ < max_coastal ? N_("Coastal") : N_("Island")));
font::draw_text(&screen,screen_area(),font::SIZE_NORMAL,font::NORMAL_COLOR,landform_str.str(),
slider_right+horz_margin,landform_rect.y);
update_rect(xpos,ypos,width,height);
disp.update_display();
disp.delay(100);
events::pump();
}
link_castles_ = link_castles.checked();
show_labels_ = show_labels.checked();
}
int show_message2(display& disp, const std::string& message, const std::string& ok_caption, const std::string& cancel_caption)
{
tmessage2 dlg(disp, message, ok_caption, cancel_caption);
dlg.show(disp.video());
return dlg.get_retval();
}
int show_dialog(display& screen, surface image,
const std::string& caption, const std::string& message,
DIALOG_TYPE type,
const std::vector<shared_string>* menu_items,
const std::vector<preview_pane*>* preview_panes,
const std::string& text_widget_label,
std::string* text_widget_text,
const int text_widget_max_chars,
std::vector<check_item>* options,
int xloc,
int yloc,
const dialog_frame::style* dialog_style,
std::vector<dialog_button_info>* action_buttons,
const menu::sorter* sorter,
menu::style* menu_style)
{
std::string title;
if (image.null()) title = caption;
const dialog::style& style = (dialog_style)? *dialog_style : dialog::default_style;
CVideo &disp = screen.video();
gui::dialog d(screen, title, message, type, style);
//add the components
if(!image.null()) {
d.set_image(image, caption);
}
if(menu_items) {
d.set_menu( new gui::menu(disp,*menu_items,type == MESSAGE,-1,dialog::max_menu_width,sorter,menu_style,false));
}
if(preview_panes) {
for(unsigned int i=0; i < preview_panes->size(); ++i) {
d.add_pane((*preview_panes)[i]);
}
}
if(text_widget_text) {
d.set_textbox(text_widget_label,*text_widget_text, text_widget_max_chars);
}
if(options) {
for(unsigned int i=0; i < options->size(); ++i) {
check_item& item = (*options)[i];
d.add_option(item.label, item.checked);
}
}
if(action_buttons) {
for(unsigned int i=0; i < action_buttons->size(); ++i) {
d.add_button((*action_buttons)[i]);
}
}
//enter the dialog loop
d.show(xloc, yloc);
// KP: unfortunately, undrawing doesn't work now since we don't have easy access to the framebuffer pixels with openGL
// so we set a global variable that the parent should redraw everything
gRedraw = true;
//send back results
if(options) {
for(unsigned int i=0; i < options->size(); ++i)
{
(*options)[i].checked = d.option_checked(i);
}
}
if(text_widget_text) {
*text_widget_text = d.textbox_text();
}
return d.result();
}
