{

const char *name;

int points;

char abbrev;

{

int group; // for navigation and mass toggling

int8_t color; // for column headers

df::profession profession; // to display graphical tiles

df::unit_labor labor; // toggled when pressing Enter

df::job_skill skill; // displayed rating

char label[3]; // column header

bool special; // specified labor is mutually exclusive with all other special labors

{

df::unit *unit;

bool allowEdit;

string name;

string transname;

string profession;

int8_t color;

int active_index;

string squad_effective_name;

string squad_info;

string job_desc;

enum { IDLE, SOCIAL, JOB } job_mode;

bool selected;

struct {

// Used for custom professions, 1-indexed

int list_id; // Position in list

int list_id_group; // Position in list by group (e.g. craftsdwarf)

int list_id_prof; // Position in list by profession (e.g. woodcrafter)

void init() {

list_id = 0;

list_id_group = 0;

list_id_prof = 0;

}

} ids;

DETAIL_MODE_PROFESSION,

DETAIL_MODE_SQUAD,

DETAIL_MODE_JOB

ALTSORT_NAME,

ALTSORT_SELECTED,

ALTSORT_DETAIL,

ALTSORT_STRESS,

ALTSORT_ARRIVAL,

ALTSORT_MAX

{

stringstream ss;

ss << n;

return ss.str();

{

if (descending)

return (d1->name > d2->name);

else

return (d1->name < d2->name);

{

if (descending)

return (d1->profession > d2->profession);

else

return (d1->profession < d2->profession);

{

bool gt = false;

if (d1->unit->military.squad_id == -1 && d2->unit->military.squad_id == -1)

gt = d1->name > d2->name;

else if (d1->unit->military.squad_id == -1)

gt = true;

else if (d2->unit->military.squad_id == -1)

gt = false;

else if (d1->unit->military.squad_id != d2->unit->military.squad_id)

gt = d1->squad_effective_name > d2->squad_effective_name;

else

gt = d1->unit->military.squad_position > d2->unit->military.squad_position;

return descending ? gt : !gt;

{

if (d1->job_mode != d2->job_mode)

{

if (descending)

return int(d1->job_mode) < int(d2->job_mode);

else

return int(d1->job_mode) > int(d2->job_mode);

}

if (descending)

return d1->job_desc > d2->job_desc;

else

return d1->job_desc < d2->job_desc;

{

if (!d1->unit->status.current_soul)

return !descending;

if (!d2->unit->status.current_soul)

return descending;

if (descending)

return (d1->unit->status.current_soul->personality.stress_level > d2->unit->status.current_soul->personality.stress_level);

else

return (d1->unit->status.current_soul->personality.stress_level < d2->unit->status.current_soul->personality.stress_level);

{

if (descending)

return (d1->active_index > d2->active_index);

else

return (d1->active_index < d2->active_index);

{

if (sort_skill != job_skill::NONE)

{

if (!d1->unit->status.current_soul)

return !descending;

if (!d2->unit->status.current_soul)

return descending;

df::unit_skill *s1 = binsearch_in_vector<df::unit_skill,df::job_skill>(d1->unit->status.current_soul->skills, &df::unit_skill::id, sort_skill);

df::unit_skill *s2 = binsearch_in_vector<df::unit_skill,df::job_skill>(d2->unit->status.current_soul->skills, &df::unit_skill::id, sort_skill);

int l1 = s1 ? s1->rating : 0;

int l2 = s2 ? s2->rating : 0;

int e1 = s1 ? s1->experience : 0;

int e2 = s2 ? s2->experience : 0;

if (descending)

{

if (l1 != l2)

return l1 > l2;

if (e1 != e2)

return e1 > e2;

}

else

{

if (l1 != l2)

return l1 < l2;

if (e1 != e2)

return e1 < e2;

}

}

if (sort_labor != unit_labor::NONE)

{

if (descending)

return d1->unit->status.labors[sort_labor] > d2->unit->status.labors[sort_labor];

else

return d1->unit->status.labors[sort_labor] < d2->unit->status.labors[sort_labor];

}

return false;

typedef string(*T_callback)(T);

typedef std::tuple<string, string, T_callback> T_opt;

typedef vector<T_opt> T_optlist;

static bool compare_opts(const string &first, const string &second)

{

return first.size() > second.size();

}

StringFormatter() {}

void add_option(string spec, string help, string (*callback)(T))

{

opt_list.push_back(std::make_tuple(spec, help, callback));

}

T_optlist *get_options() { return &opt_list; }

void clear_options()

{

opt_list.clear();

}

string grab_opt (string s, size_t start)

{

vector<string> candidates;

for (auto it = opt_list.begin(); it != opt_list.end(); ++it)

{

string opt = std::get<0>(*it);

string slice = s.substr(start, opt.size());

if (slice == opt)

candidates.push_back(slice);

}

if (!candidates.size())

return "";

// Select the longest candidate

std::sort(candidates.begin(), candidates.end(), StringFormatter<T>::compare_opts);

return candidates[0];

}

T_callback get_callback (string s)

{

for (auto it = opt_list.begin(); it != opt_list.end(); ++it)

{

if (std::get<0>(*it) == s)

return std::get<2>(*it);

}

return NULL;

}

string format (T obj, string fmt)

{

string dest = "";

bool in_opt = false;

size_t i = 0;

while (i < fmt.size())

{

if (in_opt)

{

if (fmt[i] == '%')

{

// escape: %% -> %

in_opt = false;

dest.push_back('%');

i++;

}

else

{

string opt = grab_opt(fmt, i);

if (opt.size())

{

T_callback func = get_callback(opt);

if (func != NULL)

dest += func(obj);

i += opt.size();

in_opt = false;

if (i < fmt.size() && fmt[i] == '$')

// Allow $ to terminate format options

i++;

}

else

{

// Unrecognized format option; replace with original text

dest.push_back('%');

in_opt = false;

}

}

}

else

{

if (fmt[i] == '%')

in_opt = true;

else

dest.push_back(fmt[i]);

i++;

}

}

return dest;

}

T_optlist opt_list;

{

return Translation::capitalize(u->unit->name.nickname.size() ?

u->unit->name.nickname : u->unit->name.first_name);

{

df::language_name name = u->unit->name;

string ret = "";

for (int i = 0; i < 2; i++)

{

if (name.words[i] >= 0)

ret += *world->raws.language.translations[name.language]->words[name.words[i]];

}

return Translation::capitalize(ret);

{

df::language_name name = u->unit->name;

string ret = "";

for (int i = 0; i < 2; i++)

{

if (name.words[i] >= 0)

ret += world->raws.language.words[name.words[i]]->forms[name.parts_of_speech[i]];

}

return Translation::capitalize(ret);

{

string tmp = u->unit->custom_profession;

u->unit->custom_profession = "";

string ret = get_profname(u);

u->unit->custom_profession = tmp;

return ret;

{

for (size_t i = 0; i < NUM_COLUMNS; i++)

{

if (columns[i].profession == u->unit->profession)

return string(columns[i].label);

}

return "??";

{

Units::setNickname(u->unit, nick);

u->name = get_nickname(u);

u->transname = get_nickname_eng(u);

{

u->unit->custom_profession = prof;

u->profession = get_profname(u);

{

std::string name;

bool mask;

std::vector<df::unit_labor> labors;

bool load(string directory, string file)

{

cerr << "Attempt to load " << file << endl;

std::ifstream infile(directory + "/" + file);

if (infile.bad()) {

return false;

}

std::string line;

name = file; // If no name is given we default to the filename

mask = false;

while (std::getline(infile, line)) {

if (strcmp(line.substr(0,5).c_str(),"NAME ")==0)

{

auto nextInd = line.find(' ');

name = line.substr(nextInd + 1);

continue;

}

if (line == "MASK")

{

mask = true;

continue;

}

for (size_t i = 0; i < NUM_COLUMNS; i++)

{

if (line == ENUM_KEY_STR(unit_labor, columns[i].labor))

{

labors.push_back(columns[i].labor);

}

}

}

return true;

}

bool save(string directory)

{

std::ofstream outfile(directory + "/" + name);

if (outfile.bad())

return false;

outfile << "NAME " << name << std::endl;

if (mask)

outfile << "MASK" << std::endl;

for (size_t i = 0; i < NUM_COLUMNS; i++)

{

if (hasLabor(columns[i].labor))

{

outfile << ENUM_KEY_STR(unit_labor, columns[i].labor) << std::endl;

}

}

outfile.flush();

outfile.close();

return true;

}

void apply(UnitInfo* u)

{

if (!mask && name.size() > 0)

unit_ops::set_profname(u, name);

for (size_t i = 0; i < NUM_COLUMNS; i++)

{

df::unit_labor labor = columns[i].labor;

bool status = hasLabor(labor);

if (!mask || status) {

u->unit->status.labors[labor] = status;

}

}

}

void fromUnit(UnitInfo* u)

{

for (size_t i = 0; i < NUM_COLUMNS; i++)

{

if (u->unit->status.labors[columns[i].labor])

labors.push_back(columns[i].labor);

}

}

bool hasLabor (df::unit_labor labor)

{

return std::find(labors.begin(), labors.end(), labor) != labors.end();

}

{

std::vector<ProfessionTemplate> templates;

void reload() {

unload();

load();

}

void unload() {

templates.clear();

}

void load()

{

vector <string> files;

cerr << "Attempting to load professions: " << professions_folder.c_str() << endl;

if (!Filesystem::isdir(professions_folder) && !Filesystem::mkdir(professions_folder))

{

cerr << professions_folder << ": Does not exist and cannot be created" << endl;

return;

}

Filesystem::listdir(professions_folder, files);

std::sort(files.begin(), files.end());

for(size_t i = 0; i < files.size(); i++)

{

if (files[i] == "." || files[i] == "..")

continue;

ProfessionTemplate t;

if (t.load(professions_folder, files[i]))

{

templates.push_back(t);

}

}

}

void save_from_unit(UnitInfo *unit)

{

ProfessionTemplate t = {

unit_ops::get_profname(unit)

};

t.fromUnit(unit);

t.save(professions_folder);

reload();

}

enum page { MENU, NICKNAME, PROFNAME };

viewscreen_unitbatchopst(vector<UnitInfo*> &base_units,

bool filter_selected = true,

bool *dirty_flag = NULL

)

:cur_page(MENU), entry(""), selection_empty(false), dirty(dirty_flag)

{

menu_options.multiselect = false;

menu_options.auto_select = true;

menu_options.allow_search = false;

menu_options.left_margin = 2;

menu_options.bottom_margin = 2;

menu_options.clear();

menu_options.add("Change nickname", page::NICKNAME);

menu_options.add("Change profession name", page::PROFNAME);

menu_options.filterDisplay();

formatter.add_option("n", "Displayed name (or nickname)", unit_ops::get_nickname);

formatter.add_option("N", "Real name", unit_ops::get_real_name);

formatter.add_option("en", "Displayed name (or nickname), in English", unit_ops::get_nickname_eng);

formatter.add_option("eN", "Real name, in English", unit_ops::get_real_name_eng);

formatter.add_option("fn", "Displayed first name (or nickname)", unit_ops::get_first_nickname);

formatter.add_option("fN", "Real first name", unit_ops::get_first_name);

formatter.add_option("ln", "Last name", unit_ops::get_last_name);

formatter.add_option("eln", "Last name, in English", unit_ops::get_last_name_eng);

formatter.add_option("p", "Displayed profession", unit_ops::get_profname);

formatter.add_option("P", "Real profession (non-customized)", unit_ops::get_real_profname);

formatter.add_option("bp", "Base profession (excluding nobles & other positions)", unit_ops::get_base_profname);

formatter.add_option("sp", "Short (base) profession name (from manipulator headers)", unit_ops::get_short_profname);

formatter.add_option("a", "Age (in years)", unit_ops::get_age);

formatter.add_option("i", "Position in list", unit_ops::get_list_id);

formatter.add_option("pi", "Position in list, among dwarves with same profession", unit_ops::get_list_id_prof);

formatter.add_option("gi", "Position in list, among dwarves in same profession group", unit_ops::get_list_id_group);

formatter.add_option("ri", "Raw unit ID", unit_ops::get_unit_id);

selection_empty = true;

for (auto it = base_units.begin(); it != base_units.end(); ++it)

{

UnitInfo* uinfo = *it;

if (uinfo->selected || !filter_selected)

{

selection_empty = false;

units.push_back(uinfo);

}

}

}

std::string getFocusString() { return "unitlabors/batch"; }

void select_page (page p)

{

if (p == NICKNAME || p == PROFNAME)

entry = "";

cur_page = p;

}

void apply(void (*func)(UnitInfo*, string), string arg, StringFormatter<UnitInfo*> *arg_formatter)

{

if (dirty)

*dirty = true;

for (auto it = units.begin(); it != units.end(); ++it)

{

UnitInfo* u = (*it);

if (!u || !u->unit || !u->allowEdit) continue;

string cur_arg = arg_formatter->format(u, arg);

func(u, cur_arg);

}

}

void feed(set<df::interface_key> *events)

{

if (cur_page == MENU)

{

if (events->count(interface_key::LEAVESCREEN))

{

Screen::dismiss(this);

return;

}

if (selection_empty)

return;

if (menu_options.feed(events))

{

// Allow left mouse button to trigger menu options

if (menu_options.feed_mouse_set_highlight)

events->insert(interface_key::SELECT);

else

return;

}

if (events->count(interface_key::SELECT))

select_page(menu_options.getFirstSelectedElem());

}

else if (cur_page == NICKNAME || cur_page == PROFNAME)

{

if (events->count(interface_key::LEAVESCREEN))

select_page(MENU);

else if (events->count(interface_key::SELECT))

{

apply((cur_page == NICKNAME) ? unit_ops::set_nickname : unit_ops::set_profname, entry, &formatter);

select_page(MENU);

}

else

{

for (auto it = events->begin(); it != events->end(); ++it)

{

int ch = Screen::keyToChar(*it);

if (ch == 0 && entry.size())

entry.resize(entry.size() - 1);

else if (ch > 0)

entry.push_back(char(ch));

}

}

}

}

void render()

{

dfhack_viewscreen::render();

Screen::clear();

int x = 2, y = 2;

if (cur_page == MENU)

{

Screen::drawBorder(" Dwarf Manipulator - Batch Operations ");

if (selection_empty)

{

OutputString(COLOR_LIGHTRED, x, y, "No dwarves selected!");

return;

}

menu_options.display(true);

}

OutputString(COLOR_LIGHTGREEN, x, y, itos(units.size()));

OutputString(COLOR_GREY, x, y, string(" ") + (units.size() > 1 ? "dwarves" : "dwarf") + " selected: ");

size_t max_x = gps->dimx - 2;

size_t i = 0;

for ( ; i < units.size(); i++)

{

string name = unit_ops::get_nickname(units[i]);

if (name.size() + x + 12 >= max_x) // 12 = "and xxx more"

break;

OutputString(COLOR_WHITE, x, y, name + ", ");

}

if (i == units.size())

{

x -= 2;

OutputString(COLOR_WHITE, x, y, " ");

}

else

{

OutputString(COLOR_GREY, x, y, "and " + itos(units.size() - i) + " more");

}

x = 2; y += 2;

if (cur_page == NICKNAME || cur_page == PROFNAME)

{

std::string name_type = (cur_page == page::NICKNAME) ? "Nickname" : "Profession name";

OutputString(COLOR_GREY, x, y, "Custom " + name_type + ":");

x = 2; y += 1;

OutputString(COLOR_WHITE, x, y, entry);

OutputString(COLOR_LIGHTGREEN, x, y, "_");

x = 2; y += 2;

OutputString(COLOR_DARKGREY, x, y, "(Leave blank to use original name)");

x = 2; y += 2;

OutputString(COLOR_WHITE, x, y, "Format options:");

StringFormatter<UnitInfo*>::T_optlist *format_options = formatter.get_options();

for (auto it = format_options->begin(); it != format_options->end(); ++it)

{

x = 2; y++;

auto opt = *it;

OutputString(COLOR_LIGHTCYAN, x, y, "%" + string(std::get<0>(opt)));

OutputString(COLOR_WHITE, x, y, ": " + string(std::get<1>(opt)));

}

}

}

ListColumn<page> menu_options;

page cur_page;

string entry;

vector<UnitInfo*> units;

StringFormatter<UnitInfo*> formatter;

bool selection_empty;

bool *dirty;

void resize(int32_t x, int32_t y)

{

dfhack_viewscreen::resize(x, y);

menu_options.resize();

}

viewscreen_unitprofessionset(vector<UnitInfo*> &base_units,

bool filter_selected = true

)

:menu_options(-1) // default

{

menu_options.multiselect = false;

menu_options.auto_select = true;

menu_options.allow_search = false;

menu_options.left_margin = 2;

menu_options.bottom_margin = 2;

menu_options.clear();

manager.reload();

for (size_t i = 0; i < manager.templates.size(); i++) {

std::string name = manager.templates[i].name;

if (manager.templates[i].mask)

name += " (mask)";

ListEntry<size_t> elem(name, i);

menu_options.add(elem);

}

menu_options.filterDisplay();

selection_empty = true;

for (auto it = base_units.begin(); it != base_units.end(); ++it)

{

UnitInfo* uinfo = *it;

if (uinfo->selected || !filter_selected)

{

selection_empty = false;

units.push_back(uinfo);

}

}

}

std::string getFocusString() { return "unitlabors/profession"; }

void feed(set<df::interface_key> *events)

{

if (events->count(interface_key::LEAVESCREEN))

{

Screen::dismiss(this);

return;

}