Slic3r::TextConfigurationSerialization Struct Reference

Public Types
using	TypeToName = boost::bimap<EmbossStyle::Type, std::string_view>
using	HorizontalAlignToName = boost::bimap<FontProp::HorizontalAlign, std::string_view>
using	VerticalAlignToName = boost::bimap<FontProp::VerticalAlign, std::string_view>

Public Member Functions
	TextConfigurationSerialization ()=delete

Static Public Member Functions
static EmbossStyle::Type	get_type (std::string_view type)
static std::string_view	get_name (EmbossStyle::Type type)
static void	to_xml (std::stringstream &stream, const TextConfiguration &tc)
static std::optional< TextConfiguration >	read (const char **attributes, unsigned int num_attributes)
static EmbossShape	read_old (const char **attributes, unsigned int num_attributes)

Static Public Attributes
static const TypeToName	type_to_name
	TextConfiguration serialization.
static const HorizontalAlignToName	horizontal_align_to_name
static const VerticalAlignToName	vertical_align_to_name

Detailed Description

Member Typedef Documentation

HorizontalAlignToName

using Slic3r::TextConfigurationSerialization::HorizontalAlignToName = boost::bimap<FontProp::HorizontalAlign, std::string_view>

TypeToName

using Slic3r::TextConfigurationSerialization::TypeToName = boost::bimap<EmbossStyle::Type, std::string_view>

VerticalAlignToName

using Slic3r::TextConfigurationSerialization::VerticalAlignToName = boost::bimap<FontProp::VerticalAlign, std::string_view>

Constructor & Destructor Documentation

TextConfigurationSerialization()

Slic3r::TextConfigurationSerialization::TextConfigurationSerialization ( )

delete

Member Function Documentation

get_name()

std::string_view Slic3r::TextConfigurationSerialization::get_name ( EmbossStyle::Type type )

inlinestatic

                                                             {
            const auto& to_name = TextConfigurationSerialization::type_to_name.left;
            auto type_name = to_name.find(type);
            assert(type_name != to_name.end());
            if (type_name == to_name.end()) return "unknown type";
            return type_name->second;
        }

References type_to_name.

get_type()

EmbossStyle::Type Slic3r::TextConfigurationSerialization::get_type ( std::string_view type )

inlinestatic

                                                             {
            const auto& to_type = TextConfigurationSerialization::type_to_name.right;
            auto type_item = to_type.find(type);
            assert(type_item != to_type.end());
            if (type_item == to_type.end()) return EmbossStyle::Type::undefined;
            return type_item->second;        
        }

References type_to_name, and Slic3r::EmbossStyle::undefined.

read()

std::optional< TextConfiguration > Slic3r::TextConfigurationSerialization::read ( const char ** attributes, unsigned int num_attributes )

static

{
    FontProp fp;
    int char_gap = bbs_get_attribute_value_int(attributes, num_attributes, CHAR_GAP_ATTR);
    if (char_gap != 0) fp.char_gap = char_gap;
    int line_gap = bbs_get_attribute_value_int(attributes, num_attributes, LINE_GAP_ATTR); 
    if (line_gap != 0) fp.line_gap = line_gap;
    float boldness = bbs_get_attribute_value_float(attributes, num_attributes, BOLDNESS_ATTR);
    if (std::fabs(boldness) > std::numeric_limits<float>::epsilon())
        fp.boldness = boldness;
    float skew = bbs_get_attribute_value_float(attributes, num_attributes, SKEW_ATTR);
    if (std::fabs(skew) > std::numeric_limits<float>::epsilon())
        fp.skew = skew;
    int per_glyph = bbs_get_attribute_value_int(attributes, num_attributes, PER_GLYPH_ATTR);
    if (per_glyph == 1) fp.per_glyph = true;
 
    fp.align = FontProp::Align(
        read_horizontal_align(attributes, num_attributes, horizontal_align_to_name),
        read_vertical_align(attributes, num_attributes, vertical_align_to_name));
 
    int collection_number = bbs_get_attribute_value_int(attributes, num_attributes, COLLECTION_NUMBER_ATTR);
    if (collection_number > 0) fp.collection_number = static_cast<unsigned int>(collection_number);
 
    fp.size_in_mm = bbs_get_attribute_value_float(attributes, num_attributes, LINE_HEIGHT_ATTR);
 
    std::string family = bbs_get_attribute_value_string(attributes, num_attributes, FONT_FAMILY_ATTR);
    if (!family.empty()) fp.family = family;
    std::string face_name = bbs_get_attribute_value_string(attributes, num_attributes, FONT_FACE_NAME_ATTR);
    if (!face_name.empty()) fp.face_name = face_name;
    std::string style = bbs_get_attribute_value_string(attributes, num_attributes, FONT_STYLE_ATTR);
    if (!style.empty()) fp.style = style;
    std::string weight = bbs_get_attribute_value_string(attributes, num_attributes, FONT_WEIGHT_ATTR);
    if (!weight.empty()) fp.weight = weight;
 
    std::string style_name = bbs_get_attribute_value_string(attributes, num_attributes, STYLE_NAME_ATTR);
    std::string font_descriptor = bbs_get_attribute_value_string(attributes, num_attributes, FONT_DESCRIPTOR_ATTR);
    std::string type_str = bbs_get_attribute_value_string(attributes, num_attributes, FONT_DESCRIPTOR_TYPE_ATTR);
    EmbossStyle::Type type = bimap_cvt(type_to_name, std::string_view{type_str}, EmbossStyle::Type::undefined);
 
    std::string text = bbs_get_attribute_value_string(attributes, num_attributes, TEXT_DATA_ATTR);
    EmbossStyle es{style_name, std::move(font_descriptor), type, std::move(fp)};
    return TextConfiguration{std::move(es), std::move(text)};
}

References Slic3r::FontProp::align, bbs_get_attribute_value_float(), bbs_get_attribute_value_int(), bbs_get_attribute_value_string(), Slic3r::FontProp::boldness, BOLDNESS_ATTR, Slic3r::FontProp::char_gap, CHAR_GAP_ATTR, Slic3r::FontProp::collection_number, COLLECTION_NUMBER_ATTR, Slic3r::FontProp::face_name, Slic3r::FontProp::family, FONT_DESCRIPTOR_ATTR, FONT_DESCRIPTOR_TYPE_ATTR, FONT_FACE_NAME_ATTR, FONT_FAMILY_ATTR, FONT_STYLE_ATTR, FONT_WEIGHT_ATTR, horizontal_align_to_name, Slic3r::FontProp::line_gap, LINE_GAP_ATTR, LINE_HEIGHT_ATTR, Slic3r::FontProp::per_glyph, PER_GLYPH_ATTR, read(), Slic3r::FontProp::size_in_mm, Slic3r::FontProp::skew, SKEW_ATTR, Slic3r::FontProp::style, style, STYLE_NAME_ATTR, TEXT_DATA_ATTR, type_to_name, Slic3r::EmbossStyle::undefined, vertical_align_to_name, and Slic3r::FontProp::weight.

Referenced by Slic3r::_BBS_3MF_Importer::_handle_start_text_configuration(), and read().

Here is the call graph for this function:

Here is the caller graph for this function:

read_old()

EmbossShape Slic3r::TextConfigurationSerialization::read_old ( const char ** attributes, unsigned int num_attributes )

static

{
    EmbossShape es;
    std::string fix_tr_mat_str = bbs_get_attribute_value_string(attributes, num_attributes, TRANSFORM_ATTR);
    if (!fix_tr_mat_str.empty())
        es.fix_3mf_tr = bbs_get_transform_from_3mf_specs_string(fix_tr_mat_str);
 
 
    if (bbs_get_attribute_value_int(attributes, num_attributes, USE_SURFACE_ATTR) == 1)
        es.projection.use_surface = true;
 
    es.projection.depth = bbs_get_attribute_value_float(attributes, num_attributes, DEPTH_ATTR);
 
    int use_surface = bbs_get_attribute_value_int(attributes, num_attributes, USE_SURFACE_ATTR);
    if (use_surface == 1)
        es.projection.use_surface = true;
 
    return es;
}

References bbs_get_attribute_value_float(), bbs_get_attribute_value_int(), bbs_get_attribute_value_string(), bbs_get_transform_from_3mf_specs_string(), Slic3r::EmbossProjection::depth, DEPTH_ATTR, Slic3r::EmbossShape::fix_3mf_tr, Slic3r::EmbossShape::projection, read_old(), TRANSFORM_ATTR, Slic3r::EmbossProjection::use_surface, and USE_SURFACE_ATTR.

Referenced by Slic3r::_BBS_3MF_Importer::_handle_start_text_configuration(), and read_old().

Here is the call graph for this function:

Here is the caller graph for this function:

to_xml()

void Slic3r::TextConfigurationSerialization::to_xml ( std::stringstream & stream, const TextConfiguration & tc )

static

{
    stream << "   <" << TEXT_TAG << " ";
 
    stream << TEXT_DATA_ATTR << "=\"" << xml_escape_double_quotes_attribute_value(tc.text) << "\" ";
    // font item
    const EmbossStyle &style = tc.style;
    stream << STYLE_NAME_ATTR <<  "=\"" << xml_escape_double_quotes_attribute_value(style.name) << "\" ";
    stream << FONT_DESCRIPTOR_ATTR << "=\"" << xml_escape_double_quotes_attribute_value(style.path) << "\" ";
    constexpr std::string_view dafault_type{"undefined"};
    std::string_view style_type = bimap_cvt(type_to_name, style.type, dafault_type);
    stream << FONT_DESCRIPTOR_TYPE_ATTR << "=\"" << style_type << "\" ";
 
    // font property
    const FontProp &fp = tc.style.prop;
    if (fp.char_gap.has_value())
        stream << CHAR_GAP_ATTR << "=\"" << *fp.char_gap << "\" ";
    if (fp.line_gap.has_value())
        stream << LINE_GAP_ATTR << "=\"" << *fp.line_gap << "\" ";
 
    stream << LINE_HEIGHT_ATTR << "=\"" << fp.size_in_mm << "\" ";
    if (fp.boldness.has_value())
        stream << BOLDNESS_ATTR << "=\"" << *fp.boldness << "\" ";
    if (fp.skew.has_value())
        stream << SKEW_ATTR << "=\"" << *fp.skew << "\" ";
    if (fp.per_glyph)
        stream << PER_GLYPH_ATTR << "=\"" << 1 << "\" ";
    stream << HORIZONTAL_ALIGN_ATTR << "=\"" << bimap_cvt(horizontal_align_to_name, fp.align.first, dafault_type) << "\" ";
    stream << VERTICAL_ALIGN_ATTR   << "=\"" << bimap_cvt(vertical_align_to_name,  fp.align.second, dafault_type) << "\" ";
    if (fp.collection_number.has_value())
        stream << COLLECTION_NUMBER_ATTR << "=\"" << *fp.collection_number << "\" ";
    // font descriptor
    if (fp.family.has_value())
        stream << FONT_FAMILY_ATTR << "=\"" << *fp.family << "\" ";
    if (fp.face_name.has_value())
        stream << FONT_FACE_NAME_ATTR << "=\"" << *fp.face_name << "\" ";
    if (fp.style.has_value())
        stream << FONT_STYLE_ATTR << "=\"" << *fp.style << "\" ";
    if (fp.weight.has_value())
        stream << FONT_WEIGHT_ATTR << "=\"" << *fp.weight << "\" ";
 
    stream << "/>\n"; // end TEXT_TAG
}

References Slic3r::FontProp::align, Slic3r::FontProp::boldness, BOLDNESS_ATTR, Slic3r::FontProp::char_gap, CHAR_GAP_ATTR, Slic3r::FontProp::collection_number, COLLECTION_NUMBER_ATTR, Slic3r::FontProp::face_name, Slic3r::FontProp::family, FONT_DESCRIPTOR_ATTR, FONT_DESCRIPTOR_TYPE_ATTR, FONT_FACE_NAME_ATTR, FONT_FAMILY_ATTR, FONT_STYLE_ATTR, FONT_WEIGHT_ATTR, HORIZONTAL_ALIGN_ATTR, horizontal_align_to_name, Slic3r::FontProp::line_gap, LINE_GAP_ATTR, LINE_HEIGHT_ATTR, Slic3r::FontProp::per_glyph, PER_GLYPH_ATTR, Slic3r::EmbossStyle::prop, Slic3r::FontProp::size_in_mm, Slic3r::FontProp::skew, SKEW_ATTR, Slic3r::FontProp::style, Slic3r::TextConfiguration::style, style, STYLE_NAME_ATTR, Slic3r::TextConfiguration::text, TEXT_DATA_ATTR, TEXT_TAG, to_xml(), type_to_name, VERTICAL_ALIGN_ATTR, vertical_align_to_name, Slic3r::FontProp::weight, and Slic3r::xml_escape_double_quotes_attribute_value().

Referenced by Slic3r::_BBS_3MF_Exporter::_add_model_config_file_to_archive(), and to_xml().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

horizontal_align_to_name

const TextConfigurationSerialization::HorizontalAlignToName Slic3r::TextConfigurationSerialization::horizontal_align_to_name

static

Initial value:

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

Referenced by read(), and to_xml().

type_to_name

const TextConfigurationSerialization::TypeToName Slic3r::TextConfigurationSerialization::type_to_name

static

Initial value:

=
    boost::assign::list_of<TypeToName::relation>
    (EmbossStyle::Type::file_path, "file_name")
    (EmbossStyle::Type::wx_win_font_descr, "wxFontDescriptor_Windows")
    (EmbossStyle::Type::wx_lin_font_descr, "wxFontDescriptor_Linux")
    (EmbossStyle::Type::wx_mac_font_descr, "wxFontDescriptor_MacOsX")

TextConfiguration serialization.

Referenced by get_name(), get_type(), read(), and to_xml().

vertical_align_to_name

const TextConfigurationSerialization::VerticalAlignToName Slic3r::TextConfigurationSerialization::vertical_align_to_name

static

Initial value:

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

Referenced by read(), and to_xml().

---

The documentation for this struct was generated from the following file:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Format/bbs_3mf.cpp