void display_search_results(std::vector<stash_search_result> &results);
    void show_stash_search_prompt();    

    bool display_search_results(std::vector<stash_search_result> &results,
                                const char* sort_style);
    void show_stash_search_prompt();

            cprintf("  [ENTER - travel]");

            cprintf("  [ENTER: travel]");

// helper for search_stashes
struct compare_by_distance
{
    bool operator()(const stash_search_result& lhs,
                    const stash_search_result& rhs)
    {
        if (lhs.player_distance != rhs.player_distance) {
            // Sort by increasing distance
            return (lhs.player_distance < rhs.player_distance);
        } else if (lhs.matches != rhs.matches) {
            // Then by decreasing number of matches
            return (lhs.matches > rhs.matches);
        } else {
            return false;
        }
    }
};
// helper for search_stashes
struct compare_by_name
{
    bool operator()(const stash_search_result& lhs,
                    const stash_search_result& rhs)
    {
        if (lhs.match != rhs.match) {
            // Sort by name
            return (lhs.match < rhs.match);
        } else if (lhs.player_distance != rhs.player_distance) {
            // Then sort by increasing distance
            return (lhs.player_distance < rhs.player_distance);
        } else if (lhs.matches != rhs.matches) {
            // Then by decreasing number of matches
            return (lhs.matches > rhs.matches);
        } else {
            return false;
        }
    }
};

    display_search_results(results);

    bool sort_by_dist = true;
    while (true)
    {
        const char* sort_style;
        if (sort_by_dist) {
            std::sort(results.begin(), results.end(), compare_by_distance());
            sort_style = "by dist";
        } else {
            std::sort(results.begin(), results.end(), compare_by_name());
            sort_style = "by name";
        }
        const bool again = display_search_results(results, sort_style);
        if (!again) break;
        sort_by_dist = !sort_by_dist;
    }

    // Sort stashes so that closer stashes come first and stashes on the same
    // levels with more items come first.
    std::sort(results.begin(), results.end());

    StashSearchMenu() : Menu(), can_travel(true), meta_key(0) { }

    StashSearchMenu(const char* sort_style_)
        : Menu(), can_travel(true),
          request_toggle_sort_method(false),
          menu_action(ACT_TRAVEL),
          sort_style(sort_style_)
    { }

    int meta_key;

    bool request_toggle_sort_method;
    enum action { ACT_TRAVEL, ACT_EXAMINE, ACT_NUM } menu_action;
    const char* sort_style;

        cprintf("%d %s%s", title->quantity, title->text.c_str(), 
                           title->quantity > 1? "es" : "");

        cprintf("%d %s%s, sorted %s",
                title->quantity, title->text.c_str(), 
                title->quantity > 1? "es" : "",
                sort_style);
        char buf[200];
        snprintf(buf, 200, 
                 "  [a-z: %s  ?: change action  /: change sort]",
                 menu_action == ACT_TRAVEL ? "travel" : "examine");

        if (meta_key)
            draw_title_suffix(" (x - examine)", false);
        else
            draw_title_suffix(" (x - travel; ? - examine)", false);

        draw_title_suffix(buf, false);

        meta_key  = !meta_key;

        menu_action = (action)((menu_action+1) % ACT_NUM);

    }
    else if (key == '/')
    {
        request_toggle_sort_method = true;
        return false;

void StashTracker::display_search_results(
        std::vector<stash_search_result> &results)

// Returns true to request redisplay with a different sort method
bool StashTracker::display_search_results(
    std::vector<stash_search_result> &results, 
    const char* sort_style)

        return;

        return false;

    StashSearchMenu stashmenu;

    StashSearchMenu stashmenu(sort_style);

        if (sel.size() == 1 && stashmenu.meta_key)

        if (stashmenu.request_toggle_sort_method)
        {
            return true;
        }
        if (sel.size() == 1 && stashmenu.menu_action == StashSearchMenu::ACT_EXAMINE)

                return ;

                return false;

    if (sel.size() == 1 && !stashmenu.meta_key)

    if (sel.size() == 1 && stashmenu.menu_action == StashSearchMenu::ACT_TRAVEL)

        return ;

        return false;

    return false;