diff --git a/xs/src/slic3r/GUI/ConfigExceptions.hpp b/xs/src/slic3r/GUI/ConfigExceptions.hpp
new file mode 100644
index 000000000..9038d3445
--- /dev/null
+++ b/xs/src/slic3r/GUI/ConfigExceptions.hpp
@@ -0,0 +1,15 @@
+#include <exception> 
+namespace Slic3r {
+
+class ConfigError : public std::runtime_error { 
+using std::runtime_error::runtime_error;
+};
+
+namespace GUI {
+
+class ConfigGUITypeError : public ConfigError { 
+using ConfigError::ConfigError;
+};
+}
+
+}
diff --git a/xs/src/slic3r/GUI/Field.cpp b/xs/src/slic3r/GUI/Field.cpp
new file mode 100644
index 000000000..af89b01b1
--- /dev/null
+++ b/xs/src/slic3r/GUI/Field.cpp
@@ -0,0 +1,42 @@
+#include "GUI.hpp"//"slic3r_gui.hpp"
+#include "Field.hpp"
+
+namespace Slic3r { namespace GUI {
+
+    void Field::_on_kill_focus(wxFocusEvent& event) {
+        // 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."
+        event.Skip(1);
+
+        // call the registered function if it is available
+//!        if (on_kill_focus) 
+//!            on_kill_focus(opt_id);
+    }
+    void Field::_on_change(wxCommandEvent& event) {
+        std::cerr << "calling Field::_on_change \n";
+//!        if (on_change != nullptr  && !disable_change_event)
+//!            on_change(opt_id, "A");
+    }
+    void TextCtrl::BUILD() {
+        auto size = wxSize(wxDefaultSize);
+        if (opt.height >= 0) size.SetHeight(opt.height);
+        if (opt.width >= 0) size.SetWidth(opt.width);
+
+		auto temp = new wxTextCtrl(parent, wxID_ANY, wxString(""), wxDefaultPosition, size, (opt.multiline ? wxTE_MULTILINE : 0)); //! new wxTextCtrl(parent, wxID_ANY, wxString(opt.default_value->getString()), wxDefaultPosition, size, (opt.multiline ? wxTE_MULTILINE : 0));
+
+        if (opt.tooltip.length() > 0) { temp->SetToolTip(opt.tooltip); }
+        
+        temp->Bind(wxEVT_TEXT, ([=](wxCommandEvent e) { _on_change(e); }), temp->GetId());
+        temp->Bind(wxEVT_KILL_FOCUS, ([this](wxFocusEvent e) { _on_kill_focus(e); }), temp->GetId());
+
+        // recast as a wxWindow to fit the calling convention
+        window = dynamic_cast<wxWindow*>(temp);
+
+    }
+
+    void TextCtrl::enable() { (dynamic_cast<wxTextCtrl*>(window))->Enable(); (dynamic_cast<wxTextCtrl*>(window))->SetEditable(1); }
+    void TextCtrl::disable() { dynamic_cast<wxTextCtrl*>(window)->Disable(); dynamic_cast<wxTextCtrl*>(window)->SetEditable(0); }
+    void TextCtrl::set_tooltip(const wxString& tip) { }
+}}
+
diff --git a/xs/src/slic3r/GUI/Field.hpp b/xs/src/slic3r/GUI/Field.hpp
new file mode 100644
index 000000000..c5bf74256
--- /dev/null
+++ b/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 
+}}
+
diff --git a/xs/src/slic3r/GUI/GUI.cpp b/xs/src/slic3r/GUI/GUI.cpp
index cbd84f6db..e1292bd3a 100644
--- a/xs/src/slic3r/GUI/GUI.cpp
+++ b/xs/src/slic3r/GUI/GUI.cpp
@@ -9,6 +9,15 @@
 #import <IOKit/pwr_mgt/IOPMLib.h>
 #elif _WIN32
 #include <Windows.h>
+// Undefine min/max macros incompatible with the standard library
+// For example, std::numeric_limits<std::streamsize>::max()
+// produces some weird errors
+#ifdef min
+#undef min
+#endif
+#ifdef max
+#undef max
+#endif
 #include "boost/nowide/convert.hpp"
 #pragma comment(lib, "user32.lib")
 #endif
@@ -20,6 +29,7 @@
 #include <wx/notebook.h>
 #include <wx/panel.h>
 #include <wx/sizer.h>
+#include <wx/window.h>
 
 #include "Tab.h"
 
@@ -181,8 +191,25 @@ void add_debug_menu(wxMenuBar *menu)
 //
 void create_preset_tab(const char *name)
 {
-	CTabPrint* panel = new CTabPrint(g_wxTabPanel, name/*, someParams*/);
+	CTabPrint* panel = new CTabPrint(g_wxTabPanel, name);
+	panel->create_preset_tab();
 	g_wxTabPanel->AddPage(panel, name);
+
+	//!------------Exp
+	// parse all command line options into a DynamicConfig
+/*	
+	DynamicPrintConfig print_config;
+//!	const DynamicPrintConfig &print_config    = preset_bundle.prints   .get_edited_preset().config;
+
+	auto vsizer = new wxBoxSizer(wxVERTICAL);
+	this->SetSizer(vsizer);
+	auto optgroup = GUI::ConfigOptionsGroup(this, "Custom GCode", &print_config);
+	optgroup.on_change = ON_CHANGE(= , {});
+	vsizer->Add(optgroup.sizer, 0, wxEXPAND | wxALL, 10);
+
+	optgroup.append_single_option_line(GUI::Option(*(config.def->get("before_layer_gcode")), "before_layer_gcode"));
+*/	//!------------Exp
+
 }
 
 } }
diff --git a/xs/src/slic3r/GUI/OptionsGroup.cpp b/xs/src/slic3r/GUI/OptionsGroup.cpp
index 6dd278913..1c7124710 100644
--- a/xs/src/slic3r/GUI/OptionsGroup.cpp
+++ b/xs/src/slic3r/GUI/OptionsGroup.cpp
@@ -1,124 +1,125 @@
 #include "OptionsGroup.hpp"
-#include "OptionsGroup/Field.hpp"
-#include "Config.hpp"
+#include "ConfigExceptions.hpp"
 
-// Translate the ifdef 
-#ifdef __WXOSX__
-    #define wxOSX true
-#else
-    #define wxOSX false
-#endif
-
-#define BORDER(a, b) ((wxOSX ? a : b))
+#include <utility>
+#include <wx/tooltip.h>
 
 namespace Slic3r { namespace GUI {
 
+const t_field& OptionsGroup::build_field(const Option& opt) {
+    return build_field(opt.opt_id, opt.opt);
+}
+const t_field& OptionsGroup::build_field(const t_config_option_key& id) {
+	const ConfigOptionDef& opt = options.at(id);
+    return build_field(id, opt);
+}
 
-void OptionsGroup::BUILD() {
-    if (staticbox) {
-        wxStaticBox* box = new wxStaticBox(_parent, -1, title);
-        _sizer = new wxStaticBoxSizer(box, wxVERTICAL);
-    } else {
-        _sizer = new wxBoxSizer(wxVERTICAL);
+const t_field& OptionsGroup::build_field(const t_config_option_key& id, const ConfigOptionDef& opt) {
+    // Check the gui_type field first, fall through
+    // is the normal type.
+    if (opt.gui_type.compare("select") == 0) {
+    } else if (opt.gui_type.compare("select_open") == 0) {
+    } else if (opt.gui_type.compare("color") == 0) {
+    } else if (opt.gui_type.compare("f_enum_open") == 0 || 
+                opt.gui_type.compare("i_enum_open") == 0 ||
+                opt.gui_type.compare("i_enum_closed") == 0) {
+    } else if (opt.gui_type.compare("slider") == 0) {
+    } else if (opt.gui_type.compare("i_spin") == 0) { // Spinctrl
+    } else { 
+        switch (opt.type) {
+            case coFloatOrPercent:
+            case coPercent:
+            case coFloat:
+            case coString:
+//!                    fields.emplace(id, STDMOVE(TextCtrl::Create<TextCtrl>(_parent, opt,id)));
+                break;
+            case coNone:   break;
+            default:
+				break;//! throw ConfigGUITypeError(""); break;
+        }
     }
-    size_t num_columns = 1;
-    if (label_width != 0) ++num_columns;
-    if (extra_column != 0) ++num_columns;
-
-    _grid_sizer = new wxFlexGridSizer(0, num_columns, 0, 0);
-    _grid_sizer->SetFlexibleDirection(wxHORIZONTAL);
-    _grid_sizer->AddGrowableCol(label_width > 0);
-    _sizer->Add(_grid_sizer, 0, wxEXPAND | wxALL, BORDER(0,5));
+    // Grab a reference to fields for convenience
+    const t_field& field = fields[id];
+//!        field->on_change = [this](std::string id, boost::any val) {   };
+    field->parent = parent();
+    // assign function objects for callbacks, etc.
+    return field;
 }
 
 void OptionsGroup::append_line(const Line& line) {
-    if (line.has_sizer() || (line.has_widget() && line.full_width)) {
-        wxASSERT(line.sizer() != nullptr);
-        _sizer->Add( (line.has_sizer() ? line.sizer() : line.widget().sizer()), 0, wxEXPAND | wxALL, BORDER(0, 15));
-        return;
+    if (line.sizer != nullptr || (line.widget != nullptr && line.full_width > 0)){
+        if (line.sizer != nullptr) {
+            sizer->Add(line.sizer, 0, wxEXPAND | wxALL, wxOSX ? 0 : 15);
+            return;
+        }
+        if (line.widget != nullptr) {
+            sizer->Add(line.widget(_parent), 0, wxEXPAND | wxALL, wxOSX ? 0 : 15);
+            return;
+        }
     }
-    wxSizer* grid_sizer = _grid_sizer;
-    // If we have an extra column, build it.
-    // If there's a label, build it.
+
+    auto grid_sizer = _grid_sizer;
+
+    // Build a label if we have it
     if (label_width != 0) {
-        wxStaticText* label = new wxStaticText(_parent, -1, (line.label) + ":", wxDefaultPosition);
-        label->Wrap(label_width);
-        if (wxIsEmpty(line.tooltip())) { label->SetToolTip(line.tooltip()); }
-        grid_sizer->Add(label, 0, wxALIGN_CENTER_VERTICAL, 0);
+        auto label = new wxStaticText(parent(), wxID_ANY, line.label , wxDefaultPosition, wxSize(label_width, -1));
+        label->SetFont(label_font);
+        label->Wrap(label_width); // avoid a Linux/GTK bug
+        grid_sizer->Add(label, 0, wxALIGN_CENTER_VERTICAL,0);
+        if (line.label_tooltip.compare("") != 0)
+            label->SetToolTip(line.label_tooltip);
     }
-    // If we have a widget, add it to the sizer
-    if (line.has_widget()) {
-        grid_sizer->Add(line.widget().sizer(), 0, wxEXPAND | wxALL, BORDER(0,15));
+
+    // If there's a widget, build it and add the result to the sizer.
+    if (line.widget != nullptr) {
+        auto wgt = line.widget(parent());
+        grid_sizer->Add(wgt, 0, wxEXPAND | wxALL, wxOSX ? 0 : 15);
         return;
     }
-    // If we have a single option with no sidetext just add it directly to the grid sizer
-    if (line.options().size() == 1) {
-        const ConfigOptionDef& opt = line.options()[0];
-        if (line.extra_widgets().size() && !wxIsEmpty(opt.sidetext) && line.extra_widgets().size() == 0) {
-            Field* field = _build_field(opt);
-            if (field != nullptr) {
-                if (field->has_sizer()) {
-                    grid_sizer->Add(field->sizer(), 0, (opt.full_width ? wxEXPAND : 0) | wxALIGN_CENTER_VERTICAL, 0);
-                } else if (field->has_window()) {
-                    grid_sizer->Add(field->window(), 0, (opt.full_width ? wxEXPAND : 0) | wxALIGN_CENTER_VERTICAL, 0);
-                }
-            }
-        }
+
+    
+    // if we have a single option with no sidetext just add it directly to the grid sizer
+    auto option_set = line.get_options();
+    if (option_set.size() == 1 && option_set.front().opt.sidetext.size() == 0 &&
+        option_set.front().side_widget == nullptr && line.get_extra_widgets().size() == 0) {
+        const auto& option = option_set.front();
+        const auto& field = build_field(option);
+        std::cerr << "single option, no sidetext.\n";
+        std::cerr << "field parent is not null?: " << (field->parent != nullptr) << "\n";
+
+        if (is_window_field(field)) 
+            grid_sizer->Add(field->getWindow(), 0, (option.opt.full_width ? wxEXPAND : 0) | wxALIGN_CENTER_VERTICAL, 0);
+        if (is_sizer_field(field)) 
+            grid_sizer->Add(field->getSizer(), 0, (option.opt.full_width ? wxEXPAND : 0) | wxALIGN_CENTER_VERTICAL, 0);
+        return;
     }
-    // Otherwise, there's more than one option or a single option with sidetext -- make
-    // a horizontal sizer to arrange things.
-    wxBoxSizer* sizer = new wxBoxSizer(wxHORIZONTAL);
+
+    // if we're here, we have more than one option or a single option with sidetext
+    // so we need a horizontal sizer to arrange these things
+    auto sizer = new wxBoxSizer(wxHORIZONTAL);
     grid_sizer->Add(sizer, 0, 0, 0);
-    for (auto& option : line.options()) {
-        // add label if any
-        if (!wxIsEmpty(option.label)) {
-            wxStaticText* field_label = new wxStaticText(_parent, -1, __(option.label) + ":", wxDefaultPosition, wxDefaultSize);
-            sizer->Add(field_label, 0, wxALIGN_CENTER_VERTICAL,0);
-        }
-
-        // add field
-        Field* field = _build_field(option);
-        if (field != nullptr) {
-            if (field->has_sizer()) {
-                sizer->Add(field->sizer(), 0, (option.full_width ? wxEXPAND : 0) | wxALIGN_CENTER_VERTICAL, 0);
-            } else if (field->has_window()) {
-                sizer->Add(field->window(), 0, (option.full_width ? wxEXPAND : 0) | wxALIGN_CENTER_VERTICAL, 0);
-            }
-        }
-
-        if (!wxIsEmpty(option.sidetext)) {
-        }
-		// !!! side_widget !!! find out the purpose
-//        if (option.side_widget.valid()) {
-//           sizer->Add(option.side_widget.sizer(), 0, wxLEFT | wxALIGN_CENTER_VERTICAL, 1);
-//       }
-        if (&option != &line.options().back()) {
-            sizer->AddSpacer(4);
-        }
-
-        // add side text if any
-        // add side widget if any
-    }
-    // Append extra sizers
-    for (auto& widget : line.extra_widgets()) {
-        _sizer->Add(widget.sizer(), 0, wxLEFT | wxALIGN_CENTER_VERTICAL, 4);
+    for (auto opt : option_set) {
+            
     }
+
+        
+}
+Line OptionsGroup::create_single_option_line(const Option& option) const {
+    Line retval {option.opt.label, option.opt.tooltip};
+    Option tmp(option);
+    tmp.opt.label = std::string("");
+    retval.append_option(tmp);
+    return retval;
 }
 
-Field* OptionsGroup::_build_field(const ConfigOptionDef& opt) {
-    Field* built_field = nullptr;
-    switch (opt.type) {
-        case coString:
-            {
-            printf("Making new textctrl\n");
-            TextCtrl* temp = new TextCtrl(_parent, opt);
-            printf("recasting textctrl\n");
-            built_field = dynamic_cast<Field*>(temp);
-            }
-            break;
-        default:
-            break;
-    }
-    return built_field;
+//!    void OptionsGroup::_on_change(t_config_option_key id, config_value value) {
+//!        if (on_change != nullptr)
+//!            on_change(id, value);
+//!   }
+
+void OptionsGroup::_on_kill_focus (t_config_option_key id) { 
+    // do nothing.
 }
-} }
+
+
+}}
diff --git a/xs/src/slic3r/GUI/OptionsGroup.hpp b/xs/src/slic3r/GUI/OptionsGroup.hpp
index f2db0304e..328f721d8 100644
--- a/xs/src/slic3r/GUI/OptionsGroup.hpp
+++ b/xs/src/slic3r/GUI/OptionsGroup.hpp
@@ -1,109 +1,148 @@
-#ifndef OPTIONSGROUP_HPP
-#define OPTIONSGROUP_HPP
+#include <wx/wx.h>
+#include <wx/stattext.h>
+#include <wx/settings.h>
+//#include <wx/window.h>
 
-#include <boost/any.hpp>
 #include <map>
-#include "wxinit.h"
-#include "Widget.hpp"
-#include "OptionsGroup/Field.hpp"
-#include "Config.hpp"
-namespace Slic3r { 
-class ConfigOptionDef;
-namespace GUI {
+#include <functional>
 
+#include "libslic3r/Config.hpp"
+#include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/libslic3r.h"
 
-/// Enumeration class to provide flags for these GUI hints.
-/// they resolve to hex numbers to permit boolean masking.
-enum class GUI_Type {
-    i_enum_open = 0x1,
-    f_enum_open = 0x2,
-    select_open = 0x4
+#include "Field.hpp"
+//#include "slic3r_gui.hpp"
+#include "GUI.hpp"
+
+// Translate the ifdef 
+#ifdef __WXOSX__
+    #define wxOSX true
+#else
+    #define wxOSX false
+#endif
+
+#define BORDER(a, b) ((wxOSX ? a : b))
+
+namespace Slic3r { namespace GUI {
+
+/// Widget type describes a function object that returns a wxWindow (our widget) and accepts a wxWidget (parent window).
+using widget_t = std::function<wxWindow*(wxWindow*)>;
+using column_t = std::function<wxSizer*(const Line&)>;
+
+class StaticText;
+
+/// Wraps a ConfigOptionDef and adds function object for creating a side_widget.
+struct Option {
+    ConfigOptionDef opt {ConfigOptionDef()}; 
+	t_config_option_key opt_id;//! {""};
+    widget_t side_widget {nullptr};
+    bool readonly {false};
+
+    Option(const ConfigOptionDef& _opt, t_config_option_key id) : opt(_opt), opt_id(id) {};
+};
+using t_option = std::unique_ptr<Option>;	//!
+
+/// Represents option lines
+class Line {
+public:
+    wxString label {wxString("")};
+    wxString label_tooltip {wxString("")};
+    size_t full_width {0}; 
+    wxSizer* sizer {nullptr};
+    widget_t widget {nullptr};
+
+    inline void append_option(const Option& option) {
+        _options.push_back(option);
+    }
+    Line(std::string label, std::string tooltip) : label(wxString(label)), label_tooltip(wxString(tooltip)) {} ;
+
+    const std::vector<widget_t>& get_extra_widgets() const {return _extra_widgets;}
+    const std::vector<Option>& get_options() const { return _options; }
+
+private:
+	std::vector<Option> _options;//! {std::vector<Option>()};
+    std::vector<widget_t> _extra_widgets;//! {std::vector<widget_t>()};
 };
 
-// Map these flags 
-/*constexpr */std::map<std::string, GUI_Type>gui_type_map = 
-    { { "i_enum_open", GUI_Type::i_enum_open },
-      { "f_enum_open", GUI_Type::f_enum_open },
-      { "select_open", GUI_Type::select_open }
+using t_optionfield_map = std::map<t_config_option_key, t_field>;
+using t_optionoption_map = std::map<t_config_option_key, t_option>;	//!
+
+class OptionsGroup {
+public:
+
+    const bool staticbox {true};
+    const wxString title {wxString("")};
+    size_t label_width {180};
+    wxSizer* sizer {nullptr};
+    column_t extra_column {nullptr};
+//    t_change on_change {nullptr};
+
+    /// Returns a copy of the pointer of the parent wxWindow.
+    /// Accessor function is because users are not allowed to change the parent
+    /// but defining it as const means a lot of const_casts to deal with wx functions.
+    inline wxWindow* parent() const { return _parent; }
+
+    wxFont sidetext_font {wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT) };
+    wxFont label_font {wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT) };
+
+
+    void append_line(const Line& line);
+    virtual Line create_single_option_line(const Option& option) const;
+    inline void append_single_option_line(const Option& option) { append_line(create_single_option_line(option)); }
+
+    // return a non-owning pointer reference 
+    inline const Field* get_field(t_config_option_key id) const { try { return fields.at(id).get(); } catch (std::out_of_range e) { return nullptr; } }
+//!    inline const Option& get_option(t_config_option_key id) const { try { return options.at(id).get(); } catch (std::out_of_range e) { return nullptr; } }
+ //   }
+//!    inline void set_value(t_config_option_key id, boost::any value) { try { fields.at(id).set_value(value); } catch (std::out_of_range e) {;}  }
+
+    inline void enable() { for (auto& field : fields) field.second->enable(); }
+    inline void disable() { for (auto& field : fields) field.second->disable(); }
+
+
+
+    OptionsGroup(wxWindow* _parent, std::string title, const ConfigDef& configs) : options(configs.options), _parent(_parent), title(wxString(title)) {
+        sizer = (staticbox ? new wxStaticBoxSizer(new wxStaticBox(_parent, wxID_ANY, title), wxVERTICAL) : new wxBoxSizer(wxVERTICAL));
+        auto num_columns = 1U;
+        if (label_width != 0) num_columns++;
+        if (extra_column != nullptr) num_columns++;
+        _grid_sizer = new wxFlexGridSizer(0, num_columns, 0,0);
+        static_cast<wxFlexGridSizer*>(_grid_sizer)->SetFlexibleDirection(wxHORIZONTAL);
+        static_cast<wxFlexGridSizer*>(_grid_sizer)->AddGrowableCol(label_width != 0);
+
+        sizer->Add(_grid_sizer, 0, wxEXPAND | wxALL, wxOSX ? 0: 5);
     };
 
-// Abstraction cribbed from Slic3r::ConfigOptionDefGroup::Line
-// Unsure if templated class or function overloading is the appropriate thing here.
-class Line {
-private:
-    std::vector<ConfigOptionDef> _options;
-    std::vector<Widget> _extra_widgets;
-    Widget _widget;
-    wxSizer* _sizer;
-    wxString _tooltip;
+protected:
+    /*const t_optionoption_map& options;	//*/const t_optiondef_map& options; //!
+    wxWindow* _parent {nullptr};
+
+    /// Field list, contains unique_ptrs of the derived type.
+    /// using types that need to know what it is beyond the public interface 
+    /// need to cast based on the related ConfigOptionDef.
+    t_optionfield_map fields;
+    bool _disabled {false};
+    wxGridSizer* _grid_sizer {nullptr};
+
+    /// Generate a wxSizer or wxWindow from a configuration option
+    /// Precondition: opt resolves to a known ConfigOption
+    /// Postcondition: fields contains a wx gui object.
+    const t_field& build_field(const t_config_option_key& id, const ConfigOptionDef& opt);
+    const t_field& build_field(const t_config_option_key& id);
+    const t_field& build_field(const Option& opt);
+
+    virtual void _on_kill_focus (t_config_option_key id);
+//!    virtual void _on_change(t_config_option_key id, config_value value);
+
+
+};
+
+class ConfigOptionsGroup: public OptionsGroup {
 public:
-    wxString label;
-    bool full_width;
-    wxSizer* sizer() const { return _sizer; }
-    Line() : label(wxT("")), _tooltip(wxT("")), _sizer(nullptr), full_width(false), _widget(Widget()) { }
-    Line(const ConfigOptionDef& z) : label(z.label), _tooltip(z.tooltip), _sizer(nullptr), full_width(false), _widget(Widget()) { append_option(z); }
-    Line(const wxString& label, const wxString& tooltip) : label(label), _tooltip(tooltip), _sizer(nullptr), full_width(false), _widget(Widget()) { }
-    inline void append_option(const ConfigOptionDef& z) { _options.push_back(z); };
-    void append_widget(const Widget& wid) { _extra_widgets.push_back(wid); }
-    std::vector<ConfigOptionDef> options() const { return _options; }
-    const std::vector<Widget> extra_widgets() const { return _extra_widgets; }
-    bool has_sizer() const { return _sizer != nullptr; }
-    bool has_widget() const { return _widget.valid(); }
-    Widget widget() const { return _widget; }
-    const wxString tooltip() const { return _tooltip; }
+    /// reference to libslic3r config, non-owning pointer (?).
+    const DynamicPrintConfig* config {nullptr};
+    bool full_labels {0};
+	ConfigOptionsGroup(wxWindow* parent, std::string title, DynamicPrintConfig* _config) : OptionsGroup(parent, title, *(_config->def())), config(_config) {}; //!OptionsGroup(parent, title, *(_config->def)), config(_config) {};
 };
 
-
-// OptionsGroup building class, cribbed from Slic3r::OptionGroup
-// Usage: Instantitate, add individual items to it, and add its sizer to another wxWidgets sizer.
-class OptionsGroup {
-    private:
-        bool _disabled;
-        wxFlexGridSizer* _grid_sizer;
-        wxSizer* _sizer;
-        void BUILD(); 
-        const bool staticbox;
-        wxFrame* _parent;
-        std::map<size_t, Field*> fields;
-        Field* _build_field(const ConfigOptionDef& opt);
-    public:
-        const wxString title;
-
-        size_t label_width;
-        wxFont label_font;
-        wxFont sidetext_font;
-        bool extra_column;
-
-        OptionsGroup() : _parent(nullptr), title(wxT("")), staticbox(1), fields(std::map<size_t, Field*>()){};
-        OptionsGroup(wxFrame* parent, std::string title) : 
-            _parent(parent), 
-            title(title.c_str()), 
-            staticbox(1),
-            extra_column(false),
-            label_width(0),
-            fields(std::map<size_t, Field*>())
-            { BUILD(); }
-
-        OptionsGroup(wxFrame* parent, std::string, size_t label_width) :
-            _parent(parent), 
-            title(title.c_str()), 
-            staticbox(1),
-            extra_column(false),
-            fields(std::map<size_t, Field*>()),
-            label_width(label_width) { BUILD(); }
-
-        void append_line(const Line& line);
-        Line create_single_option_line(const ConfigOptionDef& opt) { Line a = Line(opt); append_line(a); return a; }
-        void append_single_option_line(const Line& line);
-
-        wxSizer* sizer() { return _sizer; }
-        void disable() { for (auto& f: fields) f.second->disable(); }
-        void enable() { for (auto& f: fields) f.second->enable(); }
-};
-
-
-
-
-} }
-
-#endif
+}}
diff --git a/xs/src/slic3r/GUI/OptionsGroup/Field.cpp b/xs/src/slic3r/GUI/OptionsGroup/Field.cpp
deleted file mode 100644
index a512a4685..000000000
--- a/xs/src/slic3r/GUI/OptionsGroup/Field.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-#include "Field.hpp"
-
-namespace Slic3r { namespace GUI {
-
-void TextCtrl::BUILD() {
-    wxString default_value = "";
-    // Empty wxString object fails cast, default to "" if 
-    // the recast fails from boost::any.
-    try {
-        if (opt.default_value != nullptr) {
-            default_value = boost::any_cast<wxString>(*(opt.default_value));
-        }
-    } catch (const boost::bad_any_cast& e) {
-        //TODO log error
-    }
-    auto size = wxSize(opt.height,opt.width);
-    if (opt.height == 0 || opt.width == 0) { size = wxDefaultSize; }
-
-    wxTextCtrl* temp = new wxTextCtrl(_parent, wxID_ANY, default_value, wxDefaultPosition, size, (opt.multiline ? wxTE_MULTILINE : 0));
-
-    _on_change = [=](wxCommandEvent& a) { this->__on_change(a);};
-
-    // This replaces the generic EVT_TEXT call to set the table up, it works with function objects.
-    temp->Bind(wxEVT_TEXT, _on_change, temp->GetId());
-    if (opt.tooltip.length() > 0) { temp->SetToolTip(opt.tooltip); }
-
-    // recast as a wxWindow to fit the calling convention
-    _window = dynamic_cast<wxWindow*>(temp);
-}
-
-// Fixed (temporary) function. We can (and probably should) use lambdas instead.
-void TextCtrl::__on_change(wxCommandEvent& a) {
-    printf("Calling _on_change for %d.\n", opt.label);
-}
-
-} }
diff --git a/xs/src/slic3r/GUI/OptionsGroup/Field.hpp b/xs/src/slic3r/GUI/OptionsGroup/Field.hpp
deleted file mode 100644
index e60d3bc32..000000000
--- a/xs/src/slic3r/GUI/OptionsGroup/Field.hpp
+++ /dev/null
@@ -1,95 +0,0 @@
-#ifndef FIELD_HPP
-#define FIELD_HPP
-
-#include "../wxinit.h"
-
-#include <functional>
-#include <boost/any.hpp>
-#include <map>
-
-// ConfigOptionDef definition
-#include "Config.hpp"
-
-namespace Slic3r { 
-class ConfigOptionDef;
-namespace GUI {
-
-
-
-/// Interface class for fields
-/// 
-class Field {
-protected:
-    wxSizer*		_sizer;
-    wxWindow*		_window;
-    wxWindow*		_parent;
-
-    /// Instantiate the underlying wxWidgets control/window.
-    /// This function is expected to be called by the constructor.
-    virtual void BUILD() = 0;
-
-    /// Reference to underlying ConfigOptionDef this Field is
-    /// implementing.
-    /// TODO: This may not be necessary.
-    const ConfigOptionDef& opt; 
-	std::string		type;
-
-public:
-    std::function<void(wxCommandEvent&)> _on_change;
-    std::function<void(wxCommandEvent&)> _on_kill_focus;
-    // used if we need to know which ConfigOptionDef this corresponds.
-    Field() : opt(ConfigOptionDef()), _on_change(nullptr), _on_kill_focus(nullptr){}
-    Field(const ConfigOptionDef& opt) : opt(opt), type(opt.gui_type) { }
-    Field(wxFrame* parent, const ConfigOptionDef& opt) : opt(opt),  _parent(parent) { }
-    wxSizer* sizer() { return _sizer; }
-    wxWindow* window() { return _window; }
-
-    // 
-    bool has_sizer() { return _sizer != nullptr; }
-    bool has_window() { return _window != nullptr; }
-
-    /// Return the wxWidgets ID for this object.
-    ///
-    wxWindowID get_id() { if (this->has_window()) return _window->GetId(); }
-
-    /// Sets a value for this control.
-    /// subclasses should overload with a specific version
-    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;
-
-    /// subclasses should overload with a specific version
-    virtual void enable() = 0;
-    virtual void disable() = 0;
-
-};
-
-class TextCtrl : public Field {
-protected:
-    void BUILD();
-public:
-    TextCtrl();
-    TextCtrl(wxFrame* parent, const ConfigOptionDef& opt) : Field(parent, opt) { BUILD(); };
-
-    void set_value(std::string value) { 
-            dynamic_cast<wxTextCtrl*>(_window)->SetValue(wxString(value));
-    }
-    void set_value(boost::any value) { 
-        try {
-            dynamic_cast<wxTextCtrl*>(_window)->SetValue(boost::any_cast<wxString>(value));
-        } catch (boost::bad_any_cast) {
-            // TODO Log error and do nothing
-        }
-    }
-    boost::any get_value() { return boost::any(dynamic_cast<wxTextCtrl*>(_window)->GetValue()); }
-    
-    void enable() { dynamic_cast<wxTextCtrl*>(_window)->Enable(); dynamic_cast<wxTextCtrl*>(_window)->SetEditable(1); }
-    void disable() { dynamic_cast<wxTextCtrl*>(_window)->Disable(); dynamic_cast<wxTextCtrl*>(_window)->SetEditable(0); }
-    void __on_change(wxCommandEvent&);
-    
-};
-
-} }
-#endif
diff --git a/xs/src/slic3r/GUI/Tab.cpp b/xs/src/slic3r/GUI/Tab.cpp
index b6af3d998..b91680225 100644
--- a/xs/src/slic3r/GUI/Tab.cpp
+++ b/xs/src/slic3r/GUI/Tab.cpp
@@ -1,9 +1,7 @@
 #include <wx/app.h>
 #include <wx/button.h>
-#include <wx/frame.h>
+#include <wx/scrolwin.h>
 #include <wx/menu.h>
-#include <wx/notebook.h>
-#include <wx/panel.h>
 #include <wx/sizer.h>
 
 #include <wx/bmpcbox.h>
@@ -12,19 +10,11 @@
 #include <wx/imaglist.h>
 
 #include "Tab.h"
+#include "PresetBundle.hpp"
 
 namespace Slic3r {
 namespace GUI {
 
-// Declare some IDs. 
-/*const int BUTTON1 = 100;
-
-// Attach the event handlers. Put this after Slis3rFrame declaration.
-BEGIN_EVENT_TABLE(MyFrame, wxFrame)
-EVT_BUTTON(BUTTON1, MyFrame::OnButton1)
-END_EVENT_TABLE()
-*/
-
 // sub new
 void CTab::create_preset_tab()
 {
@@ -32,136 +22,483 @@ void CTab::create_preset_tab()
 	CTab *panel = this;
 	auto  *sizer = new wxBoxSizer(wxVERTICAL);
 	sizer->SetSizeHints(panel);
-	(panel)->SetSizer(sizer);
 	panel->SetSizer(sizer);
 
 	// preset chooser
+	//! Add Preset from PrintPreset
 	// choice menu for Experiments
 	wxString choices[] =
 	{
-		_T("Washington"),
-		_T("Adams"),
-		_T("Jefferson"),
-		_T("Madison"),
-		_T("Lincoln"),
-		_T("One"),
-		_T("Two"),
-		_T("Three"),
-		_T("Four")
+		_T("First"),
+		_T("Second"),
+		_T("Third")
 	};
-	int nCntEl = 9;
 
-	presets_choice = new wxBitmapComboBox(panel, wxID_ANY, "", wxDefaultPosition, wxSize(270, -1), nCntEl, choices, wxCB_READONLY);
+	presets_choice_ = new wxBitmapComboBox(panel, wxID_ANY, "", wxDefaultPosition, wxSize(270, -1)/*, nCntEl, choices, wxCB_READONLY*/);
+	const wxBitmap* bmp = new wxBitmap(wxT("var\\flag-green-icon.png"), wxBITMAP_TYPE_PNG);
+	for (auto el:choices)
+		presets_choice_->Append(wxString::FromUTF8(el).c_str(), *bmp);
+	presets_choice_->SetSelection(presets_choice_->GetCount() - 1);
 
 	//buttons
 	wxBitmap bmpMenu;
 	bmpMenu = wxBitmap(wxT("var\\disk.png"), wxBITMAP_TYPE_PNG);
-	auto *btn_save_preset = new wxBitmapButton(panel, wxID_ANY, bmpMenu, wxDefaultPosition, wxDefaultSize, wxBORDER_NONE);
+	btn_save_preset_ = new wxBitmapButton(panel, wxID_ANY, bmpMenu, wxDefaultPosition, wxDefaultSize, wxBORDER_NONE);
 	bmpMenu = wxBitmap(wxT("var\\delete.png"), wxBITMAP_TYPE_PNG);
-	auto *btn_delete_preset = new wxBitmapButton(panel, wxID_ANY, bmpMenu, wxDefaultPosition, wxDefaultSize, wxBORDER_NONE);
+	btn_delete_preset_ = new wxBitmapButton(panel, wxID_ANY, bmpMenu, wxDefaultPosition, wxDefaultSize, wxBORDER_NONE);
 
 	//	$self->{show_incompatible_presets} = 0;			// !!!
 
-	bmp_show_incompatible_presets = new wxBitmap(wxT("var\\flag-red-icon.png"), wxBITMAP_TYPE_PNG);
-	bmp_hide_incompatible_presets = new wxBitmap(wxT("var\\flag-green-icon.png"), wxBITMAP_TYPE_PNG);
-	btn_hide_incompatible_presets = new wxBitmapButton(panel, wxID_ANY, *bmp_hide_incompatible_presets, wxDefaultPosition, wxDefaultSize, wxBORDER_NONE);
+	bmp_show_incompatible_presets_ = new wxBitmap(wxT("var\\flag-red-icon.png"), wxBITMAP_TYPE_PNG);
+	bmp_hide_incompatible_presets_ = new wxBitmap(wxT("var\\flag-green-icon.png"), wxBITMAP_TYPE_PNG);
+	btn_hide_incompatible_presets_ = new wxBitmapButton(panel, wxID_ANY, *bmp_hide_incompatible_presets_, wxDefaultPosition, wxDefaultSize, wxBORDER_NONE);
 
-	wxString stTitle = _T("Save current ") + wxString(_title);//. lc($self->title) 
-	btn_save_preset->SetToolTip(stTitle);
-	btn_delete_preset->SetToolTip(_T("Delete this preset"));
-	btn_delete_preset->Disable();
+	btn_save_preset_->SetToolTip(wxT("Save current ") + wxString(title_));// (stTitle);
+	btn_delete_preset_->SetToolTip(_T("Delete this preset"));
+	btn_delete_preset_->Disable();
 
-	hsizer = new wxBoxSizer(wxHORIZONTAL);
-	sizer->Add(hsizer, 0, wxBOTTOM, 3);
-	hsizer->Add(presets_choice, 1, wxLEFT | wxRIGHT | wxTOP | wxALIGN_CENTER_VERTICAL, 3);
-	hsizer->AddSpacer(4);
-	hsizer->Add(btn_save_preset, 0, wxALIGN_CENTER_VERTICAL);
-	hsizer->AddSpacer(4);
-	hsizer->Add(btn_delete_preset, 0, wxALIGN_CENTER_VERTICAL);
-	hsizer->AddSpacer(16);
-	hsizer->Add(btn_hide_incompatible_presets, 0, wxALIGN_CENTER_VERTICAL);
+	hsizer_ = new wxBoxSizer(wxHORIZONTAL);
+	sizer->Add(hsizer_, 0, wxBOTTOM, 3);
+	hsizer_->Add(presets_choice_, 1, wxLEFT | wxRIGHT | wxTOP | wxALIGN_CENTER_VERTICAL, 3);
+	hsizer_->AddSpacer(4);
+	hsizer_->Add(btn_save_preset_, 0, wxALIGN_CENTER_VERTICAL);
+	hsizer_->AddSpacer(4);
+	hsizer_->Add(btn_delete_preset_, 0, wxALIGN_CENTER_VERTICAL);
+	hsizer_->AddSpacer(16);
+	hsizer_->Add(btn_hide_incompatible_presets_, 0, wxALIGN_CENTER_VERTICAL);
 
 	//Horizontal sizer to hold the tree and the selected page.
-	hsizer = new wxBoxSizer(wxHORIZONTAL);
-	sizer->Add(hsizer, 1, wxEXPAND, 0);
+	hsizer_ = new wxBoxSizer(wxHORIZONTAL);
+	sizer->Add(hsizer_, 1, wxEXPAND, 0);
 
 	//left vertical sizer
-	left_sizer = new wxBoxSizer(wxVERTICAL);
-	hsizer->Add(left_sizer, 0, wxEXPAND | wxLEFT | wxTOP | wxBOTTOM, 3);
+	left_sizer_ = new wxBoxSizer(wxVERTICAL);
+	hsizer_->Add(left_sizer_, 0, wxEXPAND | wxLEFT | wxTOP | wxBOTTOM, 3);
 
 	// tree
-	auto *treectrl = new wxTreeCtrl(panel, wxID_ANY, wxDefaultPosition, wxSize(185, -1), wxTR_NO_BUTTONS | wxTR_HIDE_ROOT | wxTR_SINGLE | wxTR_NO_LINES | wxBORDER_SUNKEN | wxWANTS_CHARS);
-	left_sizer->Add(treectrl, 1, wxEXPAND);
-	icons = new wxImageList(16, 16, 1);
-	// Map from an icon file name to its index in $self->{icons}.
-	//    $self->{icon_index} = {};
+	treectrl_ = new wxTreeCtrl(panel, wxID_ANY/*ID_TAB_TREE*/, wxDefaultPosition, wxSize(185, -1), wxTR_NO_BUTTONS | wxTR_HIDE_ROOT | wxTR_SINGLE | wxTR_NO_LINES | wxBORDER_SUNKEN | wxWANTS_CHARS);
+	left_sizer_->Add(treectrl_, 1, wxEXPAND);
+	icons_ = new wxImageList(16, 16, true, 1/*, 1*/);
 	// Index of the last icon inserted into $self->{icons}.
 	icon_count = -1;
-	treectrl->AssignImageList(icons);
-	treectrl->AddRoot("root");
-	//    $self->{pages} = [];
-	treectrl->SetIndent(0);
-	disable_tree_sel_changed_event = 0;
+	treectrl_->AssignImageList(icons_);
+	treectrl_->AddRoot("root");
+	treectrl_->SetIndent(0);
+	disable_tree_sel_changed_event_ = 0;
 
-	/*   EVT_TREE_SEL_CHANGED($parent, $self->{treectrl}, sub {
-	return if $self->{disable_tree_sel_changed_event};
-	my $page = first { $_->{title} eq $self->{treectrl}->GetItemText($self->{treectrl}->GetSelection) } @{$self->{pages}}
-	or return;
-	$_->Hide for @{$self->{pages}};
-	$page->Show;
-	$self->{hsizer}->Layout;
-	$self->Refresh;
-	});
-	EVT_KEY_DOWN($self->{treectrl}, sub {
-	my ($treectrl, $event) = @_;
-	if ($event->GetKeyCode == WXK_TAB) {
-	$treectrl->Navigate($event->ShiftDown ? &Wx::wxNavigateBackward : &Wx::wxNavigateForward);
-	} else {
-	$event->Skip;
-	}
-	});
+	//!-----------------------EXP
+	// Vertical sizer to hold selected page
+// 	auto *scrolled_win = new wxScrolledWindow(panel, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL);
+// 	wxBoxSizer *vs = new wxBoxSizer(wxVERTICAL);
+// 	scrolled_win->SetSizer(vs);
+// 	scrolled_win->SetScrollbars(1, 1, 1, 1);
+// 	hsizer_->Add(scrolled_win, 1, wxEXPAND | wxLEFT, 5);
+// 
+// 	wxSizer* sbs = new wxStaticBoxSizer(new wxStaticBox(scrolled_win, wxID_ANY, "Trulala"), wxVERTICAL);
+// 	vs->Add(sbs, 0, wxEXPAND | wxALL, 10);
+// 	sbs = new wxBoxSizer(wxVERTICAL);
+// 	vs->Add(sbs, 0, wxEXPAND | wxALL, 10);
+// 	sbs = new wxStaticBoxSizer(new wxStaticBox(scrolled_win, wxID_ANY, "LuTrulala"), wxVERTICAL);
+// 	vs->Add(sbs, 0, wxEXPAND | wxALL, 10);
 
-	EVT_COMBOBOX($parent, $self->{presets_choice}, sub {
-	$self->select_preset($self->{presets_choice}->GetStringSelection);
-	});
 
-	EVT_BUTTON($self, $self->{btn_save_preset}, sub { $self->save_preset });
-	EVT_BUTTON($self, $self->{btn_delete_preset}, sub { $self->delete_preset });
-	EVT_BUTTON($self, $self->{btn_hide_incompatible_presets}, sub { $self->_toggle_show_hide_incompatible });
-*/
+// 	auto *page_sizer = new wxBoxSizer(wxVERTICAL);
+// 	hsizer_->Add(page_sizer, 1, wxEXPAND | wxLEFT, 5);
+
+// 	wxStaticBox* box = new wxStaticBox(panel, wxID_ANY, "Filament");
+// 	page_sizer->Add(new wxStaticBoxSizer(box, wxHORIZONTAL), 0, wxEXPAND | wxTOP | wxLEFT | wxRIGHT | wxBOTTOM, 10);
+// 
+// 	//Horizontal sizer to hold the tree and the selected page.
+// 	wxStaticBoxSizer* tmp_hsizer = new wxStaticBoxSizer(wxHORIZONTAL, panel, "Experimental Box");
+// 	page_sizer->Add(tmp_hsizer, 0, wxEXPAND | wxTOP | wxLEFT | wxRIGHT | wxBOTTOM, 10);
+// 
+// 	auto *grid_sizer = new wxFlexGridSizer(0, 4, 0, 0);
+// 	grid_sizer->SetFlexibleDirection(wxHORIZONTAL);
+// 	tmp_hsizer->Add(grid_sizer, 0, wxEXPAND | wxALL, /*&Wx::wxMAC ? 0 :*/ 5);
+// 
+// 	wxStaticText *label = new wxStaticText(panel, wxID_ANY, "Label1", wxDefaultPosition, wxSize(200,-1));
+// 	auto *textctrl = new wxTextCtrl(panel, wxID_ANY, "TruLaLa1");
+// 	grid_sizer->Add(label, 0, wxALIGN_CENTER_VERTICAL, 0);
+// 	grid_sizer->Add(textctrl, 0, wxALIGN_CENTER_VERTICAL, 0);
+// 
+// 	label = new wxStaticText(panel, wxID_ANY, "Labelszdfdghhjk2");
+// 	textctrl = new wxTextCtrl(panel, wxID_ANY, "TruLaLa2");
+// 	grid_sizer->Add(label, 0, wxALIGN_CENTER_VERTICAL, 0);
+// 	grid_sizer->Add(textctrl, 0, wxALIGN_CENTER_VERTICAL, 0);
+// 
+// 	label = new wxStaticText(panel, wxID_ANY, "Label3");
+// 	textctrl = new wxTextCtrl(panel, wxID_ANY, "TruLaLa3");
+// 	grid_sizer->Add(label, 0, wxALIGN_CENTER_VERTICAL, 0);
+// 	grid_sizer->Add(textctrl, 0, wxALIGN_CENTER_VERTICAL, 0);
+// 
+// 	label = new wxStaticText(panel, wxID_ANY, "Label4");
+// 	textctrl = new wxTextCtrl(panel, wxID_ANY, "TruLaLa4");
+// 	grid_sizer->Add(label, 0, wxALIGN_CENTER_VERTICAL, 0);
+// 	grid_sizer->Add(textctrl, 0, wxALIGN_CENTER_VERTICAL, 0);
+// 
+// 	box = new wxStaticBox(panel, wxID_ANY, "Print");
+// 	page_sizer->Add(new wxStaticBoxSizer(box, wxHORIZONTAL), 0, wxEXPAND | wxTOP | wxLEFT | wxRIGHT | wxBOTTOM, 10);
+	//!------------------------
+
+	treectrl_->Bind(wxEVT_TREE_SEL_CHANGED, &CTab::OnTreeSelChange, this);
+	treectrl_->Bind(wxEVT_KEY_DOWN, &CTab::OnKeyDown, this);
+	treectrl_->Bind(wxEVT_COMBOBOX, &CTab::OnComboBox, this); 
+
+	btn_save_preset_->Bind(wxEVT_BUTTON, &CTab::save_preset, this);
+	btn_delete_preset_->Bind(wxEVT_BUTTON, &CTab::delete_preset, this);
+	btn_hide_incompatible_presets_->Bind(wxEVT_BUTTON, &CTab::_toggle_show_hide_incompatible, this);
+
 	// Initialize the DynamicPrintConfig by default keys/values.
 	// Possible %params keys: no_controller
-//	build(/*%params*/);
-//	rebuild_page_tree();
+	build();
+	rebuild_page_tree();
 //	_update();
 
 
 	return;//$self;
 }
 
-void CTab::OnTreeSelChange(wxCommandEvent& event)
+CPageShp CTab::add_options_page(wxString title, wxString icon)
 {
-	if (disable_tree_sel_changed_event) return;
+	// Index of icon in an icon list $self->{icons}.
+	auto icon_idx = 0;
+	if (!icon.IsEmpty()) {
+		try { icon_idx = icon_index_.at(icon);}
+		catch (std::out_of_range e) { icon_idx = -1; }
+		if (icon_idx == -1) {
+			// Add a new icon to the icon list.
+			const auto img_icon = new wxIcon(wxT("var\\") + icon, wxBITMAP_TYPE_PNG);
+			icons_->Add(*img_icon);
+			icon_idx = ++icon_count; //  $icon_idx = $self->{icon_count} + 1; $self->{icon_count} = $icon_idx;
+			icon_index_[icon] = icon_idx;
+		}
+	}
+	// Initialize the page.
+	CPageShp page(new CPage(this, title, icon_idx));
+	page->SetScrollbars(1, 1, 1, 1);
+	page->Hide();
+	hsizer_->Add(page.get(), 1, wxEXPAND | wxLEFT, 5);
+	pages_.push_back(page);
+	return page;
+}
+
+void CTabPrint::build()
+{
+//	$self->{presets} = wxTheApp->{preset_bundle}->print;
+//	$self->{config} = $self->{presets}->get_edited_preset->config;
+
+	PresetCollection *prints = new PresetCollection(Preset::TYPE_PRINT, Preset::print_options());
+	config_ = prints->get_edited_preset().config;
+
+	auto page = add_options_page("Layers and perimeters", "layers.png");
+	page->set_config(&config_);
+// 	{
+		auto optgroup = page->new_optgroup("Layer height");
+// 		optgroup->append_single_option_line("layer_height");
+// 		optgroup->append_single_option_line("first_layer_height");
+// 	}
+// 	{
+		optgroup = page->new_optgroup("Vertical shells");
+// 		$optgroup->append_single_option_line("perimeters");
+// 		$optgroup->append_single_option_line("spiral_vase");
+// 	}
+// 	{
+ 		optgroup = page->new_optgroup("Horizontal shells");
+// 		my $line = Slic3r::GUI::OptionsGroup::Line->new(
+// 			label = > "Solid layers",
+// 			);
+// 		$line->append_option($optgroup->get_option("top_solid_layers"));
+// 		$line->append_option($optgroup->get_option("bottom_solid_layers"));
+// 		$optgroup->append_line($line);
+// 	}
+// 	{
+ 		optgroup = page->new_optgroup("Quality (slower slicing)");
+// 		$optgroup->append_single_option_line("extra_perimeters");
+// 		$optgroup->append_single_option_line("ensure_vertical_shell_thickness");
+// 		$optgroup->append_single_option_line("avoid_crossing_perimeters");
+// 		$optgroup->append_single_option_line("thin_walls");
+// 		$optgroup->append_single_option_line("overhangs");
+// 	}
+// 	{
+ 		optgroup = page->new_optgroup("Advanced");
+// 		$optgroup->append_single_option_line("seam_position");
+// 		$optgroup->append_single_option_line("external_perimeters_first");
+// 	}
+
+	page = add_options_page("Infill", "infill.png");
+	page->set_config(&config_);
+// 	{
+		optgroup = page->new_optgroup("Infill");
+// 		$optgroup->append_single_option_line("fill_density");
+// 		$optgroup->append_single_option_line("fill_pattern");
+// 		$optgroup->append_single_option_line("external_fill_pattern");
+// 	}
+// 	{
+ 		optgroup = page->new_optgroup("Reducing printing time");
+// 		$optgroup->append_single_option_line("infill_every_layers");
+// 		$optgroup->append_single_option_line("infill_only_where_needed");
+// 	}
+// 	{
+ 		optgroup = page->new_optgroup("Advanced");
+// 		$optgroup->append_single_option_line("solid_infill_every_layers");
+// 		$optgroup->append_single_option_line("fill_angle");
+// 		$optgroup->append_single_option_line("solid_infill_below_area");
+// 		$optgroup->append_single_option_line("bridge_angle");
+// 		$optgroup->append_single_option_line("only_retract_when_crossing_perimeters");
+// 		$optgroup->append_single_option_line("infill_first");
+// 	}
+
+		page = add_options_page("Skirt and brim", "box.png");
+		page->set_config(&config_);
+// 	{
+ 		optgroup = page->new_optgroup("Skirt");
+// 		$optgroup->append_single_option_line("skirts");
+// 		$optgroup->append_single_option_line("skirt_distance");
+// 		$optgroup->append_single_option_line("skirt_height");
+// 		$optgroup->append_single_option_line("min_skirt_length");
+// 	}
+// 	{
+ 		optgroup = page->new_optgroup("Brim");
+// 		$optgroup->append_single_option_line("brim_width");
+// 	}
+
+	page = add_options_page("Support material", "building.png");
+	page->set_config(&config_);
+// 	{
+ 		optgroup = page->new_optgroup("Support material");
+// 		$optgroup->append_single_option_line("support_material");
+// 		$optgroup->append_single_option_line("support_material_threshold");
+// 		$optgroup->append_single_option_line("support_material_enforce_layers");
+// 	}
+// 	{
+ 		optgroup = page->new_optgroup("Raft");
+// 		$optgroup->append_single_option_line("raft_layers");
+// 		#            $optgroup->append_single_option_line("raft_contact_distance");
+// 	}
+// 	{
+ 		optgroup = page->new_optgroup("Options for support material and raft");
+// 		$optgroup->append_single_option_line("support_material_contact_distance");
+// 		$optgroup->append_single_option_line("support_material_pattern");
+// 		$optgroup->append_single_option_line("support_material_with_sheath");
+// 		$optgroup->append_single_option_line("support_material_spacing");
+// 		$optgroup->append_single_option_line("support_material_angle");
+// 		$optgroup->append_single_option_line("support_material_interface_layers");
+// 		$optgroup->append_single_option_line("support_material_interface_spacing");
+// 		$optgroup->append_single_option_line("support_material_interface_contact_loops");
+// 		$optgroup->append_single_option_line("support_material_buildplate_only");
+// 		$optgroup->append_single_option_line("support_material_xy_spacing");
+// 		$optgroup->append_single_option_line("dont_support_bridges");
+// 		$optgroup->append_single_option_line("support_material_synchronize_layers");
+// 	}
+
+	page = add_options_page("Speed", "time.png");
+	page->set_config(&config_);
+// 	{
+ 		optgroup = page->new_optgroup("Speed for print moves");
+// 		$optgroup->append_single_option_line("perimeter_speed");
+// 		$optgroup->append_single_option_line("small_perimeter_speed");
+// 		$optgroup->append_single_option_line("external_perimeter_speed");
+// 		$optgroup->append_single_option_line("infill_speed");
+// 		$optgroup->append_single_option_line("solid_infill_speed");
+// 		$optgroup->append_single_option_line("top_solid_infill_speed");
+// 		$optgroup->append_single_option_line("support_material_speed");
+// 		$optgroup->append_single_option_line("support_material_interface_speed");
+// 		$optgroup->append_single_option_line("bridge_speed");
+// 		$optgroup->append_single_option_line("gap_fill_speed");
+// 	}
+// 	{
+ 		optgroup = page->new_optgroup("Speed for non-print moves");
+// 		$optgroup->append_single_option_line("travel_speed");
+// 	}
+// 	{
+		optgroup = page->new_optgroup("Modifiers");
+// 		$optgroup->append_single_option_line("first_layer_speed");
+// 	}
+// 	{
+ 		optgroup = page->new_optgroup("Acceleration control (advanced)");
+// 		$optgroup->append_single_option_line("perimeter_acceleration");
+// 		$optgroup->append_single_option_line("infill_acceleration");
+// 		$optgroup->append_single_option_line("bridge_acceleration");
+// 		$optgroup->append_single_option_line("first_layer_acceleration");
+// 		$optgroup->append_single_option_line("default_acceleration");
+// 	}
+// 	{
+		optgroup = page->new_optgroup("Autospeed (advanced)");
+// 		$optgroup->append_single_option_line("max_print_speed");
+// 		$optgroup->append_single_option_line("max_volumetric_speed");
+// 		$optgroup->append_single_option_line("max_volumetric_extrusion_rate_slope_positive");
+// 		$optgroup->append_single_option_line("max_volumetric_extrusion_rate_slope_negative");
+// 	}
+
+	page = add_options_page("Multiple Extruders", "funnel.png");
+	page->set_config(&config_);
+// 	{
+		optgroup = page->new_optgroup("Extruders");
+// 		$optgroup->append_single_option_line("perimeter_extruder");
+// 		$optgroup->append_single_option_line("infill_extruder");
+// 		$optgroup->append_single_option_line("solid_infill_extruder");
+// 		$optgroup->append_single_option_line("support_material_extruder");
+// 		$optgroup->append_single_option_line("support_material_interface_extruder");
+// 	}
+// 	{
+ 		optgroup = page->new_optgroup("Ooze prevention");
+// 		$optgroup->append_single_option_line("ooze_prevention");
+// 		$optgroup->append_single_option_line("standby_temperature_delta");
+// 	}
+// 	{
+ 		optgroup = page->new_optgroup("Wipe tower");
+// 		$optgroup->append_single_option_line("wipe_tower");
+// 		$optgroup->append_single_option_line("wipe_tower_x");
+// 		$optgroup->append_single_option_line("wipe_tower_y");
+// 		$optgroup->append_single_option_line("wipe_tower_width");
+// 		$optgroup->append_single_option_line("wipe_tower_per_color_wipe");
+// 	}
+// 	{
+ 		optgroup = page->new_optgroup("Advanced");
+// 		$optgroup->append_single_option_line("interface_shells");
+// 	}
+
+	page = add_options_page("Advanced", "wrench.png");
+	page->set_config(&config_);
+// 	{
+		optgroup = page->new_optgroup("Extrusion width", 180);
+// 		$optgroup->append_single_option_line("extrusion_width");
+// 		$optgroup->append_single_option_line("first_layer_extrusion_width");
+// 		$optgroup->append_single_option_line("perimeter_extrusion_width");
+// 		$optgroup->append_single_option_line("external_perimeter_extrusion_width");
+// 		$optgroup->append_single_option_line("infill_extrusion_width");
+// 		$optgroup->append_single_option_line("solid_infill_extrusion_width");
+// 		$optgroup->append_single_option_line("top_infill_extrusion_width");
+// 		$optgroup->append_single_option_line("support_material_extrusion_width");
+// 	}
+// 	{
+ 		optgroup = page->new_optgroup("Overlap");
+// 		$optgroup->append_single_option_line("infill_overlap");
+// 	}
+// 	{
+		optgroup = page->new_optgroup("Flow");
+// 		$optgroup->append_single_option_line("bridge_flow_ratio");
+// 	}
+// 	{
+ 		optgroup = page->new_optgroup("Other");
+// 		$optgroup->append_single_option_line("clip_multipart_objects");
+// 		$optgroup->append_single_option_line("elefant_foot_compensation");
+// 		$optgroup->append_single_option_line("xy_size_compensation");
+// 		#            $optgroup->append_single_option_line("threads");
+// 		$optgroup->append_single_option_line("resolution");
+// 	}
+
+	page = add_options_page("Output options", "page_white_go.png");
+	page->set_config(&config_);
+// 	{
+ 		optgroup = page->new_optgroup("Sequential printing");
+// 		$optgroup->append_single_option_line("complete_objects");
+// 		my $line = Slic3r::GUI::OptionsGroup::Line->new(
+// 			label = > "Extruder clearance (mm)",
+// 			);
+// 		foreach my $opt_key(qw(extruder_clearance_radius extruder_clearance_height)) {
+// 			my $option = $optgroup->get_option($opt_key);
+// 			$option->width(60);
+// 			$line->append_option($option);
+// 		}
+// 		$optgroup->append_line($line);
+// 	}
+// 	{
+ 		optgroup = page->new_optgroup("Output file");
+// 		$optgroup->append_single_option_line("gcode_comments");
+// 
+// 		{
+// 			my $option = $optgroup->get_option("output_filename_format");
+// 			$option->full_width(1);
+// 			$optgroup->append_single_option_line($option);
+// 		}
+// 	}
+// 	{
+		optgroup = page->new_optgroup("Post-processing scripts");
+// 			label_width = > 0,
+// 			);
+// 		my $option = $optgroup->get_option("post_process");
+// 		$option->full_width(1);
+// 		$option->height(50);
+// 		$optgroup->append_single_option_line($option);
+// 	}
+
+	page = add_options_page("Notes", "note.png");
+	page->set_config(&config_);
+// 	{
+	optgroup = page->new_optgroup("Notes");	//label_width = > 0,
+// 		my $option = $optgroup->get_option("notes");
+// 		$option->full_width(1);
+// 		$option->height(250);
+// 		$optgroup->append_single_option_line($option);
+// 	}
+
+	page = add_options_page("Dependencies", "wrench.png");
+	page->set_config(&config_);
+// 	{
+ 		optgroup = page->new_optgroup("Profile dependencies");
+// 		{
+// 			my $line = Slic3r::GUI::OptionsGroup::Line->new(
+// 				label = > "Compatible printers",
+// 				widget = > $self->_compatible_printers_widget,
+// 				);
+// 			$optgroup->append_line($line);
+// 		}
+// 	}
+}
+
+
+//Regerenerate content of the page tree.
+void CTab::rebuild_page_tree()
+{
+	Freeze();
+	// get label of the currently selected item
+	auto selected = treectrl_->GetItemText(treectrl_->GetSelection());
+	auto rootItem = treectrl_->GetRootItem();
+	treectrl_->DeleteChildren(rootItem);
+	auto have_selection = 0;
+	for (auto p : pages_)
+	{
+		auto itemId = treectrl_->AppendItem(rootItem, p->title(), p->iconID());
+		if (p->title() == selected) {
+			disable_tree_sel_changed_event_ = 1;
+			treectrl_->SelectItem(itemId);
+			disable_tree_sel_changed_event_ = 0;
+			have_selection = 1;
+		}
+	}
+	
+	if (!have_selection) {
+		// this is triggered on first load, so we don't disable the sel change event
+		treectrl_->SelectItem(treectrl_->GetFirstVisibleItem());//! (treectrl->GetFirstChild(rootItem));
+	}
+	Thaw();
+}
+
+void CTab::OnTreeSelChange(wxTreeEvent& event)
+{
+	if (disable_tree_sel_changed_event_) return;
 	CPage* page = nullptr;
-	for (auto& el : pages)
-		if (el.title() == treectrl->GetSelection())
+	auto selection = treectrl_->GetItemText(treectrl_->GetSelection());
+	for (auto p : pages_)
+		if (p->title() == selection)
 		{
-			page = &el;
+			page = p.get();
 			break;
 		}
 	if (page == nullptr) return;
 
-	for (auto& el : pages)
-		el.Hide();
+	for (auto& el : pages_)
+		el.get()->Hide();
 	page->Show();
-	hsizer->Layout();
-	this->Refresh();
-};
+	hsizer_->Layout();
+	Refresh();
+}
 
 void CTab::OnKeyDown(wxKeyEvent& event)
 {
 	event.GetKeyCode() == WXK_TAB ?
-		treectrl->Navigate(event.ShiftDown() ? wxNavigationKeyEvent::IsBackward : wxNavigationKeyEvent::IsForward) :
+		treectrl_->Navigate(event.ShiftDown() ? wxNavigationKeyEvent::IsBackward : wxNavigationKeyEvent::IsForward) :
 		event.Skip();
 };
 
@@ -169,5 +506,27 @@ void CTab::save_preset(wxCommandEvent &event){};
 void CTab::delete_preset(wxCommandEvent &event){};
 void CTab::_toggle_show_hide_incompatible(wxCommandEvent &event){};
 
+// package Slic3r::GUI::Tab::Page;
+ConfigOptionsGroupShp CPage::new_optgroup(std::string title, size_t label_width /*= 0*/)
+{
+	//! config_ have to be "right"
+	ConfigOptionsGroupShp optgroup = std::make_shared<ConfigOptionsGroup>(/*parent()*/this, title, config_);
+	if (label_width != 0)
+		optgroup->label_width = label_width;
+
+//         on_change       => sub {
+//             my ($opt_key, $value) = @_;
+//             wxTheApp->CallAfter(sub {
+//                 $self->GetParent->update_dirty;
+//                 $self->GetParent->_on_value_change($opt_key, $value);
+//             });
+//         },
+
+	vsizer()->Add(optgroup->sizer, 0, wxEXPAND | wxALL, 10);
+	optgroups.push_back(optgroup);
+
+	return optgroup;
+}
+
 } // GUI
 } // Slic3r
diff --git a/xs/src/slic3r/GUI/Tab.h b/xs/src/slic3r/GUI/Tab.h
index 2c60dd556..59a7dd6e7 100644
--- a/xs/src/slic3r/GUI/Tab.h
+++ b/xs/src/slic3r/GUI/Tab.h
@@ -20,89 +20,114 @@
 #include <wx/bmpbuttn.h>
 #include <wx/treectrl.h>
 #include <wx/imaglist.h>
+#include <wx/statbox.h>
 
 #include <map>
 #include <vector>
+#include <memory>
+
+#include "OptionsGroup.hpp"
+
+//!enum { ID_TAB_TREE = wxID_HIGHEST + 1 };
 
 namespace Slic3r {
 namespace GUI {
 
 // Single Tab page containing a{ vsizer } of{ optgroups }
 // package Slic3r::GUI::Tab::Page;
+using ConfigOptionsGroupShp = std::shared_ptr<ConfigOptionsGroup>;
 class CPage : public wxScrolledWindow
 {
-	const char*	_title;
-	wxWindow*	_parent;
-	wxBoxSizer*	_vsizer;
-	size_t		_iconID;
-//	const OptionsGroup opt;  // $self->{optgroups} = [];
+	wxWindow*		parent_;
+	wxString		title_;
+	size_t			iconID_;
+	wxBoxSizer*		vsizer_;
 public:
-	CPage(){};
-	CPage(wxWindow* parent, const char* title, int iconID) :
-			_parent(parent), 
-			_title(title), 
-			_iconID(iconID)
+	CPage(wxWindow* parent, const wxString title, const int iconID) :
+			parent_(parent), 
+			title_(title), 
+			iconID_(iconID)
 	{
-		Create(_parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL);
-		this->SetScrollbars(1, 1, 1, 1);
-		_vsizer = new wxBoxSizer(wxVERTICAL);
-		this->SetSizer(_vsizer);
+		Create(parent_, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL);		
+		vsizer_ = new wxBoxSizer(wxVERTICAL);
+		SetSizer(vsizer_);
 	}
-	~CPage(){};
-	wxBoxSizer * vsizer(){ return this->_vsizer; }	
-	wxString title(){ return wxString(_title); }
+	~CPage(){}
+
+public:
+	std::vector <ConfigOptionsGroupShp> optgroups;  // $self->{optgroups} = [];
+	DynamicPrintConfig* config_;
+
+	wxBoxSizer*	vsizer() const { return vsizer_; }	
+	wxWindow*	parent() const { return parent_; }
+	wxString	title()	 const { return title_; }
+	size_t		iconID() const { return iconID_; }
+	void		set_config(DynamicPrintConfig* config_in) { config_ = config_in; }
+
+	ConfigOptionsGroupShp new_optgroup(std::string title, size_t label_width = 0);
 };
 
 // Slic3r::GUI::Tab;
+
+using CPageShp = std::shared_ptr<CPage>;
 class CTab: public wxPanel
 {
+	wxNotebook*			parent_;
 protected:
-	const char* _title;
-	wxBitmapComboBox*	presets_choice;
-	wxBitmap*	bmp_show_incompatible_presets;
-	wxBitmap*	bmp_hide_incompatible_presets;
-	wxBitmapButton*		btn_hide_incompatible_presets;
-	wxBoxSizer*	hsizer;
-	wxBoxSizer*	left_sizer;
-	wxTreeCtrl*	treectrl;
-	wxImageList*	icons;
-	int			icon_count;
-//	std::map<size_t, wxImageList*> icon_index;
-	std::vector<CPage>	pages;
-	bool	disable_tree_sel_changed_event;
-public:
-	CTab(){};
-	CTab(wxNotebook* parent, const char *title/*, someParams*/){}
-	~CTab(){};
-	
-	void create_preset_tab();
-	void OnTreeSelChange(wxCommandEvent& event);
-	void OnKeyDown(wxKeyEvent& event);
-	void OnComboBox(wxCommandEvent& event){ /*$self->select_preset(presets_choice->GetStringSelection)*/ };
-	void save_preset(wxCommandEvent &event);
-	void delete_preset(wxCommandEvent &event);
-	void _toggle_show_hide_incompatible(wxCommandEvent &event);
+	const char*			title_;
+	wxBitmapComboBox*	presets_choice_;
+	wxBitmapButton*		btn_save_preset_;
+	wxBitmapButton*		btn_delete_preset_;
+	wxBitmap*			bmp_show_incompatible_presets_;
+	wxBitmap*			bmp_hide_incompatible_presets_;
+	wxBitmapButton*		btn_hide_incompatible_presets_;
+	wxBoxSizer*			hsizer_;
+	wxBoxSizer*			left_sizer_;
+	wxTreeCtrl*			treectrl_;
+	wxImageList*		icons_;
+	int					icon_count;
+	std::map<wxString, size_t>				icon_index_;		// Map from an icon file name to its index in $self->{icons}.
+	std::vector<CPageShp>		pages_;	// $self->{pages} = [];
+	bool				disable_tree_sel_changed_event_;
 
-//	virtual void build(/*%params*/);
-//	virtual void rebuild_page_tree();
+public:
+	DynamicPrintConfig config_;
+
+public:
+	CTab() {}
+	CTab(wxNotebook* parent, const char *title) : parent_(parent), title_(title) { 
+		Create(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxBK_LEFT | wxTAB_TRAVERSAL);
+	}
+	~CTab(){}
+
+	wxWindow*	parent() const { return parent_; }
+	
+	void		create_preset_tab();
+	void		rebuild_page_tree();
+	void		select_preset(wxString preset_name){};
+
+	void		OnTreeSelChange(wxTreeEvent& event);
+	void		OnKeyDown(wxKeyEvent& event);
+	void		OnComboBox(wxCommandEvent& event) { select_preset(presets_choice_->GetStringSelection()); 	}
+	void		save_preset(wxCommandEvent &event);
+	void		delete_preset(wxCommandEvent &event);
+	void		_toggle_show_hide_incompatible(wxCommandEvent &event);
+
+	std::shared_ptr<CPage> add_options_page(wxString title, wxString icon);
+
+	virtual void build() = 0;
 //	virtual void _update();
-private:
-//	DECLARE_EVENT_TABLE()
 };
 
 //Slic3r::GUI::Tab::Print;
 class CTabPrint : public CTab
 {
 public:
-	CTabPrint() {};
-	CTabPrint(wxNotebook* parent, const char *title/*, someParams*/)
-	{
-		_title = title;
-		Create(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxBK_LEFT | wxTAB_TRAVERSAL);
-		create_preset_tab();
-	}
-	~CTabPrint(){};
-//	void  build(/*%params*/){};
+	CTabPrint() {}
+	CTabPrint(wxNotebook* parent, const char *title/*, someParams*/) : CTab(parent, title) {}
+	~CTabPrint(){}
+
+	void  build() override;
 };
 
 } // GUI
diff --git a/xs/src/slic3r/GUI/Widget.hpp b/xs/src/slic3r/GUI/Widget.hpp
index 6c3da1393..bcf772469 100644
--- a/xs/src/slic3r/GUI/Widget.hpp
+++ b/xs/src/slic3r/GUI/Widget.hpp
@@ -1,6 +1,10 @@
 #ifndef WIDGET_HPP
 #define WIDGET_HPP
-#include "wxinit.h"
+#include <wx/wxprec.h>
+#ifndef WX_PRECOM
+#include <wx/wx.h>
+#endif
+
 class Widget {
 protected:
     wxSizer* _sizer;