void item_palette::setup(const config& cfg)
{
for (const config& group : cfg.child_range("item_group")) {
groups_.push_back(item_group(group));
for (const config& item : group.child_range("item")) {
item_map_.insert(std::pair<std::string, overlay>(item["id"], overlay(item)));
group_map_[group["id"]].push_back(item["id"]);
if (!group["core"].to_bool(false))
non_core_items_.insert(item["id"]);
}
nmax_items_ = std::max(nmax_items_, group_map_[group["id"]].size());
}
select_fg_item("anvil");
select_bg_item("altar");
// Set the default group
set_group("items");
if(active_group().empty()) {
ERR_ED << "No items found." << std::endl;
}
}
void unit_palette::setup(const config& /*cfg*/)
{
for (const unit_type_data::unit_type_map::value_type &i : unit_types.types())
{
if (i.second.do_not_list())
continue;
item_map_.insert(std::pair<std::string, unit_type>(i.second.id(), i.second));
group_map_[i.second.race_id()].push_back(i.second.id());
nmax_items_ = std::max<int>(nmax_items_, group_map_[i.second.race_id()].size());
//TODO
bool core = true;
if (core) {
// Add the unit to the default group
group_map_["all"].push_back(i.second.id());
nmax_items_ = std::max<int>(nmax_items_, group_map_["all"].size());
} else {
non_core_items_.insert(i.second.id());
}
}
for (const race_map::value_type &i : unit_types.races())
{
if (group_map_[i.second.id()].empty())
continue;
config cfg;
cfg["id"] = i.second.id();
cfg["name"] = i.second.plural_name();
cfg["icon"] = "icons/unit-groups/race_" + i.second.id();
cfg["core"] = "yes";
groups_.push_back(item_group(cfg));
}
//TODO
//move "invalid" items to the end
//std::stable_partition(items.begin(), items.end(), is_valid_terrain);
select_fg_item(item_map_.begin()->second.id());
select_bg_item(item_map_.begin()->second.id());
// Set the default group
set_group(groups_[0].id);
if(active_group().empty()) {
ERR_ED << "No items found." << std::endl;
}
}
void editor_palette<Item>::set_group(const std::string& id)
{
assert(!id.empty());
bool found = false;
for (const item_group& group : groups_) {
if (group.id == id) {
found = true;
std::shared_ptr<gui::button> palette_menu_button = gui_.find_menu_button("menu-editor-terrain");
if (palette_menu_button) {
//palette_menu_button->set_label(group.name);
palette_menu_button->set_tooltip_string(group.name);
palette_menu_button->set_overlay(group.icon);
}
}
}
assert(found);
active_group_ = id;
if(active_group().empty()) {
ERR_ED << "No items found in group with the id: '" << id << "'." << std::endl;
}
}
void terrain_palette::setup(const config& cfg)
{
// Get the available terrains temporary in items
t_translation::t_list items = map().get_terrain_list();
//move "invalid" items to the end
std::stable_partition(items.begin(), items.end(), is_valid_terrain);
// Get the available groups and add them to the structure
std::set<std::string> group_names;
for (const config &group : cfg.child_range("editor_group"))
{
if (group_names.find(group["id"]) == group_names.end()) {
config group_cfg;
group_cfg["id"] = group["id"];
group_cfg["name"] = group["name"];
group_cfg["icon"] = "icons/terrain/terrain_" + group["icon"].str();
group_cfg["core"] = group["core"];
groups_.push_back(item_group(group_cfg));
group_names.insert(groups_.back().id);
}
}
std::map<std::string, item_group*> id_to_group;
for (item_group& group : groups_) {
id_to_group.insert(std::make_pair(group.id, &group));
}
// add the groups for all terrains to the map
for (const t_translation::t_terrain& t : items) {
const terrain_type& t_info = map().get_terrain_info(t);
DBG_ED << "Palette: processing terrain " << t_info.name()
<< "(editor name: '" << t_info.editor_name() << "') "
<< "(" << t_info.number() << ")"
<< ": " << t_info.editor_group() << "\n";
// don't display terrains that were automatically created from base+overlay
if (t_info.is_combined()) continue;
// nor display terrains that have hide_in_editor=true
if (t_info.hide_in_editor()) continue;
// add the terrain to the requested groups
const std::vector<std::string>& keys = utils::split(t_info.editor_group());
bool core = false;
item_map_[get_id(t)] = t;
for (const std::string& k : keys) {
group_map_[k].push_back(get_id(t));
nmax_items_ = std::max<int>(nmax_items_, group_map_[k].size());
std::map<std::string, item_group*>::iterator i = id_to_group.find(k);
if (i != id_to_group.end()) {
if (i->second->core) {
core = true;
}
}
}
// A terrain is considered core iff it appears in at least
// one core terrain group
if (core) {
// Add the terrain to the default group
group_map_["all"].push_back(get_id(t));
nmax_items_ = std::max<int>(nmax_items_, group_map_["all"].size());
} else {
non_core_items_.insert(get_id(t));
}
}
// Set the default terrain
select_fg_item("regular_mountains");
select_bg_item("grassland");
// Set the default group
set_group("all");
if(active_group().empty()) {
ERR_ED << "No items found." << std::endl;
}
}
void editor_palette<Item>::draw_contents()
{
toolkit_.set_mouseover_overlay(gui_);
std::shared_ptr<gui::button> palette_menu_button = gui_.find_menu_button("menu-editor-terrain");
if (palette_menu_button) {
t_string& name = groups_[active_group_index()].name;
std::string& icon = groups_[active_group_index()].icon;
palette_menu_button->set_tooltip_string(name);
palette_menu_button->set_overlay(icon);
}
unsigned int y = palette_y_;
unsigned int x = palette_x_;
int starting = items_start_;
int ending = std::min<int>(starting + nitems_, num_items());
std::shared_ptr<gui::button> upscroll_button = gui_.find_action_button("upscroll-button-editor");
if (upscroll_button)
upscroll_button->enable(starting != 0);
std::shared_ptr<gui::button> downscroll_button = gui_.find_action_button("downscroll-button-editor");
if (downscroll_button)
downscroll_button->enable(ending != num_items());
int counter = starting;
for (int i = 0, size = num_visible_items(); i < size ; ++i) {
//TODO check if the conditions still hold for the counter variable
//for (unsigned int counter = starting; counter < ending; counter++)
gui::tristate_button& tile = buttons_[i];
tile.hide(true);
if (i >= ending) continue;
const std::string item_id = active_group()[counter];
//typedef std::map<std::string, Item> item_map_wurscht;
typename item_map::iterator item = item_map_.find(item_id);
surface item_image(nullptr);
std::stringstream tooltip_text;
draw_item((*item).second, item_image, tooltip_text);
bool is_core = non_core_items_.find(get_id((*item).second)) == non_core_items_.end();
if (!is_core) {
tooltip_text << " "
<< font::span_color(font::BAD_COLOR)
<< _("(non-core)") << "\n"
<< _("Will not work in game without extra care.")
<< "</span>";
}
const int counter_from_zero = counter - starting;
SDL_Rect dstrect;
dstrect.x = x + (counter_from_zero % item_width_) * item_space_;
dstrect.y = y;
dstrect.w = item_size_ + 2;
dstrect.h = item_size_ + 2;
tile.set_location(dstrect);
tile.set_tooltip_string(tooltip_text.str());
tile.set_item_image(item_image);
tile.set_item_id(item_id);
// if (get_id((*item).second) == selected_bg_item_
// && get_id((*item).second) == selected_fg_item_) {
// tile.set_pressed(gui::tristate_button::BOTH);
// } else if (get_id((*item).second) == selected_bg_item_) {
// tile.set_pressed(gui::tristate_button::RIGHT);
// } else if (get_id((*item).second) == selected_fg_item_) {
// tile.set_pressed(gui::tristate_button::LEFT);
// } else {
// tile.set_pressed(gui::tristate_button::NONE);
// }
if (is_selected_bg_item(get_id(item->second))
&& is_selected_fg_item(get_id(item->second))) {
tile.set_pressed(gui::tristate_button::BOTH);
} else if (is_selected_bg_item(get_id(item->second))) {
tile.set_pressed(gui::tristate_button::RIGHT);
} else if (is_selected_fg_item(get_id(item->second))) {
tile.set_pressed(gui::tristate_button::LEFT);
} else {
tile.set_pressed(gui::tristate_button::NONE);
}
tile.set_dirty(true);
tile.hide(false);
tile.draw();
// Adjust location
if (counter_from_zero % item_width_ == item_width_ - 1)
y += item_space_;
++counter;
}
}