anonymous_namespace{GLGizmoEmboss.cpp} Namespace Reference

Classes
struct	Limit
struct	Limits
struct	TextDataBase
struct	FaceName
struct	Facenames
struct	GuiCfg

Enumerations
enum class	IconType : unsigned {   rename = 0 , erase , add , save ,   undo , italic , unitalic , bold ,   unbold , system_selector , open_file , exclamation ,   lock , lock_bold , unlock , unlock_bold ,   align_horizontal_left , align_horizontal_center , align_horizontal_right , align_vertical_top ,   align_vertical_center , align_vertical_bottom , _count }
enum class	IconState : unsigned { activable = 0 , hovered , disabled }

Functions
std::unique_ptr< DataBase >	create_emboss_data_base (const std::string &text, StyleManager &style_manager, TextLinesModel &text_lines, const Selection &selection, ModelVolumeType type, std::shared_ptr< std::atomic< bool > > &cancel)
	Prepare data for emboss.
CreateVolumeParams	create_input (GLCanvas3D &canvas, const StyleManager::Style &style, RaycastManager &raycaster, ModelVolumeType volume_type)
ImVec2	calc_fine_position (const Selection &selection, const ImVec2 &windows_size, const Size &canvas_size)
	Move window for edit emboss text near to embossed object NOTE: embossed object must be selected.
const IconManager::Icon &	get_icon (const IconManager::VIcons &icons, IconType type, IconState state)
bool	draw_button (const IconManager::VIcons &icons, IconType type, bool disable=false)
bool	store (const Facenames &facenames)
bool	load (Facenames &facenames)
void	init_face_names (Facenames &facenames)
void	init_truncated_names (Facenames &face_names, float max_width)
GuiCfg	create_gui_configuration ()
void	draw_font_preview (FaceName &face, const std::string &text, Facenames &faces, const GuiCfg &cfg, bool is_visible)
void	init_text_lines (TextLinesModel &text_lines, const Selection &selection, StyleManager &style_manager, unsigned count_lines=0)
ModelVolumePtrs	prepare_volumes_to_slice (const ModelVolume &mv)
bool	check (ModelVolumeType volume_type)
bool	can_write (StyleManager &style_manager, const std::string &text)
bool	can_write (const EmbossStyle &style, const std::string &text)
void	add_style_for_default_text (EmbossStyles &styles)
std::optional< wxString >	get_installed_face_name (const std::optional< std::string > &face_name_opt, ::Facenames &face_names)
	Check installed fonts whether optional face name exist in installed fonts.
void	fix_transformation (const StyleManager::Style &from, const StyleManager::Style &to, GLCanvas3D &canvas)
bool	is_text_empty (std::string_view text)
std::string	concat (std::vector< wxString > data)
boost::filesystem::path	get_fontlist_cache_path ()

Variables
const std::string	rotation_snapshot_name = L("Text rotate")
const std::string	move_snapshot_name = L("Text move")
static const struct anonymous_namespace{GLGizmoEmboss.cpp}::Limits	limits
static const float	SELECTABLE_INNER_OFFSET = 8.0f
const char *const	default_text = L("Embossed text")

---

Class Documentation

anonymous_namespace{GLGizmoEmboss.cpp}::Limit

struct anonymous_namespace{GLGizmoEmboss.cpp}::Limit

template<typename T>
struct anonymous_namespace{GLGizmoEmboss.cpp}::Limit< T >

Inheritance diagram for anonymous_namespace{GLGizmoEmboss.cpp}::Limit< T >:

Class Members
MinMax< T >	gui
MinMax< T >	values

anonymous_namespace{GLGizmoEmboss.cpp}::Limits

struct anonymous_namespace{GLGizmoEmboss.cpp}::Limits

Collaboration diagram for anonymous_namespace{GLGizmoEmboss.cpp}::Limits:

Class Members
MinMax< float >	angle {-180.f, 180.f}
Limit< float >	boldness {{-.5f, .5f}, {-5e5f, 5e5f}}
MinMax< int >	char_gap {-20000, 20000}
MinMax< double >	emboss {0.01, 1e4}
MinMax< int >	line_gap {-20000, 20000}
MinMax< float >	size_in_mm {0.1f, 1000.f}
Limit< float >	skew {{-1.f, 1.f}, {-100.f, 100.f}}

anonymous_namespace{GLGizmoEmboss.cpp}::FaceName

struct anonymous_namespace{GLGizmoEmboss.cpp}::FaceName

Collaboration diagram for anonymous_namespace{GLGizmoEmboss.cpp}::FaceName:

Class Members
shared_ptr< atomic< bool > >	cancel = nullptr
shared_ptr< bool >	is_created = nullptr
string	name_truncated = ""
size_t	texture_index = 0
wxString	wx_name

anonymous_namespace{GLGizmoEmboss.cpp}::GuiCfg

struct anonymous_namespace{GLGizmoEmboss.cpp}::GuiCfg

Collaboration diagram for anonymous_namespace{GLGizmoEmboss.cpp}::GuiCfg:

Class Members
float	advanced_input_offset = 0.f
bool	dark_mode = false
float	delete_pos_x = 0.f
Vec2i32	face_name_size = Vec2i32(0, 0)
float	face_name_texture_offset_x = 0.f
float	height_of_volume_type_selector = 0.f
unsigned int	icon_width = 0
float	indent = 0.f
float	input_offset = 0.f
float	input_width = 0.f
float	lock_offset = 0.f
unsigned int	max_count_opened_font_files = 10
Vec2i32	max_style_image_size = Vec2i32(0, 0)
float	max_style_name_width = 0.f
float	max_tooltip_width = 0.f
double	screen_scale
ImVec2	text_size
Translations	translations

Enumeration Type Documentation

IconState

enum class anonymous_namespace{GLGizmoEmboss.cpp}::IconState : unsigned

strong

Enumerator
activable
hovered
disabled

: unsigned { activable = 0, hovered /*1*/, disabled /*2*/ };

IconType

enum class anonymous_namespace{GLGizmoEmboss.cpp}::IconType : unsigned

strong

Enumerator
rename
erase
add
save
undo
italic
unitalic
bold
unbold
system_selector
open_file
exclamation
lock
lock_bold
unlock
unlock_bold
align_horizontal_left
align_horizontal_center
align_horizontal_right
align_vertical_top
align_vertical_center
align_vertical_bottom
_count

                    : unsigned {
    rename = 0,
    erase,
    add,
    save,
    undo,
    italic,
    unitalic,
    bold,
    unbold,
    system_selector,
    open_file,
    exclamation,
    lock,
    lock_bold,
    unlock,
    unlock_bold,
    align_horizontal_left,
    align_horizontal_center,
    align_horizontal_right,
    align_vertical_top,
    align_vertical_center,
    align_vertical_bottom,
    // automatic calc of icon's count
    _count
};

Function Documentation

add_style_for_default_text()

void anonymous_namespace{GLGizmoEmboss.cpp}::add_style_for_default_text

(

EmbossStyles &

styles

)

{
    const std::string text = _u8L(default_text);
    // the untranslated text is Latin, which the system fonts have
    if (text == default_text || can_write(styles.front(), text))
        return;
 
    for (const char *face_name : {"HarmonyOS Sans SC", "NanumGothic", "Sarabun"}) {
        wxFont wx_font = *wxNORMAL_FONT;
        if (!wx_font.SetFaceName(face_name))
            continue;
        EmbossStyle style = WxFontUtils::create_emboss_style(wx_font, _u8L("Default font"));
        if (can_write(style, text)) {
            styles.insert(styles.begin(), std::move(style));
            return;
        }
    }
}

References _u8L, add_style_for_default_text(), can_write(), Slic3r::GUI::WxFontUtils::create_emboss_style(), default_text, and style.

Referenced by add_style_for_default_text().

Here is the call graph for this function:

Here is the caller graph for this function:

calc_fine_position()

ImVec2 anonymous_namespace{GLGizmoEmboss.cpp}::calc_fine_position	(	const Selection &	selection,
		const ImVec2 &	windows_size,
		const Size &	canvas_size )

Move window for edit emboss text near to embossed object NOTE: embossed object must be selected.

{
    const Selection::IndicesList indices = selection.get_volume_idxs();
    // no selected volume
    if (indices.empty())
        return {};
    const GLVolume *volume = selection.get_volume(*indices.begin());
    // bad volume selected (e.g. deleted one)
    if (volume == nullptr)
        return {};
 
    const Camera   &camera = wxGetApp().plater()->get_camera();
    Slic3r::Polygon hull   = CameraUtils::create_hull2d(camera, *volume);
 
    ImVec2 c_size(canvas_size.get_width(), canvas_size.get_height());
    ImVec2 offset = ImGuiWrapper::suggest_location(windows_size, hull, c_size);
    return offset;
}

References Slic3r::GUI::CameraUtils::create_hull2d(), Slic3r::GUI::Size::get_height(), Slic3r::GUI::Selection::get_volume(), Slic3r::GUI::Selection::get_volume_idxs(), Slic3r::GUI::Size::get_width(), Slic3r::offset(), and Slic3r::GUI::ImGuiWrapper::suggest_location().

Here is the call graph for this function:

can_write() [1/2]

bool anonymous_namespace{GLGizmoEmboss.cpp}::can_write	(	const EmbossStyle &	style,
		const std::string &	text )

{
    StyleManager style_manager(nullptr, {});
    return style_manager.load_style(StyleManager::Style{style}) && can_write(style_manager, text);
}

References can_write(), Slic3r::GUI::Emboss::StyleManager::load_style(), and style.

Here is the call graph for this function:

can_write() [2/2]

bool anonymous_namespace{GLGizmoEmboss.cpp}::can_write	(	StyleManager &	style_manager,
		const std::string &	text )

{
    bool exist_unknown = false;
    create_range_text(text, *style_manager.get_font_file_with_cache().font_file,
                      style_manager.get_font_prop().collection_number.value_or(0), &exist_unknown);
    return !exist_unknown;
}

References can_write(), Slic3r::FontProp::collection_number, Slic3r::Emboss::create_range_text(), Slic3r::Emboss::FontFileWithCache::font_file, Slic3r::GUI::Emboss::StyleManager::get_font_file_with_cache(), and Slic3r::GUI::Emboss::StyleManager::get_font_prop().

Referenced by add_style_for_default_text(), can_write(), and can_write().

Here is the call graph for this function:

Here is the caller graph for this function:

check()

bool anonymous_namespace{GLGizmoEmboss.cpp}::check

(

ModelVolumeType

volume_type

)

                                        {
    return volume_type == ModelVolumeType::MODEL_PART ||
           volume_type == ModelVolumeType::NEGATIVE_VOLUME ||
           volume_type == ModelVolumeType::PARAMETER_MODIFIER;
}

References check(), Slic3r::MODEL_PART, Slic3r::NEGATIVE_VOLUME, and Slic3r::PARAMETER_MODIFIER.

Referenced by check().

Here is the call graph for this function:

Here is the caller graph for this function:

concat()

std::string anonymous_namespace{GLGizmoEmboss.cpp}::concat

(

std::vector< wxString >

data

)

                                           {
    std::stringstream ss;
    for (const auto &d : data) 
        ss << d.c_str() << ", ";
    return ss.str();
}

Referenced by init_face_names().

Here is the caller graph for this function:

create_emboss_data_base()

std::unique_ptr< DataBase > anonymous_namespace{GLGizmoEmboss.cpp}::create_emboss_data_base	(	const std::string &	text,
		StyleManager &	style_manager,
		TextLinesModel &	text_lines,
		const Selection &	selection,
		ModelVolumeType	type,
		std::shared_ptr< std::atomic< bool > > &	cancel )

Prepare data for emboss.

Parameters

text	Text to emboss
style_manager	Keep actual selected style
text_lines	Needed when transform per glyph
selection	Needed for transform per glyph
type	Define type of volume - side of surface(in / out)
cancel	Cancel for previous job

Returns

Base data for emboss text

{
    // create volume_name
    std::string volume_name = text; // copy
    // contain_enter?
    if (volume_name.find('\n') != std::string::npos)
        // change enters to space
        std::replace(volume_name.begin(), volume_name.end(), '\n', ' ');
 
    if (!style_manager.is_active_font()) {
        style_manager.load_valid_style();
        assert(style_manager.is_active_font());
        if (!style_manager.is_active_font())
            return {}; // no active font in style, should never happend !!!
    }
 
    const StyleManager::Style &style = style_manager.get_style();
    // actualize font path - during changes in gui it could be corrupted
    // volume must store valid path
    assert(style_manager.get_wx_font().IsOk());
    assert(style.path.compare(WxFontUtils::store_wxFont(style_manager.get_wx_font())) == 0);
 
    if (style.prop.per_glyph) {
        if (!text_lines.is_init())
            init_text_lines(text_lines, selection, style_manager);
    } else
        text_lines.reset();
    
    bool is_outside = (type == ModelVolumeType::MODEL_PART);
 
    // Cancel previous Job, when it is in process
    // worker.cancel(); --> Use less in this case I want cancel only previous EmbossJob no other jobs
    // Cancel only EmbossUpdateJob no others
    if (cancel != nullptr)
        cancel->store(true);
    // create new shared ptr to cancel new job
    cancel = std::make_shared<std::atomic<bool>>(false);
 
    DataBase base(volume_name, cancel);
    base.is_outside = is_outside;
    base.text_lines = text_lines.get_lines();
    base.from_surface = style.distance;
 
    FontFileWithCache &font = style_manager.get_font_file_with_cache();
    TextConfiguration tc{static_cast<EmbossStyle>(style), text};
    return std::make_unique<TextDataBase>(std::move(base), font, std::move(tc), style.projection);
}

References Slic3r::GUI::Emboss::StyleManager::get_font_file_with_cache(), Slic3r::GUI::TextLinesModel::get_lines(), Slic3r::GUI::Emboss::StyleManager::get_style(), Slic3r::GUI::Emboss::StyleManager::get_wx_font(), init_text_lines(), Slic3r::GUI::Emboss::StyleManager::is_active_font(), Slic3r::GUI::TextLinesModel::is_init(), Slic3r::GUI::Emboss::StyleManager::load_valid_style(), Slic3r::MODEL_PART, Slic3r::GUI::TextLinesModel::reset(), Slic3r::GUI::WxFontUtils::store_wxFont(), and style.

Here is the call graph for this function:

create_gui_configuration()

GuiCfg anonymous_namespace{GLGizmoEmboss.cpp}::create_gui_configuration

(

)

{
    GuiCfg cfg; // initialize by default values;
 
    float line_height = ImGui::GetTextLineHeight();
    float line_height_with_spacing = ImGui::GetTextLineHeightWithSpacing();
    float space = line_height_with_spacing - line_height;
    const ImGuiStyle &style  = ImGui::GetStyle();
 
    cfg.max_style_name_width = ImGui::CalcTextSize("Maximal style name..").x;
 
    cfg.icon_width = static_cast<unsigned int>(std::ceil(line_height));
    // make size pair number
    if (cfg.icon_width % 2 != 0) ++cfg.icon_width;
 
    cfg.delete_pos_x = cfg.max_style_name_width + space;
    const float count_line_of_text = 3.f;
    cfg.text_size = ImVec2(-FLT_MIN, line_height_with_spacing * count_line_of_text);
    ImVec2 letter_m_size = ImGui::CalcTextSize("M");
    const float count_letter_M_in_input = 12.f;
    cfg.input_width = letter_m_size.x * count_letter_M_in_input;
    GuiCfg::Translations &tr = cfg.translations;
 
    // TRN - Input label. Be short as possible
    // Select look of letter shape
    tr.font   = _u8L("Font");
    // TRN - Input label. Be short as possible
    // Height of one text line - Font Ascent
    tr.height = _u8L("Height");
    // TRN - Input label. Be short as possible
    // Size in emboss direction
    tr.depth  = _u8L("Depth");
 
    float max_text_width = std::max({
        ImGui::CalcTextSize(tr.font.c_str()).x,
        ImGui::CalcTextSize(tr.height.c_str()).x,
        ImGui::CalcTextSize(tr.depth.c_str()).x});
    cfg.indent       = 20.0f;
    cfg.input_offset = style.WindowPadding.x + cfg.indent + max_text_width + space;
 
    // TRN - Input label. Be short as possible
    // Copy surface of model on surface of the embossed text
    tr.use_surface = _u8L("Use surface");
    // TRN - Input label. Be short as possible
    // Option to change projection on curved surface 
    // for each character(glyph) in text separately
    tr.per_glyph = _u8L("Per glyph");
    // TRN - Input label. Be short as possible
    // Align Top|Middle|Bottom and Left|Center|Right
    tr.alignment = _u8L("Alignment");
    // TRN - Input label. Be short as possible
    tr.char_gap = _u8L("Char gap");
    // TRN - Input label. Be short as possible
    tr.line_gap = _u8L("Line gap");
    // TRN - Input label. Be short as possible
    tr.boldness = _u8L("Boldness");
 
    // TRN - Input label. Be short as possible
    // Like Font italic 
    tr.skew_ration = _u8L("Skew ratio");
 
    // TRN - Input label. Be short as possible
    // Distance from model surface to be able 
    // move text as part fully into not flat surface
    // move text as modifier fully out of not flat surface
    tr.from_surface = _u8L("From surface");
 
    // TRN - Input label. Be short as possible
    // Angle between Y axis and text line direction.
    tr.rotation = _u8L("Rotation");
 
    // TRN - Input label. Be short as possible
    // Keep vector from bottom to top of text aligned with printer Y axis
    tr.keep_up = _u8L("Keep up");
 
    // TRN - Input label. Be short as possible. 
    // Some Font file contain multiple fonts inside and
    // this is numerical selector of font inside font collections
    tr.collection = _u8L("Collection");
 
    float max_advanced_text_width = std::max({
        ImGui::CalcTextSize(tr.use_surface.c_str()).x,
        ImGui::CalcTextSize(tr.per_glyph.c_str()).x,
        ImGui::CalcTextSize(tr.alignment.c_str()).x,
        ImGui::CalcTextSize(tr.char_gap.c_str()).x,
        ImGui::CalcTextSize(tr.line_gap.c_str()).x,
        ImGui::CalcTextSize(tr.boldness.c_str()).x,
        ImGui::CalcTextSize(tr.skew_ration.c_str()).x,
        ImGui::CalcTextSize(tr.from_surface.c_str()).x,
        ImGui::CalcTextSize(tr.rotation.c_str()).x + cfg.icon_width + 2*space,
        ImGui::CalcTextSize(tr.keep_up.c_str()).x,
        ImGui::CalcTextSize(tr.collection.c_str()).x });
    cfg.advanced_input_offset = max_advanced_text_width
        + 3 * space + cfg.indent;
 
    cfg.lock_offset = cfg.advanced_input_offset - (cfg.icon_width + space);
    // calculate window size
    float input_height = line_height_with_spacing + 2*style.FramePadding.y;
    float separator_height = 2 + style.FramePadding.y;
 
    // "Text is to object" + radio buttons
    cfg.height_of_volume_type_selector = separator_height + line_height_with_spacing + input_height;
 
    int max_style_image_width = static_cast<int>(std::round(cfg.max_style_name_width - 2 * style.FramePadding.x));
    cfg.max_style_image_size = Vec2i32(max_style_image_width, line_height_with_spacing);
    cfg.face_name_size = Vec2i32(cfg.input_width, line_height_with_spacing);
    cfg.face_name_texture_offset_x = cfg.face_name_size.x() + style.WindowPadding.x + space;
 
    cfg.max_tooltip_width = ImGui::GetFontSize() * 20.0f;
 
    return cfg;
}

References _u8L, anonymous_namespace{GLGizmoEmboss.cpp}::GuiCfg::advanced_input_offset, anonymous_namespace{GLGizmoEmboss.cpp}::GuiCfg::Translations::alignment, anonymous_namespace{GLGizmoEmboss.cpp}::GuiCfg::Translations::boldness, anonymous_namespace{GLGizmoEmboss.cpp}::GuiCfg::Translations::char_gap, anonymous_namespace{GLGizmoEmboss.cpp}::GuiCfg::Translations::collection, anonymous_namespace{GLGizmoEmboss.cpp}::GuiCfg::delete_pos_x, anonymous_namespace{GLGizmoEmboss.cpp}::GuiCfg::Translations::depth, anonymous_namespace{GLGizmoEmboss.cpp}::GuiCfg::face_name_size, anonymous_namespace{GLGizmoEmboss.cpp}::GuiCfg::face_name_texture_offset_x, anonymous_namespace{GLGizmoEmboss.cpp}::GuiCfg::Translations::font, anonymous_namespace{GLGizmoEmboss.cpp}::GuiCfg::Translations::from_surface, anonymous_namespace{GLGizmoEmboss.cpp}::GuiCfg::Translations::height, anonymous_namespace{GLGizmoEmboss.cpp}::GuiCfg::height_of_volume_type_selector, anonymous_namespace{GLGizmoEmboss.cpp}::GuiCfg::icon_width, anonymous_namespace{GLGizmoEmboss.cpp}::GuiCfg::indent, anonymous_namespace{GLGizmoEmboss.cpp}::GuiCfg::input_offset, anonymous_namespace{GLGizmoEmboss.cpp}::GuiCfg::input_width, anonymous_namespace{GLGizmoEmboss.cpp}::GuiCfg::Translations::keep_up, anonymous_namespace{GLGizmoEmboss.cpp}::GuiCfg::Translations::line_gap, anonymous_namespace{GLGizmoEmboss.cpp}::GuiCfg::lock_offset, anonymous_namespace{GLGizmoEmboss.cpp}::GuiCfg::max_style_image_size, anonymous_namespace{GLGizmoEmboss.cpp}::GuiCfg::max_style_name_width, anonymous_namespace{GLGizmoEmboss.cpp}::GuiCfg::max_tooltip_width, anonymous_namespace{GLGizmoEmboss.cpp}::GuiCfg::Translations::per_glyph, anonymous_namespace{GLGizmoEmboss.cpp}::GuiCfg::Translations::rotation, anonymous_namespace{GLGizmoEmboss.cpp}::GuiCfg::Translations::skew_ration, style, anonymous_namespace{GLGizmoEmboss.cpp}::GuiCfg::text_size, anonymous_namespace{GLGizmoEmboss.cpp}::GuiCfg::translations, and anonymous_namespace{GLGizmoEmboss.cpp}::GuiCfg::Translations::use_surface.

create_input()

CreateVolumeParams anonymous_namespace{GLGizmoEmboss.cpp}::create_input	(	GLCanvas3D &	canvas,
		const StyleManager::Style &	style,
		RaycastManager &	raycaster,
		ModelVolumeType	volume_type )

{
    auto gizmo = static_cast<unsigned char>(GLGizmosManager::Emboss);
    const GLVolume *gl_volume = get_first_hovered_gl_volume(canvas);
    Plater *plater = wxGetApp().plater();
    return CreateVolumeParams{canvas, plater->get_camera(), plater->build_volume(),
        plater->get_ui_job_worker(), volume_type, raycaster, gizmo, gl_volume, style.distance, style.angle};
}

References Slic3r::GUI::GLGizmosManager::Emboss, Slic3r::GUI::get_first_hovered_gl_volume(), Slic3r::GUI::plater(), and style.

Here is the call graph for this function:

draw_button()

bool anonymous_namespace{GLGizmoEmboss.cpp}::draw_button	(	const IconManager::VIcons &	icons,
		IconType	type,
		bool	disable = false )

                                                                             {
    return Slic3r::GUI::button(
        get_icon(icons, type, IconState::activable),
        get_icon(icons, type, IconState::hovered),
        get_icon(icons, type, IconState::disabled),
        disable);}

References activable, Slic3r::GUI::button(), disabled, draw_button(), get_icon(), and hovered.

Referenced by draw_button().

Here is the call graph for this function:

Here is the caller graph for this function:

draw_font_preview()

void anonymous_namespace{GLGizmoEmboss.cpp}::draw_font_preview	(	FaceName &	face,
		const std::string &	text,
		Facenames &	faces,
		const GuiCfg &	cfg,
		bool	is_visible )

                                                                                                                   {
    // Limit for opened font files at one moment
    unsigned int &count_opened_fonts = faces.count_opened_font_files; 
    // Size of texture
    ImVec2 size(cfg.face_name_size.x(), cfg.face_name_size.y());
    float  count_cached_textures_f = static_cast<float>(faces.count_cached_textures);
    std::string state_text;
    // uv0 and uv1 set to pixel 0,0 in texture
    ImVec2 uv0(0.f, 0.f), uv1(1.f / size.x, 1.f / size.y / count_cached_textures_f);
    if (face.is_created != nullptr) {
        // not created preview 
        if (*face.is_created) {
            // Already created preview
            size_t texture_index = face.texture_index;
            uv0 = ImVec2(0.f, texture_index / count_cached_textures_f);
            uv1 = ImVec2(1.f, (texture_index + 1) / count_cached_textures_f);
        } else {
            // Not finished preview
            if (is_visible) {
                // when not canceled still loading
                state_text = (face.cancel->load()) ?
                    " " + _u8L("No symbol"):
                    " ... " + _u8L("Loading");
            } else {
                // not finished and not visible cancel job
                face.is_created = nullptr;
                face.cancel->store(true);
            }
        }
    } else if (is_visible && count_opened_fonts < cfg.max_count_opened_font_files) {
        ++count_opened_fonts;
        face.cancel     = std::make_shared<std::atomic_bool>(false);
        face.is_created = std::make_shared<bool>(false);
 
        const unsigned char gray_level = 5;
        // format type and level must match to texture data
        const GLenum format = GL_RGBA, type = GL_UNSIGNED_BYTE;
        const GLint  level = 0;
        // select next texture index
        size_t texture_index = (faces.texture_index + 1) % faces.count_cached_textures;
 
        // set previous cach as deleted
        for (FaceName &f : faces.faces)
            if (f.texture_index == texture_index) {
                if (f.cancel != nullptr) f.cancel->store(true);
                f.is_created = nullptr;
            }
 
        faces.texture_index = texture_index;
        face.texture_index         = texture_index;
 
        // render text to texture
        FontImageData data{
            text,
            face.wx_name,
            faces.encoding,
            faces.texture_id,
            faces.texture_index,
            cfg.face_name_size,
            gray_level,
            format,
            type,
            level,
            &count_opened_fonts,
            face.cancel,    // copy
            face.is_created // copy
        };
        auto  job    = std::make_unique<CreateFontImageJob>(std::move(data));
        auto &worker = wxGetApp().plater()->get_ui_job_worker();
        queue_job(worker, std::move(job));
    } else {
        // cant start new thread at this moment so wait in queue
        state_text = " ... " + _u8L("In queue");
    }
 
    if (!state_text.empty()) {
        ImGui::SameLine(cfg.face_name_texture_offset_x);
        ImGui::Text("%s", state_text.c_str());
    }
 
    ImGui::SameLine(cfg.face_name_texture_offset_x);
    ImTextureID tex_id     = (void *) (intptr_t) faces.texture_id;
    ImVec4 tint_color = ImGui::GetStyleColorVec4(ImGuiCol_Text);
    ImGui::Image(tex_id, size, uv0, uv1, tint_color);
}

References _u8L, anonymous_namespace{GLGizmoEmboss.cpp}::FaceName::cancel, anonymous_namespace{GLGizmoEmboss.cpp}::Facenames::count_cached_textures, anonymous_namespace{GLGizmoEmboss.cpp}::Facenames::count_opened_font_files, anonymous_namespace{GLGizmoEmboss.cpp}::Facenames::encoding, Slic3r::f(), anonymous_namespace{GLGizmoEmboss.cpp}::GuiCfg::face_name_size, anonymous_namespace{GLGizmoEmboss.cpp}::GuiCfg::face_name_texture_offset_x, anonymous_namespace{GLGizmoEmboss.cpp}::Facenames::faces, Slic3r::format(), GL_RGBA, GL_UNSIGNED_BYTE, anonymous_namespace{GLGizmoEmboss.cpp}::FaceName::is_created, anonymous_namespace{GLGizmoEmboss.cpp}::GuiCfg::max_count_opened_font_files, Slic3r::GUI::queue_job(), anonymous_namespace{GLGizmoEmboss.cpp}::Facenames::texture_id, anonymous_namespace{GLGizmoEmboss.cpp}::FaceName::texture_index, anonymous_namespace{GLGizmoEmboss.cpp}::Facenames::texture_index, and anonymous_namespace{GLGizmoEmboss.cpp}::FaceName::wx_name.

Here is the call graph for this function:

fix_transformation()

void anonymous_namespace{GLGizmoEmboss.cpp}::fix_transformation	(	const StyleManager::Style &	from,
		const StyleManager::Style &	to,
		GLCanvas3D &	canvas )

{
    // fix Z rotation when exists difference in styles
    const std::optional<float>& f_angle_opt = from.angle;
    const std::optional<float>& t_angle_opt = to.angle;
    if (!is_approx(f_angle_opt, t_angle_opt)) {
        // fix rotation
        float f_angle = f_angle_opt.value_or(.0f);
        float t_angle = t_angle_opt.value_or(.0f);
        do_local_z_rotate(canvas.get_selection(), t_angle - f_angle);
        std::string no_snapshot;
        canvas.do_rotate(no_snapshot);
    }
 
    // fix distance (Z move) when exists difference in styles
    const std::optional<float>& f_move_opt = from.distance;
    const std::optional<float>& t_move_opt = to.distance;
    if (!is_approx(f_move_opt, t_move_opt)) {
        float f_move = f_move_opt.value_or(.0f);
        float t_move = t_move_opt.value_or(.0f);
        do_local_z_move(canvas.get_selection(), t_move - f_move);
        std::string no_snapshot;
        canvas.do_move(no_snapshot);
    }
}

References Slic3r::GUI::Emboss::StyleManager::Style::angle, Slic3r::GUI::Emboss::StyleManager::Style::distance, Slic3r::GUI::do_local_z_move(), Slic3r::GUI::do_local_z_rotate(), Slic3r::GUI::GLCanvas3D::do_move(), Slic3r::GUI::GLCanvas3D::do_rotate(), fix_transformation(), Slic3r::GUI::GLCanvas3D::get_selection(), and Slic3r::is_approx().

Referenced by fix_transformation().

Here is the call graph for this function:

Here is the caller graph for this function:

get_fontlist_cache_path()

boost::filesystem::path anonymous_namespace{GLGizmoEmboss.cpp}::get_fontlist_cache_path

(

)

                                             {
    return boost::filesystem::path(data_dir()) / "cache" / "fonts.cereal";
}

References Slic3r::data_dir().

Referenced by init_face_names(), load(), and store().

Here is the call graph for this function:

Here is the caller graph for this function:

get_icon()

const IconManager::Icon & anonymous_namespace{GLGizmoEmboss.cpp}::get_icon	(	const IconManager::VIcons &	icons,
		IconType	type,
		IconState	state )

                                                                                                { 
    return *icons[(unsigned) type][(unsigned) state]; }

References get_icon().

Referenced by draw_button(), and get_icon().

Here is the call graph for this function:

Here is the caller graph for this function:

get_installed_face_name()

std::optional< wxString > anonymous_namespace{GLGizmoEmboss.cpp}::get_installed_face_name	(	const std::optional< std::string > &	face_name_opt,
		::Facenames &	face_names )

Check installed fonts whether optional face name exist in installed fonts.

Parameters

face_name_opt	Name from style - style.prop.face_name
face_names	All installed good and bad fonts - not const must be possible to initialize it

Returns

When it could be installed it contain value(potentionaly empty string)

{
    // Could exist OS without getter on face_name,
    // but it is able to restore font from descriptor
    // Soo default value must be TRUE
    if (!face_name_opt.has_value())
        return wxString();
 
    wxString face_name = wxString::FromUTF8(face_name_opt->c_str());
 
    // search in enumerated fonts
    // refresh list of installed font in the OS.
    init_face_names(face_names);
    face_names.is_init = false;
 
    auto cmp = [](const FaceName &fn, const wxString &wx_name) { return fn.wx_name < wx_name; };
    const std::vector<FaceName> &faces = face_names.faces;    
    // is font installed?
    if (auto it = std::lower_bound(faces.begin(), faces.end(), face_name, cmp);
        it != faces.end() && it->wx_name == face_name)
        return face_name;
 
    const std::vector<wxString> &bad = face_names.bad;
    auto it_bad = std::lower_bound(bad.begin(), bad.end(), face_name);
    if (it_bad == bad.end() || *it_bad != face_name) {
        // check if wx allowed to set it up - another encoding of name
        wxFontEnumerator::InvalidateCache();
        wxFont wx_font_;                                                                          // temporary structure
        if (wx_font_.SetFaceName(face_name) && WxFontUtils::create_font_file(wx_font_) != nullptr // can load TTF file?
        ) {
            return wxString();
            // QUESTION: add this name to allowed faces?
            // Could create twin of font face name
            // When not add it will be hard to select it again when change font
        }
    }
    return {}; // not installed    
}

References Slic3r::GUI::WxFontUtils::create_font_file(), get_installed_face_name(), init_face_names(), and anonymous_namespace{GLGizmoEmboss.cpp}::FaceName::wx_name.

Referenced by get_installed_face_name().

Here is the call graph for this function:

Here is the caller graph for this function:

init_face_names()

void anonymous_namespace{GLGizmoEmboss.cpp}::init_face_names

(

Facenames &

facenames

)

{
    Timer t("enumerate_fonts");
    if (face_names.is_init) return;
    face_names.is_init = true;
 
    // to reload fonts from system, when install new one
    wxFontEnumerator::InvalidateCache();
 
    // try load cache
    // Only not OS enumerated face has hash value 0
    if (face_names.hash == 0) {
        load(face_names);
        face_names.has_truncated_names = false;
    }
 
    using namespace std::chrono;
    steady_clock::time_point enumerate_start = steady_clock::now();
    ScopeGuard sg([&enumerate_start, &face_names = face_names]() {
        steady_clock::time_point enumerate_end = steady_clock::now();
        long long enumerate_duration = duration_cast<milliseconds>(enumerate_end - enumerate_start).count();
        BOOST_LOG_TRIVIAL(info) << "OS enumerate " << face_names.faces.size() << " fonts "
                                << "(+ " << face_names.bad.size() << " can't load "
                                << "= " << face_names.faces.size() + face_names.bad.size() << " fonts) "
                                << "in " << enumerate_duration << " ms\n" << concat(face_names.bad);
    });
    wxArrayString facenames = wxFontEnumerator::GetFacenames(face_names.encoding);
    size_t hash = boost::hash_range(facenames.begin(), facenames.end());
    // Zero value is used as uninitialized hash
    if (hash == 0) hash = 1;
    // check if it is same as last time
    if (face_names.hash == hash) { 
        // no new installed font
        BOOST_LOG_TRIVIAL(info) << "Same FontNames hash, cache is used. " 
            << "For clear cache delete file: " << get_fontlist_cache_path().string();
        return;
    }
 
    BOOST_LOG_TRIVIAL(info) << ((face_names.hash == 0) ?
        "FontName list is generate from scratch." :
        "Hash are different. Only previous bad fonts are used and set again as bad");
    face_names.hash = hash;
    
    // validation lambda
    auto is_valid_font = [encoding = face_names.encoding, bad = face_names.bad /*copy*/](const wxString &name) {
        if (name.empty()) return false;
 
        // vertical font start with @, we will filter it out
        // Not sure if it is only in Windows so filtering is on all platforms
        if (name[0] == '@') return false;        
 
        // previously detected bad font
        auto it = std::lower_bound(bad.begin(), bad.end(), name);
        if (it != bad.end() && *it == name) return false;
 
        wxFont wx_font(wxFontInfo().FaceName(name).Encoding(encoding));
        //*
        // Faster chech if wx_font is loadable but not 100%
        // names could contain not loadable font
        if (!WxFontUtils::can_load(wx_font)) return false;
 
        /*/
        // Slow copy of font files to try load font
        // After this all files are loadable
        auto font_file = WxFontUtils::create_font_file(wx_font);
        if (font_file == nullptr) 
            return false; // can't create font file
        // */
        return true;
    };
 
    face_names.faces.clear();
    face_names.faces_names.clear();
    face_names.bad.clear();
    face_names.faces.reserve(facenames.size());
    face_names.faces_names.reserve(facenames.size());
    std::sort(facenames.begin(), facenames.end());
    for (const wxString &name : facenames) {
        if (is_valid_font(name)) {
            face_names.faces.push_back({name});
            face_names.faces_names.push_back(name.utf8_string());
        }else{
            face_names.bad.push_back(name);
        }
    }
    assert(std::is_sorted(face_names.bad.begin(), face_names.bad.end()));
    face_names.has_truncated_names = false;
    store(face_names);
}

References anonymous_namespace{GLGizmoEmboss.cpp}::Facenames::bad, Slic3r::GUI::WxFontUtils::can_load(), concat(), anonymous_namespace{GLGizmoEmboss.cpp}::Facenames::encoding, anonymous_namespace{GLGizmoEmboss.cpp}::Facenames::faces, anonymous_namespace{GLGizmoEmboss.cpp}::Facenames::faces_names, get_fontlist_cache_path(), anonymous_namespace{GLGizmoEmboss.cpp}::Facenames::has_truncated_names, anonymous_namespace{GLGizmoEmboss.cpp}::Facenames::hash, anonymous_namespace{GLGizmoEmboss.cpp}::Facenames::is_init, load(), and store().

Referenced by get_installed_face_name().

Here is the call graph for this function:

Here is the caller graph for this function:

init_text_lines()

void anonymous_namespace{GLGizmoEmboss.cpp}::init_text_lines	(	TextLinesModel &	text_lines,
		const Selection &	selection,
		StyleManager &	style_manager,
		unsigned	count_lines = 0 )

{    
    const GLVolume *gl_volume_ptr = selection.get_first_volume();
    if (gl_volume_ptr == nullptr)
        return;
    const GLVolume        &gl_volume = *gl_volume_ptr;
    const ModelObjectPtrs &objects   = selection.get_model()->objects;
    const ModelVolume *mv_ptr = get_model_volume(gl_volume, objects);
    if (mv_ptr == nullptr)
        return;
    const ModelVolume &mv = *mv_ptr;
    if (mv.is_the_only_one_part())
        return;
 
    const std::optional<EmbossShape> &es_opt = mv.emboss_shape;
    if (!es_opt.has_value())
        return;
    const EmbossShape &es = *es_opt;
 
    const std::optional<TextConfiguration> &tc_opt = mv.text_configuration;
    if (!tc_opt.has_value())
        return;
    const TextConfiguration &tc = *tc_opt;
 
    // calculate count lines when not set
    if (count_lines == 0) {
        count_lines = get_count_lines(tc.text);
        if (count_lines == 0)
            return;
    }
 
    // prepare volumes to slice
    ModelVolumePtrs volumes = prepare_volumes_to_slice(mv);
 
    // For interactivity during drag over surface it must be from gl_volume not volume.
    Transform3d mv_trafo = gl_volume.get_volume_transformation().get_matrix();
    if (es.fix_3mf_tr.has_value())
        mv_trafo = mv_trafo * (es.fix_3mf_tr->inverse());
    text_lines.init(mv_trafo, volumes, style_manager, count_lines);
}

References Slic3r::ModelVolume::emboss_shape, Slic3r::EmbossShape::fix_3mf_tr, Slic3r::Emboss::get_count_lines(), Slic3r::GUI::Selection::get_first_volume(), Slic3r::Geometry::Transformation::get_matrix(), Slic3r::GUI::Selection::get_model(), Slic3r::GUI::get_model_volume(), Slic3r::GLVolume::get_volume_transformation(), Slic3r::GUI::TextLinesModel::init(), init_text_lines(), Slic3r::ModelVolume::is_the_only_one_part(), Slic3r::Model::objects, prepare_volumes_to_slice(), Slic3r::TextConfiguration::text, and Slic3r::ModelVolume::text_configuration.

Referenced by create_emboss_data_base(), and init_text_lines().

Here is the call graph for this function:

Here is the caller graph for this function:

init_truncated_names()

void anonymous_namespace{GLGizmoEmboss.cpp}::init_truncated_names	(	Facenames &	face_names,
		float	max_width )

{
    for (FaceName &face : face_names.faces) {
        std::string name_str(face.wx_name.ToUTF8().data());
        face.name_truncated = ImGuiWrapper::trunc(name_str, max_width);
    }
    face_names.has_truncated_names = true;
}

References anonymous_namespace{GLGizmoEmboss.cpp}::Facenames::faces, anonymous_namespace{GLGizmoEmboss.cpp}::Facenames::has_truncated_names, anonymous_namespace{GLGizmoEmboss.cpp}::FaceName::name_truncated, Slic3r::GUI::ImGuiWrapper::trunc(), and anonymous_namespace{GLGizmoEmboss.cpp}::FaceName::wx_name.

Here is the call graph for this function:

is_text_empty()

bool anonymous_namespace{GLGizmoEmboss.cpp}::is_text_empty

(

std::string_view

text

)

{ return text.empty() || text.find_first_not_of(" \n\t\r") == std::string::npos; }

References is_text_empty().

Referenced by is_text_empty().

Here is the call graph for this function:

Here is the caller graph for this function:

load()

bool anonymous_namespace{GLGizmoEmboss.cpp}::load

(

Facenames &

facenames

)

                                {
    boost::filesystem::path path = get_fontlist_cache_path();
    std::string             path_str = path.string();
    if (!boost::filesystem::exists(path)) {
        BOOST_LOG_TRIVIAL(warning) << "Fontlist cache - '" << path_str << "' does not exists.";
        return false;
    }
    boost::nowide::ifstream file(path_str, std::ios::binary);
    cereal::BinaryInputArchive archive(file);
    
    FacenamesSerializer data;
    try {
        archive(data);
    } catch (const std::exception &ex) {
        BOOST_LOG_TRIVIAL(error) << "Failed to load fontlist cache - '" << path_str << "'. Exception: " << ex.what();
        return false;
    }
 
    assert(std::is_sorted(data.bad.begin(), data.bad.end()));
    assert(std::is_sorted(data.good.begin(), data.good.end()));
 
    facenames.hash = data.hash;
    facenames.faces.reserve(data.good.size());
    facenames.faces_names.reserve(data.good.size());
    for (const wxString &face : data.good) {
        facenames.faces.push_back({face});
        facenames.faces_names.push_back(face.utf8_string());
    }
    facenames.bad = data.bad;
    return true;
}

References anonymous_namespace{GLGizmoEmboss.cpp}::Facenames::bad, FacenamesSerializer::bad, anonymous_namespace{GLGizmoEmboss.cpp}::Facenames::faces, anonymous_namespace{GLGizmoEmboss.cpp}::Facenames::faces_names, get_fontlist_cache_path(), FacenamesSerializer::good, anonymous_namespace{GLGizmoEmboss.cpp}::Facenames::hash, and FacenamesSerializer::hash.

Referenced by init_face_names().

Here is the call graph for this function:

Here is the caller graph for this function:

prepare_volumes_to_slice()

ModelVolumePtrs anonymous_namespace{GLGizmoEmboss.cpp}::prepare_volumes_to_slice

(

const ModelVolume &

mv

)

{
    const ModelVolumePtrs &volumes = mv.get_object()->volumes;
    ModelVolumePtrs        result;
    result.reserve(volumes.size());
    for (ModelVolume *volume : volumes) {
        // only part could be surface for volumes
        if (!volume->is_model_part())
            continue;
 
        // is selected volume
        if (mv.id() == volume->id())
            continue;
 
        result.push_back(volume);
    }
    return result;
}

References Slic3r::ModelVolume::get_object(), Slic3r::ObjectBase::id(), Slic3r::ObjectID::id, prepare_volumes_to_slice(), and Slic3r::ModelObject::volumes.

Referenced by init_text_lines(), and prepare_volumes_to_slice().

Here is the call graph for this function:

Here is the caller graph for this function:

store()

bool anonymous_namespace{GLGizmoEmboss.cpp}::store

(

const Facenames &

facenames

)

                                       {
    std::string cache_path = get_fontlist_cache_path().string();
    boost::nowide::ofstream file(cache_path, std::ios::binary);
    ::cereal::BinaryOutputArchive archive(file);
    std::vector<wxString> good;
    good.reserve(facenames.faces.size());
    for (const FaceName &face : facenames.faces) good.push_back(face.wx_name);
    FacenamesSerializer data = {facenames.hash, good, facenames.bad};
 
    assert(std::is_sorted(data.bad.begin(), data.bad.end()));
    assert(std::is_sorted(data.good.begin(), data.good.end()));
 
    try {
        archive(data);
    } catch (const std::exception &ex) {
        BOOST_LOG_TRIVIAL(error) << "Failed to write fontlist cache - " << cache_path << ex.what();
        return false;
    }
    return true;
}

References anonymous_namespace{GLGizmoEmboss.cpp}::Facenames::bad, FacenamesSerializer::bad, anonymous_namespace{GLGizmoEmboss.cpp}::Facenames::faces, get_fontlist_cache_path(), FacenamesSerializer::good, anonymous_namespace{GLGizmoEmboss.cpp}::Facenames::hash, and anonymous_namespace{GLGizmoEmboss.cpp}::FaceName::wx_name.

Referenced by init_face_names().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

default_text

const char* const anonymous_namespace{GLGizmoEmboss.cpp}::default_text = L("Embossed text")

Referenced by add_style_for_default_text().

limits

const struct anonymous_namespace{GLGizmoEmboss.cpp}::Limits anonymous_namespace{GLGizmoEmboss.cpp}::limits

static

move_snapshot_name

const std::string anonymous_namespace{GLGizmoEmboss.cpp}::move_snapshot_name = L("Text move")

rotation_snapshot_name

const std::string anonymous_namespace{GLGizmoEmboss.cpp}::rotation_snapshot_name = L("Text rotate")

SELECTABLE_INNER_OFFSET

const float anonymous_namespace{GLGizmoEmboss.cpp}::SELECTABLE_INNER_OFFSET = 8.0f

static