Slic3r::anonymous_namespace{PresetBundle.cpp} Namespace Reference

Classes
struct	BedAssetSlot
struct	PendingBedAsset

Functions
std::string	zip_slashes (std::string name)
bool	bed_extension_allowed (const char *option, const std::string &ext)
std::string	bed_asset_extension (const std::string &path, const char *option)
bool	utf8_is_file (const std::string &path)
std::string	bed_asset_dest_utf8 (const fs::path &dest)
bool	accepted_bed_zip_name (const std::string &raw, const BedAssetSlot &slot, const fs::path &bundle_dir, std::string &zip_name, std::string &folder)
std::vector< PendingBedAsset >	pending_bed_assets (const json &bundle_json, const fs::path &bundle_dir, std::unordered_set< std::string > &skip_names, const std::unordered_set< std::string > &zip_entries)
bool	stage_bed_asset (mz_zip_archive &zip, PendingBedAsset &asset, const fs::path &temp_folder)
bool	install_bed_asset (const PendingBedAsset &asset)
bool	is_pending_bed_asset_entry (const std::string &entry, const std::unordered_set< std::string > &names)
bool	printer_kept_bed_paths (const PresetCollection &printers, const std::map< std::string, std::string > &paths)

Variables
constexpr BedAssetSlot	k_bed_asset_slots []

---

Class Documentation

Slic3r::anonymous_namespace{PresetBundle.cpp}::BedAssetSlot

struct Slic3r::anonymous_namespace{PresetBundle.cpp}::BedAssetSlot

Class Members
const char *	option
const char *	stem

Slic3r::anonymous_namespace{PresetBundle.cpp}::PendingBedAsset

struct Slic3r::anonymous_namespace{PresetBundle.cpp}::PendingBedAsset

Collaboration diagram for Slic3r::anonymous_namespace{PresetBundle.cpp}::PendingBedAsset:

Class Members
string	dest
path	final_path
string	option
string	printer_key
path	staged
string	zip_name

Function Documentation

accepted_bed_zip_name()

bool Slic3r::anonymous_namespace{PresetBundle.cpp}::accepted_bed_zip_name	(	const std::string &	raw,
		const BedAssetSlot &	slot,
		const fs::path &	bundle_dir,
		std::string &	zip_name,
		std::string &	folder )

{
    const std::string name = zip_slashes(raw);
    if (name.find("..") != std::string::npos)
        return false;
    if (name.size() < 8 || name.compare(0, 4, "bed/") != 0)
        return false;
    const auto slash = name.find('/', 4);
    if (slash == std::string::npos || slash == 4 || name.find('/', slash + 1) != std::string::npos)
        return false;
    const std::string digits = name.substr(4, slash - 4);
    for (unsigned char c : digits) {
        if (!std::isdigit(c))
            return false;
    }
    const std::string filename = name.substr(slash + 1);
    const std::string ext = bed_asset_extension(filename, slot.option);
    if (ext.empty() || filename != std::string(slot.stem) + ext)
        return false;
    if (!is_path_within_root(name, bundle_dir))
        return false;
    zip_name = name;
    folder = digits;
    return true;
}

References accepted_bed_zip_name(), bed_asset_extension(), Slic3r::is_path_within_root(), Slic3r::anonymous_namespace{PresetBundle.cpp}::BedAssetSlot::option, Slic3r::anonymous_namespace{PresetBundle.cpp}::BedAssetSlot::stem, and zip_slashes().

Referenced by accepted_bed_zip_name(), and pending_bed_assets().

Here is the call graph for this function:

Here is the caller graph for this function:

bed_asset_dest_utf8()

std::string Slic3r::anonymous_namespace{PresetBundle.cpp}::bed_asset_dest_utf8

(

const fs::path &

dest

)

{
#ifdef _WIN32
    return boost::nowide::narrow(dest.wstring());
#else
    return dest.string();
#endif
}

References bed_asset_dest_utf8().

Referenced by bed_asset_dest_utf8(), pending_bed_assets(), and stage_bed_asset().

Here is the call graph for this function:

Here is the caller graph for this function:

bed_asset_extension()

std::string Slic3r::anonymous_namespace{PresetBundle.cpp}::bed_asset_extension	(	const std::string &	path,
		const char *	option )

{
    const auto slash = path.find_last_of("/\\");
    const auto base  = slash == std::string::npos ? 0 : slash + 1;
    const auto dot   = path.find_last_of('.');
    if (dot == std::string::npos || dot < base || dot + 1 >= path.size())
        return {};
    const std::string ext = path.substr(dot);
    if (!bed_extension_allowed(option, ext))
        return {};
    return ext;
}

References bed_asset_extension(), bed_extension_allowed(), and Slic3r::dot().

Referenced by accepted_bed_zip_name(), and bed_asset_extension().

Here is the call graph for this function:

Here is the caller graph for this function:

bed_extension_allowed()

bool Slic3r::anonymous_namespace{PresetBundle.cpp}::bed_extension_allowed	(	const char *	option,
		const std::string &	ext )

{
    if (std::string(option) == "bed_custom_texture")
        return boost::iequals(ext, ".png") || boost::iequals(ext, ".svg");
    if (std::string(option) == "bed_custom_model")
        return boost::iequals(ext, ".stl");
    return false;
}

References bed_extension_allowed().

Referenced by bed_asset_extension(), and bed_extension_allowed().

Here is the call graph for this function:

Here is the caller graph for this function:

install_bed_asset()

bool Slic3r::anonymous_namespace{PresetBundle.cpp}::install_bed_asset

(

const PendingBedAsset &

asset

)

{
    boost::system::error_code ec;
    fs::create_directories(asset.final_path.parent_path(), ec);
    if (!ec)
        fs::copy_file(asset.staged, asset.final_path, fs::copy_options::overwrite_existing, ec);
    if (ec) {
        BOOST_LOG_TRIVIAL(warning) << "Printer bundle asset could not be installed: " << asset.dest;
        return false;
    }
    return true;
}

References Slic3r::anonymous_namespace{PresetBundle.cpp}::PendingBedAsset::dest, Slic3r::anonymous_namespace{PresetBundle.cpp}::PendingBedAsset::final_path, install_bed_asset(), and Slic3r::anonymous_namespace{PresetBundle.cpp}::PendingBedAsset::staged.

Referenced by install_bed_asset().

Here is the call graph for this function:

Here is the caller graph for this function:

is_pending_bed_asset_entry()

bool Slic3r::anonymous_namespace{PresetBundle.cpp}::is_pending_bed_asset_entry	(	const std::string &	entry,
		const std::unordered_set< std::string > &	names )

{
    return names.count(entry) != 0 || names.count(zip_slashes(entry)) != 0;
}

References is_pending_bed_asset_entry(), and zip_slashes().

Referenced by is_pending_bed_asset_entry().

Here is the call graph for this function:

Here is the caller graph for this function:

pending_bed_assets()

std::vector< PendingBedAsset > Slic3r::anonymous_namespace{PresetBundle.cpp}::pending_bed_assets	(	const json &	bundle_json,
		const fs::path &	bundle_dir,
		std::unordered_set< std::string > &	skip_names,
		const std::unordered_set< std::string > &	zip_entries )

{
    std::vector<PendingBedAsset> pending;
    if (!bundle_json.contains("printer_asset") || !bundle_json["printer_asset"].is_object())
        return pending;
    const json &assets = bundle_json["printer_asset"];
    for (auto it = assets.begin(); it != assets.end(); ++it) {
        const std::string printer_key = it.key();
        if (zip_entries.count(printer_key) == 0) {
            BOOST_LOG_TRIVIAL(warning) << "Printer bundle asset entry is ignored, no matching printer in the zip: " << printer_key;
            continue;
        }
        if (!it.value().is_object())
            continue;
        const json &per_printer = it.value();
        for (const BedAssetSlot &slot : k_bed_asset_slots) {
            if (!per_printer.contains(slot.option) || !per_printer[slot.option].is_string())
                continue;
            const std::string raw = per_printer[slot.option].get<std::string>();
            std::string zip_name;
            std::string folder;
            if (!accepted_bed_zip_name(raw, slot, bundle_dir, zip_name, folder)) {
                BOOST_LOG_TRIVIAL(warning) << "Printer bundle asset path is rejected: " << raw;
                continue;
            }
            const std::string filename = zip_name.substr(zip_name.rfind('/') + 1);
            const fs::path final_path = fs::absolute(bundle_dir / "bed" / folder / filename);
            pending.push_back({slot.option, zip_name, bed_asset_dest_utf8(final_path), printer_key, final_path, {}});
            skip_names.insert(zip_name);
        }
    }
    return pending;
}

References accepted_bed_zip_name(), bed_asset_dest_utf8(), k_bed_asset_slots, and pending_bed_assets().

Referenced by pending_bed_assets().

Here is the call graph for this function:

Here is the caller graph for this function:

printer_kept_bed_paths()

bool Slic3r::anonymous_namespace{PresetBundle.cpp}::printer_kept_bed_paths	(	const PresetCollection &	printers,
		const std::map< std::string, std::string > &	paths )

{
    if (paths.empty())
        return false;
    for (const Preset &preset : printers.get_presets()) {
        for (const auto &entry : paths)
            if (preset.config.opt_string(entry.first) == entry.second)
                return true;
    }
    return false;
}

References Slic3r::Preset::config, Slic3r::PresetCollection::get_presets(), Slic3r::DynamicConfig::opt_string(), and printer_kept_bed_paths().

Referenced by printer_kept_bed_paths().

Here is the call graph for this function:

Here is the caller graph for this function:

stage_bed_asset()

bool Slic3r::anonymous_namespace{PresetBundle.cpp}::stage_bed_asset	(	mz_zip_archive &	zip,
		PendingBedAsset &	asset,
		const fs::path &	temp_folder )

{
    size_t size = 0;
    void *buf = mz_zip_reader_extract_file_to_heap(&zip, asset.zip_name.c_str(), &size, MZ_ZIP_FLAG_CASE_SENSITIVE);
    if (buf == nullptr) {
        BOOST_LOG_TRIVIAL(warning) << "Printer bundle asset is missing, skipping " << asset.option << ": " << asset.zip_name;
        return false;
    }
    const std::string filename = asset.zip_name.substr(asset.zip_name.rfind('/') + 1);
    asset.staged = temp_folder / "bed" / asset.final_path.parent_path().filename() / filename;
    boost::system::error_code ec;
    fs::create_directories(asset.staged.parent_path(), ec);
    const std::string staged_utf8 = bed_asset_dest_utf8(asset.staged);
    bool wrote = false;
    if (!ec) {
        boost::nowide::ofstream out(staged_utf8, std::ios::binary | std::ios::trunc);
        wrote = static_cast<bool>(out);
        if (wrote && size > 0)
            wrote = static_cast<bool>(out.write(static_cast<const char *>(buf), static_cast<std::streamsize>(size)));
    }
    mz_free(buf);
    if (!wrote) {
        BOOST_LOG_TRIVIAL(warning) << "Printer bundle asset could not be written, skipping " << asset.option << ": " << staged_utf8;
        fs::remove(asset.staged, ec);
        return false;
    }
    return true;
}

References bed_asset_dest_utf8(), Slic3r::anonymous_namespace{PresetBundle.cpp}::PendingBedAsset::final_path, Slic3r::anonymous_namespace{PresetBundle.cpp}::PendingBedAsset::option, stage_bed_asset(), Slic3r::anonymous_namespace{PresetBundle.cpp}::PendingBedAsset::staged, and Slic3r::anonymous_namespace{PresetBundle.cpp}::PendingBedAsset::zip_name.

Referenced by stage_bed_asset().

Here is the call graph for this function:

Here is the caller graph for this function:

utf8_is_file()

bool Slic3r::anonymous_namespace{PresetBundle.cpp}::utf8_is_file

(

const std::string &

path

)

{
    if (path.empty())
        return false;
    boost::system::error_code ec;
#ifdef _WIN32
    // A narrow path is the ANSI code page unless nowide_filesystem() has run.
    const std::wstring wide = boost::nowide::widen(path);
    if (wide.empty())
        return false;
    return boost::filesystem::is_regular_file(boost::filesystem::path(wide), ec) && !ec;
#else
    return boost::filesystem::is_regular_file(path, ec) && !ec;
#endif
}

References utf8_is_file().

Referenced by utf8_is_file().

Here is the call graph for this function:

Here is the caller graph for this function:

zip_slashes()

std::string Slic3r::anonymous_namespace{PresetBundle.cpp}::zip_slashes

(

std::string

name

)

{
    for (char &c : name)
        if (c == '\\')
            c = '/';
    return name;
}

References zip_slashes().

Referenced by accepted_bed_zip_name(), is_pending_bed_asset_entry(), and zip_slashes().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

k_bed_asset_slots

BedAssetSlot Slic3r::anonymous_namespace{PresetBundle.cpp}::k_bed_asset_slots[]

constexpr

Initial value:

= {
    {"bed_custom_texture", "texture"},
    {"bed_custom_model", "model"},
}

                                             {
    {"bed_custom_texture", "texture"},
    {"bed_custom_model", "model"},
};

Referenced by pending_bed_assets().