#include "PluginManager.h"

using std::vector;

using std::string;

using namespace DFHack;

DFHACK_PLUGIN("stocks");

/*

#include "uicommon.h"

#include "listcolumn.h"

#include <functional>

// DF data structure definition headers

#include "DataDefs.h"

#include "Types.h"

#include "df/item.h"

#include "df/viewscreen_dwarfmodest.h"

#include "df/viewscreen_storesst.h"

#include "df/items_other_id.h"

#include "df/job.h"

#include "df/unit.h"

#include "df/world.h"

#include "df/item_quality.h"

#include "df/caravan_state.h"

#include "df/mandate.h"

#include "df/general_ref_building_holderst.h"

#include "modules/Gui.h"

#include "modules/Items.h"

#include "modules/Job.h"

#include "modules/World.h"

#include "modules/Screen.h"

#include "modules/Maps.h"

#include "modules/Units.h"

#include "df/building_cagest.h"

#include "df/adventurest.h"

DFHACK_PLUGIN("stocks");

#define PLUGIN_VERSION 0.13

REQUIRE_GLOBAL(world);

DFhackCExport command_result plugin_shutdown ( color_ostream &out )

{

return CR_OK;

}

#define MAX_NAME 30

#define SIDEBAR_WIDTH 30

*/

/*

* Utility

*/

/*

static string get_quality_name(const df::item_quality quality)

{

if (gps->dimx - SIDEBAR_WIDTH < 60)

return int_to_string(quality);

else

return ENUM_KEY_STR(item_quality, quality);

}

static df::item *get_container_of(df::item *item)

{

auto container = Items::getContainer(item);

return (container) ? container : item;

}

static df::item *get_container_of(df::unit *unit)

{

auto ref = Units::getGeneralRef(unit, general_ref_type::CONTAINED_IN_ITEM);

return (ref) ? ref->getItem() : nullptr;

}

*/

/*

* Trade Info

*/

/*

class TradeDepotInfo

{

public:

TradeDepotInfo()

{

reset();

}

void prepareTradeVariables()

{

reset();

for(auto bld_it = world->buildings.all.begin(); bld_it != world->buildings.all.end(); bld_it++)

{

auto bld = *bld_it;

if (!isUsableDepot(bld))

continue;

depot = bld;

id = depot->id;

trade_possible = can_trade();

break;

}

}

bool assignItem(vector<df::item *> &entries)

{

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

{

auto item = *it;

item = get_container_of(item);

if (!Items::canTradeWithContents(item))

return false;

auto href = df::allocate<df::general_ref_building_holderst>();

if (!href)

return false;

auto job = new df::job();

df::coord tpos(depot->centerx, depot->centery, depot->z);

job->pos = tpos;

job->job_type = job_type::BringItemToDepot;

// job <-> item link

if (!Job::attachJobItem(job, item, df::job_item_ref::Hauled))

{

delete job;

delete href;

return false;

}

// job <-> building link

href->building_id = id;

depot->jobs.push_back(job);

job->general_refs.push_back(href);

// add to job list

Job::linkIntoWorld(job);

}

return true;

}

void reset()

{

depot = 0;

trade_possible = false;

}

bool canTrade()

{

return trade_possible;

}

private:

int32_t id;

df::building *depot;

bool trade_possible;

bool isUsableDepot(df::building* bld)

{

if (bld->getType() != building_type::TradeDepot)

return false;

if (bld->getBuildStage() < bld->getMaxBuildStage())

return false;

if (bld->jobs.size() == 1 && bld->jobs[0]->job_type == job_type::DestroyBuilding)

return false;

return true;

}

};

static TradeDepotInfo depot_info;

*/

/*

* Item manipulation

*/

/*

static map<df::item *, bool> items_in_cages;

static df::job *get_item_job(df::item *item)

{

auto ref = Items::getSpecificRef(item, specific_ref_type::JOB);

if (ref && ref->data.job)

return ref->data.job;

return nullptr;

}

static bool is_marked_for_trade(df::item *item, df::item *container = nullptr)

{

item = (container) ? container : get_container_of(item);

auto job = get_item_job(item);

if (!job)

return false;

return job->job_type == job_type::BringItemToDepot;

}

static bool is_in_inventory(df::item *item)

{

item = get_container_of(item);

return item->flags.bits.in_inventory;

}

static bool is_item_in_cage_cache(df::item *item)

{

return items_in_cages.find(item) != items_in_cages.end();

}

static string get_item_label(df::item *item, bool truncate, bool trim)

{

auto label = Items::getBookTitle(item);

if (label == "")

{

label = Items::getDescription(item, 0, false);

}

if (trim && item->getType() == item_type::BIN)

{

auto pos = label.find("<#");

if (pos != string::npos)

{

label = label.substr(0, pos-1);

}

}

auto wear = item->getWear();

if (wear > 0)

{

string wearX;

switch (wear)

{

case 1:

wearX = "x";

break;

case 2:

wearX = "X";

break;

case 3:

wearX = "xX";

break;

default:

wearX = "XX";

break;

}

label = wearX + label + wearX;

}

label = pad_string(label, MAX_NAME, false, truncate);

return label;

}

static string get_keywords(df::item *item)

{

string keywords;

if (item->flags.bits.in_job)

keywords += "job ";

if (item->flags.bits.rotten)

keywords += "rotten ";

if (item->flags.bits.owned)

keywords += "owned ";

if (item->flags.bits.forbid)

keywords += "forbid ";

if (item->flags.bits.dump)

keywords += "dump ";

if (item->flags.bits.on_fire)

keywords += "fire ";

if (item->flags.bits.melt)

keywords += "melt ";

if (is_item_in_cage_cache(item))

keywords += "caged ";

if (is_in_inventory(item))

keywords += "inventory ";

if (depot_info.canTrade())

{

if (is_marked_for_trade(item))

keywords += "trade ";

}

return keywords + get_item_label(item, false, false);

}

struct item_grouped_entry

{

std::vector<df::item *> entries;

string getLabel(bool grouped) const

{

if (entries.size() == 0)

return "";

return get_item_label(entries[0], true, grouped);

}

string getKeywords() const

{

return get_keywords(entries[0]);

}

df::item *getFirstItem() const

{

if (entries.size() == 0)

return nullptr;

return entries[0];

}

bool canMelt() const

{

df::item *item = getFirstItem();

if (!item)

return false;

return can_melt(item);

}

bool isSetToMelt() const

{

df::item *item = getFirstItem();

if (!item)

return false;

return is_set_to_melt(item);

}

bool contains(df::item *item) const

{

return std::find(entries.begin(), entries.end(), item) != entries.end();

}

void setFlags(const df::item_flags flags, const bool state)

{

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

{

if (state)

(*it)->flags.whole |= flags.whole;

else

(*it)->flags.whole &= ~flags.whole;

}

}

bool isSingleItem()

{

return entries.size() == 1;

}

};

struct extra_filters

{

bool hide_trade_marked, hide_in_inventory, hide_in_cages;

extra_filters()

{

reset();

}

void reset()

{

hide_in_inventory = false;

hide_trade_marked = false;

}

};

static bool cages_populated = false;

static vector<df::building_cagest *> cages;

static void find_cages()

{

if (cages_populated)

return;

for (size_t b=0; b < world->buildings.all.size(); b++)

{

df::building* building = world->buildings.all[b];

if (building->getType() == building_type::Cage)

{

cages.push_back(static_cast<df::building_cagest *>(building));

}

}

cages_populated = true;

}

static df::building_cagest *is_in_cage(df::unit *unit)

{

find_cages();

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

{

auto cage = *it;

for (size_t c = 0; c < cage->assigned_units.size(); c++)

{

if(cage->assigned_units[c] == unit->id)

return cage;

}

}

return nullptr;

}

template <class T>

class StockListColumn : public ListColumn<T>

{

virtual void display_extras(const T &item_group, int32_t &x, int32_t &y) const

{

auto item = item_group->getFirstItem();

if (item->flags.bits.in_job)

OutputString(COLOR_LIGHTBLUE, x, y, "J");

else

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

if (item->flags.bits.rotten)

OutputString(COLOR_CYAN, x, y, "X");

else

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

if (item->flags.bits.owned)

OutputString(COLOR_GREEN, x, y, "O");

else

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

if (item->flags.bits.forbid)

OutputString(COLOR_RED, x, y, "F");

else

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

if (item->flags.bits.dump)

OutputString(COLOR_LIGHTMAGENTA, x, y, "D");

else

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

if (item->flags.bits.on_fire)

OutputString(COLOR_LIGHTRED, x, y, "R");

else

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

if (item->flags.bits.melt)

OutputString(COLOR_BLUE, x, y, "M");

else

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

if (is_in_inventory(item))

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

else

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

if (is_item_in_cage_cache(item))

OutputString(COLOR_LIGHTRED, x, y, "C");

else

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

if (depot_info.canTrade())

{

if (is_marked_for_trade(item))

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

else

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

}

if (item->isImproved())

OutputString(COLOR_BLUE, x, y, "* ");

else

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

auto quality = static_cast<df::item_quality>(item->getQuality());

if (quality > item_quality::Ordinary)

{

auto color = COLOR_BROWN;

switch(quality)

{

case item_quality::FinelyCrafted:

color = COLOR_CYAN;

break;

case item_quality::Superior:

color = COLOR_LIGHTBLUE;

break;

case item_quality::Exceptional:

color = COLOR_GREEN;

break;

case item_quality::Masterful:

color = COLOR_LIGHTGREEN;

break;

case item_quality::Artifact:

color = COLOR_BLUE;

break;

default:

break;

}

OutputString(color, x, y, get_quality_name(quality));

}

}

virtual bool validSearchInput (unsigned char c)

{

switch (c)

{

case '(':

case ')':

return true;

break;

default:

break;

}

string &search_string = ListColumn<T>::search_string;

if (c == '^' && !search_string.size())

return true;

else if (c == '$' && search_string.size())

{

if (search_string == "^")

return false;

if (search_string[search_string.size() - 1] != '$')

return true;

}

return ListColumn<T>::validSearchInput(c);

}

std::string getRawSearch(const std::string s)

{

string raw_search = s;

if (raw_search.size() && raw_search[0] == '^')

raw_search.erase(0, 1);

if (raw_search.size() && raw_search[raw_search.size() - 1] == '$')

raw_search.erase(raw_search.size() - 1, 1);

return toLower_cp437(raw_search);

}

virtual void tokenizeSearch (vector<string> *dest, const string search)

{

string raw_search = getRawSearch(search);

ListColumn<T>::tokenizeSearch(dest, raw_search);

}

virtual bool showEntry (const ListEntry<T> *entry, const vector<string> &search_tokens)

{

string &search_string = ListColumn<T>::search_string;

if (!search_string.size())

return true;

bool match_start = false, match_end = false;

string raw_search = getRawSearch(search_string);

if (search_string.size() && search_string[0] == '^')

match_start = true;

if (search_string.size() && search_string[search_string.size() - 1] == '$')

match_end = true;

if (!ListColumn<T>::showEntry(entry, search_tokens))

return false;

string item_name = toLower_cp437(Items::getBookTitle(entry->elem->entries[0]));

if (item_name == "")

{

item_name = toLower_cp437(Items::getDescription(entry->elem->entries[0], 0, false));

}

if ((match_start || match_end) && raw_search.size() > item_name.size())

return false;

if (match_start && item_name.compare(0, raw_search.size(), raw_search) != 0)

return false;

if (match_end && item_name.compare(item_name.size() - raw_search.size(), raw_search.size(), raw_search) != 0)

return false;

return true;

}

};

class search_help : public dfhack_viewscreen

{

public:

void feed (std::set<df::interface_key> *input)

{

if (input->count(interface_key::HELP))

return;

if (Screen::isDismissed(this))

return;

Screen::dismiss(this);

if (!input->count(interface_key::LEAVESCREEN) && !input->count(interface_key::SELECT))

parent->feed(input);

}

void render()

{

static std::string text =

"\7 Flag names can be\n"

" searched for - e.g. job,\n"

" inventory, dump, forbid\n"

"\n"

"\7 Use ^ to match the start\n"

" of a name, and/or $ to\n"

" match the end of a name";

if (Screen::isDismissed(this))

return;

parent->render();

int left_margin = gps->dimx - SIDEBAR_WIDTH;

int x = left_margin, y = 2;

Screen::fillRect(Screen::Pen(' ', 0, 0), left_margin - 1, 1, gps->dimx - 2, gps->dimy - 4);

Screen::fillRect(Screen::Pen(' ', 0, 0), left_margin - 1, 1, left_margin - 1, gps->dimy - 2);

OutputString(COLOR_WHITE, x, y, "Search help", true, left_margin);

++y;

vector<string> lines;

split_string(&lines, text, "\n");

for (auto line = lines.begin(); line != lines.end(); ++line)

OutputString(COLOR_WHITE, x, y, line->c_str(), true, left_margin);

}

std::string getFocusString() { return "stocks_view/search_help"; }

};

class ViewscreenStocks : public dfhack_viewscreen

{

public:

static df::item_flags hide_flags;

static extra_filters extra_hide_flags;

ViewscreenStocks(df::building_stockpilest *sp = NULL) : sp(sp)

{

is_grouped = true;

selected_column = 0;

items_column.multiselect = false;

items_column.auto_select = true;

items_column.allow_search = true;

items_column.left_margin = 2;

items_column.bottom_margin = 1;

items_column.search_margin = gps->dimx - SIDEBAR_WIDTH;

items_column.changeHighlight(0);

apply_to_all = false;

hide_unflagged = false;

checked_flags.bits.in_job = true;

checked_flags.bits.rotten = true;

checked_flags.bits.owned = true;

checked_flags.bits.forbid = true;

checked_flags.bits.dump = true;

checked_flags.bits.on_fire = true;

checked_flags.bits.melt = true;

checked_flags.bits.on_fire = true;

min_quality = item_quality::Ordinary;

max_quality = item_quality::Artifact;

min_wear = 0;

cages.clear();

items_in_cages.clear();

cages_populated = false;

last_selected_item = nullptr;

populateItems();

items_column.selectDefaultEntry();

}

static void reset()

{

hide_flags.whole = 0;

extra_hide_flags.reset();

depot_info.reset();

}

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

{

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

{

input->clear();

Screen::dismiss(this);

return;

}

else if (input->count(interface_key::HELP))

{

Screen::show(std::make_unique<search_help>(), plugin_self);

}

bool key_processed = false;

switch (selected_column)

{

case 0:

key_processed = items_column.feed(input);

break;

}

if (key_processed)

return;

if (input->count(interface_key::CUSTOM_CTRL_J))

{

hide_flags.bits.in_job = !hide_flags.bits.in_job;

populateItems();

}

else if (input->count(interface_key::CUSTOM_CTRL_X))

{

hide_flags.bits.rotten = !hide_flags.bits.rotten;

populateItems();

}

else if (input->count(interface_key::CUSTOM_CTRL_O))

{

hide_flags.bits.owned = !hide_flags.bits.owned;

populateItems();

}

else if (input->count(interface_key::CUSTOM_CTRL_F))

{

hide_flags.bits.forbid = !hide_flags.bits.forbid;

populateItems();

}

else if (input->count(interface_key::CUSTOM_CTRL_D))

{

hide_flags.bits.dump = !hide_flags.bits.dump;

populateItems();

}

else if (input->count(interface_key::CUSTOM_CTRL_E))

{

hide_flags.bits.on_fire = !hide_flags.bits.on_fire;

populateItems();

}

else if (input->count(interface_key::CUSTOM_CTRL_M))

{

hide_flags.bits.melt = !hide_flags.bits.melt;

populateItems();

}

else if (input->count(interface_key::CUSTOM_CTRL_I))

{

extra_hide_flags.hide_in_inventory = !extra_hide_flags.hide_in_inventory;

populateItems();

}

else if (input->count(interface_key::CUSTOM_CTRL_C))

{

extra_hide_flags.hide_in_cages = !extra_hide_flags.hide_in_cages;

populateItems();

}

else if (input->count(interface_key::CUSTOM_CTRL_T))

{

extra_hide_flags.hide_trade_marked = !extra_hide_flags.hide_trade_marked;

populateItems();

}

else if (input->count(interface_key::CUSTOM_CTRL_N))

{

hide_unflagged = !hide_unflagged;

populateItems();

}

else if (input->count(interface_key::CUSTOM_SHIFT_C))

{

setAllFlags(true);

populateItems();

}

else if (input->count(interface_key::CUSTOM_SHIFT_E))

{

setAllFlags(false);

populateItems();

}

else if (input->count(interface_key::CHANGETAB))

{

is_grouped = !is_grouped;

populateItems();

items_column.centerSelection();

}

else if (input->count(interface_key::SECONDSCROLL_UP))

{

if (min_quality > item_quality::Ordinary)

{

min_quality = static_cast<df::item_quality>(static_cast<int16_t>(min_quality) - 1);

populateItems();

}

}

else if (input->count(interface_key::SECONDSCROLL_DOWN))

{

if (min_quality < max_quality && min_quality < item_quality::Artifact)

{

min_quality = static_cast<df::item_quality>(static_cast<int16_t>(min_quality) + 1);

populateItems();

}

}

else if (input->count(interface_key::SECONDSCROLL_PAGEUP))

{

if (max_quality > min_quality && max_quality > item_quality::Ordinary)

{

max_quality = static_cast<df::item_quality>(static_cast<int16_t>(max_quality) - 1);

populateItems();

}

}

else if (input->count(interface_key::SECONDSCROLL_PAGEDOWN))

{

if (max_quality < item_quality::Artifact)

{

max_quality = static_cast<df::item_quality>(static_cast<int16_t>(max_quality) + 1);

populateItems();

}

}

else if (input->count(interface_key::CUSTOM_SHIFT_W))

{

++min_wear;

if (min_wear > 3)

min_wear = 0;

populateItems();

}

else if (input->count(interface_key::CUSTOM_SHIFT_Z))

{

input->clear();

auto item_group = items_column.getFirstSelectedElem();

if (!item_group)

return;

if (is_grouped && !item_group->isSingleItem())

return;

auto item = item_group->getFirstItem();

auto pos = getRealPos(item);

if (!isRealPos(pos))

return;

Screen::dismiss(this);

auto vs = Gui::getCurViewscreen(true);

while (vs && !virtual_cast<df::viewscreen_dwarfmodest>(vs))

{

Screen::dismiss(vs);

vs = vs->parent;

}

// Could be clever here, if item is in a container, to look inside the container.

// But that's different for built containers vs bags/pots in stockpiles.

send_key(interface_key::D_LOOK);

move_cursor(pos);

}

else if (input->count(interface_key::CUSTOM_SHIFT_A))

{

apply_to_all = !apply_to_all;

}

else if (input->count(interface_key::CUSTOM_SHIFT_D))

{

df::item_flags flags;

flags.bits.dump = true;

toggleFlag(flags);

populateItems();

}

else if (input->count(interface_key::CUSTOM_SHIFT_F))

{

df::item_flags flags;

flags.bits.forbid = true;

toggleFlag(flags);

populateItems();

}

else if (input->count(interface_key::CUSTOM_SHIFT_M))

{

toggleMelt();

populateItems();

}

else if (input->count(interface_key::CUSTOM_SHIFT_T))

{

if (depot_info.canTrade())

{

auto selected = getSelectedItems();

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

{

depot_info.assignItem((*it)->entries);

}

}

}

else if (input->count(interface_key::CURSOR_LEFT))

{

--selected_column;

validateColumn();

}

else if (input->count(interface_key::CURSOR_RIGHT))

{

selected_column++;

validateColumn();

}

else if (enabler->tracking_on && enabler->mouse_lbut)

{

if (items_column.setHighlightByMouse())

selected_column = 0;

enabler->mouse_lbut = enabler->mouse_rbut = 0;

}

}

void move_cursor(const df::coord &pos)

{

Gui::setCursorCoords(pos.x, pos.y, pos.z);

Gui::refreshSidebar();

}

void send_key(const df::interface_key &key)

{

set< df::interface_key > keys;

keys.insert(key);

Gui::getCurViewscreen(true)->feed(&keys);

}

void render()

{

if (Screen::isDismissed(this))

return;

dfhack_viewscreen::render();

Screen::clear();

Screen::drawBorder(" Stocks ");

items_column.display(selected_column == 0);

int32_t y = 1;

auto left_margin = gps->dimx - SIDEBAR_WIDTH;

int32_t x = left_margin - 2;

Screen::Pen border('\xDB', 8);

for (; y < gps->dimy - 1; y++)

{

paintTile(border, x, y);

}

y = 2;

x = left_margin;

OutputString(COLOR_BROWN, x, y, "Filters ", false, left_margin);

OutputString(COLOR_LIGHTRED, x, y, "(Ctrl+Key toggles)", true, left_margin);

OutputFilterString(x, y, "In Job ", "J", !hide_flags.bits.in_job, false, left_margin, COLOR_LIGHTBLUE);

OutputFilterString(x, y, "Rotten", "X", !hide_flags.bits.rotten, true, left_margin, COLOR_CYAN);

OutputFilterString(x, y, "Owned ", "O", !hide_flags.bits.owned, false, left_margin, COLOR_GREEN);

OutputFilterString(x, y, "Forbidden", "F", !hide_flags.bits.forbid, true, left_margin, COLOR_RED);

OutputFilterString(x, y, "Dump ", "D", !hide_flags.bits.dump, false, left_margin, COLOR_LIGHTMAGENTA);

OutputFilterString(x, y, "On Fire", "E", !hide_flags.bits.on_fire, true, left_margin, COLOR_LIGHTRED);

OutputFilterString(x, y, "Melt ", "M", !hide_flags.bits.melt, false, left_margin, COLOR_BLUE);

OutputFilterString(x, y, "In Inventory", "I", !extra_hide_flags.hide_in_inventory, true, left_margin, COLOR_WHITE);

OutputFilterString(x, y, "Caged ", "C", !extra_hide_flags.hide_in_cages, false, left_margin, COLOR_LIGHTRED);

OutputFilterString(x, y, "Trade", "T", !extra_hide_flags.hide_trade_marked, true, left_margin, COLOR_LIGHTGREEN);

OutputFilterString(x, y, "No Flags", "N", !hide_unflagged, true, left_margin, COLOR_GREY);

if (gps->dimy > 26)

++y;

OutputHotkeyString(x, y, "Clear All", "Shift-C", true, left_margin);

OutputHotkeyString(x, y, "Enable All", "Shift-E", true, left_margin);

OutputHotkeyString(x, y, "Toggle Grouping", interface_key::CHANGETAB, true, left_margin);

++y;

OutputHotkeyString(x, y, "Min Qual: ", "-+");

OutputString(COLOR_BROWN, x, y, get_quality_name(min_quality), true, left_margin);

OutputHotkeyString(x, y, "Max Qual: ", "/ *");

OutputString(COLOR_BROWN, x, y, get_quality_name(max_quality), true, left_margin);

OutputHotkeyString(x, y, "Min Wear: ", "Shift-W");

OutputString(COLOR_BROWN, x, y, int_to_string(min_wear), true, left_margin);

if (gps->dimy > 27)

++y;

OutputString(COLOR_BROWN, x, y, "Actions (");

OutputString(COLOR_LIGHTGREEN, x, y, int_to_string(items_column.getDisplayedListSize()));

OutputString(COLOR_BROWN, x, y, " Items)", true, left_margin);

OutputHotkeyString(x, y, "Zoom ", "Shift-Z", false, left_margin);

OutputHotkeyString(x, y, "Dump", "-D", true, left_margin);

OutputHotkeyString(x, y, "Forbid ", "Shift-F", false, left_margin);

OutputHotkeyString(x, y, "Melt", "-M", true, left_margin);

OutputHotkeyString(x, y, "Mark for Trade", "Shift-T", true, left_margin,

depot_info.canTrade() ? COLOR_WHITE : COLOR_DARKGREY);

OutputHotkeyString(x, y, "Apply to: ", "Shift-A");

OutputString(COLOR_BROWN, x, y, (apply_to_all) ? "Listed" : "Selected", true, left_margin);

y = gps->dimy - 4;

OutputHotkeyString(x, y, "Search help", interface_key::HELP, true, left_margin);

}

std::string getFocusString() { return "stocks_view"; }

df::item *getSelectedItem() override

{

if (is_grouped)

return nullptr;

vector<item_grouped_entry*> items = getSelectedItems();

if (items.size() != 1)

return nullptr;

if (items[0]->entries.size() != 1)

return nullptr;

return items[0]->entries[0];

}

private: