Start filling the Print's Tab, using @lordofhyphens's Optionsgroup

xs/src/slic3r/GUI/Field.hpp

@@ -0,0 +1,137 @@
+#ifndef SLIC3R_GUI_FIELD_HPP
+#define SLIC3R_GUI_FIELD_HPP
+
+#include <wx/wxprec.h>
+#ifndef WX_PRECOMP
+    #include <wx/wx.h>
+#endif
+
+#include <memory>
+#include <functional>
+#include <boost/any.hpp>
+
+#include "../../libslic3r/libslic3r.h"
+#include "../../libslic3r/Config.hpp"
+
+//#include "slic3r_gui.hpp"
+#include "GUI.hpp"
+
+#if SLIC3R_CPPVER==11
+    // C++14 has make_unique, C++11 doesn't. This is really useful so we're going to steal it.
+    template<class T, class...Args>
+    std::unique_ptr<T> make_unique(Args&&... args)
+    {
+        std::unique_ptr<T> ret (new T(std::forward<Args>(args)...));
+        return ret;
+    }
+#endif
+
+namespace Slic3r { namespace GUI {
+
+class Field;
+using t_field = std::unique_ptr<Field>;
+
+class Field { 
+    protected:
+    // factory function to defer and enforce creation of derived type. 
+    virtual void PostInitialize() { BUILD(); }
+    
+    /// Finish constructing the Field's wxWidget-related properties, including setting its own sizer, etc.
+    virtual void BUILD() = 0;
+
+    /// Call the attached on_kill_focus method. 
+    void _on_kill_focus(wxFocusEvent& event);
+    /// Call the attached on_change method. 
+    void _on_change(wxCommandEvent& event);
+
+    public:
+    
+    /// parent wx item, opportunity to refactor (probably not necessary - data duplication)
+    wxWindow* parent {nullptr};
+
+    /// Function object to store callback passed in from owning object.
+//!    t_kill_focus on_kill_focus {nullptr};
+
+    /// Function object to store callback passed in from owning object.
+//!    t_change on_change {nullptr};
+
+    bool disable_change_event {false};
+
+    /// Copy of ConfigOption for deduction purposes
+    const ConfigOptionDef opt {ConfigOptionDef()}; 
+	const t_config_option_key opt_id;//! {""};
+
+    /// Sets a value for this control.
+    /// subclasses should overload with a specific version
+    /// Postcondition: Method does not fire the on_change event.
+    virtual void set_value(boost::any value) = 0;
+    
+    /// Gets a boost::any representing this control.
+    /// subclasses should overload with a specific version
+    virtual boost::any get_value() = 0;
+
+    virtual void enable() = 0;
+    virtual void disable() = 0;
+
+    /// Fires the enable or disable function, based on the input.
+    inline void toggle(bool en) { en ? enable() : disable(); }
+
+    virtual void set_tooltip(const wxString& tip) = 0;
+
+
+    Field(const ConfigOptionDef& opt, const t_config_option_key& id) : opt(opt), opt_id(id) {};
+    Field(wxWindow* parent, const ConfigOptionDef& opt, const t_config_option_key& id) : parent(parent), opt(opt), opt_id(id) {};
+
+    /// If you don't know what you are getting back, check both methods for nullptr. 
+    virtual wxSizer*  getSizer()  { return nullptr; }
+    virtual wxWindow* getWindow() { return nullptr; }
+
+
+    /// Factory method for generating new derived classes.
+    template<class T>
+    static t_field Create(wxWindow* parent, const ConfigOptionDef& opt, const t_config_option_key& id)  // interface for creating shared objects
+    {
+        auto p = std::make_unique<T>(parent, opt, id);
+        p->PostInitialize();
+        return p;
+    }
+
+};
+
+/// Convenience function, accepts a const reference to t_field and checks to see whether 
+/// or not both wx pointers are null.
+inline bool is_bad_field(const t_field& obj) { return obj->getSizer() == nullptr && obj->getWindow() == nullptr; }
+
+/// Covenience function to determine whether this field is a valid window field.
+inline bool is_window_field(const t_field& obj) { return !is_bad_field(obj) && obj->getWindow() != nullptr; }
+
+/// Covenience function to determine whether this field is a valid sizer field.
+inline bool is_sizer_field(const t_field& obj) { return !is_bad_field(obj) && obj->getSizer() != nullptr; }
+
+class TextCtrl : public Field {
+    using Field::Field;
+public:
+    void BUILD();
+    wxWindow* window {nullptr};
+
+
+    virtual void set_value(std::string value) { 
+        dynamic_cast<wxTextCtrl*>(window)->SetValue(wxString(value));
+    }
+    virtual void set_value(boost::any value) { 
+        dynamic_cast<wxTextCtrl*>(window)->SetValue(boost::any_cast<wxString>(value));
+    }
+
+    boost::any get_value() { return boost::any(dynamic_cast<wxTextCtrl*>(window)->GetValue()); }
+
+    virtual void enable();
+    virtual void disable();
+    virtual wxWindow* getWindow() { return window; } 
+    void set_tooltip(const wxString& tip);
+
+};
+
+
+#endif 
+}}
+