Slic3r::GUI::anonymous_namespace{Plater.cpp} Namespace Reference

Classes
class	SvgArchivePathsRestorer
struct	MixedGradientSlot

Typedefs
using	SvgFile = EmbossShape::SvgFile
using	SvgFiles = std::vector<SvgFile*>

Functions
bool	emboss_svg (Plater &plater, const wxString &svg_file, const Vec2d &mouse_drop_position)
std::string	imex_placement_error (PartPlate *plate)
std::string	get_file_name (const std::string &file_path)
std::string	create_unique_3mf_filepath (const std::string &file, const SvgFiles svgs)
bool	set_by_local_path (SvgFile &svg, const SvgFiles &svgs)
void	publish (Model &model, SaveStrategy strategy)
	Function to secure private data before store to 3mf.
std::vector< MixedGradientSlot >	parse_mixed_gradient_slots (const Slic3r::DynamicPrintConfig &config, size_t slot_count)

---

Class Documentation

Slic3r::GUI::anonymous_namespace{Plater.cpp}::MixedGradientSlot

struct Slic3r::GUI::anonymous_namespace{Plater.cpp}::MixedGradientSlot

Collaboration diagram for Slic3r::GUI::anonymous_namespace{Plater.cpp}::MixedGradientSlot:

Class Members
string	color_from
string	color_to
bool	is_gradient = false

Typedef Documentation

SvgFile

using Slic3r::GUI::anonymous_namespace{Plater.cpp}::SvgFile = EmbossShape::SvgFile

SvgFiles

using Slic3r::GUI::anonymous_namespace{Plater.cpp}::SvgFiles = std::vector<SvgFile*>

Function Documentation

create_unique_3mf_filepath()

std::string Slic3r::GUI::anonymous_namespace{Plater.cpp}::create_unique_3mf_filepath	(	const std::string &	file,
		const SvgFiles	svgs )

{
    // const std::string MODEL_FOLDER = "3D/"; // copy from file 3mf.cpp
    std::string path_in_3mf = "3D/" + file + ".svg";
    size_t suffix_number = 0;
    bool is_unique = false;
    do{
        is_unique = true;
        path_in_3mf = "3D/" + file + ((suffix_number++)? ("_" + std::to_string(suffix_number)) : "") + ".svg";
        for (SvgFile *svgfile : svgs) {
            if (svgfile->path_in_3mf.empty())
                continue;
            if (svgfile->path_in_3mf.compare(path_in_3mf) == 0) {
                is_unique = false;
                break;
            }
        } 
    } while (!is_unique);
    return path_in_3mf;
}

References create_unique_3mf_filepath().

Referenced by create_unique_3mf_filepath(), and publish().

Here is the call graph for this function:

Here is the caller graph for this function:

emboss_svg()

bool Slic3r::GUI::anonymous_namespace{Plater.cpp}::emboss_svg	(	Plater &	plater,
		const wxString &	svg_file,
		const Vec2d &	mouse_drop_position )

{
    std::string svg_file_str = into_u8(svg_file);
    GLCanvas3D* canvas = plater.canvas3D();
    if (canvas == nullptr)
        return false;
    auto base_svg = canvas->get_gizmos_manager().get_gizmo(GLGizmosManager::Svg);
    if (base_svg == nullptr)
        return false;
    GLGizmoSVG* svg = dynamic_cast<GLGizmoSVG *>(base_svg);
    if (svg == nullptr)
        return false;
 
    // Refresh hover state to find surface point under mouse
    wxMouseEvent evt(wxEVT_MOTION);
    evt.SetPosition(wxPoint(mouse_drop_position.x(), mouse_drop_position.y()));
    canvas->on_mouse(evt); // call render where is call GLCanvas3D::_picking_pass()
 
    return svg->create_volume(svg_file_str, mouse_drop_position, ModelVolumeType::MODEL_PART);
}

References Slic3r::GUI::GLGizmoSVG::create_volume(), emboss_svg(), Slic3r::GUI::GLGizmosManager::get_gizmo(), Slic3r::GUI::GLCanvas3D::get_gizmos_manager(), Slic3r::GUI::into_u8(), Slic3r::MODEL_PART, Slic3r::GUI::GLCanvas3D::on_mouse(), Slic3r::GUI::plater(), Slic3r::GUI::GLGizmosManager::Svg, and Slic3r::GUI::wxMouseEvent.

Referenced by emboss_svg().

Here is the call graph for this function:

Here is the caller graph for this function:

get_file_name()

std::string Slic3r::GUI::anonymous_namespace{Plater.cpp}::get_file_name

(

const std::string &

file_path

)

{
    size_t pos_last_delimiter = file_path.find_last_of("/\\");
    size_t pos_point          = file_path.find_last_of('.');
    size_t offset             = pos_last_delimiter + 1;
    size_t count              = pos_point - pos_last_delimiter - 1;
    return file_path.substr(offset, count);
}

References count, get_file_name(), and Slic3r::offset().

Referenced by get_file_name(), and publish().

Here is the call graph for this function:

Here is the caller graph for this function:

imex_placement_error()

std::string Slic3r::GUI::anonymous_namespace{Plater.cpp}::imex_placement_error

(

PartPlate *

plate

)

{
    if (!plate)
        return {};
    switch (plate->imex_placement_violation()) {
    case PartPlate::ImexPlacementViolation::Object:
        return _u8L("Cannot slice: an object overlaps an area reserved for IDEX/IQEX parallel printing "
                    "(a secondary zone, or a carriage clearance strip inside the primary zone).");
    case PartPlate::ImexPlacementViolation::PrimeTower:
        return _u8L("Cannot slice: the prime tower overlaps an area reserved for IDEX/IQEX parallel printing "
                    "(a secondary zone, or a carriage clearance strip inside the primary zone).");
    case PartPlate::ImexPlacementViolation::None:
        break;
    }
    return {};
}

References _u8L, imex_placement_error(), Slic3r::GUI::PartPlate::imex_placement_violation(), Slic3r::GUI::PartPlate::None, Slic3r::GUI::PartPlate::Object, and Slic3r::GUI::PartPlate::PrimeTower.

Referenced by imex_placement_error().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_mixed_gradient_slots()

std::vector< MixedGradientSlot > Slic3r::GUI::anonymous_namespace{Plater.cpp}::parse_mixed_gradient_slots	(	const Slic3r::DynamicPrintConfig &	config,
		size_t	slot_count )

{
    std::vector<MixedGradientSlot> result(slot_count);
    const auto* is_mixed   = config.option<ConfigOptionBools>("filament_is_mixed");
    const auto* mixed_grad = config.option<ConfigOptionBools>("filament_mixed_gradient");
    const auto* mixed_comp = config.option<ConfigOptionStrings>("filament_mixed_components");
    const auto* grad_range = config.option<ConfigOptionStrings>("filament_mixed_gradient_range");
    const auto* fil_colour = config.option<ConfigOptionStrings>("filament_colour");
    if (!is_mixed || !mixed_grad || !mixed_comp || !fil_colour) return result;
 
    for (size_t i = 0; i < slot_count && i < is_mixed->values.size(); ++i) {
        if (!is_mixed->values[i]) continue;
        if (i >= mixed_grad->values.size() || !mixed_grad->values[i]) continue;
        if (i >= mixed_comp->values.size()) continue;
 
        std::vector<unsigned int> comp_ids;
        std::istringstream iss(mixed_comp->values[i]);
        std::string tok;
        while (std::getline(iss, tok, ',')) {
            unsigned int v = 0;
            if (std::sscanf(tok.c_str(), "%u", &v) == 1)
                comp_ids.push_back(v);
        }
        if (comp_ids.size() != 2) continue;
 
        int direction = 0;
        if (grad_range && i < grad_range->values.size()) {
            CNumericLocalesSetter c_locale_setter;
            float v0 = 0, v1 = 0;
            if (std::sscanf(grad_range->values[i].c_str(), "%f,%f", &v0, &v1) == 2)
                direction = (v0 > v1) ? 0 : 1;
        }
 
        unsigned int from_id = (direction == 0) ? comp_ids[0] : comp_ids[1];
        unsigned int to_id   = (direction == 0) ? comp_ids[1] : comp_ids[0];
        result[i].is_gradient = true;
        result[i].color_from = (from_id >= 1 && from_id <= fil_colour->values.size())
            ? fil_colour->values[from_id - 1] : "#D9D9D9";
        result[i].color_to = (to_id >= 1 && to_id <= fil_colour->values.size())
            ? fil_colour->values[to_id - 1] : "#D9D9D9";
    }
    return result;
}

References Slic3r::ConfigBase::option(), parse_mixed_gradient_slots(), Slic3r::ConfigOptionVector< T >::size(), Slic3r::ConfigOptionVector< T >::values, and Slic3r::ConfigOptionVector< unsigned char >::values.

Referenced by parse_mixed_gradient_slots().

Here is the call graph for this function:

Here is the caller graph for this function:

publish()

void Slic3r::GUI::anonymous_namespace{Plater.cpp}::publish	(	Model &	model,
		SaveStrategy	strategy )

Function to secure private data before store to 3mf.

Parameters

model

Data(also private) to clean before publishing

                                                  {
 
    // SVG file publishing
    bool exist_new = false;
    SvgFiles svgfiles;
    for (ModelObject *object: model.objects){
        for (ModelVolume *volume : object->volumes) {
            if (!volume->emboss_shape.has_value())
                continue;
            if (volume->text_configuration.has_value())
                continue; // text dosen't have svg path
 
            assert(volume->emboss_shape->svg_file.has_value());
            if (!volume->emboss_shape->svg_file.has_value())
                continue;
 
            SvgFile* svg = &(*volume->emboss_shape->svg_file);
            if (svg->path_in_3mf.empty())
                exist_new = true;
            svgfiles.push_back(svg);
        }
    }
 
    for (SvgFile *svgfile : svgfiles) {
        if (!svgfile->path_in_3mf.empty())
            continue; // already suggested path (previous save)
 
        // create unique name for svgs, when local path differ
        std::string filename = "unknown";
        if (!svgfile->path.empty()) {
            if (set_by_local_path(*svgfile, svgfiles))
                continue;
            // check whether original filename is already in:
            filename = get_file_name(svgfile->path);
        }
        svgfile->path_in_3mf = create_unique_3mf_filepath(filename, svgfiles);        
    }
}

References create_unique_3mf_filepath(), Slic3r::ModelVolume::emboss_shape, get_file_name(), Slic3r::Model::objects, Slic3r::EmbossShape::SvgFile::path_in_3mf, publish(), set_by_local_path(), Slic3r::ModelVolume::text_configuration, and Slic3r::ModelObject::volumes.

Referenced by publish().

Here is the call graph for this function:

Here is the caller graph for this function:

set_by_local_path()

bool Slic3r::GUI::anonymous_namespace{Plater.cpp}::set_by_local_path	(	SvgFile &	svg,
		const SvgFiles &	svgs )

{
    // Try to find already used svg file
    for (SvgFile *svg_ : svgs) {
        if (svg_->path_in_3mf.empty())
            continue;
        if (svg.path.compare(svg_->path) == 0) {
            svg.path_in_3mf = svg_->path_in_3mf;
            return true;
        }
    }
    return false;
}

References Slic3r::EmbossShape::SvgFile::path, Slic3r::EmbossShape::SvgFile::path_in_3mf, and set_by_local_path().

Referenced by publish(), and set_by_local_path().

Here is the call graph for this function:

Here is the caller graph for this function: