2017-12-13 13:45:10 +00:00
|
|
|
#include "GUI.hpp"//"slic3r_gui.hpp"
|
|
|
|
#include "Field.hpp"
|
|
|
|
|
2017-12-18 12:58:51 +00:00
|
|
|
//#include <wx/event.h>
|
|
|
|
#include <regex>
|
|
|
|
#include <wx/numformatter.h>
|
2018-02-01 08:29:07 +00:00
|
|
|
#include <wx/tooltip.h>
|
2017-12-18 12:58:51 +00:00
|
|
|
#include "PrintConfig.hpp"
|
2018-01-27 13:21:16 +00:00
|
|
|
#include <boost/algorithm/string/predicate.hpp>
|
2018-10-01 13:09:31 +00:00
|
|
|
#include "GUI_App.hpp"
|
2017-12-18 12:58:51 +00:00
|
|
|
|
2017-12-13 13:45:10 +00:00
|
|
|
namespace Slic3r { namespace GUI {
|
|
|
|
|
2018-02-19 08:15:15 +00:00
|
|
|
wxString double_to_string(double const value)
|
|
|
|
{
|
2018-06-25 11:32:28 +00:00
|
|
|
if (value - int(value) == 0)
|
|
|
|
return wxString::Format(_T("%i"), int(value));
|
|
|
|
else {
|
|
|
|
int precision = 4;
|
|
|
|
for (size_t p = 1; p < 4; p++)
|
|
|
|
{
|
|
|
|
double cur_val = pow(10, p)*value;
|
|
|
|
if (cur_val - int(cur_val) == 0) {
|
|
|
|
precision = p;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return wxNumberFormatter::ToString(value, precision, wxNumberFormatter::Style_None);
|
|
|
|
}
|
2018-02-19 08:15:15 +00:00
|
|
|
}
|
|
|
|
|
2018-10-31 11:26:57 +00:00
|
|
|
void Field::PostInitialize()
|
|
|
|
{
|
2018-03-06 11:34:20 +00:00
|
|
|
auto color = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW);
|
2018-04-26 14:33:37 +00:00
|
|
|
m_Undo_btn = new MyButton(m_parent, wxID_ANY, "", wxDefaultPosition,wxDefaultSize, wxBU_EXACTFIT | wxNO_BORDER);
|
|
|
|
m_Undo_to_sys_btn = new MyButton(m_parent, wxID_ANY, "", wxDefaultPosition,wxDefaultSize, wxBU_EXACTFIT | wxNO_BORDER);
|
2018-03-15 08:55:31 +00:00
|
|
|
if (wxMSW) {
|
|
|
|
m_Undo_btn->SetBackgroundColour(color);
|
|
|
|
m_Undo_to_sys_btn->SetBackgroundColour(color);
|
|
|
|
}
|
2018-03-06 11:34:20 +00:00
|
|
|
m_Undo_btn->Bind(wxEVT_BUTTON, ([this](wxCommandEvent){ on_back_to_initial_value(); }));
|
2018-03-16 16:25:11 +00:00
|
|
|
m_Undo_to_sys_btn->Bind(wxEVT_BUTTON, ([this](wxCommandEvent){ on_back_to_sys_value(); }));
|
2018-03-06 11:34:20 +00:00
|
|
|
|
2018-04-26 14:33:37 +00:00
|
|
|
//set default bitmap
|
|
|
|
wxBitmap bmp;
|
|
|
|
bmp.LoadFile(from_u8(var("bullet_white.png")), wxBITMAP_TYPE_PNG);
|
|
|
|
set_undo_bitmap(&bmp);
|
|
|
|
set_undo_to_sys_bitmap(&bmp);
|
|
|
|
|
2018-06-22 14:13:34 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2018-03-06 11:34:20 +00:00
|
|
|
BUILD();
|
|
|
|
}
|
|
|
|
|
2018-10-31 11:26:57 +00:00
|
|
|
void Field::on_kill_focus(wxEvent& event)
|
|
|
|
{
|
2017-12-13 13:45:10 +00:00
|
|
|
// Without this, there will be nasty focus bugs on Windows.
|
|
|
|
// Also, docs for wxEvent::Skip() say "In general, it is recommended to skip all
|
|
|
|
// non-command events to allow the default handling to take place."
|
2018-01-31 13:59:44 +00:00
|
|
|
event.Skip();
|
2018-02-28 14:39:20 +00:00
|
|
|
// call the registered function if it is available
|
2018-01-31 13:59:44 +00:00
|
|
|
if (m_on_kill_focus!=nullptr)
|
|
|
|
m_on_kill_focus();
|
2017-12-13 13:45:10 +00:00
|
|
|
}
|
2018-01-31 15:46:17 +00:00
|
|
|
void Field::on_change_field()
|
|
|
|
{
|
2018-01-05 14:11:33 +00:00
|
|
|
// std::cerr << "calling Field::_on_change \n";
|
|
|
|
if (m_on_change != nullptr && !m_disable_change_event)
|
|
|
|
m_on_change(m_opt_id, get_value());
|
2017-12-13 13:45:10 +00:00
|
|
|
}
|
2017-12-18 12:58:51 +00:00
|
|
|
|
2018-10-31 11:26:57 +00:00
|
|
|
void Field::on_back_to_initial_value()
|
|
|
|
{
|
2018-03-07 14:05:41 +00:00
|
|
|
if (m_back_to_initial_value != nullptr && m_is_modified_value)
|
2018-03-06 11:34:20 +00:00
|
|
|
m_back_to_initial_value(m_opt_id);
|
|
|
|
}
|
|
|
|
|
2018-10-31 11:26:57 +00:00
|
|
|
void Field::on_back_to_sys_value()
|
|
|
|
{
|
2018-03-16 16:25:11 +00:00
|
|
|
if (m_back_to_sys_value != nullptr && m_is_nonsys_value)
|
|
|
|
m_back_to_sys_value(m_opt_id);
|
|
|
|
}
|
|
|
|
|
2018-01-27 13:21:16 +00:00
|
|
|
wxString Field::get_tooltip_text(const wxString& default_string)
|
|
|
|
{
|
|
|
|
wxString tooltip_text("");
|
2018-06-22 08:59:54 +00:00
|
|
|
wxString tooltip = _(m_opt.tooltip);
|
2018-02-07 16:13:52 +00:00
|
|
|
if (tooltip.length() > 0)
|
2018-08-06 13:47:03 +00:00
|
|
|
tooltip_text = tooltip + "\n" + _(L("default value")) + "\t: " +
|
2018-07-31 08:42:37 +00:00
|
|
|
(boost::iends_with(m_opt_id, "_gcode") ? "\n" : "") + default_string +
|
2018-08-06 13:47:03 +00:00
|
|
|
(boost::iends_with(m_opt_id, "_gcode") ? "" : "\n") +
|
2018-08-06 14:31:51 +00:00
|
|
|
_(L("parameter name")) + "\t: " + m_opt_id;
|
2018-01-31 15:46:17 +00:00
|
|
|
|
2018-01-27 13:21:16 +00:00
|
|
|
return tooltip_text;
|
|
|
|
}
|
2017-12-18 12:58:51 +00:00
|
|
|
|
2018-04-13 10:35:04 +00:00
|
|
|
bool Field::is_matched(const std::string& string, const std::string& pattern)
|
2017-12-18 12:58:51 +00:00
|
|
|
{
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2018-04-24 08:33:11 +00:00
|
|
|
void Field::get_value_by_opt_type(wxString& str)
|
2018-01-09 12:52:01 +00:00
|
|
|
{
|
|
|
|
switch (m_opt.type){
|
|
|
|
case coInt:
|
2018-04-24 08:33:11 +00:00
|
|
|
m_value = wxAtoi(str);
|
2018-01-09 12:52:01 +00:00
|
|
|
break;
|
2018-01-11 09:33:17 +00:00
|
|
|
case coPercent:
|
2018-01-09 12:52:01 +00:00
|
|
|
case coPercents:
|
|
|
|
case coFloats:
|
|
|
|
case coFloat:{
|
2018-02-18 22:11:43 +00:00
|
|
|
if (m_opt.type == coPercent && str.Last() == '%')
|
|
|
|
str.RemoveLast();
|
2018-05-10 09:10:44 +00:00
|
|
|
else if (str.Last() == '%') {
|
2018-05-10 10:54:02 +00:00
|
|
|
wxString label = m_Label->GetLabel();
|
|
|
|
if (label.Last() == '\n') label.RemoveLast();
|
|
|
|
while (label.Last() == ' ') label.RemoveLast();
|
|
|
|
if (label.Last() == ':') label.RemoveLast();
|
|
|
|
show_error(m_parent, wxString::Format(_(L("%s doesn't support percentage")), label));
|
2018-05-10 09:10:44 +00:00
|
|
|
set_value(double_to_string(m_opt.min), true);
|
|
|
|
m_value = double(m_opt.min);
|
|
|
|
break;
|
|
|
|
}
|
2018-01-09 12:52:01 +00:00
|
|
|
double val;
|
2018-06-14 21:56:44 +00:00
|
|
|
if(!str.ToCDouble(&val))
|
|
|
|
{
|
|
|
|
show_error(m_parent, _(L("Input value contains incorrect symbol(s).\nUse, please, only digits")));
|
|
|
|
set_value(double_to_string(val), true);
|
|
|
|
}
|
2018-05-16 11:56:03 +00:00
|
|
|
if (m_opt.min > val || val > m_opt.max)
|
2018-05-10 09:10:44 +00:00
|
|
|
{
|
|
|
|
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);
|
|
|
|
}
|
2018-05-10 10:54:02 +00:00
|
|
|
m_value = val;
|
2018-01-09 12:52:01 +00:00
|
|
|
break; }
|
|
|
|
case coString:
|
|
|
|
case coStrings:
|
2018-02-20 11:30:13 +00:00
|
|
|
case coFloatOrPercent:
|
2018-04-24 08:33:11 +00:00
|
|
|
m_value = str.ToStdString();
|
2018-01-09 12:52:01 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-12-18 12:58:51 +00:00
|
|
|
void TextCtrl::BUILD() {
|
2017-12-13 13:45:10 +00:00
|
|
|
auto size = wxSize(wxDefaultSize);
|
2018-01-05 14:11:33 +00:00
|
|
|
if (m_opt.height >= 0) size.SetHeight(m_opt.height);
|
|
|
|
if (m_opt.width >= 0) size.SetWidth(m_opt.width);
|
2017-12-13 13:45:10 +00:00
|
|
|
|
2017-12-18 12:58:51 +00:00
|
|
|
wxString text_value = wxString("");
|
|
|
|
|
2018-02-19 08:15:15 +00:00
|
|
|
switch (m_opt.type) {
|
2017-12-18 12:58:51 +00:00
|
|
|
case coFloatOrPercent:
|
|
|
|
{
|
2018-02-19 08:15:15 +00:00
|
|
|
text_value = double_to_string(m_opt.default_value->getFloat());
|
|
|
|
if (static_cast<const ConfigOptionFloatOrPercent*>(m_opt.default_value)->percent)
|
|
|
|
text_value += "%";
|
2017-12-18 12:58:51 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case coPercent:
|
|
|
|
{
|
2018-01-05 14:11:33 +00:00
|
|
|
text_value = wxString::Format(_T("%i"), int(m_opt.default_value->getFloat()));
|
2017-12-18 12:58:51 +00:00
|
|
|
text_value += "%";
|
|
|
|
break;
|
2017-12-22 10:50:28 +00:00
|
|
|
}
|
|
|
|
case coPercents:
|
|
|
|
case coFloats:
|
2018-02-19 08:15:15 +00:00
|
|
|
case coFloat:
|
2017-12-22 10:50:28 +00:00
|
|
|
{
|
2018-02-19 08:15:15 +00:00
|
|
|
double val = m_opt.type == coFloats ?
|
2018-06-22 14:13:34 +00:00
|
|
|
static_cast<const ConfigOptionFloats*>(m_opt.default_value)->get_at(m_opt_idx) :
|
2018-02-19 08:15:15 +00:00
|
|
|
m_opt.type == coFloat ?
|
|
|
|
m_opt.default_value->getFloat() :
|
2018-06-22 14:13:34 +00:00
|
|
|
static_cast<const ConfigOptionPercents*>(m_opt.default_value)->get_at(m_opt_idx);
|
2018-02-19 08:15:15 +00:00
|
|
|
text_value = double_to_string(val);
|
2017-12-22 10:50:28 +00:00
|
|
|
break;
|
2017-12-18 12:58:51 +00:00
|
|
|
}
|
|
|
|
case coString:
|
2018-01-05 14:11:33 +00:00
|
|
|
text_value = static_cast<const ConfigOptionString*>(m_opt.default_value)->value;
|
2017-12-18 12:58:51 +00:00
|
|
|
break;
|
|
|
|
case coStrings:
|
|
|
|
{
|
2018-01-05 14:11:33 +00:00
|
|
|
const ConfigOptionStrings *vec = static_cast<const ConfigOptionStrings*>(m_opt.default_value);
|
2018-06-22 14:13:34 +00:00
|
|
|
if (vec == nullptr || vec->empty()) break; //for the case of empty default value
|
|
|
|
text_value = vec->get_at(m_opt_idx);
|
2017-12-18 12:58:51 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2018-02-19 08:15:15 +00:00
|
|
|
auto temp = new wxTextCtrl(m_parent, wxID_ANY, text_value, wxDefaultPosition, size, (m_opt.multiline ? wxTE_MULTILINE : 0));
|
2017-12-13 13:45:10 +00:00
|
|
|
|
2018-01-27 13:21:16 +00:00
|
|
|
temp->SetToolTip(get_tooltip_text(text_value));
|
2017-12-13 13:45:10 +00:00
|
|
|
|
2018-01-31 15:46:17 +00:00
|
|
|
temp->Bind(wxEVT_LEFT_DOWN, ([temp](wxEvent& event)
|
|
|
|
{
|
|
|
|
//! to allow the default handling
|
|
|
|
event.Skip();
|
|
|
|
//! eliminating the g-code pop up text description
|
2018-05-11 12:41:21 +00:00
|
|
|
bool flag = false;
|
|
|
|
#ifdef __WXGTK__
|
|
|
|
// I have no idea why, but on GTK flag works in other way
|
|
|
|
flag = true;
|
|
|
|
#endif // __WXGTK__
|
|
|
|
temp->GetToolTip()->Enable(flag);
|
2018-01-31 15:46:17 +00:00
|
|
|
}), temp->GetId());
|
2018-01-31 13:59:44 +00:00
|
|
|
|
2018-05-11 12:41:21 +00:00
|
|
|
#if !defined(__WXGTK__)
|
2018-01-31 15:46:17 +00:00
|
|
|
temp->Bind(wxEVT_KILL_FOCUS, ([this, temp](wxEvent& e)
|
|
|
|
{
|
2018-04-06 11:37:00 +00:00
|
|
|
e.Skip();// on_kill_focus(e);
|
2018-01-31 15:46:17 +00:00
|
|
|
temp->GetToolTip()->Enable(true);
|
|
|
|
}), temp->GetId());
|
2018-05-11 12:41:21 +00:00
|
|
|
#endif // __WXGTK__
|
2017-12-13 13:45:10 +00:00
|
|
|
|
2018-09-05 10:02:34 +00:00
|
|
|
temp->Bind(wxEVT_TEXT, ([this](wxCommandEvent& evt)
|
2018-06-11 14:23:10 +00:00
|
|
|
{
|
|
|
|
#ifdef __WXGTK__
|
2018-09-05 13:03:20 +00:00
|
|
|
if (bChangedValueEvent)
|
2018-06-11 14:23:10 +00:00
|
|
|
#endif //__WXGTK__
|
2018-09-05 13:03:20 +00:00
|
|
|
on_change_field();
|
2018-06-11 14:23:10 +00:00
|
|
|
}), temp->GetId());
|
|
|
|
|
|
|
|
#ifdef __WXGTK__
|
2018-09-05 13:03:20 +00:00
|
|
|
// to correct value updating on GTK we should:
|
|
|
|
// call on_change_field() on wxEVT_KEY_UP instead of wxEVT_TEXT
|
|
|
|
// and prevent value updating on wxEVT_KEY_DOWN
|
|
|
|
temp->Bind(wxEVT_KEY_DOWN, &TextCtrl::change_field_value, this);
|
2018-09-05 07:47:36 +00:00
|
|
|
temp->Bind(wxEVT_KEY_UP, &TextCtrl::change_field_value, this);
|
2018-06-11 14:23:10 +00:00
|
|
|
#endif //__WXGTK__
|
2018-02-12 14:29:21 +00:00
|
|
|
|
2018-05-11 07:53:35 +00:00
|
|
|
// select all text using Ctrl+A
|
|
|
|
temp->Bind(wxEVT_CHAR, ([temp](wxKeyEvent& event)
|
|
|
|
{
|
|
|
|
if (wxGetKeyState(wxKeyCode('A')) && wxGetKeyState(WXK_CONTROL))
|
|
|
|
temp->SetSelection(-1, -1); //select all
|
|
|
|
event.Skip();
|
|
|
|
}));
|
|
|
|
|
2017-12-13 13:45:10 +00:00
|
|
|
// recast as a wxWindow to fit the calling convention
|
|
|
|
window = dynamic_cast<wxWindow*>(temp);
|
2018-01-09 12:52:01 +00:00
|
|
|
}
|
2017-12-13 13:45:10 +00:00
|
|
|
|
2018-04-24 08:33:11 +00:00
|
|
|
boost::any& TextCtrl::get_value()
|
2018-01-09 12:52:01 +00:00
|
|
|
{
|
|
|
|
wxString ret_str = static_cast<wxTextCtrl*>(window)->GetValue();
|
2018-05-10 09:10:44 +00:00
|
|
|
get_value_by_opt_type(ret_str);
|
2018-01-09 12:52:01 +00:00
|
|
|
|
2018-05-10 09:10:44 +00:00
|
|
|
return m_value;
|
2018-01-09 12:52:01 +00:00
|
|
|
}
|
2017-12-13 13:45:10 +00:00
|
|
|
|
2018-01-09 12:52:01 +00:00
|
|
|
void TextCtrl::enable() { dynamic_cast<wxTextCtrl*>(window)->Enable(); dynamic_cast<wxTextCtrl*>(window)->SetEditable(true); }
|
2017-12-18 12:58:51 +00:00
|
|
|
void TextCtrl::disable() { dynamic_cast<wxTextCtrl*>(window)->Disable(); dynamic_cast<wxTextCtrl*>(window)->SetEditable(false); }
|
|
|
|
|
2018-09-05 07:47:36 +00:00
|
|
|
#ifdef __WXGTK__
|
|
|
|
void TextCtrl::change_field_value(wxEvent& event)
|
|
|
|
{
|
2018-09-05 13:03:20 +00:00
|
|
|
if (bChangedValueEvent = event.GetEventType()==wxEVT_KEY_UP)
|
|
|
|
on_change_field();
|
2018-09-05 07:47:36 +00:00
|
|
|
event.Skip();
|
|
|
|
};
|
|
|
|
#endif //__WXGTK__
|
|
|
|
|
2017-12-18 12:58:51 +00:00
|
|
|
void CheckBox::BUILD() {
|
|
|
|
auto size = wxSize(wxDefaultSize);
|
2018-01-05 14:11:33 +00:00
|
|
|
if (m_opt.height >= 0) size.SetHeight(m_opt.height);
|
|
|
|
if (m_opt.width >= 0) size.SetWidth(m_opt.width);
|
2017-12-18 12:58:51 +00:00
|
|
|
|
2018-01-05 14:11:33 +00:00
|
|
|
bool check_value = m_opt.type == coBool ?
|
|
|
|
m_opt.default_value->getBool() : m_opt.type == coBools ?
|
2018-07-31 13:09:57 +00:00
|
|
|
static_cast<const ConfigOptionBools*>(m_opt.default_value)->get_at(m_opt_idx) :
|
2017-12-22 10:50:28 +00:00
|
|
|
false;
|
|
|
|
|
2018-01-05 14:11:33 +00:00
|
|
|
auto temp = new wxCheckBox(m_parent, wxID_ANY, wxString(""), wxDefaultPosition, size);
|
2017-12-22 10:50:28 +00:00
|
|
|
temp->SetValue(check_value);
|
2018-01-05 14:11:33 +00:00
|
|
|
if (m_opt.readonly) temp->Disable();
|
2017-12-18 12:58:51 +00:00
|
|
|
|
2018-01-31 15:46:17 +00:00
|
|
|
temp->Bind(wxEVT_CHECKBOX, ([this](wxCommandEvent e) { on_change_field(); }), temp->GetId());
|
2017-12-18 12:58:51 +00:00
|
|
|
|
2018-01-27 13:21:16 +00:00
|
|
|
temp->SetToolTip(get_tooltip_text(check_value ? "true" : "false"));
|
2017-12-18 12:58:51 +00:00
|
|
|
|
|
|
|
// recast as a wxWindow to fit the calling convention
|
|
|
|
window = dynamic_cast<wxWindow*>(temp);
|
|
|
|
}
|
|
|
|
|
2018-04-24 08:33:11 +00:00
|
|
|
boost::any& CheckBox::get_value()
|
2018-03-09 16:17:51 +00:00
|
|
|
{
|
2018-04-24 08:33:11 +00:00
|
|
|
// boost::any m_value;
|
2018-03-09 16:17:51 +00:00
|
|
|
bool value = dynamic_cast<wxCheckBox*>(window)->GetValue();
|
|
|
|
if (m_opt.type == coBool)
|
2018-04-24 08:33:11 +00:00
|
|
|
m_value = static_cast<bool>(value);
|
2018-03-09 16:17:51 +00:00
|
|
|
else
|
2018-04-24 08:33:11 +00:00
|
|
|
m_value = static_cast<unsigned char>(value);
|
|
|
|
return m_value;
|
2018-03-09 16:17:51 +00:00
|
|
|
}
|
|
|
|
|
2017-12-18 12:58:51 +00:00
|
|
|
int undef_spin_val = -9999; //! Probably, It's not necessary
|
|
|
|
|
|
|
|
void SpinCtrl::BUILD() {
|
|
|
|
auto size = wxSize(wxDefaultSize);
|
2018-01-05 14:11:33 +00:00
|
|
|
if (m_opt.height >= 0) size.SetHeight(m_opt.height);
|
|
|
|
if (m_opt.width >= 0) size.SetWidth(m_opt.width);
|
2017-12-18 12:58:51 +00:00
|
|
|
|
2017-12-22 10:50:28 +00:00
|
|
|
wxString text_value = wxString("");
|
|
|
|
int default_value = 0;
|
|
|
|
|
2018-01-05 14:11:33 +00:00
|
|
|
switch (m_opt.type) {
|
2017-12-22 10:50:28 +00:00
|
|
|
case coInt:
|
2018-01-05 14:11:33 +00:00
|
|
|
default_value = m_opt.default_value->getInt();
|
2017-12-22 10:50:28 +00:00
|
|
|
text_value = wxString::Format(_T("%i"), default_value);
|
|
|
|
break;
|
|
|
|
case coInts:
|
|
|
|
{
|
2018-01-05 14:11:33 +00:00
|
|
|
const ConfigOptionInts *vec = static_cast<const ConfigOptionInts*>(m_opt.default_value);
|
2017-12-22 10:50:28 +00:00
|
|
|
if (vec == nullptr || vec->empty()) break;
|
|
|
|
for (size_t id = 0; id < vec->size(); ++id)
|
|
|
|
{
|
|
|
|
default_value = vec->get_at(id);
|
|
|
|
text_value += wxString::Format(_T("%i"), default_value);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2018-07-29 10:19:08 +00:00
|
|
|
const int min_val = m_opt.min == INT_MIN ? 0: m_opt.min;
|
2018-03-08 15:33:38 +00:00
|
|
|
const int max_val = m_opt.max < 2147483647 ? m_opt.max : 2147483647;
|
|
|
|
|
2018-01-05 14:11:33 +00:00
|
|
|
auto temp = new wxSpinCtrl(m_parent, wxID_ANY, text_value, wxDefaultPosition, size,
|
2018-03-08 15:33:38 +00:00
|
|
|
0, min_val, max_val, default_value);
|
2017-12-18 12:58:51 +00:00
|
|
|
|
2018-04-05 10:12:35 +00:00
|
|
|
// temp->Bind(wxEVT_SPINCTRL, ([this](wxCommandEvent e) { tmp_value = undef_spin_val; on_change_field(); }), temp->GetId());
|
|
|
|
// temp->Bind(wxEVT_KILL_FOCUS, ([this](wxEvent& e) { tmp_value = undef_spin_val; on_kill_focus(e); }), temp->GetId());
|
2018-01-31 15:46:17 +00:00
|
|
|
temp->Bind(wxEVT_TEXT, ([this](wxCommandEvent e)
|
2017-12-18 12:58:51 +00:00
|
|
|
{
|
|
|
|
// # On OSX / Cocoa, wxSpinCtrl::GetValue() doesn't return the new value
|
|
|
|
// # when it was changed from the text control, so the on_change callback
|
|
|
|
// # gets the old one, and on_kill_focus resets the control to the old value.
|
|
|
|
// # As a workaround, we get the new value from $event->GetString and store
|
2018-03-15 17:06:26 +00:00
|
|
|
// # here temporarily so that we can return it from $self->get_value
|
2018-01-21 21:23:59 +00:00
|
|
|
std::string value = e.GetString().utf8_str().data();
|
2018-01-21 21:04:57 +00:00
|
|
|
if (is_matched(value, "^\\d+$"))
|
2017-12-18 12:58:51 +00:00
|
|
|
tmp_value = std::stoi(value);
|
2018-01-31 15:46:17 +00:00
|
|
|
on_change_field();
|
2017-12-18 12:58:51 +00:00
|
|
|
// # We don't reset tmp_value here because _on_change might put callbacks
|
|
|
|
// # in the CallAfter queue, and we want the tmp value to be available from
|
|
|
|
// # them as well.
|
|
|
|
}), temp->GetId());
|
2018-01-27 13:21:16 +00:00
|
|
|
|
|
|
|
temp->SetToolTip(get_tooltip_text(text_value));
|
2017-12-18 12:58:51 +00:00
|
|
|
|
|
|
|
// recast as a wxWindow to fit the calling convention
|
|
|
|
window = dynamic_cast<wxWindow*>(temp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Choice::BUILD() {
|
|
|
|
auto size = wxSize(wxDefaultSize);
|
2018-01-05 14:11:33 +00:00
|
|
|
if (m_opt.height >= 0) size.SetHeight(m_opt.height);
|
|
|
|
if (m_opt.width >= 0) size.SetWidth(m_opt.width);
|
2017-12-18 12:58:51 +00:00
|
|
|
|
2018-01-11 09:33:17 +00:00
|
|
|
wxComboBox* temp;
|
|
|
|
if (!m_opt.gui_type.empty() && m_opt.gui_type.compare("select_open") != 0)
|
|
|
|
temp = new wxComboBox(m_parent, wxID_ANY, wxString(""), wxDefaultPosition, size);
|
|
|
|
else
|
|
|
|
temp = new wxComboBox(m_parent, wxID_ANY, wxString(""), wxDefaultPosition, size, 0, NULL, wxCB_READONLY);
|
2017-12-22 10:50:28 +00:00
|
|
|
|
|
|
|
// recast as a wxWindow to fit the calling convention
|
2017-12-18 12:58:51 +00:00
|
|
|
window = dynamic_cast<wxWindow*>(temp);
|
|
|
|
|
2018-01-05 14:11:33 +00:00
|
|
|
if (m_opt.enum_labels.empty() && m_opt.enum_values.empty()){
|
2017-12-22 10:50:28 +00:00
|
|
|
}
|
|
|
|
else{
|
2018-03-13 15:14:36 +00:00
|
|
|
for (auto el : m_opt.enum_labels.empty() ? m_opt.enum_values : m_opt.enum_labels){
|
2018-06-22 08:59:54 +00:00
|
|
|
const wxString& str = _(el);//m_opt_id == "support" ? _(el) : el;
|
2018-03-13 15:14:36 +00:00
|
|
|
temp->Append(str);
|
|
|
|
}
|
2017-12-18 12:58:51 +00:00
|
|
|
set_selection();
|
|
|
|
}
|
2018-01-31 15:46:17 +00:00
|
|
|
temp->Bind(wxEVT_TEXT, ([this](wxCommandEvent e) { on_change_field(); }), temp->GetId());
|
|
|
|
temp->Bind(wxEVT_COMBOBOX, ([this](wxCommandEvent e) { on_change_field(); }), temp->GetId());
|
2017-12-18 12:58:51 +00:00
|
|
|
|
2018-01-27 13:21:16 +00:00
|
|
|
temp->SetToolTip(get_tooltip_text(temp->GetValue()));
|
2017-12-18 12:58:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Choice::set_selection()
|
|
|
|
{
|
|
|
|
wxString text_value = wxString("");
|
2018-01-05 14:11:33 +00:00
|
|
|
switch (m_opt.type){
|
2017-12-18 12:58:51 +00:00
|
|
|
case coFloat:
|
|
|
|
case coPercent: {
|
2018-01-05 14:11:33 +00:00
|
|
|
double val = m_opt.default_value->getFloat();
|
2017-12-18 12:58:51 +00:00
|
|
|
text_value = val - int(val) == 0 ? wxString::Format(_T("%i"), int(val)) : wxNumberFormatter::ToString(val, 1);
|
2018-02-01 08:29:07 +00:00
|
|
|
size_t idx = 0;
|
2018-01-05 14:11:33 +00:00
|
|
|
for (auto el : m_opt.enum_values)
|
2017-12-18 12:58:51 +00:00
|
|
|
{
|
|
|
|
if (el.compare(text_value) == 0)
|
|
|
|
break;
|
|
|
|
++idx;
|
|
|
|
}
|
2018-02-18 22:11:43 +00:00
|
|
|
// if (m_opt.type == coPercent) text_value += "%";
|
2018-01-05 14:11:33 +00:00
|
|
|
idx == m_opt.enum_values.size() ?
|
2017-12-18 12:58:51 +00:00
|
|
|
dynamic_cast<wxComboBox*>(window)->SetValue(text_value) :
|
|
|
|
dynamic_cast<wxComboBox*>(window)->SetSelection(idx);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case coEnum:{
|
2018-01-05 14:11:33 +00:00
|
|
|
int id_value = static_cast<const ConfigOptionEnum<SeamPosition>*>(m_opt.default_value)->value; //!!
|
2017-12-18 12:58:51 +00:00
|
|
|
dynamic_cast<wxComboBox*>(window)->SetSelection(id_value);
|
|
|
|
break;
|
|
|
|
}
|
2017-12-22 10:50:28 +00:00
|
|
|
case coInt:{
|
2018-01-05 14:11:33 +00:00
|
|
|
int val = m_opt.default_value->getInt(); //!!
|
2017-12-22 10:50:28 +00:00
|
|
|
text_value = wxString::Format(_T("%i"), int(val));
|
2018-02-01 08:29:07 +00:00
|
|
|
size_t idx = 0;
|
2018-01-05 14:11:33 +00:00
|
|
|
for (auto el : m_opt.enum_values)
|
2017-12-22 10:50:28 +00:00
|
|
|
{
|
|
|
|
if (el.compare(text_value) == 0)
|
|
|
|
break;
|
|
|
|
++idx;
|
|
|
|
}
|
2018-01-05 14:11:33 +00:00
|
|
|
idx == m_opt.enum_values.size() ?
|
2017-12-22 10:50:28 +00:00
|
|
|
dynamic_cast<wxComboBox*>(window)->SetValue(text_value) :
|
|
|
|
dynamic_cast<wxComboBox*>(window)->SetSelection(idx);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case coStrings:{
|
2018-06-22 14:13:34 +00:00
|
|
|
text_value = static_cast<const ConfigOptionStrings*>(m_opt.default_value)->get_at(m_opt_idx);
|
2017-12-22 10:50:28 +00:00
|
|
|
|
2018-02-01 08:29:07 +00:00
|
|
|
size_t idx = 0;
|
2018-01-05 14:11:33 +00:00
|
|
|
for (auto el : m_opt.enum_values)
|
2017-12-22 10:50:28 +00:00
|
|
|
{
|
|
|
|
if (el.compare(text_value) == 0)
|
|
|
|
break;
|
|
|
|
++idx;
|
|
|
|
}
|
2018-01-05 14:11:33 +00:00
|
|
|
idx == m_opt.enum_values.size() ?
|
2017-12-22 10:50:28 +00:00
|
|
|
dynamic_cast<wxComboBox*>(window)->SetValue(text_value) :
|
|
|
|
dynamic_cast<wxComboBox*>(window)->SetSelection(idx);
|
|
|
|
break;
|
|
|
|
}
|
2017-12-18 12:58:51 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-04-13 10:35:04 +00:00
|
|
|
void Choice::set_value(const std::string& value, bool change_event) //! Redundant?
|
2017-12-18 12:58:51 +00:00
|
|
|
{
|
2018-03-15 17:06:26 +00:00
|
|
|
m_disable_change_event = !change_event;
|
2017-12-18 12:58:51 +00:00
|
|
|
|
2018-02-01 08:29:07 +00:00
|
|
|
size_t idx=0;
|
2018-01-05 14:11:33 +00:00
|
|
|
for (auto el : m_opt.enum_values)
|
2017-12-18 12:58:51 +00:00
|
|
|
{
|
|
|
|
if (el.compare(value) == 0)
|
|
|
|
break;
|
|
|
|
++idx;
|
|
|
|
}
|
|
|
|
|
2018-01-05 14:11:33 +00:00
|
|
|
idx == m_opt.enum_values.size() ?
|
2017-12-18 12:58:51 +00:00
|
|
|
dynamic_cast<wxComboBox*>(window)->SetValue(value) :
|
|
|
|
dynamic_cast<wxComboBox*>(window)->SetSelection(idx);
|
|
|
|
|
2018-01-05 14:11:33 +00:00
|
|
|
m_disable_change_event = false;
|
2017-12-18 12:58:51 +00:00
|
|
|
}
|
|
|
|
|
2018-04-13 10:35:04 +00:00
|
|
|
void Choice::set_value(const boost::any& value, bool change_event)
|
2018-01-09 08:41:07 +00:00
|
|
|
{
|
2018-03-15 17:06:26 +00:00
|
|
|
m_disable_change_event = !change_event;
|
2018-01-27 16:39:00 +00:00
|
|
|
|
2018-01-09 08:41:07 +00:00
|
|
|
switch (m_opt.type){
|
|
|
|
case coInt:
|
|
|
|
case coFloat:
|
|
|
|
case coPercent:
|
2018-03-23 11:52:37 +00:00
|
|
|
case coString:
|
2018-01-09 08:41:07 +00:00
|
|
|
case coStrings:{
|
2018-01-16 15:28:01 +00:00
|
|
|
wxString text_value;
|
|
|
|
if (m_opt.type == coInt)
|
|
|
|
text_value = wxString::Format(_T("%i"), int(boost::any_cast<int>(value)));
|
|
|
|
else
|
|
|
|
text_value = boost::any_cast<wxString>(value);
|
2018-01-09 08:41:07 +00:00
|
|
|
auto idx = 0;
|
|
|
|
for (auto el : m_opt.enum_values)
|
|
|
|
{
|
|
|
|
if (el.compare(text_value) == 0)
|
|
|
|
break;
|
|
|
|
++idx;
|
|
|
|
}
|
|
|
|
idx == m_opt.enum_values.size() ?
|
|
|
|
dynamic_cast<wxComboBox*>(window)->SetValue(text_value) :
|
|
|
|
dynamic_cast<wxComboBox*>(window)->SetSelection(idx);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case coEnum:{
|
2018-04-24 08:33:11 +00:00
|
|
|
int val = boost::any_cast<int>(value);
|
|
|
|
if (m_opt_id.compare("external_fill_pattern") == 0)
|
|
|
|
{
|
|
|
|
if (!m_opt.enum_values.empty()){
|
|
|
|
std::string key;
|
|
|
|
t_config_enum_values map_names = ConfigOptionEnum<InfillPattern>::get_enum_values();
|
|
|
|
for (auto it : map_names) {
|
|
|
|
if (val == it.second) {
|
|
|
|
key = it.first;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
size_t idx = 0;
|
|
|
|
for (auto el : m_opt.enum_values)
|
|
|
|
{
|
|
|
|
if (el.compare(key) == 0)
|
|
|
|
break;
|
|
|
|
++idx;
|
|
|
|
}
|
|
|
|
|
|
|
|
val = idx == m_opt.enum_values.size() ? 0 : idx;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
val = 0;
|
|
|
|
}
|
|
|
|
dynamic_cast<wxComboBox*>(window)->SetSelection(val);
|
2018-01-09 08:41:07 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2018-01-27 16:39:00 +00:00
|
|
|
|
|
|
|
m_disable_change_event = false;
|
2018-01-09 08:41:07 +00:00
|
|
|
}
|
|
|
|
|
2017-12-18 12:58:51 +00:00
|
|
|
//! it's needed for _update_serial_ports()
|
2018-04-13 10:35:04 +00:00
|
|
|
void Choice::set_values(const std::vector<std::string>& values)
|
2017-12-18 12:58:51 +00:00
|
|
|
{
|
2018-01-05 14:11:33 +00:00
|
|
|
if (values.empty())
|
|
|
|
return;
|
|
|
|
m_disable_change_event = true;
|
2017-12-18 12:58:51 +00:00
|
|
|
|
2018-03-15 17:06:26 +00:00
|
|
|
// # it looks that Clear() also clears the text field in recent wxWidgets versions,
|
2017-12-18 12:58:51 +00:00
|
|
|
// # but we want to preserve it
|
|
|
|
auto ww = dynamic_cast<wxComboBox*>(window);
|
|
|
|
auto value = ww->GetValue();
|
|
|
|
ww->Clear();
|
2018-03-23 11:52:37 +00:00
|
|
|
ww->Append("");
|
2017-12-18 12:58:51 +00:00
|
|
|
for (auto el : values)
|
|
|
|
ww->Append(wxString(el));
|
|
|
|
ww->SetValue(value);
|
|
|
|
|
2018-01-05 14:11:33 +00:00
|
|
|
m_disable_change_event = false;
|
2017-12-18 12:58:51 +00:00
|
|
|
}
|
|
|
|
|
2018-04-24 08:33:11 +00:00
|
|
|
boost::any& Choice::get_value()
|
2018-01-09 12:52:01 +00:00
|
|
|
{
|
2018-04-24 08:33:11 +00:00
|
|
|
// boost::any m_value;
|
2018-01-11 09:33:17 +00:00
|
|
|
wxString ret_str = static_cast<wxComboBox*>(window)->GetValue();
|
2018-01-09 12:52:01 +00:00
|
|
|
|
2018-07-04 12:52:36 +00:00
|
|
|
// options from right panel
|
|
|
|
std::vector <std::string> right_panel_options{ "support", "scale_unit" };
|
|
|
|
for (auto rp_option: right_panel_options)
|
|
|
|
if (m_opt_id == rp_option)
|
|
|
|
return m_value = boost::any(ret_str);
|
2018-03-13 15:14:36 +00:00
|
|
|
|
2018-01-11 09:33:17 +00:00
|
|
|
if (m_opt.type != coEnum)
|
2018-04-24 08:33:11 +00:00
|
|
|
/*m_value = */get_value_by_opt_type(ret_str);
|
2018-01-11 09:33:17 +00:00
|
|
|
else
|
|
|
|
{
|
|
|
|
int ret_enum = static_cast<wxComboBox*>(window)->GetSelection();
|
2018-01-25 12:46:04 +00:00
|
|
|
if (m_opt_id.compare("external_fill_pattern") == 0)
|
|
|
|
{
|
|
|
|
if (!m_opt.enum_values.empty()){
|
|
|
|
std::string key = m_opt.enum_values[ret_enum];
|
|
|
|
t_config_enum_values map_names = ConfigOptionEnum<InfillPattern>::get_enum_values();
|
|
|
|
int value = map_names.at(key);
|
|
|
|
|
2018-04-24 08:33:11 +00:00
|
|
|
m_value = static_cast<InfillPattern>(value);
|
2018-01-25 12:46:04 +00:00
|
|
|
}
|
|
|
|
else
|
2018-04-24 08:33:11 +00:00
|
|
|
m_value = static_cast<InfillPattern>(0);
|
2018-01-25 12:46:04 +00:00
|
|
|
}
|
|
|
|
if (m_opt_id.compare("fill_pattern") == 0)
|
2018-04-24 08:33:11 +00:00
|
|
|
m_value = static_cast<InfillPattern>(ret_enum);
|
2018-01-11 09:33:17 +00:00
|
|
|
else if (m_opt_id.compare("gcode_flavor") == 0)
|
2018-04-24 08:33:11 +00:00
|
|
|
m_value = static_cast<GCodeFlavor>(ret_enum);
|
2018-01-11 09:33:17 +00:00
|
|
|
else if (m_opt_id.compare("support_material_pattern") == 0)
|
2018-04-24 08:33:11 +00:00
|
|
|
m_value = static_cast<SupportMaterialPattern>(ret_enum);
|
2018-01-11 09:33:17 +00:00
|
|
|
else if (m_opt_id.compare("seam_position") == 0)
|
2018-04-24 08:33:11 +00:00
|
|
|
m_value = static_cast<SeamPosition>(ret_enum);
|
2018-07-08 12:32:48 +00:00
|
|
|
else if (m_opt_id.compare("host_type") == 0)
|
|
|
|
m_value = static_cast<PrintHostType>(ret_enum);
|
2018-01-11 09:33:17 +00:00
|
|
|
}
|
2018-01-09 12:52:01 +00:00
|
|
|
|
2018-04-24 08:33:11 +00:00
|
|
|
return m_value;
|
2018-01-09 12:52:01 +00:00
|
|
|
}
|
|
|
|
|
2017-12-22 10:50:28 +00:00
|
|
|
void ColourPicker::BUILD()
|
|
|
|
{
|
|
|
|
auto size = wxSize(wxDefaultSize);
|
2018-01-05 14:11:33 +00:00
|
|
|
if (m_opt.height >= 0) size.SetHeight(m_opt.height);
|
|
|
|
if (m_opt.width >= 0) size.SetWidth(m_opt.width);
|
2017-12-22 10:50:28 +00:00
|
|
|
|
2018-10-18 09:32:21 +00:00
|
|
|
// Validate the color
|
|
|
|
wxString clr_str(static_cast<const ConfigOptionStrings*>(m_opt.default_value)->get_at(m_opt_idx));
|
|
|
|
wxColour clr(clr_str);
|
|
|
|
if (! clr.IsOk()) {
|
|
|
|
clr = wxTransparentColour;
|
|
|
|
}
|
|
|
|
|
2018-01-05 14:11:33 +00:00
|
|
|
auto temp = new wxColourPickerCtrl(m_parent, wxID_ANY, clr, wxDefaultPosition, size);
|
2018-10-04 09:12:55 +00:00
|
|
|
|
2017-12-22 10:50:28 +00:00
|
|
|
// // recast as a wxWindow to fit the calling convention
|
|
|
|
window = dynamic_cast<wxWindow*>(temp);
|
|
|
|
|
2018-01-31 15:46:17 +00:00
|
|
|
temp->Bind(wxEVT_COLOURPICKER_CHANGED, ([this](wxCommandEvent e) { on_change_field(); }), temp->GetId());
|
2017-12-22 10:50:28 +00:00
|
|
|
|
2018-10-18 09:32:21 +00:00
|
|
|
temp->SetToolTip(get_tooltip_text(clr_str));
|
2017-12-22 10:50:28 +00:00
|
|
|
}
|
|
|
|
|
2018-04-24 08:33:11 +00:00
|
|
|
boost::any& ColourPicker::get_value(){
|
|
|
|
// boost::any m_value;
|
2018-02-15 16:30:33 +00:00
|
|
|
|
|
|
|
auto colour = static_cast<wxColourPickerCtrl*>(window)->GetColour();
|
|
|
|
auto clr_str = wxString::Format(wxT("#%02X%02X%02X"), colour.Red(), colour.Green(), colour.Blue());
|
2018-04-24 08:33:11 +00:00
|
|
|
m_value = clr_str.ToStdString();
|
2018-02-15 16:30:33 +00:00
|
|
|
|
2018-04-24 08:33:11 +00:00
|
|
|
return m_value;
|
2018-02-15 16:30:33 +00:00
|
|
|
}
|
|
|
|
|
2018-01-25 12:46:04 +00:00
|
|
|
void PointCtrl::BUILD()
|
2017-12-22 10:50:28 +00:00
|
|
|
{
|
|
|
|
auto size = wxSize(wxDefaultSize);
|
2018-01-05 14:11:33 +00:00
|
|
|
if (m_opt.height >= 0) size.SetHeight(m_opt.height);
|
|
|
|
if (m_opt.width >= 0) size.SetWidth(m_opt.width);
|
2017-12-22 10:50:28 +00:00
|
|
|
|
|
|
|
auto temp = new wxBoxSizer(wxHORIZONTAL);
|
|
|
|
// $self->wxSizer($sizer);
|
|
|
|
//
|
|
|
|
wxSize field_size(40, -1);
|
|
|
|
|
2018-07-31 13:09:57 +00:00
|
|
|
auto default_pt = static_cast<const ConfigOptionPoints*>(m_opt.default_value)->values.at(0);
|
2018-08-17 13:53:43 +00:00
|
|
|
double val = default_pt(0);
|
2018-02-12 14:29:21 +00:00
|
|
|
wxString X = val - int(val) == 0 ? wxString::Format(_T("%i"), int(val)) : wxNumberFormatter::ToString(val, 2, wxNumberFormatter::Style_None);
|
2018-08-17 13:53:43 +00:00
|
|
|
val = default_pt(1);
|
2018-02-12 14:29:21 +00:00
|
|
|
wxString Y = val - int(val) == 0 ? wxString::Format(_T("%i"), int(val)) : wxNumberFormatter::ToString(val, 2, wxNumberFormatter::Style_None);
|
2017-12-22 10:50:28 +00:00
|
|
|
|
2018-01-05 14:11:33 +00:00
|
|
|
x_textctrl = new wxTextCtrl(m_parent, wxID_ANY, X, wxDefaultPosition, field_size);
|
|
|
|
y_textctrl = new wxTextCtrl(m_parent, wxID_ANY, Y, wxDefaultPosition, field_size);
|
2017-12-22 10:50:28 +00:00
|
|
|
|
2018-02-15 16:30:33 +00:00
|
|
|
temp->Add(new wxStaticText(m_parent, wxID_ANY, "x : "), 0, wxALIGN_CENTER_VERTICAL, 0);
|
2017-12-22 10:50:28 +00:00
|
|
|
temp->Add(x_textctrl);
|
2018-02-15 16:30:33 +00:00
|
|
|
temp->Add(new wxStaticText(m_parent, wxID_ANY, " y : "), 0, wxALIGN_CENTER_VERTICAL, 0);
|
2017-12-22 10:50:28 +00:00
|
|
|
temp->Add(y_textctrl);
|
|
|
|
|
2018-01-31 15:46:17 +00:00
|
|
|
x_textctrl->Bind(wxEVT_TEXT, ([this](wxCommandEvent e) { on_change_field(); }), x_textctrl->GetId());
|
|
|
|
y_textctrl->Bind(wxEVT_TEXT, ([this](wxCommandEvent e) { on_change_field(); }), y_textctrl->GetId());
|
2017-12-22 10:50:28 +00:00
|
|
|
|
|
|
|
// // recast as a wxWindow to fit the calling convention
|
|
|
|
sizer = dynamic_cast<wxSizer*>(temp);
|
|
|
|
|
2018-01-27 13:21:16 +00:00
|
|
|
x_textctrl->SetToolTip(get_tooltip_text(X+", "+Y));
|
|
|
|
y_textctrl->SetToolTip(get_tooltip_text(X+", "+Y));
|
2017-12-22 10:50:28 +00:00
|
|
|
}
|
|
|
|
|
2018-08-21 19:05:24 +00:00
|
|
|
void PointCtrl::set_value(const Vec2d& value, bool change_event)
|
2017-12-22 10:50:28 +00:00
|
|
|
{
|
2018-03-15 17:06:26 +00:00
|
|
|
m_disable_change_event = !change_event;
|
2017-12-22 10:50:28 +00:00
|
|
|
|
2018-08-17 13:53:43 +00:00
|
|
|
double val = value(0);
|
2018-02-12 14:29:21 +00:00
|
|
|
x_textctrl->SetValue(val - int(val) == 0 ? wxString::Format(_T("%i"), int(val)) : wxNumberFormatter::ToString(val, 2, wxNumberFormatter::Style_None));
|
2018-08-17 13:53:43 +00:00
|
|
|
val = value(1);
|
2018-02-12 14:29:21 +00:00
|
|
|
y_textctrl->SetValue(val - int(val) == 0 ? wxString::Format(_T("%i"), int(val)) : wxNumberFormatter::ToString(val, 2, wxNumberFormatter::Style_None));
|
2017-12-22 10:50:28 +00:00
|
|
|
|
2018-01-05 14:11:33 +00:00
|
|
|
m_disable_change_event = false;
|
2017-12-22 10:50:28 +00:00
|
|
|
}
|
|
|
|
|
2018-04-13 10:35:04 +00:00
|
|
|
void PointCtrl::set_value(const boost::any& value, bool change_event)
|
2018-01-25 12:46:04 +00:00
|
|
|
{
|
2018-08-21 19:05:24 +00:00
|
|
|
Vec2d pt(Vec2d::Zero());
|
|
|
|
const Vec2d *ptf = boost::any_cast<Vec2d>(&value);
|
2018-02-18 22:11:43 +00:00
|
|
|
if (!ptf)
|
2018-01-25 12:46:04 +00:00
|
|
|
{
|
2018-02-18 22:11:43 +00:00
|
|
|
ConfigOptionPoints* pts = boost::any_cast<ConfigOptionPoints*>(value);
|
|
|
|
pt = pts->values.at(0);
|
2018-01-25 12:46:04 +00:00
|
|
|
}
|
2018-02-18 22:11:43 +00:00
|
|
|
else
|
|
|
|
pt = *ptf;
|
2018-03-15 17:06:26 +00:00
|
|
|
set_value(pt, change_event);
|
2018-01-25 12:46:04 +00:00
|
|
|
}
|
|
|
|
|
2018-04-24 08:33:11 +00:00
|
|
|
boost::any& PointCtrl::get_value()
|
2017-12-22 10:50:28 +00:00
|
|
|
{
|
2018-08-21 18:34:45 +00:00
|
|
|
double x, y;
|
|
|
|
x_textctrl->GetValue().ToDouble(&x);
|
|
|
|
y_textctrl->GetValue().ToDouble(&y);
|
2018-08-21 19:05:24 +00:00
|
|
|
return m_value = Vec2d(x, y);
|
2017-12-22 10:50:28 +00:00
|
|
|
}
|
|
|
|
|
2018-06-21 14:15:56 +00:00
|
|
|
void StaticText::BUILD()
|
|
|
|
{
|
|
|
|
auto size = wxSize(wxDefaultSize);
|
|
|
|
if (m_opt.height >= 0) size.SetHeight(m_opt.height);
|
|
|
|
if (m_opt.width >= 0) size.SetWidth(m_opt.width);
|
|
|
|
|
2018-07-31 13:09:57 +00:00
|
|
|
wxString legend(static_cast<const ConfigOptionString*>(m_opt.default_value)->value);
|
2018-06-21 14:15:56 +00:00
|
|
|
auto temp = new wxStaticText(m_parent, wxID_ANY, legend, wxDefaultPosition, size);
|
2018-10-01 13:09:31 +00:00
|
|
|
temp->SetFont(wxGetApp().bold_font());
|
2018-06-21 14:15:56 +00:00
|
|
|
|
|
|
|
// // recast as a wxWindow to fit the calling convention
|
|
|
|
window = dynamic_cast<wxWindow*>(temp);
|
|
|
|
|
|
|
|
temp->SetToolTip(get_tooltip_text(legend));
|
|
|
|
}
|
|
|
|
|
2018-06-12 21:42:01 +00:00
|
|
|
void SliderCtrl::BUILD()
|
|
|
|
{
|
|
|
|
auto size = wxSize(wxDefaultSize);
|
|
|
|
if (m_opt.height >= 0) size.SetHeight(m_opt.height);
|
|
|
|
if (m_opt.width >= 0) size.SetWidth(m_opt.width);
|
|
|
|
|
|
|
|
auto temp = new wxBoxSizer(wxHORIZONTAL);
|
|
|
|
|
2018-08-24 14:20:19 +00:00
|
|
|
auto def_val = static_cast<const ConfigOptionInt*>(m_opt.default_value)->value;
|
2018-06-12 21:42:01 +00:00
|
|
|
auto min = m_opt.min == INT_MIN ? 0 : m_opt.min;
|
|
|
|
auto max = m_opt.max == INT_MAX ? 100 : m_opt.max;
|
|
|
|
|
2018-06-15 20:42:51 +00:00
|
|
|
m_slider = new wxSlider(m_parent, wxID_ANY, def_val * m_scale,
|
2018-06-12 21:42:01 +00:00
|
|
|
min * m_scale, max * m_scale,
|
|
|
|
wxDefaultPosition, size);
|
|
|
|
wxSize field_size(40, -1);
|
|
|
|
|
|
|
|
m_textctrl = new wxTextCtrl(m_parent, wxID_ANY, wxString::Format("%d", m_slider->GetValue()/m_scale),
|
|
|
|
wxDefaultPosition, field_size);
|
|
|
|
|
|
|
|
temp->Add(m_slider, 1, wxEXPAND | wxALIGN_CENTER_VERTICAL, 0);
|
|
|
|
temp->Add(m_textctrl, 0, wxALIGN_CENTER_VERTICAL, 0);
|
|
|
|
|
|
|
|
m_slider->Bind(wxEVT_SLIDER, ([this](wxCommandEvent e) {
|
|
|
|
if (!m_disable_change_event){
|
|
|
|
int val = boost::any_cast<int>(get_value());
|
|
|
|
m_textctrl->SetLabel(wxString::Format("%d", val));
|
|
|
|
on_change_field();
|
|
|
|
}
|
|
|
|
}), m_slider->GetId());
|
|
|
|
|
|
|
|
m_textctrl->Bind(wxEVT_TEXT, ([this](wxCommandEvent e) {
|
|
|
|
std::string value = e.GetString().utf8_str().data();
|
|
|
|
if (is_matched(value, "^-?\\d+(\\.\\d*)?$")){
|
|
|
|
m_disable_change_event = true;
|
|
|
|
m_slider->SetValue(stoi(value)*m_scale);
|
|
|
|
m_disable_change_event = false;
|
|
|
|
on_change_field();
|
|
|
|
}
|
|
|
|
}), m_textctrl->GetId());
|
|
|
|
|
|
|
|
m_sizer = dynamic_cast<wxSizer*>(temp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void SliderCtrl::set_value(const boost::any& value, bool change_event)
|
|
|
|
{
|
|
|
|
m_disable_change_event = !change_event;
|
|
|
|
|
|
|
|
m_slider->SetValue(boost::any_cast<int>(value)*m_scale);
|
|
|
|
int val = boost::any_cast<int>(get_value());
|
|
|
|
m_textctrl->SetLabel(wxString::Format("%d", val));
|
|
|
|
|
|
|
|
m_disable_change_event = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
boost::any& SliderCtrl::get_value()
|
|
|
|
{
|
|
|
|
// int ret_val;
|
|
|
|
// x_textctrl->GetValue().ToDouble(&val);
|
|
|
|
return m_value = int(m_slider->GetValue()/m_scale);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-12-18 12:58:51 +00:00
|
|
|
} // GUI
|
|
|
|
} // Slic3r
|
|
|
|
|
2017-12-13 13:45:10 +00:00
|
|
|
|