3DPrinting/PrusaSlicer-NonPlainar
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

rename font_item to style

Browse Source
This commit is contained in:
Filip Sykala - NTB T15p 2022-08-03 13:05:06 +02:00
parent 8e261ace29
commit 5e76d86460
7 changed files with 173 additions and 151 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/libslic3r/AppConfig.cpp
View File

@ -39,7 +39,7 @@ static const std::string VERSION_CHECK_URL = "https://files.prusa3d.com/wp-conte
const std::string AppConfig::SECTION_FILAMENTS = "filaments"; const std::string AppConfig::SECTION_FILAMENTS = "filaments";
const std::string AppConfig::SECTION_MATERIALS = "sla_materials"; const std::string AppConfig::SECTION_MATERIALS = "sla_materials";
const std::string AppConfig::SECTION_FONT = "font"; const std::string AppConfig::SECTION_EMBOSS_STYLE = "font";
void AppConfig::reset() void AppConfig::reset()
{ {

2
src/libslic3r/AppConfig.hpp
View File

@ -167,7 +167,7 @@ public:
static const std::string SECTION_FILAMENTS; static const std::string SECTION_FILAMENTS;
static const std::string SECTION_MATERIALS; static const std::string SECTION_MATERIALS;
static const std::string SECTION_FONT; static const std::string SECTION_EMBOSS_STYLE;
private: private:
template<typename T> template<typename T>

113
src/slic3r/GUI/Gizmos/GLGizmoEmboss.cpp
View File

@ -165,9 +165,8 @@ void GLGizmoEmboss::create_volume(ModelVolumeType volume_type, const Vec2d& mous
volume_type == ModelVolumeType::NEGATIVE_VOLUME || volume_type == ModelVolumeType::NEGATIVE_VOLUME ||
volume_type == ModelVolumeType::PARAMETER_MODIFIER); volume_type == ModelVolumeType::PARAMETER_MODIFIER);
if (!m_gui_cfg.has_value()) initialize(); if (!m_gui_cfg.has_value()) initialize();
set_default_text(); set_default_text();
discard_changes_in_style(); m_style_manager.discard_style_changes();
Vec2d screen_coor = mouse_pos; Vec2d screen_coor = mouse_pos;
if (mouse_pos.x() < 0 || mouse_pos.y() < 0) { if (mouse_pos.x() < 0 || mouse_pos.y() < 0) {
@ -537,7 +536,7 @@ static void draw_mouse_offset(const std::optional<Vec2d> &offset)
void GLGizmoEmboss::on_render_input_window(float x, float y, float bottom_limit) void GLGizmoEmboss::on_render_input_window(float x, float y, float bottom_limit)
{ {
initialize(); if (!m_gui_cfg.has_value()) initialize();
check_selection(); check_selection();
// TODO: fix width - showing scroll in first draw of advanced. // TODO: fix width - showing scroll in first draw of advanced.
@ -981,7 +980,7 @@ void GLGizmoEmboss::draw_window()
if (ImGui::Button("use system font")) { if (ImGui::Button("use system font")) {
size_t font_index = m_style_items.size(); size_t font_index = m_style_items.size();
m_style_items.emplace_back(WxFontUtils::get_os_font()); m_style_items.emplace_back(WxFontUtils::get_os_font());
bool loaded = load_font(font_index); bool loaded = load_style(font_index);
} }
#endif // ALLOW_DEBUG_MODE #endif // ALLOW_DEBUG_MODE
@ -1013,7 +1012,7 @@ void GLGizmoEmboss::draw_window()
#ifdef SHOW_WX_FONT_DESCRIPTOR #ifdef SHOW_WX_FONT_DESCRIPTOR
if (is_selected_style) if (is_selected_style)
m_imgui->text_colored(ImGuiWrapper::COL_GREY_DARK, m_style_manager.get_font_item().path); m_imgui->text_colored(ImGuiWrapper::COL_GREY_DARK, m_style_manager.get_style().path);
#endif // SHOW_WX_FONT_DESCRIPTOR #endif // SHOW_WX_FONT_DESCRIPTOR
if (ImGui::Button(_u8L("Close").c_str())) close(); if (ImGui::Button(_u8L("Close").c_str())) close();
@ -1471,15 +1470,15 @@ void GLGizmoEmboss::draw_model_type()
} }
void GLGizmoEmboss::draw_style_rename_popup() { void GLGizmoEmboss::draw_style_rename_popup() {
std::string& new_name = m_style_manager.get_font_item().name; std::string& new_name = m_style_manager.get_style().name;
const std::string &old_name = m_style_manager.get_stored_font_item()->name; const std::string &old_name = m_style_manager.get_stored_style()->name;
std::string text_in_popup = GUI::format(_u8L("Rename style(%1%) for embossing text: "), old_name); std::string text_in_popup = GUI::format(_u8L("Rename style(%1%) for embossing text: "), old_name);
ImGui::Text("%s", text_in_popup.c_str()); ImGui::Text("%s", text_in_popup.c_str());
bool is_unique = true; bool is_unique = true;
for (const auto &item : m_style_manager.get_styles()) { for (const auto &item : m_style_manager.get_styles()) {
const EmbossStyle &style = item.font_item; const EmbossStyle &style = item.style;
if (&style == &m_style_manager.get_font_item()) if (&style == &m_style_manager.get_style())
continue; // could be same as original name continue; // could be same as original name
if (style.name == new_name) is_unique = false; if (style.name == new_name) is_unique = false;
} }
@ -1526,7 +1525,7 @@ void GLGizmoEmboss::draw_style_rename_button()
std::string title = _u8L("Rename style"); std::string title = _u8L("Rename style");
const char * popup_id = title.c_str(); const char * popup_id = title.c_str();
if (draw_button(IconType::rename, !can_rename)) { if (draw_button(IconType::rename, !can_rename)) {
assert(m_style_manager.get_stored_font_item()); assert(m_style_manager.get_stored_style());
ImGui::OpenPopup(popup_id); ImGui::OpenPopup(popup_id);
} }
else if (ImGui::IsItemHovered()) { else if (ImGui::IsItemHovered()) {
@ -1544,9 +1543,9 @@ void GLGizmoEmboss::draw_style_save_button()
bool is_stored_style = m_style_manager.exist_stored_style(); bool is_stored_style = m_style_manager.exist_stored_style();
const EmbossStyle *stored_syle = nullptr; const EmbossStyle *stored_syle = nullptr;
if (is_stored_style) if (is_stored_style)
stored_syle = m_style_manager.get_stored_font_item(); stored_syle = m_style_manager.get_stored_style();
const EmbossStyle &style = m_style_manager.get_font_item(); const EmbossStyle &style = m_style_manager.get_style();
bool is_changed = (stored_syle)? !(*stored_syle == style) : true; bool is_changed = (stored_syle)? !(*stored_syle == style) : true;
bool is_style_order_changed = m_style_manager.is_style_order_changed(); bool is_style_order_changed = m_style_manager.is_style_order_changed();
@ -1580,7 +1579,7 @@ void GLGizmoEmboss::draw_style_save_as_popup() {
bool is_unique = true; bool is_unique = true;
for (const auto &item : m_style_manager.get_styles()) for (const auto &item : m_style_manager.get_styles())
if (item.font_item.name == new_name) is_unique = false; if (item.style.name == new_name) is_unique = false;
bool allow_change = false; bool allow_change = false;
if (new_name.empty()) { if (new_name.empty()) {
@ -1603,7 +1602,7 @@ void GLGizmoEmboss::draw_style_save_as_popup() {
ImGui::SameLine(); ImGui::SameLine();
if (ImGui::Button(_u8L("cancel").c_str())){ if (ImGui::Button(_u8L("cancel").c_str())){
// write original name to volume TextConfiguration // write original name to volume TextConfiguration
new_name = m_style_manager.get_font_item().name; new_name = m_style_manager.get_style().name;
ImGui::CloseCurrentPopup(); ImGui::CloseCurrentPopup();
} }
@ -1654,8 +1653,8 @@ void GLGizmoEmboss::draw_style_undo_button() {
const EmbossStyle *stored_style = nullptr; const EmbossStyle *stored_style = nullptr;
bool is_stored = m_style_manager.exist_stored_style(); bool is_stored = m_style_manager.exist_stored_style();
if (is_stored) if (is_stored)
stored_style = m_style_manager.get_stored_font_item(); stored_style = m_style_manager.get_stored_style();
const EmbossStyle &style = m_style_manager.get_font_item(); const EmbossStyle &style = m_style_manager.get_style();
bool is_changed = (stored_style)? !(*stored_style == style) : true; bool is_changed = (stored_style)? !(*stored_style == style) : true;
bool can_undo = is_stored && is_changed; bool can_undo = is_stored && is_changed;
if (draw_button(IconType::undo, !can_undo)) { if (draw_button(IconType::undo, !can_undo)) {
@ -1692,20 +1691,20 @@ void GLGizmoEmboss::draw_delete_style_button() {
} }
// IMPROVE: add function can_load? // IMPROVE: add function can_load?
// clean unactivable styles // clean unactivable styles
if (!m_style_manager.load_font(next_style_index)) { if (!m_style_manager.load_style(next_style_index)) {
m_style_manager.erase(next_style_index); m_style_manager.erase(next_style_index);
continue; continue;
} }
// load back // load back
m_style_manager.load_font(activ_index); m_style_manager.load_style(activ_index);
ImGui::OpenPopup(popup_id); ImGui::OpenPopup(popup_id);
break; break;
} }
} }
if (ImGui::IsItemHovered()) { if (ImGui::IsItemHovered()) {
const std::string &style_name = m_style_manager.get_font_item().name; const std::string &style_name = m_style_manager.get_style().name;
std::string tooltip; std::string tooltip;
if (can_delete) tooltip = GUI::format(_L("Delete \"%1%\" style."), style_name); if (can_delete) tooltip = GUI::format(_L("Delete \"%1%\" style."), style_name);
else if (is_last) tooltip = GUI::format(_L("Can't delete \"%1%\". It is last style."), style_name); else if (is_last) tooltip = GUI::format(_L("Can't delete \"%1%\". It is last style."), style_name);
@ -1714,12 +1713,12 @@ void GLGizmoEmboss::draw_delete_style_button() {
} }
if (ImGui::BeginPopupModal(popup_id)) { if (ImGui::BeginPopupModal(popup_id)) {
const std::string &style_name = m_style_manager.get_font_item().name; const std::string &style_name = m_style_manager.get_style().name;
std::string text_in_popup = GUI::format(_u8L("Are you sure,\nthat you want permanently and unrecoverable \nremove style \"%1%\"?"), style_name); std::string text_in_popup = GUI::format(_u8L("Are you sure,\nthat you want permanently and unrecoverable \nremove style \"%1%\"?"), style_name);
ImGui::Text("%s", text_in_popup.c_str()); ImGui::Text("%s", text_in_popup.c_str());
if (ImGui::Button(_u8L("Yes").c_str())) { if (ImGui::Button(_u8L("Yes").c_str())) {
size_t activ_index = m_style_manager.get_style_index(); size_t activ_index = m_style_manager.get_style_index();
m_style_manager.load_font(next_style_index); m_style_manager.load_style(next_style_index);
m_style_manager.erase(activ_index); m_style_manager.erase(activ_index);
m_style_manager.store_styles_to_app_config(wxGetApp().app_config); m_style_manager.store_styles_to_app_config(wxGetApp().app_config);
ImGui::CloseCurrentPopup(); ImGui::CloseCurrentPopup();
@ -1736,8 +1735,8 @@ void GLGizmoEmboss::discard_changes_in_style()
{ {
if (!m_style_manager.exist_stored_style()) return; if (!m_style_manager.exist_stored_style()) return;
EmbossStyle &emboss_style = m_style_manager.get_font_item(); EmbossStyle &emboss_style = m_style_manager.get_style();
const EmbossStyle* stored_style = m_style_manager.get_stored_font_item(); const EmbossStyle* stored_style = m_style_manager.get_stored_style();
assert(stored_style != nullptr); assert(stored_style != nullptr);
// is rotation changed // is rotation changed
@ -1772,7 +1771,7 @@ void GLGizmoEmboss::discard_changes_in_style()
if (emboss_style.path != stored_style->path) { if (emboss_style.path != stored_style->path) {
// NOTE: load font file again // NOTE: load font file again
m_style_manager.load_font(m_style_manager.get_style_index()); m_style_manager.load_style(m_style_manager.get_style_index());
//m_style_manager.get_wx_font() = WxFontUtils::load_wxFont(emboss_style.path); //m_style_manager.get_wx_font() = WxFontUtils::load_wxFont(emboss_style.path);
//m_style_manager.wx_font_changed(); //m_style_manager.wx_font_changed();
} }
@ -1791,11 +1790,11 @@ void GLGizmoEmboss::draw_revert_all_styles_button() {
void GLGizmoEmboss::draw_style_list() { void GLGizmoEmboss::draw_style_list() {
if (!m_style_manager.is_activ_font()) return; if (!m_style_manager.is_activ_font()) return;
const float &max_style_name_width = m_gui_cfg->max_style_name_width; const float &max_style_name_width = m_gui_cfg->max_style_name_width;
const EmbossStyle &actual_font_item = m_style_manager.get_font_item(); const EmbossStyle &actual_style = m_style_manager.get_style();
std::string &trunc_name = m_style_manager.get_truncated_name(); std::string &trunc_name = m_style_manager.get_truncated_name();
if (trunc_name.empty()) { if (trunc_name.empty()) {
// generate trunc name // generate trunc name
const std::string &current_name = actual_font_item.name; const std::string &current_name = actual_style.name;
trunc_name = ImGuiWrapper::trunc(current_name, max_style_name_width); trunc_name = ImGuiWrapper::trunc(current_name, max_style_name_width);
} }
@ -1812,17 +1811,17 @@ void GLGizmoEmboss::draw_style_list() {
const std::vector<EmbossStyleManager::Item> &styles = m_style_manager.get_styles(); const std::vector<EmbossStyleManager::Item> &styles = m_style_manager.get_styles();
for (const auto &item : styles) { for (const auto &item : styles) {
size_t index = &item - &styles.front(); size_t index = &item - &styles.front();
const EmbossStyle &es = item.font_item; const EmbossStyle &es = item.style;
const std::string &actual_style_name = es.name; const std::string &actual_style_name = es.name;
ImGui::PushID(actual_style_name.c_str()); ImGui::PushID(actual_style_name.c_str());
bool is_selected = (&es == &actual_font_item); bool is_selected = (&es == &actual_style);
ImVec2 select_size(0,m_gui_cfg->max_style_image_size.y()); // 0,0 --> calculate in draw ImVec2 select_size(0,m_gui_cfg->max_style_image_size.y()); // 0,0 --> calculate in draw
const std::optional<EmbossStyleManager::StyleImage> img = item.image; const std::optional<EmbossStyleManager::StyleImage> img = item.image;
// allow click delete button // allow click delete button
ImGuiSelectableFlags_ flags = ImGuiSelectableFlags_AllowItemOverlap; ImGuiSelectableFlags_ flags = ImGuiSelectableFlags_AllowItemOverlap;
if (ImGui::Selectable(item.truncated_name.c_str(), is_selected, flags, select_size)) { if (ImGui::Selectable(item.truncated_name.c_str(), is_selected, flags, select_size)) {
if (m_style_manager.load_font(index)) if (m_style_manager.load_style(index))
process(); process();
} else if (ImGui::IsItemHovered()) } else if (ImGui::IsItemHovered())
ImGui::SetTooltip("%s", actual_style_name.c_str()); ImGui::SetTooltip("%s", actual_style_name.c_str());
@ -2060,10 +2059,16 @@ void GLGizmoEmboss::draw_style_edit() {
const GuiCfg::Translations &tr = m_gui_cfg->translations; const GuiCfg::Translations &tr = m_gui_cfg->translations;
const std::optional<wxFont> &wx_font_opt = m_style_manager.get_wx_font(); const std::optional<wxFont> &wx_font_opt = m_style_manager.get_wx_font();
EmbossStyle &style = m_style_manager.get_font_item(); EmbossStyle &style = m_style_manager.get_style();
assert(wx_font_opt.has_value()); assert(wx_font_opt.has_value());
if (!wx_font_opt.has_value()) { if (!wx_font_opt.has_value()) {
// TODO: should not be there
// when actual font not loaded try to load
if (style.type == WxFontUtils::get_actual_type()) {
std::optional<wxFont> new_wx_font = WxFontUtils::load_wxFont(style.path);
}
ImGui::TextColored(ImGuiWrapper::COL_ORANGE_DARK, "%s", _u8L("Font is not loaded properly. ")); ImGui::TextColored(ImGuiWrapper::COL_ORANGE_DARK, "%s", _u8L("Font is not loaded properly. "));
return; return;
} }
@ -2073,7 +2078,7 @@ void GLGizmoEmboss::draw_style_edit() {
bool is_font_changed = false; bool is_font_changed = false;
if (exist_stored_style && wx_font_opt.has_value()) { if (exist_stored_style && wx_font_opt.has_value()) {
const wxFont &wx_font = *wx_font_opt; const wxFont &wx_font = *wx_font_opt;
const EmbossStyle *stored_style = m_style_manager.get_stored_font_item(); const EmbossStyle *stored_style = m_style_manager.get_stored_style();
assert(stored_style != nullptr); assert(stored_style != nullptr);
const std::optional<wxFont> &stored_wx = m_style_manager.get_stored_wx_font(); const std::optional<wxFont> &stored_wx = m_style_manager.get_stored_wx_font();
assert(stored_wx.has_value()); assert(stored_wx.has_value());
@ -2113,7 +2118,7 @@ void GLGizmoEmboss::draw_style_edit() {
if (is_font_changed) { if (is_font_changed) {
ImGui::SameLine(ImGui::GetStyle().FramePadding.x); ImGui::SameLine(ImGui::GetStyle().FramePadding.x);
if (draw_button(IconType::undo)) { if (draw_button(IconType::undo)) {
const EmbossStyle *stored_style = m_style_manager.get_stored_font_item(); const EmbossStyle *stored_style = m_style_manager.get_stored_style();
style.path = stored_style->path; style.path = stored_style->path;
style.prop.boldness = stored_style->prop.boldness; style.prop.boldness = stored_style->prop.boldness;
style.prop.skew = stored_style->prop.skew; style.prop.skew = stored_style->prop.skew;
@ -2133,7 +2138,7 @@ void GLGizmoEmboss::draw_style_edit() {
FontProp &font_prop = style.prop; FontProp &font_prop = style.prop;
const float * def_size = exist_stored_style? const float * def_size = exist_stored_style?
&m_style_manager.get_stored_font_item()->prop.size_in_mm : nullptr; &m_style_manager.get_stored_style()->prop.size_in_mm : nullptr;
if (rev_input(tr.size, font_prop.size_in_mm, def_size, if (rev_input(tr.size, font_prop.size_in_mm, def_size,
_u8L("Revert text size."), 0.1f, 1.f, "%.1f mm")) { _u8L("Revert text size."), 0.1f, 1.f, "%.1f mm")) {
// size can't be zero or negative // size can't be zero or negative
@ -2183,7 +2188,7 @@ void GLGizmoEmboss::draw_style_edit() {
#endif // SHOW_WX_WEIGHT_INPUT #endif // SHOW_WX_WEIGHT_INPUT
const float *def_depth = exist_stored_style ? const float *def_depth = exist_stored_style ?
&m_style_manager.get_stored_font_item()->prop.emboss : nullptr; &m_style_manager.get_stored_style()->prop.emboss : nullptr;
if (rev_input(tr.depth, font_prop.emboss, def_depth, if (rev_input(tr.depth, font_prop.emboss, def_depth,
_u8L("Revert embossed depth."), 0.1f, 0.25, "%.2f mm")) { _u8L("Revert embossed depth."), 0.1f, 0.25, "%.2f mm")) {
Limits::apply(font_prop.emboss, limits.emboss); Limits::apply(font_prop.emboss, limits.emboss);
@ -2297,7 +2302,7 @@ void GLGizmoEmboss::draw_advanced()
return; return;
} }
FontProp &font_prop = m_style_manager.get_font_item().prop; FontProp &font_prop = m_style_manager.get_style().prop;
const auto &cn = m_style_manager.get_font_prop().collection_number; const auto &cn = m_style_manager.get_font_prop().collection_number;
unsigned int font_index = (cn.has_value()) ? *cn : 0; unsigned int font_index = (cn.has_value()) ? *cn : 0;
const auto &font_info = ff.font_file->infos[font_index]; const auto &font_info = ff.font_file->infos[font_index];
@ -2324,7 +2329,7 @@ void GLGizmoEmboss::draw_advanced()
const EmbossStyle *stored_style = nullptr; const EmbossStyle *stored_style = nullptr;
if (m_style_manager.exist_stored_style()) if (m_style_manager.exist_stored_style())
stored_style = m_style_manager.get_stored_font_item(); stored_style = m_style_manager.get_stored_style();
bool can_use_surface = (m_volume==nullptr)? false : bool can_use_surface = (m_volume==nullptr)? false :
(font_prop.use_surface)? true : // already used surface must have option to uncheck (font_prop.use_surface)? true : // already used surface must have option to uncheck
@ -2518,10 +2523,10 @@ bool GLGizmoEmboss::choose_font_by_wxdialog()
data.EnableEffects(false); data.EnableEffects(false);
data.RestrictSelection(wxFONTRESTRICT_SCALABLE); data.RestrictSelection(wxFONTRESTRICT_SCALABLE);
// set previous selected font // set previous selected font
EmbossStyle &selected_font_item = m_style_manager.get_font_item(); EmbossStyle &selected_style = m_style_manager.get_style();
if (selected_font_item.type == WxFontUtils::get_actual_type()) { if (selected_style.type == WxFontUtils::get_actual_type()) {
std::optional<wxFont> selected_font = WxFontUtils::load_wxFont( std::optional<wxFont> selected_font = WxFontUtils::load_wxFont(
selected_font_item.path); selected_style.path);
if (selected_font.has_value()) data.SetInitialFont(*selected_font); if (selected_font.has_value()) data.SetInitialFont(*selected_font);
} }
@ -2539,8 +2544,8 @@ bool GLGizmoEmboss::choose_font_by_wxdialog()
bool use_deserialized_font = false; bool use_deserialized_font = false;
// Try load and use new added font // Try load and use new added font
if ((use_deserialized_font && !m_style_manager.load_font(font_index)) || if ((use_deserialized_font && !m_style_manager.load_style(font_index)) ||
(!use_deserialized_font && !m_style_manager.load_font(emboss_style, wx_font))) { (!use_deserialized_font && !m_style_manager.load_style(emboss_style, wx_font))) {
m_style_manager.erase(font_index); m_style_manager.erase(font_index);
wxString message = GUI::format_wxstr( wxString message = GUI::format_wxstr(
_L("Font '%1%' can't be used. Please select another."), _L("Font '%1%' can't be used. Please select another."),
@ -2557,7 +2562,7 @@ bool GLGizmoEmboss::choose_font_by_wxdialog()
const auto&ff = m_style_manager.get_font_file_with_cache(); const auto&ff = m_style_manager.get_font_file_with_cache();
if (WxFontUtils::is_italic(wx_font) && if (WxFontUtils::is_italic(wx_font) &&
!Emboss::is_italic(*ff.font_file, font_collection)) { !Emboss::is_italic(*ff.font_file, font_collection)) {
m_style_manager.get_font_item().prop.skew = 0.2; m_style_manager.get_style().prop.skew = 0.2;
} }
return true; return true;
} }
@ -2584,7 +2589,7 @@ bool GLGizmoEmboss::choose_true_type_file()
EmbossStyle style{ name, path, EmbossStyle::Type::file_path, prop }; EmbossStyle style{ name, path, EmbossStyle::Type::file_path, prop };
m_style_manager.add_font(style); m_style_manager.add_font(style);
// set first valid added font as active // set first valid added font as active
if (m_style_manager.load_font(index)) return true; if (m_style_manager.load_style(index)) return true;
m_style_manager.erase(index); m_style_manager.erase(index);
} }
return false; return false;
@ -2612,7 +2617,7 @@ bool GLGizmoEmboss::choose_svg_file()
BoundingBox bb; BoundingBox bb;
for (const auto &p : polys) bb.merge(p.contour.points); for (const auto &p : polys) bb.merge(p.contour.points);
const FontProp &fp = m_style_manager.get_font_item().prop; const FontProp &fp = m_style_manager.get_style().prop;
float scale = fp.size_in_mm / std::max(bb.max.x(), bb.max.y()); float scale = fp.size_in_mm / std::max(bb.max.x(), bb.max.y());
auto project = std::make_unique<Emboss::ProjectScale>( auto project = std::make_unique<Emboss::ProjectScale>(
std::make_unique<Emboss::ProjectZ>(fp.emboss / scale), scale); std::make_unique<Emboss::ProjectZ>(fp.emboss / scale), scale);
@ -2637,13 +2642,13 @@ EmbossDataBase GLGizmoEmboss::create_emboss_data_base() {
auto create_configuration = [&]() -> TextConfiguration { auto create_configuration = [&]() -> TextConfiguration {
if (!m_style_manager.is_activ_font()) { if (!m_style_manager.is_activ_font()) {
std::string default_text_for_emboss = _u8L("Embossed text"); std::string default_text_for_emboss = _u8L("Embossed text");
EmbossStyle es = m_style_manager.get_font_item(); EmbossStyle es = m_style_manager.get_style();
TextConfiguration tc{es, default_text_for_emboss}; TextConfiguration tc{es, default_text_for_emboss};
// TODO: investigace how to initialize // TODO: investigace how to initialize
return tc; return tc;
} }
EmbossStyle &es = m_style_manager.get_font_item(); EmbossStyle &es = m_style_manager.get_style();
// actualize font path - during changes in gui it could be corrupted // actualize font path - during changes in gui it could be corrupted
// volume must store valid path // volume must store valid path
assert(m_style_manager.get_wx_font().has_value()); assert(m_style_manager.get_wx_font().has_value());
@ -2666,8 +2671,8 @@ bool GLGizmoEmboss::load_configuration(ModelVolume *volume)
TextConfiguration &tc = *volume->text_configuration; TextConfiguration &tc = *volume->text_configuration;
EmbossStyle &tc_es = tc.style; EmbossStyle &tc_es = tc.style;
auto has_same_name = [&tc_es](const EmbossStyleManager::Item &font_item) -> bool { auto has_same_name = [&tc_es](const EmbossStyleManager::Item &style) -> bool {
const EmbossStyle &es = font_item.font_item; const EmbossStyle &es = style.style;
return es.name == tc_es.name; return es.name == tc_es.name;
}; };
@ -2685,18 +2690,18 @@ bool GLGizmoEmboss::load_configuration(ModelVolume *volume)
if (it == styles.end()) { if (it == styles.end()) {
// style was not found // style was not found
if (wx_font_opt.has_value()) if (wx_font_opt.has_value())
m_style_manager.load_font(tc_es, *wx_font_opt); m_style_manager.load_style(tc_es, *wx_font_opt);
} else { } else {
size_t style_index = it - styles.begin(); size_t style_index = it - styles.begin();
if (!m_style_manager.load_font(style_index)) { if (!m_style_manager.load_style(style_index)) {
// can`t load stored style // can`t load stored style
m_style_manager.erase(style_index); m_style_manager.erase(style_index);
if (wx_font_opt.has_value()) if (wx_font_opt.has_value())
m_style_manager.load_font(tc_es, *wx_font_opt); m_style_manager.load_style(tc_es, *wx_font_opt);
} else { } else {
// stored style is loaded, now set modification of style // stored style is loaded, now set modification of style
m_style_manager.get_font_item() = tc_es; m_style_manager.get_style() = tc_es;
m_style_manager.set_wx_font(*wx_font_opt); m_style_manager.set_wx_font(*wx_font_opt);
} }
} }
@ -2717,7 +2722,7 @@ void GLGizmoEmboss::create_notification_not_valid_font(
auto level = auto level =
NotificationManager::NotificationLevel::WarningNotificationLevel; NotificationManager::NotificationLevel::WarningNotificationLevel;
const EmbossStyle &es = m_style_manager.get_font_item(); const EmbossStyle &es = m_style_manager.get_style();
const auto &origin_family = tc.style.prop.face_name; const auto &origin_family = tc.style.prop.face_name;
const auto &actual_family = es.prop.face_name; const auto &actual_family = es.prop.face_name;

124
src/slic3r/Utils/EmbossStyleManager.cpp
View File

@ -30,7 +30,7 @@ EmbossStyleManager::~EmbossStyleManager() {
void EmbossStyleManager::init(const AppConfig *cfg, const EmbossStyles &default_styles) void EmbossStyleManager::init(const AppConfig *cfg, const EmbossStyles &default_styles)
{ {
EmbossStyles styles = (cfg != nullptr) ? EmbossStyles styles = (cfg != nullptr) ?
EmbossStylesSerializable::load_font_list(*cfg) : EmbossStylesSerializable::load_styles(*cfg) :
default_styles; default_styles;
if (styles.empty()) styles = default_styles; if (styles.empty()) styles = default_styles;
for (EmbossStyle &style : styles) { for (EmbossStyle &style : styles) {
@ -39,7 +39,7 @@ void EmbossStyleManager::init(const AppConfig *cfg, const EmbossStyles &default_
} }
std::optional<size_t> activ_index_opt = (cfg != nullptr) ? std::optional<size_t> activ_index_opt = (cfg != nullptr) ?
EmbossStylesSerializable::load_font_index(*cfg) : EmbossStylesSerializable::load_style_index(*cfg) :
std::optional<size_t>{}; std::optional<size_t>{};
size_t activ_index = 0; size_t activ_index = 0;
@ -50,10 +50,10 @@ void EmbossStyleManager::init(const AppConfig *cfg, const EmbossStyles &default_
if (activ_index >= m_style_items.size()) activ_index = 0; if (activ_index >= m_style_items.size()) activ_index = 0;
// find valid font item // find valid font item
if (!load_font(activ_index)) { if (!load_style(activ_index)) {
m_style_items.erase(m_style_items.begin() + activ_index); m_style_items.erase(m_style_items.begin() + activ_index);
activ_index = 0; activ_index = 0;
while (m_style_items.empty() || !load_font(activ_index)) while (m_style_items.empty() || !load_style(activ_index))
m_style_items.erase(m_style_items.begin()); m_style_items.erase(m_style_items.begin());
// no one style from config is loadable // no one style from config is loadable
if (m_style_items.empty()) { if (m_style_items.empty()) {
@ -63,7 +63,7 @@ void EmbossStyleManager::init(const AppConfig *cfg, const EmbossStyles &default_
m_style_items.push_back({std::move(style)}); m_style_items.push_back({std::move(style)});
} }
// try to load first default font // try to load first default font
bool loaded = load_font(activ_index); bool loaded = load_style(activ_index);
assert(loaded); assert(loaded);
} }
} }
@ -75,31 +75,31 @@ bool EmbossStyleManager::store_styles_to_app_config(AppConfig *cfg)
if (cfg == nullptr) return false; if (cfg == nullptr) return false;
if (exist_stored_style()) { if (exist_stored_style()) {
// update stored item // update stored item
m_style_items[m_style_cache.font_index].font_item = m_style_cache.font_item; m_style_items[m_style_cache.style_index].style = m_style_cache.style;
} else { } else {
// add new into stored list // add new into stored list
EmbossStyle &style = m_style_cache.font_item; EmbossStyle &style = m_style_cache.style;
make_unique_name(style.name); make_unique_name(style.name);
m_style_cache.font_index = m_style_items.size(); m_style_cache.style_index = m_style_items.size();
m_style_items.push_back({style}); m_style_items.push_back({style});
m_style_cache.stored_wx_font = m_style_cache.wx_font; m_style_cache.stored_wx_font = m_style_cache.wx_font;
} }
EmbossStylesSerializable::store_font_index(*cfg, m_style_cache.font_index); EmbossStylesSerializable::store_style_index(*cfg, m_style_cache.style_index);
m_stored_activ_index = m_style_cache.font_index; m_stored_activ_index = m_style_cache.style_index;
EmbossStyles font_list; EmbossStyles font_list;
font_list.reserve(m_style_items.size()); font_list.reserve(m_style_items.size());
for (const Item &item : m_style_items) font_list.push_back(item.font_item); for (const Item &item : m_style_items) font_list.push_back(item.style);
EmbossStylesSerializable::store_font_list(*cfg, font_list); EmbossStylesSerializable::store_styles(*cfg, font_list);
m_change_order = false; m_change_order = false;
return true; return true;
} }
void EmbossStyleManager::store_style(const std::string &name) { void EmbossStyleManager::store_style(const std::string &name) {
EmbossStyle& style = m_style_cache.font_item; EmbossStyle& style = m_style_cache.style;
style.name = name; style.name = name;
make_unique_name(style.name); make_unique_name(style.name);
m_style_cache.font_index = m_style_items.size(); m_style_cache.style_index = m_style_items.size();
m_style_cache.stored_wx_font = m_style_cache.wx_font; m_style_cache.stored_wx_font = m_style_cache.wx_font;
m_style_cache.truncated_name.clear(); m_style_cache.truncated_name.clear();
m_style_items.push_back({style}); m_style_items.push_back({style});
@ -112,25 +112,36 @@ void EmbossStyleManager::swap(size_t i1, size_t i2) {
m_change_order = true; m_change_order = true;
// fix selected index // fix selected index
if (!exist_stored_style()) return; if (!exist_stored_style()) return;
if (m_style_cache.font_index == i1) { if (m_style_cache.style_index == i1) {
m_style_cache.font_index = i2; m_style_cache.style_index = i2;
} else if (m_style_cache.font_index == i2) { } else if (m_style_cache.style_index == i2) {
m_style_cache.font_index = i1; m_style_cache.style_index = i1;
} }
} }
void EmbossStyleManager::discard_style_changes() {
if (exist_stored_style()) {
if (m_style_cache.style == m_style_items[m_stored_activ_index].style &&
m_style_cache.wx_font == m_style_cache.stored_wx_font)
return; // already loaded
if (load_style(m_style_cache.style_index)) return;
}
load_first_valid_font();
}
bool EmbossStyleManager::is_style_order_changed() const { return m_change_order; } bool EmbossStyleManager::is_style_order_changed() const { return m_change_order; }
bool EmbossStyleManager::is_activ_style_changed() const { bool EmbossStyleManager::is_activ_style_changed() const {
if (m_stored_activ_index == std::numeric_limits<size_t>::max()) if (m_stored_activ_index == std::numeric_limits<size_t>::max())
return true; return true;
return m_style_cache.font_index != m_stored_activ_index; return m_style_cache.style_index != m_stored_activ_index;
}; };
void EmbossStyleManager::erase(size_t index) { void EmbossStyleManager::erase(size_t index) {
if (index >= m_style_items.size()) return; if (index >= m_style_items.size()) return;
// fix selected index // fix selected index
if (exist_stored_style()) { if (exist_stored_style()) {
size_t &i = m_style_cache.font_index; size_t &i = m_style_cache.style_index;
if (index < i) --i; if (index < i) --i;
else if (index == i) i = std::numeric_limits<size_t>::max(); else if (index == i) i = std::numeric_limits<size_t>::max();
} }
@ -139,48 +150,48 @@ void EmbossStyleManager::erase(size_t index) {
} }
void EmbossStyleManager::rename(const std::string& name) { void EmbossStyleManager::rename(const std::string& name) {
m_style_cache.font_item.name = name; m_style_cache.style.name = name;
m_style_cache.truncated_name.clear(); m_style_cache.truncated_name.clear();
if (exist_stored_style()) { if (exist_stored_style()) {
Item &it = m_style_items[m_style_cache.font_index]; Item &it = m_style_items[m_style_cache.style_index];
it.font_item.name = name; it.style.name = name;
it.truncated_name.clear(); it.truncated_name.clear();
} }
} }
bool EmbossStyleManager::load_font(size_t font_index) bool EmbossStyleManager::load_style(size_t style_index)
{ {
if (font_index >= m_style_items.size()) return false; if (style_index >= m_style_items.size()) return false;
if (!load_font(m_style_items[font_index].font_item)) return false; if (!load_style(m_style_items[style_index].style)) return false;
m_style_cache.font_index = font_index; m_style_cache.style_index = style_index;
m_style_cache.stored_wx_font = m_style_cache.wx_font; m_style_cache.stored_wx_font = m_style_cache.wx_font; // copy
return true; return true;
} }
bool EmbossStyleManager::load_font(const EmbossStyle &fi) { bool EmbossStyleManager::load_style(const EmbossStyle &style) {
if (fi.type == EmbossStyle::Type::file_path) { if (style.type == EmbossStyle::Type::file_path) {
std::unique_ptr<Emboss::FontFile> font_ptr = std::unique_ptr<Emboss::FontFile> font_ptr =
Emboss::create_font_file(fi.path.c_str()); Emboss::create_font_file(style.path.c_str());
if (font_ptr == nullptr) return false; if (font_ptr == nullptr) return false;
m_style_cache.wx_font = {}; m_style_cache.wx_font = {};
m_style_cache.font_file = m_style_cache.font_file =
Emboss::FontFileWithCache(std::move(font_ptr)); Emboss::FontFileWithCache(std::move(font_ptr));
m_style_cache.font_item = fi; // copy m_style_cache.style = style; // copy
m_style_cache.font_index = std::numeric_limits<size_t>::max(); m_style_cache.style_index = std::numeric_limits<size_t>::max();
m_style_cache.stored_wx_font = {}; m_style_cache.stored_wx_font = {};
return true; return true;
} }
if (fi.type != WxFontUtils::get_actual_type()) return false; if (style.type != WxFontUtils::get_actual_type()) return false;
std::optional<wxFont> wx_font_opt = WxFontUtils::load_wxFont(fi.path); std::optional<wxFont> wx_font_opt = WxFontUtils::load_wxFont(style.path);
if (!wx_font_opt.has_value()) return false; if (!wx_font_opt.has_value()) return false;
return load_font(fi, *wx_font_opt); return load_style(style, *wx_font_opt);
} }
bool EmbossStyleManager::load_font(const EmbossStyle &fi, const wxFont &font) bool EmbossStyleManager::load_style(const EmbossStyle &style, const wxFont &font)
{ {
if (!set_wx_font(font)) return false; if (!set_wx_font(font)) return false;
m_style_cache.font_item = fi; // copy m_style_cache.style = style; // copy
m_style_cache.font_index = std::numeric_limits<size_t>::max(); m_style_cache.style_index = std::numeric_limits<size_t>::max();
m_style_cache.stored_wx_font = {}; m_style_cache.stored_wx_font = {};
m_style_cache.truncated_name.clear(); m_style_cache.truncated_name.clear();
return true; return true;
@ -190,29 +201,29 @@ bool EmbossStyleManager::is_activ_font() { return m_style_cache.font_file.has_va
bool EmbossStyleManager::load_first_valid_font() { bool EmbossStyleManager::load_first_valid_font() {
while (!m_style_items.empty()) { while (!m_style_items.empty()) {
if (load_font(0)) return true; if (load_style(0)) return true;
// can't load so erase it from list // can't load so erase it from list
m_style_items.erase(m_style_items.begin()); m_style_items.erase(m_style_items.begin());
} }
return false; return false;
} }
const EmbossStyle* EmbossStyleManager::get_stored_font_item() const const EmbossStyle* EmbossStyleManager::get_stored_style() const
{ {
if (m_style_cache.font_index >= m_style_items.size()) return nullptr; if (m_style_cache.style_index >= m_style_items.size()) return nullptr;
return &m_style_items[m_style_cache.font_index].font_item; return &m_style_items[m_style_cache.style_index].style;
} }
const std::optional<wxFont> &EmbossStyleManager::get_stored_wx_font() const { return m_style_cache.stored_wx_font; } const std::optional<wxFont> &EmbossStyleManager::get_stored_wx_font() const { return m_style_cache.stored_wx_font; }
const EmbossStyle &EmbossStyleManager::get_font_item() const { return m_style_cache.font_item; } const EmbossStyle &EmbossStyleManager::get_style() const { return m_style_cache.style; }
EmbossStyle &EmbossStyleManager::get_font_item() { return m_style_cache.font_item; } EmbossStyle &EmbossStyleManager::get_style() { return m_style_cache.style; }
const FontProp &EmbossStyleManager::get_font_prop() const { return get_font_item().prop; } const FontProp &EmbossStyleManager::get_font_prop() const { return get_style().prop; }
FontProp &EmbossStyleManager::get_font_prop() { return get_font_item().prop; } FontProp &EmbossStyleManager::get_font_prop() { return get_style().prop; }
const std::optional<wxFont> &EmbossStyleManager::get_wx_font() const { return m_style_cache.wx_font; } const std::optional<wxFont> &EmbossStyleManager::get_wx_font() const { return m_style_cache.wx_font; }
bool EmbossStyleManager::exist_stored_style() const { return m_style_cache.font_index != std::numeric_limits<size_t>::max(); } bool EmbossStyleManager::exist_stored_style() const { return m_style_cache.style_index != std::numeric_limits<size_t>::max(); }
size_t EmbossStyleManager::get_style_index() const { return m_style_cache.font_index; } size_t EmbossStyleManager::get_style_index() const { return m_style_cache.style_index; }
Emboss::FontFileWithCache &EmbossStyleManager::get_font_file_with_cache() { return m_style_cache.font_file; } Emboss::FontFileWithCache &EmbossStyleManager::get_font_file_with_cache() { return m_style_cache.font_file; }
std::string &EmbossStyleManager::get_truncated_name() { return m_style_cache.truncated_name; } std::string &EmbossStyleManager::get_truncated_name() { return m_style_cache.truncated_name; }
@ -258,7 +269,7 @@ void EmbossStyleManager::make_unique_name(std::string &name)
{ {
auto is_unique = [&](const std::string &name) -> bool { auto is_unique = [&](const std::string &name) -> bool {
for (const Item &it : m_style_items) for (const Item &it : m_style_items)
if (it.font_item.name == name) return false; if (it.style.name == name) return false;
return true; return true;
}; };
@ -282,7 +293,7 @@ void EmbossStyleManager::make_unique_name(std::string &name)
void EmbossStyleManager::init_trunc_names(float max_width) { void EmbossStyleManager::init_trunc_names(float max_width) {
for (auto &s : m_style_items) for (auto &s : m_style_items)
if (s.truncated_name.empty()) if (s.truncated_name.empty())
s.truncated_name = ImGuiWrapper::trunc(s.font_item.name, max_width); s.truncated_name = ImGuiWrapper::trunc(s.style.name, max_width);
} }
#include "slic3r/GUI/Jobs/CreateFontStyleImagesJob.hpp" #include "slic3r/GUI/Jobs/CreateFontStyleImagesJob.hpp"
@ -310,8 +321,8 @@ void EmbossStyleManager::init_style_images(const Vec2i &max_size,
// find style in font list and copy to it // find style in font list and copy to it
for (auto &it : m_style_items) { for (auto &it : m_style_items) {
if (it.font_item.name != style.text || if (it.style.name != style.text ||
!(it.font_item.prop == style.prop)) !(it.style.prop == style.prop))
continue; continue;
it.image = image; it.image = image;
break; break;
@ -330,7 +341,7 @@ void EmbossStyleManager::init_style_images(const Vec2i &max_size,
StyleImagesData::Items styles; StyleImagesData::Items styles;
styles.reserve(m_style_items.size()); styles.reserve(m_style_items.size());
for (const Item &item : m_style_items) { for (const Item &item : m_style_items) {
const EmbossStyle &style = item.font_item; const EmbossStyle &style = item.style;
std::optional<wxFont> wx_font_opt = WxFontUtils::load_wxFont(style.path); std::optional<wxFont> wx_font_opt = WxFontUtils::load_wxFont(style.path);
if (!wx_font_opt.has_value()) continue; if (!wx_font_opt.has_value()) continue;
std::unique_ptr<Emboss::FontFile> font_file = std::unique_ptr<Emboss::FontFile> font_file =
@ -399,7 +410,7 @@ ImFont *EmbossStyleManager::create_imgui_font(const std::string &text)
m_style_cache.atlas.Flags |= ImFontAtlasFlags_NoMouseCursors | m_style_cache.atlas.Flags |= ImFontAtlasFlags_NoMouseCursors |
ImFontAtlasFlags_NoPowerOfTwoHeight; ImFontAtlasFlags_NoPowerOfTwoHeight;
const FontProp &font_prop = m_style_cache.font_item.prop; const FontProp &font_prop = m_style_cache.style.prop;
float font_size = get_imgui_font_size(font_prop, font_file); float font_size = get_imgui_font_size(font_prop, font_file);
if (font_size < min_imgui_font_size) if (font_size < min_imgui_font_size)
font_size = min_imgui_font_size; font_size = min_imgui_font_size;
@ -466,10 +477,11 @@ bool EmbossStyleManager::set_wx_font(const wxFont &wx_font) {
bool EmbossStyleManager::set_wx_font(const wxFont &wx_font, std::unique_ptr<Emboss::FontFile> font_file) bool EmbossStyleManager::set_wx_font(const wxFont &wx_font, std::unique_ptr<Emboss::FontFile> font_file)
{ {
if (font_file == nullptr) return false; if (font_file == nullptr) return false;
m_style_cache.wx_font = wx_font; // copy
m_style_cache.font_file = m_style_cache.font_file =
Emboss::FontFileWithCache(std::move(font_file)); Emboss::FontFileWithCache(std::move(font_file));
EmbossStyle &style = m_style_cache.font_item; EmbossStyle &style = m_style_cache.style;
style.type = WxFontUtils::get_actual_type(); style.type = WxFontUtils::get_actual_type();
// update string path // update string path
style.path = WxFontUtils::store_wxFont(wx_font); style.path = WxFontUtils::store_wxFont(wx_font);

36
src/slic3r/Utils/EmbossStyleManager.hpp
View File

@ -42,7 +42,7 @@ public:
bool store_styles_to_app_config(AppConfig *cfg); bool store_styles_to_app_config(AppConfig *cfg);
/// <summary> /// <summary>
/// Append actual style to style list and store /// Append actual style to style list
/// </summary> /// </summary>
/// <param name="name">New name for style</param> /// <param name="name">New name for style</param>
void store_style(const std::string& name); void store_style(const std::string& name);
@ -55,6 +55,12 @@ public:
/// <param name="i2">Second index to m_style_items</param> /// <param name="i2">Second index to m_style_items</param>
void swap(size_t i1, size_t i2); void swap(size_t i1, size_t i2);
/// <summary>
/// Discard changes in activ style
/// When no activ style use last used
/// </summary>
void discard_style_changes();
/// <summary> /// <summary>
/// Track using of swap between saves /// Track using of swap between saves
/// </summary> /// </summary>
@ -86,11 +92,11 @@ public:
/// </summary> /// </summary>
/// <param name="font_index">New font index(from m_style_items range)</param> /// <param name="font_index">New font index(from m_style_items range)</param>
/// <returns>True on succes. False on fail load font</returns> /// <returns>True on succes. False on fail load font</returns>
bool load_font(size_t font_index); bool load_style(size_t font_index);
// load font style not stored in list // load font style not stored in list
bool load_font(const EmbossStyle &fi); bool load_style(const EmbossStyle &style);
// fastering load font on index by wxFont, ignore type and descriptor // fastering load font on index by wxFont, ignore type and descriptor
bool load_font(const EmbossStyle &fi, const wxFont &font); bool load_style(const EmbossStyle &style, const wxFont &font);
// clear actual selected glyphs cache // clear actual selected glyphs cache
void clear_glyphs_cache(); void clear_glyphs_cache();
@ -98,19 +104,15 @@ public:
// remove cached imgui font for actual selected font // remove cached imgui font for actual selected font
void clear_imgui_font(); void clear_imgui_font();
// erase font when not possible to load
// used at initialize phaze - fonts could be modified in appConfig file by user
bool load_first_valid_font();
// getter on stored EmbossStyle // getter on stored EmbossStyle
const EmbossStyle *get_stored_font_item() const; const EmbossStyle *get_stored_style() const;
// getter on stored wxFont // getter on stored wxFont
const std::optional<wxFont> &get_stored_wx_font() const; const std::optional<wxFont> &get_stored_wx_font() const;
// getter on active font item for access to font property // getter on active font item for access to font property
const EmbossStyle &get_font_item() const; const EmbossStyle &get_style() const;
EmbossStyle &get_font_item(); EmbossStyle &get_style();
// getter on active font property // getter on active font property
const FontProp &get_font_prop() const; const FontProp &get_font_prop() const;
@ -187,7 +189,7 @@ public:
struct Item struct Item
{ {
// define font, style and other property of text // define font, style and other property of text
EmbossStyle font_item; EmbossStyle style;
// cache for view font name with maximal width in imgui // cache for view font name with maximal width in imgui
std::string truncated_name; std::string truncated_name;
@ -206,6 +208,10 @@ public:
static float get_imgui_font_size(const FontProp& prop, const Emboss::FontFile& file); static float get_imgui_font_size(const FontProp& prop, const Emboss::FontFile& file);
private: private:
// erase font when not possible to load
// used at initialize phaze - fonts could be modified in appConfig file by user
bool load_first_valid_font();
/// <summary> /// <summary>
/// Cache data from style to reduce amount of: /// Cache data from style to reduce amount of:
/// 1) loading font from file /// 1) loading font from file
@ -230,13 +236,13 @@ private:
std::string truncated_name; std::string truncated_name;
// actual used font item // actual used font item
EmbossStyle font_item = {}; EmbossStyle style = {};
// cache for stored wx font to not create every frame // cache for stored wx font to not create every frame
std::optional<wxFont> stored_wx_font; std::optional<wxFont> stored_wx_font;
// index into m_style_items // index into m_style_items
size_t font_index = std::numeric_limits<size_t>::max(); size_t style_index = std::numeric_limits<size_t>::max();
} m_style_cache; } m_style_cache;
@ -249,7 +255,7 @@ private:
// Privat member // Privat member
std::vector<Item> m_style_items; std::vector<Item> m_style_items;
bool m_change_order = false; bool m_change_order;
size_t m_stored_activ_index; size_t m_stored_activ_index;
/// <summary> /// <summary>

35
src/slic3r/Utils/EmbossStylesSerializable.cpp
View File

@ -23,7 +23,7 @@ const std::string EmbossStylesSerializable::APP_CONFIG_ACTIVE_FONT = "activ
std::string EmbossStylesSerializable::create_section_name(unsigned index) std::string EmbossStylesSerializable::create_section_name(unsigned index)
{ {
return AppConfig::SECTION_FONT + ':' + std::to_string(index); return AppConfig::SECTION_EMBOSS_STYLE + ':' + std::to_string(index);
} }
// check only existence of flag // check only existence of flag
@ -88,7 +88,7 @@ bool EmbossStylesSerializable::read(const std::map<std::string, std::string>& se
return true; return true;
} }
std::optional<EmbossStyle> EmbossStylesSerializable::load_font_item( std::optional<EmbossStyle> EmbossStylesSerializable::load_style(
const std::map<std::string, std::string> &app_cfg_section) const std::map<std::string, std::string> &app_cfg_section)
{ {
auto path_it = app_cfg_section.find(APP_CONFIG_FONT_DESCRIPTOR); auto path_it = app_cfg_section.find(APP_CONFIG_FONT_DESCRIPTOR);
@ -96,7 +96,7 @@ std::optional<EmbossStyle> EmbossStylesSerializable::load_font_item(
const std::string &path = path_it->second; const std::string &path = path_it->second;
auto name_it = app_cfg_section.find(APP_CONFIG_FONT_NAME); auto name_it = app_cfg_section.find(APP_CONFIG_FONT_NAME);
static const std::string default_name = "font_name"; const std::string default_name = "font_name";
const std::string &name = const std::string &name =
(name_it == app_cfg_section.end()) ? (name_it == app_cfg_section.end()) ?
default_name : name_it->second; default_name : name_it->second;
@ -117,7 +117,7 @@ std::optional<EmbossStyle> EmbossStylesSerializable::load_font_item(
return EmbossStyle{ name, path, type, fp }; return EmbossStyle{ name, path, type, fp };
} }
void EmbossStylesSerializable::store_font_item(AppConfig & cfg, void EmbossStylesSerializable::store_style(AppConfig & cfg,
const EmbossStyle &fi, const EmbossStyle &fi,
unsigned index) unsigned index)
{ {
@ -146,19 +146,19 @@ void EmbossStylesSerializable::store_font_item(AppConfig & cfg,
cfg.set(section_name, APP_CONFIG_FONT_LINE_GAP, std::to_string(*fp.line_gap)); cfg.set(section_name, APP_CONFIG_FONT_LINE_GAP, std::to_string(*fp.line_gap));
} }
void EmbossStylesSerializable::store_font_index(AppConfig &cfg, unsigned index) { void EmbossStylesSerializable::store_style_index(AppConfig &cfg, unsigned index) {
// store actual font index // store actual font index
cfg.clear_section(AppConfig::SECTION_FONT); cfg.clear_section(AppConfig::SECTION_EMBOSS_STYLE);
// activ font first index is +1 to correspond with section name // activ font first index is +1 to correspond with section name
std::string activ_font = std::to_string(index); std::string activ_font = std::to_string(index);
cfg.set(AppConfig::SECTION_FONT, APP_CONFIG_ACTIVE_FONT, activ_font); cfg.set(AppConfig::SECTION_EMBOSS_STYLE, APP_CONFIG_ACTIVE_FONT, activ_font);
} }
std::optional<size_t> EmbossStylesSerializable::load_font_index(const AppConfig &cfg) std::optional<size_t> EmbossStylesSerializable::load_style_index(const AppConfig &cfg)
{ {
if (!cfg.has_section(AppConfig::SECTION_FONT)) return {}; if (!cfg.has_section(AppConfig::SECTION_EMBOSS_STYLE)) return {};
auto section = cfg.get_section(AppConfig::SECTION_FONT); auto section = cfg.get_section(AppConfig::SECTION_EMBOSS_STYLE);
auto it = section.find(APP_CONFIG_ACTIVE_FONT); auto it = section.find(APP_CONFIG_ACTIVE_FONT);
if (it == section.end()) return {}; if (it == section.end()) return {};
@ -167,30 +167,29 @@ std::optional<size_t> EmbossStylesSerializable::load_font_index(const AppConfig
return active_font - 1; return active_font - 1;
} }
EmbossStyles EmbossStylesSerializable::load_font_list(const AppConfig &cfg) EmbossStyles EmbossStylesSerializable::load_styles(const AppConfig &cfg)
{ {
EmbossStyles result; EmbossStyles result;
// human readable index inside of config starts from 1 !! // human readable index inside of config starts from 1 !!
unsigned index = 1; unsigned index = 1;
std::string section_name = create_section_name( std::string section_name = create_section_name(index);
index);
while (cfg.has_section(section_name)) { while (cfg.has_section(section_name)) {
std::optional<EmbossStyle> style_opt = load_font_item(cfg.get_section(section_name)); std::optional<EmbossStyle> style_opt = load_style(cfg.get_section(section_name));
if (style_opt.has_value()) result.emplace_back(*style_opt); if (style_opt.has_value()) result.emplace_back(*style_opt);
section_name = create_section_name(++index); section_name = create_section_name(++index);
} }
return result; return result;
} }
void EmbossStylesSerializable::store_font_list(AppConfig &cfg, const EmbossStyles font_list) void EmbossStylesSerializable::store_styles(AppConfig &cfg, const EmbossStyles& styles)
{ {
// store styles // store styles
unsigned index = 1; unsigned index = 1;
for (const EmbossStyle &fi : font_list) { for (const EmbossStyle &style : styles) {
// skip file paths + fonts from other OS(loaded from .3mf) // skip file paths + fonts from other OS(loaded from .3mf)
assert(fi.type == WxFontUtils::get_actual_type()); assert(style.type == WxFontUtils::get_actual_type());
// if (style_opt.type != WxFontUtils::get_actual_type()) continue; // if (style_opt.type != WxFontUtils::get_actual_type()) continue;
store_font_item(cfg, fi, index++); store_style(cfg, style, index++);
} }
// remove rest of font sections (after deletation) // remove rest of font sections (after deletation)

12
src/slic3r/Utils/EmbossStylesSerializable.hpp
View File

@ -34,16 +34,16 @@ class EmbossStylesSerializable
public: public:
EmbossStylesSerializable() = delete; EmbossStylesSerializable() = delete;
static void store_font_index(AppConfig &cfg, unsigned index); static void store_style_index(AppConfig &cfg, unsigned index);
static std::optional<size_t> load_font_index(const AppConfig &cfg); static std::optional<size_t> load_style_index(const AppConfig &cfg);
static EmbossStyles load_font_list(const AppConfig &cfg); static EmbossStyles load_styles(const AppConfig &cfg);
static void store_font_list(AppConfig &cfg, const EmbossStyles font_list); static void store_styles(AppConfig &cfg, const EmbossStyles& styles);
private: private:
static std::string create_section_name(unsigned index); static std::string create_section_name(unsigned index);
static std::optional<EmbossStyle> load_font_item(const std::map<std::string, std::string> &app_cfg_section); static std::optional<EmbossStyle> load_style(const std::map<std::string, std::string> &app_cfg_section);
static void store_font_item(AppConfig &cfg, const EmbossStyle &fi, unsigned index); static void store_style(AppConfig &cfg, const EmbossStyle &style, unsigned index);
// TODO: move to app config like read from section // TODO: move to app config like read from section
static bool read(const std::map<std::string, std::string>& section, const std::string& key, bool& value); static bool read(const std::map<std::string, std::string>& section, const std::string& key, bool& value);