Slic3r::MachineObject Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/DeviceManager.hpp>

Collaboration diagram for Slic3r::MachineObject:

Classes
struct	FilamentData

Public Types
enum	ActiveState { NotActive , Active , UpdateToDate }
enum	PrintOption { PRINT_OP_AUTO_RECOVERY = 0 , PRINT_OP_MAX }
enum	PlateMakerDectect : int { POS_CHECK = 1 , TYPE_POS_CHECK = 2 }
enum	DoorOpenCheckState : int { DOOR_OPEN_CHECK_DISABLE = 0 , DOOR_OPEN_CHECK_ENABLE_WARNING = 1 , DOOR_OPEN_CHECK_ENABLE_PAUSE_PRINT = 2 }
enum	DeviceMode : unsigned int { DEVICE_MODE_FDM = 0x00000001 , DEVICE_MODE_LASER = 0x00000010 , DEVICE_MODE_CUT = 0x00000100 }
typedef std::function< void(std::string topic, std::string payload)>	MsgFn

Public Member Functions
	MachineObject (DeviceManager *manager, NetworkAgent *agent, std::string name, std::string id, std::string ip)
	~MachineObject ()
void	set_agent (NetworkAgent *agent)
NetworkAgent *	get_agent () const
std::shared_ptr< DevAxis >	GetAxis () const
std::shared_ptr< DevChamber >	GetChamber () const
DevCalib *	GetCalib () const
DevStatus *	GetStatus () const
std::weak_ptr< DevUpgrade >	GetUpgrade () const
std::string	get_dev_name () const
void	set_dev_name (std::string val)
std::string	get_dev_ip () const
void	set_dev_ip (std::string ip)
std::string	get_dev_id () const
void	set_dev_id (std::string val)
std::string	get_ftp_folder ()
std::string	connection_type () const
bool	is_lan_mode_printer () const
bool	is_cloud_mode_printer () const
bool	HasRecentCloudMessage ()
bool	HasRecentLanMessage ()
bool	has_access_right () const
void	revoke_access ()
std::string	get_access_code () const
void	set_access_code (std::string code, bool only_refresh=true)
std::string	get_show_printer_type () const
PrinterSeries	get_printer_series () const
PrinterArch	get_printer_arch () const
std::string	get_printer_ams_type () const
wxString	get_printer_type_display_str () const
std::string	get_auto_pa_cali_thumbnail_img_str () const
std::string	get_printer_series_str () const
bool	is_series_n () const
bool	is_series_p () const
bool	is_series_x () const
bool	is_series_o () const
bool	can_use_emmc_print () const
void	reload_printer_settings ()
std::string	get_printer_thumbnail_img_str () const
bool	is_avaliable ()
void	set_lan_mode_connection_state (bool state)
bool	get_lan_mode_connection_state ()
void	set_ctt_dlg (wxString text)
void	show_unsupported_dlg (int code)
bool	is_in_extrusion_cali ()
bool	is_extrusion_cali_finished ()
DevAms *	get_curr_Ams ()
DevAmsTray *	get_curr_tray ()
DevAmsTray *	get_ams_tray (std::string ams_id, std::string tray_id)
std::string	get_filament_id (std::string ams_id, std::string tray_id) const
std::string	get_filament_type (const std::string &ams_id, const std::string &tray_id) const
std::string	get_filament_display_type (const std::string &ams_id, const std::string &tray_id) const
void	_parse_ams_status (int ams_status)
bool	is_target_slot_unload () const
bool	can_unload_filament ()
void	get_ams_colors (std::vector< wxColour > &ams_colors)
bool	is_main_extruder_on_left () const
bool	is_multi_extruders () const
int	get_extruder_id_by_ams_id (const std::string &ams_id)
int	get_preset_extruder_index (int extder_id) const
bool	is_nozzle_flow_type_supported () const
wxString	get_nozzle_replace_url () const
DevExtderSystem *	GetExtderSystem () const
std::weak_ptr< DevExtensionTool >	GetExtensionTool () const
DevNozzleSystem *	GetNozzleSystem () const
std::shared_ptr< DevNozzleMappingCtrl >	get_nozzle_mapping_result () const
void	clear_auto_nozzle_mapping ()
std::shared_ptr< DevFilaSystem >	GetFilaSystem () const
DevFilaSwitch *	GetFilaSwitch () const
bool	HasAms () const
DevLamp *	GetLamp () const
DevFan *	GetFan () const
DevBed *	GetBed () const
DevStorage *	GetStorage () const
DevCtrl *	GetCtrl () const
DevHMS *	GetHMS () const
DevConfig *	GetConfig () const
DevPrintOptions *	GetPrintOptions () const
DevPrintingSpeedLevel	GetPrintingSpeedLevel () const
std::string	get_firmware_type_str ()
std::string	get_lifecycle_type_str ()
bool	is_in_upgrading () const
bool	is_upgrading_avalable ()
int	get_upgrade_percent () const
std::string	get_ota_version ()
bool	check_version_valid ()
wxString	get_upgrade_result_str (int upgrade_err_code)
std::map< int, DevFirmwareVersionInfo >	get_ams_version ()
void	clear_version_info ()
void	store_version_info (const DevFirmwareVersionInfo &info)
bool	is_system_printing ()
std::string	get_print_error_str () const
void	add_command_error_code_dlg (int command_err, nlohmann::json action_json=nlohmann::json{})
void	reset_pa_cali_history_result ()
void	reset_pa_cali_result ()
void	reset_flow_rate_cali_result ()
bool	check_pa_result_validation (PACalibResult &result)
bool	is_axis_at_home (std::string axis)
bool	is_filament_at_extruder ()
wxString	get_curr_stage ()
int	get_curr_stage_idx ()
int	get_stage_remaining_seconds () const
bool	is_in_calibration ()
bool	is_calibration_running ()
bool	is_calibration_done ()
void	parse_state_changed_event ()
void	parse_home_flag (int flag)
int	get_bed_temperature_limit ()
bool	is_filament_installed ()
int	connect ()
int	disconnect ()
bool	any_loaded_filament_is_stringing_prone () const
bool	is_makeworld_subtask ()
bool	is_fdm_type () const
bool	is_sdcard_printing ()
bool	is_timelapse ()
bool	is_recording_enable ()
bool	is_recording ()
int	get_liveview_remote ()
int	get_file_remote ()
std::string	parse_version ()
void	parse_version_func ()
bool	is_studio_cmd (int seq)
bool	canEnableTimelapse (wxString &error_message) const
bool	is_timelapse_storage_low (const std::string &storage) const
int	command_get_version (bool with_retry=true)
int	command_request_push_all (bool request_now=false)
int	command_pushing (std::string cmd)
int	command_clean_print_error (std::string task_id, int print_error)
int	command_clean_print_error_uiop (int print_error)
int	command_set_printer_nozzle (std::string nozzle_type, float diameter)
int	command_set_printer_nozzle2 (int id, std::string nozzle_type, float diameter)
int	command_get_access_code ()
int	command_start_camera ()
int	command_ack_proceed (nlohmann::json &proceed)
int	command_purification_disable ()
int	command_dont_remind_next_time (nlohmann::json &mqtt_guard_json)
int	command_upgrade_confirm ()
int	command_consistency_upgrade_confirm ()
int	command_upgrade_firmware (FirmwareInfo info)
int	command_upgrade_module (std::string url, std::string module_type, std::string version)
int	command_xyz_abs ()
int	command_auto_leveling ()
int	command_go_home ()
int	command_task_abort ()
int	command_task_partskip (std::vector< int > part_ids)
int	command_task_cancel (std::string job_id)
int	command_task_pause ()
int	command_task_resume ()
int	command_hms_idle_ignore (const std::string &error_str, int type)
int	command_hms_resume (const std::string &error_str, const std::string &job_id)
int	command_hms_ignore (const std::string &error_str, const std::string &job_id)
int	command_hms_stop (const std::string &error_str, const std::string &job_id)
int	command_stop_buzzer ()
int	command_set_bed (int temp)
int	command_set_nozzle (int temp)
int	command_set_nozzle_new (int nozzle_id, int temp)
int	command_refresh_nozzle ()
int	command_set_chamber (int temp)
int	check_resume_condition ()
int	command_ams_change_filament (bool load, std::string ams_id, std::string slot_id, int old_temp=210, int new_temp=210, std::optional< int > extruder_id=std::nullopt)
int	command_ams_user_settings (bool start_read_opt, bool tray_read_opt, bool remain_flag=false)
int	command_ams_switch_filament (bool switch_filament)
int	command_ams_air_print_detect (bool air_print_detect)
int	command_ams_calibrate (int ams_id)
int	command_ams_filament_settings (int ams_id, int slot_id, std::string filament_id, std::string setting_id, std::string tray_color, std::string tray_type, int nozzle_temp_min, int nozzle_temp_max, const std::vector< std::string > &tray_colors={}, int tray_ctype=2)
int	command_ams_select_tray (std::string tray_id)
int	command_ams_refresh_rfid (int ams_id, int slot_id)
int	command_ams_control (std::string action)
int	command_ams_drying_stop ()
int	command_start_extrusion_cali (int tray_index, int nozzle_temp, int bed_temp, float max_volumetric_speed, std::string setting_id="")
int	command_stop_extrusion_cali ()
int	command_extrusion_cali_set (int tray_index, std::string setting_id, std::string name, float k, float n, int bed_temp=-1, int nozzle_temp=-1, float max_volumetric_speed=-1)
int	command_set_printing_speed (DevPrintingSpeedLevel lvl)
int	command_set_prompt_sound (bool prompt_sound)
int	command_set_filament_tangle_detect (bool fliament_tangle_detect)
int	command_set_printing_option (bool auto_recovery)
int	command_nozzle_blob_detect (bool nozzle_blob_detect)
int	command_axis_control (std::string axis, double unit=1.0f, double input_val=1.0f, int speed=3000)
int	command_extruder_control (int nozzle_id, double val)
bool	is_support_command_calibration ()
int	command_start_calibration (bool vibration, bool bed_leveling, bool xcam_cali, bool motor_noise, bool nozzle_cali, bool bed_cali, bool clumppos_cali)
int	command_start_pa_calibration (const X1CCalibInfos &pa_data, int mode=0)
int	command_set_pa_calibration (const std::vector< PACalibResult > &pa_calib_values, bool is_auto_cali)
int	command_delete_pa_calibration (const PACalibIndexInfo &pa_calib)
int	command_get_pa_calibration_tab (const PACalibExtruderInfo &calib_info)
int	command_get_pa_calibration_result (float nozzle_diameter)
int	commnad_select_pa_calibration (const PACalibIndexInfo &pa_calib_info)
int	command_start_flow_ratio_calibration (const X1CCalibInfos &calib_data)
int	command_get_flow_ratio_calibration_result (float nozzle_diameter)
int	command_ipcam_record (bool on_off)
int	command_ipcam_timelapse (bool on_off)
int	command_ipcam_resolution_set (std::string resolution)
int	command_ipcam_check_timelapse_storage (const std::string &storage, int total_layer)
int	command_ipcam_delete_oldest_timelapse (const std::string &storage, int total_layer)
int	command_xcam_control (std::string module_name, bool on_off, std::string lvl="")
int	command_xcam_control_ai_monitoring (bool on_off, std::string lvl)
int	command_xcam_control_spaghetti_detection (bool on_off, std::string lvl)
int	command_xcam_control_purgechutepileup_detection (bool on_off, std::string lvl)
int	command_xcam_control_nozzleclumping_detection (bool on_off, std::string lvl)
int	command_xcam_control_airprinting_detection (bool on_off, std::string lvl)
int	command_xcam_control_first_layer_inspector (bool on_off, bool print_halt)
int	command_xcam_control_buildplate_marker_detector (bool on_off)
int	command_xcam_control_auto_recovery_step_loss (bool on_off)
int	command_xcam_control_allow_prompt_sound (bool on_off)
int	command_xcam_control_filament_tangle_detect (bool on_off)
bool	is_local ()
void	set_bind_status (std::string status)
std::string	get_bind_str ()
bool	can_print ()
bool	can_resume ()
bool	can_pause ()
bool	can_abort ()
bool	is_in_printing ()
bool	is_in_printing_pause () const
bool	is_in_prepare ()
bool	is_printing_finished ()
bool	is_core_xy ()
void	reset_update_time ()
void	reset ()
void	set_print_state (std::string status)
void	update_print_progress (const nlohmann::json &value)
bool	is_connected ()
bool	is_connecting ()
void	set_online_state (bool on_off)
bool	is_online ()
bool	is_info_ready (bool check_version=true) const
bool	is_security_control_ready () const
bool	is_camera_busy_off ()
std::vector< std::string >	get_resolution_supported ()
std::vector< std::string >	get_compatible_machine ()
int	publish_json (const nlohmann::json &json_item, int qos=0, int flag=0)
int	publish_json (const std::string &json_str, int qos=0, int flag=0)=delete
int	cloud_publish_json (std::string json_str, int qos=0, int flag=0)
int	local_publish_json (std::string json_str, int qos=0, int flag=0)
int	parse_json (std::string tunnel, std::string payload, bool key_filed_only=false)
int	publish_gcode (std::string gcode_str)
void	update_device_cert_state (bool ready)
BBLSubTask *	get_subtask ()
BBLModelTask *	get_modeltask ()
void	set_modeltask (BBLModelTask *task)
void	update_model_task ()
void	free_slice_info ()
void	update_slice_info (std::string project_id, std::string profile_id, std::string subtask_id, int plate_idx)
void	get_firmware_info ()
bool	is_firmware_info_valid ()
int	get_max_filament_color_count () const
DevAmsTray	parse_vt_tray (nlohmann::json vtray)
bool	contains_tray (const std::string &ams_id, const std::string &tray_id) const
DevAmsTray	get_tray (const std::string &ams_id, const std::string &tray_id) const
bool	check_enable_np (const nlohmann::json &print) const
void	parse_new_info (nlohmann::json print)
void	parse_new_info2 (const nlohmann::json &info)
int	get_flag_bits (std::string str, int start, int count=1) const
uint32_t	get_flag_bits_no_border (std::string str, int start_idx, int count=1) const
int	get_flag_bits (int num, int start, int count=1, int base=10) const
void	update_filament_list ()
void	update_printer_preset_name ()
void	check_ams_filament_valid ()
bool	support_door_open_check () const
DoorOpenCheckState	get_door_open_check_state () const
void	command_set_door_open_check (DoorOpenCheckState state)
bool	get_save_remote_print_file_to_storage () const
void	command_set_save_remote_print_file_to_storage (bool save)

Static Public Member Functions
static std::string	dev_id_from_address (const std::string &host, const std::string &port="")
static bool	is_series_n (const std::string &series_str)
static bool	is_series_p (const std::string &series_str)
static bool	is_series_x (const std::string &series_str)
static bool	is_series_o (const std::string &series_str)
static std::string	get_error_code_str (int error_code)
static bool	is_in_printing_status (std::string status)
static std::string	setting_id_to_type (std::string setting_id, std::string tray_type)

Public Attributes
bool	local_use_ssl { true }
bool	local_use_ssl_for_ftp { true }
int	subscribe_counter {3}
std::string	dev_connection_type
std::chrono::system_clock::time_point	last_cloud_msg_time_
std::chrono::system_clock::time_point	last_lan_msg_time_
std::string	dev_connection_name
std::string	printer_type
std::string	printer_agent_id
std::string	dev_product_name
std::string	bind_user_name
std::string	bind_user_id
std::string	bind_sec_link
std::string	bind_ssdp_version
std::string	bind_state
time_t	last_alive
bool	m_is_online
bool	m_lan_mode_connection_state {false}
bool	m_set_ctt_dlg { false }
bool	m_unsupported_dlg_shown { false }
int	parse_msg_count = 0
int	keep_alive_count = 0
std::chrono::system_clock::time_point	last_update_time
std::chrono::system_clock::time_point	last_utc_time
std::chrono::system_clock::time_point	last_keep_alive
std::chrono::system_clock::time_point	last_push_time
std::chrono::system_clock::time_point	last_request_push
std::chrono::system_clock::time_point	last_request_start
bool	device_cert_installed = false
int	m_active_state = 0
bool	is_tunnel_mqtt = false
long	ams_exist_bits = 0
long	tray_exist_bits = 0
long	tray_is_bbl_bits = 0
long	tray_read_done_bits = 0
long	tray_reading_bits = 0
bool	ams_air_print_status { false }
bool	ams_support_virtual_tray { true }
time_t	ams_user_setting_start = 0
time_t	ams_switch_filament_start = 0
AmsStatusMain	ams_status_main = AmsStatusMain::AMS_STATUS_MAIN_IDLE
int	ams_status_sub
int	ams_version = 0
int	extrusion_cali_hold_count = 0
std::chrono::system_clock::time_point	last_extrusion_cali_start_time
int	extrusion_cali_set_tray_id = -1
std::chrono::system_clock::time_point	extrusion_cali_set_hold_start
std::string	extrusion_cali_filament_name
bool	has_extra_flow_type {false}
bool	online_rfid
bool	online_ahb
int	online_version = -1
int	last_online_version = -1
float	chamber_temp
float	chamber_temp_target
float	frame_temp
std::string	wifi_signal
std::string	link_th
std::string	link_ams
bool	network_wired { false }
bool	upgrade_force_upgrade { false }
bool	upgrade_new_version { false }
bool	upgrade_consistency_request { false }
DevFirmwareUpgradingState	upgrade_display_state
int	upgrade_display_hold_count = 0
PrinterFirmwareType	firmware_type
PrinterFirmwareType	lifecycle { PrinterFirmwareType::FIRMWARE_TYPE_PRODUCTION }
std::string	upgrade_progress
std::string	upgrade_message
std::string	upgrade_status
std::string	upgrade_module
std::string	ams_new_version_number
std::string	ota_new_version_number
std::string	ahb_new_version_number
int	get_version_retry = 0
DevFirmwareVersionInfo	air_pump_version_info
DevFirmwareVersionInfo	laser_version_info
DevFirmwareVersionInfo	cutting_module_version_info
DevFirmwareVersionInfo	extinguish_version_info
DevFirmwareVersionInfo	rotary_version_info
DevFirmwareVersionInfo	exhaustfan_version_info
DevFirmwareVersionInfo	amshub_version_info
DevFirmwareVersionInfo	filatrack_version_info
std::map< std::string, DevFirmwareVersionInfo >	module_vers
std::map< std::string, DevFirmwareVersionInfo >	new_ver_list
bool	m_new_ver_list_exist = false
int	upgrade_err_code = 0
std::vector< FirmwareInfo >	firmware_list
std::string	print_type
bool	is_220V_voltage { false }
int	mc_print_stage
int	mc_print_sub_stage
int	mc_print_error_code
int	mc_print_line_number
int	mc_print_percent
int	mc_left_time
int	last_mc_print_stage
int	m_home_flag = 0
int	hw_switch_state
int	print_error
std::string	m_print_error_img_id
std::unordered_set< GUI::DeviceErrorDialog * >	m_command_error_code_dlgs
int	curr_layer = 0
int	total_layers = 0
bool	is_support_layer_num { false }
bool	nozzle_blob_detection_enabled { false }
time_t	nozzle_blob_detection_hold_start = 0
bool	is_support_new_auto_cali_method {false}
int	last_cali_version = -1
int	cali_version = -1
float	cali_selected_nozzle_dia { 0.0 }
std::vector< CaliPresetInfo >	selected_cali_preset
float	cache_flow_ratio { 0.0 }
bool	cali_finished = true
FlowRatioCalibrationType	flow_ratio_calibration_type = FlowRatioCalibrationType::COMPLETE_CALIBRATION
ManualPaCaliMethod	manual_pa_cali_method = ManualPaCaliMethod::PA_LINE
bool	has_get_pa_calib_tab { false }
bool	request_tab_from_bbs { false }
std::vector< PACalibResult >	pa_calib_tab
bool	get_pa_calib_result { false }
std::vector< PACalibResult >	pa_calib_results
bool	get_flow_calib_result { false }
std::vector< FlowRatioCalibResult >	flow_ratio_results
std::vector< int >	stage_list_info
int	stage_curr = 0
int	stage_remaining_seconds = 0
int	m_push_count = 0
int	m_full_msg_count = 0
bool	calibration_done { false }
std::string	print_status
int	queue_number = 0
std::string	iot_print_status
int	printing_speed_mag = 100
bool	has_ipcam { false }
bool	camera_recording { false }
bool	camera_recording_when_printing { false }
bool	camera_timelapse { false }
time_t	camera_recording_ctl_start = 0
int	camera_timelapse_hold_count = 0
int	camera_resolution_hold_count = 0
std::string	camera_resolution = ""
std::vector< std::string >	camera_resolution_supported
bool	xcam_first_layer_inspector { false }
time_t	xcam_first_layer_hold_start = 0
std::string	local_rtsp_url
std::string	webcam_stream_url
std::string	tutk_state
LiveviewLocal	liveview_local { LiveviewLocal::LVL_None }
LiveviewRemote	liveview_remote { LiveviewRemote::LVR_None}
FileLocal	file_local { FileLocal::FL_None }
FileRemote	file_remote { FileRemote::FR_None }
bool	file_model_download {false}
bool	virtual_camera {false}
bool	m_has_timelapse_kit {false}
bool	xcam_ai_monitoring { false }
bool	xcam_disable_ai_detection_display {false}
bool	xcam_spaghetti_detection {false}
bool	xcam_purgechutepileup_detection {false}
bool	xcam_nozzleclumping_detection {false}
bool	xcam_airprinting_detection {false}
time_t	xcam_ai_monitoring_hold_start = 0
std::string	xcam_ai_monitoring_sensitivity
std::string	xcam_spaghetti_detection_sensitivity
std::string	xcam_purgechutepileup_detection_sensitivity
std::string	xcam_nozzleclumping_detection_sensitivity
std::string	xcam_airprinting_detection_sensitivity
bool	xcam_buildplate_marker_detector { false }
time_t	xcam_buildplate_marker_hold_start = 0
bool	xcam_auto_recovery_step_loss { false }
bool	xcam_allow_prompt_sound { false }
bool	xcam_filament_tangle_detect { false }
time_t	xcam_auto_recovery_hold_start = 0
time_t	xcam_prompt_sound_hold_start = 0
time_t	xcam_filament_tangle_detect_hold_start = 0
std::vector< int >	m_partskip_ids
int	targ_nozzle_id_from_pc = INVALID_EXTRUDER_ID
bool	is_support_build_plate_marker_detect {false}
PlateMakerDectect	m_plate_maker_detect_type { POS_CHECK }
bool	is_support_pa_calibration {false}
bool	is_support_flow_calibration {false}
bool	is_support_send_to_sdcard {false}
bool	is_support_filament_backup {false}
bool	is_support_timelapse {false}
bool	is_support_update_remain {false}
int	is_support_bed_leveling = 0
bool	is_support_auto_recovery_step_loss {false}
bool	is_support_ams_humidity {false}
bool	is_support_prompt_sound {false}
bool	is_support_filament_tangle_detect {false}
bool	is_support_1080dpi {false}
bool	is_support_cloud_print_only {false}
bool	is_support_command_ams_switch {false}
bool	is_support_mqtt_alive {false}
bool	is_support_tunnel_mqtt {false}
bool	is_support_motor_noise_cali {false}
bool	is_support_wait_sending_finish {false}
bool	is_support_user_preset {false}
bool	is_support_nozzle_blob_detection {false}
bool	is_support_air_print_detection {false}
bool	is_support_agora {false}
bool	is_support_upgrade_kit {false}
bool	is_support_filament_setting_inprinting {false}
bool	is_support_internal_timelapse { false }
bool	m_support_mqtt_homing { false }
bool	is_support_brtc {false}
bool	is_support_ext_change_assist {false}
bool	is_support_partskip {false}
bool	is_support_refresh_nozzle {false}
bool	is_support_spaghetti_detection {false}
bool	is_support_purgechutepileup_detection {false}
bool	is_support_nozzleclumping_detection {false}
bool	is_support_airprinting_detection {false}
bool	is_support_idelheadingprotect_detection {false}
std::atomic< bool >	timelapse_storage_check_done { false }
int	timelapse_storage_check_result { -1 }
bool	timelapse_storage_is_enough { true }
int	timelapse_storage_file_count { 0 }
bool	is_support_print_with_emmc {false}
bool	is_support_remote_dry = false
bool	is_support_check_track_switch_match_slice_printer {false}
bool	is_support_pa_mode {false}
bool	is_support_filament_manual_multi_color {false}
std::optional< bool >	m_firmware_support_print_tpu_left
bool	installed_upgrade_kit {false}
int	bed_temperature_limit = -1
std::vector< int >	nozzle_temp_range
std::vector< int >	bed_temp_range
json_diff	print_json
std::string	project_id_
std::string	profile_id_
std::string	task_id_
std::string	subtask_id_
std::string	job_id_
std::string	last_subtask_id_
std::string	m_agent_thumbnail_url
BBLSliceInfo *	slice_info {nullptr}
boost::thread *	get_slice_info_thread { nullptr }
boost::thread *	get_model_task_thread { nullptr }
std::vector< uint16_t >	print_job_filament_mapping
int	jobState_ = 0
DeviceMode	m_device_mode { DEVICE_MODE_FDM }
int	m_plate_index { -1 }
std::string	m_gcode_file
int	gcode_file_prepare_percent = 0
BBLSubTask *	subtask_
BBLModelTask *	model_task { nullptr }
DevPrintTaskRatingInfo *	rating_info { nullptr }
int	request_model_result = 0
bool	get_model_mall_result_need_retry = false
std::string	obj_subtask_id
std::string	subtask_name
bool	m_support_mqtt_bet_ctrl = false
bool	m_support_mqtt_axis_control = false
bool	m_firmware_valid { false }
bool	m_firmware_thread_started { false }
bool	is_enable_np { false }
bool	is_enable_ams_np { false }
bool	is_support_filament_32_colors { false }
bool	is_support_fila_change_abort { false }
bool	is_support_ext_change_assist_old { false }
std::vector< DevAmsTray >	vt_slot
std::map< std::string, FilamentData >	m_nozzle_filament_data

Static Public Attributes
static int	m_sequence_id = START_SEQ_ID

Private Member Functions
int	command_with_dialog (int cmd_result)

Private Attributes
NetworkAgent *	m_agent {nullptr}
DeviceManager *	m_manager { nullptr }
std::shared_ptr< int >	m_token = std::make_shared<int>(1)
std::string	dev_id
std::string	dev_name
std::string	dev_ip
std::string	access_code
bool	m_access_revoked = false
std::vector< std::tuple< std::string, uint64_t, uint64_t > >	message_delay
DevLamp *	m_lamp
std::shared_ptr< DevExtensionTool >	m_extension_tool
DevExtderSystem *	m_extder_system
DevNozzleSystem *	m_nozzle_system
std::shared_ptr< DevFilaSystem >	m_fila_system
DevFilaSwitch *	m_fila_switch
DevFan *	m_fan
DevBed *	m_bed
DevStorage *	m_storage
std::shared_ptr< DevAxis >	m_axis
std::shared_ptr< DevChamber >	m_chamber
DevCalib *	m_calib { nullptr }
DevStatus *	m_status { nullptr }
std::shared_ptr< DevUpgrade >	m_upgrade
DevCtrl *	m_ctrl
DevPrintOptions *	m_print_options
DevHMS *	m_hms_system
DevConfig *	m_config
std::shared_ptr< DevNozzleMappingCtrl >	m_nozzle_mapping_ptr
bool	is_support_door_open_check = false
DoorOpenCheckState	xcam_door_open_check = DoorOpenCheckState::DOOR_OPEN_CHECK_DISABLE
time_t	xcam_door_open_check_start_time = 0
bool	xcam__save_remote_print_file_to_storage = false
time_t	xcam__save_remote_print_file_to_storage_start_time = 0

Detailed Description

---

Class Documentation

Slic3r::MachineObject::FilamentData

struct Slic3r::MachineObject::FilamentData

Collaboration diagram for Slic3r::MachineObject::FilamentData:

Class Members
set< string >	checked_filament
map< string, pair< vector< int >, vector< int > > >	filament_list
string	printer_preset_name

Member Typedef Documentation

MsgFn

typedef std::function<void(std::string topic, std::string payload)> Slic3r::MachineObject::MsgFn

Member Enumeration Documentation

ActiveState

enum Slic3r::MachineObject::ActiveState

Enumerator
NotActive
Active
UpdateToDate

                     {
        NotActive,
        Active,
        UpdateToDate
    };

DeviceMode

enum Slic3r::MachineObject::DeviceMode : unsigned int

Enumerator
DEVICE_MODE_FDM
DEVICE_MODE_LASER
DEVICE_MODE_CUT

    {
        DEVICE_MODE_FDM   = 0x00000001,
        DEVICE_MODE_LASER = 0x00000010,
        DEVICE_MODE_CUT   = 0x00000100,
    };

DoorOpenCheckState

enum Slic3r::MachineObject::DoorOpenCheckState : int

Enumerator
DOOR_OPEN_CHECK_DISABLE
DOOR_OPEN_CHECK_ENABLE_WARNING
DOOR_OPEN_CHECK_ENABLE_PAUSE_PRINT

    {
        DOOR_OPEN_CHECK_DISABLE            = 0,/*do nothing*/
        DOOR_OPEN_CHECK_ENABLE_WARNING     = 1,/*warning*/
        DOOR_OPEN_CHECK_ENABLE_PAUSE_PRINT = 2,/*pause print*/
    };

PlateMakerDectect

enum Slic3r::MachineObject::PlateMakerDectect : int

Enumerator
POS_CHECK
TYPE_POS_CHECK

    {
        POS_CHECK      = 1,
        TYPE_POS_CHECK = 2,
    };

PrintOption

enum Slic3r::MachineObject::PrintOption

Enumerator
PRINT_OP_AUTO_RECOVERY
PRINT_OP_MAX

                     {
        PRINT_OP_AUTO_RECOVERY = 0,
        PRINT_OP_MAX,
    };

Constructor & Destructor Documentation

MachineObject()

Slic3r::MachineObject::MachineObject	(	DeviceManager *	manager,
		NetworkAgent *	agent,
		std::string	name,
		std::string	id,
		std::string	ip )

    :dev_name(name),
    dev_id(id),
    dev_ip(ip),
    subtask_(nullptr),
    model_task(nullptr),
    slice_info(nullptr),
    m_is_online(false)
{
    m_manager = manager;
    m_agent = agent;
 
    reset();
 
    /* temprature fields */
 
    chamber_temp        = 0.0f;
    chamber_temp_target = 0.0f;
    frame_temp          = 0.0f;
 
    /* ams fileds */
    ams_exist_bits = 0;
    tray_exist_bits = 0;
    tray_is_bbl_bits = 0;
 
    /* signals */
    wifi_signal = "";
 
    /* upgrade */
    upgrade_force_upgrade = false;
    upgrade_new_version = false;
    upgrade_consistency_request = false;
 
 
    /* printing */
    mc_print_stage = 0;
    mc_print_error_code = 0;
    print_error = 0;
    mc_print_line_number = 0;
    mc_print_percent = 0;
    mc_print_sub_stage = 0;
    mc_left_time = 0;
    hw_switch_state = 0;
    m_print_error_img_id = "";
 
    has_ipcam = true; // default true
 
 
    auto vslot = DevAmsTray(std::to_string(VIRTUAL_TRAY_MAIN_ID));
    vt_slot.push_back(vslot);
 
    {
        m_lamp = new DevLamp(this);
        m_fan = new DevFan(this);
        m_bed = new DevBed(this);
        m_storage       = new DevStorage(this);
        m_extder_system = new DevExtderSystem(this);
        m_extension_tool = DevExtensionTool::Create(this);
        m_nozzle_system = new DevNozzleSystem(this);
        m_fila_system = std::make_shared<DevFilaSystem>(this);
        m_fila_switch   = new DevFilaSwitch(this);
        m_hms_system    = new DevHMS(this);
        m_config = new DevConfig(this);
 
        m_ctrl = new DevCtrl(this);
        m_print_options = new DevPrintOptions(this);
 
        m_nozzle_mapping_ptr = std::make_shared<DevNozzleMappingCtrl>(this);
 
        // Orca: adopt DeviceCore split — axis/calib/chamber/status/upgrade modules
        m_axis    = DevAxis::Create(this);
        m_chamber = DevChamber::Create(this);
        m_upgrade = DevUpgrade::Create(this);
        m_status  = new DevStatus(this);
        m_calib   = new DevCalib(this);
    }
}

References ams_exist_bits, chamber_temp, chamber_temp_target, Slic3r::DevAxis::Create(), Slic3r::DevChamber::Create(), Slic3r::DevExtensionTool::Create(), Slic3r::DevUpgrade::Create(), dev_id, dev_ip, dev_name, frame_temp, has_ipcam, hw_switch_state, m_agent, m_axis, m_bed, m_calib, m_chamber, m_config, m_ctrl, m_extder_system, m_extension_tool, m_fan, m_fila_switch, m_fila_system, m_hms_system, m_is_online, m_lamp, m_manager, m_nozzle_mapping_ptr, m_nozzle_system, m_print_error_img_id, m_print_options, m_status, m_storage, m_upgrade, mc_left_time, mc_print_error_code, mc_print_line_number, mc_print_percent, mc_print_stage, mc_print_sub_stage, model_task, print_error, reset(), slice_info, subtask_, tray_exist_bits, tray_is_bbl_bits, upgrade_consistency_request, upgrade_force_upgrade, upgrade_new_version, VIRTUAL_TRAY_MAIN_ID, vt_slot, and wifi_signal.

Here is the call graph for this function:

~MachineObject()

Slic3r::MachineObject::~MachineObject

(

)

{
    if (subtask_) {
        delete subtask_;
        subtask_ = nullptr;
    }
 
    if (model_task) {
        delete model_task;
        model_task = nullptr;
    }
 
    free_slice_info();
 
    while (!m_command_error_code_dlgs.empty()) {
        delete *m_command_error_code_dlgs.begin();/*element will auto remove from m_command_error_code_dlgs on deleted*/
    }
 
    {
        delete m_lamp;
        m_lamp = nullptr;
 
        delete m_fan;
        m_fan  = nullptr;
 
        delete m_bed;
        m_bed = nullptr;
 
        delete m_extder_system;
        m_extder_system = nullptr;
 
        delete m_nozzle_system;
        m_nozzle_system = nullptr;
 
        delete m_ctrl;
        m_ctrl = nullptr;
 
 
        delete m_fila_switch;
        m_fila_switch = nullptr;
 
        delete m_hms_system;
        m_hms_system = nullptr;
 
        delete m_config;
        m_config = nullptr;
 
        delete m_print_options;
        m_print_options = nullptr;
 
        // Orca: adopt DeviceCore split
        delete m_calib;
        m_calib = nullptr;
 
        delete m_status;
        m_status = nullptr;
    }
}

References free_slice_info(), m_bed, m_calib, m_command_error_code_dlgs, m_config, m_ctrl, m_extder_system, m_fan, m_fila_switch, m_hms_system, m_lamp, m_nozzle_system, m_print_options, m_status, model_task, and subtask_.

Here is the call graph for this function:

Member Function Documentation

_parse_ams_status()

void Slic3r::MachineObject::_parse_ams_status

(

int

ams_status

)

{
    ams_status_sub = ams_status & 0xFF;
    int ams_status_main_int = (ams_status & 0xFF00) >> 8;
    if (ams_status_main_int == (int)AmsStatusMain::AMS_STATUS_MAIN_IDLE) {
        ams_status_main = AmsStatusMain::AMS_STATUS_MAIN_IDLE;
    } else if (ams_status_main_int == (int) AmsStatusMain::AMS_STATUS_MAIN_FILAMENT_CHANGE) {
        ams_status_main = AmsStatusMain::AMS_STATUS_MAIN_FILAMENT_CHANGE;
    } else if (ams_status_main_int == (int) AmsStatusMain::AMS_STATUS_MAIN_RFID_IDENTIFYING) {
        ams_status_main = AmsStatusMain::AMS_STATUS_MAIN_RFID_IDENTIFYING;
    } else if (ams_status_main_int == (int) AmsStatusMain::AMS_STATUS_MAIN_ASSIST) {
        ams_status_main = AmsStatusMain::AMS_STATUS_MAIN_ASSIST;
    } else if (ams_status_main_int == (int) AmsStatusMain::AMS_STATUS_MAIN_CALIBRATION) {
        ams_status_main = AmsStatusMain::AMS_STATUS_MAIN_CALIBRATION;
    } else if (ams_status_main_int == (int) AmsStatusMain::AMS_STATUS_MAIN_SELF_CHECK) {
        ams_status_main = AmsStatusMain::AMS_STATUS_MAIN_SELF_CHECK;
    } else if (ams_status_main_int == (int) AmsStatusMain::AMS_STATUS_MAIN_DEBUG) {
        ams_status_main = AmsStatusMain::AMS_STATUS_MAIN_DEBUG;
    } else if (ams_status_main_int == (int) AmsStatusMain::AMS_STATUS_MAIN_COLD_PULL) {
        ams_status_main = AmsStatusMain::AMS_STATUS_MAIN_COLD_PULL;
    } else {
        ams_status_main = AmsStatusMain::AMS_STATUS_MAIN_UNKNOWN;
    }
 
    BOOST_LOG_TRIVIAL(trace) << "ams_debug: main = " << ams_status_main_int << ", sub = " << ams_status_sub;
}

References ams_status_main, Slic3r::AMS_STATUS_MAIN_ASSIST, Slic3r::AMS_STATUS_MAIN_CALIBRATION, Slic3r::AMS_STATUS_MAIN_COLD_PULL, Slic3r::AMS_STATUS_MAIN_DEBUG, Slic3r::AMS_STATUS_MAIN_FILAMENT_CHANGE, Slic3r::AMS_STATUS_MAIN_IDLE, Slic3r::AMS_STATUS_MAIN_RFID_IDENTIFYING, Slic3r::AMS_STATUS_MAIN_SELF_CHECK, Slic3r::AMS_STATUS_MAIN_UNKNOWN, ams_status_sub, and Slic3r::trace().

Referenced by parse_json().

Here is the call graph for this function:

Here is the caller graph for this function:

add_command_error_code_dlg()

void Slic3r::MachineObject::add_command_error_code_dlg	(	int	command_err,
		nlohmann::json	action_json = nlohmann::json{} )

{
    if (command_err > 0 && !Slic3r::GUI::wxGetApp().get_hms_query()->is_internal_error(this, command_err))
    {
        GUI::wxGetApp().CallAfter([this, command_err, action_json, token = std::weak_ptr<int>(m_token)]
        {
            if (token.expired()) { return;}
            GUI::DeviceErrorDialog* device_error_dialog = new GUI::DeviceErrorDialog(this, (wxWindow*)GUI::wxGetApp().mainframe);
            device_error_dialog->Bind(wxEVT_DESTROY, [this, token = std::weak_ptr<int>(m_token)](auto& event)
                {
                    if (!token.expired()) { m_command_error_code_dlgs.erase((GUI::DeviceErrorDialog*)event.GetEventObject());}
                    event.Skip();
                });
 
            if(!action_json.is_null()) device_error_dialog->set_action_json(action_json);
            device_error_dialog->show_error_code(command_err);
            m_command_error_code_dlgs.insert(device_error_dialog);
        });
    };
}

References m_command_error_code_dlgs, m_token, Slic3r::GUI::DeviceErrorDialog::set_action_json(), and Slic3r::GUI::DeviceErrorDialog::show_error_code().

Referenced by parse_json().

Here is the call graph for this function:

Here is the caller graph for this function:

any_loaded_filament_is_stringing_prone()

bool Slic3r::MachineObject::any_loaded_filament_is_stringing_prone

(

)

const

{
    if (print_job_filament_mapping.empty()) return false;
 
    std::vector<float> nozzle_diameters;
    if (m_extder_system) {
        for (const auto& ext : m_extder_system->GetExtruders()) {
            const float d = ext.GetNozzleDiameter();
            if (d > 0.f) nozzle_diameters.push_back(d);
        }
    }
    if (nozzle_diameters.empty()) return false;
 
    for (uint16_t v : print_job_filament_mapping) {
        if (v == 0xFFFF) continue;
        const int ams_id  = (v >> 8) & 0xFF;
        const int slot_id = v & 0xFF;
        const std::string fid = this->get_filament_id(std::to_string(ams_id), std::to_string(slot_id));
        if (fid.empty()) continue;
        for (float d : nozzle_diameters) {
            if (Slic3r::is_stringing_prone_filament(fid, d))
                return true;
        }
    }
    return false;
}

References get_filament_id(), Slic3r::is_stringing_prone_filament(), m_extder_system, and print_job_filament_mapping.

Here is the call graph for this function:

can_abort()

bool Slic3r::MachineObject::can_abort

(

)

{
    return MachineObject::is_in_printing_status(print_status);
}

References is_in_printing_status(), and print_status.

Referenced by is_sdcard_printing(), and Slic3r::GUI::MachineInfoPanel::update().

Here is the call graph for this function:

Here is the caller graph for this function:

can_pause()

bool Slic3r::MachineObject::can_pause

(

)

{
    if (print_status.compare("RUNNING") == 0)
        return true;
    return false;
}

References print_status.

can_print()

bool Slic3r::MachineObject::can_print

(

)

{
    if (print_status.compare("RUNNING") == 0) {
        return false;
    }
    if (print_status.compare("IDLE") == 0 || print_status.compare("FINISH") == 0) {
        return true;
    }
    return true;
}

References print_status.

can_resume()

bool Slic3r::MachineObject::can_resume

(

)

{
    if (print_status.compare("PAUSE") == 0)
        return true;
    return false;
}

References print_status.

Referenced by Slic3r::GUI::CalibrationCaliPage::on_subtask_pause_resume(), and Slic3r::GUI::CalibrationCaliPage::update_subtask().

Here is the caller graph for this function:

can_unload_filament()

bool Slic3r::MachineObject::can_unload_filament

(

)

{
    bool result = false;
    if (!HasAms())
        return true;
 
    if (ams_status_main == AMS_STATUS_MAIN_IDLE && hw_switch_state == 1 && m_extder_system->GetCurrentAmsId() == "255") {
        return true;
    }
    return result;
}

References ams_status_main, Slic3r::AMS_STATUS_MAIN_IDLE, HasAms(), hw_switch_state, and m_extder_system.

Here is the call graph for this function:

can_use_emmc_print()

bool Slic3r::MachineObject::can_use_emmc_print

(

)

const

{
    AppConfig* config = GUI::wxGetApp().app_config;
    std::string disable_emmc_print = config ? config->get("disable_emmc_print") : "true";
    return is_support_print_with_emmc && (disable_emmc_print == "0" || disable_emmc_print == "false");
}

References Slic3r::AppConfig::get(), and is_support_print_with_emmc.

Referenced by Slic3r::GUI::SelectMachineDialog::on_send_print(), Slic3r::GUI::CalibUtils::send_to_print(), Slic3r::GUI::CalibUtils::send_to_print(), and Slic3r::GUI::SelectMachineDialog::update_show_status().

Here is the call graph for this function:

Here is the caller graph for this function:

canEnableTimelapse()

bool Slic3r::MachineObject::canEnableTimelapse

(

wxString &

error_message

)

const

{
    if (!is_support_timelapse) {
        error_message = _L("Timelapse is not supported on this printer.");
        return false;
    }
 
    if (is_support_internal_timelapse)
    {
        return true;
    }
 
    if (m_storage->get_sdcard_state() != DevStorage::SdcardState::HAS_SDCARD_NORMAL && !m_has_timelapse_kit) {
        if (m_storage->get_sdcard_state() == DevStorage::SdcardState::NO_SDCARD) {
            error_message = _L("Timelapse is not supported while the storage does not exist.");
        } else if (m_storage->get_sdcard_state() == DevStorage::SdcardState::HAS_SDCARD_ABNORMAL) {
            error_message = _L("Timelapse is not supported while the storage is unavailable.");
        } else if (m_storage->get_sdcard_state() == DevStorage::SdcardState::HAS_SDCARD_READONLY) {
            error_message = _L("Timelapse is not supported while the storage is readonly.");
        }
 
        return false;
    }
 
    return true;
}

References _L, Slic3r::DevStorage::HAS_SDCARD_ABNORMAL, Slic3r::DevStorage::HAS_SDCARD_NORMAL, Slic3r::DevStorage::HAS_SDCARD_READONLY, is_support_internal_timelapse, is_support_timelapse, m_has_timelapse_kit, m_storage, and Slic3r::DevStorage::NO_SDCARD.

Referenced by Slic3r::GUI::SelectMachineDialog::load_option_vals().

Here is the caller graph for this function:

check_ams_filament_valid()

void Slic3r::MachineObject::check_ams_filament_valid

(

)

{
    PresetBundle * preset_bundle = Slic3r::GUI::wxGetApp().preset_bundle;
    // A tray id carried by ANY system filament preset is not a dangling user-preset id
    // (ten shipped P-hex system ids pass the 'P' shape gates below), so the destructive
    // tray-wipe / temp-rewrite handling must never fire for it.
    auto is_system_filament_id = [preset_bundle](const std::string &id) {
        if (!preset_bundle)
            return false;
        for (auto it = preset_bundle->filaments.begin(); it != preset_bundle->filaments.end(); it++)
            if (it->is_system && it->filament_id == id)
                return true;
        return false;
    };
    auto printer_model = DevPrinterConfigUtil::get_printer_display_name(this->printer_type);
    std::map<std::string, std::set<std::string>> need_checked_filament_id;
    for (auto &ams_pair : m_fila_system->GetAmsList()) {
        auto ams_id = ams_pair.first;
        auto &ams = ams_pair.second;
        std::ostringstream stream;
        if (ams->GetExtruderId() < 0 || ams->GetExtruderId() >= m_extder_system->GetTotalExtderCount()) {
            return;
        }
        stream << std::fixed << std::setprecision(1) << m_extder_system->GetNozzleDiameter(ams->GetExtruderId());
        std::string nozzle_diameter_str = stream.str();
        assert(nozzle_diameter_str.size() == 3);
        if (m_nozzle_filament_data.find(nozzle_diameter_str) == m_nozzle_filament_data.end()) {
            //assert(false);
            continue;
        }
        auto &data = m_nozzle_filament_data[nozzle_diameter_str];
        auto &filament_list = data.filament_list;
        auto &checked_filament = data.checked_filament;
        for (const auto &[slot_id, curr_tray] : ams->GetTrays()) {
 
            if (curr_tray->setting_id.size() == 8 && curr_tray->setting_id[0] == 'P' && is_system_filament_id(curr_tray->setting_id))
                continue;
            if (curr_tray->setting_id.size() == 8 && curr_tray->setting_id[0] == 'P' && filament_list.find(curr_tray->setting_id) == filament_list.end()) {
                if (checked_filament.find(curr_tray->setting_id) != checked_filament.end()) {
                    need_checked_filament_id[nozzle_diameter_str].insert(curr_tray->setting_id);
                    wxColour color = *wxWHITE;
                    char     col_buf[10];
                    sprintf(col_buf, "%02X%02X%02XFF", (int) color.Red(), (int) color.Green(), (int) color.Blue());
                    try {
                        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " " << __LINE__ << " ams settings_id is not exist in filament_list and reset, ams_id: " << ams_id << " tray_id"
                                                << slot_id << "filament_id: " << curr_tray->setting_id;
 
                        command_ams_filament_settings(std::stoi(ams_id), std::stoi(slot_id), "", "", std::string(col_buf), "", 0, 0);
                        continue;
                    } catch (...) {
                        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " " << __LINE__ << " stoi error and ams_id: " << ams_id << " tray_id" << slot_id;
                    }
                }
            }
            if (curr_tray->setting_id.size() == 8 && curr_tray->setting_id[0] == 'P' && curr_tray->nozzle_temp_min != "" && curr_tray->nozzle_temp_max != "") {
                if (checked_filament.find(curr_tray->setting_id) != checked_filament.end()) {
                    need_checked_filament_id[nozzle_diameter_str].insert(curr_tray->setting_id);
                    try {
                        std::string preset_setting_id;
                        const int   extruder_id = ams->GetExtruderId();
                        bool        is_equation = preset_bundle->check_filament_temp_equation_by_printer_type_and_nozzle_for_mas_tray(printer_model, nozzle_diameter_str,
                                                                                                                               curr_tray->setting_id, curr_tray->tag_uid,
                                                                                                                               curr_tray->nozzle_temp_min,
                                                                                                                               curr_tray->nozzle_temp_max, preset_setting_id,
                                                                                                                               get_preset_extruder_index(extruder_id),
                                                                                                                               DevNozzle::ToNozzleVolumeType(m_extder_system->GetNozzleFlowType(extruder_id)));
                        if (!is_equation) {
                            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " " << __LINE__ << " ams filament is not match min max temp and reset, ams_id: " << ams_id << " tray_id"
                                                    << slot_id << "filament_id: " << curr_tray->setting_id;
 
 
                            command_ams_filament_settings(std::stoi(ams_id), std::stoi(slot_id), curr_tray->setting_id, preset_setting_id, curr_tray->color, curr_tray->m_fila_type,
                                                          std::stoi(curr_tray->nozzle_temp_min), std::stoi(curr_tray->nozzle_temp_max));
                        }
                        continue;
                    } catch (...) {
                        BOOST_LOG_TRIVIAL(info) << "check fail and curr_tray ams_id" << ams_id << " curr_tray tray_id" << slot_id;
                    }
                }
            }
        }
    }
 
    for (auto vt_tray : vt_slot) {
        int vt_id = std::stoi(vt_tray.id);
        int index = 255 - vt_id;
        if (index >= m_extder_system->GetTotalExtderCount()) {
            BOOST_LOG_TRIVIAL(error) << " vt_tray id map for nozzle id is not exist, index is: " << index << " nozzle count" << m_extder_system->GetTotalExtderCount();
            continue;
        }
        auto diameter = m_extder_system->GetNozzleDiameter(index);
        std::ostringstream stream;
        stream << std::fixed << std::setprecision(1) << diameter;
        std::string nozzle_diameter_str = stream.str();
        if (m_nozzle_filament_data.find(nozzle_diameter_str) == m_nozzle_filament_data.end()) {
            continue;
        }
        auto &data = m_nozzle_filament_data[nozzle_diameter_str];
        auto &checked_filament = data.checked_filament;
        auto &filament_list    = data.filament_list;
        if (vt_tray.setting_id.size() == 8 && vt_tray.setting_id[0] == 'P' && is_system_filament_id(vt_tray.setting_id))
            continue;
        if (vt_tray.setting_id.size() == 8 && vt_tray.setting_id[0] == 'P' && filament_list.find(vt_tray.setting_id) == filament_list.end()) {
            if (checked_filament.find(vt_tray.setting_id) != checked_filament.end()) {
                need_checked_filament_id[nozzle_diameter_str].insert(vt_tray.setting_id);
                wxColour color = *wxWHITE;
                char     col_buf[10];
                sprintf(col_buf, "%02X%02X%02XFF", (int) color.Red(), (int) color.Green(), (int) color.Blue());
                try {
                    BOOST_LOG_TRIVIAL(info) << "vt_tray.setting_id is not exist in filament_list and reset vt_tray and the filament_id is: " << vt_tray.setting_id;
                    command_ams_filament_settings(vt_id, 0, "", "", std::string(col_buf), "", 0, 0);
                    continue;
                } catch (...) {
                    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " " << __LINE__ << " stoi error and tray_id" << vt_tray.id;
                }
            }
        }
        if (vt_tray.setting_id.size() == 8 && vt_tray.setting_id[0] == 'P' && vt_tray.nozzle_temp_min != "" && vt_tray.nozzle_temp_max != "") {
            if (checked_filament.find(vt_tray.setting_id) != checked_filament.end()) {
                need_checked_filament_id[nozzle_diameter_str].insert(vt_tray.setting_id);
                try {
                    std::string        preset_setting_id;
                    PresetBundle *     preset_bundle = Slic3r::GUI::wxGetApp().preset_bundle;
                    std::ostringstream stream;
                    stream << std::fixed << std::setprecision(1) << m_extder_system->GetNozzleDiameter(MAIN_EXTRUDER_ID);
                    std::string nozzle_diameter_str = stream.str();
                    bool        is_equation = preset_bundle->check_filament_temp_equation_by_printer_type_and_nozzle_for_mas_tray(DevPrinterConfigUtil::get_printer_display_name(
                                                                                                                               this->printer_type),
                                                                                                                           nozzle_diameter_str, vt_tray.setting_id,
                                                                                                                           vt_tray.tag_uid, vt_tray.nozzle_temp_min,
                                                                                                                           vt_tray.nozzle_temp_max, preset_setting_id,
                                                                                                                           get_preset_extruder_index(index),
                                                                                                                           DevNozzle::ToNozzleVolumeType(m_extder_system->GetNozzleFlowType(index)));
                    if (!is_equation) {
                        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " " << __LINE__
                                                << " vt_tray filament is not match min max temp and reset, filament_id: " << vt_tray.setting_id;
                        command_ams_filament_settings(vt_id, 0, vt_tray.setting_id, preset_setting_id, vt_tray.color, vt_tray.m_fila_type, std::stoi(vt_tray.nozzle_temp_min),
                                                          std::stoi(vt_tray.nozzle_temp_max));
 
                    }
                } catch (...) {
                    BOOST_LOG_TRIVIAL(info) << "check fail and vt_tray.id" << vt_tray.id;
                }
            }
        }
    }
 
    for (auto &diameter_pair : m_nozzle_filament_data) {
        auto &diameter = diameter_pair.first;
        auto &data     = diameter_pair.second;
        for (auto &filament_id : need_checked_filament_id[diameter]) {
            data.checked_filament.erase(filament_id);
        }
    }
}

References Slic3r::PresetCollection::begin(), Slic3r::PresetBundle::check_filament_temp_equation_by_printer_type_and_nozzle_for_mas_tray(), command_ams_filament_settings(), Slic3r::PresetCollection::end(), Slic3r::PresetBundle::filaments, get_preset_extruder_index(), Slic3r::DevPrinterConfigUtil::get_printer_display_name(), m_extder_system, m_fila_system, m_nozzle_filament_data, MAIN_EXTRUDER_ID, printer_type, Slic3r::DevNozzle::ToNozzleVolumeType(), and vt_slot.

Here is the call graph for this function:

check_enable_np()

bool Slic3r::MachineObject::check_enable_np

(

const nlohmann::json &

print

)

const

{
    if (print.contains("cfg") && print.contains("fun") && print.contains("aux") && print.contains("stat"))
    {
        return true;
    }
 
    return false;
}

Referenced by parse_json(), and parse_new_info().

Here is the caller graph for this function:

check_pa_result_validation()

bool Slic3r::MachineObject::check_pa_result_validation

(

PACalibResult &

result

)

{
    if (result.k_value < 0 || result.k_value > 10)
        return false;
 
    return true;
}

References Slic3r::PACalibResult::k_value.

Referenced by parse_json().

Here is the caller graph for this function:

check_resume_condition()

int Slic3r::MachineObject::check_resume_condition

(

)

{
    if (jobState_ > 1) {
        GUI::wxGetApp().show_dialog(_L("To ensure your safety, certain processing tasks (such as laser) can only be resumed on printer."));
        return 1;
    }
    return 0;
}

References _L, and jobState_.

Referenced by command_ams_control(), command_hms_idle_ignore(), command_hms_ignore(), command_hms_resume(), and command_task_resume().

Here is the caller graph for this function:

check_version_valid()

bool Slic3r::MachineObject::check_version_valid

(

)

{
    bool valid = true;
    for (auto module : module_vers) {
        if (module.second.sn.empty()
            && module.first != "ota"
            && module.first != "xm")
            return false;
        if (module.second.sw_ver.empty())
            return false;
    }
    get_version_retry = 0;
    return valid;
}

References get_version_retry, Slic3r::module(), and module_vers.

Referenced by parse_json().

Here is the call graph for this function:

Here is the caller graph for this function:

clear_auto_nozzle_mapping()

void Slic3r::MachineObject::clear_auto_nozzle_mapping

(

)

{
    if (m_nozzle_mapping_ptr) {
        m_nozzle_mapping_ptr->Clear();
    }
}

References m_nozzle_mapping_ptr.

Referenced by reset().

Here is the caller graph for this function:

clear_version_info()

void Slic3r::MachineObject::clear_version_info

(

)

{
    air_pump_version_info = DevFirmwareVersionInfo();
    laser_version_info = DevFirmwareVersionInfo();
    cutting_module_version_info = DevFirmwareVersionInfo();
    extinguish_version_info = DevFirmwareVersionInfo();
    rotary_version_info = DevFirmwareVersionInfo();
    exhaustfan_version_info = DevFirmwareVersionInfo();
    amshub_version_info = DevFirmwareVersionInfo();
    filatrack_version_info = DevFirmwareVersionInfo();
    module_vers.clear();
    // Drop cached rack-hotend (WTM) firmware alongside the module list.
    // Inert for non-rack printers (rack firmware map is empty).
    m_nozzle_system->ClearFirmwareInfoWTM();
}

References air_pump_version_info, amshub_version_info, cutting_module_version_info, exhaustfan_version_info, extinguish_version_info, filatrack_version_info, laser_version_info, m_nozzle_system, module_vers, and rotary_version_info.

Referenced by parse_json().

Here is the caller graph for this function:

cloud_publish_json()

int Slic3r::MachineObject::cloud_publish_json	(	std::string	json_str,
		int	qos = 0,
		int	flag = 0 )

{
    int result = -1;
    if (m_agent)
        result = m_agent->send_message(get_dev_id(), json_str, qos, flag);
 
    return result;
}

References get_dev_id(), and m_agent.

Referenced by publish_json().

Here is the call graph for this function:

Here is the caller graph for this function:

command_ack_proceed()

int Slic3r::MachineObject::command_ack_proceed

(

nlohmann::json &

proceed

)

                                                    {
    if (proceed["command"].empty()) return -1;
 
    proceed["err_code"] = 0;
    if (proceed.contains("err_ignored")) {
        proceed["err_ignored"].push_back(proceed["err_index"]);
    } else {
        proceed["err_ignored"] = std::vector<int>{proceed["err_index"]};
    }
 
    for (auto& item : proceed["err_ignored"]) {
        json error_item;
        error_item["idx"] = item.get<int>();
        error_item["mode"] = 0;
        proceed["rm_idx"].push_back(error_item);
    }
 
    proceed["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
 
    json j;
    j["print"] = proceed;
    return this->publish_json(j);
}

References Slic3r::empty(), m_sequence_id, and publish_json().

Here is the call graph for this function:

command_ams_air_print_detect()

int Slic3r::MachineObject::command_ams_air_print_detect

(

bool

air_print_detect

)

{
    json j;
    j["print"]["command"] = "print_option";
    j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
    j["print"]["air_print_detect"] = air_print_detect;
 
    ams_air_print_status = air_print_detect;
    BOOST_LOG_TRIVIAL(trace) << "command_ams_air_print_detect:" << air_print_detect;
 
    return this->publish_json(j);
}

References ams_air_print_status, m_sequence_id, publish_json(), and Slic3r::trace().

Here is the call graph for this function:

command_ams_calibrate()

int Slic3r::MachineObject::command_ams_calibrate

(

int

ams_id

)

{
    if (!m_agent) return -1;
    return command_with_dialog(m_agent->command_ams_calibrate(get_dev_id(), ams_id, MachineObject::m_sequence_id++, is_lan_mode_printer()));
}

References command_with_dialog(), get_dev_id(), is_lan_mode_printer(), m_agent, and m_sequence_id.

Here is the call graph for this function:

command_ams_change_filament()

int Slic3r::MachineObject::command_ams_change_filament	(	bool	load,
		std::string	ams_id,
		std::string	slot_id,
		int	old_temp = 210,
		int	new_temp = 210,
		std::optional< int >	extruder_id = std::nullopt )

{
    json j;
    try {
        auto tray_id = 0;
        if (atoi(ams_id.c_str()) < 16) {
            tray_id = atoi(ams_id.c_str()) * 4 + atoi(slot_id.c_str());
        }
        // TODO: Orca hack
        if (ams_id == "254")
            ams_id = "255";
 
        j["print"]["command"]     = "ams_change_filament";
        j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
        j["print"]["curr_temp"]   = old_temp;
        j["print"]["tar_temp"]    = new_temp;
        j["print"]["ams_id"]      = atoi(ams_id.c_str());
 
        if (!load) {
            j["print"]["target"]  = 255;
            j["print"]["slot_id"] = 255; // the new protocol to mark unload
 
        } else {
            if (tray_id == 0) {
                j["print"]["target"]  = atoi(ams_id.c_str());
            } else {
                j["print"]["target"]  = tray_id;
            }
 
            j["print"]["slot_id"] = atoi(slot_id.c_str());
        }
 
        // Filament Track Switch: route the load to the chosen extruder. Only present when the
        // caller supplied a value (FTS-installed+ready path), so every other caller is unchanged.
        if (extruder_id.has_value())
        {
            j["print"]["extruder_id"] = *extruder_id;
        }
 
    } catch (const std::exception &) {}
    return this->publish_json(j);
}

References load(), m_sequence_id, and publish_json().

Referenced by Slic3r::GUI::AMSDryCtrWin::create_cannot_dry_panel().

Here is the call graph for this function:

Here is the caller graph for this function:

command_ams_control()

int Slic3r::MachineObject::command_ams_control

(

std::string

action

)

{
    if (action == "resume" && check_resume_condition()) return 0;
 
    //valid actions
    if (action == "resume" || action == "reset" || action == "pause" || action == "done" || action == "abort") {
        json j;
        j["print"]["command"] = "ams_control";
        j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
        j["print"]["param"] = action;
        return this->publish_json(j);
    }
    return -1;
}

References check_resume_condition(), m_sequence_id, and publish_json().

Here is the call graph for this function:

command_ams_drying_stop()

int Slic3r::MachineObject::command_ams_drying_stop

(

)

{
    json j;
    j["print"]["command"] = "auto_stop_ams_dry";
    j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
    return this->publish_json(j);
}

References m_sequence_id, and publish_json().

Here is the call graph for this function:

command_ams_filament_settings()

int Slic3r::MachineObject::command_ams_filament_settings	(	int	ams_id,
		int	slot_id,
		std::string	filament_id,
		std::string	setting_id,
		std::string	tray_color,
		std::string	tray_type,
		int	nozzle_temp_min,
		int	nozzle_temp_max,
		const std::vector< std::string > &	tray_colors = {},
		int	tray_ctype = 2 )

{
    int tag_tray_id = 0;
    int tag_ams_id  = ams_id;
    int tag_slot_id = slot_id;
 
    if (tag_ams_id == VIRTUAL_TRAY_MAIN_ID || tag_ams_id == VIRTUAL_TRAY_DEPUTY_ID) {
        tag_tray_id = VIRTUAL_TRAY_DEPUTY_ID;
    } else {
        tag_tray_id = tag_slot_id;
    }
 
 
    BOOST_LOG_TRIVIAL(info) << "command_ams_filament_settings, ams_id = " << tag_ams_id << ", slot_id = " << tag_slot_id << ", tray_id = " << tag_tray_id << ", tray_color = " << tray_color
                            << ", tray_type = " << tray_type << ", filament_id = " << filament_id
                            << ", setting_id = " << setting_id << ", temp_min: = " << nozzle_temp_min << ", temp_max: = " << nozzle_temp_max;
    json j;
    j["print"]["command"]       = "ams_filament_setting";
    j["print"]["sequence_id"]   = std::to_string(MachineObject::m_sequence_id++);
    j["print"]["ams_id"]        = tag_ams_id;
    j["print"]["slot_id"]       = tag_slot_id;
    j["print"]["tray_id"]       = tag_tray_id;
    j["print"]["tray_info_idx"] = filament_id;
    j["print"]["setting_id"]    = setting_id;
    // format "FFFFFFFF"   RGBA
    j["print"]["tray_color"]        = tray_color;
    j["print"]["nozzle_temp_min"]   = nozzle_temp_min;
    j["print"]["nozzle_temp_max"]   = nozzle_temp_max;
    j["print"]["tray_type"]         = tray_type;
    if (!tray_colors.empty()) {
        j["print"]["cols"]  = tray_colors;
        j["print"]["ctype"] = tray_ctype;
    }
 
    return this->publish_json(j);
}

References m_sequence_id, publish_json(), VIRTUAL_TRAY_DEPUTY_ID, and VIRTUAL_TRAY_MAIN_ID.

Referenced by check_ams_filament_valid().

Here is the call graph for this function:

Here is the caller graph for this function:

command_ams_refresh_rfid()

int Slic3r::MachineObject::command_ams_refresh_rfid	(	int	ams_id,
		int	slot_id )

{
    if (!m_agent) return -1;
    return command_with_dialog(m_agent->command_ams_refresh_rfid(get_dev_id(), ams_id, slot_id, MachineObject::m_sequence_id++, is_lan_mode_printer()));
}

References command_with_dialog(), get_dev_id(), is_lan_mode_printer(), m_agent, and m_sequence_id.

Here is the call graph for this function:

command_ams_select_tray()

int Slic3r::MachineObject::command_ams_select_tray

(

std::string

tray_id

)

{
    if (!m_agent) return -1;
    return command_with_dialog(m_agent->command_ams_select_tray(get_dev_id(), tray_id, MachineObject::m_sequence_id++, is_lan_mode_printer()));
}

References command_with_dialog(), get_dev_id(), is_lan_mode_printer(), m_agent, and m_sequence_id.

Here is the call graph for this function:

command_ams_switch_filament()

int Slic3r::MachineObject::command_ams_switch_filament

(

bool

switch_filament

)

{
    json j;
    j["print"]["command"] = "print_option";
    j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
    j["print"]["auto_switch_filament"] = switch_filament;
 
    m_fila_system->GetAmsSystemSetting().SetAutoRefillEnabled(switch_filament);
    BOOST_LOG_TRIVIAL(trace) << "command_ams_filament_settings:" << switch_filament;
    ams_switch_filament_start = time(nullptr);
 
    return this->publish_json(j);
}

References ams_switch_filament_start, m_fila_system, m_sequence_id, publish_json(), and Slic3r::trace().

Here is the call graph for this function:

command_ams_user_settings()

int Slic3r::MachineObject::command_ams_user_settings	(	bool	start_read_opt,
		bool	tray_read_opt,
		bool	remain_flag = false )

{
    json j;
    j["print"]["command"] = "ams_user_setting";
    j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
    j["print"]["ams_id"] = -1; // all ams
    j["print"]["startup_read_option"]   = start_read_opt;
    j["print"]["tray_read_option"]      = tray_read_opt;
    j["print"]["calibrate_remain_flag"] = remain_flag;
 
    m_fila_system->GetAmsSystemSetting().SetDetectOnInsertEnabled(tray_read_opt);
    m_fila_system->GetAmsSystemSetting().SetDetectOnPowerupEnabled(start_read_opt);
    m_fila_system->GetAmsSystemSetting().SetDetectRemainEnabled(remain_flag);
    ams_user_setting_start = time(nullptr);
 
    return this->publish_json(j);
}

References ams_user_setting_start, m_fila_system, m_sequence_id, and publish_json().

Here is the call graph for this function:

command_auto_leveling()

int Slic3r::MachineObject::command_auto_leveling

(

)

{
    if (!m_agent) return -1;
    return command_with_dialog(m_agent->command_auto_leveling(get_dev_id(), MachineObject::m_sequence_id++, is_lan_mode_printer()));
}

References command_with_dialog(), get_dev_id(), is_lan_mode_printer(), m_agent, and m_sequence_id.

Here is the call graph for this function:

command_axis_control()

int Slic3r::MachineObject::command_axis_control	(	std::string	axis,
		double	unit = 1.0f,
		double	input_val = 1.0f,
		int	speed = 3000 )

{
    if (!m_agent) return -1;
    return command_with_dialog(m_agent->command_axis_control(get_dev_id(), axis, unit, input_val, speed, is_core_xy(),
                                                             m_support_mqtt_axis_control, MachineObject::m_sequence_id++,
                                                             is_lan_mode_printer()));
}

References command_with_dialog(), get_dev_id(), is_core_xy(), is_lan_mode_printer(), m_agent, m_sequence_id, and m_support_mqtt_axis_control.

Here is the call graph for this function:

command_clean_print_error()

int Slic3r::MachineObject::command_clean_print_error	(	std::string	task_id,
		int	print_error )

{
    BOOST_LOG_TRIVIAL(info) << "command_clean_print_error, id = " << subtask_id;
    json j;
    j["print"]["command"] = "clean_print_error";
    j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
    j["print"]["subtask_id"] = subtask_id;
    j["print"]["print_error"] = print_error;
 
    return this->publish_json(j);
}

References m_sequence_id, print_error, and publish_json().

Here is the call graph for this function:

command_clean_print_error_uiop()

int Slic3r::MachineObject::command_clean_print_error_uiop

(

int

print_error

)

{
    json j;
    j["system"]["command"] = "uiop";
    j["system"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
    j["system"]["name"] = "print_error";
    j["system"]["action"] = "close";
    j["system"]["source"] = 1;// 0-Mushu 1-Studio
    j["system"]["type"] = "dialog";
 
    // the error to be cleaned
    char buf[32];
    ::sprintf(buf, "%08X", print_error);
    j["system"]["err"] = std::string(buf);
 
    return this->publish_json(j);
}

References m_sequence_id, print_error, and publish_json().

Here is the call graph for this function:

command_consistency_upgrade_confirm()

int Slic3r::MachineObject::command_consistency_upgrade_confirm

(

)

{
    BOOST_LOG_TRIVIAL(info) << "command_consistency_upgrade_confirm";
    json j;
    j["upgrade"]["command"] = "consistency_confirm";
    j["upgrade"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
    j["upgrade"]["src_id"] = 1; // 1 for slicer
    return this->publish_json(j);
}

References m_sequence_id, and publish_json().

Here is the call graph for this function:

command_delete_pa_calibration()

int Slic3r::MachineObject::command_delete_pa_calibration

(

const PACalibIndexInfo &

pa_calib

)

{
    json j;
    j["print"]["command"]         = "extrusion_cali_del";
    j["print"]["sequence_id"]     = std::to_string(MachineObject::m_sequence_id++);
    j["print"]["extruder_id"]     = pa_calib.extruder_id;
    j["print"]["nozzle_id"]       = _generate_nozzle_id(pa_calib.nozzle_volume_type, to_string_nozzle_diameter(pa_calib.nozzle_diameter)).ToStdString();
    j["print"]["filament_id"]     = pa_calib.filament_id;
    j["print"]["cali_idx"]        = pa_calib.cali_idx;
    if (pa_calib.nozzle_pos_id >= 0) {
        j["print"]["nozzle_pos"] = pa_calib.nozzle_pos_id;
        j["print"]["nozzle_sn"]  = pa_calib.nozzle_sn;
    }
    j["print"]["nozzle_diameter"] = to_string_nozzle_diameter(pa_calib.nozzle_diameter);
 
    BOOST_LOG_TRIVIAL(info) << "extrusion_cali_del: " << j.dump();
    return this->publish_json(j);
}

References Slic3r::_generate_nozzle_id(), Slic3r::PACalibIndexInfo::cali_idx, Slic3r::PACalibIndexInfo::extruder_id, Slic3r::PACalibIndexInfo::filament_id, m_sequence_id, Slic3r::PACalibIndexInfo::nozzle_diameter, Slic3r::PACalibIndexInfo::nozzle_pos_id, Slic3r::PACalibIndexInfo::nozzle_sn, Slic3r::PACalibIndexInfo::nozzle_volume_type, publish_json(), and to_string_nozzle_diameter().

Referenced by Slic3r::GUI::CalibUtils::delete_PA_calib_result().

Here is the call graph for this function:

Here is the caller graph for this function:

command_dont_remind_next_time()

int Slic3r::MachineObject::command_dont_remind_next_time

(

nlohmann::json &

mqtt_guard_json

)

{
    if (!mqtt_guard_json.contains("command") ||
        !mqtt_guard_json.contains("err_index") ||
        mqtt_guard_json["err_index"].empty()) return -1;
 
    json j;
    j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
 
    try {
        j["print"]["command"] = mqtt_guard_json["command"].get<std::string>();
        int err_index = mqtt_guard_json["err_index"].get<int>();
 
        if (mqtt_guard_json.contains("err_ignored") &&
            mqtt_guard_json["err_ignored"].is_array()) {
            j["print"]["err_ignored"] = mqtt_guard_json["err_ignored"];
            j["print"]["err_ignored"].push_back(err_index);
        } else {
            j["print"]["err_ignored"] = std::vector<int>{err_index};
        }
 
        for (auto& item : j["print"]["err_ignored"]) {
            if (!item.is_number_integer()) continue;
 
            json item_json;
            item_json["idx"] = item.get<int>();
            item_json["mode"] = 1; // 1-next time ignore, 2-always ignore
            j["print"]["rm_idx"].push_back(item_json);
        }
    } catch (const json::exception& e) {
        BOOST_LOG_TRIVIAL(error) << "JSON parsing error in command_dont_remind_next_time: " << e.what();
        return -1;
    }
 
    return this->publish_json(j, 1);
}

References m_sequence_id, and publish_json().

Here is the call graph for this function:

command_extruder_control()

int Slic3r::MachineObject::command_extruder_control	(	int	nozzle_id,
		double	val )

{
    json j;
    j["print"]["command"]     = "set_extrusion_length";
    j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
    j["print"]["extruder_index"] = nozzle_id;
    j["print"]["length"] = (int)val;
    return this->publish_json(j);
}

References m_sequence_id, and publish_json().

Here is the call graph for this function:

command_extrusion_cali_set()

int Slic3r::MachineObject::command_extrusion_cali_set	(	int	tray_index,
		std::string	setting_id,
		std::string	name,
		float	k,
		float	n,
		int	bed_temp = -1,
		int	nozzle_temp = -1,
		float	max_volumetric_speed = -1 )

{
    BOOST_LOG_TRIVIAL(trace) << "extrusion_cali: tray_id = " << tray_index << ", setting_id = " << setting_id << ", k = " << k
                            << ", n = " << n;
    json j;
    j["print"]["command"] = "extrusion_cali_set";
    j["print"]["sequence_id"]   = std::to_string(MachineObject::m_sequence_id++);
    j["print"]["tray_id"]       = tray_index;
    //j["print"]["setting_id"]    = setting_id;
    //j["print"]["name"]          = name;
    j["print"]["k_value"]       = k;
    j["print"]["n_coef"]        = 1.4f;     // fixed n
    //j["print"]["n_coef"]        = n;
    if (bed_temp >= 0 && nozzle_temp >= 0 && max_volumetric_speed >= 0) {
        j["print"]["bed_temp"]      = bed_temp;
        j["print"]["nozzle_temp"]   = nozzle_temp;
        j["print"]["max_volumetric_speed"] = max_volumetric_speed;
    }
    return this->publish_json(j);
}

References m_sequence_id, publish_json(), and Slic3r::trace().

Here is the call graph for this function:

command_get_access_code()

int Slic3r::MachineObject::command_get_access_code

(

)

                                           {
    BOOST_LOG_TRIVIAL(info) << "command_get_access_code";
    json j;
    j["system"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
    j["system"]["command"] = "get_access_code";
 
    return this->publish_json(j);
}

References m_sequence_id, and publish_json().

Here is the call graph for this function:

command_get_flow_ratio_calibration_result()

int Slic3r::MachineObject::command_get_flow_ratio_calibration_result

(

float

nozzle_diameter

)

{
    json j;
    j["print"]["command"]         = "flowrate_get_result";
    j["print"]["sequence_id"]     = std::to_string(MachineObject::m_sequence_id++);
    j["print"]["nozzle_diameter"] = to_string_nozzle_diameter(nozzle_diameter);
 
    BOOST_LOG_TRIVIAL(info) << "flowrate_get_result: " << j.dump();
    return this->publish_json(j);
}

References m_sequence_id, Slic3r::nozzle_diameter(), publish_json(), and to_string_nozzle_diameter().

Referenced by Slic3r::GUI::CalibUtils::emit_get_flow_ratio_calib_results().

Here is the call graph for this function:

Here is the caller graph for this function:

command_get_pa_calibration_result()

int Slic3r::MachineObject::command_get_pa_calibration_result

(

float

nozzle_diameter

)

{
    json j;
    j["print"]["command"]         = "extrusion_cali_get_result";
    j["print"]["sequence_id"]     = std::to_string(MachineObject::m_sequence_id++);
    j["print"]["nozzle_diameter"] = to_string_nozzle_diameter(nozzle_diameter);
 
    BOOST_LOG_TRIVIAL(info) << "extrusion_cali_get_result: " << j.dump();
    return this->publish_json(j);
}

References m_sequence_id, Slic3r::nozzle_diameter(), publish_json(), and to_string_nozzle_diameter().

Referenced by Slic3r::GUI::CalibUtils::emit_get_PA_calib_results().

Here is the call graph for this function:

Here is the caller graph for this function:

command_get_pa_calibration_tab()

int Slic3r::MachineObject::command_get_pa_calibration_tab

(

const PACalibExtruderInfo &

calib_info

)

{
    reset_pa_cali_history_result();
 
    json j;
    j["print"]["command"]         = "extrusion_cali_get";
    j["print"]["sequence_id"]     = std::to_string(MachineObject::m_sequence_id++);
    j["print"]["filament_id"]     = calib_info.filament_id;
    if (calib_info.use_extruder_id)
        j["print"]["extruder_id"] = calib_info.extruder_id;
    if (calib_info.use_nozzle_volume_type)
        j["print"]["nozzle_id"] = _generate_nozzle_id(calib_info.nozzle_volume_type, to_string_nozzle_diameter(calib_info.nozzle_diameter)).ToStdString();
    j["print"]["nozzle_diameter"] = to_string_nozzle_diameter(calib_info.nozzle_diameter);
 
    if (calib_info.nozzle_pos_id >= 0) {
        j["print"]["nozzle_pos"] = calib_info.nozzle_pos_id;
        j["print"]["nozzle_sn"]  = calib_info.nozzle_sn;
    }
 
    BOOST_LOG_TRIVIAL(info) << "extrusion_cali_get: " << j.dump();
    request_tab_from_bbs = true;
    return this->publish_json(j);
}

References Slic3r::_generate_nozzle_id(), Slic3r::PACalibExtruderInfo::extruder_id, Slic3r::PACalibExtruderInfo::filament_id, m_sequence_id, Slic3r::PACalibExtruderInfo::nozzle_diameter, Slic3r::PACalibExtruderInfo::nozzle_pos_id, Slic3r::PACalibExtruderInfo::nozzle_sn, Slic3r::PACalibExtruderInfo::nozzle_volume_type, publish_json(), request_tab_from_bbs, reset_pa_cali_history_result(), to_string_nozzle_diameter(), Slic3r::PACalibExtruderInfo::use_extruder_id, and Slic3r::PACalibExtruderInfo::use_nozzle_volume_type.

Referenced by Slic3r::GUI::CalibUtils::emit_get_PA_calib_infos(), and Slic3r::DevCalib::RequestPAHistory().

Here is the call graph for this function:

Here is the caller graph for this function:

command_get_version()

int Slic3r::MachineObject::command_get_version

(

bool

with_retry = true

)

{
    BOOST_LOG_TRIVIAL(info) << "command_get_version";
    json j;
    j["info"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
    j["info"]["command"] = "get_version";
    if (with_retry)
        get_version_retry = GET_VERSION_RETRYS;
    return this->publish_json(j, 1);
}

References get_version_retry, GET_VERSION_RETRYS, m_sequence_id, and publish_json().

Referenced by Slic3r::GUI::SelectMachineDialog::on_selection_changed(), Slic3r::GUI::SendToPrinterDialog::on_selection_changed(), parse_json(), and Slic3r::GUI::UpgradePanel::refresh_version_and_firmware().

Here is the call graph for this function:

Here is the caller graph for this function:

command_go_home()

int Slic3r::MachineObject::command_go_home

(

)

{
    if (!m_agent) return -1;
    return command_with_dialog(m_agent->command_go_home(get_dev_id(), this->is_in_printing(), m_support_mqtt_homing, MachineObject::m_sequence_id++, is_lan_mode_printer()));
}

References command_with_dialog(), get_dev_id(), is_in_printing(), is_lan_mode_printer(), m_agent, m_sequence_id, and m_support_mqtt_homing.

Here is the call graph for this function:

command_hms_idle_ignore()

int Slic3r::MachineObject::command_hms_idle_ignore	(	const std::string &	error_str,
		int	type )

{
    if(check_resume_condition()) return 0;
 
    json j;
    j["print"]["command"]     = "idle_ignore";
    j["print"]["err"]         = error_str;
    j["print"]["type"]        = type;
    j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
    return this->publish_json(j, 1);
}

References check_resume_condition(), m_sequence_id, and publish_json().

Here is the call graph for this function:

command_hms_ignore()

int Slic3r::MachineObject::command_hms_ignore	(	const std::string &	error_str,
		const std::string &	job_id )

{
    if(check_resume_condition()) return 0;
 
    json j;
    j["print"]["command"] = "ignore";
    j["print"]["err"] = error_str;
    j["print"]["param"] = "reserve";
    j["print"]["job_id"] = job_id;
    j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
 
    return this->publish_json(j, 1);
}

References check_resume_condition(), m_sequence_id, and publish_json().

Here is the call graph for this function:

command_hms_resume()

int Slic3r::MachineObject::command_hms_resume	(	const std::string &	error_str,
		const std::string &	job_id )

{
    if(check_resume_condition()) return 0;
 
    json j;
    j["print"]["command"] = "resume";
    j["print"]["err"] = error_str;
    j["print"]["param"] = "reserve";
    j["print"]["job_id"] = job_id;
    j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
 
    return this->publish_json(j, 1);
}

References check_resume_condition(), m_sequence_id, and publish_json().

Here is the call graph for this function:

command_hms_stop()

int Slic3r::MachineObject::command_hms_stop	(	const std::string &	error_str,
		const std::string &	job_id )

                                                                                       {
    json j;
    j["print"]["command"]     = "stop";
    j["print"]["err"]         = error_str;
    j["print"]["param"]       = "reserve";
    j["print"]["job_id"]      = job_id;
    j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
 
    return this->publish_json(j, 1);
}

References m_sequence_id, and publish_json().

Here is the call graph for this function:

command_ipcam_check_timelapse_storage()

int Slic3r::MachineObject::command_ipcam_check_timelapse_storage	(	const std::string &	storage,
		int	total_layer )

{
    json j;
    j["camera"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
    j["camera"]["command"] = "ipcam_get_media_info";
    j["camera"]["sub_command"] = "is_timelapse_storage_enough";
    j["camera"]["storage"] = storage;
    j["camera"]["total_layer"] = total_layer;
    return this->publish_json(j);
}

References m_sequence_id, and publish_json().

Referenced by Slic3r::GUI::SelectMachineDialog::start_timelapse_storage_check().

Here is the call graph for this function:

Here is the caller graph for this function:

command_ipcam_delete_oldest_timelapse()

int Slic3r::MachineObject::command_ipcam_delete_oldest_timelapse	(	const std::string &	storage,
		int	total_layer )

{
    json j;
    j["camera"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
    j["camera"]["command"] = "ipcam_delete_oldest_timelapse";
    j["camera"]["storage"] = storage;
    j["camera"]["total_layer"] = total_layer;
    return this->publish_json(j);
}

References m_sequence_id, and publish_json().

Referenced by Slic3r::GUI::SelectMachineDialog::show_timelapse_storage_dialog().

Here is the call graph for this function:

Here is the caller graph for this function:

command_ipcam_record()

int Slic3r::MachineObject::command_ipcam_record

(

bool

on_off

)

{
    BOOST_LOG_TRIVIAL(info) << "command_ipcam_record = " << on_off;
    json j;
    j["camera"]["command"] = "ipcam_record_set";
    j["camera"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
    j["camera"]["control"] = on_off ? "enable" : "disable";
    camera_recording_ctl_start          = time(nullptr);
    this->camera_recording_when_printing = on_off;
    return this->publish_json(j);
}

References camera_recording_ctl_start, camera_recording_when_printing, m_sequence_id, and publish_json().

Here is the call graph for this function:

command_ipcam_resolution_set()

int Slic3r::MachineObject::command_ipcam_resolution_set

(

std::string

resolution

)

{
    BOOST_LOG_TRIVIAL(info) << "command:ipcam_resolution_set" << ", resolution:" << resolution;
    json j;
    j["camera"]["command"] = "ipcam_resolution_set";
    j["camera"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
    j["camera"]["resolution"] = resolution;
    camera_resolution_hold_count = HOLD_COUNT_CAMERA;
    camera_recording_ctl_start = time(nullptr);
    this->camera_resolution = resolution;
    return this->publish_json(j);
}

References camera_recording_ctl_start, camera_resolution, camera_resolution_hold_count, HOLD_COUNT_CAMERA, m_sequence_id, publish_json(), and Slic3r::resolution().

Here is the call graph for this function:

command_ipcam_timelapse()

int Slic3r::MachineObject::command_ipcam_timelapse

(

bool

on_off

)

{
    BOOST_LOG_TRIVIAL(info) << "command_ipcam_timelapse " << on_off;
    json j;
    j["camera"]["command"] = "ipcam_timelapse";
    j["camera"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
    j["camera"]["control"] = on_off ? "enable" : "disable";
    camera_timelapse_hold_count = HOLD_COUNT_CAMERA;
    this->camera_timelapse = on_off;
    return this->publish_json(j);
}

References camera_timelapse, camera_timelapse_hold_count, HOLD_COUNT_CAMERA, m_sequence_id, and publish_json().

Here is the call graph for this function:

command_nozzle_blob_detect()

int Slic3r::MachineObject::command_nozzle_blob_detect

(

bool

nozzle_blob_detect

)

{
    json j;
    j["print"]["command"] = "print_option";
    j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
    j["print"]["nozzle_blob_detect"] = nozzle_blob_detect;
    nozzle_blob_detection_enabled = nozzle_blob_detect;
    nozzle_blob_detection_hold_start = time(nullptr);
    return this->publish_json(j);
}

References m_sequence_id, nozzle_blob_detection_enabled, nozzle_blob_detection_hold_start, and publish_json().

Here is the call graph for this function:

command_purification_disable()

int Slic3r::MachineObject::command_purification_disable

(

)

{
    json j;
    j["print"]["command"] = "close_air_filt";
    j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
 
    return this->publish_json(j, 1);
}

References m_sequence_id, and publish_json().

Here is the call graph for this function:

command_pushing()

int Slic3r::MachineObject::command_pushing

(

std::string

cmd

)

{
    auto curr_time = std::chrono::system_clock::now();
    auto diff = std::chrono::duration_cast<std::chrono::milliseconds>(curr_time - last_request_start);
    if (diff.count() < REQUEST_START_MIN_TIME) {
        BOOST_LOG_TRIVIAL(trace) << "static: command_request_start: send request too fast, dev_id=" << dev_id;
        return -1;
    }
    else {
        BOOST_LOG_TRIVIAL(trace) << "static: command_request_start, dev_id=" << dev_id;
        last_request_start = std::chrono::system_clock::now();
    }
 
    if (cmd == "start" || cmd == "stop") {
        json j;
        j["pushing"]["command"] = cmd;
        j["pushing"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
        return this->publish_json(j);
    }
    return -1;
}

References dev_id, Slic3r::diff(), last_request_start, m_sequence_id, publish_json(), REQUEST_START_MIN_TIME, and Slic3r::trace().

Referenced by Slic3r::DeviceManager::check_pushing().

Here is the call graph for this function:

Here is the caller graph for this function:

command_refresh_nozzle()

int Slic3r::MachineObject::command_refresh_nozzle

(

)

                                         {
    json j;
    j["print"]["sequence_id"]    = std::to_string(MachineObject::m_sequence_id++);
    j["print"]["command"]        = "refresh_nozzle";
 
    return this->publish_json(j, 1);
}

References m_sequence_id, and publish_json().

Here is the call graph for this function:

command_request_push_all()

int Slic3r::MachineObject::command_request_push_all

(

bool

request_now = false

)

{
    auto curr_time = std::chrono::system_clock::now();
    auto diff = std::chrono::duration_cast<std::chrono::milliseconds>(curr_time - last_request_push);
 
    if (diff.count() < REQUEST_PUSH_MIN_TIME) {
        if (request_now) {
            BOOST_LOG_TRIVIAL(trace) << "static: command_request_push_all, dev_id=" << dev_id;
            last_request_push = std::chrono::system_clock::now();
        }
        else {
            BOOST_LOG_TRIVIAL(trace) << "static: command_request_push_all: send request too fast, dev_id=" << dev_id;
            return -1;
        }
    } else {
        BOOST_LOG_TRIVIAL(trace) << "static: command_request_push_all, dev_id=" << dev_id;
        last_request_push = std::chrono::system_clock::now();
    }
 
    json j;
    j["pushing"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
    j["pushing"]["command"]     = "pushall";
    j["pushing"]["version"]     =  1;
    j["pushing"]["push_target"] =  1;
    return this->publish_json(j);
}

References dev_id, Slic3r::diff(), last_request_push, m_sequence_id, publish_json(), REQUEST_PUSH_MIN_TIME, and Slic3r::trace().

Referenced by Slic3r::DeviceManager::keep_alive(), Slic3r::GUI::SelectMachineDialog::on_selection_changed(), Slic3r::GUI::SendToPrinterDialog::on_selection_changed(), and parse_json().

Here is the call graph for this function:

Here is the caller graph for this function:

command_set_bed()

int Slic3r::MachineObject::command_set_bed

(

int

temp

)

{
    if (!m_agent) return -1;
    return command_with_dialog(m_agent->command_set_bed(get_dev_id(), temp, m_support_mqtt_bet_ctrl, MachineObject::m_sequence_id++, is_lan_mode_printer()));
}

References command_with_dialog(), get_dev_id(), is_lan_mode_printer(), m_agent, m_sequence_id, and m_support_mqtt_bet_ctrl.

Here is the call graph for this function:

command_set_chamber()

int Slic3r::MachineObject::command_set_chamber

(

int

temp

)

{
    json j;
    j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
    j["print"]["command"] = "set_ctt";
    j["print"]["ctt_val"] = temp;
 
    return this->publish_json(j, 1);
}

References m_sequence_id, and publish_json().

Here is the call graph for this function:

command_set_door_open_check()

void Slic3r::MachineObject::command_set_door_open_check

(

DoorOpenCheckState

state

)

{
    json j;
    j["system"]["command"]       = "set_door_stat";
    j["system"]["sequence_id"]   = std::to_string(MachineObject::m_sequence_id++);
    switch (state)
    {
         case Slic3r::MachineObject::DOOR_OPEN_CHECK_DISABLE:            j["system"]["config"] = 0; break;
         case Slic3r::MachineObject::DOOR_OPEN_CHECK_ENABLE_WARNING:     j["system"]["config"] = 1; break;
         case Slic3r::MachineObject::DOOR_OPEN_CHECK_ENABLE_PAUSE_PRINT: j["system"]["config"] = 2; break;
         default: assert(0); return;
    }
 
    if (publish_json(j) == 0)
    {
        xcam_door_open_check = state;
        xcam_door_open_check_start_time = time(nullptr);
    }
}

References DOOR_OPEN_CHECK_DISABLE, DOOR_OPEN_CHECK_ENABLE_PAUSE_PRINT, DOOR_OPEN_CHECK_ENABLE_WARNING, m_sequence_id, publish_json(), xcam_door_open_check, and xcam_door_open_check_start_time.

Here is the call graph for this function:

command_set_filament_tangle_detect()

int Slic3r::MachineObject::command_set_filament_tangle_detect

(

bool

fliament_tangle_detect

)

                                                                                 {
    json j;
    j["print"]["command"] = "print_option";
    j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
    j["print"]["filament_tangle_detect"] = filament_tangle_detect;
 
    return this->publish_json(j);
}

References m_sequence_id, and publish_json().

Referenced by command_xcam_control_filament_tangle_detect().

Here is the call graph for this function:

Here is the caller graph for this function:

command_set_nozzle()

int Slic3r::MachineObject::command_set_nozzle

(

int

temp

)

{
    if (!m_agent) return -1;
    return command_with_dialog(m_agent->command_set_nozzle(get_dev_id(), temp, MachineObject::m_sequence_id++, is_lan_mode_printer()));
}

References command_with_dialog(), get_dev_id(), is_lan_mode_printer(), m_agent, and m_sequence_id.

Here is the call graph for this function:

command_set_nozzle_new()

int Slic3r::MachineObject::command_set_nozzle_new	(	int	nozzle_id,
		int	temp )

{
    BOOST_LOG_TRIVIAL(info) << "set_nozzle_temp";
 
    json j;
    j["print"]["sequence_id"]    = std::to_string(MachineObject::m_sequence_id++);
    j["print"]["command"]        = "set_nozzle_temp";
    j["print"]["extruder_index"] = nozzle_id;
    j["print"]["target_temp"]    = temp;
 
    return this->publish_json(j, 1);
}

References m_sequence_id, and publish_json().

Here is the call graph for this function:

command_set_pa_calibration()

int Slic3r::MachineObject::command_set_pa_calibration	(	const std::vector< PACalibResult > &	pa_calib_values,
		bool	is_auto_cali )

{
    CNumericLocalesSetter locales_setter;
 
    if (pa_calib_values.size() > 0) {
        json j;
        j["print"]["command"]     = "extrusion_cali_set";
        j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
        j["print"]["nozzle_diameter"] = to_string_nozzle_diameter(pa_calib_values[0].nozzle_diameter);
 
        for (int i = 0; i < pa_calib_values.size(); ++i) {
            if (pa_calib_values[i].tray_id >= 0)
                j["print"]["filaments"][i]["tray_id"] = pa_calib_values[i].tray_id;
            if (pa_calib_values[i].cali_idx >= 0)
                j["print"]["filaments"][i]["cali_idx"] = pa_calib_values[i].cali_idx;
            j["print"]["filaments"][i]["tray_id"]     = pa_calib_values[i].tray_id;
            j["print"]["filaments"][i]["extruder_id"] = pa_calib_values[i].extruder_id;
            j["print"]["filaments"][i]["nozzle_id"]   = _generate_nozzle_id(pa_calib_values[i].nozzle_volume_type, to_string_nozzle_diameter(pa_calib_values[i].nozzle_diameter)).ToStdString();
            j["print"]["filaments"][i]["nozzle_diameter"] = to_string_nozzle_diameter(pa_calib_values[i].nozzle_diameter);
            j["print"]["filaments"][i]["ams_id"]      = pa_calib_values[i].ams_id;
            j["print"]["filaments"][i]["slot_id"]     = pa_calib_values[i].slot_id;
            j["print"]["filaments"][i]["filament_id"] = pa_calib_values[i].filament_id;
            j["print"]["filaments"][i]["setting_id"]  = pa_calib_values[i].setting_id;
            j["print"]["filaments"][i]["name"]        = pa_calib_values[i].name;
            j["print"]["filaments"][i]["k_value"]     = std::to_string(pa_calib_values[i].k_value);
            if (is_auto_cali)
                j["print"]["filaments"][i]["n_coef"] = std::to_string(pa_calib_values[i].n_coef);
            else
                j["print"]["filaments"][i]["n_coef"]  = "0.0";
            if (pa_calib_values[i].nozzle_pos_id >= 0) {
                j["print"]["filaments"][i]["nozzle_pos"] = pa_calib_values[i].nozzle_pos_id;
                j["print"]["filaments"][i]["nozzle_sn"]  = pa_calib_values[i].nozzle_sn;
            }
        }
 
        BOOST_LOG_TRIVIAL(info) << "extrusion_cali_set: " << j.dump();
        return this->publish_json(j);
    }
 
    return -1;
}

References Slic3r::_generate_nozzle_id(), m_sequence_id, Slic3r::nozzle_diameter(), Slic3r::nozzle_volume_type(), publish_json(), and to_string_nozzle_diameter().

Referenced by Slic3r::GUI::CalibUtils::set_PA_calib_result().

Here is the call graph for this function:

Here is the caller graph for this function:

command_set_printer_nozzle()

int Slic3r::MachineObject::command_set_printer_nozzle	(	std::string	nozzle_type,
		float	diameter )

References Slic3r::nozzle_type().

Here is the call graph for this function:

command_set_printer_nozzle2()

int Slic3r::MachineObject::command_set_printer_nozzle2	(	int	id,
		std::string	nozzle_type,
		float	diameter )

References Slic3r::nozzle_type().

Here is the call graph for this function:

command_set_printing_option()

int Slic3r::MachineObject::command_set_printing_option

(

bool

auto_recovery

)

{
    int print_option = (int)auto_recovery << (int)PRINT_OP_AUTO_RECOVERY;
    json j;
    j["print"]["command"]       = "print_option";
    j["print"]["sequence_id"]   = std::to_string(MachineObject::m_sequence_id++);
    j["print"]["option"]        = print_option;
    j["print"]["auto_recovery"] = auto_recovery;
 
    return this->publish_json(j);
}

References m_sequence_id, PRINT_OP_AUTO_RECOVERY, and publish_json().

Referenced by command_xcam_control_auto_recovery_step_loss().

Here is the call graph for this function:

Here is the caller graph for this function:

command_set_printing_speed()

int Slic3r::MachineObject::command_set_printing_speed

(

DevPrintingSpeedLevel

lvl

)

{
    json j;
    j["print"]["command"] = "print_speed";
    j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
    j["print"]["param"] = std::to_string((int)lvl);
 
    return this->publish_json(j);
}

References m_sequence_id, and publish_json().

Here is the call graph for this function:

command_set_prompt_sound()

int Slic3r::MachineObject::command_set_prompt_sound

(

bool

prompt_sound

)

                                                            {
    json j;
    j["print"]["command"] = "print_option";
    j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
    j["print"]["sound_enable"] = prompt_sound;
 
    return this->publish_json(j);
}

References m_sequence_id, and publish_json().

Referenced by command_xcam_control_allow_prompt_sound().

Here is the call graph for this function:

Here is the caller graph for this function:

command_set_save_remote_print_file_to_storage()

void Slic3r::MachineObject::command_set_save_remote_print_file_to_storage

(

bool

save

)

{
    if (get_save_remote_print_file_to_storage() != save)
    {
        json j;
        j["system"]["command"] = "print_cache_set";
        j["system"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
        j["system"]["config"] = save ? true : false;
 
        if (publish_json(j) == 0)
        {
            xcam__save_remote_print_file_to_storage = save;
            xcam__save_remote_print_file_to_storage_start_time = time(nullptr);
        }
    }
}

References get_save_remote_print_file_to_storage(), m_sequence_id, publish_json(), save(), xcam__save_remote_print_file_to_storage, and xcam__save_remote_print_file_to_storage_start_time.

Here is the call graph for this function:

command_start_calibration()

int Slic3r::MachineObject::command_start_calibration	(	bool	vibration,
		bool	bed_leveling,
		bool	xcam_cali,
		bool	motor_noise,
		bool	nozzle_cali,
		bool	bed_cali,
		bool	clumppos_cali )

{
    if (!is_support_command_calibration()) {
        // fixed gcode file
        json j;
        j["print"]["command"] = "gcode_file";
        j["print"]["param"] = "/usr/etc/print/auto_cali_for_user.gcode";
        j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
        return this->publish_json(j);
    } else {
        json j;
        j["print"]["command"] = "calibration";
        j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
        j["print"]["option"]  = +   (clumppos_cali ? 1 << 6 : 0)
                                +   (bed_cali     ? 1 << 5 : 0)
                                +   (nozzle_cali  ? 1 << 4 : 0)
                                +   (motor_noise  ? 1 << 3 : 0)
                                +   (vibration    ? 1 << 2 : 0)
                                +   (bed_leveling ? 1 << 1 : 0)
                                +   (xcam_cali    ? 1 << 0 : 0);
        return this->publish_json(j);
    }
}

References is_support_command_calibration(), m_sequence_id, and publish_json().

Here is the call graph for this function:

command_start_camera()

int Slic3r::MachineObject::command_start_camera

(

)

{
    if (!m_agent) return -1;
    return m_agent->command_start_camera(get_dev_id());
}

References get_dev_id(), and m_agent.

Here is the call graph for this function:

command_start_extrusion_cali()

int Slic3r::MachineObject::command_start_extrusion_cali	(	int	tray_index,
		int	nozzle_temp,
		int	bed_temp,
		float	max_volumetric_speed,
		std::string	setting_id = "" )

{
    BOOST_LOG_TRIVIAL(trace) << "extrusion_cali: tray_id = " << tray_index << ", nozzle_temp = " << nozzle_temp << ", bed_temp = " << bed_temp
                            << ", max_volumetric_speed = " << max_volumetric_speed;
 
    json j;
    j["print"]["command"] = "extrusion_cali";
    j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
    j["print"]["tray_id"] = tray_index;
    //j["print"]["setting_id"] = setting_id;
    //j["print"]["name"] = "";
    j["print"]["nozzle_temp"] = nozzle_temp;
    j["print"]["bed_temp"] = bed_temp;
    j["print"]["max_volumetric_speed"] = max_volumetric_speed;
 
    // enter extusion cali
    last_extrusion_cali_start_time = std::chrono::system_clock::now();
    BOOST_LOG_TRIVIAL(trace) << "extrusion_cali: " << j.dump();
    return this->publish_json(j);
}

References last_extrusion_cali_start_time, m_sequence_id, publish_json(), and Slic3r::trace().

Here is the call graph for this function:

command_start_flow_ratio_calibration()

int Slic3r::MachineObject::command_start_flow_ratio_calibration

(

const X1CCalibInfos &

calib_data

)

{
    CNumericLocalesSetter locales_setter;
 
    if (calib_data.calib_datas.size() > 0) {
        json j;
        j["print"]["command"]     = "flowrate_cali";
        j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
        j["print"]["tray_id"] = calib_data.calib_datas[0].tray_id;
        j["print"]["nozzle_diameter"] = to_string_nozzle_diameter(calib_data.calib_datas[0].nozzle_diameter);
 
        std::string filament_ids;
        for (int i = 0; i < calib_data.calib_datas.size(); ++i) {
            j["print"]["filaments"][i]["tray_id"]              = calib_data.calib_datas[i].tray_id;
            j["print"]["filaments"][i]["bed_temp"]             = calib_data.calib_datas[i].bed_temp;
            j["print"]["filaments"][i]["filament_id"]          = calib_data.calib_datas[i].filament_id;
            j["print"]["filaments"][i]["setting_id"]           = calib_data.calib_datas[i].setting_id;
            j["print"]["filaments"][i]["nozzle_temp"]          = calib_data.calib_datas[i].nozzle_temp;
            j["print"]["filaments"][i]["def_flow_ratio"]       = std::to_string(calib_data.calib_datas[i].flow_rate);
            j["print"]["filaments"][i]["max_volumetric_speed"] = std::to_string(calib_data.calib_datas[i].max_volumetric_speed);
            j["print"]["filaments"][i]["extruder_id"]          = calib_data.calib_datas[i].extruder_id;
            j["print"]["filaments"][i]["ams_id"]               = calib_data.calib_datas[i].ams_id;
            j["print"]["filaments"][i]["slot_id"]              = calib_data.calib_datas[i].slot_id;
 
            if (i > 0)
                filament_ids += ",";
            filament_ids += calib_data.calib_datas[i].filament_id;
        }
 
        BOOST_LOG_TRIVIAL(info) << "flowrate_cali: " << j.dump();
        return this->publish_json(j);
    }
    return -1;
}

References Slic3r::X1CCalibInfos::calib_datas, Slic3r::filament_ids(), m_sequence_id, publish_json(), and to_string_nozzle_diameter().

Referenced by Slic3r::GUI::CalibUtils::calib_flowrate_X1C().

Here is the call graph for this function:

Here is the caller graph for this function:

command_start_pa_calibration()

int Slic3r::MachineObject::command_start_pa_calibration	(	const X1CCalibInfos &	pa_data,
		int	mode = 0 )

{
    CNumericLocalesSetter locales_setter;
 
    pa_calib_results.clear();
    json j;
    j["print"]["command"]         = "extrusion_cali";
    j["print"]["sequence_id"]     = std::to_string(MachineObject::m_sequence_id++);
    j["print"]["nozzle_diameter"] = to_string_nozzle_diameter(pa_data.calib_datas[0].nozzle_diameter);
    j["print"]["mode"]            = mode;
 
    std::string filament_ids;
    for (int i = 0; i < pa_data.calib_datas.size(); ++i) {
        j["print"]["filaments"][i]["tray_id"]              = pa_data.calib_datas[i].tray_id;
        j["print"]["filaments"][i]["extruder_id"]          = pa_data.calib_datas[i].extruder_id;
        j["print"]["filaments"][i]["bed_temp"]             = pa_data.calib_datas[i].bed_temp;
        j["print"]["filaments"][i]["filament_id"]          = pa_data.calib_datas[i].filament_id;
        j["print"]["filaments"][i]["setting_id"]           = pa_data.calib_datas[i].setting_id;
        j["print"]["filaments"][i]["nozzle_temp"]          = pa_data.calib_datas[i].nozzle_temp;
        j["print"]["filaments"][i]["ams_id"]               = pa_data.calib_datas[i].ams_id;
        j["print"]["filaments"][i]["slot_id"]              = pa_data.calib_datas[i].slot_id;
        j["print"]["filaments"][i]["nozzle_id"]            = _generate_nozzle_id(pa_data.calib_datas[i].nozzle_volume_type,to_string_nozzle_diameter(pa_data.calib_datas[i].nozzle_diameter)).ToStdString();
        j["print"]["filaments"][i]["nozzle_diameter"]      = to_string_nozzle_diameter(pa_data.calib_datas[i].nozzle_diameter);
        j["print"]["filaments"][i]["max_volumetric_speed"] = std::to_string(pa_data.calib_datas[i].max_volumetric_speed);
 
        if (i > 0) filament_ids += ",";
        filament_ids += pa_data.calib_datas[i].filament_id;
    }
 
    BOOST_LOG_TRIVIAL(info) << "extrusion_cali: " << j.dump();
 
    return this->publish_json(j);
}

References Slic3r::_generate_nozzle_id(), Slic3r::X1CCalibInfos::calib_datas, Slic3r::filament_ids(), m_sequence_id, pa_calib_results, publish_json(), and to_string_nozzle_diameter().

Referenced by Slic3r::GUI::CalibUtils::calib_PA().

Here is the call graph for this function:

Here is the caller graph for this function:

command_stop_buzzer()

int Slic3r::MachineObject::command_stop_buzzer

(

)

{
    json j;
    j["print"]["command"] = "buzzer_ctrl";
    j["print"]["mode"] = 0;
    j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
 
    return this->publish_json(j, 1);
}

References m_sequence_id, and publish_json().

Here is the call graph for this function:

command_stop_extrusion_cali()

int Slic3r::MachineObject::command_stop_extrusion_cali

(

)

{
    BOOST_LOG_TRIVIAL(trace) << "extrusion_cali: stop";
    if (is_in_extrusion_cali()) {
        return command_task_abort();
    }
    return 0;
}

References command_task_abort(), is_in_extrusion_cali(), and Slic3r::trace().

Here is the call graph for this function:

command_task_abort()

int Slic3r::MachineObject::command_task_abort

(

)

{
    BOOST_LOG_TRIVIAL(trace) << "command_task_abort: ";
    json j;
    j["print"]["command"] = "stop";
    j["print"]["param"] = "";
    j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
 
    return this->publish_json(j, 1);
}

References m_sequence_id, publish_json(), and Slic3r::trace().

Referenced by command_stop_extrusion_cali(), Slic3r::GUI::CalibrationCaliPage::on_subtask_abort(), and Slic3r::GUI::MultiTaskItem::onStop().

Here is the call graph for this function:

Here is the caller graph for this function:

command_task_cancel()

int Slic3r::MachineObject::command_task_cancel

(

std::string

job_id

)

{
    BOOST_LOG_TRIVIAL(trace) << "command_task_cancel: " << job_id;
    json j;
    j["print"]["command"] = "stop";
    j["print"]["param"] = "";
    j["print"]["job_id"] = job_id;
    j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
 
    return this->publish_json(j, 1);
}

References m_sequence_id, publish_json(), and Slic3r::trace().

Referenced by Slic3r::GUI::MultiTaskItem::onCancel().

Here is the call graph for this function:

Here is the caller graph for this function:

command_task_partskip()

int Slic3r::MachineObject::command_task_partskip

(

std::vector< int >

part_ids

)

{
    BOOST_LOG_TRIVIAL(trace) << "command_task_partskip: ";
    json j;
    j["print"]["command"] = "skip_objects";
    j["print"]["obj_list"] = part_ids;
    j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
 
    return this->publish_json(j, 1);
}

References m_sequence_id, publish_json(), and Slic3r::trace().

Here is the call graph for this function:

command_task_pause()

int Slic3r::MachineObject::command_task_pause

(

)

{
    json j;
    j["print"]["command"] = "pause";
    j["print"]["param"] = "";
    j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
 
    return this->publish_json(j, 1);
}

References m_sequence_id, and publish_json().

Referenced by Slic3r::GUI::CalibrationCaliPage::on_subtask_pause_resume(), and Slic3r::GUI::MultiTaskItem::onPause().

Here is the call graph for this function:

Here is the caller graph for this function:

command_task_resume()

int Slic3r::MachineObject::command_task_resume

(

)

{
    if(check_resume_condition()) return 0;
 
    json j;
    j["print"]["command"] = "resume";
    j["print"]["param"] = "";
    j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
 
    return this->publish_json(j, 1);
}

References check_resume_condition(), m_sequence_id, and publish_json().

Referenced by Slic3r::GUI::CalibrationCaliPage::on_subtask_pause_resume(), and Slic3r::GUI::MultiTaskItem::onResume().

Here is the call graph for this function:

Here is the caller graph for this function:

command_upgrade_confirm()

int Slic3r::MachineObject::command_upgrade_confirm

(

)

{
    BOOST_LOG_TRIVIAL(info) << "command_upgrade_confirm";
    json j;
    j["upgrade"]["command"] = "upgrade_confirm";
    j["upgrade"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
    j["upgrade"]["src_id"] = 1; // 1 for slicer
    return this->publish_json(j);
}

References m_sequence_id, and publish_json().

Referenced by Slic3r::GUI::MachineInfoPanel::confirm_upgrade().

Here is the call graph for this function:

Here is the caller graph for this function:

command_upgrade_firmware()

int Slic3r::MachineObject::command_upgrade_firmware

(

FirmwareInfo

info

)

{
    std::string version     = info.version;
    std::string dst_url     = info.url;
    std::string module_name = info.module_type;
 
    json j;
    j["upgrade"]["command"]     = "start";
    j["upgrade"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
    j["upgrade"]["url"]         = info.url;
    j["upgrade"]["module"]      = info.module_type;
    j["upgrade"]["version"]     = info.version;
    j["upgrade"]["src_id"]      = 1;
 
    return this->publish_json(j);
}

References m_sequence_id, Slic3r::FirmwareInfo::module_type, publish_json(), Slic3r::FirmwareInfo::url, and Slic3r::FirmwareInfo::version.

Here is the call graph for this function:

command_upgrade_module()

int Slic3r::MachineObject::command_upgrade_module	(	std::string	url,
		std::string	module_type,
		std::string	version )

{
    json j;
    j["upgrade"]["command"] = "start";
    j["upgrade"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
    j["upgrade"]["url"] = url;
    j["upgrade"]["module"] = module_type;
    j["upgrade"]["version"] = version;
    j["upgrade"]["src_id"] = 1;
 
    return this->publish_json(j);
}

References m_sequence_id, and publish_json().

Here is the call graph for this function:

command_with_dialog()

int Slic3r::MachineObject::command_with_dialog ( int cmd_result )

private

{
    if (!m_agent)
        return -1;
    if (cmd_result == ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED || cmd_result == ORCA_NETWORK_ERR_CAP_NOT_AVAILABLE)
        show_unsupported_dlg(cmd_result);
    return cmd_result;
}

References m_agent, ORCA_NETWORK_ERR_CAP_NOT_AVAILABLE, ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED, and show_unsupported_dlg().

Referenced by command_ams_calibrate(), command_ams_refresh_rfid(), command_ams_select_tray(), command_auto_leveling(), command_axis_control(), command_go_home(), command_set_bed(), command_set_nozzle(), and command_xyz_abs().

Here is the call graph for this function:

Here is the caller graph for this function:

command_xcam_control()

int Slic3r::MachineObject::command_xcam_control	(	std::string	module_name,
		bool	on_off,
		std::string	lvl = "" )

{
    json j;
    j["xcam"]["command"] = "xcam_control_set";
    j["xcam"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
    j["xcam"]["module_name"] = module_name;
    j["xcam"]["control"] = on_off;
    j["xcam"]["enable"] = on_off;       //old protocol
    j["xcam"]["print_halt"]  = true;    //old protocol
    if (!lvl.empty()) {
        j["xcam"]["halt_print_sensitivity"] = lvl;
    }
 
   // int           cfg = 123;
   // get_flag_bits(cfg, 11, 2);
 
    BOOST_LOG_TRIVIAL(info) << "command:xcam_control_set" << ", module_name:" << module_name << ", control:" << on_off << ", halt_print_sensitivity:" << lvl;
    return this->publish_json(j);
}

References m_sequence_id, and publish_json().

Referenced by command_xcam_control_ai_monitoring(), command_xcam_control_airprinting_detection(), command_xcam_control_buildplate_marker_detector(), command_xcam_control_first_layer_inspector(), command_xcam_control_nozzleclumping_detection(), command_xcam_control_purgechutepileup_detection(), and command_xcam_control_spaghetti_detection().

Here is the call graph for this function:

Here is the caller graph for this function:

command_xcam_control_ai_monitoring()

int Slic3r::MachineObject::command_xcam_control_ai_monitoring	(	bool	on_off,
		std::string	lvl )

{
    bool print_halt = (lvl == "never_halt") ? false:true;
 
    xcam_ai_monitoring = on_off;
    xcam_ai_monitoring_hold_start  = time(nullptr);
    xcam_ai_monitoring_sensitivity = lvl;
    return command_xcam_control("printing_monitor", on_off, lvl);
}

References command_xcam_control(), xcam_ai_monitoring, xcam_ai_monitoring_hold_start, and xcam_ai_monitoring_sensitivity.

Here is the call graph for this function:

command_xcam_control_airprinting_detection()

int Slic3r::MachineObject::command_xcam_control_airprinting_detection	(	bool	on_off,
		std::string	lvl )

{
    bool print_halt = (lvl == "never_halt") ? false : true;
 
    xcam_airprinting_detection     = on_off;
    xcam_ai_monitoring_hold_start  = time(nullptr);
    xcam_airprinting_detection_sensitivity = lvl;
    return command_xcam_control("airprint_detector", on_off, lvl);
}

References command_xcam_control(), xcam_ai_monitoring_hold_start, xcam_airprinting_detection, and xcam_airprinting_detection_sensitivity.

Here is the call graph for this function:

command_xcam_control_allow_prompt_sound()

int Slic3r::MachineObject::command_xcam_control_allow_prompt_sound

(

bool

on_off

)

{
    xcam_allow_prompt_sound = on_off;
    xcam_prompt_sound_hold_start = time(nullptr);
    return command_set_prompt_sound(on_off);
}

References command_set_prompt_sound(), xcam_allow_prompt_sound, and xcam_prompt_sound_hold_start.

Here is the call graph for this function:

command_xcam_control_auto_recovery_step_loss()

int Slic3r::MachineObject::command_xcam_control_auto_recovery_step_loss

(

bool

on_off

)

{
    xcam_auto_recovery_step_loss = on_off;
    xcam_auto_recovery_hold_start = time(nullptr);
    return command_set_printing_option(on_off);
}

References command_set_printing_option(), xcam_auto_recovery_hold_start, and xcam_auto_recovery_step_loss.

Here is the call graph for this function:

command_xcam_control_buildplate_marker_detector()

int Slic3r::MachineObject::command_xcam_control_buildplate_marker_detector

(

bool

on_off

)

{
    xcam_buildplate_marker_detector = on_off;
    xcam_buildplate_marker_hold_start = time(nullptr);
    return command_xcam_control("buildplate_marker_detector", on_off);
}

References command_xcam_control(), xcam_buildplate_marker_detector, and xcam_buildplate_marker_hold_start.

Here is the call graph for this function:

command_xcam_control_filament_tangle_detect()

int Slic3r::MachineObject::command_xcam_control_filament_tangle_detect

(

bool

on_off

)

{
    xcam_filament_tangle_detect = on_off;
    xcam_filament_tangle_detect_hold_start = time(nullptr);
    return command_set_filament_tangle_detect(on_off);
}

References command_set_filament_tangle_detect(), xcam_filament_tangle_detect, and xcam_filament_tangle_detect_hold_start.

Here is the call graph for this function:

command_xcam_control_first_layer_inspector()

int Slic3r::MachineObject::command_xcam_control_first_layer_inspector	(	bool	on_off,
		bool	print_halt )

{
    xcam_first_layer_inspector = on_off;
    xcam_first_layer_hold_start = time(nullptr);
    return command_xcam_control("first_layer_inspector", on_off);
}

References command_xcam_control(), xcam_first_layer_hold_start, and xcam_first_layer_inspector.

Here is the call graph for this function:

command_xcam_control_nozzleclumping_detection()

int Slic3r::MachineObject::command_xcam_control_nozzleclumping_detection	(	bool	on_off,
		std::string	lvl )

{
    bool print_halt = (lvl == "never_halt") ? false : true;
 
    xcam_nozzleclumping_detection  = on_off;
    xcam_ai_monitoring_hold_start  = time(nullptr);
    xcam_nozzleclumping_detection_sensitivity = lvl;
    return command_xcam_control("clump_detector", on_off, lvl);
}

References command_xcam_control(), xcam_ai_monitoring_hold_start, xcam_nozzleclumping_detection, and xcam_nozzleclumping_detection_sensitivity.

Here is the call graph for this function:

command_xcam_control_purgechutepileup_detection()

int Slic3r::MachineObject::command_xcam_control_purgechutepileup_detection	(	bool	on_off,
		std::string	lvl )

{
    bool print_halt = (lvl == "never_halt") ? false : true;
 
    xcam_purgechutepileup_detection = on_off;
    xcam_ai_monitoring_hold_start  = time(nullptr);
    xcam_purgechutepileup_detection_sensitivity = lvl;
    return command_xcam_control("pileup_detector", on_off, lvl);
}

References command_xcam_control(), xcam_ai_monitoring_hold_start, xcam_purgechutepileup_detection, and xcam_purgechutepileup_detection_sensitivity.

Here is the call graph for this function:

command_xcam_control_spaghetti_detection()

int Slic3r::MachineObject::command_xcam_control_spaghetti_detection	(	bool	on_off,
		std::string	lvl )

{
    bool print_halt = (lvl == "never_halt") ? false : true;
 
    xcam_spaghetti_detection       = on_off;
    xcam_ai_monitoring_hold_start  = time(nullptr);
    xcam_spaghetti_detection_sensitivity = lvl;
    return command_xcam_control("spaghetti_detector", on_off, lvl);
}

References command_xcam_control(), xcam_ai_monitoring_hold_start, xcam_spaghetti_detection, and xcam_spaghetti_detection_sensitivity.

Here is the call graph for this function:

command_xyz_abs()

int Slic3r::MachineObject::command_xyz_abs

(

)

{
    if (!m_agent) return -1;
    return command_with_dialog(m_agent->command_xyz_abs(get_dev_id(), MachineObject::m_sequence_id++, is_lan_mode_printer()));
}

References command_with_dialog(), get_dev_id(), is_lan_mode_printer(), m_agent, and m_sequence_id.

Here is the call graph for this function:

commnad_select_pa_calibration()

int Slic3r::MachineObject::commnad_select_pa_calibration

(

const PACalibIndexInfo &

pa_calib_info

)

{
    json j;
    j["print"]["command"]         = "extrusion_cali_sel";
    j["print"]["sequence_id"]     = std::to_string(MachineObject::m_sequence_id++);
    j["print"]["tray_id"]         = pa_calib_info.tray_id;
    j["print"]["ams_id"]          = pa_calib_info.ams_id;
    j["print"]["slot_id"]         = pa_calib_info.slot_id;
    j["print"]["cali_idx"]        = pa_calib_info.cali_idx;
    j["print"]["filament_id"]     = pa_calib_info.filament_id;
    if (pa_calib_info.nozzle_pos_id >= 0) {
        j["print"]["nozzle_pos"] = pa_calib_info.nozzle_pos_id;
        j["print"]["nozzle_sn"]  = pa_calib_info.nozzle_sn;
    }
    j["print"]["nozzle_diameter"] = to_string_nozzle_diameter(pa_calib_info.nozzle_diameter);
 
    BOOST_LOG_TRIVIAL(info) << "extrusion_cali_sel: " << j.dump();
    return this->publish_json(j);
}

References Slic3r::PACalibIndexInfo::ams_id, Slic3r::PACalibIndexInfo::cali_idx, Slic3r::PACalibIndexInfo::filament_id, m_sequence_id, Slic3r::PACalibIndexInfo::nozzle_diameter, Slic3r::PACalibIndexInfo::nozzle_pos_id, Slic3r::PACalibIndexInfo::nozzle_sn, publish_json(), Slic3r::PACalibIndexInfo::slot_id, to_string_nozzle_diameter(), and Slic3r::PACalibIndexInfo::tray_id.

Referenced by Slic3r::GUI::CalibUtils::select_PA_calib_result().

Here is the call graph for this function:

Here is the caller graph for this function:

connect()

int Slic3r::MachineObject::connect

(

)

{
    if (m_access_revoked || get_dev_ip().empty()) return -1;
    std::string username = m_agent ? m_agent->default_lan_username() : std::string();
    std::string password = get_access_code();
 
    std::string port;
    std::string input = get_dev_ip();
 
    bool use_ssl = input.rfind("https", 0) == 0;
 
    // This strips out the http/https prefix
    std::string host = Http::get_host_from_url(input, &port);
    std::string ca_file;
 
    if (wxTheApp && GUI::wxGetApp().preset_bundle) {
        const auto& config = GUI::wxGetApp().preset_bundle->printers.get_edited_preset().config;
        if (port.empty())
            port = config.opt_string("printhost_port");
        ca_file = config.opt_string("printhost_cafile");
 
        // Refresh credentials from the matching preset for connections that bypass GUI_App::select_machine().
        const std::string print_host = config.opt_string("print_host");
        if (printer_agent_id == MOONRAKER_PRINTER_AGENT_ID && config.opt_string("printer_agent") == MOONRAKER_PRINTER_AGENT_ID &&
            !print_host.empty() && dev_id_from_address(print_host, config.opt_string("printhost_port")) == get_dev_id()) {
            password = config.opt_string("printhost_apikey");
            use_ssl  = boost::istarts_with(print_host, "https://");
            if (password != get_access_code())
                set_access_code(password);
        }
    }
 
    if (host.empty())
        host = get_dev_ip();
 
    if (m_agent) {
        try {
            PrinterConnectionParams params{
                get_dev_id(),
                host,
                port,
                username,
                password,
                use_ssl,
                ca_file
            };
            return m_agent->connect_printer(params);
        } catch (...) {
            ;
        }
    }
    return -1;
}

References dev_id_from_address(), Slic3r::empty(), get_access_code(), get_dev_id(), get_dev_ip(), Slic3r::Http::get_host_from_url(), m_access_revoked, m_agent, Slic3r::MOONRAKER_PRINTER_AGENT_ID, printer_agent_id, and set_access_code().

Here is the call graph for this function:

connection_type()

std::string Slic3r::MachineObject::connection_type ( ) const

inline

{ return dev_connection_type; }

References dev_connection_type.

Referenced by Slic3r::GUI::SendToPrinterDialog::ChangeConnectMethod(), Slic3r::GUI::SendToPrinterDialog::on_ok(), Slic3r::GUI::SelectMachineDialog::on_send_print(), Slic3r::DeviceManager::parse_user_print_info(), Slic3r::GUI::Plater::print_job_finished(), Slic3r::GUI::SendMultiMachinePage::request_params(), Slic3r::anonymous_namespace{PluginHostApp.cpp}::selected_printer(), Slic3r::GUI::CalibUtils::send_to_print(), and Slic3r::GUI::CalibUtils::send_to_print().

Here is the caller graph for this function:

contains_tray()

bool Slic3r::MachineObject::contains_tray	(	const std::string &	ams_id,
		const std::string &	tray_id ) const

{
    if (ams_id != VIRTUAL_AMS_MAIN_ID_STR && ams_id != VIRTUAL_AMS_DEPUTY_ID_STR) {
 
        return m_fila_system->GetAmsTray(ams_id, tray_id) != nullptr;
    } else {
        for (const auto& tray : vt_slot) {
            if (tray.id == ams_id) { return true; }
        }
    }
 
    return false;
}

References m_fila_system, VIRTUAL_AMS_DEPUTY_ID_STR, VIRTUAL_AMS_MAIN_ID_STR, and vt_slot.

Referenced by Slic3r::GUI::_check_kval_not_default(), and Slic3r::GUI::SelectMachineDialog::update_show_status().

Here is the caller graph for this function:

dev_id_from_address()

std::string Slic3r::MachineObject::dev_id_from_address ( const std::string & host, const std::string & port = "" )

static

{
    std::string result = host;
    // Normalize host: strip protocol and path
    if (result.find("http://") == 0)
        result = result.substr(7);
    else if (result.find("https://") == 0)
        result = result.substr(8);
    auto slash = result.find('/');
    if (slash != std::string::npos)
        result = result.substr(0, slash);
 
    // Build full address (host:port)
    if (!port.empty()) {
        // Strip inline port if present (port comes from printhost_port)
        auto colon = result.find(':');
        if (colon != std::string::npos)
            result = result.substr(0, colon);
 
        result += ":" + port;
    }
    return result;
}

Referenced by connect(), Slic3r::GUI::GUI_App::select_machine(), and Slic3r::GUI::GUI_App::switch_printer_agent().

Here is the caller graph for this function:

disconnect()

int Slic3r::MachineObject::disconnect

(

)

{
    if (m_agent) {
        const int result = m_agent->disconnect_printer();
        if (result == 0)
            set_online_state(false);
        return result;
    }
    return -1;
}

References m_agent, and set_online_state().

Here is the call graph for this function:

free_slice_info()

void Slic3r::MachineObject::free_slice_info

(

)

{
    if (get_slice_info_thread)
    {
        if (get_slice_info_thread->joinable())
        {
            get_slice_info_thread->interrupt();
            get_slice_info_thread->join();
        }
 
        delete get_slice_info_thread;
        get_slice_info_thread = nullptr;
    }
 
    if (slice_info)
    {
        delete slice_info;
        slice_info = nullptr;
    }
}

References get_slice_info_thread, and slice_info.

Referenced by ~MachineObject().

Here is the caller graph for this function:

get_access_code()

std::string Slic3r::MachineObject::get_access_code

(

)

const

{
    return access_code;
}

References access_code.

Referenced by connect(), Slic3r::GUI::PartSkipDialog::fetchUrl(), Slic3r::GUI::SendToPrinterDialog::GetConnection(), has_access_right(), Slic3r::GUI::SendToPrinterDialog::on_ok(), Slic3r::GUI::SelectMachineDialog::on_send_print(), Slic3r::GUI::GUI_App::select_machine(), Slic3r::GUI::CalibUtils::send_to_print(), Slic3r::GUI::CalibUtils::send_to_print(), Slic3r::GUI::MediaPlayCtrl::SetMachineObject(), Slic3r::GUI::GUI_App::switch_printer_agent(), Slic3r::DeviceManager::update_local_machine(), and Slic3r::GUI::MediaFilePanel::UpdateByObj().

Here is the caller graph for this function:

get_agent()

NetworkAgent * Slic3r::MachineObject::get_agent ( ) const

inline

{ return m_agent; } // Orca: needed by DeviceCore modules (DevAxisCtrl)

References m_agent.

get_ams_colors()

void Slic3r::MachineObject::get_ams_colors

(

std::vector< wxColour > &

ams_colors

)

                                                                  {
    m_fila_system->CollectAmsColors(ams_colors);
}

References m_fila_system.

Referenced by Slic3r::GUI::SelectMachineDialog::do_ams_mapping(), and Slic3r::GUI::SyncAmsInfoDialog::do_ams_mapping().

Here is the caller graph for this function:

get_ams_tray()

Slic3r::DevAmsTray * Slic3r::MachineObject::get_ams_tray	(	std::string	ams_id,
		std::string	tray_id )

{
    return m_fila_system->GetAmsTray(ams_id, tray_id);
}

References m_fila_system.

get_ams_version()

std::map< int, DevFirmwareVersionInfo > Slic3r::MachineObject::get_ams_version

(

)

{
    std::vector<std::string> multi_tray_ams_type = {"ams", "n3f"};
    std::map<int, DevFirmwareVersionInfo> result;
    for (int i = 0; i < 8; i++) {
        std::string ams_id;
        for (auto type : multi_tray_ams_type)
        {
            ams_id = type + "/" + std::to_string(i);
            auto it = module_vers.find(ams_id);
            if (it != module_vers.end()) {
                result.emplace(std::pair(i, it->second));
            }
        }
    }
 
    std::string single_tray_ams_type = "n3s";
    int n3s_start_id = 128;
    for (int i = n3s_start_id; i < n3s_start_id + 8; i++) {
        std::string ams_id;
        ams_id = single_tray_ams_type + "/" + std::to_string(i);
        auto it = module_vers.find(ams_id);
        if (it != module_vers.end()) {
            result.emplace(std::pair(i, it->second));
        }
    }
    return result;
}

References module_vers.

Referenced by Slic3r::GUI::MachineInfoPanel::update_ams_ext().

Here is the caller graph for this function:

get_auto_pa_cali_thumbnail_img_str()

std::string Slic3r::MachineObject::get_auto_pa_cali_thumbnail_img_str

(

)

const

{
    return DevPrinterConfigUtil::get_printer_auto_pa_cali_image(printer_type);
}

References Slic3r::DevPrinterConfigUtil::get_printer_auto_pa_cali_image(), and printer_type.

Here is the call graph for this function:

get_bed_temperature_limit()

int Slic3r::MachineObject::get_bed_temperature_limit

(

)

{
    if (get_printer_series() == PrinterSeries::SERIES_X1) {
        if (is_220V_voltage)
            return 110;
        else {
            return 120;
        }
    } else {
        int limit = bed_temperature_limit < 0?BED_TEMP_LIMIT:bed_temperature_limit;
        return limit;
    }
    return BED_TEMP_LIMIT;
}

References BED_TEMP_LIMIT, bed_temperature_limit, get_printer_series(), is_220V_voltage, and SERIES_X1.

Here is the call graph for this function:

get_bind_str()

std::string Slic3r::MachineObject::get_bind_str

(

)

{
    std::string default_result = "N/A";
    if (bind_user_name.compare("null") == 0) {
        return "Free";
    }
    else if (!bind_user_name.empty()) {
        return bind_user_name;
    }
    return default_result;
}

References bind_user_name.

get_compatible_machine()

std::vector< std::string > Slic3r::MachineObject::get_compatible_machine

(

)

{
    return DevPrinterConfigUtil::get_compatible_machine(printer_type);
}

References Slic3r::DevPrinterConfigUtil::get_compatible_machine(), and printer_type.

Referenced by Slic3r::DevPrinterConfigUtil::is_printer_model_compatible().

Here is the call graph for this function:

Here is the caller graph for this function:

get_curr_Ams()

Slic3r::DevAms * Slic3r::MachineObject::get_curr_Ams

(

)

{
    return m_fila_system->GetAmsById(m_extder_system->GetCurrentAmsId());
}

References m_extder_system, and m_fila_system.

Referenced by get_curr_tray().

Here is the caller graph for this function:

get_curr_stage()

wxString Slic3r::MachineObject::get_curr_stage

(

)

{
    if (stage_list_info.empty()) {
        return "";
    }
    return get_stage_string(stage_curr);
}

References Slic3r::get_stage_string(), stage_curr, and stage_list_info.

Referenced by Slic3r::GUI::CalibrationCaliPage::update_subtask().

Here is the call graph for this function:

Here is the caller graph for this function:

get_curr_stage_idx()

int Slic3r::MachineObject::get_curr_stage_idx

(

)

{
    int result = -1;
    for (int i = 0; i < stage_list_info.size(); i++) {
        if (stage_list_info[i] == stage_curr) {
            return i;
        }
    }
    return -1;
}

References stage_curr, and stage_list_info.

Referenced by Slic3r::GUI::CalibrationDialog::update_cali().

Here is the caller graph for this function:

get_curr_tray()

DevAmsTray * Slic3r::MachineObject::get_curr_tray

(

)

{
    const std::string& cur_ams_id = m_extder_system->GetCurrentAmsId();
    if (cur_ams_id.compare(std::to_string(VIRTUAL_TRAY_MAIN_ID)) == 0) {
        return &vt_slot[0];
    }
 
    DevAms* curr_ams = get_curr_Ams();
    if (!curr_ams) return nullptr;
 
    auto it = curr_ams->GetTrays().find(m_extder_system->GetCurrentSlotId());
    if (it != curr_ams->GetTrays().end())
    {
        return it->second;
    }
 
    return nullptr;
}

References get_curr_Ams(), Slic3r::DevAms::GetTrays(), m_extder_system, VIRTUAL_TRAY_MAIN_ID, and vt_slot.

Here is the call graph for this function:

get_dev_id()

std::string Slic3r::MachineObject::get_dev_id ( ) const

inline

{ return dev_id; }

References dev_id.

Referenced by Slic3r::DevCtrlInfo::DevCtrlInfo(), Slic3r::GUI::MultiMachineItem::MultiMachineItem(), Slic3r::GUI::CalibrationWizard::back_preset_info(), Slic3r::GUI::Sidebar::build_filament_ams_list(), cloud_publish_json(), command_ams_calibrate(), command_ams_refresh_rfid(), command_ams_select_tray(), command_auto_leveling(), command_axis_control(), command_go_home(), command_set_bed(), command_set_nozzle(), command_start_camera(), command_xyz_abs(), connect(), Slic3r::GUI::PartSkipDialog::fetchUrl(), Slic3r::GUI::HMSQuery::get_dev_id_type(), get_firmware_info(), Slic3r::GUI::get_hms_wiki_url(), Slic3r::GUI::Sidebar::priv::get_nozzle_options(), Slic3r::GUI::SendToPrinterDialog::GetConnection(), Slic3r::GUI::SelectMachineDialog::init_bind(), Slic3r::GUI::SelectMachineDialog::is_same_printer_model(), Slic3r::GUI::Sidebar::load_ams_list(), Slic3r::GUI::SelectMachineDialog::load_option_vals(), local_publish_json(), Slic3r::GUI::CalibrationWizard::on_device_connected(), Slic3r::GUI::SendToPrinterDialog::on_ok(), Slic3r::GUI::SelectMachineDialog::on_ok_btn(), Slic3r::GUI::MonitorPanel::on_select_printer(), Slic3r::GUI::SelectMachineDialog::on_selection_changed(), Slic3r::GUI::SendToPrinterDialog::on_selection_changed(), Slic3r::GUI::SelectMachineDialog::on_send_print(), Slic3r::GUI::PrintingTaskPanel::on_stage_clicked(), Slic3r::GUI::GUI_App::on_start_subscribe_again(), Slic3r::DeviceManagerRefresher::on_timer(), Slic3r::DeviceManager::OnMachineBindStateChanged(), Slic3r::GUI::MultiTaskItem::onPause(), Slic3r::GUI::MultiTaskItem::onResume(), Slic3r::GUI::MultiTaskItem::onStop(), parse_json(), Slic3r::GUI::Plater::print_job_finished(), Slic3r::GUI::GUI_App::process_network_msg(), Slic3r::GUI::CalibrationWizard::recover_preset_info(), Slic3r::GUI::SendMultiMachinePage::request_params(), Slic3r::GUI::SelectMachineDialog::reset_and_sync_ams_list(), Slic3r::GUI::sCheckFilamentInfo(), set_access_code(), Slic3r::GUI::SelectMachineDialog::set_default_from_sdcard(), Slic3r::GUI::MediaPlayCtrl::SetMachineObject(), Slic3r::GUI::GUI_App::switch_printer_agent(), Slic3r::GUI::MultiMachineManagerPage::sync_state(), Slic3r::GUI::CalibrationCaliPage::update(), Slic3r::GUI::MachineInfoPanel::update(), Slic3r::DeviceManager::update_local_machine(), Slic3r::GUI::SelectMachinePopup::update_other_devices(), Slic3r::GUI::SelectMachineDialog::update_show_status(), Slic3r::GUI::Sidebar::priv::update_sync_status(), Slic3r::GUI::SendToPrinterDialog::update_user_printer(), and Slic3r::GUI::MediaFilePanel::UpdateByObj().

get_dev_ip()

std::string Slic3r::MachineObject::get_dev_ip ( ) const

inline

{ return dev_ip; }

References dev_ip.

Referenced by connect(), Slic3r::GUI::PartSkipDialog::fetchUrl(), Slic3r::GUI::SendToPrinterDialog::GetConnection(), is_local(), Slic3r::DeviceManager::on_machine_alive(), Slic3r::GUI::SendToPrinterDialog::on_ok(), Slic3r::GUI::SelectMachineDialog::on_send_print(), Slic3r::DeviceManager::parse_user_print_info(), Slic3r::GUI::SendMultiMachinePage::request_params(), Slic3r::GUI::SelectMachinePopup::search_for_printer(), Slic3r::GUI::selected_machines(), Slic3r::GUI::CalibUtils::send_to_print(), Slic3r::GUI::CalibUtils::send_to_print(), Slic3r::GUI::MediaPlayCtrl::SetMachineObject(), Slic3r::DeviceManager::update_local_machine(), Slic3r::GUI::SendToPrinterDialog::update_show_status(), and Slic3r::GUI::MediaFilePanel::UpdateByObj().

Here is the caller graph for this function:

get_dev_name()

std::string Slic3r::MachineObject::get_dev_name ( ) const

inline

{ return dev_name; }

References dev_name.

Referenced by Slic3r::GUI::_compare_obj_names(), Slic3r::GUI::MultiSendMachineModel::AddMachine(), Slic3r::GUI::SelectMachineDialog::init_bind(), Slic3r::DeviceManager::parse_user_print_info(), Slic3r::GUI::SendMultiMachinePage::request_params(), Slic3r::GUI::SelectMachinePopup::search_for_printer(), Slic3r::GUI::selected_machines(), Slic3r::GUI::SelectMachineDialog::set_default_from_sdcard(), Slic3r::GUI::MultiMachineManagerPage::sync_state(), Slic3r::GUI::MachineInfoPanel::update(), Slic3r::GUI::SyncAmsInfoDialog::update_lan_machine_list(), Slic3r::DeviceManager::update_local_machine(), Slic3r::GUI::SideTools::update_status(), and Slic3r::GUI::SyncAmsInfoDialog::update_user_printer().

Here is the caller graph for this function:

get_door_open_check_state()

DoorOpenCheckState Slic3r::MachineObject::get_door_open_check_state ( ) const

inline

{ return xcam_door_open_check;};

References xcam_door_open_check.

get_error_code_str()

std::string Slic3r::MachineObject::get_error_code_str ( int error_code )

static

{
    if (error_code < 0) { return std::string();}
 
    char buf[32];
    ::sprintf(buf, "%08X", error_code);
    std::string print_error_str = std::string(buf);
    if (print_error_str.size() > 4) { print_error_str.insert(4, "-"); }
    return print_error_str;
}

Referenced by get_print_error_str().

Here is the caller graph for this function:

get_extruder_id_by_ams_id()

int Slic3r::MachineObject::get_extruder_id_by_ams_id

(

const std::string &

ams_id

)

{
    return m_fila_system->GetExtruderIdByAmsId(ams_id);
}

References m_fila_system.

Referenced by Slic3r::check_filaments_printable(), Slic3r::GUI::SelectMachineDialog::update_show_status(), and Slic3r::GUI::SyncAmsInfoDialog::update_show_status().

Here is the caller graph for this function:

get_filament_display_type()

std::string Slic3r::MachineObject::get_filament_display_type	(	const std::string &	ams_id,
		const std::string &	tray_id ) const

                                                                                                          {
    return this->get_tray(ams_id, tray_id).get_display_filament_type();
}

References Slic3r::DevAmsTray::get_display_filament_type(), and get_tray().

Here is the call graph for this function:

get_filament_id()

std::string Slic3r::MachineObject::get_filament_id	(	std::string	ams_id,
		std::string	tray_id ) const

                                                                                  {
    return this->get_tray(ams_id, tray_id).setting_id;
}

References get_tray(), and Slic3r::DevAmsTray::setting_id.

Referenced by any_loaded_filament_is_stringing_prone(), and Slic3r::GUI::SelectMachineDialog::update_show_status().

Here is the call graph for this function:

Here is the caller graph for this function:

get_filament_type()

std::string Slic3r::MachineObject::get_filament_type	(	const std::string &	ams_id,
		const std::string &	tray_id ) const

                                                                                                  {
    return this->get_tray(ams_id, tray_id).get_filament_type();
}

References Slic3r::DevAmsTray::get_filament_type(), and get_tray().

Referenced by Slic3r::GUI::SelectMachineDialog::on_ok_btn().

Here is the call graph for this function:

Here is the caller graph for this function:

get_file_remote()

int Slic3r::MachineObject::get_file_remote

(

)

{
    if (is_support_agora)
        file_remote = file_remote == FR_None ? FR_Agora : file_remote == FR_Tutk ? FR_TutkAgora : file_remote;
    return file_remote;
}

References file_remote, Slic3r::FR_Agora, Slic3r::FR_None, Slic3r::FR_Tutk, Slic3r::FR_TutkAgora, and is_support_agora.

Referenced by Slic3r::GUI::SendToPrinterDialog::GetConnection(), and Slic3r::GUI::MediaFilePanel::UpdateByObj().

Here is the caller graph for this function:

get_firmware_info()

void Slic3r::MachineObject::get_firmware_info

(

)

{
    m_firmware_valid = false;
    if (m_firmware_thread_started)
        return;
 
    boost::thread update_info_thread = Slic3r::create_thread(
        [&] {
            m_firmware_thread_started = true;
            int          result = 0;
            unsigned int http_code;
            std::string  http_body;
            if (!m_agent) return;
            result = m_agent->get_printer_firmware(get_dev_id(), &http_code, &http_body, Slic3r::GUI::wxGetApp().get_printer_cloud_provider());
            if (result < 0) {
                // get upgrade list failed
                return;
            }
            try {
                json j = json::parse(http_body);
                if (j.contains("devices") && !j["devices"].is_null()) {
                    firmware_list.clear();
                    for (json::iterator it = j["devices"].begin(); it != j["devices"].end(); it++) {
                        if ((*it)["dev_id"].get<std::string>() == this->get_dev_id()) {
                            try {
                                json firmware = (*it)["firmware"];
                                for (json::iterator firmware_it = firmware.begin(); firmware_it != firmware.end(); firmware_it++) {
                                    FirmwareInfo item;
                                    item.version = (*firmware_it)["version"].get<std::string>();
                                    item.url = (*firmware_it)["url"].get<std::string>();
                                    if ((*firmware_it).contains("description"))
                                        item.description = (*firmware_it)["description"].get<std::string>();
                                    item.module_type = "ota";
                                    int name_start = item.url.find_last_of('/') + 1;
                                    if (name_start > 0) {
                                        item.name = item.url.substr(name_start, item.url.length() - name_start);
                                        firmware_list.push_back(item);
                                    }
                                    else {
                                        BOOST_LOG_TRIVIAL(trace) << "skip";
                                    }
                                }
                            }
                            catch (...) {}
                            try {
                                if ((*it).contains("ams")) {
                                    json ams_list = (*it)["ams"];
                                    if (ams_list.size() > 0) {
                                        auto ams_front = ams_list.front();
                                        json firmware_ams = (ams_front)["firmware"];
                                        for (json::iterator ams_it = firmware_ams.begin(); ams_it != firmware_ams.end(); ams_it++) {
                                            FirmwareInfo item;
                                            item.version = (*ams_it)["version"].get<std::string>();
                                            item.url = (*ams_it)["url"].get<std::string>();
                                            if ((*ams_it).contains("description"))
                                                item.description = (*ams_it)["description"].get<std::string>();
                                            item.module_type = "ams";
                                            int name_start = item.url.find_last_of('/') + 1;
                                            if (name_start > 0) {
                                                item.name = item.url.substr(name_start, item.url.length() - name_start);
                                                firmware_list.push_back(item);
                                            }
                                            else {
                                                BOOST_LOG_TRIVIAL(trace) << "skip";
                                            }
                                        }
                                    }
                                }
                            }
                            catch (...) {
                                ;
                            }
                        }
                    }
                }
            }
            catch (...) {
                return;
            }
            m_firmware_thread_started = false;
            m_firmware_valid = true;
        }
    );
    return;
}

References Slic3r::create_thread(), Slic3r::FirmwareInfo::description, firmware_list, get_dev_id(), m_agent, m_firmware_thread_started, m_firmware_valid, Slic3r::FirmwareInfo::module_type, Slic3r::FirmwareInfo::name, Slic3r::trace(), Slic3r::FirmwareInfo::url, and Slic3r::FirmwareInfo::version.

Referenced by Slic3r::GUI::UpgradePanel::refresh_version_and_firmware().

Here is the call graph for this function:

Here is the caller graph for this function:

get_firmware_type_str()

std::string Slic3r::MachineObject::get_firmware_type_str

(

)

{
    /*if (firmware_type == PrinterFirmwareType::FIRMWARE_TYPE_ENGINEER)
        return "engineer";
    else if (firmware_type == PrinterFirmwareType::FIRMWARE_TYPE_PRODUCTION)
        return "product";*/
 
    // return product by default;
    // always return product, printer do not push this field
    return "product";
}

get_flag_bits() [1/2]

int Slic3r::MachineObject::get_flag_bits	(	int	num,
		int	start,
		int	count = 1,
		int	base = 10 ) const

{
    try {
        unsigned long long mask = (1ULL << count) - 1;
        unsigned long long value;
        if (base == 10) {
            value = static_cast<unsigned long long>(num);
        } else if (base == 16) {
            value = static_cast<unsigned long long>(std::stoul(std::to_string(num), nullptr, 16));
        } else {
            throw std::invalid_argument("Unsupported base");
        }
 
        int flag = (value >> start) & mask;
        return flag;
    } catch (...) {
        return 0;
    }
}

References count.

get_flag_bits() [2/2]

int Slic3r::MachineObject::get_flag_bits	(	std::string	str,
		int	start,
		int	count = 1 ) const

{
    try {
        unsigned long long decimal_value = std::stoull(str, nullptr, 16);
        unsigned long long mask = (1ULL << count) - 1;
        int flag = (decimal_value >> start) & mask;
        return flag;
    }
    catch (...) {
        return 0;
    }
}

References count.

Referenced by parse_home_flag(), parse_json(), parse_new_info(), and Slic3r::DevBed::ParseV2_0().

Here is the caller graph for this function:

get_flag_bits_no_border()

uint32_t Slic3r::MachineObject::get_flag_bits_no_border	(	std::string	str,
		int	start_idx,
		int	count = 1 ) const

{
    if (start_idx < 0 || count <= 0) return 0;
 
    try {
        // --- 1) trim ---
        auto ltrim = [](std::string& s) {
            s.erase(s.begin(), std::find_if(s.begin(), s.end(),
                [](unsigned char ch) { return !std::isspace(ch); }));
            };
        auto rtrim = [](std::string& s) {
            s.erase(std::find_if(s.rbegin(), s.rend(),
                [](unsigned char ch) { return !std::isspace(ch); }).base(), s.end());
            };
        ltrim(str); rtrim(str);
 
        // --- 2) remove 0x/0X prefix ---
        if (str.size() >= 2 && str[0] == '0' && (str[1] == 'x' || str[1] == 'X')) {
            str.erase(0, 2);
        }
 
        // --- 3) keep only hex digits ---
        std::string hex;
        hex.reserve(str.size());
        for (char c : str) {
            if (std::isxdigit(static_cast<unsigned char>(c))) hex.push_back(c);
        }
        if (hex.empty()) return 0;
 
        // --- 4) use size_t for all index/bit math ---
        const size_t total_bits = hex.size() * 4ULL;
 
        const size_t ustart = static_cast<size_t>(start_idx);
        if (ustart >= total_bits) return 0;
 
        const int int_bits = std::numeric_limits<uint32_t>::digits; // typically 32
        const size_t need_bits = static_cast<size_t>(std::min(count, int_bits));
 
        // [first_bit, last_bit]
        const size_t first_bit = ustart;
        const size_t last_bit = std::min(ustart + need_bits, total_bits) - 1ULL;
        if (last_bit < first_bit) return 0;
 
 
        const size_t right_index = hex.size() - 1ULL;
 
        const size_t first_nibble = first_bit / 4ULL;
        const size_t last_nibble = last_bit / 4ULL;
 
        const size_t start_idx = right_index - last_nibble;
        const size_t end_idx = right_index - first_nibble;
        if (end_idx < start_idx) return 0;
 
        const size_t sub_len = end_idx - start_idx + 1ULL;
        if (end_idx >= hex.size()) return 0;
 
        const std::string sub_hex = hex.substr(start_idx, sub_len);
 
        unsigned long long chunk = std::stoull(sub_hex, nullptr, 16);
 
        const unsigned nibble_offset = static_cast<unsigned>(first_bit % 4ULL);
        const unsigned long long shifted =
            (nibble_offset == 0U) ? chunk : (chunk >> nibble_offset);
 
        uint32_t mask;
        if (need_bits >= static_cast<size_t>(std::numeric_limits<uint32_t>::digits)) {
            mask = std::numeric_limits<uint32_t>::max();
        }
        else {
            mask = static_cast<uint32_t>((1ULL << need_bits) - 1ULL);
        }
 
        const uint32_t val = static_cast<uint32_t>(shifted & mask);
        return val;
    }
    catch (const std::invalid_argument&) {
        return 0;
    }
    catch (const std::out_of_range&) {
        return 0;
    }
    catch (...) {
        return 0;
    }
}

References count.

Referenced by Slic3r::DevPrintOptionsParser::Parse(), and parse_new_info().

Here is the caller graph for this function:

get_ftp_folder()

std::string Slic3r::MachineObject::get_ftp_folder

(

)

{
    return DevPrinterConfigUtil::get_ftp_folder(printer_type);
}

References Slic3r::DevPrinterConfigUtil::get_ftp_folder(), and printer_type.

Referenced by Slic3r::GUI::SelectMachineDialog::on_send_print(), Slic3r::GUI::SendMultiMachinePage::request_params(), Slic3r::GUI::CalibUtils::send_to_print(), and Slic3r::GUI::CalibUtils::send_to_print().

Here is the call graph for this function:

Here is the caller graph for this function:

get_lan_mode_connection_state()

bool Slic3r::MachineObject::get_lan_mode_connection_state ( )

inline

{return m_lan_mode_connection_state;};

References m_lan_mode_connection_state.

Referenced by Slic3r::GUI::SelectMachineDialog::on_selection_changed(), and Slic3r::GUI::SendToPrinterDialog::on_selection_changed().

Here is the caller graph for this function:

get_lifecycle_type_str()

std::string Slic3r::MachineObject::get_lifecycle_type_str

(

)

{
    /*if (lifecycle == PrinterFirmwareType::FIRMWARE_TYPE_ENGINEER)
        return "engineer";
    else if (lifecycle == PrinterFirmwareType::FIRMWARE_TYPE_PRODUCTION)
        return "product";*/
 
    // return product by default;
    // always return product, printer do not push this field
    return "product";
}

get_liveview_remote()

int Slic3r::MachineObject::get_liveview_remote

(

)

{
    if (is_support_agora) {
        return liveview_remote == LVR_None ? LVR_Agora : liveview_remote == LVR_Tutk ? LVR_TutkAgora : liveview_remote;
    }
    return liveview_remote;
}

References is_support_agora, liveview_remote, Slic3r::LVR_Agora, Slic3r::LVR_None, Slic3r::LVR_Tutk, and Slic3r::LVR_TutkAgora.

Referenced by Slic3r::GUI::MediaPlayCtrl::SetMachineObject().

Here is the caller graph for this function:

get_max_filament_color_count()

int Slic3r::MachineObject::get_max_filament_color_count

(

)

const

{
    if (is_support_filament_32_colors) return 32;
    if (is_enable_ams_np && !is_series_x())              return 20;
    if (!is_series_x() && !is_series_o()) return 16;
    return 0;
}

References is_enable_ams_np, is_series_o(), is_series_x(), and is_support_filament_32_colors.

Referenced by Slic3r::GUI::SelectMachineDialog::update_show_status().

Here is the call graph for this function:

Here is the caller graph for this function:

get_modeltask()

BBLModelTask * Slic3r::MachineObject::get_modeltask

(

)

{
    return model_task;
}

References model_task.

Referenced by Slic3r::GUI::CalibrationCaliPage::update_subtask().

Here is the caller graph for this function:

get_nozzle_mapping_result()

std::shared_ptr< DevNozzleMappingCtrl > Slic3r::MachineObject::get_nozzle_mapping_result ( ) const

inline

{ return m_nozzle_mapping_ptr; }

References m_nozzle_mapping_ptr.

Referenced by Slic3r::GUI::SelectMachineDialog::CheckErrorSyncNozzleMappingResultV0(), Slic3r::GUI::SelectMachineDialog::CheckErrorSyncNozzleMappingResultV1(), Slic3r::GUI::SelectMachineDialog::get_mapped_nozzle_str(), Slic3r::GUI::SelectMachineDialog::get_mapped_nozzles(), Slic3r::GUI::SelectMachineDialog::on_send_print(), Slic3r::GUI::AmsMapingPopup::OnNozzleMappingSelected(), Slic3r::GUI::AmsMapingPopup::update_flush_waste(), and Slic3r::GUI::AmsMapingPopup::update_rack_select().

Here is the caller graph for this function:

get_nozzle_replace_url()

wxString Slic3r::MachineObject::get_nozzle_replace_url ( ) const

nodiscard

{
    const wxString& strLanguage = GUI::wxGetApp().app_config->get("language");
    const wxString& lan_code = strLanguage.BeforeFirst('_');
 
    const json& link_map = DevPrinterConfigUtil::get_json_from_config(printer_type, "print", "nozzle_replace_wiki");
    if (link_map.contains(lan_code.ToStdString())) {
        return link_map[lan_code.ToStdString()].get<wxString>();
    }
 
    if (link_map.contains("en")){
        return link_map["en"].get<wxString>();
    }/*retry with en*/
 
    // Orca: no neutral wiki equivalent for this fallback — return empty so the caller hides the link
    // (PrinterPartsDialog::OnWikiClicked reports "No wiki link available" instead of opening a browser)
    return wxEmptyString;
}

References Slic3r::DevPrinterConfigUtil::get_json_from_config(), and printer_type.

Here is the call graph for this function:

get_ota_version()

std::string Slic3r::MachineObject::get_ota_version

(

)

{
    auto it = module_vers.find("ota");
    if (it != module_vers.end()) {
        //double check name
        if (it->second.name == "ota") {
            return it->second.sw_ver;
        }
    }
    return "";
}

References module_vers.

Referenced by Slic3r::GUI::PartSkipDialog::fetchUrl(), Slic3r::GUI::SendToPrinterDialog::GetConnection(), Slic3r::GUI::SelectMachineDialog::on_send_print(), Slic3r::anonymous_namespace{PluginHostApp.cpp}::selected_printer(), Slic3r::GUI::MediaPlayCtrl::SetMachineObject(), and Slic3r::GUI::MediaFilePanel::UpdateByObj().

Here is the caller graph for this function:

get_preset_extruder_index()

int Slic3r::MachineObject::get_preset_extruder_index ( int extder_id ) const

inline

{ return is_multi_extruders() ? (is_main_extruder_on_left() ? extder_id : 1 - extder_id) : 0; }

References is_main_extruder_on_left(), and is_multi_extruders().

Referenced by check_ams_filament_valid().

Here is the call graph for this function:

Here is the caller graph for this function:

get_print_error_str()

std::string Slic3r::MachineObject::get_print_error_str ( ) const

inline

{ return MachineObject::get_error_code_str(this->print_error); }

References get_error_code_str().

Here is the call graph for this function:

get_printer_ams_type()

std::string Slic3r::MachineObject::get_printer_ams_type

(

)

const

{
    return DevPrinterConfigUtil::get_printer_use_ams_type(printer_type);
}

References Slic3r::DevPrinterConfigUtil::get_printer_use_ams_type(), and printer_type.

Referenced by Slic3r::DevFilaSystemParser::ParseV1_0().

Here is the call graph for this function:

Here is the caller graph for this function:

get_printer_arch()

PrinterArch Slic3r::MachineObject::get_printer_arch

(

)

const

{
    return DevPrinterConfigUtil::get_printer_arch(printer_type);
}

References Slic3r::DevPrinterConfigUtil::get_printer_arch(), and printer_type.

Referenced by is_core_xy(), Slic3r::GUI::CalibrationPAStartPage::on_device_connected(), and Slic3r::GUI::SelectMachineDialog::update_select_layout().

Here is the call graph for this function:

Here is the caller graph for this function:

get_printer_series()

PrinterSeries Slic3r::MachineObject::get_printer_series

(

)

const

{
    std::string series =  DevPrinterConfigUtil::get_printer_series_str(printer_type);
    if (series == "series_x1" || series == "series_o")
        return PrinterSeries::SERIES_X1;
    else if (series == "series_p1p")
        return PrinterSeries::SERIES_P1P;
    else
        return PrinterSeries::SERIES_P1P;
}

References Slic3r::DevPrinterConfigUtil::get_printer_series_str(), printer_type, SERIES_P1P, and SERIES_X1.

Referenced by get_bed_temperature_limit(), Slic3r::GUI::get_cali_filament_mode(), Slic3r::GUI::get_cali_style(), Slic3r::GUI::get_obj_calibration_mode(), is_camera_busy_off(), is_support_command_calibration(), Slic3r::GUI::CalibrationPresetPage::need_check_sdcard(), Slic3r::GUI::CalibrationFlowRateStartPage::on_device_connected(), Slic3r::GUI::CalibrationPAStartPage::on_device_connected(), and parse_version().

Here is the call graph for this function:

Here is the caller graph for this function:

get_printer_series_str()

std::string Slic3r::MachineObject::get_printer_series_str

(

)

const

{ return DevPrinterConfigUtil::get_printer_series_str(printer_type);};

References Slic3r::DevPrinterConfigUtil::get_printer_series_str(), and printer_type.

Here is the call graph for this function:

get_printer_thumbnail_img_str()

std::string Slic3r::MachineObject::get_printer_thumbnail_img_str

(

)

const

{
    std::string img_str = DevPrinterConfigUtil::get_printer_thumbnail_img(printer_type);
    std::string img_url;
 
     if (!img_str.empty())
     {
        img_url = Slic3r::resources_dir() + "\\images\\" + img_str ;
        if (fs::exists(img_url + ".svg"))
        {
            return img_url;
        }
        else
        {
            img_url = img_str;
        }
     }
     else
     {
        img_url =  "printer_thumbnail";
     }
 
    return img_url;
}

References Slic3r::DevPrinterConfigUtil::get_printer_thumbnail_img(), printer_type, and Slic3r::resources_dir().

Referenced by Slic3r::GUI::MachineInfoPanel::update_printer_imgs().

Here is the call graph for this function:

Here is the caller graph for this function:

get_printer_type_display_str()

wxString Slic3r::MachineObject::get_printer_type_display_str

(

)

const

{
    std::string display_name = DevPrinterConfigUtil::get_printer_display_name(printer_type);
 
    // Bambu printers use m_resource_file_path + "/printers/" + type_str + ".json", which is a semantic that only works for their profiles.
    // For any other profile, we can simply consult preset bundle if the model_id exists. 
    if (display_name.empty()) {
        for (const auto& [vendor_id, vendor] : GUI::wxGetApp().preset_bundle->vendors) {
            for (const auto& model : vendor.models) {
                if (printer_type == model.model_id)
                    display_name = model.name;
            }
        }
    }
 
    if (!display_name.empty())
        return display_name;
    else if (printer_type == "orcasonar")
        return "OrcaSonar Printer";
    else
        return _L("Unknown");
}

References _L, Slic3r::DevPrinterConfigUtil::get_printer_display_name(), and printer_type.

Referenced by Slic3r::GUI::_get_tips(), Slic3r::GUI::SelectMachineDialog::show_status(), Slic3r::GUI::SyncAmsInfoDialog::show_status(), and Slic3r::GUI::MachineInfoPanel::update().

Here is the call graph for this function:

Here is the caller graph for this function:

get_resolution_supported()

std::vector< std::string > Slic3r::MachineObject::get_resolution_supported

(

)

{
    return camera_resolution_supported;
}

References camera_resolution_supported.

get_save_remote_print_file_to_storage()

bool Slic3r::MachineObject::get_save_remote_print_file_to_storage ( ) const

inline

{ return xcam__save_remote_print_file_to_storage; };

References xcam__save_remote_print_file_to_storage.

Referenced by command_set_save_remote_print_file_to_storage().

Here is the caller graph for this function:

get_show_printer_type()

std::string Slic3r::MachineObject::get_show_printer_type

(

)

const

{
    std::string printer_type = this->printer_type;
    if (this->is_support_upgrade_kit && this->installed_upgrade_kit)
        printer_type = "C12";
    return printer_type;
}

References installed_upgrade_kit, is_support_upgrade_kit, and printer_type.

Referenced by Slic3r::GUI::Plater::priv::check_ams_status_impl(), Slic3r::GUI::Plater::check_printer_initialized(), Slic3r::GUI::Plater::priv::get_machine_sync_status(), Slic3r::GUI::get_printer_preset(), Slic3r::GUI::Sidebar::need_auto_sync_extruder_list_after_connect_priner(), Slic3r::GUI::Plater::priv::on_select_preset(), Slic3r::GUI::Sidebar::priv::sync_extruder_list(), and Slic3r::GUI::Sidebar::priv::update_sync_status().

Here is the caller graph for this function:

get_stage_remaining_seconds()

int Slic3r::MachineObject::get_stage_remaining_seconds ( ) const

inline

{ return stage_remaining_seconds; }

References stage_remaining_seconds.

Referenced by Slic3r::GUI::ThermalPreconditioningDialog::update_thermal_remaining_time().

Here is the caller graph for this function:

get_subtask()

BBLSubTask * Slic3r::MachineObject::get_subtask

(

)

{
    if (!subtask_)
        subtask_ = new BBLSubTask(nullptr);
    return subtask_;
}

References subtask_.

Referenced by parse_json(), and update_print_progress().

Here is the caller graph for this function:

get_tray()

DevAmsTray Slic3r::MachineObject::get_tray	(	const std::string &	ams_id,
		const std::string &	tray_id ) const

{
    if (ams_id.empty() && tray_id.empty())
    {
        return DevAmsTray(tray_id);
    }
 
    if (ams_id != VIRTUAL_AMS_MAIN_ID_STR && ams_id != VIRTUAL_AMS_DEPUTY_ID_STR) {
        auto tray = m_fila_system->GetAmsTray(ams_id, tray_id);
        if (tray) { return *tray;};
    }
    else {
        for (const auto &tray : vt_slot) {
            if (tray.id == ams_id) { return tray; }
        }
    }
 
    assert(0);/*use contains_tray() check first*/
    return DevAmsTray(tray_id);
}

References m_fila_system, VIRTUAL_AMS_DEPUTY_ID_STR, VIRTUAL_AMS_MAIN_ID_STR, and vt_slot.

Referenced by Slic3r::GUI::_check_kval_not_default(), get_filament_display_type(), get_filament_id(), get_filament_type(), and Slic3r::GUI::SelectMachineDialog::update_show_status().

Here is the caller graph for this function:

get_upgrade_percent()

int Slic3r::MachineObject::get_upgrade_percent

(

)

const

{
    if (upgrade_progress.empty())
        return 0;
    try {
        int result = atoi(upgrade_progress.c_str());
        return result;
    } catch(...) {
        ;
    }
    return 0;
}

References upgrade_progress.

Referenced by Slic3r::GUI::MachineInfoPanel::update(), and Slic3r::GUI::AMSSettingTypePanel::UpdateInfo().

Here is the caller graph for this function:

get_upgrade_result_str()

wxString Slic3r::MachineObject::get_upgrade_result_str

(

int

upgrade_err_code

)

{
    switch(err_code) {
    case UpgradeNoError:
        return _L("Update successful.");
    case UpgradeDownloadFailed:
        return _L("Downloading failed.");
    case UpgradeVerfifyFailed:
        return _L("Verification failed.");
    case UpgradeFlashFailed:
        return _L("Update failed.");
    case UpgradePrinting:
        return _L("Update failed.");
    default:
        return _L("Update failed.");
    }
    return "";
}

References _L, UpgradeDownloadFailed, UpgradeFlashFailed, UpgradeNoError, UpgradePrinting, and UpgradeVerfifyFailed.

Referenced by Slic3r::GUI::MachineInfoPanel::update().

Here is the caller graph for this function:

GetAxis()

std::shared_ptr< DevAxis > Slic3r::MachineObject::GetAxis ( ) const

inline

{ return m_axis; }

References m_axis.

GetBed()

DevBed * Slic3r::MachineObject::GetBed ( ) const

inline

{ return m_bed; };

References m_bed.

GetCalib()

DevCalib * Slic3r::MachineObject::GetCalib ( ) const

inline

{ return m_calib; }

References m_calib.

GetChamber()

std::shared_ptr< DevChamber > Slic3r::MachineObject::GetChamber ( ) const

inline

{ return m_chamber; }

References m_chamber.

GetConfig()

DevConfig * Slic3r::MachineObject::GetConfig ( ) const

inline

{ return m_config; } /* config*/

References m_config.

Referenced by Slic3r::GUI::CalibUtils::send_to_print(), Slic3r::GUI::CalibUtils::send_to_print(), Slic3r::GUI::CalibrationDialog::update_cali(), Slic3r::GUI::SelectMachineDialog::update_option_opts(), Slic3r::GUI::PrintOptionsDialog::update_options(), Slic3r::GUI::CalibrationPresetPage::update_show_status(), Slic3r::GUI::SelectMachineDialog::update_show_status(), and Slic3r::GUI::SyncAmsInfoDialog::update_show_status().

Here is the caller graph for this function:

GetCtrl()

DevCtrl * Slic3r::MachineObject::GetCtrl ( ) const

inline

{ return m_ctrl; }       /* ctrl*/

References m_ctrl.

GetExtderSystem()

DevExtderSystem * Slic3r::MachineObject::GetExtderSystem ( ) const

inline

{ return m_extder_system; }

References m_extder_system.

Referenced by Slic3r::GUI::NewCalibrationHistoryDialog::NewCalibrationHistoryDialog(), Slic3r::GUI::_get_tips(), Slic3r::GUI::Plater::priv::check_ams_status_impl(), Slic3r::GUI::check_nozzle_diameter_and_type(), Slic3r::GUI::CalibUtils::check_printable_status_before_cali(), Slic3r::GUI::CalibUtils::check_printable_status_before_cali(), Slic3r::GUI::Plater::check_printer_initialized(), Slic3r::GUI::SelectMachineDialog::CheckErrorExtruderNozzleWithSlicing(), Slic3r::GUI::SelectMachineDialog::CheckWarningFilamentCrossExtruder(), Slic3r::GUI::SelectMachineDialog::do_ams_mapping(), Slic3r::GUI::NewCalibrationHistoryDialog::get_all_filaments(), Slic3r::GUI::SelectMachineDialog::get_mapped_nozzles(), Slic3r::GUI::get_printer_preset(), Slic3r::GUI::CalibrationCaliPage::get_selected_calibration_nozzle_dia(), Slic3r::DevNozzle::GetTotalExtruderCount(), Slic3r::GUI::CalibrationPresetPage::init_with_machine(), Slic3r::GUI::is_same_nozzle_type(), Slic3r::GUI::SyncAmsInfoDialog::is_same_nozzle_type(), Slic3r::GUI::Plater::priv::on_select_preset(), Slic3r::GUI::SelectMachineDialog::on_timer(), Slic3r::GUI::SyncAmsInfoDialog::on_timer(), Slic3r::GUI::Sidebar::priv::sync_extruder_list(), Slic3r::GUI::AmsMapingPopup::update(), Slic3r::GUI::CalibrationCaliPage::update(), Slic3r::GUI::PressureAdvanceWizard::update(), Slic3r::GUI::SelectMachineDialog::update_filament_change_count(), Slic3r::GUI::AMSDryCtrWin::update_filament_list(), Slic3r::GUI::AmsReplaceMaterialDialog::update_machine_obj(), Slic3r::GUI::SelectMachineDialog::update_material_item_pos(), Slic3r::GUI::AMSDryCtrWin::update_printer_state(), Slic3r::GUI::SelectMachineDialog::update_show_status(), Slic3r::GUI::SyncAmsInfoDialog::update_show_status(), Slic3r::GUI::Sidebar::priv::update_sync_status(), and Slic3r::GUI::ExtruderSwithingStatus::updateBy().

Here is the caller graph for this function:

GetExtensionTool()

std::weak_ptr< DevExtensionTool > Slic3r::MachineObject::GetExtensionTool ( ) const

inline

{ return m_extension_tool; }

References m_extension_tool.

Referenced by Slic3r::GUI::SelectMachineDialog::UpdateStatusCheckWarning_ExtensionTool().

Here is the caller graph for this function:

GetFan()

DevFan * Slic3r::MachineObject::GetFan ( ) const

inline

{ return m_fan; }

References m_fan.

Referenced by Slic3r::GUI::FanControlPopupNew::update_fan_data(), and Slic3r::GUI::PrintOptionsDialog::update_purify_air_at_print_end().

Here is the caller graph for this function:

GetFilaSwitch()

DevFilaSwitch * Slic3r::MachineObject::GetFilaSwitch ( ) const

inline

{ return m_fila_switch;}

References m_fila_switch.

Referenced by Slic3r::GUI::SelectMachineDialog::can_hybrid_mapping(), Slic3r::GUI::SelectMachineDialog::CheckErrorDynamicSwitchNozzle(), Slic3r::GUI::SelectMachineDialog::get_filament_change_gap_time(), Slic3r::GUI::SelectMachineDialog::get_filament_suggest_pos(), Slic3r::GUI::SelectMachineDialog::get_mapped_nozzle_str(), Slic3r::GUI::SyncAmsInfoDialog::has_selector(), Slic3r::GUI::AMSControl::isFilaSwitchReady(), Slic3r::GUI::SelectMachineDialog::on_ok_btn(), Slic3r::DevFilaSystemParser::ParseV1_0(), Slic3r::GUI::sCheckFilamentInfo(), Slic3r::GUI::CalibrationPresetPage::sync_ams_info(), Slic3r::GUI::SelectMachineDialog::sync_ams_mapping_result(), Slic3r::GUI::Sidebar::priv::sync_extruder_list(), Slic3r::GUI::AmsMapingPopup::update_ams_tips(), Slic3r::GUI::AmsReplaceMaterialDialog::update_machine_obj(), Slic3r::GUI::SelectMachineDialog::update_material_item_pos(), Slic3r::GUI::SelectMachineDialog::update_show_status(), and Slic3r::GUI::Sidebar::priv::update_sync_status().

Here is the caller graph for this function:

GetFilaSystem()

std::shared_ptr< DevFilaSystem > Slic3r::MachineObject::GetFilaSystem ( ) const

inline

{ return m_fila_system;}

References m_fila_system.

Referenced by Slic3r::_get_filament_name_from_ams(), Slic3r::DevMappingUtil::ams_filament_mapping(), Slic3r::MoonrakerPrinterAgent::build_ams_payload(), Slic3r::GUI::Sidebar::build_filament_ams_list(), Slic3r::GUI::ReselectMachineDialog::CaculateSwitcherDistribution(), Slic3r::GUI::FeedDirectionDialog::calcTrayName(), Slic3r::GUI::Plater::priv::check_ams_status_impl(), Slic3r::GUI::SyncAmsInfoDialog::deal_only_exist_ext_spool(), Slic3r::GUI::SelectMachineDialog::do_ams_mapping(), Slic3r::DevCalib::ExtrusionCalibGetResultParse(), Slic3r::DevCalib::ExtrusionCalibSelectParse(), Slic3r::DevCalib::ExtrusionCalibSetParse(), Slic3r::GUI::SelectMachineDialog::get_filament_change_gap_time(), Slic3r::GUI::SelectMachineDialog::get_filament_suggest_pos(), Slic3r::DevExtderSystem::GetBackupAmsSlotInGroup(), Slic3r::GUI::ReselectMachineDialog::getTrayID(), Slic3r::GUI::SelectMachineDialog::is_ams_drying(), Slic3r::GUI::SelectMachineDialog::is_at_suggested_pos(), Slic3r::GUI::SelectMachineDialog::is_selected_ams_drying(), Slic3r::DevMappingUtil::is_valid_mapping_result(), Slic3r::GUI::SelectMachineDialog::on_ok_btn(), Slic3r::GUI::SelectMachineDialog::on_timer(), Slic3r::GUI::SyncAmsInfoDialog::on_timer(), Slic3r::GUI::AMSControl::parse_object(), Slic3r::GUI::sCheckFilamentInfo(), Slic3r::GUI::FilamentLoad::SetupSteps(), Slic3r::GUI::ExtruderGroup::sync_ams(), Slic3r::GUI::CalibrationPresetPage::sync_ams_info(), Slic3r::GUI::Sidebar::priv::sync_extruder_list(), Slic3r::GUI::AmsMapingPopup::update(), Slic3r::GUI::TrayListModel::update(), Slic3r::GUI::MachineInfoPanel::update_ams_ext(), Slic3r::GUI::AMSSetting::update_ams_img(), Slic3r::GUI::AMSDryCtrWin::update_filament_list(), Slic3r::GUI::AMSSetting::update_insert_material_read_mode(), Slic3r::GUI::AmsMapingPopup::update_mapping_items(), Slic3r::GUI::SelectMachineDialog::update_show_status(), Slic3r::GUI::Sidebar::priv::update_sync_status(), Slic3r::GUI::AMSControl::UpdateAmsDryControl(), Slic3r::GUI::AMSSetting::UpdateByObj(), Slic3r::GUI::AMSSettingTypePanel::UpdateInfo(), and Slic3r::GUI::ReselectMachineDialog::UpdateInfo().

Here is the caller graph for this function:

GetHMS()

DevHMS * Slic3r::MachineObject::GetHMS ( ) const

inline

{ return m_hms_system; }   /* hms*/

References m_hms_system.

GetLamp()

DevLamp * Slic3r::MachineObject::GetLamp ( ) const

inline

{ return m_lamp; }

References m_lamp.

GetNozzleSystem()

DevNozzleSystem * Slic3r::MachineObject::GetNozzleSystem ( ) const

inline

{ return m_nozzle_system;}

References m_nozzle_system.

Referenced by Slic3r::GUI::EditCalibrationHistoryDialog::EditCalibrationHistoryDialog(), Slic3r::GUI::_is_rack_managed_nozzle(), Slic3r::GUI::Plater::priv::check_ams_status_impl(), Slic3r::GUI::SelectMachineDialog::CheckErrorExtruderNozzleWithSlicing(), Slic3r::GUI::SelectMachineDialog::CheckErrorRackStatus(), Slic3r::GUI::SelectMachineDialog::CheckErrorSyncNozzleMappingResultV0(), Slic3r::GUI::SelectMachineDialog::CheckErrorSyncNozzleMappingResultV1(), Slic3r::GUI::SelectMachineDialog::CheckWarningRackStatus(), Slic3r::GUI::SelectMachineDialog::get_mapped_nozzle_str(), Slic3r::GUI::SelectMachineDialog::get_mapped_nozzles(), Slic3r::GUI::Sidebar::priv::get_nozzle_options(), Slic3r::DevNozzleMappingCtrl::GetFlushWeight(), Slic3r::DevFilaSystem::GetNozzleFlowStringByAmsId(), Slic3r::DevNozzle::GetTotalExtruderCount(), Slic3r::GUI::SelectMachineDialog::on_flow_cali_option_changed(), Slic3r::GUI::SelectMachineDialog::on_pa_value_option_changed(), Slic3r::GUI::AmsMapingPopup::OnNozzleMappingSelected(), Slic3r::GUI::sCheckFilamentInfo(), Slic3r::GUI::SelectMachineDialog::sync_ams_mapping_result(), Slic3r::GUI::tryPopUpMultiNozzleDialog(), Slic3r::GUI::MachineInfoPanel::update_nozzle_rack(), and Slic3r::GUI::AmsMapingPopup::update_rack_select().

Here is the caller graph for this function:

GetPrintingSpeedLevel()

Slic3r::DevPrintingSpeedLevel Slic3r::MachineObject::GetPrintingSpeedLevel

(

)

const

{
    return m_print_options->GetPrintingSpeedLevel();
}

References m_print_options.

GetPrintOptions()

DevPrintOptions * Slic3r::MachineObject::GetPrintOptions ( ) const

inline

{ return m_print_options; } /* print options */

References m_print_options.

Referenced by Slic3r::GUI::SelectMachineDialog::CheckWarningSmartNozzleBlobAuto(), Slic3r::GUI::PrintOptionsDialog::update_options(), Slic3r::GUI::PrintOptionsDialog::update_purify_air_at_print_end(), and Slic3r::GUI::SelectMachineDialog::update_show_status().

Here is the caller graph for this function:

GetStatus()

DevStatus * Slic3r::MachineObject::GetStatus ( ) const

inline

{ return m_status; }

References m_status.

GetStorage()

DevStorage * Slic3r::MachineObject::GetStorage ( ) const

inline

{ return m_storage; }

References m_storage.

Referenced by Slic3r::MoonrakerPrinterAgent::build_ams_payload(), Slic3r::GUI::SelectMachineDialog::check_sdcard_for_timelpase(), Slic3r::GUI::SendToPrinterDialog::on_ok(), Slic3r::GUI::SelectMachineDialog::on_send_print(), Slic3r::GUI::SendMultiMachinePage::request_params(), Slic3r::GUI::CalibUtils::send_to_print(), Slic3r::GUI::CalibUtils::send_to_print(), Slic3r::GUI::SelectMachineDialog::show_timelapse_folder_popup(), Slic3r::GUI::CalibrationPresetPage::update_show_status(), Slic3r::GUI::SelectMachineDialog::update_show_status(), Slic3r::GUI::SendToPrinterDialog::update_show_status(), Slic3r::GUI::SyncAmsInfoDialog::update_show_status(), and Slic3r::GUI::MediaFilePanel::UpdateByObj().

Here is the caller graph for this function:

GetUpgrade()

std::weak_ptr< DevUpgrade > Slic3r::MachineObject::GetUpgrade ( ) const

inline

{ return m_upgrade; }

References m_upgrade.

has_access_right()

bool Slic3r::MachineObject::has_access_right

(

)

const

{
    return !m_access_revoked && (printer_agent_id == MOONRAKER_PRINTER_AGENT_ID || !get_access_code().empty());
}

References get_access_code(), m_access_revoked, Slic3r::MOONRAKER_PRINTER_AGENT_ID, and printer_agent_id.

Referenced by Slic3r::DeviceManager::load_local_machines_from_config(), Slic3r::GUI::GUI_App::select_machine(), set_access_code(), Slic3r::GUI::SyncAmsInfoDialog::update_lan_machine_list(), Slic3r::DeviceManager::update_local_machine(), Slic3r::GUI::SelectMachinePopup::update_other_devices(), and Slic3r::GUI::SyncAmsInfoDialog::update_user_printer().

Here is the call graph for this function:

Here is the caller graph for this function:

HasAms()

bool Slic3r::MachineObject::HasAms

(

)

const

{
    return m_fila_system->HasAms();
}

References m_fila_system.

Referenced by can_unload_filament(), Slic3r::GUI::SelectMachineDialog::do_ams_mapping(), Slic3r::GUI::SelectMachineDialog::on_send_print(), Slic3r::GUI::CalibrationPresetPage::sync_ams_info(), and Slic3r::GUI::SelectMachineDialog::update_ams_check().

Here is the caller graph for this function:

HasRecentCloudMessage()

bool Slic3r::MachineObject::HasRecentCloudMessage

(

)

{
    auto curr_time = std::chrono::system_clock::now();
    auto diff = std::chrono::duration_cast<std::chrono::milliseconds>(curr_time - last_cloud_msg_time_);
    return diff.count() < 5000;
}

References Slic3r::diff(), and last_cloud_msg_time_.

Here is the call graph for this function:

HasRecentLanMessage()

bool Slic3r::MachineObject::HasRecentLanMessage

(

)

{
    auto curr_time = std::chrono::system_clock::now();
    auto diff = std::chrono::duration_cast<std::chrono::milliseconds>(curr_time - last_lan_msg_time_);
    return diff.count() < 5000;
}

References Slic3r::diff(), and last_lan_msg_time_.

Here is the call graph for this function:

is_avaliable()

bool Slic3r::MachineObject::is_avaliable ( )

inline

{ return bind_state == "free"; }

References bind_state.

Referenced by Slic3r::GUI::SyncAmsInfoDialog::update_lan_machine_list(), Slic3r::GUI::SelectMachinePopup::update_other_devices(), and Slic3r::GUI::SyncAmsInfoDialog::update_user_printer().

Here is the caller graph for this function:

is_axis_at_home()

bool Slic3r::MachineObject::is_axis_at_home

(

std::string

axis

)

{
    if (m_home_flag == 0) { return true; }
 
    if (axis == "X") {
        return (m_home_flag & 1) == 1;
    } else if (axis == "Y") {
        return ((m_home_flag >> 1) & 1) == 1;
    } else if (axis == "Z") {
        return ((m_home_flag >> 2) & 1) == 1;
    }
 
    return true;
}

References m_home_flag.

is_calibration_done()

bool Slic3r::MachineObject::is_calibration_done

(

)

{
    return calibration_done;
}

References calibration_done.

Referenced by Slic3r::GUI::CalibrationDialog::update_cali().

Here is the caller graph for this function:

is_calibration_running()

bool Slic3r::MachineObject::is_calibration_running

(

)

{
    if (is_in_calibration() && is_in_printing_status(print_status))
        return true;
    return false;
}

References is_in_calibration(), is_in_printing_status(), and print_status.

Referenced by Slic3r::GUI::CalibrationDialog::update_cali().

Here is the call graph for this function:

Here is the caller graph for this function:

is_camera_busy_off()

bool Slic3r::MachineObject::is_camera_busy_off

(

)

{
    if (get_printer_series() == PrinterSeries::SERIES_P1P)
        return is_in_prepare() || is_in_upgrading();
    return false;
}

References get_printer_series(), is_in_prepare(), is_in_upgrading(), and SERIES_P1P.

Referenced by Slic3r::GUI::SendToPrinterDialog::GetConnection(), Slic3r::GUI::MediaPlayCtrl::SetMachineObject(), and Slic3r::GUI::MediaFilePanel::UpdateByObj().

Here is the call graph for this function:

Here is the caller graph for this function:

is_cloud_mode_printer()

bool Slic3r::MachineObject::is_cloud_mode_printer ( ) const

inline

{ return dev_connection_type == "cloud"; }

References dev_connection_type.

is_connected()

bool Slic3r::MachineObject::is_connected

(

)

{
    std::chrono::system_clock::time_point curr_time = std::chrono::system_clock::now();
    auto diff = std::chrono::duration_cast<std::chrono::milliseconds>(curr_time - last_update_time);
    if (diff.count() > DISCONNECT_TIMEOUT) {
        BOOST_LOG_TRIVIAL(trace) << "machine_object: dev_id=" << dev_id <<", diff count = " << diff.count();
        return false;
    }
 
    if (!is_lan_mode_printer()) {
        NetworkAgent* m_agent = Slic3r::GUI::wxGetApp().getAgent();
        if (m_agent) {
            return m_agent->is_server_connected(Slic3r::GUI::wxGetApp().get_printer_cloud_provider());
        }
    }
    return true;
}

References dev_id, Slic3r::diff(), DISCONNECT_TIMEOUT, is_lan_mode_printer(), last_update_time, m_agent, and Slic3r::trace().

Referenced by Slic3r::GUI::_collect_sorted_machines(), is_connecting(), Slic3r::GUI::SelectMachineDialog::on_send_print(), Slic3r::anonymous_namespace{PluginHostApp.cpp}::selected_printer(), Slic3r::GUI::CalibrationCaliPage::update(), Slic3r::GUI::MachineInfoPanel::update(), Slic3r::GUI::CalibrationPresetPage::update_show_status(), and Slic3r::GUI::SideTools::update_status().

Here is the call graph for this function:

Here is the caller graph for this function:

is_connecting()

bool Slic3r::MachineObject::is_connecting

(

)

{
    return is_connected() && m_push_count == 0;
}

References is_connected(), and m_push_count.

Referenced by Slic3r::GUI::GUI_App::on_start_subscribe_again(), Slic3r::GUI::CalibrationCaliPage::update(), Slic3r::GUI::CalibrationPresetPage::update_show_status(), and Slic3r::GUI::SideTools::update_status().

Here is the call graph for this function:

Here is the caller graph for this function:

is_core_xy()

bool Slic3r::MachineObject::is_core_xy

(

)

{
    if (get_printer_arch() == PrinterArch::ARCH_CORE_XY)
        return true;
    return false;
}

References ARCH_CORE_XY, and get_printer_arch().

Referenced by command_axis_control().

Here is the call graph for this function:

Here is the caller graph for this function:

is_extrusion_cali_finished()

bool Slic3r::MachineObject::is_extrusion_cali_finished

(

)

{
    auto curr_time = std::chrono::system_clock::now();
    auto diff = std::chrono::duration_cast<std::chrono::milliseconds>(curr_time - last_extrusion_cali_start_time);
    if (diff.count() < EXTRUSION_OMIT_TIME) {
        return false;
    }
 
    if (boost::contains(m_gcode_file, "extrusion_cali")
        && this->mc_print_percent == 100)
        return true;
    else
        return false;
}

References Slic3r::diff(), EXTRUSION_OMIT_TIME, last_extrusion_cali_start_time, m_gcode_file, and mc_print_percent.

Here is the call graph for this function:

is_fdm_type()

bool Slic3r::MachineObject::is_fdm_type ( ) const

inline

{ return m_device_mode == DEVICE_MODE_FDM; }

References DEVICE_MODE_FDM, and m_device_mode.

Referenced by Slic3r::GUI::SelectMachineDialog::update_show_status(), and Slic3r::GUI::AMSControl::UpdateAms().

Here is the caller graph for this function:

is_filament_at_extruder()

bool Slic3r::MachineObject::is_filament_at_extruder

(

)

{
    if (hw_switch_state == 1)
        return true;
    else if (hw_switch_state == 0)
        return false;
    else {
       //default
        return true;
    }
}

References hw_switch_state.

is_filament_installed()

bool Slic3r::MachineObject::is_filament_installed

(

)

{
    if (m_extder_system->GetTotalExtderCount() > 0) {
        // right//or single
        auto ext = m_extder_system->m_extders[MAIN_EXTRUDER_ID];
        if (ext.m_ext_has_filament) {
            return true;
        }
    }
    /*left*/
    if (m_extder_system->GetTotalExtderCount() > 1) {
        auto ext = m_extder_system->m_extders[DEPUTY_EXTRUDER_ID];
        if (ext.m_ext_has_filament) {
            return true;
        }
    }
    return false;
}

References DEPUTY_EXTRUDER_ID, m_extder_system, and MAIN_EXTRUDER_ID.

is_firmware_info_valid()

bool Slic3r::MachineObject::is_firmware_info_valid

(

)

{
    return m_firmware_valid;
}

References m_firmware_valid.

is_in_calibration()

bool Slic3r::MachineObject::is_in_calibration

(

)

{
    // gcode file: auto_cali_for_user.gcode or auto_cali_for_user_param
    if (boost::contains(m_gcode_file, "auto_cali_for_user")
        && stage_curr != 0) {
        return true;
    } else {
        // reset
        if (stage_curr != 0) {
            calibration_done = false;
        }
    }
    return false;
}

References calibration_done, m_gcode_file, and stage_curr.

Referenced by is_calibration_running(), is_system_printing(), and Slic3r::GUI::CalibrationCaliPage::update_subtask().

Here is the caller graph for this function:

is_in_extrusion_cali()

bool Slic3r::MachineObject::is_in_extrusion_cali

(

)

{
    auto curr_time = std::chrono::system_clock::now();
    auto diff = std::chrono::duration_cast<std::chrono::milliseconds>(curr_time - last_extrusion_cali_start_time);
    if (diff.count() < EXTRUSION_OMIT_TIME) {
        mc_print_percent = 0;
        return true;
    }
 
    if (is_in_printing_status(print_status)
        && print_type == "system"
        && boost::contains(m_gcode_file, "extrusion_cali")
        )
    {
        return true;
    }
    return false;
}

References Slic3r::diff(), EXTRUSION_OMIT_TIME, is_in_printing_status(), last_extrusion_cali_start_time, m_gcode_file, mc_print_percent, print_status, and print_type.

Referenced by command_stop_extrusion_cali().

Here is the call graph for this function:

Here is the caller graph for this function:

is_in_prepare()

bool Slic3r::MachineObject::is_in_prepare

(

)

{
    return print_status == "PREPARE";
}

References print_status.

Referenced by is_camera_busy_off(), and Slic3r::GUI::CalibrationCaliPage::update_subtask().

Here is the caller graph for this function:

is_in_printing()

bool Slic3r::MachineObject::is_in_printing

(

)

{
    /* use print_status if print_status is valid */
    if (!print_status.empty())
        return MachineObject::is_in_printing_status(print_status);
    else {
        return MachineObject::is_in_printing_status(iot_print_status);
    }
    return false;
}

References iot_print_status, is_in_printing_status(), and print_status.

Referenced by command_go_home(), Slic3r::GUI::FlowRateWizard::on_device_connected(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_device_connected(), Slic3r::GUI::PressureAdvanceWizard::on_device_connected(), Slic3r::GUI::CalibUtils::send_to_print(), Slic3r::GUI::CalibUtils::send_to_print(), Slic3r::GUI::CalibrationDialog::update_cali(), Slic3r::GUI::SelectMachinePopup::update_other_devices(), Slic3r::GUI::AMSDryCtrWin::update_printer_state(), Slic3r::GUI::PrintOptionsDialog::update_purify_air_at_print_end(), Slic3r::GUI::CalibrationPresetPage::update_show_status(), Slic3r::GUI::SelectMachineDialog::update_show_status(), Slic3r::GUI::SyncAmsInfoDialog::update_show_status(), and Slic3r::GUI::CalibrationCaliPage::update_subtask().

Here is the call graph for this function:

Here is the caller graph for this function:

is_in_printing_pause()

bool Slic3r::MachineObject::is_in_printing_pause

(

)

const

{
    return print_status == "PAUSE";
}

References print_status.

is_in_printing_status()

bool Slic3r::MachineObject::is_in_printing_status ( std::string status )

static

{
    if (status.compare("PAUSE") == 0
        || status.compare("RUNNING") == 0
        || status.compare("SLICING") == 0
        || status.compare("PREPARE") == 0) {
        return true;
    }
    return false;
}

Referenced by can_abort(), is_calibration_running(), is_in_extrusion_cali(), is_in_printing(), is_system_printing(), and Slic3r::GUI::PrintJob::process().

Here is the caller graph for this function:

is_in_upgrading()

bool Slic3r::MachineObject::is_in_upgrading

(

)

const

{
    return upgrade_display_state == DevFirmwareUpgradingState::UpgradingInProgress;
}

References upgrade_display_state, and Slic3r::UpgradingInProgress.

Referenced by is_camera_busy_off(), Slic3r::GUI::CalibUtils::send_to_print(), Slic3r::GUI::CalibUtils::send_to_print(), Slic3r::GUI::CalibrationPresetPage::update_show_status(), Slic3r::GUI::SelectMachineDialog::update_show_status(), Slic3r::GUI::SendToPrinterDialog::update_show_status(), and Slic3r::GUI::SyncAmsInfoDialog::update_show_status().

Here is the caller graph for this function:

is_info_ready()

bool Slic3r::MachineObject::is_info_ready

(

bool

check_version = true

)

const

{
    if (check_version && module_vers.empty())
    {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": not ready, failed to check version";
        return false;
    }
 
    std::chrono::system_clock::time_point curr_time = std::chrono::system_clock::now();
    auto diff = std::chrono::duration_cast<std::chrono::microseconds>(last_push_time - curr_time);
    if (m_full_msg_count > 0 && m_push_count > 0 && diff.count() < PUSHINFO_TIMEOUT) {
        return true;
    }
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__
        << ": not ready, m_full_msg_count=" << m_full_msg_count
        << ", m_push_count=" << m_push_count
        << ", diff.count()=" << diff.count()
        << ", dev_id=" << dev_id;
    return false;
}

References dev_id, Slic3r::diff(), last_push_time, m_full_msg_count, m_push_count, module_vers, and PUSHINFO_TIMEOUT.

Referenced by Slic3r::GUI::SyncAmsInfoDialog::on_timer(), Slic3r::GUI::MediaPlayCtrl::SetMachineObject(), Slic3r::GUI::CalibrationPresetPage::update_combobox_filaments(), Slic3r::GUI::SelectMachineDialog::update_show_status(), Slic3r::GUI::SendToPrinterDialog::update_show_status(), Slic3r::GUI::SyncAmsInfoDialog::update_show_status(), Slic3r::GUI::Sidebar::priv::update_sync_status(), and Slic3r::GUI::MediaFilePanel::UpdateByObj().

Here is the call graph for this function:

Here is the caller graph for this function:

is_lan_mode_printer()

bool Slic3r::MachineObject::is_lan_mode_printer ( ) const

inline

{ return dev_connection_type == "lan"; }

References dev_connection_type.

Referenced by command_ams_calibrate(), command_ams_refresh_rfid(), command_ams_select_tray(), command_auto_leveling(), command_axis_control(), command_go_home(), command_set_bed(), command_set_nozzle(), command_xyz_abs(), Slic3r::GUI::PartSkipDialog::fetchUrl(), is_connected(), Slic3r::GUI::SendToPrinterDialog::on_ok(), Slic3r::GUI::SelectMachineDialog::on_send_print(), Slic3r::DeviceManagerRefresher::on_timer(), parse_json(), Slic3r::GUI::GUI_App::process_network_msg(), publish_json(), Slic3r::GUI::CalibUtils::send_to_print(), Slic3r::GUI::CalibUtils::send_to_print(), set_access_code(), Slic3r::GUI::MediaPlayCtrl::SetMachineObject(), Slic3r::GUI::SyncAmsInfoDialog::update_lan_machine_list(), Slic3r::DeviceManager::update_local_machine(), Slic3r::GUI::SelectMachinePopup::update_other_devices(), Slic3r::GUI::CalibrationPresetPage::update_show_status(), Slic3r::GUI::SelectMachineDialog::update_show_status(), Slic3r::GUI::SendToPrinterDialog::update_show_status(), Slic3r::GUI::SyncAmsInfoDialog::update_show_status(), Slic3r::GUI::SideTools::update_status(), Slic3r::GUI::SyncAmsInfoDialog::update_user_printer(), and Slic3r::GUI::MediaFilePanel::UpdateByObj().

Here is the caller graph for this function:

is_local()

bool Slic3r::MachineObject::is_local ( )

inline

{ return !get_dev_ip().empty(); }

References get_dev_ip().

Here is the call graph for this function:

is_main_extruder_on_left()

bool Slic3r::MachineObject::is_main_extruder_on_left ( ) const

inline

{ return false;  } // only means the extruder is on the left hand when extruder id is 0

Referenced by Slic3r::GUI::Plater::priv::check_ams_status_impl(), Slic3r::GUI::SelectMachineDialog::do_ams_mapping(), get_preset_extruder_index(), Slic3r::GUI::CalibrationPresetPage::init_with_machine(), Slic3r::GUI::Sidebar::priv::sync_extruder_list(), and Slic3r::GUI::Sidebar::priv::update_sync_status().

Here is the caller graph for this function:

is_makeworld_subtask()

bool Slic3r::MachineObject::is_makeworld_subtask

(

)

{
    if (model_task && model_task->design_id > 0) {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " model task id: " << model_task->task_id << " is makeworld model";
        return true;
    }
    return false;
}

References model_task.

is_multi_extruders()

bool Slic3r::MachineObject::is_multi_extruders

(

)

const

{
    return m_extder_system->GetTotalExtderCount() > 1;
}

References m_extder_system.

Referenced by Slic3r::GUI::EditCalibrationHistoryDialog::EditCalibrationHistoryDialog(), Slic3r::GUI::CalibrationWizard::cache_preset_info(), Slic3r::GUI::CalibUtils::calib_generic_auto_pa_cali(), Slic3r::GUI::Plater::priv::check_ams_status_impl(), Slic3r::check_filaments_printable(), Slic3r::GUI::CalibUtils::check_printable_status_before_cali(), Slic3r::GUI::CalibUtils::check_printable_status_before_cali(), Slic3r::GUI::CalibrationPresetPage::create_ams_items_sizer(), Slic3r::GUI::Plater::priv::get_extruder_filament_info(), get_preset_extruder_index(), Slic3r::GUI::CalibrationPresetPage::init_with_machine(), Slic3r::GUI::Sidebar::need_auto_sync_extruder_list_after_connect_priner(), Slic3r::GUI::HistoryWindow::on_device_connected(), Slic3r::GUI::Plater::priv::on_select_preset(), Slic3r::GUI::CalibrationPresetPage::sync_ams_info(), and Slic3r::GUI::HistoryWindow::sync_history_result().

Here is the caller graph for this function:

is_nozzle_flow_type_supported()

bool Slic3r::MachineObject::is_nozzle_flow_type_supported ( ) const

inlinenodiscard

{ return is_enable_np | has_extra_flow_type; };

References has_extra_flow_type, and is_enable_np.

Referenced by Slic3r::GUI::SelectMachineDialog::CheckErrorExtruderNozzleWithSlicing(), Slic3r::GUI::Sidebar::priv::sync_extruder_list(), and Slic3r::GUI::Sidebar::priv::update_sync_status().

Here is the caller graph for this function:

is_online()

bool Slic3r::MachineObject::is_online ( )

inline

{ return m_is_online; }

References m_is_online.

Referenced by Slic3r::GUI::_collect_sorted_machines(), Slic3r::anonymous_namespace{PluginHostApp.cpp}::selected_printer(), Slic3r::GUI::SyncAmsInfoDialog::update_lan_machine_list(), Slic3r::GUI::SideTools::update_status(), and Slic3r::GUI::SyncAmsInfoDialog::update_user_printer().

Here is the caller graph for this function:

is_printing_finished()

bool Slic3r::MachineObject::is_printing_finished

(

)

{
    if (print_status.compare("FINISH") == 0
        || print_status.compare("FAILED") == 0) {
        return true;
    }
    return false;
}

References print_status.

Referenced by Slic3r::GUI::FlowRateWizard::on_device_connected(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_device_connected(), Slic3r::GUI::PressureAdvanceWizard::on_device_connected(), and Slic3r::GUI::CalibrationCaliPage::update().

Here is the caller graph for this function:

is_recording()

bool Slic3r::MachineObject::is_recording

(

)

{
    return camera_recording;
}

References camera_recording.

is_recording_enable()

bool Slic3r::MachineObject::is_recording_enable

(

)

{
    return camera_recording_when_printing;
}

References camera_recording_when_printing.

is_sdcard_printing()

bool Slic3r::MachineObject::is_sdcard_printing

(

)

{
    if (can_abort()
        && (obj_subtask_id.compare("0") == 0 || obj_subtask_id.empty())
        && (profile_id_ == "0" || profile_id_.empty())
        && (project_id_ == "0" || project_id_.empty()))
        return true;
    else
        return false;
}

References can_abort(), obj_subtask_id, profile_id_, and project_id_.

Here is the call graph for this function:

is_security_control_ready()

bool Slic3r::MachineObject::is_security_control_ready

(

)

const

{
    return device_cert_installed;
}

References device_cert_installed.

is_series_n() [1/2]

bool Slic3r::MachineObject::is_series_n

(

)

const

{ return is_series_n(DevPrinterConfigUtil::get_printer_series_str(printer_type)); }

References Slic3r::DevPrinterConfigUtil::get_printer_series_str(), is_series_n(), and printer_type.

Referenced by is_series_n().

Here is the call graph for this function:

Here is the caller graph for this function:

is_series_n() [2/2]

bool Slic3r::MachineObject::is_series_n ( const std::string & series_str )

static

{ return series_str == "series_n";  }

Referenced by Slic3r::GUI::AMSextruder::updateNozzleNum().

Here is the caller graph for this function:

is_series_o() [1/2]

bool Slic3r::MachineObject::is_series_o

(

)

const

{ return is_series_o(DevPrinterConfigUtil::get_printer_series_str(printer_type)); }

References Slic3r::DevPrinterConfigUtil::get_printer_series_str(), is_series_o(), and printer_type.

Referenced by get_max_filament_color_count(), is_series_o(), parse_home_flag(), and parse_new_info().

Here is the call graph for this function:

Here is the caller graph for this function:

is_series_o() [2/2]

bool Slic3r::MachineObject::is_series_o ( const std::string & series_str )

static

{ return series_str == "series_o";  }

Referenced by Slic3r::GUI::MachineInfoPanel::update_ams_ext(), and Slic3r::GUI::MachineInfoPanel::update_amshub().

Here is the caller graph for this function:

is_series_p() [1/2]

bool Slic3r::MachineObject::is_series_p

(

)

const

{ return is_series_p(DevPrinterConfigUtil::get_printer_series_str(printer_type)); }

References Slic3r::DevPrinterConfigUtil::get_printer_series_str(), is_series_p(), and printer_type.

Referenced by is_series_p(), parse_home_flag(), and parse_new_info().

Here is the call graph for this function:

Here is the caller graph for this function:

is_series_p() [2/2]

bool Slic3r::MachineObject::is_series_p ( const std::string & series_str )

static

{ return series_str == "series_p1p";}

Referenced by Slic3r::GUI::AMSextruder::updateNozzleNum().

Here is the caller graph for this function:

is_series_x() [1/2]

bool Slic3r::MachineObject::is_series_x

(

)

const

{ return is_series_x(DevPrinterConfigUtil::get_printer_series_str(printer_type)); }

References Slic3r::DevPrinterConfigUtil::get_printer_series_str(), is_series_x(), and printer_type.

Referenced by get_max_filament_color_count(), and is_series_x().

Here is the call graph for this function:

Here is the caller graph for this function:

is_series_x() [2/2]

bool Slic3r::MachineObject::is_series_x ( const std::string & series_str )

static

{ return series_str == "series_x1"; }

Referenced by Slic3r::GUI::CalibUtils::check_printable_status_before_cali(), Slic3r::GUI::CalibUtils::check_printable_status_before_cali(), and Slic3r::GUI::AMSextruder::updateNozzleNum().

Here is the caller graph for this function:

is_studio_cmd()

bool Slic3r::MachineObject::is_studio_cmd

(

int

seq

)

{
    if (sequence_id >= START_SEQ_ID && sequence_id < END_SEQ_ID) {
        return true;
    }
    return false;
}

References END_SEQ_ID, and START_SEQ_ID.

Referenced by parse_json().

Here is the caller graph for this function:

is_support_command_calibration()

bool Slic3r::MachineObject::is_support_command_calibration

(

)

{
    if (get_printer_series() == PrinterSeries::SERIES_X1) {
        auto ap_ver_it = module_vers.find("rv1126");
        if (ap_ver_it != module_vers.end()) {
            if (ap_ver_it->second.sw_ver.compare("00.00.15.79") < 0)
                return false;
        }
    }
    return true;
}

References get_printer_series(), module_vers, and SERIES_X1.

Referenced by command_start_calibration().

Here is the call graph for this function:

Here is the caller graph for this function:

is_system_printing()

bool Slic3r::MachineObject::is_system_printing

(

)

{
    if (is_in_calibration() && is_in_printing_status(print_status))
        return true;
    //FIXME
    //if (print_type == "system" && is_in_printing_status(print_status))
        //return true;
    return false;
}

References is_in_calibration(), is_in_printing_status(), and print_status.

Referenced by Slic3r::GUI::CalibUtils::send_to_print(), Slic3r::GUI::CalibUtils::send_to_print(), Slic3r::GUI::CalibrationPresetPage::update_show_status(), Slic3r::GUI::SelectMachineDialog::update_show_status(), Slic3r::GUI::SendToPrinterDialog::update_show_status(), Slic3r::GUI::SyncAmsInfoDialog::update_show_status(), and Slic3r::GUI::CalibrationCaliPage::update_subtask().

Here is the call graph for this function:

Here is the caller graph for this function:

is_target_slot_unload()

bool Slic3r::MachineObject::is_target_slot_unload

(

)

const

{
    return m_extder_system->GetTargetSlotId().compare("255") == 0;
}

References m_extder_system.

is_timelapse()

bool Slic3r::MachineObject::is_timelapse

(

)

{
    return camera_timelapse;
}

References camera_timelapse.

is_timelapse_storage_low()

bool Slic3r::MachineObject::is_timelapse_storage_low

(

const std::string &

storage

)

const

{
    return m_storage && m_storage->is_timelapse_storage_low(storage);
}

References m_storage.

Referenced by Slic3r::GUI::SelectMachineDialog::check_timelapse_storage_warning().

Here is the caller graph for this function:

is_upgrading_avalable()

bool Slic3r::MachineObject::is_upgrading_avalable

(

)

{
    return upgrade_display_state == DevFirmwareUpgradingState::UpgradingAvaliable;
}

References upgrade_display_state, and Slic3r::UpgradingAvaliable.

local_publish_json()

int Slic3r::MachineObject::local_publish_json	(	std::string	json_str,
		int	qos = 0,
		int	flag = 0 )

{
    int result = -1;
    if (m_agent) {
        result = m_agent->send_message_to_printer(get_dev_id(), json_str, qos, flag);
    }
    return result;
}

References get_dev_id(), and m_agent.

Referenced by publish_json().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_home_flag()

void Slic3r::MachineObject::parse_home_flag

(

int

flag

)

{
    m_home_flag = flag;
 
    is_220V_voltage = ((flag >> 3) & 0x1) != 0;
    if (time(nullptr) - xcam_auto_recovery_hold_start > HOLD_TIME_3SEC) {
        xcam_auto_recovery_step_loss = ((flag >> 4) & 0x1) != 0;
    }
 
    camera_recording            = ((flag >> 5) & 0x1) != 0;
 
    if (time(nullptr) - ams_user_setting_start > HOLD_COUNT_MAX)
    {
        m_fila_system->GetAmsSystemSetting().SetDetectRemainEnabled(((flag >> 7) & 0x1) != 0);
    }
 
   // sdcard_state = MachineObject::SdcardState(get_flag_bits(flag, 8, 2));
   m_storage->set_sdcard_state(get_flag_bits(flag, 8, 2));
 
 
    if (time(nullptr) - ams_switch_filament_start > HOLD_TIME_3SEC)
    {
        m_fila_system->GetAmsSystemSetting().SetAutoRefillEnabled(((flag >> 10) & 0x1) != 0);
    }
 
    is_support_flow_calibration = ((flag >> 15) & 0x1) != 0;
    if (this->is_series_o()) { is_support_flow_calibration = false; } // todo: Temp modification due to incorrect machine push message for H2D
 
    is_support_pa_calibration = ((flag >> 16) & 0x1) != 0;
    if (this->is_series_p()) { is_support_pa_calibration = false; } // todo: Temp modification due to incorrect machine push message for P
 
    if (time(nullptr) - xcam_prompt_sound_hold_start > HOLD_TIME_3SEC) {
        xcam_allow_prompt_sound = ((flag >> 17) & 0x1) != 0;
    }
 
    is_support_prompt_sound = ((flag >> 18) & 0x1) != 0;
    is_support_filament_tangle_detect = ((flag >> 19) & 0x1) != 0;
 
    if (time(nullptr) - xcam_filament_tangle_detect_hold_start > HOLD_TIME_3SEC) {
        xcam_filament_tangle_detect = ((flag >> 20) & 0x1) != 0;
    }
 
    /*if(!is_support_motor_noise_cali){
        is_support_motor_noise_cali = ((flag >> 21) & 0x1) != 0;
    }*/
    is_support_motor_noise_cali = ((flag >> 21) & 0x1) != 0;
 
    is_support_user_preset = ((flag >> 22) & 0x1) != 0;
 
    is_support_nozzle_blob_detection = ((flag >> 25) & 0x1) != 0;
 
    if (time(nullptr) - nozzle_blob_detection_hold_start > HOLD_TIME_3SEC) {
        nozzle_blob_detection_enabled = ((flag >> 24) & 0x1) != 0;
    }
 
    is_support_air_print_detection = ((flag >> 29) & 0x1) != 0;
    if (auto ptr = m_fila_system->GetAmsFirmwareSwitch().lock();
        ptr->GetCurrentFirmwareIdxRun() == DevAmsSystemFirmwareSwitch::IDX_AMS_AMS2_AMSHT) {
        is_support_air_print_detection = false;// special case, for the firmware, air print is not supported
    }
    ams_air_print_status = ((flag >> 28) & 0x1) != 0;
 
    /*if (!is_support_p1s_plus) {
        auto supported_plus = ((flag >> 27) & 0x1) != 0;
        auto installed_plus = ((flag >> 26) & 0x1) != 0;
 
        if (installed_plus && supported_plus) {
            is_support_p1s_plus = true;
        }
        else {
            is_support_p1s_plus = false;
        }
    }*/
 
    is_support_upgrade_kit = ((flag >> 27) & 0x1) != 0;
    installed_upgrade_kit = ((flag >> 26) & 0x1) != 0;
 
    is_support_agora = ((flag >> 30) & 0x1) != 0;
    if (is_support_agora)
        is_support_tunnel_mqtt = false;
}

References ams_air_print_status, ams_switch_filament_start, ams_user_setting_start, camera_recording, get_flag_bits(), HOLD_COUNT_MAX, HOLD_TIME_3SEC, Slic3r::DevAmsSystemFirmwareSwitch::IDX_AMS_AMS2_AMSHT, installed_upgrade_kit, is_220V_voltage, is_series_o(), is_series_p(), is_support_agora, is_support_air_print_detection, is_support_filament_tangle_detect, is_support_flow_calibration, is_support_motor_noise_cali, is_support_nozzle_blob_detection, is_support_pa_calibration, is_support_prompt_sound, is_support_tunnel_mqtt, is_support_upgrade_kit, is_support_user_preset, m_fila_system, m_home_flag, m_storage, nozzle_blob_detection_enabled, nozzle_blob_detection_hold_start, xcam_allow_prompt_sound, xcam_auto_recovery_hold_start, xcam_auto_recovery_step_loss, xcam_filament_tangle_detect, xcam_filament_tangle_detect_hold_start, and xcam_prompt_sound_hold_start.

Referenced by parse_json().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_json()

int Slic3r::MachineObject::parse_json	(	std::string	tunnel,
		std::string	payload,
		bool	key_filed_only = false )

{
#ifdef ORCA_NETWORK_DEBUG
    BOOST_LOG_TRIVIAL(info) << "parse_json: payload = " << payload;
    flush_logs();
#endif
 
    if (tunnel == "lan") last_lan_msg_time_ = std::chrono::system_clock::now();
    if (tunnel == "cloud") last_cloud_msg_time_ = std::chrono::system_clock::now();
 
    parse_msg_count++;
    std::chrono::system_clock::time_point clock_start = std::chrono::system_clock::now();
 
    json j_pre;
    bool parse_ok = false;
    try {
        j_pre = json::parse(payload);
        parse_ok = true;
    }
    catch(...) {
        parse_ok = false;
        /* post process payload */
        sanitizeToUtf8(payload);
        BOOST_LOG_TRIVIAL(info) << "parse_json: sanitize to utf8";
        try {
            j_pre = json::parse(payload);
            parse_ok = true;
        }
        catch (...) {}
    }
 
    bool client_disconnected = false;
    if (parse_ok && j_pre.is_object() && j_pre.contains("event") && j_pre["event"].is_object() &&
        j_pre["event"].contains("event") && j_pre["event"]["event"].is_string()) {
        client_disconnected = j_pre["event"]["event"].get<std::string>() == "client.disconnected";
    }
 
    // A disconnect notification is a transport message too, but it must not first mark an
    // already-offline device as online through the generic message-received path.
    set_online_state(!client_disconnected);
 
    std::chrono::system_clock::time_point curr_time = std::chrono::system_clock::now();
    auto diff1 = std::chrono::duration_cast<std::chrono::microseconds>(curr_time - last_update_time);
 
    /* update last received time */
    last_update_time = std::chrono::system_clock::now();
 
    try {
        bool restored_json = false;
        json j;
        if (!parse_ok)
            j_pre = json::parse(payload);
        CNumericLocalesSetter locales_setter;
        if (j_pre.empty()) {
            return 0;
        }
        if (j_pre.contains("print")) {
            if (m_active_state == NotActive) m_active_state = Active;
            if (j_pre["print"].contains("command")) {
                if (j_pre["print"]["command"].get<std::string>() == "push_status") {
                    if (j_pre["print"].contains("msg")) {
                        if (j_pre["print"]["msg"].get<int>() == 0) {           //all message
                            BOOST_LOG_TRIVIAL(trace) << "static: get push_all msg, dev_id=" << dev_id;
                            m_push_count++;
                            m_full_msg_count++;
 
                            if (!printer_type.empty())
                                print_json.load_compatible_settings(printer_type, "");
                            print_json.diff2all_base_reset(j_pre);
                        } else if (j_pre["print"]["msg"].get<int>() == 1) {    //diff message
                            if (print_json.diff2all(j_pre, j) == 0) {
                                restored_json = true;
                            } else {
                                BOOST_LOG_TRIVIAL(trace) << "parse_json: restore failed! count = " << parse_msg_count;
                                if (print_json.is_need_request()) {
                                    BOOST_LOG_TRIVIAL(trace) << "parse_json: need request pushall, count = " << parse_msg_count;
                                    // request new push
                                    GUI::wxGetApp().CallAfter([this]{
                                        this->command_request_push_all();
                                    });
                                    return -1;
                                }
                                return -1;
                            }
                        } else {
                            BOOST_LOG_TRIVIAL(warning) << "unsupported msg_type=" << j_pre["print"]["msg"].get<std::string>();
                        }
                    }
                    else {
                        if (!printer_type.empty()) {
                            m_full_msg_count++;/* all message package is full at LAN mode*/
                            print_json.load_compatible_settings(printer_type, "");
                        }
 
                        print_json.diff2all_base_reset(j_pre);
                    }
 
                    if (j_pre["print"].contains("s_obj")){
                        if(j_pre["print"]["s_obj"].is_array()){
                            m_partskip_ids.clear();
                            for(auto it=j_pre["print"]["s_obj"].begin(); it!=j_pre["print"]["s_obj"].end(); it++){
                                m_partskip_ids.push_back(it.value().get<int>());
                            }
                        }
                    }
                }
            }
            if (j_pre["print"].contains("plate_idx")){ // && m_plate_index == -1
                if (j_pre["print"]["plate_idx"].is_number())
                {
                    m_plate_index = j_pre["print"]["plate_idx"].get<int>();
                }
                else if (j_pre["print"]["plate_idx"].is_string())
                {
                    try
                    {
                        m_plate_index = std::stoi(j_pre["print"]["plate_idx"].get<std::string>());
                    }
                    catch (...) { BOOST_LOG_TRIVIAL(error) << "parse_json: failed to convert plate_idx to int"; }
                }
            }
        }
        if (j_pre.contains("system")) {
            if (j_pre["system"].contains("command")) {
                if (j_pre["system"]["command"].get<std::string>() == "get_access_code") {
                    if (j_pre["system"].contains("access_code")) {
                        std::string access_code = j_pre["system"]["access_code"].get<std::string>();
                        if (!access_code.empty()) {
                            set_access_code(access_code);
                        }
                    }
                }
            }
        }
        if (!restored_json) {
            j = j_pre;
        }
 
        uint64_t t_utc = j.value("t_utc", 0ULL);
        if (t_utc > 0) {
            last_utc_time = std::chrono::system_clock::time_point(t_utc * 1ms);
            std::chrono::system_clock::time_point now = std::chrono::system_clock::now();
            auto millisec_since_epoch = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count();
            auto delay = millisec_since_epoch - t_utc;  //ms
 
            std::string message_type = is_lan_mode_printer() ? "Local Mqtt" : is_tunnel_mqtt ? "Tunnel Mqtt" : "Cloud Mqtt";
            if (!message_delay.empty()) {
                const auto& [first_type, first_time_stamp, first_delay] = message_delay.front();
                const auto& [last_type, last_time_stap, last_delay] = message_delay.back();
 
                BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << ", message delay, last time stamp: " << last_time_stap;
                if (last_time_stap - first_time_stamp >= MINUTE_30) {
                    // record, excluding current data
                    int total = message_delay.size();
                    int local_mqtt = 0;
                    int tunnel_mqtt = 0;
                    int cloud_mqtt = 0;
 
                    int local_mqtt_timeout = 0;
                    int tunnel_mqtt_timeout = 0;
                    int cloud_mqtt_timeout = 0;
 
                    for (const auto& [type, time_stamp, delay] : message_delay) {
                        if (type == "Local Mqtt") {
                            local_mqtt++;
                            if (delay >= TIME_OUT) {
                                local_mqtt_timeout++;
                            }
                        }
                        else if (type == "Tunnel Mqtt") {
                            tunnel_mqtt++;
                            if (delay >= TIME_OUT) {
                                tunnel_mqtt_timeout++;
                            }
                        }
                        else if (type == "Cloud Mqtt"){
                            cloud_mqtt++;
                            if (delay >= TIME_OUT) {
                                cloud_mqtt_timeout++;
                            }
                        }
                    }
 
                    BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << ", message delay, message total: " << total;
 
                    message_delay.clear();
                    message_delay.shrink_to_fit();
                }
            }
            message_delay.push_back(std::make_tuple(message_type, t_utc, delay));
        }
        else
            last_utc_time = last_update_time;
 
#if !BBL_RELEASE_TO_PUBLIC
        BOOST_LOG_TRIVIAL(info) << "parse_json: dev_id=" << dev_id << ", tunnel is=" << tunnel << ", merged playload=" << j.dump();
#else
        if (Slic3r::get_logging_level() < level_string_to_boost("trace")) {
            BOOST_LOG_TRIVIAL(info) << "parse_json: dev_id=" << dev_id << ", origin playload=" << j_pre.dump();
        } else {
            BOOST_LOG_TRIVIAL(trace) << "parse_json: dev_id=" << dev_id << ", tunnel is=" << tunnel << ", merged playload=" << j.dump();
        }
#endif
 
        // Parse version info first, as if version arrive or change, 'print' need parse again with new compatible settings
        try {
            if (j.contains("info")) {
                if (j["info"].contains("command") && j["info"]["command"].get<std::string>() == "get_version") {
                    json j_module = j["info"]["module"];
                    clear_version_info();
                    for (auto it = j_module.begin(); it != j_module.end(); it++) {
                        DevFirmwareVersionInfo ver_info;
                        ver_info.name = (*it)["name"].get<std::string>();
                        if ((*it).contains("product_name"))
                            ver_info.product_name = wxString::FromUTF8((*it)["product_name"].get<std::string>());
                        if ((*it).contains("sw_ver"))
                            ver_info.sw_ver = (*it)["sw_ver"].get<std::string>();
                        if ((*it).contains("sw_new_ver"))
                            ver_info.sw_new_ver = (*it)["sw_new_ver"].get<std::string>();
                        if ((*it).contains("visible") && (*it).contains("new_ver")) {
                            ver_info.sw_new_ver = (*it)["new_ver"].get<std::string>();
                        }
                        if ((*it).contains("sn"))
                            ver_info.sn = (*it)["sn"].get<std::string>();
                        if ((*it).contains("hw_ver"))
                            ver_info.hw_ver = (*it)["hw_ver"].get<std::string>();
                        if((*it).contains("flag"))
                            ver_info.firmware_flag= (*it)["flag"].get<int>();
 
                        store_version_info(ver_info);
                        if (ver_info.name == "ota") {
                            NetworkAgent* agent = GUI::wxGetApp().getAgent();
                            if (agent) {
                                std::string dev_ota_str = "dev_ota_ver:" + this->get_dev_id();
                                agent->track_update_property(dev_ota_str, ver_info.sw_ver);
                            }
                        }
                    }
 
                    parse_version_func();
 
                    bool get_version_result = true;
                    if (j["info"].contains("result"))
                        if (j["info"]["result"].get<std::string>() == "fail")
                            get_version_result = false;
                    if ((!check_version_valid() && get_version_retry-- >= 0)
                        && get_version_result) {
                            BOOST_LOG_TRIVIAL(info) << "get_version_retry = " << get_version_retry;
                            boost::thread retry = boost::thread([this] {
                                boost::this_thread::sleep_for(boost::chrono::milliseconds(RETRY_INTERNAL));
                                GUI::wxGetApp().CallAfter([this] {
                                    this->command_get_version(false);
                            });
                        });
                    }
                }
                std::string version = parse_version();
                if (!version.empty() && print_json.load_compatible_settings(printer_type, version)) {
                    // reload because compatible settings changed
                    j.clear();
                    print_json.diff2all(json{}, j);
                }
 
            }
        } catch (...) {}
 
        try {
            if (j.contains("info"))
                parse_new_info2(j["info"]);
        } catch (...) {
            BOOST_LOG_TRIVIAL(error) << "parse_json: failed to parse OrcaSonar capability info";
        }
 
        try {
            if (auto ptr = m_fila_system->GetAmsFirmwareSwitch().lock()) {
                ptr->ParseFirmwareSwitch(j);
            }
        } catch (...) {
            BOOST_LOG_TRIVIAL(error) << "parse_json: failed to parse firmware switch info";
        }
 
        if (j.contains("print")) {
            json jj = j["print"];
            int sequence_id = 0;
            if (jj.contains("sequence_id")) {
                if (jj["sequence_id"].is_string()) {
                    std::string str_seq = jj["sequence_id"].get<std::string>();
                    try {
                        sequence_id = stoi(str_seq);
                    }
                    catch(...) {
                        ;
                    }
                }
            }
 
            if (!key_field_only) {
                if (!m_manager->IsMultiMachineEnabled() && !is_support_agora) {
                    if (jj.contains("support_tunnel_mqtt")) {
                        if (jj["support_tunnel_mqtt"].is_boolean()) {
                            is_support_tunnel_mqtt = jj["support_tunnel_mqtt"].get<bool>();
                        }
                    }
                }
 
                //nozzle temp range
                if (jj.contains("nozzle_temp_range")) {
                    if (jj["nozzle_temp_range"].is_array()) {
                        nozzle_temp_range.clear();
                        for (auto it = jj["nozzle_temp_range"].begin(); it != jj["nozzle_temp_range"].end(); it++) {
                            nozzle_temp_range.push_back(it.value().get<int>());
                        }
                    }
                }
 
                // bed temp range
                if (jj.contains("bed_temp_range")) {
                    if (jj["bed_temp_range"].is_array()) {
                        bed_temp_range.clear();
                        for (auto it = jj["bed_temp_range"].begin(); it != jj["bed_temp_range"].end(); it++) {
                            bed_temp_range.push_back(it.value().get<int>());
                        }
                    }
                }
 
                //supported function
                m_config->ParseConfig(jj);
                m_status->ParseStatus(jj); // Orca: adopt DeviceCore split — populate DevStatus module
 
                if (jj.contains("support_build_plate_marker_detect")) {
                    if (jj["support_build_plate_marker_detect"].is_boolean()) {
                        is_support_build_plate_marker_detect = jj["support_build_plate_marker_detect"].get<bool>();
                    }
                }
 
                if(jj.contains("support_build_plate_marker_detect_type") && jj["support_build_plate_marker_detect_type"].is_number()) {
                    m_plate_maker_detect_type = (PlateMakerDectect)jj["support_build_plate_marker_detect_type"].get<int>();
                }
 
                if (jj.contains("support_flow_calibration") && jj["support_flow_calibration"].is_boolean())
                {
                    is_support_pa_calibration = jj["support_flow_calibration"].get<bool>();
                }
 
                if (jj.contains("support_send_to_sd")) {
                    if (jj["support_send_to_sd"].is_boolean()) {
                        is_support_send_to_sdcard = jj["support_send_to_sd"].get<bool>();
                    }
                }
 
              m_fan->ParseV2_0(jj);
                m_fila_switch->ParseFilaSwitchInfo(jj);
 
                if (jj.contains("support_filament_backup")) {
                    if (jj["support_filament_backup"].is_boolean()) {
                        is_support_filament_backup = jj["support_filament_backup"].get<bool>();
                    }
                }
 
                if (jj.contains("support_update_remain")) {
                    if (jj["support_update_remain"].is_boolean()) {
                        is_support_update_remain = jj["support_update_remain"].get<bool>();
                        if (auto ptr = m_fila_system->GetAmsFirmwareSwitch().lock();
                            ptr->GetCurrentFirmwareIdxRun() == DevAmsSystemFirmwareSwitch::IDX_AMS_AMS2_AMSHT) {
                            is_support_update_remain = true;// special case, for the firmware, remain is supported
                        }
                    }
                }
 
                if (jj.contains("support_bed_leveling")) {
                    if (jj["support_bed_leveling"].is_number_integer()) {
                        is_support_bed_leveling = jj["support_bed_leveling"].get<int>();
                    }
                }
 
                if (jj.contains("support_auto_recovery_step_loss")) {
                    if (jj["support_auto_recovery_step_loss"].is_boolean()) {
                        is_support_auto_recovery_step_loss = jj["support_auto_recovery_step_loss"].get<bool>();
                    }
                }
 
                if (jj.contains("support_ams_humidity")) {
                    if (jj["support_ams_humidity"].is_boolean()) {
                        is_support_ams_humidity = jj["support_ams_humidity"].get<bool>();
                    }
                }
 
                if (jj.contains("support_prompt_sound")) {
                    if (jj["support_prompt_sound"].is_boolean()) {
                        is_support_prompt_sound = jj["support_prompt_sound"].get<bool>();
                    }
                }
 
                if (jj.contains("support_filament_tangle_detect")) {
                    if (jj["support_filament_tangle_detect"].is_boolean()) {
                        is_support_filament_tangle_detect = jj["support_filament_tangle_detect"].get<bool>();
                    }
                }
 
                if (jj.contains("support_1080dpi")) {
                    if (jj["support_1080dpi"].is_boolean()) {
                        is_support_1080dpi = jj["support_1080dpi"].get<bool>();
                    }
                }
 
                if (jj.contains("support_cloud_print_only")) {
                    if (jj["support_cloud_print_only"].is_boolean()) {
                        is_support_cloud_print_only = jj["support_cloud_print_only"].get<bool>();
                    }
                }
 
                if (jj.contains("support_command_ams_switch")) {
                    if (jj["support_command_ams_switch"].is_boolean()) {
                        is_support_command_ams_switch = jj["support_command_ams_switch"].get<bool>();
                    }
                }
 
                if (jj.contains("support_mqtt_alive")) {
                    if (jj["support_mqtt_alive"].is_boolean()) {
                        is_support_mqtt_alive = jj["support_mqtt_alive"].get<bool>();
                    }
                }
 
                if (jj.contains("support_motor_noise_cali")) {
                    if (jj["support_motor_noise_cali"].is_boolean()) {
                        is_support_motor_noise_cali = jj["support_motor_noise_cali"].get<bool>();
                    }
                }
 
                if (jj.contains("support_timelapse")) {
                    if (jj["support_timelapse"].is_boolean()) {
                        is_support_timelapse = jj["support_timelapse"].get<bool>();
                    }
                }
 
                if (jj.contains("support_user_preset")) {
                    if (jj["support_user_preset"].is_boolean()) {
                        is_support_user_preset = jj["support_user_preset"].get<bool>();
                    }
                }
 
                if (jj.contains("bed_temperature_limit")) {
                    if (jj["bed_temperature_limit"].is_number_integer()) {
                        bed_temperature_limit = jj["bed_temperature_limit"].get<int>();
                    }
                }
 
                if (jj.contains("support_refresh_nozzle")) {
                    if (jj["support_refresh_nozzle"].is_boolean()) {
                        is_support_refresh_nozzle = jj["support_refresh_nozzle"].get<bool>();
                    }
                }
            }
 
 
            if (jj.contains("command")) {
                m_nozzle_mapping_ptr->ParseAutoNozzleMapping(jj);
 
                if (jj["command"].get<std::string>() == "ams_change_filament") {
                    if (jj.contains("errno")) {
                        if (jj["errno"].is_number()) {
                            if (jj.contains("soft_temp")) {
                                int soft_temp = jj["soft_temp"].get<int>();
                                if (jj["errno"].get<int>() == -2) {
                                    wxString text = wxString::Format(_L("The chamber temperature is too high, which may cause the filament to soften. Please wait until the chamber temperature drops below %d\u2103. You may open the front door or enable fans to cool down."), soft_temp);
                                    GUI::wxGetApp().push_notification(this, text);
                                } else if (jj["errno"].get<int>() == -4) {
                                    wxString text = wxString::Format(_L("AMS temperature is too high, which may cause the filament to soften. Please wait until the AMS temperature drops below %d\u2103."), soft_temp);
                                    GUI::wxGetApp().push_notification(this, text);
                                }
                            } else {
                                if (jj["errno"].get<int>() == -2) {
                                    wxString text = _L("The current chamber temperature or the target chamber temperature exceeds 45\u2103. In order to avoid extruder clogging, low temperature filament(PLA/PETG/TPU) is not allowed to be loaded.");
                                    GUI::wxGetApp().push_notification(this, text);
                                }
                            }
                        }
                    }
                }
 
                if (jj["command"].get<std::string>() == "set_ctt") {
                    if (m_agent && is_studio_cmd(sequence_id)) {
                        if (jj["errno"].is_number()) {
                            wxString text;
                            if (jj["errno"].get<int>() == -2) {
                                 text = _L("Low temperature filament(PLA/PETG/TPU) is loaded in the extruder. In order to avoid extruder clogging, it is not allowed to set the chamber temperature.");
                            }
                            else if (jj["errno"].get<int>() == -4) {
                                 text = _L("When you set the chamber temperature below 40\u2103, the chamber temperature control will not be activated, "
                                           "and the target chamber temperature will automatically be set to 0\u2103." /* 0°C */);
                            }
                            if(!text.empty()){
#if __WXOSX__
                            set_ctt_dlg(text);
#else
                            GUI::wxGetApp().push_notification(this, text);
#endif
                            }
                        }
                    }
                }
 
                if (!key_field_only)
                {
                    if (is_studio_cmd(sequence_id) && jj.contains("command") && jj.contains("err_code"))
                    {
                        if (jj["err_code"].is_number())
                        {
                            /* proceed action*/
                            json action_json = jj.contains("err_index") ? jj : json();
 
                            add_command_error_code_dlg(jj["err_code"].get<int>(), action_json);
                        }
                    }
                }
 
                if (jj["command"].get<std::string>() == "push_status") {
                    m_push_count++;
                    last_push_time = last_update_time;
#pragma region printing
                    // U0 firmware
                    if (jj.contains("print_type")) {
                        print_type = jj["print_type"].get<std::string>();
                    }
                    if (jj.contains("mc_percent")) {
                        update_print_progress(jj["mc_percent"]);
                    }
                    if (jj.contains("mc_print_sub_stage")) {
                        if (jj["mc_print_sub_stage"].is_number_integer())
                            mc_print_sub_stage = j["print"]["mc_print_sub_stage"].get<int>();
                    }
                    /* printing */
                    if (jj.contains("mc_print_stage")) {
                        if (jj["mc_print_stage"].is_string())
                            mc_print_stage = atoi(jj["mc_print_stage"].get<std::string>().c_str());
                        if (jj["mc_print_stage"].is_number())
                            mc_print_stage = jj["mc_print_stage"].get<int>();
                    }
                    if (jj.contains("mc_print_error_code")) {
                        if (jj["mc_print_error_code"].is_number())
                            mc_print_error_code = jj["mc_print_error_code"].get<int>();
                    }
                    if (jj.contains("mc_remaining_time")) {
                        if (jj["mc_remaining_time"].is_string())
                            mc_left_time = stoi(j["print"]["mc_remaining_time"].get<std::string>()) * 60;
                        else if (jj["mc_remaining_time"].is_number_integer())
                            mc_left_time = j["print"]["mc_remaining_time"].get<int>() * 60;
                    }
                    if (jj.contains("print_error")) {
                        if (jj["print_error"].is_number())
                            print_error = jj["print_error"].get<int>();
                    }
                    // Orca: keep the failure-snapshot id only while an error is active, so a stale
                    // id can't leak into a later unrelated error dialog once the failure clears.
                    if (print_error <= 0) {
                        m_print_error_img_id.clear();
                    }
                    else if (jj.contains("err2") && jj["err2"].is_object()) {
                        json err2 = jj["err2"];
                        if (err2.contains("img_id") && err2["img_id"].is_string()) {
                            m_print_error_img_id = err2["img_id"].get<std::string>();
                        }
                    }
 
                     DevStorage::ParseV1_0(jj, m_storage);
 
                    if (!key_field_only) {
                        if (jj.contains("home_flag")) { parse_home_flag(jj["home_flag"].get<int>());}
 
                        /*the param is invalid in np for Yeshu*/
                        if (jj.contains("hw_switch_state")) {
                            hw_switch_state = jj["hw_switch_state"].get<int>();
                            m_extder_system->m_extders[MAIN_EXTRUDER_ID].m_ext_has_filament = hw_switch_state;
                        }
                        if (jj.contains("mc_print_line_number")) {
                            if (jj["mc_print_line_number"].is_string() && !jj["mc_print_line_number"].is_null())
                                mc_print_line_number = atoi(jj["mc_print_line_number"].get<std::string>().c_str());
                        }
                    }
                    if (!key_field_only) {
                        if (jj.contains("flag3")) {
                            int flag3 = jj["flag3"].get<int>();
                            is_support_filament_setting_inprinting =  get_flag_bits(flag3, 3);
                            is_enable_ams_np =  get_flag_bits(flag3, 9);
                            is_support_fila_change_abort = get_flag_bits(flag3, 13); // filament-change Stop button
                            is_support_ext_change_assist_old = get_flag_bits(flag3, 16); // A/P-series multi-color external change assist
                            is_support_filament_32_colors = get_flag_bits(flag3, 17);
                        }
                    }
                    if (!key_field_only) {
                        if (jj.contains("net")) {
                            if (jj["net"].contains("conf")) {
                                network_wired = (jj["net"]["conf"].get<int>() & (0x1)) != 0;
                            }
                            if (jj["net"].contains("info")) {
                                for (auto info_item = jj["net"]["info"].begin(); info_item != jj["net"]["info"].end(); info_item++) {
 
                                    if (info_item->contains("ip")) {
                                        auto tmp_dev_ip = (*info_item)["ip"].get<int64_t>();
                                        if (tmp_dev_ip == 0)
                                            continue ;
                                        else {
                                           set_dev_ip(DevUtil::convertToIp(tmp_dev_ip));
                                        }
                                    } else {
                                        break;
                                    }
                                }
                            }
                        }
                    }
 
#pragma endregion
 
#pragma region online
                    if (!key_field_only) {
                        // parse online info
                        try {
                            if (jj.contains("online")) {
                                if (jj["online"].contains("ahb")) {
                                    if (jj["online"]["ahb"].get<bool>()) {
                                        online_ahb = true;
                                    } else {
                                        online_ahb = false;
                                    }
                                }
                                if (jj["online"].contains("rfid")) {
                                    if (jj["online"]["rfid"].get<bool>()) {
                                        online_rfid = true;
                                    } else {
                                        online_rfid = false;
                                    }
                                }
                                std::string str = jj.dump();
                                if (jj["online"].contains("version")) {
                                    online_version = jj["online"]["version"].get<int>();
                                }
                                if (last_online_version != online_version) {
                                    last_online_version = online_version;
                                    GUI::wxGetApp().CallAfter([this] {
                                        this->command_get_version();
                                        });
                                }
                            }
                        } catch (...) {
                            ;
                        }
                    }
#pragma endregion
 
#pragma region print_task
                    if (jj.contains("gcode_state")) {
                        this->set_print_state(jj["gcode_state"].get<std::string>());
                    }
                    if (jj.contains("job_id")) {
                        is_support_wait_sending_finish = true;
                        this->job_id_ = DevJsonValParser::get_longlong_val(jj["job_id"]);
                    }
                    else {
                        is_support_wait_sending_finish = false;
                    }
 
                    if (jj.contains("subtask_name")) {
                        subtask_name = jj["subtask_name"].get<std::string>();
                    }
 
                    if (!key_field_only) {
                        if (jj.contains("printer_type")) {
                            printer_type = _parse_printer_type(jj["printer_type"].get<std::string>());
                        }
 
                        if (jj.contains("layer_num")) {
                            curr_layer = jj["layer_num"].get<int>();
                        }
                        if (jj.contains("total_layer_num")) {
                            total_layers = jj["total_layer_num"].get<int>();
                            if (total_layers == 0)
                                is_support_layer_num = false;
                            else
                                is_support_layer_num = true;
                        }
                        else {
                            is_support_layer_num = false;
                        }
                        if (jj.contains("queue_number")) {
                            this->queue_number = jj["queue_number"].get<int>();
                        }
                        else {
                            this->queue_number = 0;
                        }
 
                        if (jj.contains("task_id")) {
                            this->task_id_ = jj["task_id"].get<std::string>();
                        }
 
                        if (jj.contains("thumbnail_url") && jj["thumbnail_url"].is_string())
                            m_agent_thumbnail_url = jj["thumbnail_url"].get<std::string>();
 
                        if (jj.contains("job_attr")) {
                            int jobAttr = jj["job_attr"].get<int>();
                            jobState_ =  get_flag_bits(jobAttr, 4, 4);
                        }
 
                        if (jj.contains("gcode_file"))
                            this->m_gcode_file = jj["gcode_file"].get<std::string>();
                        if (jj.contains("gcode_file_prepare_percent")) {
                            std::string percent_str = jj["gcode_file_prepare_percent"].get<std::string>();
                            if (!percent_str.empty()) {
                                try {
                                    this->gcode_file_prepare_percent = atoi(percent_str.c_str());
                                }
                                catch (...) {}
                            }
                        }
                    }
 
                    if (jj.contains("project_id")
                        && jj.contains("profile_id")
                        && jj.contains("subtask_id")
                        ) {
                        obj_subtask_id = jj["subtask_id"].get<std::string>();
 
                        int plate_index = -1;
                        /* parse local plate_index from task */
                        if (obj_subtask_id.compare("0") == 0 && jj["profile_id"].get<std::string>() != "0") {
                            if (jj.contains("gcode_file")) {
                                m_gcode_file = jj["gcode_file"].get<std::string>();
                                int idx_start = m_gcode_file.find_last_of("_") + 1;
                                int idx_end = m_gcode_file.find_last_of(".");
                                if (idx_start > 0 && idx_end > idx_start) {
                                    try {
                                        plate_index = atoi(m_gcode_file.substr(idx_start, idx_end - idx_start).c_str());
                                        this->m_plate_index = plate_index;
                                    }
                                    catch (...) {
                                        ;
                                    }
                                }
                            }
                        }
                        update_slice_info(jj["project_id"].get<std::string>(), jj["profile_id"].get<std::string>(), jj["subtask_id"].get<std::string>(), plate_index);
                        BBLSubTask* curr_task = get_subtask();
                        if (curr_task) {
                            curr_task->printing_status = print_status;
                            curr_task->task_id = jj["subtask_id"].get<std::string>();
                        }
                    }
 
#pragma endregion
 
#pragma region status
                    if (!key_field_only) {
                        /* temperature */
 
                        // Orca: adopt DeviceCore split — populate DevAxis/DevChamber modules
                        // alongside the inline handling (side-effect-free; inline stays authoritative).
                        // Contained locally so a malformed field cannot abort the whole status parse.
                        try {
                            m_axis->ParseAxis(jj);
                            m_chamber->ParseChamber(jj);
                        } catch (...) {
                            BOOST_LOG_TRIVIAL(warning) << "parse_json: DevAxis/DevChamber parse failed";
                        }
 
                        DevBed::ParseV1_0(jj,m_bed);
 
                        if (jj.contains("frame_temper")) {
                            if (jj["frame_temper"].is_number()) {
                                frame_temp = jj["frame_temper"].get<float>();
                            }
                        }
 
                        ExtderSystemParser::ParseV1_0(jj, m_extder_system);
 
                        if (jj.contains("chamber_temper")) {
                            if (jj["chamber_temper"].is_number()) {
                                chamber_temp = jj["chamber_temper"].get<float>();
                            }
                        }
                        if (jj.contains("ctt")) {
                            if (jj["ctt"].is_number()) {
                                chamber_temp_target = jj["ctt"].get<float>();
                            }
                        }
                        /* signals */
                        if (jj.contains("link_th_state"))
                            link_th = jj["link_th_state"].get<std::string>();
                        if (jj.contains("link_ams_state"))
                            link_ams = jj["link_ams_state"].get<std::string>();
                        if (jj.contains("wifi_signal"))
                            wifi_signal = jj["wifi_signal"].get<std::string>();
 
                        /* cooling */
                        m_fan->ParseV1_0(jj);
 
                        /* parse speed */
                        DevPrintOptionsParser::Parse(m_print_options, jj);
 
                        try {
                            if (jj.contains("spd_mag")) {
                                printing_speed_mag = jj["spd_mag"].get<int>();
                            }
                        }
                        catch (...) {
                            ;
                        }
                    }
 
                    try {
                        if (jj.contains("stg")) {
                            stage_list_info.clear();
                            if (jj["stg"].is_array()) {
                                for (auto it = jj["stg"].begin(); it != jj["stg"].end(); it++) {
                                    for (auto kv = (*it).begin(); kv != (*it).end(); kv++) {
                                        stage_list_info.push_back(kv.value().get<int>());
                                    }
                                }
                            }
                        }
                        if (jj.contains("stg_cur")) {
                           stage_curr = jj["stg_cur"].get<int>();
                        }
 
                        if (jj.contains("stg_cd")) {
                            stage_remaining_seconds = jj["stg_cd"].get<int>();
                        }
                    }
                    catch (...) {
                        ;
                    }
 
                    if (!key_field_only) {
                        /*get filam_bak*/
                        try {
                            m_extder_system->m_extders[MAIN_EXTRUDER_ID].m_filam_bak.clear();
 
                            if (jj.contains("filam_bak")) {
                                if (jj["filam_bak"].is_array()) {
                                    for (auto it = jj["filam_bak"].begin(); it != jj["filam_bak"].end(); it++) {
                                        const auto& filam_bak_val = it.value().get<int>();
                                        m_extder_system->m_extders[MAIN_EXTRUDER_ID].m_filam_bak.push_back(filam_bak_val);
                                    }
                                }
                            }
                        }
                        catch (...) {
                            ;
                        }
 
                        /* get fimware type */
                        try {
                            if (jj.contains("mess_production_state")) {
                                if (jj["mess_production_state"].get<std::string>() == "engineer")
                                    firmware_type = PrinterFirmwareType::FIRMWARE_TYPE_ENGINEER;
                                else if (jj["mess_production_state"].get<std::string>() == "product")
                                    firmware_type = PrinterFirmwareType::FIRMWARE_TYPE_PRODUCTION;
                            }
                        }
                        catch (...) {
                            ;
                        }
                    }
                    if (!key_field_only) {
                        try {
                            if (jj.contains("lifecycle")) {
                                if (jj["lifecycle"].get<std::string>() == "engineer")
                                    lifecycle = PrinterFirmwareType::FIRMWARE_TYPE_ENGINEER;
                                else if (jj["lifecycle"].get<std::string>() == "product")
                                    lifecycle = PrinterFirmwareType::FIRMWARE_TYPE_PRODUCTION;
                            }
                        }
                        catch (...) {
                            ;
                        }
 
                        try {
                            if (jj.contains("lights_report") && jj["lights_report"].is_array()) {
                                for (auto it = jj["lights_report"].begin(); it != jj["lights_report"].end(); it++) {
                                    if ((*it)["node"].get<std::string>().compare("chamber_light") == 0)
                                    {
                                        m_lamp->SetChamberLight((*it)["mode"].get<std::string>());
                                    }
                                }
                            }
                        }
                        catch (...) {
                            ;
                        }
                    }
#pragma endregion
                    if (!key_field_only) {
 
                        if (jj.contains("nozzle_diameter") && jj.contains("nozzle_type"))
                        {
                            std::optional<int> flag_e3d;
                            if (jj.contains("flag3")) {
                                int flag3           = jj["flag3"].get<int>();
                                flag_e3d            = std::make_optional(get_flag_bits(flag3, 10, 3));
                                has_extra_flow_type = true;
                            }
 
                            DevNozzleSystemParser::ParseV1_0(jj["nozzle_type"], jj["nozzle_diameter"], m_nozzle_system, flag_e3d);
                        }
                    }
 
#pragma region upgrade
                    try {
                        if (jj.contains("upgrade_state")) {
                            if (jj["upgrade_state"].contains("status"))
                                upgrade_status = jj["upgrade_state"]["status"].get<std::string>();
                            if (jj["upgrade_state"].contains("progress")) {
                                upgrade_progress = jj["upgrade_state"]["progress"].get<std::string>();
                            } if (jj["upgrade_state"].contains("new_version_state"))
                                upgrade_new_version = jj["upgrade_state"]["new_version_state"].get<int>() == 1 ? true : false;
                            if (!check_enable_np(jj) && jj["upgrade_state"].contains("ams_new_version_number"))/* is not used in new np, by AP*/
                                ams_new_version_number = jj["upgrade_state"]["ams_new_version_number"].get<std::string>();
                            if (jj["upgrade_state"].contains("ota_new_version_number"))
                                ota_new_version_number = jj["upgrade_state"]["ota_new_version_number"].get<std::string>();
                            if (jj["upgrade_state"].contains("ahb_new_version_number"))
                                ahb_new_version_number = jj["upgrade_state"]["ahb_new_version_number"].get<std::string>();
                            if (jj["upgrade_state"].contains("module"))
                                upgrade_module = jj["upgrade_state"]["module"].get<std::string>();
                            if (jj["upgrade_state"].contains("message"))
                                upgrade_message = jj["upgrade_state"]["message"].get<std::string>();
                            if (jj["upgrade_state"].contains("consistency_request"))
                                upgrade_consistency_request = jj["upgrade_state"]["consistency_request"].get<bool>();
                            if (jj["upgrade_state"].contains("force_upgrade"))
                                upgrade_force_upgrade = jj["upgrade_state"]["force_upgrade"].get<bool>();
                            if (jj["upgrade_state"].contains("err_code"))
                                upgrade_err_code = jj["upgrade_state"]["err_code"].get<int>();
                            if (jj["upgrade_state"].contains("dis_state")) {
                                if ((int)upgrade_display_state != jj["upgrade_state"]["dis_state"].get<int>()
                                    && jj["upgrade_state"]["dis_state"].get<int>() == 3) {
                                    GUI::wxGetApp().CallAfter([this] {
                                        this->command_get_version();
                                        });
                                }
                                if (upgrade_display_hold_count > 0)
                                {
                                    upgrade_display_hold_count--;
                                }
                                else
                                {
                                    upgrade_display_state = (DevFirmwareUpgradingState)jj["upgrade_state"]["dis_state"].get<int>();
                                    if ((upgrade_display_state == DevFirmwareUpgradingState::UpgradingAvaliable) && is_lan_mode_printer())
                                    {
                                        upgrade_display_state = DevFirmwareUpgradingState::UpgradingUnavaliable;
                                    }
                                }
                            }
                            else {
                                if (upgrade_display_hold_count > 0)
                                    upgrade_display_hold_count--;
                                else {
                                    //BBS compatibility with old version
                                    if (upgrade_status == "DOWNLOADING"
                                        || upgrade_status == "FLASHING"
                                        || upgrade_status == "UPGRADE_REQUEST"
                                        || upgrade_status == "PRE_FLASH_START"
                                        || upgrade_status == "PRE_FLASH_SUCCESS") {
                                        upgrade_display_state = DevFirmwareUpgradingState::UpgradingInProgress;
                                    }
                                    else if (upgrade_status == "UPGRADE_SUCCESS"
                                        || upgrade_status == "DOWNLOAD_FAIL"
                                        || upgrade_status == "FLASH_FAIL"
                                        || upgrade_status == "PRE_FLASH_FAIL"
                                        || upgrade_status == "UPGRADE_FAIL") {
                                        upgrade_display_state = DevFirmwareUpgradingState::UpgradingFinished;
                                    }
                                    else {
                                        if (upgrade_new_version) {
                                            upgrade_display_state = DevFirmwareUpgradingState::UpgradingAvaliable;
                                        }
                                        else {
                                            upgrade_display_state = DevFirmwareUpgradingState::UpgradingUnavaliable;
                                        }
                                    }
                                }
                            }
                            // new ver list
                            if (jj["upgrade_state"].contains("new_ver_list")) {
                                m_new_ver_list_exist = true;
                                new_ver_list.clear();
                                for (auto ver_item = jj["upgrade_state"]["new_ver_list"].begin(); ver_item != jj["upgrade_state"]["new_ver_list"].end(); ver_item++) {
                                    DevFirmwareVersionInfo ver_info;
                                    if (ver_item->contains("name"))
                                        ver_info.name = (*ver_item)["name"].get<std::string>();
                                    else
                                        continue;
 
                                    if (ver_item->contains("cur_ver"))
                                        ver_info.sw_ver = (*ver_item)["cur_ver"].get<std::string>();
                                    if (ver_item->contains("new_ver"))
                                        ver_info.sw_new_ver = (*ver_item)["new_ver"].get<std::string>();
 
                                    if (ver_info.name == "ota") {
                                        ota_new_version_number = ver_info.sw_new_ver;
                                    }
 
                                    new_ver_list.insert(std::make_pair(ver_info.name, ver_info));
                                }
                            }
                            else {
                                new_ver_list.clear();
                            }
                        }
                    }
                    catch (...) {
                        ;
                    }
#pragma endregion
 
#pragma region  camera
                    if (!key_field_only) {
                        // parse camera info
                        try {
                            if (jj.contains("ipcam")) {
                                json const & ipcam = jj["ipcam"];
                                if (ipcam.contains("ipcam_record")) {
                                    if (time(nullptr) - camera_recording_ctl_start > HOLD_TIME_3SEC) {
                                        if (ipcam["ipcam_record"].get<std::string>() == "enable") {
                                            camera_recording_when_printing = true;
                                        }
                                        else {
                                            camera_recording_when_printing = false;
                                        }
                                    }
                                }
                                if (ipcam.contains("timelapse")) {
                                    if (camera_timelapse_hold_count > 0)
                                        camera_timelapse_hold_count--;
                                    else {
                                        if (ipcam["timelapse"].get<std::string>() == "enable") {
                                            camera_timelapse = true;
                                        }
                                        else {
                                            camera_timelapse = false;
                                        }
                                    }
                                }
                                if (ipcam.contains("ipcam_dev")) {
                                    if (ipcam["ipcam_dev"].get<std::string>() == "1") {
                                        has_ipcam = true;
                                    } else {
                                        has_ipcam = false;
                                        webcam_stream_url.clear();
                                    }
                                }
                                if (ipcam.contains("resolution")) {
                                    if (camera_resolution_hold_count > 0)
                                        camera_resolution_hold_count--;
                                    else {
                                        camera_resolution = ipcam["resolution"].get<std::string>();
                                    }
                                }
                                if (ipcam.contains("resolution_supported")) {
                                    std::vector<std::string> resolution_supported;
                                    for (auto res : ipcam["resolution_supported"])
                                        resolution_supported.emplace_back(res.get<std::string>());
                                    camera_resolution_supported.swap(resolution_supported);
                                }
                                if (ipcam.contains("liveview")) {
                                    char const *local_protos[] = {"none", "disabled", "local", "rtsps", "rtsp"};
                                    liveview_local = enum_index_of(ipcam["liveview"].value<std::string>("local", "none").c_str(), local_protos, 5, LiveviewLocal::LVL_None);
                                    char const *remote_protos[] = {"none", "tutk", "agora", "tutk_agaro"};
                                    liveview_remote = enum_index_of(ipcam["liveview"].value<std::string>("remote", "none").c_str(), remote_protos, 4, LiveviewRemote::LVR_None);
                                }
                                if (ipcam.contains("file")) {
                                    char const *local_protos[] = {"none", "local"};
                                    file_local  = enum_index_of(ipcam["file"].value<std::string>("local", "none").c_str(), local_protos, 2, FileLocal::FL_None);
                                    char const *remote_protos[] = {"none", "tutk", "agora", "tutk_agaro"};
                                    file_remote = enum_index_of(ipcam["file"].value<std::string>("remote", "none").c_str(), remote_protos, 4, FileRemote::FR_None);
                                    file_model_download = ipcam["file"].value<std::string>("model_download", "disabled") == "enabled";
                                }
                                virtual_camera = ipcam.value<std::string>("virtual_camera", "disabled") == "enabled";
                                if (ipcam.contains("rtsp_url")) {
                                    local_rtsp_url = ipcam["rtsp_url"].get<std::string>();
                                    liveview_local = local_rtsp_url.empty() ? LVL_None : local_rtsp_url == "disable"
                                            ? LVL_Disable : boost::algorithm::starts_with(local_rtsp_url, "rtsps") ? LVL_Rtsps : LVL_Rtsp;
                                }
                                if (ipcam.contains("stream_url") && ipcam["stream_url"].is_string()) {
                                    webcam_stream_url = ipcam["stream_url"].get<std::string>();
                                }
                                if (ipcam.contains("tutk_server")) {
                                    tutk_state = ipcam["tutk_server"].get<std::string>();
                                }
                            }
                        }
                        catch (...) {
                            ;
                        }
 
                        try {
                            if (jj.contains("xcam")) {
                                if (time(nullptr) - xcam_ai_monitoring_hold_start > HOLD_TIME_3SEC) {
 
                                    if (jj["xcam"].contains("cfg")) {
                                        xcam_disable_ai_detection_display = true;
                                       //  std::string cfg    = jj["xcam"]["cfg"].get<std::string>();
 
                                        int cfg                  = jj["xcam"]["cfg"].get<int>();
                                         xcam_spaghetti_detection = get_flag_bits(cfg,7);
                                         switch (get_flag_bits(cfg, 8, 2)) {
                                             case 0: xcam_spaghetti_detection_sensitivity = "low"; break;
                                             case 1: xcam_spaghetti_detection_sensitivity = "medium"; break;
                                             case 2: xcam_spaghetti_detection_sensitivity = "high"; break;
                                             default: break;
                                         }
 
                                         xcam_purgechutepileup_detection = get_flag_bits(cfg, 10);
                                         switch (get_flag_bits(cfg, 11, 2)) {
 
                                         case 0: xcam_purgechutepileup_detection_sensitivity = "low"; break;
                                         case 1: xcam_purgechutepileup_detection_sensitivity = "medium"; break;
                                         case 2: xcam_purgechutepileup_detection_sensitivity = "high"; break;
                                         default: break;
                                         }
 
                                         xcam_nozzleclumping_detection = get_flag_bits(cfg, 13);
                                         switch (get_flag_bits(cfg, 14, 2)) {
 
                                         case 0: xcam_nozzleclumping_detection_sensitivity = "low"; break;
                                         case 1: xcam_nozzleclumping_detection_sensitivity = "medium"; break;
                                         case 2: xcam_nozzleclumping_detection_sensitivity = "high"; break;
                                         default: break;
                                         }
 
                                         xcam_airprinting_detection    = get_flag_bits(cfg, 16);
                                         switch (get_flag_bits(cfg, 17, 2)) {
 
                                         case 0: xcam_airprinting_detection_sensitivity = "low"; break;
                                         case 1: xcam_airprinting_detection_sensitivity = "medium"; break;
                                         case 2: xcam_airprinting_detection_sensitivity = "high"; break;
                                         default: break;
                                         }
 
                                    }
                                    else if (jj["xcam"].contains("printing_monitor")) {
                                        // new protocol
                                        xcam_ai_monitoring = jj["xcam"]["printing_monitor"].get<bool>();
                                    } else {
                                        // old version protocol
                                        if (jj["xcam"].contains("spaghetti_detector")) {
                                            xcam_ai_monitoring = jj["xcam"]["spaghetti_detector"].get<bool>();
                                            if (jj["xcam"].contains("print_halt")) {
                                                bool print_halt = jj["xcam"]["print_halt"].get<bool>();
                                                if (print_halt) { xcam_ai_monitoring_sensitivity = "medium"; }
                                            }
                                        }
                                    }
 
                                    if (jj["xcam"].contains("halt_print_sensitivity")) {
                                        xcam_ai_monitoring_sensitivity = jj["xcam"]["halt_print_sensitivity"].get<std::string>();
                                    }
 
                                }
 
                                if (time(nullptr) - xcam_first_layer_hold_start > HOLD_TIME_3SEC) {
                                    if (jj["xcam"].contains("first_layer_inspector")) {
                                        xcam_first_layer_inspector = jj["xcam"]["first_layer_inspector"].get<bool>();
                                    }
                                }
 
                                if (time(nullptr) - xcam_buildplate_marker_hold_start > HOLD_TIME_3SEC) {
                                    if (jj["xcam"].contains("buildplate_marker_detector")) {
                                        xcam_buildplate_marker_detector = jj["xcam"]["buildplate_marker_detector"].get<bool>();
                                        is_support_build_plate_marker_detect = true;
                                    } else {
                                        is_support_build_plate_marker_detect = false;
                                    }
                                }
                            }
                        }
                        catch (...) {
                            ;
                        }
                    }
#pragma endregion
 
#pragma region hms
                    if (!key_field_only && jj.contains("hms")) {
                        m_hms_system->ParseHMSItems(jj["hms"]);
                    }
#pragma endregion
 
 
#pragma region push_ams
                    /* ams status */
                    try {
                        if (jj.contains("ams_status")) {
                            int ams_status = jj["ams_status"].get<int>();
                            this->_parse_ams_status(ams_status);
                        }
                        std::string str_j = jj.dump();
                        if (jj.contains("cali_version")) {
                            cali_version = jj["cali_version"].get<int>();
                        }
                        else {
                            cali_version = -1;
                        }
                        std::string str = jj.dump();
                    }
                    catch (...) {
                        ;
                    }
                    update_printer_preset_name();
                    update_filament_list();
                    if (jj.contains("ams")) {
                        DevFilaSystemParser::ParseV1_0(jj, this, m_fila_system.get(), key_field_only);
                    }
 
                    /* vitrual tray*/
                    if (!key_field_only) {
                        try {
                            if (jj.contains("vir_slot") && jj["vir_slot"].is_array()) {
 
                                for (auto it = jj["vir_slot"].begin(); it != jj["vir_slot"].end(); it++) {
                                    auto vslot = parse_vt_tray(it.value().get<json>());
 
                                    if (vslot.id == std::to_string(VIRTUAL_TRAY_MAIN_ID)) {
                                        auto it = std::next(vt_slot.begin(), 0);
                                        if (it != vt_slot.end()) {
                                            vt_slot[0] = vslot;
                                        }
                                        else {
                                            vt_slot.push_back(vslot);
                                        }
                                    }
                                    else if (vslot.id == std::to_string(VIRTUAL_TRAY_DEPUTY_ID)) {
                                        auto it = std::next(vt_slot.begin(), 1);
                                        if (it != vt_slot.end()) {
                                            vt_slot[1] = vslot;
                                        }
                                        else {
                                            vt_slot.push_back(vslot);
                                        }
                                    }
                                }
 
                            }
                            else if (jj.contains("vt_tray")) {
                                auto main_slot = parse_vt_tray(jj["vt_tray"].get<json>());
                                main_slot.id = std::to_string(VIRTUAL_TRAY_MAIN_ID);
 
 
                                auto it = std::next(vt_slot.begin(), 0);
                                if (it != vt_slot.end()) {
                                    vt_slot[0] = main_slot;
                                }
                                else {
                                    vt_slot.push_back(main_slot);
                                }
                            }
                            else {
                                ams_support_virtual_tray = false;
                            }
                        }
                        catch (...) {
                            ;
                        }
                    }
 
                    /*parse new print data*/
                    try {
                        parse_new_info(jj);
                    } catch (...) {}
#pragma endregion
                } else if (jj["command"].get<std::string>() == "gcode_line") {
                    //ack of gcode_line
                    BOOST_LOG_TRIVIAL(debug) << "parse_json, ack of gcode_line = " << j.dump(4);
                } else if (jj["command"].get<std::string>() == "project_prepare") {
                    //ack of project file
                    BOOST_LOG_TRIVIAL(info) << "parse_json, ack of project_prepare = " << j.dump(4);
                    if (m_agent) {
                        if (jj.contains("job_id")) {
                            this->job_id_ = DevJsonValParser::get_longlong_val(jj["job_id"]);
                        }
                    }
 
                } else if (jj["command"].get<std::string>() == "project_file") {
                    //ack of project file
                    BOOST_LOG_TRIVIAL(debug) << "parse_json, ack of project_file = " << j.dump(4);
                    std::string result;
                    if (jj.contains("result")) {
                        result = jj["result"].get<std::string>();
                        if (result == "FAIL") {
                            wxString text = _L("Failed to start print job");
                            GUI::wxGetApp().push_notification(this, text);
                        }
                    }
                } else if (jj["command"].get<std::string>() == "ams_filament_setting" && !key_field_only) {
                    // BBS trigger ams UI update
                    ams_version = -1;
 
                    if (jj["ams_id"].is_number()) {
                        int ams_id = jj["ams_id"].get<int>();
                        int tray_id = 0;
                        if (jj.contains("tray_id")) {
                            tray_id = jj["tray_id"].get<int>();
                        }
                        if (ams_id == 255 && tray_id == VIRTUAL_TRAY_MAIN_ID) {
                            BOOST_LOG_TRIVIAL(info) << "ams_filament_setting, parse tray info";
                            vt_slot[0].nozzle_temp_max = std::to_string(jj["nozzle_temp_max"].get<int>());
                            vt_slot[0].nozzle_temp_min = std::to_string(jj["nozzle_temp_min"].get<int>());
                            vt_slot[0].color = jj["tray_color"].get<std::string>();
                            vt_slot[0].setting_id = jj["tray_info_idx"].get<std::string>();
                            //vt_tray.type = jj["tray_type"].get<std::string>();
                            vt_slot[0].m_fila_type = setting_id_to_type(vt_slot[0].setting_id, jj["tray_type"].get<std::string>());
                            // delay update
                            vt_slot[0].set_hold_count();
                        } else {
                            auto ams = m_fila_system->GetAmsById(std::to_string(ams_id));
                            if (ams) {
                                tray_id = jj["tray_id"].get<int>();
                                auto tray_it = ams->GetTrays().find(std::to_string(tray_id));
                                if (tray_it != ams->GetTrays().end()) {
                                    BOOST_LOG_TRIVIAL(trace) << "ams_filament_setting, parse tray info";
                                    tray_it->second->nozzle_temp_max = std::to_string(jj["nozzle_temp_max"].get<int>());
                                    tray_it->second->nozzle_temp_min = std::to_string(jj["nozzle_temp_min"].get<int>());
                                    //tray_it->second->type = jj["tray_type"].get<std::string>();
                                    tray_it->second->color = jj["tray_color"].get<std::string>();
 
                                    /*tray_it->second->cols.clear();
                                    if (jj.contains("cols")) {
                                        if (jj["cols"].is_array()) {
                                            for (auto it = jj["cols"].begin(); it != jj["cols"].end(); it++) {
                                                tray_it->second->cols.push_back(it.value().get<std::string>());
                                            }
                                        }
                                    }*/
 
                                    tray_it->second->setting_id = jj["tray_info_idx"].get<std::string>();
                                    tray_it->second->m_fila_type = setting_id_to_type(tray_it->second->setting_id, jj["tray_type"].get<std::string>());
                                    // delay update
                                    tray_it->second->set_hold_count();
                                } else {
                                    BOOST_LOG_TRIVIAL(warning) << "ams_filament_setting, can not find in trayList, tray_id=" << tray_id;
                                }
                            } else {
                                BOOST_LOG_TRIVIAL(warning) << "ams_filament_setting, can not find in amsList, ams_id=" << ams_id;
                            }
                        }
                    }
                } else if (jj["command"].get<std::string>() == "xcam_control_set" && !key_field_only) {
                    if (jj.contains("module_name")) {
                        if (jj.contains("enable") || jj.contains("control")) {
                            bool enable = false;
                            if (jj.contains("enable"))
                                enable = jj["enable"].get<bool>();
                            else if (jj.contains("control"))
                                enable = jj["control"].get<bool>();
                            else {
                                ;
                            }
 
                            if (jj["module_name"].get<std::string>() == "first_layer_inspector") {
                                if (time(nullptr) - xcam_first_layer_hold_start > HOLD_TIME_3SEC) {
                                    xcam_first_layer_inspector = enable;
                                }
                            }
                            else if (jj["module_name"].get<std::string>() == "buildplate_marker_detector") {
                                if (time(nullptr) - xcam_buildplate_marker_hold_start > HOLD_TIME_3SEC) {
                                    xcam_buildplate_marker_detector = enable;
                                }
                            }
                            else if (jj["module_name"].get<std::string>() == "printing_monitor") {
                                if (time(nullptr) - xcam_ai_monitoring_hold_start > HOLD_TIME_3SEC) {
                                    xcam_ai_monitoring = enable;
                                    if (jj.contains("halt_print_sensitivity")) {
                                        xcam_ai_monitoring_sensitivity = jj["halt_print_sensitivity"].get<std::string>();
                                    }
                                }
                            }
                            else if (jj["module_name"].get<std::string>() == "spaghetti_detector") {
                                if (time(nullptr) - xcam_ai_monitoring_hold_start > HOLD_TIME_3SEC) {
                                    // old protocol
                                    xcam_ai_monitoring = enable;
                                    if (jj.contains("print_halt")) {
                                        if (jj["print_halt"].get<bool>()) {
                                            xcam_ai_monitoring_sensitivity = "medium";
                                        }
                                    }
                                }
                            }
                        }
                    }
                } else if(jj["command"].get<std::string>() == "print_option") {
                     try {
                          if (jj.contains("option")) {
                              if (jj["option"].is_number()) {
                                  int option = jj["option"].get<int>();
                                  if (time(nullptr) - xcam_auto_recovery_hold_start > HOLD_TIME_3SEC) {
                                      xcam_auto_recovery_step_loss = ((option >> (int)PRINT_OP_AUTO_RECOVERY) & 0x01) != 0;
                                  }
                              }
                          }
 
                          if (time(nullptr) - xcam_auto_recovery_hold_start > HOLD_TIME_3SEC) {
                              if (jj.contains("auto_recovery")) {
                                  xcam_auto_recovery_step_loss = jj["auto_recovery"].get<bool>();
                              }
                          }
                     }
                     catch(...) {
                     }
                } else if (jj["command"].get<std::string>() == "extrusion_cali" || jj["command"].get<std::string>() == "flowrate_cali") {
                    if (jj.contains("result")) {
                        if (jj["result"].get<std::string>() == "success") {
                            ;
                        }
                        else if (jj["result"].get<std::string>() == "fail") {
                            std::string cali_mode = jj["command"].get<std::string>();
                            std::string reason = jj["reason"].get<std::string>();
                            wxString info = "";
                            if (reason == "invalid nozzle_diameter" || reason == "nozzle_diameter is not supported") {
                                info = _L("This calibration does not support the currently selected nozzle diameter");
                            }
                            else if (reason == "invalid handle_flowrate_cali param") {
                                info = _L("Current flowrate cali param is invalid");
                            }
                            else if (reason == "nozzle_diameter is not matched") {
                                info = _L("Selected diameter and machine diameter do not match");
                            }
                            else if (reason == "generate auto filament cali gcode failure") {
                                info = _L("Failed to generate calibration G-code");
                            }
                            else {
                                info = reason;
                            }
                            GUI::wxGetApp().push_notification(this, info, _L("Calibration error"), UserNotificationStyle::UNS_WARNING_CONFIRM);
                            BOOST_LOG_TRIVIAL(info) << cali_mode << " result fail, reason = " << reason;
                        }
                    }
                } else if (jj["command"].get<std::string>() == "extrusion_cali_set") {
                    int ams_id = -1;
                    int tray_id = -1;
                    int curr_tray_id = -1;
                    if (jj.contains("tray_id")) {
                        try {
                            curr_tray_id = jj["tray_id"].get<int>();
                            if (curr_tray_id == VIRTUAL_TRAY_MAIN_ID)
                                tray_id = curr_tray_id;
                            else if (curr_tray_id >= 0 && curr_tray_id < 16){
                                ams_id = curr_tray_id / 4;
                                tray_id = curr_tray_id % 4;
                            } else {
                                BOOST_LOG_TRIVIAL(trace) << "extrusion_cali_set: unsupported tray_id = " << curr_tray_id;
                            }
                        }
                        catch(...) {
                            ;
                        }
                    }
                    if (tray_id == VIRTUAL_TRAY_MAIN_ID) {
                        if (jj.contains("k_value"))
                            vt_slot[0].k = jj["k_value"].get<float>();
                        if (jj.contains("n_coef"))
                            vt_slot[0].n = jj["n_coef"].get<float>();
                    } else {
 
                        auto ams_item = m_fila_system->GetAmsById(std::to_string(ams_id));
                        if (ams_item) {
                            auto tray_item = ams_item->GetTrays().find(std::to_string(tray_id));
                            if (tray_item != ams_item->GetTrays().end()) {
                                if (jj.contains("k_value"))
                                    tray_item->second->k = jj["k_value"].get<float>();
                                if (jj.contains("n_coef"))
                                    tray_item->second->n = jj["n_coef"].get<float>();
                            }
                        }
                    }
                    extrusion_cali_set_tray_id = curr_tray_id;
                    extrusion_cali_set_hold_start = std::chrono::system_clock::now();
                }
                else if (jj["command"].get<std::string>() == "extrusion_cali_sel") {
                    int ams_id       = -1;
                    int slot_id      = -1;
                    int tray_id      = -1;
 
                    if (jj.contains("ams_id")) {
                        try {
                            ams_id  = jj["ams_id"].get<int>();
                            slot_id = jj["slot_id"].get<int>();
                        } catch (...) {
                            ;
                        }
                    }
                    else {
                        tray_id = jj["tray_id"].get<int>();
                        if(tray_id >= 0 && tray_id < 16)
                        {
                            ams_id  = tray_id / 4;
                            slot_id = tray_id % 4;
                        }
                        else if(tray_id == VIRTUAL_TRAY_MAIN_ID || tray_id == VIRTUAL_TRAY_DEPUTY_ID){
                            ams_id  = tray_id;
                            slot_id = 0;
                        }
                    }
 
                    BOOST_LOG_TRIVIAL(trace) << "extrusion_cali_sel: unsupported ams_id = " << ams_id << "slot_id = " << slot_id;
 
                    if (jj.contains("cali_idx")) {
                        if (ams_id == VIRTUAL_TRAY_MAIN_ID || ams_id == VIRTUAL_TRAY_DEPUTY_ID) {
 
                            if (ams_id == VIRTUAL_TRAY_MAIN_ID && vt_slot.size() > 0) {
 
                                vt_slot[MAIN_EXTRUDER_ID].cali_idx = jj["cali_idx"].get<int>();
                                vt_slot[MAIN_EXTRUDER_ID].set_hold_count();
 
                            } else if (ams_id == VIRTUAL_TRAY_DEPUTY_ID && vt_slot.size() > 1) {
 
                                vt_slot[DEPUTY_EXTRUDER_ID].cali_idx = jj["cali_idx"].get<int>();
                                vt_slot[DEPUTY_EXTRUDER_ID].set_hold_count();
 
                            }
 
                        }
                        else {
                            auto tray_item = m_fila_system->GetAmsTray(std::to_string(ams_id), std::to_string(slot_id));
                            if (tray_item)
                            {
                                tray_item->cali_idx = jj["cali_idx"].get<int>();
                                tray_item->set_hold_count();
                            }
                        }
                    }
 
                }
                else if (jj["command"].get<std::string>() == "extrusion_cali_get") {
                    std::string str = jj.dump();
                    if (request_tab_from_bbs) {
                        BOOST_LOG_TRIVIAL(info) << "bbs extrusion_cali_get: " << str;
                        request_tab_from_bbs = false;
                        reset_pa_cali_history_result();
                        bool is_succeed = true;
                        if (jj.contains("result") && jj.contains("reason")) {
                            if (jj["result"].get<std::string>() == "fail") {
                                is_succeed = false;
                            }
                        }
 
                        if (is_succeed) {
                            last_cali_version = cali_version;
                            has_get_pa_calib_tab = true;
                        }
 
                        if (jj.contains("filaments") && jj["filaments"].is_array()) {
                            try {
                                for (auto it = jj["filaments"].begin(); it != jj["filaments"].end(); it++) {
                                    PACalibResult pa_calib_result;
                                    pa_calib_result.filament_id = (*it)["filament_id"].get<std::string>();
                                    pa_calib_result.name        = (*it)["name"].get<std::string>();
                                    pa_calib_result.cali_idx    = (*it)["cali_idx"].get<int>();
 
                                    if ((*it).contains("setting_id")) {
                                        pa_calib_result.setting_id  = (*it)["setting_id"].get<std::string>();
                                    }
 
                                    if ((*it).contains("extruder_id")) {
                                        pa_calib_result.extruder_id = (*it)["extruder_id"].get<int>();
                                    }
 
                                    if ((*it).contains("nozzle_id")) {
                                        pa_calib_result.nozzle_volume_type = convert_to_nozzle_type((*it)["nozzle_id"].get<std::string>());
                                    }
 
                                    if ((*it).contains("nozzle_pos")) {
                                        pa_calib_result.nozzle_pos_id = (*it)["nozzle_pos"].get<int>();
                                    }
 
                                    if ((*it).contains("nozzle_sn")) {
                                        pa_calib_result.nozzle_sn = (*it)["nozzle_sn"].get<std::string>();
                                    }
 
                                    if (jj["nozzle_diameter"].is_number_float()) {
                                        pa_calib_result.nozzle_diameter = jj["nozzle_diameter"].get<float>();
                                    } else if (jj["nozzle_diameter"].is_string()) {
                                        pa_calib_result.nozzle_diameter = string_to_float(jj["nozzle_diameter"].get<std::string>());
                                    }
 
                                    if ((*it)["k_value"].is_number_float())
                                        pa_calib_result.k_value = (*it)["k_value"].get<float>();
                                    else if ((*it)["k_value"].is_string())
                                        pa_calib_result.k_value = string_to_float((*it)["k_value"].get<std::string>());
 
                                    if ((*it)["n_coef"].is_number_float())
                                        pa_calib_result.n_coef = (*it)["n_coef"].get<float>();
                                    else if ((*it)["n_coef"].is_string())
                                        pa_calib_result.n_coef = string_to_float((*it)["n_coef"].get<std::string>());
 
                                    if (check_pa_result_validation(pa_calib_result))
                                        pa_calib_tab.push_back(pa_calib_result);
                                    else {
                                        BOOST_LOG_TRIVIAL(info) << "pa result is invalid";
                                    }
                                }
 
                            }
                            catch (...) {
 
                            }
                        }
                        // notify cali history to update
                    }
                }
                else if (jj["command"].get<std::string>() == "extrusion_cali_get_result") {
                    std::string str = jj.dump();
                    BOOST_LOG_TRIVIAL(info) << "extrusion_cali_get_result: " << str;
                    reset_pa_cali_result();
                    bool is_succeed = true;
                    if (jj.contains("result") && jj.contains("reason")) {
                        if (jj["result"].get<std::string>() == "fail") {
                            if (jj.contains("err_code")) {
                                is_succeed    = false;
                            }
                        }
                    }
 
                    if (is_succeed)
                        get_pa_calib_result = true;
 
                    if (jj.contains("filaments") && jj["filaments"].is_array()) {
                        try {
                            for (auto it = jj["filaments"].begin(); it != jj["filaments"].end(); it++) {
                                PACalibResult pa_calib_result;
                                pa_calib_result.filament_id = (*it)["filament_id"].get<std::string>();
 
                                if ((*it).contains("setting_id")) {
                                    pa_calib_result.setting_id  = (*it)["setting_id"].get<std::string>();
                                }
 
                                // old
                                if (jj["nozzle_diameter"].is_number_float()) {
                                    pa_calib_result.nozzle_diameter = jj["nozzle_diameter"].get<float>();
                                } else if (jj["nozzle_diameter"].is_string()) {
                                    pa_calib_result.nozzle_diameter = string_to_float(jj["nozzle_diameter"].get<std::string>());
                                }
 
                                // new: should get nozzle diameter from filament item
                                if ((*it).contains("setting_id")) {
                                    if ((*it)["nozzle_diameter"].is_number_float()) {
                                        pa_calib_result.nozzle_diameter = (*it)["nozzle_diameter"].get<float>();
                                    } else if ((*it)["nozzle_diameter"].is_string()) {
                                        pa_calib_result.nozzle_diameter = string_to_float((*it)["nozzle_diameter"].get<std::string>());
                                    }
                                }
 
                                if (it->contains("ams_id")) {
                                    pa_calib_result.ams_id = (*it)["ams_id"].get<int>();
                                } else {
                                    pa_calib_result.ams_id = 0;
                                }
 
                                if (it->contains("slot_id")) {
                                    pa_calib_result.slot_id = (*it)["slot_id"].get<int>();
                                } else {
                                    pa_calib_result.slot_id = 0;
                                }
 
                                if (it->contains("extruder_id")) {
                                    pa_calib_result.extruder_id = (*it)["extruder_id"].get<int>();
                                } else {
                                    pa_calib_result.extruder_id = -1;
                                }
 
                                if (it->contains("nozzle_id")) {
                                    pa_calib_result.nozzle_volume_type = convert_to_nozzle_type((*it)["nozzle_id"].get<std::string>());
                                } else {
                                    pa_calib_result.nozzle_volume_type = NozzleVolumeType::nvtStandard;
                                }
 
                                if (it->contains("nozzle_pos")) {
                                    pa_calib_result.nozzle_pos_id = (*it)["nozzle_pos"].get<int>();
                                }
 
                                if (it->contains("nozzle_sn")) {
                                    pa_calib_result.nozzle_sn = (*it)["nozzle_sn"].get<std::string>();
                                }
 
                                if ((*it)["k_value"].is_number_float())
                                    pa_calib_result.k_value = (*it)["k_value"].get<float>();
                                else if ((*it)["k_value"].is_string())
                                    pa_calib_result.k_value = string_to_float((*it)["k_value"].get<std::string>());
 
                                if ((*it)["n_coef"].is_number_float())
                                    pa_calib_result.n_coef = (*it)["n_coef"].get<float>();
                                else if ((*it)["n_coef"].is_string())
                                    pa_calib_result.n_coef = string_to_float((*it)["n_coef"].get<std::string>());
 
                                if (it->contains("confidence")) {
                                    pa_calib_result.confidence = (*it)["confidence"].get<int>();
                                } else {
                                    pa_calib_result.confidence = 0;
                                }
 
                                if (this->is_support_new_auto_cali_method)
                                    pa_calib_result.tray_id = get_tray_id_by_ams_id_and_slot_id(pa_calib_result.ams_id, pa_calib_result.slot_id);
                                else
                                    pa_calib_result.tray_id = (*it)["tray_id"].get<int>();
 
                                if (check_pa_result_validation(pa_calib_result))
                                    pa_calib_results.push_back(pa_calib_result);
                                else {
                                    BOOST_LOG_TRIVIAL(info) << "pa result is invalid";
                                }
                            }
                        } catch (...) {}
                    }
 
                    if (pa_calib_results.empty()) {
                        BOOST_LOG_TRIVIAL(info) << "no pa calib result";
                    }
                }
                else if (jj["command"].get<std::string>() == "flowrate_get_result" && !key_field_only) {
                    this->reset_flow_rate_cali_result();
 
                    get_flow_calib_result = true;
                    if (jj.contains("filaments") && jj["filaments"].is_array()) {
                        try {
#ifdef CALI_DEBUG
                            std::string str = jj.dump();
                            BOOST_LOG_TRIVIAL(info) << "flowrate_get_result: " << str;
#endif
                            for (auto it = jj["filaments"].begin(); it != jj["filaments"].end(); it++) {
                                FlowRatioCalibResult flow_ratio_calib_result;
                                flow_ratio_calib_result.tray_id     = (*it)["tray_id"].get<int>();
                                flow_ratio_calib_result.filament_id = (*it)["filament_id"].get<std::string>();
                                flow_ratio_calib_result.setting_id  = (*it)["setting_id"].get<std::string>();
                                flow_ratio_calib_result.nozzle_diameter = string_to_float(jj["nozzle_diameter"].get<std::string>());
                                flow_ratio_calib_result.flow_ratio      = string_to_float((*it)["flow_ratio"].get<std::string>());
                                if (it->contains("confidence")) {
                                    flow_ratio_calib_result.confidence = (*it)["confidence"].get<int>();
                                } else {
                                    flow_ratio_calib_result.confidence = 0;
                                }
 
                                flow_ratio_results.push_back(flow_ratio_calib_result);
                            }
 
                        } catch (...) {}
                    }
                }
               m_fan->command_handle_response(jj);
            }
        }
 
        if (!key_field_only) {
            try {
                if (j.contains("camera")) {
                    if (j["camera"].contains("command")) {
                        if (j["camera"]["command"].get<std::string>() == "ipcam_timelapse") {
                            if (camera_timelapse_hold_count > 0) {
                                camera_timelapse_hold_count--;
                            }
                            else
                            {
                                if (j["camera"]["control"].get<std::string>() == "enable") this->camera_timelapse = true;
                                if (j["camera"]["control"].get<std::string>() == "disable") this->camera_timelapse = false;
                                BOOST_LOG_TRIVIAL(info) << "ack of timelapse = " << camera_timelapse;
                            }
                        } else if (j["camera"]["command"].get<std::string>() == "ipcam_record_set") {
                            if (time(nullptr) - camera_recording_ctl_start > HOLD_TIME_3SEC) {
                                if (j["camera"]["control"].get<std::string>() == "enable") this->camera_recording_when_printing = true;
                                if (j["camera"]["control"].get<std::string>() == "disable") this->camera_recording_when_printing = false;
                                BOOST_LOG_TRIVIAL(info) << "ack of ipcam_record_set " << camera_recording_when_printing;
                            }
                        } else if (j["camera"]["command"].get<std::string>() == "ipcam_resolution_set") {
                            if (camera_resolution_hold_count > 0) {
                                camera_resolution_hold_count--;
                            }
                            else
                            {
                                this->camera_resolution = j["camera"]["resolution"].get<std::string>();
                                BOOST_LOG_TRIVIAL(info) << "ack of resolution = " << camera_resolution;
                            }
                        } else if (j["camera"]["command"].get<std::string>() == "ipcam_get_media_info") {
                            if (j["camera"].contains("sub_command") &&
                                j["camera"]["sub_command"].get<std::string>() == "is_timelapse_storage_enough") {
                                timelapse_storage_check_result = j["camera"].value("result", -1);
                                timelapse_storage_is_enough = j["camera"].value("is_enough", true);
                                timelapse_storage_file_count = j["camera"].value("file_count", 0);
                                timelapse_storage_check_done = true;
                                BOOST_LOG_TRIVIAL(info) << "timelapse storage check: result=" << timelapse_storage_check_result
                                    << " is_enough=" << timelapse_storage_is_enough
                                    << " file_count=" << timelapse_storage_file_count;
                            }
                        }
                    }
                }
            } catch (...) {}
        }
 
        if (!key_field_only) {
            // upgrade
            try {
                if (j.contains("upgrade")) {
                    if (j["upgrade"].contains("command")) {
                        if (j["upgrade"]["command"].get<std::string>() == "upgrade_confirm") {
                            this->upgrade_display_state = DevFirmwareUpgradingState::UpgradingInProgress;
                            upgrade_display_hold_count = HOLD_COUNT_MAX;
                            BOOST_LOG_TRIVIAL(info) << "ack of upgrade_confirm";
                        }
 
                        bool check_studio_cmd = true;
                        if (j["upgrade"].contains("sequence_id")) {
                            try
                            {
                                std::string str_seq = j["upgrade"]["sequence_id"].get<std::string>();
                                check_studio_cmd = is_studio_cmd(stoi(str_seq));
                            }
                            catch (...) { }
                        }
 
                        if (check_studio_cmd && j["upgrade"].contains("err_code")) {
                            if (j["upgrade"]["err_code"].is_number()) {
                                add_command_error_code_dlg(j["upgrade"]["err_code"].get<int>());
                            }
                        }
                    }
                }
            }
            catch (...) {
                ;
            }
        }
 
        if (!key_field_only) {
            BOOST_LOG_TRIVIAL(trace) << "parse_json  m_active_state =" << m_active_state;
            parse_state_changed_event();
        }
    }
    catch (...) {
        BOOST_LOG_TRIVIAL(trace) << "parse_json failed! dev_id=" << this->get_dev_id() <<", payload = " << payload;
    }
 
    std::chrono::system_clock::time_point clock_stop = std::chrono::system_clock::now();
    auto diff = std::chrono::duration_cast<std::chrono::milliseconds>(clock_stop - clock_start);
    if (diff.count() > 10.0f) {
        BOOST_LOG_TRIVIAL(trace) << "parse_json timeout = " << diff.count();
    }
    DeviceManager::update_local_machine(*this, m_manager ? m_manager->get_app_config() : GUI::wxGetApp().app_config);
 
    return 0;
}

References _L, _parse_ams_status(), Slic3r::_parse_printer_type(), access_code, Active, add_command_error_code_dlg(), ahb_new_version_number, Slic3r::PACalibResult::ams_id, ams_new_version_number, ams_support_virtual_tray, ams_version, bed_temp_range, bed_temperature_limit, Slic3r::PACalibResult::cali_idx, cali_version, camera_recording_ctl_start, camera_recording_when_printing, camera_resolution, camera_resolution_hold_count, camera_resolution_supported, camera_timelapse, camera_timelapse_hold_count, chamber_temp, chamber_temp_target, check_enable_np(), check_pa_result_validation(), check_version_valid(), clear_version_info(), command_get_version(), command_request_push_all(), Slic3r::FlowRatioCalibResult::confidence, Slic3r::PACalibResult::confidence, Slic3r::Geometry::contains(), Slic3r::convert_to_nozzle_type(), Slic3r::DevUtil::convertToIp(), curr_layer, DEPUTY_EXTRUDER_ID, dev_id, Slic3r::diff(), Slic3r::enum_index_of(), Slic3r::PACalibResult::extruder_id, extrusion_cali_set_hold_start, extrusion_cali_set_tray_id, Slic3r::FlowRatioCalibResult::filament_id, Slic3r::PACalibResult::filament_id, file_local, file_model_download, file_remote, Slic3r::DevFirmwareVersionInfo::firmware_flag, firmware_type, Slic3r::FIRMWARE_TYPE_ENGINEER, Slic3r::FIRMWARE_TYPE_PRODUCTION, Slic3r::FL_None, Slic3r::FlowRatioCalibResult::flow_ratio, flow_ratio_results, Slic3r::flush_logs(), Slic3r::FR_None, frame_temp, gcode_file_prepare_percent, get_dev_id(), get_flag_bits(), get_flow_calib_result, Slic3r::get_logging_level(), Slic3r::DevJsonValParser::get_longlong_val(), get_pa_calib_result, get_subtask(), get_tray_id_by_ams_id_and_slot_id(), get_version_retry, has_extra_flow_type, has_get_pa_calib_tab, has_ipcam, HOLD_COUNT_MAX, HOLD_TIME_3SEC, hw_switch_state, Slic3r::DevFirmwareVersionInfo::hw_ver, Slic3r::DevAmsSystemFirmwareSwitch::IDX_AMS_AMS2_AMSHT, is_enable_ams_np, is_lan_mode_printer(), is_studio_cmd(), is_support_1080dpi, is_support_agora, is_support_ams_humidity, is_support_auto_recovery_step_loss, is_support_bed_leveling, is_support_build_plate_marker_detect, is_support_cloud_print_only, is_support_command_ams_switch, is_support_ext_change_assist_old, is_support_fila_change_abort, is_support_filament_32_colors, is_support_filament_backup, is_support_filament_setting_inprinting, is_support_filament_tangle_detect, is_support_layer_num, is_support_motor_noise_cali, is_support_mqtt_alive, is_support_new_auto_cali_method, is_support_pa_calibration, is_support_prompt_sound, is_support_refresh_nozzle, is_support_send_to_sdcard, is_support_timelapse, is_support_tunnel_mqtt, is_support_update_remain, is_support_user_preset, is_support_wait_sending_finish, is_tunnel_mqtt, job_id_, jobState_, Slic3r::PACalibResult::k_value, last_cali_version, last_cloud_msg_time_, last_lan_msg_time_, last_online_version, last_push_time, last_update_time, last_utc_time, Slic3r::level_string_to_boost(), lifecycle, link_ams, link_th, liveview_local, liveview_remote, local_rtsp_url, Slic3r::LVL_Disable, Slic3r::LVL_None, Slic3r::LVL_Rtsp, Slic3r::LVL_Rtsps, Slic3r::LVR_None, m_active_state, m_agent, m_agent_thumbnail_url, m_axis, m_bed, m_chamber, m_config, m_extder_system, m_fan, m_fila_switch, m_fila_system, m_full_msg_count, m_gcode_file, m_hms_system, m_lamp, m_manager, m_new_ver_list_exist, m_nozzle_mapping_ptr, m_nozzle_system, m_partskip_ids, m_plate_index, m_plate_maker_detect_type, m_print_error_img_id, m_print_options, m_push_count, m_status, m_storage, MAIN_EXTRUDER_ID, mc_left_time, mc_print_error_code, mc_print_line_number, mc_print_stage, mc_print_sub_stage, message_delay, MINUTE_30, Slic3r::PACalibResult::n_coef, Slic3r::DevFirmwareVersionInfo::name, Slic3r::PACalibResult::name, network_wired, new_ver_list, NotActive, Slic3r::FlowRatioCalibResult::nozzle_diameter, Slic3r::PACalibResult::nozzle_diameter, Slic3r::PACalibResult::nozzle_pos_id, Slic3r::PACalibResult::nozzle_sn, nozzle_temp_range, Slic3r::PACalibResult::nozzle_volume_type, Slic3r::nvtStandard, obj_subtask_id, online_ahb, online_rfid, online_version, ota_new_version_number, pa_calib_results, pa_calib_tab, Slic3r::DevPrintOptionsParser::Parse(), parse_home_flag(), parse_msg_count, parse_new_info(), parse_new_info2(), parse_state_changed_event(), parse_version(), parse_version_func(), parse_vt_tray(), Slic3r::DevBed::ParseV1_0(), Slic3r::DevFilaSystemParser::ParseV1_0(), Slic3r::DevNozzleSystemParser::ParseV1_0(), Slic3r::DevStorage::ParseV1_0(), Slic3r::ExtderSystemParser::ParseV1_0(), print_error, print_json, PRINT_OP_AUTO_RECOVERY, print_status, print_type, printer_type, printing_speed_mag, Slic3r::BBLSubTask::printing_status, Slic3r::DevFirmwareVersionInfo::product_name, queue_number, request_tab_from_bbs, reset_flow_rate_cali_result(), reset_pa_cali_history_result(), reset_pa_cali_result(), RETRY_INTERNAL, sanitizeToUtf8(), set_access_code(), set_ctt_dlg(), set_dev_ip(), set_online_state(), set_print_state(), Slic3r::FlowRatioCalibResult::setting_id, Slic3r::PACalibResult::setting_id, setting_id_to_type(), Slic3r::PACalibResult::slot_id, Slic3r::DevFirmwareVersionInfo::sn, stage_curr, stage_list_info, stage_remaining_seconds, store_version_info(), Slic3r::string_to_float(), subtask_name, Slic3r::DevFirmwareVersionInfo::sw_new_ver, Slic3r::DevFirmwareVersionInfo::sw_ver, Slic3r::BBLSubTask::task_id, task_id_, TIME_OUT, timelapse_storage_check_done, timelapse_storage_check_result, timelapse_storage_file_count, timelapse_storage_is_enough, total_layers, Slic3r::trace(), Slic3r::NetworkAgent::track_update_property(), Slic3r::FlowRatioCalibResult::tray_id, Slic3r::PACalibResult::tray_id, tutk_state, Slic3r::UNS_WARNING_CONFIRM, update_filament_list(), Slic3r::DeviceManager::update_local_machine(), update_print_progress(), update_printer_preset_name(), update_slice_info(), upgrade_consistency_request, upgrade_display_hold_count, upgrade_display_state, upgrade_err_code, upgrade_force_upgrade, upgrade_message, upgrade_module, upgrade_new_version, upgrade_progress, upgrade_status, Slic3r::UpgradingAvaliable, Slic3r::UpgradingFinished, Slic3r::UpgradingInProgress, Slic3r::UpgradingUnavaliable, virtual_camera, VIRTUAL_TRAY_DEPUTY_ID, VIRTUAL_TRAY_MAIN_ID, vt_slot, webcam_stream_url, wifi_signal, xcam_ai_monitoring, xcam_ai_monitoring_hold_start, xcam_ai_monitoring_sensitivity, xcam_airprinting_detection, xcam_airprinting_detection_sensitivity, xcam_auto_recovery_hold_start, xcam_auto_recovery_step_loss, xcam_buildplate_marker_detector, xcam_buildplate_marker_hold_start, xcam_disable_ai_detection_display, xcam_first_layer_hold_start, xcam_first_layer_inspector, xcam_nozzleclumping_detection, xcam_nozzleclumping_detection_sensitivity, xcam_purgechutepileup_detection, xcam_purgechutepileup_detection_sensitivity, xcam_spaghetti_detection, and xcam_spaghetti_detection_sensitivity.

Referenced by reload_printer_settings().

Here is the caller graph for this function:

parse_new_info()

void Slic3r::MachineObject::parse_new_info

(

nlohmann::json

print

)

{
    is_enable_np = check_enable_np(print);
    if (!is_enable_np)
    {
        return;
    }
 
    BOOST_LOG_TRIVIAL(info) << "using new print data for parsing";
 
    /*cfg*/
    std::string cfg = print["cfg"].get<std::string>();
 
    BOOST_LOG_TRIVIAL(info) << "new print data cfg = " << cfg;
 
    if(!cfg.empty()){
        if (camera_resolution_hold_count > 0) camera_resolution_hold_count--;
        if (camera_timelapse_hold_count > 0) camera_timelapse_hold_count--;
 
 
        if (time(nullptr) - ams_user_setting_start > HOLD_COUNT_MAX)
        {
            m_fila_system->GetAmsSystemSetting().SetDetectOnInsertEnabled(get_flag_bits(cfg, 0));
            m_fila_system->GetAmsSystemSetting().SetDetectOnPowerupEnabled(get_flag_bits(cfg, 1));
        }
 
        upgrade_force_upgrade = get_flag_bits(cfg, 2);
 
        if (time(nullptr) - camera_recording_ctl_start > HOLD_COUNT_MAX)
        {
            camera_recording_when_printing = get_flag_bits(cfg, 3);
        }
 
        if (camera_resolution_hold_count > 0)
        {
            camera_resolution_hold_count--;
        }
        else
        {
            camera_resolution = get_flag_bits(cfg, 4) == 0 ? "720p" : "1080p";
        }
 
        if (camera_timelapse_hold_count > 0)
        {
            camera_timelapse_hold_count--;
        }
        else
        {
            camera_timelapse = get_flag_bits(cfg, 5);
        }
 
        tutk_state = get_flag_bits(cfg, 6) == 1 ? "disable" : "";
        m_lamp->SetChamberLight(get_flag_bits(cfg, 7) == 1 ? DevLamp::LIGHT_EFFECT_ON : DevLamp::LIGHT_EFFECT_OFF);
        //is_support_build_plate_marker_detect = get_flag_bits(cfg, 12); todo yangcong
        if (time(nullptr) - xcam_first_layer_hold_start > HOLD_TIME_3SEC) { xcam_first_layer_inspector = get_flag_bits(cfg, 12); }
 
        if (time(nullptr) - xcam_ai_monitoring_hold_start > HOLD_COUNT_MAX) {
            xcam_ai_monitoring = get_flag_bits(cfg, 15);
 
            switch (get_flag_bits(cfg, 13, 2)) {
            case 0: xcam_ai_monitoring_sensitivity = "never_halt"; break;
            case 1: xcam_ai_monitoring_sensitivity = "low"; break;
            case 2: xcam_ai_monitoring_sensitivity = "medium"; break;
            case 3: xcam_ai_monitoring_sensitivity = "high"; break;
            default: break;
            }
        }
 
        if (time(nullptr) - xcam_auto_recovery_hold_start > HOLD_COUNT_MAX) {
            xcam_auto_recovery_step_loss = get_flag_bits(cfg, 16);
        }
 
        if (time(nullptr) - ams_user_setting_start > HOLD_COUNT_MAX){
            m_fila_system->GetAmsSystemSetting().SetDetectRemainEnabled(get_flag_bits(cfg, 17));
        }
 
        if (time(nullptr) - ams_switch_filament_start > HOLD_TIME_3SEC){
            m_fila_system->GetAmsSystemSetting().SetAutoRefillEnabled(get_flag_bits(cfg, 18));
        }
 
        if (time(nullptr) - xcam__save_remote_print_file_to_storage_start_time > HOLD_TIME_3SEC){
            xcam__save_remote_print_file_to_storage = get_flag_bits(cfg, 19);
        }
 
        if (time(nullptr) - xcam_door_open_check_start_time > HOLD_TIME_3SEC){
            xcam_door_open_check = (DoorOpenCheckState) get_flag_bits(cfg, 20, 2);
        }
 
        if (time(nullptr) - xcam_prompt_sound_hold_start > HOLD_TIME_3SEC) {
            xcam_allow_prompt_sound = get_flag_bits(cfg, 22);
        }
 
        if (time(nullptr) - xcam_filament_tangle_detect_hold_start > HOLD_TIME_3SEC){
            xcam_filament_tangle_detect = get_flag_bits(cfg, 23);
        }
 
        if (time(nullptr) - nozzle_blob_detection_hold_start > HOLD_TIME_3SEC) {
            nozzle_blob_detection_enabled = get_flag_bits(cfg, 24);
        }
 
        installed_upgrade_kit = get_flag_bits(cfg, 25);
 
        DevPrintOptionsParser::ParseDetectionV2_1(m_print_options, cfg);
    }
 
    /*fun*/
    std::string fun = print["fun"].get<std::string>();
    BOOST_LOG_TRIVIAL(info) << "new print data fun = " << fun;
 
    if (!fun.empty()) {
 
        is_support_agora    = get_flag_bits(fun, 1);
        if (is_support_agora) is_support_tunnel_mqtt = false;
 
        is_220V_voltage  = get_flag_bits(fun, 2) == 0?false:true;
        is_support_flow_calibration = get_flag_bits(fun, 6);
        if (this->is_series_o()) { is_support_flow_calibration = false; } // todo: Temp modification due to incorrect machine push message for H2D
        is_support_pa_calibration = get_flag_bits(fun, 7);
        if (this->is_series_p()) { is_support_pa_calibration = false; } // todo: Temp modification due to incorrect machine push message for P
        is_support_prompt_sound = get_flag_bits(fun, 8);
        is_support_filament_tangle_detect = get_flag_bits(fun, 9);
        is_support_motor_noise_cali = get_flag_bits(fun, 10);
        is_support_user_preset = get_flag_bits(fun, 11);
        is_support_door_open_check = get_flag_bits(fun, 12);
        is_support_nozzle_blob_detection = get_flag_bits(fun, 13);
        m_nozzle_system->SetSupportNozzleRack(get_flag_bits(fun, 60)); // H2C hotend rack support (device-side gate for the sync dialog)
        is_support_upgrade_kit = get_flag_bits(fun, 14);
        is_support_internal_timelapse = get_flag_bits(fun, 28);
        m_support_mqtt_homing = get_flag_bits(fun, 32);
        is_support_brtc = get_flag_bits(fun, 31);
        m_support_mqtt_axis_control = get_flag_bits(fun, 38);
        m_support_mqtt_bet_ctrl = get_flag_bits(fun, 39);
        is_support_new_auto_cali_method = get_flag_bits(fun, 40);
        is_support_spaghetti_detection = get_flag_bits(fun, 42);
        is_support_purgechutepileup_detection = get_flag_bits(fun, 43);
        is_support_nozzleclumping_detection = get_flag_bits(fun, 44);
        is_support_airprinting_detection = get_flag_bits(fun, 45);
        m_fan->SetSupportCoolingFilter(get_flag_bits(fun, 46));
        is_support_ext_change_assist = get_flag_bits(fun, 48);
        is_support_partskip = get_flag_bits(fun, 49);
        is_support_idelheadingprotect_detection = get_flag_bits(fun, 62);
    }
 
    /*fun2*/
    std::string fun2;
    if (print.contains("fun2") && print["fun2"].is_string()) {
        fun2 = print["fun2"].get<std::string>();
        BOOST_LOG_TRIVIAL(info) << "new print data fun2 = " << fun2;
    }
 
    // fun2 may have infinite length, use get_flag_bits_no_border
    if (!fun2.empty()) {
        is_support_print_with_emmc = get_flag_bits_no_border(fun2, 0) == 1;
        is_support_pa_mode = (get_flag_bits_no_border(fun2, 3) == 1);
        is_support_remote_dry = (get_flag_bits_no_border(fun2, 5) == 1);
        is_support_check_track_switch_match_slice_printer = get_flag_bits_no_border(fun2, 19) == 1;
        is_support_filament_manual_multi_color = (get_flag_bits_no_border(fun2, 23) == 1);
 
        if (DevPrinterConfigUtil::support_print_check_firmware_for_tpu_left(printer_type)) {
            m_firmware_support_print_tpu_left = get_flag_bits_no_border(fun2, 7) == 1;
        }
    }
 
    /* Per-filament-index AMS slot mapping reported by the printer (task-level state) */
    if (print.contains("mapping") && print["mapping"].is_array()) {
        std::vector<uint16_t> new_mapping;
        new_mapping.reserve(print["mapping"].size());
        for (const auto& v : print["mapping"]) {
            new_mapping.push_back(static_cast<uint16_t>(v.get<unsigned>()));
        }
        print_job_filament_mapping = std::move(new_mapping);
    }
 
    /*aux*/
    std::string aux = print["aux"].get<std::string>();
 
    BOOST_LOG_TRIVIAL(info) << "new print data aux = " << aux;
 
    if (!aux.empty()) {
        m_storage->set_sdcard_state(get_flag_bits(aux, 12, 2));
        m_has_timelapse_kit = (get_flag_bits(aux, 26, 1) == 1);
    }
 
    /*stat*/
    std::string stat = print["stat"].get<std::string>();
 
    BOOST_LOG_TRIVIAL(info) << "new print data stat = " << stat;
 
    if (!stat.empty()) {
        camera_recording = get_flag_bits(stat, 7);
        m_lamp->SetLampCloseRecheck((get_flag_bits(stat, 36) == 1));
    }
 
    /*device*/
    if (print.contains("device")) {
        json const& device = print["device"];
 
 
        //new fan data
        m_fan->ParseV3_0(device);
 
        if (device.contains("type")) {
            m_device_mode = (DeviceMode)device["type"].get<int>();// FDM:1<<0 Laser:1<< Cut:1<<2
        }
 
        DevBed::ParseV2_0(device,m_bed);
 
        // Pass the whole device json: ParseV2_0 reads ext/rack nozzles from device["nozzle"] and the
        // hotend-rack state from device["holder"] (rack data lives outside device["nozzle"]). It is a
        // no-op for devices that report neither key, so non-rack machines are unaffected.
        DevNozzleSystemParser::ParseV2_0(device, m_nozzle_system);
        if (device.contains("extruder")) { ExtderSystemParser::ParseV2_0(device["extruder"], m_extder_system);}
        if (device.contains("ext_tool")) { DevExtensionToolParser::ParseV2_0(device["ext_tool"], m_extension_tool); }
 
        if (device.contains("ctc")) {
            json const& ctc = device["ctc"];
            int state = get_flag_bits(ctc["state"].get<int>(), 0, 4);
            if (ctc.contains("info")) {
                json const &info = ctc["info"];
                chamber_temp = get_flag_bits(info["temp"].get<int>(), 0, 16);
                chamber_temp_target  = get_flag_bits(info["temp"].get<int>(), 16, 16);
            }
        }
    }
}

References ams_switch_filament_start, ams_user_setting_start, camera_recording, camera_recording_ctl_start, camera_recording_when_printing, camera_resolution, camera_resolution_hold_count, camera_timelapse, camera_timelapse_hold_count, chamber_temp, chamber_temp_target, check_enable_np(), get_flag_bits(), get_flag_bits_no_border(), HOLD_COUNT_MAX, HOLD_TIME_3SEC, installed_upgrade_kit, is_220V_voltage, is_enable_np, is_series_o(), is_series_p(), is_support_agora, is_support_airprinting_detection, is_support_brtc, is_support_check_track_switch_match_slice_printer, is_support_door_open_check, is_support_ext_change_assist, is_support_filament_manual_multi_color, is_support_filament_tangle_detect, is_support_flow_calibration, is_support_idelheadingprotect_detection, is_support_internal_timelapse, is_support_motor_noise_cali, is_support_new_auto_cali_method, is_support_nozzle_blob_detection, is_support_nozzleclumping_detection, is_support_pa_calibration, is_support_pa_mode, is_support_partskip, is_support_print_with_emmc, is_support_prompt_sound, is_support_purgechutepileup_detection, is_support_remote_dry, is_support_spaghetti_detection, is_support_tunnel_mqtt, is_support_upgrade_kit, is_support_user_preset, Slic3r::DevLamp::LIGHT_EFFECT_OFF, Slic3r::DevLamp::LIGHT_EFFECT_ON, m_bed, m_device_mode, m_extder_system, m_extension_tool, m_fan, m_fila_system, m_firmware_support_print_tpu_left, m_has_timelapse_kit, m_lamp, m_nozzle_system, m_print_options, m_storage, m_support_mqtt_axis_control, m_support_mqtt_bet_ctrl, m_support_mqtt_homing, nozzle_blob_detection_enabled, nozzle_blob_detection_hold_start, Slic3r::DevPrintOptionsParser::ParseDetectionV2_1(), Slic3r::DevBed::ParseV2_0(), Slic3r::DevExtensionToolParser::ParseV2_0(), Slic3r::DevNozzleSystemParser::ParseV2_0(), Slic3r::ExtderSystemParser::ParseV2_0(), print_job_filament_mapping, printer_type, Slic3r::DevPrinterConfigUtil::support_print_check_firmware_for_tpu_left(), tutk_state, upgrade_force_upgrade, xcam__save_remote_print_file_to_storage, xcam__save_remote_print_file_to_storage_start_time, xcam_ai_monitoring, xcam_ai_monitoring_hold_start, xcam_ai_monitoring_sensitivity, xcam_allow_prompt_sound, xcam_auto_recovery_hold_start, xcam_auto_recovery_step_loss, xcam_door_open_check, xcam_door_open_check_start_time, xcam_filament_tangle_detect, xcam_filament_tangle_detect_hold_start, xcam_first_layer_hold_start, xcam_first_layer_inspector, and xcam_prompt_sound_hold_start.

Referenced by parse_json().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_new_info2()

void Slic3r::MachineObject::parse_new_info2

(

const nlohmann::json &

info

)

{
    if (!info.is_object() || info.value("command", "") != "get_capabilities")
        return;
 
    const auto capabilities_it = info.find("capabilities");
    if (capabilities_it == info.end() || !capabilities_it->is_object())
        return;
    const auto flags_it = capabilities_it->find("flags");
    if (flags_it == capabilities_it->end() || !flags_it->is_object())
        return;
 
    const json& flags = *flags_it;
    BOOST_LOG_TRIVIAL(info) << "parse_new_info2: OrcaSonar capability flags=" << flags.dump();
 
    auto parse_bool = [&flags](const char* name, bool& target) {
        const auto it = flags.find(name);
        if (it != flags.end() && it->is_boolean())
            target = it->get<bool>();
    };
 
    parse_bool("support_send_to_sd", is_support_send_to_sdcard);
    parse_bool("support_filament_backup", is_support_filament_backup);
    parse_bool("support_update_remain", is_support_update_remain);
    parse_bool("support_auto_recovery_step_loss", is_support_auto_recovery_step_loss);
    parse_bool("support_ams_humidity", is_support_ams_humidity);
    parse_bool("support_prompt_sound", is_support_prompt_sound);
    parse_bool("support_filament_tangle_detect", is_support_filament_tangle_detect);
    parse_bool("support_1080dpi", is_support_1080dpi);
    parse_bool("support_cloud_print_only", is_support_cloud_print_only);
    parse_bool("support_command_ams_switch", is_support_command_ams_switch);
    parse_bool("support_mqtt_alive", is_support_mqtt_alive);
    parse_bool("support_motor_noise_cali", is_support_motor_noise_cali);
    parse_bool("support_timelapse", is_support_timelapse);
    parse_bool("support_user_preset", is_support_user_preset);
    parse_bool("support_refresh_nozzle", is_support_refresh_nozzle);
    parse_bool("support_flow_calibration", is_support_flow_calibration);
    parse_bool("support_build_plate_marker_detect", is_support_build_plate_marker_detect);
    parse_bool("support_nozzle_blob_detect", is_support_nozzle_blob_detection);
 
    if (!m_manager->IsMultiMachineEnabled() && !is_support_agora)
        parse_bool("support_tunnel_mqtt", is_support_tunnel_mqtt);
 
    const auto bed_leveling_it = flags.find("support_bed_leveling");
    if (bed_leveling_it != flags.end() && bed_leveling_it->is_number_integer())
        is_support_bed_leveling = bed_leveling_it->get<int>();
 
    auto copy_bool = [&flags](json& target, const char* name) {
        const auto it = flags.find(name);
        if (it != flags.end() && it->is_boolean())
            target[name] = *it;
    };
 
    // The capability manifest uses an object for this range, while the legacy
    // DeviceCore parser consumes a boolean plus a two-element range array.
    json device_config;
    copy_bool(device_config, "support_chamber");
    copy_bool(device_config, "support_first_layer_inspect");
    copy_bool(device_config, "support_ai_monitoring");
    copy_bool(device_config, "support_lidar_calibration");
    const auto chamber_edit_it = flags.find("support_chamber_temp_edit");
    if (chamber_edit_it != flags.end() && chamber_edit_it->is_boolean()) {
        device_config["support_chamber_temp_edit"] = *chamber_edit_it;
    } else if (chamber_edit_it != flags.end() && chamber_edit_it->is_object()) {
        const auto min_it = chamber_edit_it->find("min");
        const auto max_it = chamber_edit_it->find("max");
        if (min_it != chamber_edit_it->end() && max_it != chamber_edit_it->end() && min_it->is_number() && max_it->is_number()) {
            device_config["support_chamber_temp_edit"]       = true;
            device_config["support_chamber_temp_edit_range"] = {*min_it, *max_it};
        }
    }
 
    json fan_config;
    copy_bool(fan_config, "support_aux_fan");
    copy_bool(fan_config, "support_chamber_fan");
 
    m_config->ParseConfig(device_config);
    m_fan->ParseV2_0(fan_config);
}

References is_support_1080dpi, is_support_agora, is_support_ams_humidity, is_support_auto_recovery_step_loss, is_support_bed_leveling, is_support_build_plate_marker_detect, is_support_cloud_print_only, is_support_command_ams_switch, is_support_filament_backup, is_support_filament_tangle_detect, is_support_flow_calibration, is_support_motor_noise_cali, is_support_mqtt_alive, is_support_nozzle_blob_detection, is_support_prompt_sound, is_support_refresh_nozzle, is_support_send_to_sdcard, is_support_timelapse, is_support_tunnel_mqtt, is_support_update_remain, is_support_user_preset, m_config, m_fan, and m_manager.

Referenced by parse_json().

Here is the caller graph for this function:

parse_state_changed_event()

void Slic3r::MachineObject::parse_state_changed_event

(

)

{
    // parse calibration done
    if (last_mc_print_stage != mc_print_stage) {
        if (mc_print_stage == 1 && boost::contains(m_gcode_file, "auto_cali_for_user")) {
            calibration_done = true;
        } else {
            calibration_done = false;
        }
    }
    last_mc_print_stage = mc_print_stage;
}

References calibration_done, last_mc_print_stage, m_gcode_file, and mc_print_stage.

Referenced by parse_json().

Here is the caller graph for this function:

parse_version()

std::string Slic3r::MachineObject::parse_version

(

)

{
    auto ota_version = module_vers.find("ota");
    if (ota_version != module_vers.end()) return ota_version->second.sw_ver;
    auto series = get_printer_series();
    if (series == PrinterSeries::SERIES_X1) {
        auto rv1126_version = module_vers.find("rv1126");
        if (rv1126_version != module_vers.end()) return rv1126_version->second.sw_ver;
    } else if (series == PrinterSeries::SERIES_P1P) {
        auto esp32_version = module_vers.find("esp32");
        if (esp32_version != module_vers.end()) return esp32_version->second.sw_ver;
    }
    return "";
}

References get_printer_series(), module_vers, SERIES_P1P, and SERIES_X1.

Referenced by parse_json().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_version_func()

void Slic3r::MachineObject::parse_version_func

(

)

{
}

Referenced by parse_json().

Here is the caller graph for this function:

parse_vt_tray()

DevAmsTray Slic3r::MachineObject::parse_vt_tray

(

nlohmann::json

vtray

)

{
    auto vt_tray = DevAmsTray(std::to_string(VIRTUAL_TRAY_MAIN_ID));
 
    if (vtray.contains("id"))
        vt_tray.id = vtray["id"].get<std::string>();
    auto curr_time = std::chrono::system_clock::now();
    auto diff = std::chrono::duration_cast<std::chrono::milliseconds>(curr_time - extrusion_cali_set_hold_start);
    if (diff.count() > HOLD_TIMEOUT || diff.count() < 0
        || extrusion_cali_set_tray_id != VIRTUAL_TRAY_MAIN_ID) {
        if (vtray.contains("k"))
            vt_tray.k = vtray["k"].get<float>();
        if (vtray.contains("n"))
            vt_tray.n = vtray["n"].get<float>();
    }
    ams_support_virtual_tray = true;
 
    if (vt_tray.hold_count > 0) {
        vt_tray.hold_count--;
    }
    else {
        if (vtray.contains("tag_uid"))
            vt_tray.tag_uid = vtray["tag_uid"].get<std::string>();
        else
            vt_tray.tag_uid = "0";
        if (vtray.contains("tray_info_idx") && vtray.contains("tray_type")) {
            vt_tray.setting_id = vtray["tray_info_idx"].get<std::string>();
            //std::string type = vtray["tray_type"].get<std::string>();
            std::string type = setting_id_to_type(vt_tray.setting_id, vtray["tray_type"].get<std::string>());
            // vt_tray.setting_id is our OF id (translated on the way in); the two support ids below are the printer's own.
            auto* agent = GUI::wxGetApp().getAgent();
            const std::string printer_filament_id = agent ? agent->from_orca_filament_id(vt_tray.setting_id) : vt_tray.setting_id;
            if (printer_filament_id == "GFS00") {
                vt_tray.m_fila_type = "PLA-S";
            }
            else if (printer_filament_id == "GFS01") {
                vt_tray.m_fila_type = "PA-S";
            }
            else {
                vt_tray.m_fila_type = type;
            }
        }
        else {
            vt_tray.setting_id = "";
            vt_tray.m_fila_type = "";
        }
        if (vtray.contains("tray_sub_brands"))
            vt_tray.sub_brands = vtray["tray_sub_brands"].get<std::string>();
        else
            vt_tray.sub_brands = "";
        if (vtray.contains("tray_weight"))
            vt_tray.weight = vtray["tray_weight"].get<std::string>();
        else
            vt_tray.weight = "";
        if (vtray.contains("tray_diameter"))
            vt_tray.diameter = vtray["tray_diameter"].get<std::string>();
        else
            vt_tray.diameter = "";
        if (vtray.contains("tray_temp"))
            vt_tray.temp = vtray["tray_temp"].get<std::string>();
        else
            vt_tray.temp = "";
        if (vtray.contains("tray_time"))
            vt_tray.time = vtray["tray_time"].get<std::string>();
        else
            vt_tray.time = "";
        if (vtray.contains("bed_temp_type"))
            vt_tray.bed_temp_type = vtray["bed_temp_type"].get<std::string>();
        else
            vt_tray.bed_temp_type = "";
        if (vtray.contains("bed_temp"))
            vt_tray.bed_temp = vtray["bed_temp"].get<std::string>();
        else
            vt_tray.bed_temp = "";
        if (vtray.contains("tray_color")) {
            auto color = vtray["tray_color"].get<std::string>();
            vt_tray.UpdateColorFromStr(color);
        }
        else {
            vt_tray.color = "";
        }
        if (vtray.contains("ctype")) {
            vt_tray.ctype = vtray["ctype"].get<int>();
        }
        else {
            vt_tray.ctype = 1;
        }
        if (vtray.contains("nozzle_temp_max"))
            vt_tray.nozzle_temp_max = vtray["nozzle_temp_max"].get<std::string>();
        else
            vt_tray.nozzle_temp_max = "";
        if (vtray.contains("nozzle_temp_min"))
            vt_tray.nozzle_temp_min = vtray["nozzle_temp_min"].get<std::string>();
        else
            vt_tray.nozzle_temp_min = "";
        if (vtray.contains("xcam_info"))
            vt_tray.xcam_info = vtray["xcam_info"].get<std::string>();
        else
            vt_tray.xcam_info = "";
        if (vtray.contains("tray_uuid"))
            vt_tray.uuid = vtray["tray_uuid"].get<std::string>();
        else
            vt_tray.uuid = "0";
 
        if (vtray.contains("cali_idx"))
            vt_tray.cali_idx = vtray["cali_idx"].get<int>();
        else
            vt_tray.cali_idx = -1;
        vt_tray.cols.clear();
        if (vtray.contains("cols")) {
            if (vtray["cols"].is_array()) {
                for (auto it = vtray["cols"].begin(); it != vtray["cols"].end(); it++) {
                    vt_tray.cols.push_back(it.value().get<std::string>());
                }
            }
        } else {
            vt_tray.cols.push_back(vt_tray.color);
        }
 
        if (vtray.contains("remain")) {
            vt_tray.remain = vtray["remain"].get<int>();
        }
        else {
            vt_tray.remain = -1;
        }
    }
 
    return vt_tray;
}

References ams_support_virtual_tray, Slic3r::diff(), extrusion_cali_set_hold_start, extrusion_cali_set_tray_id, HOLD_TIMEOUT, setting_id_to_type(), and VIRTUAL_TRAY_MAIN_ID.

Referenced by parse_json().

Here is the call graph for this function:

Here is the caller graph for this function:

publish_gcode()

int Slic3r::MachineObject::publish_gcode

(

std::string

gcode_str

)

{
    json j;
    j["print"]["command"] = "gcode_line";
    j["print"]["param"] = gcode_str;
    j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
 
    return publish_json(j);
}

References m_sequence_id, and publish_json().

Here is the call graph for this function:

publish_json() [1/2]

int Slic3r::MachineObject::publish_json	(	const nlohmann::json &	json_item,
		int	qos = 0,
		int	flag = 0 )

{
    int rtn = 0;
    if (is_lan_mode_printer()) {
        rtn = local_publish_json(json_item.dump(), qos, flag);
    } else {
        rtn = cloud_publish_json(json_item.dump(), qos, flag);
    }
 
    if (rtn == 0) {
        BOOST_LOG_TRIVIAL(info) << "publish_json: " << json_item.dump() << " code: " << rtn;
    } else {
        BOOST_LOG_TRIVIAL(error) << "publish_json: " << json_item.dump() << " code: " << rtn;
    }
 
    // why: the agent is the only thing that knows what it can translate, so it reports
    // not-supported in its return value and this - the single funnel every command_* builder
    // passes through - is the one place that turns it into something the user sees. No list of
    // unsupported commands is needed anywhere: an agent that has no case for a command says so.
    if (rtn == ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED || rtn == ORCA_NETWORK_ERR_CAP_NOT_AVAILABLE) {
        show_unsupported_dlg(rtn);
    }
 
    return rtn;
}

References cloud_publish_json(), is_lan_mode_printer(), local_publish_json(), ORCA_NETWORK_ERR_CAP_NOT_AVAILABLE, ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED, and show_unsupported_dlg().

Referenced by command_ack_proceed(), command_ams_air_print_detect(), command_ams_change_filament(), command_ams_control(), command_ams_drying_stop(), command_ams_filament_settings(), command_ams_switch_filament(), command_ams_user_settings(), command_clean_print_error(), command_clean_print_error_uiop(), command_consistency_upgrade_confirm(), command_delete_pa_calibration(), command_dont_remind_next_time(), command_extruder_control(), command_extrusion_cali_set(), command_get_access_code(), command_get_flow_ratio_calibration_result(), command_get_pa_calibration_result(), command_get_pa_calibration_tab(), command_get_version(), command_hms_idle_ignore(), command_hms_ignore(), command_hms_resume(), command_hms_stop(), command_ipcam_check_timelapse_storage(), command_ipcam_delete_oldest_timelapse(), command_ipcam_record(), command_ipcam_resolution_set(), command_ipcam_timelapse(), command_nozzle_blob_detect(), command_purification_disable(), command_pushing(), command_refresh_nozzle(), command_request_push_all(), command_set_chamber(), command_set_door_open_check(), Slic3r::DevPrintOptions::command_set_filament_tangle_detect(), command_set_filament_tangle_detect(), command_set_nozzle_new(), command_set_pa_calibration(), Slic3r::DevPrintOptions::command_set_printing_option(), command_set_printing_option(), command_set_printing_speed(), Slic3r::DevPrintOptions::command_set_prompt_sound(), command_set_prompt_sound(), Slic3r::DevPrintOptions::command_set_purify_air_at_print_end(), command_set_save_remote_print_file_to_storage(), Slic3r::DevPrintOptions::command_set_snapshot_control(), command_start_calibration(), command_start_extrusion_cali(), command_start_flow_ratio_calibration(), command_start_pa_calibration(), command_stop_buzzer(), command_task_abort(), command_task_cancel(), command_task_partskip(), command_task_pause(), command_task_resume(), command_upgrade_confirm(), command_upgrade_firmware(), command_upgrade_module(), Slic3r::DevPrintOptions::command_xcam_control(), command_xcam_control(), commnad_select_pa_calibration(), Slic3r::DevAmsSystemFirmwareSwitch::CrtlSwitchFirmware(), and publish_gcode().

Here is the call graph for this function:

publish_json() [2/2]

int Slic3r::MachineObject::publish_json ( const std::string & json_str, int qos = 0, int flag = 0 )

delete

reload_printer_settings()

void Slic3r::MachineObject::reload_printer_settings

(

)

{
    print_json.load_compatible_settings("", "");
    parse_json("cloud", "{}");
}

References parse_json(), and print_json.

Here is the call graph for this function:

reset()

void Slic3r::MachineObject::reset

(

)

{
    BOOST_LOG_TRIVIAL(trace) << "reset dev_id=" << dev_id;
    last_update_time = std::chrono::system_clock::now();
    subscribe_counter = SUBSCRIBE_RETRY_COUNT;
    m_push_count = 0;
    m_full_msg_count = 0;
    is_220V_voltage = false;
    get_version_retry = 0;
    camera_recording = false;
    camera_recording_when_printing = false;
    camera_timelapse = false;
    //camera_resolution = "";
    printing_speed_mag = 100;
    gcode_file_prepare_percent = 0;
    iot_print_status = "";
    print_status = "";
    last_mc_print_stage = -1;
    m_new_ver_list_exist = false;
    network_wired = false;
    dev_connection_name = "";
    job_id_ = "";
    jobState_ = 0;
    m_plate_index = -1;
    device_cert_installed = false;
    clear_auto_nozzle_mapping();// reset nozzle mapping
 
    // reset print_json
    json empty_j;
    print_json.diff2all_base_reset(empty_j);
 
    for (auto i = 0; i < vt_slot.size(); i++) {
        vt_slot[i].reset();
 
        if (i == 1) {
            vt_slot.erase(vt_slot.begin() + 1);
        }
    }
    // why: reset reuses MachineObject, so release its lazy subtask
    // before dropping the pointer to prevent reconnect leaks.
    if (subtask_) {
        delete subtask_;
        subtask_ = nullptr;
    }
    has_extra_flow_type = false;
    m_partskip_ids.clear();
}

References camera_recording, camera_recording_when_printing, camera_timelapse, clear_auto_nozzle_mapping(), dev_connection_name, dev_id, device_cert_installed, gcode_file_prepare_percent, get_version_retry, has_extra_flow_type, iot_print_status, is_220V_voltage, job_id_, jobState_, last_mc_print_stage, last_update_time, m_full_msg_count, m_new_ver_list_exist, m_partskip_ids, m_plate_index, m_push_count, network_wired, print_json, print_status, printing_speed_mag, subscribe_counter, SUBSCRIBE_RETRY_COUNT, subtask_, Slic3r::trace(), and vt_slot.

Referenced by MachineObject().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_flow_rate_cali_result()

void Slic3r::MachineObject::reset_flow_rate_cali_result ( )

inline

                                       {
        get_flow_calib_result = false;
        flow_ratio_results.clear();
    }

References flow_ratio_results, and get_flow_calib_result.

Referenced by parse_json().

Here is the caller graph for this function:

reset_pa_cali_history_result()

void Slic3r::MachineObject::reset_pa_cali_history_result ( )

inline

    {
        has_get_pa_calib_tab = false;
        pa_calib_tab.clear();
    }

References has_get_pa_calib_tab, and pa_calib_tab.

Referenced by command_get_pa_calibration_tab(), and parse_json().

Here is the caller graph for this function:

reset_pa_cali_result()

void Slic3r::MachineObject::reset_pa_cali_result ( )

inline

                                {
        get_pa_calib_result = false;
        pa_calib_results.clear();
    }

References get_pa_calib_result, and pa_calib_results.

Referenced by parse_json().

Here is the caller graph for this function:

reset_update_time()

void Slic3r::MachineObject::reset_update_time

(

)

{
    BOOST_LOG_TRIVIAL(trace) << "reset reset_update_time, dev_id =" << dev_id;
    last_update_time = std::chrono::system_clock::now();
    subscribe_counter = SUBSCRIBE_RETRY_COUNT;
}

References dev_id, last_update_time, subscribe_counter, SUBSCRIBE_RETRY_COUNT, and Slic3r::trace().

Here is the call graph for this function:

revoke_access()

void Slic3r::MachineObject::revoke_access

(

)

{
    // UI panels retain this object; revoke its binding without invalidating their pointers.
    access_code.clear();
    m_access_revoked = true;
}

References access_code, and m_access_revoked.

set_access_code()

void Slic3r::MachineObject::set_access_code	(	std::string	code,
		bool	only_refresh = true )

{
    this->access_code = code;
    m_access_revoked = false;
    if (only_refresh) {
        AppConfig* config = m_manager ? m_manager->get_app_config() : GUI::wxGetApp().app_config;
        if (config) {
            if (is_lan_mode_printer()) {
                // why: LAN codes are scoped via BBLocalMachine::access_code, keyed by dev_id and
                // scoped by that record's own printer_agent_id field - see the matching comment
                // on get_access_code_with_legacy_fallback() in DevManager.cpp - so binding this
                // device under one printer agent doesn't silently read as already-bound under a
                // different, independent one. Cloud devices (the else branch below) aren't
                // scoped this way: they're never recalled from a stale local cache across a
                // session boundary, since parse_user_print_info() always overwrites their code
                // fresh from the cloud API's current response, so there's no cross-agent leakage
                // risk to guard against there.
                if (has_access_right()) {
                    DeviceManager::update_local_machine(*this, config);
                } else {
                    config->clear_local_machine_access_code(get_dev_id(), printer_agent_id);
                }
            } else {
                if (!code.empty())
                    config->set_str("access_code", get_dev_id(), code);
                else
                    config->erase("access_code", get_dev_id());
            }
        }
    }
}

References access_code, Slic3r::AppConfig::clear_local_machine_access_code(), Slic3r::AppConfig::erase(), get_dev_id(), has_access_right(), is_lan_mode_printer(), m_access_revoked, m_manager, printer_agent_id, Slic3r::AppConfig::set_str(), and Slic3r::DeviceManager::update_local_machine().

Referenced by connect(), Slic3r::DeviceManager::insert_local_device(), Slic3r::DeviceManager::load_local_machines_from_config(), Slic3r::DeviceManager::on_machine_alive(), Slic3r::GUI::UnBindMachineDialog::on_unbind_printer(), parse_json(), Slic3r::DeviceManager::parse_user_print_info(), and Slic3r::GUI::GUI_App::select_machine().

Here is the call graph for this function:

Here is the caller graph for this function:

set_agent()

void Slic3r::MachineObject::set_agent ( NetworkAgent * agent )

inline

{ m_agent = agent; }

References m_agent.

set_bind_status()

void Slic3r::MachineObject::set_bind_status

(

std::string

status

)

{
    bind_user_name = status;
}

References bind_user_name.

Referenced by Slic3r::DeviceManager::parse_user_print_info().

Here is the caller graph for this function:

set_ctt_dlg()

void Slic3r::MachineObject::set_ctt_dlg

(

wxString

text

)

                                             {
    if (!m_set_ctt_dlg) {
        m_set_ctt_dlg = true;
        // Parented so it is destroyed with the main frame: a parentless top-level window,
        // even hidden, keeps wx from leaving the event loop on exit.
        auto print_error_dlg = new GUI::SecondaryCheckDialog(GUI::wxGetApp().mainframe, wxID_ANY, _L("Warning"), GUI::SecondaryCheckDialog::VisibleButtons::ONLY_CONFIRM); // ORCA VisibleButtons instead ButtonStyle
        print_error_dlg->update_text(text);
        print_error_dlg->Bind(wxEVT_SHOW, [this](auto& e) {
            if (!e.IsShown()) {
                m_set_ctt_dlg = false;
            }
            });
        print_error_dlg->Bind(wxEVT_CLOSE_WINDOW, [this](auto& e) {
            e.Skip();
            m_set_ctt_dlg = false;
            });
        print_error_dlg->on_show();
 
    }
}

References _L, m_set_ctt_dlg, and Slic3r::GUI::SecondaryCheckDialog::ONLY_CONFIRM.

Referenced by parse_json().

Here is the caller graph for this function:

set_dev_id()

void Slic3r::MachineObject::set_dev_id ( std::string val )

inline

{ dev_id = val; }

References dev_id.

Referenced by Slic3r::DeviceManager::parse_user_print_info(), and Slic3r::GUI::CalibrationWizard::recover_preset_info().

Here is the caller graph for this function:

set_dev_ip()

void Slic3r::MachineObject::set_dev_ip ( std::string ip )

inline

{ dev_ip = ip;  }

References dev_ip.

Referenced by Slic3r::DeviceManager::on_machine_alive(), and parse_json().

Here is the caller graph for this function:

set_dev_name()

void Slic3r::MachineObject::set_dev_name ( std::string val )

inline

{ dev_name = val; }

References dev_name.

Referenced by Slic3r::DeviceManager::on_machine_alive(), and Slic3r::DeviceManager::parse_user_print_info().

Here is the caller graph for this function:

set_lan_mode_connection_state()

void Slic3r::MachineObject::set_lan_mode_connection_state ( bool state )

inline

{m_lan_mode_connection_state = state;};

References m_lan_mode_connection_state.

set_modeltask()

void Slic3r::MachineObject::set_modeltask

(

BBLModelTask *

task

)

{
    model_task = task;
}

References model_task.

set_online_state()

void Slic3r::MachineObject::set_online_state

(

bool

on_off

)

{
    const bool changed = (m_is_online != on_off);
    m_is_online = on_off;
    if (!on_off) m_active_state = NotActive;
    if (changed) {
        LifecycleEventContext ctx;
        ctx.name  = dev_id;
        ctx.code  = LifecycleEvtCode::Ok;
        ctx.msg   = on_off ? "online" : "offline";
        fire_lifecycle_event(on_off ? LifecycleEvent::DeviceOnline : LifecycleEvent::DeviceOffline, ctx);
    }
}

References Slic3r::LifecycleEventContext::code, dev_id, Slic3r::DeviceOffline, Slic3r::DeviceOnline, Slic3r::fire_lifecycle_event(), m_active_state, m_is_online, Slic3r::LifecycleEventContext::msg, Slic3r::LifecycleEventContext::name, NotActive, and Slic3r::Ok.

Referenced by disconnect(), Slic3r::DeviceManager::on_machine_alive(), and parse_json().

Here is the call graph for this function:

Here is the caller graph for this function:

set_print_state()

void Slic3r::MachineObject::set_print_state

(

std::string

status

)

{
    const bool changed = (print_status != status);
    print_status = status;
    if (changed) {
        LifecycleEventContext ctx;
        ctx.name  = dev_id;
        ctx.code  = LifecycleEvtCode::Ok;
        ctx.msg   = print_status;
        fire_lifecycle_event(LifecycleEvent::PrintStateChanged, ctx);
    }
}

References Slic3r::LifecycleEventContext::code, dev_id, Slic3r::fire_lifecycle_event(), Slic3r::LifecycleEventContext::msg, Slic3r::LifecycleEventContext::name, Slic3r::Ok, print_status, and Slic3r::PrintStateChanged.

Referenced by parse_json().

Here is the call graph for this function:

Here is the caller graph for this function:

setting_id_to_type()

std::string Slic3r::MachineObject::setting_id_to_type ( std::string setting_id, std::string tray_type )

static

{
    std::string type;
    PresetBundle* preset_bundle = GUI::wxGetApp().preset_bundle;
    if (preset_bundle) {
        for (auto it = preset_bundle->filaments.begin(); it != preset_bundle->filaments.end(); it++) {
 
            if (it->filament_id.compare(setting_id) == 0 && it->is_system) {
                std::string display_filament_type;
                it->config.get_filament_type(display_filament_type);
                type = display_filament_type;
                break;
            }
        }
    }
 
    if (tray_type != type || type.empty()) {
        if (type.empty()) { type = tray_type; }
        BOOST_LOG_TRIVIAL(info) << "The values of tray_info_idx and tray_type do not match tray_info_idx " << setting_id << " tray_type " << tray_type << " system_type" << type;
    }
    return type;
}

References Slic3r::PresetCollection::begin(), Slic3r::PresetCollection::end(), and Slic3r::PresetBundle::filaments.

Referenced by parse_json(), parse_vt_tray(), and Slic3r::DevFilaSystemParser::ParseV1_0().

Here is the call graph for this function:

Here is the caller graph for this function:

show_unsupported_dlg()

void Slic3r::MachineObject::show_unsupported_dlg

(

int

code

)

{
    // why: a dead control invites repeat clicks, and the frame is modeless - without the guard
    // every click stacks another one. Same shape as set_ctt_dlg above, including the reset on
    // both hide and close so a dismissed dialog can reappear on the next attempt.
    if (m_unsupported_dlg_shown) {
        return;
    }
    m_unsupported_dlg_shown = true;
 
    // why: two codes so the user learns which kind of dead end this is - the slicer having no
    // translation for the command, or the printer's own config lacking the hardware to run it.
    const wxString text = (code == ORCA_NETWORK_ERR_CAP_NOT_AVAILABLE) ?
                              _L("This printer is not configured with the hardware this control needs.") :
                              _L("This control is not supported on this printer.");
 
    // note: constructed directly rather than through CallAfter because every publish_json caller
    // is on the UI thread - clicks come from wx handlers, and the agent marshals its own push
    // callbacks back to main before parse_json runs. set_ctt_dlg relies on the same property.
    // Parented for the same reason as in set_ctt_dlg.
    auto unsupported_dlg = new GUI::SecondaryCheckDialog(GUI::wxGetApp().mainframe, wxID_ANY, _L("Warning"),
                                                         GUI::SecondaryCheckDialog::VisibleButtons::ONLY_CONFIRM);
    unsupported_dlg->update_text(text);
    unsupported_dlg->Bind(wxEVT_SHOW, [this](auto& e) {
        if (!e.IsShown()) {
            m_unsupported_dlg_shown = false;
        }
        });
    unsupported_dlg->Bind(wxEVT_CLOSE_WINDOW, [this](auto& e) {
        e.Skip();
        m_unsupported_dlg_shown = false;
        });
    unsupported_dlg->on_show();
}

References _L, m_unsupported_dlg_shown, Slic3r::GUI::SecondaryCheckDialog::ONLY_CONFIRM, and ORCA_NETWORK_ERR_CAP_NOT_AVAILABLE.

Referenced by command_with_dialog(), and publish_json().

Here is the caller graph for this function:

store_version_info()

void Slic3r::MachineObject::store_version_info

(

const DevFirmwareVersionInfo &

info

)

{
    if (info.isAirPump()) {
        air_pump_version_info = info;
    } else if (info.isLaszer()) {
        laser_version_info = info;
    } else if (info.isCuttingModule()) {
        cutting_module_version_info = info;
    } else if (info.isExtinguishSystem()) {
        extinguish_version_info = info;
    } else if (info.isRotary()) {
        rotary_version_info = info;
    } else if (info.isWTM()) {
        // Route rack-hotend / extruder-nozzle firmware into the nozzle system so
        // the rack upgrade UI can read per-nozzle versions. isWTM() is false for every non-rack
        // printer's modules, so this branch never fires outside H2C.
        m_nozzle_system->AddFirmwareInfoWTM(info);
    } else if (info.isExhaustFan()) {
        exhaustfan_version_info = info;
    } else if (info.isHmshub()) {
        amshub_version_info = info;
    } else if (info.isFilaTrackSwitch()) {
        filatrack_version_info = info;
    }
 
    module_vers.emplace(info.name, info);
}

References air_pump_version_info, amshub_version_info, cutting_module_version_info, exhaustfan_version_info, extinguish_version_info, filatrack_version_info, Slic3r::DevFirmwareVersionInfo::isAirPump(), Slic3r::DevFirmwareVersionInfo::isCuttingModule(), Slic3r::DevFirmwareVersionInfo::isExhaustFan(), Slic3r::DevFirmwareVersionInfo::isExtinguishSystem(), Slic3r::DevFirmwareVersionInfo::isFilaTrackSwitch(), Slic3r::DevFirmwareVersionInfo::isHmshub(), Slic3r::DevFirmwareVersionInfo::isLaszer(), Slic3r::DevFirmwareVersionInfo::isRotary(), Slic3r::DevFirmwareVersionInfo::isWTM(), laser_version_info, m_nozzle_system, module_vers, Slic3r::DevFirmwareVersionInfo::name, and rotary_version_info.

Referenced by parse_json().

Here is the call graph for this function:

Here is the caller graph for this function:

support_door_open_check()

bool Slic3r::MachineObject::support_door_open_check ( ) const

inline

{ return is_support_door_open_check;};

References is_support_door_open_check.

update_device_cert_state()

void Slic3r::MachineObject::update_device_cert_state

(

bool

ready

)

{
    device_cert_installed = ready;
}

References device_cert_installed.

update_filament_list()

void Slic3r::MachineObject::update_filament_list

(

)

{
    PresetBundle *preset_bundle = Slic3r::GUI::wxGetApp().preset_bundle;
 
    // custom filament
    typedef std::map<std::string, std::pair<std::vector<int>, std::vector<int>>> map_pair;
    std::map<std::string, map_pair>                    map_list;
    for (auto &pair : m_nozzle_filament_data) {
        map_list[pair.second.printer_preset_name] = map_pair{};
    }
    for (auto &preset : preset_bundle->filaments()) {
        if (preset.is_user() && preset.inherits() == "") {
            ConfigOption *       printer_opt  = const_cast<Preset &>(preset).config.option("compatible_printers");
            ConfigOptionStrings *printer_strs = dynamic_cast<ConfigOptionStrings *>(printer_opt);
            for (const std::string &printer_str : printer_strs->values) {
                if (map_list.find(printer_str) != map_list.end()) {
                    auto &        filament_list = map_list[printer_str];
                    // Every variant's range, so a change to any of them rechecks the trays
                    std::vector<int> min_temps{-1}, max_temps{-1};
                    if (auto *opt_min = preset.config.option<ConfigOptionInts>("nozzle_temperature_range_low"))
                        min_temps = opt_min->values;
                    if (auto *opt_max = preset.config.option<ConfigOptionInts>("nozzle_temperature_range_high"))
                        max_temps = opt_max->values;
                    filament_list[preset.filament_id] = std::make_pair(min_temps, max_temps);
                    break;
                }
            }
        }
    }
 
    for (auto& pair : m_nozzle_filament_data) {
        auto & m_printer_preset_name = pair.second.printer_preset_name;
        auto & m_filament_list       = pair.second.filament_list;
        auto & m_checked_filament    = pair.second.checked_filament;
        auto & filament_list         = map_list[m_printer_preset_name];
 
        for (auto it = filament_list.begin(); it != filament_list.end(); it++) {
            if (m_filament_list.find(it->first) != m_filament_list.end()) {
                // User roots may legitimately carry adopted system-shaped ids (GF*/OF*/P-hex
                // system), so a non-'P' id here is expected, not an invariant violation.
                if (it->first.size() != 8 || it->first[0] != 'P')
                    BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << ": user-root filament_id is not user-shaped: " << it->first;
 
                if (it->second.first != m_filament_list[it->first].first) {
                    BOOST_LOG_TRIVIAL(info) << "old min temp is not equal to new min temp and filament id: " << it->first;
                    continue;
                }
 
                if (it->second.second != m_filament_list[it->first].second) {
                    BOOST_LOG_TRIVIAL(info) << "old max temp is not equal to new max temp and filament id: " << it->first;
                    continue;
                }
 
                m_filament_list.erase(it->first);
            }
        }
 
        for (auto it = m_filament_list.begin(); it != m_filament_list.end(); it++) { m_checked_filament.insert(it->first); }
 
        m_filament_list = filament_list;
    }
}

References Slic3r::PresetBundle::filaments, m_nozzle_filament_data, and Slic3r::ConfigOptionVector< T >::values.

Referenced by parse_json().

Here is the caller graph for this function:

update_model_task()

void Slic3r::MachineObject::update_model_task

(

)

{
    if (request_model_result > 10) return;
    if (!m_agent) return;
    if (!model_task) return;
    if (!subtask_) return;
    if (model_task->task_id != subtask_->task_id) {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " times: " << request_model_result << " model_task_id !=subtask_id";
        return;
    }
    if (model_task->instance_id <= 0) {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " times: " << request_model_result << " instance_id <= 0";
        return;
    }
 
    if ((!subtask_id_.empty() && last_subtask_id_ != subtask_id_) || get_model_mall_result_need_retry) {
        if (!subtask_id_.empty() && last_subtask_id_ != subtask_id_) {
            BOOST_LOG_TRIVIAL(info) << "update_model_task: last=" << last_subtask_id_ << ", curr=" << subtask_id_;
            last_subtask_id_     = subtask_id_;
            request_model_result = 0;
        }
        if (get_model_mall_result_need_retry) {
            BOOST_LOG_TRIVIAL(info) << "need retry";
            get_model_mall_result_need_retry = false;
        }
    } else {
        BOOST_LOG_TRIVIAL(info) << "subtask_id_ no change and do not need retry";
        return;
    }
 
    int curr_instance_id = model_task->instance_id;
    if (rating_info) {
        delete rating_info;
        rating_info = nullptr;
    }
    get_model_task_thread = new boost::thread([this, curr_instance_id, token = std::weak_ptr<int>(m_token)]{
        if (token.expired()) { return; }
        try {
            std::string  rating_result;
            unsigned int http_code = 404;
            std::string  http_error;
            int          res = -1;
            res = m_agent->get_model_mall_rating_result(curr_instance_id, rating_result, http_code, http_error, Slic3r::GUI::wxGetApp().get_printer_cloud_provider());
            request_model_result++;
            BOOST_LOG_TRIVIAL(info) << "request times: " << request_model_result << " http code: " << http_code;
            auto rating_info = new DevPrintTaskRatingInfo();
            rating_info->http_code = http_code;
            if (0 == res && 200 == http_code) {
                try {
                    json rating_json = json::parse(rating_result);
                    if (rating_json.contains("id")) {
                        rating_info->rating_id = rating_json["id"].get<unsigned int>();
                        //rating id is necessary info, so rating id must have
                        request_model_result            = 0;
                        rating_info->request_successful = true;
                        BOOST_LOG_TRIVIAL(info) << "get rating id";
                    } else {
                        rating_info->request_successful = false;
                        BOOST_LOG_TRIVIAL(info) << "can not get rating id";
                        Slic3r::GUI::wxGetApp().CallAfter([this, token, rating_info]() {
                            if (!token.expired()) this->rating_info = rating_info;
                        });
                        return;
                    }
                    if (rating_json.contains("score")) {
                            rating_info->start_count = rating_json["score"].get<int>();
                        }
                    if (rating_json.contains("content"))
                        rating_info->content = rating_json["content"].get<std::string>();
                    if (rating_json.contains("successPrinted"))
                        rating_info->success_printed = rating_json["successPrinted"].get<bool>();
                    if (rating_json.contains("images")) {
                        rating_info->image_url_paths = rating_json["images"].get<std::vector<std::string>>();
                    }
                    Slic3r::GUI::wxGetApp().CallAfter([this, token, rating_info]() {
                        if (!token.expired()) this->rating_info = rating_info;
                    });
                } catch (...) {
                    BOOST_LOG_TRIVIAL(info) << "parse model mall result json failed";
                }
            }
            else {
                rating_info->request_successful = false;
                Slic3r::GUI::wxGetApp().CallAfter([this, token, rating_info]() {
                    if (!token.expired()) this->rating_info = rating_info;
                });
                BOOST_LOG_TRIVIAL(info) << "model mall result request failed, request time: " << request_model_result << " http_code: " << http_code
                                        << " error msg: " << http_error;
                return;
            }
        }
        catch (...) {
            BOOST_LOG_TRIVIAL(info) << "get mall model rating id failed and hide scoring page";
        }
    });
}

References get_model_mall_result_need_retry, get_model_task_thread, last_subtask_id_, m_agent, m_token, model_task, rating_info, request_model_result, subtask_, and subtask_id_.

update_print_progress()

void Slic3r::MachineObject::update_print_progress

(

const nlohmann::json &

value

)

{
    if (value.is_string()) {
        const std::string progress = value.get<std::string>();
        int              parsed_progress;
        const auto       result = std::from_chars(progress.data(), progress.data() + progress.size(), parsed_progress);
        if (result.ec != std::errc{} || result.ptr != progress.data() + progress.size())
            return;
        mc_print_percent = parsed_progress;
    } else if (value.is_number_integer())
        mc_print_percent = value.get<int>();
    else
        return;
 
    if (BBLSubTask* curr_task = get_subtask())
        curr_task->task_progress = mc_print_percent;
}

References get_subtask(), and mc_print_percent.

Referenced by parse_json().

Here is the call graph for this function:

Here is the caller graph for this function:

update_printer_preset_name()

void Slic3r::MachineObject::update_printer_preset_name

(

)

{
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " " << __LINE__ << "start update preset_name";
    PresetBundle *     preset_bundle = Slic3r::GUI::wxGetApp().preset_bundle;
    if (!preset_bundle) return;
    auto               printer_model = DevPrinterConfigUtil::get_printer_display_name(this->printer_type);
    std::set<std::string> diameter_set;
    for (auto &nozzle : m_extder_system->m_extders) {
        float diameter = nozzle.GetNozzleDiameter();
        std::ostringstream stream;
        stream << std::fixed << std::setprecision(1) << diameter;
        std::string nozzle_diameter_str = stream.str();
        diameter_set.insert(nozzle_diameter_str);
        if (m_nozzle_filament_data.find(nozzle_diameter_str) != m_nozzle_filament_data.end()) continue;
        auto data = FilamentData();
        auto printer_set = preset_bundle->get_printer_names_by_printer_type_and_nozzle(printer_model, nozzle_diameter_str);
        if (printer_set.size() > 0) {
            data.printer_preset_name = *printer_set.begin();
            m_nozzle_filament_data[nozzle_diameter_str] = data;
        }
        else
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " " << __LINE__ << " update printer preset name failed: "<< "printer_type: " << printer_type << "nozzle_diameter_str" << nozzle_diameter_str;
    }
 
    for (auto iter = m_nozzle_filament_data.begin(); iter != m_nozzle_filament_data.end();)
    {
        if (diameter_set.find(iter->first) == diameter_set.end())
        {
            iter = m_nozzle_filament_data.erase(iter);
        }
        else
        {
            ++iter;
        }
    }
}

References Slic3r::DevPrinterConfigUtil::get_printer_display_name(), Slic3r::PresetBundle::get_printer_names_by_printer_type_and_nozzle(), m_extder_system, m_nozzle_filament_data, and printer_type.

Referenced by parse_json().

Here is the call graph for this function:

Here is the caller graph for this function:

update_slice_info()

void Slic3r::MachineObject::update_slice_info	(	std::string	project_id,
		std::string	profile_id,
		std::string	subtask_id,
		int	plate_idx )

{
    if (!m_agent) return;
 
    if (project_id_ != project_id || profile_id_ != profile_id || slice_info == nullptr || subtask_id_ != subtask_id) {
        project_id_ = project_id;
        profile_id_ = profile_id;
        subtask_id_ = subtask_id;
 
        if (project_id.empty()
            || profile_id.empty()
            || subtask_id.empty()) {
            return;
        }
 
        if (project_id.compare("0") == 0
            || profile_id.compare("0") == 0
            || subtask_id.compare("0") == 0) return;
 
        BOOST_LOG_TRIVIAL(trace) << "slice_info: start";
        slice_info = new BBLSliceInfo();
        get_slice_info_thread = new boost::thread([this, project_id, profile_id, subtask_id, plate_idx] {
            int plate_index = -1;
 
            if (!m_agent) return;
            if (!slice_info) return;
            if (!get_slice_info_thread) return;/*STUDIO-12264*/
            if (get_slice_info_thread->interruption_requested()) { return;}
 
            if (plate_idx >= 0) {
                plate_index = plate_idx;
                this->m_plate_index = plate_idx;
            }
            else {
                std::string subtask_json;
                unsigned http_code = 0;
                std::string http_body;
                if (m_agent->get_subtask_info(subtask_id, &subtask_json, &http_code, &http_body,
                                              Slic3r::GUI::wxGetApp().get_printer_cloud_provider()) == 0) {
                    try {
                        if (!subtask_json.empty()) {
 
                            json task_j = json::parse(subtask_json);
                            if (task_j.contains("content")) {
                                std::string content_str = task_j["content"].get<std::string>();
                                json content_j = json::parse(content_str);
                                plate_index = content_j["info"]["plate_idx"].get<int>();
                            }
 
                            if (task_j.contains("context") && task_j["context"].contains("plates")) {
                                for (int i = 0; i < task_j["context"]["plates"].size(); i++) {
                                    if (task_j["context"]["plates"][i].contains("index") && task_j["context"]["plates"][i]["index"].get<int>() == plate_index) {
                                        if (task_j["context"]["plates"][i].contains("thumbnail") && task_j["context"]["plates"][i]["thumbnail"].contains("url")) {
                                            slice_info->thumbnail_url = task_j["context"]["plates"][i]["thumbnail"]["url"].get<std::string>();
                                        }
                                        if (task_j["context"]["plates"][i].contains("prediction")) {
                                            slice_info->prediction = task_j["context"]["plates"][i]["prediction"].get<int>();
                                        }
                                        if (task_j["context"]["plates"][i].contains("weight")) {
                                            slice_info->weight = task_j["context"]["plates"][i]["weight"].get<float>();
                                        }
                                        if (!task_j["context"]["plates"][i]["filaments"].is_null()) {
                                            for (auto filament : task_j["context"]["plates"][i]["filaments"]) {
                                                FilamentInfo f;
                                                if(filament.contains("color")){
                                                    f.color = filament["color"].get<std::string>();
                                                }
                                                if (filament.contains("type")) {
                                                    f.type = filament["type"].get<std::string>();
                                                }
                                                if (filament.contains("used_g")) {
                                                    f.used_g = stof(filament["used_g"].get<std::string>());
                                                }
                                                if (filament.contains("used_m")) {
                                                    f.used_m = stof(filament["used_m"].get<std::string>());
                                                }
                                                slice_info->filaments_info.push_back(f);
                                            }
                                        }
                                        BOOST_LOG_TRIVIAL(trace) << "task_info: thumbnail url=" << slice_info->thumbnail_url;
                                    }
                                }
                            }
                            else {
                                BOOST_LOG_TRIVIAL(error) << "task_info: no context or plates";
                            }
                        }
                    }
                    catch (...) {
                    }
                }
                else {
                    BOOST_LOG_TRIVIAL(error) << "task_info: get subtask id failed!";
                }
            }
            // this->m_plate_index = plate_index;
            });
    }
}

References Slic3r::Geometry::contains(), Slic3r::f(), get_slice_info_thread, m_agent, m_plate_index, profile_id_, project_id_, slice_info, subtask_id_, and Slic3r::trace().

Referenced by parse_json().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

access_code

std::string Slic3r::MachineObject::access_code

private

Referenced by get_access_code(), parse_json(), revoke_access(), and set_access_code().

ahb_new_version_number

std::string Slic3r::MachineObject::ahb_new_version_number

Referenced by parse_json(), and Slic3r::GUI::MachineInfoPanel::update_ams_ext().

air_pump_version_info

DevFirmwareVersionInfo Slic3r::MachineObject::air_pump_version_info

Referenced by clear_version_info(), store_version_info(), and Slic3r::GUI::MachineInfoPanel::update_air_pump().

ams_air_print_status

bool Slic3r::MachineObject::ams_air_print_status { false }

{ false };

Referenced by command_ams_air_print_detect(), parse_home_flag(), and Slic3r::GUI::AMSSetting::update_air_printing_detection().

ams_exist_bits

long Slic3r::MachineObject::ams_exist_bits = 0

Referenced by MachineObject(), Slic3r::GUI::SelectMachineDialog::on_timer(), Slic3r::GUI::SyncAmsInfoDialog::on_timer(), Slic3r::DevFilaSystemParser::ParseV1_0(), and Slic3r::GUI::MachineInfoPanel::update_ams_ext().

ams_new_version_number

std::string Slic3r::MachineObject::ams_new_version_number

Referenced by parse_json(), and Slic3r::GUI::MachineInfoPanel::update_ams_ext().

ams_status_main

AmsStatusMain Slic3r::MachineObject::ams_status_main = AmsStatusMain::AMS_STATUS_MAIN_IDLE

Referenced by _parse_ams_status(), can_unload_filament(), Slic3r::GUI::SelectMachineDialog::update_show_status(), and Slic3r::GUI::SyncAmsInfoDialog::update_show_status().

ams_status_sub

int Slic3r::MachineObject::ams_status_sub

Referenced by _parse_ams_status().

ams_support_virtual_tray

bool Slic3r::MachineObject::ams_support_virtual_tray { true }

Whether this printer supports virtual trays (external/manual filament loading). When true, vt_slot data is used by build_filament_ams_list() to include external filaments.

{ true };

Referenced by Slic3r::GUI::Sidebar::build_filament_ams_list(), parse_json(), and parse_vt_tray().

ams_switch_filament_start

time_t Slic3r::MachineObject::ams_switch_filament_start = 0

Referenced by command_ams_switch_filament(), parse_home_flag(), and parse_new_info().

ams_user_setting_start

time_t Slic3r::MachineObject::ams_user_setting_start = 0

Referenced by command_ams_user_settings(), parse_home_flag(), parse_new_info(), and Slic3r::DevFilaSystemParser::ParseV1_0().

ams_version

int Slic3r::MachineObject::ams_version = 0

Referenced by parse_json(), and Slic3r::DevFilaSystemParser::ParseV1_0().

amshub_version_info

DevFirmwareVersionInfo Slic3r::MachineObject::amshub_version_info

Referenced by clear_version_info(), store_version_info(), and Slic3r::GUI::MachineInfoPanel::update_amshub().

bed_temp_range

std::vector<int> Slic3r::MachineObject::bed_temp_range

Referenced by parse_json().

bed_temperature_limit

int Slic3r::MachineObject::bed_temperature_limit = -1

Referenced by get_bed_temperature_limit(), and parse_json().

bind_sec_link

std::string Slic3r::MachineObject::bind_sec_link

Referenced by Slic3r::DeviceManager::insert_local_device(), Slic3r::DeviceManager::load_local_machines_from_config(), and Slic3r::DeviceManager::on_machine_alive().

bind_ssdp_version

std::string Slic3r::MachineObject::bind_ssdp_version

Referenced by Slic3r::DeviceManager::insert_local_device(), and Slic3r::DeviceManager::on_machine_alive().

bind_state

std::string Slic3r::MachineObject::bind_state

Referenced by Slic3r::DeviceManager::insert_local_device(), is_avaliable(), Slic3r::DeviceManager::load_local_machines_from_config(), and Slic3r::DeviceManager::on_machine_alive().

bind_user_id

std::string Slic3r::MachineObject::bind_user_id

bind_user_name

std::string Slic3r::MachineObject::bind_user_name

Referenced by get_bind_str(), and set_bind_status().

cache_flow_ratio

float Slic3r::MachineObject::cache_flow_ratio { 0.0 }

{ 0.0 };

Referenced by Slic3r::GUI::CalibrationWizard::back_preset_info(), Slic3r::GUI::FlowRateWizard::cache_coarse_info(), Slic3r::GUI::CalibrationWizard::cache_preset_info(), Slic3r::GUI::CalibrationWizard::on_device_connected(), Slic3r::GUI::CalibrationWizard::recover_preset_info(), and Slic3r::GUI::CalibrationCaliPage::update().

cali_finished

bool Slic3r::MachineObject::cali_finished = true

Referenced by Slic3r::GUI::CalibrationWizard::on_device_connected(), Slic3r::GUI::FlowRateWizard::on_device_connected(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_device_connected(), Slic3r::GUI::PressureAdvanceWizard::on_device_connected(), Slic3r::GUI::CalibrationWizard::recover_preset_info(), and Slic3r::GUI::CalibrationCaliPage::update().

cali_selected_nozzle_dia

float Slic3r::MachineObject::cali_selected_nozzle_dia { 0.0 }

{ 0.0 };

Referenced by Slic3r::GUI::CalibrationCaliPage::get_selected_calibration_nozzle_dia(), and Slic3r::GUI::CalibrationPresetPage::update_combobox_filaments().

cali_version

int Slic3r::MachineObject::cali_version = -1

Referenced by Slic3r::GUI::CalibrationFlowRateStartPage::on_device_connected(), Slic3r::GUI::CalibrationPAStartPage::on_device_connected(), Slic3r::GUI::CalibrationWizard::on_device_connected(), Slic3r::GUI::AMSinfo::parse_ams_info(), Slic3r::GUI::AMSinfo::parse_ext_info(), parse_json(), Slic3r::GUI::CalibrationCaliPage::update(), Slic3r::GUI::HistoryWindow::update(), and Slic3r::GUI::PressureAdvanceWizard::update().

calibration_done

bool Slic3r::MachineObject::calibration_done { false }

{ false };

Referenced by is_calibration_done(), is_in_calibration(), and parse_state_changed_event().

camera_recording

bool Slic3r::MachineObject::camera_recording { false }

{ false };

Referenced by is_recording(), parse_home_flag(), parse_new_info(), and reset().

camera_recording_ctl_start

time_t Slic3r::MachineObject::camera_recording_ctl_start = 0

Referenced by command_ipcam_record(), command_ipcam_resolution_set(), parse_json(), and parse_new_info().

camera_recording_when_printing

bool Slic3r::MachineObject::camera_recording_when_printing { false }

{ false };

Referenced by command_ipcam_record(), is_recording_enable(), parse_json(), parse_new_info(), and reset().

camera_resolution

std::string Slic3r::MachineObject::camera_resolution = ""

Referenced by command_ipcam_resolution_set(), parse_json(), and parse_new_info().

camera_resolution_hold_count

int Slic3r::MachineObject::camera_resolution_hold_count = 0

Referenced by command_ipcam_resolution_set(), parse_json(), and parse_new_info().

camera_resolution_supported

std::vector<std::string> Slic3r::MachineObject::camera_resolution_supported

Referenced by get_resolution_supported(), and parse_json().

camera_timelapse

bool Slic3r::MachineObject::camera_timelapse { false }

{ false };

Referenced by command_ipcam_timelapse(), is_timelapse(), parse_json(), parse_new_info(), and reset().

camera_timelapse_hold_count

int Slic3r::MachineObject::camera_timelapse_hold_count = 0

Referenced by command_ipcam_timelapse(), parse_json(), and parse_new_info().

chamber_temp

float Slic3r::MachineObject::chamber_temp

Referenced by MachineObject(), parse_json(), and parse_new_info().

chamber_temp_target

float Slic3r::MachineObject::chamber_temp_target

Referenced by MachineObject(), parse_json(), and parse_new_info().

curr_layer

int Slic3r::MachineObject::curr_layer = 0

Referenced by parse_json(), and Slic3r::GUI::CalibrationCaliPage::update_subtask().

cutting_module_version_info

DevFirmwareVersionInfo Slic3r::MachineObject::cutting_module_version_info

Referenced by clear_version_info(), store_version_info(), and Slic3r::GUI::MachineInfoPanel::update_cut().

dev_connection_name

std::string Slic3r::MachineObject::dev_connection_name

Referenced by Slic3r::DeviceManager::on_machine_alive(), and reset().

dev_connection_type

std::string Slic3r::MachineObject::dev_connection_type

Referenced by connection_type(), Slic3r::DeviceManager::insert_local_device(), is_cloud_mode_printer(), is_lan_mode_printer(), Slic3r::DeviceManager::load_local_machines_from_config(), Slic3r::DeviceManager::on_machine_alive(), and Slic3r::DeviceManager::parse_user_print_info().

dev_id

std::string Slic3r::MachineObject::dev_id

private

Referenced by MachineObject(), command_pushing(), command_request_push_all(), get_dev_id(), is_connected(), is_info_ready(), parse_json(), reset(), reset_update_time(), set_dev_id(), set_online_state(), and set_print_state().

dev_ip

std::string Slic3r::MachineObject::dev_ip

private

Referenced by MachineObject(), get_dev_ip(), and set_dev_ip().

dev_name

std::string Slic3r::MachineObject::dev_name

private

Referenced by MachineObject(), get_dev_name(), and set_dev_name().

dev_product_name

std::string Slic3r::MachineObject::dev_product_name

Referenced by Slic3r::DeviceManager::parse_user_print_info().

device_cert_installed

bool Slic3r::MachineObject::device_cert_installed = false

Referenced by is_security_control_ready(), reset(), and update_device_cert_state().

exhaustfan_version_info

DevFirmwareVersionInfo Slic3r::MachineObject::exhaustfan_version_info

Referenced by clear_version_info(), store_version_info(), and Slic3r::GUI::MachineInfoPanel::update_exhaustfan().

extinguish_version_info

DevFirmwareVersionInfo Slic3r::MachineObject::extinguish_version_info

Referenced by clear_version_info(), store_version_info(), and Slic3r::GUI::MachineInfoPanel::update_extinguish().

extrusion_cali_filament_name

std::string Slic3r::MachineObject::extrusion_cali_filament_name

extrusion_cali_hold_count

int Slic3r::MachineObject::extrusion_cali_hold_count = 0

extrusion_cali_set_hold_start

std::chrono::system_clock::time_point Slic3r::MachineObject::extrusion_cali_set_hold_start

Referenced by Slic3r::DevCalib::ExtrusionCalibSetParse(), parse_json(), parse_vt_tray(), and Slic3r::DevFilaSystemParser::ParseV1_0().

extrusion_cali_set_tray_id

int Slic3r::MachineObject::extrusion_cali_set_tray_id = -1

Referenced by Slic3r::DevCalib::ExtrusionCalibSetParse(), parse_json(), parse_vt_tray(), and Slic3r::DevFilaSystemParser::ParseV1_0().

filatrack_version_info

DevFirmwareVersionInfo Slic3r::MachineObject::filatrack_version_info

Referenced by clear_version_info(), store_version_info(), and Slic3r::GUI::MachineInfoPanel::update_filatrack().

file_local

FileLocal Slic3r::MachineObject::file_local { FileLocal::FL_None }

{ FileLocal::FL_None };

Referenced by parse_json(), and Slic3r::GUI::MediaFilePanel::UpdateByObj().

file_model_download

bool Slic3r::MachineObject::file_model_download {false}

{false};

Referenced by parse_json(), and Slic3r::GUI::MediaFilePanel::UpdateByObj().

file_remote

FileRemote Slic3r::MachineObject::file_remote { FileRemote::FR_None }

{ FileRemote::FR_None };

Referenced by get_file_remote(), and parse_json().

firmware_list

std::vector<FirmwareInfo> Slic3r::MachineObject::firmware_list

Referenced by get_firmware_info().

firmware_type

PrinterFirmwareType Slic3r::MachineObject::firmware_type

Referenced by parse_json().

flow_ratio_calibration_type

FlowRatioCalibrationType Slic3r::MachineObject::flow_ratio_calibration_type = FlowRatioCalibrationType::COMPLETE_CALIBRATION

Referenced by Slic3r::GUI::CalibrationWizard::back_preset_info(), Slic3r::GUI::CalibrationPresetPage::init_with_machine(), and Slic3r::GUI::CalibrationWizard::recover_preset_info().

flow_ratio_results

std::vector<FlowRatioCalibResult> Slic3r::MachineObject::flow_ratio_results

Referenced by Slic3r::GUI::CalibUtils::get_flow_ratio_calib_results(), parse_json(), and reset_flow_rate_cali_result().

frame_temp

float Slic3r::MachineObject::frame_temp

Referenced by MachineObject(), and parse_json().

gcode_file_prepare_percent

int Slic3r::MachineObject::gcode_file_prepare_percent = 0

Referenced by parse_json(), reset(), and Slic3r::GUI::CalibrationCaliPage::update_subtask().

get_flow_calib_result

bool Slic3r::MachineObject::get_flow_calib_result { false }

{ false };

Referenced by parse_json(), reset_flow_rate_cali_result(), and Slic3r::GUI::CalibrationCaliPage::update().

get_model_mall_result_need_retry

bool Slic3r::MachineObject::get_model_mall_result_need_retry = false

Referenced by update_model_task().

get_model_task_thread

boost::thread* Slic3r::MachineObject::get_model_task_thread { nullptr }

{ nullptr };

Referenced by update_model_task().

get_pa_calib_result

bool Slic3r::MachineObject::get_pa_calib_result { false }

{ false };

Referenced by parse_json(), reset_pa_cali_result(), and Slic3r::GUI::CalibrationCaliPage::update().

get_slice_info_thread

boost::thread* Slic3r::MachineObject::get_slice_info_thread { nullptr }

{ nullptr };

Referenced by free_slice_info(), and update_slice_info().

get_version_retry

int Slic3r::MachineObject::get_version_retry = 0

Referenced by check_version_valid(), command_get_version(), parse_json(), and reset().

has_extra_flow_type

bool Slic3r::MachineObject::has_extra_flow_type {false}

{false};

Referenced by is_nozzle_flow_type_supported(), parse_json(), and reset().

has_get_pa_calib_tab

bool Slic3r::MachineObject::has_get_pa_calib_tab { false }

{ false };

Referenced by Slic3r::GUI::CalibUtils::get_PA_calib_tab(), parse_json(), reset_pa_cali_history_result(), and Slic3r::GUI::HistoryWindow::update().

has_ipcam

bool Slic3r::MachineObject::has_ipcam { false }

{ false };

Referenced by MachineObject(), parse_json(), and Slic3r::GUI::MediaPlayCtrl::SetMachineObject().

hw_switch_state

int Slic3r::MachineObject::hw_switch_state

Referenced by MachineObject(), can_unload_filament(), is_filament_at_extruder(), and parse_json().

installed_upgrade_kit

bool Slic3r::MachineObject::installed_upgrade_kit {false}

{false};

Referenced by Slic3r::GUI::CalibrationPresetPage::get_printer_preset(), get_show_printer_type(), Slic3r::GUI::SelectMachineDialog::is_same_printer_model(), Slic3r::GUI::SyncAmsInfoDialog::is_same_printer_model(), parse_home_flag(), and parse_new_info().

iot_print_status

std::string Slic3r::MachineObject::iot_print_status

Referenced by is_in_printing(), Slic3r::DeviceManager::parse_user_print_info(), and reset().

is_220V_voltage

bool Slic3r::MachineObject::is_220V_voltage { false }

{ false };

Referenced by get_bed_temperature_limit(), parse_home_flag(), parse_new_info(), and reset().

is_enable_ams_np

bool Slic3r::MachineObject::is_enable_ams_np { false }

{ false };

Referenced by get_max_filament_color_count(), parse_json(), Slic3r::DevFilaSystemParser::ParseV1_0(), and Slic3r::GUI::SelectMachineDialog::update_show_status().

is_enable_np

bool Slic3r::MachineObject::is_enable_np { false }

{ false };

Referenced by Slic3r::GUI::get_tray_ams_and_slot_id(), is_nozzle_flow_type_supported(), parse_new_info(), Slic3r::GUI::SelectMachineDialog::update_ams_check(), and Slic3r::GUI::SelectMachineDialog::update_show_status().

is_support_1080dpi

bool Slic3r::MachineObject::is_support_1080dpi {false}

{false};

Referenced by Slic3r::GUI::CameraPopup::check_func_supported(), parse_json(), and parse_new_info2().

is_support_agora

bool Slic3r::MachineObject::is_support_agora {false}

{false};

Referenced by get_file_remote(), get_liveview_remote(), parse_home_flag(), parse_json(), parse_new_info(), and parse_new_info2().

is_support_air_print_detection

bool Slic3r::MachineObject::is_support_air_print_detection {false}

{false};

Referenced by parse_home_flag(), and Slic3r::GUI::AMSSetting::update_air_printing_detection().

is_support_airprinting_detection

bool Slic3r::MachineObject::is_support_airprinting_detection {false}

{false};

Referenced by parse_new_info(), and Slic3r::GUI::PrintOptionsDialog::update_options().

is_support_ams_humidity

bool Slic3r::MachineObject::is_support_ams_humidity {false}

{false};

Referenced by Slic3r::GUI::ReselectMachineDialog::CaculateSwitcherDistribution(), parse_json(), parse_new_info2(), Slic3r::GUI::ExtruderGroup::sync_ams(), and Slic3r::GUI::CalibrationPresetPage::sync_ams_info().

is_support_auto_recovery_step_loss

bool Slic3r::MachineObject::is_support_auto_recovery_step_loss {false}

{false};

Referenced by parse_json(), parse_new_info2(), and Slic3r::GUI::PrintOptionsDialog::update_options().

is_support_bed_leveling

int Slic3r::MachineObject::is_support_bed_leveling = 0

Referenced by parse_json(), parse_new_info2(), Slic3r::GUI::CalibrationDialog::update_cali(), and Slic3r::GUI::SelectMachineDialog::update_option_opts().

is_support_brtc

bool Slic3r::MachineObject::is_support_brtc {false}

{false};                 // fun[31], support tcp and upload protocol

Referenced by Slic3r::GUI::PrintingTaskPanel::enable_partskip_button(), Slic3r::GUI::SendToPrinterDialog::on_ok(), parse_new_info(), and Slic3r::GUI::SendToPrinterDialog::update_show_status().

is_support_build_plate_marker_detect

bool Slic3r::MachineObject::is_support_build_plate_marker_detect {false}

{false};

Referenced by parse_json(), parse_new_info2(), Slic3r::DevPrintOptionsParser::ParseDetectionV1_0(), and Slic3r::GUI::PrintOptionsDialog::update_options().

is_support_check_track_switch_match_slice_printer

bool Slic3r::MachineObject::is_support_check_track_switch_match_slice_printer {false}

{false};

Referenced by Slic3r::GUI::SelectMachineDialog::CheckErrorDynamicSwitchNozzle(), and parse_new_info().

is_support_cloud_print_only

bool Slic3r::MachineObject::is_support_cloud_print_only {false}

{false};

Referenced by Slic3r::GUI::SelectMachineDialog::on_send_print(), parse_json(), parse_new_info2(), Slic3r::GUI::SendMultiMachinePage::request_params(), Slic3r::GUI::CalibUtils::send_to_print(), and Slic3r::GUI::CalibUtils::send_to_print().

is_support_command_ams_switch

bool Slic3r::MachineObject::is_support_command_ams_switch {false}

{false};

Referenced by parse_json(), and parse_new_info2().

is_support_door_open_check

bool Slic3r::MachineObject::is_support_door_open_check = false

private

Referenced by parse_new_info(), and support_door_open_check().

is_support_ext_change_assist

bool Slic3r::MachineObject::is_support_ext_change_assist {false}

{false};

Referenced by parse_new_info(), and Slic3r::GUI::SelectMachineDialog::update_show_status().

is_support_ext_change_assist_old

bool Slic3r::MachineObject::is_support_ext_change_assist_old { false }

{ false }; // A/P-series multi-color external change assist

Referenced by parse_json(), and Slic3r::GUI::SelectMachineDialog::update_show_status().

is_support_fila_change_abort

bool Slic3r::MachineObject::is_support_fila_change_abort { false }

{ false }; // filament-change Stop button

Referenced by parse_json().

is_support_filament_32_colors

bool Slic3r::MachineObject::is_support_filament_32_colors { false }

{ false };

Referenced by get_max_filament_color_count(), and parse_json().

is_support_filament_backup

bool Slic3r::MachineObject::is_support_filament_backup {false}

{false};

Referenced by Slic3r::GUI::SelectMachineDialog::on_timer(), Slic3r::GUI::SyncAmsInfoDialog::on_timer(), parse_json(), and parse_new_info2().

is_support_filament_manual_multi_color

bool Slic3r::MachineObject::is_support_filament_manual_multi_color {false}

{false};

Referenced by parse_new_info().

is_support_filament_setting_inprinting

bool Slic3r::MachineObject::is_support_filament_setting_inprinting {false}

{false};

Referenced by parse_json().

is_support_filament_tangle_detect

bool Slic3r::MachineObject::is_support_filament_tangle_detect {false}

{false};

Referenced by parse_home_flag(), parse_json(), parse_new_info(), parse_new_info2(), and Slic3r::GUI::PrintOptionsDialog::update_options().

is_support_flow_calibration

bool Slic3r::MachineObject::is_support_flow_calibration {false}

{false};

Referenced by Slic3r::GUI::CalibrationFlowRateStartPage::on_device_connected(), parse_home_flag(), parse_new_info(), and parse_new_info2().

is_support_idelheadingprotect_detection

bool Slic3r::MachineObject::is_support_idelheadingprotect_detection {false}

{false};

Referenced by parse_new_info().

is_support_internal_timelapse

bool Slic3r::MachineObject::is_support_internal_timelapse { false }

{ false };// fun[28], support timelapse without SD card

Referenced by canEnableTimelapse(), Slic3r::GUI::SelectMachineDialog::check_sdcard_for_timelpase(), Slic3r::GUI::SelectMachineDialog::check_timelapse_storage_warning(), Slic3r::GUI::SelectMachineDialog::on_ok_btn(), Slic3r::GUI::SelectMachineDialog::on_send_print(), parse_new_info(), and Slic3r::GUI::SelectMachineDialog::update_option_opts().

is_support_layer_num

bool Slic3r::MachineObject::is_support_layer_num { false }

{ false };

Referenced by parse_json(), and Slic3r::GUI::CalibrationCaliPage::update_subtask().

is_support_motor_noise_cali

bool Slic3r::MachineObject::is_support_motor_noise_cali {false}

{false};

Referenced by parse_home_flag(), parse_json(), parse_new_info(), parse_new_info2(), and Slic3r::GUI::CalibrationDialog::update_cali().

is_support_mqtt_alive

bool Slic3r::MachineObject::is_support_mqtt_alive {false}

{false};

Referenced by Slic3r::DeviceManager::check_pushing(), parse_json(), and parse_new_info2().

is_support_new_auto_cali_method

bool Slic3r::MachineObject::is_support_new_auto_cali_method {false}

{false};

Referenced by parse_json(), and parse_new_info().

is_support_nozzle_blob_detection

bool Slic3r::MachineObject::is_support_nozzle_blob_detection {false}

{false};

Referenced by parse_home_flag(), parse_new_info(), and parse_new_info2().

is_support_nozzleclumping_detection

bool Slic3r::MachineObject::is_support_nozzleclumping_detection {false}

{false};

Referenced by parse_new_info(), and Slic3r::GUI::PrintOptionsDialog::update_options().

is_support_pa_calibration

bool Slic3r::MachineObject::is_support_pa_calibration {false}

{false};

Referenced by Slic3r::GUI::CalibrationPAStartPage::on_device_connected(), parse_home_flag(), parse_json(), parse_new_info(), and Slic3r::GUI::SelectMachineDialog::update_option_opts().

is_support_pa_mode

bool Slic3r::MachineObject::is_support_pa_mode {false}

{false};

Referenced by Slic3r::GUI::SelectMachineDialog::CheckErrorSyncNozzleMappingResultV0(), Slic3r::GUI::SelectMachineDialog::on_send_print(), parse_new_info(), and Slic3r::GUI::SelectMachineDialog::update_pa_value_option().

is_support_partskip

bool Slic3r::MachineObject::is_support_partskip {false}

{false};

Referenced by parse_new_info().

is_support_print_with_emmc

bool Slic3r::MachineObject::is_support_print_with_emmc {false}

{false};

Referenced by can_use_emmc_print(), Slic3r::GUI::SelectMachineDialog::on_send_print(), and parse_new_info().

is_support_prompt_sound

bool Slic3r::MachineObject::is_support_prompt_sound {false}

{false};

Referenced by parse_home_flag(), parse_json(), parse_new_info(), parse_new_info2(), and Slic3r::GUI::PrintOptionsDialog::update_options().

is_support_purgechutepileup_detection

bool Slic3r::MachineObject::is_support_purgechutepileup_detection {false}

{false};

Referenced by parse_new_info(), and Slic3r::GUI::PrintOptionsDialog::update_options().

is_support_refresh_nozzle

bool Slic3r::MachineObject::is_support_refresh_nozzle {false}

{false};

Referenced by parse_json(), and parse_new_info2().

is_support_remote_dry

bool Slic3r::MachineObject::is_support_remote_dry = false

Referenced by Slic3r::GUI::AMSControl::AMSControl(), Slic3r::DevAms::IsSupportRemoteDry(), parse_new_info(), and Slic3r::DevFilaSystemParser::ParseV1_0().

is_support_send_to_sdcard

bool Slic3r::MachineObject::is_support_send_to_sdcard {false}

{false};

Referenced by parse_json(), parse_new_info2(), and Slic3r::GUI::SendToPrinterDialog::update_show_status().

is_support_spaghetti_detection

bool Slic3r::MachineObject::is_support_spaghetti_detection {false}

{false};

Referenced by parse_new_info(), and Slic3r::GUI::PrintOptionsDialog::update_options().

is_support_timelapse

bool Slic3r::MachineObject::is_support_timelapse {false}

{false};

Referenced by canEnableTimelapse(), parse_json(), and parse_new_info2().

is_support_tunnel_mqtt

bool Slic3r::MachineObject::is_support_tunnel_mqtt {false}

{false};

Referenced by parse_home_flag(), parse_json(), parse_new_info(), and parse_new_info2().

is_support_update_remain

bool Slic3r::MachineObject::is_support_update_remain {false}

{false};

Referenced by parse_json(), parse_new_info2(), and Slic3r::GUI::AMSSetting::UpdateByObj().

is_support_upgrade_kit

bool Slic3r::MachineObject::is_support_upgrade_kit {false}

{false};

Referenced by Slic3r::GUI::CalibrationPresetPage::get_printer_preset(), get_show_printer_type(), Slic3r::GUI::SelectMachineDialog::is_same_printer_model(), Slic3r::GUI::SyncAmsInfoDialog::is_same_printer_model(), parse_home_flag(), and parse_new_info().

is_support_user_preset

bool Slic3r::MachineObject::is_support_user_preset {false}

{false};

Referenced by Slic3r::GUI::NewCalibrationHistoryDialog::get_all_filaments(), parse_home_flag(), parse_json(), parse_new_info(), parse_new_info2(), and Slic3r::GUI::AMSDryCtrWin::update_filament_list().

is_support_wait_sending_finish

bool Slic3r::MachineObject::is_support_wait_sending_finish {false}

{false};

Referenced by parse_json(), and Slic3r::GUI::PrintJob::process().

is_tunnel_mqtt

bool Slic3r::MachineObject::is_tunnel_mqtt = false

Referenced by parse_json().

job_id_

std::string Slic3r::MachineObject::job_id_

Referenced by parse_json(), Slic3r::GUI::PrintJob::process(), and reset().

jobState_

int Slic3r::MachineObject::jobState_ = 0

Referenced by check_resume_condition(), parse_json(), and reset().

keep_alive_count

int Slic3r::MachineObject::keep_alive_count = 0

Referenced by Slic3r::DeviceManager::keep_alive().

laser_version_info

DevFirmwareVersionInfo Slic3r::MachineObject::laser_version_info

Referenced by clear_version_info(), store_version_info(), and Slic3r::GUI::MachineInfoPanel::update_laszer().

last_alive

time_t Slic3r::MachineObject::last_alive

Referenced by Slic3r::DeviceManager::insert_local_device(), Slic3r::DeviceManager::load_local_machines_from_config(), and Slic3r::DeviceManager::on_machine_alive().

last_cali_version

int Slic3r::MachineObject::last_cali_version = -1

Referenced by parse_json(), and Slic3r::GUI::HistoryWindow::update().

last_cloud_msg_time_

std::chrono::system_clock::time_point Slic3r::MachineObject::last_cloud_msg_time_

Referenced by HasRecentCloudMessage(), and parse_json().

last_extrusion_cali_start_time

std::chrono::system_clock::time_point Slic3r::MachineObject::last_extrusion_cali_start_time

Referenced by command_start_extrusion_cali(), is_extrusion_cali_finished(), and is_in_extrusion_cali().

last_keep_alive

std::chrono::system_clock::time_point Slic3r::MachineObject::last_keep_alive

Referenced by Slic3r::DeviceManager::keep_alive().

last_lan_msg_time_

std::chrono::system_clock::time_point Slic3r::MachineObject::last_lan_msg_time_

Referenced by HasRecentLanMessage(), and parse_json().

last_mc_print_stage

int Slic3r::MachineObject::last_mc_print_stage

Referenced by parse_state_changed_event(), and reset().

last_online_version

int Slic3r::MachineObject::last_online_version = -1

Referenced by parse_json().

last_push_time

std::chrono::system_clock::time_point Slic3r::MachineObject::last_push_time

Referenced by Slic3r::MoonrakerPrinterAgent::build_ams_payload(), is_info_ready(), and parse_json().

last_request_push

std::chrono::system_clock::time_point Slic3r::MachineObject::last_request_push

Referenced by command_request_push_all().

last_request_start

std::chrono::system_clock::time_point Slic3r::MachineObject::last_request_start

Referenced by command_pushing().

last_subtask_id_

std::string Slic3r::MachineObject::last_subtask_id_

Referenced by update_model_task().

last_update_time

std::chrono::system_clock::time_point Slic3r::MachineObject::last_update_time

Referenced by Slic3r::DeviceManager::check_pushing(), is_connected(), parse_json(), reset(), and reset_update_time().

last_utc_time

std::chrono::system_clock::time_point Slic3r::MachineObject::last_utc_time

Referenced by parse_json().

lifecycle

PrinterFirmwareType Slic3r::MachineObject::lifecycle { PrinterFirmwareType::FIRMWARE_TYPE_PRODUCTION }

{ PrinterFirmwareType::FIRMWARE_TYPE_PRODUCTION };

Referenced by parse_json().

link_ams

std::string Slic3r::MachineObject::link_ams

Referenced by parse_json().

link_th

std::string Slic3r::MachineObject::link_th

Referenced by parse_json().

liveview_local

LiveviewLocal Slic3r::MachineObject::liveview_local { LiveviewLocal::LVL_None }

{ LiveviewLocal::LVL_None };

Referenced by parse_json(), and Slic3r::GUI::MediaPlayCtrl::SetMachineObject().

liveview_remote

LiveviewRemote Slic3r::MachineObject::liveview_remote { LiveviewRemote::LVR_None}

{ LiveviewRemote::LVR_None};

Referenced by get_liveview_remote(), and parse_json().

local_rtsp_url

std::string Slic3r::MachineObject::local_rtsp_url

Referenced by parse_json().

local_use_ssl

bool Slic3r::MachineObject::local_use_ssl { true }

{ true };

Referenced by Slic3r::GUI::SendToPrinterDialog::on_ok(), Slic3r::GUI::SelectMachineDialog::on_send_print(), Slic3r::GUI::GUI_App::select_machine(), Slic3r::GUI::CalibUtils::send_to_print(), and Slic3r::GUI::CalibUtils::send_to_print().

local_use_ssl_for_ftp

bool Slic3r::MachineObject::local_use_ssl_for_ftp { true }

{ true };

Referenced by Slic3r::GUI::SendToPrinterDialog::on_ok(), Slic3r::GUI::SelectMachineDialog::on_send_print(), Slic3r::GUI::CalibUtils::send_to_print(), and Slic3r::GUI::CalibUtils::send_to_print().

m_access_revoked

bool Slic3r::MachineObject::m_access_revoked = false

private

Referenced by connect(), has_access_right(), revoke_access(), and set_access_code().

m_active_state

int Slic3r::MachineObject::m_active_state = 0

Referenced by parse_json(), and set_online_state().

m_agent

NetworkAgent* Slic3r::MachineObject::m_agent {nullptr}

private

{nullptr};

Referenced by MachineObject(), cloud_publish_json(), command_ams_calibrate(), command_ams_refresh_rfid(), command_ams_select_tray(), command_auto_leveling(), command_axis_control(), command_go_home(), command_set_bed(), command_set_nozzle(), command_start_camera(), command_with_dialog(), command_xyz_abs(), connect(), disconnect(), get_agent(), get_firmware_info(), is_connected(), local_publish_json(), parse_json(), set_agent(), update_model_task(), and update_slice_info().

m_agent_thumbnail_url

std::string Slic3r::MachineObject::m_agent_thumbnail_url

Referenced by parse_json().

m_axis

std::shared_ptr<DevAxis> Slic3r::MachineObject::m_axis

private

Referenced by MachineObject(), GetAxis(), and parse_json().

m_bed

DevBed* Slic3r::MachineObject::m_bed

private

Referenced by MachineObject(), ~MachineObject(), GetBed(), parse_json(), and parse_new_info().

m_calib

DevCalib* Slic3r::MachineObject::m_calib { nullptr }

private

{ nullptr };

Referenced by MachineObject(), ~MachineObject(), and GetCalib().

m_chamber

std::shared_ptr<DevChamber> Slic3r::MachineObject::m_chamber

private

Referenced by MachineObject(), GetChamber(), and parse_json().

m_command_error_code_dlgs

std::unordered_set<GUI::DeviceErrorDialog*> Slic3r::MachineObject::m_command_error_code_dlgs

Referenced by ~MachineObject(), and add_command_error_code_dlg().

m_config

DevConfig* Slic3r::MachineObject::m_config

private

Referenced by MachineObject(), ~MachineObject(), GetConfig(), parse_json(), and parse_new_info2().

m_ctrl

DevCtrl* Slic3r::MachineObject::m_ctrl

private

Referenced by MachineObject(), ~MachineObject(), and GetCtrl().

m_device_mode

DeviceMode Slic3r::MachineObject::m_device_mode { DEVICE_MODE_FDM }

{ DEVICE_MODE_FDM };

Referenced by is_fdm_type(), and parse_new_info().

m_extder_system

DevExtderSystem* Slic3r::MachineObject::m_extder_system

private

Referenced by MachineObject(), ~MachineObject(), any_loaded_filament_is_stringing_prone(), can_unload_filament(), check_ams_filament_valid(), get_curr_Ams(), get_curr_tray(), GetExtderSystem(), is_filament_installed(), is_multi_extruders(), is_target_slot_unload(), parse_json(), parse_new_info(), and update_printer_preset_name().

m_extension_tool

std::shared_ptr<DevExtensionTool> Slic3r::MachineObject::m_extension_tool

private

Referenced by MachineObject(), GetExtensionTool(), and parse_new_info().

m_fan

DevFan* Slic3r::MachineObject::m_fan

private

Referenced by MachineObject(), ~MachineObject(), GetFan(), parse_json(), parse_new_info(), and parse_new_info2().

m_fila_switch

DevFilaSwitch* Slic3r::MachineObject::m_fila_switch

private

Referenced by MachineObject(), ~MachineObject(), GetFilaSwitch(), and parse_json().

m_fila_system

std::shared_ptr<DevFilaSystem> Slic3r::MachineObject::m_fila_system

private

Referenced by MachineObject(), check_ams_filament_valid(), command_ams_switch_filament(), command_ams_user_settings(), contains_tray(), get_ams_colors(), get_ams_tray(), get_curr_Ams(), get_extruder_id_by_ams_id(), get_tray(), GetFilaSystem(), HasAms(), parse_home_flag(), parse_json(), and parse_new_info().

m_firmware_support_print_tpu_left

std::optional<bool> Slic3r::MachineObject::m_firmware_support_print_tpu_left

Referenced by parse_new_info(), and Slic3r::GUI::SelectMachineDialog::update_show_status().

m_firmware_thread_started

bool Slic3r::MachineObject::m_firmware_thread_started { false }

{ false };

Referenced by get_firmware_info().

m_firmware_valid

bool Slic3r::MachineObject::m_firmware_valid { false }

{ false };

Referenced by get_firmware_info(), and is_firmware_info_valid().

m_full_msg_count

int Slic3r::MachineObject::m_full_msg_count = 0

Referenced by Slic3r::MoonrakerPrinterAgent::build_ams_payload(), is_info_ready(), parse_json(), and reset().

m_gcode_file

std::string Slic3r::MachineObject::m_gcode_file

Referenced by Slic3r::GUI::get_obj_calibration_mode(), is_extrusion_cali_finished(), is_in_calibration(), is_in_extrusion_cali(), Slic3r::GUI::CalibrationWizard::on_device_connected(), parse_json(), parse_state_changed_event(), and Slic3r::GUI::CalibrationCaliPage::update().

m_has_timelapse_kit

bool Slic3r::MachineObject::m_has_timelapse_kit {false}

{false};

Referenced by canEnableTimelapse(), Slic3r::GUI::SelectMachineDialog::check_sdcard_for_timelpase(), and parse_new_info().

m_hms_system

DevHMS* Slic3r::MachineObject::m_hms_system

private

Referenced by MachineObject(), ~MachineObject(), GetHMS(), and parse_json().

m_home_flag

int Slic3r::MachineObject::m_home_flag = 0

Referenced by is_axis_at_home(), and parse_home_flag().

m_is_online

bool Slic3r::MachineObject::m_is_online

Referenced by MachineObject(), Slic3r::DeviceManager::insert_local_device(), is_online(), Slic3r::DeviceManager::load_local_machines_from_config(), Slic3r::DeviceManager::on_machine_alive(), Slic3r::DeviceManager::parse_user_print_info(), and set_online_state().

m_lamp

DevLamp* Slic3r::MachineObject::m_lamp

private

Referenced by MachineObject(), ~MachineObject(), GetLamp(), parse_json(), and parse_new_info().

m_lan_mode_connection_state

bool Slic3r::MachineObject::m_lan_mode_connection_state {false}

{false};

Referenced by get_lan_mode_connection_state(), and set_lan_mode_connection_state().

m_manager

DeviceManager* Slic3r::MachineObject::m_manager { nullptr }

private

{ nullptr };

Referenced by MachineObject(), parse_json(), parse_new_info2(), and set_access_code().

m_new_ver_list_exist

bool Slic3r::MachineObject::m_new_ver_list_exist = false

Referenced by parse_json(), reset(), Slic3r::GUI::MachineInfoPanel::update_ams_ext(), and Slic3r::GUI::MachineInfoPanel::update_version_text().

m_nozzle_filament_data

std::map<std::string, FilamentData> Slic3r::MachineObject::m_nozzle_filament_data

Referenced by check_ams_filament_valid(), update_filament_list(), and update_printer_preset_name().

m_nozzle_mapping_ptr

std::shared_ptr<DevNozzleMappingCtrl> Slic3r::MachineObject::m_nozzle_mapping_ptr

private

Referenced by MachineObject(), clear_auto_nozzle_mapping(), get_nozzle_mapping_result(), and parse_json().

m_nozzle_system

DevNozzleSystem* Slic3r::MachineObject::m_nozzle_system

private

Referenced by MachineObject(), ~MachineObject(), clear_version_info(), GetNozzleSystem(), parse_json(), parse_new_info(), and store_version_info().

m_partskip_ids

std::vector<int> Slic3r::MachineObject::m_partskip_ids

Referenced by parse_json(), and reset().

m_plate_index

int Slic3r::MachineObject::m_plate_index { -1 }

{ -1 };

Referenced by parse_json(), reset(), and update_slice_info().

m_plate_maker_detect_type

PlateMakerDectect Slic3r::MachineObject::m_plate_maker_detect_type { POS_CHECK }

{ POS_CHECK };

Referenced by parse_json(), and Slic3r::GUI::PrintOptionsDialog::update_options().

m_print_error_img_id

std::string Slic3r::MachineObject::m_print_error_img_id

Referenced by MachineObject(), and parse_json().

m_print_options

DevPrintOptions* Slic3r::MachineObject::m_print_options

private

Referenced by MachineObject(), ~MachineObject(), GetPrintingSpeedLevel(), GetPrintOptions(), parse_json(), and parse_new_info().

m_push_count

int Slic3r::MachineObject::m_push_count = 0

Referenced by Slic3r::MoonrakerPrinterAgent::build_ams_payload(), is_connecting(), is_info_ready(), Slic3r::DeviceManager::keep_alive(), parse_json(), reset(), Slic3r::GUI::MediaPlayCtrl::SetMachineObject(), and Slic3r::GUI::MediaFilePanel::UpdateByObj().

m_sequence_id

int Slic3r::MachineObject::m_sequence_id = START_SEQ_ID

inlinestatic

Referenced by command_ack_proceed(), command_ams_air_print_detect(), command_ams_calibrate(), command_ams_change_filament(), command_ams_control(), command_ams_drying_stop(), command_ams_filament_settings(), Slic3r::BBLPrinterAgent::command_ams_refresh_rfid(), command_ams_refresh_rfid(), command_ams_select_tray(), command_ams_switch_filament(), command_ams_user_settings(), command_auto_leveling(), command_axis_control(), command_clean_print_error(), command_clean_print_error_uiop(), command_consistency_upgrade_confirm(), Slic3r::DevFan::command_control_air_duct(), Slic3r::DevFan::command_control_fan_new(), command_delete_pa_calibration(), command_dont_remind_next_time(), command_extruder_control(), command_extrusion_cali_set(), command_get_access_code(), command_get_flow_ratio_calibration_result(), command_get_pa_calibration_result(), command_get_pa_calibration_tab(), command_get_version(), command_go_home(), command_hms_idle_ignore(), command_hms_ignore(), command_hms_resume(), command_hms_stop(), command_ipcam_check_timelapse_storage(), command_ipcam_delete_oldest_timelapse(), command_ipcam_record(), command_ipcam_resolution_set(), command_ipcam_timelapse(), command_nozzle_blob_detect(), command_purification_disable(), command_pushing(), command_refresh_nozzle(), command_request_push_all(), Slic3r::DevCtrl::command_select_extruder(), Slic3r::DevPrintOptions::command_set_against_continued_heating_mode(), command_set_bed(), command_set_chamber(), Slic3r::DevLamp::command_set_chamber_light(), Slic3r::DevLamp::command_set_chamber_light2(), command_set_door_open_check(), Slic3r::DevPrintOptions::command_set_filament_tangle_detect(), command_set_filament_tangle_detect(), command_set_nozzle(), command_set_nozzle_new(), command_set_pa_calibration(), Slic3r::DevPrintOptions::command_set_printing_option(), command_set_printing_option(), command_set_printing_speed(), Slic3r::DevPrintOptions::command_set_prompt_sound(), command_set_prompt_sound(), Slic3r::DevPrintOptions::command_set_purify_air_at_print_end(), command_set_save_remote_print_file_to_storage(), Slic3r::DevPrintOptions::command_set_snapshot_control(), Slic3r::DevPrintOptions::command_smart_nozzle_blob_detect_mode(), command_start_calibration(), command_start_extrusion_cali(), command_start_flow_ratio_calibration(), command_start_pa_calibration(), command_stop_buzzer(), command_task_abort(), command_task_cancel(), command_task_partskip(), command_task_pause(), command_task_resume(), command_upgrade_confirm(), command_upgrade_firmware(), command_upgrade_module(), Slic3r::DevPrintOptions::command_xcam_control(), command_xcam_control(), command_xyz_abs(), commnad_select_pa_calibration(), Slic3r::DevNozzleRack::CrtlRackReadNozzle(), Slic3r::DevAmsSystemFirmwareSwitch::CrtlSwitchFirmware(), Slic3r::DevAxis::Ctrl_Axis(), Slic3r::DevAxis::Ctrl_GoHome(), Slic3r::DevFilaSystem::CtrlAmsReset(), Slic3r::DevFilaSystem::CtrlAmsStartDryingHour(), Slic3r::DevFilaSystem::CtrlAmsStopDrying(), Slic3r::DevNozzleMappingCtrl::CtrlGetAutoNozzleMappingV0(), Slic3r::DevNozzleMappingCtrl::CtrlGetAutoNozzleMappingV1(), Slic3r::DevNozzleRack::CtrlRackConfirmAll(), Slic3r::DevNozzleRack::CtrlRackConfirmNozzle(), Slic3r::DevNozzleRack::CtrlRackPosGoHome(), Slic3r::DevNozzleRack::CtrlRackPosMove(), Slic3r::DevNozzleRack::CtrlRackReadAll(), Slic3r::DevNozzleRack::CtrlRackUpgrade(), Slic3r::DevChamber::CtrlSetChamberTemp(), Slic3r::DevUpgrade::CtrlUpgradeConfirm(), Slic3r::DevUpgrade::CtrlUpgradeConsistencyConfirm(), Slic3r::DevUpgrade::CtrlUpgradeFirmware(), Slic3r::DevUpgrade::CtrlUpgradeModule(), and publish_gcode().

m_set_ctt_dlg

bool Slic3r::MachineObject::m_set_ctt_dlg { false }

{ false };

Referenced by set_ctt_dlg().

m_status

DevStatus* Slic3r::MachineObject::m_status { nullptr }

private

{ nullptr };

Referenced by MachineObject(), ~MachineObject(), GetStatus(), and parse_json().

m_storage

DevStorage* Slic3r::MachineObject::m_storage

private

Referenced by MachineObject(), canEnableTimelapse(), GetStorage(), is_timelapse_storage_low(), parse_home_flag(), parse_json(), and parse_new_info().

m_support_mqtt_axis_control

bool Slic3r::MachineObject::m_support_mqtt_axis_control = false

Referenced by command_axis_control(), and parse_new_info().

m_support_mqtt_bet_ctrl

bool Slic3r::MachineObject::m_support_mqtt_bet_ctrl = false

Referenced by command_set_bed(), and parse_new_info().

m_support_mqtt_homing

bool Slic3r::MachineObject::m_support_mqtt_homing { false }

{ false };// fun[32]

Referenced by command_go_home(), and parse_new_info().

m_token

std::shared_ptr<int> Slic3r::MachineObject::m_token = std::make_shared<int>(1)

private

Referenced by add_command_error_code_dlg(), and update_model_task().

m_unsupported_dlg_shown

bool Slic3r::MachineObject::m_unsupported_dlg_shown { false }

{ false };

Referenced by show_unsupported_dlg().

m_upgrade

std::shared_ptr<DevUpgrade> Slic3r::MachineObject::m_upgrade

private

Referenced by MachineObject(), and GetUpgrade().

manual_pa_cali_method

ManualPaCaliMethod Slic3r::MachineObject::manual_pa_cali_method = ManualPaCaliMethod::PA_LINE

Referenced by Slic3r::GUI::PressureAdvanceWizard::on_device_connected().

mc_left_time

int Slic3r::MachineObject::mc_left_time

Referenced by MachineObject(), parse_json(), and Slic3r::GUI::CalibrationCaliPage::update_subtask().

mc_print_error_code

int Slic3r::MachineObject::mc_print_error_code

Referenced by MachineObject(), and parse_json().

mc_print_line_number

int Slic3r::MachineObject::mc_print_line_number

Referenced by MachineObject(), and parse_json().

mc_print_percent

int Slic3r::MachineObject::mc_print_percent

Referenced by MachineObject(), is_extrusion_cali_finished(), is_in_extrusion_cali(), and update_print_progress().

mc_print_stage

int Slic3r::MachineObject::mc_print_stage

Referenced by MachineObject(), parse_json(), and parse_state_changed_event().

mc_print_sub_stage

int Slic3r::MachineObject::mc_print_sub_stage

Referenced by MachineObject(), and parse_json().

message_delay

std::vector<std::tuple<std::string, uint64_t, uint64_t> > Slic3r::MachineObject::message_delay

private

Referenced by parse_json().

model_task

BBLModelTask* Slic3r::MachineObject::model_task { nullptr }

{ nullptr };

Referenced by MachineObject(), ~MachineObject(), get_modeltask(), is_makeworld_subtask(), set_modeltask(), and update_model_task().

module_vers

std::map<std::string, DevFirmwareVersionInfo> Slic3r::MachineObject::module_vers

Referenced by Slic3r::MoonrakerPrinterAgent::build_ams_payload(), check_version_valid(), clear_version_info(), get_ams_version(), get_ota_version(), is_info_ready(), is_support_command_calibration(), parse_version(), store_version_info(), Slic3r::GUI::MachineInfoPanel::update_ams_ext(), Slic3r::GUI::MachineInfoPanel::update_amshub(), Slic3r::GUI::AMSSetting::update_insert_material_read_mode(), and Slic3r::GUI::MachineInfoPanel::update_version_text().

network_wired

bool Slic3r::MachineObject::network_wired { false }

{ false };

Referenced by parse_json(), reset(), and Slic3r::GUI::SideTools::update_status().

new_ver_list

std::map<std::string, DevFirmwareVersionInfo> Slic3r::MachineObject::new_ver_list

Referenced by parse_json(), Slic3r::GUI::MachineInfoPanel::update_ams_ext(), and Slic3r::GUI::MachineInfoPanel::update_version_text().

nozzle_blob_detection_enabled

bool Slic3r::MachineObject::nozzle_blob_detection_enabled { false }

{ false };

Referenced by command_nozzle_blob_detect(), parse_home_flag(), parse_new_info(), and Slic3r::GUI::PrintOptionsDialog::update_options().

nozzle_blob_detection_hold_start

time_t Slic3r::MachineObject::nozzle_blob_detection_hold_start = 0

Referenced by command_nozzle_blob_detect(), parse_home_flag(), and parse_new_info().

nozzle_temp_range

std::vector<int> Slic3r::MachineObject::nozzle_temp_range

Referenced by parse_json().

obj_subtask_id

std::string Slic3r::MachineObject::obj_subtask_id

Referenced by is_sdcard_printing(), and parse_json().

online_ahb

bool Slic3r::MachineObject::online_ahb

Referenced by parse_json(), Slic3r::GUI::MachineInfoPanel::update_ams_ext(), and Slic3r::GUI::MachineInfoPanel::update_amshub().

online_rfid

bool Slic3r::MachineObject::online_rfid

Referenced by parse_json().

online_version

int Slic3r::MachineObject::online_version = -1

Referenced by parse_json().

ota_new_version_number

std::string Slic3r::MachineObject::ota_new_version_number

Referenced by parse_json(), and Slic3r::GUI::MachineInfoPanel::update_version_text().

pa_calib_results

std::vector<PACalibResult> Slic3r::MachineObject::pa_calib_results

Referenced by command_start_pa_calibration(), Slic3r::GUI::CalibUtils::get_PA_calib_results(), parse_json(), reset_pa_cali_result(), and Slic3r::GUI::CalibrationPASavePage::sync_cali_result().

pa_calib_tab

std::vector<PACalibResult> Slic3r::MachineObject::pa_calib_tab

Referenced by Slic3r::GUI::CalibUtils::get_PA_calib_tab(), Slic3r::GUI::CalibUtils::get_pa_k_n_value_by_cali_idx(), parse_json(), reset_pa_cali_history_result(), Slic3r::GUI::CalibrationPASavePage::sync_cali_result(), and Slic3r::GUI::HistoryWindow::sync_history_result().

parse_msg_count

int Slic3r::MachineObject::parse_msg_count = 0

Referenced by parse_json().

print_error

int Slic3r::MachineObject::print_error

Referenced by MachineObject(), command_clean_print_error(), command_clean_print_error_uiop(), parse_json(), and Slic3r::GUI::CalibrationCaliPage::update().

print_job_filament_mapping

std::vector<uint16_t> Slic3r::MachineObject::print_job_filament_mapping

Referenced by any_loaded_filament_is_stringing_prone(), and parse_new_info().

print_json

json_diff Slic3r::MachineObject::print_json

Referenced by parse_json(), reload_printer_settings(), and reset().

print_status

std::string Slic3r::MachineObject::print_status

Referenced by can_abort(), can_pause(), can_print(), can_resume(), is_calibration_running(), is_in_extrusion_cali(), is_in_prepare(), is_in_printing(), is_in_printing_pause(), is_printing_finished(), is_system_printing(), Slic3r::GUI::CalibrationWizard::on_device_connected(), parse_json(), Slic3r::GUI::PrintJob::process(), reset(), set_print_state(), Slic3r::GUI::MultiMachineManagerPage::sync_state(), Slic3r::GUI::CalibrationCaliPage::update(), and Slic3r::GUI::CalibrationCaliPage::update_subtask().

print_type

std::string Slic3r::MachineObject::print_type

Referenced by Slic3r::GUI::PrintingTaskPanel::enable_partskip_button(), is_in_extrusion_cali(), and parse_json().

printer_agent_id

std::string Slic3r::MachineObject::printer_agent_id

Referenced by connect(), has_access_right(), Slic3r::DeviceManager::insert_local_device(), Slic3r::DeviceManager::load_local_machines_from_config(), Slic3r::DeviceManager::on_machine_alive(), Slic3r::DeviceManager::parse_user_print_info(), Slic3r::GUI::GUI_App::select_machine(), Slic3r::anonymous_namespace{PluginHostApp.cpp}::selected_printer(), set_access_code(), Slic3r::DeviceManager::update_local_machine(), and Slic3r::GUI::SelectMachinePopup::update_other_devices().

printer_type

std::string Slic3r::MachineObject::printer_type

Referenced by Slic3r::GUI::EditCalibrationHistoryDialog::EditCalibrationHistoryDialog(), Slic3r::MoonrakerPrinterAgent::build_ams_payload(), Slic3r::GUI::CalibUtils::calib_generic_auto_pa_cali(), Slic3r::GUI::SelectMachineDialog::can_support_pa_auto_cali(), check_ams_filament_valid(), Slic3r::check_filaments_printable(), Slic3r::GUI::NewCalibrationHistoryDialog::get_all_filaments(), get_auto_pa_cali_thumbnail_img_str(), get_compatible_machine(), get_ftp_folder(), get_nozzle_replace_url(), get_printer_ams_type(), get_printer_arch(), Slic3r::GUI::CalibrationPresetPage::get_printer_preset(), get_printer_series(), get_printer_series_str(), get_printer_thumbnail_img_str(), get_printer_type_display_str(), get_show_printer_type(), Slic3r::GUI::FanControlPopupNew::init_names(), Slic3r::DeviceManager::insert_local_device(), Slic3r::DevPrinterConfigUtil::is_printer_model_compatible(), Slic3r::GUI::Plater::is_same_printer_for_connected_and_selected(), Slic3r::GUI::SelectMachineDialog::is_same_printer_model(), Slic3r::GUI::SyncAmsInfoDialog::is_same_printer_model(), is_series_n(), is_series_o(), is_series_p(), is_series_x(), Slic3r::DeviceManager::load_local_machines_from_config(), Slic3r::GUI::SelectMachineDialog::load_option_vals(), Slic3r::GUI::CalibrationWizard::on_device_connected(), Slic3r::GUI::HistoryWindow::on_device_connected(), Slic3r::DeviceManager::on_machine_alive(), Slic3r::GUI::SelectMachineDialog::on_ok_btn(), parse_json(), parse_new_info(), Slic3r::DeviceManager::parse_user_print_info(), Slic3r::GUI::CalibUtils::process_and_store_3mf(), Slic3r::GUI::SelectMachineDialog::save_option_vals(), Slic3r::GUI::sCheckFilamentInfo(), Slic3r::anonymous_namespace{PluginHostApp.cpp}::selected_printer(), Slic3r::GUI::MediaPlayCtrl::SetMachineObject(), Slic3r::GUI::Sidebar::priv::sync_extruder_list(), Slic3r::GUI::CalibrationCaliPage::update(), Slic3r::GUI::AMSSetting::update_ams_img(), Slic3r::GUI::AMSDryCtrWin::update_filament_list(), Slic3r::GUI::AMSSetting::update_insert_material_read_mode(), Slic3r::DeviceManager::update_local_machine(), Slic3r::GUI::AmsReplaceMaterialDialog::update_machine_obj(), update_printer_preset_name(), Slic3r::GUI::CalibrationPresetPage::update_show_status(), Slic3r::GUI::SelectMachineDialog::update_show_status(), Slic3r::GUI::SyncAmsInfoDialog::update_show_status(), Slic3r::GUI::Sidebar::priv::update_sync_status(), Slic3r::GUI::AmsMapingPopup::update_title(), and Slic3r::GUI::SelectMachineDialog::UpdateStatusCheckWarning_ExtensionTool().

printing_speed_mag

int Slic3r::MachineObject::printing_speed_mag = 100

Referenced by parse_json(), and reset().

profile_id_

std::string Slic3r::MachineObject::profile_id_

Referenced by is_sdcard_printing(), and update_slice_info().

project_id_

std::string Slic3r::MachineObject::project_id_

Referenced by is_sdcard_printing(), and update_slice_info().

queue_number

int Slic3r::MachineObject::queue_number = 0

Referenced by parse_json(), and Slic3r::GUI::CalibrationCaliPage::update_subtask().

rating_info

DevPrintTaskRatingInfo* Slic3r::MachineObject::rating_info { nullptr }

{ nullptr };

Referenced by update_model_task().

request_model_result

int Slic3r::MachineObject::request_model_result = 0

Referenced by update_model_task().

request_tab_from_bbs

bool Slic3r::MachineObject::request_tab_from_bbs { false }

{ false };

Referenced by command_get_pa_calibration_tab(), and parse_json().

rotary_version_info

DevFirmwareVersionInfo Slic3r::MachineObject::rotary_version_info

Referenced by clear_version_info(), store_version_info(), and Slic3r::GUI::MachineInfoPanel::update_rotary().

selected_cali_preset

std::vector<CaliPresetInfo> Slic3r::MachineObject::selected_cali_preset

Referenced by Slic3r::GUI::CalibrationWizard::back_preset_info(), Slic3r::GUI::CalibrationWizard::cache_preset_info(), Slic3r::GUI::get_cached_selected_filament(), Slic3r::GUI::get_cached_selected_filament_for_multi_extruder(), Slic3r::GUI::CalibrationWizard::on_device_connected(), and Slic3r::GUI::CalibrationWizard::recover_preset_info().

slice_info

BBLSliceInfo* Slic3r::MachineObject::slice_info {nullptr}

{nullptr};

Referenced by MachineObject(), free_slice_info(), update_slice_info(), and Slic3r::GUI::CalibrationCaliPage::update_subtask().

stage_curr

int Slic3r::MachineObject::stage_curr = 0

Referenced by Slic3r::GUI::PrintingTaskPanel::create_panel(), get_curr_stage(), get_curr_stage_idx(), is_in_calibration(), Slic3r::GUI::PrintingTaskPanel::on_stage_clicked(), Slic3r::GUI::ThermalPreconditioningDialog::on_timer(), parse_json(), and Slic3r::GUI::PrintingTaskPanel::update_stage_value_with_machine().

stage_list_info

std::vector<int> Slic3r::MachineObject::stage_list_info

Referenced by get_curr_stage(), get_curr_stage_idx(), Slic3r::GUI::CalibrationDialog::is_stage_list_info_changed(), parse_json(), and Slic3r::GUI::CalibrationDialog::update_cali().

stage_remaining_seconds

int Slic3r::MachineObject::stage_remaining_seconds = 0

Referenced by get_stage_remaining_seconds(), and parse_json().

subscribe_counter

int Slic3r::MachineObject::subscribe_counter {3}

{3};

Referenced by Slic3r::GUI::GUI_App::on_start_subscribe_again(), reset(), and reset_update_time().

subtask_

BBLSubTask* Slic3r::MachineObject::subtask_

Referenced by MachineObject(), ~MachineObject(), get_subtask(), reset(), update_model_task(), and Slic3r::GUI::CalibrationCaliPage::update_subtask().

subtask_id_

std::string Slic3r::MachineObject::subtask_id_

Referenced by update_model_task(), and update_slice_info().

subtask_name

std::string Slic3r::MachineObject::subtask_name

Referenced by Slic3r::GUI::PrintingTaskPanel::enable_partskip_button(), Slic3r::GUI::get_obj_calibration_mode(), Slic3r::GUI::CalibrationWizard::on_device_connected(), parse_json(), Slic3r::GUI::CalibrationCaliPage::update(), and Slic3r::GUI::CalibrationCaliPage::update_subtask().

targ_nozzle_id_from_pc

int Slic3r::MachineObject::targ_nozzle_id_from_pc = INVALID_EXTRUDER_ID

Referenced by Slic3r::ExtderSystemParser::ParseV2_0().

task_id_

std::string Slic3r::MachineObject::task_id_

Referenced by parse_json().

timelapse_storage_check_done

std::atomic<bool> Slic3r::MachineObject::timelapse_storage_check_done { false }

{ false };

Referenced by Slic3r::GUI::SelectMachineDialog::on_timelapse_storage_check_timer(), parse_json(), and Slic3r::GUI::SelectMachineDialog::start_timelapse_storage_check().

timelapse_storage_check_result

int Slic3r::MachineObject::timelapse_storage_check_result { -1 }

{ -1 };

Referenced by Slic3r::GUI::SelectMachineDialog::on_timelapse_storage_check_result(), parse_json(), and Slic3r::GUI::SelectMachineDialog::start_timelapse_storage_check().

timelapse_storage_file_count

int Slic3r::MachineObject::timelapse_storage_file_count { 0 }

{ 0 };

Referenced by parse_json(), and Slic3r::GUI::SelectMachineDialog::show_timelapse_storage_dialog().

timelapse_storage_is_enough

bool Slic3r::MachineObject::timelapse_storage_is_enough { true }

{ true };

Referenced by Slic3r::GUI::SelectMachineDialog::on_timelapse_storage_check_result(), and parse_json().

total_layers

int Slic3r::MachineObject::total_layers = 0

Referenced by parse_json(), and Slic3r::GUI::CalibrationCaliPage::update_subtask().

tray_exist_bits

long Slic3r::MachineObject::tray_exist_bits = 0

Referenced by MachineObject(), and Slic3r::DevFilaSystemParser::ParseV1_0().

tray_is_bbl_bits

long Slic3r::MachineObject::tray_is_bbl_bits = 0

Referenced by MachineObject(), and Slic3r::DevFilaSystemParser::ParseV1_0().

tray_read_done_bits

long Slic3r::MachineObject::tray_read_done_bits = 0

Referenced by Slic3r::DevFilaSystemParser::ParseV1_0().

tray_reading_bits

long Slic3r::MachineObject::tray_reading_bits = 0

Referenced by Slic3r::DevFilaSystemParser::ParseV1_0().

tutk_state

std::string Slic3r::MachineObject::tutk_state

Referenced by parse_json(), parse_new_info(), and Slic3r::GUI::MediaPlayCtrl::SetMachineObject().

upgrade_consistency_request

bool Slic3r::MachineObject::upgrade_consistency_request { false }

{ false };

Referenced by MachineObject(), parse_json(), Slic3r::GUI::CalibrationPresetPage::update_show_status(), Slic3r::GUI::SelectMachineDialog::update_show_status(), and Slic3r::GUI::SyncAmsInfoDialog::update_show_status().

upgrade_display_hold_count

int Slic3r::MachineObject::upgrade_display_hold_count = 0

Referenced by Slic3r::GUI::MachineInfoPanel::confirm_upgrade(), and parse_json().

upgrade_display_state

DevFirmwareUpgradingState Slic3r::MachineObject::upgrade_display_state

Referenced by Slic3r::GUI::MachineInfoPanel::confirm_upgrade(), is_in_upgrading(), is_upgrading_avalable(), parse_json(), Slic3r::GUI::MachineInfoPanel::update(), and Slic3r::GUI::MachineInfoPanel::update_version_text().

upgrade_err_code

int Slic3r::MachineObject::upgrade_err_code = 0

Referenced by parse_json(), and Slic3r::GUI::MachineInfoPanel::update().

upgrade_force_upgrade

bool Slic3r::MachineObject::upgrade_force_upgrade { false }

{ false };

Referenced by MachineObject(), parse_json(), parse_new_info(), Slic3r::GUI::CalibrationPresetPage::update_show_status(), Slic3r::GUI::SelectMachineDialog::update_show_status(), and Slic3r::GUI::SyncAmsInfoDialog::update_show_status().

upgrade_message

std::string Slic3r::MachineObject::upgrade_message

Referenced by parse_json().

upgrade_module

std::string Slic3r::MachineObject::upgrade_module

Referenced by parse_json().

upgrade_new_version

bool Slic3r::MachineObject::upgrade_new_version { false }

{ false };

Referenced by MachineObject(), parse_json(), Slic3r::GUI::MachineInfoPanel::update_ams_ext(), and Slic3r::GUI::MachineInfoPanel::update_version_text().

upgrade_progress

std::string Slic3r::MachineObject::upgrade_progress

Referenced by get_upgrade_percent(), and parse_json().

upgrade_status

std::string Slic3r::MachineObject::upgrade_status

Referenced by parse_json(), and Slic3r::GUI::MachineInfoPanel::update().

virtual_camera

bool Slic3r::MachineObject::virtual_camera {false}

{false};

Referenced by parse_json().

vt_slot

std::vector<DevAmsTray> Slic3r::MachineObject::vt_slot

Virtual Tray (vt_slot) - External/manual filament loading slots.

Data Flow: Populated from printer JSON via parse_vt_tray() during MachineObject::parse_json(). Used by: Sidebar::build_filament_ams_list() when ams_support_virtual_tray is true.

Virtual trays represent filament that is manually loaded into the extruder rather than fed through an AMS unit. This supports printers without AMS or scenarios where users want to bypass the AMS.

Referenced by MachineObject(), Slic3r::DevMappingUtil::ams_filament_mapping(), Slic3r::GUI::Sidebar::build_filament_ams_list(), check_ams_filament_valid(), contains_tray(), Slic3r::DevCalib::ExtrusionCalibSelectParse(), Slic3r::DevCalib::ExtrusionCalibSetParse(), get_curr_tray(), get_tray(), parse_json(), Slic3r::DevFilaSystemParser::ParseAgentFilament(), reset(), Slic3r::GUI::CalibrationPresetPage::sync_ams_info(), and Slic3r::GUI::AmsMapingPopup::update_mapping_items().

webcam_stream_url

std::string Slic3r::MachineObject::webcam_stream_url

Referenced by parse_json().

wifi_signal

std::string Slic3r::MachineObject::wifi_signal

Referenced by MachineObject(), Slic3r::DeviceManager::on_machine_alive(), parse_json(), and Slic3r::GUI::SideTools::update_status().

xcam__save_remote_print_file_to_storage

bool Slic3r::MachineObject::xcam__save_remote_print_file_to_storage = false

private

Referenced by command_set_save_remote_print_file_to_storage(), get_save_remote_print_file_to_storage(), and parse_new_info().

xcam__save_remote_print_file_to_storage_start_time

time_t Slic3r::MachineObject::xcam__save_remote_print_file_to_storage_start_time = 0

private

Referenced by command_set_save_remote_print_file_to_storage(), and parse_new_info().

xcam_ai_monitoring

bool Slic3r::MachineObject::xcam_ai_monitoring { false }

{ false };

Referenced by command_xcam_control_ai_monitoring(), parse_json(), parse_new_info(), and Slic3r::GUI::PrintOptionsDialog::update_options().

xcam_ai_monitoring_hold_start

time_t Slic3r::MachineObject::xcam_ai_monitoring_hold_start = 0

Referenced by command_xcam_control_ai_monitoring(), command_xcam_control_airprinting_detection(), command_xcam_control_nozzleclumping_detection(), command_xcam_control_purgechutepileup_detection(), command_xcam_control_spaghetti_detection(), parse_json(), and parse_new_info().

xcam_ai_monitoring_sensitivity

std::string Slic3r::MachineObject::xcam_ai_monitoring_sensitivity

Referenced by command_xcam_control_ai_monitoring(), parse_json(), parse_new_info(), and Slic3r::GUI::PrintOptionsDialog::update_options().

xcam_airprinting_detection

bool Slic3r::MachineObject::xcam_airprinting_detection {false}

{false};

Referenced by command_xcam_control_airprinting_detection(), parse_json(), and Slic3r::GUI::PrintOptionsDialog::update_options().

xcam_airprinting_detection_sensitivity

std::string Slic3r::MachineObject::xcam_airprinting_detection_sensitivity

Referenced by command_xcam_control_airprinting_detection(), parse_json(), and Slic3r::GUI::PrintOptionsDialog::update_options().

xcam_allow_prompt_sound

bool Slic3r::MachineObject::xcam_allow_prompt_sound { false }

{ false };

Referenced by command_xcam_control_allow_prompt_sound(), parse_home_flag(), parse_new_info(), and Slic3r::GUI::PrintOptionsDialog::update_options().

xcam_auto_recovery_hold_start

time_t Slic3r::MachineObject::xcam_auto_recovery_hold_start = 0

Referenced by command_xcam_control_auto_recovery_step_loss(), parse_home_flag(), parse_json(), and parse_new_info().

xcam_auto_recovery_step_loss

bool Slic3r::MachineObject::xcam_auto_recovery_step_loss { false }

{ false };

Referenced by command_xcam_control_auto_recovery_step_loss(), parse_home_flag(), parse_json(), parse_new_info(), and Slic3r::GUI::PrintOptionsDialog::update_options().

xcam_buildplate_marker_detector

bool Slic3r::MachineObject::xcam_buildplate_marker_detector { false }

{ false };

Referenced by command_xcam_control_buildplate_marker_detector(), parse_json(), and Slic3r::GUI::PrintOptionsDialog::update_options().

xcam_buildplate_marker_hold_start

time_t Slic3r::MachineObject::xcam_buildplate_marker_hold_start = 0

Referenced by command_xcam_control_buildplate_marker_detector(), and parse_json().

xcam_disable_ai_detection_display

bool Slic3r::MachineObject::xcam_disable_ai_detection_display {false}

{false};

Referenced by parse_json(), and Slic3r::GUI::PrintOptionsDialog::update_options().

xcam_door_open_check

DoorOpenCheckState Slic3r::MachineObject::xcam_door_open_check = DoorOpenCheckState::DOOR_OPEN_CHECK_DISABLE

private

Referenced by command_set_door_open_check(), get_door_open_check_state(), and parse_new_info().

xcam_door_open_check_start_time

time_t Slic3r::MachineObject::xcam_door_open_check_start_time = 0

private

Referenced by command_set_door_open_check(), and parse_new_info().

xcam_filament_tangle_detect

bool Slic3r::MachineObject::xcam_filament_tangle_detect { false }

{ false };

Referenced by command_xcam_control_filament_tangle_detect(), parse_home_flag(), parse_new_info(), and Slic3r::GUI::PrintOptionsDialog::update_options().

xcam_filament_tangle_detect_hold_start

time_t Slic3r::MachineObject::xcam_filament_tangle_detect_hold_start = 0

Referenced by command_xcam_control_filament_tangle_detect(), parse_home_flag(), and parse_new_info().

xcam_first_layer_hold_start

time_t Slic3r::MachineObject::xcam_first_layer_hold_start = 0

Referenced by command_xcam_control_first_layer_inspector(), parse_json(), and parse_new_info().

xcam_first_layer_inspector

bool Slic3r::MachineObject::xcam_first_layer_inspector { false }

{ false };

Referenced by command_xcam_control_first_layer_inspector(), parse_json(), parse_new_info(), and Slic3r::GUI::PrintOptionsDialog::update_options().

xcam_nozzleclumping_detection

bool Slic3r::MachineObject::xcam_nozzleclumping_detection {false}

{false};

Referenced by command_xcam_control_nozzleclumping_detection(), parse_json(), and Slic3r::GUI::PrintOptionsDialog::update_options().

xcam_nozzleclumping_detection_sensitivity

std::string Slic3r::MachineObject::xcam_nozzleclumping_detection_sensitivity

Referenced by command_xcam_control_nozzleclumping_detection(), parse_json(), and Slic3r::GUI::PrintOptionsDialog::update_options().

xcam_prompt_sound_hold_start

time_t Slic3r::MachineObject::xcam_prompt_sound_hold_start = 0

Referenced by command_xcam_control_allow_prompt_sound(), parse_home_flag(), and parse_new_info().

xcam_purgechutepileup_detection

bool Slic3r::MachineObject::xcam_purgechutepileup_detection {false}

{false};

Referenced by command_xcam_control_purgechutepileup_detection(), parse_json(), and Slic3r::GUI::PrintOptionsDialog::update_options().

xcam_purgechutepileup_detection_sensitivity

std::string Slic3r::MachineObject::xcam_purgechutepileup_detection_sensitivity

Referenced by command_xcam_control_purgechutepileup_detection(), parse_json(), and Slic3r::GUI::PrintOptionsDialog::update_options().

xcam_spaghetti_detection

bool Slic3r::MachineObject::xcam_spaghetti_detection {false}

{false};

Referenced by command_xcam_control_spaghetti_detection(), parse_json(), and Slic3r::GUI::PrintOptionsDialog::update_options().

xcam_spaghetti_detection_sensitivity

std::string Slic3r::MachineObject::xcam_spaghetti_detection_sensitivity

Referenced by command_xcam_control_spaghetti_detection(), parse_json(), and Slic3r::GUI::PrintOptionsDialog::update_options().

---

The documentation for this class was generated from the following files:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/DeviceManager.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/DeviceCore/DevMappingNozzle.cpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/DeviceManager.cpp