Slic3r::GUI::Emboss::StyleManager Class Reference

Manage Emboss text styles Cache actual state of style. More...

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/Utils/EmbossStyleManager.hpp>

Collaboration diagram for Slic3r::GUI::Emboss::StyleManager:

Classes
struct	StyleImage
	Describe image in GPU to show settings of style. More...
struct	Style
	All connected with one style keep temporary data and caches for style. More...
struct	StyleCache
	Cache data from style to reduce amount of: 1) loading font from file 2) Create atlas of symbols for imgui 3) Keep loaded(and modified by style) glyphs from font. More...
struct	StyleImagesData
	Keep data needed to create Font Style Images in Job. More...

Public Types
using	Styles = std::vector<Style>

Public Member Functions
	StyleManager (const ImWchar *language_glyph_range, const std::function< EmbossStyles()> &create_default_styles)
	Parameters language_glyph_range Character to load for imgui when initialize imgui font create_default_styles Function to create default styles
	~StyleManager ()
	Release imgui font and style images from GPU.
void	init (AppConfig *app_config)
	Load font style list from config Also select actual activ font.
bool	store_styles_to_app_config (bool use_modification=true, bool store_active_index=true)
	Write font list into AppConfig.
void	add_style (const std::string &name)
	Append actual style to style list.
void	swap (size_t i1, size_t i2)
	Change order of style item in m_styles. Fix selected font index when (i1 || i2) == m_font_selected.
void	discard_style_changes ()
	Discard changes in activ style When no activ style use last used OR first loadable.
void	erase (size_t index)
	Remove style from m_styles. Fix selected font index when index is under m_font_selected.
void	rename (const std::string &name)
	Rename actual selected font item.
void	load_valid_style ()
	load some valid style
bool	load_style (size_t font_index)
	Change active font When font not loaded roll back activ font.
bool	load_style (const Style &style)
bool	load_style (const Style &style, const wxFont &font)
void	clear_glyphs_cache ()
void	clear_imgui_font ()
const Style *	get_stored_style () const
const Style &	get_style () const
Style &	get_style ()
size_t	get_style_index () const
std::string &	get_truncated_name ()
const ImFontAtlas &	get_atlas () const
const FontProp &	get_font_prop () const
FontProp &	get_font_prop ()
const wxFont &	get_wx_font () const
const wxFont &	get_stored_wx_font () const
Slic3r::Emboss::FontFileWithCache &	get_font_file_with_cache ()
bool	has_collections () const
bool	exist_stored_style () const
bool	is_font_changed () const
	check whether current style differ to selected
bool	is_unique_style_name (const std::string &name) const
bool	set_wx_font (const wxFont &wx_font)
	Setter on wx_font when changed.
bool	set_wx_font (const wxFont &wx_font, std::unique_ptr< Slic3r::Emboss::FontFile > font_file)
	Faster way of set wx_font when font file is known(do not load font file twice) When you not sure that wx_font is made by font_file use only set_wx_font(wx_font).
ImFont *	get_imgui_font ()
ImFont *	create_imgui_font (const std::string &text, double scale)
void	init_trunc_names (float max_width)
void	init_style_images (const Vec2i32 &max_size, const std::string &text)
	Initialization texture with rendered font style.
void	free_style_images ()
const std::vector< Style > &	get_styles () const
bool	is_active_font ()

Static Public Member Functions
static float	get_imgui_font_size (const FontProp &prop, const Slic3r::Emboss::FontFile &file, double scale)

Static Public Attributes
static float	min_imgui_font_size = 18.f
static float	max_imgui_font_size = 60.f

Private Attributes
std::function< EmbossStyles()>	m_create_default_styles
const ImWchar *	m_imgui_init_glyph_range
struct Slic3r::GUI::Emboss::StyleManager::StyleCache	m_style_cache
Styles	m_styles
AppConfig *	m_app_config = nullptr
size_t	m_last_style_index = std::numeric_limits<size_t>::max()
std::shared_ptr< StyleImagesData::StyleImages >	m_temp_style_images = nullptr
bool	m_exist_style_images = false

Friends
class	CreateFontStyleImagesJob

Detailed Description

Manage Emboss text styles Cache actual state of style.

• imgui font
• wx font

---

Class Documentation

Slic3r::GUI::Emboss::StyleManager::StyleImage

struct Slic3r::GUI::Emboss::StyleManager::StyleImage

Describe image in GPU to show settings of style.

Collaboration diagram for Slic3r::GUI::Emboss::StyleManager::StyleImage:

Class Members
BoundingBox	bounding_box
Point	offset = Point(0, 0)
ImVec2	tex_size
void *	texture_id = nullptr
ImVec2	uv0
ImVec2	uv1

Slic3r::GUI::Emboss::StyleManager::StyleCache

struct Slic3r::GUI::Emboss::StyleManager::StyleCache

Cache data from style to reduce amount of: 1) loading font from file 2) Create atlas of symbols for imgui 3) Keep loaded(and modified by style) glyphs from font.

Collaboration diagram for Slic3r::GUI::Emboss::StyleManager::StyleCache:

Class Members
ImFontAtlas	atlas = {}
FontFileWithCache	font_file = {}
ImVector< ImWchar >	ranges = {}
wxFont	stored_wx_font = {}
Style	style = {}
size_t	style_index = std::numeric_limits<size_t>::max()
string	truncated_name
wxFont	wx_font = {}

Slic3r::GUI::Emboss::StyleManager::StyleImagesData

struct Slic3r::GUI::Emboss::StyleManager::StyleImagesData

Keep data needed to create Font Style Images in Job.

Collaboration diagram for Slic3r::GUI::Emboss::StyleManager::StyleImagesData:

Class Members
typedef vector< Item >	Items std::vector<Item>

Class Members
Vec2i32	max_size
double	ppm
shared_ptr< StyleImages >	result
Items	styles
string	text

Member Typedef Documentation

Styles

using Slic3r::GUI::Emboss::StyleManager::Styles = std::vector<Style>

Constructor & Destructor Documentation

StyleManager()

StyleManager::StyleManager	(	const ImWchar *	language_glyph_range,
		const std::function< EmbossStyles()> &	create_default_styles )

Parameters

language_glyph_range	Character to load for imgui when initialize imgui font
create_default_styles	Function to create default styles

    : m_create_default_styles(create_default_styles)
    , m_imgui_init_glyph_range(language_glyph_range)
{}

References m_create_default_styles, and m_imgui_init_glyph_range.

~StyleManager()

StyleManager::~StyleManager

(

)

Release imgui font and style images from GPU.

                            { 
    clear_imgui_font();
    free_style_images();
}

References clear_imgui_font(), and free_style_images().

Here is the call graph for this function:

Member Function Documentation

add_style()

void StyleManager::add_style

(

const std::string &

name

)

Append actual style to style list.

Parameters

name	New name for style

                                                  {
    EmbossStyle& style = m_style_cache.style;
    style.name = name;
    ::make_unique_name(m_styles, style.name);
    m_style_cache.style_index = m_styles.size();
    m_style_cache.stored_wx_font = m_style_cache.wx_font;
    m_style_cache.truncated_name.clear();
    m_styles.push_back({style});
}

References m_style_cache, m_styles, and style.

clear_glyphs_cache()

void StyleManager::clear_glyphs_cache

(

)

{
    FontFileWithCache &ff = m_style_cache.font_file;
    if (!ff.has_value()) return;
    ff.cache = std::make_shared<Glyphs>();
}

References Slic3r::Emboss::FontFileWithCache::cache, Slic3r::Emboss::FontFileWithCache::has_value(), and m_style_cache.

Here is the call graph for this function:

clear_imgui_font()

void StyleManager::clear_imgui_font

(

)

{ m_style_cache.atlas.Clear(); }

References m_style_cache.

Referenced by ~StyleManager(), and set_wx_font().

Here is the caller graph for this function:

create_imgui_font()

ImFont * StyleManager::create_imgui_font	(	const std::string &	text,
		double	scale )

{
    // inspiration inside of ImGuiWrapper::init_font
    auto& ff = m_style_cache.font_file;
    if (!ff.has_value()) return nullptr;
    const FontFile &font_file = *ff.font_file;
 
    ImFontGlyphRangesBuilder builder;
    builder.AddRanges(m_imgui_init_glyph_range);
    if (!text.empty())
        builder.AddText(text.c_str());
 
    ImVector<ImWchar> &ranges = m_style_cache.ranges;
    ranges.clear();
    builder.BuildRanges(&ranges);
        
    m_style_cache.atlas.Flags |= ImFontAtlasFlags_NoMouseCursors |
                                ImFontAtlasFlags_NoPowerOfTwoHeight;
 
    const FontProp &font_prop = m_style_cache.style.prop;
    float font_size = get_imgui_font_size(font_prop, font_file, scale);
    if (font_size < min_imgui_font_size)
        font_size = min_imgui_font_size;
    if (font_size > max_imgui_font_size)
        font_size = max_imgui_font_size;
 
    ImFontConfig font_config;
    // TODO: start using merge mode
    //font_config.MergeMode = true;
    int unit_per_em = get_font_info(font_file, font_prop).unit_per_em;
    float coef = font_size / (double) unit_per_em;
    if (font_prop.char_gap.has_value())
        font_config.GlyphExtraSpacing.x = coef * (*font_prop.char_gap);    
    if (font_prop.line_gap.has_value())
        font_config.GlyphExtraSpacing.y = coef * (*font_prop.line_gap);    
 
    font_config.FontDataOwnedByAtlas = false;
 
    const std::vector<unsigned char> &buffer = *font_file.data;
    ImFont * font = m_style_cache.atlas.AddFontFromMemoryTTF(
        (void *) buffer.data(), buffer.size(), font_size, &font_config, m_style_cache.ranges.Data);
 
    unsigned char *pixels;
    int            width, height;
    m_style_cache.atlas.GetTexDataAsRGBA32(&pixels, &width, &height);
 
    // Upload texture to graphics system
    GLint last_texture;
    glsafe(::glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture));
    ScopeGuard sg([last_texture]() {
        glsafe(::glBindTexture(GL_TEXTURE_2D, last_texture));
    });
 
    GLuint font_texture;
    glsafe(::glGenTextures(1, &font_texture));
    glsafe(::glBindTexture(GL_TEXTURE_2D, font_texture));
    glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
    glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
    glsafe(::glPixelStorei(GL_UNPACK_ROW_LENGTH, 0));
    if (OpenGLManager::are_compressed_textures_supported())
        glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels));
    else
        glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels));
 
    // Store our identifier
    m_style_cache.atlas.TexID = (ImTextureID) (intptr_t) font_texture;
    assert(!m_style_cache.atlas.Fonts.empty());
    if (m_style_cache.atlas.Fonts.empty()) return nullptr;
    assert(font == m_style_cache.atlas.Fonts.back());
    if (!font->IsLoaded()) return nullptr;
    assert(font->IsLoaded());
    return font;
}

References Slic3r::GUI::OpenGLManager::are_compressed_textures_supported(), Slic3r::FontProp::char_gap, Slic3r::Emboss::FontFile::data, Slic3r::Emboss::get_font_info(), get_imgui_font_size(), GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_LINEAR, GL_RGBA, GL_TEXTURE_2D, GL_TEXTURE_BINDING_2D, GL_TEXTURE_MAG_FILTER, GL_TEXTURE_MIN_FILTER, GL_UNPACK_ROW_LENGTH, GL_UNSIGNED_BYTE, glBindTexture, glGenTextures, glGetIntegerv, glPixelStorei, glsafe, glTexImage2D, glTexParameteri, Slic3r::FontProp::line_gap, m_imgui_init_glyph_range, m_style_cache, max_imgui_font_size, min_imgui_font_size, scale(), and Slic3r::Emboss::FontFile::Info::unit_per_em.

Here is the call graph for this function:

discard_style_changes()

void StyleManager::discard_style_changes

(

)

Discard changes in activ style When no activ style use last used OR first loadable.

                                         {
    if (exist_stored_style()) {
        if (load_style(m_style_cache.style_index))
            return; // correct reload style
    } else {
        if(load_style(m_last_style_index))
            return; // correct load last used style
    }
 
    // try to save situation by load some font
    load_valid_style();
}

References exist_stored_style(), load_style(), load_valid_style(), m_last_style_index, and m_style_cache.

Here is the call graph for this function:

erase()

void StyleManager::erase

(

size_t

index

)

Remove style from m_styles. Fix selected font index when index is under m_font_selected.

Parameters

index

Index of style to be removed

                                     {
    if (index >= m_styles.size()) return;
 
    // fix selected index
    if (exist_stored_style()) {
        size_t &i = m_style_cache.style_index;
        if (index < i) --i;
        else if (index == i) i = std::numeric_limits<size_t>::max();
    }
 
    m_styles.erase(m_styles.begin() + index);
}

References exist_stored_style(), m_style_cache, and m_styles.

Here is the call graph for this function:

exist_stored_style()

bool Slic3r::GUI::Emboss::StyleManager::exist_stored_style ( ) const

inline

{ return m_style_cache.style_index != std::numeric_limits<size_t>::max(); }

References m_style_cache.

Referenced by discard_style_changes(), erase(), is_font_changed(), rename(), store_styles_to_app_config(), and swap().

Here is the caller graph for this function:

free_style_images()

void StyleManager::free_style_images

(

)

                                     {
    if (!m_exist_style_images) return;
    GLuint tex_id = 0;
    for (Style &it : m_styles) {
        if (tex_id == 0 && it.image.has_value())
            tex_id = (GLuint)(intptr_t) it.image->texture_id;
        it.image.reset();
    }
    if (tex_id != 0)
        glsafe(::glDeleteTextures(1, &tex_id));
    m_exist_style_images = false;
}

References glDeleteTextures, glsafe, m_exist_style_images, and m_styles.

Referenced by ~StyleManager().

Here is the caller graph for this function:

get_atlas()

const ImFontAtlas & Slic3r::GUI::Emboss::StyleManager::get_atlas ( ) const

inline

{ return m_style_cache.atlas; } 

References m_style_cache.

get_font_file_with_cache()

Slic3r::Emboss::FontFileWithCache & Slic3r::GUI::Emboss::StyleManager::get_font_file_with_cache ( )

inline

{ return m_style_cache.font_file; }

References m_style_cache.

Referenced by anonymous_namespace{GLGizmoEmboss.cpp}::can_write(), anonymous_namespace{GLGizmoEmboss.cpp}::create_emboss_data_base(), and Slic3r::GUI::TextLinesModel::init().

Here is the caller graph for this function:

get_font_prop() [1/2]

FontProp & Slic3r::GUI::Emboss::StyleManager::get_font_prop ( )

inline

{ return get_style().prop; }

References get_style(), and Slic3r::EmbossStyle::prop.

Here is the call graph for this function:

get_font_prop() [2/2]

const FontProp & Slic3r::GUI::Emboss::StyleManager::get_font_prop ( ) const

inline

{ return get_style().prop; }

References get_style(), and Slic3r::EmbossStyle::prop.

Referenced by anonymous_namespace{GLGizmoEmboss.cpp}::can_write(), and Slic3r::GUI::TextLinesModel::init().

Here is the call graph for this function:

Here is the caller graph for this function:

get_imgui_font()

ImFont * StyleManager::get_imgui_font

(

)

{
    if (!is_active_font()) return nullptr;
    
    ImVector<ImFont *> &fonts = m_style_cache.atlas.Fonts;
    if (fonts.empty()) return nullptr;
 
    // check correct index
    int f_size = fonts.size();
    assert(f_size == 1);
    if (f_size != 1) return nullptr;
    ImFont *font = fonts.front();
    if (font == nullptr) return nullptr;
    return font;
}

References is_active_font(), and m_style_cache.

Here is the call graph for this function:

get_imgui_font_size()

float StyleManager::get_imgui_font_size ( const FontProp & prop, const Slic3r::Emboss::FontFile & file, double scale )

static

{
    const FontFile::Info& info = get_font_info(file, prop);
    // coeficient for convert line height to font size
    float c1 = (info.ascent - info.descent + info.linegap) /
               (float) info.unit_per_em;
 
    // The point size is defined as 1/72 of the Anglo-Saxon inch (25.4 mm):
    // It is approximately 0.0139 inch or 352.8 um.
    return c1 * std::abs(prop.size_in_mm) / 0.3528f * scale;
}

References Slic3r::Emboss::FontFile::Info::ascent, Slic3r::Emboss::FontFile::Info::descent, Slic3r::Emboss::get_font_info(), Slic3r::Emboss::FontFile::Info::linegap, scale(), Slic3r::FontProp::size_in_mm, and Slic3r::Emboss::FontFile::Info::unit_per_em.

Referenced by create_imgui_font(), and Slic3r::GUI::GLGizmoEmboss::draw_text_input().

Here is the call graph for this function:

Here is the caller graph for this function:

get_stored_style()

const StyleManager::Style * StyleManager::get_stored_style

(

)

const

{
    if (m_style_cache.style_index >= m_styles.size()) return nullptr;
    return &m_styles[m_style_cache.style_index];
}

References m_style_cache, and m_styles.

Referenced by is_font_changed().

Here is the caller graph for this function:

get_stored_wx_font()

const wxFont & Slic3r::GUI::Emboss::StyleManager::get_stored_wx_font ( ) const

inline

{ return m_style_cache.stored_wx_font; }

References m_style_cache.

Referenced by is_font_changed().

Here is the caller graph for this function:

get_style() [1/2]

Style & Slic3r::GUI::Emboss::StyleManager::get_style ( )

inline

{ return m_style_cache.style; }

References m_style_cache.

get_style() [2/2]

const Style & Slic3r::GUI::Emboss::StyleManager::get_style ( ) const

inline

{ return m_style_cache.style; }

References m_style_cache.

Referenced by anonymous_namespace{GLGizmoEmboss.cpp}::create_emboss_data_base(), get_font_prop(), get_font_prop(), and is_font_changed().

Here is the caller graph for this function:

get_style_index()

size_t Slic3r::GUI::Emboss::StyleManager::get_style_index ( ) const

inline

{ return m_style_cache.style_index; }

References m_style_cache.

get_styles()

const StyleManager::Styles & StyleManager::get_styles

(

)

const

{ return m_styles; }

References m_styles.

get_truncated_name()

std::string & Slic3r::GUI::Emboss::StyleManager::get_truncated_name ( )

inline

{ return m_style_cache.truncated_name; }

References m_style_cache.

get_wx_font()

const wxFont & Slic3r::GUI::Emboss::StyleManager::get_wx_font ( ) const

inline

{ return m_style_cache.wx_font; }

References m_style_cache.

Referenced by anonymous_namespace{GLGizmoEmboss.cpp}::create_emboss_data_base(), and is_font_changed().

Here is the caller graph for this function:

has_collections()

bool Slic3r::GUI::Emboss::StyleManager::has_collections ( ) const

inline

                                 { return m_style_cache.font_file.font_file != nullptr && 
                                          m_style_cache.font_file.font_file->infos.size() > 1; }

References m_style_cache.

init()

void StyleManager::init

(

AppConfig *

app_config

)

Load font style list from config Also select actual activ font.

Parameters

app_config

Application configuration loaded from file "PrusaSlicer.ini" cfg is stored to privat variable

{
    assert(app_config != nullptr);
    m_app_config = app_config;
    m_styles = ::load_styles(*app_config);
 
    if (m_styles.empty()) {
        // No styles loaded from ini file so use default
        EmbossStyles styles = m_create_default_styles();
        for (EmbossStyle &style : styles) {
            ::make_unique_name(m_styles, style.name);
            m_styles.push_back({style});
        }
    }
 
    std::optional<size_t> active_index_opt = (app_config != nullptr) ? 
        ::load_style_index(*app_config) : 
        std::optional<size_t>{};
 
    size_t active_index = 0;
    if (active_index_opt.has_value()) active_index = *active_index_opt;    
    if (active_index >= m_styles.size()) active_index = 0;
    
    // find valid font item
    if (load_style(active_index))
        return; // style is loaded
 
    // Try to fix that style can't be loaded
    m_styles.erase(m_styles.begin() + active_index);
 
    load_valid_style();
}

References load_style(), load_valid_style(), m_app_config, m_create_default_styles, m_styles, and style.

Here is the call graph for this function:

init_style_images()

void StyleManager::init_style_images	(	const Vec2i32 &	max_size,
		const std::string &	text )

Initialization texture with rendered font style.

Parameters

max_size	Maximal width and height of one style texture
text	Text to render by style

{
    // check already initialized
    if (m_exist_style_images) return;
 
    // check is initializing
    if (m_temp_style_images != nullptr) {
        // is initialization finished
        if (!m_temp_style_images->styles.empty()) { 
            assert(m_temp_style_images->images.size() ==
                   m_temp_style_images->styles.size());
            // copy images into styles
            for (StyleManager::StyleImage &image : m_temp_style_images->images){
                size_t index = &image - &m_temp_style_images->images.front();
                StyleImagesData::Item &style = m_temp_style_images->styles[index];
 
                // find style in font list and copy to it
                for (auto &it : m_styles) {
                    if (it.name != style.text ||
                        !(it.prop == style.prop))
                        continue;
                    it.image = image;
                    break;
                }
            }
            m_temp_style_images = nullptr;
            m_exist_style_images = true;
            return;
        }
        // in process of initialization inside of job
        return;
    }
 
    // create job for init images
    m_temp_style_images = std::make_shared<StyleImagesData::StyleImages>();
    StyleImagesData::Items styles;
    styles.reserve(m_styles.size());
    for (const Style &style : m_styles) {
        std::optional<wxFont> wx_font_opt = WxFontUtils::load_wxFont(style.path);
        if (!wx_font_opt.has_value()) continue;
        std::unique_ptr<FontFile> font_file =
            WxFontUtils::create_font_file(*wx_font_opt);
        if (font_file == nullptr) continue;
        styles.push_back({
            FontFileWithCache(std::move(font_file)), 
            style.name,
            style.prop
        });
    }
 
    auto mf = wxGetApp().mainframe;
    // dot per inch for monitor
    int dpi = get_dpi_for_window(mf);
    // pixel per millimeter
    double ppm = dpi / GizmoObjectManipulation::in_to_mm;
 
    auto &worker = wxGetApp().plater()->get_ui_job_worker();
    StyleImagesData data{std::move(styles), max_size, text, m_temp_style_images, ppm};
    queue_job(worker, std::make_unique<CreateFontStyleImagesJob>(std::move(data)));
}

References Slic3r::GUI::WxFontUtils::create_font_file(), Slic3r::GUI::get_dpi_for_window(), Slic3r::GUI::GizmoObjectManipulation::in_to_mm, Slic3r::GUI::WxFontUtils::load_wxFont(), m_exist_style_images, m_styles, m_temp_style_images, Slic3r::GUI::queue_job(), and style.

Here is the call graph for this function:

init_trunc_names()

void StyleManager::init_trunc_names

(

float

max_width

)

                                                   { 
    for (auto &s : m_styles)
        if (s.truncated_name.empty()) {
            std::string name = s.name;
            ImGuiWrapper::escape_double_hash(name);
            s.truncated_name = ImGuiWrapper::trunc(name, max_width);
        }
}

References Slic3r::GUI::ImGuiWrapper::escape_double_hash(), m_styles, and Slic3r::GUI::ImGuiWrapper::trunc().

Here is the call graph for this function:

is_active_font()

bool StyleManager::is_active_font

(

)

{ return m_style_cache.font_file.has_value(); }

References m_style_cache.

Referenced by anonymous_namespace{GLGizmoEmboss.cpp}::create_emboss_data_base(), get_imgui_font(), and Slic3r::GUI::TextLinesModel::init().

Here is the caller graph for this function:

is_font_changed()

bool StyleManager::is_font_changed

(

)

const

check whether current style differ to selected

Returns

{
    const wxFont &wx_font = get_wx_font();
    if (!wx_font.IsOk())
        return false;
    if (!exist_stored_style())
        return false;
    const EmbossStyle *stored_style = get_stored_style();
    if (stored_style == nullptr)
        return false;
 
    const wxFont &wx_font_stored = get_stored_wx_font();
    if (!wx_font_stored.IsOk())
        return false;
 
    const FontProp &prop = get_style().prop;
    const FontProp &prop_stored = stored_style->prop;
 
    // Exist change in face name?
    if(wx_font_stored.GetFaceName() != wx_font.GetFaceName()) return true;
 
    const std::optional<float> &skew = prop.skew;
    bool is_italic = skew.has_value() || WxFontUtils::is_italic(wx_font);
    const std::optional<float> &skew_stored = prop_stored.skew;
    bool is_stored_italic = skew_stored.has_value() || WxFontUtils::is_italic(wx_font_stored);
    // is italic changed
    if (is_italic != is_stored_italic)
        return true;
 
    const std::optional<float> &boldness = prop.boldness;
    bool is_bold = boldness.has_value() || WxFontUtils::is_bold(wx_font);
    const std::optional<float> &boldness_stored = prop_stored.boldness;
    bool is_stored_bold = boldness_stored.has_value() || WxFontUtils::is_bold(wx_font_stored);
    // is bold changed
    return is_bold != is_stored_bold;
}

References Slic3r::FontProp::boldness, exist_stored_style(), get_stored_style(), get_stored_wx_font(), get_style(), get_wx_font(), Slic3r::GUI::WxFontUtils::is_bold(), Slic3r::Emboss::is_italic(), Slic3r::GUI::WxFontUtils::is_italic(), Slic3r::EmbossStyle::prop, and Slic3r::FontProp::skew.

Here is the call graph for this function:

is_unique_style_name()

bool StyleManager::is_unique_style_name

(

const std::string &

name

)

const

                                                                   {
    for (const StyleManager::Style &style : m_styles)
        if (style.name == name)
            return false;
    return true;
}

References m_styles, and style.

load_style() [1/3]

bool StyleManager::load_style

(

const Style &

style

)

                                                {
    if (style.type == EmbossStyle::Type::file_path) {
        std::unique_ptr<FontFile> font_ptr =
            create_font_file(style.path.c_str());
        if (font_ptr == nullptr) return false;
        m_style_cache.wx_font = {};
        m_style_cache.font_file = 
            FontFileWithCache(std::move(font_ptr));
        m_style_cache.style          = style; // copy
        m_style_cache.style_index    = std::numeric_limits<size_t>::max();
        m_style_cache.stored_wx_font = {};
        return true;
    }
    if (style.type != WxFontUtils::get_current_type()) return false;
    std::optional<wxFont> wx_font_opt = WxFontUtils::load_wxFont(style.path);
    if (!wx_font_opt.has_value()) return false;
    return load_style(style, *wx_font_opt);
}

References Slic3r::Emboss::create_font_file(), Slic3r::EmbossStyle::file_path, Slic3r::GUI::WxFontUtils::get_current_type(), load_style(), Slic3r::GUI::WxFontUtils::load_wxFont(), m_style_cache, and style.

Here is the call graph for this function:

load_style() [2/3]

bool StyleManager::load_style	(	const Style &	style,
		const wxFont &	font )

{
    m_style_cache.style = style; // copy
 
    // wx font property has bigger priority to set
    // it must be after copy of the style
    if (!set_wx_font(font)) return false;
 
    m_style_cache.style_index = std::numeric_limits<size_t>::max();
    m_style_cache.stored_wx_font = {};
    m_style_cache.truncated_name.clear();
    return true;
}

References m_style_cache, set_wx_font(), and style.

Here is the call graph for this function:

load_style() [3/3]

bool StyleManager::load_style

(

size_t

font_index

)

Change active font When font not loaded roll back activ font.

Parameters

font_index

New font index(from m_styles range)

Returns

True on succes. False on fail load font

{
    if (style_index >= m_styles.size()) return false;
    if (!load_style(m_styles[style_index])) return false;
    m_style_cache.style_index    = style_index;
    m_style_cache.stored_wx_font = m_style_cache.wx_font; // copy
    m_last_style_index           = style_index;
    return true;
}

References load_style(), m_last_style_index, m_style_cache, and m_styles.

Referenced by anonymous_namespace{GLGizmoEmboss.cpp}::can_write(), discard_style_changes(), init(), load_style(), load_style(), load_valid_style(), and Slic3r::GUI::GLGizmoEmboss::re_emboss().

Here is the call graph for this function:

Here is the caller graph for this function:

load_valid_style()

void StyleManager::load_valid_style

(

)

load some valid style

{
    // iterate over all known styles
    while (!m_styles.empty()) {
        if (load_style(0))
            return;
        // can't load so erase it from list
        m_styles.erase(m_styles.begin());
    }
 
    // no one style is loadable
    // set up default font list
    EmbossStyles def_style = m_create_default_styles();
    for (EmbossStyle &style : def_style) {
        ::make_unique_name(m_styles, style.name);
        m_styles.push_back({std::move(style)});
    }
 
    // iterate over default styles
    // There have to be option to use build in font
    while (!m_styles.empty()) {
        if (load_style(0))
            return;
        // can't load so erase it from list
        m_styles.erase(m_styles.begin());
    }
 
    // This OS doesn't have TTF as default font,
    // find some loadable font out of default list
    assert(false);
}

References load_style(), m_create_default_styles, m_styles, and style.

Referenced by anonymous_namespace{GLGizmoEmboss.cpp}::create_emboss_data_base(), discard_style_changes(), and init().

Here is the call graph for this function:

Here is the caller graph for this function:

rename()

void StyleManager::rename

(

const std::string &

name

)

Rename actual selected font item.

Parameters

name

New name

                                               {
    m_style_cache.style.name = name;
    m_style_cache.truncated_name.clear();
    if (exist_stored_style()) { 
        Style &it = m_styles[m_style_cache.style_index];
        it.name = name;
        it.truncated_name.clear();
    }
}

References exist_stored_style(), m_style_cache, m_styles, Slic3r::EmbossStyle::name, and Slic3r::GUI::Emboss::StyleManager::Style::truncated_name.

Here is the call graph for this function:

set_wx_font() [1/2]

bool StyleManager::set_wx_font

(

const wxFont &

wx_font

)

Setter on wx_font when changed.

Parameters

wx_font

new wx font

Returns

True on success set otherwise FALSE

                                                    {
    std::unique_ptr<FontFile> font_file = 
        WxFontUtils::create_font_file(wx_font);
    return set_wx_font(wx_font, std::move(font_file));
}

References Slic3r::GUI::WxFontUtils::create_font_file(), and set_wx_font().

Referenced by load_style(), and set_wx_font().

Here is the call graph for this function:

Here is the caller graph for this function:

set_wx_font() [2/2]

bool StyleManager::set_wx_font	(	const wxFont &	wx_font,
		std::unique_ptr< Slic3r::Emboss::FontFile >	font_file )

Faster way of set wx_font when font file is known(do not load font file twice) When you not sure that wx_font is made by font_file use only set_wx_font(wx_font).

Parameters

wx_font	Must be source of font file
font_file	font file created by WxFontUtils::create_font_file(wx_font)

Returns

True on success otherwise false

{
    if (font_file == nullptr) return false;
    m_style_cache.wx_font = wx_font; // copy
    m_style_cache.font_file = 
        FontFileWithCache(std::move(font_file));
 
    EmbossStyle &style = m_style_cache.style;
    style.type = WxFontUtils::get_current_type();
    // update string path
    style.path = WxFontUtils::store_wxFont(wx_font);
    WxFontUtils::update_property(style.prop, wx_font);
    clear_imgui_font();
    return true;
}

References clear_imgui_font(), Slic3r::GUI::WxFontUtils::get_current_type(), m_style_cache, Slic3r::GUI::WxFontUtils::store_wxFont(), style, and Slic3r::GUI::WxFontUtils::update_property().

Here is the call graph for this function:

store_styles_to_app_config()

bool StyleManager::store_styles_to_app_config	(	bool	use_modification = true,
		bool	store_active_index = true )

Write font list into AppConfig.

Parameters

item_to_store	Configuration
use_modification	When true cache state will be used for store
use_modification	When true store activ index into configuration

Returns

True on succes otherwise False.

{
    assert(m_app_config != nullptr);
    if (m_app_config == nullptr) return false;
    if (use_modification) {
        if (exist_stored_style()) {
            // update stored item
            m_styles[m_style_cache.style_index] = m_style_cache.style;
        } else {
            // add new into stored list
            EmbossStyle &style = m_style_cache.style;
            ::make_unique_name(m_styles, style.name);
            m_style_cache.truncated_name.clear();
            m_style_cache.style_index = m_styles.size();
            m_styles.push_back({style});
        }
        m_style_cache.stored_wx_font = m_style_cache.wx_font;
    }
 
    if (store_active_index)
    {
        size_t style_index = exist_stored_style() ?
                                 m_style_cache.style_index :
                                 m_last_style_index;
        store_style_index(*m_app_config, style_index);
    }
 
    store_styles(*m_app_config, m_styles);
    return true;
}

References exist_stored_style(), m_app_config, m_last_style_index, m_style_cache, m_styles, and style.

Here is the call graph for this function:

swap()

void StyleManager::swap	(	size_t	i1,
		size_t	i2 )

Change order of style item in m_styles. Fix selected font index when (i1 || i2) == m_font_selected.

Parameters

i1	First index to m_styles
i2	Second index to m_styles

                                            {
    if (i1 >= m_styles.size() || 
        i2 >= m_styles.size()) return;
    std::swap(m_styles[i1], m_styles[i2]);
    // fix selected index
    if (!exist_stored_style()) return;
    if (m_style_cache.style_index == i1) {
        m_style_cache.style_index = i2;
    } else if (m_style_cache.style_index == i2) {
        m_style_cache.style_index = i1;
    }
}

References exist_stored_style(), m_style_cache, and m_styles.

Here is the call graph for this function:

Friends And Related Symbol Documentation

CreateFontStyleImagesJob

friend class CreateFontStyleImagesJob

friend

References CreateFontStyleImagesJob, and style.

Referenced by CreateFontStyleImagesJob.

Member Data Documentation

m_app_config

AppConfig* Slic3r::GUI::Emboss::StyleManager::m_app_config = nullptr

private

Referenced by init(), and store_styles_to_app_config().

m_create_default_styles

std::function<EmbossStyles()> Slic3r::GUI::Emboss::StyleManager::m_create_default_styles

private

Referenced by StyleManager(), init(), and load_valid_style().

m_exist_style_images

bool Slic3r::GUI::Emboss::StyleManager::m_exist_style_images = false

private

Referenced by free_style_images(), and init_style_images().

m_imgui_init_glyph_range

const ImWchar* Slic3r::GUI::Emboss::StyleManager::m_imgui_init_glyph_range

private

Referenced by StyleManager(), and create_imgui_font().

m_last_style_index

size_t Slic3r::GUI::Emboss::StyleManager::m_last_style_index = std::numeric_limits<size_t>::max()

private

Referenced by discard_style_changes(), load_style(), and store_styles_to_app_config().

m_style_cache

struct Slic3r::GUI::Emboss::StyleManager::StyleCache Slic3r::GUI::Emboss::StyleManager::m_style_cache

private

Referenced by add_style(), clear_glyphs_cache(), clear_imgui_font(), create_imgui_font(), discard_style_changes(), erase(), exist_stored_style(), get_atlas(), get_font_file_with_cache(), get_imgui_font(), get_stored_style(), get_stored_wx_font(), get_style(), get_style(), get_style_index(), get_truncated_name(), get_wx_font(), has_collections(), is_active_font(), load_style(), load_style(), load_style(), rename(), set_wx_font(), store_styles_to_app_config(), and swap().

m_styles

Styles Slic3r::GUI::Emboss::StyleManager::m_styles

private

Referenced by add_style(), erase(), free_style_images(), get_stored_style(), get_styles(), init(), init_style_images(), init_trunc_names(), is_unique_style_name(), load_style(), load_valid_style(), rename(), store_styles_to_app_config(), and swap().

m_temp_style_images

std::shared_ptr<StyleImagesData::StyleImages> Slic3r::GUI::Emboss::StyleManager::m_temp_style_images = nullptr

private

Referenced by init_style_images().

max_imgui_font_size

float StyleManager::max_imgui_font_size = 60.f

static

Referenced by create_imgui_font(), and Slic3r::GUI::GLGizmoEmboss::draw_text_input().

min_imgui_font_size

float StyleManager::min_imgui_font_size = 18.f

static

Referenced by create_imgui_font(), and Slic3r::GUI::GLGizmoEmboss::draw_text_input().

---

The documentation for this class was generated from the following files:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/Utils/EmbossStyleManager.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/Utils/EmbossStyleManager.cpp