2010-04-02 19:52:46 -06:00
|
|
|
/*
|
2011-06-16 15:53:39 -06:00
|
|
|
https://github.com/peterix/dfhack
|
|
|
|
Copyright (c) 2009-2011 Petr Mrázek (peterix@gmail.com)
|
2010-04-02 19:52:46 -06:00
|
|
|
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
|
2011-06-16 15:53:39 -06:00
|
|
|
|
2010-05-26 04:24:45 -06:00
|
|
|
#include "Internal.h"
|
2011-04-10 02:19:15 -06:00
|
|
|
|
|
|
|
#include <string>
|
|
|
|
#include <vector>
|
|
|
|
#include <map>
|
|
|
|
using namespace std;
|
|
|
|
|
2011-12-31 04:48:42 -07:00
|
|
|
#include "modules/Gui.h"
|
|
|
|
#include "MemAccess.h"
|
|
|
|
#include "VersionInfo.h"
|
|
|
|
#include "Types.h"
|
|
|
|
#include "Error.h"
|
2011-03-18 01:53:59 -06:00
|
|
|
#include "ModuleFactory.h"
|
2011-12-31 04:48:42 -07:00
|
|
|
#include "Core.h"
|
2011-12-31 05:09:12 -07:00
|
|
|
#include "PluginManager.h"
|
2012-01-14 08:31:43 -07:00
|
|
|
#include "MiscUtils.h"
|
2010-04-02 19:52:46 -06:00
|
|
|
using namespace DFHack;
|
|
|
|
|
2012-05-21 12:29:03 -06:00
|
|
|
#include "modules/Job.h"
|
|
|
|
|
2011-12-31 05:09:12 -07:00
|
|
|
#include "DataDefs.h"
|
2012-01-07 08:21:07 -07:00
|
|
|
#include "df/world.h"
|
2012-02-20 03:42:40 -07:00
|
|
|
#include "df/global_objects.h"
|
2011-12-31 05:09:12 -07:00
|
|
|
#include "df/viewscreen_dwarfmodest.h"
|
2012-03-10 04:55:42 -07:00
|
|
|
#include "df/viewscreen_dungeonmodest.h"
|
2012-04-07 09:08:30 -06:00
|
|
|
#include "df/viewscreen_dungeon_monsterstatusst.h"
|
2012-02-19 12:27:44 -07:00
|
|
|
#include "df/viewscreen_joblistst.h"
|
2012-02-20 06:53:39 -07:00
|
|
|
#include "df/viewscreen_unitlistst.h"
|
2012-01-14 08:31:43 -07:00
|
|
|
#include "df/viewscreen_itemst.h"
|
2012-04-26 01:05:35 -06:00
|
|
|
#include "df/viewscreen_layerst.h"
|
|
|
|
#include "df/viewscreen_layer_workshop_profilest.h"
|
|
|
|
#include "df/viewscreen_layer_noblelistst.h"
|
|
|
|
#include "df/viewscreen_layer_overall_healthst.h"
|
2012-05-18 07:54:05 -06:00
|
|
|
#include "df/viewscreen_layer_assigntradest.h"
|
2012-05-19 09:50:36 -06:00
|
|
|
#include "df/viewscreen_layer_militaryst.h"
|
2012-04-26 01:05:35 -06:00
|
|
|
#include "df/viewscreen_petst.h"
|
2012-05-18 07:54:05 -06:00
|
|
|
#include "df/viewscreen_tradegoodsst.h"
|
2012-05-21 12:29:03 -06:00
|
|
|
#include "df/viewscreen_storesst.h"
|
2012-01-14 08:31:43 -07:00
|
|
|
#include "df/ui_unit_view_mode.h"
|
|
|
|
#include "df/ui_sidebar_menus.h"
|
|
|
|
#include "df/ui_look_list.h"
|
2012-01-07 08:21:07 -07:00
|
|
|
#include "df/job.h"
|
|
|
|
#include "df/ui_build_selector.h"
|
|
|
|
#include "df/building_workshopst.h"
|
|
|
|
#include "df/building_furnacest.h"
|
2012-05-19 09:50:36 -06:00
|
|
|
#include "df/building_trapst.h"
|
|
|
|
#include "df/building_civzonest.h"
|
2012-01-14 08:31:43 -07:00
|
|
|
#include "df/general_ref.h"
|
|
|
|
#include "df/unit_inventory_item.h"
|
2012-01-15 04:19:20 -07:00
|
|
|
#include "df/report.h"
|
|
|
|
#include "df/popup_message.h"
|
2012-03-15 12:00:47 -06:00
|
|
|
#include "df/interfacest.h"
|
2012-01-24 21:18:21 -07:00
|
|
|
#include "df/graphic.h"
|
2012-04-26 01:05:35 -06:00
|
|
|
#include "df/layer_object_listst.h"
|
2012-05-18 07:54:05 -06:00
|
|
|
#include "df/assign_trade_status.h"
|
2012-01-07 08:21:07 -07:00
|
|
|
|
|
|
|
using namespace df::enums;
|
2012-01-24 21:18:21 -07:00
|
|
|
using df::global::gview;
|
|
|
|
using df::global::init;
|
|
|
|
using df::global::gps;
|
2012-05-19 09:50:36 -06:00
|
|
|
using df::global::ui;
|
|
|
|
using df::global::world;
|
2011-12-31 02:25:46 -07:00
|
|
|
|
2012-04-26 01:05:35 -06:00
|
|
|
static df::layer_object_listst *getLayerList(df::viewscreen_layerst *layer, int idx)
|
|
|
|
{
|
|
|
|
return virtual_cast<df::layer_object_listst>(vector_get(layer->layer_objects,idx));
|
|
|
|
}
|
|
|
|
|
2012-05-19 09:50:36 -06:00
|
|
|
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;
|
|
|
|
if (trap->trap_type == trap_type::Lever) {
|
|
|
|
focus += "/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";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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)
|
|
|
|
focus += "/Position";
|
|
|
|
else
|
|
|
|
{
|
|
|
|
focus += "/Material";
|
|
|
|
if (ui_build_selector->is_grouped)
|
|
|
|
focus += "/Groups";
|
|
|
|
else
|
|
|
|
focus += "/Items";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ViewUnits:
|
|
|
|
if (ui_selected_unit)
|
|
|
|
{
|
|
|
|
if (auto unit = 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_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;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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->bright) cur_list = 0;
|
|
|
|
else if (list2->bright) cur_list = 1;
|
|
|
|
else if (list3->bright) 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;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
DEFINE_GET_FOCUS_STRING_HANDLER(layer_workshop_profile)
|
|
|
|
{
|
|
|
|
auto list1 = getLayerList(screen, 0);
|
|
|
|
if (!list1) return;
|
|
|
|
|
|
|
|
if (vector_get(screen->workers, list1->cursor))
|
|
|
|
focus += "/Unit";
|
|
|
|
else
|
|
|
|
focus += "/None";
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
2012-05-21 12:29:03 -06:00
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
2012-05-19 09:50:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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->bright)
|
|
|
|
focus += "/Groups";
|
|
|
|
else
|
|
|
|
focus += "/Items";
|
|
|
|
}
|
|
|
|
|
2012-05-21 11:30:53 -06:00
|
|
|
DEFINE_GET_FOCUS_STRING_HANDLER(stores)
|
|
|
|
{
|
|
|
|
if (!screen->in_right_list)
|
|
|
|
focus += "/Categories";
|
|
|
|
else if (screen->in_group_mode)
|
|
|
|
focus += "/Groups";
|
|
|
|
else
|
|
|
|
focus += "/Items";
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-05-19 09:50:36 -06:00
|
|
|
std::string Gui::getFocusString(df::viewscreen *top)
|
|
|
|
{
|
2012-05-19 11:31:42 -06:00
|
|
|
if (!top)
|
|
|
|
return "";
|
2012-05-19 09:50:36 -06:00
|
|
|
|
2012-05-19 11:31:42 -06:00
|
|
|
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);
|
2012-05-19 09:50:36 -06:00
|
|
|
|
2012-05-19 11:31:42 -06:00
|
|
|
return name;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
Core &core = Core::getInstance();
|
|
|
|
std::string name = core.p->readClassName(*(void**)top);
|
|
|
|
return name.substr(11, name.size()-11-2);
|
|
|
|
}
|
2012-05-19 09:50:36 -06:00
|
|
|
}
|
|
|
|
|
2011-12-31 02:25:46 -07:00
|
|
|
// Predefined common guard functions
|
|
|
|
|
2012-03-10 04:55:42 -07:00
|
|
|
bool Gui::default_hotkey(df::viewscreen *top)
|
2011-12-31 02:25:46 -07:00
|
|
|
{
|
|
|
|
// Default hotkey guard function
|
|
|
|
for (;top ;top = top->parent)
|
2012-03-10 04:55:42 -07:00
|
|
|
{
|
2011-12-31 02:25:46 -07:00
|
|
|
if (strict_virtual_cast<df::viewscreen_dwarfmodest>(top))
|
|
|
|
return true;
|
2012-03-10 04:55:42 -07:00
|
|
|
if (strict_virtual_cast<df::viewscreen_dungeonmodest>(top))
|
|
|
|
return true;
|
|
|
|
}
|
2011-12-31 02:25:46 -07:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2012-03-10 04:55:42 -07:00
|
|
|
bool Gui::dwarfmode_hotkey(df::viewscreen *top)
|
2011-12-31 02:25:46 -07:00
|
|
|
{
|
|
|
|
// Require the main dwarf mode screen
|
|
|
|
return !!strict_virtual_cast<df::viewscreen_dwarfmodest>(top);
|
|
|
|
}
|
|
|
|
|
2012-03-10 04:55:42 -07:00
|
|
|
bool Gui::unitjobs_hotkey(df::viewscreen *top)
|
2012-01-14 08:31:43 -07:00
|
|
|
{
|
2012-02-20 06:53:39 -07:00
|
|
|
// Require the unit or jobs list
|
|
|
|
return !!strict_virtual_cast<df::viewscreen_joblistst>(top) ||
|
|
|
|
!!strict_virtual_cast<df::viewscreen_unitlistst>(top);
|
2012-01-14 08:31:43 -07:00
|
|
|
}
|
|
|
|
|
2012-03-10 04:55:42 -07:00
|
|
|
bool Gui::item_details_hotkey(df::viewscreen *top)
|
2012-01-14 08:31:43 -07:00
|
|
|
{
|
|
|
|
// Require the main dwarf mode screen
|
|
|
|
return !!strict_virtual_cast<df::viewscreen_itemst>(top);
|
|
|
|
}
|
|
|
|
|
2012-03-10 04:55:42 -07:00
|
|
|
bool Gui::cursor_hotkey(df::viewscreen *top)
|
2011-12-31 02:25:46 -07:00
|
|
|
{
|
2012-03-10 04:55:42 -07:00
|
|
|
if (!dwarfmode_hotkey(top))
|
2011-12-31 02:25:46 -07:00
|
|
|
return false;
|
|
|
|
|
|
|
|
// Also require the cursor.
|
|
|
|
if (!df::global::cursor || df::global::cursor->x == -30000)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2012-03-10 04:55:42 -07:00
|
|
|
bool Gui::workshop_job_hotkey(df::viewscreen *top)
|
2012-01-07 08:21:07 -07:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
|
2012-03-10 04:55:42 -07:00
|
|
|
if (!dwarfmode_hotkey(top))
|
2012-01-07 08:21:07 -07:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-03-10 04:55:42 -07:00
|
|
|
bool Gui::build_selector_hotkey(df::viewscreen *top)
|
2012-01-07 08:21:07 -07:00
|
|
|
{
|
|
|
|
using namespace ui_sidebar_mode;
|
|
|
|
using df::global::ui;
|
|
|
|
using df::global::ui_build_selector;
|
|
|
|
|
2012-03-10 04:55:42 -07:00
|
|
|
if (!dwarfmode_hotkey(top))
|
2012-01-07 08:21:07 -07:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-03-10 04:55:42 -07:00
|
|
|
bool Gui::view_unit_hotkey(df::viewscreen *top)
|
2012-01-14 08:31:43 -07:00
|
|
|
{
|
|
|
|
using df::global::ui;
|
|
|
|
using df::global::world;
|
|
|
|
using df::global::ui_selected_unit;
|
|
|
|
|
2012-03-10 04:55:42 -07:00
|
|
|
if (!dwarfmode_hotkey(top))
|
2012-01-14 08:31:43 -07:00
|
|
|
return false;
|
|
|
|
if (ui->main.mode != ui_sidebar_mode::ViewUnits)
|
|
|
|
return false;
|
|
|
|
if (!ui_selected_unit) // allow missing
|
|
|
|
return false;
|
|
|
|
|
2012-04-21 02:46:55 -06:00
|
|
|
return vector_get(world->units.active, *ui_selected_unit) != NULL;
|
2012-01-14 08:31:43 -07:00
|
|
|
}
|
|
|
|
|
2012-03-10 04:55:42 -07:00
|
|
|
bool Gui::unit_inventory_hotkey(df::viewscreen *top)
|
2012-01-14 08:31:43 -07:00
|
|
|
{
|
|
|
|
using df::global::ui_unit_view_mode;
|
|
|
|
|
2012-03-10 04:55:42 -07:00
|
|
|
if (!view_unit_hotkey(top))
|
2012-01-14 08:31:43 -07:00
|
|
|
return false;
|
|
|
|
if (!ui_unit_view_mode)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return ui_unit_view_mode->value == df::ui_unit_view_mode::Inventory;
|
|
|
|
}
|
|
|
|
|
2012-03-10 04:55:42 -07:00
|
|
|
df::job *Gui::getSelectedWorkshopJob(color_ostream &out, bool quiet)
|
2012-01-07 08:21:07 -07:00
|
|
|
{
|
|
|
|
using df::global::world;
|
|
|
|
using df::global::ui_workshop_job_cursor;
|
|
|
|
|
2012-03-10 04:55:42 -07:00
|
|
|
if (!workshop_job_hotkey(Core::getTopViewscreen())) {
|
2012-01-07 08:21:07 -07:00
|
|
|
if (!quiet)
|
2012-03-10 04:55:42 -07:00
|
|
|
out.printerr("Not in a workshop, or no job is highlighted.\n");
|
2012-01-07 08:21:07 -07:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
df::building *selected = world->selected_building;
|
|
|
|
int idx = *ui_workshop_job_cursor;
|
|
|
|
|
2012-04-20 03:30:37 -06:00
|
|
|
if (size_t(idx) >= selected->jobs.size())
|
2012-01-07 08:21:07 -07:00
|
|
|
{
|
2012-03-10 04:55:42 -07:00
|
|
|
out.printerr("Invalid job cursor index: %d\n", idx);
|
2012-01-07 08:21:07 -07:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return selected->jobs[idx];
|
|
|
|
}
|
|
|
|
|
2012-03-10 04:55:42 -07:00
|
|
|
bool Gui::any_job_hotkey(df::viewscreen *top)
|
2012-01-14 08:31:43 -07:00
|
|
|
{
|
2012-02-19 12:27:44 -07:00
|
|
|
if (VIRTUAL_CAST_VAR(screen, df::viewscreen_joblistst, top))
|
2012-01-14 08:31:43 -07:00
|
|
|
return vector_get(screen->jobs, screen->cursor_pos) != NULL;
|
|
|
|
|
2012-02-20 06:53:39 -07:00
|
|
|
if (VIRTUAL_CAST_VAR(screen, df::viewscreen_unitlistst, top))
|
|
|
|
return vector_get(screen->jobs[screen->page], screen->cursor_pos[screen->page]) != NULL;
|
|
|
|
|
2012-03-10 04:55:42 -07:00
|
|
|
return workshop_job_hotkey(top);
|
2012-01-14 08:31:43 -07:00
|
|
|
}
|
|
|
|
|
2012-03-10 04:55:42 -07:00
|
|
|
df::job *Gui::getSelectedJob(color_ostream &out, bool quiet)
|
2012-01-14 08:31:43 -07:00
|
|
|
{
|
2012-03-10 04:55:42 -07:00
|
|
|
df::viewscreen *top = Core::getTopViewscreen();
|
2012-01-14 08:31:43 -07:00
|
|
|
|
2012-02-29 17:29:55 -07:00
|
|
|
if (VIRTUAL_CAST_VAR(joblist, df::viewscreen_joblistst, top))
|
2012-01-14 08:31:43 -07:00
|
|
|
{
|
2012-02-29 17:29:55 -07:00
|
|
|
df::job *job = vector_get(joblist->jobs, joblist->cursor_pos);
|
2012-01-14 08:31:43 -07:00
|
|
|
|
|
|
|
if (!job && !quiet)
|
2012-03-10 04:55:42 -07:00
|
|
|
out.printerr("Selected unit has no job\n");
|
2012-01-14 08:31:43 -07:00
|
|
|
|
|
|
|
return job;
|
|
|
|
}
|
2012-02-29 17:29:55 -07:00
|
|
|
else if (VIRTUAL_CAST_VAR(unitlist, df::viewscreen_unitlistst, top))
|
2012-02-20 06:53:39 -07:00
|
|
|
{
|
2012-02-29 17:29:55 -07:00
|
|
|
int page = unitlist->page;
|
|
|
|
df::job *job = vector_get(unitlist->jobs[page], unitlist->cursor_pos[page]);
|
2012-02-20 06:53:39 -07:00
|
|
|
|
|
|
|
if (!job && !quiet)
|
2012-03-10 04:55:42 -07:00
|
|
|
out.printerr("Selected unit has no job\n");
|
2012-02-20 06:53:39 -07:00
|
|
|
|
|
|
|
return job;
|
|
|
|
}
|
2012-01-14 08:31:43 -07:00
|
|
|
else
|
2012-03-10 04:55:42 -07:00
|
|
|
return getSelectedWorkshopJob(out, quiet);
|
2012-01-14 08:31:43 -07:00
|
|
|
}
|
|
|
|
|
2012-03-10 04:55:42 -07:00
|
|
|
static df::unit *getAnyUnit(df::viewscreen *top)
|
2012-01-14 08:31:43 -07:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
|
2012-02-19 12:27:44 -07:00
|
|
|
if (VIRTUAL_CAST_VAR(screen, df::viewscreen_joblistst, top))
|
2012-05-21 12:29:03 -06:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
2012-01-14 08:31:43 -07:00
|
|
|
|
2012-02-20 06:53:39 -07:00
|
|
|
if (VIRTUAL_CAST_VAR(screen, df::viewscreen_unitlistst, top))
|
|
|
|
return vector_get(screen->units[screen->page], screen->cursor_pos[screen->page]);
|
|
|
|
|
2012-04-07 09:08:30 -06:00
|
|
|
if (VIRTUAL_CAST_VAR(screen, df::viewscreen_dungeon_monsterstatusst, top))
|
|
|
|
return screen->unit;
|
|
|
|
|
2012-01-14 08:31:43 -07:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2012-04-26 01:05:35 -06:00
|
|
|
if (VIRTUAL_CAST_VAR(screen, df::viewscreen_layer_workshop_profilest, top))
|
|
|
|
{
|
|
|
|
if (auto list1 = getLayerList(screen, 0))
|
|
|
|
return vector_get(screen->workers, list1->cursor);
|
|
|
|
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_petst, top))
|
|
|
|
{
|
|
|
|
switch (screen->mode)
|
|
|
|
{
|
|
|
|
case df::viewscreen_petst::List:
|
|
|
|
if (!vector_get(screen->is_vermin, screen->cursor))
|
|
|
|
return (df::unit*)vector_get(screen->animal, screen->cursor);
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2012-03-10 04:55:42 -07:00
|
|
|
if (!Gui::dwarfmode_hotkey(top))
|
2012-01-14 08:31:43 -07:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
switch (ui->main.mode) {
|
|
|
|
case ViewUnits:
|
|
|
|
{
|
|
|
|
if (!ui_selected_unit)
|
|
|
|
return NULL;
|
|
|
|
|
2012-04-21 02:46:55 -06:00
|
|
|
return vector_get(world->units.active, *ui_selected_unit);
|
2012-01-14 08:31:43 -07:00
|
|
|
}
|
|
|
|
case LookAround:
|
|
|
|
{
|
|
|
|
if (!ui_look_list || !ui_look_cursor)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
auto item = vector_get(ui_look_list->items, *ui_look_cursor);
|
|
|
|
if (item && item->type == df::ui_look_list::T_items::Unit)
|
|
|
|
return item->unit;
|
|
|
|
else
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-03-10 04:55:42 -07:00
|
|
|
bool Gui::any_unit_hotkey(df::viewscreen *top)
|
2012-01-14 08:31:43 -07:00
|
|
|
{
|
2012-03-10 04:55:42 -07:00
|
|
|
return getAnyUnit(top) != NULL;
|
2012-01-14 08:31:43 -07:00
|
|
|
}
|
|
|
|
|
2012-03-10 04:55:42 -07:00
|
|
|
df::unit *Gui::getSelectedUnit(color_ostream &out, bool quiet)
|
2012-01-14 08:31:43 -07:00
|
|
|
{
|
2012-03-10 04:55:42 -07:00
|
|
|
df::unit *unit = getAnyUnit(Core::getTopViewscreen());
|
2012-01-14 08:31:43 -07:00
|
|
|
|
|
|
|
if (!unit && !quiet)
|
2012-03-10 04:55:42 -07:00
|
|
|
out.printerr("No unit is selected in the UI.\n");
|
2012-01-14 08:31:43 -07:00
|
|
|
|
|
|
|
return unit;
|
|
|
|
}
|
|
|
|
|
2012-03-10 04:55:42 -07:00
|
|
|
static df::item *getAnyItem(df::viewscreen *top)
|
2012-01-14 08:31:43 -07:00
|
|
|
{
|
|
|
|
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_unit_view_mode;
|
|
|
|
using df::global::ui_building_item_cursor;
|
|
|
|
using df::global::ui_sidebar_menus;
|
|
|
|
|
|
|
|
if (VIRTUAL_CAST_VAR(screen, df::viewscreen_itemst, top))
|
|
|
|
{
|
|
|
|
df::general_ref *ref = vector_get(screen->entry_ref, screen->cursor_pos);
|
|
|
|
return ref ? ref->getItem() : NULL;
|
|
|
|
}
|
|
|
|
|
2012-05-18 07:54:05 -06:00
|
|
|
if (VIRTUAL_CAST_VAR(screen, df::viewscreen_layer_assigntradest, top))
|
|
|
|
{
|
|
|
|
auto list1 = getLayerList(screen, 0);
|
|
|
|
auto list2 = getLayerList(screen, 1);
|
|
|
|
if (!list1 || !list2 || !list2->bright)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
int list_idx = vector_get(screen->visible_lists, list1->cursor, (int16_t)-1);
|
|
|
|
unsigned num_lists = sizeof(screen->lists)/sizeof(std::vector<int32_t>);
|
|
|
|
if (unsigned(list_idx) >= num_lists)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
int idx = vector_get(screen->lists[list_idx], list2->cursor, -1);
|
|
|
|
if (auto info = vector_get(screen->info, idx))
|
|
|
|
return info->item;
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (VIRTUAL_CAST_VAR(screen, df::viewscreen_tradegoodsst, top))
|
|
|
|
{
|
|
|
|
if (screen->in_right_pane)
|
|
|
|
return vector_get(screen->broker_items, screen->broker_cursor);
|
|
|
|
else
|
|
|
|
return vector_get(screen->trader_items, screen->trader_cursor);
|
|
|
|
}
|
|
|
|
|
2012-05-21 12:29:03 -06:00
|
|
|
if (VIRTUAL_CAST_VAR(screen, df::viewscreen_storesst, top))
|
|
|
|
{
|
|
|
|
if (screen->in_right_list && !screen->in_group_mode)
|
|
|
|
return vector_get(screen->items, screen->item_cursor);
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2012-03-10 04:55:42 -07:00
|
|
|
if (!Gui::dwarfmode_hotkey(top))
|
2012-01-14 08:31:43 -07:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
switch (ui->main.mode) {
|
|
|
|
case ViewUnits:
|
|
|
|
{
|
|
|
|
if (!ui_unit_view_mode || !ui_look_cursor || !ui_sidebar_menus)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (ui_unit_view_mode->value != df::ui_unit_view_mode::Inventory)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
auto inv_item = vector_get(ui_sidebar_menus->unit.inv_items, *ui_look_cursor);
|
|
|
|
return inv_item ? inv_item->item : NULL;
|
|
|
|
}
|
|
|
|
case LookAround:
|
|
|
|
{
|
|
|
|
if (!ui_look_list || !ui_look_cursor)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
auto item = vector_get(ui_look_list->items, *ui_look_cursor);
|
|
|
|
if (item && item->type == df::ui_look_list::T_items::Item)
|
|
|
|
return item->item;
|
|
|
|
else
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
case BuildingItems:
|
|
|
|
{
|
|
|
|
if (!ui_building_item_cursor)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
VIRTUAL_CAST_VAR(selected, df::building_actual, world->selected_building);
|
|
|
|
if (!selected)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
auto inv_item = vector_get(selected->contained_items, *ui_building_item_cursor);
|
|
|
|
return inv_item ? inv_item->item : NULL;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-03-10 04:55:42 -07:00
|
|
|
bool Gui::any_item_hotkey(df::viewscreen *top)
|
2012-01-14 08:31:43 -07:00
|
|
|
{
|
2012-03-10 04:55:42 -07:00
|
|
|
return getAnyItem(top) != NULL;
|
2012-01-14 08:31:43 -07:00
|
|
|
}
|
|
|
|
|
2012-03-10 04:55:42 -07:00
|
|
|
df::item *Gui::getSelectedItem(color_ostream &out, bool quiet)
|
2012-01-14 08:31:43 -07:00
|
|
|
{
|
2012-03-10 04:55:42 -07:00
|
|
|
df::item *item = getAnyItem(Core::getTopViewscreen());
|
2012-01-14 08:31:43 -07:00
|
|
|
|
|
|
|
if (!item && !quiet)
|
2012-03-10 04:55:42 -07:00
|
|
|
out.printerr("No item is selected in the UI.\n");
|
2012-01-14 08:31:43 -07:00
|
|
|
|
|
|
|
return item;
|
|
|
|
}
|
|
|
|
|
2011-12-31 02:25:46 -07:00
|
|
|
//
|
|
|
|
|
2012-03-03 06:38:24 -07:00
|
|
|
void Gui::showAnnouncement(std::string message, int color, bool bright)
|
2012-01-15 04:19:20 -07:00
|
|
|
{
|
|
|
|
using df::global::world;
|
|
|
|
using df::global::cur_year;
|
|
|
|
using df::global::cur_year_tick;
|
|
|
|
|
|
|
|
int year = 0, year_time = 0;
|
|
|
|
|
|
|
|
if (cur_year && cur_year_tick)
|
|
|
|
{
|
|
|
|
year = *cur_year;
|
|
|
|
year_time = *cur_year_tick;
|
|
|
|
}
|
|
|
|
else if (!world->status.reports.empty())
|
|
|
|
{
|
|
|
|
// Fallback: copy from the last report
|
|
|
|
df::report *last = world->status.reports.back();
|
|
|
|
year = last->year;
|
|
|
|
year_time = last->time;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool continued = false;
|
|
|
|
|
|
|
|
while (!message.empty())
|
|
|
|
{
|
|
|
|
df::report *new_rep = new df::report();
|
|
|
|
|
|
|
|
new_rep->color = color;
|
|
|
|
new_rep->bright = bright;
|
|
|
|
new_rep->year = year;
|
|
|
|
new_rep->time = year_time;
|
|
|
|
|
|
|
|
new_rep->flags.bits.continuation = continued;
|
|
|
|
new_rep->flags.bits.announcement = true;
|
|
|
|
|
|
|
|
int size = std::min(message.size(), 73U);
|
|
|
|
new_rep->text = message.substr(0, size);
|
|
|
|
message = message.substr(size);
|
|
|
|
|
|
|
|
continued = true;
|
|
|
|
|
|
|
|
// Add the object to the lists
|
|
|
|
new_rep->id = world->status.next_report_id++;
|
|
|
|
|
|
|
|
world->status.reports.push_back(new_rep);
|
|
|
|
world->status.announcements.push_back(new_rep);
|
|
|
|
world->status.display_timer = 2000;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2012-03-03 06:38:24 -07:00
|
|
|
void Gui::showPopupAnnouncement(std::string message, int color, bool bright)
|
2012-01-15 04:19:20 -07:00
|
|
|
{
|
|
|
|
using df::global::world;
|
|
|
|
|
|
|
|
df::popup_message *popup = new df::popup_message();
|
|
|
|
popup->text = message;
|
|
|
|
popup->color = color;
|
|
|
|
popup->bright = bright;
|
|
|
|
world->status.popups.push_back(popup);
|
|
|
|
}
|
|
|
|
|
2012-01-24 21:18:21 -07:00
|
|
|
df::viewscreen * Gui::GetCurrentScreen()
|
2010-04-02 19:52:46 -06:00
|
|
|
{
|
2012-01-24 21:18:21 -07:00
|
|
|
df::viewscreen * ws = &gview->view;
|
2011-07-09 03:33:58 -06:00
|
|
|
while(ws)
|
2010-04-02 19:52:46 -06:00
|
|
|
{
|
2011-07-09 03:33:58 -06:00
|
|
|
if(ws->child)
|
|
|
|
ws = ws->child;
|
|
|
|
else
|
|
|
|
return ws;
|
2010-04-02 19:52:46 -06:00
|
|
|
}
|
2011-07-09 03:33:58 -06:00
|
|
|
return 0;
|
2010-04-02 19:52:46 -06:00
|
|
|
}
|
2011-03-18 04:09:26 -06:00
|
|
|
|
|
|
|
bool Gui::getViewCoords (int32_t &x, int32_t &y, int32_t &z)
|
|
|
|
{
|
2012-03-03 06:38:24 -07:00
|
|
|
x = *df::global::window_x;
|
|
|
|
y = *df::global::window_y;
|
|
|
|
z = *df::global::window_z;
|
2011-03-18 04:09:26 -06:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Gui::setViewCoords (const int32_t x, const int32_t y, const int32_t z)
|
|
|
|
{
|
2012-03-03 06:38:24 -07:00
|
|
|
(*df::global::window_x) = x;
|
|
|
|
(*df::global::window_y) = y;
|
|
|
|
(*df::global::window_z) = z;
|
2011-03-18 04:09:26 -06:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Gui::getCursorCoords (int32_t &x, int32_t &y, int32_t &z)
|
|
|
|
{
|
2012-01-24 21:18:21 -07:00
|
|
|
x = df::global::cursor->x;
|
|
|
|
y = df::global::cursor->y;
|
|
|
|
z = df::global::cursor->z;
|
2012-03-03 06:38:24 -07:00
|
|
|
return (x == -30000) ? false : true;
|
2011-03-18 04:09:26 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
//FIXME: confine writing of coords to map bounds?
|
|
|
|
bool Gui::setCursorCoords (const int32_t x, const int32_t y, const int32_t z)
|
|
|
|
{
|
2012-01-24 21:18:21 -07:00
|
|
|
df::global::cursor->x = x;
|
|
|
|
df::global::cursor->y = y;
|
|
|
|
df::global::cursor->z = z;
|
2011-03-18 04:09:26 -06:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2011-09-25 19:39:27 -06:00
|
|
|
bool Gui::getDesignationCoords (int32_t &x, int32_t &y, int32_t &z)
|
|
|
|
{
|
2012-01-24 21:18:21 -07:00
|
|
|
x = df::global::selection_rect->start_x;
|
|
|
|
y = df::global::selection_rect->start_y;
|
|
|
|
z = df::global::selection_rect->start_z;
|
2012-03-03 06:38:24 -07:00
|
|
|
return (x == -30000) ? false : true;
|
2011-09-25 19:39:27 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
bool Gui::setDesignationCoords (const int32_t x, const int32_t y, const int32_t z)
|
|
|
|
{
|
2012-01-24 21:18:21 -07:00
|
|
|
df::global::selection_rect->start_x = x;
|
|
|
|
df::global::selection_rect->start_y = y;
|
|
|
|
df::global::selection_rect->start_z = z;
|
2011-09-25 19:39:27 -06:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Gui::getMousePos (int32_t & x, int32_t & y)
|
|
|
|
{
|
2012-01-24 21:18:21 -07:00
|
|
|
x = gps->mouse_x;
|
|
|
|
y = gps->mouse_y;
|
2012-03-03 06:38:24 -07:00
|
|
|
return (x == -1) ? false : true;
|
2011-09-25 19:39:27 -06:00
|
|
|
}
|
|
|
|
|
2011-03-18 04:09:26 -06:00
|
|
|
bool Gui::getWindowSize (int32_t &width, int32_t &height)
|
|
|
|
{
|
2012-01-24 21:18:21 -07:00
|
|
|
width = gps->dimx;
|
|
|
|
height = gps->dimy;
|
2011-03-18 04:09:26 -06:00
|
|
|
return true;
|
2012-02-22 00:30:44 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
bool Gui::getMenuWidth(uint8_t &menu_width, uint8_t &area_map_width)
|
|
|
|
{
|
2012-03-03 06:38:24 -07:00
|
|
|
menu_width = *df::global::ui_menu_width;
|
|
|
|
area_map_width = *df::global::ui_area_map_width;
|
2012-02-22 00:30:44 -07:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Gui::setMenuWidth(const uint8_t menu_width, const uint8_t area_map_width)
|
|
|
|
{
|
2012-03-03 06:38:24 -07:00
|
|
|
*df::global::ui_menu_width = menu_width;
|
|
|
|
*df::global::ui_area_map_width = area_map_width;
|
2012-02-22 00:30:44 -07:00
|
|
|
return true;
|
2011-03-18 04:09:26 -06:00
|
|
|
}
|