Added a lock icon to the list of filaments, added some

helper methods to PresetBundle.

xs/CMakeLists.txt

@@ -171,6 +171,8 @@ add_library(libslic3r STATIC
 add_library(libslic3r_gui STATIC
     ${LIBDIR}/slic3r/GUI/AppConfig.cpp
     ${LIBDIR}/slic3r/GUI/AppConfig.hpp
+    ${LIBDIR}/slic3r/GUI/BitmapCache.cpp
+    ${LIBDIR}/slic3r/GUI/BitmapCache.hpp
     ${LIBDIR}/slic3r/GUI/3DScene.cpp
     ${LIBDIR}/slic3r/GUI/3DScene.hpp
     ${LIBDIR}/slic3r/GUI/GLShader.cpp

xs/src/slic3r/GUI/BitmapCache.cpp

@@ -0,0 +1,120 @@
+#include "BitmapCache.hpp"
+
+namespace Slic3r { namespace GUI {
+
+void BitmapCache::clear()
+{
+    for (std::pair<const std::string, wxBitmap*> &bitmap : m_map)
+        delete bitmap.second;
+}
+
+wxBitmap* BitmapCache::insert(const std::string &bitmap_key, size_t width, size_t height)
+{
+	wxBitmap *bitmap = nullptr;
+	auto 	  it     = m_map.find(bitmap_key);
+	if (it == m_map.end()) {
+		bitmap = new wxBitmap(width, height);
+    	m_map[bitmap_key] = bitmap;
+	} else {
+		bitmap = it->second;
+		if (bitmap->GetWidth() != width || bitmap->GetHeight() != height)
+			bitmap->Create(width, height);
+	}
+#if defined(__APPLE__) || defined(_MSC_VER)
+    bitmap->UseAlpha();
+#endif
+    return bitmap;
+}
+
+wxBitmap* BitmapCache::insert(const std::string &bitmap_key, const wxBitmap &bmp)
+{
+	wxBitmap *bitmap = this->insert(bitmap_key, bmp.GetWidth(), bmp.GetHeight());
+
+    wxMemoryDC memDC;
+    memDC.SelectObject(*bitmap);
+    memDC.SetBackground(*wxTRANSPARENT_BRUSH);
+    memDC.Clear();
+    memDC.DrawBitmap(bmp, 0, 0, true);
+    memDC.SelectObject(wxNullBitmap);
+
+	return bitmap;
+}
+
+wxBitmap* BitmapCache::insert(const std::string &bitmap_key, const wxBitmap &bmp, const wxBitmap &bmp2)
+{
+	wxBitmap *bitmap = this->insert(bitmap_key, bmp.GetWidth() + bmp2.GetWidth(), std::max(bmp.GetHeight(), bmp2.GetHeight()));
+
+    wxMemoryDC memDC;
+    memDC.SelectObject(*bitmap);
+    memDC.SetBackground(*wxTRANSPARENT_BRUSH);
+    memDC.Clear();
+    if (bmp.GetWidth() > 0)
+    	memDC.DrawBitmap(bmp,  0, 				0, true);
+    if (bmp2.GetWidth() > 0)
+	    memDC.DrawBitmap(bmp2, bmp.GetWidth(), 	0, true);
+    memDC.SelectObject(wxNullBitmap);
+
+	return bitmap;
+}
+
+wxBitmap* BitmapCache::insert(const std::string &bitmap_key, const wxBitmap &bmp, const wxBitmap &bmp2, const wxBitmap &bmp3)
+{
+	wxBitmap *bitmap = this->insert(bitmap_key, bmp.GetWidth() + bmp2.GetWidth() + bmp3.GetWidth(), std::max(std::max(bmp.GetHeight(), bmp2.GetHeight()), bmp3.GetHeight()));
+
+    wxMemoryDC memDC;
+    memDC.SelectObject(*bitmap);
+    memDC.SetBackground(*wxTRANSPARENT_BRUSH);
+    memDC.Clear();
+    if (bmp.GetWidth() > 0)
+	    memDC.DrawBitmap(bmp,  0, 									0, true);
+    if (bmp2.GetWidth() > 0)
+    	memDC.DrawBitmap(bmp2, bmp.GetWidth(), 						0, true);
+    if (bmp3.GetWidth() > 0)
+	    memDC.DrawBitmap(bmp3, bmp.GetWidth() + bmp2.GetWidth(), 	0, true);
+    memDC.SelectObject(wxNullBitmap);
+
+	return bitmap;
+}
+
+wxBitmap* BitmapCache::insert(const std::string &bitmap_key, std::vector<wxBitmap> &bmps)
+{
+	size_t width  = 0;
+	size_t height = 0;
+	for (wxBitmap &bmp : bmps) {
+		width += bmp.GetWidth();
+		height = std::max<size_t>(height, bmp.GetHeight());
+	}
+	wxBitmap *bitmap = this->insert(bitmap_key, width, height);
+
+    wxMemoryDC memDC;
+    memDC.SelectObject(*bitmap);
+    memDC.SetBackground(*wxTRANSPARENT_BRUSH);
+    memDC.Clear();
+    size_t x = 0;
+	for (wxBitmap &bmp : bmps) {
+	    if (bmp.GetWidth() > 0)
+		    memDC.DrawBitmap(bmp, x, 0, true);
+		x += bmp.GetWidth();
+	}
+    memDC.SelectObject(wxNullBitmap);
+
+	return bitmap;
+}
+
+wxBitmap BitmapCache::mksolid(size_t width, size_t height, unsigned char r, unsigned char g, unsigned char b, unsigned char transparency)
+{
+    wxImage image(width, height);
+    image.InitAlpha();
+    unsigned char* imgdata = image.GetData();
+    unsigned char* imgalpha = image.GetAlpha();
+    for (size_t i = 0; i < width * height; ++ i) {
+        *imgdata ++ = r;
+        *imgdata ++ = g;
+        *imgdata ++ = b;
+        *imgalpha ++ = transparency;
+    }
+    return wxBitmap(std::move(image));
+}
+
+} // namespace GUI
+} // namespace Slic3r

xs/src/slic3r/GUI/BitmapCache.hpp

@@ -0,0 +1,43 @@
+#ifndef SLIC3R_GUI_BITMAP_CACHE_HPP
+#define SLIC3R_GUI_BITMAP_CACHE_HPP
+
+#include <wx/wxprec.h>
+#ifndef WX_PRECOMP
+    #include <wx/wx.h>
+#endif
+
+#include "../../libslic3r/libslic3r.h"
+#include "../../libslic3r/Config.hpp"
+
+#include "GUI.hpp"
+
+namespace Slic3r { namespace GUI {
+
+class BitmapCache
+{
+public:
+	BitmapCache() {}
+	~BitmapCache() { clear(); }
+	void 			clear();
+
+	wxBitmap* 		find(const std::string &name) 		{ auto it = m_map.find(name); return (it == m_map.end()) ? nullptr : it->second; }
+	const wxBitmap* find(const std::string &name) const { return const_cast<BitmapCache*>(this)->find(name); }
+
+	wxBitmap*       insert(const std::string &name, size_t width, size_t height);
+	wxBitmap* 		insert(const std::string &name, const wxBitmap &bmp);
+	wxBitmap* 		insert(const std::string &name, const wxBitmap &bmp, const wxBitmap &bmp2);
+	wxBitmap* 		insert(const std::string &name, const wxBitmap &bmp, const wxBitmap &bmp2, const wxBitmap &bmp3);
+	wxBitmap* 		insert(const std::string &name, std::vector<wxBitmap> &bmps);
+
+	static wxBitmap mksolid(size_t width, size_t height, unsigned char r, unsigned char g, unsigned char b, unsigned char transparency);
+	static wxBitmap mksolid(size_t width, size_t height, const unsigned char rgb[3]) { return mksolid(width, height, rgb[0], rgb[1], rgb[2], wxALPHA_OPAQUE); }
+	static wxBitmap mkclear(size_t width, size_t height) { return mksolid(width, height, 0, 0, 0, wxALPHA_TRANSPARENT); }
+
+private:
+    std::map<std::string, wxBitmap*>	m_map;
+};
+
+} // GUI
+} // Slic3r
+
+#endif /* SLIC3R_GUI_BITMAP_CACHE_HPP */

xs/src/slic3r/GUI/Field.hpp

@@ -264,9 +264,7 @@ public:
 	wxSizer*		getSizer() override { return sizer; }
 };
 
-
-#endif
 } // GUI
 } // Slic3r
 
-
+#endif /* SLIC3R_GUI_FIELD_HPP */

xs/src/slic3r/GUI/Preset.cpp

@@ -345,16 +345,33 @@ void PresetCollection::save_current_preset(const std::string &new_name)
     if (it != m_presets.end() && it->name == new_name) {
         // Preset with the same name found.
         Preset &preset = *it;
-        if (preset.is_default)
+        if (preset.is_default || preset.is_external || preset.is_system)
             // Cannot overwrite the default preset.
             return;
         // Overwriting an existing preset.
         preset.config = std::move(m_edited_preset.config);
     } else {
         // Creating a new preset.
-		Preset &preset = *m_presets.insert(it, m_edited_preset);
+		Preset       &preset   = *m_presets.insert(it, m_edited_preset);
+        std::string  &inherits = preset.config.opt_string("inherits", true);
+        std::string   old_name = preset.name;
         preset.name = new_name;
 		preset.file = this->path_from_name(new_name);
+        preset.vendor = nullptr;
+        if (preset.is_system) {
+            // Inheriting from a system preset.
+            inherits = /* preset.vendor->name + "/" + */ old_name;
+        } else if (inherits.empty()) {
+            // Inheriting from a user preset. Link the new preset to the old preset.
+            inherits = old_name;
+        } else {
+            // Inherited from a user preset. Just maintain the "inherited" flag, 
+            // meaning it will inherit from either the system preset, or the inherited user preset.
+        }
+        preset.inherits = inherits;
+        preset.is_default  = false;
+        preset.is_system   = false;
+        preset.is_external = false;
     }
 	// 2) Activate the saved preset.
 	this->select_preset_by_name(new_name, true);
@@ -387,6 +404,15 @@ bool PresetCollection::load_bitmap_default(const std::string &file_name)
     return m_bitmap_main_frame->LoadFile(wxString::FromUTF8(Slic3r::var(file_name).c_str()), wxBITMAP_TYPE_PNG);
 }
 
+const Preset* PresetCollection::get_selected_preset_parent() const
+{
+    auto *inherits = dynamic_cast<const ConfigOptionString*>(this->get_edited_preset().config.option("inherits"));
+    if (inherits == nullptr || inherits->value.empty())
+        return nullptr;
+    const Preset* preset = this->find_preset(inherits->value, false);
+    return (preset == nullptr || preset->is_default || preset->is_external) ? nullptr : preset;
+}
+
 // Return a preset by its name. If the preset is active, a temporary copy is returned.
 // If a preset is not found by its name, null is returned.
 Preset* PresetCollection::find_preset(const std::string &name, bool first_visible_if_not_found)
@@ -530,16 +556,19 @@ bool PresetCollection::update_dirty_ui(wxBitmapComboBox *ui)
     return was_dirty != is_dirty;
 }
 
-std::vector<std::string> PresetCollection::current_dirty_options() const
+std::vector<std::string> PresetCollection::dirty_options(const Preset *edited, const Preset *reference)
-{ 
+{
-    std::vector<std::string> changed = this->get_selected_preset().config.diff(this->get_edited_preset().config);
+    std::vector<std::string> changed;
-    // The "compatible_printers" option key is handled differently from the others:
+    if (edited != nullptr && reference != nullptr) {
-    // It is not mandatory. If the key is missing, it means it is compatible with any printer.
+        changed = reference->config.diff(edited->config);
-    // If the key exists and it is empty, it means it is compatible with no printer.
+        // The "compatible_printers" option key is handled differently from the others:
-    std::initializer_list<const char*> optional_keys { "compatible_printers", "compatible_printers_condition" };
+        // It is not mandatory. If the key is missing, it means it is compatible with any printer.
-    for (auto &opt_key : optional_keys) {
+        // If the key exists and it is empty, it means it is compatible with no printer.
-        if (this->get_selected_preset().config.has(opt_key) != this->get_edited_preset().config.has(opt_key))
+        std::initializer_list<const char*> optional_keys { "compatible_printers", "compatible_printers_condition" };
-            changed.emplace_back(opt_key);
+        for (auto &opt_key : optional_keys) {
+            if (reference->config.has(opt_key) != edited->config.has(opt_key))
+                changed.emplace_back(opt_key);
+        }
     }
     return changed;
 }

xs/src/slic3r/GUI/Preset.hpp

@@ -191,6 +191,8 @@ public:
     // Compatible & incompatible marks, to be placed at the wxBitmapComboBox items.
     void            set_bitmap_compatible  (const wxBitmap *bmp) { m_bitmap_compatible   = bmp; }
     void            set_bitmap_incompatible(const wxBitmap *bmp) { m_bitmap_incompatible = bmp; }
+    void            set_bitmap_lock        (const wxBitmap *bmp) { m_bitmap_lock         = bmp; }
+    void            set_bitmap_lock_open   (const wxBitmap *bmp) { m_bitmap_lock_open    = bmp; }
 
     // Enable / disable the "- default -" preset.
     void            set_default_suppressed(bool default_suppressed);
@@ -202,6 +204,11 @@ public:
     Preset&         get_selected_preset()       { return m_presets[m_idx_selected]; }
     const Preset&   get_selected_preset() const { return m_presets[m_idx_selected]; }
     int             get_selected_idx()    const { return m_idx_selected; }
+    // For the current edited preset, return the parent preset if there is one.
+    // If there is no parent preset, nullptr is returned.
+    // The parent preset may be a system preset or a user preset, which will be
+    // reflected by the UI.
+    const Preset*   get_selected_preset_parent() const;
     // Return the selected preset including the user modifications.
     Preset&         get_edited_preset()         { return m_edited_preset; }
     const Preset&   get_edited_preset() const   { return m_edited_preset; }
@@ -238,7 +245,11 @@ public:
     // Compare the content of get_selected_preset() with get_edited_preset() configs, return true if they differ.
     bool                        current_is_dirty() const { return ! this->current_dirty_options().empty(); }
     // Compare the content of get_selected_preset() with get_edited_preset() configs, return the list of keys where they differ.
-    std::vector<std::string>    current_dirty_options() const;
+    std::vector<std::string>    current_dirty_options() const 
+        { return dirty_options(&this->get_edited_preset(), &this->get_selected_preset()); }
+    // Compare the content of get_selected_preset() with get_edited_preset() configs, return the list of keys where they differ.
+    std::vector<std::string>    current_different_from_parent_options() const
+        { return dirty_options(&this->get_edited_preset(), this->get_selected_preset_parent()); }
 
     // Update the choice UI from the list of presets.
     // If show_incompatible, all presets are shown, otherwise only the compatible presets are shown.
@@ -278,6 +289,8 @@ private:
     std::deque<Preset>::const_iterator find_preset_internal(const std::string &name) const
         { return const_cast<PresetCollection*>(this)->find_preset_internal(name); }
 
+    static std::vector<std::string> dirty_options(const Preset *edited, const Preset *reference);
+
     // Type of this PresetCollection: TYPE_PRINT, TYPE_FILAMENT or TYPE_PRINTER.
     Preset::Type            m_type;
     // List of presets, starting with the "- default -" preset.
@@ -292,8 +305,10 @@ private:
     bool                    m_default_suppressed = true;
     // Compatible & incompatible marks, to be placed at the wxBitmapComboBox items of a Platter.
     // These bitmaps are not owned by PresetCollection, but by a PresetBundle.
-    const wxBitmap         *m_bitmap_compatible = nullptr;
+    const wxBitmap         *m_bitmap_compatible   = nullptr;
     const wxBitmap         *m_bitmap_incompatible = nullptr;
+    const wxBitmap         *m_bitmap_lock         = nullptr;
+    const wxBitmap         *m_bitmap_lock_open    = nullptr;
     // Marks placed at the wxBitmapComboBox of a MainFrame.
     // These bitmaps are owned by PresetCollection.
     wxBitmap               *m_bitmap_main_frame;

xs/src/slic3r/GUI/PresetBundle.cpp

@@ -2,6 +2,7 @@
 #include <cassert>
 
 #include "PresetBundle.hpp"
+#include "BitmapCache.hpp"
 
 #include <fstream>
 #include <boost/filesystem.hpp>
@@ -37,7 +38,10 @@ PresetBundle::PresetBundle() :
     filaments(Preset::TYPE_FILAMENT, Preset::filament_options()), 
     printers(Preset::TYPE_PRINTER, Preset::printer_options()),
     m_bitmapCompatible(new wxBitmap),
-    m_bitmapIncompatible(new wxBitmap)
+    m_bitmapIncompatible(new wxBitmap),
+    m_bitmapLock(new wxBitmap),
+    m_bitmapLockOpen(new wxBitmap),
+    m_bitmapCache(new GUI::BitmapCache)
 {
     if (wxImage::FindHandler(wxBITMAP_TYPE_PNG) == nullptr)
         wxImage::AddHandler(new wxPNGHandler);
@@ -70,12 +74,18 @@ PresetBundle::~PresetBundle()
 {
 	assert(m_bitmapCompatible != nullptr);
 	assert(m_bitmapIncompatible != nullptr);
+    assert(m_bitmapLock != nullptr);
+    assert(m_bitmapLockOpen != nullptr);
 	delete m_bitmapCompatible;
 	m_bitmapCompatible = nullptr;
     delete m_bitmapIncompatible;
 	m_bitmapIncompatible = nullptr;
-    for (std::pair<const std::string, wxBitmap*> &bitmap : m_mapColorToBitmap)
+    delete m_bitmapLock;
-        delete bitmap.second;
+    m_bitmapLock = nullptr;
+    delete m_bitmapLockOpen;
+    m_bitmapLockOpen = nullptr;
+    delete m_bitmapCache;
+    m_bitmapCache = nullptr;
 }
 
 void PresetBundle::reset(bool delete_files)
@@ -244,10 +254,16 @@ bool PresetBundle::load_compatible_bitmaps()
 {
     const std::string path_bitmap_compatible   = "flag-green-icon.png";
     const std::string path_bitmap_incompatible = "flag-red-icon.png";
+    const std::string path_bitmap_lock         = "lock.png";
+    const std::string path_bitmap_lock_open    = "lock_open.png";
     bool loaded_compatible   = m_bitmapCompatible  ->LoadFile(
         wxString::FromUTF8(Slic3r::var(path_bitmap_compatible).c_str()), wxBITMAP_TYPE_PNG);
     bool loaded_incompatible = m_bitmapIncompatible->LoadFile(
         wxString::FromUTF8(Slic3r::var(path_bitmap_incompatible).c_str()), wxBITMAP_TYPE_PNG);
+    bool loaded_lock = m_bitmapLock->LoadFile(
+        wxString::FromUTF8(Slic3r::var(path_bitmap_lock).c_str()), wxBITMAP_TYPE_PNG);
+    bool loaded_lock_open = m_bitmapLockOpen->LoadFile(
+        wxString::FromUTF8(Slic3r::var(path_bitmap_lock_open).c_str()), wxBITMAP_TYPE_PNG);
     if (loaded_compatible) {
         prints   .set_bitmap_compatible(m_bitmapCompatible);
         filaments.set_bitmap_compatible(m_bitmapCompatible);
@@ -258,7 +274,17 @@ bool PresetBundle::load_compatible_bitmaps()
         filaments.set_bitmap_incompatible(m_bitmapIncompatible);
 //        printers .set_bitmap_incompatible(m_bitmapIncompatible);        
     }
-    return loaded_compatible && loaded_incompatible;
+    if (loaded_lock) {
+        prints   .set_bitmap_lock(m_bitmapLock);
+        filaments.set_bitmap_lock(m_bitmapLock);
+        printers .set_bitmap_lock(m_bitmapLock);
+    }
+    if (loaded_lock_open) {
+        prints   .set_bitmap_lock_open(m_bitmapLock);
+        filaments.set_bitmap_lock_open(m_bitmapLock);
+        printers .set_bitmap_lock_open(m_bitmapLock);
+    }
+    return loaded_compatible && loaded_incompatible && loaded_lock && loaded_lock_open;
 }
 
 DynamicPrintConfig PresetBundle::full_config() const
@@ -973,49 +999,26 @@ void PresetBundle::update_platter_filament_ui(unsigned int idx_extruder, wxBitma
         // If the filament preset is not compatible and there is a "red flag" icon loaded, show it left
         // to the filament color image.
         if (wide_icons)
-            bitmap_key += preset.is_compatible ? "comp" : "notcomp";
+            bitmap_key += preset.is_compatible ? ",cmpt" : ",ncmpt";
-        auto          it           = m_mapColorToBitmap.find(bitmap_key);
+        bitmap_key += (preset.is_system || preset.is_default) ? ",syst" : ",nsyst";
-        wxBitmap     *bitmap       = (it == m_mapColorToBitmap.end()) ? nullptr : it->second;
+        wxBitmap     *bitmap       = m_bitmapCache->find(bitmap_key);
         if (bitmap == nullptr) {
             // Create the bitmap with color bars.
-            bitmap = new wxBitmap((wide_icons ? 16 : 0) + 24, 16);
+            std::vector<wxBitmap> bmps;
-#if defined(__APPLE__) || defined(_MSC_VER)
+            if (wide_icons)
-            bitmap->UseAlpha();
+                // Paint a red flag for incompatible presets.
-#endif
+                bmps.emplace_back(preset.is_compatible ? m_bitmapCache->mkclear(16, 16) : *m_bitmapIncompatible);
-            wxMemoryDC memDC;
-            memDC.SelectObject(*bitmap);
-            memDC.SetBackground(*wxTRANSPARENT_BRUSH);
-            memDC.Clear();
-            if (wide_icons && ! preset.is_compatible)
-                // Paint the red flag.
-                memDC.DrawBitmap(*m_bitmapIncompatible, 0, 0, true);
             // Paint the color bars.
             parse_color(filament_rgb, rgb);
-            wxImage image(24, 16);
+            bmps.emplace_back(m_bitmapCache->mksolid(single_bar ? 24 : 16, 16, rgb));
-            image.InitAlpha();
-            unsigned char* imgdata = image.GetData();
-            unsigned char* imgalpha = image.GetAlpha();
-            for (size_t i = 0; i < image.GetWidth() * image.GetHeight(); ++ i) {
-                *imgdata ++ = rgb[0];
-                *imgdata ++ = rgb[1];
-                *imgdata ++ = rgb[2];
-                *imgalpha ++ = wxALPHA_OPAQUE;
-            }
             if (! single_bar) {
                 parse_color(extruder_rgb, rgb);
-                imgdata = image.GetData();
+                bmps.emplace_back(m_bitmapCache->mksolid(8,  16, rgb));
-                for (size_t r = 0; r < 16; ++ r) {
-                    imgdata = image.GetData() + r * image.GetWidth() * 3;
-                    for (size_t c = 0; c < 16; ++ c) {
-                        *imgdata ++ = rgb[0];
-                        *imgdata ++ = rgb[1];
-                        *imgdata ++ = rgb[2];
-                    }
-                }
             }
-            memDC.DrawBitmap(wxBitmap(image), wide_icons ? 16 : 0, 0, true);
+            // Paint a lock at the system presets.
-            memDC.SelectObject(wxNullBitmap);
+            bmps.emplace_back(m_bitmapCache->mkclear(4, 16));
-            m_mapColorToBitmap[bitmap_key] = bitmap;
+            bmps.emplace_back((preset.is_system || preset.is_default) ? *m_bitmapLock : m_bitmapCache->mkclear(16, 16));
+            bitmap = m_bitmapCache->insert(bitmap_key, bmps);
 		}
 		ui->Append(wxString::FromUTF8((preset.name + (preset.is_dirty ? Preset::suffix_modified() : "")).c_str()), (bitmap == 0) ? wxNullBitmap : *bitmap);
         if (selected)

xs/src/slic3r/GUI/PresetBundle.hpp

@@ -8,6 +8,10 @@
 
 namespace Slic3r {
 
+namespace GUI {
+    class BitmapCache;
+};
+
 class PlaceholderParser;
 
 // Bundle of Print + Filament + Printer presets.
@@ -131,8 +135,12 @@ private:
     wxBitmap                            *m_bitmapCompatible;
     // Indicator, that the preset is NOT compatible with the selected printer.
     wxBitmap                            *m_bitmapIncompatible;
-    // Caching color bitmaps for the 
+    // Indicator, that the preset is system and not modified.
-    std::map<std::string, wxBitmap*>     m_mapColorToBitmap;
+    wxBitmap                            *m_bitmapLock;
+    // Indicator, that the preset is system and user modified.
+    wxBitmap                            *m_bitmapLockOpen;
+    // Caching color bitmaps for the filament combo box.
+    GUI::BitmapCache                    *m_bitmapCache;
 };
 
 } // namespace Slic3r