/*

https://github.com/peterix/dfhack

Copyright (c) 2009-2012 Petr Mrázek (peterix@gmail.com)

This software is provided 'as-is', without any express or implied

warranty. In no event will the authors be held liable for any

damages arising from the use of this software.

Permission is granted to anyone to use this software for any

purpose, including commercial applications, and to alter it and

redistribute it freely, subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must

not claim that you wrote the original software. If you use this

software in a product, an acknowledgment in the product documentation

would be appreciated but is not required.

2. Altered source versions must be plainly marked as such, and

must not be misrepresented as being the original software.

3. This notice may not be removed or altered from any source

distribution.

*/

#include "Internal.h"

#include <string>

#include <vector>

#include <map>

using namespace std;

#include "modules/Gui.h"

#include "MemAccess.h"

#include "VersionInfo.h"

#include "Types.h"

#include "Error.h"

#include "ModuleFactory.h"

#include "Core.h"

#include "PluginManager.h"

#include "MiscUtils.h"

using namespace DFHack;

#include "modules/Job.h"

#include "modules/Screen.h"

#include "modules/Maps.h"

#include "DataDefs.h"

#include "df/announcement_flags.h"

#include "df/assign_trade_status.h"

#include "df/building_cagest.h"

#include "df/building_civzonest.h"

#include "df/building_furnacest.h"

#include "df/building_trapst.h"

#include "df/building_type.h"

#include "df/building_workshopst.h"

#include "df/d_init.h"

#include "df/game_mode.h"

#include "df/general_ref.h"

#include "df/global_objects.h"

#include "df/graphic.h"

#include "df/historical_figure.h"

#include "df/interfacest.h"

#include "df/item_corpsepiecest.h"

#include "df/item_corpsest.h"

#include "df/job.h"

#include "df/layer_object_listst.h"

#include "df/occupation.h"

#include "df/plant.h"

#include "df/popup_message.h"

#include "df/report.h"

#include "df/route_stockpile_link.h"

#include "df/stop_depart_condition.h"

#include "df/ui_advmode.h"

#include "df/ui_build_selector.h"

#include "df/ui_look_list.h"

#include "df/ui_sidebar_menus.h"

#include "df/ui_unit_view_mode.h"

#include "df/unit.h"

#include "df/unit_inventory_item.h"

#include "df/viewscreen_announcelistst.h"

#include "df/viewscreen_assign_display_itemst.h"

#include "df/viewscreen_buildinglistst.h"

#include "df/viewscreen_customize_unitst.h"

#include "df/viewscreen_dungeon_monsterstatusst.h"

#include "df/viewscreen_dungeonmodest.h"

#include "df/viewscreen_dwarfmodest.h"

#include "df/viewscreen_itemst.h"

#include "df/viewscreen_joblistst.h"

#include "df/viewscreen_jobmanagementst.h"

#include "df/viewscreen_jobst.h"

#include "df/viewscreen_layer.h"

#include "df/viewscreen_layer_assigntradest.h"

#include "df/viewscreen_layer_militaryst.h"

#include "df/viewscreen_layer_noblelistst.h"

#include "df/viewscreen_layer_overall_healthst.h"

#include "df/viewscreen_layer_stockpilest.h"

#include "df/viewscreen_layer_unit_healthst.h"

#include "df/viewscreen_layer_unit_relationshipst.h"

#include "df/viewscreen_locationsst.h"

#include "df/viewscreen_petst.h"

#include "df/viewscreen_storesst.h"

#include "df/viewscreen_textviewerst.h"

#include "df/viewscreen_tradegoodsst.h"

#include "df/viewscreen_unitlistst.h"

#include "df/viewscreen_unitst.h"

#include "df/viewscreen_reportlistst.h"

#include "df/viewscreen_workquota_conditionst.h"

#include "df/viewscreen_workshop_profilest.h"

#include "df/world.h"

using namespace df::enums;

using df::global::gamemode;

using df::global::gps;

using df::global::gview;

using df::global::init;

using df::global::selection_rect;

using df::global::ui;

using df::global::ui_menu_width;

using df::global::ui_sidebar_menus;

using df::global::world;

static df::layer_object_listst *getLayerList(df::viewscreen_layer *layer, int idx)

{

return virtual_cast<df::layer_object_listst>(vector_get(layer->layer_objects,idx));

}

static std::string getNameChunk(virtual_identity *id, int start, int end)

{

if (!id)

return "UNKNOWN";

const char *name = id->getName();

int len = strlen(name);

if (len > start + end)

return std::string(name+start, len-start-end);

else

return name;

}

/*

* Classifying focus context by means of a string path.

*/

typedef void (*getFocusStringHandler)(std::string &str, df::viewscreen *screen);

static std::map<virtual_identity*, getFocusStringHandler> getFocusStringHandlers;

#define VIEWSCREEN(name) df::viewscreen_##name##st

#define DEFINE_GET_FOCUS_STRING_HANDLER(screen_type) \

static void getFocusString_##screen_type(std::string &focus, VIEWSCREEN(screen_type) *screen);\

DFHACK_STATIC_ADD_TO_MAP(\

&getFocusStringHandlers, &VIEWSCREEN(screen_type)::_identity, \

(getFocusStringHandler)getFocusString_##screen_type \

); \

static void getFocusString_##screen_type(std::string &focus, VIEWSCREEN(screen_type) *screen)

DEFINE_GET_FOCUS_STRING_HANDLER(dwarfmode)

{

using namespace df::enums::ui_sidebar_mode;

using df::global::ui_workshop_in_add;

using df::global::ui_build_selector;

using df::global::ui_selected_unit;

using df::global::ui_look_list;

using df::global::ui_look_cursor;

using df::global::ui_building_item_cursor;

using df::global::ui_building_assign_type;

using df::global::ui_building_assign_is_marked;

using df::global::ui_building_assign_units;

using df::global::ui_building_assign_items;

using df::global::ui_building_in_assign;

focus += "/" + enum_item_key(ui->main.mode);

switch (ui->main.mode)

{

case QueryBuilding:

if (df::building *selected = world->selected_building)

{

if (!selected->jobs.empty() &&

selected->jobs[0]->job_type == job_type::DestroyBuilding)

{

focus += "/Destroying";

break;

}

focus += "/Some";

virtual_identity *id = virtual_identity::get(selected);

bool jobs = false;

if (id == &df::building_workshopst::_identity ||

id == &df::building_furnacest::_identity)

{

focus += "/Workshop";

jobs = true;

}

else if (id == &df::building_trapst::_identity)

{

auto trap = (df::building_trapst*)selected;

focus += "/" + enum_item_key(trap->trap_type);

if (trap->trap_type == trap_type::Lever)

jobs = true;

}

else if (ui_building_in_assign && *ui_building_in_assign &&

ui_building_assign_type && ui_building_assign_units &&

ui_building_assign_type->size() == ui_building_assign_units->size())

{

focus += "/Assign";

if (ui_building_item_cursor)

{

auto unit = vector_get(*ui_building_assign_units, *ui_building_item_cursor);

focus += unit ? "/Unit" : "/None";

}

}

else

focus += "/" + enum_item_key(selected->getType());

if (jobs)

{

if (ui_workshop_in_add && *ui_workshop_in_add)

focus += "/AddJob";

else if (!selected->jobs.empty())

focus += "/Job";

else

focus += "/Empty";

}

}

else

focus += "/None";

break;

case Build:

if (ui_build_selector)

{

// Not selecting, or no choices?

if (ui_build_selector->building_type < 0)

focus += "/Type";

else if (ui_build_selector->stage != 2)

{

if (ui_build_selector->stage != 1)

focus += "/NoMaterials";

else

focus += "/Position";

focus += "/" + enum_item_key(ui_build_selector->building_type);

}

else

{

focus += "/Material";

if (ui_build_selector->is_grouped)

focus += "/Groups";

else

focus += "/Items";

}

}

break;

case ViewUnits:

if (ui_selected_unit)

{

if (vector_get(world->units.active, *ui_selected_unit))

{

focus += "/Some";

using df::global::ui_unit_view_mode;

if (ui_unit_view_mode)

focus += "/" + enum_item_key(ui_unit_view_mode->value);

}

else

focus += "/None";

}

break;

case LookAround:

if (ui_look_list && ui_look_cursor)

{

auto item = vector_get(ui_look_list->items, *ui_look_cursor);

if (item)

focus += "/" + enum_item_key(item->type);

else

focus += "/None";

}

break;

case BuildingItems:

if (VIRTUAL_CAST_VAR(selected, df::building_actual, world->selected_building))

{

if (selected->contained_items.empty())

focus += "/Some/Empty";

else

focus += "/Some/Item";

}

else

focus += "/None";

break;

case ZonesPenInfo:

if (ui_building_assign_type && ui_building_assign_units &&

ui_building_assign_is_marked && ui_building_assign_items &&

ui_building_assign_type->size() == ui_building_assign_units->size())

{

focus += "/Assign";

if (ui_building_item_cursor)

{

if (vector_get(*ui_building_assign_units, *ui_building_item_cursor))

focus += "/Unit";

else if (vector_get(*ui_building_assign_items, *ui_building_item_cursor))

focus += "/Vermin";

else

focus += "/None";

}

}

break;

case Burrows:

if (ui->burrows.in_confirm_delete)

focus += "/ConfirmDelete";

else if (ui->burrows.in_add_units_mode)

focus += "/AddUnits";

else if (ui->burrows.in_edit_name_mode)

focus += "/EditName";

else if (ui->burrows.in_define_mode)

focus += "/Define";

else

focus += "/List";

break;

case Hauling:

if (ui->hauling.in_assign_vehicle)

{

auto vehicle = vector_get(ui->hauling.vehicles, ui->hauling.cursor_vehicle);

focus += "/AssignVehicle/" + std::string(vehicle ? "Some" : "None");

}

else

{

int idx = ui->hauling.cursor_top;

auto route = vector_get(ui->hauling.view_routes, idx);

auto stop = vector_get(ui->hauling.view_stops, idx);

std::string tag = stop ? "Stop" : (route ? "Route" : "None");

if (ui->hauling.in_name)

focus += "/Rename/" + tag;

else if (ui->hauling.in_stop)

{

int sidx = ui->hauling.cursor_stop;

auto cond = vector_get(ui->hauling.stop_conditions, sidx);

auto link = vector_get(ui->hauling.stop_links, sidx);

focus += "/DefineStop";

if (cond)

focus += "/Cond/" + enum_item_key(cond->mode);

else if (link)

{

focus += "/Link/";

if (link->mode.bits.give) focus += "Give";

if (link->mode.bits.take) focus += "Take";

}

else

focus += "/None";

}

else

focus += "/Select/" + tag;

}

break;

default:

break;

}

}

DEFINE_GET_FOCUS_STRING_HANDLER(dungeonmode)

{

using df::global::ui_advmode;

if (!ui_advmode)

return;

focus += "/" + enum_item_key(ui_advmode->menu);

}

DEFINE_GET_FOCUS_STRING_HANDLER(unitlist)

{

focus += "/" + enum_item_key(screen->page);

}

DEFINE_GET_FOCUS_STRING_HANDLER(layer_military)

{

auto list1 = getLayerList(screen, 0);

auto list2 = getLayerList(screen, 1);

auto list3 = getLayerList(screen, 2);

if (!list1 || !list2 || !list3) return;

focus += "/" + enum_item_key(screen->page);

int cur_list;

if (list1->active) cur_list = 0;

else if (list2->active) cur_list = 1;

else if (list3->active) cur_list = 2;

else return;

switch (screen->page)

{

case df::viewscreen_layer_militaryst::Positions:

{

static const char *lists[] = { "/Squads", "/Positions", "/Candidates" };

focus += lists[cur_list];

break;

}

case df::viewscreen_layer_militaryst::Equip:

{

focus += "/" + enum_item_key(screen->equip.mode);

switch (screen->equip.mode)

{

case df::viewscreen_layer_militaryst::T_equip::Customize:

{

if (screen->equip.edit_mode < 0)

focus += "/View";

else

focus += "/" + enum_item_key(screen->equip.edit_mode);

break;

}

case df::viewscreen_layer_militaryst::T_equip::Uniform:

break;

case df::viewscreen_layer_militaryst::T_equip::Priority:

{

if (screen->equip.prio_in_move >= 0)

focus += "/Move";

else

focus += "/View";

break;

}

}

static const char *lists[] = { "/Squads", "/Positions", "/Choices" };

focus += lists[cur_list];

break;

}

default:

break;

}

}

DEFINE_GET_FOCUS_STRING_HANDLER(workshop_profile)

{

typedef df::viewscreen_workshop_profilest::T_tab T_tab;

switch(screen->tab)

{

case T_tab::Workers:

focus += "/Unit";

break;

case T_tab::Orders:

focus += "/Orders";

break;

case T_tab::Restrictions:

focus += "/Restrictions";

break;

}

}

DEFINE_GET_FOCUS_STRING_HANDLER(layer_noblelist)

{

auto list1 = getLayerList(screen, 0);

auto list2 = getLayerList(screen, 1);

if (!list1 || !list2) return;

focus += "/" + enum_item_key(screen->mode);

}

DEFINE_GET_FOCUS_STRING_HANDLER(pet)

{

focus += "/" + enum_item_key(screen->mode);

switch (screen->mode)

{

case df::viewscreen_petst::List:

focus += vector_get(screen->is_vermin, screen->cursor) ? "/Vermin" : "/Unit";

break;

case df::viewscreen_petst::SelectTrainer:

if (vector_get(screen->trainer_unit, screen->trainer_cursor))

focus += "/Unit";

break;

default:

break;

}

}

DEFINE_GET_FOCUS_STRING_HANDLER(layer_overall_health)

{

auto list1 = getLayerList(screen, 0);

if (!list1) return;

focus += "/Units";

}

DEFINE_GET_FOCUS_STRING_HANDLER(tradegoods)

{

if (!screen->has_traders || screen->is_unloading)

focus += "/NoTraders";

else if (screen->in_edit_count)

focus += "/EditCount";

else

focus += (screen->in_right_pane ? "/Items/Broker" : "/Items/Trader");

}

DEFINE_GET_FOCUS_STRING_HANDLER(layer_assigntrade)

{

auto list1 = getLayerList(screen, 0);

auto list2 = getLayerList(screen, 1);

if (!list1 || !list2) return;

int list_idx = vector_get(screen->visible_lists, list1->cursor, (int16_t)-1);

unsigned num_lists = sizeof(screen->lists)/sizeof(screen->lists[0]);

if (unsigned(list_idx) >= num_lists)

return;

if (list1->active)

focus += "/Groups";

else

focus += "/Items";

}

DEFINE_GET_FOCUS_STRING_HANDLER(stores)

{

if (!screen->in_right_list)

focus += "/Categories";

else if (screen->in_group_mode)

focus += "/Groups";

else

focus += "/Items";

}

DEFINE_GET_FOCUS_STRING_HANDLER(layer_stockpile)

{

auto list1 = getLayerList(screen, 0);

auto list2 = getLayerList(screen, 1);

auto list3 = getLayerList(screen, 2);

if (!list1 || !list2 || !list3 || !screen->settings) return;

auto group = screen->cur_group;

if (group != vector_get(screen->group_ids, list1->cursor))

return;

focus += "/" + enum_item_key(group);

auto bits = vector_get(screen->group_bits, list1->cursor);

if (bits.whole && !(bits.whole & screen->settings->flags.whole))

{

focus += "/Off";

return;

}

focus += "/On";

if (list2->active || list3->active || screen->list_ids.empty()) {

focus += "/" + enum_item_key(screen->cur_list);

if (list3->active)

focus += (screen->item_names.empty() ? "/None" : "/Item");

}

}

DEFINE_GET_FOCUS_STRING_HANDLER(locations)

{

focus += "/" + enum_item_key(screen->menu);

}

DEFINE_GET_FOCUS_STRING_HANDLER(jobmanagement)

{

focus += (screen->in_max_workshops ? "/MaxWorkshops" : "/Main");

}

DEFINE_GET_FOCUS_STRING_HANDLER(workquota_condition)

{

focus += "/" + enum_item_key(screen->mode);

if (screen->item_count_edit)

focus += "/EditCount";

}

std::string Gui::getFocusString(df::viewscreen *top)

{

if (!top)

return "";

if (dfhack_viewscreen::is_instance(top))

{

auto name = static_cast<dfhack_viewscreen*>(top)->getFocusString();

return name.empty() ? "dfhack" : "dfhack/"+name;

}

else if (virtual_identity *id = virtual_identity::get(top))

{

std::string name = getNameChunk(id, 11, 2);

auto handler = map_find(getFocusStringHandlers, id);

if (handler)

handler(name, top);

return name;

}

else

{

Core &core = Core::getInstance();

std::string name = core.p->readClassName(*(void**)top);

return name.substr(11, name.size()-11-2);

}

}

// Predefined common guard functions

bool Gui::default_hotkey(df::viewscreen *top)

{

// Default hotkey guard function

for (;top ;top = top->parent)

{

if (strict_virtual_cast<df::viewscreen_dwarfmodest>(top))

return true;

if (strict_virtual_cast<df::viewscreen_dungeonmodest>(top))

return true;

}

return false;

}

bool Gui::dwarfmode_hotkey(df::viewscreen *top)

{

// Require the main dwarf mode screen

return !!strict_virtual_cast<df::viewscreen_dwarfmodest>(top);

}

bool Gui::unitjobs_hotkey(df::viewscreen *top)

{

// Require the unit or jobs list

return !!strict_virtual_cast<df::viewscreen_joblistst>(top) ||

!!strict_virtual_cast<df::viewscreen_unitlistst>(top);

}

bool Gui::item_details_hotkey(df::viewscreen *top)

{

// Require the main dwarf mode screen

return !!strict_virtual_cast<df::viewscreen_itemst>(top);

}

static bool has_cursor()

{

return df::global::cursor && df::global::cursor->x != -30000;

}

bool Gui::cursor_hotkey(df::viewscreen *top)

{

if (!dwarfmode_hotkey(top))

return false;

// Also require the cursor.

if (!has_cursor())

return false;

return true;

}

bool Gui::workshop_job_hotkey(df::viewscreen *top)

{

using namespace ui_sidebar_mode;

using df::global::ui;

using df::global::world;

using df::global::ui_workshop_in_add;

using df::global::ui_workshop_job_cursor;

if (!dwarfmode_hotkey(top))

return false;

switch (ui->main.mode) {

case QueryBuilding:

{

if (!ui_workshop_job_cursor) // allow missing

return false;

df::building *selected = world->selected_building;

if (!virtual_cast<df::building_workshopst>(selected) &&

!virtual_cast<df::building_furnacest>(selected))

return false;

// No jobs?

if (selected->jobs.empty() ||

selected->jobs[0]->job_type == job_type::DestroyBuilding)

return false;

// Add job gui activated?

if (ui_workshop_in_add && *ui_workshop_in_add)

return false;

return true;

};

default:

return false;

}

}

bool Gui::build_selector_hotkey(df::viewscreen *top)

{

using namespace ui_sidebar_mode;

using df::global::ui;

using df::global::ui_build_selector;

if (!dwarfmode_hotkey(top))

return false;

switch (ui->main.mode) {

case Build:

{

if (!ui_build_selector) // allow missing

return false;

// Not selecting, or no choices?

if (ui_build_selector->building_type < 0 ||

ui_build_selector->stage != 2 ||

ui_build_selector->choices.empty())

return false;

return true;

};

default:

return false;

}

}

bool Gui::view_unit_hotkey(df::viewscreen *top)

{

using df::global::ui;

using df::global::world;

using df::global::ui_selected_unit;

if (!dwarfmode_hotkey(top))

return false;

if (ui->main.mode != ui_sidebar_mode::ViewUnits)

return false;

if (!ui_selected_unit) // allow missing

return false;

return vector_get(world->units.active, *ui_selected_unit) != NULL;

}

bool Gui::unit_inventory_hotkey(df::viewscreen *top)

{

using df::global::ui_unit_view_mode;

if (!view_unit_hotkey(top))

return false;

if (!ui_unit_view_mode)

return false;

return ui_unit_view_mode->value == df::ui_unit_view_mode::Inventory;

}

df::job *Gui::getSelectedWorkshopJob(color_ostream &out, bool quiet)

{

using df::global::world;

using df::global::ui_workshop_job_cursor;

if (!workshop_job_hotkey(Core::getTopViewscreen())) {

if (!quiet)

out.printerr("Not in a workshop, or no job is highlighted.\n");

return NULL;

}

df::building *selected = world->selected_building;

int idx = *ui_workshop_job_cursor;

if (size_t(idx) >= selected->jobs.size())

{

out.printerr("Invalid job cursor index: %d\n", idx);

return NULL;

}

return selected->jobs[idx];

}

bool Gui::any_job_hotkey(df::viewscreen *top)

{

if (VIRTUAL_CAST_VAR(screen, df::viewscreen_joblistst, top))

return vector_get(screen->jobs, screen->cursor_pos) != NULL;

if (VIRTUAL_CAST_VAR(screen, df::viewscreen_unitlistst, top))

return vector_get(screen->jobs[screen->page], screen->cursor_pos[screen->page]) != NULL;

return workshop_job_hotkey(top);

}

df::job *Gui::getSelectedJob(color_ostream &out, bool quiet)

{

df::viewscreen *top = Core::getTopViewscreen();

if (VIRTUAL_CAST_VAR(screen, df::viewscreen_jobst, top))

{

return screen->job;

}

if (VIRTUAL_CAST_VAR(joblist, df::viewscreen_joblistst, top))

{

df::job *job = vector_get(joblist->jobs, joblist->cursor_pos);

if (!job && !quiet)

out.printerr("Selected unit has no job\n");

return job;

}

else if (VIRTUAL_CAST_VAR(unitlist, df::viewscreen_unitlistst, top))

{

int page = unitlist->page;

df::job *job = vector_get(unitlist->jobs[page], unitlist->cursor_pos[page]);

if (!job && !quiet)

out.printerr("Selected unit has no job\n");

return job;

}

else if (auto dfscreen = dfhack_viewscreen::try_cast(top))

return dfscreen->getSelectedJob();

else

return getSelectedWorkshopJob(out, quiet);

}

df::unit *Gui::getAnyUnit(df::viewscreen *top)

{

using namespace ui_sidebar_mode;

using df::global::ui;

using df::global::world;

using df::global::ui_look_cursor;

using df::global::ui_look_list;

using df::global::ui_selected_unit;

using df::global::ui_building_in_assign;

using df::global::ui_building_assign_units;

using df::global::ui_building_item_cursor;

if (VIRTUAL_CAST_VAR(screen, df::viewscreen_unitst, top))

{

return screen->unit;

}

if (VIRTUAL_CAST_VAR(screen, df::viewscreen_joblistst, top))

{

if (auto unit = vector_get(screen->units, screen->cursor_pos))

return unit;

if (auto job = vector_get(screen->jobs, screen->cursor_pos))

return Job::getWorker(job);

return NULL;

}

if (VIRTUAL_CAST_VAR(screen, df::viewscreen_unitlistst, top))

return vector_get(screen->units[screen->page], screen->cursor_pos[screen->page]);

if (VIRTUAL_CAST_VAR(screen, df::viewscreen_dungeon_monsterstatusst, top))

return screen->unit;

if (VIRTUAL_CAST_VAR(screen, df::viewscreen_layer_unit_relationshipst, top))

{

if (VIRTUAL_CAST_VAR(list, df::layer_object_listst, vector_get(screen->layer_objects, 0)))

return vector_get(screen->relation_unit, list->cursor);

return NULL;

}

if (VIRTUAL_CAST_VAR(screen, df::viewscreen_itemst, top))

{

df::general_ref *ref = vector_get(screen->entry_ref, screen->cursor_pos);

return ref ? ref->getUnit() : NULL;

}

if (VIRTUAL_CAST_VAR(screen, df::viewscreen_workshop_profilest, top))

{

if (screen->tab == df::viewscreen_workshop_profilest::Workers)

return vector_get(screen->workers, screen->worker_idx);

return NULL;

}

if (VIRTUAL_CAST_VAR(screen, df::viewscreen_layer_noblelistst, top))

{

switch (screen->mode)

{

case df::viewscreen_layer_noblelistst::List:

if (auto list1 = getLayerList(screen, 0))

{

if (auto info = vector_get(screen->info, list1->cursor))

return info->unit;

}

return NULL;

case df::viewscreen_layer_noblelistst::Appoint:

if (auto list2 = getLayerList(screen, 1))

{

if (auto info = vector_get(screen->candidates, list2->cursor))

return info->unit;

}

return NULL;

default:

return NULL;

}

}

if (VIRTUAL_CAST_VAR(screen, df::viewscreen_locationsst, top))

{

switch (screen->menu)

{

case df::viewscreen_locationsst::AssignOccupation:

return vector_get(screen->units, screen->unit_idx);

case df::viewscreen_locationsst::Occupations:

{

auto occ = vector_get(screen->occupations, screen->occupation_idx);

if (occ)

return df::unit::find(occ->unit_id);

return NULL;

}

default:

return NULL;

}

}

if (VIRTUAL_CAST_VAR(screen, df::viewscreen_petst, top))

{

df::viewscreen_petst::T_animal animal_default;

animal_default.unit = NULL;

switch (screen->mode)

{

case df::viewscreen_petst::List:

if (!vector_get(screen->is_vermin, screen->cursor))

return vector_get(screen->animal, screen->cursor, animal_default).unit;

return NULL;

case df::viewscreen_petst::SelectTrainer:

return vector_get(screen->trainer_unit, screen->trainer_cursor);

default:

return NULL;

}

}

if (VIRTUAL_CAST_VAR(screen, df::viewscreen_layer_overall_healthst, top))

{

if (auto list1 = getLayerList(screen, 0))

return vector_get(screen->unit, list1->cursor);

return NULL;

}

if (VIRTUAL_CAST_VAR(screen, df::viewscreen_textviewerst, top))

{

if (screen->parent)

return getAnyUnit(screen->parent);

return NULL;

}

if (VIRTUAL_CAST_VAR(screen, df::viewscreen_reportlistst, top))

return vector_get(screen->units, screen->cursor);

if (VIRTUAL_CAST_VAR(screen, df::viewscreen_announcelistst, top))

{

if (world && screen->unit) {

// in (r)eports -> enter

auto *report = vector_get(screen->reports, screen->sel_idx);

if (report)

{

for (df::unit *unit : world->units.all)

{

if (unit && screen->report_type >= 0 && screen->report_type < 3

&& unit != screen->unit) // find 'other' unit related to this report

{

for (int32_t report_id : unit->reports.log[screen->report_type])

{

if (report_id == report->id)

return unit;

}

}

}

}

} else {

// in (a)nnouncements

return NULL; // cannot determine unit from reports

}

}

if (VIRTUAL_CAST_VAR(screen, df::viewscreen_layer_militaryst, top))

{

if (screen->page == df::viewscreen_layer_militaryst::T_page::Positions) {

auto positions = getLayerList(screen, 1);

if (positions && positions->enabled && positions->active)

return vector_get(screen->positions.assigned, positions->cursor);

auto candidates = getLayerList(screen, 2);

if (candidates && candidates->enabled && candidates->active)

return vector_get(screen->positions.candidates, candidates->cursor);

}

if (screen->page == df::viewscreen_layer_militaryst::T_page::Equip) {

auto positions = getLayerList(screen, 1);

if (positions && positions->enabled && positions->active)