Slic3r::GUI::Choice Class Reference

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

Inheritance diagram for Slic3r::GUI::Choice:

Collaboration diagram for Slic3r::GUI::Choice:

Public Member Functions
	Choice (const ConfigOptionDef &opt, const t_config_option_key &id)
	Choice (wxWindow *parent, const ConfigOptionDef &opt, const t_config_option_key &id)
	~Choice ()
void	BUILD () override
	Finish constructing the Field's wxWidget-related properties, including setting its own sizer, etc.
void	propagate_value ()
void	set_selection ()
void	set_value (const std::string &value, bool change_event=false)
	Redundant?
void	set_value (const boost::any &value, bool change_event=false) override
	Sets a value for this control. subclasses should overload with a specific version Postcondition: Method does not fire the on_change event.
void	set_values (const std::vector< std::string > &values)
	it's needed for _update_serial_ports()
void	set_values (const wxArrayString &values)
boost::any &	get_value () override
	Gets a boost::any representing this control. subclasses should overload with a specific version.
void	msw_rescale () override
void	enable () override
void	disable () override
wxWindow *	getWindow () override
void	suppress_scroll ()
void	on_back_to_initial_value ()
	Call the attached m_back_to_initial_value method.
void	on_back_to_sys_value ()
	Call the attached m_back_to_sys_value method.
virtual void	set_last_meaningful_value ()
virtual void	set_na_value ()
void	toggle (bool en)
	Fires the enable or disable function, based on the input.
virtual wxString	get_tooltip_text (const wxString &default_string)
void	field_changed ()
virtual wxSizer *	getSizer ()
	If you don't know what you are getting back, check both methods for nullptr.
bool	is_matched (const std::string &string, const std::string &pattern)
void	get_value_by_opt_type (wxString &str, const bool check_value=true)
virtual void	sys_color_changed ()
bool	get_enter_pressed () const
void	set_enter_pressed (bool pressed)
bool	set_undo_bitmap (const ScalableBitmap *bmp)
bool	set_undo_to_sys_bitmap (const ScalableBitmap *bmp)
bool	set_label_colour (const wxColour *clr)
bool	set_undo_tooltip (const wxString *tip)
bool	set_undo_to_sys_tooltip (const wxString *tip)
bool	has_undo_ui () const
const wxBitmapBundle &	undo_bitmap () const
const wxString *	undo_tooltip () const
const wxBitmapBundle &	undo_to_sys_bitmap () const
const wxString *	undo_to_sys_tooltip () const
const wxColour *	label_color () const
const bool	blink () const
bool *	get_blink_ptr ()

Static Public Member Functions
template<class T >
static t_field	Create (wxWindow *parent, const ConfigOptionDef &opt, const t_config_option_key &id)
	Factory method for generating new derived classes.
static int	def_width ()
static int	def_width_wider ()
static int	def_width_thinner ()

Public Attributes
wxWindow *	window { nullptr }
bool	m_is_editable { false }
bool	m_is_dropped { false }
bool	m_suppress_scroll { false }
int	m_last_selected { wxNOT_FOUND }
wxWindow *	m_parent {nullptr}
	parent wx item, opportunity to refactor (probably not necessary - data duplication)
t_kill_focus	m_on_kill_focus {nullptr}
	Function object to store callback passed in from owning object.
t_change	m_on_change {nullptr}
	Function object to store callback passed in from owning object.
t_back_to_init	m_back_to_initial_value { nullptr }
	Function object to store callback passed in from owning object.
t_back_to_init	m_back_to_sys_value { nullptr }
bool	m_disable_change_event {false}
bool	m_is_modified_value {false}
bool	m_is_nonsys_value {true}
const ConfigOptionDef	m_opt {ConfigOptionDef()}
	Copy of ConfigOption for deduction purposes.
const t_config_option_key	m_opt_id
int	m_opt_idx = 0
	{""};
double	opt_height { 0.0 }
bool	parent_is_custom_ctrl { false }

Protected Member Functions
virtual void	PostInitialize ()
void	on_kill_focus ()
	Call the attached on_kill_focus method. It's important to use wxEvent instead of wxFocusEvent, in another case we can't unfocused control at all.
void	on_change_field ()
	Call the attached on_change method.

Protected Attributes
boost::any	m_value
boost::any	m_last_meaningful_value
int	m_em_unit
bool	bEnterPressed = false

Private Member Functions
	Field (const ConfigOptionDef &opt, const t_config_option_key &id)
	Field (wxWindow *parent, const ConfigOptionDef &opt, const t_config_option_key &id)

Private Attributes
UndoValueUI	m_undo_ui

Detailed Description

Constructor & Destructor Documentation

Choice() [1/2]

Slic3r::GUI::Choice::Choice ( const ConfigOptionDef &  opt, const t_config_option_key &  id  )

inline

: Field(opt, id) {}

Choice() [2/2]

Slic3r::GUI::Choice::Choice ( wxWindow *  parent, const ConfigOptionDef &  opt, const t_config_option_key &  id  )

inline

: Field(parent, opt, id) {}

~Choice()

Slic3r::GUI::Choice::~Choice ( )

inline

{}

Member Function Documentation

blink()

const bool Slic3r::GUI::UndoValueUIManager::blink ( ) const

inlineinherited

{ return m_undo_ui.blink; }

References Slic3r::GUI::UndoValueUIManager::UndoValueUI::blink, and Slic3r::GUI::UndoValueUIManager::m_undo_ui.

Referenced by Slic3r::GUI::OG_CustomCtrl::CtrlLine::render().

Here is the caller graph for this function:

BUILD()

void Slic3r::GUI::Choice::BUILD ( )

overridevirtual

Finish constructing the Field's wxWidget-related properties, including setting its own sizer, etc.

Implements Slic3r::GUI::Field.

                   {
    wxSize size(def_width_wider() * m_em_unit, wxDefaultCoord);
    if (m_opt.height >= 0) size.SetHeight(m_opt.height*m_em_unit);
    if (m_opt.width >= 0) size.SetWidth(m_opt.width*m_em_unit);
 
  choice_ctrl* temp;
    if (m_opt.gui_type != ConfigOptionDef::GUIType::undefined 
        && m_opt.gui_type != ConfigOptionDef::GUIType::select_close) {
        m_is_editable = true;
        temp = new choice_ctrl(m_parent, wxID_ANY, wxString(""), wxDefaultPosition, size, 0, nullptr, wxTE_PROCESS_ENTER);
    }
    else {
#ifdef __WXOSX__
        /* wxBitmapComboBox with wxCB_READONLY style return NULL for GetTextCtrl(),
         * so ToolTip doesn't shown.
         * Next workaround helps to solve this problem
         */
        temp = new choice_ctrl();
        temp->SetTextCtrlStyle(wxTE_READONLY);
        temp->Create(m_parent, wxID_ANY, wxString(""), wxDefaultPosition, size, 0, nullptr);
#else
        temp = new choice_ctrl(m_parent, wxID_ANY, wxString(""), wxDefaultPosition, size, 0, nullptr, wxCB_READONLY);
#endif //__WXOSX__
    }
 
#ifdef __WXGTK3__
    wxSize best_sz = temp->GetBestSize();
    if (best_sz.x > size.x)
        temp->SetSize(best_sz);
#endif //__WXGTK3__
 
  temp->SetFont(Slic3r::GUI::wxGetApp().normal_font());
    if (!wxOSX) temp->SetBackgroundStyle(wxBG_STYLE_PAINT);
 
  // recast as a wxWindow to fit the calling convention
  window = dynamic_cast<wxWindow*>(temp);
 
    if (m_opt.enum_def) {
        if (auto& labels = m_opt.enum_def->labels(); !labels.empty()) {
            bool localized = m_opt.enum_def->has_labels();
            for (const std::string& el : labels)
                temp->Append(localized ? _(from_u8(el)) : from_u8(el));
            set_selection();
        }
  }
 
    temp->Bind(wxEVT_MOUSEWHEEL, [this](wxMouseEvent& e) {
        if (m_suppress_scroll && !m_is_dropped)
            e.StopPropagation();
        else
            e.Skip();
        });
    temp->Bind(wxEVT_COMBOBOX_DROPDOWN, [this](wxCommandEvent&) { m_is_dropped = true; });
    temp->Bind(wxEVT_COMBOBOX_CLOSEUP,  [this](wxCommandEvent&) { m_is_dropped = false; });
 
    temp->Bind(wxEVT_COMBOBOX,          [this](wxCommandEvent&) { on_change_field(); }, temp->GetId());
 
    if (m_is_editable) {
        temp->Bind(wxEVT_KILL_FOCUS, [this](wxEvent& e) {
            e.Skip();
            if (!bEnterPressed)
                propagate_value();
        } );
 
        temp->Bind(wxEVT_TEXT_ENTER, [this](wxEvent& e) {
            EnterPressed enter(this);
            propagate_value();
        } );
    }
 
  temp->SetToolTip(get_tooltip_text(temp->GetValue()));
}

References _, Slic3r::GUI::from_u8(), and wxOSX.

Here is the call graph for this function:

Create()

template<class T >

static t_field Slic3r::GUI::Field::Create ( wxWindow *  parent, const ConfigOptionDef &  opt, const t_config_option_key &  id  )

inlinestaticinherited

Factory method for generating new derived classes.

p;

    {
        auto p = Slic3r::make_unique<T>(parent, opt, id);
        p->PostInitialize();
    return std::move(p); 
    }

def_width()

int Slic3r::GUI::Field::def_width ( )

staticinherited

{ return 8; }

def_width_thinner()

int Slic3r::GUI::Field::def_width_thinner ( )

staticinherited

{ return 4; }

Referenced by Slic3r::GUI::DiamTextCtrl::DiamTextCtrl(), and Slic3r::GUI::OptionsGroup::activate_line().

Here is the caller graph for this function:

def_width_wider()

int Slic3r::GUI::Field::def_width_wider ( )

staticinherited

{ return 16; }

Referenced by Slic3r::GUI::PhysicalPrinterDialog::build_printhost_settings().

Here is the caller graph for this function:

disable()

void Slic3r::GUI::Choice::disable ( )

overridevirtual

Implements Slic3r::GUI::Field.

{ dynamic_cast<choice_ctrl*>(window)->Disable(); }

References Slic3r::Disable.

enable()

void Slic3r::GUI::Choice::enable ( )

overridevirtual

Implements Slic3r::GUI::Field.

{ dynamic_cast<choice_ctrl*>(window)->Enable(); }

References Slic3r::Enable.

Field() [1/2]

Slic3r::GUI::Field::Field ( const ConfigOptionDef &  opt, const t_config_option_key &  id  )

inlineprivate

: m_opt(opt), m_opt_id(id) {}

Field() [2/2]

Slic3r::GUI::Field::Field ( wxWindow *  parent, const ConfigOptionDef &  opt, const t_config_option_key &  id  )

inlineprivate

: m_parent(parent), m_opt(opt), m_opt_id(id) {}

field_changed()

void Slic3r::GUI::Field::field_changed ( )

inlineinherited

{ on_change_field(); }

References Slic3r::GUI::Field::on_change_field().

Referenced by Slic3r::GUI::PhysicalPrinterDialog::build_printhost_settings().

Here is the call graph for this function:

Here is the caller graph for this function:

get_blink_ptr()

bool * Slic3r::GUI::UndoValueUIManager::get_blink_ptr ( )

inlineinherited

{ return &m_undo_ui.blink; }

References Slic3r::GUI::UndoValueUIManager::UndoValueUI::blink, and Slic3r::GUI::UndoValueUIManager::m_undo_ui.

Referenced by Slic3r::GUI::ConfigOptionsGroup::get_custom_ctrl_with_blinking_ptr().

Here is the caller graph for this function:

get_enter_pressed()

bool Slic3r::GUI::Field::get_enter_pressed ( ) const

inlineinherited

{ return bEnterPressed; }

References Slic3r::GUI::Field::bEnterPressed.

get_tooltip_text()

wxString Slic3r::GUI::Field::get_tooltip_text ( const wxString &  default_string )

virtualinherited

{
    if (m_opt.tooltip.empty())
        return "";
 
    std::string opt_id = m_opt_id;
    auto hash_pos = opt_id.find('#');
    if (hash_pos != std::string::npos) {
        opt_id.replace(hash_pos, 1,"[");
        opt_id += "]";
    }
 
  return from_u8(m_opt.tooltip) + "\n" + _L("default value") + "\t: " +
        (boost::iends_with(opt_id, "_gcode") ? "\n" : "") + default_string +
        (boost::iends_with(opt_id, "_gcode") ? "" : "\n") +
        _L("parameter name") + "\t: " + opt_id;
}

References _L, and Slic3r::GUI::from_u8().

Here is the call graph for this function:

get_value()

boost::any & Slic3r::GUI::Choice::get_value ( )

overridevirtual

Gets a boost::any representing this control. subclasses should overload with a specific version.

Implements Slic3r::GUI::Field.

{
    choice_ctrl* field = dynamic_cast<choice_ctrl*>(window);
 
  wxString ret_str = field->GetValue();
 
  // options from right panel
  std::vector <std::string> right_panel_options{ "support", "pad", "scale_unit" };
  for (auto rp_option: right_panel_options)
    if (m_opt_id == rp_option)
      return m_value = boost::any(ret_str);
 
  if (m_opt.type == coEnum)
        // Closed enum: The combo box item index returned by the field must be convertible to an enum value.
        m_value = m_opt.enum_def->index_to_enum(field->GetSelection());
    else if (m_opt.gui_type == ConfigOptionDef::GUIType::f_enum_open || m_opt.gui_type == ConfigOptionDef::GUIType::i_enum_open) {
        // Open enum: The combo box item index returned by the field 
        const int ret_enum = field->GetSelection();
        if (ret_enum < 0 || ! m_opt.enum_def->has_values() || m_opt.type == coStrings ||
            (into_u8(ret_str) != m_opt.enum_def->value(ret_enum) && ret_str != _(m_opt.enum_def->label(ret_enum))))
      // modifies ret_string!
            get_value_by_opt_type(ret_str);
        else if (m_opt.type == coFloatOrPercent)
            m_value = m_opt.enum_def->value(ret_enum);
        else if (m_opt.type == coInt)
            m_value = atoi(m_opt.enum_def->value(ret_enum).c_str());
        else
            m_value = string_to_double_decimal_point(m_opt.enum_def->value(ret_enum));
    }
  else
    // modifies ret_string!
        get_value_by_opt_type(ret_str);
 
  return m_value;
}

References _, Slic3r::coEnum, Slic3r::coFloatOrPercent, Slic3r::coInt, Slic3r::coStrings, Slic3r::GUI::into_u8(), and Slic3r::string_to_double_decimal_point().

Here is the call graph for this function:

get_value_by_opt_type()

void Slic3r::GUI::Field::get_value_by_opt_type ( wxString &  str, const bool  check_value = true  )

inherited

{
  switch (m_opt.type) {
  case coInt:
    m_value = wxAtoi(str);
    break;
  case coPercent:
  case coPercents:
  case coFloats:
  case coFloat:{
    if (m_opt.type == coPercent && !str.IsEmpty() &&  str.Last() == '%')
      str.RemoveLast();
    else if (!str.IsEmpty() && str.Last() == '%')
        {
            if (!check_value) {
                m_value.clear();
                break;
            }
 
      wxString label = m_opt.full_label.empty() ? _(m_opt.label) : _(m_opt.full_label);
            show_error(m_parent, format_wxstr(_L("%s doesn't support percentage"), label));
      set_value(double_to_string(m_opt.min), true);
      m_value = double(m_opt.min);
      break;
    }
        double val;
 
        bool is_na_value = m_opt.nullable && str == na_value();
 
        const char dec_sep = is_decimal_separator_point() ? '.' : ',';
        const char dec_sep_alt = dec_sep == '.' ? ',' : '.';
        // Replace the first incorrect separator in decimal number, 
        // if this value doesn't "N/A" value in some language
        // see https://github.com/prusa3d/PrusaSlicer/issues/6921
        if (!is_na_value && str.Replace(dec_sep_alt, dec_sep, false) != 0)
            set_value(str, false);
 
        if (str == dec_sep)
            val = 0.0;
        else
        {
            if (is_na_value)
                val = ConfigOptionFloatsNullable::nil_value();
            else if (!str.ToDouble(&val))
            {
                if (!check_value) {
                    m_value.clear();
                    break;
                }
                show_error(m_parent, _(L("Invalid numeric input.")));
                set_value(double_to_string(val), true);
            }
            if (m_opt.min > val || val > m_opt.max)
            {
                if (!check_value) {
                    m_value.clear();
                    break;
                }
                if (m_opt_id == "extrusion_multiplier") {
                    if (m_value.empty() || boost::any_cast<double>(m_value) != val) {
                        wxString msg_text = format_wxstr(_L("Input value is out of range\n"
                            "Are you sure that %s is a correct value and that you want to continue?"), str);
//                        wxMessageDialog dialog(m_parent, msg_text, _L("Parameter validation") + ": " + m_opt_id, wxICON_WARNING | wxYES | wxNO);
                        WarningDialog dialog(m_parent, msg_text, _L("Parameter validation") + ": " + m_opt_id, wxYES | wxNO);
                        if (dialog.ShowModal() == wxID_NO) {
                            if (m_value.empty()) {
                                if (m_opt.min > val) val = m_opt.min;
                                if (val > m_opt.max) val = m_opt.max;
                            }
                            else
                                val = boost::any_cast<double>(m_value);
                            set_value(double_to_string(val), true);
                        }
                    }
                }
                else {
                    show_error(m_parent, _L("Input value is out of range"));
                    if (m_opt.min > val) val = m_opt.min;
                    if (val > m_opt.max) val = m_opt.max;
                    set_value(double_to_string(val), true);
                }
            }
        }
        m_value = val;
    break; }
  case coString:
  case coStrings:
    case coFloatsOrPercents:
    case coFloatOrPercent: {
        if (m_opt.type == coFloatOrPercent && m_opt.opt_key == "first_layer_height" && !str.IsEmpty() && str.Last() == '%') {
            // Workaroud to avoid of using of the % for first layer height
            // see https://github.com/prusa3d/PrusaSlicer/issues/7418
            wxString label = m_opt.full_label.empty() ? _(m_opt.label) : _(m_opt.full_label);
            show_error(m_parent, format_wxstr(_L("%s doesn't support percentage"), label));
            const wxString stVal = double_to_string(0.01, 2);
            set_value(stVal, true);
            m_value = into_u8(stVal);;
            break;
        }
        if ((m_opt.type == coFloatOrPercent || m_opt.type == coFloatsOrPercents) && !str.IsEmpty() &&  str.Last() != '%')
        {
            double val = 0.;
            const char dec_sep = is_decimal_separator_point() ? '.' : ',';
            const char dec_sep_alt = dec_sep == '.' ? ',' : '.';
            // Replace the first incorrect separator in decimal number.
            if (str.Replace(dec_sep_alt, dec_sep, false) != 0)
                set_value(str, false);
 
 
            // remove space and "mm" substring, if any exists
            str.Replace(" ", "", true);
            str.Replace("m", "", true);
 
            if (!str.ToDouble(&val))
            {
                if (!check_value) {
                    m_value.clear();
                    break;
                }
                show_error(m_parent, _(L("Invalid numeric input.")));
                set_value(double_to_string(val), true);
            }
            else if (((m_opt.sidetext.rfind("mm/s") != std::string::npos && val > m_opt.max) ||
                     (m_opt.sidetext.rfind("mm ") != std::string::npos && val > /*1*/m_opt.max_literal)) &&
                     (m_value.empty() || into_u8(str) != boost::any_cast<std::string>(m_value)))
            {
                if (!check_value) {
                    m_value.clear();
                    break;
                }
 
                bool infill_anchors = m_opt.opt_key == "infill_anchor" || m_opt.opt_key == "infill_anchor_max";
 
                const std::string sidetext = m_opt.sidetext.rfind("mm/s") != std::string::npos ? "mm/s" : "mm";
                const wxString stVal = double_to_string(val, 2);
                // TRN %1% = Value, %2% = units
                const wxString msg_text = format_wxstr(_L("Do you mean %1%%% instead of %1% %2%?\n"
                    "Select YES if you want to change this value to %1%%%, \n"
                    "or NO if you are sure that %1% %2% is a correct value."), stVal, sidetext);
                WarningDialog dialog(m_parent, msg_text, _L("Parameter validation") + ": " + m_opt_id, wxYES | wxNO);
                if ((!infill_anchors || val > 100) && dialog.ShowModal() == wxID_YES) {
                    set_value(from_u8((boost::format("%s%%") % stVal).str()), false/*true*/);
                    str += "%%";
                }
        else
          set_value(stVal, false); // it's no needed but can be helpful, when inputted value contained "," instead of "."
            }
        }
 
        m_value = into_u8(str);
    break; }
 
    case coPoints: {
        std::vector<Vec2d> out_values;
        str.Replace(" ", wxEmptyString, true);
        if (!str.IsEmpty()) {
            bool invalid_val = false;
            bool out_of_range_val = false;
            wxStringTokenizer thumbnails(str, ",");
            while (thumbnails.HasMoreTokens()) {
                wxString token = thumbnails.GetNextToken();
                double x, y;
                wxStringTokenizer thumbnail(token, "x");
                if (thumbnail.HasMoreTokens()) {
                    wxString x_str = thumbnail.GetNextToken();
                    if (x_str.ToDouble(&x) && thumbnail.HasMoreTokens()) {
                        wxString y_str = thumbnail.GetNextToken();
                        if (y_str.ToDouble(&y) && !thumbnail.HasMoreTokens()) {
                            if (0 < x && x < 1000 && 0 < y && y < 1000) {
                                out_values.push_back(Vec2d(x, y));
                                continue;
                            }
                            out_of_range_val = true;
                            break;
                        }
                    }
                }
                invalid_val = true;
                break;
            }
 
            if (out_of_range_val) {
                wxString text_value;
                if (!m_value.empty())
                    text_value = get_thumbnails_string(boost::any_cast<std::vector<Vec2d>>(m_value));
                set_value(text_value, true);
                show_error(m_parent, _L("Input value is out of range"));
            }
            else if (invalid_val) {
                wxString text_value;
                if (!m_value.empty())
                    text_value = get_thumbnails_string(boost::any_cast<std::vector<Vec2d>>(m_value));
                set_value(text_value, true);
                show_error(m_parent, format_wxstr(_L("Invalid input format. Expected vector of dimensions in the following format: \"%1%\""),"XxY, XxY, ..." ));
            }
        }
 
        m_value = out_values;
        break; }
 
  default:
    break;
  }
}

References _, _L, Slic3r::coFloat, Slic3r::coFloatOrPercent, Slic3r::coFloats, Slic3r::coFloatsOrPercents, Slic3r::coInt, Slic3r::coPercent, Slic3r::coPercents, Slic3r::coPoints, Slic3r::coString, Slic3r::coStrings, Slic3r::GUI::double_to_string(), Slic3r::GUI::format_wxstr(), Slic3r::GUI::from_u8(), Slic3r::GUI::get_thumbnails_string(), Slic3r::GUI::into_u8(), Slic3r::is_decimal_separator_point(), L, Slic3r::GUI::na_value(), Slic3r::ConfigOptionFloatsTempl< NULLABLE >::nil_value(), and Slic3r::GUI::show_error().

Here is the call graph for this function:

getSizer()

virtual wxSizer * Slic3r::GUI::Field::getSizer ( )

inlinevirtualinherited

If you don't know what you are getting back, check both methods for nullptr.

Reimplemented in Slic3r::GUI::PointCtrl, and Slic3r::GUI::SliderCtrl.

{ return nullptr; }

Referenced by Slic3r::GUI::OG_CustomCtrl::CtrlLine::correct_items_positions(), Slic3r::GUI::OG_CustomCtrl::CtrlLine::render(), and Slic3r::GUI::OG_CustomCtrl::CtrlLine::update_visibility().

Here is the caller graph for this function:

getWindow()

wxWindow * Slic3r::GUI::Choice::getWindow ( )

inlineoverridevirtual

Reimplemented from Slic3r::GUI::Field.

{ return window; }

References window.

has_undo_ui()

bool Slic3r::GUI::UndoValueUIManager::has_undo_ui ( ) const

inlineinherited

{ return m_undo_ui.undo_bitmap != nullptr; }

References Slic3r::GUI::UndoValueUIManager::m_undo_ui, and Slic3r::GUI::UndoValueUIManager::UndoValueUI::undo_bitmap.

Referenced by Slic3r::GUI::OG_CustomCtrl::get_pos(), and Slic3r::GUI::OG_CustomCtrl::CtrlLine::render().

Here is the caller graph for this function:

is_matched()

bool Slic3r::GUI::Field::is_matched ( const std::string &  string, const std::string &  pattern  )

inherited

{
  std::regex regex_pattern(pattern, std::regex_constants::icase); // use ::icase to make the matching case insensitive like /i in perl
  return std::regex_match(string, regex_pattern);
}

label_color()

const wxColour * Slic3r::GUI::UndoValueUIManager::label_color ( ) const

inlineinherited

{ return m_undo_ui.label_color; }

References Slic3r::GUI::UndoValueUIManager::UndoValueUI::label_color, and Slic3r::GUI::UndoValueUIManager::m_undo_ui.

Referenced by Slic3r::GUI::OG_CustomCtrl::CtrlLine::render().

Here is the caller graph for this function:

msw_rescale()

void Slic3r::GUI::Choice::msw_rescale ( )

overridevirtual

Reimplemented from Slic3r::GUI::Field.

{
    Field::msw_rescale();
 
    choice_ctrl* field = dynamic_cast<choice_ctrl*>(window);
#ifdef __WXOSX__
    const wxString selection = field->GetValue();// field->GetString(index);
 
  /* To correct scaling (set new controll size) of a wxBitmapCombobox
   * we need to refill control with new bitmaps. So, in our case :
   * 1. clear control
   * 2. add content
   * 3. add scaled "empty" bitmap to the at least one item
   */
    field->Clear();
    wxSize size(wxDefaultSize);
    size.SetWidth((m_opt.width > 0 ? m_opt.width : def_width_wider()) * m_em_unit);
 
    // Set rescaled min height to correct layout
    field->SetMinSize(wxSize(-1, int(1.5f*field->GetFont().GetPixelSize().y + 0.5f)));
    // Set rescaled size
    field->SetSize(size);
 
    if (m_opt.enum_def) {
        if (auto& labels = m_opt.enum_def->labels(); !labels.empty()) {
            const bool localized = m_opt.enum_def->has_labels();
            for (const std::string& el : labels)
                field->Append(localized ? _(from_u8(el)) : from_u8(el));
 
            if (auto opt = m_opt.enum_def->label_to_index(into_u8(selection)); opt.has_value())
                // This enum has a value field of the same content as text_value. Select it.
                field->SetSelection(*opt);
            else
                field->SetValue(selection);
        }
    }
#else
#ifdef _WIN32
    field->Rescale();
#endif
    auto size = wxSize(def_width_wider() * m_em_unit, wxDefaultCoord);
    if (m_opt.height >= 0) size.SetHeight(m_opt.height * m_em_unit);
    if (m_opt.width >= 0) size.SetWidth(m_opt.width * m_em_unit);
 
    if (parent_is_custom_ctrl)
        field->SetSize(size);
    else
        field->SetMinSize(size);
#endif
}

References _, Slic3r::GUI::from_u8(), and Slic3r::GUI::into_u8().

Here is the call graph for this function:

on_back_to_initial_value()

void Slic3r::GUI::Field::on_back_to_initial_value ( )

inherited

Call the attached m_back_to_initial_value method.

{
  if (m_back_to_initial_value != nullptr && m_is_modified_value)
    m_back_to_initial_value(m_opt_id);
}

on_back_to_sys_value()

void Slic3r::GUI::Field::on_back_to_sys_value ( )

inherited

Call the attached m_back_to_sys_value method.

{
  if (m_back_to_sys_value != nullptr && m_is_nonsys_value)
    m_back_to_sys_value(m_opt_id);
}

on_change_field()

void Slic3r::GUI::Field::on_change_field ( )

protectedinherited

Call the attached on_change method.

{
//       std::cerr << "calling Field::_on_change \n";
    if (m_on_change != nullptr  && !m_disable_change_event)
        m_on_change(m_opt_id, get_value());
}

Referenced by Slic3r::GUI::Field::field_changed().

Here is the caller graph for this function:

on_kill_focus()

void Slic3r::GUI::Field::on_kill_focus ( )

protectedinherited

Call the attached on_kill_focus method. It's important to use wxEvent instead of wxFocusEvent, in another case we can't unfocused control at all.

{
  // call the registered function if it is available
    if (m_on_kill_focus!=nullptr)
        m_on_kill_focus(m_opt_id);
}

PostInitialize()

void Slic3r::GUI::Field::PostInitialize ( )

protectedvirtualinherited

{
  auto color = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW);
 
  switch (m_opt.type)
  {
  case coPercents:
  case coFloats:
  case coStrings:
  case coBools:
  case coInts: {
    auto tag_pos = m_opt_id.find("#");
    if (tag_pos != std::string::npos)
      m_opt_idx = stoi(m_opt_id.substr(tag_pos + 1, m_opt_id.size()));
    break;
  }
  default:
    break;
  }
 
    // initialize m_unit_value
    m_em_unit = em_unit(m_parent);
    parent_is_custom_ctrl = dynamic_cast<OG_CustomCtrl*>(m_parent) != nullptr;
 
  BUILD();
 
  // For the mode, when settings are in non-modal dialog, neither dialog nor tabpanel doesn't receive wxEVT_KEY_UP event, when some field is selected.
  // So, like a workaround check wxEVT_KEY_UP event for the Filed and switch between tabs if Ctrl+(1-4) was pressed
  if (getWindow())
    getWindow()->Bind(wxEVT_KEY_UP, [](wxKeyEvent& evt) {
        if ((evt.GetModifiers() & wxMOD_CONTROL) != 0) {
          int tab_id = -1;
          switch (evt.GetKeyCode()) {
          case '1': { tab_id = 0; break; }
          case '2': { tab_id = 1; break; }
        case '3': { tab_id = 2; break; }
        case '4': { tab_id = 3; break; }
#ifdef __APPLE__
        case 'f':
#else /* __APPLE__ */
        case WXK_CONTROL_F:
#endif /* __APPLE__ */
        case 'F': { wxGetApp().plater()->search(false); break; }
          default: break;
          }
          if (tab_id >= 0)
          wxGetApp().mainframe->select_tab(tab_id);
        if (tab_id > 0)
          // tab panel should be focused for correct navigation between tabs
            wxGetApp().tab_panel()->SetFocus();
        }
 
        evt.Skip();
      });
}

References Slic3r::GUI::Field::BUILD(), Slic3r::coBools, Slic3r::coFloats, Slic3r::coInts, Slic3r::coPercents, Slic3r::coStrings, em_unit(), Slic3r::GUI::Field::getWindow(), if(), Slic3r::GUI::Field::m_em_unit, Slic3r::GUI::Field::m_opt, Slic3r::GUI::Field::m_opt_id, Slic3r::GUI::Field::m_opt_idx, Slic3r::GUI::Field::m_parent, Slic3r::GUI::Field::parent_is_custom_ctrl, and Slic3r::ConfigOptionDef::type.

Here is the call graph for this function:

propagate_value()

void Slic3r::GUI::Choice::propagate_value

(

)

{
    if (m_opt.type == coStrings) {
        on_change_field();
        return;
    }
 
    if (is_defined_input_value<choice_ctrl>(window, m_opt.type)) {
        switch (m_opt.type) {
        case coFloatOrPercent:
        {
            std::string old_val = !m_value.empty() ? boost::any_cast<std::string>(m_value) : "";
            if (old_val == boost::any_cast<std::string>(get_value()))
                return;
            break;
        }
        case coInt:
        {
            int old_val = !m_value.empty() ? boost::any_cast<int>(m_value) : 0;
            if (old_val == boost::any_cast<int>(get_value()))
                return;
            break;
        }
        default:
        {
            double old_val = !m_value.empty() ? boost::any_cast<double>(m_value) : -99999;
            if (fabs(old_val - boost::any_cast<double>(get_value())) <= 0.0001)
                return;
        }
        }
        on_change_field();
    }
    else
        on_kill_focus();
}

References Slic3r::coFloatOrPercent, Slic3r::coInt, and Slic3r::coStrings.

set_enter_pressed()

void Slic3r::GUI::Field::set_enter_pressed ( bool  pressed )

inlineinherited

{ bEnterPressed = pressed; }

References Slic3r::GUI::Field::bEnterPressed.

Referenced by Slic3r::GUI::Field::EnterPressed::EnterPressed(), and Slic3r::GUI::Field::EnterPressed::~EnterPressed().

Here is the caller graph for this function:

set_label_colour()

bool Slic3r::GUI::UndoValueUIManager::set_label_colour ( const wxColour *  clr )

inlineinherited

{ return m_undo_ui.set_label_colour(clr); }

References Slic3r::GUI::UndoValueUIManager::m_undo_ui, and Slic3r::GUI::UndoValueUIManager::UndoValueUI::set_label_colour().

Referenced by Slic3r::GUI::Tab::create_line_with_widget(), Slic3r::GUI::Tab::decorate(), and Slic3r::GUI::Tab::update_label_colours().

Here is the call graph for this function:

Here is the caller graph for this function:

set_last_meaningful_value()

virtual void Slic3r::GUI::Field::set_last_meaningful_value ( )

inlinevirtualinherited

Reimplemented in Slic3r::GUI::TextCtrl, Slic3r::GUI::CheckBox, and Slic3r::GUI::SpinCtrl.

{}

set_na_value()

virtual void Slic3r::GUI::Field::set_na_value ( )

inlinevirtualinherited

Reimplemented in Slic3r::GUI::TextCtrl, Slic3r::GUI::CheckBox, and Slic3r::GUI::SpinCtrl.

{}

set_selection()

void Slic3r::GUI::Choice::set_selection

(

)

{
    /* To prevent earlier control updating under OSX set m_disable_change_event to true
     * (under OSX wxBitmapComboBox send wxEVT_COMBOBOX even after SetSelection())
     */
    m_disable_change_event = true;
 
  wxString text_value = wxString("");
 
    choice_ctrl* field = dynamic_cast<choice_ctrl*>(window);
  switch (m_opt.type) {
  case coEnum:{
        field->SetSelection(m_opt.default_value->getInt());
    break;
  }
  case coFloat:
  case coPercent: {
    double val = m_opt.default_value->getFloat();
    text_value = val - int(val) == 0 ? wxString::Format(_T("%i"), int(val)) : wxNumberFormatter::ToString(val, 1);
    break;
  }
  case coInt:{
    text_value = wxString::Format(_T("%i"), int(m_opt.default_value->getInt()));
    break;
  }
  case coStrings:{
    text_value = m_opt.get_default_value<ConfigOptionStrings>()->get_at(m_opt_idx);
    break;
  }
  case coFloatOrPercent: {
    text_value = double_to_string(m_opt.default_value->getFloat());
    if (m_opt.get_default_value<ConfigOptionFloatOrPercent>()->percent)
      text_value += "%";
    break;
  }
    default: break;
  }
 
  if (!text_value.IsEmpty()) {
    if (auto opt = m_opt.enum_def->value_to_index(into_u8(text_value)); opt.has_value())
            // This enum has a value field of the same content as text_value. Select it.
            field->SetSelection(*opt);
        else
            field->SetValue(text_value);
  }
}

References Slic3r::coEnum, Slic3r::coFloat, Slic3r::coFloatOrPercent, Slic3r::coInt, Slic3r::coPercent, Slic3r::coStrings, Slic3r::GUI::double_to_string(), Slic3r::GUI::into_u8(), and Slic3r::ConfigOptionFloatOrPercent::percent.

Referenced by Slic3r::GUI::PhysicalPrinterDialog::build_printhost_settings().

Here is the call graph for this function:

Here is the caller graph for this function:

set_undo_bitmap()

bool Slic3r::GUI::UndoValueUIManager::set_undo_bitmap ( const ScalableBitmap *  bmp )

inlineinherited

{ return m_undo_ui.set_undo_bitmap(bmp); }

References Slic3r::GUI::UndoValueUIManager::m_undo_ui, and Slic3r::GUI::UndoValueUIManager::UndoValueUI::set_undo_bitmap().

Referenced by Slic3r::GUI::Tab::create_line_with_widget(), and Slic3r::GUI::Tab::decorate().

Here is the call graph for this function:

Here is the caller graph for this function:

set_undo_to_sys_bitmap()

bool Slic3r::GUI::UndoValueUIManager::set_undo_to_sys_bitmap ( const ScalableBitmap *  bmp )

inlineinherited

{ return m_undo_ui.set_undo_to_sys_bitmap(bmp); }

References Slic3r::GUI::UndoValueUIManager::m_undo_ui, and Slic3r::GUI::UndoValueUIManager::UndoValueUI::set_undo_to_sys_bitmap().

Referenced by Slic3r::GUI::Tab::create_line_with_widget(), and Slic3r::GUI::Tab::decorate().

Here is the call graph for this function:

Here is the caller graph for this function:

set_undo_to_sys_tooltip()

bool Slic3r::GUI::UndoValueUIManager::set_undo_to_sys_tooltip ( const wxString *  tip )

inlineinherited

{ return m_undo_ui.set_undo_to_sys_tooltip(tip); }  

References Slic3r::GUI::UndoValueUIManager::m_undo_ui, and Slic3r::GUI::UndoValueUIManager::UndoValueUI::set_undo_to_sys_tooltip().

Referenced by Slic3r::GUI::Tab::create_line_with_widget(), and Slic3r::GUI::Tab::decorate().

Here is the call graph for this function:

Here is the caller graph for this function:

set_undo_tooltip()

bool Slic3r::GUI::UndoValueUIManager::set_undo_tooltip ( const wxString *  tip )

inlineinherited

{ return m_undo_ui.set_undo_tooltip(tip); }

References Slic3r::GUI::UndoValueUIManager::m_undo_ui, and Slic3r::GUI::UndoValueUIManager::UndoValueUI::set_undo_tooltip().

Referenced by Slic3r::GUI::Tab::create_line_with_widget(), and Slic3r::GUI::Tab::decorate().

Here is the call graph for this function:

Here is the caller graph for this function:

set_value() [1/2]

void Slic3r::GUI::Choice::set_value ( const boost::any &  value, bool  change_event = false  )

overridevirtual

Sets a value for this control. subclasses should overload with a specific version Postcondition: Method does not fire the on_change event.

Implements Slic3r::GUI::Field.

{
  m_disable_change_event = !change_event;
 
    choice_ctrl* field = dynamic_cast<choice_ctrl*>(window);
 
  switch (m_opt.type) {
  case coInt:
  case coFloat:
  case coPercent:
  case coFloatOrPercent:
  case coString:
  case coStrings: {
    wxString text_value = m_opt.type == coInt ? 
            wxString::Format(_T("%i"), int(boost::any_cast<int>(value))) :
            boost::any_cast<wxString>(value);
        int sel_idx = -1;
        if (m_opt.enum_def) {
            if (auto idx = m_opt.enum_def->label_to_index(into_u8(text_value)); idx.has_value())
                sel_idx = *idx;
            else if (idx = m_opt.enum_def->value_to_index(into_u8(text_value)); idx.has_value())
                sel_idx = *idx;
        }
 
        if (sel_idx >= 0 )
            field->SetSelection(sel_idx);
        else {
            // For editable Combobox under OSX is needed to set selection to -1 explicitly,
            // otherwise selection doesn't be changed
            field->SetSelection(-1);
            field->SetValue(text_value);
        }
 
        if (!m_value.empty() && m_opt.opt_key == "fill_density") {
            // If m_value was changed before, then update m_value here too to avoid case 
            // when control's value is already changed from the ConfigManipulation::update_print_fff_config(),
            // but m_value doesn't respect it.
            if (double val; text_value.ToDouble(&val))
                m_value = val;
        }
 
    break;
  }
  case coEnum: {
    auto val = m_opt.enum_def->enum_to_index(boost::any_cast<int>(value));
        assert(val.has_value());
    field->SetSelection(val.has_value() ? *val : 0);
    break;
  }
  default:
    break;
  }
 
  m_disable_change_event = false;
}

References Slic3r::coEnum, Slic3r::coFloat, Slic3r::coFloatOrPercent, Slic3r::coInt, Slic3r::coPercent, Slic3r::coString, Slic3r::coStrings, and Slic3r::GUI::into_u8().

Here is the call graph for this function:

set_value() [2/2]

void Slic3r::GUI::Choice::set_value	(	const std::string &	value,
		bool	change_event = false
	)

Redundant?

{
  m_disable_change_event = !change_event;
    choice_ctrl* field = dynamic_cast<choice_ctrl*>(window);
    if (auto opt = m_opt.enum_def->value_to_index(value); opt.has_value())
        // This enum has a value field of the same content as text_value. Select it.
        field->SetSelection(*opt);
    else
        field->SetValue(value);
    m_disable_change_event = false;
}

Referenced by Slic3r::GUI::PhysicalPrinterDialog::update_host_type().

Here is the caller graph for this function:

set_values() [1/2]

void Slic3r::GUI::Choice::set_values

(

const std::vector< std::string > &

values

)

it's needed for _update_serial_ports()

{
  if (values.empty())
    return;
  m_disable_change_event = true;
 
//  # it looks that Clear() also clears the text field in recent wxWidgets versions,
//  # but we want to preserve it
  auto ww = dynamic_cast<choice_ctrl*>(window);
  auto value = ww->GetValue();
  ww->Clear();
  ww->Append("");
  for (const auto &el : values)
    ww->Append(wxString(el));
  ww->SetValue(value);
 
  m_disable_change_event = false;
}

Referenced by Slic3r::GUI::PhysicalPrinterDialog::build_printhost_settings(), Slic3r::GUI::PhysicalPrinterDialog::update_host_type(), and Slic3r::GUI::PhysicalPrinterDialog::update_printers().

Here is the caller graph for this function:

set_values() [2/2]

void Slic3r::GUI::Choice::set_values

(

const wxArrayString &

values

)

{
  if (values.empty())
    return;
 
  m_disable_change_event = true;
 
  //  # it looks that Clear() also clears the text field in recent wxWidgets versions,
  //  # but we want to preserve it
  auto ww = dynamic_cast<choice_ctrl*>(window);
  auto value = ww->GetValue();
  ww->Clear();
//  ww->Append("");
  for (const auto &el : values)
    ww->Append(el);
  ww->SetValue(value);
 
  m_disable_change_event = false;
}

suppress_scroll()

void Slic3r::GUI::Choice::suppress_scroll

(

)

{
    m_suppress_scroll = true;
}

Referenced by Slic3r::GUI::FreqChangedParams::FreqChangedParams().

Here is the caller graph for this function:

sys_color_changed()

void Slic3r::GUI::Field::sys_color_changed ( )

virtualinherited

Reimplemented in Slic3r::GUI::ColourPicker, and Slic3r::GUI::PointCtrl.

{
#ifdef _WIN32
  if (wxWindow* win = this->getWindow())
    wxGetApp().UpdateDarkUI(win);
#endif
}

toggle()

void Slic3r::GUI::Field::toggle ( bool  en )

inlineinherited

Fires the enable or disable function, based on the input.

{ en ? enable() : disable(); }

References Slic3r::GUI::Field::disable(), and Slic3r::GUI::Field::enable().

Referenced by Slic3r::GUI::Tab::compatible_widget_reload(), Slic3r::GUI::Tab::toggle_option(), Slic3r::GUI::ObjectSettings::update_config_values(), and Slic3r::GUI::TabFilament::update_line_with_near_label_widget().

Here is the call graph for this function:

Here is the caller graph for this function:

undo_bitmap()

const wxBitmapBundle & Slic3r::GUI::UndoValueUIManager::undo_bitmap ( ) const

inlineinherited

{ return m_undo_ui.undo_bitmap->bmp(); }

References ScalableBitmap::bmp(), Slic3r::GUI::UndoValueUIManager::m_undo_ui, and Slic3r::GUI::UndoValueUIManager::UndoValueUI::undo_bitmap.

Referenced by Slic3r::GUI::OG_CustomCtrl::CtrlLine::render().

Here is the call graph for this function:

Here is the caller graph for this function:

undo_to_sys_bitmap()

const wxBitmapBundle & Slic3r::GUI::UndoValueUIManager::undo_to_sys_bitmap ( ) const

inlineinherited

{ return m_undo_ui.undo_to_sys_bitmap->bmp(); }

References ScalableBitmap::bmp(), Slic3r::GUI::UndoValueUIManager::m_undo_ui, and Slic3r::GUI::UndoValueUIManager::UndoValueUI::undo_to_sys_bitmap.

Referenced by Slic3r::GUI::OG_CustomCtrl::CtrlLine::render().

Here is the call graph for this function:

Here is the caller graph for this function:

undo_to_sys_tooltip()

const wxString * Slic3r::GUI::UndoValueUIManager::undo_to_sys_tooltip ( ) const

inlineinherited

{ return m_undo_ui.undo_to_sys_tooltip; }

References Slic3r::GUI::UndoValueUIManager::m_undo_ui, and Slic3r::GUI::UndoValueUIManager::UndoValueUI::undo_to_sys_tooltip.

undo_tooltip()

const wxString * Slic3r::GUI::UndoValueUIManager::undo_tooltip ( ) const

inlineinherited

{ return m_undo_ui.undo_tooltip; }

References Slic3r::GUI::UndoValueUIManager::m_undo_ui, and Slic3r::GUI::UndoValueUIManager::UndoValueUI::undo_tooltip.

Member Data Documentation

bEnterPressed

bool Slic3r::GUI::Field::bEnterPressed = false

protectedinherited

Referenced by Slic3r::GUI::Field::get_enter_pressed(), and Slic3r::GUI::Field::set_enter_pressed().

m_back_to_initial_value

t_back_to_init Slic3r::GUI::Field::m_back_to_initial_value { nullptr }

inherited

Function object to store callback passed in from owning object.

Referenced by Slic3r::GUI::Field::~Field().

m_back_to_sys_value

t_back_to_init Slic3r::GUI::Field::m_back_to_sys_value { nullptr }

inherited

Referenced by Slic3r::GUI::Field::~Field().

m_disable_change_event

bool Slic3r::GUI::Field::m_disable_change_event {false}

inherited

Referenced by Slic3r::GUI::CheckBox::set_value(), Slic3r::GUI::StaticText::set_value(), Slic3r::GUI::TextCtrl::set_value(), Slic3r::GUI::ColourPicker::set_value(), and Slic3r::GUI::StaticText::set_value().

m_em_unit

int Slic3r::GUI::Field::m_em_unit

protectedinherited

Referenced by Slic3r::GUI::Field::PostInitialize().

m_is_dropped

bool Slic3r::GUI::Choice::m_is_dropped { false }

m_is_editable

bool Slic3r::GUI::Choice::m_is_editable { false }

m_is_modified_value

bool Slic3r::GUI::Field::m_is_modified_value {false}

inherited

Referenced by Slic3r::GUI::Tab::decorate().

m_is_nonsys_value

bool Slic3r::GUI::Field::m_is_nonsys_value {true}

inherited

Referenced by Slic3r::GUI::Tab::decorate().

m_last_meaningful_value

boost::any Slic3r::GUI::Field::m_last_meaningful_value

protectedinherited

m_last_selected

int Slic3r::GUI::Choice::m_last_selected { wxNOT_FOUND }

m_on_change

t_change Slic3r::GUI::Field::m_on_change {nullptr}

inherited

Function object to store callback passed in from owning object.

Referenced by Slic3r::GUI::Field::~Field().

m_on_kill_focus

t_kill_focus Slic3r::GUI::Field::m_on_kill_focus {nullptr}

inherited

Function object to store callback passed in from owning object.

Referenced by Slic3r::GUI::Field::~Field().

m_opt

const ConfigOptionDef Slic3r::GUI::Field::m_opt {ConfigOptionDef()}

inherited

Copy of ConfigOption for deduction purposes.

Referenced by Slic3r::GUI::Field::PostInitialize(), and Slic3r::GUI::PhysicalPrinterDialog::update_host_type().

m_opt_id

const t_config_option_key Slic3r::GUI::Field::m_opt_id

inherited

Referenced by Slic3r::GUI::Field::PostInitialize().

m_opt_idx

int Slic3r::GUI::Field::m_opt_idx = 0

inherited

{""};

Referenced by Slic3r::GUI::Field::PostInitialize().

m_parent

wxWindow* Slic3r::GUI::Field::m_parent {nullptr}

inherited

parent wx item, opportunity to refactor (probably not necessary - data duplication)

Referenced by Slic3r::GUI::Field::PostInitialize().

m_suppress_scroll

bool Slic3r::GUI::Choice::m_suppress_scroll { false }

m_undo_ui

UndoValueUI Slic3r::GUI::UndoValueUIManager::m_undo_ui

privateinherited

Referenced by Slic3r::GUI::UndoValueUIManager::blink(), Slic3r::GUI::UndoValueUIManager::get_blink_ptr(), Slic3r::GUI::UndoValueUIManager::has_undo_ui(), Slic3r::GUI::UndoValueUIManager::label_color(), Slic3r::GUI::UndoValueUIManager::set_label_colour(), Slic3r::GUI::UndoValueUIManager::set_undo_bitmap(), Slic3r::GUI::UndoValueUIManager::set_undo_to_sys_bitmap(), Slic3r::GUI::UndoValueUIManager::set_undo_to_sys_tooltip(), Slic3r::GUI::UndoValueUIManager::set_undo_tooltip(), Slic3r::GUI::UndoValueUIManager::undo_bitmap(), Slic3r::GUI::UndoValueUIManager::undo_to_sys_bitmap(), Slic3r::GUI::UndoValueUIManager::undo_to_sys_tooltip(), and Slic3r::GUI::UndoValueUIManager::undo_tooltip().

m_value

boost::any Slic3r::GUI::Field::m_value

protectedinherited

Referenced by Slic3r::GUI::StaticText::get_value().

opt_height

double Slic3r::GUI::Field::opt_height { 0.0 }

inherited

parent_is_custom_ctrl

bool Slic3r::GUI::Field::parent_is_custom_ctrl { false }

inherited

Referenced by Slic3r::GUI::Field::PostInitialize().

window

wxWindow* Slic3r::GUI::Choice::window { nullptr }

Referenced by getWindow().

---

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

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