OrcaSlicer/src/slic3r/GUI/Search.cpp

#include "Search.hpp"

#include <vector>
#include <cstddef>
#include <string>
#include <boost/algorithm/string.hpp>
#include <boost/optional.hpp>
#include <boost/nowide/convert.hpp>

#include "wx/dataview.h"
#include "wx/numformatter.h"
#include "Widgets/Label.hpp"

#include "libslic3r/PrintConfig.hpp"
#include "libslic3r/PresetBundle.hpp"
#include "GUI_App.hpp"
#include "Plater.hpp"
#include "Tab.hpp"

#define FTS_FUZZY_MATCH_IMPLEMENTATION
#include "fts_fuzzy_match.h"

#include "imgui/imconfig.h"

using boost::optional;

namespace Slic3r {

wxDEFINE_EVENT(wxCUSTOMEVT_JUMP_TO_OPTION, wxCommandEvent);
wxDEFINE_EVENT(wxCUSTOMEVT_EXIT_SEARCH, wxCommandEvent);

using GUI::from_u8;
using GUI::into_u8;

namespace Search {

static char marker_by_type(Preset::Type type, PrinterTechnology pt)
{
    switch (type) {
    case Preset::TYPE_PRINT:
    case Preset::TYPE_SLA_PRINT: return ImGui::PrintIconMarker;
    case Preset::TYPE_FILAMENT: return ImGui::FilamentIconMarker;
    case Preset::TYPE_SLA_MATERIAL: return ImGui::MaterialIconMarker;
    case Preset::TYPE_PRINTER: return pt == ptSLA ? ImGui::PrinterSlaIconMarker : ImGui::PrinterIconMarker;
    default: return ' ';
    }
}

std::string Option::opt_key() const { return boost::nowide::narrow(key).substr(2); }

void FoundOption::get_marked_label_and_tooltip(const char **label_, const char **tooltip_) const
{
    *label_   = marked_label.c_str();
    *tooltip_ = tooltip.c_str();
}

template<class T>
// void change_opt_key(std::string& opt_key, DynamicPrintConfig* config)
void change_opt_key(std::string &opt_key, DynamicPrintConfig *config, int &cnt)
{
    T *opt_cur = static_cast<T *>(config->option(opt_key));
    cnt        = opt_cur->values.size();
    return;

    if (opt_cur->values.size() > 0) opt_key += "#" + std::to_string(0);
}

static std::string get_key(const std::string &opt_key, Preset::Type type) { return std::to_string(int(type)) + ";" + opt_key; }

void OptionsSearcher::append_options(DynamicPrintConfig *config, Preset::Type type, ConfigOptionMode mode)
{
    auto emplace = [this, type](const std::string key, const wxString &label) {
        const GroupAndCategory &gc = groups_and_categories[key];
        if (gc.group.IsEmpty() || gc.category.IsEmpty()) return;

        wxString suffix;
        wxString suffix_local;
        if (gc.category == "Machine limits") {
            //suffix       = key.back() == '1' ? L("Stealth") : L("Normal");
            suffix       = key.back() == '1' ? wxEmptyString : wxEmptyString;
            suffix_local = " " + _(suffix);
            suffix       = " " + suffix;
        }

        if (!label.IsEmpty())
            options.emplace_back(Option{boost::nowide::widen(key), type, (label + suffix).ToStdWstring(), (_(label) + suffix_local).ToStdWstring(), gc.group.ToStdWstring(),
                                        _(gc.group).ToStdWstring(), gc.category.ToStdWstring(), GUI::Tab::translate_category(gc.category, type).ToStdWstring()});
    };

    for (std::string opt_key : config->keys()) {
        const ConfigOptionDef &opt = config->def()->options.at(opt_key);
        if (opt.mode > mode) continue;

        int cnt = 0;

        if ((type == Preset::TYPE_SLA_MATERIAL || type == Preset::TYPE_PRINTER) && opt_key != "printable_area")
            switch (config->option(opt_key)->type()) {
            case coInts: change_opt_key<ConfigOptionInts>(opt_key, config, cnt); break;
            case coBools: change_opt_key<ConfigOptionBools>(opt_key, config, cnt); break;
            case coFloats: change_opt_key<ConfigOptionFloats>(opt_key, config, cnt); break;
            case coStrings: change_opt_key<ConfigOptionStrings>(opt_key, config, cnt); break;
            case coPercents: change_opt_key<ConfigOptionPercents>(opt_key, config, cnt); break;
            case coPoints: change_opt_key<ConfigOptionPoints>(opt_key, config, cnt); break;
            // BBS
            case coEnums: change_opt_key<ConfigOptionInts>(opt_key, config, cnt); break;
            default: break;
            }

        wxString label = opt.full_label.empty() ? opt.label : opt.full_label;

        std::string key = get_key(opt_key, type);
        if (cnt == 0)
            emplace(key, label);
        else
            for (int i = 0; i < cnt; ++i)
                // ! It's very important to use "#". opt_key#n is a real option key used in GroupAndCategory
                emplace(key + "#" + std::to_string(i), label);
    }
}

// Mark a string using ColorMarkerStart and ColorMarkerEnd symbols
static std::wstring mark_string(const std::wstring &str, const std::vector<uint16_t> &matches, Preset::Type type, PrinterTechnology pt)
{
    std::wstring out;
    out += marker_by_type(type, pt);
    if (matches.empty())
        out += str;
    else {
        out.reserve(str.size() * 2);
        if (matches.front() > 0) out += str.substr(0, matches.front());
        for (size_t i = 0;;) {
            // Find the longest string of successive indices.
            size_t j = i + 1;
            while (j < matches.size() && matches[j] == matches[j - 1] + 1) ++j;
            out += ImGui::ColorMarkerStart;
            out += str.substr(matches[i], matches[j - 1] - matches[i] + 1);
            out += ImGui::ColorMarkerEnd;
            if (j == matches.size()) {
                out += str.substr(matches[j - 1] + 1);
                break;
            }
            out += str.substr(matches[j - 1] + 1, matches[j] - matches[j - 1] - 1);
            i = j;
        }
    }
    return out;
}

bool OptionsSearcher::search() { return search(search_line, true); }

static bool fuzzy_match(const std::wstring &search_pattern, const std::wstring &label, int &out_score, std::vector<uint16_t> &out_matches)
{
    uint16_t matches[fts::max_matches + 1]; // +1 for the stopper
    int      score;
    if (fts::fuzzy_match(search_pattern.c_str(), label.c_str(), score, matches)) {
        size_t cnt = 0;
        for (; matches[cnt] != fts::stopper; ++cnt)
            ;
        out_matches.assign(matches, matches + cnt);
        out_score = score;
        return true;
    } else
        return false;
}

bool OptionsSearcher::search(const std::string &search, bool force /* = false*/, Preset::Type type/* = Preset::TYPE_INVALID*/)
{
    if (search_line == search && search_type == type && !force) return false;

    found.clear();

    bool         full_list = search.empty();
    std::wstring sep       = L" : ";

    auto get_label = [this, &sep](const Option &opt, bool marked = true) {
        std::wstring out;
        if (marked) out += marker_by_type(opt.type, printer_technology);
        const std::wstring *prev = nullptr;
        for (const std::wstring *const s : {view_params.category ? &opt.category_local : nullptr, &opt.group_local, &opt.label_local})
            if (s != nullptr && (prev == nullptr || *prev != *s)) {
                if (out.size() > 2) out += sep;
                out += *s;
                prev = s;
            }
        return out;
    };

    auto get_label_english = [this, &sep](const Option &opt, bool marked = true) {
        std::wstring out;
        if (marked) out += marker_by_type(opt.type, printer_technology);
        const std::wstring *prev = nullptr;
        for (const std::wstring *const s : {view_params.category ? &opt.category : nullptr, &opt.group, &opt.label})
            if (s != nullptr && (prev == nullptr || *prev != *s)) {
                if (out.size() > 2) out += sep;
                out += *s;
                prev = s;
            }
        return out;
    };

    auto get_tooltip = [this, &sep](const Option &opt) {
        return marker_by_type(opt.type, printer_technology) + opt.category_local + sep + opt.group_local + sep + opt.label_local;
    };

    std::vector<uint16_t> matches, matches2;
    for (size_t i = 0; i < options.size(); i++) {
        const Option &opt = options[i];
        if (full_list) {
            std::string label = into_u8(get_label(opt));
            //all
            if (type == Preset::TYPE_INVALID) { 
                found.emplace_back(FoundOption{label, label, boost::nowide::narrow(get_tooltip(opt)), i, 0});
            } else if (type == opt.type){
                found.emplace_back(FoundOption{label, label, boost::nowide::narrow(get_tooltip(opt)), i, 0});
            }
            
            continue;
        }

        std::wstring wsearch = boost::nowide::widen(search);
        boost::trim_left(wsearch);
        std::wstring label         = get_label(opt, false);
        std::wstring label_english = get_label_english(opt, false);
        int          score         = std::numeric_limits<int>::min();
        int          score2;
        matches.clear();
        fuzzy_match(wsearch, label, score, matches);
        // bbs hide the contents in parentheses
        /* if (fuzzy_match(wsearch, opt.key, score2, matches2) && score2 > score) {
             for (fts::pos_type &pos : matches2) pos += label.size() + 1;
             label += L"(" + opt.key + L")";
             append(matches, matches2);
             score = score2;
         }*/
        if (view_params.english && fuzzy_match(wsearch, label_english, score2, matches2) && score2 > score) {
            label   = std::move(label_english);
            matches = std::move(matches2);
            score   = score2;
        }
        if (score > 90 /*std::numeric_limits<int>::min()*/) {
            label = mark_string(label, matches, opt.type, printer_technology);
            //label += L"  [" + std::to_wstring(score) + L"]"; // add score value
            std::string label_u8    = into_u8(label);
            std::string label_plain = label_u8;

#ifdef SUPPORTS_MARKUP
            boost::replace_all(label_plain, std::string(1, char(ImGui::ColorMarkerStart)), "<b>");
            boost::replace_all(label_plain, std::string(1, char(ImGui::ColorMarkerEnd)), "</b>");
#else
            boost::erase_all(label_plain, std::string(1, char(ImGui::ColorMarkerStart)));
            boost::erase_all(label_plain, std::string(1, char(ImGui::ColorMarkerEnd)));
#endif

            if (type == Preset::TYPE_INVALID) {
                found.emplace_back(FoundOption{label_plain, label_u8, boost::nowide::narrow(get_tooltip(opt)), i, score});
            } else if (type == opt.type) {
                found.emplace_back(FoundOption{label_plain, label_u8, boost::nowide::narrow(get_tooltip(opt)), i, score});
            }
            
        }
    }

    if (!full_list) sort_found();

    if (search_line != search) search_line = search;
    if (search_type != type) search_type = type;

    return true;
}

OptionsSearcher::OptionsSearcher() {}

OptionsSearcher::~OptionsSearcher() {}

void OptionsSearcher::init(std::vector<InputInfo> input_values)
{
    options.clear();
    for (auto i : input_values) append_options(i.config, i.type, i.mode);
    sort_options();

    search(search_line, true, search_type);
}

void OptionsSearcher::apply(DynamicPrintConfig *config, Preset::Type type, ConfigOptionMode mode)
{
    if (options.empty()) return;

    options.erase(std::remove_if(options.begin(), options.end(), [type](Option opt) { return opt.type == type; }), options.end());

    append_options(config, type, mode);

    sort_options();

    search(search_line, true, search_type);
}

const Option &OptionsSearcher::get_option(size_t pos_in_filter) const
{
    assert(pos_in_filter != size_t(-1) && found[pos_in_filter].option_idx != size_t(-1));
    return options[found[pos_in_filter].option_idx];
}

const Option &OptionsSearcher::get_option(const std::string &opt_key, Preset::Type type) const
{
    auto it = std::lower_bound(options.begin(), options.end(), Option({boost::nowide::widen(get_key(opt_key, type))}));
    // BBS: return the 0th option when not found in searcher caused by mode difference
    // assert(it != options.end());
    if (it == options.end()) return options[0];

    return options[it - options.begin()];
}

static Option create_option(const std::string &opt_key, const wxString &label, Preset::Type type, const GroupAndCategory &gc)
{
    wxString suffix;
    wxString suffix_local;
    if (gc.category == "Machine limits") {
        //suffix       = opt_key.back() == '1' ? L("Stealth") : L("Normal");
        suffix       = opt_key.back() == '1' ? wxEmptyString : wxEmptyString;
        suffix_local = " " + _(suffix);
        suffix       = " " + suffix;
    }

    wxString category = gc.category;
    if (type == Preset::TYPE_PRINTER && category.Contains("Extruder ")) {
        std::string opt_idx = opt_key.substr(opt_key.find("#") + 1);
        category            = wxString::Format("%s %d", "Extruder", atoi(opt_idx.c_str()) + 1);
    }

    return Option{boost::nowide::widen(get_key(opt_key, type)),
                  type,
                  (label + suffix).ToStdWstring(),
                  (_(label) + suffix_local).ToStdWstring(),
                  gc.group.ToStdWstring(),
                  _(gc.group).ToStdWstring(),
                  gc.category.ToStdWstring(),
                  GUI::Tab::translate_category(category, type).ToStdWstring()};
}

Option OptionsSearcher::get_option(const std::string &opt_key, const wxString &label, Preset::Type type) const
{
    std::string key = get_key(opt_key, type);
    auto        it  = std::lower_bound(options.begin(), options.end(), Option({boost::nowide::widen(key)}));
    // BBS: return the 0th option when not found in searcher caused by mode difference
    if (it == options.end()) return options[0];
    if (it->key == boost::nowide::widen(key)) return options[it - options.begin()];
    if (groups_and_categories.find(key) == groups_and_categories.end()) {
        size_t pos = key.find('#');
        if (pos == std::string::npos) return options[it - options.begin()];

        std::string zero_opt_key = key.substr(0, pos + 1) + "0";

        if (groups_and_categories.find(zero_opt_key) == groups_and_categories.end()) return options[it - options.begin()];

        return create_option(opt_key, label, type, groups_and_categories.at(zero_opt_key));
    }

    const GroupAndCategory &gc = groups_and_categories.at(key);
    if (gc.group.IsEmpty() || gc.category.IsEmpty()) return options[it - options.begin()];

    return create_option(opt_key, label, type, gc);
}

void OptionsSearcher::show_dialog(Preset::Type type, wxWindow *parent, wxTextCtrl *input, wxWindow* ssearch_btn)
{
    if (parent == nullptr || input == nullptr) return;
    auto    search_dialog = new SearchDialog(this, type, parent, input, ssearch_btn);
    wxPoint pos = input->GetParent()->ClientToScreen(wxPoint(0, 0));
    pos.y += input->GetParent()->GetRect().height;
    search_dialog->SetPosition(pos);
    search_dialog->Popup();
}

void OptionsSearcher::dlg_sys_color_changed()
{
    /*if (search_dialog)
        search_dialog->on_sys_color_changed();*/
}

void OptionsSearcher::dlg_msw_rescale()
{
    if (search_dialog) search_dialog->msw_rescale();
}

void OptionsSearcher::add_key(const std::string &opt_key, Preset::Type type, const wxString &group, const wxString &category)
{
    groups_and_categories[get_key(opt_key, type)] = GroupAndCategory{group, category};
}
//------------------------------------------
//          SearchItem
//------------------------------------------

SearchItem::SearchItem(wxWindow *parent, wxString text, int index, SearchDialog* sdialog)
    : wxWindow(parent, wxID_ANY, wxDefaultPosition, wxSize(parent->GetSize().GetWidth(), 3 * GUI::wxGetApp().em_unit()))
{
    m_sdialog = sdialog;
    m_text  = text;
    m_index = index;

    SetBackgroundColour(wxColour(255, 255, 255));
    Bind(wxEVT_ENTER_WINDOW, &SearchItem::on_mouse_enter, this);
    Bind(wxEVT_LEAVE_WINDOW, &SearchItem::on_mouse_leave, this);
    Bind(wxEVT_LEFT_DOWN, &SearchItem::on_mouse_left_down, this);
    Bind(wxEVT_LEFT_UP, &SearchItem::on_mouse_left_up, this);
    Bind(wxEVT_PAINT, &SearchItem::OnPaint, this);
}

wxSize SearchItem::DrawTextString(wxDC &dc, const wxString &text, const wxPoint &pt, bool bold)
{
    if (bold) {
        dc.SetFont(Label::Head_14);
    } else {
        dc.SetFont(Label::Body_14);
    }

    dc.SetBackgroundMode(wxTRANSPARENT);
    dc.SetTextForeground(wxColour(43, 52, 54));
    dc.DrawText(text, pt);
    return dc.GetTextExtent(text);
}

void SearchItem::OnPaint(wxPaintEvent &event)
{
    wxPaintDC dc(this);
    auto      top  = 5;
    int       left = 20;

    auto bold_pair = std::vector<std::pair<int, int>>();
    
    auto index     = 0;

    auto b_first_list  = std::vector<int>();
    auto b_second_list = std::vector<int>();

    auto position      = 0;
    while ((position = m_text.find("<b>", position)) != wxString::npos) {
        b_first_list.push_back(position);
        position++;
    }

    position = 0;
    while ((position = m_text.find("</b>", position)) != wxString::npos) {
        b_second_list.push_back(position + 3);
        position++;
    }

    if (b_first_list.size() != b_second_list.size()) { return; }

    for (auto i = 0; i < b_first_list.size(); i++) {
        auto pair = std::make_pair(b_first_list[i], b_second_list[i]);
        bold_pair.push_back(pair);
    }

    //DrawTextString(dc, m_text, wxPoint(left, top), false);
    /*if (bold_pair.size() <= 0) {
        DrawTextString(dc, m_text, wxPoint(left, top), false);
    } else {
        auto index = 0;
        for (auto i = 0; i < bold_pair.size(); i++) { DrawTextString(dc, m_text.SubString(index, bold_pair[i].second), wxPoint(left, top), true); }
    }*/
    auto str = wxString("");
    for (auto c = 0; c < m_text.length(); c++) {
        str = m_text[c];

        auto inset = false;
        auto pair_index = 0;
        for (auto o = 0; o < bold_pair.size(); o++) {
            if (c >= bold_pair[o].first && c <= bold_pair[o].second) { 
                pair_index = o;
                inset = true;
                break;
            }
        }

        if (!inset) { 
            left += DrawTextString(dc, str, wxPoint(left, top), false).GetWidth();
        } else {
            //str = str.erase(bold_pair[pair_index].first, 3);
            //str = str.erase(bold_pair[pair_index].second, 4);
            if (c - bold_pair[pair_index].first >= 3 && bold_pair[pair_index].second - c > 3) { 
                left += DrawTextString(dc, str, wxPoint(left, top), true).GetWidth();
            }
        }
    }
}

void SearchItem::on_mouse_enter(wxMouseEvent &evt)
{
    SetBackgroundColour(wxColour(238, 238, 238));
    Refresh();
}

void SearchItem::on_mouse_leave(wxMouseEvent &evt)
{
    SetBackgroundColour(wxColour(255, 255, 255));
    Refresh();
}

void SearchItem::on_mouse_left_down(wxMouseEvent &evt)
{
    SetBackgroundColour(wxColour(228, 228, 228));
    Refresh();
}

void SearchItem::on_mouse_left_up(wxMouseEvent &evt)
{

    //if (m_sdialog->prevent_list_events) return;
    // if (wxGetMouseState().LeftIsDown())
    m_sdialog->Die();
    wxCommandEvent event(wxCUSTOMEVT_JUMP_TO_OPTION);
    event.SetInt(m_index);
    wxPostEvent(GUI::wxGetApp().plater(), event);
}

//------------------------------------------
//          SearchDialog
//------------------------------------------

static const std::map<const char, int> icon_idxs = {
    {ImGui::PrintIconMarker, 0}, {ImGui::PrinterIconMarker, 1}, {ImGui::PrinterSlaIconMarker, 2}, {ImGui::FilamentIconMarker, 3}, {ImGui::MaterialIconMarker, 4},
};

SearchDialog::SearchDialog(OptionsSearcher *searcher, Preset::Type type, wxWindow *parent, wxTextCtrl *input, wxWindow *search_btn) 
    : wxPopupTransientWindow(parent, wxBORDER_NONE | wxPU_CONTAINS_CONTROLS), searcher(searcher)
{
    m_event_tag       = parent;
    search_line       = input;
    search_type       = type;

    m_search_item_tag = search_btn;

    // set border color
    Freeze();
    SetBackgroundColour(wxColour(238, 238, 238));

    em = GUI::wxGetApp().em_unit();

    m_text_color   = wxColour(38, 46, 48);
    m_bg_colour    = wxColour(255, 255, 255);
    m_hover_colour = wxColour(248, 248, 248);
    m_thumb_color  = wxColour(196, 196, 196);

    SetFont(GUI::wxGetApp().normal_font());
    SetSizeHints(wxDefaultSize, wxDefaultSize);

    m_sizer_border = new wxBoxSizer(wxVERTICAL);
    m_sizer_main   = new wxBoxSizer(wxVERTICAL);
    m_sizer_body   = new wxBoxSizer(wxVERTICAL);

    // border
    m_border_panel = new wxPanel(this, wxID_ANY, wxDefaultPosition, wxSize(POPUP_WIDTH * em, POPUP_HEIGHT * em), wxTAB_TRAVERSAL);
    m_border_panel->SetBackgroundColour(m_bg_colour);

    // client
    m_client_panel = new wxPanel(m_border_panel, wxID_ANY, wxDefaultPosition, wxSize(POPUP_WIDTH * em, POPUP_HEIGHT * em), wxTAB_TRAVERSAL);
    m_client_panel->SetBackgroundColour(m_bg_colour);

    // search line
    //search_line = new wxTextCtrl(m_client_panel, wxID_ANY, "", wxDefaultPosition, wxDefaultSize, wxTE_PROCESS_ENTER);

    // default_string = _L("Enter a search term");
    search_line->Bind(wxEVT_TEXT, &SearchDialog::OnInputText, this);
    search_line->Bind(wxEVT_LEFT_UP, &SearchDialog::OnLeftUpInTextCtrl, this);
    search_line->Bind(wxEVT_KEY_DOWN, &SearchDialog::OnKeyDown, this);

    // scroll window
    m_scrolledWindow = new ScrolledWindow(m_client_panel, wxID_ANY, wxDefaultPosition, wxSize(POPUP_WIDTH * em - (em + em /2), POPUP_HEIGHT * em), wxVSCROLL, 6, 6);
    m_scrolledWindow->SetMarginColor(m_bg_colour);
    m_scrolledWindow->SetScrollbarColor(m_thumb_color);
    m_scrolledWindow->SetBackgroundColour(m_bg_colour);

    auto m_listsizer = new wxBoxSizer(wxVERTICAL);
    auto m_listPanel = new wxWindow(m_scrolledWindow->GetPanel(), -1);
    m_listPanel->SetBackgroundColour(m_bg_colour);
    m_listPanel->SetSize(wxSize(m_scrolledWindow->GetSize().GetWidth(), -1));

    m_listPanel->SetSizer(m_listsizer);
    m_listPanel->Fit();
    m_scrolledWindow->SetScrollbars(1, 1, 0, m_listPanel->GetSize().GetHeight());

    //m_sizer_body->Add(search_line, 0, wxEXPAND | wxTOP, em + em / 2);
    m_sizer_body->Add(m_scrolledWindow, 0, wxEXPAND | wxALL, em);

    m_client_panel->SetSizer(m_sizer_body);
    m_client_panel->Layout();
    m_sizer_body->Fit(m_client_panel);
    m_sizer_main->Add(m_client_panel, 1, wxEXPAND, 0);

    m_border_panel->SetSizer(m_sizer_main);
    m_border_panel->Layout();
    m_sizer_border->Add(m_border_panel, 0, wxEXPAND | wxALL, 1);

    SetSizer(m_sizer_border);
    Layout();
    m_sizer_border->Fit(this);
    Thaw();

    // check_category->Bind(wxEVT_CHECKBOX, &SearchDialog::OnCheck, this);
    // Bind(wxEVT_MOTION, &SearchDialog::OnMotion, this);
    // Bind(wxEVT_LEFT_DOWN, &SearchDialog::OnLeftDown, this);

    // SetSizer(topSizer);
    // topSizer->SetSizeHints(this);
}

SearchDialog::~SearchDialog() {}

void SearchDialog::Popup(wxPoint position /*= wxDefaultPosition*/)
{
    /* const std::string& line = searcher->search_string();
     search_line->SetValue(line.empty() ? default_string : from_u8(line));

     update_list();

     const OptionViewParameters& params = searcher->view_params;
     check_category->SetValue(params.category);*/

    //const std::string &line = searcher->search_string();
    //search_line->SetValue(line.empty() ? default_string : from_u8(line));
    search_line->SetValue(wxString(""));
    //const std::string &line = searcher->search_string();
    //searcher->search(into_u8(line), true);
    wxPopupTransientWindow::Popup();
    update_list();
}


void SearchDialog::MSWDismissUnfocusedPopup()
{
    Dismiss();
    OnDismiss();
}

void SearchDialog::OnDismiss() { }

void SearchDialog::Dismiss()
{
    auto pos = wxGetMousePosition();
    if (!m_event_tag->GetScreenRect().Contains(pos) && !this->GetScreenRect().Contains(pos) && !m_search_item_tag->GetScreenRect().Contains(pos)) { 
        Die();
    }
}

void SearchDialog::Die() 
{
    wxPopupTransientWindow::Dismiss();
    wxCommandEvent event(wxCUSTOMEVT_EXIT_SEARCH);
    wxPostEvent(search_line, event);
}

void SearchDialog::ProcessSelection(wxDataViewItem selection)
{
    if (!selection.IsOk()) return;
    // this->EndModal(wxID_CLOSE);

    // If call GUI::wxGetApp().sidebar.jump_to_option() directly from here,
    // then mainframe will not have focus and found option will not be "active" (have cursor) as a result
    // SearchDialog have to be closed and have to lose a focus
    // and only after that jump_to_option() function can be called
    // So, post event to plater:
    wxCommandEvent event(wxCUSTOMEVT_JUMP_TO_OPTION);
    event.SetInt(search_list_model->GetRow(selection));
    wxPostEvent(GUI::wxGetApp().plater(), event);
}

void SearchDialog::OnInputText(wxCommandEvent &)
{
    search_line->SetInsertionPointEnd();
    wxString input_string = search_line->GetValue();
    if (input_string == default_string) input_string.Clear();
    searcher->search(into_u8(input_string), true, search_type);
    update_list();
}

void SearchDialog::OnLeftUpInTextCtrl(wxEvent &event)
{
    if (search_line->GetValue() == default_string) search_line->SetValue("");
    event.Skip();
}

void SearchDialog::OnKeyDown(wxKeyEvent &event)
{
    event.Skip();
    /* int key = event.GetKeyCode();

     if (key == WXK_UP || key == WXK_DOWN)
     {
         search_list->SetFocus();

         auto item = search_list->GetSelection();

         if (item.IsOk()) {
             unsigned selection = search_list_model->GetRow(item);

             if (key == WXK_UP && selection > 0)
                 selection--;
             if (key == WXK_DOWN && selection < unsigned(search_list_model->GetCount() - 1))
                 selection++;

             prevent_list_events = true;
             search_list->Select(search_list_model->GetItem(selection));
             prevent_list_events = false;
         }
     }

     else if (key == WXK_NUMPAD_ENTER || key == WXK_RETURN)
         ProcessSelection(search_list->GetSelection());
     else
         event.Skip();*/
}

void SearchDialog::OnActivate(wxDataViewEvent &event) { ProcessSelection(event.GetItem()); }

void SearchDialog::OnSelect(wxDataViewEvent &event)
{
    if (prevent_list_events) return;
    // if (wxGetMouseState().LeftIsDown())
    // ProcessSelection(search_list->GetSelection());
}

void SearchDialog::update_list()
{
    Freeze();
    m_scrolledWindow->Destroy();

    m_scrolledWindow = new ScrolledWindow(m_client_panel, wxID_ANY, wxDefaultPosition, wxSize(POPUP_WIDTH * em - (em + em / 2), POPUP_HEIGHT * em - em), wxVSCROLL, 6, 6);
    m_scrolledWindow->SetMarginColor(m_bg_colour);
    m_scrolledWindow->SetScrollbarColor(m_thumb_color);
    m_scrolledWindow->SetBackgroundColour(m_bg_colour);

    auto m_listsizer = new wxBoxSizer(wxVERTICAL);
    auto m_listPanel = new wxWindow(m_scrolledWindow->GetPanel(), -1);
    m_listPanel->SetBackgroundColour(m_bg_colour);
    m_listPanel->SetSize(wxSize(m_scrolledWindow->GetSize().GetWidth(), -1));

    const std::vector<FoundOption> &filters = searcher->found_options();
    auto                            index   = 0;
    for (const FoundOption &item : filters) {
        wxString str = from_u8(item.label).Remove(0, 1);
        auto     tmp = new SearchItem(m_listPanel, str, index, this);
        m_listsizer->Add(tmp, 0, wxEXPAND, 0);
        index++;
    }

    m_listPanel->SetSizer(m_listsizer);
    m_listPanel->Fit();
    m_scrolledWindow->SetScrollbars(1, 1, 0, m_listPanel->GetSize().GetHeight());

    m_sizer_body->Add(m_scrolledWindow, 0, wxEXPAND | wxALL, em);
    m_sizer_body->Fit(m_client_panel);
    m_sizer_body->Layout();
    Thaw();

    // Under OSX model->Clear invoke wxEVT_DATAVIEW_SELECTION_CHANGED, so
    // set prevent_list_events to true already here
    // prevent_list_events = true;
    // search_list_model->Clear();

    /* const std::vector<FoundOption> &filters = searcher->found_options();
      for (const FoundOption &item : filters)
          search_list_model->Prepend(item.label);*/

    // select first item, if search_list
    /*if (search_list_model->GetCount() > 0)
        search_list->Select(search_list_model->GetItem(0));
        prevent_list_events = false;*/
    // Refresh();
}

void SearchDialog::OnCheck(wxCommandEvent &event)
{
    OptionViewParameters &params = searcher->view_params;
    params.category              = check_category->GetValue();

    searcher->search();
    update_list();
}

void SearchDialog::OnMotion(wxMouseEvent &event)
{
    wxDataViewItem    item;
    wxDataViewColumn *col;
    wxWindow *        win = this;

    // search_list->HitTest(wxGetMousePosition() - win->GetScreenPosition(), item, col);
    // search_list->Select(item);

    event.Skip();
}

void SearchDialog::OnLeftDown(wxMouseEvent &event) { ProcessSelection(search_list->GetSelection()); }

void SearchDialog::msw_rescale()
{
    /* const int &em = GUI::wxGetApp().em_unit();

     search_list_model->msw_rescale();
     search_list->GetColumn(SearchListModel::colIcon      )->SetWidth(3  * em);
     search_list->GetColumn(SearchListModel::colMarkedText)->SetWidth(45 * em);

     msw_buttons_rescale(this, em, { wxID_CANCEL });

     const wxSize& size = wxSize(40 * em, 30 * em);
     SetMinSize(size);

     Fit();
     Refresh();*/
}

// void SearchDialog::on_sys_color_changed()
//{
//#ifdef _WIN32
//    GUI::wxGetApp().UpdateAllStaticTextDarkUI(this);
//    GUI::wxGetApp().UpdateDarkUI(static_cast<wxButton*>(this->FindWindowById(wxID_CANCEL, this)), true);
//    for (wxWindow* win : std::vector<wxWindow*> {search_line, search_list, check_category, check_english})
//        if (win) GUI::wxGetApp().UpdateDarkUI(win);
//#endif
//
//    // msw_rescale updates just icons, so use it
//    search_list_model->msw_rescale();
//
//    Refresh();
//}

// ----------------------------------------------------------------------------
// SearchListModel
// ----------------------------------------------------------------------------

SearchListModel::SearchListModel(wxWindow *parent) : wxDataViewVirtualListModel(0)
{
    int icon_id = 0;
    for (const std::string &icon : {"cog", "printer", "printer", "spool", "blank_16"}) m_icon[icon_id++] = ScalableBitmap(parent, icon);
}

void SearchListModel::Clear()
{
    m_values.clear();
    Reset(0);
}

void SearchListModel::Prepend(const std::string &label)
{
    const char icon_c   = label.at(0);
    int        icon_idx = icon_idxs.at(icon_c);
    wxString   str      = from_u8(label).Remove(0, 1);

    m_values.emplace_back(str, icon_idx);

    RowPrepended();
}

void SearchListModel::msw_rescale()
{
    for (ScalableBitmap &bmp : m_icon) bmp.msw_rescale();
}

wxString SearchListModel::GetColumnType(unsigned int col) const
{
    if (col == colIcon) return "wxBitmap";
    return "string";
}

void SearchListModel::GetValueByRow(wxVariant &variant, unsigned int row, unsigned int col) const
{
    switch (col) {
    case colIcon: variant << m_icon[m_values[row].second].bmp(); break;
    case colMarkedText: variant = m_values[row].first; break;
    case colMax: wxFAIL_MSG("invalid column");
    default: break;
    }
}

} // namespace Search

} // namespace Slic3r