From 30c859ac7f8568ce6e102f7d511d6ec49898c5b7 Mon Sep 17 00:00:00 2001 From: bubnikv Date: Mon, 12 Mar 2018 16:04:32 +0100 Subject: [PATCH] Added a lock icon to the list of filaments, added some helper methods to PresetBundle. --- xs/CMakeLists.txt | 2 + xs/src/slic3r/GUI/BitmapCache.cpp | 120 +++++++++++++++++++++++++++++ xs/src/slic3r/GUI/BitmapCache.hpp | 43 +++++++++++ xs/src/slic3r/GUI/Field.hpp | 4 +- xs/src/slic3r/GUI/Preset.cpp | 53 ++++++++++--- xs/src/slic3r/GUI/Preset.hpp | 19 ++++- xs/src/slic3r/GUI/PresetBundle.cpp | 83 ++++++++++---------- xs/src/slic3r/GUI/PresetBundle.hpp | 12 ++- 8 files changed, 277 insertions(+), 59 deletions(-) create mode 100644 xs/src/slic3r/GUI/BitmapCache.cpp create mode 100644 xs/src/slic3r/GUI/BitmapCache.hpp diff --git a/xs/CMakeLists.txt b/xs/CMakeLists.txt index 590b5d24f..d834b4608 100644 --- a/xs/CMakeLists.txt +++ b/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 diff --git a/xs/src/slic3r/GUI/BitmapCache.cpp b/xs/src/slic3r/GUI/BitmapCache.cpp new file mode 100644 index 000000000..f92369650 --- /dev/null +++ b/xs/src/slic3r/GUI/BitmapCache.cpp @@ -0,0 +1,120 @@ +#include "BitmapCache.hpp" + +namespace Slic3r { namespace GUI { + +void BitmapCache::clear() +{ + for (std::pair &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 &bmps) +{ + size_t width = 0; + size_t height = 0; + for (wxBitmap &bmp : bmps) { + width += bmp.GetWidth(); + height = std::max(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 diff --git a/xs/src/slic3r/GUI/BitmapCache.hpp b/xs/src/slic3r/GUI/BitmapCache.hpp new file mode 100644 index 000000000..0cf9d8acf --- /dev/null +++ b/xs/src/slic3r/GUI/BitmapCache.hpp @@ -0,0 +1,43 @@ +#ifndef SLIC3R_GUI_BITMAP_CACHE_HPP +#define SLIC3R_GUI_BITMAP_CACHE_HPP + +#include +#ifndef WX_PRECOMP + #include +#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(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 &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 m_map; +}; + +} // GUI +} // Slic3r + +#endif /* SLIC3R_GUI_BITMAP_CACHE_HPP */ diff --git a/xs/src/slic3r/GUI/Field.hpp b/xs/src/slic3r/GUI/Field.hpp index 492629b41..9d4febe2e 100644 --- a/xs/src/slic3r/GUI/Field.hpp +++ b/xs/src/slic3r/GUI/Field.hpp @@ -264,9 +264,7 @@ public: wxSizer* getSizer() override { return sizer; } }; - -#endif } // GUI } // Slic3r - +#endif /* SLIC3R_GUI_FIELD_HPP */ diff --git a/xs/src/slic3r/GUI/Preset.cpp b/xs/src/slic3r/GUI/Preset.cpp index d3d569cae..a1706ba47 100644 --- a/xs/src/slic3r/GUI/Preset.cpp +++ b/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(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 PresetCollection::current_dirty_options() const -{ - std::vector changed = this->get_selected_preset().config.diff(this->get_edited_preset().config); - // The "compatible_printers" option key is handled differently from the others: - // It is not mandatory. If the key is missing, it means it is compatible with any printer. - // If the key exists and it is empty, it means it is compatible with no printer. - std::initializer_list optional_keys { "compatible_printers", "compatible_printers_condition" }; - for (auto &opt_key : optional_keys) { - if (this->get_selected_preset().config.has(opt_key) != this->get_edited_preset().config.has(opt_key)) - changed.emplace_back(opt_key); +std::vector PresetCollection::dirty_options(const Preset *edited, const Preset *reference) +{ + std::vector changed; + if (edited != nullptr && reference != nullptr) { + changed = reference->config.diff(edited->config); + // The "compatible_printers" option key is handled differently from the others: + // It is not mandatory. If the key is missing, it means it is compatible with any printer. + // If the key exists and it is empty, it means it is compatible with no printer. + std::initializer_list optional_keys { "compatible_printers", "compatible_printers_condition" }; + for (auto &opt_key : optional_keys) { + if (reference->config.has(opt_key) != edited->config.has(opt_key)) + changed.emplace_back(opt_key); + } } return changed; } diff --git a/xs/src/slic3r/GUI/Preset.hpp b/xs/src/slic3r/GUI/Preset.hpp index c56b91bcf..a6ce77dfe 100644 --- a/xs/src/slic3r/GUI/Preset.hpp +++ b/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 current_dirty_options() const; + std::vector 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 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::const_iterator find_preset_internal(const std::string &name) const { return const_cast(this)->find_preset_internal(name); } + static std::vector 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; diff --git a/xs/src/slic3r/GUI/PresetBundle.cpp b/xs/src/slic3r/GUI/PresetBundle.cpp index 77eb5c081..453208fde 100644 --- a/xs/src/slic3r/GUI/PresetBundle.cpp +++ b/xs/src/slic3r/GUI/PresetBundle.cpp @@ -2,6 +2,7 @@ #include #include "PresetBundle.hpp" +#include "BitmapCache.hpp" #include #include @@ -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 &bitmap : m_mapColorToBitmap) - delete bitmap.second; + delete m_bitmapLock; + 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"; - auto it = m_mapColorToBitmap.find(bitmap_key); - wxBitmap *bitmap = (it == m_mapColorToBitmap.end()) ? nullptr : it->second; + bitmap_key += preset.is_compatible ? ",cmpt" : ",ncmpt"; + bitmap_key += (preset.is_system || preset.is_default) ? ",syst" : ",nsyst"; + 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); -#if defined(__APPLE__) || defined(_MSC_VER) - bitmap->UseAlpha(); -#endif - 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); + std::vector bmps; + if (wide_icons) + // Paint a red flag for incompatible presets. + bmps.emplace_back(preset.is_compatible ? m_bitmapCache->mkclear(16, 16) : *m_bitmapIncompatible); // Paint the color bars. parse_color(filament_rgb, rgb); - wxImage image(24, 16); - 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; - } + bmps.emplace_back(m_bitmapCache->mksolid(single_bar ? 24 : 16, 16, rgb)); if (! single_bar) { parse_color(extruder_rgb, rgb); - imgdata = image.GetData(); - 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]; - } - } + bmps.emplace_back(m_bitmapCache->mksolid(8, 16, rgb)); } - memDC.DrawBitmap(wxBitmap(image), wide_icons ? 16 : 0, 0, true); - memDC.SelectObject(wxNullBitmap); - m_mapColorToBitmap[bitmap_key] = bitmap; + // Paint a lock at the system presets. + bmps.emplace_back(m_bitmapCache->mkclear(4, 16)); + 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) diff --git a/xs/src/slic3r/GUI/PresetBundle.hpp b/xs/src/slic3r/GUI/PresetBundle.hpp index aaa66265a..f481ba374 100644 --- a/xs/src/slic3r/GUI/PresetBundle.hpp +++ b/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 - std::map m_mapColorToBitmap; + // Indicator, that the preset is system and not modified. + 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