bool menu::imgsel_style::load_image(const std::string &img_sub)
{
std::string path = img_base_ + "-" + img_sub + ".png";
const surface image = image::get_image(path);
img_map_[img_sub] = image;
return(!image.null());
}
dialog_image(label *const caption, CVideo &video, surface img) : widget(video, false),
surf_(img), caption_(caption)
{
if(!img.null()) {
set_measurements(img->w, img->h);
}
}
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();
}
SDL_Rect draw_text_line(surface gui_surface, const SDL_Rect& area, int size,
const SDL_Color& colour, const std::string& text,
int x, int y, bool use_tooltips, int style)
{
if (gui_surface.null()) {
text_surface const &u = text_cache::find(text_surface(text, size, colour, style));
SDL_Rect res = {0, 0, u.width(), u.height()};
return res;
}
if(area.w == 0) { // no place to draw
SDL_Rect res = {0,0,0,0};
return res;
}
const std::string etext = make_text_ellipsis(text, size, area.w);
// for the main current use, we already parsed markup
surface surface(render_text(etext,size,colour,style,false));
if(surface == NULL) {
SDL_Rect res = {0,0,0,0};
return res;
}
SDL_Rect dest;
if(x!=-1) {
dest.x = x;
#ifdef HAVE_FRIBIDI
// Oron -- Conditional, until all draw_text_line calls have fixed area parameter
if(getenv("NO_RTL") == NULL) {
bool is_rtl = text_cache::find(text_surface(text, size, colour, style)).is_rtl();
if(is_rtl)
dest.x = area.x + area.w - surface->w - (x - area.x);
}
#endif
} else
dest.x = (area.w/2)-(surface->w/2);
if(y!=-1)
dest.y = y;
else
dest.y = (area.h/2)-(surface->h/2);
dest.w = surface->w;
dest.h = surface->h;
if(line_width(text, size) > area.w) {
tooltips::add_tooltip(dest,text);
}
if(dest.x + dest.w > area.x + area.w) {
dest.w = area.x + area.w - dest.x;
}
if(dest.y + dest.h > area.y + area.h) {
dest.h = area.y + area.h - dest.y;
}
if(gui_surface != NULL) {
SDL_Rect src = dest;
src.x = 0;
src.y = 0;
SDL_BlitSurface(surface,&src,gui_surface,&dest);
}
if(use_tooltips) {
tooltips::add_tooltip(dest,text);
}
return dest;
}
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();
}
void unit_drawer::redraw_unit (const unit & u) const
{
unit_animation_component & ac = u.anim_comp();
map_location loc = u.get_location();
int side = u.side();
bool hidden = u.get_hidden();
bool is_flying = u.is_flying();
map_location::DIRECTION facing = u.facing();
int hitpoints = u.hitpoints();
int max_hitpoints = u.max_hitpoints();
int movement_left = u.movement_left();
int total_movement = u.total_movement();
bool can_recruit = u.can_recruit();
bool can_advance = u.can_advance();
int experience = u.experience();
int max_experience = u.max_experience();
bool emit_zoc = u.emits_zoc();
SDL_Color hp_color=u.hp_color();
SDL_Color xp_color=u.xp_color();
std::string ellipse=u.image_ellipse();
if ( hidden || is_blindfolded || !u.is_visible_to_team(viewing_team_ref, dc, show_everything) )
{
ac.clear_haloes();
if(ac.anim_) {
ac.anim_->update_last_draw_time();
}
return;
}
if (!ac.anim_) {
ac.set_standing();
if (!ac.anim_) return;
}
if (ac.refreshing_) return;
ac.refreshing_ = true;
ac.anim_->update_last_draw_time();
frame_parameters params;
const t_translation::terrain_code terrain = map.get_terrain(loc);
const terrain_type& terrain_info = map.get_terrain_info(terrain);
// do not set to 0 so we can distinguish the flying from the "not on submerge terrain"
// instead use -1.0 (as in "negative depth", it will be ignored by rendering)
params.submerge= is_flying ? -1.0 : terrain_info.unit_submerge();
if (u.invisible(loc, dc) &&
params.highlight_ratio > 0.5) {
params.highlight_ratio = 0.5;
}
if (loc == sel_hex && params.highlight_ratio == 1.0) {
params.highlight_ratio = 1.5;
}
int height_adjust = static_cast<int>(terrain_info.unit_height_adjust() * zoom_factor);
if (is_flying && height_adjust < 0) {
height_adjust = 0;
}
params.y -= height_adjust;
params.halo_y -= height_adjust;
int red = 0,green = 0,blue = 0,tints = 0;
double blend_ratio = 0;
// Add future colored states here
if(u.poisoned()) {
green += 255;
blend_ratio += 0.25;
tints += 1;
}
if(u.slowed()) {
red += 191;
green += 191;
blue += 255;
blend_ratio += 0.25;
tints += 1;
}
if(tints > 0) {
params.blend_with = disp.rgb((red/tints),(green/tints),(blue/tints));
params.blend_ratio = ((blend_ratio/tints));
}
//hackish : see unit_frame::merge_parameters
// we use image_mod on the primary image
// and halo_mod on secondary images and all haloes
params.image_mod = u.image_mods();
params.halo_mod = u.TC_image_mods();
params.image= u.default_anim_image();
if(u.incapacitated()) params.image_mod +="~GS()";
params.primary_frame = t_true;
const frame_parameters adjusted_params = ac.anim_->get_current_params(params);
const map_location dst = loc.get_direction(facing);
const int xsrc = disp.get_location_x(loc);
const int ysrc = disp.get_location_y(loc);
const int xdst = disp.get_location_x(dst);
const int ydst = disp.get_location_y(dst);
const int x = static_cast<int>(adjusted_params.offset * xdst + (1.0-adjusted_params.offset) * xsrc) + hex_size_by_2;
const int y = static_cast<int>(adjusted_params.offset * ydst + (1.0-adjusted_params.offset) * ysrc) + hex_size_by_2;
bool has_halo = ac.unit_halo_ && ac.unit_halo_->valid();
if(!has_halo && !u.image_halo().empty()) {
ac.unit_halo_ = halo_man.add(x, y - height_adjust, u.image_halo()+u.TC_image_mods(), map_location(-1, -1));
}
if(has_halo && u.image_halo().empty()) {
halo_man.remove(ac.unit_halo_);
ac.unit_halo_ = halo::handle(); //halo::NO_HALO;
} else if(has_halo) {
halo_man.set_location(ac.unit_halo_, x, y - height_adjust);
}
// We draw bars only if wanted, visible on the map view
bool draw_bars = ac.draw_bars_ ;
if (draw_bars) {
SDL_Rect unit_rect = sdl::create_rect(xsrc, ysrc +adjusted_params.y, hex_size, hex_size);
draw_bars = sdl::rects_overlap(unit_rect, disp.map_outside_area());
}
surface ellipse_front(nullptr);
surface ellipse_back(nullptr);
int ellipse_floating = 0;
// Always show the ellipse for selected units
if(draw_bars && (preferences::show_side_colors() || sel_hex == loc)) {
if(adjusted_params.submerge > 0.0) {
// The division by 2 seems to have no real meaning,
// It just works fine with the current center of ellipse
// and prevent a too large adjust if submerge = 1.0
ellipse_floating = static_cast<int>(adjusted_params.submerge * hex_size_by_2);
}
if(ellipse.empty()){
ellipse="misc/ellipse";
}
if(ellipse != "none") {
// check if the unit has a ZoC or can recruit
const std::string nozoc = !emit_zoc ? "nozoc-" : "";
const std::string leader = can_recruit ? "leader-" : "";
const std::string selected = sel_hex == loc ? "selected-" : "";
const std::string tc = team::get_side_color_index(side);
const std::string ellipse_top = formatter() << ellipse << "-" << leader << nozoc << selected << "top.png~RC(ellipse_red>" << tc << ")";
const std::string ellipse_bot = formatter() << ellipse << "-" << leader << nozoc << selected << "bottom.png~RC(ellipse_red>" << tc << ")";
// Load the ellipse parts recolored to match team color
ellipse_back.assign(image::get_image(image::locator(ellipse_top), image::SCALED_TO_ZOOM));
ellipse_front.assign(image::get_image(image::locator(ellipse_bot), image::SCALED_TO_ZOOM));
}
}
if (ellipse_back != nullptr) {
//disp.drawing_buffer_add(display::LAYER_UNIT_BG, loc,
disp.drawing_buffer_add(display::LAYER_UNIT_FIRST, loc,
xsrc, ysrc +adjusted_params.y-ellipse_floating, ellipse_back);
}
if (ellipse_front != nullptr) {
//disp.drawing_buffer_add(display::LAYER_UNIT_FG, loc,
disp.drawing_buffer_add(display::LAYER_UNIT_FIRST, loc,
xsrc, ysrc +adjusted_params.y-ellipse_floating, ellipse_front);
}
if(draw_bars) {
const image::locator* orb_img = nullptr;
const surface unit_img = image::get_image(u.default_anim_image(), image::SCALED_TO_ZOOM);
const int xoff = unit_img.null() ? hex_size_by_2 : (hex_size - unit_img->w)/2;
const int yoff = unit_img.null() ? hex_size_by_2 : (hex_size - unit_img->h)/2;
/*static*/ const image::locator partmoved_orb(game_config::images::orb + "~RC(magenta>" +
preferences::partial_color() + ")" );
/*static*/ const image::locator moved_orb(game_config::images::orb + "~RC(magenta>" +
preferences::moved_color() + ")" );
/*static*/ const image::locator ally_orb(game_config::images::orb + "~RC(magenta>" +
preferences::allied_color() + ")" );
/*static*/ const image::locator enemy_orb(game_config::images::orb + "~RC(magenta>" +
preferences::enemy_color() + ")" );
/*static*/ const image::locator unmoved_orb(game_config::images::orb + "~RC(magenta>" +
preferences::unmoved_color() + ")" );
const std::string* energy_file = &game_config::images::energy;
if(size_t(side) != viewing_team+1) {
if(disp.team_valid() &&
viewing_team_ref.is_enemy(side)) {
if (preferences::show_enemy_orb() && !u.incapacitated())
orb_img = &enemy_orb;
else
orb_img = nullptr;
} else {
if (preferences::show_allied_orb())
orb_img = &ally_orb;
else orb_img = nullptr;
}
} else {
if (preferences::show_moved_orb())
orb_img = &moved_orb;
else orb_img = nullptr;
if(playing_team == viewing_team && !u.user_end_turn()) {
if (movement_left == total_movement) {
if (preferences::show_unmoved_orb())
orb_img = &unmoved_orb;
else orb_img = nullptr;
} else if ( dc.unit_can_move(u) ) {
if (preferences::show_partial_orb())
orb_img = &partmoved_orb;
else orb_img = nullptr;
}
}
}
if (orb_img != nullptr) {
surface orb(image::get_image(*orb_img,image::SCALED_TO_ZOOM));
disp.drawing_buffer_add(display::LAYER_UNIT_BAR,
loc, xsrc + xoff, ysrc + yoff + adjusted_params.y, orb);
}
double unit_energy = 0.0;
if(max_hitpoints > 0) {
unit_energy = double(hitpoints)/double(max_hitpoints);
}
const int bar_shift = static_cast<int>(-5*zoom_factor);
const int hp_bar_height = static_cast<int>(max_hitpoints * u.hp_bar_scaling());
const fixed_t bar_alpha = (loc == mouse_hex || loc == sel_hex) ? ftofxp(1.0): ftofxp(0.8);
draw_bar(*energy_file, xsrc+xoff+bar_shift, ysrc+yoff+adjusted_params.y,
loc, hp_bar_height, unit_energy,hp_color, bar_alpha);
if(experience > 0 && can_advance) {
const double filled = double(experience)/double(max_experience);
const int xp_bar_height = static_cast<int>(max_experience * u.xp_bar_scaling() / std::max<int>(u.level(),1));
draw_bar(*energy_file, xsrc+xoff, ysrc+yoff+adjusted_params.y,
loc, xp_bar_height, filled, xp_color, bar_alpha);
}
if (can_recruit) {
surface crown(image::get_image(u.leader_crown(),image::SCALED_TO_ZOOM));
if(!crown.null()) {
//if(bar_alpha != ftofxp(1.0)) {
// crown = adjust_surface_alpha(crown, bar_alpha);
//}
disp.drawing_buffer_add(display::LAYER_UNIT_BAR,
loc, xsrc+xoff, ysrc+yoff+adjusted_params.y, crown);
}
}
for(std::vector<std::string>::const_iterator ov = u.overlays().begin(); ov != u.overlays().end(); ++ov) {
const surface ov_img(image::get_image(*ov, image::SCALED_TO_ZOOM));
if(ov_img != nullptr) {
disp.drawing_buffer_add(display::LAYER_UNIT_BAR,
loc, xsrc+xoff, ysrc+yoff+adjusted_params.y, ov_img);
}
}
}
// Smooth unit movements from terrain of different elevation.
// Do this separately from above so that the health bar doesn't go up and down.
const t_translation::terrain_code terrain_dst = map.get_terrain(dst);
const terrain_type& terrain_dst_info = map.get_terrain_info(terrain_dst);
int height_adjust_unit = static_cast<int>((terrain_info.unit_height_adjust() * (1.0 - adjusted_params.offset) +
terrain_dst_info.unit_height_adjust() * adjusted_params.offset) *
zoom_factor);
if (is_flying && height_adjust_unit < 0) {
height_adjust_unit = 0;
}
params.y -= height_adjust_unit - height_adjust;
params.halo_y -= height_adjust_unit - height_adjust;
ac.anim_->redraw(params, halo_man);
ac.refreshing_ = false;
}
