Slic3r::Search::OptionsSearcher Class Reference

#include <src/slic3r/GUI/Search.hpp>

Collaboration diagram for Slic3r::Search::OptionsSearcher:

Public Member Functions
	OptionsSearcher ()
	~OptionsSearcher ()
void	append_preferences_option (const GUI::Line &opt_line)
void	append_preferences_options (const std::vector< GUI::Line > &opt_lines)
void	check_and_update (PrinterTechnology pt_in, ConfigOptionMode mode_in, std::vector< InputInfo > input_values)
bool	search ()
bool	search (const std::string &search, bool force=false)
void	add_key (const std::string &opt_key, Preset::Type type, const wxString &group, const wxString &category)
size_t	size () const
const FoundOption &	operator[] (const size_t pos) const noexcept
const Option &	get_option (size_t pos_in_filter) const
const Option &	get_option (const std::string &opt_key, Preset::Type type) const
Option	get_option (const std::string &opt_key, const wxString &label, Preset::Type type) const
const std::vector< FoundOption > &	found_options ()
const GroupAndCategory &	get_group_and_category (const std::string &opt_key)
std::string &	search_string ()
void	sort_options_by_key ()
void	sort_options_by_label ()
void	show_dialog ()
void	dlg_sys_color_changed ()
void	dlg_msw_rescale ()

Public Attributes
OptionViewParameters	view_params
SearchDialog *	search_dialog { nullptr }

Private Member Functions
void	append_options (DynamicPrintConfig *config, Preset::Type type)
void	sort_options ()
void	sort_found ()
size_t	options_size () const
size_t	found_size () const

Private Attributes
std::string	search_line
std::map< std::string, GroupAndCategory >	groups_and_categories
PrinterTechnology	printer_technology {ptAny}
ConfigOptionMode	mode { comUndef }
std::vector< Option >	options {}
std::vector< Option >	preferences_options {}
std::vector< FoundOption >	found {}

Detailed Description

Constructor & Destructor Documentation

OptionsSearcher()

Slic3r::Search::OptionsSearcher::OptionsSearcher

(

)

{
}

~OptionsSearcher()

Slic3r::Search::OptionsSearcher::~OptionsSearcher

(

)

{
}

Member Function Documentation

add_key()

void Slic3r::Search::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};
}

References Slic3r::Search::get_key(), and groups_and_categories.

Referenced by Slic3r::GUI::TabPrinter::create_bed_shape_widget().

Here is the call graph for this function:

Here is the caller graph for this function:

append_options()

void Slic3r::Search::OptionsSearcher::append_options ( DynamicPrintConfig *  config, Preset::Type  type  )

private

{
    auto emplace = [this, type](std::string key, const wxString& label, int id = -1)
    {
        if (id >= 0)
            // ! It's very important to use "#". opt_key#n is a real option key used in GroupAndCategory
            key += "#" + std::to_string(id);
 
        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 = id == 1 ? L("Stealth") : L("Normal");
            suffix_local = " " + _(suffix);
            suffix = " " + suffix;
        }
        else if (gc.group == "Dynamic overhang speed" && id >= 0) {
            suffix = " " + std::to_string(id+1);
            suffix_local = 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->option_def(opt_key);
        if (opt.mode > mode)
            continue;
 
        int cnt = 0;
 
        if ( type != Preset::TYPE_FILAMENT && !PresetCollection::is_independent_from_extruder_number_option(opt_key) )
            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;
            case coFloatsOrPercents:  change_opt_key<ConfigOptionFloatsOrPercents >(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)
                emplace(key, label, i);
    }
}

References _, Slic3r::Search::GroupAndCategory::category, Slic3r::coBools, Slic3r::coFloats, Slic3r::coFloatsOrPercents, Slic3r::coInts, Slic3r::coPercents, Slic3r::coPoints, Slic3r::coStrings, Slic3r::ConfigOptionDef::full_label, Slic3r::Search::get_key(), Slic3r::Search::GroupAndCategory::group, groups_and_categories, Slic3r::PresetCollection::is_independent_from_extruder_number_option(), Slic3r::DynamicConfig::keys(), L, Slic3r::ConfigOptionDef::label, Slic3r::ConfigOptionDef::mode, mode, Slic3r::ConfigBase::option(), Slic3r::ConfigBase::option_def(), options, Slic3r::GUI::Tab::translate_category(), Slic3r::ConfigOption::type(), Slic3r::Preset::TYPE_FILAMENT, and boost::nowide::widen().

Referenced by check_and_update().

Here is the call graph for this function:

Here is the caller graph for this function:

append_preferences_option()

void Slic3r::Search::OptionsSearcher::append_preferences_option

(

const GUI::Line &

opt_line

)

{
    Preset::Type type = Preset::TYPE_PREFERENCES;
    wxString label = opt_line.label;
    if (label.IsEmpty())
        return;
 
    std::string key = get_key(opt_line.get_options().front().opt_id, type);
    const GroupAndCategory& gc = groups_and_categories[key];
    if (gc.group.IsEmpty() || gc.category.IsEmpty())
        return;        
        
    preferences_options.emplace_back(Search::Option{ boost::nowide::widen(key), type,
                                label.ToStdWstring(), _(label).ToStdWstring(),
                                gc.group.ToStdWstring(), _(gc.group).ToStdWstring(),
                                gc.category.ToStdWstring(), _(gc.category).ToStdWstring() });
}

References _, Slic3r::Search::GroupAndCategory::category, Slic3r::Search::get_key(), Slic3r::GUI::Line::get_options(), Slic3r::Search::GroupAndCategory::group, groups_and_categories, Slic3r::GUI::Line::label, preferences_options, Slic3r::Preset::TYPE_PREFERENCES, and boost::nowide::widen().

Referenced by append_preferences_options().

Here is the call graph for this function:

Here is the caller graph for this function:

append_preferences_options()

void Slic3r::Search::OptionsSearcher::append_preferences_options

(

const std::vector< GUI::Line > &

opt_lines

)

{
    //Preset::Type type = Preset::TYPE_PREFERENCES;
    for (const GUI::Line& line : opt_lines) {
        if (line.is_separator())
            continue;
        append_preferences_option(line);
        //wxString label = line.label;
        //if (label.IsEmpty())
        //    continue;
 
        //std::string key = get_key(line.get_options().front().opt_id, type);        
        //const GroupAndCategory& gc = groups_and_categories[key];
        //if (gc.group.IsEmpty() || gc.category.IsEmpty())
        //    continue;        
        //
        //preferences_options.emplace_back(Search::Option{ boost::nowide::widen(key), type,
        //                            label.ToStdWstring(), _(label).ToStdWstring(),
        //                            gc.group.ToStdWstring(), _(gc.group).ToStdWstring(),
        //                            gc.category.ToStdWstring(), _(gc.category).ToStdWstring() });
    }
}

References append_preferences_option().

Here is the call graph for this function:

check_and_update()

void Slic3r::Search::OptionsSearcher::check_and_update	(	PrinterTechnology	pt_in,
		ConfigOptionMode	mode_in,
		std::vector< InputInfo >	input_values
	)

{
    if (printer_technology == pt_in && mode == mode_in)
        return;
 
    options.clear();
 
    printer_technology = pt_in;
    mode = mode_in;
 
    for (auto i : input_values)
        append_options(i.config, i.type);
 
    options.insert(options.end(), preferences_options.begin(), preferences_options.end());
 
    sort_options();
 
    search(search_line, true);
}

References append_options(), mode, options, preferences_options, printer_technology, search(), search_line, and sort_options().

Here is the call graph for this function:

dlg_msw_rescale()

void Slic3r::Search::OptionsSearcher::dlg_msw_rescale

(

)

{
    if (search_dialog)
        search_dialog->msw_rescale();
}

References Slic3r::Search::SearchDialog::msw_rescale(), and search_dialog.

Here is the call graph for this function:

dlg_sys_color_changed()

void Slic3r::Search::OptionsSearcher::dlg_sys_color_changed

(

)

{
    if (search_dialog)
        search_dialog->on_sys_color_changed();
}

References Slic3r::Search::SearchDialog::on_sys_color_changed(), and search_dialog.

Here is the call graph for this function:

found_options()

const std::vector< FoundOption > & Slic3r::Search::OptionsSearcher::found_options ( )

inline

{ return found; }

References found.

Referenced by Slic3r::Search::SearchDialog::update_list().

Here is the caller graph for this function:

found_size()

size_t Slic3r::Search::OptionsSearcher::found_size ( ) const

inlineprivate

{ return found.size(); }

References found.

Referenced by size().

Here is the caller graph for this function:

get_group_and_category()

const GroupAndCategory & Slic3r::Search::OptionsSearcher::get_group_and_category ( const std::string &  opt_key )

inline

{ return groups_and_categories[opt_key]; }

References groups_and_categories.

Referenced by Slic3r::GUI::TabPrinter::create_bed_shape_widget().

Here is the caller graph for this function:

get_option() [1/3]

Option Slic3r::Search::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) }));
    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);
}

References Slic3r::Search::GroupAndCategory::category, Slic3r::Search::create_option(), Slic3r::Search::get_key(), Slic3r::Search::GroupAndCategory::group, groups_and_categories, options, and boost::nowide::widen().

Here is the call graph for this function:

get_option() [2/3]

const Option & Slic3r::Search::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)) }));
    assert(it != options.end());
 
    return options[it - options.begin()];
}

References Slic3r::Search::get_key(), options, and boost::nowide::widen().

Here is the call graph for this function:

get_option() [3/3]

const Option & Slic3r::Search::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];
}

References found, and options.

Referenced by Slic3r::GUI::DiffPresetDialog::update_tree(), and Slic3r::GUI::UnsavedChangesDialog::update_tree().

Here is the caller graph for this function:

operator[]()

const FoundOption & Slic3r::Search::OptionsSearcher::operator[] ( const size_t  pos ) const

inlinenoexcept

{ return found[pos]; }

References found.

options_size()

size_t Slic3r::Search::OptionsSearcher::options_size ( ) const

inlineprivate

{ return options.size(); }

References options.

search() [1/2]

bool Slic3r::Search::OptionsSearcher::search

(

)

{
    return search(search_line, true);
}

References search(), and search_line.

Referenced by check_and_update(), Slic3r::Search::SearchDialog::OnCheck(), Slic3r::Search::SearchDialog::OnInputText(), search(), and search().

Here is the call graph for this function:

Here is the caller graph for this function:

search() [2/2]

bool Slic3r::Search::OptionsSearcher::search	(	const std::string &	search,
		bool	force = false
	)

{
    if (search_line == search && !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));
            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);
        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
          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;
 
    return true;
}

References Slic3r::append(), Slic3r::Search::Option::category, Slic3r::Search::OptionViewParameters::category, Slic3r::Search::Option::category_local, ImGui::ColorMarkerEnd, ImGui::ColorMarkerStart, Slic3r::Search::OptionViewParameters::english, found, Slic3r::Search::fuzzy_match(), Slic3r::Search::Option::group, Slic3r::Search::Option::group_local, Slic3r::Search::Option::key, L, Slic3r::Search::Option::label, Slic3r::Search::Option::label_local, Slic3r::Search::mark_string(), Slic3r::Search::marker_by_type(), boost::nowide::narrow(), options, printer_technology, search(), search_line, sort_found(), Slic3r::Search::Option::type, view_params, and boost::nowide::widen().

Here is the call graph for this function:

search_string()

std::string & Slic3r::Search::OptionsSearcher::search_string ( )

inline

{ return search_line; }

References search_line.

Referenced by Slic3r::Search::SearchDialog::Popup().

Here is the caller graph for this function:

show_dialog()

void Slic3r::Search::OptionsSearcher::show_dialog

(

)

{
    if (!search_dialog) {
        search_dialog = new SearchDialog(this);
 
        auto parent = search_dialog->GetParent();
        wxPoint pos = parent->ClientToScreen(wxPoint(0, 0));
        pos.x += em_unit(parent) * 40;
        pos.y += em_unit(parent) * 4;
 
        search_dialog->SetPosition(pos);
    }
 
    search_dialog->Popup();
}

References em_unit(), Slic3r::Search::SearchDialog::Popup(), and search_dialog.

Here is the call graph for this function:

size()

size_t Slic3r::Search::OptionsSearcher::size ( ) const

inline

{ return found_size(); }

References found_size().

Referenced by Slic3r::GUI::Plater::search_string_getter().

Here is the call graph for this function:

Here is the caller graph for this function:

sort_found()

void Slic3r::Search::OptionsSearcher::sort_found ( )

inlineprivate

                      {
        std::sort(found.begin(), found.end(), [](const FoundOption& f1, const FoundOption& f2) {
            return f1.outScore > f2.outScore || (f1.outScore == f2.outScore && f1.label < f2.label); });
    };

References found.

Referenced by search().

Here is the caller graph for this function:

sort_options()

void Slic3r::Search::OptionsSearcher::sort_options ( )

inlineprivate

                        {
        std::sort(options.begin(), options.end(), [](const Option& o1, const Option& o2) {
            return o1.label < o2.label; });
    }

References options.

Referenced by check_and_update(), and sort_options_by_label().

Here is the caller graph for this function:

sort_options_by_key()

void Slic3r::Search::OptionsSearcher::sort_options_by_key ( )

inline

                               {
        std::sort(options.begin(), options.end(), [](const Option& o1, const Option& o2) {
            return o1.key < o2.key; });
    }

References options.

Referenced by Slic3r::GUI::DiffPresetDialog::update_tree(), and Slic3r::GUI::UnsavedChangesDialog::update_tree().

Here is the caller graph for this function:

sort_options_by_label()

void Slic3r::Search::OptionsSearcher::sort_options_by_label ( )

inline

{ sort_options(); }

References sort_options().

Referenced by Slic3r::GUI::DiffPresetDialog::update_tree(), and Slic3r::GUI::UnsavedChangesDialog::update_tree().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

found

std::vector<FoundOption> Slic3r::Search::OptionsSearcher::found {}

private

Referenced by found_options(), found_size(), get_option(), operator[](), search(), and sort_found().

groups_and_categories

std::map<std::string, GroupAndCategory> Slic3r::Search::OptionsSearcher::groups_and_categories

private

Referenced by add_key(), append_options(), append_preferences_option(), get_group_and_category(), and get_option().

mode

ConfigOptionMode Slic3r::Search::OptionsSearcher::mode { comUndef }

private

Referenced by append_options(), and check_and_update().

options

std::vector<Option> Slic3r::Search::OptionsSearcher::options {}

private

Referenced by append_options(), check_and_update(), get_option(), get_option(), get_option(), options_size(), search(), sort_options(), and sort_options_by_key().

preferences_options

std::vector<Option> Slic3r::Search::OptionsSearcher::preferences_options {}

private

Referenced by append_preferences_option(), and check_and_update().

printer_technology

PrinterTechnology Slic3r::Search::OptionsSearcher::printer_technology {ptAny}

private

Referenced by check_and_update(), and search().

search_dialog

SearchDialog* Slic3r::Search::OptionsSearcher::search_dialog { nullptr }

Referenced by dlg_msw_rescale(), dlg_sys_color_changed(), and show_dialog().

search_line

std::string Slic3r::Search::OptionsSearcher::search_line

private

Referenced by check_and_update(), search(), search(), and search_string().

view_params

OptionViewParameters Slic3r::Search::OptionsSearcher::view_params

Referenced by Slic3r::GUI::GLCanvas3D::_render_search_list(), Slic3r::Search::SearchDialog::OnCheck(), Slic3r::Search::SearchDialog::Popup(), and search().

---

The documentation for this class was generated from the following files:

• src/slic3r/GUI/Search.hpp
• src/slic3r/GUI/Search.cpp