anonymous_namespace{EmbossStyleManager.cpp} Namespace Reference

For store/load emboss style to/from AppConfig. More...

Typedefs
using	HorizontalAlignToName = boost::bimap<FontProp::HorizontalAlign, std::string_view>
using	VerticalAlignToName = boost::bimap<FontProp::VerticalAlign, std::string_view>
using	Section = std::map<std::string,std::string>

Functions
void	store_style_index (AppConfig &cfg, size_t index)
::std::optional< size_t >	load_style_index (const AppConfig &cfg)
StyleManager::Styles	load_styles (const AppConfig &cfg)
void	store_styles (AppConfig &cfg, const StyleManager::Styles &styles)
void	make_unique_name (const StyleManager::Styles &styles, std::string &name)
std::string	create_section_name (unsigned index)
bool	read (const Section &section, const std::string &key, bool &value)
bool	read (const Section &section, const std::string &key, Slic3r::FontProp::HorizontalAlign &value)
bool	read (const Section &section, const std::string &key, Slic3r::FontProp::VerticalAlign &value)
bool	read (const Section &section, const std::string &key, float &value)
bool	read (const Section &section, const std::string &key, std::optional< int > &value)
bool	read (const Section &section, const std::string &key, std::optional< unsigned int > &value)
bool	read (const Section &section, const std::string &key, std::optional< float > &value)
std::optional< StyleManager::Style >	load_style (const Section &app_cfg_section)
void	store_style (AppConfig &cfg, const StyleManager::Style &s, unsigned index)

Variables
const HorizontalAlignToName	horizontal_align_to_name
const VerticalAlignToName	vertical_align_to_name
const std::string	APP_CONFIG_FONT_NAME = "name"
const std::string	APP_CONFIG_FONT_DESCRIPTOR = "descriptor"
const std::string	APP_CONFIG_FONT_LINE_HEIGHT = "line_height"
const std::string	APP_CONFIG_FONT_DEPTH = "depth"
const std::string	APP_CONFIG_FONT_USE_SURFACE = "use_surface"
const std::string	APP_CONFIG_PER_GLYPH = "per_glyph"
const std::string	APP_CONFIG_VERTICAL_ALIGN = "vertical_align"
const std::string	APP_CONFIG_HORIZONTAL_ALIGN = "horizontal_align"
const std::string	APP_CONFIG_FONT_BOLDNESS = "boldness"
const std::string	APP_CONFIG_FONT_SKEW = "skew"
const std::string	APP_CONFIG_FONT_DISTANCE = "distance"
const std::string	APP_CONFIG_FONT_ANGLE = "angle"
const std::string	APP_CONFIG_FONT_COLLECTION = "collection"
const std::string	APP_CONFIG_FONT_CHAR_GAP = "char_gap"
const std::string	APP_CONFIG_FONT_LINE_GAP = "line_gap"
const std::string	APP_CONFIG_ACTIVE_FONT = "active_font"

Detailed Description

For store/load emboss style to/from AppConfig.

Typedef Documentation

HorizontalAlignToName

using anonymous_namespace{EmbossStyleManager.cpp}::HorizontalAlignToName = boost::bimap<FontProp::HorizontalAlign, std::string_view>

Section

using anonymous_namespace{EmbossStyleManager.cpp}::Section = std::map<std::string,std::string>

VerticalAlignToName

using anonymous_namespace{EmbossStyleManager.cpp}::VerticalAlignToName = boost::bimap<FontProp::VerticalAlign, std::string_view>

Function Documentation

create_section_name()

std::string anonymous_namespace{EmbossStyleManager.cpp}::create_section_name

(

unsigned

index

)

{
    return AppConfig::SECTION_EMBOSS_STYLE + ':' + std::to_string(index);
}

References create_section_name(), and Slic3r::AppConfig::SECTION_EMBOSS_STYLE.

Referenced by create_section_name(), load_styles(), store_style(), and store_styles().

Here is the call graph for this function:

Here is the caller graph for this function:

load_style()

std::optional< StyleManager::Style > anonymous_namespace{EmbossStyleManager.cpp}::load_style

(

const Section &

app_cfg_section

)

{
    auto path_it = app_cfg_section.find(APP_CONFIG_FONT_DESCRIPTOR);
    if (path_it == app_cfg_section.end())
        return {};
        
    StyleManager::Style s;
    EmbossProjection& ep = s.projection;
    FontProp& fp = s.prop;
    
    s.path = path_it->second;
    s.type = WxFontUtils::get_current_type();
    auto name_it = app_cfg_section.find(APP_CONFIG_FONT_NAME);
    const std::string  default_name = "font_name";
    s.name = (name_it == app_cfg_section.end()) ? default_name : name_it->second;
 
    read(app_cfg_section, APP_CONFIG_FONT_LINE_HEIGHT, fp.size_in_mm);
    float depth = 1.;
    read(app_cfg_section, APP_CONFIG_FONT_DEPTH, depth);
    ep.depth = depth;
    read(app_cfg_section, APP_CONFIG_FONT_USE_SURFACE, ep.use_surface);
    read(app_cfg_section, APP_CONFIG_PER_GLYPH, fp.per_glyph);
    read(app_cfg_section, APP_CONFIG_HORIZONTAL_ALIGN, fp.align.first);
    read(app_cfg_section, APP_CONFIG_VERTICAL_ALIGN, fp.align.second);
    read(app_cfg_section, APP_CONFIG_FONT_BOLDNESS, fp.boldness);
    read(app_cfg_section, APP_CONFIG_FONT_SKEW, fp.skew);
    read(app_cfg_section, APP_CONFIG_FONT_DISTANCE, s.distance);
    read(app_cfg_section, APP_CONFIG_FONT_ANGLE, s.angle);
    read(app_cfg_section, APP_CONFIG_FONT_COLLECTION, fp.collection_number);
    read(app_cfg_section, APP_CONFIG_FONT_CHAR_GAP, fp.char_gap);
    read(app_cfg_section, APP_CONFIG_FONT_LINE_GAP, fp.line_gap);
    return s;
}

References Slic3r::FontProp::align, Slic3r::GUI::Emboss::StyleManager::Style::angle, APP_CONFIG_FONT_ANGLE, APP_CONFIG_FONT_BOLDNESS, APP_CONFIG_FONT_CHAR_GAP, APP_CONFIG_FONT_COLLECTION, APP_CONFIG_FONT_DEPTH, APP_CONFIG_FONT_DESCRIPTOR, APP_CONFIG_FONT_DISTANCE, APP_CONFIG_FONT_LINE_GAP, APP_CONFIG_FONT_LINE_HEIGHT, APP_CONFIG_FONT_NAME, APP_CONFIG_FONT_SKEW, APP_CONFIG_FONT_USE_SURFACE, APP_CONFIG_HORIZONTAL_ALIGN, APP_CONFIG_PER_GLYPH, APP_CONFIG_VERTICAL_ALIGN, Slic3r::FontProp::boldness, Slic3r::FontProp::char_gap, Slic3r::FontProp::collection_number, Slic3r::EmbossProjection::depth, Slic3r::GUI::Emboss::StyleManager::Style::distance, Slic3r::GUI::WxFontUtils::get_current_type(), Slic3r::FontProp::line_gap, load_style(), Slic3r::EmbossStyle::name, Slic3r::EmbossStyle::path, Slic3r::FontProp::per_glyph, Slic3r::GUI::Emboss::StyleManager::Style::projection, Slic3r::EmbossStyle::prop, read(), Slic3r::FontProp::size_in_mm, Slic3r::FontProp::skew, Slic3r::EmbossStyle::type, and Slic3r::EmbossProjection::use_surface.

Referenced by load_style(), and load_styles().

Here is the call graph for this function:

Here is the caller graph for this function:

load_style_index()

std::optional< size_t > anonymous_namespace{EmbossStyleManager.cpp}::load_style_index

(

const AppConfig &

cfg

)

{
    if (!cfg.has_section(AppConfig::SECTION_EMBOSS_STYLE))
        return {};
 
    auto section = cfg.get_section(AppConfig::SECTION_EMBOSS_STYLE);
    auto it      = section.find(APP_CONFIG_ACTIVE_FONT);
    if (it == section.end())
        return {};
 
    size_t active_font = static_cast<size_t>(std::atoi(it->second.c_str()));
    // order in config starts with number 1
    return active_font - 1;
}

References APP_CONFIG_ACTIVE_FONT, Slic3r::AppConfig::get_section(), Slic3r::AppConfig::has_section(), load_style_index(), and Slic3r::AppConfig::SECTION_EMBOSS_STYLE.

Referenced by load_style_index().

Here is the call graph for this function:

Here is the caller graph for this function:

load_styles()

StyleManager::Styles anonymous_namespace{EmbossStyleManager.cpp}::load_styles

(

const AppConfig &

cfg

)

{
    StyleManager::Styles result;
    // human readable index inside of config starts from 1 !!
    unsigned    index        = 1;
    std::string section_name = create_section_name(index);
    while (cfg.has_section(section_name)) {
        std::optional<StyleManager::Style> style_opt = load_style(cfg.get_section(section_name));
        if (style_opt.has_value()) {
            make_unique_name(result, style_opt->name);
            result.emplace_back(*style_opt);
        }
 
        section_name = create_section_name(++index);
    }
    return result;
}

References create_section_name(), Slic3r::AppConfig::get_section(), Slic3r::AppConfig::has_section(), load_style(), load_styles(), make_unique_name(), and Slic3r::GUI::section_name().

Referenced by load_styles().

Here is the call graph for this function:

Here is the caller graph for this function:

make_unique_name()

void anonymous_namespace{EmbossStyleManager.cpp}::make_unique_name	(	const StyleManager::Styles &	styles,
		std::string &	name )

{
    auto is_unique = [&styles](const std::string &name){
        for (const StyleManager::Style &it : styles)
            if (it.name == name) return false;
        return true;
    };
 
    // Style name can't be empty so default name is set
    if (name.empty()) name = "Text style";
 
    // When name is already unique, nothing need to be changed
    if (is_unique(name)) return;
 
    // when there is previous version of style name only find number
    const char *prefix = " (";
    const char  suffix  = ')';
    auto pos = name.find_last_of(prefix);
    if (name.c_str()[name.size() - 1] == suffix && 
        pos != std::string::npos) {
        // short name by ord number
        name = name.substr(0, pos);
    }
 
    int order = 1; // start with value 2 to represents same font name
    std::string new_name;
    do {
        new_name = name + prefix + std::to_string(++order) + suffix;
    } while (!is_unique(new_name));
    name = new_name;
}

References make_unique_name().

Referenced by load_styles(), and make_unique_name().

Here is the call graph for this function:

Here is the caller graph for this function:

read() [1/7]

bool anonymous_namespace{EmbossStyleManager.cpp}::read	(	const Section &	section,
		const std::string &	key,
		bool &	value )

{
    auto item = section.find(key);
    if (item == section.end())
        return false;
 
    value = true;
    return true;
}

References read().

Referenced by load_style(), read(), read(), read(), read(), read(), read(), and read().

Here is the call graph for this function:

Here is the caller graph for this function:

read() [2/7]

bool anonymous_namespace{EmbossStyleManager.cpp}::read	(	const Section &	section,
		const std::string &	key,
		float &	value )

{
    auto item = section.find(key);
    if (item == section.end())
        return false;
    const std::string &data = item->second;
    if (data.empty())
        return false;
    float value_;
    fast_float::from_chars(data.c_str(), data.c_str() + data.length(), value_);
    // read only non zero value
    if (fabs(value_) <= std::numeric_limits<float>::epsilon())
        return false;
 
    value = value_;
    return true;
}

References read().

Here is the call graph for this function:

read() [3/7]

bool anonymous_namespace{EmbossStyleManager.cpp}::read	(	const Section &	section,
		const std::string &	key,
		Slic3r::FontProp::HorizontalAlign &	value )

                                                                                              {
    auto item = section.find(key);
    if (item == section.end())
        return false;
 
    const std::string &data = item->second;
    if (data.empty())
        return false;
 
    const auto& map = horizontal_align_to_name.right; 
    auto it = map.find(data);
    value = (it != map.end()) ? it->second : Slic3r::FontProp::HorizontalAlign::center;
    return true;
}

References Slic3r::FontProp::center, horizontal_align_to_name, and read().

Here is the call graph for this function:

read() [4/7]

bool anonymous_namespace{EmbossStyleManager.cpp}::read	(	const Section &	section,
		const std::string &	key,
		Slic3r::FontProp::VerticalAlign &	value )

                                                                                            {
    auto item = section.find(key);
    if (item == section.end())
        return false;
 
    const std::string &data = item->second;
    if (data.empty())
        return false;
 
    const auto &map = vertical_align_to_name.right;
    auto it = map.find(data);
    value = (it != map.end()) ? it->second : Slic3r::FontProp::VerticalAlign::center;
    return true;
}

References Slic3r::FontProp::center, read(), and vertical_align_to_name.

Here is the call graph for this function:

read() [5/7]

bool anonymous_namespace{EmbossStyleManager.cpp}::read	(	const Section &	section,
		const std::string &	key,
		std::optional< float > &	value )

{
    auto item = section.find(key);
    if (item == section.end())
        return false;
    const std::string &data = item->second;
    if (data.empty())
        return false;
    float value_;
    fast_float::from_chars(data.c_str(), data.c_str() + data.length(), value_);
    // read only non zero value
    if (fabs(value_) <= std::numeric_limits<float>::epsilon())
        return false;
 
    value = value_;
    return true;
}

References read().

Here is the call graph for this function:

read() [6/7]

bool anonymous_namespace{EmbossStyleManager.cpp}::read	(	const Section &	section,
		const std::string &	key,
		std::optional< int > &	value )

{
    auto item = section.find(key);
    if (item == section.end())
        return false;
    const std::string &data = item->second;
    if (data.empty())
        return false;
    int value_ = std::atoi(data.c_str());
    if (value_ == 0)
        return false;
 
    value = value_;
    return true;
}

References read().

Here is the call graph for this function:

read() [7/7]

bool anonymous_namespace{EmbossStyleManager.cpp}::read	(	const Section &	section,
		const std::string &	key,
		std::optional< unsigned int > &	value )

{
    auto item = section.find(key);
    if (item == section.end())
        return false;
    const std::string &data = item->second;
    if (data.empty())
        return false;
    int value_ = std::atoi(data.c_str());
    if (value_ <= 0)
        return false;
 
    value = static_cast<unsigned int>(value_);
    return true;
}

References read().

Here is the call graph for this function:

store_style()

void anonymous_namespace{EmbossStyleManager.cpp}::store_style	(	AppConfig &	cfg,
		const StyleManager::Style &	s,
		unsigned	index )

{
    const EmbossProjection &ep = s.projection;
    Section data;
    data[APP_CONFIG_FONT_NAME]        = s.name;
    data[APP_CONFIG_FONT_DESCRIPTOR]  = s.path;
    const FontProp &fp                = s.prop;
    data[APP_CONFIG_FONT_LINE_HEIGHT] = std::to_string(fp.size_in_mm);
    data[APP_CONFIG_FONT_DEPTH]       = std::to_string(ep.depth);
    if (ep.use_surface)
        data[APP_CONFIG_FONT_USE_SURFACE] = "true";
    if (fp.per_glyph)
        data[APP_CONFIG_PER_GLYPH] = "true";
    if (fp.align.first != FontProp::HorizontalAlign::center)
        data[APP_CONFIG_HORIZONTAL_ALIGN] = horizontal_align_to_name.left.find(fp.align.first)->second;
    if (fp.align.second != FontProp::VerticalAlign::center)
        data[APP_CONFIG_VERTICAL_ALIGN] = vertical_align_to_name.left.find(fp.align.second)->second;
    if (fp.boldness.has_value())
        data[APP_CONFIG_FONT_BOLDNESS] = std::to_string(*fp.boldness);
    if (fp.skew.has_value())
        data[APP_CONFIG_FONT_SKEW] = std::to_string(*fp.skew);
    if (s.distance.has_value())
        data[APP_CONFIG_FONT_DISTANCE] = std::to_string(*s.distance);
    if (s.angle.has_value())
        data[APP_CONFIG_FONT_ANGLE] = std::to_string(*s.angle);
    if (fp.collection_number.has_value())
        data[APP_CONFIG_FONT_COLLECTION] = std::to_string(*fp.collection_number);
    if (fp.char_gap.has_value())
        data[APP_CONFIG_FONT_CHAR_GAP] = std::to_string(*fp.char_gap);
    if (fp.line_gap.has_value())
        data[APP_CONFIG_FONT_LINE_GAP] = std::to_string(*fp.line_gap);
    cfg.set_section(create_section_name(index), std::move(data));
}

References Slic3r::FontProp::align, Slic3r::GUI::Emboss::StyleManager::Style::angle, APP_CONFIG_FONT_ANGLE, APP_CONFIG_FONT_BOLDNESS, APP_CONFIG_FONT_CHAR_GAP, APP_CONFIG_FONT_COLLECTION, APP_CONFIG_FONT_DEPTH, APP_CONFIG_FONT_DESCRIPTOR, APP_CONFIG_FONT_DISTANCE, APP_CONFIG_FONT_LINE_GAP, APP_CONFIG_FONT_LINE_HEIGHT, APP_CONFIG_FONT_NAME, APP_CONFIG_FONT_SKEW, APP_CONFIG_FONT_USE_SURFACE, APP_CONFIG_HORIZONTAL_ALIGN, APP_CONFIG_PER_GLYPH, APP_CONFIG_VERTICAL_ALIGN, Slic3r::FontProp::boldness, Slic3r::FontProp::center, Slic3r::FontProp::char_gap, Slic3r::FontProp::collection_number, create_section_name(), Slic3r::EmbossProjection::depth, Slic3r::GUI::Emboss::StyleManager::Style::distance, horizontal_align_to_name, Slic3r::FontProp::line_gap, Slic3r::EmbossStyle::name, Slic3r::EmbossStyle::path, Slic3r::FontProp::per_glyph, Slic3r::GUI::Emboss::StyleManager::Style::projection, Slic3r::EmbossStyle::prop, Slic3r::AppConfig::set_section(), Slic3r::FontProp::size_in_mm, Slic3r::FontProp::skew, store_style(), Slic3r::EmbossProjection::use_surface, and vertical_align_to_name.

Referenced by store_style(), and store_styles().

Here is the call graph for this function:

Here is the caller graph for this function:

store_style_index()

void anonymous_namespace{EmbossStyleManager.cpp}::store_style_index	(	AppConfig &	cfg,
		size_t	index )

{
    // store actual font index
    // active font first index is +1 to correspond with section name
    Section data;
    data[APP_CONFIG_ACTIVE_FONT] = std::to_string(index);
    cfg.set_section(AppConfig::SECTION_EMBOSS_STYLE, std::move(data));
}

References APP_CONFIG_ACTIVE_FONT, Slic3r::AppConfig::SECTION_EMBOSS_STYLE, Slic3r::AppConfig::set_section(), and store_style_index().

Referenced by store_style_index().

Here is the call graph for this function:

Here is the caller graph for this function:

store_styles()

void anonymous_namespace{EmbossStyleManager.cpp}::store_styles	(	AppConfig &	cfg,
		const StyleManager::Styles &	styles )

{
    EmbossStyle::Type current_type = WxFontUtils::get_current_type();
    // store styles
    unsigned index = 1;
    for (const StyleManager::Style &style : styles) {
        // skip file paths + fonts from other OS(loaded from .3mf)
        assert(style.type == current_type);
        if (style.type != current_type)
            continue;
        store_style(cfg, style, index);
        ++index;
    }
 
    // remove rest of font sections (after deletation)
    std::string section_name = create_section_name(index);
    while (cfg.has_section(section_name)) {
        cfg.clear_section(section_name);
        section_name = create_section_name(index);
        ++index;
    }
}

References Slic3r::AppConfig::clear_section(), create_section_name(), Slic3r::GUI::WxFontUtils::get_current_type(), Slic3r::AppConfig::has_section(), Slic3r::GUI::section_name(), store_style(), store_styles(), and style.

Referenced by store_styles().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

APP_CONFIG_ACTIVE_FONT

const std::string anonymous_namespace{EmbossStyleManager.cpp}::APP_CONFIG_ACTIVE_FONT = "active_font"

Referenced by load_style_index(), and store_style_index().

APP_CONFIG_FONT_ANGLE

const std::string anonymous_namespace{EmbossStyleManager.cpp}::APP_CONFIG_FONT_ANGLE = "angle"

Referenced by load_style(), and store_style().

APP_CONFIG_FONT_BOLDNESS

const std::string anonymous_namespace{EmbossStyleManager.cpp}::APP_CONFIG_FONT_BOLDNESS = "boldness"

Referenced by load_style(), and store_style().

APP_CONFIG_FONT_CHAR_GAP

const std::string anonymous_namespace{EmbossStyleManager.cpp}::APP_CONFIG_FONT_CHAR_GAP = "char_gap"

Referenced by load_style(), and store_style().

APP_CONFIG_FONT_COLLECTION

const std::string anonymous_namespace{EmbossStyleManager.cpp}::APP_CONFIG_FONT_COLLECTION = "collection"

Referenced by load_style(), and store_style().

APP_CONFIG_FONT_DEPTH

const std::string anonymous_namespace{EmbossStyleManager.cpp}::APP_CONFIG_FONT_DEPTH = "depth"

Referenced by load_style(), and store_style().

APP_CONFIG_FONT_DESCRIPTOR

const std::string anonymous_namespace{EmbossStyleManager.cpp}::APP_CONFIG_FONT_DESCRIPTOR = "descriptor"

Referenced by load_style(), and store_style().

APP_CONFIG_FONT_DISTANCE

const std::string anonymous_namespace{EmbossStyleManager.cpp}::APP_CONFIG_FONT_DISTANCE = "distance"

Referenced by load_style(), and store_style().

APP_CONFIG_FONT_LINE_GAP

const std::string anonymous_namespace{EmbossStyleManager.cpp}::APP_CONFIG_FONT_LINE_GAP = "line_gap"

Referenced by load_style(), and store_style().

APP_CONFIG_FONT_LINE_HEIGHT

const std::string anonymous_namespace{EmbossStyleManager.cpp}::APP_CONFIG_FONT_LINE_HEIGHT = "line_height"

Referenced by load_style(), and store_style().

APP_CONFIG_FONT_NAME

const std::string anonymous_namespace{EmbossStyleManager.cpp}::APP_CONFIG_FONT_NAME = "name"

Referenced by load_style(), and store_style().

APP_CONFIG_FONT_SKEW

const std::string anonymous_namespace{EmbossStyleManager.cpp}::APP_CONFIG_FONT_SKEW = "skew"

Referenced by load_style(), and store_style().

APP_CONFIG_FONT_USE_SURFACE

const std::string anonymous_namespace{EmbossStyleManager.cpp}::APP_CONFIG_FONT_USE_SURFACE = "use_surface"

Referenced by load_style(), and store_style().

APP_CONFIG_HORIZONTAL_ALIGN

const std::string anonymous_namespace{EmbossStyleManager.cpp}::APP_CONFIG_HORIZONTAL_ALIGN = "horizontal_align"

Referenced by load_style(), and store_style().

APP_CONFIG_PER_GLYPH

const std::string anonymous_namespace{EmbossStyleManager.cpp}::APP_CONFIG_PER_GLYPH = "per_glyph"

Referenced by load_style(), and store_style().

APP_CONFIG_VERTICAL_ALIGN

const std::string anonymous_namespace{EmbossStyleManager.cpp}::APP_CONFIG_VERTICAL_ALIGN = "vertical_align"

Referenced by load_style(), and store_style().

horizontal_align_to_name

const HorizontalAlignToName anonymous_namespace{EmbossStyleManager.cpp}::horizontal_align_to_name

Initial value:

= 
boost::assign::list_of<HorizontalAlignToName::relation>
    (FontProp::HorizontalAlign::left, "left")
    (FontProp::HorizontalAlign::center, "center")
    (FontProp::HorizontalAlign::right, "right")

Referenced by read(), and store_style().

vertical_align_to_name

const VerticalAlignToName anonymous_namespace{EmbossStyleManager.cpp}::vertical_align_to_name

Initial value:

=
boost::assign::list_of<VerticalAlignToName::relation>
    (FontProp::VerticalAlign::top, "top")
    (FontProp::VerticalAlign::center, "middle")
    (FontProp::VerticalAlign::bottom, "bottom")

Referenced by read(), and store_style().