Menu_bar and preset_tabs are in main window now

src/slic3r/GUI/GUI.cpp

@@ -128,9 +128,10 @@ wxColour    g_color_label_modified;
 wxColour    g_color_label_sys;
 wxColour    g_color_label_default;
 
+// #ys_FIXME_for_delete
 std::vector<Tab *> g_tabs_list;
 
-wxLocale*	g_wxLocale;
+wxLocale*	g_wxLocale {nullptr};
 
 wxFont		g_small_font;
 wxFont		g_bold_font;
@@ -346,6 +347,11 @@ bool select_language(wxArrayString & names,
 	return false;
 }
 
+wxLocale* get_locale() {
+    return g_wxLocale;
+}
+
+// #ys_FIXME_for_delete
 bool load_language()
 {
 	wxString language = wxEmptyString;
@@ -429,6 +435,7 @@ enum ConfigMenuIDs {
 	ConfigMenuCnt,
 };
 
+// #ys_FIXME_for_delete	
 ConfigMenuIDs get_view_mode()
 {
 	if (!g_AppConfig->has("view_mode"))
@@ -439,7 +446,7 @@ ConfigMenuIDs get_view_mode()
 }
 
 static wxString dots("…", wxConvUTF8);
-
+// #ys_FIXME_for_delete
 void add_config_menu(wxMenuBar *menu, int event_preferences_changed, int event_language_change)
 {
     auto local_menu = new wxMenu();
@@ -560,6 +567,7 @@ void open_model(wxWindow *parent, wxArrayString& input_files){
 
 // This is called when closing the application, when loading a config file or when starting the config wizard
 // to notify the user whether he is aware that some preset changes will be lost.
+// #ys_FIXME_for_delete
 bool check_unsaved_changes()
 {
 	std::string dirty;
@@ -636,8 +644,8 @@ std::vector<PresetTab> preset_tabs = {
     { "filament",     nullptr, ptFFF },
     { "sla_material", nullptr, ptSLA }
 };
-const std::vector<PresetTab>& get_preset_tabs() {
+std::vector<PresetTab>* get_preset_tabs() {
-    return preset_tabs;
+    return &preset_tabs;
 }
 
 Tab* get_tab(const std::string& name)
@@ -781,7 +789,7 @@ void change_opt_value(DynamicPrintConfig& config, const t_config_option_key& opt
 		int i = 0;//no reason, just experiment
 	}
 }
-
+// #ys_FIXME_for_delete
 void add_created_tab(Tab* panel, int event_value_change, int event_presets_changed)
 {
 	panel->create_preset_tab(g_PresetBundle);
@@ -1212,7 +1220,7 @@ bool is_expert_mode(){
 
 ConfigOptionsGroup* get_optgroup(size_t i)
 {
-	return m_optgroups[i].get();
+	return m_optgroups.empty() ? nullptr : m_optgroups[i].get();
 }
 
 std::vector <std::shared_ptr<ConfigOptionsGroup>>& get_optgroups() {

src/slic3r/GUI/GUI.hpp

@@ -146,7 +146,7 @@ wxWindow*			get_right_panel();
 const size_t&		label_width();
 
 Tab*         get_tab(const std::string& name);
-const std::vector<PresetTab>& get_preset_tabs();
+std::vector<PresetTab>* get_preset_tabs();
 
 extern void add_menus(wxMenuBar *menu, int event_preferences_changed, int event_language_change);
 
@@ -189,6 +189,7 @@ void warning_catcher(wxWindow* parent, const wxString& message);
 void set_print_callback_event(Print *print, int id);
 
 // load language saved at application config 
+wxLocale* get_locale();
 bool load_language();
 // save language at application config 
 void save_language();

src/slic3r/GUI/GUI_App.cpp

@@ -18,56 +18,68 @@
 #include "3DScene.hpp"
 
 #include "../Utils/PresetUpdater.hpp"
+#include "ConfigWizard_private.hpp"
+#include "slic3r/Config/Snapshot.hpp"
+#include "ConfigSnapshotDialog.hpp"
+#include "FirmwareDialog.hpp"
+#include "Preferences.hpp"
+#include "Tab.hpp"
 
 namespace Slic3r {
 namespace GUI {
 
-// IMPLEMENT_APP(GUI_App)
+IMPLEMENT_APP(GUI_App)
 bool GUI_App::OnInit()
 {
     SetAppName("Slic3rPE");
     SetAppDisplayName("Slic3r Prusa Edition");
 
-    //     Slic3r::debugf "wxWidgets version %s, Wx version %s\n", &Wx::wxVERSION_STRING, $Wx::VERSION;
+//     Slic3r::debugf "wxWidgets version %s, Wx version %s\n", wxVERSION_STRING, wxVERSION;
-    // 
+
     // Set the Slic3r data directory at the Slic3r XS module.
     // Unix: ~/ .Slic3r
     // Windows : "C:\Users\username\AppData\Roaming\Slic3r" or "C:\Documents and Settings\username\Application Data\Slic3r"
     // Mac : "~/Library/Application Support/Slic3r"
-//     datadir.empty() ?
+    datadir.empty() ?
-//         Slic3r::set_data_dir(wxStandardPaths::Get().GetUserDataDir().ToStdString()) :
+        Slic3r::set_data_dir(wxStandardPaths::Get().GetUserDataDir().ToStdString()) :
-//         Slic3r::set_data_dir(datadir);
+        Slic3r::set_data_dir(datadir);
     //     set_wxapp(this); // #ys_FIXME
 
-//     app_config = new AppConfig();
+    // #ys_FIXME temporary workaround 
+    if (var_dir().empty())
+        set_var_dir("c:\\src\\Slic3r_TMP\\resources\\icons");
+    if (localization_dir().empty())
+        set_local_dir("c:\\src\\Slic3r_TMP\\resources\\localization");
+
+    app_config = new AppConfig();
     //     set_app_config(app_config);// #ys_FIXME
-//     preset_bundle = new PresetBundle();
+    preset_bundle = new PresetBundle();
     //     set_preset_bundle(preset_bundle);// #ys_FIXME
 
     // just checking for existence of Slic3r::data_dir is not enough : it may be an empty directory
     // supplied as argument to --datadir; in that case we should still run the wizard
     //     eval{ 
-//     preset_bundle->setup_directories();
+    preset_bundle->setup_directories();
     //     };
     //     if ($@) {
     //         warn $@ . "\n";
     //         fatal_error(undef, $@);
     //     }
-//     app_conf_exists = app_config->exists();
+    app_conf_exists = app_config->exists();
     // load settings
-//     if (app_conf_exists) app_config->load();
+    if (app_conf_exists) app_config->load();
-    //     app_config->set("version", Slic3r::VERSION);
+    app_config->set("version", "Slic3r_VERSION"/*Slic3r::VERSION*/);
-//     app_config->save();
+    app_config->save();
 
-//     preset_updater = new PresetUpdater(VERSION_ONLINE_EVENT);
+//     preset_updater = new PresetUpdater();
-    //     set_preset_updater(preset_updater); // #ys_FIXME
+//     set_preset_updater(preset_updater); // #ys_FIXME
 
-//     Slic3r::GUI::load_language();
+    load_language();
 
     // Suppress the '- default -' presets.
-//     preset_bundle->set_default_suppressed(app_config->get("no_defaults").empty() ? false : true);
+    preset_bundle->set_default_suppressed(app_config->get("no_defaults").empty() ? false : true);
     //     eval{ 
-//     preset_bundle->load_presets(*app_config);
+    preset_bundle->load_presets(*app_config);
     //     };
     //     if ($@) {
     //         warn $@ . "\n";
@@ -133,12 +145,6 @@ bool GUI_App::OnInit()
 // 
 
     // #ys_FIXME All of this should to be removed
-    //     # The following event is emited by the C++ menu implementation of application language change.
-    //     EVT_COMMAND($self, -1, $LANGUAGE_CHANGE_EVENT, sub{
-    //         print STDERR "LANGUAGE_CHANGE_EVENT\n";
-    //         $self->recreate_GUI;
-    //     });
-    // 
     //     # The following event is emited by the C++ menu implementation of preferences change.
     //     EVT_COMMAND($self, -1, $PREFERENCES_EVENT, sub{
     //         $self->update_ui_from_settings;
@@ -154,7 +160,6 @@ bool GUI_App::OnInit()
     //     });
 
     mainframe->Show(true);
-
     return true;
 }
 
@@ -249,13 +254,13 @@ void GUI_App::CallAfter(std::function<void()> cb)
     callback_register.unlock();
 }
 
-wxMenuItem* GUI_App::append_menu_item(wxMenu* menu,
+wxMenuItem* GUI_App::append_menu_item(  wxMenu* menu,
-    int id,
+                                        int id,
-    const wxString& string,
+                                        const wxString& string,
-    const wxString& description,
+                                        const wxString& description,
-    const std::string& icon,
+                                        const std::string& icon,
-    std::function<void(wxCommandEvent& event)> cb,
+                                        std::function<void(wxCommandEvent& event)> cb,
-    wxItemKind kind/* = wxITEM_NORMAL*/)
+                                        wxItemKind kind/* = wxITEM_NORMAL*/)
 {
     if (id == wxID_ANY)
         id = wxNewId();
@@ -322,6 +327,182 @@ void GUI_App::restore_window_pos(wxTopLevelWindow* window, const std::string& na
         window->Maximize();
 }
 
+bool GUI_App::load_language()
+{
+    wxString language = wxEmptyString;
+    if (app_config->has("translation_language"))
+        language = app_config->get("translation_language");
+
+    if (language.IsEmpty())
+        return false;
+    wxArrayString	names;
+    wxArrayLong		identifiers;
+    get_installed_languages(names, identifiers);
+    for (size_t i = 0; i < identifiers.Count(); i++)
+    {
+        if (wxLocale::GetLanguageCanonicalName(identifiers[i]) == language)
+        {
+            auto locale = get_locale();
+            locale = new wxLocale;
+            locale->Init(identifiers[i]);
+            locale->AddCatalogLookupPathPrefix(wxPathOnly(localization_dir()));
+            locale->AddCatalog(GetAppName());
+            wxSetlocale(LC_NUMERIC, "C");
+            Preset::update_suffix_modified();
+            return true;
+        }
+    }
+    return false;
+}
+
+ConfigMenuIDs GUI_App::get_view_mode()
+{
+    if (!app_config->has("view_mode"))
+        return ConfigMenuModeSimple;
+
+    const auto mode = app_config->get("view_mode");
+    return mode == "expert" ? ConfigMenuModeExpert : ConfigMenuModeSimple;
+}
+
+static wxString dots("…", wxConvUTF8);
+
+void GUI_App::add_config_menu(wxMenuBar *menu)
+{
+    auto local_menu = new wxMenu();
+    wxWindowID config_id_base = wxWindow::NewControlId((int)ConfigMenuCnt);
+
+    const auto config_wizard_name = _(ConfigWizard::name().wx_str());
+    const auto config_wizard_tooltip = wxString::Format(_(L("Run %s")), config_wizard_name);
+    // Cmd+, is standard on OS X - what about other operating systems?
+    local_menu->Append(config_id_base + ConfigMenuWizard, config_wizard_name + dots, config_wizard_tooltip);
+    local_menu->Append(config_id_base + ConfigMenuSnapshots, _(L("Configuration Snapshots")) + dots, _(L("Inspect / activate configuration snapshots")));
+    local_menu->Append(config_id_base + ConfigMenuTakeSnapshot, _(L("Take Configuration Snapshot")), _(L("Capture a configuration snapshot")));
+    // 	local_menu->Append(config_id_base + ConfigMenuUpdate, 		_(L("Check for updates")), 					_(L("Check for configuration updates")));
+    local_menu->AppendSeparator();
+    local_menu->Append(config_id_base + ConfigMenuPreferences, _(L("Preferences")) + dots + "\tCtrl+,", _(L("Application preferences")));
+    local_menu->AppendSeparator();
+    auto mode_menu = new wxMenu();
+    mode_menu->AppendRadioItem(config_id_base + ConfigMenuModeSimple, _(L("&Simple")), _(L("Simple View Mode")));
+    mode_menu->AppendRadioItem(config_id_base + ConfigMenuModeExpert, _(L("&Expert")), _(L("Expert View Mode")));
+    mode_menu->Check(config_id_base + get_view_mode(), true);
+    local_menu->AppendSubMenu(mode_menu, _(L("&Mode")), _(L("Slic3r View Mode")));
+    local_menu->AppendSeparator();
+    local_menu->Append(config_id_base + ConfigMenuLanguage, _(L("Change Application Language")));
+    local_menu->AppendSeparator();
+    local_menu->Append(config_id_base + ConfigMenuFlashFirmware, _(L("Flash printer firmware")), _(L("Upload a firmware image into an Arduino based printer")));
+    // TODO: for when we're able to flash dictionaries
+    // local_menu->Append(config_id_base + FirmwareMenuDict,  _(L("Flash language file")),    _(L("Upload a language dictionary file into a Prusa printer")));
+
+    local_menu->Bind(wxEVT_MENU, [this, config_id_base](wxEvent &event){
+        switch (event.GetId() - config_id_base) {
+        case ConfigMenuWizard:
+            config_wizard(ConfigWizard::RR_USER);
+            break;
+        case ConfigMenuTakeSnapshot:
+            // Take a configuration snapshot.
+            if (check_unsaved_changes()) {
+                wxTextEntryDialog dlg(nullptr, _(L("Taking configuration snapshot")), _(L("Snapshot name")));
+                if (dlg.ShowModal() == wxID_OK)
+                    app_config->set("on_snapshot",
+                    Slic3r::GUI::Config::SnapshotDB::singleton().take_snapshot(
+                    *app_config, Slic3r::GUI::Config::Snapshot::SNAPSHOT_USER, dlg.GetValue().ToUTF8().data()).id);
+            }
+            break;
+        case ConfigMenuSnapshots:
+            if (check_unsaved_changes()) {
+                std::string on_snapshot;
+                if (Config::SnapshotDB::singleton().is_on_snapshot(*app_config))
+                    on_snapshot = app_config->get("on_snapshot");
+                ConfigSnapshotDialog dlg(Slic3r::GUI::Config::SnapshotDB::singleton(), on_snapshot);
+                dlg.ShowModal();
+                if (!dlg.snapshot_to_activate().empty()) {
+                    if (!Config::SnapshotDB::singleton().is_on_snapshot(*app_config))
+                        Config::SnapshotDB::singleton().take_snapshot(*app_config, Config::Snapshot::SNAPSHOT_BEFORE_ROLLBACK);
+                    app_config->set("on_snapshot",
+                        Config::SnapshotDB::singleton().restore_snapshot(dlg.snapshot_to_activate(), *app_config).id);
+                    preset_bundle->load_presets(*app_config);
+                    // Load the currently selected preset into the GUI, update the preset selection box.
+                    load_current_presets();
+                }
+            }
+            break;
+        case ConfigMenuPreferences:
+        {
+//             PreferencesDialog dlg(mainframe, event_preferences_changed);
+//             dlg.ShowModal();
+            break;
+        }
+        case ConfigMenuLanguage:
+        {
+            wxArrayString names;
+            wxArrayLong identifiers;
+            get_installed_languages(names, identifiers);
+            if (select_language(names, identifiers)) {
+                save_language();
+                show_info(mainframe->m_tabpanel, _(L("Application will be restarted")), _(L("Attention!")));
+                _3DScene::remove_all_canvases();// remove all canvas before recreate GUI
+                recreate_GUI();
+            }
+            break;
+        }
+        case ConfigMenuFlashFirmware:
+            FirmwareDialog::run(mainframe);
+            break;
+        default:
+            break;
+        }
+    });
+    mode_menu->Bind(wxEVT_MENU, [this, config_id_base](wxEvent& event) {
+        std::string mode = event.GetId() - config_id_base == ConfigMenuModeExpert ?
+            "expert" : "simple";
+        app_config->set("view_mode", mode);
+        app_config->save();
+        update_mode();
+    });
+    menu->Append(local_menu, _(L("&Configuration")));
+}
+
+// This is called when closing the application, when loading a config file or when starting the config wizard
+// to notify the user whether he is aware that some preset changes will be lost.
+bool GUI_App::check_unsaved_changes()
+{
+    std::string dirty;
+    for (Tab *tab : tabs_list)
+        if (tab->current_preset_is_dirty())
+            if (dirty.empty())
+                dirty = tab->name();
+            else
+                dirty += std::string(", ") + tab->name();
+    if (dirty.empty())
+        // No changes, the application may close or reload presets.
+        return true;
+    // Ask the user.
+    auto dialog = new wxMessageDialog(mainframe,
+        _(L("You have unsaved changes ")) + dirty + _(L(". Discard changes and continue anyway?")),
+        _(L("Unsaved Presets")),
+        wxICON_QUESTION | wxYES_NO | wxNO_DEFAULT);
+    return dialog->ShowModal() == wxID_YES;
+}
+
+wxNotebook* GUI_App::tab_panel() const 
+{
+    return mainframe->m_tabpanel;
+}
+
+// std::vector<PresetTab>  preset_tabs = {
+//     { "print", nullptr, ptFFF },
+//     { "filament", nullptr, ptFFF },
+//     { "sla_material", nullptr, ptSLA }
+// };
+// 
+// Tab* GUI_App::get_tab(const std::string& name)
+// {
+//     std::vector<PresetTab>::iterator it = std::find_if(preset_tabs.begin(), preset_tabs.end(),
+//         [name](PresetTab& tab){ return name == tab.name; });
+//     return it != preset_tabs.end() ? it->panel : nullptr;
+// }
+
+
 // static method accepting a wxWindow object as first parameter
 // void warning_catcher{
 //     my($self, $message_dialog) = @_;

src/slic3r/GUI/GUI_App.hpp

@@ -3,7 +3,7 @@
 
 #include <string>
 // #include <vector>
-// #include "PrintConfig.hpp"
+#include "PrintConfig.hpp"
 // #include "../../libslic3r/Utils.hpp"
 // #include "GUI.hpp"
 
@@ -13,7 +13,9 @@
 #include <stack>
 
 class wxMenuItem;
+class wxMenuBar;
 class wxTopLevelWindow;
+class wxNotebook;
 
 namespace Slic3r {
 class AppConfig;
@@ -22,7 +24,21 @@ class PresetUpdater;
 
 namespace GUI
 {
+enum ConfigMenuIDs {
+    ConfigMenuWizard,
+    ConfigMenuSnapshots,
+    ConfigMenuTakeSnapshot,
+    ConfigMenuUpdate,
+    ConfigMenuPreferences,
+    ConfigMenuModeSimple,
+    ConfigMenuModeExpert,
+    ConfigMenuLanguage,
+    ConfigMenuFlashFirmware,
+    ConfigMenuCnt,
+};
+
 class MainFrame;
+class Tab;
 
 class GUI_App : public wxApp
 {
@@ -64,13 +80,23 @@ public:
                                     const std::string& icon);
     void            save_window_pos(wxTopLevelWindow* window, const std::string& name);
     void            restore_window_pos(wxTopLevelWindow* window, const std::string& name);
+    bool            load_language();
+    ConfigMenuIDs   get_view_mode();
+    void            add_config_menu(wxMenuBar *menu);
+    bool            check_unsaved_changes();
+    //     Tab*            get_tab(const std::string& name);
 
     AppConfig*      app_config{ nullptr };
     PresetBundle*   preset_bundle{ nullptr };
     PresetUpdater*  preset_updater{ nullptr };
     MainFrame*      mainframe{ nullptr };
+
+    wxNotebook*     tab_panel() const ;
+
+    std::vector<Tab *>      tabs_list;
+
 };
-// DECLARE_APP(GUI_App)
+DECLARE_APP(GUI_App)
 
 } // GUI
 } //Slic3r

src/slic3r/GUI/GUI_ObjectParts.cpp

@@ -15,6 +15,7 @@
 
 #include <wx/glcanvas.h>
 #include "3DScene.hpp"
+#include "GUI_App.hpp"
 
 namespace Slic3r
 {
@@ -103,8 +104,8 @@ void get_options_menu(settings_menu_hierarchy& settings_menu, bool is_part)
 {
 	auto options = get_options(is_part);
 
-    auto extruders_cnt = get_preset_bundle()->printers.get_selected_preset().printer_technology() == ptSLA ? 1 :
+    auto extruders_cnt = wxGetApp().preset_bundle->printers.get_selected_preset().printer_technology() == ptSLA ? 1 :
-                         get_preset_bundle()->printers.get_edited_preset().config.option<ConfigOptionFloats>("nozzle_diameter")->values.size();
+                         wxGetApp().preset_bundle->printers.get_edited_preset().config.option<ConfigOptionFloats>("nozzle_diameter")->values.size();
 
 	DynamicPrintConfig config;
 	for (auto& option : options)
@@ -398,7 +399,7 @@ void update_after_moving()
 
 wxSizer* object_movers(wxWindow *win)
 {
-// 	DynamicPrintConfig* config = &get_preset_bundle()->/*full_config();//*/printers.get_edited_preset().config; // TODO get config from Model_volume
+// 	DynamicPrintConfig* config = &wxGetApp().preset_bundle->/*full_config();//*/printers.get_edited_preset().config; // TODO get config from Model_volume
 	std::shared_ptr<ConfigOptionsGroup> optgroup = std::make_shared<ConfigOptionsGroup>(win, "Move"/*, config*/);
 	optgroup->label_width = 20;
 	optgroup->m_on_change = [](t_config_option_key opt_key, boost::any value){
@@ -453,7 +454,7 @@ wxSizer* object_movers(wxWindow *win)
 
 wxBoxSizer* content_settings(wxWindow *win)
 {
-	DynamicPrintConfig* config = &get_preset_bundle()->/*full_config();//*/printers.get_edited_preset().config; // TODO get config from Model_volume
+	DynamicPrintConfig* config = &wxGetApp().preset_bundle->/*full_config();//*/printers.get_edited_preset().config; // TODO get config from Model_volume
 	std::shared_ptr<ConfigOptionsGroup> optgroup = std::make_shared<ConfigOptionsGroup>(win, "Extruders", config);
 	optgroup->label_width = label_width();
 
@@ -915,8 +916,8 @@ void update_settings_list()
         std::vector<std::string> categories;
         if (!(opt_keys.size() == 1 && opt_keys[0] == "extruder"))// return;
         {
-            auto extruders_cnt = get_preset_bundle()->printers.get_selected_preset().printer_technology() == ptSLA ? 1 :
+            auto extruders_cnt = wxGetApp().preset_bundle->printers.get_selected_preset().printer_technology() == ptSLA ? 1 :
-                get_preset_bundle()->printers.get_edited_preset().config.option<ConfigOptionFloats>("nozzle_diameter")->values.size();
+                wxGetApp().preset_bundle->printers.get_edited_preset().config.option<ConfigOptionFloats>("nozzle_diameter")->values.size();
 
             for (auto& opt_key : opt_keys) {
                 auto category = (*m_config)->def()->get(opt_key)->category;
@@ -1461,7 +1462,7 @@ void on_btn_split(const bool split_part)
 		return;
     ModelVolume* volume;
     if (!get_volume_by_item(split_part, item, volume)) return;
-    DynamicPrintConfig&	config = get_preset_bundle()->printers.get_edited_preset().config;
+    DynamicPrintConfig&	config = wxGetApp().preset_bundle->printers.get_edited_preset().config;
     const auto nozzle_dmrs_cnt = config.option<ConfigOptionFloats>("nozzle_diameter")->values.size();
     if (volume->split(nozzle_dmrs_cnt) == 1) {
         wxMessageBox(_(L("The selected object couldn't be split because it contains only one part.")));
@@ -1916,7 +1917,8 @@ void on_drop(wxDataViewEvent &event)
 
 void update_objects_list_extruder_column(int extruders_count)
 {
-    if (get_preset_bundle()->printers.get_selected_preset().printer_technology() == ptSLA)
+    if (!m_objects_ctrl) return; // #ys_FIXME
+    if (wxGetApp().preset_bundle->printers.get_selected_preset().printer_technology() == ptSLA)
         extruders_count = 1;
 
     // delete old 3rd column

src/slic3r/GUI/MainFrame.cpp

@@ -18,17 +18,20 @@
 
 #include <fstream>
 #include <boost/geometry/strategies/spherical/compare_circular.hpp>
+#include "GUI_App.hpp"
 
 namespace Slic3r {
-namespace GUI
+namespace GUI {
-{
+
+static wxString dots("…", wxConvUTF8);
+
 MainFrame::MainFrame(const bool no_plater, const bool loaded) :
 wxFrame(NULL, wxID_ANY, "FORK_NAME-VERSION", wxDefaultPosition, wxDefaultSize, wxDEFAULT_FRAME_STYLE),
         m_no_plater(no_plater),
         m_loaded(loaded)
 {
 //     Slic3r::GUI::set_main_frame(this);
-//     m_appController = new Slic3r::AppController();
+    m_appController = new Slic3r::AppController();
 
 // #if _WIN32
 //     // Load the icon either from the exe, or from the ico file.
@@ -36,73 +39,68 @@ wxFrame(NULL, wxID_ANY, "FORK_NAME-VERSION", wxDefaultPosition, wxDefaultSize, w
 //         auto iconfile = Slic3r::var("Slic3r.ico");// unless - f iconfile;
 //     SetIcon(wxIcon(iconfile, wxBITMAP_TYPE_ICO));
 // #else
-//     SetIcon(wxIcon(Slic3r::var("Slic3r_128px.png"), wxBITMAP_TYPE_PNG));
+    SetIcon(wxIcon(Slic3r::var("Slic3r_128px.png"), wxBITMAP_TYPE_PNG));
-    SetIcon(wxIcon("c:\\src\\Slic3r_TMP\\resources\\icons\\Slic3r_128px.png", wxBITMAP_TYPE_PNG));
 // #ifdef // _WIN32
 
     // initialize tabpanel and menubar
-//     init_tabpanel();
+    init_tabpanel();
-//     init_menubar();
+    init_menubar();
 
     // set default tooltip timer in msec
     // SetAutoPop supposedly accepts long integers but some bug doesn't allow for larger values
     // (SetAutoPop is not available on GTK.)
-//     wxToolTip::SetAutoPop(32767);
+    wxToolTip::SetAutoPop(32767);
 
     // initialize status bar
-//     m_statusbar = new Slic3r::GUI::ProgressStatusBar(this);
+    m_statusbar = new Slic3r::GUI::ProgressStatusBar(this);
-//     m_statusbar->embed();
+    m_statusbar->embed(this);
-//     m_statusbar->set_status_text(L("Version ").Slic3r::VERSION.L(" - Remember to check for updates at http://github.com/prusa3d/slic3r/releases"));
+    m_statusbar->set_status_text(_(L("Version ")) + 
+                                 "Slic3r_VERSION" + // Slic3r::VERSION + 
+                                 _(L(" - Remember to check for updates at http://github.com/prusa3d/slic3r/releases")));
     // Make the global status bar and its progress indicator available in C++
-//     m_appController->set_global_progress_indicator(m_statusbar);
+    m_appController->set_global_progress_indicator(m_statusbar);
 
 //     m_appController->set_model(m_plater->model);
 //     m_appController->set_print(m_plater->print);
-// 
 //     m_plater->appController = m_appController;
 
-//     m_loaded = true;
+    m_loaded = true;
-// 
+
-//     // initialize layout
+    // initialize layout
-//     auto sizer = new wxBoxSizer(wxVERTICAL);
+    auto sizer = new wxBoxSizer(wxVERTICAL);
-//     if (m_tabpanel)
+    if (m_tabpanel)
-//         sizer->Add(m_tabpanel, 1, wxEXPAND);
+        sizer->Add(m_tabpanel, 1, wxEXPAND);
-//     sizer->SetSizeHints(this);
+    sizer->SetSizeHints(this);
-//     SetSizer(sizer);
+    SetSizer(sizer);
-//     Fit();
+    Fit();
-//     SetMinSize(wxSize(760, 490));
+    SetMinSize(wxSize(760, 490));
-//     SetSize(GetMinSize());
+    SetSize(GetMinSize());
-// //     wxTheApp->restore_window_pos(this, "main_frame");
+    wxGetApp().restore_window_pos(this, "main_frame");
-//     Show();
+    Show();
-//     Layout();
+    Layout();
 
     // declare events
-//     Bind(wxEVT_CLOSE_WINDOW,  [](wxEvent& event){
+    Bind(wxEVT_CLOSE_WINDOW, [this](wxCloseEvent& event){
-//         if (event.CanVeto() && !Slic3r::GUI::check_unsaved_changes) {
+        if (event.CanVeto() && !wxGetApp().check_unsaved_changes()) {
-//             event.Veto();
+            event.Veto();
-//             return;
+            return;
-//         }
+        }
-//         // save window size
+        // save window size
-//         wxTheApp->save_window_pos(this, "main_frame");
+        wxGetApp().save_window_pos(this, "main_frame");
-//         // Save the slic3r.ini.Usually the ini file is saved from "on idle" callback,
+        // Save the slic3r.ini.Usually the ini file is saved from "on idle" callback,
-//         // but in rare cases it may not have been called yet.
+        // but in rare cases it may not have been called yet.
-//         wxTheApp->{app_config}->save();
+        wxGetApp().app_config->save();
 //         if (m_plater)
 //             m_plater->print = undef;
-//         _3DScene::remove_all_canvases();
+        _3DScene::remove_all_canvases();
 //         Slic3r::GUI::deregister_on_request_update_callback();
-//         // propagate event
+        // propagate event
-//         event.Skip();
+        event.Skip();
-//     });
+    });
 
 //     update_ui_from_settings();
 // 
 //     Slic3r::GUI::update_mode();
-    wxMenu *menuHelp = new wxMenu;
-    menuHelp->Append(wxID_ABOUT);
-    wxMenuBar *menuBar = new wxMenuBar;
-    menuBar->Append(menuHelp, "&Help");
-    SetMenuBar(menuBar);
 
     return;
 }
@@ -110,18 +108,18 @@ wxFrame(NULL, wxID_ANY, "FORK_NAME-VERSION", wxDefaultPosition, wxDefaultSize, w
 void MainFrame::init_tabpanel()
 {
     m_tabpanel = new wxNotebook(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxNB_TOP | wxTAB_TRAVERSAL);
-    Slic3r::GUI::set_tab_panel(m_tabpanel);
+//     Slic3r::GUI::set_tab_panel(m_tabpanel);
 
-//     m_tabpanel->Bind(wxEVT_NOTEBOOK_PAGE_CHANGED, [m_tabpanel](wxEvent&){
+    m_tabpanel->Bind(wxEVT_NOTEBOOK_PAGE_CHANGED, [this](wxEvent&){
-//         auto panel = m_tabpanel->GetCurrentPage();
+        auto panel = m_tabpanel->GetCurrentPage();
-// //             panel->OnActivate(); if panel->can('OnActivate');
+//             panel->OnActivate(); if panel->can('OnActivate');
-// 
+
-//         std::vector<std::string> tab_names = { "print", "filament", "printer" };
+        std::vector<std::string> tab_names = { "print", "filament", "printer" };
-//         for (auto& tab_name : tab_names) {
+        for (auto& tab_name : tab_names) {
-//             if (tab_name == panel->GetName())
+            if (tab_name == panel->GetName())
-//                 Slic3r::GUI::get_preset_tab(tab_name.c_str())->OnActivate();
+                m_options_tabs.at(tab_name)->OnActivate();
-//         }
+        }
-//     });
+    });
 
     if (!m_no_plater) {
 //        m_plater = new Slic3r::GUI::Plater(m_tabpanel,
@@ -221,10 +219,10 @@ void MainFrame::init_tabpanel()
 //     });
 
 
-//     Slic3r::GUI::create_preset_tabs(true, VALUE_CHANGE_EVENT, PRESETS_CHANGED_EVENT);
+    create_preset_tabs();
     std::vector<std::string> tab_names = { "print", "filament", "sla_material", "printer" };    
-//     for (auto tab_name : tab_names)
+    for (auto tab_name : tab_names)
-//         m_options_tabs[tab_name] = Slic3r::GUI::get_preset_tab(tab_name.c_str()); // 
+        m_options_tabs[tab_name] = get_preset_tab(tab_name.c_str()); 
 
     if (m_plater) {
 //         m_plater->on_select_preset(sub{
@@ -232,7 +230,7 @@ void MainFrame::init_tabpanel()
 //             $self->{options_tabs}{$group}->select_preset($name);
 //         });
         // load initial config
-        auto full_config = Slic3r::GUI::get_preset_bundle()->full_config();
+        auto full_config = wxGetApp().preset_bundle->full_config();
 //         m_plater->on_config_change(full_config);
 
         // Show a correct number of filament fields.
@@ -246,51 +244,99 @@ void MainFrame::init_tabpanel()
     }
 }
 
+Tab* MainFrame::get_preset_tab(const std::string& name)
+{
+    Tab* tab = get_tab(name);
+    if (tab) return tab;
+
+    for (size_t i = 0; i < m_tabpanel->GetPageCount(); ++i) {
+        tab = dynamic_cast<Tab*>(m_tabpanel->GetPage(i));
+        if (!tab)
+            continue;
+        if (tab->name() == name) {
+            return tab;
+        }
+    }
+    return nullptr;
+}
+
+void MainFrame::create_preset_tabs()
+{
+//    update_label_colours_from_appconfig();
+    add_created_tab(new TabPrint(m_tabpanel));
+    add_created_tab(new TabFilament(m_tabpanel));
+    add_created_tab(new TabSLAMaterial(m_tabpanel));
+    add_created_tab(new TabPrinter(m_tabpanel));
+}
+
+void MainFrame::add_created_tab(Tab* panel)
+{
+    panel->create_preset_tab(wxGetApp().preset_bundle);
+
+    // Load the currently selected preset into the GUI, update the preset selection box.
+    panel->load_current_preset();
+
+    const wxString& tab_name = panel->GetName();
+    bool add_panel = true;
+
+    auto preset_tabs = get_preset_tabs();
+    auto it = std::find_if(preset_tabs->begin(), preset_tabs->end(),
+        [tab_name](PresetTab& tab){return tab.name == tab_name; });
+    if (it != preset_tabs->end()) {
+        it->panel = panel;
+        add_panel = it->technology == wxGetApp().preset_bundle->printers.get_edited_preset().printer_technology();
+    }
+
+    if (add_panel)
+        m_tabpanel->AddPage(panel, panel->title());
+}
+
 void MainFrame::init_menubar()
 {
     // File menu
-    auto fileMenu = new wxMenu();
+    wxMenu* fileMenu = new wxMenu;
     {
-//         wxTheApp->append_menu_item(fileMenu, L("Open STL/OBJ/AMF/3MF…\tCtrl+O"), L('Open a model'), [](wxCommandEvent&){
+        wxGetApp().append_menu_item(fileMenu, wxID_ANY, _(L("Open STL/OBJ/AMF/3MF…\tCtrl+O")), _(L("Open a model")), 
+            "", [](wxCommandEvent&){
 //             if (m_plater) m_plater->add();
-//         }, undef, undef); //'brick_add.png');
+        }); //'brick_add.png');
-        append_menu_item(fileMenu, wxID_ANY, _(L("&Load Config…\tCtrl+L")), _(L("Load exported configuration file")), 
+        append_menu_item(fileMenu, wxID_ANY, _(L("&Load Config…\tCtrl+L")), _(L("Load exported configuration file")), 
                         [this](wxCommandEvent&){ load_config_file(); }, "plugin_add.png");
-        append_menu_item(fileMenu, wxID_ANY, _(L("&Export Config…\tCtrl+E")), _(L("Export current configuration to file")), 
+        append_menu_item(fileMenu, wxID_ANY, _(L("&Export Config…\tCtrl+E")), _(L("Export current configuration to file")), 
                         [this](wxCommandEvent&){ export_config(); }, "plugin_go.png");
-        append_menu_item(fileMenu, wxID_ANY, _(L("&Load Config Bundle…")), _(L("Load presets from a bundle")), 
+        append_menu_item(fileMenu, wxID_ANY, _(L("&Load Config Bundle…")), _(L("Load presets from a bundle")), 
                         [this](wxCommandEvent&){ load_configbundle(); }, "lorry_add.png");
-        append_menu_item(fileMenu, wxID_ANY, _(L("&Export Config Bundle…")), _(L("Export all presets to file")), 
+        append_menu_item(fileMenu, wxID_ANY, _(L("&Export Config Bundle…")), _(L("Export all presets to file")), 
                         [this](wxCommandEvent&){ export_configbundle(); }, "lorry_go.png");
         fileMenu->AppendSeparator();
         wxMenuItem* repeat = nullptr;
-        append_menu_item(fileMenu, wxID_ANY, _(L("Q&uick Slice…\tCtrl+U")), _(L("Slice a file into a G-code")), 
+        append_menu_item(fileMenu, wxID_ANY, _(L("Q&uick Slice…\tCtrl+U")), _(L("Slice a file into a G-code")), 
             [this, repeat](wxCommandEvent&){
                 wxTheApp->CallAfter([this, repeat](){
                     quick_slice();
-                    repeat->Enable(is_last_input_file()/*defined $Slic3r::GUI::MainFrame::last_input_file*/);
+                    repeat->Enable(is_last_input_file());
             }); }, "cog_go.png");
-        append_menu_item(fileMenu, wxID_ANY, _(L("Quick Slice and Save &As…\tCtrl+Alt+U")), _(L("Slice a file into a G-code, save as")), 
+        append_menu_item(fileMenu, wxID_ANY, _(L("Quick Slice and Save &As…\tCtrl+Alt+U")), _(L("Slice a file into a G-code, save as")), 
             [this, repeat](wxCommandEvent&){
                 wxTheApp->CallAfter([this, repeat](){
-                    quick_slice(/*save_as = > 1*/qsSaveAs);
+                    quick_slice(qsSaveAs);
-                    repeat->Enable(is_last_input_file()/*defined $Slic3r::GUI::MainFrame::last_input_file*/);
+                    repeat->Enable(is_last_input_file());
             }); }, "cog_go.png");
         repeat = append_menu_item(fileMenu, wxID_ANY, _(L("&Repeat Last Quick Slice\tCtrl+Shift+U")), _(L("Repeat last quick slice")), 
             [this](wxCommandEvent&){
             wxTheApp->CallAfter([this](){
-                quick_slice(/*reslice = > 1*/qsReslice);
+                quick_slice(qsReslice);
             }); }, "cog_go.png");
         repeat->Enable(0);
         fileMenu->AppendSeparator();
-        append_menu_item(fileMenu, wxID_ANY, _(L("Slice to SV&G…\tCtrl+G")), _(L("Slice file to a multi-layer SVG")),
+        append_menu_item(fileMenu, wxID_ANY, _(L("Slice to SV&G…\tCtrl+G")), _(L("Slice file to a multi-layer SVG")),
-            [this](wxCommandEvent&){ quick_slice(/*save_as = > 1, export_svg = > 1*/qsSaveAs | qsExportSVG); }, "shape_handles.png");
+            [this](wxCommandEvent&){ quick_slice(qsSaveAs | qsExportSVG); }, "shape_handles.png");
-        append_menu_item(fileMenu, wxID_ANY, _(L("Slice to PNG…")), _(L("Slice file to a set of PNG files")),
+        append_menu_item(fileMenu, wxID_ANY, _(L("Slice to PNG…")), _(L("Slice file to a set of PNG files")),
             [this](wxCommandEvent&){ slice_to_png(); /*$self->quick_slice(save_as = > 0, export_png = > 1);*/ }, "shape_handles.png");
         m_menu_item_reslice_now = append_menu_item(fileMenu, wxID_ANY, _(L("(&Re)Slice Now\tCtrl+S")), _(L("Start new slicing process")),
             [this](wxCommandEvent&){ reslice_now(); }, "shape_handles.png");
         fileMenu->AppendSeparator();
-        append_menu_item(fileMenu, wxID_ANY, _(L("Repair STL file…")), _(L("Automatically repair an STL file")),
+        append_menu_item(fileMenu, wxID_ANY, _(L("Repair STL file…")), _(L("Automatically repair an STL file")),
             [this](wxCommandEvent&){ repair_stl(); }, "wrench.png");
         fileMenu->AppendSeparator();
         append_menu_item(fileMenu, wxID_EXIT, _(L("&Quit")), _(L("Quit Slic3r")),
@@ -372,7 +418,7 @@ void MainFrame::init_menubar()
             [this](wxCommandEvent&){ wxLaunchDefaultBrowser("http://manual.slic3r.org/"); });
         helpMenu->AppendSeparator();
         append_menu_item(helpMenu, wxID_ANY, _(L("System Info")), _(L("Show system information")), 
-            [this](wxCommandEvent&){ /*wxTheApp->system_info();*/ });
+            [this](wxCommandEvent&){ wxGetApp().system_info(); });
         append_menu_item(helpMenu, wxID_ANY, _(L("Show &Configuration Folder")), _(L("Show user configuration folder (datadir)")), 
             [this](wxCommandEvent&){ Slic3r::GUI::desktop_open_datadir_folder(); });
         append_menu_item(helpMenu, wxID_ANY, _(L("Report an Issue")), _(L("Report an issue on the Slic3r Prusa Edition")), 
@@ -392,7 +438,7 @@ void MainFrame::init_menubar()
         menubar->Append(windowMenu, L("&Window"));
         if (m_viewMenu) menubar->Append(m_viewMenu, L("&View"));
         // Add additional menus from C++
-//         Slic3r::GUI::add_menus(menubar, preferences_event, lang_ch_event);
+        wxGetApp().add_config_menu(menubar);
         menubar->Append(helpMenu, L("&Help"));
         SetMenuBar(menubar);
     }
@@ -414,22 +460,19 @@ void MainFrame::slice_to_png(){
 }
 
 // To perform the "Quck Slice", "Quick Slice and Save As", "Repeat last Quick Slice" and "Slice to SVG".
-void MainFrame::quick_slice(const /*QuickSlice*/int qs/* = qsUndef const bool reslice,
+void MainFrame::quick_slice(const int qs){
-                            const bool export_svg,
-                            const bool export_png,
-                            const bool save_as*/){
 //     my $progress_dialog;
     wxString input_file;
 //  eval
 //     {
     // validate configuration
-    auto config = get_preset_bundle()->full_config();
+    auto config = wxGetApp().preset_bundle->full_config();
     config.validate();
 
     // select input file
-    if (/*!reslice*/(qs & qsReslice) == 0) {
+    if (!(qs & qsReslice)) {
         auto dlg = new wxFileDialog(this, _(L("Choose a file to slice (STL/OBJ/AMF/3MF/PRUSA):")),
-            get_app_config()->get_last_dir(), "",
+            wxGetApp().app_config->get_last_dir(), "",
             MODEL_WILDCARD, wxFD_OPEN | wxFD_FILE_MUST_EXIST);
         if (dlg->ShowModal() != wxID_OK) {
             dlg->Destroy();
@@ -437,7 +480,7 @@ void MainFrame::quick_slice(const /*QuickSlice*/int qs/* = qsUndef const bool re
         }
         input_file = dlg->GetPath();
         dlg->Destroy();
-        if (/*!export_svg*/(qs & qsExportSVG) == 0)
+        if (!(qs & qsExportSVG))
             m_qs_last_input_file = input_file;
     }
     else {
@@ -456,7 +499,7 @@ void MainFrame::quick_slice(const /*QuickSlice*/int qs/* = qsUndef const bool re
         input_file = m_qs_last_input_file;
     }
     auto input_file_basename = get_base_name(input_file);
-    get_app_config()->update_skein_dir(get_dir_name(input_file));
+    wxGetApp().app_config->update_skein_dir(get_dir_name(input_file));
 
     auto bed_shape = Slic3r::Polygon::new_scale(config.option<ConfigOptionPoints>("bed_shape")->values);
 //     auto print_center = Slic3r::Pointf->new_unscale(bed_shape.bounding_box().center());
@@ -464,7 +507,7 @@ void MainFrame::quick_slice(const /*QuickSlice*/int qs/* = qsUndef const bool re
 //     auto sprint = new Slic3r::Print::Simple(
 //         print_center = > print_center,
 //         status_cb = > [](int percent, const wxString& msg){
-//         m_progress_dialog->Update(percent, msg+"…");
+//         m_progress_dialog->Update(percent, msg+"…");
 //     });
 
     // keep model around
@@ -474,22 +517,22 @@ void MainFrame::quick_slice(const /*QuickSlice*/int qs/* = qsUndef const bool re
 //     sprint->set_model(model);
 
     // Copy the names of active presets into the placeholder parser.
-//     get_preset_bundle()->export_selections(sprint->placeholder_parser);
+//     wxGetApp().preset_bundle->export_selections(sprint->placeholder_parser);
 
     // select output file
     wxString output_file;
-    if (/*reslice*/(qs & qsReslice)/* != 0*/) {
+    if (qs & qsReslice) {
         if (!m_qs_last_output_file.IsEmpty())
             output_file = m_qs_last_output_file;
     } 
-    else if (/*save_as*/(qs & qsSaveAs)/* != 0*/) {
+    else if (qs & qsSaveAs) {
         // The following line may die if the output_filename_format template substitution fails.
 //         output_file = sprint->output_filepath;
 //         if (export_svg)
 //         output_file = ~s / \.[gG][cC][oO][dD][eE]$ / .svg /;
-        auto dlg = new wxFileDialog(this, _(L("Save ")) + (qs & qsExportSVG/*export_svg*/ ? _(L("SVG")) : _(L("G-code"))) + _(L(" file as:")),
+        auto dlg = new wxFileDialog(this, _(L("Save ")) + (qs & qsExportSVG ? _(L("SVG")) : _(L("G-code"))) + _(L(" file as:")),
-            get_app_config()->get_last_output_dir(get_dir_name(output_file)), get_base_name(input_file), 
+            wxGetApp().app_config->get_last_output_dir(get_dir_name(output_file)), get_base_name(input_file), 
-            qs & qsExportSVG/*export_svg*/ ? FILE_WILDCARDS.at("svg") : FILE_WILDCARDS.at("gcode"),
+            qs & qsExportSVG ? FILE_WILDCARDS.at("svg") : FILE_WILDCARDS.at("gcode"),
             wxFD_SAVE | wxFD_OVERWRITE_PROMPT);
         if (dlg->ShowModal() != wxID_OK) {
             dlg->Destroy();
@@ -497,15 +540,15 @@ void MainFrame::quick_slice(const /*QuickSlice*/int qs/* = qsUndef const bool re
         }
         output_file = dlg->GetPath();
         dlg->Destroy();
-        if (/*!export_svg*/!(qs & qsExportSVG))
+        if (!(qs & qsExportSVG))
             m_qs_last_output_file = output_file;
-        get_app_config()->update_last_output_dir(get_dir_name(output_file));
+        wxGetApp().app_config->update_last_output_dir(get_dir_name(output_file));
     } 
-    else if (/*export_png*/qs & qsExportPNG) {
+    else if (qs & qsExportPNG) {
 //         output_file = sprint->output_filepath;
 //         output_file = ~s / \.[gG][cC][oO][dD][eE]$ / .zip / ;
         auto dlg = new wxFileDialog(this, _(L("Save zip file as:")),
-            get_app_config()->get_last_output_dir(get_dir_name(output_file)),
+            wxGetApp().app_config->get_last_output_dir(get_dir_name(output_file)),
             get_base_name(output_file), "*.zip", wxFD_SAVE | wxFD_OVERWRITE_PROMPT);
         if (dlg->ShowModal() != wxID_OK) {
             dlg->Destroy();
@@ -516,7 +559,7 @@ void MainFrame::quick_slice(const /*QuickSlice*/int qs/* = qsUndef const bool re
     }
 
     // show processbar dialog
-    m_progress_dialog = new wxProgressDialog(_(L("Slicing…")), _(L("Processing ")) + input_file_basename + "…",
+    m_progress_dialog = new wxProgressDialog(_(L("Slicing…")), _(L("Processing ")) + input_file_basename + "…",
         100, this, 4);
     m_progress_dialog->Pulse();
     {
@@ -556,7 +599,7 @@ void MainFrame::repair_stl()
     wxString input_file;
     {
         auto dlg = new wxFileDialog(this, _(L("Select the STL file to repair:")),
-            get_app_config()->get_last_dir(), "",
+            wxGetApp().app_config->get_last_dir(), "",
             FILE_WILDCARDS.at("stl"), wxFD_OPEN | wxFD_FILE_MUST_EXIST);
         if (dlg->ShowModal() != wxID_OK) {
             dlg->Destroy();
@@ -590,7 +633,7 @@ void MainFrame::repair_stl()
 void MainFrame::export_config()
 {
     // Generate a cummulative configuration for the selected print, filaments and printer.
-    auto config = get_preset_bundle()->full_config();
+    auto config = wxGetApp().preset_bundle->full_config();
     // Validate the cummulative configuration.
     auto valid = config.validate();
     if (!valid.empty()) {
@@ -599,13 +642,13 @@ void MainFrame::export_config()
     }
     // Ask user for the file name for the config file.
     auto dlg = new wxFileDialog(this, _(L("Save configuration as:")),
-        !m_last_config.IsEmpty() ? get_dir_name(m_last_config) : get_app_config()->get_last_dir(),
+        !m_last_config.IsEmpty() ? get_dir_name(m_last_config) : wxGetApp().app_config->get_last_dir(),
         !m_last_config.IsEmpty() ? get_base_name(m_last_config) : "config.ini",
         FILE_WILDCARDS.at("ini"), wxFD_SAVE | wxFD_OVERWRITE_PROMPT);
     wxString file = dlg->ShowModal() == wxID_OK ? dlg->GetPath() : wxEmptyString;
     dlg->Destroy();
     if (!file.IsEmpty()) {
-        get_app_config()->update_config_dir(get_dir_name(file));
+        wxGetApp().app_config->update_config_dir(get_dir_name(file));
         m_last_config = file;
         config.save(file.ToStdString());
     }
@@ -615,10 +658,10 @@ void MainFrame::export_config()
 void MainFrame::load_config_file(wxString file/* = wxEmptyString*/)
 {
     if (file.IsEmpty()) {
-        if (!Slic3r::GUI::check_unsaved_changes())
+        if (!wxGetApp().check_unsaved_changes())
             return;
         auto dlg = new wxFileDialog(this, _(L("Select configuration to load:")),
-            !m_last_config.IsEmpty() ? get_dir_name(m_last_config) : get_app_config()->get_last_dir(),
+            !m_last_config.IsEmpty() ? get_dir_name(m_last_config) : wxGetApp().app_config->get_last_dir(),
             "config.ini", "INI files (*.ini, *.gcode)|*.ini;*.INI;*.gcode;*.g", wxFD_OPEN | wxFD_FILE_MUST_EXIST);
         if (dlg->ShowModal() != wxID_OK)
             return;
@@ -626,39 +669,39 @@ void MainFrame::load_config_file(wxString file/* = wxEmptyString*/)
         dlg->Destroy();
     }
 //     eval{ 
-        get_preset_bundle()->load_config_file(file.ToStdString()); 
+        wxGetApp().preset_bundle->load_config_file(file.ToStdString()); 
 //     };
     // Dont proceed further if the config file cannot be loaded.
 //     if (Slic3r::GUI::catch_error(this))
 //         return;
     for (auto tab : m_options_tabs )
         tab.second->load_current_preset();
-    get_app_config()->update_config_dir(get_dir_name(file));
+    wxGetApp().app_config->update_config_dir(get_dir_name(file));
     m_last_config = file;
 }
 
 void MainFrame::export_configbundle()
 {
-    if (!Slic3r::GUI::check_unsaved_changes())
+    if (!wxGetApp().check_unsaved_changes())
         return;
     // validate current configuration in case it's dirty
-    auto valid = get_preset_bundle()->full_config().validate();
+    auto valid = wxGetApp().preset_bundle->full_config().validate();
     if (!valid.empty()) {
 //         Slic3r::GUI::catch_error(this);
         return;
     }
     // Ask user for a file name.
     auto dlg = new wxFileDialog(this, _(L("Save presets bundle as:")),
-        !m_last_config.IsEmpty() ? get_dir_name(m_last_config) : get_app_config()->get_last_dir(),
+        !m_last_config.IsEmpty() ? get_dir_name(m_last_config) : wxGetApp().app_config->get_last_dir(),
         "Slic3r_config_bundle.ini",
         FILE_WILDCARDS.at("ini"), wxFD_SAVE | wxFD_OVERWRITE_PROMPT);
     wxString file = dlg->ShowModal() == wxID_OK ? dlg->GetPath() : wxEmptyString;
     dlg->Destroy();
     if (!file.IsEmpty()) {
         // Export the config bundle.
-       get_app_config()->update_config_dir(get_dir_name(file));
+       wxGetApp().app_config->update_config_dir(get_dir_name(file));
 //         eval{ 
-            get_preset_bundle()->export_configbundle(file.ToStdString()); 
+            wxGetApp().preset_bundle->export_configbundle(file.ToStdString()); 
 //         };
 //         Slic3r::GUI::catch_error(this);
     }
@@ -668,11 +711,11 @@ void MainFrame::export_configbundle()
 // to auto - install a config bundle on a fresh user account,
 // but that behavior was not documented and likely buggy.
 void MainFrame::load_configbundle(wxString file/* = wxEmptyString, const bool reset_user_profile*/){
-    if (!Slic3r::GUI::check_unsaved_changes())
+    if (!wxGetApp().check_unsaved_changes())
         return;
     if (file.IsEmpty()) {
         auto dlg = new wxFileDialog(this, _(L("Select configuration to load:")),
-            !m_last_config.IsEmpty() ? get_dir_name(m_last_config) : get_app_config()->get_last_dir(),
+            !m_last_config.IsEmpty() ? get_dir_name(m_last_config) : wxGetApp().app_config->get_last_dir(),
             "config.ini", FILE_WILDCARDS.at("ini"), wxFD_OPEN | wxFD_FILE_MUST_EXIST);
         if (dlg->ShowModal() != wxID_OK)
             return;
@@ -680,11 +723,11 @@ void MainFrame::load_configbundle(wxString file/* = wxEmptyString, const bool re
         dlg->Destroy();
     }
 
-    get_app_config()->update_config_dir(get_dir_name(file));
+    wxGetApp().app_config->update_config_dir(get_dir_name(file));
 
     auto presets_imported = 0;
 //     eval{ 
-        presets_imported = get_preset_bundle()->load_configbundle(file.ToStdString()); 
+    presets_imported = wxGetApp().preset_bundle->load_configbundle(file.ToStdString());
 //     };
 //     Slic3r::GUI::catch_error(this) and return;
 
@@ -734,7 +777,7 @@ wxMenuItem* MainFrame::append_menu_item(wxMenu* menu,
 // Update the UI based on the current preferences.
 void MainFrame::update_ui_from_settings()
 {
-//     m_menu_item_reslice_now->Enable(get_app_config()->get("background_processing"));
+    m_menu_item_reslice_now->Enable(wxGetApp().app_config->get("background_processing") == "1");
 //     if (m_plater) m_plater->update_ui_from_settings();
     std::vector<std::string> tab_names = { "print", "filament", "printer" };
     for (auto tab_name: tab_names)
@@ -754,4 +797,4 @@ std::string MainFrame::get_dir_name(const wxString full_name) const
 
 
 } // GUI
-} //Slic3r
+} // Slic3r

src/slic3r/GUI/MainFrame.hpp

@@ -45,8 +45,8 @@ class MainFrame : public wxFrame
     wxString    m_qs_last_output_file = wxEmptyString;
     wxString    m_last_config = wxEmptyString;
 
-    ProgressStatusBar*              m_statusbar;
+    ProgressStatusBar*              m_statusbar { nullptr };
-    AppController*                  m_appController = nullptr;
+    AppController*                  m_appController { nullptr };
     std::map<std::string, Tab*>     m_options_tabs;
 
     wxMenuItem* append_menu_item(wxMenu* menu,
@@ -56,10 +56,10 @@ class MainFrame : public wxFrame
                                  std::function<void(wxCommandEvent& event)> cb,
                                  const std::string& icon = "");
 
-    wxMenuItem* m_menu_item_reslice_now = nullptr;
+    wxMenuItem* m_menu_item_reslice_now { nullptr };
-    wxMenu*     m_plater_menu = nullptr;
+    wxMenu*     m_plater_menu { nullptr };
-    wxMenu*     m_object_menu = nullptr;
+    wxMenu*     m_object_menu { nullptr };
-    wxMenu*     m_viewMenu = nullptr;
+    wxMenu*     m_viewMenu { nullptr };
 
     std::string     get_base_name(const wxString full_name) const ;
     std::string     get_dir_name(const wxString full_name) const ;
@@ -70,6 +70,9 @@ public:
 
 
     void        init_tabpanel();
+    Tab*        get_preset_tab(const std::string& name);
+    void        create_preset_tabs();
+    void        add_created_tab(Tab* panel);
     void        init_menubar();
 
     void        update_ui_from_settings();
@@ -90,9 +93,9 @@ public:
     void        select_view(const std::string& direction);
 
 
-    wxPanel*            m_plater = nullptr;
+    wxPanel*            m_plater {nullptr};
-    wxNotebook*         m_tabpanel = nullptr;
+    wxNotebook*         m_tabpanel { nullptr };
-    wxProgressDialog*   m_progress_dialog = nullptr;
+    wxProgressDialog*   m_progress_dialog { nullptr };
 };
 
 } // GUI

src/slic3r/GUI/OptionsGroup.cpp

@@ -218,10 +218,10 @@ void OptionsGroup::append_line(const Line& line, wxStaticText**	colored_Label/*
 
 		add_undo_buttuns_to_sizer(sizer, field);
 		if (is_window_field(field)) 
-			sizer->Add(field->getWindow(), option.opt.full_width ? 1 : 0, (option.opt.full_width ? wxEXPAND : 0) |
+			sizer->Add(field->getWindow(), option.opt.full_width ? 1 : 0, //(option.opt.full_width ? wxEXPAND : 0) |
-							wxBOTTOM | wxTOP | wxALIGN_CENTER_VERTICAL, (wxOSX||!staticbox) ? 0 : 2);
+            wxBOTTOM | wxTOP | (option.opt.full_width ? wxEXPAND : wxALIGN_CENTER_VERTICAL), (wxOSX || !staticbox) ? 0 : 2);
 		if (is_sizer_field(field)) 
-			sizer->Add(field->getSizer(), 1, (option.opt.full_width ? wxEXPAND : 0) | wxALIGN_CENTER_VERTICAL, 0);
+			sizer->Add(field->getSizer(), 1, /*(*/option.opt.full_width ? wxEXPAND : /*0) |*/ wxALIGN_CENTER_VERTICAL, 0);
 		return;
 	}
 
@@ -244,7 +244,7 @@ void OptionsGroup::append_line(const Line& line, wxStaticText**	colored_Label/*
 // 								L_str(option.label);
 			label = new wxStaticText(parent(), wxID_ANY, str_label + ":", wxDefaultPosition, wxDefaultSize);
 			label->SetFont(label_font);
-			sizer_tmp->Add(label, 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL, 0);
+			sizer_tmp->Add(label, 0, /*wxALIGN_RIGHT |*/ wxALIGN_CENTER_VERTICAL, 0);
 		}
 
 		// add field

src/slic3r/GUI/ProgressStatusBar.cpp

@@ -130,7 +130,7 @@ void ProgressStatusBar::run(int rate)
 
 void ProgressStatusBar::embed(wxFrame *frame)
 {
-    wxFrame* mf = frame? frame : GUI::get_main_frame();
+    wxFrame* mf = frame ? frame : GUI::get_main_frame();
     mf->SetStatusBar(self);
 }
 

src/slic3r/GUI/Tab.cpp

@@ -28,6 +28,7 @@
 #include <wx/wupdlock.h>
 
 #include <chrono>
+#include "GUI_App.hpp"
 
 namespace Slic3r {
 namespace GUI {
@@ -513,8 +514,8 @@ void Tab::update_changed_tree_ui()
 			}
 			break;
 		}
-		auto next_item = m_treectrl->GetNextVisible(cur_item);
+        auto next_item = m_treectrl->GetNextVisible(cur_item);
-		cur_item = next_item;
+        cur_item = !m_treectrl->IsVisible(cur_item) ? m_treectrl->GetNextVisible(cur_item) : nullptr;// next_item;
 	}
 	update_undo_buttons();
 }
@@ -713,15 +714,16 @@ void Tab::on_value_change(const std::string& opt_key, const boost::any& value)
 
 // Show/hide the 'purging volumes' button
 void Tab::update_wiping_button_visibility() {
-    if (get_preset_bundle()->printers.get_selected_preset().printer_technology() == ptSLA)
+    if (wxGetApp().preset_bundle->printers.get_selected_preset().printer_technology() == ptSLA)
         return; // ys_FIXME
     bool wipe_tower_enabled = dynamic_cast<ConfigOptionBool*>(  (m_preset_bundle->prints.get_edited_preset().config  ).option("wipe_tower"))->value;
     bool multiple_extruders = dynamic_cast<ConfigOptionFloats*>((m_preset_bundle->printers.get_edited_preset().config).option("nozzle_diameter"))->values.size() > 1;
     bool single_extruder_mm = dynamic_cast<ConfigOptionBool*>(  (m_preset_bundle->printers.get_edited_preset().config).option("single_extruder_multi_material"))->value;
 
+    if (get_wiping_dialog_button()) {
 	get_wiping_dialog_button()->Show(wipe_tower_enabled && multiple_extruders && single_extruder_mm);	
-	
     (get_wiping_dialog_button()->GetParent())->Layout();
+    }
 }
 
 
@@ -787,6 +789,7 @@ void Tab::update_preset_description_line()
 
 void Tab::update_frequently_changed_parameters()
 {
+    if (!get_optgroup(ogFrequentlyChangingParameters)) return;
 	boost::any value = get_optgroup(ogFrequentlyChangingParameters)->get_config_value(*m_config, "fill_density");
 	get_optgroup(ogFrequentlyChangingParameters)->set_value("fill_density", value);
 
@@ -1041,7 +1044,7 @@ void TabPrint::reload_config(){
 
 void TabPrint::update()
 {
-    if (get_preset_bundle()->printers.get_selected_preset().printer_technology() == ptSLA)
+    if (wxGetApp().preset_bundle->printers.get_selected_preset().printer_technology() == ptSLA)
         return; // ys_FIXME
 
 	Freeze();
@@ -1407,7 +1410,7 @@ void TabFilament::reload_config(){
 
 void TabFilament::update()
 {
-    if (get_preset_bundle()->printers.get_selected_preset().printer_technology() == ptSLA)
+    if (wxGetApp().preset_bundle->printers.get_selected_preset().printer_technology() == ptSLA)
         return; // ys_FIXME
 
 	Freeze();
@@ -2189,15 +2192,15 @@ void Tab::load_current_preset()
             PrinterTechnology& printer_technology = m_presets->get_edited_preset().printer_technology();
             if (printer_technology != static_cast<TabPrinter*>(this)->m_printer_technology)
             {
-                for (auto& tab : get_preset_tabs()){
+                for (auto& tab : *get_preset_tabs()){
                     if (tab.technology != printer_technology)
                     {
-                        int page_id = get_tab_panel()->FindPage(tab.panel);
+                        int page_id = wxGetApp().tab_panel()->FindPage(tab.panel);
-                        get_tab_panel()->GetPage(page_id)->Show(false);
+                        wxGetApp().tab_panel()->GetPage(page_id)->Show(false);
-                        get_tab_panel()->RemovePage(page_id);
+                        wxGetApp().tab_panel()->RemovePage(page_id);
                     }
                     else
-                        get_tab_panel()->InsertPage(get_tab_panel()->FindPage(this), tab.panel, tab.panel->title());
+                        wxGetApp().tab_panel()->InsertPage(wxGetApp().tab_panel()->FindPage(this), tab.panel, tab.panel->title());
                 }
 
                 static_cast<TabPrinter*>(this)->m_printer_technology = printer_technology;
@@ -2225,8 +2228,9 @@ void Tab::rebuild_page_tree(bool tree_sel_change_event /*= false*/)
 {
 	Freeze();
 	// get label of the currently selected item
-	auto selected = m_treectrl->GetItemText(m_treectrl->GetSelection());
+    const auto sel_item = m_treectrl->GetSelection();
-	auto rootItem = m_treectrl->GetRootItem();
+	const auto selected = sel_item ? m_treectrl->GetItemText(sel_item) : "";
+	const auto rootItem = m_treectrl->GetRootItem();
 
 	auto have_selection = 0;
 	m_treectrl->DeleteChildren(rootItem);
@@ -2375,7 +2379,8 @@ void Tab::OnTreeSelChange(wxTreeEvent& event)
 #endif
 
 	Page* page = nullptr;
-	auto selection = m_treectrl->GetItemText(m_treectrl->GetSelection());
+    const auto sel_item = m_treectrl->GetSelection();
+    const auto selection = sel_item ? m_treectrl->GetItemText(sel_item) : "";
 	for (auto p : m_pages)
 		if (p->title() == selection)
 		{
@@ -2517,7 +2522,7 @@ void Tab::update_ui_from_settings()
 {
 	// Show the 'show / hide presets' button only for the print and filament tabs, and only if enabled
 	// in application preferences.
-	m_show_btn_incompatible_presets = get_app_config()->get("show_incompatible_presets")[0] == '1' ? true : false;
+	m_show_btn_incompatible_presets = wxGetApp().app_config->get("show_incompatible_presets")[0] == '1' ? true : false;
 	bool show = m_show_btn_incompatible_presets && m_presets->name().compare("printer") != 0;
 	show ? m_btn_hide_incompatible_presets->Show() :  m_btn_hide_incompatible_presets->Hide();
 	// If the 'show / hide presets' button is hidden, hide the incompatible presets.
@@ -2616,7 +2621,7 @@ void Tab::update_presetsctrl(wxDataViewTreeCtrl* ui, bool show_incompatible)
 	auto root_sys = ui->AppendContainer(wxDataViewItem(0), _(L("System presets")));
 	auto root_def = ui->AppendContainer(wxDataViewItem(0), _(L("Default presets")));
 
-	auto show_def = get_app_config()->get("no_defaults")[0] != '1';
+	auto show_def = wxGetApp().app_config->get("no_defaults")[0] != '1';
 
 	for (size_t i = presets.front().is_visible ? 0 : 1; i < presets.size(); ++i) {
 		const Preset &preset = presets[i];
@@ -2702,7 +2707,7 @@ void Tab::update_tab_presets(wxComboCtrl* ui, bool show_incompatible)
 		auto root_sys = popup->AppendContainer(wxDataViewItem(0), _(L("System presets")));
 		auto root_def = popup->AppendContainer(wxDataViewItem(0), _(L("Default presets")));
 
-		auto show_def = get_app_config()->get("no_defaults")[0] != '1';
+		auto show_def = wxGetApp().app_config->get("no_defaults")[0] != '1';
 
 		for (size_t i = presets.front().is_visible ? 0 : 1; i < presets.size(); ++i) {
 			const Preset &preset = presets[i];
@@ -3025,7 +3030,7 @@ void TabSLAMaterial::build()
 
 void TabSLAMaterial::update()
 {
-    if (get_preset_bundle()->printers.get_selected_preset().printer_technology() == ptFFF)
+    if (wxGetApp().preset_bundle->printers.get_selected_preset().printer_technology() == ptFFF)
         return; // ys_FIXME
 }
 

src/slic3r/Utils/PresetUpdater.cpp

@@ -24,6 +24,7 @@
 #include "slic3r/Utils/Http.hpp"
 #include "slic3r/Config/Version.hpp"
 #include "slic3r/Config/Snapshot.hpp"
+#include "slic3r/GUI/GUI_App.hpp"
 
 namespace fs = boost::filesystem;
 using Slic3r::GUI::Config::Index;
@@ -90,7 +91,6 @@ struct Updates
 
 struct PresetUpdater::priv
 {
-	int version_online_event;
 	std::vector<Index> index_db;
 
 	bool enabled_version_check;
@@ -105,7 +105,7 @@ struct PresetUpdater::priv
 	bool cancel;
 	std::thread thread;
 
-	priv(int version_online_event);
+	priv();
 
 	void set_download_prefs(AppConfig *app_config);
 	bool get_file(const std::string &url, const fs::path &target_path) const;
@@ -120,15 +120,14 @@ struct PresetUpdater::priv
 	static void copy_file(const fs::path &from, const fs::path &to);
 };
 
-PresetUpdater::priv::priv(int version_online_event) :
+PresetUpdater::priv::priv() :
-	version_online_event(version_online_event),
 	had_config_update(false),
 	cache_path(fs::path(Slic3r::data_dir()) / "cache"),
 	rsrc_path(fs::path(resources_dir()) / "profiles"),
 	vendor_path(fs::path(Slic3r::data_dir()) / "vendor"),
 	cancel(false)
 {
-	set_download_prefs(GUI::get_app_config());
+	set_download_prefs(GUI::wxGetApp().app_config);
 	check_install_indices();
 	index_db = std::move(Index::load_db());
 }
@@ -209,9 +208,11 @@ void PresetUpdater::priv::sync_version() const
 		.on_complete([&](std::string body, unsigned /* http_status */) {
 			boost::trim(body);
 			BOOST_LOG_TRIVIAL(info) << boost::format("Got Slic3rPE online version: `%1%`. Sending to GUI thread...") % body;
-			wxCommandEvent* evt = new wxCommandEvent(version_online_event);
+// 			wxCommandEvent* evt = new wxCommandEvent(version_online_event);
-			evt->SetString(body);
+// 			evt->SetString(body);
-			GUI::get_app()->QueueEvent(evt);
+// 			GUI::get_app()->QueueEvent(evt);
+	        GUI::wxGetApp().app_config->set("version_online", body);
+	        GUI::wxGetApp().app_config->save();
 		})
 		.perform_sync();
 }
@@ -395,7 +396,7 @@ void PresetUpdater::priv::perform_updates(Updates &&updates, bool snapshot) cons
 	if (updates.incompats.size() > 0) {
 		if (snapshot) {
 			BOOST_LOG_TRIVIAL(info) << "Taking a snapshot...";
-			SnapshotDB::singleton().take_snapshot(*GUI::get_app_config(), Snapshot::SNAPSHOT_DOWNGRADE);
+			SnapshotDB::singleton().take_snapshot(*GUI::wxGetApp().app_config, Snapshot::SNAPSHOT_DOWNGRADE);
 		}
 
 		BOOST_LOG_TRIVIAL(info) << boost::format("Deleting %1% incompatible bundles") % updates.incompats.size();
@@ -408,7 +409,7 @@ void PresetUpdater::priv::perform_updates(Updates &&updates, bool snapshot) cons
 	else if (updates.updates.size() > 0) {
 		if (snapshot) {
 			BOOST_LOG_TRIVIAL(info) << "Taking a snapshot...";
-			SnapshotDB::singleton().take_snapshot(*GUI::get_app_config(), Snapshot::SNAPSHOT_UPGRADE);
+			SnapshotDB::singleton().take_snapshot(*GUI::wxGetApp().app_config, Snapshot::SNAPSHOT_UPGRADE);
 		}
 
 		BOOST_LOG_TRIVIAL(info) << boost::format("Performing %1% updates") % updates.updates.size();
@@ -466,8 +467,8 @@ void PresetUpdater::priv::copy_file(const fs::path &source, const fs::path &targ
 }
 
 
-PresetUpdater::PresetUpdater(int version_online_event) :
+PresetUpdater::PresetUpdater() :
-	p(new priv(version_online_event))
+	p(new priv())
 {}
 
 
@@ -485,7 +486,7 @@ PresetUpdater::~PresetUpdater()
 
 void PresetUpdater::sync(PresetBundle *preset_bundle)
 {
-	p->set_download_prefs(GUI::get_app_config());
+	p->set_download_prefs(GUI::wxGetApp().app_config);
 	if (!p->enabled_version_check && !p->enabled_config_update) { return; }
 
 	// Copy the whole vendors data for use in the background thread
@@ -509,7 +510,7 @@ void PresetUpdater::slic3r_update_notify()
 		return;
 	}
 
-	auto* app_config = GUI::get_app_config();
+	auto* app_config = GUI::wxGetApp().app_config;
 	const auto ver_slic3r = Semver::parse(SLIC3R_VERSION);
 	const auto ver_online_str = app_config->get("version_online");
 	const auto ver_online = Semver::parse(ver_online_str);
@@ -601,7 +602,7 @@ bool PresetUpdater::config_update() const
 			p->perform_updates(std::move(updates));
 
 			// Reload global configuration
-			auto *app_config = GUI::get_app_config();
+			auto *app_config = GUI::wxGetApp().app_config;
 			GUI::get_preset_bundle()->load_presets(*app_config);
 			GUI::load_current_presets();
 		} else {

src/slic3r/Utils/PresetUpdater.hpp

@@ -13,7 +13,7 @@ class PresetBundle;
 class PresetUpdater
 {
 public:
-	PresetUpdater(int version_online_event);
+	PresetUpdater();
 	PresetUpdater(PresetUpdater &&) = delete;
 	PresetUpdater(const PresetUpdater &) = delete;
 	PresetUpdater &operator=(PresetUpdater &&) = delete;