Slic3r::Utils Namespace Reference

Namespaces
namespace	__get_put_time_emulation
namespace	anonymous_namespace{Time.cpp}

Classes
struct	HexFile
struct	SerialPortInfo
class	Serial
struct	SerialMessage
class	TCPConsole

Enumerations
enum class	TimeZone { local , utc }
enum class	TimeFormat { gcode , iso8601Z }
enum	SerialMessageType { Command , Data }

Functions
static const char *	get_fmtstr (TimeFormat fmt)
time_t	get_current_time_utc ()
static std::string	tm2str (const std::tm *tms, const char *fmt)
std::string	time2str (const time_t &t, TimeZone zone, TimeFormat fmt)
static time_t	str2time (std::istream &stream, TimeZone zone, const char *fmt)
time_t	str2time (const std::string &str, TimeZone zone, TimeFormat fmt)
std::string	millis_to_iso8601 (long long unix_millis)
long long	iso8601_to_millis (const std::string &iso_time)
std::string	time2str (TimeZone zone, TimeFormat fmt)
std::string	utc_timestamp (time_t t)
std::string	utc_timestamp ()
std::string	local_timestamp (TimeFormat fmt=TimeFormat::gcode)
std::string	iso_utc_timestamp (time_t t)
std::string	iso_utc_timestamp ()
time_t	parse_iso_utc_timestamp (const std::string &str)
bool	is_file_too_large (std::string file_path, bool &try_ok)
void	slash_to_back_slash (std::string &file_path)
static HexFile::DeviceKind	parse_device_kind (const std::string &str)
static size_t	hex_num_sections (fs::ifstream &file)
static bool	looks_like_printer (const std::string &friendly_name)
std::vector< SerialPortInfo >	scan_serial_ports_extended ()
std::vector< std::string >	scan_serial_ports ()
bool	operator== (const SerialPortInfo &sp1, const SerialPortInfo &sp2)

Variables
static const constexpr char *const	SLICER_UTC_TIME_FMT = "%Y-%m-%d at %T"
static const constexpr char *const	ISO8601Z_TIME_FMT = "%Y%m%dT%H%M%SZ"

Enumeration Type Documentation

SerialMessageType

enum Slic3r::Utils::SerialMessageType

Enumerator
Command
Data

{ Command, Data };

TimeFormat

enum class Slic3r::Utils::TimeFormat

strong

Enumerator
gcode
iso8601Z

{ gcode, iso8601Z };

TimeZone

enum class Slic3r::Utils::TimeZone

strong

Enumerator
local
utc

{ local, utc };

Function Documentation

get_current_time_utc()

time_t Slic3r::Utils::get_current_time_utc

(

)

{
    using clk = std::chrono::system_clock;
    return clk::to_time_t(clk::now());
}

Referenced by Slic3r::DeviceManager::insert_local_device(), iso_utc_timestamp(), Slic3r::DeviceManager::load_local_machines_from_config(), local_timestamp(), Slic3r::DeviceManager::on_machine_alive(), Slic3r::CLI::run(), Slic3r::GUI::Config::SnapshotDB::take_snapshot(), time2str(), and utc_timestamp().

Here is the caller graph for this function:

get_fmtstr()

const char * Slic3r::Utils::get_fmtstr ( TimeFormat fmt )

static

{
    switch (fmt) {
    case TimeFormat::gcode: return SLICER_UTC_TIME_FMT;
    case TimeFormat::iso8601Z: return ISO8601Z_TIME_FMT;
    }
 
    return "";
}

References gcode, iso8601Z, ISO8601Z_TIME_FMT, and SLICER_UTC_TIME_FMT.

Referenced by str2time(), and time2str().

Here is the caller graph for this function:

hex_num_sections()

size_t Slic3r::Utils::hex_num_sections ( fs::ifstream & file )

static

{
  file.seekg(0);
  if (! file.good()) {
    return 0;
  }
 
  static const char *hex_terminator = ":00000001FF\r";
  size_t res = 0;
  std::string line;
  while (getline(file, line, '\n').good()) {
    // Account for LF vs CRLF
    if (!line.empty() && line.back() != '\r') {
      line.push_back('\r');
    }
 
    if (line == hex_terminator) {
      res++;
    }
  }
 
  return res;
}

is_file_too_large()

bool Slic3r::Utils::is_file_too_large	(	std::string	file_path,
		bool &	try_ok )

{
    try {
        uintmax_t fileSizeBytes = boost::filesystem::file_size(file_path);
        double    fileSizeMB    = static_cast<double>(fileSizeBytes) / 1024 / 1024;
        try_ok                  = true;
        if (fileSizeMB > STL_SVG_MAX_FILE_SIZE_MB) { return true; }
    } catch (boost::filesystem::filesystem_error &e) {
        try_ok = false;
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " error message: " << e.what();
    }
    return false;
}

References STL_SVG_MAX_FILE_SIZE_MB.

Referenced by Slic3r::GUI::CreatePrinterPresetDialog::load_model_stl(), and Slic3r::GUI::CreatePrinterPresetDialog::load_texture().

Here is the caller graph for this function:

iso8601_to_millis()

long long Slic3r::Utils::iso8601_to_millis

(

const std::string &

iso_time

)

{
    if (iso_time.empty()) return -1;
 
    int y, M, d, h, m, s, ms = 0;
 
    // Try parsing with milliseconds: "2025-11-28T14:30:00.123Z"
    int parsed = sscanf(iso_time.c_str(), "%d-%d-%dT%d:%d:%d.%dZ",
        &y, &M, &d, &h, &m, &s, &ms);
 
    if (parsed < 6) {
        // Try without milliseconds: "2025-11-28T14:30:00Z"
        parsed = sscanf(iso_time.c_str(), "%d-%d-%dT%d:%d:%dZ",
            &y, &M, &d, &h, &m, &s);
        ms = 0;
    }
 
    if (parsed < 6) return -1;
 
    // Normalize milliseconds (handle .1, .12, .123, .1234, etc.)
    if (parsed >= 7) {
        // Count digits in the fractional part to normalize
        const char* dot = strchr(iso_time.c_str(), '.');
        if (dot) {
            int digits = 0;
            for (const char* p = dot + 1; *p && *p != 'Z' && std::isdigit(*p); ++p)
                digits++;
            // Normalize to 3 digits (milliseconds)
            while (digits < 3) { ms *= 10; digits++; }
            while (digits > 3) { ms /= 10; digits--; }
        }
    }
 
    std::tm tms = {};
    tms.tm_year = y - 1900;
    tms.tm_mon  = M - 1;
    tms.tm_mday = d;
    tms.tm_hour = h;
    tms.tm_min  = m;
    tms.tm_sec  = s;
 
    time_t seconds = _timegm(&tms);
    if (seconds == time_t(-1)) return -1;
 
    return static_cast<long long>(seconds) * 1000 + ms;
}

References Slic3r::dot().

Here is the call graph for this function:

iso_utc_timestamp() [1/2]

std::string Slic3r::Utils::iso_utc_timestamp ( )

inline

{
    return iso_utc_timestamp(get_current_time_utc());
}

References get_current_time_utc(), and iso_utc_timestamp().

Referenced by iso_utc_timestamp(), Slic3r::GUI::Config::Snapshot::save_ini(), and Slic3r::GUI::Config::SnapshotDB::take_snapshot().

Here is the call graph for this function:

Here is the caller graph for this function:

iso_utc_timestamp() [2/2]

std::string Slic3r::Utils::iso_utc_timestamp ( time_t t )

inline

{
    return time2str(t, TimeZone::utc, TimeFormat::iso8601Z);
}

References iso8601Z, time2str(), and utc.

Here is the call graph for this function:

local_timestamp()

std::string Slic3r::Utils::local_timestamp ( TimeFormat fmt = TimeFormat::gcode )

inline

                                                                   {
     return time2str(get_current_time_utc(), TimeZone::local, fmt);
}

References gcode, get_current_time_utc(), local, and time2str().

Referenced by Slic3r::GCode::_do_export().

Here is the call graph for this function:

Here is the caller graph for this function:

looks_like_printer()

bool Slic3r::Utils::looks_like_printer ( const std::string & friendly_name )

static

{
  return friendly_name.find("Original Prusa") != std::string::npos;
}

Referenced by scan_serial_ports_extended().

Here is the caller graph for this function:

millis_to_iso8601()

std::string Slic3r::Utils::millis_to_iso8601

(

long long

unix_millis

)

{
    time_t seconds = static_cast<time_t>(unix_millis / 1000);
    int millis = static_cast<int>(unix_millis % 1000);
 
    std::tm tms = {};
    _gmtime_r(&seconds, &tms);
 
    char buf[32];
    std::snprintf(buf, sizeof(buf), "%04d-%02d-%02dT%02d:%02d:%02d.%03dZ",
        tms.tm_year + 1900,
        tms.tm_mon + 1,
        tms.tm_mday,
        tms.tm_hour,
        tms.tm_min,
        tms.tm_sec,
        millis);
 
    return std::string(buf);
}

operator==()

bool Slic3r::Utils::operator== ( const SerialPortInfo & sp1, const SerialPortInfo & sp2 )

inline

{
  return
    sp1.port       == sp2.port       &&
    sp1.id_vendor  == sp2.id_vendor  &&
    sp1.id_product == sp2.id_product &&
    sp1.is_printer == sp2.is_printer;
}

References Slic3r::Utils::SerialPortInfo::id_product, Slic3r::Utils::SerialPortInfo::id_vendor, Slic3r::Utils::SerialPortInfo::is_printer, and Slic3r::Utils::SerialPortInfo::port.

parse_device_kind()

HexFile::DeviceKind Slic3r::Utils::parse_device_kind ( const std::string & str )

static

{
       if (str == "mk2") { return HexFile::DEV_MK2; }
  else if (str == "mk3") { return HexFile::DEV_MK3; }
  else if (str == "mm-control") { return HexFile::DEV_MM_CONTROL; }
  else if (str == "cw1") { return HexFile::DEV_CW1; }
  else if (str == "cw1s") { return HexFile::DEV_CW1S; }
  else { return HexFile::DEV_GENERIC; }
}

References Slic3r::Utils::HexFile::DEV_CW1, Slic3r::Utils::HexFile::DEV_CW1S, Slic3r::Utils::HexFile::DEV_GENERIC, Slic3r::Utils::HexFile::DEV_MK2, Slic3r::Utils::HexFile::DEV_MK3, and Slic3r::Utils::HexFile::DEV_MM_CONTROL.

parse_iso_utc_timestamp()

time_t Slic3r::Utils::parse_iso_utc_timestamp ( const std::string & str )

inline

{
    return str2time(str, TimeZone::utc, TimeFormat::iso8601Z);
}

References iso8601Z, str2time(), and utc.

Referenced by Slic3r::GUI::Config::Snapshot::load_ini().

Here is the call graph for this function:

Here is the caller graph for this function:

scan_serial_ports()

std::vector< std::string > Slic3r::Utils::scan_serial_ports

(

)

{
  std::vector<SerialPortInfo> ports = scan_serial_ports_extended();
  std::vector<std::string> output;
  output.reserve(ports.size());
  for (const SerialPortInfo &spi : ports)
    output.emplace_back(std::move(spi.port));
  return output;
}

References scan_serial_ports_extended().

Here is the call graph for this function:

scan_serial_ports_extended()

std::vector< SerialPortInfo > Slic3r::Utils::scan_serial_ports_extended

(

)

{
  std::vector<SerialPortInfo> output;
 
#ifdef _WIN32
  SP_DEVINFO_DATA devInfoData = { 0 };
  devInfoData.cbSize = sizeof(devInfoData);
  // Get the tree containing the info for the ports.
  HDEVINFO hDeviceInfo = SetupDiGetClassDevs(&GUID_DEVCLASS_PORTS, 0, nullptr, DIGCF_PRESENT);
  if (hDeviceInfo != INVALID_HANDLE_VALUE) {
    // Iterate over all the devices in the tree.
    for (int nDevice = 0; SetupDiEnumDeviceInfo(hDeviceInfo, nDevice, &devInfoData); ++ nDevice) {
      SerialPortInfo port_info;
      // Get the registry key which stores the ports settings.
      HKEY hDeviceKey = SetupDiOpenDevRegKey(hDeviceInfo, &devInfoData, DICS_FLAG_GLOBAL, 0, DIREG_DEV, KEY_QUERY_VALUE);
      if (hDeviceKey) {
        // Read in the name of the port.
        wchar_t pszPortName[4096];
        DWORD dwSize = sizeof(pszPortName);
        DWORD dwType = 0;
        if (RegQueryValueEx(hDeviceKey, L"PortName", NULL, &dwType, (LPBYTE)pszPortName, &dwSize) == ERROR_SUCCESS)
          port_info.port = boost::nowide::narrow(pszPortName);
        RegCloseKey(hDeviceKey);
        if (port_info.port.empty())
          continue;
      }
 
      // Find the size required to hold the device info.
      DWORD regDataType;
      DWORD reqSize = 0;
      SetupDiGetDeviceRegistryProperty(hDeviceInfo, &devInfoData, SPDRP_HARDWAREID, nullptr, nullptr, 0, &reqSize);
      std::vector<wchar_t> hardware_id(reqSize > 1 ? reqSize : 1);
      // Now store it in a buffer.
      if (! SetupDiGetDeviceRegistryProperty(hDeviceInfo, &devInfoData, SPDRP_HARDWAREID, &regDataType, (BYTE*)hardware_id.data(), reqSize, nullptr))
        continue;
      parse_hardware_id(boost::nowide::narrow(hardware_id.data()), port_info);
 
      // Find the size required to hold the friendly name.
      reqSize = 0;
      SetupDiGetDeviceRegistryProperty(hDeviceInfo, &devInfoData, SPDRP_FRIENDLYNAME, nullptr, nullptr, 0, &reqSize);
      std::vector<wchar_t> friendly_name;
      friendly_name.reserve(reqSize > 1 ? reqSize : 1);
      // Now store it in a buffer.
      if (! SetupDiGetDeviceRegistryProperty(hDeviceInfo, &devInfoData, SPDRP_FRIENDLYNAME, nullptr, (BYTE*)friendly_name.data(), reqSize, nullptr)) {
        port_info.friendly_name = port_info.port;
      } else {
        port_info.friendly_name = boost::nowide::narrow(friendly_name.data());
        port_info.is_printer = looks_like_printer(port_info.friendly_name);
      }
      output.emplace_back(std::move(port_info));
    }
  }
#elif __APPLE__
  // inspired by https://sigrok.org/wiki/Libserialport
  CFMutableDictionaryRef classes = IOServiceMatching(kIOSerialBSDServiceValue);
  if (classes != 0) {
    io_iterator_t iter;
    if (IOServiceGetMatchingServices(kIOMasterPortDefault, classes, &iter) == KERN_SUCCESS) {
      io_object_t port;
      while ((port = IOIteratorNext(iter)) != 0) {
        CFTypeRef cf_property = IORegistryEntryCreateCFProperty(port, CFSTR(kIOCalloutDeviceKey), kCFAllocatorDefault, 0);
        if (cf_property) {
          char path[PATH_MAX];
          Boolean result = CFStringGetCString((CFStringRef)cf_property, path, sizeof(path), kCFStringEncodingUTF8);
          CFRelease(cf_property);
          if (result) {
            SerialPortInfo port_info;
            port_info.port = path;
 
            // Attempt to read out the device friendly name
            if ((cf_property = IORegistryEntrySearchCFProperty(port, kIOServicePlane,
                     CFSTR("USB Interface Name"), kCFAllocatorDefault,
                     kIORegistryIterateRecursively | kIORegistryIterateParents)) ||
                (cf_property = IORegistryEntrySearchCFProperty(port, kIOServicePlane,
                     CFSTR("USB Product Name"), kCFAllocatorDefault,
                     kIORegistryIterateRecursively | kIORegistryIterateParents)) ||
                (cf_property = IORegistryEntrySearchCFProperty(port, kIOServicePlane,
                     CFSTR("Product Name"), kCFAllocatorDefault,
                     kIORegistryIterateRecursively | kIORegistryIterateParents)) ||
                (cf_property = IORegistryEntryCreateCFProperty(port, 
                     CFSTR(kIOTTYDeviceKey), kCFAllocatorDefault, 0))) {
              // Description limited to 127 char, anything longer would not be user friendly anyway.
              char description[128];
              if (CFStringGetCString((CFStringRef)cf_property, description, sizeof(description), kCFStringEncodingUTF8)) {
                port_info.friendly_name = std::string(description) + " (" + port_info.port + ")";
                port_info.is_printer = looks_like_printer(port_info.friendly_name);
              }
              CFRelease(cf_property);
            }
            if (port_info.friendly_name.empty())
              port_info.friendly_name = port_info.port;
 
            // Attempt to read out the VID & PID
            int vid, pid;
            auto cf_vendor = IORegistryEntrySearchCFProperty(port, kIOServicePlane, CFSTR("idVendor"),
              kCFAllocatorDefault, kIORegistryIterateRecursively | kIORegistryIterateParents);
            auto cf_product = IORegistryEntrySearchCFProperty(port, kIOServicePlane, CFSTR("idProduct"),
              kCFAllocatorDefault, kIORegistryIterateRecursively | kIORegistryIterateParents);
            if (cf_vendor && cf_product) {
              if (CFNumberGetValue((CFNumberRef)cf_vendor, kCFNumberIntType, &vid) &&
                CFNumberGetValue((CFNumberRef)cf_product, kCFNumberIntType, &pid)) {
                port_info.id_vendor = vid;
                port_info.id_product = pid;
              }
            }
            if (cf_vendor) { CFRelease(cf_vendor); }
            if (cf_product) { CFRelease(cf_product); }
 
            output.emplace_back(std::move(port_info));
          }
        }
        IOObjectRelease(port);
      }
    }
  }
#else
    // UNIX / Linux
    std::initializer_list<const char*> prefixes { "ttyUSB" , "ttyACM", "tty.", "cu.", "rfcomm" };
    for (auto &dir_entry : boost::filesystem::directory_iterator(boost::filesystem::path("/dev"))) {
        std::string name = dir_entry.path().filename().string();
        for (const char *prefix : prefixes) {
            if (boost::starts_with(name, prefix)) {
                const auto path = dir_entry.path().string();
                SerialPortInfo spi;
                spi.port = path;
#ifdef __linux__
        auto friendly_name = sysfs_tty_prop(name, "product");
        if (friendly_name) {
          spi.is_printer = looks_like_printer(*friendly_name);
          spi.friendly_name = (boost::format("%1% (%2%)") % *friendly_name % path).str();
        } else {
          spi.friendly_name = path;
        }
        auto vid = sysfs_tty_prop_hex(name, "idVendor");
        auto pid = sysfs_tty_prop_hex(name, "idProduct");
        if (vid && pid) {
          spi.id_vendor = *vid;
          spi.id_product = *pid;
        }
#else
                spi.friendly_name = path;
#endif
                output.emplace_back(std::move(spi));
                break;
            }
        }
    }
#endif
 
    output.erase(std::remove_if(output.begin(), output.end(), 
        [](const SerialPortInfo &info) {
            return boost::starts_with(info.port, "Bluetooth") || boost::starts_with(info.port, "FireFly"); 
        }),
        output.end());
    return output;
}

References Slic3r::Boolean, Slic3r::Utils::SerialPortInfo::friendly_name, Slic3r::Utils::SerialPortInfo::id_product, Slic3r::Utils::SerialPortInfo::id_vendor, Slic3r::Utils::SerialPortInfo::is_printer, L, looks_like_printer(), and Slic3r::Utils::SerialPortInfo::port.

Referenced by scan_serial_ports().

Here is the call graph for this function:

Here is the caller graph for this function:

slash_to_back_slash()

void Slic3r::Utils::slash_to_back_slash

(

std::string &

file_path

)

                                               {
    std::replace(file_path.begin(), file_path.end(), '\\', '/');
}

Referenced by Slic3r::GUI::GLTexture::load_from_svg_file(), Slic3r::GUI::CreatePrinterPresetDialog::save_printable_area_config(), and Slic3r::GUI::PartPlateList::update_logo_texture_filename().

Here is the caller graph for this function:

str2time() [1/2]

time_t Slic3r::Utils::str2time	(	const std::string &	str,
		TimeZone	zone,
		TimeFormat	fmt )

{
    std::string fmtstr = process_format(get_fmtstr(fmt), zone).c_str();
    std::stringstream ss(str);
 
    ss.imbue(std::locale("C"));
    return str2time(ss, zone, fmtstr.c_str());
}

References get_fmtstr(), and str2time().

Here is the call graph for this function:

str2time() [2/2]

time_t Slic3r::Utils::str2time ( std::istream & stream, TimeZone zone, const char * fmt )

static

{
    std::tm tms = {};
    tms.tm_isdst = -1;
 
    stream >> __get_put_time_emulation::get_time(&tms, fmt);
    time_t ret = time_t(-1);
 
    switch (zone) {
    case TimeZone::local: ret = _mktime(&tms); break;
    case TimeZone::utc:   ret = _timegm(&tms); break;
    }
 
    if (stream.fail() || ret < time_t(0)) ret = time_t(-1);
 
    return ret;
}

References Slic3r::Utils::__get_put_time_emulation::get_time(), local, and utc.

Referenced by parse_iso_utc_timestamp(), and str2time().

Here is the call graph for this function:

Here is the caller graph for this function:

time2str() [1/2]

std::string Slic3r::Utils::time2str	(	const time_t &	t,
		TimeZone	zone,
		TimeFormat	fmt )

{
    std::string ret;
    std::tm tms = {};
    tms.tm_isdst = -1;
    std::string fmtstr = process_format(get_fmtstr(fmt), zone);
 
    switch (zone) {
    case TimeZone::local:
        ret = tm2str(_localtime_r(&t, &tms), fmtstr.c_str()); break;
    case TimeZone::utc:
        ret = tm2str(_gmtime_r(&t, &tms), fmtstr.c_str()); break;
    }
 
    return ret;
}

References get_fmtstr(), local, tm2str(), and utc.

Referenced by iso_utc_timestamp(), local_timestamp(), Slic3r::PresetBundle::migrate_legacy_user_filament_presets(), time2str(), and utc_timestamp().

Here is the call graph for this function:

Here is the caller graph for this function:

time2str() [2/2]

std::string Slic3r::Utils::time2str ( TimeZone zone, TimeFormat fmt )

inline

{
    return time2str(get_current_time_utc(), zone, fmt);
}

References get_current_time_utc(), and time2str().

Here is the call graph for this function:

tm2str()

std::string Slic3r::Utils::tm2str ( const std::tm * tms, const char * fmt )

static

{
    std::stringstream ss;
    ss.imbue(std::locale("C"));
    ss << __get_put_time_emulation::put_time(tms, fmt);
    return ss.str();
}

References Slic3r::Utils::__get_put_time_emulation::put_time().

Referenced by time2str().

Here is the call graph for this function:

Here is the caller graph for this function:

utc_timestamp() [1/2]

std::string Slic3r::Utils::utc_timestamp ( )

inline

{
    return utc_timestamp(get_current_time_utc());
}

References get_current_time_utc(), and utc_timestamp().

Referenced by utc_timestamp().

Here is the call graph for this function:

Here is the caller graph for this function:

utc_timestamp() [2/2]

std::string Slic3r::Utils::utc_timestamp ( time_t t )

inline

{
    return time2str(t, TimeZone::utc, TimeFormat::gcode);
}

References gcode, time2str(), and utc.

Referenced by Slic3r::anonymous_namespace{SL1.cpp}::fill_iniconf().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

ISO8601Z_TIME_FMT

const constexpr char* const Slic3r::Utils::ISO8601Z_TIME_FMT = "%Y%m%dT%H%M%SZ"

staticconstexpr

Referenced by get_fmtstr().

SLICER_UTC_TIME_FMT

const constexpr char* const Slic3r::Utils::SLICER_UTC_TIME_FMT = "%Y-%m-%d at %T"

staticconstexpr

Referenced by get_fmtstr(), and Slic3r::Utils::anonymous_namespace{Time.cpp}::process_format().