Slic3r::Search::OptionsSearcher Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/Search.hpp>

Collaboration diagram for Slic3r::Search::OptionsSearcher:

Public Member Functions
	OptionsSearcher ()
	~OptionsSearcher ()
SettingsIndex &	index ()
const SettingsIndex &	index () const
void	init (std::vector< InputInfo > input_values)
void	apply (DynamicPrintConfig *config, Preset::Type type, ConfigOptionMode mode)
bool	search ()
bool	search (const std::string &search, bool force=false, Preset::Type type=Preset::TYPE_INVALID)
size_t	size () const
const FoundOption &	operator[] (const size_t pos) const noexcept
const Option &	get_option (size_t pos_in_filter) const
const std::vector< FoundOption > &	found_options ()
std::string &	search_string ()
void	set_printer_technology (PrinterTechnology pt)
void	show_dialog (Preset::Type type, wxWindow *parent, TextInput *input, wxWindow *ssearch_btn)
void	dlg_sys_color_changed ()
void	dlg_msw_rescale ()

Public Attributes
OptionViewParameters	view_params
SearchDialog *	search_dialog {nullptr}

Private Member Functions
void	sort_found ()
size_t	found_size () const

Private Attributes
SettingsIndex	m_index
std::string	search_line
Preset::Type	search_type = Preset::TYPE_INVALID
PrinterTechnology	printer_technology
std::vector< FoundOption >	found {}

Detailed Description

Constructor & Destructor Documentation

OptionsSearcher()

Slic3r::Search::OptionsSearcher::OptionsSearcher

(

)

{}

~OptionsSearcher()

Slic3r::Search::OptionsSearcher::~OptionsSearcher

(

)

{}

Member Function Documentation

apply()

void Slic3r::Search::OptionsSearcher::apply	(	DynamicPrintConfig *	config,
		Preset::Type	type,
		ConfigOptionMode	mode )

{
    if (m_index.apply(config, type, mode))
        search(search_line, true, search_type);
}

References m_index, search(), search_line, and search_type.

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 search_dialog.

dlg_sys_color_changed()

void Slic3r::Search::OptionsSearcher::dlg_sys_color_changed

(

)

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

found_options()

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

inline

{ return found; }

References found.

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_option()

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 m_index.option_at(found[pos_in_filter].option_idx);
}

References found, and m_index.

index() [1/2]

SettingsIndex & Slic3r::Search::OptionsSearcher::index ( )

inline

{ return m_index; }

References m_index.

index() [2/2]

const SettingsIndex & Slic3r::Search::OptionsSearcher::index ( ) const

inline

{ return m_index; }

References m_index.

init()

void Slic3r::Search::OptionsSearcher::init

(

std::vector< InputInfo >

input_values

)

{
    m_index.init(std::move(input_values));
 
    search(search_line, true, search_type);
}

References m_index, search(), search_line, and search_type.

Here is the call graph for this function:

operator[]()

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

inlinenoexcept

{ return found[pos]; }

References found.

search() [1/2]

bool Slic3r::Search::OptionsSearcher::search

(

)

{ return search(search_line, true); }

References search(), and search_line.

Referenced by apply(), init(), 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,
		Preset::Type	type = Preset::TYPE_INVALID )

{
    if (search_line == search && search_type == type && !force) return false;
 
    found.clear();
 
    bool         full_list = search.empty();
    wxString 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.multi_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.multi_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 wxString(marker_by_type(opt.type, printer_technology)) + opt.category_local + sep + opt.group_local + sep + opt.label_local;
    };
 
    std::vector<uint16_t>      matches, matches2;
    const std::vector<Option> &options = m_index.options();
    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, into_u8(get_tooltip(opt)), i, 0});
            } else if (type == opt.type){
                found.emplace_back(FoundOption{label, label, into_u8(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, into_u8(get_tooltip(opt)), i, score});
            } else if (type == opt.type) {
                found.emplace_back(FoundOption{label_plain, label_u8, into_u8(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;
}

References found, Slic3r::Search::fuzzy_match(), Slic3r::into_u8(), L, m_index, Slic3r::Search::mark_string(), Slic3r::Search::marker_by_type(), printer_technology, search(), search_line, search_type, sort_found(), Slic3r::Preset::TYPE_INVALID, and view_params.

Here is the call graph for this function:

search_string()

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

inline

{ return search_line; }

References search_line.

set_printer_technology()

void Slic3r::Search::OptionsSearcher::set_printer_technology ( PrinterTechnology pt )

inline

{ printer_technology = pt; }

References printer_technology.

show_dialog()

void Slic3r::Search::OptionsSearcher::show_dialog	(	Preset::Type	type,
		wxWindow *	parent,
		TextInput *	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));
#ifndef __WXGTK__
    pos.y += input->GetParent()->GetRect().height;
#else
    input->GetParent()->Hide();
#endif
    search_dialog->SetPosition(pos);
    search_dialog->Popup();
}

References search_dialog.

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:

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().

m_index

SettingsIndex Slic3r::Search::OptionsSearcher::m_index

private

Referenced by apply(), get_option(), index(), index(), init(), and search().

printer_technology

PrinterTechnology Slic3r::Search::OptionsSearcher::printer_technology

private

Referenced by search(), and set_printer_technology().

search_dialog

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

{nullptr};

Referenced by dlg_msw_rescale(), and show_dialog().

search_line

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

private

Referenced by apply(), init(), search(), search(), and search_string().

search_type

Preset::Type Slic3r::Search::OptionsSearcher::search_type = Preset::TYPE_INVALID

private

Referenced by apply(), init(), and search().

view_params

OptionViewParameters Slic3r::Search::OptionsSearcher::view_params

Referenced by search().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/Search.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/Search.cpp