Slic3r::GUI::GUI_App Class Reference

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

Inheritance diagram for Slic3r::GUI::GUI_App:

Collaboration diagram for Slic3r::GUI::GUI_App:

Public Types
enum class	EAppMode : unsigned char { Editor , GCodeViewer }

Public Member Functions
void	on_start_subscribe_again (std::string dev_id)
void	reset_unsigned_plugin_warning ()
std::string	get_local_models_path ()
bool	OnInit () override
int	OnExit () override
void	CleanUp () override
bool	initialized () const
bool	is_enable_multi_machine ()
	GUI_App ()
	~GUI_App () override
void	show_message_box (std::string msg)
EAppMode	get_app_mode () const
Slic3r::DeviceManager *	getDeviceManager ()
bool	is_blocking_printing (MachineObject *obj_=nullptr)
bool	is_blocking_printing (MachineObject *obj_, const std::string &source_model)
Slic3r::TaskManager *	getTaskManager ()
HMSQuery *	get_hms_query ()
NetworkAgent *	getAgent ()
const boost::optional< Semver > &	last_config_version () const
void	switch_printer_agent ()
void	switch_printer_agent_if_pending ()
std::string	resolve_printer_agent_id (const std::string &stored_id) const
std::string	canonical_printer_agent_id (const std::string &picked_id)
FilamentColorCodeQuery *	get_filament_color_code_query ()
bool	is_editor () const
bool	is_gcode_viewer () const
bool	is_recreating_gui () const
int	input_idle_ms () const
int	FilterEvent (wxEvent &event) override
bool	starts_on_prepare () const
std::string	logo_name () const
bool	is_closing () const
void	set_closing (bool closing)
void	start_exit_watchdog ()
bool	show_gcode_window () const
void	toggle_show_gcode_window ()
bool	show_3d_navigator () const
void	toggle_show_3d_navigator () const
bool	show_plate_gridlines () const
void	toggle_show_plate_gridlines () const
bool	focus_mode () const
void	toggle_focus_mode () const
bool	show_canvas_zoom_button () const
void	toggle_canvas_zoom_button () const
bool	show_outline () const
void	toggle_show_outline () const
bool	show_center_of_mass () const
void	toggle_show_center_of_mass () const
wxString	get_inf_dialog_contect ()
std::vector< std::string >	split_str (std::string src, std::string separator)
void	post_init ()
void	shutdown ()
wxGLContext *	init_glcontext (wxGLCanvas &canvas)
bool	init_opengl ()
void	init_download_path ()
void	open_orca_cloud (const std::string &next=std::string())
const wxColour	get_label_default_clr_system ()
const wxColour	get_label_default_clr_modified ()
void	init_label_colours ()
void	update_label_colours_from_appconfig ()
void	update_publish_status ()
bool	has_model_mall ()
void	update_label_colours ()
void	UpdateDarkUI (wxWindow *window, bool highlited=false, bool just_font=false)
void	UpdateDarkUIWin (wxWindow *win)
void	Update_dark_mode_flag ()
void	UpdateDlgDarkUI (wxDialog *dlg)
void	UpdateFrameDarkUI (wxFrame *dlg)
void	UpdateDVCDarkUI (wxDataViewCtrl *dvc, bool highlited=false)
void	UpdateAllStaticTextDarkUI (wxWindow *parent)
void	init_fonts ()
void	update_fonts (const MainFrame *main_frame=nullptr)
void	set_label_clr_modified (const wxColour &clr)
void	set_label_clr_sys (const wxColour &clr)
bool	get_side_menu_popup_status ()
void	set_side_menu_popup_status (bool status)
std::string	link_to_network_check ()
std::string	link_to_lan_only_wiki ()
const wxColour &	get_label_clr_modified ()
const wxColour &	get_label_clr_sys ()
const wxColour &	get_label_clr_default ()
const wxColour &	get_window_default_clr ()
const wxColour &	get_label_highlight_clr ()
const wxColour &	get_highlight_default_clr ()
const wxColour &	get_color_hovered_btn_label ()
const wxColour &	get_color_selected_btn_bg ()
void	force_colors_update ()
void	force_menu_update ()
const wxFont &	small_font ()
const wxFont &	bold_font ()
const wxFont &	normal_font ()
const wxFont &	code_font ()
const wxFont &	link_font ()
int	em_unit () const
bool	tabs_as_menu () const
wxSize	get_min_size () const
float	toolbar_icon_scale (const bool is_limited=false) const
void	set_auto_toolbar_icon_scale (float scale) const
void	check_printer_presets ()
void	recreate_GUI (const wxString &message)
void	keyboard_shortcuts (ShortcutContext page, wxWindow *parent=nullptr)
void	troubleshoot ()
void	load_project (wxWindow *parent, wxString &input_file) const
void	import_model (wxWindow *parent, wxArrayString &input_files) const
void	import_zip (wxWindow *parent, wxString &input_file) const
void	load_gcode (wxWindow *parent, wxString &input_file) const
wxString	transition_tridid (int trid_id) const
void	ShowUserGuide ()
void	ShowDownNetPluginDlg ()
void	ShowUserLogin (bool show=true, const std::string &provider=ORCA_CLOUD_PROVIDER)
void	ShowOnlyFilament ()
void	request_login (bool show_user_info=false, const std::string &provider=ORCA_CLOUD_PROVIDER)
bool	check_login (const std::string &provider=ORCA_CLOUD_PROVIDER)
void	get_login_info (const std::string &provider=ORCA_CLOUD_PROVIDER)
bool	is_user_login (const std::string &provider=ORCA_CLOUD_PROVIDER)
std::string	get_printer_cloud_provider () const
void	request_user_login (int online_login=0, const std::string &provider=ORCA_CLOUD_PROVIDER)
void	request_user_handle (int online_login=0, const std::string &provider=ORCA_CLOUD_PROVIDER)
void	request_user_logout (const std::string &provider=ORCA_CLOUD_PROVIDER, bool user_initiated=false)
void	post_logout_to_webview (const std::string &provider)
int	request_user_unbind (std::string dev_id, const std::string &provider=ORCA_CLOUD_PROVIDER)
std::string	handle_web_request (std::string cmd)
void	handle_script_message (std::string msg, const std::string &provider=ORCA_CLOUD_PROVIDER)
void	request_model_download (wxString url)
void	download_project (std::string project_id)
void	request_project_download (std::string project_id)
void	request_open_project (std::string project_id)
void	request_remove_project (std::string project_id)
void	handle_http_error (unsigned int status, std::string body, const std::string &provider="")
void	on_http_error (wxCommandEvent &evt)
void	on_update_machine_list (wxCommandEvent &evt)
void	on_user_login (wxCommandEvent &evt)
void	on_user_login_handle (wxCommandEvent &evt)
wxString	cloud_webview_handoff (const std::string &next=std::string())
void	request_cloud_web_session (const std::string &state)
void	mint_cloud_web_session (const std::string &state, uint64_t gen)
void	on_cloud_web_session_minted (const std::string &state, uint64_t gen, const std::string &token_hash)
void	enable_user_preset_folder (bool enable)
bool	is_studio_active ()
void	reset_to_active ()
void	check_update (bool show_tips, int by_user)
void	check_new_version (bool show_tips=false, int by_user=0)
void	check_new_version_sf (bool show_tips=false, int by_user=0)
void	check_legacy_user_filament_presets (bool by_user)
bool	process_network_msg (std::string dev_id, std::string msg)
void	request_new_version (int by_user)
void	enter_force_upgrade ()
void	set_skip_version (bool skip=true)
void	no_new_version ()
std::string	format_IP (const std::string &ip)
void	show_dialog (wxString msg)
void	push_notification (const MachineObject *obj, wxString msg, wxString title=wxEmptyString, UserNotificationStyle style=UserNotificationStyle::UNS_NORMAL)
bool	reload_settings ()
void	remove_user_presets ()
bool	maybe_migrate_user_presets_on_login ()
bool	check_preset_parent_available (const std::pair< std::string, std::map< std::string, std::string > > &preset_data)
void	add_pending_vendor_preset (const std::pair< std::string, std::map< std::string, std::string > > &preset_data)
void	load_pending_vendors ()
void	sync_preset (Preset *preset, bool force=false)
void	start_sync_user_preset (bool with_progress_dlg=false)
void	stop_sync_user_preset ()
void	restart_sync_user_preset ()
void	force_push_conflicting_preset (const std::string &setting_id)
void	on_stealth_mode_enter ()
void	check_bundle_updates ()
int	sync_bundle (std::string bundle_id, std::string version)
bool	unsubscribe_bundle (const std::string &id)
void	update_single_bundle (wxCommandEvent &evt)
void	start_http_server (const std::string &provider=ORCA_CLOUD_PROVIDER)
void	start_http_server (int port, const std::string &provider=ORCA_CLOUD_PROVIDER)
void	stop_http_server ()
void	on_show_check_privacy_dlg (int online_login=0, const std::string &provider=ORCA_CLOUD_PROVIDER)
void	show_check_privacy_dlg (wxCommandEvent &evt)
void	on_check_privacy_update (wxCommandEvent &evt)
bool	check_privacy_update ()
void	check_privacy_version (int online_login=0, const std::string &provider=ORCA_CLOUD_PROVIDER)
void	check_track_enable ()
void	persist_window_geometry (wxTopLevelWindow *window, bool default_maximized=false)
void	update_ui_from_settings ()
bool	load_language (wxString language, bool initial)
Tab *	get_tab (Preset::Type type)
Tab *	get_plate_tab ()
Tab *	get_model_tab (bool part=false)
Tab *	get_layer_tab ()
ConfigOptionMode	get_saved_mode ()
ConfigOptionMode	get_mode ()
std::string	get_saved_mode_str ()
std::string	get_mode_str ()
void	save_mode (const int mode)
void	set_mode (ConfigOptionMode mode)
void	enable_developer_mode ()
void	update_mode ()
void	update_internal_development ()
void	show_ip_address_enter_dialog (wxString title=wxEmptyString)
void	show_ip_address_enter_dialog_handler (wxCommandEvent &evt)
bool	show_modal_ip_address_enter_dialog (bool input_sn, wxString title=wxEmptyString)
bool	has_unsaved_preset_changes () const
bool	has_current_preset_changes () const
void	update_saved_preset_from_current_preset ()
std::vector< std::pair< unsigned int, std::string > >	get_selected_presets () const
bool	check_and_save_current_preset_changes (const wxString &caption, const wxString &header, bool remember_choice=true, bool use_dont_save_insted_of_discard=false)
void	apply_keeped_preset_modifications ()
bool	check_and_keep_current_preset_changes (const wxString &caption, const wxString &header, int action_buttons, bool *postponed_apply_of_keeped_changes=nullptr)
bool	can_load_project ()
bool	check_print_host_queue ()
bool	checked_tab (Tab *tab)
void	load_current_presets (bool active_preset_combox=false, bool check_printer_presets=true)
std::map< std::string, std::string > &	get_delete_cache_presets ()
std::map< std::string, std::string >	get_delete_cache_presets_lock ()
void	process_delete_presets ()
void	delete_preset_from_cloud (std::string setting_id, std::string preset_file_path)
void	preset_deleted_from_cloud (std::string setting_id)
void	scan_orphaned_info_files ()
wxString	filter_string (wxString str)
wxString	current_language_code () const
wxString	current_language_code_safe () const
bool	is_localized () const
void	open_preferences ()
void	open_preferences (PreferencesTab tab, const std::string &highlight_option=std::string())
void	open_presetbundledialog (size_t open_on_tab=0, const std::string &highlight_option=std::string())
void	open_plugins_dialog (size_t open_on_tab=0, const std::string &highlight_option=std::string())
void	refresh_plugins ()
void	install_local_plugin ()
void	open_terminal_dialog ()
void	open_speed_dial ()
ActionRegistry &	action_registry ()
void	open_exportpresetbundledialog (size_t open_on_tab=0, const std::string &highlight_option=std::string())
virtual bool	OnExceptionInMainLoop () override
bool	open_browser_with_warning_dialog (const wxString &url, int flags=0)
Sidebar &	sidebar ()
GizmoObjectManipulation *	obj_manipul ()
ObjectSettings *	obj_settings ()
ObjectList *	obj_list ()
ObjectLayers *	obj_layers ()
Plater *	plater ()
const Plater *	plater () const
ParamsPanel *	params_panel ()
ParamsDialog *	params_dialog ()
Model &	model ()
NotificationManager *	notification_manager ()
Downloader *	downloader ()
void	set_download_model_url (std::string url)
void	set_download_model_name (std::string name)
std::string	get_download_model_url ()
std::string	get_download_model_name ()
void	load_url (wxString url)
void	open_mall_page_dialog ()
void	open_publish_page_dialog ()
void	remove_mall_system_dialog ()
void	run_script (wxString js)
bool	is_adding_script_handler ()
void	set_adding_script_handler (bool status)
char	from_hex (char ch)
std::string	url_encode (std::string value)
std::string	url_decode (std::string value)
void	popup_ping_bind_dialog ()
void	remove_ping_bind_dialog ()
PresetUpdater *	get_preset_updater ()
Notebook *	tab_panel () const
int	extruders_cnt () const
int	extruders_edited_cnt () const
int	filaments_cnt () const
PrintSequence	global_print_sequence () const
RemovableDriveManager *	removable_drive_manager ()
OtherInstanceMessageHandler *	other_instance_message_handler ()
wxSingleInstanceChecker *	single_instance_checker ()
void	init_single_instance_checker (const std::string &name, const std::string &path)
void	set_instance_hash (const size_t hash)
std::string	get_instance_hash_string ()
size_t	get_instance_hash_int ()
ImGuiWrapper *	imgui ()
ShortcutRegistry &	shortcuts ()
void	on_shortcuts_changed ()
PrintHostJobQueue &	printhost_job_queue ()
void	open_web_page_localized (const std::string &http_address)
bool	may_switch_to_SLA_preset (const wxString &caption)
bool	run_wizard (ConfigWizard::RunReason reason, ConfigWizard::StartPage start_page=ConfigWizard::SP_WELCOME)
void	show_desktop_integration_dialog ()
OpenGLManager &	get_opengl_manager ()
GLShaderProgram *	get_shader (const std::string &shader_name)
GLShaderProgram *	get_current_shader ()
bool	is_gl_version_greater_or_equal_to (unsigned int major, unsigned int minor) const
bool	is_glsl_version_greater_or_equal_to (unsigned int major, unsigned int minor) const
int	GetSingleChoiceIndex (const wxString &message, const wxString &caption, const wxArrayString &choices, int initialSelection)
void	associate_files (std::wstring extend)
void	disassociate_files (std::wstring extend)
bool	check_url_association (std::wstring url_prefix, std::wstring &reg_bin)
void	associate_url (std::wstring url_prefix)
void	disassociate_url (std::wstring url_prefix)
void	start_download (std::string url)
std::string	get_plugin_url (std::string name, std::string country_code)
int	download_plugin (std::string name, std::string package_name, InstallProgressFn pro_fn=nullptr, WasCancelledFn cancel_fn=nullptr)
int	install_plugin (std::string name, std::string package_name, InstallProgressFn pro_fn=nullptr, WasCancelledFn cancel_fn=nullptr)
std::string	get_http_url (std::string country_code, std::string path={})
std::string	get_model_http_url (std::string country_code)
bool	use_legacy_network_plugin () const
bool	is_compatibility_version ()
bool	check_networking_version ()
void	cancel_networking_install ()
void	restart_networking ()
void	check_config_updates_from_updater ()
void	show_network_plugin_download_dialog (bool is_update=false)
void	migrate_network_plugin_config ()
bool	hot_reload_network_plugin ()
bool	install_network_plugin_from_ota (bool &had_cache)
std::string	get_latest_network_version () const
bool	has_network_update_available () const
std::string	get_bbl_client_version ()

Static Public Member Functions
static std::string	get_gl_info (bool for_github)
static unsigned	get_colour_approx_luma (const wxColour &colour)
static bool	dark_mode ()
static std::string	format_display_version ()
static bool	catch_error (std::function< void()> cb, const std::string &err)
static std::string	extract_setting_id_from_info (const std::string &info_file_path)

Public Attributes
std::map< std::string, bool >	test_url_state
bool	m_studio_active = true
std::chrono::system_clock::time_point	last_active_point
PresetBundleDialog *	m_preset_bundle_dlg {nullptr}
PluginsDialog *	m_plugins_dlg {nullptr}
SpeedDialWebDialog *	m_speed_dial_dialog {nullptr}
TerminalDialog *	m_terminal_dlg {nullptr}
ActionRegistry	m_action_registry
std::string	m_mall_model_download_url
std::string	m_mall_model_download_name
ModelMallDialog *	m_mall_publish_dialog { nullptr }
PingCodeBindDialog *	m_ping_code_binding_dialog { nullptr }
NetworkErrorDialog *	m_server_error_dialog { nullptr }
GUI_InitParams *	init_params { nullptr }
AppConfig *	app_config { nullptr }
PresetBundle *	preset_bundle { nullptr }
PresetUpdater *	preset_updater { nullptr }
MainFrame *	mainframe { nullptr }
Plater *	plater_ { nullptr }
std::vector< Tab * >	tabs_list
std::vector< Tab * >	model_tabs_list
Tab *	plate_tab

Private Member Functions
int	updating_bambu_networking ()
bool	on_init_inner ()
void	copy_network_if_available ()
bool	on_init_network (bool try_backup=false)
void	init_networking_callbacks ()
void	init_app_config ()
void	init_plugin_gui_wiring ()
void	remove_old_networking_plugins ()
void	drain_pending_events (int timeout_ms)
bool	wait_for_network_idle (int timeout_ms)
bool	check_older_app_config (Semver current_version, bool backup)
void	copy_older_config ()
void	window_pos_save (wxTopLevelWindow *window, const std::string &name)
bool	window_pos_restore (wxTopLevelWindow *window, const std::string &name, bool default_maximized=false)
void	window_pos_sanitize (wxTopLevelWindow *window)
void	window_pos_center (wxTopLevelWindow *window)
void	refresh_printer_agent_dropdown ()
void	set_live_printer_agent (std::shared_ptr< IPrinterAgent > agent)
bool	config_wizard_startup ()
void	check_updates (const bool verbose)
void	select_machine (const std::string &agent_id)

Private Attributes
bool	m_initialized { false }
bool	m_post_initialized { false }
bool	m_app_conf_exists { false }
EAppMode	m_app_mode { EAppMode::Editor }
bool	m_is_recreating_gui { false }
std::chrono::steady_clock::time_point	m_last_input { std::chrono::steady_clock::now() }
wxColour	m_color_label_modified
wxColour	m_color_label_sys
wxColour	m_color_label_default
wxColour	m_color_window_default
wxColour	m_color_highlight_label_default
wxColour	m_color_hovered_btn_label
wxColour	m_color_default_btn_label
wxColour	m_color_highlight_default
wxColour	m_color_selected_btn_bg
bool	m_force_colors_update { false }
wxFont	m_small_font
wxFont	m_bold_font
wxFont	m_normal_font
wxFont	m_code_font
wxFont	m_link_font
int	m_em_unit
std::unique_ptr< wxLocale >	m_wxLocale
const wxLanguageInfo *	m_language_info_system = nullptr
const wxLanguageInfo *	m_language_info_best = nullptr
wxString	m_active_language_code
OpenGLManager	m_opengl_mgr
std::unique_ptr< RemovableDriveManager >	m_removable_drive_manager
std::unique_ptr< ImGuiWrapper >	m_imgui
std::unique_ptr< ShortcutRegistry >	m_shortcuts
std::unique_ptr< PrintHostJobQueue >	m_printhost_job_queue
std::unique_ptr< OtherInstanceMessageHandler >	m_other_instance_message_handler
std::unique_ptr< wxSingleInstanceChecker >	m_single_instance_checker
std::string	m_instance_hash_string
size_t	m_instance_hash_int
std::unique_ptr< Downloader >	m_downloader
std::atomic< bool >	m_is_closing {false}
Slic3r::DeviceManager *	m_device_manager { nullptr }
Slic3r::UserManager *	m_user_manager { nullptr }
Slic3r::TaskManager *	m_task_manager { nullptr }
NetworkAgent *	m_agent { nullptr }
std::map< std::string, std::string >	need_delete_presets
std::vector< bool >	m_create_preset_blocked { false, false, false, false, false, false }
std::vector< std::string >	m_pending_conflict_setting_ids
bool	m_networking_compatible { false }
bool	m_networking_need_update { false }
bool	m_networking_cancel_update { false }
std::shared_ptr< UpgradeNetworkJob >	m_upgrade_network_job
std::map< std::string, std::map< std::string, std::set< std::string > > >	need_add_vendors
std::map< std::string, std::string >	need_add_filaments
ZUserLogin *	login_dlg { nullptr }
VersionInfo	version_info
VersionInfo	privacy_version_info
HMSQuery *	hms_query { nullptr }
FilamentColorCodeQuery *	m_filament_color_code_query { nullptr }
boost::thread	m_sync_update_thread
std::shared_ptr< int >	m_user_sync_token
std::atomic< bool >	m_restart_sync_pending {false}
std::atomic< bool >	m_sync_user_preset_dlg_active {false}
std::atomic< bool >	m_sync_user_presets_now {false}
bool	m_user_preset_pull_pending {false}
bool	m_legacy_filament_check_due {false}
bool	m_legacy_filament_check_running {false}
std::atomic< bool >	m_migration_retry_pending {false}
bool	m_is_dark_mode { false }
bool	m_adding_script_handler { false }
bool	m_side_popup_status {false}
bool	m_show_http_error_msgdlg {false}
std::chrono::steady_clock::time_point	m_last_401_error_time
std::string	m_cloud_handoff_state
std::string	m_cloud_open_path
uint64_t	m_cloud_handoff_gen { 0 }
bool	m_show_error_msgdlg {false}
wxString	m_info_dialog_content
HttpServer	m_http_server
bool	m_show_gcode_window {true}
boost::thread	m_check_network_thread
bool	m_init_app_config_from_older { false }
bool	m_datadir_redefined { false }
std::string	m_older_data_dir_path
bool	m_unsigned_plugin_warning_shown { false }
boost::optional< Semver >	m_last_config_version
bool	m_config_corrupted { false }
std::string	m_open_method

Static Private Attributes
static std::string	version_display = ""

Detailed Description

Member Enumeration Documentation

EAppMode

enum class Slic3r::GUI::GUI_App::EAppMode : unsigned char

strong

Enumerator
Editor
GCodeViewer

    {
        Editor,
        GCodeViewer
    };

Constructor & Destructor Documentation

GUI_App()

Slic3r::GUI::GUI_App::GUI_App ( )

explicit

    : wxApp()
    //, m_app_mode(mode)
    , m_app_mode(EAppMode::Editor)
    , m_em_unit(10)
    , m_imgui(new ImGuiWrapper())
  , m_removable_drive_manager(std::make_unique<RemovableDriveManager>())
    , m_downloader(std::make_unique<Downloader>())
  , m_other_instance_message_handler(std::make_unique<OtherInstanceMessageHandler>())
{
  //app config initializes early becasuse it is used in instance checking in OrcaSlicer.cpp
    this->init_app_config();
    m_shortcuts = std::make_unique<ShortcutRegistry>();
    m_shortcuts->load(*app_config);
    this->init_download_path();
    // Note: the WebView2 runtime check (init_webview_runtime) used to run here, but
    // the constructor executes before wxWidgets is fully initialized and before the
    // event loop starts, so its modal prompt/installer could silently fail to appear.
    // It now runs in post_init(), before the first WebView (the setup wizard) is created.
 
    reset_to_active();
}

References GUI_App(), app_config, init_app_config(), init_download_path(), m_app_mode, m_downloader, m_em_unit, m_imgui, m_other_instance_message_handler, m_removable_drive_manager, m_shortcuts, Slic3r::make_unique(), and reset_to_active().

Referenced by GUI_App(), and init_plugin_gui_wiring().

Here is the call graph for this function:

Here is the caller graph for this function:

~GUI_App()

Slic3r::GUI::GUI_App::~GUI_App ( )

override

{
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__<< boost::format(": enter");
 
    if (m_agent)
        m_agent->set_printer_agent(nullptr);
    NetworkAgentFactory::clear_printer_agent_cache();
 
    Slic3r::PluginManager::instance().shutdown();
    Slic3r::PythonInterpreter::instance().shutdown();
 
    if (app_config != nullptr) {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__<< boost::format(": destroy app_config");
        delete app_config;
    }
 
    if (preset_bundle != nullptr) {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__<< boost::format(": destroy preset_bundle");
        delete preset_bundle;
    }
 
    if (preset_updater != nullptr) {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__<< boost::format(": destroy preset updater");
        delete preset_updater;
    }
 
    StaticBambuLib::release();
    BBLNetworkPlugin::shutdown();
 
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__<< boost::format(": exit");
    shutdown_console_logging();
}

References ~GUI_App(), app_config, Slic3r::NetworkAgentFactory::clear_printer_agent_cache(), Slic3r::PluginManager::instance(), Slic3r::PythonInterpreter::instance(), m_agent, preset_bundle, preset_updater, StaticBambuLib::release(), Slic3r::BBLNetworkPlugin::shutdown(), Slic3r::PluginManager::shutdown(), Slic3r::PythonInterpreter::shutdown(), and Slic3r::shutdown_console_logging().

Referenced by ~GUI_App().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Function Documentation

action_registry()

ActionRegistry & Slic3r::GUI::GUI_App::action_registry ( )

inline

{ return m_action_registry; }

References m_action_registry.

add_pending_vendor_preset()

void Slic3r::GUI::GUI_App::add_pending_vendor_preset

(

const std::pair< std::string, std::map< std::string, std::string > > &

preset_data

)

{
    Preset::Type type = Preset::Type::TYPE_INVALID;
    if (preset_data.second.at(BBL_JSON_KEY_TYPE) == PRESET_IOT_PRINT_TYPE)
        type = Preset::Type::TYPE_PRINT;
    else if (preset_data.second.at(BBL_JSON_KEY_TYPE) == PRESET_IOT_PRINTER_TYPE)
        type = Preset::Type::TYPE_PRINTER;
    else if (preset_data.second.at(BBL_JSON_KEY_TYPE) == PRESET_IOT_FILAMENT_TYPE)
        type = Preset::Type::TYPE_FILAMENT;
    std::string inherits_name = preset_data.second.at(BBL_JSON_KEY_INHERITS);
 
    // Add the corresponding vendor
    std::string vendor_name = PresetBundle::find_preset_vendor(inherits_name, type);
    if (vendor_name.empty()) {
        // No vendor ships this preset's parent. An unnamed entry here becomes an
        // unnamed bundle at install time, which nothing can install.
        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": no vendor carries " << inherits_name << ", skipping";
        return;
    }
    if (need_add_vendors.find(vendor_name) == need_add_vendors.end())
        need_add_vendors[vendor_name] = std::map<std::string, std::set<std::string>>();
 
    // Add printers/filament if applicable
    if (type == Preset::Type::TYPE_PRINTER) {
        // Extract float from preset name if present
        std::string model_name = inherits_name;
        std::regex float_regex(R"((\b\d+\.\d+))");
        std::smatch match;
        if (std::regex_search(model_name, match, float_regex) && match.size() > 1) {
            // Get variant i.e., nozzle diameter
            std::string nozzle_diameter = match[1].str();
            // Get model name
            model_name.erase(model_name.find(nozzle_diameter));
            model_name.erase(model_name.rfind(' '));
            if(need_add_vendors[vendor_name].find(model_name) == need_add_vendors[vendor_name].end())
                need_add_vendors[vendor_name][model_name] = std::set<std::string>();
            
            need_add_vendors[vendor_name][model_name].insert(nozzle_diameter);
        }
    }
    else if (type == Preset::Type::TYPE_FILAMENT) {
        need_add_filaments[inherits_name] = "true";
    }
}

References add_pending_vendor_preset(), BBL_JSON_KEY_INHERITS, BBL_JSON_KEY_TYPE, Slic3r::PresetBundle::find_preset_vendor(), need_add_filaments, need_add_vendors, Slic3r::nozzle_diameter(), PRESET_IOT_FILAMENT_TYPE, PRESET_IOT_PRINT_TYPE, PRESET_IOT_PRINTER_TYPE, Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_INVALID, Slic3r::Preset::TYPE_PRINT, and Slic3r::Preset::TYPE_PRINTER.

Referenced by add_pending_vendor_preset(), reload_settings(), sync_bundle(), and update_single_bundle().

Here is the call graph for this function:

Here is the caller graph for this function:

apply_keeped_preset_modifications()

void Slic3r::GUI::GUI_App::apply_keeped_preset_modifications

(

)

{
    PrinterTechnology printer_technology = preset_bundle->printers.get_edited_preset().printer_technology();
    for (Tab* tab : tabs_list) {
        if (tab->supports_printer_technology(printer_technology))
            tab->apply_config_from_cache();
    }
    load_current_presets(false);
}

References apply_keeped_preset_modifications(), load_current_presets(), preset_bundle, Slic3r::GUI::printer_technology(), and tabs_list.

Referenced by apply_keeped_preset_modifications(), check_and_keep_current_preset_changes(), Slic3r::GUI::ConfigWizard::run(), and Slic3r::GUI::GuideFrame::run().

Here is the call graph for this function:

Here is the caller graph for this function:

associate_files()

void Slic3r::GUI::GUI_App::associate_files

(

std::wstring

extend

)

{
#ifdef WIN32
    // MSIX: shell integration is declared in the package manifest; registry
    // writes from a packaged process are virtualized and invisible to the shell.
    if (is_running_in_msix())
        return;
    wchar_t app_path[MAX_PATH];
    ::GetModuleFileNameW(nullptr, app_path, sizeof(app_path));
 
    std::wstring prog_path = L"\"" + std::wstring(app_path) + L"\"";
    std::wstring prog_id = L" Orca.Slicer.1";
    std::wstring prog_desc = L"OrcaSlicer";
    std::wstring prog_command = prog_path + L" \"%1\"";
    std::wstring reg_base = L"Software\\Classes";
    std::wstring reg_extension = reg_base + L"\\." + extend;
    std::wstring reg_prog_id = reg_base + L"\\" + prog_id;
    std::wstring reg_prog_id_command = reg_prog_id + L"\\Shell\\Open\\Command";
 
    bool is_new = false;
    is_new |= set_into_win_registry(HKEY_CURRENT_USER, reg_extension.c_str(), prog_id.c_str());
    is_new |= set_into_win_registry(HKEY_CURRENT_USER, reg_prog_id.c_str(), prog_desc.c_str());
    is_new |= set_into_win_registry(HKEY_CURRENT_USER, reg_prog_id_command.c_str(), prog_command.c_str());
    if (is_new)
        // notify Windows only when any of the values gets changed
        ::SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_IDLIST, nullptr, nullptr);
#endif // WIN32
}

References associate_files(), Slic3r::GUI::is_running_in_msix(), and L.

Referenced by associate_files(), on_init_inner(), and open_preferences().

Here is the call graph for this function:

Here is the caller graph for this function:

associate_url()

void Slic3r::GUI::GUI_App::associate_url

(

std::wstring

url_prefix

)

{
#ifdef WIN32
    if (is_running_in_msix())
        return;
    boost::filesystem::path binary_path(boost::filesystem::canonical(boost::dll::program_location()));
    wxString wbinary = from_path(binary_path);
    BOOST_LOG_TRIVIAL(info) << "Downloader registration: Path of binary: " << wbinary.ToUTF8().data();
 
    wxString key_string = "\"" + wbinary + "\" \"%1\"";
 
    wxRegKey key_first(wxRegKey::HKCU, L"Software\\Classes\\" + url_prefix);
    wxRegKey key_full(wxRegKey::HKCU, L"Software\\Classes\\" + url_prefix + L"\\shell\\open\\command");
    if (!key_first.Exists()) {
        key_first.Create(false);
    }
    key_first.SetValue("URL Protocol", "");
 
    if (!key_full.Exists()) {
        key_full.Create(false);
    }
    key_full = key_string;
#elif defined(__linux__) && defined(SLIC3R_DESKTOP_INTEGRATION)
    DesktopIntegrationDialog::perform_downloader_desktop_integration(into_u8(url_prefix));
#endif // WIN32
}

References associate_url(), Slic3r::GUI::from_path(), Slic3r::GUI::into_u8(), Slic3r::GUI::is_running_in_msix(), and L.

Referenced by associate_url(), on_init_inner(), and open_preferences().

Here is the call graph for this function:

Here is the caller graph for this function:

bold_font()

const wxFont & Slic3r::GUI::GUI_App::bold_font ( )

inline

{ return m_bold_font; }

References m_bold_font.

can_load_project()

bool Slic3r::GUI::GUI_App::can_load_project

(

)

{
    return true;
}

References can_load_project().

Referenced by can_load_project().

Here is the call graph for this function:

Here is the caller graph for this function:

cancel_networking_install()

void Slic3r::GUI::GUI_App::cancel_networking_install

(

)

{
    m_networking_cancel_update = true;
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__<< boost::format(": plugin install cancelled!");
}

References m_networking_cancel_update.

canonical_printer_agent_id()

std::string Slic3r::GUI::GUI_App::canonical_printer_agent_id

(

const std::string &

picked_id

)

{
    return picked_id == resolve_printer_agent_id("") ? std::string() : picked_id;
}

References canonical_printer_agent_id(), and resolve_printer_agent_id().

Referenced by canonical_printer_agent_id().

Here is the call graph for this function:

Here is the caller graph for this function:

catch_error()

bool Slic3r::GUI::GUI_App::catch_error ( std::function< void()> cb, const std::string & err )

static

{
    if (!err.empty()) {
        if (cb)
            cb();
        //         if (message_dialog)
        //             message_dialog->(err, "Error", wxOK | wxICON_ERROR);
        show_error(/*this*/nullptr, err);
        return true;
    }
    return false;
}

References catch_error(), and Slic3r::GUI::show_error().

Referenced by catch_error().

Here is the call graph for this function:

Here is the caller graph for this function:

check_and_keep_current_preset_changes()

bool Slic3r::GUI::GUI_App::check_and_keep_current_preset_changes	(	const wxString &	caption,
		const wxString &	header,
		int	action_buttons,
		bool *	postponed_apply_of_keeped_changes = nullptr )

{
    if (has_current_preset_changes()) {
        bool is_called_from_configwizard = postponed_apply_of_keeped_changes != nullptr;
 
        UnsavedChangesDialog dlg(caption, header, "", action_buttons);
        bool no_need_change = dlg.getUpdateItemCount() == 0 ? true : false;
        if (!no_need_change && dlg.ShowModal() == wxID_CANCEL)
            return false;
 
        auto reset_modifications = [this]() {
            //if (is_called_from_configwizard)
            //    return; // no need to discared changes. It will be done fromConfigWizard closing
 
            PrinterTechnology printer_technology = preset_bundle->printers.get_edited_preset().printer_technology();
            for (const Tab* const tab : tabs_list) {
                if (tab->supports_printer_technology(printer_technology) && tab->current_preset_is_dirty())
                    tab->m_presets->discard_current_changes();
            }
            load_current_presets(false);
        };
 
        if (dlg.discard() || no_need_change)
            reset_modifications();
        else  // save selected changes
        {
            //BBS: add project embedded preset relate logic
            const auto& preset_names_and_types = dlg.get_names_and_types();
            if (dlg.save_preset()) {
                for (const UnsavedChangesDialog::PresetData& nt : preset_names_and_types)
                    preset_bundle->save_changes_for_preset(nt.name, nt.type, dlg.get_unselected_options(nt.type), nt.save_to_project);
 
                // if we saved changes to the new presets, we should to
                // synchronize config.ini with the current selections.
                preset_bundle->export_selections(*app_config);
 
                //wxString text = _L_PLURAL("Modifications to the preset have been saved",
                //    "Modifications to the presets have been saved", preset_names_and_types.size());
                //if (!is_called_from_configwizard)
                //    text += "\n\n" + _L("All modifications will be discarded for new project.");
 
                //MessageDialog(nullptr, text).ShowModal();
                reset_modifications();
            }
            else if (dlg.transfer_changes() && (dlg.has_unselected_options() || is_called_from_configwizard)) {
                // execute this part of code only if not all modifications are keeping to the new project
                // OR this function is called when ConfigWizard is closed and "Keep modifications" is selected
                for (const UnsavedChangesDialog::PresetData& nt : preset_names_and_types) {
                    Preset::Type type = nt.type;
                    Tab* tab = get_tab(type);
                    std::vector<std::string> selected_options = dlg.get_selected_options(type);
                    if (type == Preset::TYPE_PRINTER) {
                        auto it = std::find(selected_options.begin(), selected_options.end(), "extruders_count");
                        if (it != selected_options.end()) {
                            // erase "extruders_count" option from the list
                            selected_options.erase(it);
                            // cache the extruders count
                            static_cast<TabPrinter*>(tab)->cache_extruder_cnt();
                        }
                    }
                    std::vector<std::string> selected_options2;
                    std::transform(selected_options.begin(), selected_options.end(), std::back_inserter(selected_options2), [](auto & o) {
                        auto i = o.find('#');
                        return i != std::string::npos ? o.substr(0, i) : o;
                    });
                    tab->cache_config_diff(selected_options2);
                    if (!is_called_from_configwizard)
                        tab->m_presets->discard_current_changes();
                }
                if (is_called_from_configwizard)
                    *postponed_apply_of_keeped_changes = true;
                else
                    apply_keeped_preset_modifications();
            }
        }
    }
 
    return true;
}

References app_config, apply_keeped_preset_modifications(), Slic3r::GUI::Tab::cache_config_diff(), check_and_keep_current_preset_changes(), Slic3r::GUI::UnsavedChangesDialog::discard(), Slic3r::PresetCollection::discard_current_changes(), Slic3r::GUI::UnsavedChangesDialog::get_names_and_types(), Slic3r::GUI::UnsavedChangesDialog::get_selected_options(), get_tab(), Slic3r::GUI::UnsavedChangesDialog::get_unselected_options(), Slic3r::GUI::UnsavedChangesDialog::getUpdateItemCount(), has_current_preset_changes(), Slic3r::GUI::UnsavedChangesDialog::has_unselected_options(), load_current_presets(), Slic3r::GUI::Tab::m_presets, preset_bundle, Slic3r::GUI::printer_technology(), Slic3r::GUI::UnsavedChangesDialog::save_preset(), Slic3r::GUI::UnsavedChangesDialog::ShowModal(), tabs_list, Slic3r::GUI::UnsavedChangesDialog::transfer_changes(), and Slic3r::Preset::TYPE_PRINTER.

Referenced by check_and_keep_current_preset_changes().

Here is the call graph for this function:

Here is the caller graph for this function:

check_and_save_current_preset_changes()

bool Slic3r::GUI::GUI_App::check_and_save_current_preset_changes	(	const wxString &	caption,
		const wxString &	header,
		bool	remember_choice = true,
		bool	use_dont_save_insted_of_discard = false )

{
    if (has_current_preset_changes()) {
        int act_buttons = ActionButtons::SAVE;
        if (dont_save_insted_of_discard)
            act_buttons |= ActionButtons::DONT_SAVE;
        if (remember_choice)
            act_buttons |= ActionButtons::REMEMBER_CHOISE;
        UnsavedChangesDialog dlg(caption, header, "", act_buttons);
        bool no_need_change = dlg.getUpdateItemCount() == 0 ? true : false;
        if (!no_need_change && dlg.ShowModal() == wxID_CANCEL)
            return false;
 
        if (dlg.save_preset())  // save selected changes
        {
            //BBS: add project embedded preset relate logic
            for (const UnsavedChangesDialog::PresetData& nt : dlg.get_names_and_types())
                preset_bundle->save_changes_for_preset(nt.name, nt.type, dlg.get_unselected_options(nt.type), nt.save_to_project);
            //for (const std::pair<std::string, Preset::Type>& nt : dlg.get_names_and_types())
            //    preset_bundle->save_changes_for_preset(nt.first, nt.second, dlg.get_unselected_options(nt.second));
 
            load_current_presets(false);
 
            // if we saved changes to the new presets, we should to
            // synchronize config.ini with the current selections.
            preset_bundle->export_selections(*app_config);
 
            //MessageDialog(nullptr, _L_PLURAL("Modifications to the preset have been saved",
            //                                 "Modifications to the presets have been saved", dlg.get_names_and_types().size())).ShowModal();
        }
    }
 
    return true;
}

References app_config, check_and_save_current_preset_changes(), Slic3r::GUI::DONT_SAVE, Slic3r::GUI::UnsavedChangesDialog::get_names_and_types(), Slic3r::GUI::UnsavedChangesDialog::get_unselected_options(), Slic3r::GUI::UnsavedChangesDialog::getUpdateItemCount(), has_current_preset_changes(), load_current_presets(), preset_bundle, Slic3r::GUI::REMEMBER_CHOISE, Slic3r::GUI::SAVE, Slic3r::GUI::UnsavedChangesDialog::save_preset(), and Slic3r::GUI::UnsavedChangesDialog::ShowModal().

Referenced by check_and_save_current_preset_changes().

Here is the call graph for this function:

Here is the caller graph for this function:

check_bundle_updates()

void Slic3r::GUI::GUI_App::check_bundle_updates

(

)

{
    if (!m_agent || !m_agent->is_user_login()) return;
    auto orca_agent = std::dynamic_pointer_cast<OrcaCloudServiceAgent>(m_agent->get_cloud_agent());
    if (!orca_agent) return;
 
    BOOST_LOG_TRIVIAL(info) << "check_bundle_updates: checking for bundle updates";
 
    // Fetch all subscribed bundles from cloud
    std::vector<std::pair<std::string, std::string>> subscribed_bundles;
    std::vector<std::string> notfound;
    std::vector<std::string> unauthorized;
    int result = orca_agent->get_subscribed_bundles(&subscribed_bundles,notfound,unauthorized);
 
    if (result != 0) {
        BOOST_LOG_TRIVIAL(warning) << "check_bundle_updates: failed to fetch subscribed bundles, result=" << result;
        return;
    }
 
    if(!notfound.empty())
    {
        for(auto& n : notfound)
        {
            std::string text = format(_L("Bundle %s is no longer available."), n);
            wxGetApp().plater()->get_notification_manager()->push_notification(NotificationType::CustomNotification,NotificationManager::NotificationLevel::RegularNotificationLevel,text);
        }
    }
    if(!unauthorized.empty())
    {
        for(auto& i : unauthorized)
        {
            std::string text = format(_L("Bundle %s access is unauthorized."), i);
            wxGetApp().plater()->get_notification_manager()->push_notification(NotificationType::CustomNotification,NotificationManager::NotificationLevel::RegularNotificationLevel,text);
        }
    }
 
    // Fetch presets for each bundle
    std::map<std::string, std::map<std::string, std::map<std::string, std::string>>> subscribed_bundle_presets;
    std::map<std::string, BundleMetadata> subscribed_bundle_metadata;
 
    for (const auto& bundle : subscribed_bundles) {
        std::map<std::string, std::map<std::string, std::string>> presets;
        BundleMetadata metadata;
        int preset_result = orca_agent->get_shared_bundle(bundle.first, &presets, &metadata);
 
        if (preset_result == 0) {
            subscribed_bundle_presets[bundle.first] = presets;
            subscribed_bundle_metadata[bundle.first] = metadata;
        } else {
            BOOST_LOG_TRIVIAL(warning) << "check_bundle_updates: Failed to get presets for bundle_id=" << bundle.first << ", result=" << preset_result;
            // Continue with other bundles even if one fails
        }
    }
 
    // Iterate through local bundles and check for updates
    if (!preset_bundle) return;
 
    int bundles_checked = 0;
    int updates_available = 0;
 
    for (auto& [bundle_id, local_metadata] : preset_bundle->bundles.m_bundles) {
        // Only check subscribed bundles (those with UUID-style IDs from Orca Cloud)
        // Skip external bundles (those with name+timestamp IDs)
        if (!local_metadata.is_subscribed) {
            continue;
        }
 
        // Find corresponding remote metadata
        auto remote_it = subscribed_bundle_metadata.find(bundle_id);
        if (remote_it == subscribed_bundle_metadata.end()) {
            BOOST_LOG_TRIVIAL(info) << "check_bundle_updates: bundle " << bundle_id << " not found in remote subscriptions";
            continue;
        }
 
        const auto& remote_metadata = remote_it->second;
 
        // Compare versions using Semver
        auto local_version = Semver::parse(local_metadata.version);
        auto remote_version = Semver::parse(remote_metadata.version);
 
        if (!local_version || !remote_version) {
            BOOST_LOG_TRIVIAL(warning) << "check_bundle_updates: failed to parse versions for bundle " << bundle_id
                                       << " (local: " << local_metadata.version << ", remote: " << remote_metadata.version << ")";
            continue;
        }
 
        bundles_checked++;
 
        // Update the runtime-only flag if remote version is newer
        if (remote_version > local_version) {
            local_metadata.update_available = true;
            updates_available++;
            BOOST_LOG_TRIVIAL(info) << "check_bundle_updates: bundle " << bundle_id << " (" << local_metadata.name
                                    << ") has update available: local=" << local_metadata.version
                                    << ", remote=" << remote_metadata.version;
        } else {
            local_metadata.update_available = false;
        }
    }
 
    BOOST_LOG_TRIVIAL(info) << "check_bundle_updates: checked " << bundles_checked
                            << " bundles, found " << updates_available << " updates available";
}

References _L, check_bundle_updates(), Slic3r::GUI::CustomNotification, Slic3r::GUI::format(), m_agent, Slic3r::Semver::parse(), preset_bundle, and Slic3r::GUI::NotificationManager::RegularNotificationLevel.

Referenced by check_bundle_updates().

Here is the call graph for this function:

Here is the caller graph for this function:

check_config_updates_from_updater()

void Slic3r::GUI::GUI_App::check_config_updates_from_updater ( )

inline

{ check_updates(false); }

References check_updates().

Here is the call graph for this function:

check_legacy_user_filament_presets()

void Slic3r::GUI::GUI_App::check_legacy_user_filament_presets

(

bool

by_user

)

{
    // One check at a time: the startup check can come due while the manual one is open, and on macOS the menu bar
    // stays usable while a modal dialog is up.
    if (m_legacy_filament_check_running)
        return;
    if (!by_user && app_config->get_bool("legacy_user_filament_presets_dont_remind"))
        return;
    // The local copies may be older than the cloud ones another machine changed: migrating them would push changes
    // made against stale copies and conflict with the cloud. The startup check waits for the presets to be pulled.
    if (!by_user && m_user_preset_pull_pending) {
        m_legacy_filament_check_due = true;
        return;
    }
    // This check also answers a startup check that is still waiting.
    m_legacy_filament_check_due = false;
    m_legacy_filament_check_running = true;
    ScopeGuard running_guard([this] { m_legacy_filament_check_running = false; });
 
    const std::vector<LegacyUserFilamentPreset> legacy_presets = preset_bundle->legacy_user_filament_presets();
    if (legacy_presets.empty()) {
        if (by_user)
            MessageDialog(mainframe, _L("All your filament presets are available on the printers they were made for."),
                          _L("Migrate Filament Presets"), wxOK | wxICON_INFORMATION).ShowModal();
        return;
    }
 
    wxString message = _L("OrcaSlicer 2.5.0 restructured many system filament presets to fix incorrect profiles and prepare "
                          "for future features. As a result, the presets below no longer show on some printers they were made "
                          "for. Sorry for the trouble; this is a one-time fix.\n\n"
                          "Add those printers back to your presets now? Your presets are backed up first. You can also do this "
                          "later from Help > Migrate Filament Presets.") + "\n";
    for (const LegacyUserFilamentPreset &legacy : legacy_presets) {
        message += "\n" + format_wxstr(_L("%1% (based on %2%)"), legacy.preset, legacy.parent);
        for (const std::string &printer : legacy.printers)
            message += "\n    " + from_u8(printer);
    }
    RichMessageDialog dlg(mainframe, message, _L("Migrate Filament Presets"), wxYES | wxNO | wxICON_QUESTION);
    if (!by_user)
        dlg.ShowCheckBox(_L("Don't remind me again"));
    const bool migrate = dlg.ShowModal() == wxID_YES;
    if (dlg.IsCheckBoxChecked())
        app_config->set_bool("legacy_user_filament_presets_dont_remind", true);
    if (!migrate)
        return;
 
    const PresetBundle::LegacyUserFilamentPresetMigration migration = preset_bundle->migrate_legacy_user_filament_presets(legacy_presets);
    const std::string              &backup = migration.backup;
    const std::vector<std::string> &failed = migration.failed;
    if (backup.empty()) {
        show_error(mainframe, _L("Your presets could not be backed up, so they were not migrated."));
        return;
    }
    if (!migration.locked) {
        // The lock is also refused for a while after a miss, and when the lock file itself cannot be opened.
        show_error(mainframe, _L("The user presets folder could not be locked, so nothing was migrated. Another OrcaSlicer "
                                 "instance may be saving presets; try again later from Help > Migrate Filament Presets."));
        return;
    }
    if (failed.size() == legacy_presets.size()) {
        show_error(mainframe, format_wxstr(_L("Your filament presets could not be migrated. A backup of your presets was saved to:\n%1%"), backup));
        return;
    }
    // Ask the sync loop to push on its next pass instead of its next 60 s round, which shortens the time the migrated
    // presets stay unpushed.
    m_sync_user_presets_now.store(true, std::memory_order_release);
    preset_bundle->update_compatible(PresetSelectCompatibleType::Never);
    mainframe->update_side_preset_ui();
    for (auto tab : tabs_list) {
        tab->reload_config();
        tab->update_changed_ui();
    }
 
    message = format_wxstr(_L("Your filament presets were migrated. Select them again in the filament list where you used them.\n\n"
                              "A backup of your presets was saved to:\n%1%"), backup);
    if (!failed.empty()) {
        message += "\n\n" + _L("These presets could not be migrated:");
        for (const std::string &name : failed)
            message += "\n" + from_u8(name);
    }
    MessageDialog(mainframe, message, _L("Migrate Filament Presets"), wxOK | (failed.empty() ? wxICON_INFORMATION : wxICON_WARNING)).ShowModal();
}

References _L, app_config, Slic3r::PresetBundle::LegacyUserFilamentPresetMigration::backup, check_legacy_user_filament_presets(), Slic3r::PresetBundle::LegacyUserFilamentPresetMigration::failed, Slic3r::GUI::format_wxstr(), Slic3r::GUI::from_u8(), Slic3r::GUI::RichMessageDialog::IsCheckBoxChecked(), Slic3r::PresetBundle::LegacyUserFilamentPresetMigration::locked, m_legacy_filament_check_due, m_legacy_filament_check_running, m_sync_user_presets_now, m_user_preset_pull_pending, mainframe, Slic3r::Never, preset_bundle, Slic3r::GUI::show_error(), Slic3r::GUI::RichMessageDialog::ShowCheckBox(), Slic3r::GUI::DPIAware< P >::ShowModal(), Slic3r::GUI::RichMessageDialog::ShowModal(), and tabs_list.

Referenced by check_legacy_user_filament_presets(), post_init(), and start_sync_user_preset().

Here is the call graph for this function:

Here is the caller graph for this function:

check_login()

bool Slic3r::GUI::GUI_App::check_login

(

const std::string &

provider = ORCA_CLOUD_PROVIDER

)

{
    bool result = false;
    if (m_agent) {
        result = m_agent->is_user_login(provider);
    }
 
    if (!result) {
        ShowUserLogin(true, provider);
    }
    return result;
}

References check_login(), m_agent, and ShowUserLogin().

Referenced by check_login(), and request_project_download().

Here is the call graph for this function:

Here is the caller graph for this function:

check_networking_version()

bool Slic3r::GUI::GUI_App::check_networking_version

(

)

{
    std::string network_ver = Slic3r::NetworkAgent::get_version();
    if (!network_ver.empty()) {
        BOOST_LOG_TRIVIAL(info) << "get_network_agent_version=" << network_ver;
    }
 
    std::string studio_ver;
    if (use_legacy_network_plugin()) {
        studio_ver = BAMBU_NETWORK_AGENT_VERSION_LEGACY;
    } else if (app_config) {
        std::string user_version = app_config->get_network_plugin_version();
        studio_ver = user_version.empty() ? get_latest_network_version() : user_version;
    } else {
        studio_ver = get_latest_network_version();
    }
 
    BOOST_LOG_TRIVIAL(info) << "check_networking_version: network_ver=" << network_ver << ", expected=" << studio_ver;
 
    // A configured version outside the whitelisted series must never pass as compatible,
    // even if it matches the loaded library - its ABI does not match this build.
    if (!use_legacy_network_plugin() && !is_supported_network_version(studio_ver)) {
        m_networking_compatible = false;
        return false;
    }
 
    if (network_ver.length() >= 8 && studio_ver.length() >= 8) {
        if (network_ver.substr(0,8) == studio_ver.substr(0,8)) {
            m_networking_compatible = true;
            return true;
        }
    }
 
    m_networking_compatible = false;
    return false;
}

References app_config, BAMBU_NETWORK_AGENT_VERSION_LEGACY, get_latest_network_version(), Slic3r::NetworkAgent::get_version(), Slic3r::is_supported_network_version(), m_networking_compatible, and use_legacy_network_plugin().

Referenced by on_init_network().

Here is the call graph for this function:

Here is the caller graph for this function:

check_new_version()

void Slic3r::GUI::GUI_App::check_new_version	(	bool	show_tips = false,
		int	by_user = 0 )

{
    return; // orca: not used, see check_new_version_sf
    std::string platform = "windows";
 
#ifdef __WINDOWS__
    platform = "windows";
#endif
#ifdef __APPLE__
    platform = "macos";
#endif
#ifdef __LINUX__
    platform = "linux";
#endif
    std::string query_params = (boost::format("?name=slicer&version=%1%&guide_version=%2%")
        % VersionInfo::convert_full_version(SLIC3R_VERSION)
        % VersionInfo::convert_full_version("0.0.0.1")
        ).str();
 
    std::string url = get_http_url(app_config->get_country_code()) + query_params;
    Slic3r::Http http = Slic3r::Http::get(url);
 
    http.header("accept", "application/json")
        .timeout_connect(TIMEOUT_CONNECT)
        .timeout_max(TIMEOUT_RESPONSE)
        .on_complete([this, show_tips, by_user](std::string body, unsigned) {
        try {
            json j = json::parse(body);
            if (j.contains("message")) {
                if (j["message"].get<std::string>() == "success") {
                    if (j.contains("software")) {
                        if (j["software"].empty() && show_tips) {
                            this->no_new_version();
                        }
                        else {
                            if (j["software"].contains("url")
                                && j["software"].contains("version")
                                && j["software"].contains("description")) {
                                version_info.url = j["software"]["url"].get<std::string>();
                                version_info.version_str = j["software"]["version"].get<std::string>();
                                version_info.description = j["software"]["description"].get<std::string>();
                            }
                            if (j["software"].contains("force_update")) {
                                version_info.force_upgrade = j["software"]["force_update"].get<bool>();
                            }
                            CallAfter([this, show_tips, by_user](){
                                this->check_update(show_tips, by_user);
                            });
                        }
                    }
                }
            }
        }
        catch (...) {
            ;
        }
            })
        .on_error([this](std::string body, std::string error, unsigned int status) {
            handle_http_error(status, body);
            BOOST_LOG_TRIVIAL(error) << "check new version error" << body;
    }).perform();
}

References app_config, check_new_version(), check_update(), Slic3r::Geometry::contains(), Slic3r::GUI::VersionInfo::convert_full_version(), Slic3r::empty(), Slic3r::Http::get(), get_http_url(), handle_http_error(), Slic3r::http, no_new_version(), Slic3r::platform(), TIMEOUT_CONNECT, TIMEOUT_RESPONSE, and version_info.

Referenced by check_new_version().

Here is the call graph for this function:

Here is the caller graph for this function:

check_new_version_sf()

void Slic3r::GUI::GUI_App::check_new_version_sf	(	bool	show_tips = false,
		int	by_user = 0 )

{
    AppConfig* app_config = wxGetApp().app_config;
    bool       check_stable_only = app_config->get_bool("check_stable_update_only");
    auto version_check_url = app_config->version_check_url();
 
    UpdaterQuery query{
        detect_updater_iid(app_config),
        detect_updater_version(),
        platform_os_type(),
        platform_architecture(),
        detect_updater_os_info()
    };
 
    const std::string query_string = build_updater_query(query);
    if (!query_string.empty()) {
        const bool has_query = version_check_url.find('?') != std::string::npos;
        if (!has_query)
            version_check_url.push_back('?');
        else if (!version_check_url.empty() && version_check_url.back() != '&' && version_check_url.back() != '?')
            version_check_url.push_back('&');
        version_check_url += query_string;
    }
 
    auto http = Http::get(version_check_url);
    maybe_attach_updater_signature(http, query_string, version_check_url);
 
    http.header("accept", "application/vnd.github.v3+json")
        .timeout_connect(5)
        .timeout_max(10)
        .on_error([&](std::string body, std::string error, unsigned http_status) {
          (void)body;
          BOOST_LOG_TRIVIAL(error) << format("Error getting: `%1%`: HTTP %2%, %3%", "check_new_version_sf", http_status,
                                             error);
        })
        .on_complete([this, by_user, check_stable_only](std::string body, unsigned http_status) {
          if (http_status != 200)
            return;
          try {
            boost::trim(body);
            if (body.empty()) {
                if (by_user != 0)
                    this->no_new_version();
                return;
            }
 
            boost::property_tree::ptree root;
            std::stringstream           json_stream(body);
            boost::property_tree::read_json(json_stream, root);
 
            std::regex matcher("[0-9]+\\.[0-9]+(\\.[0-9]+)*(-[A-Za-z0-9]+)?(\\+[A-Za-z0-9]+)?");
            Semver    current_version = get_version(SoftFever_VERSION, matcher);
            Semver    best_pre(0, 0, 0);
            Semver    best_release(0, 0, 0);
            bool      best_pre_valid = false;
            bool      best_release_valid = false;
            std::string best_pre_url;
            std::string best_release_url;
            std::string best_release_content;
            std::string best_pre_content;
 
            auto consider_release = [&](const boost::property_tree::ptree& node) {
                auto tag_opt = node.get_optional<std::string>("tag_name");
                if (!tag_opt)
                    return;
 
                std::string tag = *tag_opt;
                if (!tag.empty() && tag.front() == 'v')
                    tag.erase(0, 1);
 
                Semver tag_version = get_version(tag, matcher);
                if (!tag_version.valid())
                    return;
 
                const bool is_prerelease = node.get_optional<bool>("prerelease").get_value_or(false);
                const std::string html_url = node.get_optional<std::string>("html_url").get_value_or(std::string());
                const std::string body_copy = node.get_optional<std::string>("body").get_value_or(std::string());
 
                if (is_prerelease) {
                    if (!best_pre_valid || best_pre < tag_version) {
                        best_pre        = tag_version;
                        best_pre_url    = html_url;
                        best_pre_content = body_copy;
                        best_pre_valid  = true;
                    }
                } else {
                    if (!best_release_valid || best_release < tag_version) {
                        best_release         = tag_version;
                        best_release_url     = html_url;
                        best_release_content = body_copy;
                        best_release_valid   = true;
                    }
                }
            };
 
            if (root.get_optional<std::string>("tag_name")) {
                consider_release(root);
            } else {
                for (const auto& child : root)
                    consider_release(child.second);
            }
 
            if (!best_release_valid && !best_pre_valid) {
                if (by_user != 0)
                    this->no_new_version();
                return;
            }
 
            if (best_pre_valid && best_release_valid && best_pre < best_release) {
                best_pre        = best_release;
                best_pre_url    = best_release_url;
                best_pre_content = best_release_content;
                best_pre_valid  = true;
            }
 
            const bool        prefer_release = check_stable_only || !best_pre_valid;
            const Semver&     chosen_version = prefer_release ? best_release : best_pre;
            const bool        chosen_valid   = prefer_release ? best_release_valid : best_pre_valid;
 
            if (!chosen_valid) {
                if (by_user != 0)
                    this->no_new_version();
                return;
            }
 
            if (current_version.valid() && chosen_version <= current_version) {
                if (by_user != 0)
                    this->no_new_version();
                return;
            }
 
            version_info.url           = prefer_release ? best_release_url : best_pre_url;
            version_info.version_str   = prefer_release ? best_release.to_string_sf() : best_pre.to_string_sf();
            version_info.description   = prefer_release ? best_release_content : best_pre_content;
            version_info.force_upgrade = false;
 
            wxCommandEvent* evt = new wxCommandEvent(EVT_SLIC3R_VERSION_ONLINE);
            evt->SetString((prefer_release ? best_release : best_pre).to_string());
            GUI::wxGetApp().QueueEvent(evt);
          } catch (...) {}
        });
 
    http.perform();
}

References app_config, check_new_version_sf(), Slic3r::GUI::format(), Slic3r::Http::get(), Slic3r::GUI::get_version(), Slic3r::http, no_new_version(), Slic3r::platform_architecture(), Slic3r::platform_os_type(), Slic3r::GUI::to_string(), Slic3r::Semver::to_string_sf(), Slic3r::Semver::valid(), and version_info.

Referenced by check_new_version_sf(), and post_init().

Here is the call graph for this function:

Here is the caller graph for this function:

check_older_app_config()

bool Slic3r::GUI::GUI_App::check_older_app_config ( Semver current_version, bool backup )

private

{
    //BBS: current no need these logic
    return false;
}

References check_older_app_config().

Referenced by check_older_app_config().

Here is the call graph for this function:

Here is the caller graph for this function:

check_preset_parent_available()

bool Slic3r::GUI::GUI_App::check_preset_parent_available

(

const std::pair< std::string, std::map< std::string, std::string > > &

preset_data

)

{
    auto it = preset_data.second.find(BBL_JSON_KEY_INHERITS);
    if (it == preset_data.second.end() || it->second.empty())
        return true;
    const std::string& inherits_name = it->second;
    // If contains "fdm_", "@System", and "@base", is a common base template that doesn't need to be installed
    if (inherits_name.find("fdm_") != std::string::npos || inherits_name.find("@System") != std::string::npos || inherits_name.find("@base") != std::string::npos)
        return true;
 
    if (preset_data.second.at(BBL_JSON_KEY_TYPE) == PRESET_IOT_PRINT_TYPE)
        return preset_bundle->prints.find_preset2(inherits_name) != nullptr;
    else if (preset_data.second.at(BBL_JSON_KEY_TYPE) == PRESET_IOT_PRINTER_TYPE)
        return preset_bundle->printers.find_preset2(inherits_name) != nullptr;
    else if (preset_data.second.at(BBL_JSON_KEY_TYPE) == PRESET_IOT_FILAMENT_TYPE)
        return preset_bundle->filaments.find_preset2(inherits_name) != nullptr;
    return true;
}

References BBL_JSON_KEY_INHERITS, BBL_JSON_KEY_TYPE, check_preset_parent_available(), preset_bundle, PRESET_IOT_FILAMENT_TYPE, PRESET_IOT_PRINT_TYPE, and PRESET_IOT_PRINTER_TYPE.

Referenced by check_preset_parent_available(), reload_settings(), sync_bundle(), and update_single_bundle().

Here is the call graph for this function:

Here is the caller graph for this function:

check_print_host_queue()

bool Slic3r::GUI::GUI_App::check_print_host_queue

(

)

{
    wxString dirty;
    std::vector<std::pair<std::string, std::string>> jobs;
    // Get ongoing jobs from dialog
    mainframe->m_printhost_queue_dlg->get_active_jobs(jobs);
    if (jobs.empty())
        return true;
    // Show dialog
    wxString job_string = wxString();
    for (const auto& job : jobs) {
        job_string += format_wxstr("   %1% : %2% \n", job.first, job.second);
    }
    wxString message;
    message += _(L("The uploads are still ongoing")) + ":\n\n" + job_string +"\n" + _(L("Stop them and continue anyway?"));
    //wxMessageDialog dialog(mainframe,
    MessageDialog dialog(mainframe,
        message,
        wxString(SLIC3R_APP_NAME) + " - " + _(L("Ongoing uploads")),
        wxICON_QUESTION | wxYES_NO | wxNO_DEFAULT);
    if (dialog.ShowModal() == wxID_YES)
        return true;
 
    // TODO: If already shown, bring forward
    mainframe->m_printhost_queue_dlg->Show();
    return false;
}

References _, check_print_host_queue(), Slic3r::GUI::format_wxstr(), L, mainframe, and Slic3r::GUI::DPIAware< P >::ShowModal().

Referenced by check_print_host_queue().

Here is the call graph for this function:

Here is the caller graph for this function:

check_printer_presets()

void Slic3r::GUI::GUI_App::check_printer_presets

(

)

{
//BBS
#if 0
    std::vector<std::string> preset_names = PhysicalPrinter::presets_with_print_host_information(preset_bundle->printers);
    if (preset_names.empty())
        return;
 
    // BBS: remove "print host upload" message dialog
    preset_bundle->physical_printers.load_printers_from_presets(preset_bundle->printers);
#endif
}

References check_printer_presets(), preset_bundle, and Slic3r::PhysicalPrinter::presets_with_print_host_information().

Referenced by check_printer_presets(), and load_current_presets().

Here is the call graph for this function:

Here is the caller graph for this function:

check_privacy_update()

bool Slic3r::GUI::GUI_App::check_privacy_update

(

)

{
    if (privacy_version_info.version_str.empty() || privacy_version_info.description.empty()
        || privacy_version_info.url.empty()) {
        return false;
    }
 
    std::string local_privacy_ver = app_config->get("privacy_version");
    auto curr_version = Semver::parse(local_privacy_ver);
    auto remote_version = Semver::parse(privacy_version_info.version_str);
    if (curr_version && remote_version) {
        if (*remote_version > *curr_version || app_config->get("privacy_update_checked") != "true") {
            return true;
        }
    }
    return false;
}

References app_config, check_privacy_update(), Slic3r::Semver::parse(), and privacy_version_info.

Referenced by check_privacy_update(), and on_check_privacy_update().

Here is the call graph for this function:

Here is the caller graph for this function:

check_privacy_version()

void Slic3r::GUI::GUI_App::check_privacy_version	(	int	online_login = 0,
		const std::string &	provider = ORCA_CLOUD_PROVIDER )

{
    if (app_config->get_stealth_mode()) {
        request_user_handle(online_login);
        return;
    }
 
    std::string query_params = "?policy/privacy=00.00.00.00";
    std::string url = get_http_url(app_config->get_country_code()) + query_params;
    Slic3r::Http http = Slic3r::Http::get(url);
 
    http.header("accept", "application/json")
        .timeout_connect(TIMEOUT_CONNECT)
        .timeout_max(TIMEOUT_RESPONSE)
        .on_complete([this, online_login, provider](std::string body, unsigned) {
            try {
                json j = json::parse(body);
                if (j.contains("message")) {
                    if (j["message"].get<std::string>() == "success") {
                        if (j.contains("resources")) {
                            for (auto it = j["resources"].begin(); it != j["resources"].end(); it++) {
                                if (it->contains("type")) {
                                    if ((*it)["type"] == std::string("policy/privacy")
                                        && it->contains("version")
                                        && it->contains("description")
                                        && it->contains("url")
                                        && it->contains("force_update")) {
                                        privacy_version_info.version_str = (*it)["version"].get<std::string>();
                                        privacy_version_info.description = (*it)["description"].get<std::string>();
                                        privacy_version_info.url = (*it)["url"].get<std::string>();
                                        privacy_version_info.force_upgrade = (*it)["force_update"].get<bool>();
                                        break;
                                    }
                                }
                            }
                            CallAfter([this, online_login, provider]() {
                                auto evt = new wxCommandEvent(EVT_CHECK_PRIVACY_VER);
                                evt->SetInt(online_login);
                                evt->SetString(wxString::FromUTF8(provider));
                                wxQueueEvent(this, evt);
                            });
                        }
                    }
                }
            }
            catch (...) {
                request_user_handle(online_login, provider);
            }
        })
        .on_error([this, online_login, provider](std::string body, std::string error, unsigned int status) {
            request_user_handle(online_login, provider);
            BOOST_LOG_TRIVIAL(error) << "check privacy version error" << body;
    }).perform();
}

References app_config, check_privacy_version(), Slic3r::Http::get(), get_http_url(), Slic3r::http, privacy_version_info, request_user_handle(), TIMEOUT_CONNECT, and TIMEOUT_RESPONSE.

Referenced by check_privacy_version(), and on_user_login().

Here is the call graph for this function:

Here is the caller graph for this function:

check_track_enable()

void Slic3r::GUI::GUI_App::check_track_enable

(

)

{
    // Orca: telemetry only exists on the BBL cloud agent; always disable it.
    if (m_agent) {
        m_agent->track_enable(false);
        m_agent->track_remove_files();
    }
}

References check_track_enable(), and m_agent.

Referenced by check_track_enable(), on_init_network(), and on_user_login().

Here is the call graph for this function:

Here is the caller graph for this function:

check_update()

void Slic3r::GUI::GUI_App::check_update	(	bool	show_tips,
		int	by_user )

{
    if (version_info.version_str.empty()) return;
    if (version_info.url.empty()) return;
 
    auto curr_version = Semver::parse(SLIC3R_VERSION);
    auto remote_version = Semver::parse(version_info.version_str);
    if (curr_version && remote_version && (*remote_version > *curr_version)) {
        if (version_info.force_upgrade) {
            wxGetApp().app_config->set_bool("force_upgrade", version_info.force_upgrade);
            wxGetApp().app_config->set("upgrade", "force_upgrade", true);
            wxGetApp().app_config->set("upgrade", "description", version_info.description);
            wxGetApp().app_config->set("upgrade", "version", version_info.version_str);
            wxGetApp().app_config->set("upgrade", "url", version_info.url);
            GUI::wxGetApp().enter_force_upgrade();
        }
        else {
            GUI::wxGetApp().request_new_version(by_user);
        }
    } else {
        wxGetApp().app_config->set("upgrade", "force_upgrade", false);
        if (show_tips)
            this->no_new_version();
    }
}

References check_update(), no_new_version(), Slic3r::Semver::parse(), and version_info.

Referenced by check_new_version(), and check_update().

Here is the call graph for this function:

Here is the caller graph for this function:

check_updates()

void Slic3r::GUI::GUI_App::check_updates ( const bool verbose )

private

{
  PresetUpdater::UpdateResult updater_result;
  try {
    updater_result = preset_updater->config_update(app_config->orig_version(), verbose ? PresetUpdater::UpdateParams::SHOW_TEXT_BOX : PresetUpdater::UpdateParams::SHOW_NOTIFICATION);
    if (updater_result == PresetUpdater::R_INCOMPAT_EXIT) {
      mainframe->Close();
    }
    else if (updater_result == PresetUpdater::R_INCOMPAT_CONFIGURED) {
            m_app_conf_exists = true;
    }
    else if (verbose && updater_result == PresetUpdater::R_NOOP) {
      MsgNoUpdates dlg;
      dlg.ShowModal();
    }
  }
  catch (const std::exception & ex) {
    show_error(nullptr, ex.what());
  }
}

References app_config, check_updates(), m_app_conf_exists, mainframe, preset_updater, Slic3r::PresetUpdater::R_INCOMPAT_CONFIGURED, Slic3r::PresetUpdater::R_INCOMPAT_EXIT, Slic3r::PresetUpdater::R_NOOP, Slic3r::GUI::show_error(), Slic3r::PresetUpdater::SHOW_NOTIFICATION, Slic3r::PresetUpdater::SHOW_TEXT_BOX, and Slic3r::GUI::DPIAware< P >::ShowModal().

Referenced by check_config_updates_from_updater(), and check_updates().

Here is the call graph for this function:

Here is the caller graph for this function:

check_url_association()

bool Slic3r::GUI::GUI_App::check_url_association	(	std::wstring	url_prefix,
		std::wstring &	reg_bin )

{
    reg_bin = L"";
#ifdef WIN32
    wxRegKey key_full(wxRegKey::HKCU, L"Software\\Classes\\" + url_prefix + L"\\shell\\open\\command");
    if (!key_full.Exists()) {
        return false;
    }
    wxString reg_value = key_full.QueryDefaultValue();
    reg_bin = reg_value.ToStdWstring();
 
    boost::filesystem::path binary_path(boost::filesystem::canonical(boost::dll::program_location()));
    wxString key_string = "\"" + from_path(binary_path) + "\" \"%1\"";
    return key_string == reg_value;
#else
    return false;
#endif // WIN32
}

References check_url_association(), Slic3r::GUI::from_path(), and L.

Referenced by check_url_association().

Here is the call graph for this function:

Here is the caller graph for this function:

checked_tab()

bool Slic3r::GUI::GUI_App::checked_tab

(

Tab *

tab

)

{
    bool ret = true;
    if (find(tabs_list.begin(), tabs_list.end(), tab) == tabs_list.end() &&
        find(model_tabs_list.begin(), model_tabs_list.end(), tab) == model_tabs_list.end())
        ret = false;
    return ret;
}

References checked_tab(), model_tabs_list, and tabs_list.

Referenced by checked_tab().

Here is the call graph for this function:

Here is the caller graph for this function:

CleanUp()

void Slic3r::GUI::GUI_App::CleanUp ( )

override

{
    // OnExit() does not run when OnInit() fails, and m_agent is then still set. Stop the check before
    // wxApp::CleanUp() resets wxTheApp, which a result posted from the worker would still be using.
    stop_orca_health_check(m_agent);
    wxApp::CleanUp();
}

References CleanUp(), and m_agent.

Referenced by CleanUp().

Here is the call graph for this function:

Here is the caller graph for this function:

cloud_webview_handoff()

wxString Slic3r::GUI::GUI_App::cloud_webview_handoff

(

const std::string &

next = std::string()

)

{
    // The cloud pane loads the Start URL, not a token: the page checks the webview's own session
    // and asks for a handoff itself (guide §4). Signed out, user_id is omitted and the page will
    // post request_web_session, which is what opens the desktop login dialog.
    auto orca = get_orca_cloud_agent(m_agent);
    if (!orca)
        return {};
    return from_u8(orca->build_web_session_start_url(next));
}

References cloud_webview_handoff(), Slic3r::GUI::from_u8(), Slic3r::GUI::get_orca_cloud_agent(), and m_agent.

Referenced by cloud_webview_handoff(), on_user_login_handle(), and open_orca_cloud().

Here is the call graph for this function:

Here is the caller graph for this function:

code_font()

const wxFont & Slic3r::GUI::GUI_App::code_font ( )

inline

{ return m_code_font; }

References m_code_font.

config_wizard_startup()

bool Slic3r::GUI::GUI_App::config_wizard_startup ( )

private

{
    if (!m_app_conf_exists || preset_bundle->printers.only_default_printers()) {
        BOOST_LOG_TRIVIAL(info) << "run wizard...";
        run_wizard(ConfigWizard::RR_DATA_EMPTY);
        BOOST_LOG_TRIVIAL(info) << "finished run wizard";
        return true;
    } /*else if (get_app_config()->legacy_datadir()) {
        // Looks like user has legacy pre-vendorbundle data directory,
        // explain what this is and run the wizard
 
        MsgDataLegacy dlg;
        dlg.ShowModal();
 
        run_wizard(ConfigWizard::RR_DATA_LEGACY);
        return true;
    }*/
    return false;
}

References config_wizard_startup(), m_app_conf_exists, preset_bundle, Slic3r::GUI::ConfigWizard::RR_DATA_EMPTY, and run_wizard().

Referenced by config_wizard_startup(), and post_init().

Here is the call graph for this function:

Here is the caller graph for this function:

copy_network_if_available()

void Slic3r::GUI::GUI_App::copy_network_if_available ( )

private

{
    if (app_config->get("update_network_plugin") != "true")
        return;
 
    bool had_cache = false;
    bool installed = install_network_plugin_from_ota(had_cache);
    // Success consumes the cache and a missing cache leaves nothing to do; only a
    // failed copy keeps the flag so the install is retried on the next launch.
    if (installed || !had_cache)
        app_config->set("update_network_plugin", "false");
}

References app_config, copy_network_if_available(), and install_network_plugin_from_ota().

Referenced by copy_network_if_available(), and on_init_inner().

Here is the call graph for this function:

Here is the caller graph for this function:

copy_older_config()

void Slic3r::GUI::GUI_App::copy_older_config ( )

private

{
    preset_bundle->copy_files(m_older_data_dir_path);
}

References copy_older_config(), m_older_data_dir_path, and preset_bundle.

Referenced by copy_older_config(), and on_init_inner().

Here is the call graph for this function:

Here is the caller graph for this function:

current_language_code()

wxString Slic3r::GUI::GUI_App::current_language_code ( ) const

inline

{ return m_active_language_code.empty() && m_wxLocale ? m_wxLocale->GetCanonicalName() : m_active_language_code; }

References m_active_language_code, and m_wxLocale.

Referenced by current_language_code_safe(), open_mall_page_dialog(), open_publish_page_dialog(), and post_init().

Here is the caller graph for this function:

current_language_code_safe()

wxString Slic3r::GUI::GUI_App::current_language_code_safe

(

)

const

{
  // Translate the language code to a code, for which Prusa Research maintains translations.
  const std::map<wxString, wxString> mapping {
    { "cs",   "cs_CZ", },
    { "sk",   "cs_CZ", },
    { "de",   "de_DE", },
    { "nl",   "nl_NL", },
    { "sv",   "sv_SE", },
    { "es",   "es_ES", },
    { "fr",   "fr_FR", },
    { "it",   "it_IT", },
    { "ja",   "ja_JP", },
    { "ko",   "ko_KR", },
    { "pl",   "pl_PL", },
    { "uk",   "uk_UA", },
    { "zh",   "zh_CN", },
    { "ru",   "ru_RU", },
        { "tr",   "tr_TR", },
        { "pt",   "pt_BR", },
        { "lt",   "lt_LT", },
        { "vi",   "vi_VN", },
        { "th",   "th_TH", },
  };
  wxString language_code = this->current_language_code().BeforeFirst('_');
  auto it = mapping.find(language_code);
  if (it != mapping.end())
    language_code = it->second;
  else
    language_code = "en_US";
  return language_code;
}

References current_language_code(), and current_language_code_safe().

Referenced by Slic3r::anonymous_namespace{PluginHostApp.cpp}::app_info(), current_language_code_safe(), and open_web_page_localized().

Here is the call graph for this function:

Here is the caller graph for this function:

dark_mode()

bool Slic3r::GUI::GUI_App::dark_mode ( )

static

{
#ifdef SUPPORT_DARK_MODE
#if __APPLE__
    // The check for dark mode returns false positive on 10.12 and 10.13,
    // which allowed setting dark menu bar and dock area, which is
    // is detected as dark mode. We must run on at least 10.14 where the
    // proper dark mode was first introduced.
    return wxPlatformInfo::Get().CheckOSVersion(10, 14) && mac_dark_mode();
#else
    // When the user has explicitly chosen a mode, honour it directly.
    // Falling through to check_dark_mode() for an explicit "0" would query
    // wxSystemSettings::GetAppearance().IsDark(), which is contaminated by
    // wxWidgets 3.3's MSWEnableDarkMode(DarkMode_Auto) and can return true
    // even though the user asked for light mode.
    const auto &val = wxGetApp().app_config->get("dark_color_mode");
    if (val == "1") return true;
    if (val == "0") return false;
    return check_dark_mode();
#endif
#else
    //BBS disable DarkUI mode
    return false;
#endif
}

References Slic3r::GUI::check_dark_mode(), dark_mode(), and Slic3r::GUI::mac_dark_mode().

Referenced by dark_mode(), force_colors_update(), get_label_default_clr_modified(), get_label_default_clr_system(), init_label_colours(), on_init_inner(), Update_dark_mode_flag(), and UpdateDVCDarkUI().

Here is the call graph for this function:

Here is the caller graph for this function:

delete_preset_from_cloud()

void Slic3r::GUI::GUI_App::delete_preset_from_cloud	(	std::string	setting_id,
		std::string	preset_file_path )

{
    std::scoped_lock l(mutex_delete_cache_presets);
    fs::path info_path = fs::path(preset_file_path);
    info_path.replace_extension("info");
    need_delete_presets.emplace(setting_id, info_path.string());
}

References delete_preset_from_cloud(), Slic3r::GUI::mutex_delete_cache_presets, and need_delete_presets.

Referenced by delete_preset_from_cloud(), and scan_orphaned_info_files().

Here is the call graph for this function:

Here is the caller graph for this function:

disassociate_files()

void Slic3r::GUI::GUI_App::disassociate_files

(

std::wstring

extend

)

{
#ifdef WIN32
    if (is_running_in_msix())
        return;
    wchar_t app_path[MAX_PATH];
    ::GetModuleFileNameW(nullptr, app_path, sizeof(app_path));
 
    std::wstring prog_path = L"\"" + std::wstring(app_path) + L"\"";
    std::wstring prog_id = L" Orca.Slicer.1";
    std::wstring prog_desc = L"OrcaSlicer";
    std::wstring prog_command = prog_path + L" \"%1\"";
    std::wstring reg_base = L"Software\\Classes";
    std::wstring reg_extension = reg_base + L"\\." + extend;
    std::wstring reg_prog_id = reg_base + L"\\" + prog_id;
    std::wstring reg_prog_id_command = reg_prog_id + L"\\Shell\\Open\\Command";
 
    bool is_new = false;
    is_new |= del_win_registry(HKEY_CURRENT_USER, reg_extension.c_str(), prog_id.c_str());
 
    bool is_associate_3mf  = app_config->get("associate_3mf") == "true";
    bool is_associate_stl  = app_config->get("associate_stl") == "true";
    bool is_associate_step = app_config->get("associate_step") == "true";
    if (!is_associate_3mf && !is_associate_stl && !is_associate_step)
    {
        is_new |= del_win_registry(HKEY_CURRENT_USER, reg_prog_id.c_str(), prog_desc.c_str());
        is_new |= del_win_registry(HKEY_CURRENT_USER, reg_prog_id_command.c_str(), prog_command.c_str());
    }
 
    if (is_new)
       ::SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_IDLIST, nullptr, nullptr);
#endif // WIN32
}

References app_config, disassociate_files(), Slic3r::GUI::is_running_in_msix(), and L.

Referenced by disassociate_files().

Here is the call graph for this function:

Here is the caller graph for this function:

disassociate_url()

void Slic3r::GUI::GUI_App::disassociate_url

(

std::wstring

url_prefix

)

{
#ifdef WIN32
    if (is_running_in_msix())
        return;
    wxRegKey key_full(wxRegKey::HKCU, L"Software\\Classes\\" + url_prefix + L"\\shell\\open\\command");
    if (!key_full.Exists()) {
        return;
    }
    key_full = "";
#endif // WIN32
}

References disassociate_url(), Slic3r::GUI::is_running_in_msix(), and L.

Referenced by disassociate_url().

Here is the call graph for this function:

Here is the caller graph for this function:

download_plugin()

int Slic3r::GUI::GUI_App::download_plugin	(	std::string	name,
		std::string	package_name,
		InstallProgressFn	pro_fn = nullptr,
		WasCancelledFn	cancel_fn = nullptr )

{
    int result = 0;
    json j;
    std::string err_msg;
 
    // get country_code
    AppConfig* app_config = wxGetApp().app_config;
    if (!app_config) {
        j["result"] = "failed";
        j["error_msg"] = "app_config is nullptr";
        return -1;
    }
 
    BOOST_LOG_TRIVIAL(info) << "[download_plugin]: enter";
    m_networking_cancel_update = false;
    // get temp path
    fs::path target_file_path = (fs::temp_directory_path() / package_name);
    fs::path tmp_path = target_file_path;
    tmp_path += format(".%1%%2%", get_current_pid(), ".tmp");
 
    // Determine OS type for plugin download (must be set per-request since global
    // extra headers are no longer initialised on this branch).
#if defined(__WINDOWS__)
    std::string os_type = (is_running_on_arm64() && !use_legacy_network_plugin()) ? "windows_arm" : "windows";
#elif defined(__APPLE__)
    std::string os_type = "macos";
#elif defined(__linux__)
    std::string os_type = "linux";
#else
    std::string os_type = "windows";
#endif
 
    // get_url
    std::string  url = get_plugin_url(name, app_config->get_country_code());
    std::string download_url;
    Slic3r::Http http_url = Slic3r::Http::get(url);
    BOOST_LOG_TRIVIAL(info) << "[download_plugin]: check the plugin from " << url;
    http_url.timeout_connect(TIMEOUT_CONNECT)
        .timeout_max(TIMEOUT_RESPONSE)
        .header("X-BBL-OS-Type", os_type)
        .on_complete(
        [&download_url](std::string body, unsigned status) {
            try {
                json j = json::parse(body);
                std::string message = j["message"].get<std::string>();
 
                if (message == "success") {
                    json resource = j.at("resources");
                    if (resource.is_array()) {
                        for (auto iter = resource.begin(); iter != resource.end(); iter++) {
                            Semver version;
                            std::string version_str;
                            std::string url;
                            std::string type;
                            std::string vendor;
                            std::string description;
                            for (auto sub_iter = iter.value().begin(); sub_iter != iter.value().end(); sub_iter++) {
                                if (boost::iequals(sub_iter.key(), "type")) {
                                    type = sub_iter.value();
                                    BOOST_LOG_TRIVIAL(info) << "[download_plugin]: get version of settings's type, " << sub_iter.value();
                                }
                                else if (boost::iequals(sub_iter.key(), "version")) {
                                    version_str = sub_iter.value();
                                    version = *(Semver::parse(version_str));
                                }
                                else if (boost::iequals(sub_iter.key(), "description")) {
                                    description = sub_iter.value();
                                }
                                else if (boost::iequals(sub_iter.key(), "url")) {
                                    url = sub_iter.value();
                                }
                            }
                            BOOST_LOG_TRIVIAL(info) << "[download_plugin 1]: get type " << type << ", version " << version.to_string() << ", url " << url;
                            download_url = url;
                        }
                    }
                }
                else {
                    BOOST_LOG_TRIVIAL(info) << "[download_plugin 1]: get version of plugin failed, body=" << body;
                }
            }
            catch (...) {
                BOOST_LOG_TRIVIAL(error) << "[download_plugin 1]: catch unknown exception";
                ;
            }
        }).on_error(
            [&result, &err_msg](std::string body, std::string error, unsigned int status) {
                BOOST_LOG_TRIVIAL(error) << "[download_plugin 1] on_error: " << error<<", body = " << body;
                err_msg += "[download_plugin 1] on_error: " + error + ", body = " + body;
                result = -1;
        }).perform_sync();
 
    bool cancel = false;
    if (result < 0) {
        j["result"] = "failed";
        j["error_msg"] = err_msg;
        if (pro_fn) pro_fn(InstallStatusDownloadFailed, 0, cancel);
        return result;
    }
 
 
    if (download_url.empty()) {
        BOOST_LOG_TRIVIAL(info) << "[download_plugin 1]: no available plugin found for this app version: " << SLIC3R_VERSION;
        if (pro_fn) pro_fn(InstallStatusDownloadFailed, 0, cancel);
        j["result"] = "failed";
        j["error_msg"] = "[download_plugin 1]: no available plugin found for this app version: " + std::string(SLIC3R_VERSION);
        return -1;
    }
    else if (pro_fn) {
        pro_fn(InstallStatusNormal, 5, cancel);
    }
 
    if (m_networking_cancel_update || cancel) {
        BOOST_LOG_TRIVIAL(info) << boost::format("[download_plugin 1]: %1%, cancelled by user") % __LINE__;
        j["result"] = "failed";
        j["error_msg"] = (boost::format("[download_plugin 1]: %1%, cancelled by user") % __LINE__).str();
        return -1;
    }
    BOOST_LOG_TRIVIAL(info) << "[download_plugin] get_url = " << download_url;
 
    // download
    Slic3r::Http http = Slic3r::Http::get(download_url);
    int reported_percent = 0;
    http.header("X-BBL-OS-Type", os_type)
        .on_progress(
        [this, &pro_fn, cancel_fn, &result, &reported_percent, &err_msg](Slic3r::Http::Progress progress, bool& cancel) {
            int percent = 0;
            if (progress.dltotal != 0)
                percent = progress.dlnow * 50 / progress.dltotal;
            bool was_cancel = false;
            if (pro_fn && ((percent - reported_percent) >= 10)) {
                pro_fn(InstallStatusNormal, percent, was_cancel);
                reported_percent = percent;
                BOOST_LOG_TRIVIAL(info) << "[download_plugin 2] progress: " << reported_percent;
            }
            cancel = m_networking_cancel_update || was_cancel;
            if (cancel_fn)
                if (cancel_fn())
                    cancel = true;
 
            if (cancel) {
                err_msg += "[download_plugin] cancel";
                result = -1;
            }
        })
        .on_complete([&pro_fn, tmp_path, target_file_path](std::string body, unsigned status) {
            BOOST_LOG_TRIVIAL(info) << "[download_plugin 2] completed";
            bool cancel = false;
            int percent = 0;
            fs::fstream file(tmp_path, std::ios::out | std::ios::binary | std::ios::trunc);
            file.write(body.c_str(), body.size());
            file.close();
            fs::rename(tmp_path, target_file_path);
            if (pro_fn) pro_fn(InstallStatusDownloadCompleted, 80, cancel);
            })
        .on_error([&pro_fn, &result, &err_msg](std::string body, std::string error, unsigned int status) {
            bool cancel = false;
            if (pro_fn) pro_fn(InstallStatusDownloadFailed, 0, cancel);
            BOOST_LOG_TRIVIAL(error) << "[download_plugin 2] on_error: " << error<<", body = " << body;
            err_msg += "[download_plugin 2] on_error: " + error + ", body = " + body;
            result = -1;
        });
    http.perform_sync();
 
    // No version adoption: the stored identity is the AA.BB.CC series, so install_plugin() names
    // the library after the configured series regardless of which build the series-keyed endpoint
    // served (02.08.01.53). The series config never diverges from the file name, so there is
    // nothing to adopt.
    j["result"] = result < 0 ? "failed" : "success";
    j["error_msg"] = err_msg;
    return result;
}

References app_config, Slic3r::Http::Progress::dlnow, Slic3r::Http::Progress::dltotal, Slic3r::GUI::format(), Slic3r::Http::get(), Slic3r::get_current_pid(), get_plugin_url(), Slic3r::Http::header(), Slic3r::http, Slic3r::GUI::InstallStatusDownloadCompleted, Slic3r::GUI::InstallStatusDownloadFailed, Slic3r::GUI::InstallStatusNormal, m_networking_cancel_update, Slic3r::Http::on_complete(), Slic3r::Semver::parse(), TIMEOUT_CONNECT, Slic3r::Http::timeout_connect(), Slic3r::Http::timeout_max(), TIMEOUT_RESPONSE, Slic3r::Semver::to_string(), and use_legacy_network_plugin().

Here is the call graph for this function:

download_project()

void Slic3r::GUI::GUI_App::download_project

(

std::string

project_id

)

{
    if (plater_) {
        plater_->request_download_project(project_id);
    }
}

References download_project(), and plater_.

Referenced by download_project(), and request_project_download().

Here is the call graph for this function:

Here is the caller graph for this function:

downloader()

Downloader * Slic3r::GUI::GUI_App::downloader

(

)

{
    return m_downloader.get();
}

References downloader(), and m_downloader.

Referenced by downloader().

Here is the call graph for this function:

Here is the caller graph for this function:

drain_pending_events()

void Slic3r::GUI::GUI_App::drain_pending_events ( int timeout_ms )

private

{
    const auto deadline = std::chrono::steady_clock::now() +
                          std::chrono::milliseconds(timeout_ms);
    int yield_count = 0;
 
    while (std::chrono::steady_clock::now() < deadline) {
        // Process pending events
        if (wxTheApp) {
            wxTheApp->ProcessPendingEvents();
        }
 
        // Bounded wxYield to prevent infinite loops
        if (yield_count < MAX_YIELD_ITERATIONS) {
            wxYield();
            ++yield_count;
        }
 
        std::this_thread::sleep_for(std::chrono::milliseconds(POLL_INTERVAL_MS));
    }
}

Referenced by hot_reload_network_plugin().

Here is the caller graph for this function:

em_unit()

int Slic3r::GUI::GUI_App::em_unit ( ) const

inline

{ return m_em_unit; }

References m_em_unit.

enable_developer_mode()

void Slic3r::GUI::GUI_App::enable_developer_mode

(

)

{
    app_config->set_bool("developer_mode", true);
    update_mode();
}

References app_config, enable_developer_mode(), and update_mode().

Referenced by enable_developer_mode().

Here is the call graph for this function:

Here is the caller graph for this function:

enable_user_preset_folder()

void Slic3r::GUI::GUI_App::enable_user_preset_folder

(

bool

enable

)

{
    if (enable) {
        std::string user_id = m_agent->get_user_id();
        app_config->set("preset_folder", user_id);
        GUI::wxGetApp().preset_bundle->update_user_presets_directory(user_id);
        PluginManager::instance().set_cloud_user(user_id);
    } else {
        BOOST_LOG_TRIVIAL(info) << "preset_folder: set to empty";
        app_config->set("preset_folder", "");
        GUI::wxGetApp().preset_bundle->update_user_presets_directory(DEFAULT_USER_FOLDER_NAME);
        PluginManager::instance().set_cloud_user("");
    }
}

References app_config, DEFAULT_USER_FOLDER_NAME, enable_user_preset_folder(), Slic3r::PluginManager::instance(), and m_agent.

Referenced by enable_user_preset_folder(), on_init_inner(), on_user_login_handle(), request_user_logout(), and restart_networking().

Here is the call graph for this function:

Here is the caller graph for this function:

enter_force_upgrade()

void Slic3r::GUI::GUI_App::enter_force_upgrade

(

)

{
    wxCommandEvent *evt = new wxCommandEvent(EVT_ENTER_FORCE_UPGRADE);
    GUI::wxGetApp().QueueEvent(evt);
}

References enter_force_upgrade().

Referenced by enter_force_upgrade().

Here is the call graph for this function:

Here is the caller graph for this function:

extract_setting_id_from_info()

std::string Slic3r::GUI::GUI_App::extract_setting_id_from_info ( const std::string & info_file_path )

static

{
    boost::nowide::ifstream file(info_file_path);
    if (!file.is_open())
        return "";
 
    std::string line;
    while (std::getline(file, line)) {
        if (line.find("setting_id") == 0) {
            size_t pos = line.find("=");
            if (pos != std::string::npos) {
                std::string setting_id = line.substr(pos + 1);
                // Trim whitespace
                setting_id.erase(0, setting_id.find_first_not_of(" \t"));
                setting_id.erase(setting_id.find_last_not_of(" \t\r\n") + 1);
                return setting_id;
            }
        }
    }
    return "";
}

References extract_setting_id_from_info().

Referenced by extract_setting_id_from_info(), and scan_orphaned_info_files().

Here is the call graph for this function:

Here is the caller graph for this function:

extruders_cnt()

int Slic3r::GUI::GUI_App::extruders_cnt

(

)

const

{
    const Preset& preset = preset_bundle->printers.get_selected_preset();
    return preset.printer_technology() == ptSLA ? 1 :
           preset.config.option<ConfigOptionFloats>("nozzle_diameter")->values.size();
}

References Slic3r::Preset::config, extruders_cnt(), Slic3r::ConfigBase::option(), preset_bundle, Slic3r::Preset::printer_technology(), and Slic3r::ptSLA.

Referenced by extruders_cnt().

Here is the call graph for this function:

Here is the caller graph for this function:

extruders_edited_cnt()

int Slic3r::GUI::GUI_App::extruders_edited_cnt

(

)

const

{
    const Preset& preset = preset_bundle->printers.get_edited_preset();
    return preset.printer_technology() == ptSLA ? 1 :
           preset.config.option<ConfigOptionFloats>("nozzle_diameter")->values.size();
}

References Slic3r::Preset::config, extruders_edited_cnt(), Slic3r::ConfigBase::option(), preset_bundle, Slic3r::Preset::printer_technology(), and Slic3r::ptSLA.

Referenced by extruders_edited_cnt().

Here is the call graph for this function:

Here is the caller graph for this function:

filaments_cnt()

int Slic3r::GUI::GUI_App::filaments_cnt

(

)

const

{
    return preset_bundle->filament_presets.size();
}

References filaments_cnt(), and preset_bundle.

Referenced by filaments_cnt().

Here is the call graph for this function:

Here is the caller graph for this function:

filter_string()

wxString Slic3r::GUI::GUI_App::filter_string

(

wxString

str

)

{
    std::string result = str.utf8_string();
    std::string input = str.utf8_string();
 
 
    std::regex domainRegex(R"(([a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(?:\.[a-zA-Z]{2,})?))");
    std::sregex_iterator it(input.begin(), input.end(), domainRegex);
    std::sregex_iterator end;
 
    while (it != end) {
        std::smatch match = *it;
        std::string domain = match.str();
        result.replace(match.position(), domain.length(), "[***]");
        ++it;
    }
 
    return wxString::FromUTF8(result);
}

References filter_string().

Referenced by filter_string().

Here is the call graph for this function:

Here is the caller graph for this function:

FilterEvent()

int Slic3r::GUI::GUI_App::FilterEvent ( wxEvent & event )

override

{
    if ((!event.IsCommandEvent() && (event.GetEventCategory() & wxEVT_CATEGORY_USER_INPUT)) ||
        (event.GetEventType() == wxEVT_SIZE && event.GetEventObject() == mainframe))
        m_last_input = std::chrono::steady_clock::now();
    return Event_Skip;
}

References FilterEvent(), m_last_input, and mainframe.

Referenced by FilterEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

focus_mode()

bool Slic3r::GUI::GUI_App::focus_mode ( ) const

inline

{ return app_config->get_bool("focus_mode"); }

References app_config.

Referenced by toggle_focus_mode().

Here is the caller graph for this function:

force_colors_update()

void Slic3r::GUI::GUI_App::force_colors_update

(

)

{
#ifdef _MSW_DARK_MODE
#ifdef __WINDOWS__
    NppDarkMode::SetDarkMode(dark_mode());
#if wxVERSION_NUMBER < 3300
    if (WXHWND wxHWND = wxToolTip::GetToolTipCtrl())
        NppDarkMode::SetDarkExplorerTheme((HWND)wxHWND);
#endif
    NppDarkMode::SetDarkTitleBar(mainframe->GetHWND());
 
 
    //NppDarkMode::SetDarkExplorerTheme((HWND)mainframe->m_settings_dialog.GetHWND());
    //NppDarkMode::SetDarkTitleBar(mainframe->m_settings_dialog.GetHWND());
 
#endif // __WINDOWS__
#endif //_MSW_DARK_MODE
    m_force_colors_update = true;
}

References dark_mode(), force_colors_update(), m_force_colors_update, mainframe, NppDarkMode::SetDarkExplorerTheme(), NppDarkMode::SetDarkMode(), and NppDarkMode::SetDarkTitleBar().

Referenced by force_colors_update().

Here is the call graph for this function:

Here is the caller graph for this function:

force_menu_update()

void Slic3r::GUI::GUI_App::force_menu_update

(

)

force_push_conflicting_preset()

void Slic3r::GUI::GUI_App::force_push_conflicting_preset

(

const std::string &

setting_id

)

{
    if (setting_id.empty() || !preset_bundle)
        return;
 
    // Queue the id so the next push-sync re-uploads this preset with force=true.
    {
        std::scoped_lock lock(conflict_ids_mutex);
        m_pending_conflict_setting_ids.push_back(setting_id);
    }
 
    const std::string user_id = m_agent ? m_agent->get_user_id() : std::string();
 
    // The 409 left this preset on "hold", which get_user_presets() skips. Restore it to
    // "update" so the next push-sync re-includes it and consumes the queued force flag.
    // (We must NOT pull from the cloud here as the Pull path does — that would overwrite
    // the local changes the user is trying to force-push.)
    // For a -3 tombstone on a newly created preset the on-disk setting_id is EMPTY (it only
    // gets assigned after a successful first push), so derive it on the fly from the preset
    // name and stamp it onto the preset — otherwise sync_with_lock's `id == preset.setting_id`
    // check never fires and the force-push silently no-ops.
    PresetCollection* collections[] = {&preset_bundle->prints, &preset_bundle->filaments, &preset_bundle->printers};
    for (PresetCollection* coll : collections) {
        for (const Preset& preset : coll->get_presets()) {
            if (preset.sync_info != "hold")
                continue;
            const std::string preset_id = preset.setting_id.empty()
                ? OrcaCloudServiceAgent::generate_uuid_for_setting_id(preset.name, user_id)
                : preset.setting_id;
            if (preset_id == setting_id) {
                coll->set_sync_info_and_save(preset.name, setting_id, "update", 0, user_id);
                break;
            }
        }
    }
 
    // Nudge the sync loop to push on its next tick instead of waiting for the 60s cadence.
    m_sync_user_presets_now.store(true, std::memory_order_release);
}

References Slic3r::GUI::conflict_ids_mutex, force_push_conflicting_preset(), Slic3r::OrcaCloudServiceAgent::generate_uuid_for_setting_id(), m_agent, m_pending_conflict_setting_ids, m_sync_user_presets_now, and preset_bundle.

Referenced by force_push_conflicting_preset(), and on_http_error().

Here is the call graph for this function:

Here is the caller graph for this function:

format_display_version()

std::string Slic3r::GUI::GUI_App::format_display_version ( )

static

{
    if (!version_display.empty()) return version_display;
 
    version_display = SoftFever_VERSION;
    return version_display;
}

References format_display_version(), and version_display.

Referenced by format_display_version(), and Slic3r::GUI::AboutDialog::onCopyToClipboard().

Here is the call graph for this function:

Here is the caller graph for this function:

format_IP()

std::string Slic3r::GUI::GUI_App::format_IP

(

const std::string &

ip

)

{
    std::string format_ip = ip;
    size_t pos_st = 0;
    size_t pos_en = 0;
 
    for (int i = 0; i < 2; i++) {
        pos_en = format_ip.find('.', pos_st + 1);
        if (pos_en == std::string::npos) {
            return ip;
        }
        format_ip.replace(pos_st, pos_en - pos_st, "***");
        pos_st = pos_en + 1;
    }
 
    return format_ip;
}

References format_IP().

Referenced by format_IP().

Here is the call graph for this function:

Here is the caller graph for this function:

from_hex()

char Slic3r::GUI::GUI_App::from_hex

(

char

ch

)

                              {
    return isdigit(ch) ? ch - '0' : tolower(ch) - 'a' + 10;
}

References from_hex().

Referenced by from_hex().

Here is the call graph for this function:

Here is the caller graph for this function:

get_app_mode()

EAppMode Slic3r::GUI::GUI_App::get_app_mode ( ) const

inline

{ return m_app_mode; }

References m_app_mode.

get_bbl_client_version()

std::string Slic3r::GUI::GUI_App::get_bbl_client_version

(

)

{
    if (BBLNetworkPlugin::instance().get_get_my_token() == nullptr) {
        return "01.10.01.50";
    }
    return VersionInfo::convert_full_version(SLIC3R_VERSION);
}

References Slic3r::GUI::VersionInfo::convert_full_version(), get_bbl_client_version(), and Slic3r::BBLNetworkPlugin::instance().

Referenced by get_bbl_client_version().

Here is the call graph for this function:

Here is the caller graph for this function:

get_color_hovered_btn_label()

const wxColour & Slic3r::GUI::GUI_App::get_color_hovered_btn_label ( )

inline

{ return m_color_hovered_btn_label; }

References m_color_hovered_btn_label.

get_color_selected_btn_bg()

const wxColour & Slic3r::GUI::GUI_App::get_color_selected_btn_bg ( )

inline

{ return m_color_selected_btn_bg; }

References m_color_selected_btn_bg.

get_colour_approx_luma()

unsigned Slic3r::GUI::GUI_App::get_colour_approx_luma ( const wxColour & colour )

static

{
    double r = colour.Red();
    double g = colour.Green();
    double b = colour.Blue();
 
    return std::round(std::sqrt(
        r * r * .241 +
        g * g * .691 +
        b * b * .068
        ));
}

References get_colour_approx_luma().

Referenced by get_colour_approx_luma().

Here is the call graph for this function:

Here is the caller graph for this function:

get_current_shader()

GLShaderProgram * Slic3r::GUI::GUI_App::get_current_shader ( )

inline

{ return m_opengl_mgr.get_current_shader(); }

References m_opengl_mgr.

get_delete_cache_presets()

std::map< std::string, std::string > & Slic3r::GUI::GUI_App::get_delete_cache_presets

(

)

{
    return need_delete_presets;
}

References get_delete_cache_presets(), and need_delete_presets.

Referenced by get_delete_cache_presets(), and reload_settings().

Here is the call graph for this function:

Here is the caller graph for this function:

get_delete_cache_presets_lock()

std::map< std::string, std::string > Slic3r::GUI::GUI_App::get_delete_cache_presets_lock

(

)

{
    std::scoped_lock l(mutex_delete_cache_presets);
    return need_delete_presets;
}

References get_delete_cache_presets_lock(), Slic3r::GUI::mutex_delete_cache_presets, and need_delete_presets.

Referenced by get_delete_cache_presets_lock(), and process_delete_presets().

Here is the call graph for this function:

Here is the caller graph for this function:

get_download_model_name()

std::string Slic3r::GUI::GUI_App::get_download_model_name ( )

inline

{return m_mall_model_download_name;}

References m_mall_model_download_name.

get_download_model_url()

std::string Slic3r::GUI::GUI_App::get_download_model_url ( )

inline

{return m_mall_model_download_url;}

References m_mall_model_download_url.

get_filament_color_code_query()

FilamentColorCodeQuery * Slic3r::GUI::GUI_App::get_filament_color_code_query

(

)

{
    if (!m_filament_color_code_query)
    {
        m_filament_color_code_query = new FilamentColorCodeQuery();
    }
 
    return m_filament_color_code_query;
}

References get_filament_color_code_query(), and m_filament_color_code_query.

Referenced by get_filament_color_code_query().

Here is the call graph for this function:

Here is the caller graph for this function:

get_gl_info()

std::string Slic3r::GUI::GUI_App::get_gl_info ( bool for_github )

static

{
    return OpenGLManager::get_gl_info().to_string(for_github);
}

References get_gl_info(), and Slic3r::GUI::OpenGLManager::get_gl_info().

Referenced by get_gl_info().

Here is the call graph for this function:

Here is the caller graph for this function:

get_highlight_default_clr()

const wxColour & Slic3r::GUI::GUI_App::get_highlight_default_clr ( )

inline

{ return m_color_highlight_default; }

References m_color_highlight_default.

Referenced by Slic3r::GUI::anonymous_namespace{WebViewHostDialog.cpp}::host_theme_vars_css().

Here is the caller graph for this function:

get_hms_query()

HMSQuery * Slic3r::GUI::GUI_App::get_hms_query ( )

inline

{ return hms_query; }

References hms_query.

get_http_url()

std::string Slic3r::GUI::GUI_App::get_http_url	(	std::string	country_code,
		std::string	path = {} )

{
    std::string url;
    if (country_code == "US") {
        url = "https://api.bambulab.com/";
    }
    else if (country_code == "CN") {
        url = "https://api.bambulab.cn/";
    }
    else if (country_code == "ENV_CN_DEV") {
        url = "https://api-dev.bambu-lab.com/";
    }
    else if (country_code == "ENV_CN_QA") {
        url = "https://api-qa.bambu-lab.com/";
    }
    else if (country_code == "ENV_CN_PRE") {
        url = "https://api-pre.bambu-lab.com/";
    }
    else {
        url = "https://api.bambulab.com/";
    }
 
    url += path.empty() ? "v1/iot-service/api/slicer/resource" : path;
    return url;
}

Referenced by check_new_version(), check_privacy_version(), get_plugin_url(), and post_init().

Here is the caller graph for this function:

get_inf_dialog_contect()

wxString Slic3r::GUI::GUI_App::get_inf_dialog_contect ( )

inline

{return m_info_dialog_content;};

References m_info_dialog_content.

get_instance_hash_int()

size_t Slic3r::GUI::GUI_App::get_instance_hash_int ( )

inline

{ return m_instance_hash_int; }

References m_instance_hash_int.

get_instance_hash_string()

std::string Slic3r::GUI::GUI_App::get_instance_hash_string ( )

inline

{ return m_instance_hash_string; }

References m_instance_hash_string.

get_label_clr_default()

const wxColour & Slic3r::GUI::GUI_App::get_label_clr_default ( )

inline

{ return m_color_label_default; }

References m_color_label_default.

Referenced by Slic3r::GUI::anonymous_namespace{WebViewHostDialog.cpp}::host_theme_vars_css().

Here is the caller graph for this function:

get_label_clr_modified()

const wxColour & Slic3r::GUI::GUI_App::get_label_clr_modified ( )

inline

{ return m_color_label_modified; }

References m_color_label_modified.

get_label_clr_sys()

const wxColour & Slic3r::GUI::GUI_App::get_label_clr_sys ( )

inline

{ return m_color_label_sys; }

References m_color_label_sys.

Referenced by Slic3r::GUI::anonymous_namespace{WebViewHostDialog.cpp}::host_theme_vars_css().

Here is the caller graph for this function:

get_label_default_clr_modified()

const wxColour Slic3r::GUI::GUI_App::get_label_default_clr_modified

(

)

{
    return dark_mode() ? wxColour(253, 111, 40) : wxColour(252, 77, 1);
}

References dark_mode(), and get_label_default_clr_modified().

Referenced by get_label_default_clr_modified().

Here is the call graph for this function:

Here is the caller graph for this function:

get_label_default_clr_system()

const wxColour Slic3r::GUI::GUI_App::get_label_default_clr_system

(

)

{
    return dark_mode() ? wxColour(115, 220, 103) : wxColour(26, 132, 57);
}

References dark_mode(), and get_label_default_clr_system().

Referenced by get_label_default_clr_system().

Here is the call graph for this function:

Here is the caller graph for this function:

get_label_highlight_clr()

const wxColour & Slic3r::GUI::GUI_App::get_label_highlight_clr ( )

inline

{ return m_color_highlight_label_default; }

References m_color_highlight_label_default.

get_latest_network_version()

std::string Slic3r::GUI::GUI_App::get_latest_network_version

(

)

const

{
    return Slic3r::get_latest_network_version();
}

References Slic3r::get_latest_network_version().

Referenced by check_networking_version(), get_plugin_url(), has_network_update_available(), install_plugin(), on_init_network(), and show_network_plugin_download_dialog().

Here is the call graph for this function:

Here is the caller graph for this function:

get_layer_tab()

Tab * Slic3r::GUI::GUI_App::get_layer_tab

(

)

{
    return model_tabs_list[2];
}

References get_layer_tab(), and model_tabs_list.

Referenced by get_layer_tab().

Here is the call graph for this function:

Here is the caller graph for this function:

get_local_models_path()

std::string Slic3r::GUI::GUI_App::get_local_models_path

(

)

{
    std::string local_path = "";
    if (data_dir().empty()) {
        return local_path;
    }
 
    auto models_folder = (boost::filesystem::path(data_dir()) / "models");
    local_path = models_folder.string();
 
    if (!fs::exists(models_folder)) {
        if (!fs::create_directory(models_folder)) {
            local_path = "";
        }
        BOOST_LOG_TRIVIAL(info) << "create models folder:" << models_folder.string();
    }
    return local_path;
}

References Slic3r::data_dir(), Slic3r::empty(), and get_local_models_path().

Referenced by get_local_models_path().

Here is the call graph for this function:

Here is the caller graph for this function:

get_login_info()

void Slic3r::GUI::GUI_App::get_login_info

(

const std::string &

provider = ORCA_CLOUD_PROVIDER

)

{
    if (m_agent) {
        if (m_agent->is_user_login(provider)) {
            std::string login_cmd = m_agent->build_login_cmd(provider);
            wxString strJS = wxString::Format("window.postMessage(%s)", from_u8(login_cmd));
            GUI::wxGetApp().run_script(strJS);
        } else {
            m_agent->user_logout(false, provider);
            std::string logout_cmd = m_agent->build_logout_cmd(provider);
            wxString    strJS      = wxString::Format("window.postMessage(%s)", from_u8(logout_cmd));
            GUI::wxGetApp().run_script(strJS);
        }
        if (WebViewPanel* home = WebViewPanel::if_built())
            home->SetLoginPanelVisibility(true);
    }
}

References Slic3r::GUI::from_u8(), get_login_info(), Slic3r::GUI::LazyInstance< WebViewPanel >::if_built(), and m_agent.

Referenced by get_login_info(), handle_web_request(), and request_login().

Here is the call graph for this function:

Here is the caller graph for this function:

get_min_size()

wxSize Slic3r::GUI::GUI_App::get_min_size

(

)

const

{
    return wxSize(76*m_em_unit, 49 * m_em_unit);
}

References get_min_size(), and m_em_unit.

Referenced by get_min_size().

Here is the call graph for this function:

Here is the caller graph for this function:

get_mode()

ConfigOptionMode Slic3r::GUI::GUI_App::get_mode

(

)

{
    return app_config->get_bool("developer_mode") ? comDevelop : get_saved_mode();
}

References app_config, Slic3r::comDevelop, get_mode(), and get_saved_mode().

Referenced by get_mode(), and get_mode_str().

Here is the call graph for this function:

Here is the caller graph for this function:

get_mode_str()

std::string Slic3r::GUI::GUI_App::get_mode_str

(

)

{
    return effective_mode_to_string(get_mode());
}

References get_mode(), and get_mode_str().

Referenced by get_mode_str().

Here is the call graph for this function:

Here is the caller graph for this function:

get_model_http_url()

std::string Slic3r::GUI::GUI_App::get_model_http_url

(

std::string

country_code

)

{
    std::string url;
    if (country_code == "US") {
        url = "https://makerworld.com/";
    }
    else if (country_code == "CN") {
        url = "https://makerworld.com/";
    }
    else if (country_code == "ENV_CN_DEV") {
        url = "https://makerhub-dev.bambu-lab.com/";
    }
    else if (country_code == "ENV_CN_QA") {
        url = "https://makerhub-qa.bambu-lab.com/";
    }
    else if (country_code == "ENV_CN_PRE") {
        url = "https://makerhub-pre.bambu-lab.com/";
    }
    else {
        url = "https://makerworld.com/";
    }
 
    return url;
}

Referenced by open_mall_page_dialog(), and open_publish_page_dialog().

Here is the caller graph for this function:

get_model_tab()

Tab * Slic3r::GUI::GUI_App::get_model_tab

(

bool

part = false

)

{
    return model_tabs_list[part ? 1 : 0];
}

References get_model_tab(), and model_tabs_list.

Referenced by get_model_tab().

Here is the call graph for this function:

Here is the caller graph for this function:

get_opengl_manager()

OpenGLManager & Slic3r::GUI::GUI_App::get_opengl_manager ( )

inline

{ return m_opengl_mgr; }

References m_opengl_mgr.

get_plate_tab()

Tab * Slic3r::GUI::GUI_App::get_plate_tab

(

)

{
    return plate_tab;
}

References get_plate_tab(), and plate_tab.

Referenced by get_plate_tab().

Here is the call graph for this function:

Here is the caller graph for this function:

get_plugin_url()

std::string Slic3r::GUI::GUI_App::get_plugin_url	(	std::string	name,
		std::string	country_code )

{
    std::string url = get_http_url(country_code);
 
    std::string curr_version;
    if (use_legacy_network_plugin()) {
        curr_version = BAMBU_NETWORK_AGENT_VERSION_LEGACY;
    } else if (name == "plugins" && app_config) {
        std::string user_version = app_config->get_network_plugin_version();
        curr_version = user_version.empty() ? get_latest_network_version() : user_version;
    } else {
        curr_version = get_latest_network_version();
    }
 
    // The cloud endpoint is series-keyed and serves the series' newest build: AA.BB.CC.00.
    // Build it from the series so an 8-char series string (02.08.01) works too.
    std::string using_version = use_legacy_network_plugin()
        ? curr_version.substr(0, 9) + "00"
        : network_plugin_series(curr_version) + ".00";
    if (name == "cameratools")
        using_version = curr_version.substr(0, 6) + "00.00";
    url += (boost::format("?slicer/%1%/cloud=%2%") % name % using_version).str();
    return url;
}

References app_config, BAMBU_NETWORK_AGENT_VERSION_LEGACY, get_http_url(), get_latest_network_version(), Slic3r::network_plugin_series(), and use_legacy_network_plugin().

Referenced by download_plugin().

Here is the call graph for this function:

Here is the caller graph for this function:

get_preset_updater()

PresetUpdater * Slic3r::GUI::GUI_App::get_preset_updater ( )

inline

{ return preset_updater; }

References preset_updater.

get_printer_cloud_provider()

std::string Slic3r::GUI::GUI_App::get_printer_cloud_provider

(

)

const

{
    const std::string agent_id = resolve_printer_agent_id(
        preset_bundle ? preset_bundle->printers.get_edited_preset().config.opt_string("printer_agent")
                      : std::string());
    return agent_id == BBL_PRINTER_AGENT_ID ? BBL_CLOUD_PROVIDER : ORCA_CLOUD_PROVIDER;
}

References Slic3r::BBL_CLOUD_PROVIDER(), Slic3r::BBL_PRINTER_AGENT_ID, get_printer_cloud_provider(), Slic3r::ORCA_CLOUD_PROVIDER(), preset_bundle, and resolve_printer_agent_id().

Referenced by get_printer_cloud_provider(), post_init(), and request_user_logout().

Here is the call graph for this function:

Here is the caller graph for this function:

get_saved_mode()

ConfigOptionMode Slic3r::GUI::GUI_App::get_saved_mode

(

)

{
    if (!app_config->has("user_mode"))
        return comSimple;
 
    return saved_mode_from_string(app_config->get("user_mode"));
}

References app_config, Slic3r::comSimple, and get_saved_mode().

Referenced by get_mode(), get_saved_mode(), get_saved_mode_str(), and save_mode().

Here is the call graph for this function:

Here is the caller graph for this function:

get_saved_mode_str()

std::string Slic3r::GUI::GUI_App::get_saved_mode_str

(

)

{
    return saved_mode_to_string(get_saved_mode());
}

References get_saved_mode(), and get_saved_mode_str().

Referenced by get_saved_mode_str().

Here is the call graph for this function:

Here is the caller graph for this function:

get_selected_presets()

std::vector< std::pair< unsigned int, std::string > > Slic3r::GUI::GUI_App::get_selected_presets

(

)

const

{
    std::vector<std::pair<unsigned int, std::string>> ret;
    PrinterTechnology printer_technology = preset_bundle->printers.get_edited_preset().printer_technology();
    for (Tab* tab : tabs_list) {
        if (tab->supports_printer_technology(printer_technology)) {
            const PresetCollection* presets = tab->get_presets();
            ret.push_back({ static_cast<unsigned int>(presets->type()), presets->get_selected_preset_name() });
        }
    }
    return ret;
}

References Slic3r::PresetCollection::get_presets(), Slic3r::PresetCollection::get_selected_preset_name(), get_selected_presets(), preset_bundle, Slic3r::GUI::printer_technology(), tabs_list, and Slic3r::PresetCollection::type().

Referenced by get_selected_presets(), Slic3r::GUI::ProjectDirtyStateManager::reset_initial_presets(), and Slic3r::GUI::ProjectDirtyStateManager::update_from_presets().

Here is the call graph for this function:

Here is the caller graph for this function:

get_shader()

GLShaderProgram * Slic3r::GUI::GUI_App::get_shader ( const std::string & shader_name )

inline

{ return m_opengl_mgr.get_shader(shader_name); }

References m_opengl_mgr.

Referenced by Slic3r::GUI::TextLinesModel::render().

Here is the caller graph for this function:

get_side_menu_popup_status()

bool Slic3r::GUI::GUI_App::get_side_menu_popup_status

(

)

{
    return m_side_popup_status;
}

References get_side_menu_popup_status(), and m_side_popup_status.

Referenced by get_side_menu_popup_status().

Here is the call graph for this function:

Here is the caller graph for this function:

get_tab()

Tab * Slic3r::GUI::GUI_App::get_tab

(

Preset::Type

type

)

{
    for (Tab* tab: tabs_list)
        if (tab->type() == type)
            return tab->completed() ? tab : nullptr; // To avoid actions with no-completed Tab
    return nullptr;
}

References get_tab(), and tabs_list.

Referenced by check_and_keep_current_preset_changes(), get_tab(), refresh_printer_agent_dropdown(), and Slic3r::anonymous_namespace{PluginHostPresets.cpp}::require_tab().

Here is the call graph for this function:

Here is the caller graph for this function:

get_window_default_clr()

const wxColour & Slic3r::GUI::GUI_App::get_window_default_clr ( )

inline

{ return m_color_window_default; }

References m_color_window_default.

Referenced by Slic3r::GUI::anonymous_namespace{WebViewHostDialog.cpp}::host_theme_vars_css().

Here is the caller graph for this function:

getAgent()

NetworkAgent * Slic3r::GUI::GUI_App::getAgent ( )

inline

{ return m_agent; }

References m_agent.

Referenced by open_mall_page_dialog(), and open_publish_page_dialog().

Here is the caller graph for this function:

getDeviceManager()

Slic3r::DeviceManager * Slic3r::GUI::GUI_App::getDeviceManager ( )

inline

{ return m_device_manager; }

References m_device_manager.

Referenced by is_blocking_printing(), process_network_msg(), Slic3r::anonymous_namespace{PluginHostApp.cpp}::selected_printer(), and set_live_printer_agent().

Here is the caller graph for this function:

GetSingleChoiceIndex()

int Slic3r::GUI::GUI_App::GetSingleChoiceIndex	(	const wxString &	message,
		const wxString &	caption,
		const wxArrayString &	choices,
		int	initialSelection )

{
#ifdef _WIN32
    wxSingleChoiceDialog dialog(nullptr, message, caption, choices);
    dialog.SetBackgroundColour(*wxWHITE);
    wxGetApp().UpdateDlgDarkUI(&dialog);
 
    dialog.SetSelection(initialSelection);
    return dialog.ShowModal() == wxID_OK ? dialog.GetSelection() : -1;
#else
    return wxGetSingleChoiceIndex(message, caption, choices, initialSelection);
#endif
}

References GetSingleChoiceIndex().

Referenced by GetSingleChoiceIndex().

Here is the call graph for this function:

Here is the caller graph for this function:

getTaskManager()

Slic3r::TaskManager * Slic3r::GUI::GUI_App::getTaskManager ( )

inline

{ return m_task_manager; }

References m_task_manager.

global_print_sequence()

PrintSequence Slic3r::GUI::GUI_App::global_print_sequence

(

)

const

{
    PrintSequence global_print_seq = PrintSequence::ByDefault;
    const auto &curr_preset_config = preset_bundle->prints.get_edited_preset().config;
    if (curr_preset_config.has("print_sequence"))
        global_print_seq = curr_preset_config.option<ConfigOptionEnum<PrintSequence>>("print_sequence")->value;
    return global_print_seq;
}

References Slic3r::ByDefault, global_print_sequence(), and preset_bundle.

Referenced by global_print_sequence().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_http_error()

void Slic3r::GUI::GUI_App::handle_http_error	(	unsigned int	status,
		std::string	body,
		const std::string &	provider = "" )

{
    // tips body size must less than 1024
    auto evt = new wxCommandEvent(EVT_HTTP_ERROR);
    evt->SetInt(status);
    // Encode provider into the event string alongside body
    json evt_data;
    evt_data["body"] = body;
    evt_data["provider"] = provider;
    evt->SetString(wxString::FromUTF8(evt_data.dump()));
    wxQueueEvent(this, evt);
}

References handle_http_error().

Referenced by check_new_version(), handle_http_error(), post_init(), and restart_networking().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_script_message()

void Slic3r::GUI::GUI_App::handle_script_message	(	std::string	msg,
		const std::string &	provider = ORCA_CLOUD_PROVIDER )

{
    try {
        json j = json::parse(msg);
        if (j.contains("command")) {
            wxString cmd = j["command"];
            if (cmd == "user_login") {
                if (m_agent) {
                    m_agent->change_user(j.dump(), provider);
                    if (m_agent->is_user_login(provider)) {
                        request_user_login(1, provider);
                    }
                }
            }
        }
    }
    catch (...) {
        ;
    }
}

References handle_script_message(), m_agent, and request_user_login().

Referenced by handle_script_message().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_web_request()

std::string Slic3r::GUI::GUI_App::handle_web_request

(

std::string

cmd

)

{
    try {
        //BBS use nlohmann json format
        std::stringstream ss(cmd), oss;
        pt::ptree root, response;
        pt::read_json(ss, root);
        if (root.empty())
            return "";
 
        boost::optional<std::string> sequence_id = root.get_optional<std::string>("sequence_id");
        boost::optional<std::string> command = root.get_optional<std::string>("command");
        if (command.has_value()) {
            std::string command_str = command.value();
            static const std::unordered_set<std::string> stealth_blocked_info_commands = {
                "get_login_info",
                "get_orca_login_info",
                "get_bambu_login_info",
            };
            static const std::unordered_set<std::string> stealth_blocked_login_commands = {
                "homepage_login_or_register",
                "homepage_orca_login_or_register",
                "homepage_bambu_login_or_register",
            };
            if (app_config->get_stealth_mode() && stealth_blocked_info_commands.count(command_str)) {
                CallAfter([] {
                    if (WebViewPanel* home = WebViewPanel::if_built())
                        home->SendCloudProvidersInfo();
                });
                return "";
            }
            if (app_config->get_stealth_mode() && stealth_blocked_login_commands.count(command_str)) {
                CallAfter([this, command_str] {
                    MessageDialog dlg(mainframe,
                        _L("You are currently in Stealth Mode. To log into the Cloud, you need to disable Stealth Mode first."),
                        _L("Stealth Mode"),
                        wxOK | wxCANCEL | wxCENTRE);
                    dlg.SetButtonLabel(wxID_OK, _L("Quit Stealth Mode"));
                    if (dlg.ShowModal() == wxID_OK) {
                        app_config->set_bool("stealth_mode", false);
                        app_config->save();
                        if (WebViewPanel* home = WebViewPanel::if_built())
                            home->SendCloudProvidersInfo();
                        // Continue with login
                        if (command_str == "homepage_login_or_register")
                            this->request_login(true);
                        else if (command_str == "homepage_orca_login_or_register")
                            this->request_login(true, ORCA_CLOUD_PROVIDER);
                        else if (command_str == "homepage_bambu_login_or_register")
                            this->request_login(true, BBL_CLOUD_PROVIDER);
                    }
                });
                return "";
            }
            if (command_str.compare("request_project_download") == 0) {
                if (root.get_child_optional("data") != boost::none) {
                    pt::ptree data_node = root.get_child("data");
                    boost::optional<std::string> project_id = data_node.get_optional<std::string>("project_id");
                    if (project_id.has_value()) {
                        this->request_project_download(project_id.value());
                    }
                }
            }
            else if (command_str.compare("open_project") == 0) {
                if (root.get_child_optional("data") != boost::none) {
                    pt::ptree data_node = root.get_child("data");
                    boost::optional<std::string> project_id = data_node.get_optional<std::string>("project_id");
                    if (project_id.has_value()) {
                        this->request_open_project(project_id.value());
                    }
                }
            }
            else if (command_str.compare("get_login_info") == 0) {
                CallAfter([this] {
                        get_login_info();
                    });
            }
            else if (command_str.compare("homepage_login_or_register") == 0) {
                CallAfter([this] {
                    this->request_login(true);
                });
            }
            else if (command_str.compare("homepage_logout") == 0) {
                CallAfter([this] {
                    BOOST_LOG_TRIVIAL(info) << "logout: homepage_logout";
                    request_user_logout(ORCA_CLOUD_PROVIDER, /*user_initiated=*/true);
                });
            }
            else if (command_str.compare("get_orca_login_info") == 0) {
                CallAfter([this] { get_login_info(ORCA_CLOUD_PROVIDER); });
            }
            else if (command_str.compare("get_bambu_login_info") == 0) {
                CallAfter([this] { get_login_info(BBL_CLOUD_PROVIDER); });
            }
            else if (command_str.compare("homepage_bambu_login_or_register") == 0) {
                CallAfter([this] { request_login(true, BBL_CLOUD_PROVIDER); });
            }
            else if (command_str.compare("homepage_bambu_logout") == 0) {
                CallAfter([this] {
                    BOOST_LOG_TRIVIAL(info) << "logout: homepage_bambu_logout";
                    request_user_logout(BBL_CLOUD_PROVIDER, /*user_initiated=*/true);
                });
            }
            else if (command_str.compare("homepage_orca_login_or_register") == 0) {
                CallAfter([this] { request_login(true, ORCA_CLOUD_PROVIDER); });
            }
            else if (command_str.compare("homepage_orca_logout") == 0) {
                CallAfter([this] {
                    BOOST_LOG_TRIVIAL(info) << "logout: homepage_orca_logout";
                    request_user_logout(ORCA_CLOUD_PROVIDER, /*user_initiated=*/true);
                });
            }
            else if (command_str.compare("homepage_modeldepot") == 0) {
                CallAfter([this] { open_mall_page_dialog(); });
            }
            else if (command_str.compare("homepage_newproject") == 0) {
                this->request_open_project("<new>");
            }
            else if (command_str.compare("homepage_openproject") == 0) {
                this->request_open_project({});
            }
            else if (command_str.compare("homepage_open_cloud") == 0) {
                this->open_orca_cloud();
            }
            else if (command_str.compare("homepage_close_cloud") == 0) {
                CallAfter([]() {
                    if (WebViewPanel* home = WebViewPanel::if_built())
                        home->set_cloud_mode(false);
                });
            }
            else if (command_str.compare("get_recent_projects") == 0) {
                if (mainframe) {
                    if (WebViewPanel* home = WebViewPanel::if_built()) {
                        home->SendRecentList(INT_MAX);
                    }
                }
            }
            // else if (command_str.compare("modelmall_model_advise_get") == 0) {
            //     if (mainframe && this->app_config->get("staff_pick_switch") == "true") {
            //         if (mainframe->m_webview) {
            //             mainframe->m_webview->SendDesignStaffpick(has_model_mall());
            //         }
            //     }
            // }
            // else if (command_str.compare("modelmall_model_open") == 0) {
            //     if (root.get_child_optional("data") != boost::none) {
            //         pt::ptree data_node = root.get_child("data");
            //         boost::optional<std::string> id = data_node.get_optional<std::string>("id");
            //         if (id.has_value() && mainframe->m_webview) {
            //             mainframe->m_webview->OpenModelDetail(id.value(), m_agent);
            //         }
            //     }
            // }
            else if (command_str.compare("homepage_open_recentfile") == 0) {
                if (root.get_child_optional("data") != boost::none) {
                    pt::ptree data_node = root.get_child("data");
                    boost::optional<std::string> path = data_node.get_optional<std::string>("path");
                    if (path.has_value()) {
                        this->request_open_project(path.value());
                    }
                }
            }
            else if (command_str.compare("homepage_delete_recentfile") == 0) {
                if (root.get_child_optional("data") != boost::none) {
                    pt::ptree                    data_node = root.get_child("data");
                    boost::optional<std::string> path      = data_node.get_optional<std::string>("path");
                    if (path.has_value()) {
                        this->request_remove_project(path.value());
                    }
                }
            }
            else if (command_str.compare("homepage_delete_all_recentfile") == 0) {
                this->request_remove_project("");
            }
            else if (command_str.compare("homepage_explore_recentfile") == 0) {
                if (root.get_child_optional("data") != boost::none) {
                    pt::ptree                    data_node = root.get_child("data");
                    boost::optional<std::string> path      = data_node.get_optional<std::string>("path");
                    if (path.has_value())
                    {
                        boost::filesystem::path NowFile(path.value());
 
                        std::string FilePath = NowFile.make_preferred().string();
                        desktop_open_any_folder(FilePath);
                    }
                }
            }
            else if (command_str.compare("homepage_open_hotspot") == 0) {
                if (root.get_child_optional("data") != boost::none) {
                    pt::ptree data_node = root.get_child("data");
                    boost::optional<std::string> url = data_node.get_optional<std::string>("url");
                    if (url.has_value()) {
                        this->request_open_project(url.value());
                    }
                }
            }
            else if (command_str.compare("begin_network_plugin_download") == 0) {
                CallAfter([] { wxGetApp().ShowDownNetPluginDlg(); });
            }
            else if (command_str.compare("get_web_shortcut") == 0) {
                if (root.get_child_optional("key_event") != boost::none) {
                    pt::ptree key_event_node = root.get_child("key_event");
                    auto keyCode = key_event_node.get<int>("key");
                    auto ctrlKey = key_event_node.get<bool>("ctrl");
                    auto shiftKey = key_event_node.get<bool>("shift");
                    auto cmdKey = key_event_node.get<bool>("cmd");
 
                    wxKeyEvent e(wxEVT_CHAR_HOOK);
#ifdef __APPLE__
                    e.SetControlDown(cmdKey);
                    e.SetRawControlDown(ctrlKey);
#else
                    e.SetControlDown(ctrlKey);
#endif
                    e.SetShiftDown(shiftKey);
                    keyCode     = keyCode == 188 ? ',' : keyCode;
                    e.m_keyCode = keyCode;
                    e.SetEventObject(mainframe);
                    wxPostEvent(mainframe, e);
                }
            }
            else if (command_str.compare("userguide_wiki_open") == 0) {
                if (root.get_child_optional("data") != boost::none) {
                    pt::ptree                    data_node = root.get_child("data");
                    boost::optional<std::string> path      = data_node.get_optional<std::string>("url");
                    if (path.has_value()) {
                        wxLaunchDefaultBrowser(path.value());
                    }
                }
            }
            else if (command_str.compare("homepage_open_ccabin") == 0) {
                if (root.get_child_optional("data") != boost::none) {
                    pt::ptree                    data_node = root.get_child("data");
                    boost::optional<std::string> path      = data_node.get_optional<std::string>("file");
                    if (path.has_value()) {
                        std::string Fullpath = resources_dir() + "/web/homepage/model/" + path.value();
 
                        this->request_open_project(Fullpath);
                    }
                }
            }
            else if (command_str.compare("common_openurl") == 0) {
                boost::optional<std::string> path      = root.get_optional<std::string>("url");
                if (path.has_value()) {
                    wxLaunchDefaultBrowser(path.value());
                }
            } 
            else if (command_str.compare("homepage_makerlab_get") == 0) {
                //if (mainframe->m_webview) { mainframe->m_webview->SendMakerlabList(); }
            }
            else if (command_str.compare("makerworld_model_open") == 0) 
            {
                if (root.get_child_optional("model") != boost::none) {
                    pt::ptree                    data_node = root.get_child("model");
                    boost::optional<std::string> path      = data_node.get_optional<std::string>("url");
                    if (path.has_value()) 
                    { 
                        wxString realurl = from_u8(url_decode(path.value()));
                        wxGetApp().request_model_download(realurl);
                    }
                }
            }
        }
    }
    catch (...) {
        BOOST_LOG_TRIVIAL(warning) << "parse json cmd failed " << cmd;
        return "";
    }
    return "";
}

References _L, app_config, Slic3r::BBL_CLOUD_PROVIDER(), Slic3r::GUI::desktop_open_any_folder(), Slic3r::GUI::from_u8(), get_login_info(), handle_web_request(), Slic3r::GUI::LazyInstance< WebViewPanel >::if_built(), mainframe, open_mall_page_dialog(), open_orca_cloud(), Slic3r::ORCA_CLOUD_PROVIDER(), request_login(), request_open_project(), request_project_download(), request_remove_project(), request_user_logout(), Slic3r::resources_dir(), Slic3r::GUI::MsgDialog::SetButtonLabel(), Slic3r::GUI::DPIAware< P >::ShowModal(), and url_decode().

Referenced by handle_web_request().

Here is the call graph for this function:

Here is the caller graph for this function:

has_current_preset_changes()

bool Slic3r::GUI::GUI_App::has_current_preset_changes

(

)

const

{
    PrinterTechnology printer_technology = preset_bundle->printers.get_edited_preset().printer_technology();
    for (const Tab* const tab : tabs_list) {
        if (tab->supports_printer_technology(printer_technology) && tab->current_preset_is_dirty())
            return true;
    }
    return false;
}

References has_current_preset_changes(), preset_bundle, Slic3r::GUI::printer_technology(), and tabs_list.

Referenced by check_and_keep_current_preset_changes(), check_and_save_current_preset_changes(), and has_current_preset_changes().

Here is the call graph for this function:

Here is the caller graph for this function:

has_model_mall()

bool Slic3r::GUI::GUI_App::has_model_mall

(

)

{
    if (auto cc = app_config->get_region(); cc == "CNH" || cc == "China" || cc == "")
        return false;
    return true;
}

References app_config, and has_model_mall().

Referenced by has_model_mall().

Here is the call graph for this function:

Here is the caller graph for this function:

has_network_update_available()

bool Slic3r::GUI::GUI_App::has_network_update_available

(

)

const

{
    std::string current = Slic3r::NetworkAgent::get_version();
    std::string latest = get_latest_network_version();
 
    if (current.empty() || current == "00.00.00.00")
        return false;
 
    return current.substr(0, 8) != latest.substr(0, 8);
}

References get_latest_network_version(), and Slic3r::NetworkAgent::get_version().

Referenced by on_init_network().

Here is the call graph for this function:

Here is the caller graph for this function:

has_unsaved_preset_changes()

bool Slic3r::GUI::GUI_App::has_unsaved_preset_changes

(

)

const

{
    PrinterTechnology printer_technology = preset_bundle->printers.get_edited_preset().printer_technology();
    for (const Tab* const tab : tabs_list) {
        if (tab->supports_printer_technology(printer_technology) && tab->saved_preset_is_dirty())
            return true;
    }
    return false;
}

References has_unsaved_preset_changes(), preset_bundle, Slic3r::GUI::printer_technology(), and tabs_list.

Referenced by has_unsaved_preset_changes(), and Slic3r::GUI::ProjectDirtyStateManager::update_from_presets().

Here is the call graph for this function:

Here is the caller graph for this function:

hot_reload_network_plugin()

bool Slic3r::GUI::GUI_App::hot_reload_network_plugin

(

)

{
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": starting hot reload";
 
    wxBusyCursor busy;
    wxBusyInfo info(_L("Reloading network plug-in..."), mainframe);
    wxYield();
    wxWindowDisabler disabler;
 
    if (mainframe) {
        wxString current_tab = mainframe->m_tabpanel->GetSelectedPageName();
        if (current_tab == TAB_ID_MONITOR) {
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": navigating away from Monitor tab before unload";
            mainframe->m_tabpanel->SelectPageByName(TAB_ID_PREPARE);
        }
    }
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": stopping sync thread before unload";
    if (m_user_sync_token) {
        m_user_sync_token.reset();
    }
    if (m_sync_update_thread.joinable()) {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": waiting for sync thread to finish";
        m_sync_update_thread.join();
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": sync thread finished";
    }
 
    if (m_agent) {
        // Stop the health check first: a result it posts after the Phase 2 drain would run while
        // m_agent is null or replaced.
        stop_orca_health_check(m_agent);
 
        // Phase 1: Clear all callbacks (stops new invocations)
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": Phase 1 - clearing callbacks";
        m_agent->set_on_ssdp_msg_fn(nullptr);
        m_agent->set_on_printer_connected_fn(nullptr);
        m_agent->set_on_server_connected_fn(nullptr);
        m_agent->set_on_http_error_fn(nullptr);
        m_agent->set_on_subscribe_failure_fn(nullptr);
        m_agent->set_on_message_fn(nullptr);
        m_agent->set_on_user_message_fn(nullptr);
        m_agent->set_on_local_connect_fn(nullptr);
        m_agent->set_on_local_message_fn(nullptr);
        m_agent->set_queue_on_main_fn(nullptr);
 
        // Phase 2: Drain pending CallAfter callbacks (bounded)
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": Phase 2 - draining callbacks";
        drain_pending_events(CALLBACK_DRAIN_TIMEOUT_MS);
 
        // Phase 3: Stop operations and verify return values
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": Phase 3 - stopping operations";
        bool discovery_stopped = m_agent->start_discovery(false, false);
        int disconnect_result = m_agent->disconnect_printer();
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": discovery_stopped=" << discovery_stopped
                                << ", disconnect_result=" << disconnect_result;
 
        // Phase 4: Wait for idle with state verification
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": Phase 4 - waiting for idle";
        bool became_idle = wait_for_network_idle(NETWORK_IDLE_TIMEOUT_MS);
        if (!became_idle) {
            BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": proceeding despite timeout";
        }
 
        // Phase 5: Final bounded drain before destruction
        drain_pending_events(FINAL_DRAIN_TIMEOUT_MS);
 
        // Phase 6: Destroy agent
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": Phase 6 - destroying agent";
        delete m_agent;
        m_agent = nullptr;
    }
 
    // Phase 7: Unload module
    if (Slic3r::NetworkAgent::is_network_module_loaded()) {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": Phase 7 - unloading module";
        drain_pending_events(FINAL_DRAIN_TIMEOUT_MS);
        int unload_result = Slic3r::NetworkAgent::unload_network_module();
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": unload_result=" << unload_result;
    }
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": calling restart_networking";
    restart_networking();
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": restart_networking returned";
 
    std::string loaded_version = Slic3r::NetworkAgent::get_version();
    bool success = m_agent != nullptr && !loaded_version.empty() && loaded_version != "00.00.00.00";
    bool user_logged_in = m_agent && m_agent->is_user_login();
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": after restart_networking, is_user_login = " << user_logged_in
                            << ", m_agent = " << (m_agent ? "valid" : "null")
                            << ", version = " << loaded_version;
 
    if (success && m_agent && m_device_manager && !app_config->get_stealth_mode()) {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": connecting to cloud server";
        m_agent->connect_server();
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": re-subscribing to cloud printers";
        m_device_manager->add_user_subscribe();
    }
 
    if (MonitorPanel* monitor = MonitorPanel::if_built()) {
        monitor->update_network_version_footer();
        monitor->set_default();
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": reset monitor panel";
    }
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": hot reload " << (success ? "successful" : "failed");
    return success;
}

References _L, app_config, drain_pending_events(), Slic3r::NetworkAgent::get_version(), Slic3r::GUI::LazyInstance< MonitorPanel >::if_built(), Slic3r::NetworkAgent::is_network_module_loaded(), m_agent, m_device_manager, m_sync_update_thread, m_user_sync_token, mainframe, restart_networking(), TAB_ID_MONITOR, TAB_ID_PREPARE, Slic3r::NetworkAgent::unload_network_module(), wait_for_network_idle(), and wxWindowDisabler.

Here is the call graph for this function:

imgui()

ImGuiWrapper * Slic3r::GUI::GUI_App::imgui ( )

inline

{ return m_imgui.get(); }

References m_imgui.

Referenced by on_http_error().

Here is the caller graph for this function:

import_model()

void Slic3r::GUI::GUI_App::import_model	(	wxWindow *	parent,
		wxArrayString &	input_files ) const

{
    input_files.Clear();
    wxFileDialog dialog(parent ? parent : GetTopWindow(),
#ifdef __APPLE__
        _L("Choose one or more files (3MF/STEP/STL/SVG/OBJ/AMF/USD*/ABC/PLY):"),
#else
        _L("Choose one or more files (3MF/STEP/STL/SVG/OBJ/AMF):"),
#endif
        from_u8(app_config->get_last_dir()), "",
        file_wildcards(FT_MODEL), wxFD_OPEN | wxFD_MULTIPLE | wxFD_FILE_MUST_EXIST);
 
    if (dialog.ShowModal() == wxID_OK)
        dialog.GetPaths(input_files);
}

References _L, app_config, Slic3r::GUI::file_wildcards(), Slic3r::GUI::from_u8(), Slic3r::GUI::FT_MODEL, and import_model().

Referenced by import_model().

Here is the call graph for this function:

Here is the caller graph for this function:

import_zip()

void Slic3r::GUI::GUI_App::import_zip	(	wxWindow *	parent,
		wxString &	input_file ) const

{
    wxFileDialog dialog(parent ? parent : GetTopWindow(),
                        _L("Choose ZIP file") + ":",
                        from_u8(app_config->get_last_dir()), "",
                        file_wildcards(FT_ZIP), wxFD_OPEN | wxFD_FILE_MUST_EXIST);
 
    if (dialog.ShowModal() == wxID_OK)
        input_file = dialog.GetPath();
}

References _L, app_config, Slic3r::GUI::file_wildcards(), Slic3r::GUI::from_u8(), Slic3r::GUI::FT_ZIP, and import_zip().

Referenced by import_zip().

Here is the call graph for this function:

Here is the caller graph for this function:

init_app_config()

void Slic3r::GUI::GUI_App::init_app_config ( )

private

{
  // Profiles for the alpha are stored into the PrusaSlicer-alpha directory to not mix with the current release.
    SetAppName(SLIC3R_APP_KEY);
//  SetAppName(SLIC3R_APP_KEY "-alpha");
//  SetAppName(SLIC3R_APP_KEY "-beta");
//  SetAppDisplayName(SLIC3R_APP_NAME);
 
  // Set the Slic3r data directory at the Slic3r XS module.
  // Unix: ~/ .Slic3r
  // Windows : "C:\Users\username\AppData\Roaming\Slic3r" or "C:\Documents and Settings\username\Application Data\Slic3r"
  // Mac : "~/Library/Application Support/Slic3r"
 
    if (data_dir().empty()) {
        // Orca: check if data_dir folder exists in application folder use it if it exists
        // Note:wxStandardPaths::Get().GetExecutablePath() return following paths
        // Unix: /usr/local/bin/exename
        // Windows: "C:\Programs\AppFolder\exename.exe"
        // Mac: /Applications/exename.app/Contents/MacOS/exename
        // TODO: have no idea what to do with Linux bundles
        auto _app_folder = boost::filesystem::path(wxStandardPaths::Get().GetExecutablePath().ToUTF8().data()).parent_path();
#ifdef __APPLE__
        // On macOS, the executable is inside the .app bundle.
        _app_folder = _app_folder.parent_path().parent_path().parent_path();
#endif
        boost::filesystem::path app_data_dir_path = _app_folder / "data_dir";
        if (boost::filesystem::exists(app_data_dir_path)) {
            set_data_dir(app_data_dir_path.string());
        }
        else{
            boost::filesystem::path data_dir_path;
            #ifndef __linux__
                std::string data_dir = wxStandardPaths::Get().GetUserDataDir().ToUTF8().data();
                //BBS create folder if not exists
                data_dir_path = boost::filesystem::path(data_dir);
                set_data_dir(data_dir);
            #else
                // Since version 2.3, config dir on Linux is in ${XDG_CONFIG_HOME}.
                // https://github.com/prusa3d/PrusaSlicer/issues/2911
                wxString dir;
                if (! wxGetEnv(wxS("XDG_CONFIG_HOME"), &dir) || dir.empty() )
                    dir = wxFileName::GetHomeDir() + wxS("/.config");
                data_dir_path = boost::filesystem::path((dir + "/" + GetAppName()).ToUTF8().data());
                migrate_flatpak_legacy_datadir(data_dir_path);
                set_data_dir(data_dir_path.string());
            #endif
            if (!boost::filesystem::exists(data_dir_path)){
                boost::filesystem::create_directory(data_dir_path);
            }
        }
 
        // Change current dirtory of application
 
#ifdef _WIN32
    [[maybe_unused]] auto unused_result = _chdir(encode_path((Slic3r::data_dir() + "/log").c_str()).c_str());
#else
    [[maybe_unused]] auto unused_result = chdir(encode_path((Slic3r::data_dir() + "/log").c_str()).c_str());
#endif
 
    } else {
        m_datadir_redefined = true;
    }
 
    // start log here
    std::time_t       t        = std::time(0);
    std::tm *         now_time = std::localtime(&t);
    std::stringstream buf;
    buf << std::put_time(now_time, "debug_%a_%b_%d_%H_%M_%S_");
    buf << get_current_pid() << ".log";
    std::string log_filename = buf.str();
#if !BBL_RELEASE_TO_PUBLIC
    set_log_path_and_level(log_filename, 5);
#else
    set_log_path_and_level(log_filename, 3);
#endif
 
    BOOST_LOG_TRIVIAL(info) << boost::format("gui mode, Current OrcaSlicer Version %1% build %2%") % SoftFever_VERSION % build_commit_label;
 
    //BBS: remove GCodeViewer as seperate APP logic
  if (!app_config)
        app_config = new AppConfig();
        //app_config = new AppConfig(is_editor() ? AppConfig::EAppMode::Editor : AppConfig::EAppMode::GCodeViewer);
 
    m_config_corrupted = false;
  // load settings
  m_app_conf_exists = app_config->exists();
  if (m_app_conf_exists) {
        std::string error = app_config->load();
        if (!error.empty()) {
            // Orca: if the config file is corrupted, we will show a error dialog and create a default config file.
            m_config_corrupted = true;
 
        }
        // Save orig_version here, so its empty if no app_config existed before this run.
        m_last_config_version = app_config->orig_version();//parse_semver_from_ini(app_config->config_path());
    }
    else {
#ifdef _WIN32
        // update associate files from registry information
        if (is_associate_files(L"3mf")) {
            app_config->set("associate_3mf", "true");
        }
        if (is_associate_files(L"stl")) {
            app_config->set("associate_stl", "true");
        }
        if (is_associate_files(L"step") && is_associate_files(L"stp")) {
            app_config->set("associate_step", "true");
        }
#endif // _WIN32
    }
    // Speed Dial opens on a bare Space from any page by default. Seed the flag so Preferences and the
    // MainFrame shortcut read the same value; an existing config (true or false) is left untouched.
    if (app_config->get("enable_speed_dial").empty())
        app_config->set_bool("enable_speed_dial", true);
    set_logging_level(Slic3r::level_string_to_boost(app_config->get("log_severity_level")));
 
}

References app_config, Slic3r::GUI::build_commit_label, Slic3r::data_dir(), Slic3r::empty(), Slic3r::encode_path(), Slic3r::get_current_pid(), init_app_config(), L, Slic3r::level_string_to_boost(), m_app_conf_exists, m_config_corrupted, m_datadir_redefined, m_last_config_version, Slic3r::set_data_dir(), Slic3r::set_log_path_and_level(), and Slic3r::set_logging_level().

Referenced by GUI_App(), and init_app_config().

Here is the call graph for this function:

Here is the caller graph for this function:

init_download_path()

void Slic3r::GUI::GUI_App::init_download_path

(

)

{
    std::string down_path = app_config->get("download_path");
 
    if (down_path.empty()) {
        std::string user_down_path = wxStandardPaths::Get().GetUserDir(wxStandardPaths::Dir_Downloads).ToUTF8().data();
        app_config->set("download_path", user_down_path);
    }
    else {
        fs::path dp(down_path);
        // ORCA: non-throwing probe; ec is deliberately unread, a download_path that cannot be
        //       probed falls back to the default like a missing one instead of failing startup.
        boost::system::error_code ec;
        if (!fs::exists(dp, ec)) {
 
            std::string user_down_path = wxStandardPaths::Get().GetUserDir(wxStandardPaths::Dir_Downloads).ToUTF8().data();
            app_config->set("download_path", user_down_path);
        }
    }
}

References app_config, and init_download_path().

Referenced by GUI_App(), and init_download_path().

Here is the call graph for this function:

Here is the caller graph for this function:

init_fonts()

void Slic3r::GUI::GUI_App::init_fonts

(

)

{
    // BBS: modify font
    m_small_font = Label::Body_10;
    m_bold_font = Label::Body_10.Bold();
    m_normal_font = Label::Body_10;
 
#ifdef __WXMAC__
    m_small_font.SetPointSize(11);
    m_bold_font.SetPointSize(13);
#endif /*__WXMAC__*/
 
    // wxSYS_OEM_FIXED_FONT and wxSYS_ANSI_FIXED_FONT use the same as
    // DEFAULT in wxGtk. Use the TELETYPE family as a work-around
    m_code_font = wxFont(wxFontInfo().Family(wxFONTFAMILY_TELETYPE));
    m_code_font.SetPointSize(m_small_font.GetPointSize());
}

References Label::Body_10, init_fonts(), m_bold_font, m_code_font, m_normal_font, and m_small_font.

Referenced by init_fonts(), and on_init_inner().

Here is the call graph for this function:

Here is the caller graph for this function:

init_glcontext()

wxGLContext * Slic3r::GUI::GUI_App::init_glcontext

(

wxGLCanvas &

canvas

)

{
    return m_opengl_mgr.init_glcontext(canvas, init_params != nullptr ? init_params->opengl_version : std::make_pair(0, 0),
        init_params != nullptr ? init_params->opengl_compatibility_profile : false, init_params != nullptr ? init_params->opengl_debug : false);
}

References init_glcontext(), init_params, and m_opengl_mgr.

Referenced by init_glcontext().

Here is the call graph for this function:

Here is the caller graph for this function:

init_label_colours()

void Slic3r::GUI::GUI_App::init_label_colours

(

)

{
    bool is_dark_mode = dark_mode();
    m_color_label_modified = is_dark_mode ? wxColour("#F1754E") : wxColour("#F1754E");
    m_color_label_sys      = is_dark_mode ? wxColour("#B2B3B5") : wxColour("#363636");
 
#if defined(_WIN32) || defined(__linux__) || defined(__APPLE__)
    m_color_label_default           = is_dark_mode ? wxColour(250, 250, 250) : m_color_label_sys; // wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT);
    m_color_highlight_label_default = is_dark_mode ? wxColour(230, 230, 230): wxSystemSettings::GetColour(/*wxSYS_COLOUR_HIGHLIGHTTEXT*/wxSYS_COLOUR_WINDOWTEXT);
    m_color_highlight_default       = is_dark_mode ? wxColour("#36363B") : wxColour("#F1F1F1"); // ORCA row highlighting
    m_color_hovered_btn_label       = is_dark_mode ? wxColour(255, 255, 254) : wxColour(0,0,0);
    m_color_default_btn_label       = is_dark_mode ? wxColour(255, 255, 254): wxColour(0,0,0);
    m_color_selected_btn_bg         = is_dark_mode ? wxColour(84, 84, 91)   : wxColour(206, 206, 206);
#else
    m_color_label_default = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT);
#endif
    m_color_window_default          = is_dark_mode ? wxColour(43, 43, 43)   : wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW);
    StateColor::SetDarkMode(is_dark_mode);
}

References dark_mode(), init_label_colours(), m_color_default_btn_label, m_color_highlight_default, m_color_highlight_label_default, m_color_hovered_btn_label, m_color_label_default, m_color_label_modified, m_color_label_sys, m_color_selected_btn_bg, m_color_window_default, and StateColor::SetDarkMode().

Referenced by init_label_colours(), and on_init_inner().

Here is the call graph for this function:

Here is the caller graph for this function:

init_networking_callbacks()

void Slic3r::GUI::GUI_App::init_networking_callbacks ( )

private

{
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__<< boost::format(": enter, m_agent=%1%")%m_agent;
    if (m_agent) {
        //set callbacks
        m_agent->set_server_callback([](std::string url, int status) {
            BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(": server_callback, url=%1%, status=%2%") % url % status;
            //CallAfter([this]() {
            //    if (!m_server_error_dialog) {
            //        /*m_server_error_dialog->EndModal(wxCLOSE);
            //        m_server_error_dialog->Destroy();
            //        m_server_error_dialog = nullptr;*/
            //        m_server_error_dialog = new NetworkErrorDialog(mainframe);
            //    }
            //
            //    if(plater()->get_select_machine_dialog() && plater()->get_select_machine_dialog()->IsShown()){
            //        return;
            //    }
            //
            //    if (m_server_error_dialog->m_show_again) {
            //        return;
            //    }
            //
            //    if (m_server_error_dialog->IsShown()) {
            //        return;
            //    }
            //
            //    m_server_error_dialog->ShowModal();
            //});
        });
 
 
        m_agent->set_on_server_connected_fn([this](CloudEvent event, int return_code, int reason_code) {
            if (is_closing()) {
                return;
            }
            if (return_code == 5) {
                GUI::wxGetApp().CallAfter([this, provider = event.provider] {
                    BOOST_LOG_TRIVIAL(info) << "logout: login expired";
                    // Involuntary: the desktop lost its session on its own. Leave the webview's
                    // own session alone (guide §8).
                    this->request_user_logout(provider, /*user_initiated=*/false);
                    MessageDialog msg_dlg(nullptr, _L("Login information expired. Please login again."), "", wxAPPLY | wxOK);
                    if (msg_dlg.ShowModal() == wxOK) {
                        return;
                    }
                });
                return;
            }
            GUI::wxGetApp().CallAfter([this, provider = event.provider] {
                if (is_closing())
                    return;
                BOOST_LOG_TRIVIAL(trace) << "static: server connected";
                if (provider != this->get_printer_cloud_provider()) {
                    return;
                }
                m_agent->set_user_selected_machine(m_agent->get_user_selected_machine());
                if (this->is_enable_multi_machine()) {
                    auto evt = new wxCommandEvent(EVT_UPDATE_MACHINE_LIST);
                    wxQueueEvent(this, evt);
                }
                m_agent->set_user_selected_machine(m_agent->get_user_selected_machine());
                if (m_agent->is_user_login(provider)) {
 
                    /*disconnect lan*/
                    DeviceManager* dev = this->getDeviceManager();
                    if (!dev) return;
 
                    MachineObject *obj = dev->get_selected_machine();
                    if (!obj) return;
 
                    /* resubscribe the cache dev list */
                    if (this->is_enable_multi_machine()) {
 
                        if (!dev->subscribe_list_cache.empty()) {
                            dev->subscribe_device_list(dev->subscribe_list_cache);
                        }
                    }
                }
            });
        });
 
        m_agent->set_on_printer_connected_fn([this](std::string dev_id) {
            if (is_closing()) {
                return;
            }
            GUI::wxGetApp().CallAfter([this, dev_id] {
                if (is_closing())
                    return;
                bool tunnel = boost::algorithm::starts_with(dev_id, "tunnel/");
                /* request_pushing */
                MachineObject* obj = m_device_manager->get_my_machine(tunnel ? dev_id.substr(7) : dev_id);
                if (obj) {
                    obj->is_tunnel_mqtt = tunnel;
                    obj->command_request_push_all(true);
                    obj->command_get_version();
                    obj->command_get_access_code();
                    if (m_agent)
                        m_agent->install_device_cert(obj->get_dev_id(), obj->is_lan_mode_printer());
 
                    obj->set_online_state(true);
                }
                });
            });
 
        m_agent->set_get_country_code_fn([this]() {
            if (app_config)
                return app_config->get_country_code();
            return std::string();
            }
        );
 
        m_agent->set_on_subscribe_failure_fn([this](std::string dev_id) {
            CallAfter([this, dev_id] {
                on_start_subscribe_again(dev_id);
            });
        });
 
        m_agent->set_on_local_connect_fn(
            [this](int state, std::string dev_id, std::string msg) {
                if (is_closing()) {
                    return;
                }
                CallAfter([this, state, dev_id, msg] {
                    if (is_closing()) {
                        return;
                    }
                    /* request_pushing */
                    MachineObject* obj = m_device_manager->get_my_machine(dev_id);
                    wxCommandEvent event(EVT_CONNECT_LAN_MODE_PRINT);
 
                    if (obj) {
 
                        if (obj->is_lan_mode_printer()) {
                            if (state == ConnectStatus::ConnectStatusOk) {
                                obj->command_request_push_all(true);
                                obj->command_get_version();
                                event.SetInt(0);
                                event.SetString(obj->get_dev_id());
 
                                obj->set_online_state(true);
                            } else if (state == ConnectStatus::ConnectStatusFailed) {
                                // Orca: only update status if same device id
                                if (m_device_manager->selected_machine != dev_id) return;
 
                                m_device_manager->set_selected_machine("");
                                wxString text;
                                if (msg == "5") {
                                    obj->set_access_code("");
                                    text = wxString::Format(_L("Incorrect password"));
                                    wxGetApp().show_dialog(text);
                                } else {
                                text = wxString::Format(_L("Connect %s failed! [SN:%s, code=%s]"), from_u8(obj->get_dev_name()), obj->get_dev_id(), msg);
                                    wxGetApp().show_dialog(text);
                                }
                                event.SetInt(-1);
 
                                obj->set_online_state(false);
                            } else if (state == ConnectStatus::ConnectStatusLost) {
                                m_device_manager->set_selected_machine("");
                                event.SetInt(-1);
                                BOOST_LOG_TRIVIAL(info) << "set_on_local_connect_fn: state = lost";
 
                                obj->set_online_state(false);
                            } else {
                                event.SetInt(-1);
                                BOOST_LOG_TRIVIAL(info) << "set_on_local_connect_fn: state = " << state;
                            }
 
                            obj->set_lan_mode_connection_state(false);
                        }
                        else {
                            if (state == ConnectStatus::ConnectStatusOk) {
                                event.SetInt(1);
                                event.SetString(obj->get_dev_id());
                            }
                            else if(msg == "5") {
                                event.SetInt(5);
                                event.SetString(obj->get_dev_id());
                            }
                            else {
                                event.SetInt(-2);
                                event.SetString(obj->get_dev_id());
                            }
                        }
                    }
                    if (wxGetApp().plater()->get_select_machine_dialog()) {
                        wxPostEvent(wxGetApp().plater()->get_select_machine_dialog(), event);
                    }
                });
            }
        );
 
        auto message_arrive_fn = [this](std::string dev_id, std::string msg) {
            if (is_closing()) {
                return;
            }
            CallAfter([this, dev_id, msg] {
                if (is_closing())
                    return;
 
                if (process_network_msg(dev_id, msg)) {
                    return;
                }
 
                const std::string provider = this->get_printer_cloud_provider();
                if (MachineObject* obj = this->m_device_manager->get_user_machine(dev_id, provider)) {
                    auto sel = this->m_device_manager->get_selected_machine();
                    if (sel && sel->get_dev_id() == dev_id) {
                        obj->parse_json("cloud", msg);
                        GUI::wxGetApp().sidebar().load_ams_list(obj);
                    } else {
                        obj->parse_json("cloud", msg, true);
                    }
                }
 
                if (GUI::wxGetApp().plater())
                    GUI::wxGetApp().plater()->update_machine_sync_status();
            });
        };
 
        m_agent->set_on_message_fn(message_arrive_fn);
 
        auto user_message_arrive_fn = [this](std::string user_id, std::string msg) {
            if (is_closing()) {
                return;
            }
            CallAfter([this, user_id, msg] {
                if (is_closing())
                    return;
 
                //check user
                if (user_id == m_agent->get_user_id(get_printer_cloud_provider())) {
                    this->m_user_manager->parse_json(msg);
                }
 
            });
        };
 
        m_agent->set_on_user_message_fn(user_message_arrive_fn);
 
 
        auto lan_message_arrive_fn = [this](std::string dev_id, std::string msg) {
            if (is_closing()) {
                return;
            }
            CallAfter([this, dev_id, msg] {
                if (is_closing())
                    return;
 
                if (this->process_network_msg(dev_id, msg)) {
                    return;
                }
 
                if (MachineObject* obj = m_device_manager->get_my_machine(dev_id)) {
                    obj->parse_json("lan", msg);
                    // Orca: skip it if it doesn't support subscription based filament sync
                    if (this->m_device_manager->get_selected_machine() == obj &&
                        m_agent->get_filament_sync_mode() == FilamentSyncMode::subscription) {
                        GUI::wxGetApp().sidebar().load_ams_list(obj);
                    }
                }
 
                if (GUI::wxGetApp().plater())
                    GUI::wxGetApp().plater()->update_machine_sync_status();
                });
        };
        m_agent->set_on_local_message_fn(lan_message_arrive_fn);
        m_agent->set_queue_on_main_fn([this](std::function<void()> callback) {
            CallAfter(callback);
        });
    }
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__<< boost::format(": exit, m_agent=%1%")%m_agent;
}

References is_closing(), is_enable_multi_machine(), m_agent, and Slic3r::CloudEvent::provider.

Referenced by on_init_network(), and restart_networking().

Here is the call graph for this function:

Here is the caller graph for this function:

init_opengl()

bool Slic3r::GUI::GUI_App::init_opengl

(

)

{
#ifdef __linux__
    bool status = m_opengl_mgr.init_gl();
    if (status)
        m_opengl_initialized = true;
    return status;
#else
    return m_opengl_mgr.init_gl();
#endif
}

References init_opengl(), and m_opengl_mgr.

Referenced by init_opengl().

Here is the call graph for this function:

Here is the caller graph for this function:

init_plugin_gui_wiring()

void Slic3r::GUI::GUI_App::init_plugin_gui_wiring ( )

private

{
    PluginManager& plugin_mgr = PluginManager::instance();
 
    auto refresh_plugins_dialog = [] {
        if (!wxTheApp)
            return;
 
        GUI_App* app = &GUI::wxGetApp();
        if (app->is_closing())
            return;
 
        app->CallAfter([app] {
            if (!app->is_closing() && app->m_plugins_dlg)
                app->m_plugins_dlg->update_plugin_dialog_ui();
        });
    };
 
    // why: a newly loaded plugin only adds a selectable agent
    // refresh the dropdown and leave the live agent alone, unless it brought a printer connection
    // the selected preset may be waiting for: plugins load asynchronously and can register their
    // agent after the startup preset is applied
    auto refresh_printer_agent_after_load = [](bool provides_printer_connection)
    {
        if (!wxTheApp)
            return;
 
        GUI_App* app = &GUI::wxGetApp();
        if (app->is_closing())
            return;
 
        app->CallAfter([app, provides_printer_connection]
        {
            if (app->is_closing())
                return;
 
            if (provides_printer_connection)
                app->switch_printer_agent_if_pending();
            app->refresh_printer_agent_dropdown();
        });
    };
 
    // why: the unloaded plugin may have been the provider of the live agent
    // re-run selection, where a now-missing agent will be cleared
    // refresh dropdown after
    auto switch_printer_agent_after_unload = [](const std::string&)
    {
        if (!wxTheApp)
            return;
 
        GUI_App* app = &GUI::wxGetApp();
        if (app->is_closing())
            return;
 
        app->CallAfter([app] {
            if (app->is_closing())
                return;
 
            app->switch_printer_agent();
            app->refresh_printer_agent_dropdown();
        });
    };
 
    plugin_mgr.subscribe_on_unload_callback(PluginHostUi::close_windows_for_plugin);
    plugin_mgr.subscribe_on_load_callback([refresh_plugins_dialog](const std::string&) { refresh_plugins_dialog(); });
    plugin_mgr.subscribe_on_unload_callback([refresh_plugins_dialog](const std::string&) { refresh_plugins_dialog(); });
    plugin_mgr.subscribe_on_load_callback(NetworkAgentFactory::register_python_plugin);
    plugin_mgr.subscribe_on_unload_callback(NetworkAgentFactory::deregister_python_plugin);
    plugin_mgr.subscribe_on_load_callback([](const std::string& plugin_key) {
        if (wxTheApp == nullptr || wxGetApp().is_closing() || wxGetApp().mainframe == nullptr)
            return;
        wxGetApp().mainframe->plugin_pages().on_plugin_register(plugin_key);
    });
    plugin_mgr.subscribe_on_unload_callback([](const std::string& plugin_key) {
        if (wxTheApp == nullptr || wxGetApp().is_closing() || wxGetApp().mainframe == nullptr)
            return;
        wxGetApp().mainframe->plugin_pages().on_plugin_deregister(plugin_key);
    });
    plugin_mgr.subscribe_on_load_callback([refresh_printer_agent_after_load](const std::string& plugin_key) {
        refresh_printer_agent_after_load(!PluginManager::instance()
                                              .get_plugin_capabilities(plugin_key, PluginCapabilityType::PrinterConnection,
                                                                       /*only_enabled=*/true)
                                              .empty());
    });
    plugin_mgr.subscribe_on_unload_callback(switch_printer_agent_after_unload);
    plugin_mgr.subscribe_on_capability_load_callback(
        [refresh_plugins_dialog, refresh_printer_agent_after_load](const PluginCapabilityId& capability) {
            if (capability.type == PluginCapabilityType::PrinterConnection)
                NetworkAgentFactory::register_python_printer_agent(capability.plugin_key, capability.name);
            refresh_plugins_dialog();
            refresh_printer_agent_after_load(capability.type == PluginCapabilityType::PrinterConnection);
            // A newly loaded capability may satisfy a missing-plugin notification; re-validate the
            // current plate (on the UI thread) so the notification clears once its plugin is available.
            if (wxTheApp && !wxGetApp().is_closing())
                wxGetApp().CallAfter([]() {
                    if (Plater* plater = wxGetApp().plater())
                        plater->revalidate_current_plate_if_plugins_missing();
                });
            if (capability.type == PluginCapabilityType::Pages && wxTheApp && !wxGetApp().is_closing() && wxGetApp().mainframe)
                wxGetApp().mainframe->plugin_pages().on_cap_register(capability);
        });
    plugin_mgr.subscribe_on_capability_unload_callback(
        [refresh_plugins_dialog, switch_printer_agent_after_unload](const PluginCapabilityId& capability) {
            if (capability.type == PluginCapabilityType::PrinterConnection)
                NetworkAgentFactory::deregister_python_printer_agent(capability.plugin_key, capability.name);
            if (capability.type == PluginCapabilityType::Pages && wxTheApp && !wxGetApp().is_closing() && wxGetApp().mainframe)
                wxGetApp().mainframe->plugin_pages().on_cap_deregister(capability);
            refresh_plugins_dialog();
            switch_printer_agent_after_unload(capability.plugin_key);
        });
    plugin_mgr.subscribe_on_load_callback([](const std::string& plugin_key) {
        if (wxTheApp == nullptr || wxGetApp().is_closing())
            return;
        PluginResourceTextures::instance().on_plugin_register(plugin_key);
        Slic3r::GUI::bump_texture_library_generation();
    });
    plugin_mgr.subscribe_on_unload_callback([](const std::string& plugin_key) {
        if (wxTheApp == nullptr || wxGetApp().is_closing())
            return;
        PluginResourceTextures::instance().on_plugin_deregister(plugin_key);
        Slic3r::GUI::bump_texture_library_generation();
    });
    plugin_mgr.subscribe_on_capability_load_callback([](const PluginCapabilityId& capability) {
        if (capability.type != PluginCapabilityType::ResourceTexture)
            return;
        if (wxTheApp == nullptr || wxGetApp().is_closing())
            return;
        PluginResourceTextures::instance().on_cap_register(capability);
        Slic3r::GUI::bump_texture_library_generation();
    });
    plugin_mgr.subscribe_on_capability_unload_callback([](const PluginCapabilityId& capability) {
        if (capability.type != PluginCapabilityType::ResourceTexture)
            return;
        if (wxTheApp == nullptr || wxGetApp().is_closing())
            return;
        PluginResourceTextures::instance().on_cap_deregister(capability);
        Slic3r::GUI::bump_texture_library_generation();
    });
    // Packs already loaded before this wiring, or in tests where no callback fires.
    PluginResourceTextures::instance().initial_sweep();
    Slic3r::GUI::bump_texture_library_generation();
}

References GUI_App(), Slic3r::GUI::bump_texture_library_generation(), Slic3r::PluginHostUi::close_windows_for_plugin(), Slic3r::NetworkAgentFactory::deregister_python_plugin(), Slic3r::NetworkAgentFactory::deregister_python_printer_agent(), Slic3r::empty(), init_plugin_gui_wiring(), Slic3r::PluginManager::instance(), Slic3r::PluginResourceTextures::instance(), is_closing(), m_plugins_dlg, mainframe, Slic3r::PluginCapabilityId::name, Slic3r::Pages, plater(), Slic3r::PluginCapabilityId::plugin_key, Slic3r::PrinterConnection, refresh_printer_agent_dropdown(), Slic3r::NetworkAgentFactory::register_python_plugin(), Slic3r::NetworkAgentFactory::register_python_printer_agent(), Slic3r::ResourceTexture, Slic3r::PluginManager::subscribe_on_capability_load_callback(), Slic3r::PluginManager::subscribe_on_capability_unload_callback(), Slic3r::PluginManager::subscribe_on_load_callback(), Slic3r::PluginManager::subscribe_on_unload_callback(), switch_printer_agent(), switch_printer_agent_if_pending(), Slic3r::PluginCapabilityId::type, and Slic3r::GUI::PluginsDialog::update_plugin_dialog_ui().

Referenced by init_plugin_gui_wiring(), and on_init_inner().

Here is the call graph for this function:

Here is the caller graph for this function:

init_single_instance_checker()

void Slic3r::GUI::GUI_App::init_single_instance_checker	(	const std::string &	name,
		const std::string &	path )

{
    BOOST_LOG_TRIVIAL(debug) << "init wx instance checker " << name << " "<< path;
    m_single_instance_checker = std::make_unique<wxSingleInstanceChecker>(boost::nowide::widen(name), boost::nowide::widen(path));
}

References init_single_instance_checker(), and m_single_instance_checker.

Referenced by init_single_instance_checker().

Here is the call graph for this function:

Here is the caller graph for this function:

initialized()

bool Slic3r::GUI::GUI_App::initialized ( ) const

inline

{ return m_initialized; }

References m_initialized.

Referenced by post_init().

Here is the caller graph for this function:

input_idle_ms()

int Slic3r::GUI::GUI_App::input_idle_ms

(

)

const

{
    return int(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - m_last_input).count());
}

References count, input_idle_ms(), and m_last_input.

Referenced by input_idle_ms().

Here is the call graph for this function:

Here is the caller graph for this function:

install_local_plugin()

void Slic3r::GUI::GUI_App::install_local_plugin

(

)

{
    if (mainframe == nullptr)
        return;
 
    wxFileDialog dialog(mainframe, _L("Select plugin package"), wxEmptyString, wxEmptyString, _L("Plugin files (*.py;*.whl)|*.py;*.whl"),
                        wxFD_OPEN | wxFD_FILE_MUST_EXIST);
    if (dialog.ShowModal() != wxID_OK)
        return;
 
    wxString message;
    const bool ok = install_local_plugin_package(boost::filesystem::path(dialog.GetPath().ToUTF8().data()), mainframe, message);
    if (message.IsEmpty())
        return; // user cancelled the overwrite prompt
 
    Plater* plater = this->plater();
    if (plater == nullptr)
        return;
    plater->get_notification_manager()->push_notification(
        NotificationType::CustomNotification,
        ok ? NotificationManager::NotificationLevel::RegularNotificationLevel : NotificationManager::NotificationLevel::ErrorNotificationLevel,
        into_u8(message));
}

References _L, Slic3r::GUI::CustomNotification, Slic3r::GUI::NotificationManager::ErrorNotificationLevel, install_local_plugin(), Slic3r::GUI::install_local_plugin_package(), Slic3r::GUI::into_u8(), mainframe, plater(), and Slic3r::GUI::NotificationManager::RegularNotificationLevel.

Referenced by install_local_plugin().

Here is the call graph for this function:

Here is the caller graph for this function:

install_network_plugin_from_ota()

bool Slic3r::GUI::GUI_App::install_network_plugin_from_ota

(

bool &

had_cache

)

{
    had_cache = false;
 
    std::string data_dir_str = data_dir();
    boost::filesystem::path data_dir_path(data_dir_str);
    auto plugin_folder = data_dir_path / "plugins";
    auto cache_folder = data_dir_path / "ota" / "plugins";
    std::string changelog_file = cache_folder.string() + "/network_plugins.json";
 
    std::string cached_version;
    if (boost::filesystem::exists(changelog_file)) {
        try {
            boost::nowide::ifstream ifs(changelog_file);
            json j;
            ifs >> j;
            if (j.contains("version"))
                cached_version = j["version"];
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": cached_version = " << cached_version;
        } catch (nlohmann::detail::parse_error& err) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": parse " << changelog_file << " failed: " << err.what();
        }
    }
 
    if (cached_version.empty()) {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": no version found in changelog, nothing to install";
        return false;
    }
    had_cache = true;
 
    std::string network_library, player_library, live555_library, network_library_dst, player_library_dst, live555_library_dst;
#if defined(_MSC_VER) || defined(_WIN32)
    network_library = cache_folder.string() + "/bambu_networking.dll";
    player_library = cache_folder.string() + "/BambuSource.dll";
    live555_library = cache_folder.string() + "/live555.dll";
    network_library_dst = plugin_folder.string() + "/" + std::string(BAMBU_NETWORK_LIBRARY) + "_" + cached_version + ".dll";
    player_library_dst = plugin_folder.string() + "/BambuSource.dll";
    live555_library_dst = plugin_folder.string() + "/live555.dll";
#elif defined(__WXMAC__)
    network_library = cache_folder.string() + "/libbambu_networking.dylib";
    player_library = cache_folder.string() + "/libBambuSource.dylib";
    live555_library = cache_folder.string() + "/liblive555.dylib";
    network_library_dst = plugin_folder.string() + "/lib" + std::string(BAMBU_NETWORK_LIBRARY) + "_" + cached_version + ".dylib";
    player_library_dst = plugin_folder.string() + "/libBambuSource.dylib";
    live555_library_dst = plugin_folder.string() + "/liblive555.dylib";
#else
    network_library = cache_folder.string() + "/libbambu_networking.so";
    player_library = cache_folder.string() + "/libBambuSource.so";
    live555_library = cache_folder.string() + "/liblive555.so";
    network_library_dst = plugin_folder.string() + "/lib" + std::string(BAMBU_NETWORK_LIBRARY) + "_" + cached_version + ".so";
    player_library_dst = plugin_folder.string() + "/libBambuSource.so";
    live555_library_dst = plugin_folder.string() + "/liblive555.so";
#endif
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": checking network_library " << network_library << ", player_library " << player_library;
    if (!boost::filesystem::exists(plugin_folder)) {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": create directory " << plugin_folder.string();
        boost::filesystem::create_directory(plugin_folder);
    }
 
    // Replace a destination even while the running process still maps it: an in-use
    // file cannot be deleted or overwritten on Windows, but it can be renamed aside;
    // the stale ".old" copy is swept on the next launch (see on_init_network).
    auto install_file = [](const std::string& src, const std::string& dst) -> bool {
        boost::system::error_code ec;
        if (boost::filesystem::exists(dst, ec)) {
            boost::filesystem::remove(dst, ec);
            if (ec) {
                boost::filesystem::path aside(dst);
                aside += ".old";
                boost::system::error_code ec2;
                boost::filesystem::remove(aside, ec2);
                boost::filesystem::rename(dst, aside, ec2);
                if (ec2) {
                    BOOST_LOG_TRIVIAL(error) << "install_network_plugin_from_ota: cannot replace in-use file " << dst << ": " << ec2.message();
                    return false;
                }
            }
        }
        std::string error_message;
        CopyFileResult cfr = copy_file(src, dst, error_message, false);
        if (cfr != CopyFileResult::SUCCESS) {
            BOOST_LOG_TRIVIAL(error) << "install_network_plugin_from_ota: copying " << src << " failed(" << cfr << "): " << error_message;
            return false;
        }
        static constexpr const auto perms = fs::owner_read | fs::owner_write | fs::group_read | fs::others_read;
        fs::permissions(dst, perms);
        boost::filesystem::remove(src, ec);
        return true;
    };
 
    if (boost::filesystem::exists(network_library)) {
        if (!install_file(network_library, network_library_dst))
            return false;
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": Copying network library from " << network_library << " to " << network_library_dst << " successfully.";
 
        app_config->set_network_plugin_version(cached_version);
        app_config->save();
    }
 
    if (boost::filesystem::exists(player_library)) {
        if (!install_file(player_library, player_library_dst))
            return false;
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": Copying player library from " << player_library << " to " << player_library_dst << " successfully.";
    }
 
    if (boost::filesystem::exists(live555_library)) {
        if (!install_file(live555_library, live555_library_dst))
            return false;
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": Copying live555 library from " << live555_library << " to " << live555_library_dst << " successfully.";
    }
    // All cached files consumed - drop the whole ota/plugins cache folder.
    try {
        if (boost::filesystem::exists(cache_folder))
            fs::remove_all(cache_folder);
    } catch (...) {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": failed to remove the plugin cache folder " << cache_folder.string();
    }
    return true;
}

References app_config, BAMBU_NETWORK_LIBRARY, Slic3r::copy_file(), Slic3r::data_dir(), install_network_plugin_from_ota(), and Slic3r::SUCCESS.

Referenced by copy_network_if_available(), and install_network_plugin_from_ota().

Here is the call graph for this function:

Here is the caller graph for this function:

install_plugin()

int Slic3r::GUI::GUI_App::install_plugin	(	std::string	name,
		std::string	package_name,
		InstallProgressFn	pro_fn = nullptr,
		WasCancelledFn	cancel_fn = nullptr )

{
    bool cancel = false;
    std::string target_file_path = (fs::temp_directory_path() / package_name).string();
 
    BOOST_LOG_TRIVIAL(info) << "[install_plugin] enter";
    // get plugin folder
    std::string data_dir_str = data_dir();
    boost::filesystem::path data_dir_path(data_dir_str);
    auto plugin_folder = data_dir_path / name;
    //auto plugin_folder = boost::filesystem::path(wxStandardPaths::Get().GetUserDataDir().ToUTF8().data()) / "plugins";
    auto backup_folder = plugin_folder/"backup";
    if (!boost::filesystem::exists(plugin_folder)) {
        BOOST_LOG_TRIVIAL(info) << "[install_plugin] will create directory "<<plugin_folder.string();
        boost::filesystem::create_directory(plugin_folder);
    }
    if (!boost::filesystem::exists(backup_folder)) {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(", will create directory %1%")%backup_folder.string();
        boost::filesystem::create_directory(backup_folder);
    }
 
    if (m_networking_cancel_update) {
        BOOST_LOG_TRIVIAL(info) << boost::format("[install_plugin]: %1%, cancelled by user")%__LINE__;
        return -1;
    }
    if (pro_fn) {
        pro_fn(InstallStatusNormal, 50, cancel);
    }
    // unzip
    mz_zip_archive archive;
    mz_zip_zero_struct(&archive);
    if (!open_zip_reader(&archive, target_file_path)) {
        BOOST_LOG_TRIVIAL(error) << boost::format("[install_plugin]: %1%, open zip file failed")%__LINE__;
        if (pro_fn) pro_fn(InstallStatusDownloadFailed, 0, cancel);
        return InstallStatusUnzipFailed;
    }
 
    boost::filesystem::path legacy_lib_path, legacy_lib_backup;
    bool had_existing_legacy = false;
    if (name == "plugins") {
#if defined(_MSC_VER) || defined(_WIN32)
        legacy_lib_path = plugin_folder / (std::string(BAMBU_NETWORK_LIBRARY) + ".dll");
#elif defined(__WXMAC__)
        legacy_lib_path = plugin_folder / (std::string("lib") + std::string(BAMBU_NETWORK_LIBRARY) + ".dylib");
#else
        legacy_lib_path = plugin_folder / (std::string("lib") + std::string(BAMBU_NETWORK_LIBRARY) + ".so");
#endif
        legacy_lib_backup = legacy_lib_path;
        legacy_lib_backup += ".backup";
 
        if (boost::filesystem::exists(legacy_lib_path)) {
            had_existing_legacy = true;
            boost::system::error_code ec;
            boost::filesystem::rename(legacy_lib_path, legacy_lib_backup, ec);
            if (ec) {
                BOOST_LOG_TRIVIAL(warning) << "[install_plugin] failed to backup existing legacy library: " << ec.message();
                had_existing_legacy = false;
            } else {
                BOOST_LOG_TRIVIAL(info) << "[install_plugin] backed up existing legacy library";
            }
        }
    }
 
    mz_uint num_entries = mz_zip_reader_get_num_files(&archive);
    mz_zip_archive_file_stat stat;
    BOOST_LOG_TRIVIAL(error) << boost::format("[install_plugin]: %1%, got %2% files")%__LINE__ %num_entries;
    for (mz_uint i = 0; i < num_entries; i++) {
        if (m_networking_cancel_update || cancel) {
            BOOST_LOG_TRIVIAL(info) << boost::format("[install_plugin]: %1%, cancelled by user")%__LINE__;
            return -1;
        }
        if (mz_zip_reader_file_stat(&archive, i, &stat)) {
            if (stat.m_uncomp_size > 0) {
                std::string dest_file;
                if (stat.m_is_utf8) {
                    dest_file = stat.m_filename;
                }
                else {
                    std::string extra(1024, 0);
                    size_t n = mz_zip_reader_get_extra(&archive, stat.m_file_index, extra.data(), extra.size());
                    dest_file = decode(extra.substr(0, n), stat.m_filename);
                }
                if (!is_path_within_root(dest_file, plugin_folder)) {
                    BOOST_LOG_TRIVIAL(error) << "[install_plugin] entry " << dest_file << " resolves outside " << plugin_folder.string();
                    close_zip_reader(&archive);
                    if (pro_fn) { pro_fn(InstallStatusUnzipFailed, 0, cancel); }
                    return InstallStatusUnzipFailed;
                }
                auto dest_path = plugin_folder / dest_file;
                std::string dest_zip_file = encode_path(dest_path.string().c_str());
#ifndef WIN32
                // Validate a symlink's target before anything at the destination is replaced.
                const bool is_link = S_ISLNK(stat.m_external_attr >> 16);
                std::string link;
                if (is_link) {
                    link.assign(stat.m_uncomp_size, 0);
                    if (!mz_zip_reader_extract_to_mem(&archive, stat.m_file_index, link.data(), stat.m_uncomp_size, 0) ||
                        !is_symlink_target_within_root(dest_file, link, plugin_folder)) {
                        BOOST_LOG_TRIVIAL(error) << "[install_plugin] link " << dest_file << " -> " << link << " is unreadable or resolves outside " << plugin_folder.string();
                        close_zip_reader(&archive);
                        if (pro_fn) { pro_fn(InstallStatusUnzipFailed, 0, cancel); }
                        return InstallStatusUnzipFailed;
                    }
                }
#endif
                try {
                    boost::filesystem::create_directories(dest_path.parent_path());
                    // symlink_status so that an existing symlink, dangling or not, is replaced rather than written through.
                    if (fs::exists(fs::symlink_status(dest_path))) {
                        boost::system::error_code ec;
                        fs::remove(dest_path, ec);
                        if (ec) {
                            // On Windows a currently-loaded DLL (e.g. BambuSource.dll, or the
                            // networking library in legacy mode) cannot be deleted or overwritten
                            // in place, which failed the whole install with "The plug-in file may
                            // be in use" (issue #14373). It CAN however be renamed aside: the
                            // running module keeps mapping the renamed file while we write the new
                            // one. The stale ".old" copy is cleared on the next install/launch.
                            boost::filesystem::path aside = dest_path;
                            aside += ".old";
                            boost::system::error_code ec2;
                            fs::remove(aside, ec2);
                            fs::rename(dest_path, aside, ec2);
                            if (ec2) {
                                close_zip_reader(&archive);
                                BOOST_LOG_TRIVIAL(error) << "[install_plugin] cannot replace in-use file "
                                                         << dest_path.string() << ": " << ec2.message();
                                if (pro_fn) { pro_fn(InstallStatusUnzipFailed, 0, cancel); }
                                return InstallStatusUnzipFailed;
                            }
                            BOOST_LOG_TRIVIAL(warning) << "[install_plugin] " << dest_path.filename().string()
                                                       << " was in use, renamed aside to .old";
                        }
                    }
                    mz_bool res = 0;
#ifndef WIN32
                    if (is_link) {
                        res = 1;
                        try {
                            boost::filesystem::create_symlink(link, dest_path);
                        } catch (const std::exception &e) {
                            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " create_symlink:" << e.what();
                        }
                    } else {
#endif
                        res = mz_zip_reader_extract_to_file(&archive, stat.m_file_index, dest_zip_file.c_str(), 0);
#ifndef WIN32
                    }
#endif
                    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(", extract  %1% from plugin zip %2%\n") % dest_file % stat.m_filename;
                    if (res == 0) {
#ifdef WIN32
                        std::wstring new_dest_zip_file = boost::locale::conv::utf_to_utf<wchar_t>(dest_path.generic_string());
                        res                            = mz_zip_reader_extract_to_file_w(&archive, stat.m_file_index, new_dest_zip_file.c_str(), 0);
#endif
                        if (res == 0) {
                            mz_zip_error zip_error = mz_zip_get_last_error(&archive);
                            BOOST_LOG_TRIVIAL(error) << "[install_plugin]Archive read error:" << mz_zip_get_error_string(zip_error) << std::endl;
                            close_zip_reader(&archive);
                            if (pro_fn) { pro_fn(InstallStatusUnzipFailed, 0, cancel); }
                            return InstallStatusUnzipFailed;
                        }
                    }
                }
                catch (const std::exception& e)
                {
                    // ensure the zip archive is closed and rethrow the exception
                    close_zip_reader(&archive);
                    BOOST_LOG_TRIVIAL(error) << "[install_plugin]Archive read exception:"<<e.what();
                    if (pro_fn) {
                        pro_fn(InstallStatusUnzipFailed, 0, cancel);
                    }
                    return InstallStatusUnzipFailed;
                }
            }
        }
        else {
            BOOST_LOG_TRIVIAL(error) << boost::format("[install_plugin]: %1%, mz_zip_reader_file_stat for file %2% failed")%__LINE__%i;
        }
    }
 
    close_zip_reader(&archive);
 
    if (name == "plugins") {
        std::string config_version = app_config->get_network_plugin_version();
        if (config_version.empty()) {
            config_version = get_latest_network_version();
            BOOST_LOG_TRIVIAL(info) << "[install_plugin] config_version was empty, using latest: " << config_version;
            app_config->set_network_plugin_version(config_version);
            GUI::wxGetApp().CallAfter([this] {
                if (app_config)
                    app_config->save();
            });
        }
        if (!config_version.empty() && boost::filesystem::exists(legacy_lib_path)) {
#if defined(_MSC_VER) || defined(_WIN32)
            auto versioned_lib = plugin_folder / (std::string(BAMBU_NETWORK_LIBRARY) + "_" + config_version + ".dll");
#elif defined(__WXMAC__)
            auto versioned_lib = plugin_folder / (std::string("lib") + std::string(BAMBU_NETWORK_LIBRARY) + "_" + config_version + ".dylib");
#else
            auto versioned_lib = plugin_folder / (std::string("lib") + std::string(BAMBU_NETWORK_LIBRARY) + "_" + config_version + ".so");
#endif
            BOOST_LOG_TRIVIAL(info) << "[install_plugin] renaming newly extracted " << legacy_lib_path.string() << " to " << versioned_lib.string();
            boost::system::error_code ec;
            if (boost::filesystem::exists(versioned_lib)) {
                boost::filesystem::remove(versioned_lib, ec);
            }
            boost::filesystem::rename(legacy_lib_path, versioned_lib, ec);
            if (ec) {
                BOOST_LOG_TRIVIAL(error) << "[install_plugin] failed to rename to versioned: " << ec.message();
            }
        }
 
        if (had_existing_legacy && boost::filesystem::exists(legacy_lib_backup)) {
            BOOST_LOG_TRIVIAL(info) << "[install_plugin] restoring backed up legacy library";
            boost::system::error_code ec;
            boost::filesystem::rename(legacy_lib_backup, legacy_lib_path, ec);
            if (ec) {
                BOOST_LOG_TRIVIAL(warning) << "[install_plugin] failed to restore legacy library backup: " << ec.message();
            }
        }
    }
 
    {
        fs::path dir_path(plugin_folder);
        if (fs::exists(dir_path) && fs::is_directory(dir_path)) {
            int file_count = 0, file_index = 0;
            for (fs::directory_iterator it(dir_path); it != fs::directory_iterator(); ++it) {
                if (fs::is_regular_file(it->status())) { ++file_count; }
            }
            for (fs::directory_iterator it(dir_path); it != fs::directory_iterator(); ++it) {
                BOOST_LOG_TRIVIAL(info) << " current path:" << it->path().string();
                if (it->path().string() == backup_folder) {
                    continue;
                }
                auto dest_path = backup_folder.string() + "/" + it->path().filename().string();
                if (fs::is_regular_file(it->status())) {
                    BOOST_LOG_TRIVIAL(info) << " copy file:" << it->path().string() << "," << it->path().filename();
                    try {
                        if (pro_fn) { pro_fn(InstallStatusNormal, 50 + file_index / file_count, cancel); }
                        file_index++;
                        if (fs::exists(dest_path)) { fs::remove(dest_path); }
                        std::string    error_message;
                        CopyFileResult cfr = copy_file(it->path().string(), dest_path, error_message, false);
                        if (cfr != CopyFileResult::SUCCESS) { BOOST_LOG_TRIVIAL(error) << "Copying to backup failed(" << cfr << "): " << error_message; }
                    } catch (const std::exception &e) {
                        BOOST_LOG_TRIVIAL(error) << "Copying to backup failed: " << e.what();
                    }
                } else {
                    BOOST_LOG_TRIVIAL(info) << " copy framework:" << it->path().string() << "," << it->path().filename();
                    copy_framework(it->path().string(), dest_path);
                }
            }
        }
    }
 
 
    if (pro_fn)
        pro_fn(InstallStatusInstallCompleted, 100, cancel);
    if (name == "plugins")
        app_config->set_bool("installed_networking", true);
    BOOST_LOG_TRIVIAL(info) << "[install_plugin] success";
    return 0;
}

References app_config, BAMBU_NETWORK_LIBRARY, Slic3r::close_zip_reader(), Slic3r::copy_file(), Slic3r::copy_framework(), Slic3r::data_dir(), Slic3r::GUI::decode(), Slic3r::encode_path(), get_latest_network_version(), Slic3r::GUI::InstallStatusDownloadFailed, Slic3r::GUI::InstallStatusInstallCompleted, Slic3r::GUI::InstallStatusNormal, Slic3r::GUI::InstallStatusUnzipFailed, Slic3r::is_path_within_root(), Slic3r::is_symlink_target_within_root(), m_networking_cancel_update, Slic3r::open_zip_reader(), and Slic3r::SUCCESS.

Here is the call graph for this function:

is_adding_script_handler()

bool Slic3r::GUI::GUI_App::is_adding_script_handler ( )

inline

{ return m_adding_script_handler; }

References m_adding_script_handler.

Referenced by run_wizard().

Here is the caller graph for this function:

is_blocking_printing() [1/2]

bool Slic3r::GUI::GUI_App::is_blocking_printing	(	MachineObject *	obj_,
		const std::string &	source_model )

{
    DeviceManager *dev = getDeviceManager();
    if (!dev) return true;
    if (obj_ == nullptr)
        obj_ = dev->get_selected_machine();
    if (!obj_)
        return false;
 
    return !DevPrinterConfigUtil::is_printer_model_compatible(source_model, *obj_);
}

References Slic3r::DeviceManager::get_selected_machine(), getDeviceManager(), is_blocking_printing(), and Slic3r::DevPrinterConfigUtil::is_printer_model_compatible().

Here is the call graph for this function:

is_blocking_printing() [2/2]

bool Slic3r::GUI::GUI_App::is_blocking_printing

(

MachineObject *

obj_ = nullptr

)

{
    PresetBundle *preset_bundle = wxGetApp().preset_bundle;
    const std::string source_model = preset_bundle
        ? preset_bundle->printers.get_edited_preset().get_printer_type(preset_bundle)
        : std::string();
    return is_blocking_printing(obj_, source_model);
}

References is_blocking_printing(), and preset_bundle.

Referenced by is_blocking_printing(), and is_blocking_printing().

Here is the call graph for this function:

Here is the caller graph for this function:

is_closing()

bool Slic3r::GUI::GUI_App::is_closing ( ) const

inline

{ return m_is_closing.load(std::memory_order_acquire); }

References m_is_closing.

Referenced by init_networking_callbacks(), init_plugin_gui_wiring(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::list_bundle_ids(), maybe_migrate_user_presets_on_login(), mint_cloud_web_session(), on_cloud_web_session_minted(), on_http_error(), post_init(), refresh_plugins(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::reload_local_bundle(), reload_settings(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::require_gui_app(), restart_networking(), restart_sync_user_preset(), Slic3r::GUI::NativeCommands::run(), start_sync_user_preset(), stop_sync_user_preset(), sync_bundle(), and update_single_bundle().

Here is the caller graph for this function:

is_compatibility_version()

bool Slic3r::GUI::GUI_App::is_compatibility_version

(

)

{
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__<< boost::format(": m_networking_compatible=%1%")%m_networking_compatible;
    return m_networking_compatible;
}

References m_networking_compatible.

is_editor()

bool Slic3r::GUI::GUI_App::is_editor ( ) const

inline

{ return m_app_mode == EAppMode::Editor; }

References Editor, and m_app_mode.

Referenced by Slic3r::anonymous_namespace{PluginHostApp.cpp}::app_info(), logo_name(), on_init_inner(), open_preferences(), post_init(), and recreate_GUI().

Here is the caller graph for this function:

is_enable_multi_machine()

bool Slic3r::GUI::GUI_App::is_enable_multi_machine ( )

inline

{ return this->app_config&& this->app_config->get("enable_multi_machine") == "true"; }

References app_config.

Referenced by init_networking_callbacks(), on_init_network(), and push_notification().

Here is the caller graph for this function:

is_gcode_viewer()

bool Slic3r::GUI::GUI_App::is_gcode_viewer ( ) const

inline

{ return m_app_mode == EAppMode::GCodeViewer; }

References GCodeViewer, and m_app_mode.

Referenced by on_init_inner(), and post_init().

Here is the caller graph for this function:

is_gl_version_greater_or_equal_to()

bool Slic3r::GUI::GUI_App::is_gl_version_greater_or_equal_to ( unsigned int major, unsigned int minor ) const

inline

{ return m_opengl_mgr.get_gl_info().is_version_greater_or_equal_to(major, minor); }

References m_opengl_mgr.

is_glsl_version_greater_or_equal_to()

bool Slic3r::GUI::GUI_App::is_glsl_version_greater_or_equal_to ( unsigned int major, unsigned int minor ) const

inline

{ return m_opengl_mgr.get_gl_info().is_glsl_version_greater_or_equal_to(major, minor); }

References m_opengl_mgr.

is_localized()

bool Slic3r::GUI::GUI_App::is_localized ( ) const

inline

{ return m_wxLocale->GetLocale() != "English"; }

References m_wxLocale.

is_recreating_gui()

bool Slic3r::GUI::GUI_App::is_recreating_gui ( ) const

inline

{ return m_is_recreating_gui; }

References m_is_recreating_gui.

is_studio_active()

bool Slic3r::GUI::GUI_App::is_studio_active

(

)

{
    auto curr_time = std::chrono::system_clock::now();
    auto diff = std::chrono::duration_cast<std::chrono::milliseconds>(curr_time - last_active_point);
    if (diff.count() < STUDIO_INACTIVE_TIMEOUT) {
        return true;
    }
    return false;
}

References Slic3r::diff(), is_studio_active(), last_active_point, and STUDIO_INACTIVE_TIMEOUT.

Referenced by is_studio_active(), and on_init_inner().

Here is the call graph for this function:

Here is the caller graph for this function:

is_user_login()

bool Slic3r::GUI::GUI_App::is_user_login

(

const std::string &

provider = ORCA_CLOUD_PROVIDER

)

{
    if (m_agent) {
        return m_agent->is_user_login(provider);
    }
    return false;
}

References is_user_login(), and m_agent.

Referenced by Slic3r::anonymous_namespace{PluginHostApp.cpp}::app_info(), is_user_login(), open_mall_page_dialog(), open_publish_page_dialog(), and post_init().

Here is the call graph for this function:

Here is the caller graph for this function:

keyboard_shortcuts()

void Slic3r::GUI::GUI_App::keyboard_shortcuts	(	ShortcutContext	page,
		wxWindow *	parent = nullptr )

{
    KBShortcutsDialog dlg(parent != nullptr ? parent : mainframe, page);
    dlg.ShowModal();
}

References keyboard_shortcuts(), mainframe, and Slic3r::GUI::DPIAware< P >::ShowModal().

Referenced by keyboard_shortcuts().

Here is the call graph for this function:

Here is the caller graph for this function:

last_config_version()

const boost::optional< Semver > & Slic3r::GUI::GUI_App::last_config_version ( ) const

inline

{ return m_last_config_version; }

References m_last_config_version.

Referenced by Slic3r::anonymous_namespace{PluginHostApp.cpp}::app_info().

Here is the caller graph for this function:

link_font()

const wxFont & Slic3r::GUI::GUI_App::link_font ( )

inline

{ return m_link_font; }

References m_link_font.

link_to_lan_only_wiki()

std::string Slic3r::GUI::GUI_App::link_to_lan_only_wiki

(

)

{
    std::string url;
    std::string country_code = app_config->get_country_code();
 
    if (country_code == "US") {
        url = "https://wiki.bambulab.com/en/knowledge-sharing/enable-lan-mode";
    }
    else if (country_code == "CN") {
        url = "https://wiki.bambulab.com/zh/knowledge-sharing/enable-lan-mode";
    }
    else {
        url = "https://wiki.bambulab.com/en/knowledge-sharing/enable-lan-mode";
    }
    //wxLaunchDefaultBrowser(url);
    return url; // ORCA
}

References app_config, and link_to_lan_only_wiki().

Referenced by link_to_lan_only_wiki().

Here is the call graph for this function:

Here is the caller graph for this function:

link_to_network_check()

std::string Slic3r::GUI::GUI_App::link_to_network_check

(

)

{
    std::string url;
    std::string country_code = app_config->get_country_code();
 
 
    if (country_code == "US") {
        url = "https://status.bambulab.com";
    }
    else if (country_code == "CN") {
        url = "https://status.bambulab.cn";
    }
    else {
        url = "https://status.bambulab.com";
    }
    //wxLaunchDefaultBrowser(url);
    return url; // ORCA
}

References app_config, and link_to_network_check().

Referenced by link_to_network_check().

Here is the call graph for this function:

Here is the caller graph for this function:

load_current_presets()

void Slic3r::GUI::GUI_App::load_current_presets	(	bool	active_preset_combox = false,
		bool	check_printer_presets = true )

{
    // check printer_presets for the containing information about "Print Host upload"
    // and create physical printer from it, if any exists
    if (check_printer_presets_)
        check_printer_presets();
 
    auto& edited_printer_preset = preset_bundle->printers.get_edited_preset();
    PrinterTechnology printer_technology = edited_printer_preset.printer_technology();
    // ORCA: Sync filament count with the printer's nozzle count before loading presets for multi-tool printers.
    // This ensures filament_presets vector is properly sized when combo boxes are created/updated.
    if (printer_technology == ptFFF && !edited_printer_preset.config.opt_bool("single_extruder_multi_material")) {
        auto* nozzle_diameter = edited_printer_preset.config.option<ConfigOptionFloats>("nozzle_diameter");
        if (nozzle_diameter) {
            // Mixed-color slots are virtual filaments kept at the tail of the list, so they have no
            // nozzle of their own and the count has to allow for them. Only ever grow: this sizes
            // the list so the combo boxes have something to bind to, and set_num_filaments() trims
            // at the raw tail, so shrinking here would eat the mixes rather than the surplus
            // physical slots. A list longer than the nozzle count is a state the app reaches
            // legitimately - raising the extruder count and not saving the printer preset leaves
            // exactly that on the next start - and losing the project's mixes to it is worse than
            // carrying a filament the printer has no nozzle for until the count is next changed.
            const size_t target = nozzle_diameter->values.size() + preset_bundle->num_mixed_filaments();
            if (target > preset_bundle->filament_presets.size())
                preset_bundle->set_num_filaments(target);
        }
    }
  this->plater()->set_printer_technology(printer_technology);
    for (Tab *tab : tabs_list)
    if (tab->supports_printer_technology(printer_technology)) {
      if (tab->type() == Preset::TYPE_PRINTER) {
        static_cast<TabPrinter*>(tab)->update_pages();
        // Mark the plater to update print bed by tab->load_current_preset() from Plater::on_config_change().
        this->plater()->force_print_bed_update();
      }
      tab->load_current_preset();
      //BBS: add preset combox re-active logic
      if (active_preset_combox)
        tab->reactive_preset_combo_box();
    }
    // Preset loading can resize the filament list without an extruder-count change event.
    // Refresh the controls even when the list already matches the printer's nozzle count.
    if (printer_technology == ptFFF)
        this->plater()->on_filament_count_change(preset_bundle->filament_presets.size());
 
    // BBS: model config
    for (Tab *tab : model_tabs_list)
    if (tab->supports_printer_technology(printer_technology)) {
            tab->rebuild_page_tree();
        }
}

References check_printer_presets(), load_current_presets(), model_tabs_list, Slic3r::nozzle_diameter(), plater(), preset_bundle, Slic3r::GUI::printer_technology(), Slic3r::ptFFF, tabs_list, and Slic3r::Preset::TYPE_PRINTER.

Referenced by apply_keeped_preset_modifications(), check_and_keep_current_preset_changes(), check_and_save_current_preset_changes(), load_current_presets(), on_init_inner(), recreate_GUI(), run_wizard(), ShowOnlyFilament(), and ShowUserGuide().

Here is the call graph for this function:

Here is the caller graph for this function:

load_gcode()

void Slic3r::GUI::GUI_App::load_gcode	(	wxWindow *	parent,
		wxString &	input_file ) const

{
    input_file.Clear();
    wxFileDialog dialog(parent ? parent : GetTopWindow(),
        _L("Choose one file (GCODE/3MF):"),
        app_config->get_last_dir(), "",
        file_wildcards(FT_GCODE), wxFD_OPEN | wxFD_FILE_MUST_EXIST);
 
    if (dialog.ShowModal() == wxID_OK)
        input_file = dialog.GetPath();
}

References _L, app_config, Slic3r::GUI::file_wildcards(), Slic3r::GUI::FT_GCODE, and load_gcode().

Referenced by load_gcode().

Here is the call graph for this function:

Here is the caller graph for this function:

load_language()

bool Slic3r::GUI::GUI_App::load_language	(	wxString	language,
		bool	initial )

{
    BOOST_LOG_TRIVIAL(info) << boost::format("%1%: language %2%, initial: %3%") %__FUNCTION__ %language %initial;
    if (initial) {
      // There is a static list of lookup path prefixes in wxWidgets. Add ours.
      wxFileTranslationsLoader::AddCatalogLookupPathPrefix(from_u8(localization_dir()));
      // Get the active language from PrusaSlicer.ini, or empty string if the key does not exist.
        language = app_config->get("language");
        if (! language.empty())
          BOOST_LOG_TRIVIAL(info) << boost::format("language provided by OrcaSlicer.conf: %1%") % language;
        else {
            // Get the system language.
            const wxLanguage lang_system = wxLanguage(wxLocale::GetSystemLanguage());
            if (lang_system != wxLANGUAGE_UNKNOWN) {
                m_language_info_system = wxLocale::GetLanguageInfo(lang_system);
#ifdef __WXMSW__
                WCHAR wszLanguagesBuffer[LOCALE_NAME_MAX_LENGTH];
                ::LCIDToLocaleName(LOCALE_USER_DEFAULT, wszLanguagesBuffer, LOCALE_NAME_MAX_LENGTH, 0);
                wxString lang(wszLanguagesBuffer);
                lang.Replace('-', '_');
                if (auto info = wxLocale::FindLanguageInfo(lang))
                    m_language_info_system = info;
#endif
                BOOST_LOG_TRIVIAL(info) << boost::format("System language detected (user locales and such): %1%") % m_language_info_system->CanonicalName.ToUTF8().data();
                // BBS set language to app config
                app_config->set("language", m_language_info_system->CanonicalName.ToUTF8().data());
            } else {
                {
                    // Allocating a temporary locale will switch the default wxTranslations to its internal wxTranslations instance.
                    wxLocale temp_locale;
                    temp_locale.Init();
                    // Set the current translation's language to default, otherwise GetBestTranslation() may not work (see the wxWidgets source code).
                    wxTranslations::Get()->SetLanguage(wxLANGUAGE_DEFAULT);
                    // Let the wxFileTranslationsLoader enumerate all translation dictionaries for PrusaSlicer
                    // and try to match them with the system specific "preferred languages".
                    // There seems to be a support for that on Windows and OSX, while on Linuxes the code just returns wxLocale::GetSystemLanguage().
                    // The last parameter gets added to the list of detected dictionaries. This is a workaround
                    // for not having the English dictionary. Let's hope wxWidgets of various versions process this call the same way.
                    wxString best_language = wxTranslations::Get()->GetBestTranslation(SLIC3R_APP_KEY, wxLANGUAGE_ENGLISH);
                    if (!best_language.IsEmpty()) {
                        m_language_info_best = wxLocale::FindLanguageInfo(best_language);
                        BOOST_LOG_TRIVIAL(info) << boost::format("Best translation language detected (may be different from user locales): %1%") %
                                                        m_language_info_best->CanonicalName.ToUTF8().data();
                        app_config->set("language", m_language_info_best->CanonicalName.ToUTF8().data());
                    }
#ifdef __linux__
                    wxString lc_all;
                    if (wxGetEnv("LC_ALL", &lc_all) && !lc_all.IsEmpty()) {
                        // Best language returned by wxWidgets on Linux apparently does not respect LC_ALL.
                        // Disregard the "best" suggestion in case LC_ALL is provided.
                        m_language_info_best = nullptr;
                    }
#endif
                }
            }
        }
    }
 
  const wxLanguageInfo *language_info = language.empty() ? nullptr : wxLocale::FindLanguageInfo(language);
  if (! language.empty() && (language_info == nullptr || language_info->CanonicalName.empty())) {
    // Fix for wxWidgets issue, where the FindLanguageInfo() returns locales with undefined ANSII code (wxLANGUAGE_KONKANI or wxLANGUAGE_MANIPURI).
    language_info = nullptr;
      BOOST_LOG_TRIVIAL(error) << boost::format("Language code \"%1%\" is not supported") % language.ToUTF8().data();
  }
 
  if (language_info != nullptr && language_info->LayoutDirection == wxLayout_RightToLeft) {
      BOOST_LOG_TRIVIAL(trace) << boost::format("The following language code requires right to left layout, which is not supported by OrcaSlicer: %1%") % language_info->CanonicalName.ToUTF8().data();
    language_info = nullptr;
  }
 
    if (language_info == nullptr) {
        // PrusaSlicer does not support the Right to Left languages yet.
        if (m_language_info_system != nullptr && m_language_info_system->LayoutDirection != wxLayout_RightToLeft)
            language_info = m_language_info_system;
        if (m_language_info_best != nullptr && m_language_info_best->LayoutDirection != wxLayout_RightToLeft)
          language_info = m_language_info_best;
      if (language_info == nullptr)
      language_info = wxLocale::GetLanguageInfo(wxLANGUAGE_ENGLISH_US);
    }
 
    const wxLanguageInfo *translation_language_info = language_info;
    const wxString requested_language_code = translation_language_info->CanonicalName;
    const wxLanguageInfo *locale_language_info = translation_language_info;
    BOOST_LOG_TRIVIAL(trace) << boost::format("Requested translation language %1%") % requested_language_code.ToUTF8().data();
 
    // Select language for locales. This language may be different from the language of the dictionary.
    //if (language_info == m_language_info_best || language_info == m_language_info_system) {
    //    // The current language matches user's default profile exactly. That's great.
    //} else if (m_language_info_best != nullptr && language_info->CanonicalName.BeforeFirst('_') == m_language_info_best->CanonicalName.BeforeFirst('_')) {
    //    // Use whatever the operating system recommends, if it the language code of the dictionary matches the recommended language.
    //    // This allows a Swiss guy to use a German dictionary without forcing him to German locales.
    //    language_info = m_language_info_best;
    //} else if (m_language_info_system != nullptr && language_info->CanonicalName.BeforeFirst('_') == m_language_info_system->CanonicalName.BeforeFirst('_'))
    //    language_info = m_language_info_system;
 
    // Alternate language code.
    wxLanguage language_dict = wxLanguage(translation_language_info->Language);
    if (translation_language_info->CanonicalName.BeforeFirst('_') == "sk") {
      // Slovaks understand Czech well. Give them the Czech translation.
      language_dict = wxLANGUAGE_CZECH;
    BOOST_LOG_TRIVIAL(info) << "Using Czech dictionaries for Slovak language";
    }
 
#ifdef __linux__
    // If we can't find this locale , try to use different one for the language
    // instead of just reporting that it is impossible to switch.
    if (!wxLocale::IsAvailable(locale_language_info->Language) && m_language_info_system) {
        std::string original_lang = into_u8(locale_language_info->CanonicalName);
        locale_language_info = linux_get_existing_locale_language(locale_language_info, m_language_info_system);
        if (locale_language_info != nullptr && locale_language_info != translation_language_info) {
            BOOST_LOG_TRIVIAL(info) << boost::format("Can't use locale %1% directly (missing locales). Using locale %2% instead.")
                                        % original_lang % locale_language_info->CanonicalName.ToUTF8().data();
        }
    }
#endif
 
    // Try base language without region (e.g., "en" from "en_IL") on all platforms
    if (locale_language_info == nullptr || !wxLocale::IsAvailable(locale_language_info->Language)) {
        wxString base_lang = requested_language_code.BeforeFirst('_');
        if (base_lang != requested_language_code) {
            const wxLanguageInfo *base_info = wxLocale::FindLanguageInfo(base_lang);
            if (base_info && wxLocale::IsAvailable(base_info->Language)) {
                BOOST_LOG_TRIVIAL(info) << boost::format("Locale %1% not available. Falling back to base language %2%.")
                    % requested_language_code.ToUTF8().data() % base_info->CanonicalName.ToUTF8().data();
                locale_language_info = base_info;
            }
        }
    }
 
    // Generic fallback chain for all platforms
    if (locale_language_info == nullptr || !wxLocale::IsAvailable(locale_language_info->Language)) {
        auto try_locale = [](const wxLanguageInfo* candidate) -> const wxLanguageInfo* {
            return (candidate && wxLocale::IsAvailable(candidate->Language)) ? candidate : nullptr;
        };
        const wxLanguageInfo* fallback_locale_info =
            try_locale(m_wxLocale ? wxLocale::GetLanguageInfo(wxLanguage(m_wxLocale->GetLanguage())) : nullptr);
        if (!fallback_locale_info) fallback_locale_info = try_locale(m_language_info_system);
        if (!fallback_locale_info) fallback_locale_info = try_locale(m_language_info_best);
        if (!fallback_locale_info) fallback_locale_info = try_locale(wxLocale::GetLanguageInfo(wxLANGUAGE_ENGLISH_US));
        if (!fallback_locale_info) fallback_locale_info = try_locale(wxLocale::GetLanguageInfo(wxLANGUAGE_ENGLISH_UK));
        if (fallback_locale_info != nullptr) {
            BOOST_LOG_TRIVIAL(info) << boost::format("Using fallback locale %1% while keeping translation dictionary %2%.")
                                        % fallback_locale_info->CanonicalName.ToUTF8().data() % requested_language_code.ToUTF8().data();
            locale_language_info = fallback_locale_info;
        }
    }
 
    if (initial) {
        // bbs supported languages
        //TODO: use a global one with Preference
        //wxLanguage supported_languages[]{
        //    wxLANGUAGE_ENGLISH,
        //    wxLANGUAGE_CHINESE_SIMPLIFIED,
        //    wxLANGUAGE_GERMAN,
        //    wxLANGUAGE_FRENCH,
        //    wxLANGUAGE_SPANISH,
        //    wxLANGUAGE_SWEDISH,
        //    wxLANGUAGE_DUTCH,
        //    wxLANGUAGE_HUNGARIAN,
        //    wxLANGUAGE_JAPANESE,
        //    wxLANGUAGE_ITALIAN
        //};
        //std::string cur_language = app_config->get("language");
        //if (cur_language != "") {
        //    //cleanup the language wrongly set before
        //    const wxLanguageInfo *langinfo = nullptr;
        //    bool embedded_language = false;
        //    int language_num = sizeof(supported_languages) / sizeof(supported_languages[0]);
        //    for (auto index = 0; index < language_num; index++) {
        //        langinfo = wxLocale::GetLanguageInfo(supported_languages[index]);
        //        std::string temp_lan = langinfo->CanonicalName.ToUTF8().data();
        //        if (cur_language == temp_lan) {
        //            embedded_language = true;
        //            break;
        //        }
        //    }
        //    if (!embedded_language)
        //        app_config->erase("app", "language");
        //}
    }
 
  BOOST_LOG_TRIVIAL(trace) << boost::format("Switching wxLocales to %1%") % locale_language_info->CanonicalName.ToUTF8().data();
 
    if (!wxLocale::IsAvailable(locale_language_info->Language)) {
      // Loading the language dictionary failed.
      wxString message = wxString::Format(_L("Switching Orca Slicer to language %s failed."), requested_language_code);
#if !defined(_WIN32) && !defined(__APPLE__)
        // likely some linux system
        message += _L("\nYou may need to reconfigure the missing locales, likely by running the \"locale-gen\" and \"dpkg-reconfigure locales\" commands.\n");
#endif
        if (initial)
          message += "\n\n" + _L("Application will close.");
        wxMessageBox(message, _L("Orca Slicer - Switching language failed"), wxOK | wxICON_ERROR);
        if (initial)
      std::exit(EXIT_FAILURE);
    else
      return false;
    }
 
    // Release the old locales, create new locales.
    //FIXME wxWidgets cause havoc if the current locale is deleted. We just forget it causing memory leaks for now.
    m_wxLocale.release();
    m_wxLocale = Slic3r::make_unique<wxLocale>();
    m_wxLocale->Init(locale_language_info->Language);
    // Override language at the active wxTranslations class (which is stored in the active m_wxLocale)
    // to load possibly different dictionary, for example, load Czech dictionary for Slovak language.
    wxTranslations::Get()->SetLanguage(language_dict);
    m_wxLocale->AddCatalog(SLIC3R_APP_KEY);
    m_active_language_code = requested_language_code;
    m_imgui->set_language(into_u8(requested_language_code));
 
    //FIXME This is a temporary workaround, the correct solution is to switch to "C" locale during file import / export only.
    //wxSetlocale(LC_NUMERIC, "C");
    Preset::update_suffix_modified((_L("*") + " ").ToUTF8().data());
    HintDatabase::get_instance().reinit();
  return true;
}

References _L, app_config, Slic3r::GUI::from_u8(), Slic3r::GUI::HintDatabase::get_instance(), Slic3r::GUI::into_u8(), load_language(), Slic3r::localization_dir(), m_active_language_code, m_imgui, m_language_info_best, m_language_info_system, m_wxLocale, Slic3r::make_unique(), Slic3r::trace(), and Slic3r::Preset::update_suffix_modified().

Referenced by load_language(), on_init_inner(), and open_preferences().

Here is the call graph for this function:

Here is the caller graph for this function:

load_pending_vendors()

void Slic3r::GUI::GUI_App::load_pending_vendors

(

)

{
    if (need_add_vendors.size() == 0 && need_add_filaments.size() == 0)
        return;
 
    preset_bundle->apply_vendor_config(need_add_vendors, need_add_filaments, app_config, false);
    if (is_main_thread_active())
        app_config->save();
    else
        CallAfter([this] { app_config->save(); });
    need_add_vendors.clear();
    need_add_filaments.clear();
}

References app_config, Slic3r::is_main_thread_active(), load_pending_vendors(), need_add_filaments, need_add_vendors, and preset_bundle.

Referenced by load_pending_vendors(), reload_settings(), sync_bundle(), and update_single_bundle().

Here is the call graph for this function:

Here is the caller graph for this function:

load_project()

void Slic3r::GUI::GUI_App::load_project	(	wxWindow *	parent,
		wxString &	input_file ) const

{
    input_file.Clear();
    wxFileDialog dialog(parent ? parent : GetTopWindow(),
        _L("Choose one file (3MF):"),
        app_config->get_last_dir(), "",
        file_wildcards(FT_PROJECT), wxFD_OPEN | wxFD_FILE_MUST_EXIST);
 
    if (dialog.ShowModal() == wxID_OK)
        input_file = dialog.GetPath();
}

References _L, app_config, Slic3r::GUI::file_wildcards(), Slic3r::GUI::FT_PROJECT, and load_project().

Referenced by load_project().

Here is the call graph for this function:

Here is the caller graph for this function:

load_url()

void Slic3r::GUI::GUI_App::load_url

(

wxString

url

)

{
    if (mainframe)
        return mainframe->load_url(url);
}

References load_url(), and mainframe.

Referenced by load_url().

Here is the call graph for this function:

Here is the caller graph for this function:

logo_name()

std::string Slic3r::GUI::GUI_App::logo_name ( ) const

inline

{ return is_editor() ? "OrcaSlicer" : "OrcaSlicer-gcodeviewer"; }

References is_editor().

Here is the call graph for this function:

may_switch_to_SLA_preset()

bool Slic3r::GUI::GUI_App::may_switch_to_SLA_preset

(

const wxString &

caption

)

{
    if (model_has_multi_part_objects(model())) {
        // BBS: remove SLA related message
        return false;
    }
    return true;
}

References may_switch_to_SLA_preset(), model(), and Slic3r::model_has_multi_part_objects().

Referenced by may_switch_to_SLA_preset().

Here is the call graph for this function:

Here is the caller graph for this function:

maybe_migrate_user_presets_on_login()

bool Slic3r::GUI::GUI_App::maybe_migrate_user_presets_on_login

(

)

{
    namespace fs = boost::filesystem;
 
    BOOST_LOG_TRIVIAL(info) << "Migrate user presets to the OrcaCloud user folder if needed.";
 
    if (!m_agent || !m_agent->is_user_login())
        return false;
 
    std::string new_user_id = m_agent->get_user_id();
    if (new_user_id.empty()) {
        BOOST_LOG_TRIVIAL(warning) << "Failed to get user ID, skipping migration.";
        return false;
    }
 
    fs::path user_base = fs::path(data_dir()) / PRESET_USER_DIR;
    fs::path target_dir = user_base / new_user_id;
 
    // Check if the user already has presets on OrcaCloud.
    // We must query the cloud (not the local folder) to avoid overwriting existing cloud profiles
    // that haven't been synced down yet (e.g. fresh install with existing cloud account).
    {
        std::map<std::string, std::map<std::string, std::string>> cloud_presets;
        int ret = m_agent->get_user_presets(&cloud_presets);
        if (ret == 0 && !cloud_presets.empty()) {
            BOOST_LOG_TRIVIAL(info) << "OrcaCloud already has " << cloud_presets.size()
                                    << " presets, skipping migration for user: " << new_user_id;
            return false;
        }
        if (ret != 0) {
            BOOST_LOG_TRIVIAL(warning) << "Failed to query OrcaCloud presets (error " << ret
                                       << "), skipping migration to avoid overwriting cloud data.";
            // If this looks like a transient 401 from token propagation delay (within grace period),
            // schedule one deferred retry so first-time users don't silently lose their preset migration.
            if (std::chrono::steady_clock::now() - m_last_401_error_time < std::chrono::seconds(30)
                && !m_migration_retry_pending.exchange(true)) {
                BOOST_LOG_TRIVIAL(info) << "Scheduling migration retry after token propagation window.";
                boost::thread([this]() {
                    std::this_thread::sleep_for(std::chrono::seconds(5));
                    CallAfter([this]() {
                        m_migration_retry_pending = false;
                        if (is_closing() || !m_agent || !m_agent->is_user_login()) return;
                        BOOST_LOG_TRIVIAL(info) << "Retrying preset migration after token propagation window.";
                        if (maybe_migrate_user_presets_on_login()) {
                            const std::string user_id = m_agent->get_user_id();
                            preset_bundle->load_user_presets(user_id, ForwardCompatibilitySubstitutionRule::Enable);
                            if (mainframe) mainframe->update_side_preset_ui();
                        }
                    });
                }).detach();
            }
            return false;
        }
        BOOST_LOG_TRIVIAL(info) << "OrcaCloud has no presets for user " << new_user_id << ", proceeding with migration check.";
    }
 
    // Helper to check if a local directory has any .json preset files.
    auto has_json_presets = [](const fs::path& dir) -> bool {
        try {
            if (!fs::exists(dir) || !fs::is_directory(dir))
                return false;
            boost::system::error_code ec;
            for (auto it = fs::recursive_directory_iterator(dir, ec); it != fs::recursive_directory_iterator(); it.increment(ec)) {
                if (ec) {
                    BOOST_LOG_TRIVIAL(warning) << "Error scanning directory " << dir << ": " << ec.message();
                    continue;
                }
                if (fs::is_regular_file(*it) && it->path().extension() == ".json")
                    return true;
            }
        } catch (const fs::filesystem_error& e) {
            BOOST_LOG_TRIVIAL(warning) << "Failed to scan directory for presets: " << e.what();
        }
        return false;
    };
 
    // Determine the source directory to migrate from.
    // Priority: 1) Bambu Cloud user folder (if user was logged in), 2) "default" folder, 3) any other user-ID folder
    fs::path source_dir;
    bool source_is_default = false;
    bool source_is_bbl = false;
    fs::path default_dir = user_base / DEFAULT_USER_FOLDER_NAME;
 
    // Check if the user was previously logged into Bambu Cloud and has presets there
    if (m_agent->is_user_login(BBL_CLOUD_PROVIDER)) {
        std::string bbl_user_id = m_agent->get_user_id(BBL_CLOUD_PROVIDER);
        if (!bbl_user_id.empty() && bbl_user_id != new_user_id) {
            fs::path bbl_dir = user_base / bbl_user_id;
            if (has_json_presets(bbl_dir)) {
                source_dir = bbl_dir;
                source_is_bbl = true;
                BOOST_LOG_TRIVIAL(info) << "Migration source: Bambu Cloud user folder: " << source_dir;
            }
        }
    }
 
    // Fallback to default folder
    if (source_dir.empty() && has_json_presets(default_dir)) {
        source_dir = default_dir;
        source_is_default = true;
        BOOST_LOG_TRIVIAL(info) << "Migration source: default user folder: " << source_dir;
    }
 
    // Last resort: scan for any other user-ID folder with presets
    if (source_dir.empty() && fs::exists(user_base) && fs::is_directory(user_base)) {
        for (auto& entry : fs::directory_iterator(user_base)) {
            if (!fs::is_directory(entry))
                continue;
            std::string folder_name = entry.path().filename().string();
            if (folder_name == new_user_id || folder_name == DEFAULT_USER_FOLDER_NAME)
                continue;
            if (has_json_presets(entry.path())) {
                source_dir = entry.path();
                BOOST_LOG_TRIVIAL(info) << "Migration source: user folder: " << source_dir;
                break;
            }
        }
    }
 
    if (source_dir.empty()) {
        BOOST_LOG_TRIVIAL(info) << "No existing user presets found to migrate.";
        return false;
    }
 
    // Ask the user for confirmation with a message tailored to the source type
    wxString source_description;
    if (source_is_bbl) {
        source_description = wxString::Format(
            _L("your Orca Cloud profile (user ID: \"%s\")"),
            from_u8(source_dir.filename().string()));
    } else if (source_is_default) {
        source_description = _L("your default profile");
    } else {
        source_description = wxString::Format(
            _L("a user profile (folder: \"%s\")"),
            from_u8(source_dir.filename().string()));
    }
 
    wxString msg = wxString::Format(
        _L("Existing user presets were found in %s.\n"
           "Do you want to migrate them to your OrcaCloud profile?\n"
           "This will copy your presets so they are available under your new account."),
        source_description);
 
    MessageDialog dlg(mainframe, msg, _L("Migrate User Presets"),
                      wxCENTER | wxYES_DEFAULT | wxYES_NO | wxICON_INFORMATION);
    if (dlg.ShowModal() != wxID_YES) {
        BOOST_LOG_TRIVIAL(info) << "User declined preset migration.";
        return false;
    }
 
    // Perform the migration using copy_directory_recursively in merge mode
    // to preserve any existing files (e.g. .info sync markers) in the target directory.
    try {
        wxBusyCursor busy;
        BOOST_LOG_TRIVIAL(info) << "Migrating user presets from " << source_dir << " to " << target_dir;
 
        auto info_filter = [](const std::string& filename) -> bool {
            // Return true to skip .info files
            return filename.size() >= 5 &&
                   filename.compare(filename.size() - 5, 5, ".info") == 0;
        };
 
        copy_directory_recursively(source_dir, target_dir, info_filter, /*merge_mode=*/true);
        BOOST_LOG_TRIVIAL(info) << "User preset migration completed successfully.";
    } catch (const std::exception& ex) {
        BOOST_LOG_TRIVIAL(error) << "Failed to migrate user presets: " << ex.what();
        wxString err_msg = wxString::Format(
            _L("Failed to migrate user presets:\n%s"),
            from_u8(ex.what()));
        show_error(nullptr, err_msg);
        return false;
    }
 
    return true;
}

References _L, Slic3r::BBL_CLOUD_PROVIDER(), Slic3r::copy_directory_recursively(), Slic3r::data_dir(), DEFAULT_USER_FOLDER_NAME, Slic3r::Enable, Slic3r::GUI::from_u8(), is_closing(), m_agent, m_last_401_error_time, m_migration_retry_pending, mainframe, maybe_migrate_user_presets_on_login(), preset_bundle, PRESET_USER_DIR, Slic3r::GUI::show_error(), and Slic3r::GUI::DPIAware< P >::ShowModal().

Referenced by maybe_migrate_user_presets_on_login(), and on_user_login_handle().

Here is the call graph for this function:

Here is the caller graph for this function:

migrate_network_plugin_config()

void Slic3r::GUI::GUI_App::migrate_network_plugin_config

(

)

{
    if (!app_config)
        return;
 
    const std::string cfg = app_config->get_network_plugin_version();
    if (!is_series_managed_version(cfg) || !is_supported_network_version(cfg))
        return; // empty / legacy / custom-named / unsupported old series -> nothing to migrate here
                // (an unsupported old config is handled by the fallback in on_init_network)
 
    const std::string series = network_plugin_series(cfg);
    if (cfg != series) {
        app_config->set_network_plugin_version(series);
        app_config->save();
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": network_plugin_version " << cfg << " -> " << series;
    }
 
    // Consolidate the on-disk files onto the series name. Runs at startup before the plug-in is
    // loaded, so the rename is safe even on Windows (nothing holds the file open yet). If it is
    // skipped or fails, resolve_library_path() still loads the specific build for this series.
    std::string newest;
    for (const auto& v : BBLNetworkPlugin::scan_plugin_versions())
        if (is_series_managed_version(v) && network_plugin_series(v) == series && (newest.empty() || v > newest))
            newest = v;
    if (newest.empty())
        return;
 
    boost::system::error_code ec;
    const boost::filesystem::path series_path(BBLNetworkPlugin::get_versioned_library_path(series));
    if (newest != series) {
        // Make the newest same-series build the series file. Safe here (pre-load); if the rename
        // fails, resolve_library_path() still loads the specific build for this series.
        boost::filesystem::remove(series_path, ec);
        boost::filesystem::rename(BBLNetworkPlugin::get_versioned_library_path(newest), series_path, ec);
        if (ec)
            BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": rename " << newest << " -> " << series
                                       << " failed (" << ec.message() << "), loader will resolve it";
    }
 
    // Tidy strictly-older same-series managed builds (best-effort; never touch custom/legacy).
    for (const auto& v : BBLNetworkPlugin::scan_plugin_versions()) {
        if (v == series || !is_series_managed_version(v) || network_plugin_series(v) != series)
            continue;
        boost::filesystem::remove(BBLNetworkPlugin::get_versioned_library_path(v), ec);
    }
}

References app_config, Slic3r::BBLNetworkPlugin::get_versioned_library_path(), Slic3r::is_series_managed_version(), Slic3r::is_supported_network_version(), Slic3r::network_plugin_series(), and Slic3r::BBLNetworkPlugin::scan_plugin_versions().

Referenced by on_init_network().

Here is the call graph for this function:

Here is the caller graph for this function:

mint_cloud_web_session()

void Slic3r::GUI::GUI_App::mint_cloud_web_session	(	const std::string &	state,
		uint64_t	gen )

{
    auto orca = get_orca_cloud_agent(m_agent);
    if (!orca)
        return;
 
    // The endpoint call blocks on network I/O (and possibly a cross-process token refresh), so
    // it must not run on the UI thread. Hand off to a worker and marshal the token back.
    boost::thread([this, orca, state, gen]() {
        std::string  token_hash;
        std::string  error_code;
        unsigned int http_code = 0;
        orca->request_web_session_handoff(token_hash, error_code, http_code);
 
        if (is_closing())
            return;
 
        if (token_hash.empty()) {
            // No token: 401 after retry, 409/429/503 or a transport error. The page owns its own
            // "Sign-in link expired"/"Try again" UI; the desktop stays silent. Never log the body
            // (it may echo account data), only the status/error code.
            BOOST_LOG_TRIVIAL(warning) << "cloud web session handoff not minted - http_code=" << http_code
                                       << " error_code=" << error_code;
            return;
        }
 
        GUI::wxGetApp().CallAfter([this, state, gen, token_hash]() {
            on_cloud_web_session_minted(state, gen, token_hash);
        });
    }).detach();
}

References Slic3r::GUI::get_orca_cloud_agent(), is_closing(), m_agent, mint_cloud_web_session(), and on_cloud_web_session_minted().

Referenced by mint_cloud_web_session(), and request_cloud_web_session().

Here is the call graph for this function:

Here is the caller graph for this function:

model()

Model & Slic3r::GUI::GUI_App::model

(

)

{
    return plater_->model();
}

References model(), and plater_.

Referenced by may_switch_to_SLA_preset(), and model().

Here is the call graph for this function:

Here is the caller graph for this function:

no_new_version()

void Slic3r::GUI::GUI_App::no_new_version

(

)

{
    wxCommandEvent* evt = new wxCommandEvent(EVT_SHOW_NO_NEW_VERSION);
    GUI::wxGetApp().QueueEvent(evt);
}

References no_new_version().

Referenced by check_new_version(), check_new_version_sf(), check_update(), and no_new_version().

Here is the call graph for this function:

Here is the caller graph for this function:

normal_font()

const wxFont & Slic3r::GUI::GUI_App::normal_font ( )

inline

{ return m_normal_font; }

References m_normal_font.

Referenced by Slic3r::GUI::anonymous_namespace{WebViewHostDialog.cpp}::host_theme_vars_css().

Here is the caller graph for this function:

notification_manager()

NotificationManager * Slic3r::GUI::GUI_App::notification_manager

(

)

{
    if (plater_)
        return plater_->get_notification_manager();
    return nullptr;
}

References notification_manager(), and plater_.

Referenced by notification_manager().

Here is the call graph for this function:

Here is the caller graph for this function:

obj_layers()

ObjectLayers * Slic3r::GUI::GUI_App::obj_layers

(

)

{
    return sidebar().obj_layers();
}

References obj_layers(), and sidebar().

Referenced by obj_layers().

Here is the call graph for this function:

Here is the caller graph for this function:

obj_list()

ObjectList * Slic3r::GUI::GUI_App::obj_list

(

)

{
    return sidebar().obj_list();
}

References obj_list(), and sidebar().

Referenced by anonymous_namespace{EmbossJob.cpp}::create_volume(), Slic3r::GUI::GLGizmoEmboss::draw_model_type(), Slic3r::GUI::GLGizmoSVG::draw_model_type(), anonymous_namespace{EmbossJob.cpp}::CreateObjectJob::finalize(), obj_list(), on_init_inner(), on_shortcuts_changed(), recreate_GUI(), and Slic3r::GUI::Emboss::UpdateJob::update_volume().

Here is the call graph for this function:

Here is the caller graph for this function:

obj_manipul()

GizmoObjectManipulation * Slic3r::GUI::GUI_App::obj_manipul

(

)

{
    // If this method is called before plater_ has been initialized, return nullptr (to avoid a crash)
    return (plater_ != nullptr) ? &plater_->get_view3D_canvas3D()->get_gizmos_manager().get_object_manipulation() : nullptr;
}

References obj_manipul(), and plater_.

Referenced by obj_manipul().

Here is the call graph for this function:

Here is the caller graph for this function:

obj_settings()

ObjectSettings * Slic3r::GUI::GUI_App::obj_settings

(

)

{
    return sidebar().obj_settings();
}

References obj_settings(), and sidebar().

Referenced by obj_settings().

Here is the call graph for this function:

Here is the caller graph for this function:

on_check_privacy_update()

void Slic3r::GUI::GUI_App::on_check_privacy_update

(

wxCommandEvent &

evt

)

{
    int online_login = evt.GetInt();
    std::string provider = evt.GetString().ToStdString();
    if (provider.empty()) provider = ORCA_CLOUD_PROVIDER;
    bool result = check_privacy_update();
    if (result)
        on_show_check_privacy_dlg(online_login, provider);
    else
        request_user_handle(online_login, provider);
}

References check_privacy_update(), on_check_privacy_update(), on_show_check_privacy_dlg(), Slic3r::ORCA_CLOUD_PROVIDER(), and request_user_handle().

Referenced by on_check_privacy_update(), and on_init_inner().

Here is the call graph for this function:

Here is the caller graph for this function:

on_cloud_web_session_minted()

void Slic3r::GUI::GUI_App::on_cloud_web_session_minted	(	const std::string &	state,
		uint64_t	gen,
		const std::string &	token_hash )

{
    if (is_closing())
        return;
    // Drop a result for a superseded request (a newer request_web_session, login or sign-out).
    if (gen != m_cloud_handoff_gen || state != m_cloud_handoff_state)
        return;
    if (token_hash.empty())
        return;
 
    auto orca = get_orca_cloud_agent(m_agent);
    if (!orca)
        return;
 
    // Load the Complete URL in the SAME webview that posted request_web_session, because the
    // state lives in that webview's session storage (guide §3/§7).
    if (WebViewPanel* home = WebViewPanel::if_built())
        home->load_cloud_url(from_u8(orca->build_web_session_complete_url(token_hash, state)));
}

References Slic3r::GUI::from_u8(), Slic3r::GUI::get_orca_cloud_agent(), Slic3r::GUI::LazyInstance< WebViewPanel >::if_built(), is_closing(), m_agent, m_cloud_handoff_gen, m_cloud_handoff_state, and on_cloud_web_session_minted().

Referenced by mint_cloud_web_session(), and on_cloud_web_session_minted().

Here is the call graph for this function:

Here is the caller graph for this function:

on_http_error()

void Slic3r::GUI::GUI_App::on_http_error

(

wxCommandEvent &

evt

)

{
    int status = evt.GetInt();
    std::string provider = "";
    std::string body_str;
 
    // Extract provider and body from event data
    try {
        auto evt_str = evt.GetString().utf8_string();
        if (!evt_str.empty()) {
            json evt_data = json::parse(evt_str);
            if (evt_data.contains("provider"))
                provider = evt_data["provider"].get<std::string>();
            if (evt_data.contains("body"))
                body_str = evt_data["body"].get<std::string>();
        }
    } catch (...) {}
 
    int code = 0;
    std::string error;
    if (status >= 400 && status < 500) {
        try {
            if (!body_str.empty()) {
                json j = json::parse(body_str);
                if (j.contains("code")) {
                    if (!j["code"].is_null())
                        code = j["code"].get<int>();
                }
                if (j.contains("error"))
                    if (!j["error"].is_null())
                        error = j["error"].get<std::string>();
            }
        } catch (...) {}
    }
 
    // Version limit
    if (code == HttpErrorVersionLimited) {
        MessageDialog msg_dlg(nullptr, _L("The version of Orca Slicer is too low and needs to be updated to the latest version before it can be used normally."), "", wxAPPLY | wxOK);
        if (msg_dlg.ShowModal() == wxOK) {
        }
    }
 
    // request login
    if (status == 401) {
        if (m_agent) {
            if (!provider.empty() && m_agent->is_user_login(provider)) {
                if (std::chrono::steady_clock::now() - m_last_401_error_time > 30s) {
                    BOOST_LOG_TRIVIAL(warning) << "logout: http error 401.";
                    // Involuntary: a 401 means the desktop session was rejected. Leave the
                    // webview's own session alone (guide §8).
                    this->request_user_logout(provider, /*user_initiated=*/false);
 
                    if (!m_show_http_error_msgdlg) {
                        MessageDialog msg_dlg(nullptr, _L("Login information expired. Please login again."), "", wxAPPLY | wxOK);
                        m_show_http_error_msgdlg = true;
                        auto modal_result        = msg_dlg.ShowModal();
                        if (modal_result == wxOK || modal_result == wxCLOSE) {
                            m_show_http_error_msgdlg = false;
                            return;
                        }
                    }
 
                    m_last_401_error_time = std::chrono::steady_clock::now();
                } else {
                    BOOST_LOG_TRIVIAL(warning) << "401 encountered within grace period, suppressing logout";
                }
            }
        }
        return;
    }
 
    // No need to show dialog for 410: 410 means resource has been deleted from the server.
    if (status == 410) {
        BOOST_LOG_TRIVIAL(info) << "Http error 410.";
        return;
    }
 
    if (status == 409 && provider == ORCA_CLOUD_PROVIDER) {
        BOOST_LOG_TRIVIAL(info) << "Http error 409.";
        // Parse the conflict body to extract the error code and server profile id
        int conflict_code = 0;
        std::string conflict_setting_id;
        std::string conflict_preset_name;
        try {
            json conflict_body = json::parse(body_str);
            if (conflict_body.contains("code"))
                conflict_code = conflict_body["code"].get<int>();
            if (conflict_body.contains("server_profile") && conflict_body["server_profile"].contains("id")
                && conflict_body["server_profile"]["id"].is_string())
                conflict_setting_id = conflict_body["server_profile"]["id"].get<std::string>();
            // The local preset name is injected into the conflict body by the agent (sync_push),
            // since the server response itself omits it for tombstone (-3) conflicts.
            if (conflict_body.contains("name") && conflict_body["name"].is_string())
                conflict_preset_name = conflict_body["name"].get<std::string>();
        } catch (...) {
            BOOST_LOG_TRIVIAL(warning) << "Failed to parse 409 conflict body.";
        }
        // Capture the user id up front so the force-push closure does not have to touch m_agent.
        std::string conflict_user_id = m_agent ? m_agent->get_user_id() : std::string();
        auto* plater = wxGetApp().plater();
        if (plater != nullptr && wxGetApp().imgui()->display_initialized()) {
            std::string text;
 
            // Name the specific preset in the header so the user knows which one conflicts.
            // The agent injects the local preset name into every 409 conflict body, so this is
            // normally populated; fall back to a generic header if it is somehow missing.
            const std::string header = conflict_preset_name.empty()
                ? _u8L("Cloud sync conflict:")
                : format(_u8L("Cloud sync conflict for preset \"%s\":"), conflict_preset_name);
 
            switch (conflict_code) {
            case -1:
                text = header + " " + _u8L("This preset has a newer version in OrcaCloud.\n"
                            "Pull downloads the cloud copy. Force push overwrites it with your local preset.");
                break;
            case -2:
                text = header + " " + _u8L("A preset with this name already exists in OrcaCloud.\n"
                            "Pull downloads the cloud copy. Force push overwrites it with your local preset.");
                break;
            case -3:
                text = header + " " + _u8L("A preset with the same name was previously deleted from the cloud.\n"
                            "Delete will delete your local preset. Force push overwrites it with your local preset.");
                break;
            default:
                text = header + " " + _u8L("There was an unexpected or unidentified preset conflict.\n"
                            "Pull downloads the cloud copy. Force push overwrites it with your local preset.");
                break;
            };
 
            plater->get_notification_manager()->push_orca_sync_conflict_notification(
                text, conflict_code,
                [this](wxEvtHandler*) {
                    // Runs on the GUI thread (on_http_error is a queued wx event); restart_sync_user_preset()
                    // already joins the old sync thread off the UI thread, so no extra thread is needed here.
                    if (is_closing() || !m_agent || !preset_bundle)
                        return false;
                    BOOST_LOG_TRIVIAL(info) << "Pulling Orca Cloud settings to resolve sync conflict.";
                    restart_sync_user_preset();
                    return true;
                },
                [this, conflict_setting_id, conflict_preset_name, conflict_user_id](wxEvtHandler*) {
                    if (mainframe == nullptr)
                        return false;
                    const wxString confirm_msg = conflict_preset_name.empty()
                        ? _L("Force push will overwrite the cloud copy with your local preset changes.\nDo you want to continue?")
                        : format_wxstr(_L("Force push will overwrite the cloud copy of preset \"%s\" with your local changes.\nDo you want to continue?"),
                                       conflict_preset_name);
                    MessageDialog dlg(mainframe, confirm_msg, _L("Resolve cloud sync conflict"),
                                      wxCENTER | wxYES_NO | wxNO_DEFAULT | wxICON_WARNING);
                    if (dlg.ShowModal() != wxID_YES)
                        return false;
 
                    std::string setting_id = conflict_setting_id;
                    if (setting_id.empty()) {
                        setting_id = OrcaCloudServiceAgent::generate_uuid_for_setting_id(conflict_preset_name, conflict_user_id);
                        BOOST_LOG_TRIVIAL(info) << "conflict setting id empty, generated one: " << setting_id;
                    }
 
                    force_push_conflicting_preset(setting_id);
                    return true;
                });
        }
        return;
    }
 
    // Show general error notification for Orca Cloud API failures (not Bambu)
    if (provider == ORCA_CLOUD_PROVIDER && status >= 400 && code != HttpErrorVersionLimited) {
        BOOST_LOG_TRIVIAL(warning) << "API call to OrcaCloud failed with status=" << status;
    }
}

References _L, _u8L, force_push_conflicting_preset(), Slic3r::GUI::format(), Slic3r::GUI::format_wxstr(), Slic3r::OrcaCloudServiceAgent::generate_uuid_for_setting_id(), Slic3r::HttpErrorVersionLimited, imgui(), is_closing(), m_agent, m_last_401_error_time, m_show_http_error_msgdlg, mainframe, on_http_error(), Slic3r::ORCA_CLOUD_PROVIDER(), plater(), preset_bundle, request_user_logout(), restart_sync_user_preset(), and Slic3r::GUI::DPIAware< P >::ShowModal().

Referenced by on_http_error(), and on_init_inner().

Here is the call graph for this function:

Here is the caller graph for this function:

on_init_inner()

bool Slic3r::GUI::GUI_App::on_init_inner ( )

private

{
    wxLog::SetActiveTarget(new wxBoostLog());
 
#ifdef __APPLE__
    // Override wxWidgets' kAEGetURL handler so orcaslicer:// deep links keep
    // working after the wxWidgets 3.3.2 upgrade on macOS (#13119).
    register_mac_deep_link_handler();
#endif
#if BBL_RELEASE_TO_PUBLIC
    wxLog::SetLogLevel(wxLOG_Message);
#endif
 
    ::Label::initSysFont();
 
    // Register wxInspector plugins for Orca custom controls
    RegisterOrcaInspectorPlugins();
 
    // Set initialization of image handlers before any UI actions - See GH issue #7469
    wxInitAllImageHandlers();
#ifdef NDEBUG
    wxImage::SetDefaultLoadFlags(0); // ignore waring in release build
#endif
 
#if defined(_WIN32) && ! defined(_WIN64)
    // BBS: remove 32bit build prompt
    // Win32 32bit build.
#endif // _WIN64
 
    // Forcing back menu icons under gtk2 and gtk3. Solution is based on:
    // https://docs.gtk.org/gtk3/class.Settings.html
    // see also https://docs.wxwidgets.org/3.0/classwx_menu_item.html#a2b5d6bcb820b992b1e4709facbf6d4fb
    // TODO: Find workaround for GTK4
#if defined(__WXGTK20__) || defined(__WXGTK3__)
    g_object_set (gtk_settings_get_default (), "gtk-menu-images", TRUE, NULL);
#endif
 
#if defined(__WXGTK20__) || defined(__WXGTK3__)
    // Suppress harmless GTK critical warnings from the GTK3/wxWidgets interaction.
    // These include widget allocation on hidden widgets, events on unrealized widgets,
    // and style context operations during widget construction (SetBackgroundColour
    // before GTK widget realization).
    g_log_set_handler("Gtk", G_LOG_LEVEL_CRITICAL,
        [](const gchar *log_domain, GLogLevelFlags log_level, const gchar *message, gpointer user_data) {
            if (message && (strstr(message, "gtk_widget_set_allocation") ||
                            strstr(message, "WIDGET_REALIZED_FOR_EVENT") ||
                            strstr(message, "gtk_widget_get_style_context") ||
                            strstr(message, "gtk_style_context_add_provider")))
                return;
            g_log_default_handler(log_domain, log_level, message, user_data);
        }, nullptr);
#endif
 
#ifdef WIN32
    //BBS set crash log folder
    CBaseException::set_log_folder(data_dir());
#endif
 
    wxGetApp().Bind(wxEVT_QUERY_END_SESSION, [this](auto & e) {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__<< "received wxEVT_QUERY_END_SESSION";
        if (mainframe) {
            wxCloseEvent e2(wxEVT_CLOSE_WINDOW);
            e2.SetCanVeto(true);
            mainframe->GetEventHandler()->ProcessEvent(e2);
            if (e2.GetVeto()) {
                e.Veto();
                return;
            }
        }
        for (auto d : dialogStack)
            d->EndModal(wxID_ABORT);
    });
 
#ifdef __APPLE__
    // A quit request from the Dock, a logout or a restart ends with AppKit calling exit() right after this event, so
    // OnExit() and ~GUI_App() never run. Shut the plugins and Python down here as ~GUI_App() does. Left to
    // PluginManager's static destructor, the shutdown locks hook state that has already been destroyed and aborts.
    // Unload the Bambu network plugin too. Its static destructors abort if its agent's threads are still running.
    // Stop the Orca Cloud health check as OnExit() does, so no request is in flight while exit() tears down.
    wxGetApp().Bind(wxEVT_END_SESSION, [this](wxCloseEvent &e) {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << "received wxEVT_END_SESSION";
        stop_sync_user_preset();
        stop_orca_health_check(m_agent);
        Slic3r::NetworkAgent::unload_network_module();
        Slic3r::PluginManager::instance().shutdown();
        Slic3r::PythonInterpreter::instance().shutdown();
        e.Skip();
    });
#endif
 
    // Verify resources path
    const wxString resources_dir = from_u8(Slic3r::resources_dir());
    wxCHECK_MSG(wxDirExists(resources_dir), false,
        wxString::Format(_L("Resources path does not exist or is not a directory: %s"), resources_dir));
 
#ifdef __linux__
    if (! check_old_linux_datadir(GetAppName())) {
        std::cerr << "Quitting, user chose to move their data to new location." << std::endl;
        return false;
    }
#endif
 
    BOOST_LOG_TRIVIAL(info) << get_system_info();
 
// initialize label colors and fonts
    init_label_colours();
    init_fonts();
    wxGetApp().Update_dark_mode_flag();
    
#if defined(__WINDOWS__)
    HMODULE hKernel32 = GetModuleHandleW(L"kernel32.dll");
    m_is_arm64 = false;
    if (hKernel32) {
        auto fnIsWow64Process2 = (LPFN_ISWOW64PROCESS2)GetProcAddress(hKernel32, "IsWow64Process2");
        if (fnIsWow64Process2) {
            USHORT processMachine = 0;
            USHORT nativeMachine = 0;
            if (fnIsWow64Process2(GetCurrentProcess(), &processMachine, &nativeMachine)) {
                if (nativeMachine == IMAGE_FILE_MACHINE_ARM64) {//IMAGE_FILE_MACHINE_ARM64
                    m_is_arm64 = true;
                }
                BOOST_LOG_TRIVIAL(info) << boost::format("processMachine architecture %1%, nativeMachine %2% m_is_arm64 %3%")%(int)(processMachine) %(int) nativeMachine %m_is_arm64;
            }
            else {
                BOOST_LOG_TRIVIAL(info) << boost::format("IsWow64Process2 failed, set m_is_arm64 to %1%") %m_is_arm64;
            }
        }
        else {
            BOOST_LOG_TRIVIAL(info) << boost::format("can not find IsWow64Process2, set m_is_arm64 to %1%") %m_is_arm64;
        }
    }
    else {
        BOOST_LOG_TRIVIAL(info) << boost::format("can not find kernel32, set m_is_arm64 to %1%") %m_is_arm64;
    }
#endif
    // Enable this to get the default Win32 COMCTRL32 behavior of static boxes.
//    wxSystemOptions::SetOption("msw.staticbox.optimized-paint", 0);
    // Enable this to disable Windows Vista themes for all wxNotebooks. The themes seem to lead to terrible
    // performance when working on high resolution multi-display setups.
//    wxSystemOptions::SetOption("msw.notebook.themed-background", 0);
 
//     Slic3r::debugf "wxWidgets version %s, Wx version %s\n", wxVERSION_STRING, wxVERSION;
    if (is_editor()) {
        std::string msg = Slic3r::Http::tls_global_init();
        std::string ssl_cert_store = app_config->get("tls_accepted_cert_store_location");
        bool ssl_accept = app_config->get("tls_cert_store_accepted") == "yes" && ssl_cert_store == Slic3r::Http::tls_system_cert_store();
 
        if (!msg.empty() && !ssl_accept) {
            RichMessageDialog
                dlg(nullptr,
                    wxString::Format(_L("%s\nDo you want to continue?"), msg),
                    "OrcaSlicer", wxICON_QUESTION | wxYES_NO);
            dlg.ShowCheckBox(_L("Remember my choice"));
            if (dlg.ShowModal() != wxID_YES) return false;
 
            app_config->set("tls_cert_store_accepted",
                dlg.IsCheckBoxChecked() ? "yes" : "no");
            app_config->set("tls_accepted_cert_store_location",
                dlg.IsCheckBoxChecked() ? Slic3r::Http::tls_system_cert_store() : "");
        }
    }
 
    // !!! Initialization of UI settings as a language, application color mode, fonts... have to be done before first UI action.
    // Like here, before the show InfoDialog in check_older_app_config()
 
    // If load_language() fails, the application closes.
    load_language(wxString(), true);
#ifdef _MSW_DARK_MODE
 
#ifndef __WINDOWS__
    // The label colours and the dark mode flag were set above from the saved mode. When the system theme
    // differs from it, refresh them, or dialogs that map their colours stay in the old mode for this session.
    const bool saved_dark_mode = dark_mode();
    wxSystemAppearance app = wxSystemSettings::GetAppearance();
    GUI::wxGetApp().app_config->set("dark_color_mode", app.IsDark() ? "1" : "0");
    GUI::wxGetApp().app_config->save();
    if (dark_mode() != saved_dark_mode) {
        init_label_colours();
        Update_dark_mode_flag();
    }
#endif // __APPLE__
 
 
    bool init_dark_color_mode = dark_mode();
    bool init_sys_menu_enabled = app_config->get("sys_menu_enabled") == "1";
#ifdef __WINDOWS__
     // Inform wxWidgets 3.3's dark mode system so it tracks NppDarkMode's state.
     // Must be called before NppDarkMode::InitDarkMode() so that NppDarkMode's
     // SetPreferredAppMode(ForceDark) overrides the AllowDark state set here.
     // Orca: todo switch to native dark mode support in wxWidgets and remove NppDarkMode
     MSWEnableDarkMode(DarkMode_Auto);
     NppDarkMode::InitDarkMode(init_dark_color_mode, init_sys_menu_enabled);
#endif // __WINDOWS__
 
#endif
 
 
#ifdef _MSW_DARK_MODE
    // app_config can be updated in check_older_app_config(), so check if dark_color_mode and sys_menu_enabled was changed
    if (bool new_dark_color_mode = dark_mode();
        init_dark_color_mode != new_dark_color_mode) {
 
#ifdef __WINDOWS__
        NppDarkMode::SetDarkMode(new_dark_color_mode);
#endif // __WINDOWS__
 
        init_label_colours();
        //update_label_colours_from_appconfig();
    }
    if (bool new_sys_menu_enabled = app_config->get("sys_menu_enabled") == "1";
        init_sys_menu_enabled != new_sys_menu_enabled) {
#ifdef __WINDOWS__
        NppDarkMode::SetSystemMenuForApp(new_sys_menu_enabled);
#endif
    }
#endif
 
    // Orca: we allow user to pin the version of plugin, so we don't need to remove old networking plugins when the app version is updated
    //
    // if (m_last_config_version) {
    //     int last_major = m_last_config_version->maj();
    //     int last_minor = m_last_config_version->min();
    //     int last_patch = m_last_config_version->patch()/100;
    //     std::string studio_ver = SLIC3R_VERSION;
    //     int cur_major = atoi(studio_ver.substr(0,2).c_str());
    //     int cur_minor = atoi(studio_ver.substr(3,2).c_str());
    //     int cur_patch = atoi(studio_ver.substr(6,2).c_str());
    //     BOOST_LOG_TRIVIAL(info) << boost::format("last app version {%1%.%2%.%3%}, current version {%4%.%5%.%6%}")
    //         %last_major%last_minor%last_patch%cur_major%cur_minor%cur_patch;
    //     if ((last_major != cur_major)
    //         ||(last_minor != cur_minor)
    //         ||(last_patch != cur_patch)) {
    //         remove_old_networking_plugins();
    //     }
    // }
 
    //Orca: write OrcaSlicer version
    if(app_config->get("version") != SoftFever_VERSION) {
        app_config->set("version", SoftFever_VERSION);
    }
 
    // Orca: use wxWeakRef to provent wild pointer.
    wxWeakRef<SplashScreen> scrn = nullptr;
    if (app_config->get("show_splash_screen") == "true") {
        // Detect position (display) to show the splash screen
        // Now this position is equal to the mainframe position
        wxPoint splashscreen_pos = wxDefaultPosition;
        if (app_config->has("window_mainframe")) {
            auto metrics = WindowMetrics::deserialize(app_config->get("window_mainframe"));
            if (metrics)
                splashscreen_pos = metrics->get_rect().GetPosition();
        }
 
        BOOST_LOG_TRIVIAL(info) << "begin to show the splash screen...";
        //BBS use BBL splashScreen
        scrn = new SplashScreen(splashscreen_pos);
        wxYield();
        scrn->SetText(_L("Loading configuration") + dots, 5);
    }
 
    BOOST_LOG_TRIVIAL(info) << "loading systen presets...";
    preset_bundle = new PresetBundle();
 
    // just checking for existence of Slic3r::data_dir is not enough : it may be an empty directory
    // supplied as argument to --datadir; in that case we should still run the wizard
    preset_bundle->setup_directories();
 
 
    if (m_init_app_config_from_older)
        copy_older_config();
 
    if (is_editor()) {
#ifdef __WXMSW__
        if (app_config->get("associate_3mf") == "true")
            associate_files(L"3mf");
        if (app_config->get("associate_stl") == "true")
            associate_files(L"stl");
        if (app_config->get("associate_step") == "true") {
            associate_files(L"step");
            associate_files(L"stp");
        }
        associate_url(L"orcaslicer");
 
        if (app_config->get("associate_gcode") == "true")
            associate_files(L"gcode");
#endif // __WXMSW__
 
        preset_updater = new PresetUpdater();
        Bind(EVT_SLIC3R_VERSION_ONLINE, [this](const wxCommandEvent& evt) {
            if (this->plater_ != nullptr) {
                // this->plater_->get_notification_manager()->push_notification(NotificationType::NewAppAvailable);
                //BBS show msg box to download new version
               /* wxString tips = wxString::Format(_L("Click to download new version in default browser: %s"), version_info.version_str);
                DownloadDialog dialog(this->mainframe,
                    tips,
                    _L("New version of Orca Slicer"),
                    false,
                    wxCENTER | wxICON_INFORMATION);
 
 
                dialog.SetExtendedMessage(extmsg);*/
                std::string skip_version_str = this->app_config->get("app", "skip_version");
                bool skip_this_version = false;
                if (!skip_version_str.empty()) {
                    BOOST_LOG_TRIVIAL(info) << "new version = " << version_info.version_str << ", skip version = " << skip_version_str;
                    if (version_info.version_str <= skip_version_str) {
                        skip_this_version = true;
                    } else {
                        app_config->set("skip_version", "");
                        skip_this_version = false;
                    }
                }
                if (!skip_this_version
                    || evt.GetInt() != 0) {
                    UpdateVersionDialog dialog(this->mainframe);
                    wxString            extmsg = wxString::FromUTF8(version_info.description);
                    dialog.update_version_info(extmsg, version_info.version_str);
                    //dialog.update_version_info(version_info.description);
                    if (evt.GetInt() != 0) {
                        dialog.m_button_skip_version->Hide();
                    }
                    switch (dialog.ShowModal())
                    {
                    case wxID_YES:
                        // Store builds get updates from the Microsoft Store, not the GitHub release page.
                        if (is_running_in_msix())
                            open_ms_store_product_page();
                        else
                            wxLaunchDefaultBrowser(version_info.url);
                        break;
                    case wxID_NO:
                        break;
                    default:
                        ;
                    }
                }
            }
            });
 
        Bind(EVT_ENTER_FORCE_UPGRADE, [this](const wxCommandEvent& evt) {
                wxString      version_str = wxString::FromUTF8(this->app_config->get("upgrade", "version"));
                wxString      description_text = wxString::FromUTF8(this->app_config->get("upgrade", "description"));
                std::string   download_url = this->app_config->get("upgrade", "url");
                wxString tips = wxString::Format(_L("Click to download new version in default browser: %s"), version_str);
                DownloadDialog dialog(this->mainframe,
                    tips,
                    _L("OrcaSlicer needs an update"),
                    false,
                    wxCENTER | wxICON_INFORMATION);
                dialog.SetExtendedMessage(description_text);
 
                int result = dialog.ShowModal();
                switch (result)
                {
                 case wxID_YES:
                     wxLaunchDefaultBrowser(download_url);
                     break;
                 case wxID_NO:
                     wxGetApp().mainframe->Close(true);
                     break;
                 default:
                     wxGetApp().mainframe->Close(true);
                }
            });
 
        Bind(EVT_SHOW_NO_NEW_VERSION, [](const wxCommandEvent& evt) {
            wxString msg = _L("This is the newest version.");
            InfoDialog dlg(nullptr, _L("Info"), msg);
            dlg.ShowModal();
        });
 
        Bind(EVT_SHOW_DIALOG, [this](const wxCommandEvent& evt) {
            wxString msg = evt.GetString();
            InfoDialog dlg(this->mainframe, _L("Info"), msg);
            dlg.Bind(wxEVT_DESTROY, [this](auto& e) {
                m_info_dialog_content = wxEmptyString;
            });
            dlg.ShowModal();
        });
    }
    else {
#ifdef __WXMSW__
        if (app_config->get("associate_gcode") == "true")
            associate_files(L"gcode");
#endif // __WXMSW__
    }
 
    // Suppress the '- default -' presets.
    preset_bundle->set_default_suppressed(true);
 
    preset_bundle->backup_user_folder();
 
    Bind(EVT_UPDATE_MACHINE_LIST, &GUI_App::on_update_machine_list, this);
    Bind(EVT_USER_LOGIN, &GUI_App::on_user_login, this);
    Bind(EVT_USER_LOGIN_HANDLE, &GUI_App::on_user_login_handle, this);
    Bind(EVT_CHECK_PRIVACY_VER, &GUI_App::on_check_privacy_update, this);
    Bind(EVT_CHECK_PRIVACY_SHOW, &GUI_App::show_check_privacy_dlg, this);
 
    Bind(EVT_SHOW_IP_DIALOG, &GUI_App::show_ip_address_enter_dialog_handler, this);
 
 
 
    // Orca: select network plugin version based on configured version string
    std::string configured_version = app_config->get_network_plugin_version();
    BOOST_LOG_TRIVIAL(info) << "Network plugin mode: "
        << (use_legacy_network_plugin() ? ("legacy (version: " + std::string(BAMBU_NETWORK_AGENT_VERSION_LEGACY) + ")") : ("modern (version: " + configured_version + ")"));
    // Force legacy network plugin if debugger attached
    // See https://github.com/bambulab/BambuStudio/issues/6726
    /* if (!NetworkAgent::use_legacy_network) {
        bool debugger_attached = false;
#if defined(__WINDOWS__)
        debugger_attached = IsDebuggerPresent();
#elif defined(__WXOSX__) || defined(__linux__)
        debugger_attached = is_debugger_present();
#endif
        if (debugger_attached) {
            NetworkAgent::use_legacy_network = true;
            wxMessageBox("Force using legacy bambu networking plugin because debugger is attached! If the app terminates itself immediately, please delete installed plugin and try again!");
        }
    } */
 
 
    if (scrn) {
        scrn->SetText(_L("Loading Plugins") + dots, 20);
        wxYield();
    }
 
    // Initialize plugins after network then register on_load callbacks so once the plugin loads finish, it gets registered automatically.
    // initialize() also installs the libslic3r hooks (capability resolver,
    // slicing-pipeline dispatcher) via plugin_hooks::install() -- no
    // per-capability wiring belongs here.
    PluginManager& plugin_mgr = PluginManager::instance();
    plugin_mgr.initialize();
 
    // Set cloud plugin directory from previous session so cloud-installed
    // plugins are discovered even before the network agent is ready.
    const std::string preset_folder = app_config->get("preset_folder");
    if (!preset_folder.empty()) {
        plugin_mgr.set_cloud_user(preset_folder);
    }
 
    plugin_mgr.discover_plugins(false, true);
 
    init_plugin_gui_wiring();
 
    // Subscribe to the plugin loader and enumerate current actions (UI thread, once).
    m_action_registry.init();
 
    for (const std::string& plugin_key : plugin_mgr.get_enabled_plugin_keys()) {
        if (!plugin_mgr.is_plugin_loaded(plugin_key)) {
            plugin_mgr.load_plugin(plugin_key, false);
            BOOST_LOG_TRIVIAL(info) << "Auto-loading plugin on startup: " << plugin_key;
        }
    }
 
    copy_network_if_available();
    on_init_network();
 
    if (m_agent)
        plugin_mgr.set_cloud_agent(std::dynamic_pointer_cast<OrcaCloudServiceAgent>(m_agent->get_cloud_agent()));
 
    if (m_agent && m_agent->is_user_login()) {
        enable_user_preset_folder(true);
        plugin_mgr.set_cloud_user(m_agent->get_user_id());
        // If there is a user logged in we do an immediate sync.
        std::vector<std::string> not_found, unauthorized;
        plugin_mgr.fetch_plugins_from_cloud(&not_found, &unauthorized);
        if (plater()) {
            for (const auto& uuid : not_found) {
                plater()->get_notification_manager()->push_notification(
                    NotificationType::CustomNotification,
                    NotificationManager::NotificationLevel::RegularNotificationLevel,
                    format(_L("Plugin %s is no longer available."), uuid));
            }
            for (const auto& uuid : unauthorized) {
                plater()->get_notification_manager()->push_notification(
                    NotificationType::CustomNotification,
                    NotificationManager::NotificationLevel::RegularNotificationLevel,
                    format(_L("Plugin %s access is unauthorized."), uuid));
            }
        }
    } else {
        enable_user_preset_folder(false);
        plugin_mgr.set_cloud_user("");
    }
 
    // BBS if load user preset failed
    // Let the libslic3r know the callback, which will translate messages on demand.
    // Installed before the presets load so that their load errors are translated too.
    Slic3r::I18N::set_translate_callback(libslic3r_translate_callback);
 
    //if (loaded_preset_result != 0) {
        try {
            // Enable all substitutions (in both user and system profiles), but log the substitutions in user profiles only.
            // If there are substitutions in system profiles, then a "reconfigure" event shall be triggered, which will force
            // installation of a compatible system preset, thus nullifying the system preset substitutions.
            if (scrn) { scrn->SetText(_L("Loading printer & filament profiles") + dots, 30); wxYield(); }
            init_params->preset_substitutions = preset_bundle->load_presets(*app_config, ForwardCompatibilitySubstitutionRule::EnableSystemSilent);
        }
        catch (const std::exception& ex) {
            show_error(nullptr, ex.what());
        }
    //}
 
#ifdef WIN32
    register_win32_device_notification_event();
#endif // WIN32
 
#if defined(__WXGTK__) && wxHAS_EGL
    // Configure GL backend before any wxGLCanvas is created.
    // On X11, prefer GLX for maximum driver compatibility.
    // On Wayland, EGL is used by default (only option).
    if (Slic3r::GUI::is_running_on_x11()) {
        wxGLCanvas::PreferGLX();
        BOOST_LOG_TRIVIAL(info) << "X11 detected, using GLX for OpenGL context";
    } else if (Slic3r::GUI::is_running_on_wayland()) {
        BOOST_LOG_TRIVIAL(info) << "Wayland detected, using EGL for OpenGL context";
    } else {
        BOOST_LOG_TRIVIAL(warning) << "Unknown display backend, defaulting to EGL";
    }
#endif
 
    if (scrn) {
        const auto scrn_txt = _L("Creating main window") + dots;
        scrn->SetText(scrn_txt, 70);
        wxYield();
    }
    BOOST_LOG_TRIVIAL(info) << "create the main window";
    mainframe = new MainFrame();
    // The first render can happen as soon as the frame is shown, before the queued
    // new_project() sets the same view.
    plater_->get_camera().select_view("topfront");
    plater_->get_camera().requires_zoom_to_bed = true;
    if (is_editor()) {
        if (starts_on_prepare()) {
            mainframe->select_tab(TAB_ID_PREPARE);
        } else {
            mainframe->select_tab(TAB_ID_HOME);
        }
    }
 
    sidebar().obj_list()->init();
    //sidebar().aux_list()->init_auxiliary();
 
//     update_mode(); // !!! do that later
    SetTopWindow(mainframe);
 
    plater_->init_notification_manager();
 
    m_printhost_job_queue.reset(new PrintHostJobQueue(mainframe->printhost_queue_dlg()));
 
    if (is_gcode_viewer()) {
        mainframe->update_layout();
        if (plater_ != nullptr)
            // ensure the selected technology is ptFFF
            plater_->set_printer_technology(ptFFF);
    }
    else {
        if (scrn) { scrn->SetText(_L("Loading current preset") + dots, 85); wxYield(); }
        load_current_presets();
    }
 
    if (plater_ != nullptr) {
        plater_->reset_project_dirty_initial_presets();
        plater_->update_project_dirty_from_presets();
        plater_->get_partplate_list().set_filament_count(preset_bundle->filament_presets.size());
    }
 
    // BBS:
#ifdef __WINDOWS__
    mainframe->topbar()->SaveNormalRect();
#endif
    if (scrn) { scrn->SetText(_L("Showing main window") + dots, 95); wxYield(); }
    mainframe->Show(true);
    // Close the splash now that the main UI is visible.
    if (scrn) { scrn->SetText(_L("Showing main window") + dots, 100); scrn->Destroy(); scrn = nullptr; }
    BOOST_LOG_TRIVIAL(info) << "main frame firstly shown";
 
//#if BBL_HAS_FIRST_PAGE
    //BBS: set tp3DEditor firstly
    /*plater_->canvas3D()->enable_render(false);
    mainframe->select_tab(size_t(MainFrame::tp3DEditor));
    scrn->SetText(_L("Loading Opengl resourses..."));
    plater_->select_view_3D("3D");
    //BBS init the opengl resource here
    Size canvas_size = plater_->canvas3D()->get_canvas_size();
    wxGetApp().imgui()->set_display_size(static_cast<float>(canvas_size.get_width()), static_cast<float>(canvas_size.get_height()));
    wxGetApp().init_opengl();
    plater_->canvas3D()->init();
    wxGetApp().imgui()->new_frame();
    plater_->canvas3D()->enable_render(true);
    plater_->canvas3D()->render();
    if (is_editor())
        mainframe->select_tab(size_t(0));*/
//#else
    //plater_->trigger_restore_project(1);
//#endif
 
    obj_list()->set_min_height();
 
    update_mode(); // update view mode after fix of the object_list size
 
#ifdef __APPLE__
   other_instance_message_handler()->bring_instance_forward();
#endif //__APPLE__
 
    Bind(EVT_HTTP_ERROR, &GUI_App::on_http_error, this);
 
 
    Bind(wxEVT_IDLE, [this](wxIdleEvent& event)
    {
        bool curr_studio_active = this->is_studio_active();
        if (m_studio_active != curr_studio_active) {
            if (curr_studio_active) {
                BOOST_LOG_TRIVIAL(info) << "studio is active, start to subscribe";
                if (m_agent) {
                    json j = json::object();
                    m_agent->start_subscribe("app");
                }
            } else {
                BOOST_LOG_TRIVIAL(info) << "studio is inactive, stop to subscribe";
                if (m_agent) {
                    json j = json::object();
                    m_agent->stop_subscribe("app");
                }
            }
            m_studio_active = curr_studio_active;
        }
 
 
        if (! plater_)
            return;
 
        // BBS
        //this->obj_manipul()->update_if_dirty();
 
        //use m_post_initialized instead
        //static bool update_gui_after_init = true;
 
        // An ugly solution to GH #5537 in which GUI_App::init_opengl (normally called from events wxEVT_PAINT
        // and wxEVT_SET_FOCUS before GUI_App::post_init is called) wasn't called before GUI_App::post_init and OpenGL wasn't initialized.
//#ifdef __linux__
//        if (!m_post_initialized && m_opengl_initialized) {
//#else
        if (!m_post_initialized && !m_adding_script_handler) {
//#endif
            m_post_initialized = true;
#ifdef WIN32
            this->mainframe->register_win32_callbacks();
#endif
            this->post_init();
 
            update_publish_status();
        }
 
        if (m_post_initialized && app_config->dirty() && app_config->save_due())
            app_config->save();
 
    });
 
    m_initialized = true;
 
    flush_logs();
 
    BOOST_LOG_TRIVIAL(info) << "finished the gui app init";
    if (m_config_corrupted) {
        m_config_corrupted = false;
        show_error(nullptr,
                   _u8L(
                       "The OrcaSlicer configuration file may be corrupted and cannot be parsed.\nOrcaSlicer has attempted to recreate the "
                       "configuration file.\nPlease note, application settings will be lost, but printer profiles will not be affected."));
    }
    return true;
}

References _L, _u8L, app_config, associate_files(), associate_url(), BAMBU_NETWORK_AGENT_VERSION_LEGACY, copy_network_if_available(), copy_older_config(), Slic3r::GUI::CustomNotification, dark_mode(), Slic3r::data_dir(), Slic3r::GUI::WindowMetrics::deserialize(), Slic3r::GUI::dialogStack, Slic3r::PluginManager::discover_plugins(), Slic3r::GUI::dots(), enable_user_preset_folder(), Slic3r::EnableSystemSilent, Slic3r::PluginManager::fetch_plugins_from_cloud(), Slic3r::flush_logs(), Slic3r::GUI::format(), Slic3r::GUI::from_u8(), Slic3r::PluginManager::get_enabled_plugin_keys(), Slic3r::GUI::get_system_info(), init_fonts(), init_label_colours(), init_params, init_plugin_gui_wiring(), NppDarkMode::InitDarkMode(), Slic3r::PluginManager::initialize(), Label::initSysFont(), Slic3r::PluginManager::instance(), Slic3r::PythonInterpreter::instance(), is_editor(), is_gcode_viewer(), Slic3r::PluginManager::is_plugin_loaded(), Slic3r::GUI::is_running_in_msix(), is_studio_active(), Slic3r::GUI::RichMessageDialog::IsCheckBoxChecked(), L, Slic3r::GUI::libslic3r_translate_callback(), load_current_presets(), load_language(), Slic3r::PluginManager::load_plugin(), m_action_registry, m_adding_script_handler, m_agent, Slic3r::GUI::UpdateVersionDialog::m_button_skip_version, m_config_corrupted, m_info_dialog_content, m_init_app_config_from_older, m_initialized, m_post_initialized, m_printhost_job_queue, m_studio_active, mainframe, obj_list(), on_check_privacy_update(), on_http_error(), on_init_inner(), on_init_network(), on_update_machine_list(), on_user_login(), on_user_login_handle(), Slic3r::GUI::open_ms_store_product_page(), other_instance_message_handler(), plater(), plater_, post_init(), preset_bundle, preset_updater, Slic3r::ptFFF, Slic3r::GUI::register_mac_deep_link_handler(), RegisterOrcaInspectorPlugins(), Slic3r::GUI::NotificationManager::RegularNotificationLevel, Slic3r::resources_dir(), Slic3r::PluginManager::set_cloud_agent(), Slic3r::PluginManager::set_cloud_user(), CBaseException::set_log_folder(), Slic3r::I18N::set_translate_callback(), NppDarkMode::SetDarkMode(), Slic3r::GUI::DownloadDialog::SetExtendedMessage(), NppDarkMode::SetSystemMenuForApp(), show_check_privacy_dlg(), Slic3r::GUI::show_error(), show_ip_address_enter_dialog_handler(), Slic3r::GUI::RichMessageDialog::ShowCheckBox(), Slic3r::GUI::DPIAware< P >::ShowModal(), Slic3r::GUI::RichMessageDialog::ShowModal(), Slic3r::PluginManager::shutdown(), Slic3r::PythonInterpreter::shutdown(), sidebar(), starts_on_prepare(), stop_sync_user_preset(), TAB_ID_HOME, TAB_ID_PREPARE, Slic3r::Http::tls_global_init(), Slic3r::Http::tls_system_cert_store(), Slic3r::NetworkAgent::unload_network_module(), Update_dark_mode_flag(), update_mode(), update_publish_status(), Slic3r::GUI::UpdateVersionDialog::update_version_info(), use_legacy_network_plugin(), and version_info.

Referenced by on_init_inner(), and OnInit().

Here is the caller graph for this function:

on_init_network()

bool Slic3r::GUI::GUI_App::on_init_network ( bool try_backup = false )

private

{
    // Clean up stale ".old" files left by install_plugin() when it had to rename an in-use
    // DLL aside (see the rename-aside path in install_plugin). This runs before the plug-in
    // is (re)loaded - at startup nothing is mapped yet, and on a hot reload the previous
    // module has already been unloaded - so the previously locked files can now be removed.
    {
        boost::filesystem::path plugin_folder = boost::filesystem::path(data_dir()) / "plugins";
        boost::system::error_code ec;
        if (boost::filesystem::is_directory(plugin_folder, ec)) {
            for (boost::filesystem::directory_iterator it(plugin_folder, ec), end; !ec && it != end; it.increment(ec)) {
                if (it->path().extension() == ".old") {
                    boost::system::error_code rm_ec;
                    boost::filesystem::remove(it->path(), rm_ec);
                    if (rm_ec)
                        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": could not remove stale " << it->path().filename().string()
                                                << " (" << rm_ec.message() << "), will retry next launch";
                }
            }
        }
    }
 
    auto should_load_networking_plugin = app_config->get_bool("installed_networking");
 
    // Normalize an older full-version identity to the AA.BB.CC series before it drives loading.
    migrate_network_plugin_config();
 
    std::string config_version = app_config->get_network_plugin_version();
 
    if (should_load_networking_plugin) {
        // A version outside the whitelisted series (e.g. 02.03.00.62 configured by an older
        // Orca release) must not be loaded - its ABI no longer matches this build. Fall back
        // to the latest supported build if it is already on disk; otherwise clear the
        // configured version so the normal empty-version download flow takes over (the
        // download URL and install adoption both derive from the configured version, so it
        // must not keep pointing at the unsupported build).
        if (!config_version.empty() && !is_supported_network_version(config_version)) {
            std::string latest = get_latest_network_version();
            BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": configured plugin version " << config_version
                                       << " is no longer supported, falling back to " << latest;
            config_version = BBLNetworkPlugin::versioned_library_exists(latest) ? latest : "";
            app_config->set_network_plugin_version(config_version);
            app_config->save();
        }
 
        if (config_version.empty()) {
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": no version configured, need to download";
            m_networking_need_update = true;
        } else {
            int load_agent_dll = Slic3r::NetworkAgent::initialize_network_module(false, config_version);
        __retry:
            if (!load_agent_dll) {
                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": on_init_network, load dll ok";
 
                std::string loaded_version = Slic3r::NetworkAgent::get_version();
                if (app_config && !loaded_version.empty() && loaded_version != "00.00.00.00") {
                    // Self-heal only when a genuinely different series loaded than configured (e.g. the
                    // configured build was unavailable and a fallback loaded). Within a series the
                    // loaded build (02.08.01.53) differs from the series config (02.08.01) by design, so
                    // compare series, not the raw string, and store the managed series form - a custom
                    // config (02.08.01_custom) keeps its own name.
                    std::string config_version = app_config->get_network_plugin_version();
                    std::string loaded_series  = network_plugin_series(loaded_version);
                    if (network_plugin_series(config_version) != loaded_series) {
                        std::string synced = is_series_managed_version(loaded_version) ? loaded_series : loaded_version;
                        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": syncing config version from " << config_version
                                                << " to loaded " << loaded_version << " (stored as " << synced << ")";
                        app_config->set_network_plugin_version(synced);
                        app_config->save();
                    }
                }
 
                if (check_networking_version()) {
                    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": on_init_network, compatibility version";
                    auto bambu_source = Slic3r::NetworkAgent::get_bambu_source_entry();
                    if (!bambu_source) {
                        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": can not get bambu source module!";
                        m_networking_compatible = false;
                        if (should_load_networking_plugin) {
                            m_networking_need_update = true;
                        }
                    }
                } else {
                    if (try_backup) {
                        int result = Slic3r::NetworkAgent::unload_network_module();
                        BOOST_LOG_TRIVIAL(info) << "on_init_network, version mismatch, unload_network_module, result = " << result;
                        load_agent_dll = Slic3r::NetworkAgent::initialize_network_module(true, config_version);
                        try_backup     = false;
                        goto __retry;
                    }
                    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": on_init_network, version dismatch, need upload network module";
                    if (should_load_networking_plugin) {
                        m_networking_need_update = true;
                    }
                }
            } else {
                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": on_init_network, load dll failed";
                // A failed install can leave the config naming a build that never made it to disk;
                // fall back to the installed latest instead of dropping the user into the re-download
                // flow. Only when the configured library is genuinely absent, though - a pinned series
                // that is on disk but failed to load once must keep its pin, not be rewritten for good.
                std::string latest = get_latest_network_version();
                if (config_version != latest && !BBLNetworkPlugin::versioned_library_exists(config_version)
                    && BBLNetworkPlugin::versioned_library_exists(latest)) {
                    BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": falling back to installed " << latest;
                    config_version = latest;
                    app_config->set_network_plugin_version(latest);
                    app_config->save();
                    load_agent_dll = Slic3r::NetworkAgent::initialize_network_module(false, config_version);
                    goto __retry;
                }
                if (should_load_networking_plugin) {
                    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": on_init_network, need upload network module";
                    m_networking_need_update = true;
                }
            }
        }
    }
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(", create network agent...");
    //std::string data_dir = wxStandardPaths::Get().GetUserDataDir().ToUTF8().data();
    std::string data_directory = data_dir();
 
    // Register all printer agents before creating the network agent
    Slic3r::NetworkAgentFactory::register_all_agents();
 
    // m_agent = new Slic3r::NetworkAgent(data_directory);
    std::unique_ptr<Slic3r::NetworkAgent> agent_ptr = Slic3r::create_agent_from_config(data_directory, app_config);
    // A direct restart_networking() replaces m_agent without deleting it, so a health check in flight
    // on the old agent would still report into the GUI.
    stop_orca_health_check(m_agent);
    m_agent = agent_ptr.release();
 
    if (!m_device_manager)
        m_device_manager = new Slic3r::DeviceManager(m_agent);
    else
        m_device_manager->set_agent(m_agent);
 
    if (!m_user_manager)
        m_user_manager = new Slic3r::UserManager(m_agent);
    else
        m_user_manager->set_agent(m_agent);
 
    // A hot reload deletes the agent the task manager was built with. It lives until restart, so repoint it
    // even if multi-device has since been turned off.
    if (m_task_manager)
        m_task_manager->set_agent(m_agent);
 
    if (this->is_enable_multi_machine()) {
        if (!m_task_manager) {
            m_task_manager = new Slic3r::TaskManager(m_agent);
            m_task_manager->start();
        }
 
        m_device_manager->EnableMultiMachine(true);
    } else {
        m_device_manager->EnableMultiMachine(false);
    }
 
    //BBS set config dir
    if (m_agent) {
        m_agent->set_config_dir(data_directory);
    }
    //BBS start http log
    if (m_agent) {
        m_agent->init_log();
    }
 
    //BBS set cert dir
    if (m_agent)
        m_agent->set_cert_file(resources_dir() + "/cert", "slicer_base64.cer");
 
    if (m_agent) {
        init_networking_callbacks();
        std::string country_code = app_config->get_country_code();
        m_agent->set_country_code(country_code);
        m_agent->start();
        // Orca: disable Bambu telemetry up-front (before any login) so it never starts.
        check_track_enable();
    }
 
    // When using Orca cloud alongside the BBL network plugin, the BBL DLL agent still
    // needs to be created and configured (config dir, certs, country, start) so that
    // BBLPrinterAgent can use it for LAN discovery and printer communication.
    if (should_load_networking_plugin && !m_networking_need_update) {
        auto& plugin = BBLNetworkPlugin::instance();
        if (plugin.is_loaded() && !plugin.has_agent()) {
            plugin.create_agent(data_directory);
        }
        if (plugin.has_agent()) {
            BBLCloudServiceAgent bbl;
            bbl.set_config_dir(data_directory);
            bbl.init_log();
            bbl.set_cert_file(resources_dir() + "/cert", "slicer_base64.cer");
            bbl.set_country_code(app_config->get_country_code());
            // Orca: disable Bambu telemetry before start() so the DLL never spins up tracking
            // workers. This covers the case where the BBL plugin is loaded for LAN discovery
            // but the user has not registered BBL_CLOUD_PROVIDER (so m_agent->track_enable
            // would not reach this DLL instance).
            bbl.track_enable(false);
            bbl.track_remove_files();
            bbl.start();
        }
    }
 
    if (!should_load_networking_plugin) {
        int result = Slic3r::NetworkAgent::unload_network_module();
        BOOST_LOG_TRIVIAL(info) << "on_init_network, unload_network_module, result = " << result;
 
        if (!m_device_manager)
            m_device_manager = new Slic3r::DeviceManager();
 
        if (!m_user_manager)
            m_user_manager = new Slic3r::UserManager();
    }
 
    // A version pinned to something other than the latest series is a deliberate choice, so it
    // is exempt from the upgrade prompt the same way the legacy pin already is - otherwise the
    // dialog reappears on every launch for as long as the pin is held.
    const std::string pinned_version = app_config->get_network_plugin_version();
    const bool pinned_to_older_series = !pinned_version.empty() &&
        network_plugin_series(pinned_version) != network_plugin_series(get_latest_network_version());
 
    if (should_load_networking_plugin && m_networking_compatible && !pinned_to_older_series) {
        app_config->clear_remind_network_update_later();
 
        if (has_network_update_available()) {
            std::string latest = get_latest_network_version();
 
            bool should_prompt = !app_config->is_network_update_prompt_disabled()
                && !app_config->is_network_version_skipped(latest)
                && !app_config->should_remind_network_update_later();
 
            if (should_prompt) {
                CallAfter([this]() {
                    show_network_plugin_download_dialog(true);
                });
            }
        }
    }
 
    return true;
}

References app_config, check_networking_version(), check_track_enable(), Slic3r::create_agent_from_config(), Slic3r::data_dir(), Slic3r::NetworkAgent::get_bambu_source_entry(), get_latest_network_version(), Slic3r::NetworkAgent::get_version(), has_network_update_available(), Slic3r::BBLCloudServiceAgent::init_log(), init_networking_callbacks(), Slic3r::NetworkAgent::initialize_network_module(), Slic3r::BBLNetworkPlugin::instance(), is_enable_multi_machine(), Slic3r::is_series_managed_version(), Slic3r::is_supported_network_version(), m_agent, m_device_manager, m_networking_compatible, m_networking_need_update, m_task_manager, m_user_manager, migrate_network_plugin_config(), Slic3r::network_plugin_series(), on_init_network(), Slic3r::NetworkAgentFactory::register_all_agents(), Slic3r::resources_dir(), Slic3r::BBLCloudServiceAgent::set_cert_file(), Slic3r::BBLCloudServiceAgent::set_config_dir(), Slic3r::BBLCloudServiceAgent::set_country_code(), show_network_plugin_download_dialog(), Slic3r::BBLCloudServiceAgent::start(), Slic3r::BBLCloudServiceAgent::track_enable(), Slic3r::BBLCloudServiceAgent::track_remove_files(), Slic3r::NetworkAgent::unload_network_module(), and Slic3r::BBLNetworkPlugin::versioned_library_exists().

Referenced by on_init_inner(), on_init_network(), and restart_networking().

Here is the call graph for this function:

Here is the caller graph for this function:

on_shortcuts_changed()

void Slic3r::GUI::GUI_App::on_shortcuts_changed

(

)

{
    m_shortcuts->save(*app_config);
    app_config->save();
    if (mainframe == nullptr)
        return;
    mainframe->update_shortcut_labels();
    if (Plater* plater = this->plater(); plater != nullptr) {
        if (GLCanvas3D* canvas = plater->get_view3D_canvas3D(); canvas != nullptr)
            canvas->update_shortcut_tooltips();
#ifdef __WXOSX__
        obj_list()->update_shortcut_accelerators();
#endif
    }
}

References app_config, m_shortcuts, mainframe, obj_list(), on_shortcuts_changed(), and plater().

Referenced by on_shortcuts_changed().

Here is the call graph for this function:

Here is the caller graph for this function:

on_show_check_privacy_dlg()

void Slic3r::GUI::GUI_App::on_show_check_privacy_dlg	(	int	online_login = 0,
		const std::string &	provider = ORCA_CLOUD_PROVIDER )

{
    auto evt = new wxCommandEvent(EVT_CHECK_PRIVACY_SHOW);
    evt->SetInt(online_login);
    evt->SetString(wxString::FromUTF8(provider));
    wxQueueEvent(this, evt);
}

References on_show_check_privacy_dlg().

Referenced by on_check_privacy_update(), and on_show_check_privacy_dlg().

Here is the call graph for this function:

Here is the caller graph for this function:

on_start_subscribe_again()

void Slic3r::GUI::GUI_App::on_start_subscribe_again

(

std::string

dev_id

)

{
    auto start_subscribe_timer = new wxTimer(this, wxID_ANY);
    Bind(wxEVT_TIMER, [start_subscribe_timer, dev_id](auto& e) {
        start_subscribe_timer->Stop();
        Slic3r::DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager();
        if (!dev) return;
        MachineObject* obj = dev->get_selected_machine();
        if (!obj) return;
 
        if ( (dev_id == obj->get_dev_id()) && obj->is_connecting() && obj->subscribe_counter > 0) {
            obj->subscribe_counter--;
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": dev_id=" << obj->get_dev_id();
        }
    });
    start_subscribe_timer->Start(5000, wxTIMER_ONE_SHOT);
}

References Slic3r::MachineObject::get_dev_id(), Slic3r::DeviceManager::get_selected_machine(), Slic3r::MachineObject::is_connecting(), on_start_subscribe_again(), and Slic3r::MachineObject::subscribe_counter.

Referenced by on_start_subscribe_again().

Here is the call graph for this function:

Here is the caller graph for this function:

on_stealth_mode_enter()

void Slic3r::GUI::GUI_App::on_stealth_mode_enter

(

)

{
    stop_sync_user_preset();
    BOOST_LOG_TRIVIAL(info) << "logout: on_stealth_mode_enter";
    // Stealth mode forces a desktop logout, but the user did not choose "Sign out": guide §8 ties
    // ?signout=1 to the explicit desktop sign-out only. Leave the cloud webview's own session
    // alone, so it is re-checked (and re-seeded with the right account) on the next open.
    request_user_logout(ORCA_CLOUD_PROVIDER, /*user_initiated=*/false);
    request_user_logout(BBL_CLOUD_PROVIDER, /*user_initiated=*/false);
    if (WebViewPanel* home = WebViewPanel::if_built()) {
        home->SendCloudProvidersInfo();
    }
}

References Slic3r::BBL_CLOUD_PROVIDER(), Slic3r::GUI::LazyInstance< WebViewPanel >::if_built(), on_stealth_mode_enter(), Slic3r::ORCA_CLOUD_PROVIDER(), request_user_logout(), and stop_sync_user_preset().

Referenced by on_stealth_mode_enter().

Here is the call graph for this function:

Here is the caller graph for this function:

on_update_machine_list()

void Slic3r::GUI::GUI_App::on_update_machine_list

(

wxCommandEvent &

evt

)

{
    /* DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager();
     if (dev) {
         dev->add_user_subscribe();
     }*/
}

References on_update_machine_list().

Referenced by on_init_inner(), and on_update_machine_list().

Here is the call graph for this function:

Here is the caller graph for this function:

on_user_login()

void Slic3r::GUI::GUI_App::on_user_login

(

wxCommandEvent &

evt

)

{
    if (!m_agent) { return; }
    int online_login = evt.GetInt();
    std::string provider = evt.GetString().ToStdString();
    if (provider.empty()) provider = ORCA_CLOUD_PROVIDER;
 
    // check privacy before handle
    check_privacy_version(online_login, provider);
    check_track_enable();
}

References check_privacy_version(), check_track_enable(), m_agent, on_user_login(), and Slic3r::ORCA_CLOUD_PROVIDER().

Referenced by on_init_inner(), and on_user_login().

Here is the call graph for this function:

Here is the caller graph for this function:

on_user_login_handle()

void Slic3r::GUI::GUI_App::on_user_login_handle

(

wxCommandEvent &

evt

)

{
    if (!m_agent) { return; }
    if (app_config->get_stealth_mode()) {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": stealth mode enabled, skipping cloud connection";
        return;
    }
 
    int online_login = evt.GetInt();
    std::string provider = evt.GetString().ToStdString();
    if (provider.empty()) provider = ORCA_CLOUD_PROVIDER;
 
    // Reset 401 grace period so transient token-propagation 401s
    // during login warmup don't trigger immediate logout.
    m_last_401_error_time = std::chrono::steady_clock::now();
 
    m_agent->connect_server();
    // get machine list
    DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager();
    if (!dev) return;
 
    boost::thread update_thread = boost::thread([dev, provider] {
        dev->update_user_machine_list_info(provider);
    });
 
    if (online_login && provider == ORCA_CLOUD_PROVIDER) {
        // The steps below run synchronously on the UI thread (cloud plugin fetch and
        // user-preset load both block on network/disk). Show an indeterminate progress
        // dialog so the window isn't frozen without feedback. Percentages are cosmetic
        // milestones, not measured progress.
        ProgressDialog dlg(_L("Loading"), _L("Syncing your account…"), 100, mainframe, wxPD_AUTO_HIDE | wxPD_APP_MODAL);
 
        dlg.Update(10, _L("Migrating presets…"));
        maybe_migrate_user_presets_on_login();
        remove_user_presets();
        enable_user_preset_folder(true);
 
        dlg.Update(40, _L("Fetching plugins…"));
        PluginManager::instance().fetch_plugins_from_cloud();
        if (m_plugins_dlg)
            m_plugins_dlg->update_plugin_dialog_ui();
 
        dlg.Update(70, _L("Loading user presets…"));
        preset_bundle->load_user_presets(m_agent->get_user_id(provider), ForwardCompatibilitySubstitutionRule::Enable);
        mainframe->update_side_preset_ui();
 
        dlg.Update(100);
        GUI::wxGetApp().mainframe->show_sync_dialog();
    }
 
    // Ensure sync thread starts after login completes (regardless of login type).
    // Safe: start_sync_user_preset() has a dedup guard (m_user_sync_token) to prevent duplicate threads.
    if (app_config->get("sync_user_preset") == "true") {
        start_sync_user_preset();
    }
 
    // Re-seed the embedded OrcaCloud pane if it is already open, so it picks up the new session
    // without waiting for the next open. On a fresh login or account switch this invalidates any
    // in-flight handoff for the previous account and loads the Start URL with the new user_id, so
    // the page drops the old account and re-requests (guide §8).
    ++m_cloud_handoff_gen;
    m_cloud_handoff_state.clear();
    if (WebViewPanel* home = WebViewPanel::if_built())
        if (home->cloud_mode_active())
            home->set_cloud_mode(true, cloud_webview_handoff(m_cloud_open_path));
}

References _L, app_config, cloud_webview_handoff(), Slic3r::Enable, enable_user_preset_folder(), Slic3r::GUI::LazyInstance< WebViewPanel >::if_built(), Slic3r::PluginManager::instance(), m_agent, m_cloud_handoff_gen, m_cloud_handoff_state, m_cloud_open_path, m_last_401_error_time, m_plugins_dlg, mainframe, maybe_migrate_user_presets_on_login(), on_user_login_handle(), Slic3r::ORCA_CLOUD_PROVIDER(), preset_bundle, remove_user_presets(), start_sync_user_preset(), Slic3r::GUI::ProgressDialog::Update(), and Slic3r::DeviceManager::update_user_machine_list_info().

Referenced by on_init_inner(), and on_user_login_handle().

Here is the call graph for this function:

Here is the caller graph for this function:

OnExceptionInMainLoop()

bool Slic3r::GUI::GUI_App::OnExceptionInMainLoop ( )

overridevirtual

{
    generic_exception_handle();
    return false;
}

References Slic3r::GUI::generic_exception_handle(), and OnExceptionInMainLoop().

Referenced by OnExceptionInMainLoop().

Here is the call graph for this function:

Here is the caller graph for this function:

OnExit()

int Slic3r::GUI::GUI_App::OnExit ( )

override

{
    stop_http_server();
    stop_sync_user_preset();
 
    if (m_device_manager) {
        delete m_device_manager;
        m_device_manager = nullptr;
    }
 
    if (m_user_manager) {
        delete m_user_manager;
        m_user_manager = nullptr;
    }
 
    // Clear the printer agent cache before destroying the NetworkAgent.
    // This disconnects all cached agents and releases their shared_ptrs,
    // ensuring clean thread shutdown before the agent is deleted.
    NetworkAgentFactory::clear_printer_agent_cache();
 
    if (m_agent) {
        stop_orca_health_check(m_agent);
        // BBS avoid a crash on mac platform
#ifdef __WINDOWS__
        m_agent->start_discovery(false, false);
#endif
        delete m_agent;
        m_agent = nullptr;
    }
 
    // Orca: clean up encrypted bbl network log file if plugin is used
    // No point to keep them as they are encrypted and can't be used for debugging
    try {
        auto              log_folder  = boost::filesystem::path(data_dir()) / "log";
        const std::string filePattern = R"(debug_network_.*\.log\.enc)";
        std::regex        pattern(filePattern);
        if (boost::filesystem::exists(log_folder)) {
            std::vector<boost::filesystem::path> network_logs;
            for (auto& it : boost::filesystem::directory_iterator(log_folder)) {
                auto temp_path = it.path();
                if (boost::filesystem::is_regular_file(temp_path) && std::regex_match(temp_path.filename().string(), pattern)) {
                    network_logs.push_back(temp_path.filename());
                }
            }
            for (auto f : network_logs) {
                boost::filesystem::remove(f);
            }
        }
    } catch (...) {
        BOOST_LOG_TRIVIAL(error) << "Failed to clean up encrypt bbl network log file";
    }
 
    return wxApp::OnExit();
}

References Slic3r::NetworkAgentFactory::clear_printer_agent_cache(), Slic3r::data_dir(), Slic3r::f(), m_agent, m_device_manager, m_user_manager, OnExit(), stop_http_server(), and stop_sync_user_preset().

Referenced by OnExit().

Here is the call graph for this function:

Here is the caller graph for this function:

OnInit()

bool Slic3r::GUI::GUI_App::OnInit ( )

override

{
    try {
        return on_init_inner();
    } catch (const std::exception& e) {
        BOOST_LOG_TRIVIAL(fatal) << "OnInit Got Fatal error: " << e.what();
        generic_exception_handle();
        return false;
    }
}

References Slic3r::GUI::generic_exception_handle(), on_init_inner(), and OnInit().

Referenced by OnInit().

Here is the call graph for this function:

Here is the caller graph for this function:

open_browser_with_warning_dialog()

bool Slic3r::GUI::GUI_App::open_browser_with_warning_dialog	(	const wxString &	url,
		int	flags = 0 )

{
    return wxLaunchDefaultBrowser(url, flags);
}

References open_browser_with_warning_dialog().

Referenced by open_browser_with_warning_dialog(), and open_web_page_localized().

Here is the call graph for this function:

Here is the caller graph for this function:

open_exportpresetbundledialog()

void Slic3r::GUI::GUI_App::open_exportpresetbundledialog	(	size_t	open_on_tab = 0,
		const std::string &	highlight_option = std::string() )

{
    bool app_layout_changed = false;
    {
        ExportPresetBundleDialog dlg(mainframe, open_on_tab, highlight_option);
        dlg.ShowModal();
        this->plater_->get_current_canvas3D()->force_set_focus();
        #if ENABLE_GCODE_LINES_ID_IN_H_SLIDER
            if (dlg.seq_top_layer_only_changed() || dlg.seq_seq_top_gcode_indices_changed())
        #else
                if (dlg.seq_top_layer_only_changed())
        #endif // ENABLE_GCODE_LINES_ID_IN_H_SLIDER
                    this->plater_->reload_print();
    }
}

References mainframe, open_exportpresetbundledialog(), plater_, Slic3r::GUI::ExportPresetBundleDialog::seq_top_layer_only_changed(), and Slic3r::GUI::DPIAware< P >::ShowModal().

Referenced by open_exportpresetbundledialog().

Here is the call graph for this function:

Here is the caller graph for this function:

open_mall_page_dialog()

void Slic3r::GUI::GUI_App::open_mall_page_dialog

(

)

{
    std::string host_url;
    std::string model_url;
    std::string link_url;
 
    int result = -1;
 
    //model api url
    host_url = get_model_http_url(app_config->get_country_code());
 
    //model url
 
    wxString language_code = this->current_language_code().BeforeFirst('_');
    model_url = language_code.ToStdString();
 
    if (getAgent() && mainframe) {
 
        //login already
        if (getAgent()->is_user_login()) {
            std::string ticket;
            result = getAgent()->request_bind_ticket(&ticket);
 
            if(result == 0){
                link_url = host_url + "api/sign-in/ticket?to=" + host_url + url_encode(model_url) + "&ticket=" + ticket;
            }
        }
    }
 
    if (result < 0) {
       link_url = host_url + model_url;
    }
 
    if (link_url.find("?") != std::string::npos) {
        link_url += "&from=orcaslicer";
    } else {
        link_url += "?from=orcaslicer";
    }
 
    wxLaunchDefaultBrowser(link_url);
}

References app_config, current_language_code(), get_model_http_url(), getAgent(), is_user_login(), mainframe, open_mall_page_dialog(), and url_encode().

Referenced by handle_web_request(), and open_mall_page_dialog().

Here is the call graph for this function:

Here is the caller graph for this function:

open_orca_cloud()

void Slic3r::GUI::GUI_App::open_orca_cloud

(

const std::string &

next = std::string()

)

{
    // Remembered so a login while the pane is open re-seeds the same page rather than the default.
    m_cloud_open_path = next;
    // Deferred: set_cloud_mode() may create the second native webview, so this must not run inside
    // the caller's frame (a webview script-message callback or an ImGui frame).
    CallAfter([this]() {
        if (mainframe != nullptr)
            mainframe->select_tab(TAB_ID_HOME);
        // The Home page is built lazily, so the tab switch may not have created it yet: ensure() builds
        // it if needed, matching what showing the tab does, rather than dropping the open request.
        if (WebViewPanel* home = WebViewPanel::ensure())
            home->set_cloud_mode(true, cloud_webview_handoff(m_cloud_open_path), cloud_page_url(m_agent, m_cloud_open_path));
    });
}

References Slic3r::GUI::cloud_page_url(), cloud_webview_handoff(), Slic3r::GUI::LazyInstance< WebViewPanel >::ensure(), m_agent, m_cloud_open_path, mainframe, open_orca_cloud(), and TAB_ID_HOME.

Referenced by handle_web_request(), and open_orca_cloud().

Here is the call graph for this function:

Here is the caller graph for this function:

open_plugins_dialog()

void Slic3r::GUI::GUI_App::open_plugins_dialog	(	size_t	open_on_tab = 0,
		const std::string &	highlight_option = std::string() )

{
    if (m_plugins_dlg) {
        m_plugins_dlg->Show();
        m_plugins_dlg->Raise();
        return;
    }
 
    try {
        m_plugins_dlg = new PluginsDialog(mainframe, wxID_ANY, _L("Plugins"));
        m_plugins_dlg->set_open_terminal_dlg_fn();
        m_plugins_dlg->Bind(wxEVT_DESTROY, [this](wxWindowDestroyEvent& event) {
            if (event.GetEventObject() == m_plugins_dlg)
                m_plugins_dlg = nullptr;
            event.Skip();
        });
 
        m_plugins_dlg->Show();
        m_plugins_dlg->Raise();
    } catch (const std::exception& e) {
        BOOST_LOG_TRIVIAL(error) << "open_plugins_dialog failed: " << e.what();
        if (m_plugins_dlg) {
            m_plugins_dlg->Destroy();
            m_plugins_dlg = nullptr;
        }
        wxMessageBox(wxString::Format(_L("Failed to open the Plugins dialog:\n%s"), from_u8(e.what())), _L("Plugins"),
                     wxOK | wxICON_ERROR, mainframe);
    } catch (...) {
        BOOST_LOG_TRIVIAL(error) << "open_plugins_dialog failed with a non-standard exception";
        if (m_plugins_dlg) {
            m_plugins_dlg->Destroy();
            m_plugins_dlg = nullptr;
        }
        wxMessageBox(_L("Failed to open the Plugins dialog (unknown error)."), _L("Plugins"), wxOK | wxICON_ERROR, mainframe);
    }
}

References _L, Slic3r::GUI::from_u8(), m_plugins_dlg, mainframe, and open_plugins_dialog().

Referenced by open_plugins_dialog().

Here is the call graph for this function:

Here is the caller graph for this function:

open_preferences() [1/2]

void Slic3r::GUI::GUI_App::open_preferences

(

)

{ open_preferences(PreferencesTab::General); }

References Slic3r::GUI::General, and open_preferences().

Referenced by open_preferences(), and open_preferences().

Here is the call graph for this function:

Here is the caller graph for this function:

open_preferences() [2/2]

void Slic3r::GUI::GUI_App::open_preferences	(	PreferencesTab	tab,
		const std::string &	highlight_option = std::string() )

{
    // Render settings the canvas reads every frame; a change needs one redraw to show.
    static constexpr const char* opengl_render_setting_keys[] = {
        SETTING_OPENGL_FXAA_ENABLED, SETTING_OPENGL_FPS_CAP, SETTING_OPENGL_SHOW_FPS_OVERLAY, SETTING_OPENGL_SHOW_RENDER_TIMINGS,
        SETTING_OPENGL_SCENE_CACHE, SETTING_OPENGL_SKIP_IDENTICAL_FRAMES, SETTING_OPENGL_REALISTIC_SHADOWS,
        SETTING_OPENGL_REALISTIC_GLOSS
    };
    std::vector<std::string> previous_opengl_render_settings;
    for (const char* key : opengl_render_setting_keys)
        previous_opengl_render_settings.emplace_back(app_config->get(key));
 
    bool need_recreate_gui = false;
    std::string pending_language;
    {
        // the dialog needs to be destroyed before the call to recreate_GUI()
        // or sometimes the application crashes into wxDialogBase() destructor
        // so we put it into an inner scope
        PreferencesDialog dlg(mainframe);
        dlg.select_tab(tab, highlight_option);
        dlg.ShowModal();
        need_recreate_gui = dlg.recreate_GUI();
        pending_language = dlg.pending_language();
        if (!need_recreate_gui) {
            this->plater_->get_current_canvas3D()->force_set_focus();
#if ENABLE_GCODE_LINES_ID_IN_H_SLIDER
            if (dlg.seq_top_layer_only_changed() || dlg.seq_seq_top_gcode_indices_changed())
#else
            if (dlg.seq_top_layer_only_changed())
#endif // ENABLE_GCODE_LINES_ID_IN_H_SLIDER
                this->plater_->reload_print();
#ifdef _WIN32
            if (is_editor()) {
                if (app_config->get("associate_3mf") == "true")
                    associate_files(L"3mf");
                if (app_config->get("associate_stl") == "true")
                    associate_files(L"stl");
                if (app_config->get("associate_step") == "true") {
                    associate_files(L"step");
                    associate_files(L"stp");
                }
                associate_url(L"orcaslicer");
            }
            else {
                if (app_config->get("associate_gcode") == "true")
                    associate_files(L"gcode");
            }
#endif // _WIN32
        }
    }
 
    bool opengl_render_settings_changed = false;
    for (size_t i = 0; i < previous_opengl_render_settings.size(); ++i)
        opengl_render_settings_changed |= app_config->get(opengl_render_setting_keys[i]) != previous_opengl_render_settings[i];
    if (opengl_render_settings_changed && !need_recreate_gui && this->plater_ != nullptr) {
        this->plater_->set_current_canvas_as_dirty();
        this->plater_->get_current_canvas3D()->force_set_focus();
    }
 
    if (!pending_language.empty()) {
        const std::string previous_language = app_config->get("language");
        app_config->set("language", pending_language);
        if (!load_language(wxString::FromUTF8(pending_language), false)) {
            app_config->set("language", previous_language);
            if (this->plater_)
                this->plater_->get_current_canvas3D()->force_set_focus();
            return;
        }
        // Built-in Speed Dial command titles are copied from the catalog at init and don't follow a
        // live locale switch; rebuild them in the new language before the GUI (and palette) rebuilds.
        m_action_registry.relocalize_builtins();
    }
 
    if (need_recreate_gui)
        recreate_GUI(_L("Changing application language"));
}

References _L, app_config, associate_files(), associate_url(), is_editor(), L, load_language(), m_action_registry, mainframe, open_preferences(), Slic3r::GUI::PreferencesDialog::pending_language(), plater_, recreate_GUI(), Slic3r::GUI::PreferencesDialog::recreate_GUI(), Slic3r::GUI::PreferencesDialog::select_tab(), Slic3r::GUI::PreferencesDialog::seq_top_layer_only_changed(), SETTING_OPENGL_FPS_CAP, SETTING_OPENGL_FXAA_ENABLED, SETTING_OPENGL_REALISTIC_GLOSS, SETTING_OPENGL_REALISTIC_SHADOWS, SETTING_OPENGL_SCENE_CACHE, SETTING_OPENGL_SHOW_FPS_OVERLAY, SETTING_OPENGL_SHOW_RENDER_TIMINGS, SETTING_OPENGL_SKIP_IDENTICAL_FRAMES, and Slic3r::GUI::DPIAware< P >::ShowModal().

Here is the call graph for this function:

open_presetbundledialog()

void Slic3r::GUI::GUI_App::open_presetbundledialog	(	size_t	open_on_tab = 0,
		const std::string &	highlight_option = std::string() )

{
    bool app_layout_changed = false;
    {
 
        if(m_preset_bundle_dlg)
        {
            return;
        }
        m_preset_bundle_dlg = new PresetBundleDialog(mainframe, open_on_tab, highlight_option);
        m_preset_bundle_dlg->Bind(wxEVT_DESTROY, [this](wxWindowDestroyEvent&) {                                                                                                                                                                                                          
            if (m_preset_bundle_dlg)                                                                                                                                                                                                                                           
                m_preset_bundle_dlg = nullptr;                                                                                                                                                                                                                                                
        });
        // PresetBundleDialog dlg(mainframe, open_on_tab, highlight_option);
        m_preset_bundle_dlg->ShowModal();
        if (m_preset_bundle_dlg) {                                                                                                                                                                                                                                             
            m_preset_bundle_dlg->Destroy();                                                                                                                                                                                                                                                              
            m_preset_bundle_dlg = nullptr;                                                                                                                                                                                                                                            
        }
        this->plater_->get_current_canvas3D()->force_set_focus();
        
    }
}

References m_preset_bundle_dlg, mainframe, open_presetbundledialog(), and plater_.

Referenced by open_presetbundledialog().

Here is the call graph for this function:

Here is the caller graph for this function:

open_publish_page_dialog()

void Slic3r::GUI::GUI_App::open_publish_page_dialog

(

)

{
    std::string host_url;
    std::string model_url;
    std::string link_url;
 
    int result = -1;
 
    //model api url
    host_url = get_model_http_url(app_config->get_country_code());
 
    //publish url
    wxString language_code = this->current_language_code().BeforeFirst('_');
    model_url += (language_code.ToStdString() + "/my/models/publish");
 
    if (getAgent() && mainframe) {
 
        //login already
        if (getAgent()->is_user_login()) {
            std::string ticket;
            result = getAgent()->request_bind_ticket(&ticket);
 
            if (result == 0) {
                link_url = host_url + "api/sign-in/ticket?to=" + host_url + url_encode(model_url) + "&ticket=" + ticket;
            }
        }
    }
 
    if (result < 0) {
        link_url = host_url + model_url;
    }
 
    wxLaunchDefaultBrowser(link_url);
}

References app_config, current_language_code(), get_model_http_url(), getAgent(), is_user_login(), mainframe, open_publish_page_dialog(), and url_encode().

Referenced by open_publish_page_dialog().

Here is the call graph for this function:

Here is the caller graph for this function:

open_speed_dial()

void Slic3r::GUI::GUI_App::open_speed_dial

(

)

{
    if (!mainframe)
        return;
    if (!m_speed_dial_dialog) {
        m_speed_dial_dialog = new SpeedDialWebDialog(mainframe);
        m_speed_dial_dialog->Bind(wxEVT_DESTROY, [this](wxWindowDestroyEvent& event) {
            if (event.GetEventObject() == m_speed_dial_dialog)
                m_speed_dial_dialog = nullptr;
            event.Skip();
        });
    }
    m_speed_dial_dialog->request_show();
}

References m_speed_dial_dialog, mainframe, and open_speed_dial().

Referenced by open_speed_dial().

Here is the call graph for this function:

Here is the caller graph for this function:

open_terminal_dialog()

void Slic3r::GUI::GUI_App::open_terminal_dialog

(

)

{
    // Reached from the plugins dialog's webview ("open_terminal" command), i.e. from
    // inside the webview script-message callback, which GTK/macOS deliver synchronously
    // (see ui_create_window in PluginHostUi.cpp). TerminalDialog hosts a webview of its
    // own, so creating or presenting it on that stack is the same class as the Linux
    // gtk_window_present crash — defer all window work to a clean main-loop iteration.
    CallAfter([this]() {
        if (m_terminal_dlg) {
            // Re-front the existing window; guard Show() per #13657 (GTK re-enters
            // layout when showing an already-visible window).
            if (!m_terminal_dlg->IsShown())
                m_terminal_dlg->Show();
            m_terminal_dlg->Raise();
            return;
        }
 
        m_terminal_dlg = new TerminalDialog(mainframe, wxID_ANY, _L("Plugin Terminal"),
                                            wxDefaultPosition, wxSize(820, 600));
        m_terminal_dlg->Bind(wxEVT_DESTROY, [this](wxWindowDestroyEvent& event) {
            if (event.GetEventObject() == m_terminal_dlg)
                m_terminal_dlg = nullptr;
            event.Skip();
        });
 
        // Show() alone activates and fronts a freshly created window on every platform.
        m_terminal_dlg->Show();
    });
}

References _L, m_terminal_dlg, mainframe, and open_terminal_dialog().

Referenced by open_terminal_dialog().

Here is the call graph for this function:

Here is the caller graph for this function:

open_web_page_localized()

void Slic3r::GUI::GUI_App::open_web_page_localized

(

const std::string &

http_address

)

{
    open_browser_with_warning_dialog(http_address + "&lng=" + this->current_language_code_safe());
}

References current_language_code_safe(), open_browser_with_warning_dialog(), and open_web_page_localized().

Referenced by open_web_page_localized().

Here is the call graph for this function:

Here is the caller graph for this function:

other_instance_message_handler()

OtherInstanceMessageHandler * Slic3r::GUI::GUI_App::other_instance_message_handler ( )

inline

{ return m_other_instance_message_handler.get(); }

References m_other_instance_message_handler.

Referenced by on_init_inner().

Here is the caller graph for this function:

params_dialog()

ParamsDialog * Slic3r::GUI::GUI_App::params_dialog

(

)

{
    if (mainframe)
        return mainframe->m_param_dialog;
    return nullptr;
}

References mainframe, and params_dialog().

Referenced by params_dialog().

Here is the call graph for this function:

Here is the caller graph for this function:

params_panel()

ParamsPanel * Slic3r::GUI::GUI_App::params_panel

(

)

{
    if (mainframe)
        return mainframe->m_param_panel;
    return nullptr;
}

References mainframe, and params_panel().

Referenced by params_panel().

Here is the call graph for this function:

Here is the caller graph for this function:

persist_window_geometry()

void Slic3r::GUI::GUI_App::persist_window_geometry	(	wxTopLevelWindow *	window,
		bool	default_maximized = false )

{
    const std::string name = into_u8(window->GetName());
 
    window->Bind(wxEVT_CLOSE_WINDOW, [=](wxCloseEvent &event) {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__<< ": received wxEVT_CLOSE_WINDOW, trigger save for window_mainframe";
        window_pos_save(window, "mainframe");
        event.Skip();
    });
 
    if (window_pos_restore(window, "mainframe", default_maximized)) {
        on_window_geometry(window, [=]() {
            window_pos_sanitize(window);
        });
    } else {
        on_window_geometry(window, [=]() {
            window_pos_center(window);
        });
    }
}

References Slic3r::GUI::into_u8(), Slic3r::GUI::on_window_geometry(), persist_window_geometry(), window_pos_center(), window_pos_restore(), window_pos_sanitize(), and window_pos_save().

Referenced by persist_window_geometry().

Here is the call graph for this function:

Here is the caller graph for this function:

plater() [1/2]

Plater * Slic3r::GUI::GUI_App::plater

(

)

{
    return plater_;
}

References plater(), and plater_.

Referenced by Slic3r::anonymous_namespace{PluginHostPresets.cpp}::bind_filament_target(), anonymous_namespace{EmbossJob.cpp}::create_volume(), Slic3r::GUI::GLGizmoEmboss::draw_model_type(), Slic3r::GUI::GLGizmoSVG::draw_model_type(), anonymous_namespace{EmbossJob.cpp}::CreateObjectJob::finalize(), init_plugin_gui_wiring(), install_local_plugin(), load_current_presets(), on_http_error(), on_init_inner(), on_shortcuts_changed(), plater(), plater(), post_init(), refresh_plugins(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::reload_local_bundle(), Slic3r::GUI::TextLinesModel::render(), request_open_project(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::require_gui_app(), Slic3r::GUI::ConfigWizard::run(), Slic3r::GUI::GuideFrame::run(), start_sync_user_preset(), sync_preset(), Slic3r::GUI::ProjectDirtyStateManager::update_from_presets(), update_mode(), and Slic3r::GUI::Emboss::UpdateJob::update_volume().

Here is the call graph for this function:

Here is the caller graph for this function:

plater() [2/2]

const Plater * Slic3r::GUI::GUI_App::plater

(

)

const

{
    return plater_;
}

References plater(), and plater_.

Here is the call graph for this function:

popup_ping_bind_dialog()

void Slic3r::GUI::GUI_App::popup_ping_bind_dialog

(

)

{
    if (m_ping_code_binding_dialog == nullptr) {
        m_ping_code_binding_dialog = new PingCodeBindDialog();
        m_ping_code_binding_dialog->ShowModal();
        remove_ping_bind_dialog();
    }
}

References m_ping_code_binding_dialog, popup_ping_bind_dialog(), and remove_ping_bind_dialog().

Referenced by popup_ping_bind_dialog().

Here is the call graph for this function:

Here is the caller graph for this function:

post_init()

void Slic3r::GUI::GUI_App::post_init

(

)

{
    assert(initialized());
    if (! this->initialized())
        throw Slic3r::RuntimeError("Calling post_init() while not yet initialized");
 
#if wxUSE_WEBVIEW_EDGE
    // Ensure the Microsoft WebView2 runtime is installed before any WebView is
    // created. The setup wizard and several dialogs render entirely through
    // WebView2; without the runtime they come up blank. This runs here (not in the
    // constructor) so that wxWidgets is fully initialized and the event loop is
    // running, and so it precedes the first WebView creation (the setup wizard).
    init_webview_runtime();
#endif
 
    m_open_method = "double_click";
    bool switch_to_3d = false;
 
    if (!this->init_params->input_files.empty()) {
 
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(", init with input files, size %1%, input_gcode %2%")
            %this->init_params->input_files.size() %this->init_params->input_gcode;
 
        switch_to_3d = true;
 
        const auto first_url = this->init_params->input_files.front();
        if (this->init_params->input_files.size() == 1 && is_supported_open_protocol(first_url)) {
            start_download(first_url);
            m_open_method = "url";
        } else {
            if (this->init_params->input_gcode) {
                mainframe->select_tab(TAB_ID_PREPARE);
                plater_->select_view_3D("3D");
                this->plater()->load_gcode(from_u8(this->init_params->input_files.front()));
                m_open_method = "gcode";
            } else {
                mainframe->select_tab(TAB_ID_PREPARE);
                plater_->select_view_3D("3D");
                wxArrayString input_files;
                for (auto& file : this->init_params->input_files) {
                    input_files.push_back(wxString::FromUTF8(file));
                }
                this->plater()->set_project_filename(_L("Untitled"));
                this->plater()->load_files(input_files);
                try {
                    if (!input_files.empty()) {
                        std::string           file_path = input_files.front().ToStdString();
                        std::filesystem::path path(file_path);
                        m_open_method = "file_" + path.extension().string();
                    }
                } catch (...) {
                    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ", file path exception!";
                    m_open_method = "file";
                }
            }
        }
    }
 
//#if BBL_HAS_FIRST_PAGE
    bool slow_bootup = false;
    if (app_config->get("slow_bootup") == "true") {
        slow_bootup = true;
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ", slow bootup, won't render gl here.";
    }
    // Starting on Home, the GL resources load at idle so Home paints first and Prepare is never
    // shown.
    const bool gl_at_idle = !starts_on_prepare() && is_editor();
    if (!switch_to_3d && gl_at_idle) {
        plater_->select_view_3D("3D");
    } else if (!switch_to_3d) {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ", begin load_gl_resources";
#ifndef __linux__
        mainframe->Freeze();
#endif
        plater_->canvas3D()->enable_render(false);
        mainframe->select_prepare_for_gl_init();
        plater_->select_view_3D("3D");
        //BBS init the opengl resource here
        if (!plater_->canvas3D()->get_wxglcanvas()->IsShownOnScreen() ||
            !plater_->canvas3D()->make_current_for_postinit()) {
            BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": glcontext not ready, postpone init";
            plater_->canvas3D()->enable_render(true);
            plater_->canvas3D()->set_as_dirty();
#ifdef __linux__
            // Wayland/EGL may not have committed the GL surface yet; ask the
            // idle loop to retry post_init when the canvas is actually mapped.
            // Without this, GL function pointers stay null and the first
            // Preview focus crashes in Camera::apply_viewport.
            m_post_initialized = false;
            return;
#endif
        } else {
            Size canvas_size = plater_->canvas3D()->get_canvas_size();
            wxGetApp().imgui()->set_display_size(static_cast<float>(canvas_size.get_width()), static_cast<float>(canvas_size.get_height()));
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ", start to init opengl";
            wxGetApp().init_opengl();
 
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ", finished init opengl";
            plater_->canvas3D()->init();
 
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ", finished init canvas3D";
            wxGetApp().imgui()->new_frame();
 
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ", finished init imgui frame";
            plater_->canvas3D()->enable_render(true);
 
            if (!slow_bootup) {
                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ", start to render a first frame for test";
                plater_->canvas3D()->render(false);
                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ", finished rendering a first frame for test";
            }
        }
        if (starts_on_prepare())
            mainframe->select_tab(TAB_ID_PREPARE);
#ifndef __linux__
        mainframe->Thaw();
#endif
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ", end load_gl_resources";
    }
 
    plater_->trigger_restore_project(1);
    //#endif
    mainframe->prebuild_pages_when_idle();
 
    //BBS: remove GCodeViewer as seperate APP logic
    /*if (this->init_params->start_as_gcodeviewer) {
        if (! this->init_params->input_files.empty())
            this->plater()->load_gcode(wxString::FromUTF8(this->init_params->input_files[0].c_str()));
    }
    else
    {
        if (! this->init_params->preset_substitutions.empty())
            show_substitutions_info(this->init_params->preset_substitutions);
 
#if 0
        // Load the cummulative config over the currently active profiles.
        //FIXME if multiple configs are loaded, only the last one will have an effect.
        // We need to decide what to do about loading of separate presets (just print preset, just filament preset etc).
        // As of now only the full configs are supported here.
        if (!m_print_config.empty())
            this->gui->mainframe->load_config(m_print_config);
#endif
        if (! this->init_params->load_configs.empty())
            // Load the last config to give it a name at the UI. The name of the preset may be later
            // changed by loading an AMF or 3MF.
            //FIXME this is not strictly correct, as one may pass a print/filament/printer profile here instead of a full config.
            this->mainframe->load_config_file(this->init_params->load_configs.back());
        // If loading a 3MF file, the config is loaded from the last one.
        if (!this->init_params->input_files.empty()) {
            const std::vector<size_t> res = this->plater()->load_files(this->init_params->input_files);
            if (!res.empty() && this->init_params->input_files.size() == 1) {
                // Update application titlebar when opening a project file
                const std::string& filename = this->init_params->input_files.front();
                //BBS: remove amf logic as project
                if (boost::algorithm::iends_with(filename, ".3mf"))
                    this->plater()->set_project_filename(filename);
            }
        }
        if (! this->init_params->extra_config.empty())
            this->mainframe->load_config(this->init_params->extra_config);
    }*/
 
    // BBS: to be checked
#if 1
    // show "Did you know" notification
    if (app_config->get("show_hints") == "true" && !is_gcode_viewer()) {
        plater_->get_notification_manager()->push_hint_notification(false);
    }
#endif
 
    hms_query = new HMSQuery();
 
    m_show_gcode_window = app_config->get_bool("show_gcode_window");
    if (m_networking_need_update) {
        show_network_plugin_download_dialog(false);
    }
 
    // Start preset sync after project opened, otherwise we could have preset change during project opening which could cause crash 
    if (app_config->get("sync_user_preset") == "true") {
        // BBS loading user preset
        // Always async, not such startup step
        // BOOST_LOG_TRIVIAL(info) << "Loading user presets...";
        // scrn->SetText(_L("Loading user presets..."));
        if (m_agent) {
            start_sync_user_preset();
        }
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " sync_user_preset: true";
    } else {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " sync_user_preset: false";
    }
 
    // The extra CallAfter() is needed because of Mac, where this is the only way
    // to popup a modal dialog on start without screwing combo boxes.
    // This is ugly but I honestly found no better way to do it.
    // Neither wxShowEvent nor wxWindowCreateEvent work reliably.
    if (this->preset_updater) { // G-Code Viewer does not initialize preset_updater.
        CallAfter([this] {
            bool cw_showed = this->config_wizard_startup();
 
            if (!app_config->get_stealth_mode()) {
                std::string http_url = get_http_url(app_config->get_country_code());
                std::string language = GUI::into_u8(current_language_code());
                std::string network_ver = Slic3r::NetworkAgent::get_version();
                bool        sys_preset  = app_config->get("sync_system_preset") == "true";
                this->preset_updater->sync(http_url, language, network_ver, sys_preset ? preset_bundle : nullptr);
            }
 
            this->check_new_version_sf();
            if (!cw_showed)
                this->check_legacy_user_filament_presets(false);
            const auto cloud_provider = get_printer_cloud_provider();
            if (is_user_login(cloud_provider) && !app_config->get_stealth_mode()) {
              // this->check_privacy_version(0);
              request_user_handle(0, cloud_provider);
            }
        });
    }
 
    // Orca: notify users upgrading from a pre-2.4.0 version that profile syncing
    // moved from Bambu Cloud to Orca Cloud.
    if (is_editor() && m_last_config_version && m_last_config_version->valid()
        && *m_last_config_version < Semver(2, 4, 0)) {
        CallAfter([] {
            const wxString wiki_url = "https://www.orcaslicer.com/wiki/user_profiles/user_profiles.html#profiles-missing-after-updating-from-bambu-cloud";
            MessageDialog dlg(nullptr,
                _L("Since version 2.4.0, OrcaSlicer syncs user profiles through Orca Cloud instead of Bambu Cloud.\n\n"
                   "To migrate your existing profiles, log in to Orca Cloud and they will be transferred automatically. "
                   "To learn more about how OrcaSlicer stores and syncs your profiles, or to migrate your presets manually, check out our wiki.\n\n"
                   "If you did not use Bambu Cloud to sync profiles, this change does not affect you and you can safely ignore this message."),
                _L("Profile syncing change"),
                wxOK,
                "",
                _L("Learn more"),
                [wiki_url](const wxString &) { wxLaunchDefaultBrowser(wiki_url); });
            // Hack: the "Learn more" link renders the message in a wxHtmlWindow whose
            // height is underestimated for multi-paragraph text, leaving a scrollbar.
            // The html sits in a proportion-1 sizer chain, so grow the dialog (never
            // shrink it below its content width) to give the text enough room.
            const wxSize sz = dlg.GetSize();
            dlg.SetSize(std::max(sz.x, dlg.FromDIP(280)), std::max(sz.y, dlg.FromDIP(200)));
            dlg.CenterOnParent();
            dlg.ShowModal();
        });
    }
 
    if(!m_networking_need_update && m_agent) {
        m_agent->set_on_ssdp_msg_fn(
            [this](std::string json_str) {
                if (!is_closing() && m_device_manager)
                    m_device_manager->on_machine_alive(json_str);
            }
        );
        m_agent->set_on_http_error_fn([this](CloudEvent event, unsigned int status, std::string body) {
            this->handle_http_error(status, body, event.provider);
        });
        m_agent->start_discovery(true, false);
    }
 
    //update the plugin tips
    CallAfter([this] {
            mainframe->refresh_plugin_tips();
        });
 
    // remove old log files over LOG_FILES_MAX_NUM
    std::string log_addr = data_dir();
    if (!log_addr.empty()) {
        auto log_folder = boost::filesystem::path(log_addr) / "log";
        if (boost::filesystem::exists(log_folder)) {
           std::vector<std::pair<time_t, std::string>> files_vec;
           for (auto& it : boost::filesystem::directory_iterator(log_folder)) {
               auto temp_path = it.path();
               try {
                   if (it.status().type() == boost::filesystem::regular_file) {
                       std::time_t lw_t = boost::filesystem::last_write_time(temp_path) ;
                       files_vec.push_back({ lw_t, temp_path.filename().string() });
                   }
               } catch (const std::exception &) {
               }
           }
           std::sort(files_vec.begin(), files_vec.end(), [](
               std::pair<time_t, std::string> &a, std::pair<time_t, std::string> &b) {
               return a.first > b.first;
           });
 
           while (files_vec.size() > LOG_FILES_MAX_NUM) {
               auto full_path = log_folder / boost::filesystem::path(files_vec[files_vec.size() - 1].second);
               BOOST_LOG_TRIVIAL(info) << "delete log file over " << LOG_FILES_MAX_NUM << ", filename: "<< files_vec[files_vec.size() - 1].second;
               try {
                   boost::filesystem::remove(full_path);
               }
               catch (const std::exception& ex) {
                   BOOST_LOG_TRIVIAL(error) << "failed to delete log file: "<< files_vec[files_vec.size() - 1].second << ". Error: " << ex.what();
               }
               files_vec.pop_back();
           }
        }
    }
    BOOST_LOG_TRIVIAL(info) << "finished post_init";
//BBS: remove the single instance currently
#ifdef _WIN32
    // Sets window property to mainframe so other instances can indentify it.
    OtherInstanceMessageHandler::init_windows_properties(mainframe, m_instance_hash_int);
#endif //WIN32
}

References _L, app_config, check_legacy_user_filament_presets(), check_new_version_sf(), config_wizard_startup(), current_language_code(), Slic3r::data_dir(), Slic3r::GUI::from_u8(), Slic3r::GUI::Size::get_height(), get_http_url(), get_printer_cloud_provider(), Slic3r::NetworkAgent::get_version(), Slic3r::GUI::Size::get_width(), handle_http_error(), hms_query, init_params, initialized(), Slic3r::GUI::into_u8(), is_closing(), is_editor(), is_gcode_viewer(), Slic3r::is_supported_open_protocol(), is_user_login(), Slic3r::GUI::Plater::load_files(), Slic3r::GUI::Plater::load_gcode(), LOG_FILES_MAX_NUM, m_agent, m_device_manager, m_instance_hash_int, m_last_config_version, m_networking_need_update, m_open_method, m_post_initialized, m_show_gcode_window, mainframe, plater(), plater_, preset_bundle, preset_updater, Slic3r::CloudEvent::provider, request_user_handle(), Slic3r::GUI::Plater::set_project_filename(), show_network_plugin_download_dialog(), Slic3r::GUI::DPIAware< P >::ShowModal(), start_download(), start_sync_user_preset(), starts_on_prepare(), and TAB_ID_PREPARE.

Referenced by on_init_inner().

Here is the call graph for this function:

Here is the caller graph for this function:

post_logout_to_webview()

void Slic3r::GUI::GUI_App::post_logout_to_webview

(

const std::string &

provider

)

{
    std::string logout_cmd = m_agent->build_logout_cmd(provider);
    if (!logout_cmd.empty()) {
        wxString strJS = wxString::Format("window.postMessage(%s)", logout_cmd);
        GUI::wxGetApp().run_script(strJS);
    }
}

References m_agent, and post_logout_to_webview().

Referenced by post_logout_to_webview(), request_user_logout(), and show_check_privacy_dlg().

Here is the call graph for this function:

Here is the caller graph for this function:

preset_deleted_from_cloud()

void Slic3r::GUI::GUI_App::preset_deleted_from_cloud

(

std::string

setting_id

)

{
    std::scoped_lock l(mutex_delete_cache_presets);
 
    // Get the preset info path BEFORE erasing from the map
    std::string preset_file_path = need_delete_presets[setting_id];
 
    // Delete the .info file after cloud deletion is confirmed
    if (!preset_file_path.empty() && fs::exists(fs::path(preset_file_path))) {
        InstanceLock instance_lock(user_presets_lock_path());
        boost::nowide::remove(preset_file_path.c_str());
        BOOST_LOG_TRIVIAL(info) << "Deleted .info file after cloud confirmation: " << preset_file_path;
    }
 
    // Now erase from map
    need_delete_presets.erase(setting_id);
}

References Slic3r::GUI::mutex_delete_cache_presets, need_delete_presets, preset_deleted_from_cloud(), and Slic3r::user_presets_lock_path().

Referenced by preset_deleted_from_cloud(), and process_delete_presets().

Here is the call graph for this function:

Here is the caller graph for this function:

printhost_job_queue()

PrintHostJobQueue & Slic3r::GUI::GUI_App::printhost_job_queue ( )

inline

{ return *m_printhost_job_queue.get(); }

References m_printhost_job_queue.

process_delete_presets()

void Slic3r::GUI::GUI_App::process_delete_presets

(

)

{
    std::map<std::string, std::string> delete_cache_presets = get_delete_cache_presets_lock();
    for (auto it = delete_cache_presets.begin(); it != delete_cache_presets.end();) {
        if (it->first.empty()) continue;
        std::string del_setting_id = it->first;
        int result = m_agent->delete_setting(del_setting_id);
        if (result == 0) {
            preset_deleted_from_cloud(del_setting_id);
            it = delete_cache_presets.erase(it);
            m_create_preset_blocked = { false, false, false, false, false, false };
            BOOST_LOG_TRIVIAL(trace) << "sync_preset: sync operation: delete success! setting id = " << del_setting_id;
        }
        else {
            BOOST_LOG_TRIVIAL(info) << "delete setting = " <<del_setting_id << " failed";
            it++;
        }
    }
}

References get_delete_cache_presets_lock(), m_agent, m_create_preset_blocked, preset_deleted_from_cloud(), process_delete_presets(), and Slic3r::trace().

Referenced by process_delete_presets(), and start_sync_user_preset().

Here is the call graph for this function:

Here is the caller graph for this function:

process_network_msg()

bool Slic3r::GUI::GUI_App::process_network_msg	(	std::string	dev_id,
		std::string	msg )

{
    if (dev_id.empty()) {
        if (msg == "wait_info") {
            BOOST_LOG_TRIVIAL(info) << "process_network_msg, wait_info";
            Slic3r::DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager();
            if (!dev)
                return true;
            MachineObject* obj = dev->get_selected_machine();
            if (obj && m_agent)
                m_agent->install_device_cert(obj->get_dev_id(), obj->is_lan_mode_printer());
            if (!m_show_error_msgdlg) {
                MessageDialog msg_dlg(nullptr, _L("Retrieving printer information, please try again later."), "", wxAPPLY | wxOK);
                m_show_error_msgdlg = true;
                msg_dlg.ShowModal();
                m_show_error_msgdlg = false;
            }
            return true;
        }
        else if (msg == "update_studio") {
            BOOST_LOG_TRIVIAL(info) << "process_network_msg, update_studio";
            if (!m_show_error_msgdlg) {
                MessageDialog msg_dlg(nullptr, _L("Please try updating OrcaSlicer and then try again."), "", wxAPPLY | wxOK);
                m_show_error_msgdlg = true;
                msg_dlg.ShowModal();
                m_show_error_msgdlg = false;
            }
            return true;
        }
        else if (msg == "update_fixed_studio") {
            BOOST_LOG_TRIVIAL(info) << "process_network_msg, update_fixed_studio";
            if (!m_show_error_msgdlg) {
                MessageDialog msg_dlg(nullptr, _L("Please try updating OrcaSlicer and then try again."), "", wxAPPLY | wxOK);
                m_show_error_msgdlg = true;
                msg_dlg.ShowModal();
                m_show_error_msgdlg = false;
            }
            return true;
        }
        else if (msg == "cert_expired") {
            BOOST_LOG_TRIVIAL(info) << "process_network_msg, cert_expired";
            if (!m_show_error_msgdlg) {
                MessageDialog msg_dlg(nullptr, _L("The certificate has expired. Please check the time settings or update OrcaSlicer and try again."), "", wxAPPLY | wxOK);
                m_show_error_msgdlg = true;
                msg_dlg.ShowModal();
                m_show_error_msgdlg = false;
            }
            return true;
        }
        else if (msg == "cert_revoked") {
            BOOST_LOG_TRIVIAL(info) << "process_network_msg, cert_revoked";
            if (!m_show_error_msgdlg) {
                MessageDialog msg_dlg(nullptr, _L("The certificate is no longer valid and the printing functions are unavailable."), "", wxAPPLY | wxOK);
                m_show_error_msgdlg = true;
                msg_dlg.ShowModal();
                m_show_error_msgdlg = false;
            }
            return true;
        }
        else if (msg == "update_firmware_studio") {
            BOOST_LOG_TRIVIAL(info) << "process_network_msg, firmware internal error";
            if (!m_show_error_msgdlg) {
                MessageDialog msg_dlg(nullptr, _L("Internal error. Please try upgrading the firmware and OrcaSlicer version. If the issue persists, contact support."), "", wxAPPLY | wxOK);
                m_show_error_msgdlg = true;
                msg_dlg.ShowModal();
                m_show_error_msgdlg = false;
            }
            return true;
        }
        else if (msg == "unsigned_studio") {
            BOOST_LOG_TRIVIAL(info) << "process_network_msg, unsigned_studio";
            // Plugin re-emits this on every subscribe retry; latch it so it shows
            // once per connection episode.
            if (!m_show_error_msgdlg && !m_unsigned_plugin_warning_shown) {
                m_unsigned_plugin_warning_shown = true;
                MessageDialog
                    msg_dlg(nullptr,
                            _L("To use OrcaSlicer with Bambu Lab printers, you need to enable LAN mode and Developer mode on your printer.\n\n"
                               "Please go to your printer's settings and:\n"
                               "1. Turn on LAN mode\n"
                               "2. Enable Developer mode\n\n"
                               "Developer mode allows the printer to work exclusively through local network access, "
                               "enabling full functionality with OrcaSlicer."),
                            _L("Network Plug-in Restriction"), wxAPPLY | wxOK);
                m_show_error_msgdlg = true;
                msg_dlg.ShowModal();
                m_show_error_msgdlg = false;
            }
            return true;
        }
    }
    else if (msg == "device_cert_installed") {
        BOOST_LOG_TRIVIAL(info) << "process_network_msg, device_cert_installed";
        if (Slic3r::DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager()) {
            if (MachineObject* obj = dev->get_my_machine(dev_id)) {
                obj->update_device_cert_state(true);
            }
        }
        return true;
    }
    else if (msg == "device_cert_uninstalled") {
        BOOST_LOG_TRIVIAL(info) << "process_network_msg, device_cert_uninstalled";
        if (Slic3r::DeviceManager *dev = Slic3r::GUI::wxGetApp().getDeviceManager()) {
            if (MachineObject* obj = dev->get_my_machine(dev_id)){
                obj->update_device_cert_state(false);
            }
        }
        return true;
    }
 
    return false;
}

References _L, Slic3r::MachineObject::get_dev_id(), Slic3r::DeviceManager::get_selected_machine(), getDeviceManager(), Slic3r::MachineObject::is_lan_mode_printer(), m_agent, m_show_error_msgdlg, m_unsigned_plugin_warning_shown, process_network_msg(), and Slic3r::GUI::DPIAware< P >::ShowModal().

Referenced by process_network_msg().

Here is the call graph for this function:

Here is the caller graph for this function:

push_notification()

void Slic3r::GUI::GUI_App::push_notification	(	const MachineObject *	obj,
		wxString	msg,
		wxString	title = wxEmptyString,
		UserNotificationStyle	style = UserNotificationStyle::UNS_NORMAL )

{
    if (this->is_enable_multi_machine())
    {
        if (m_device_manager && (obj != m_device_manager->get_selected_machine()))
        {
            return;
        }
    }
 
    if (style == UserNotificationStyle::UNS_NORMAL)
    {
        if (m_info_dialog_content.empty())
        {
            wxCommandEvent* evt = new wxCommandEvent(EVT_SHOW_DIALOG);
            evt->SetString(msg);
            GUI::wxGetApp().QueueEvent(evt);
            m_info_dialog_content = msg;
        }
    }
    else if (style == UserNotificationStyle::UNS_WARNING_CONFIRM)
    {
        GUI::wxGetApp().CallAfter([msg, title]
            {
                GUI::MessageDialog msg_dlg(nullptr, msg, title, wxICON_WARNING | wxOK);
                msg_dlg.ShowModal();
            });
    }
}

References is_enable_multi_machine(), m_device_manager, m_info_dialog_content, push_notification(), Slic3r::GUI::DPIAware< P >::ShowModal(), style, Slic3r::UNS_NORMAL, and Slic3r::UNS_WARNING_CONFIRM.

Referenced by push_notification().

Here is the call graph for this function:

Here is the caller graph for this function:

recreate_GUI()

void Slic3r::GUI::GUI_App::recreate_GUI

(

const wxString &

message

)

{
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << "recreate_GUI enter";
    m_is_recreating_gui = true;
 
    // The palette injects its translated strings once, at creation; drop the cached dialog so the
    // next open rebuilds it in the current locale (and can't outlive the old mainframe).
    if (m_speed_dial_dialog) {
        m_speed_dial_dialog->Destroy();
        m_speed_dial_dialog = nullptr;
    }
 
    mainframe->shutdown();
    ProgressDialog dlg(msg_name, msg_name, 100, nullptr, wxPD_AUTO_HIDE);
    dlg.Pulse();
    dlg.Update(10, _L("Rebuild") + dots);
 
    MainFrame *old_main_frame = mainframe;
    struct ClientData : wxClientData
    {
        ~ClientData() { release_window_pools(); }
    };
    old_main_frame->SetClientObject(new ClientData);
 
    switch_window_pools();
    mainframe = new MainFrame();
    if (is_editor())
        // hide settings tabs after first Layout
        mainframe->select_tab(TAB_ID_PREPARE);
    // Propagate model objects to object list.
    sidebar().obj_list()->init();
    //sidebar().aux_list()->init_auxiliary();
    //mainframe->m_auxiliary->init_auxiliary();
    SetTopWindow(mainframe);
 
    dlg.Update(30, _L("Rebuild") + dots);
    old_main_frame->Destroy();
 
    dlg.Update(80, _L("Loading current presets") + dots);
    m_printhost_job_queue.reset(new PrintHostJobQueue(mainframe->printhost_queue_dlg()));
    load_current_presets();
    mainframe->Show(true);
    //mainframe->refresh_plugin_tips();
 
    dlg.Update(90, _L("Loading a mode view") + dots);
 
    obj_list()->set_min_height();
    update_mode();
 
    // clear previous hms query, so that the hms info can use different language
    if (hms_query) hms_query->clear_hms_info();
 
    //BBS: trigger restore project logic here, and skip confirm
    plater_->trigger_restore_project(1);
    mainframe->prebuild_pages_when_idle();
 
    // #ys_FIXME_delete_after_testing  Do we still need this  ?
//     CallAfter([]() {
//         // Run the config wizard, don't offer the "reset user profile" checkbox.
//         config_wizard_startup(true);
//     });
 
 
    update_publish_status();
 
    m_is_recreating_gui = false;
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << "recreate_GUI exit";
}

References _L, Slic3r::GUI::dots(), hms_query, is_editor(), load_current_presets(), m_is_recreating_gui, m_printhost_job_queue, m_speed_dial_dialog, mainframe, obj_list(), plater_, Slic3r::GUI::ProgressDialog::Pulse(), recreate_GUI(), Slic3r::GUI::release_window_pools(), sidebar(), Slic3r::GUI::switch_window_pools(), TAB_ID_PREPARE, Slic3r::GUI::ProgressDialog::Update(), update_mode(), and update_publish_status().

Referenced by open_preferences(), and recreate_GUI().

Here is the call graph for this function:

Here is the caller graph for this function:

refresh_plugins()

void Slic3r::GUI::GUI_App::refresh_plugins

(

)

{
    // The metadata refresh blocks on disc discovery and a cloud round-trip, so run it on a worker
    // and report completion through the notification manager -- the speed dial needs no dialog.
    std::thread([]() {
        wxString error;
        bool unknown_error = false;
        try {
            refresh_plugin_metadata_blocking(/*fetch_cloud=*/true);
        } catch (const std::exception& ex) {
            error = from_u8(ex.what());
        } catch (...) {
            unknown_error = true; // translated in CallAfter: wx translation isn't safe off the UI thread
        }
        if (!wxTheApp)
            return;
        wxTheApp->CallAfter([error, unknown_error]() {
            if (wxGetApp().is_closing())
                return;
            Plater* plater = wxGetApp().plater();
            if (plater == nullptr)
                return;
            if (error.IsEmpty() && !unknown_error)
                plater->get_notification_manager()->push_notification(
                    NotificationType::CustomNotification,
                    NotificationManager::NotificationLevel::RegularNotificationLevel,
                    into_u8(_L("Plugins refreshed.")));
            else
                plater->get_notification_manager()->push_notification(
                    NotificationType::CustomNotification,
                    NotificationManager::NotificationLevel::ErrorNotificationLevel,
                    into_u8(wxString::Format(_L("Failed to refresh plugins: %s"), unknown_error ? _L("Unknown error") : error)));
        });
    }).detach();
}

References _L, Slic3r::GUI::CustomNotification, Slic3r::GUI::NotificationManager::ErrorNotificationLevel, Slic3r::GUI::from_u8(), Slic3r::GUI::into_u8(), is_closing(), plater(), Slic3r::GUI::refresh_plugin_metadata_blocking(), refresh_plugins(), and Slic3r::GUI::NotificationManager::RegularNotificationLevel.

Referenced by refresh_plugins().

Here is the call graph for this function:

Here is the caller graph for this function:

refresh_printer_agent_dropdown()

void Slic3r::GUI::GUI_App::refresh_printer_agent_dropdown ( )

private

{
    if (Tab* tab = get_tab(Preset::TYPE_PRINTER))
    {
        if (auto* printer_tab = dynamic_cast<TabPrinter*>(tab))
            printer_tab->refresh_printer_agent_dropdown();
    }
}

References get_tab(), refresh_printer_agent_dropdown(), and Slic3r::Preset::TYPE_PRINTER.

Referenced by init_plugin_gui_wiring(), and refresh_printer_agent_dropdown().

Here is the call graph for this function:

Here is the caller graph for this function:

reload_settings()

bool Slic3r::GUI::GUI_App::reload_settings

(

)

{
    if (preset_bundle && m_agent) {
        // Load user's personal presets
        std::map<std::string, std::map<std::string, std::string>> user_presets;
        int result = m_agent->get_user_presets(&user_presets);
        if (result != 0) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": get_user_presets failed with code " << result << ", skipping sync";
            return false;
        }
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << __LINE__ << " cloud user preset number is: " << user_presets.size();
        auto refresh_synced_ui = [this, user_presets = std::move(user_presets)]() mutable {
            if (is_closing() || !preset_bundle || !app_config || !mainframe)
                return;
 
            // Snapshot each collection's edited config BEFORE any mutation.
            // load_pending_vendors() via apply_vendor_config() can call select_preset(0)
            // resetting all selections to defaults and overwriting m_edited_preset.
            // The cloud load_user_presets() can also trigger select_preset() via
            // remove_users_preset() and overwrite m_edited_preset.config via load_user_preset().
            struct PresetSnapshot { std::string name; DynamicPrintConfig config; bool dirty; };
            auto snapshot_collection = [](const PresetCollection& col) -> PresetSnapshot {
                auto& sel = col.get_selected_preset();
                auto& ed  = col.get_edited_preset();
                return {sel.name, ed.config, sel.is_dirty};
            };
            PresetSnapshot print_snap    = snapshot_collection(preset_bundle->prints);
            PresetSnapshot filament_snap = snapshot_collection(preset_bundle->filaments);
            PresetSnapshot printer_snap  = snapshot_collection(preset_bundle->printers);
 
            // Check the user presets for any system vendors that need to be installed
            for (auto data : user_presets) {
                if (!check_preset_parent_available(data))
                    add_pending_vendor_preset(data);
            }
            load_pending_vendors();
 
            preset_bundle->load_user_presets(*app_config, user_presets, ForwardCompatibilitySubstitutionRule::Enable);
            preset_bundle->save_user_presets(*app_config, get_delete_cache_presets());
 
            // Re-apply any edited config that was wiped during vendor loading or sync.
            auto restore_snapshot = [](PresetCollection& col, const PresetSnapshot& snap, const char* label) {
                auto& ed = col.get_edited_preset();
                bool changed = !ed.config.equals(snap.config);
                BOOST_LOG_TRIVIAL(info) << "reload_settings restore " << label
                    << ": snap_name=" << snap.name << " snap_dirty=" << snap.dirty
                    << " current_name=" << ed.name << " changed=" << changed;
                if (!snap.dirty) return; // nothing to protect, let cloud updates stand
                Preset* p = col.find_preset(snap.name, false, true);
                if (p && p->name == snap.name) {
                    BOOST_LOG_TRIVIAL(info) << "reload_settings RESTORING " << label
                        << ": name=" << snap.name;
                    // If the snapshot preset is not currently selected, re-select it first.
                    if (col.get_selected_preset().name != snap.name)
                        col.select_preset_by_name(snap.name, true);
                    ed = col.get_edited_preset();
                    ed.config = snap.config;
                    col.get_selected_preset().is_dirty = snap.dirty;
                    ed.is_dirty = snap.dirty;
                } else {
                    BOOST_LOG_TRIVIAL(info) << "reload_settings restore " << label
                        << ": preset not found name=" << snap.name;
                }
            };
            restore_snapshot(preset_bundle->prints, print_snap, "print");
            restore_snapshot(preset_bundle->filaments, filament_snap, "filament");
            restore_snapshot(preset_bundle->printers, printer_snap, "printer");
 
            // Orca: settings changed, refresh ui to reflect the new preset values
            mainframe->update_side_preset_ui();
            for (auto tab : tabs_list) {
                tab->reload_config();
                tab->update_changed_ui();
            }
            if (plater_) {
                plater_->sidebar().update_all_preset_comboboxes();
                plater_->normalize_bed_types(false);
            }
        };
        if (is_main_thread_active())
            refresh_synced_ui();
        else
            CallAfter(refresh_synced_ui);
        return true;
    }
    return false;
}

References add_pending_vendor_preset(), app_config, check_preset_parent_available(), Slic3r::Preset::config, Slic3r::Enable, Slic3r::DynamicConfig::equals(), Slic3r::PresetCollection::find_preset(), get_delete_cache_presets(), Slic3r::PresetCollection::get_edited_preset(), Slic3r::PresetCollection::get_selected_preset(), is_closing(), Slic3r::Preset::is_dirty, Slic3r::is_main_thread_active(), load_pending_vendors(), m_agent, mainframe, Slic3r::Preset::name, plater_, preset_bundle, reload_settings(), Slic3r::PresetCollection::select_preset_by_name(), and tabs_list.

Referenced by reload_settings(), and start_sync_user_preset().

Here is the call graph for this function:

Here is the caller graph for this function:

removable_drive_manager()

RemovableDriveManager * Slic3r::GUI::GUI_App::removable_drive_manager ( )

inline

{ return m_removable_drive_manager.get(); }

References m_removable_drive_manager.

Referenced by shutdown().

Here is the caller graph for this function:

remove_mall_system_dialog()

void Slic3r::GUI::GUI_App::remove_mall_system_dialog

(

)

{
    if (m_mall_publish_dialog != nullptr) {
        m_mall_publish_dialog->Destroy();
        delete m_mall_publish_dialog;
    }
}

References m_mall_publish_dialog, and remove_mall_system_dialog().

Referenced by remove_mall_system_dialog().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_old_networking_plugins()

void Slic3r::GUI::GUI_App::remove_old_networking_plugins ( )

private

{
    std::string data_dir_str = data_dir();
    boost::filesystem::path data_dir_path(data_dir_str);
    auto plugin_folder = data_dir_path / "plugins";
    //auto plugin_folder = boost::filesystem::path(wxStandardPaths::Get().GetUserDataDir().ToUTF8().data()) / "plugins";
    if (boost::filesystem::exists(plugin_folder)) {
        BOOST_LOG_TRIVIAL(info) << "[remove_old_networking_plugins] remove the directory "<<plugin_folder.string();
        try {
            fs::remove_all(plugin_folder);
        } catch (...) {
            BOOST_LOG_TRIVIAL(error) << "Failed  removing the plugins directory " << plugin_folder.string();
        }
    }
}

References Slic3r::data_dir().

Here is the call graph for this function:

remove_ping_bind_dialog()

void Slic3r::GUI::GUI_App::remove_ping_bind_dialog

(

)

{
    if (m_ping_code_binding_dialog != nullptr) {
        m_ping_code_binding_dialog->Destroy();
        delete m_mall_publish_dialog;
        m_ping_code_binding_dialog = nullptr;
    }
}

References m_mall_publish_dialog, m_ping_code_binding_dialog, and remove_ping_bind_dialog().

Referenced by popup_ping_bind_dialog(), and remove_ping_bind_dialog().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_user_presets()

void Slic3r::GUI::GUI_App::remove_user_presets

(

)

{
    if (preset_bundle && m_agent) {
        preset_bundle->remove_users_preset(*app_config);
 
        // Not remove user preset cache
        //std::string user_id = m_agent->get_user_id();
        //preset_bundle->remove_user_presets_directory(user_id);
 
        //update ui
        mainframe->update_side_preset_ui();
    }
}

References app_config, m_agent, mainframe, preset_bundle, and remove_user_presets().

Referenced by on_user_login_handle(), remove_user_presets(), request_user_logout(), and restart_networking().

Here is the call graph for this function:

Here is the caller graph for this function:

request_cloud_web_session()

void Slic3r::GUI::GUI_App::request_cloud_web_session

(

const std::string &

state

)

{
    if (state.empty())
        return;
 
    // Only the newest request counts: a newer state supersedes any mint or login still in flight.
    m_cloud_handoff_state = state;
    const uint64_t gen    = ++m_cloud_handoff_gen;
 
    auto orca = get_orca_cloud_agent(m_agent);
    if (!orca || !orca->is_user_login()) {
        // Desktop signed out: open the desktop login dialog and stop here. On success
        // on_user_login_handle reloads the Start URL, which makes the page request again; on
        // cancel nothing happens (the guide's "on cancel, do nothing"). The newest state is
        // already stored, so a repeat request while the dialog is open is dropped rather than
        // stacking another dialog.
        if (!login_dlg || !login_dlg->IsShown())
            request_login(true, ORCA_CLOUD_PROVIDER);
        return;
    }
 
    mint_cloud_web_session(state, gen);
}

References Slic3r::GUI::get_orca_cloud_agent(), login_dlg, m_agent, m_cloud_handoff_gen, m_cloud_handoff_state, mint_cloud_web_session(), Slic3r::ORCA_CLOUD_PROVIDER(), request_cloud_web_session(), and request_login().

Referenced by request_cloud_web_session().

Here is the call graph for this function:

Here is the caller graph for this function:

request_login()

void Slic3r::GUI::GUI_App::request_login	(	bool	show_user_info = false,
		const std::string &	provider = ORCA_CLOUD_PROVIDER )

{
    ShowUserLogin(true, provider);
 
    if (show_user_info) {
        CallAfter([this, provider] {
            get_login_info(provider);
        });
    }
}

References get_login_info(), request_login(), and ShowUserLogin().

Referenced by handle_web_request(), request_cloud_web_session(), and request_login().

Here is the call graph for this function:

Here is the caller graph for this function:

request_model_download()

void Slic3r::GUI::GUI_App::request_model_download

(

wxString

url

)

{
    if (plater_) {
        plater_->request_model_download(url);
    }
}

References plater_, and request_model_download().

Referenced by request_model_download().

Here is the call graph for this function:

Here is the caller graph for this function:

request_new_version()

void Slic3r::GUI::GUI_App::request_new_version

(

int

by_user

)

{
    wxCommandEvent* evt = new wxCommandEvent(EVT_SLIC3R_VERSION_ONLINE);
    evt->SetString(GUI::from_u8(version_info.version_str));
    evt->SetInt(by_user);
    GUI::wxGetApp().QueueEvent(evt);
}

References Slic3r::GUI::from_u8(), request_new_version(), and version_info.

Referenced by request_new_version().

Here is the call graph for this function:

Here is the caller graph for this function:

request_open_project()

void Slic3r::GUI::GUI_App::request_open_project

(

std::string

project_id

)

{
    if (plater()->is_background_process_slicing()) {
        Slic3r::GUI::show_info(nullptr, _L("new or open project file is not allowed during the slicing process!"), _L("Open Project"));
        return;
    }
 
    if (project_id == "<new>")
        plater()->new_project();
    else if (project_id.empty())
        plater()->load_project();
    else if (std::find_if_not(project_id.begin(), project_id.end(),
        [](char c) { return std::isdigit(c); }) == project_id.end())
        ;
    else if (boost::algorithm::starts_with(project_id, "http"))
        ;
    else
        CallAfter([this, project_id] { mainframe->open_recent_project(-1, wxString::FromUTF8(project_id)); });
}

References _L, mainframe, plater(), request_open_project(), and Slic3r::GUI::show_info().

Referenced by handle_web_request(), and request_open_project().

Here is the call graph for this function:

Here is the caller graph for this function:

request_project_download()

void Slic3r::GUI::GUI_App::request_project_download

(

std::string

project_id

)

{
    if (!check_login()) return;
 
    download_project(project_id);
}

References check_login(), download_project(), and request_project_download().

Referenced by handle_web_request(), and request_project_download().

Here is the call graph for this function:

Here is the caller graph for this function:

request_remove_project()

void Slic3r::GUI::GUI_App::request_remove_project

(

std::string

project_id

)

{
    mainframe->remove_recent_project(-1, wxString::FromUTF8(project_id));
}

References mainframe, and request_remove_project().

Referenced by handle_web_request(), and request_remove_project().

Here is the call graph for this function:

Here is the caller graph for this function:

request_user_handle()

void Slic3r::GUI::GUI_App::request_user_handle	(	int	online_login = 0,
		const std::string &	provider = ORCA_CLOUD_PROVIDER )

{
    auto evt = new wxCommandEvent(EVT_USER_LOGIN_HANDLE);
    evt->SetInt(online_login);
    evt->SetString(wxString::FromUTF8(provider));
    wxQueueEvent(this, evt);
}

References request_user_handle().

Referenced by check_privacy_version(), on_check_privacy_update(), post_init(), request_user_handle(), and show_check_privacy_dlg().

Here is the call graph for this function:

Here is the caller graph for this function:

request_user_login()

void Slic3r::GUI::GUI_App::request_user_login	(	int	online_login = 0,
		const std::string &	provider = ORCA_CLOUD_PROVIDER )

{
    auto evt = new wxCommandEvent(EVT_USER_LOGIN);
    evt->SetInt(online_login);
    evt->SetString(wxString::FromUTF8(provider));
    wxQueueEvent(this, evt);
}

References request_user_login().

Referenced by handle_script_message(), and request_user_login().

Here is the call graph for this function:

Here is the caller graph for this function:

request_user_logout()

void Slic3r::GUI::GUI_App::request_user_logout	(	const std::string &	provider = ORCA_CLOUD_PROVIDER,
		bool	user_initiated = false )

{
    if (m_agent && m_agent->is_user_login(provider)) {
        m_agent->user_logout(true, provider);
 
        if (provider == get_printer_cloud_provider()) {
            m_agent->set_user_selected_machine("");
            if (m_device_manager) {
                m_device_manager->clean_user_info(true);
            }
        }
 
        if (provider == ORCA_CLOUD_PROVIDER) {
            // Invalidate any handoff still in flight, so a token minted for the signed-out
            // account is never loaded into the pane.
            ++m_cloud_handoff_gen;
            m_cloud_handoff_state.clear();
 
            // An explicit user sign-out also ends the webview's own cloud session (guide §8).
            // A session the desktop lost on its own must NOT do this: a 2FA user would otherwise
            // loop through the code prompt on every desktop re-login.
            if (user_initiated) {
                if (auto orca = get_orca_cloud_agent(m_agent)) {
                    if (WebViewPanel* home = WebViewPanel::if_built())
                        home->cloud_signed_out(from_u8(orca->build_web_session_signout_url()));
                }
            }
 
            /* delete old user settings */
            bool     transfer_preset_changes = false;
            wxString header = _L("Some presets are modified.") + "\n" +
                _L("You can keep the modified presets for the new project, discard, or save changes as new presets.");
            wxGetApp().check_and_keep_current_preset_changes(_L("User logged out"), header, ActionButtons::KEEP | ActionButtons::SAVE, &transfer_preset_changes);
 
            remove_user_presets();
            enable_user_preset_folder(false);
            Slic3r::PluginManager::instance().unload_cloud_plugins();
            Slic3r::PluginManager::instance().clear_cloud_plugin_metadata();
            Slic3r::PluginManager::instance().set_cloud_user("");
            preset_bundle->load_user_presets(DEFAULT_USER_FOLDER_NAME, ForwardCompatibilitySubstitutionRule::Enable);
            mainframe->update_side_preset_ui();
 
            // keep this here. refresh_from_catalog is meant to update the dialog UI.
            if (m_plugins_dlg)
                m_plugins_dlg->update_plugin_dialog_ui();
 
            GUI::wxGetApp().stop_sync_user_preset();
        }
 
        post_logout_to_webview(provider);
    }
}

References _L, Slic3r::PluginManager::clear_cloud_plugin_metadata(), DEFAULT_USER_FOLDER_NAME, Slic3r::Enable, enable_user_preset_folder(), Slic3r::GUI::from_u8(), Slic3r::GUI::get_orca_cloud_agent(), get_printer_cloud_provider(), Slic3r::GUI::LazyInstance< WebViewPanel >::if_built(), Slic3r::PluginManager::instance(), Slic3r::GUI::KEEP, m_agent, m_cloud_handoff_gen, m_cloud_handoff_state, m_device_manager, m_plugins_dlg, mainframe, Slic3r::ORCA_CLOUD_PROVIDER(), post_logout_to_webview(), preset_bundle, remove_user_presets(), request_user_logout(), Slic3r::GUI::SAVE, Slic3r::PluginManager::set_cloud_user(), and Slic3r::PluginManager::unload_cloud_plugins().

Referenced by handle_web_request(), on_http_error(), on_stealth_mode_enter(), and request_user_logout().

Here is the call graph for this function:

Here is the caller graph for this function:

request_user_unbind()

int Slic3r::GUI::GUI_App::request_user_unbind	(	std::string	dev_id,
		const std::string &	provider = ORCA_CLOUD_PROVIDER )

{
    int result = -1;
    if (m_agent) {
        result = m_agent->unbind(dev_id);
        BOOST_LOG_TRIVIAL(info) << "request_user_unbind, dev_id = " << dev_id << ", result = " << result;
        return result;
    }
    return result;
}

References m_agent, and request_user_unbind().

Referenced by request_user_unbind().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_to_active()

void Slic3r::GUI::GUI_App::reset_to_active

(

)

{
    last_active_point = std::chrono::system_clock::now();
}

References last_active_point, and reset_to_active().

Referenced by GUI_App(), and reset_to_active().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_unsigned_plugin_warning()

void Slic3r::GUI::GUI_App::reset_unsigned_plugin_warning ( )

inline

{ m_unsigned_plugin_warning_shown = false; }

References m_unsigned_plugin_warning_shown.

resolve_printer_agent_id()

std::string Slic3r::GUI::GUI_App::resolve_printer_agent_id

(

const std::string &

stored_id

)

const

{
    if (!stored_id.empty())
        return stored_id;
    return (preset_bundle && preset_bundle->is_bbl_vendor()) ? BBL_PRINTER_AGENT_ID : ORCA_PRINTER_AGENT_ID;
}

References Slic3r::BBL_PRINTER_AGENT_ID, Slic3r::ORCA_PRINTER_AGENT_ID, preset_bundle, and resolve_printer_agent_id().

Referenced by canonical_printer_agent_id(), get_printer_cloud_provider(), resolve_printer_agent_id(), switch_printer_agent(), and switch_printer_agent_if_pending().

Here is the call graph for this function:

Here is the caller graph for this function:

restart_networking()

void Slic3r::GUI::GUI_App::restart_networking

(

)

{
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__<< boost::format(" enter, mainframe %1%")%mainframe;
    on_init_network(true);
    StaticBambuLib::reset();
    if(m_agent) {
        init_networking_callbacks();
        m_agent->set_on_ssdp_msg_fn(
            [this](std::string json_str) {
                if (!is_closing() && m_device_manager)
                    m_device_manager->on_machine_alive(json_str);
            }
        );
        m_agent->set_on_http_error_fn([this](CloudEvent event, unsigned int status, std::string body) {
            this->handle_http_error(status, body, event.provider);
        });
        // on_init_network() rebuilt m_agent with a null printer agent, so calling
        // m_agent->start_discovery() directly would no-op (NetworkAgent::start_discovery
        // returns false when m_printer_agent is null). Re-establish the printer agent for the
        // active preset first - switch_printer_agent() installs it and then starts discovery,
        // mirroring startup - otherwise LAN discovery stays dead after a plugin hot reload
        // until the user next changes a preset/tab.
        switch_printer_agent();
        if (mainframe)
            mainframe->refresh_plugin_tips();
        if (plater_)
            plater_->get_notification_manager()->bbl_close_plugin_install_notification();
 
        if (m_agent->is_user_login()) {
            remove_user_presets();
            enable_user_preset_folder(true);
            preset_bundle->load_user_presets(m_agent->get_user_id(), ForwardCompatibilitySubstitutionRule::Enable);
            mainframe->update_side_preset_ui();
        }
 
        if (app_config->get("sync_user_preset") == "true") {
            start_sync_user_preset();
        }
        // if (mainframe && this->app_config->get("staff_pick_switch") == "true") {
        //     if (mainframe->m_webview) { mainframe->m_webview->SendDesignStaffpick(has_model_mall()); }
        // }
    }
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__<< boost::format(" exit, m_agent=%1%")%m_agent;
}

References app_config, Slic3r::Enable, enable_user_preset_folder(), handle_http_error(), init_networking_callbacks(), is_closing(), m_agent, m_device_manager, mainframe, on_init_network(), plater_, preset_bundle, Slic3r::CloudEvent::provider, remove_user_presets(), StaticBambuLib::reset(), start_sync_user_preset(), and switch_printer_agent().

Referenced by hot_reload_network_plugin().

Here is the call graph for this function:

Here is the caller graph for this function:

restart_sync_user_preset()

void Slic3r::GUI::GUI_App::restart_sync_user_preset

(

)

{
    // A manual sync's progress dialog is already on screen — ignore repeat triggers so a
    // second modal dialog can never stack. This matters most offline: each attempt blocks
    // on a long HTTP timeout and can't be cancelled mid-request, and on macOS the global
    // menu bar stays clickable even while the dialog disables the main window, so without
    // this guard repeated clicks pile up modal dialogs and wedge the UI (force-quit only).
    if (m_sync_user_preset_dlg_active)
        return;
 
    if (!m_user_sync_token) {
        // No sync running. If a restart helper is already in flight it will
        // start the new sync once the old thread is joined — don't race it.
        if (!m_restart_sync_pending)
            start_sync_user_preset(true);
        return;
    }
 
    // Resetting the token signals the old thread to stop (cancelFn checks
    // t.expired(), so it exits after its current HTTP request completes).
    // A helper thread joins the old thread off the UI thread — no freeze —
    // then starts the new sync via CallAfter once the old one is fully done.
    m_user_sync_token.reset();
    m_restart_sync_pending = true;
 
    auto old_thread = std::move(m_sync_update_thread);
 
    std::thread([this, old_thread = std::move(old_thread)]() mutable {
        if (old_thread.joinable())
            old_thread.join();
        m_restart_sync_pending = false;
        if (!is_closing())
            CallAfter([this]() {
                if (!is_closing())
                    start_sync_user_preset(true);
            });
    }).detach();
}

References is_closing(), m_restart_sync_pending, m_sync_update_thread, m_sync_user_preset_dlg_active, m_user_sync_token, restart_sync_user_preset(), and start_sync_user_preset().

Referenced by on_http_error(), and restart_sync_user_preset().

Here is the call graph for this function:

Here is the caller graph for this function:

run_script()

void Slic3r::GUI::GUI_App::run_script

(

wxString

js

)

{
    if (mainframe)
        return mainframe->RunScript(js);
}

References mainframe, and run_script().

Referenced by run_script().

Here is the call graph for this function:

Here is the caller graph for this function:

run_wizard()

bool Slic3r::GUI::GUI_App::run_wizard	(	ConfigWizard::RunReason	reason,
		ConfigWizard::StartPage	start_page = ConfigWizard::SP_WELCOME )

{
    wxCHECK_MSG(mainframe != nullptr, false, "Internal error: Main frame not created / null");
 
#ifdef __APPLE__
     if (is_adding_script_handler()) {
        BOOST_LOG_TRIVIAL(info) << "run_wizard: Script handler is being added, delaying wizard creation";
        auto timer = new wxTimer();
        timer->Bind(wxEVT_TIMER, [this, reason, start_page, timer](wxTimerEvent &) {
            timer->Stop();
            run_wizard(reason, start_page);
            delete timer;
        });
        timer->StartOnce(200);
 
        return true;
    }
#endif
 
    //if (reason == ConfigWizard::RR_USER) {
    //    //TODO: turn off it currently, maybe need to turn on in the future
    //    if (preset_updater->config_update(app_config->orig_version(), PresetUpdater::UpdateParams::FORCED_BEFORE_WIZARD) == PresetUpdater::R_ALL_CANCELED)
    //        return false;
    //}
 
    //auto wizard_t = new ConfigWizard(mainframe);
    //const bool res = wizard_t->run(reason, start_page);
 
    std::string strFinish = wxGetApp().app_config->get("firstguide", "finish");
    long        pStyle    = wxCAPTION | wxCLOSE_BOX | wxSYSTEM_MENU;
    if (strFinish == "false" || strFinish.empty())
        pStyle = wxCAPTION | wxTAB_TRAVERSAL;
 
    GuideFrame wizard(this, pStyle);
    auto page = start_page == ConfigWizard::SP_WELCOME ? GuideFrame::BBL_WELCOME :
                start_page == ConfigWizard::SP_FILAMENTS ? GuideFrame::BBL_FILAMENT_ONLY :
                start_page == ConfigWizard::SP_PRINTERS ? GuideFrame::BBL_MODELS_ONLY :
                GuideFrame::BBL_MODELS;
    wizard.SetStartPage(page);
    bool       res = wizard.run();
 
    if (res) {
        load_current_presets();
        update_publish_status();
        mainframe->refresh_plugin_tips();
        // BBS: remove SLA related message
    }
 
    return res;
}

References Slic3r::GUI::GuideFrame::BBL_FILAMENT_ONLY, Slic3r::GUI::GuideFrame::BBL_MODELS, Slic3r::GUI::GuideFrame::BBL_MODELS_ONLY, Slic3r::GUI::GuideFrame::BBL_WELCOME, is_adding_script_handler(), load_current_presets(), mainframe, Slic3r::GUI::GuideFrame::run(), run_wizard(), Slic3r::GUI::GuideFrame::SetStartPage(), Slic3r::GUI::ConfigWizard::SP_FILAMENTS, Slic3r::GUI::ConfigWizard::SP_PRINTERS, Slic3r::GUI::ConfigWizard::SP_WELCOME, and update_publish_status().

Referenced by config_wizard_startup(), and run_wizard().

Here is the call graph for this function:

Here is the caller graph for this function:

save_mode()

void Slic3r::GUI::GUI_App::save_mode

(

const int

mode

)

{
    const auto saved_mode = mode == comExpert ? comExpert :
                            mode == comAdvanced ? comAdvanced :
                            mode == comSimple ? comSimple :
                            get_saved_mode();
    app_config->set("user_mode", saved_mode_to_string(saved_mode));
    update_mode();
}

References app_config, Slic3r::comAdvanced, Slic3r::comExpert, Slic3r::comSimple, get_saved_mode(), save_mode(), and update_mode().

Referenced by save_mode(), and set_mode().

Here is the call graph for this function:

Here is the caller graph for this function:

scan_orphaned_info_files()

void Slic3r::GUI::GUI_App::scan_orphaned_info_files

(

)

{
    // Get user preset directory
    std::string user_sub_folder = app_config->get("preset_folder");
    if (user_sub_folder.empty())
        user_sub_folder = DEFAULT_USER_FOLDER_NAME;
    const std::string dir_user_presets = data_dir() + "/" + PRESET_USER_DIR + "/" + user_sub_folder;
 
    // Scan for orphaned .info files in each preset type directory
    std::vector<std::string> preset_types = {PRESET_PRINT_NAME, PRESET_FILAMENT_NAME, PRESET_PRINTER_NAME};
 
    for (const std::string& type : preset_types) {
        fs::path type_dir = fs::path(dir_user_presets) / type;
        if (!fs::exists(type_dir))
            continue;
 
        // Iterate through all .info files. Use the error_code-based iterator so a transient
        // directory-read failure (e.g. macOS readdir returning ENOTSUP) is logged and skipped
        // instead of throwing an uncaught exception that would terminate the app from the
        // background sync thread this runs on.
        boost::system::error_code ec;
        for (boost::filesystem::directory_iterator it(type_dir, ec), end; !ec && it != end; it.increment(ec)) {
            const auto& entry = *it;
            if (entry.path().extension() != ".info")
                continue;
 
            fs::path info_file = entry.path();
            fs::path preset_file = info_file;
            preset_file.replace_extension(".json");
 
            // If .json doesn't exist, .info is orphaned. Read under the lock, so a
            // remove_files() in another instance is seen whole or not at all; the
            // delete queue's own mutex is taken after the lock is released.
            std::string setting_id;
            {
                InstanceLock instance_lock(user_presets_lock_path());
                if (!fs::exists(preset_file))
                    setting_id = extract_setting_id_from_info(info_file.string());
            }
            if (!setting_id.empty()) {
                // Add to need_delete_presets
                delete_preset_from_cloud(setting_id, info_file.string());
                BOOST_LOG_TRIVIAL(info) << "Found orphaned .info file on startup: " << info_file.string();
            }
        }
        if (ec)
            BOOST_LOG_TRIVIAL(warning) << "scan_orphaned_info_files: failed to scan " << type_dir.string() << ": " << ec.message();
    }
}

References app_config, Slic3r::data_dir(), DEFAULT_USER_FOLDER_NAME, delete_preset_from_cloud(), extract_setting_id_from_info(), PRESET_FILAMENT_NAME, PRESET_PRINT_NAME, PRESET_PRINTER_NAME, PRESET_USER_DIR, scan_orphaned_info_files(), and Slic3r::user_presets_lock_path().

Referenced by scan_orphaned_info_files(), and start_sync_user_preset().

Here is the call graph for this function:

Here is the caller graph for this function:

select_machine()

void Slic3r::GUI::GUI_App::select_machine ( const std::string & agent_id )

private

{
    // Skip for BBL agent for now - uses its own device discovery/selection
    // Orca todo: revisit in future if we want to support auto-switching for BBL printers
    if (agent_id == BBL_PRINTER_AGENT_ID) {
        return;
    }
 
    if (!m_device_manager || !preset_bundle) {
        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": no device manager or preset bundle";
        return;
    }
 
    // Get config source (preset or physical printer)
    const auto& preset = preset_bundle->printers.get_edited_preset();
    const DynamicPrintConfig* host_cfg = &preset.config;
 
    // Hands the machine to the Device tab's full selection flow (UI updates, callbacks, etc.).
    auto select_dev = [this](const std::string& dev_id) {
        if (MonitorPanel* monitor = MonitorPanel::if_built()) {
            monitor->select_machine(dev_id);
            BOOST_LOG_TRIVIAL(info) << "GUI_App::select_machine" << ": triggered select_machine for dev_id=" << dev_id;
        } else if (m_device_manager->set_selected_machine(dev_id)) {
            // The Device tab's own state is set when the tab is built.
            MonitorPanel::on_machine_selected(m_device_manager->get_selected_machine());
            BOOST_LOG_TRIVIAL(info) << "GUI_App::select_machine" << ": set_selected_machine dev_id=" << dev_id;
        }
    };
 
    std::string print_host = host_cfg->opt_string("print_host");
    if (print_host.empty()) {
        // Orca: a printer bound from the Device tab is kept as a device of the agent rather than in
        // the preset's print_host. Select it when it is the agent's only one, as
        // MainFrame::load_printer_url() does; otherwise nothing is selected until the print dialog
        // picks it, and filament sync has no printer to read from.
        const auto machines = m_device_manager->get_my_machine_list(agent_id);
        if (machines.size() == 1 && machines.begin()->second)
            select_dev(machines.begin()->second->get_dev_id());
        return;
    }
    std::string port = host_cfg->opt_string("printhost_port");
    std::string access_code = host_cfg->opt_string("printhost_apikey");
    if (access_code.empty() && agent_id != MOONRAKER_PRINTER_AGENT_ID)
        access_code = "88888888";
 
    // Generate dev_id from host and port
    std::string dev_id = MachineObject::dev_id_from_address(print_host, port);
 
    // Check if already exists by dev_id
    MachineObject* existing = m_device_manager->get_local_machine(dev_id);
 
    // If not found by dev_id, search by full_addr
    if (!existing) {
        auto local_machines = m_device_manager->get_local_machinelist();
        for (auto& [id, machine] : local_machines) {
            if (machine && machine->get_dev_ip() == dev_id) {
                existing = machine;
                break;
            }
        }
    }
 
    // If machine doesn't exist, create it first
    if (!existing) {
        BBLocalMachine machine;
        machine.dev_id = dev_id;
        // We use dev_id as dev_ip to store the address (host:port)
        machine.dev_ip = dev_id;
        machine.dev_name = dev_id;
        machine.printer_type = preset.config.opt_string("printer_model");
 
        existing = m_device_manager->insert_local_device(
            machine, "lan", "free", "", access_code);
 
        if (!existing) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": failed to create machine dev_id=" << dev_id;
            return;
        }
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": created new machine dev_id=" << dev_id;
    } else if (agent_id == MOONRAKER_PRINTER_AGENT_ID && existing->printer_agent_id == agent_id &&
               (!existing->has_access_right() || existing->get_access_code() != access_code)) {
        existing->set_access_code(access_code);
    }
    existing->local_use_ssl = boost::istarts_with(print_host, "https://");
    select_dev(dev_id);
}

References Slic3r::BBL_PRINTER_AGENT_ID, Slic3r::BBLocalMachine::dev_id, Slic3r::MachineObject::dev_id_from_address(), Slic3r::BBLocalMachine::dev_ip, Slic3r::BBLocalMachine::dev_name, Slic3r::MachineObject::get_access_code(), Slic3r::MachineObject::has_access_right(), Slic3r::GUI::LazyInstance< MonitorPanel >::if_built(), Slic3r::MachineObject::local_use_ssl, m_device_manager, Slic3r::MOONRAKER_PRINTER_AGENT_ID, Slic3r::GUI::MonitorPanel::on_machine_selected(), Slic3r::DynamicConfig::opt_string(), preset_bundle, Slic3r::MachineObject::printer_agent_id, Slic3r::BBLocalMachine::printer_type, select_machine(), and Slic3r::MachineObject::set_access_code().

Referenced by select_machine(), and switch_printer_agent().

Here is the call graph for this function:

Here is the caller graph for this function:

set_adding_script_handler()

void Slic3r::GUI::GUI_App::set_adding_script_handler ( bool status )

inline

{ m_adding_script_handler = status; }

References m_adding_script_handler.

set_auto_toolbar_icon_scale()

void Slic3r::GUI::GUI_App::set_auto_toolbar_icon_scale

(

float

scale

)

const

{
#ifdef __APPLE__
    const float icon_sc = 1.0f; // for Retina display will be used its own scale
#else
    const float icon_sc = m_em_unit * 0.1f;
#endif // __APPLE__
 
    long int_val = std::min(int(std::lround(scale / icon_sc * 100)), 100);
    std::string val = std::to_string(int_val);
 
    app_config->set("toolkit_size", val);
}

References app_config, m_em_unit, scale(), and set_auto_toolbar_icon_scale().

Referenced by set_auto_toolbar_icon_scale().

Here is the call graph for this function:

Here is the caller graph for this function:

set_closing()

void Slic3r::GUI::GUI_App::set_closing ( bool closing )

inline

{ m_is_closing.store(closing, std::memory_order_release); }

References Slic3r::closing(), and m_is_closing.

Referenced by shutdown().

Here is the call graph for this function:

Here is the caller graph for this function:

set_download_model_name()

void Slic3r::GUI::GUI_App::set_download_model_name ( std::string name )

inline

{m_mall_model_download_name = name;}

References m_mall_model_download_name.

set_download_model_url()

void Slic3r::GUI::GUI_App::set_download_model_url ( std::string url )

inline

{m_mall_model_download_url = url;}

References m_mall_model_download_url.

set_instance_hash()

void Slic3r::GUI::GUI_App::set_instance_hash ( const size_t hash )

inline

{ m_instance_hash_int = hash; m_instance_hash_string = std::to_string(hash); }

References m_instance_hash_int, and m_instance_hash_string.

set_label_clr_modified()

void Slic3r::GUI::GUI_App::set_label_clr_modified

(

const wxColour &

clr

)

{
    return;
    //BBS
    /*
    if (m_color_label_modified == clr)
        return;
    m_color_label_modified = clr;
    const std::string str = encode_color(ColorRGB(clr.Red(), clr.Green(), clr.Blue()));
    app_config->save();
    */
}

References set_label_clr_modified().

Referenced by set_label_clr_modified().

Here is the call graph for this function:

Here is the caller graph for this function:

set_label_clr_sys()

void Slic3r::GUI::GUI_App::set_label_clr_sys

(

const wxColour &

clr

)

{
    return;
    //BBS
    /*
    if (m_color_label_sys == clr)
        return;
    m_color_label_sys = clr;
    const std::string str = encode_color(ColorRGB(clr.Red(), clr.Green(), clr.Blue()));
    app_config->save();
    */
}

References set_label_clr_sys().

Referenced by set_label_clr_sys().

Here is the call graph for this function:

Here is the caller graph for this function:

set_live_printer_agent()

void Slic3r::GUI::GUI_App::set_live_printer_agent ( std::shared_ptr< IPrinterAgent > agent )

private

{
    if (!m_agent)
        return;
 
    // why: tearing down the old machine selection is only ever the prefix of setting the live
    // agent (to a new one, or to null when the selection is missing) - so it lives here, not as
    // a standalone helper. Pass nullptr to clear the selection.
    if (DeviceManager* dev = getDeviceManager())
    {
        dev->set_selected_machine(""); // why: empty id disconnects and deselects the current machine
        m_agent->set_user_selected_machine("");
        // note: belt-and-suspenders (precedent: DeviceManagerRefresher::on_timer)
        dev->OnSelectedMachineLost(); // why: clear stale sidebar sync-status / AMS
        // why: retain agent-owned LAN discoveries so agents without automatic discovery (for
        // example the Moonraker-based Qidi/Snapmaker agents) can reuse them after a switch.
        dev->clear_other_devices();
    }
 
    m_agent->set_printer_agent(agent);
    sidebar().update_all_preset_comboboxes();
}

References getDeviceManager(), m_agent, set_live_printer_agent(), and sidebar().

Referenced by set_live_printer_agent(), and switch_printer_agent().

Here is the call graph for this function:

Here is the caller graph for this function:

set_mode()

void Slic3r::GUI::GUI_App::set_mode

(

ConfigOptionMode

mode

)

{
    const bool was_developer = app_config->get_bool("developer_mode");
    if (was_developer)
        app_config->set_bool("developer_mode", false);
    save_mode(mode);
    if (was_developer)
        app_config->save();
}

References app_config, save_mode(), and set_mode().

Referenced by set_mode().

Here is the call graph for this function:

Here is the caller graph for this function:

set_side_menu_popup_status()

void Slic3r::GUI::GUI_App::set_side_menu_popup_status

(

bool

status

)

{
    m_side_popup_status = status;
}

References m_side_popup_status, and set_side_menu_popup_status().

Referenced by set_side_menu_popup_status().

Here is the call graph for this function:

Here is the caller graph for this function:

set_skip_version()

void Slic3r::GUI::GUI_App::set_skip_version

(

bool

skip = true

)

{
    BOOST_LOG_TRIVIAL(info) << "set_skip_version, skip = " << skip << ", version = " <<version_info.version_str;
    if (skip) {
        app_config->set("skip_version", version_info.version_str);
    }else {
        app_config->set("skip_version", "");
    }
}

References app_config, set_skip_version(), and version_info.

Referenced by set_skip_version().

Here is the call graph for this function:

Here is the caller graph for this function:

shortcuts()

ShortcutRegistry & Slic3r::GUI::GUI_App::shortcuts ( )

inline

{ return *m_shortcuts; }

References m_shortcuts.

show_3d_navigator()

bool Slic3r::GUI::GUI_App::show_3d_navigator ( ) const

inline

{ return app_config->get_bool("show_3d_navigator"); }

References app_config.

Referenced by toggle_show_3d_navigator().

Here is the caller graph for this function:

show_canvas_zoom_button()

bool Slic3r::GUI::GUI_App::show_canvas_zoom_button ( ) const

inline

{ return app_config->get_bool("show_canvas_zoom_button"); }

References app_config.

Referenced by toggle_canvas_zoom_button().

Here is the caller graph for this function:

show_center_of_mass()

bool Slic3r::GUI::GUI_App::show_center_of_mass ( ) const

inline

{ return app_config->get_bool("show_center_of_mass"); }

References app_config.

Referenced by toggle_show_center_of_mass().

Here is the caller graph for this function:

show_check_privacy_dlg()

void Slic3r::GUI::GUI_App::show_check_privacy_dlg

(

wxCommandEvent &

evt

)

{
    int online_login = evt.GetInt();
    std::string provider = evt.GetString().ToStdString();
    if (provider.empty()) provider = ORCA_CLOUD_PROVIDER;
    PrivacyUpdateDialog privacy_dlg(this->mainframe, wxID_ANY, _L("Privacy Policy Update"));
    privacy_dlg.Bind(EVT_PRIVACY_UPDATE_CONFIRM, [this, online_login, provider](wxCommandEvent &e) {
        app_config->set("privacy_version", privacy_version_info.version_str);
        app_config->set_bool("privacy_update_checked", true);
        request_user_handle(online_login, provider);
        });
    privacy_dlg.Bind(EVT_PRIVACY_UPDATE_CANCEL, [this, provider](wxCommandEvent &e) {
            app_config->set_bool("privacy_update_checked", false);
            if (m_agent) {
                BOOST_LOG_TRIVIAL(info) << "logout: Privacy update dialog cancelled.";
                m_agent->user_logout(false, provider);
                post_logout_to_webview(provider);
            }
        });
 
    privacy_dlg.set_text(privacy_version_info.description);
    privacy_dlg.on_show();
}

References _L, app_config, m_agent, mainframe, Slic3r::GUI::PrivacyUpdateDialog::on_show(), Slic3r::ORCA_CLOUD_PROVIDER(), post_logout_to_webview(), privacy_version_info, request_user_handle(), Slic3r::GUI::PrivacyUpdateDialog::set_text(), and show_check_privacy_dlg().

Referenced by on_init_inner(), and show_check_privacy_dlg().

Here is the call graph for this function:

Here is the caller graph for this function:

show_desktop_integration_dialog()

void Slic3r::GUI::GUI_App::show_desktop_integration_dialog

(

)

{
#ifdef __linux__
    //wxCHECK_MSG(mainframe != nullptr, false, "Internal error: Main frame not created / null");
    DesktopIntegrationDialog dialog(mainframe);
    dialog.ShowModal();
#endif //__linux__
}

References mainframe, and show_desktop_integration_dialog().

Referenced by show_desktop_integration_dialog().

Here is the call graph for this function:

Here is the caller graph for this function:

show_dialog()

void Slic3r::GUI::GUI_App::show_dialog

(

wxString

msg

)

{
    if (m_info_dialog_content.empty()) {
        wxCommandEvent* evt = new wxCommandEvent(EVT_SHOW_DIALOG);
        evt->SetString(msg);
        GUI::wxGetApp().QueueEvent(evt);
        m_info_dialog_content = msg;
    }
}

References m_info_dialog_content, and show_dialog().

Referenced by show_dialog().

Here is the call graph for this function:

Here is the caller graph for this function:

show_gcode_window()

bool Slic3r::GUI::GUI_App::show_gcode_window ( ) const

inline

{ return m_show_gcode_window; }

References m_show_gcode_window.

show_ip_address_enter_dialog()

void Slic3r::GUI::GUI_App::show_ip_address_enter_dialog

(

wxString

title = wxEmptyString

)

{
    auto evt = new wxCommandEvent(EVT_SHOW_IP_DIALOG);
    evt->SetString(title);
    evt->SetInt(-1);
    wxQueueEvent(this, evt);
}

References show_ip_address_enter_dialog().

Referenced by show_ip_address_enter_dialog().

Here is the call graph for this function:

Here is the caller graph for this function:

show_ip_address_enter_dialog_handler()

void Slic3r::GUI::GUI_App::show_ip_address_enter_dialog_handler

(

wxCommandEvent &

evt

)

{
    wxString title = evt.GetString();
    int mode = evt.GetInt();
    show_modal_ip_address_enter_dialog(mode == -1?false:true, title);
}

References show_ip_address_enter_dialog_handler(), and show_modal_ip_address_enter_dialog().

Referenced by on_init_inner(), and show_ip_address_enter_dialog_handler().

Here is the call graph for this function:

Here is the caller graph for this function:

show_message_box()

void Slic3r::GUI::GUI_App::show_message_box ( std::string msg )

inline

{ wxMessageBox(msg); }

show_modal_ip_address_enter_dialog()

bool Slic3r::GUI::GUI_App::show_modal_ip_address_enter_dialog	(	bool	input_sn,
		wxString	title = wxEmptyString )

{
    DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager();
    if (!dev) return false;
    if (!dev->get_selected_machine()) return false;
    auto obj = dev->get_selected_machine();
 
    InputIpAddressDialog dlg(nullptr);
    dlg.m_need_input_sn = input_sn;
    dlg.set_machine_obj(obj);
    if (!title.empty()) dlg.update_title(title);
 
    dlg.Bind(EVT_ENTER_IP_ADDRESS, [obj](wxCommandEvent& e) {
        auto selection_data_arr = wxSplit(e.GetString().ToStdString(), '|');
 
        if (selection_data_arr.size() == 2) {
            auto ip_address = selection_data_arr[0];
            auto access_code = selection_data_arr[1];
 
            BOOST_LOG_TRIVIAL(info) << "User enter IP address is " << ip_address;
            if (!ip_address.empty()) {
                wxGetApp().app_config->set_str("ip_address", obj->get_dev_id(), ip_address.ToStdString());
                wxGetApp().app_config->save();
 
                obj->set_dev_ip(ip_address.ToStdString());
                obj->set_access_code(access_code.ToStdString());
            }
        }
    });
 
    if (dlg.ShowModal() == wxID_YES) {
        return true;
    }
    return false;
}

References Slic3r::DeviceManager::get_selected_machine(), Slic3r::GUI::InputIpAddressDialog::m_need_input_sn, Slic3r::GUI::InputIpAddressDialog::set_machine_obj(), show_modal_ip_address_enter_dialog(), Slic3r::GUI::DPIAware< P >::ShowModal(), and Slic3r::GUI::InputIpAddressDialog::update_title().

Referenced by show_ip_address_enter_dialog_handler(), and show_modal_ip_address_enter_dialog().

Here is the call graph for this function:

Here is the caller graph for this function:

show_network_plugin_download_dialog()

void Slic3r::GUI::GUI_App::show_network_plugin_download_dialog

(

bool

is_update = false

)

{
    auto load_error = Slic3r::NetworkAgent::get_load_error();
 
    NetworkPluginDownloadDialog::Mode mode;
    if (load_error.has_error) {
        mode = NetworkPluginDownloadDialog::Mode::CorruptedPlugin;
    } else if (is_update) {
        mode = NetworkPluginDownloadDialog::Mode::UpdateAvailable;
    } else {
        mode = NetworkPluginDownloadDialog::Mode::MissingPlugin;
    }
 
    std::string current_version = Slic3r::NetworkAgent::get_version();
 
    NetworkPluginDownloadDialog dlg(mainframe, mode, current_version,
        load_error.message, load_error.technical_details);
 
    int result = dlg.ShowModal();
 
    switch (result) {
    case NetworkPluginDownloadDialog::RESULT_DOWNLOAD:
        {
            std::string selected = dlg.get_selected_version();
            app_config->set_network_plugin_version(selected);
            app_config->save();
 
            DownloadProgressDialog download_dlg(_L("Downloading Network Plug-in"));
            download_dlg.ShowModal();
        }
        break;
 
    case NetworkPluginDownloadDialog::RESULT_REMIND_LATER:
        app_config->set_remind_network_update_later(true);
        app_config->save();
        break;
 
    case NetworkPluginDownloadDialog::RESULT_SKIP_VERSION:
        {
            std::string latest = get_latest_network_version();
            app_config->add_skipped_network_version(latest);
            app_config->save();
        }
        break;
 
    case NetworkPluginDownloadDialog::RESULT_DONT_ASK:
        app_config->set_network_update_prompt_disabled(true);
        app_config->save();
        break;
 
    case NetworkPluginDownloadDialog::RESULT_SKIP:
    default:
        break;
    }
}

References _L, app_config, Slic3r::GUI::NetworkPluginDownloadDialog::CorruptedPlugin, get_latest_network_version(), Slic3r::NetworkAgent::get_load_error(), Slic3r::GUI::NetworkPluginDownloadDialog::get_selected_version(), Slic3r::NetworkAgent::get_version(), mainframe, Slic3r::GUI::NetworkPluginDownloadDialog::MissingPlugin, Slic3r::GUI::NetworkPluginDownloadDialog::RESULT_DONT_ASK, Slic3r::GUI::NetworkPluginDownloadDialog::RESULT_DOWNLOAD, Slic3r::GUI::NetworkPluginDownloadDialog::RESULT_REMIND_LATER, Slic3r::GUI::NetworkPluginDownloadDialog::RESULT_SKIP, Slic3r::GUI::NetworkPluginDownloadDialog::RESULT_SKIP_VERSION, Slic3r::GUI::DPIAware< P >::ShowModal(), and Slic3r::GUI::NetworkPluginDownloadDialog::UpdateAvailable.

Referenced by on_init_network(), and post_init().

Here is the call graph for this function:

Here is the caller graph for this function:

show_outline()

bool Slic3r::GUI::GUI_App::show_outline ( ) const

inline

{ return app_config->get_bool("show_outline"); }

References app_config.

Referenced by toggle_show_outline().

Here is the caller graph for this function:

show_plate_gridlines()

bool Slic3r::GUI::GUI_App::show_plate_gridlines ( ) const

inline

{ return app_config->get_bool("show_plate_gridlines"); }

References app_config.

Referenced by toggle_show_plate_gridlines().

Here is the caller graph for this function:

ShowDownNetPluginDlg()

void Slic3r::GUI::GUI_App::ShowDownNetPluginDlg

(

)

                                   {
    try {
        auto iter = std::find_if(dialogStack.begin(), dialogStack.end(), [](auto dialog) {
            return dynamic_cast<DownloadProgressDialog *>(dialog) != nullptr;
        });
        if (iter != dialogStack.end())
            return;
        DownloadProgressDialog dlg(_L("Downloading Bambu Network Plug-in"));
        dlg.ShowModal();
    } catch (std::exception &) {
        ;
    }
}

References _L, Slic3r::GUI::dialogStack, ShowDownNetPluginDlg(), and Slic3r::GUI::DPIAware< P >::ShowModal().

Referenced by ShowDownNetPluginDlg().

Here is the call graph for this function:

Here is the caller graph for this function:

ShowOnlyFilament()

void Slic3r::GUI::GUI_App::ShowOnlyFilament

(

)

                               {
    // BBS:Show NewUser Guide
    try {
        bool       res = false;
        GuideFrame GuideDlg(this);
        GuideDlg.SetStartPage(GuideFrame::GuidePage::BBL_FILAMENT_ONLY);
        res = GuideDlg.run();
        if (res) {
            load_current_presets();
 
            // BBS: remove SLA related message
        }
    } catch (std::exception &) {
        // wxMessageBox(e.what(), "", MB_OK);
    }
}

References Slic3r::GUI::GuideFrame::BBL_FILAMENT_ONLY, load_current_presets(), Slic3r::GUI::GuideFrame::run(), Slic3r::GUI::GuideFrame::SetStartPage(), and ShowOnlyFilament().

Referenced by ShowOnlyFilament().

Here is the call graph for this function:

Here is the caller graph for this function:

ShowUserGuide()

void Slic3r::GUI::GUI_App::ShowUserGuide

(

)

                            {
    // BBS:Show NewUser Guide
    try {
        bool res = false;
        GuideFrame GuideDlg(this);
                //if (GuideDlg.IsFirstUse())
        res = GuideDlg.run();
if (res) {
            load_current_presets();
            update_publish_status();
            mainframe->refresh_plugin_tips();
            // BBS: remove SLA related message
        }
    } catch (std::exception &) {
        // wxMessageBox(e.what(), "", MB_OK);
    }
}

References load_current_presets(), mainframe, Slic3r::GUI::GuideFrame::run(), ShowUserGuide(), and update_publish_status().

Referenced by ShowUserGuide().

Here is the call graph for this function:

Here is the caller graph for this function:

ShowUserLogin()

void Slic3r::GUI::GUI_App::ShowUserLogin	(	bool	show = true,
		const std::string &	provider = ORCA_CLOUD_PROVIDER )

{
    // Show user Login Dialog for specified cloud
    if (show) {
        try {
            delete login_dlg;
            auto cloud_agent = m_agent->get_cloud_agent(provider);
            login_dlg        = new ZUserLogin(cloud_agent);
            login_dlg->ShowModal();
        } catch (std::exception &) {
            ;
        }
    } else {
        if (login_dlg)
            login_dlg->EndModal(wxID_OK);
    }
}

References login_dlg, m_agent, and ShowUserLogin().

Referenced by check_login(), request_login(), and ShowUserLogin().

Here is the call graph for this function:

Here is the caller graph for this function:

shutdown()

void Slic3r::GUI::GUI_App::shutdown

(

)

{
    BOOST_LOG_TRIVIAL(info) << "GUI_App::shutdown enter";
 
  if (m_removable_drive_manager) {
    removable_drive_manager()->shutdown();
  }
 
    // destroy login dialog
    if (login_dlg != nullptr) {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__<< boost::format(": destroy login dialog");
        delete login_dlg;
        login_dlg = nullptr;
    }
 
    if (m_is_recreating_gui) return;
    stop_http_server();
    set_closing(true);
    Slic3r::PluginManager::instance().set_shutting_down();
 
    if (m_agent)
        m_agent->set_printer_agent(nullptr);
    NetworkAgentFactory::clear_printer_agent_cache();
 
    BOOST_LOG_TRIVIAL(info) << "GUI_App::shutdown exit";
}

References Slic3r::NetworkAgentFactory::clear_printer_agent_cache(), Slic3r::PluginManager::instance(), login_dlg, m_agent, m_is_recreating_gui, m_removable_drive_manager, removable_drive_manager(), set_closing(), Slic3r::PluginManager::set_shutting_down(), Slic3r::GUI::RemovableDriveManager::shutdown(), and stop_http_server().

Here is the call graph for this function:

sidebar()

Sidebar & Slic3r::GUI::GUI_App::sidebar

(

)

{
    return plater_->sidebar();
}

References plater_, and sidebar().

Referenced by obj_layers(), obj_list(), obj_settings(), on_init_inner(), recreate_GUI(), set_live_printer_agent(), sidebar(), and update_mode().

Here is the call graph for this function:

Here is the caller graph for this function:

single_instance_checker()

wxSingleInstanceChecker * Slic3r::GUI::GUI_App::single_instance_checker ( )

inline

{return m_single_instance_checker.get();}

References m_single_instance_checker.

small_font()

const wxFont & Slic3r::GUI::GUI_App::small_font ( )

inline

{ return m_small_font; }

References m_small_font.

split_str()

std::vector< std::string > Slic3r::GUI::GUI_App::split_str	(	std::string	src,
		std::string	separator )

{
    std::string::size_type pos;
    std::vector<std::string> result;
    src += separator;
    int size = src.size();
 
    for (int i = 0; i < size; i++)
    {
        pos = src.find(separator, i);
        if (pos < size)
        {
            std::string s = src.substr(i, pos - i);
            result.push_back(s);
            i = pos + separator.size() - 1;
        }
    }
    return result;
}

start_download()

void Slic3r::GUI::GUI_App::start_download

(

std::string

url

)

{
    if (!plater_) {
        BOOST_LOG_TRIVIAL(error) << "Could not start URL download: plater is nullptr.";
        return;
    }
    //lets always init so if the download dest folder was changed, new dest is used
    boost::filesystem::path dest_folder(app_config->get("download_path"));
    // ORCA: non-throwing probe, as in init_download_path(); ec is deliberately unread.
    boost::system::error_code ec;
    if (dest_folder.empty() || !boost::filesystem::is_directory(dest_folder, ec)) {
        std::string msg = _u8L("Could not start URL download. Destination folder is not set. Please choose destination folder in Configuration Wizard.");
        BOOST_LOG_TRIVIAL(error) << msg;
        show_error(nullptr, msg);
        return;
    }
    m_downloader->init(dest_folder);
    m_downloader->start_download(url);
 
}

References _u8L, app_config, m_downloader, plater_, Slic3r::GUI::show_error(), and start_download().

Referenced by post_init(), and start_download().

Here is the call graph for this function:

Here is the caller graph for this function:

start_exit_watchdog()

void Slic3r::GUI::GUI_App::start_exit_watchdog

(

)

{
    // Last resort for code that never returns while the app closes (plugins, vendor libraries,
    // network calls). The app config is saved on idle and again in MainFrame::shutdown, so ending
    // the process loses little; static destructors and atexit handlers are skipped too, as they may
    // be what is stuck.
    constexpr auto grace = std::chrono::seconds(30);
    try {
        // Made now: by the time the watchdog fires, static destruction may be under way. The logger
        // holds its own reference, which keeps boost::log's core and sinks alive.
        boost::log::sources::severity_logger_mt<boost::log::trivial::severity_level> logger;
        std::thread([grace, logger]() mutable {
            std::this_thread::sleep_for(grace);
            try {
                BOOST_LOG_SEV(logger, boost::log::trivial::error)
                    << "OrcaSlicer did not finish closing within " << grace.count() << " s; ending the process";
            } catch (...) {
                // A failing log sink must not stop the exit.
            }
            std::_Exit(EXIT_FAILURE);
        }).detach();
    } catch (const std::system_error& ex) {
        BOOST_LOG_TRIVIAL(warning) << "Could not start the exit watchdog: " << ex.what();
    }
}

start_http_server() [1/2]

void Slic3r::GUI::GUI_App::start_http_server

(

const std::string &

provider = ORCA_CLOUD_PROVIDER

)

{
    m_http_server.set_request_handler([provider](const std::string& url) {
        return HttpServer::auth_handle_request(url, provider);
    });
 
    if (!m_http_server.is_started())
        m_http_server.start();
}

References Slic3r::GUI::HttpServer::auth_handle_request(), m_http_server, and start_http_server().

Referenced by start_http_server(), and start_http_server().

Here is the call graph for this function:

Here is the caller graph for this function:

start_http_server() [2/2]

void Slic3r::GUI::GUI_App::start_http_server	(	int	port,
		const std::string &	provider = ORCA_CLOUD_PROVIDER )

{
    if (port <= 0) {
        start_http_server(provider);
        return;
    }
 
    m_http_server.set_request_handler([provider](const std::string& url) {
        return HttpServer::auth_handle_request(url, provider);
    });
 
    if (m_http_server.is_started()) {
        if (m_http_server.get_port() == static_cast<boost::asio::ip::port_type>(port)) {
            return;
        }
        m_http_server.stop();
    }
 
    m_http_server.set_port(static_cast<boost::asio::ip::port_type>(port));
    m_http_server.start();
}

References Slic3r::GUI::HttpServer::auth_handle_request(), m_http_server, and start_http_server().

Here is the call graph for this function:

start_sync_user_preset()

void Slic3r::GUI::GUI_App::start_sync_user_preset

(

bool

with_progress_dlg = false

)

{
    if (app_config->get_stealth_mode())
        return;
 
    if (!m_agent || !m_agent->is_user_login()) return;
    if(!m_agent->get_cloud_agent())
        return;
 
    // has already start sync
    if (m_user_sync_token) return;
 
    // Sync only when login
    ProgressFn progressFn;
    WasCancelledFn cancelFn;
    std::function<void(bool)> finishFn;
 
    BOOST_LOG_TRIVIAL(info) << "start_sync_service...";
    // BBS
    m_user_sync_token.reset(new int(0));
    m_user_preset_pull_pending = true;
    if (with_progress_dlg) {
        // Mark a manual progress dialog as active so restart_sync_user_preset() ignores
        // repeat triggers while it is on screen (prevents stacking modal dialogs).
        m_sync_user_preset_dlg_active = true;
        auto dlg = new ProgressDialog(_L("Loading"), "", 100, this->mainframe, wxPD_AUTO_HIDE | wxPD_APP_MODAL | wxPD_CAN_ABORT);
        dlg->Update(0, _L("Loading user preset"));
        progressFn = [this, dlg](int percent) {
            CallAfter([=]{
                dlg->Update(percent, _L("Loading user preset"));
            });
        };
        cancelFn = [this, dlg, t = std::weak_ptr<int>(m_user_sync_token)]() {
            return is_closing() || dlg->WasCanceled() || t.expired();
        };
        finishFn = [this, dlg](bool) {
            // Clear the guard together with destroying the dialog, on the GUI thread, so the
            // next manual sync is allowed exactly once this dialog leaves the screen.
            CallAfter([=]{ dlg->Destroy(); m_sync_user_preset_dlg_active = false; });
        };
    }
    else {
        finishFn = [](bool) {}; // reload_settings() is now triggered from the background thread
        cancelFn = [this, t = std::weak_ptr<int>(m_user_sync_token)]() {
            return is_closing() || t.expired();
        };
    }
 
    Bind(EVT_UPDATE_PRESET_BUNDLE,&GUI_App::update_single_bundle,this);
 
    m_sync_update_thread = Slic3r::create_thread(
        [this, progressFn, cancelFn, finishFn, t = std::weak_ptr<int>(m_user_sync_token)] {
            // finishFn tears down the progress dialog (and clears the re-entrancy guard), so it
            // must run on every exit path — otherwise an early bail-out would leak the modal
            // dialog and leave the guard stuck, blocking all later manual syncs.
            // Guard the whole thread body: an uncaught exception here (e.g. a transient
            // boost::filesystem error while scanning the preset folder) would otherwise
            // propagate out of the thread and terminate the entire application.
            try {
            if (!m_agent) { finishFn(false); return; }
 
            // One-time scan for orphaned .info files left over from offline deletions; queues HTTP DELETEs.
            scan_orphaned_info_files();
            process_delete_presets();
 
            // get setting list, update setting list
            std::string version = preset_bundle->get_vendor_profile_version(PresetBundle::ORCA_DEFAULT_BUNDLE).to_string();
 
            // run check_and_fix_user_presets_syncinfo once before syncing to make sure all presets have correct sync_info
            // So that we can sync presets that are migrated from old version or users manually put preset files in preset folder
            preset_bundle->check_and_fix_user_presets_syncinfo(m_agent->get_user_id());
 
            int ret = m_agent->get_setting_list2(version, [this](auto info) {
                auto type = info[BBL_JSON_KEY_TYPE];
                auto name = info[BBL_JSON_KEY_NAME];
                auto setting_id = info[BBL_JSON_KEY_SETTING_ID];
                auto update_time_str = info[ORCA_JSON_KEY_UPDATE_TIME];
                long long update_time = 0;
                if (!update_time_str.empty())
                    update_time = std::atoll(update_time_str.c_str());
                if (type == "filament") {
                    return preset_bundle->filaments.need_sync(name, setting_id, update_time);
                } else if (type == "print") {
                    return preset_bundle->prints.need_sync(name, setting_id, update_time);
                } else if (type == "printer") {
                    return preset_bundle->printers.need_sync(name, setting_id, update_time);
                } else {
                    return true;
                }
            }, progressFn, cancelFn);
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << __LINE__ << " get_setting_list2 ret = " << ret << " m_is_closing = " << m_is_closing;
 
            finishFn(ret == 0);
 
            // Queued after the refresh reload_settings() queues, so it runs once the pulled presets are loaded.
            if (ret == 0 && m_agent && !t.expired() && reload_settings())
                CallAfter([this, t] {
                    // A stopped or restarted sync: the next sync, if one starts, pulls the presets again.
                    if (t.expired() || is_closing())
                        return;
                    m_user_preset_pull_pending = false;
                    if (m_legacy_filament_check_due)
                        check_legacy_user_filament_presets(false);
                });
 
            // For orca specific syncing
            auto orca_agent = std::dynamic_pointer_cast<OrcaCloudServiceAgent>(m_agent->get_cloud_agent());
            int tick_tock = -1, sync_count = 0; // tick_tock = -1 to immediately run sync the frist time this thread runs
            std::vector<Preset> presets_to_sync;
            std::vector<std::pair<std::string, std::string>> bundles_to_sync;
            std::unordered_set<std::string> bundles_synced;
 
            std::unordered_set<std::string> known_available_updates;
 
            bool update_available = false;
            // Sync once immediately, then every 60 seconds.
            while (!t.expired()) {
                ++tick_tock;
                // Sync once immediately, then every 60s, or right away when a force-push or a preset migration asked
                // for it. The request is consumed on every tick, so one made before a scheduled pass is served by it
                // instead of running a second pass straight after.
                const bool push_now = m_sync_user_presets_now.exchange(false, std::memory_order_acq_rel);
                if (tick_tock % 120 == 0 || push_now) {
                    tick_tock = 0;
                    if (m_agent) {
                        if (!m_agent->is_user_login()) {
                            continue;
                        }
                        //sync preset
                        if (!preset_bundle) continue;
 
                        int total_count = 0;
                        sync_count = preset_bundle->prints.get_user_presets(preset_bundle, presets_to_sync);
 
                        auto sync_with_lock = [this](Preset& preset) {
                            bool force = false;
                            {
                                std::scoped_lock lock(conflict_ids_mutex);
                                auto it = std::find_if(m_pending_conflict_setting_ids.begin(), m_pending_conflict_setting_ids.end(),
                                                [&preset](const std::string& id) { return id == preset.setting_id; });
                                if (it != m_pending_conflict_setting_ids.end()) {
                                    force = true;
                                    m_pending_conflict_setting_ids.erase(it);
                                }
                            }
                            sync_preset(&preset, force);
                        };
 
                        if (sync_count > 0) {
                            for (Preset& preset : presets_to_sync) {
                                sync_with_lock(preset);
                                boost::this_thread::sleep_for(boost::chrono::milliseconds(100));
                            }
                        }
                        total_count += sync_count;
 
                        sync_count = preset_bundle->filaments.get_user_presets(preset_bundle, presets_to_sync);
                        if (sync_count > 0) {
                            for (Preset& preset : presets_to_sync) {
                                sync_with_lock(preset);
                                boost::this_thread::sleep_for(boost::chrono::milliseconds(100));
                            }
                        }
                        total_count += sync_count;
 
                        sync_count = preset_bundle->printers.get_user_presets(preset_bundle, presets_to_sync);
                        if (sync_count > 0) {
                            for (Preset& preset : presets_to_sync) {
                                sync_with_lock(preset);
                                boost::this_thread::sleep_for(boost::chrono::milliseconds(100));
                            }
                        }
                        total_count += sync_count;
 
                        if (total_count == 0) {
                            CallAfter([this] {
                                if (!is_closing())
                                    plater()->get_notification_manager()->close_notification_of_type(NotificationType::BBLUserPresetExceedLimit);
                            });
                        }
 
                        process_delete_presets();
                    }
 
                    // sync subscribed bundles, if orca
                    if (orca_agent)
                    {
                        bundles_to_sync.clear();
                        bundles_synced.clear();
                        std::vector<std::string> not_found;
                        std::vector<std::string> unauthorized;
                        
                        int result = orca_agent->get_subscribed_bundles(&bundles_to_sync, not_found, unauthorized);
                        if (result != 0) {
                            BOOST_LOG_TRIVIAL(warning) << "start_sync_user_preset: failed to fetch subscribed bundles, result=" << result;
                            continue;
                        }
 
                        if(!not_found.empty())
                        {
                            for(auto& n : not_found)
                            {
                                std::string text = format(_L("Bundle %s is no longer available."), n);
                                wxGetApp().plater()->get_notification_manager()->push_notification(NotificationType::CustomNotification,NotificationManager::NotificationLevel::RegularNotificationLevel,text);
                            }
                        }
                        if(!unauthorized.empty())
                        {
                            for(auto& i : unauthorized)
                            {
                                std::string text = format(_L("Bundle %s access is unauthorized."), i);
                                wxGetApp().plater()->get_notification_manager()->push_notification(NotificationType::CustomNotification,NotificationManager::NotificationLevel::RegularNotificationLevel,text);
                                preset_bundle->bundles.ReadLock();
                                if(preset_bundle->bundles.m_bundles.find(i) != preset_bundle->bundles.m_bundles.end())
                                {
                                    preset_bundle->bundles.m_bundles[i].unauthorized = true;
                                }
                                preset_bundle->bundles.ReadUnlock();
                            }
                        }
                        
                            // Iterate over the bundles, and update/create
                        for (const auto& bundle_entry : bundles_to_sync) {
                            bundles_synced.insert(bundle_entry.first);
                            // Sync each bundle individually
                            // if(!preset_bundle->bundles.pauseReads.load()) // if pause is true we will skip updating this frame altogether
                            // {
                            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << __LINE__ << "ORCA : Update thread syncing bundles";
                            int res = sync_bundle(bundle_entry.first, bundle_entry.second);
 
                            const std::string known_update_key = bundle_entry.first + ":" + bundle_entry.second;
                            if (res == 1 && known_available_updates.insert(known_update_key).second) {
                                update_available = true;
                            }
 
                            // }
                            // Small delay between bundle syncs to avoid overwhelming the server
                            boost::this_thread::sleep_for(boost::chrono::milliseconds(100));
                        }
 
                        if (update_available) {
                            wxGetApp()
                                .plater()
                                ->get_notification_manager()
                                ->push_notification(NotificationType::CustomNotification,
                                                    NotificationManager::NotificationLevel::RegularNotificationLevel, _u8L("There is an update available. Open the preset bundle dialog to update it."));
 
                            update_available = false;
                        }
                        
                        std::vector<BundleMetadata> to_delete;
                        preset_bundle->bundles.ReadLock();
                        for (const auto& [id, bundle] : preset_bundle->bundles.m_bundles) {                                                                                                                                                    
                            if (bundle.bundle_type != BundleType::Subscribed)                                                                                                                                                                                         
                                continue;                                                                                                                                                                                                      
                            if (bundles_synced.find(id) != bundles_synced.end())                                                                                                                                                               
                                continue;
                            if(bundle.unauthorized && bundle.is_subscribed)
                                continue;
                            
                            to_delete.push_back(bundle);
                        }
                        preset_bundle->bundles.ReadUnlock();  
 
                        bool has_deletion = false;
                        for (const auto& bundle : to_delete) {
 
                            // Delete the presets first (force=true: bundle presets have is_from_bundle=true)
                            for (auto printer : bundle.printer_presets)
                                preset_bundle->printers.delete_preset(printer, true);
                            for (auto filament : bundle.filament_presets)
                                preset_bundle->filaments.delete_preset(filament, true);
                            for (auto print : bundle.print_presets)
                                preset_bundle->prints.delete_preset(print, true);
 
                            // Delete the bundle folder and bundle
                            fs::path bundle_folder = fs::path(bundle.path.c_str()).parent_path();
                            {
                                boost::system::error_code ec;
                                InstanceLock instance_lock(user_presets_lock_path());
                                boost::filesystem::remove_all(bundle_folder, ec);
                            }
 
                            preset_bundle->bundles.WriteLock();
                            preset_bundle->bundles.m_bundles.erase(bundle.id);
                            preset_bundle->bundles.WriteUnlock();
 
                            std::string text = format(_L("%s has been removed."), bundle.name);
                            wxGetApp().plater()->get_notification_manager()->push_notification(NotificationType::CustomNotification,NotificationManager::NotificationLevel::RegularNotificationLevel,text);
                            has_deletion = true;
                        }
 
                        // Update UI on main thread after deletion
                        if (has_deletion)
                            CallAfter([this]() {
                                if (!is_closing() && preset_bundle && mainframe) {
                                    // update_compatible() ensures proper selection state after deletion
                                    preset_bundle->update_compatible(PresetSelectCompatibleType::Never);
                                    preset_bundle->update_multi_material_filament_presets();
                                    mainframe->update_side_preset_ui();
 
                                    auto* evt = new wxCommandEvent(EVT_UPDATE_BUNDLE_COMPLETE);                                                                                                                                                       
                                    // evt->SetString(wxString::FromUTF8(bundle_id));               
                                    if (m_preset_bundle_dlg)                                                                                                                                                                                                                                                          
                                        wxQueueEvent(m_preset_bundle_dlg, evt);                                                                                                                                                                                                                                       
                                    else                                                                                                                                                                                                                                                                                 
                                        delete evt;
                                }
                        });
                    }
                } else {
                    boost::this_thread::sleep_for(boost::chrono::milliseconds(500));
                }
            }
            } catch (const std::exception& e) {
                BOOST_LOG_TRIVIAL(error) << "user preset sync thread terminated by exception: " << e.what();
            } catch (...) {
                BOOST_LOG_TRIVIAL(error) << "user preset sync thread terminated by unknown exception";
            }
        });
}

References _L, _u8L, app_config, BBL_JSON_KEY_NAME, BBL_JSON_KEY_SETTING_ID, BBL_JSON_KEY_TYPE, Slic3r::GUI::BBLUserPresetExceedLimit, check_legacy_user_filament_presets(), Slic3r::GUI::conflict_ids_mutex, Slic3r::create_thread(), Slic3r::GUI::CustomNotification, Slic3r::GUI::format(), is_closing(), m_agent, m_is_closing, m_legacy_filament_check_due, m_pending_conflict_setting_ids, m_preset_bundle_dlg, m_sync_update_thread, m_sync_user_preset_dlg_active, m_sync_user_presets_now, m_user_preset_pull_pending, m_user_sync_token, mainframe, Slic3r::Never, Slic3r::PresetBundle::ORCA_DEFAULT_BUNDLE, ORCA_JSON_KEY_UPDATE_TIME, plater(), preset_bundle, process_delete_presets(), Slic3r::GUI::NotificationManager::RegularNotificationLevel, reload_settings(), scan_orphaned_info_files(), start_sync_user_preset(), Slic3r::Subscribed, sync_bundle(), sync_preset(), update_single_bundle(), and Slic3r::user_presets_lock_path().

Referenced by on_user_login_handle(), post_init(), restart_networking(), restart_sync_user_preset(), and start_sync_user_preset().

Here is the call graph for this function:

Here is the caller graph for this function:

starts_on_prepare()

bool Slic3r::GUI::GUI_App::starts_on_prepare

(

)

const

{
    return app_config->get("default_page") == "1";
}

References app_config, and starts_on_prepare().

Referenced by on_init_inner(), post_init(), and starts_on_prepare().

Here is the call graph for this function:

Here is the caller graph for this function:

stop_http_server()

void Slic3r::GUI::GUI_App::stop_http_server

(

)

{
    m_http_server.stop();
}

References m_http_server, and stop_http_server().

Referenced by OnExit(), shutdown(), and stop_http_server().

Here is the call graph for this function:

Here is the caller graph for this function:

stop_sync_user_preset()

void Slic3r::GUI::GUI_App::stop_sync_user_preset

(

)

{
    if (!m_user_sync_token)
        return;
 
    m_user_sync_token.reset();
    if (m_sync_update_thread.joinable()) {
        if (is_closing())
            m_sync_update_thread.join();
        else
            m_sync_update_thread.detach();
    }
}

References is_closing(), m_sync_update_thread, m_user_sync_token, and stop_sync_user_preset().

Referenced by on_init_inner(), on_stealth_mode_enter(), OnExit(), and stop_sync_user_preset().

Here is the call graph for this function:

Here is the caller graph for this function:

switch_printer_agent()

void Slic3r::GUI::GUI_App::switch_printer_agent

(

)

{
    if (!m_agent) {
        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": no agent exists";
        return;
    }
 
    // why: installing an agent updates the sidebar and the main frame's print button; until the
    // main window exists, load_current_presets() has not run Tab::on_presets_changed(), which
    // installs the selected preset's agent once the window is up
    if (!mainframe || !plater_)
        return;
 
    const DynamicPrintConfig& config = preset_bundle->printers.get_edited_preset().config;
    const std::string effective_agent_id = resolve_printer_agent_id(config.opt_string("printer_agent"));
 
    // Check if agent is registered
    const PrinterAgentInfo* agent_info_ptr = NetworkAgentFactory::get_printer_agent_info(effective_agent_id);
    if (!agent_info_ptr) {
        // why: the selected agent's provider is gone (e.g. plugin unloaded); leaving the old
        // live agent up would keep talking to a machine the user can no longer select.
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": agent ID '" << effective_agent_id
                                << "' is unregistered; clearing live printer agent";
        set_live_printer_agent(nullptr);
        return;
    }
    const PrinterAgentInfo agent_info = *agent_info_ptr;
 
    std::string log_dir        = data_dir();
    std::string cloud_agent_id = agent_info.id == BBL_PRINTER_AGENT_ID ? BBL_CLOUD_PROVIDER : ORCA_CLOUD_PROVIDER;
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " " << agent_info.id;
    std::shared_ptr<ICloudServiceAgent> cloud_agent = m_agent->get_cloud_agent(cloud_agent_id);
 
    // Create new printer agent via registry
    std::shared_ptr<IPrinterAgent> new_printer_agent =
        NetworkAgentFactory::create_printer_agent_by_id(effective_agent_id, cloud_agent, log_dir);
 
    if (!new_printer_agent) {
        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": failed to create agent '" << effective_agent_id
                                   << "'; clearing live printer agent";
        set_live_printer_agent(nullptr);
        return;
    }
 
    // Compare the registered IDs, not only the implementation pointer. Different registry IDs
    // may intentionally be backed by the same implementation object (especially for plugins).
    const auto current_printer_agent = m_agent->get_printer_agent();
    if (current_printer_agent && current_printer_agent->get_agent_info().id == effective_agent_id) {
        // Orca: the agent type is unchanged (e.g. switching between two Moonraker/Klipper
        // printer presets), so the selected machine and the agent's cached device_info still
        // point at the previously active printer preset. Re-select the machine when the new
        // preset targets a different host, otherwise filament sync keeps hitting the old
        // printer. (#12506)
        if (effective_agent_id != BBL_PRINTER_AGENT_ID && m_device_manager && preset_bundle) {
            const std::string print_host = config.opt_string("print_host");
            if (!print_host.empty()) {
                const std::string dev_id = MachineObject::dev_id_from_address(print_host, config.opt_string("printhost_port"));
                MachineObject* sel = m_device_manager->get_selected_machine();
                const bool access_code_changed = effective_agent_id == MOONRAKER_PRINTER_AGENT_ID && sel &&
                                                 sel->get_access_code() != config.opt_string("printhost_apikey");
                if (!sel || sel->get_dev_id() != dev_id || access_code_changed)
                    select_machine(effective_agent_id);
            }
        }
        return;
    }
 
    // Swap the agent; set_live_printer_agent resets the device selection so the new
    // agent starts clean (#124).
    set_live_printer_agent(new_printer_agent);
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": printer agent switched to " << effective_agent_id;
 
    // Start discovery so Python agents can populate the device list via SSDP callback
    m_agent->start_discovery(true, false);
 
    // Auto-switch MachineObject (new agent has empty device_info, so always re-select)
    select_machine(effective_agent_id);
}

References Slic3r::BBL_CLOUD_PROVIDER(), Slic3r::BBL_PRINTER_AGENT_ID, Slic3r::NetworkAgentFactory::create_printer_agent_by_id(), Slic3r::data_dir(), Slic3r::MachineObject::dev_id_from_address(), Slic3r::MachineObject::get_access_code(), Slic3r::MachineObject::get_dev_id(), Slic3r::NetworkAgentFactory::get_printer_agent_info(), Slic3r::PrinterAgentInfo::id, m_agent, m_device_manager, mainframe, Slic3r::MOONRAKER_PRINTER_AGENT_ID, Slic3r::DynamicConfig::opt_string(), Slic3r::ORCA_CLOUD_PROVIDER(), plater_, preset_bundle, resolve_printer_agent_id(), select_machine(), set_live_printer_agent(), and switch_printer_agent().

Referenced by init_plugin_gui_wiring(), restart_networking(), switch_printer_agent(), and switch_printer_agent_if_pending().

Here is the call graph for this function:

Here is the caller graph for this function:

switch_printer_agent_if_pending()

void Slic3r::GUI::GUI_App::switch_printer_agent_if_pending

(

)

{
    if (!m_agent || !preset_bundle)
        return;
 
    const std::string wanted_agent_id = resolve_printer_agent_id(preset_bundle->printers.get_edited_preset().config.opt_string("printer_agent"));
    const auto        live_agent      = m_agent->get_printer_agent();
    if (live_agent && live_agent->get_agent_info().id == wanted_agent_id)
        return;
    if (!NetworkAgentFactory::get_printer_agent_info(wanted_agent_id))
        return;
 
    switch_printer_agent();
}

References Slic3r::NetworkAgentFactory::get_printer_agent_info(), m_agent, preset_bundle, resolve_printer_agent_id(), switch_printer_agent(), and switch_printer_agent_if_pending().

Referenced by init_plugin_gui_wiring(), and switch_printer_agent_if_pending().

Here is the call graph for this function:

Here is the caller graph for this function:

sync_bundle()

int Slic3r::GUI::GUI_App::sync_bundle	(	std::string	bundle_id,
		std::string	version )

{
    // if(preset_bundle->bundles.pauseReads.load())
    // {
    //     BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << __LINE__ << "ORCA : Update thread sync_bundle function yielded to main thread. 1";
    //     return; // if the main thread acquires the lock at the start of our operations, we will yield
    // }
    if (!m_agent || !m_agent->is_user_login()) return 0;
    auto orca_agent = std::dynamic_pointer_cast<OrcaCloudServiceAgent>(m_agent->get_cloud_agent());
    if (!orca_agent) return 0;
 
    BOOST_LOG_TRIVIAL(info) << "sync_bundle: checking bundle " << bundle_id << " for updates";
 
    bool is_new  =  false;
    bool is_update = false;
 
    preset_bundle->bundles.ReadLock(); // acquire a read lock to check for updates
 
    // if bundle already downloaded, check for updates
    auto bundle_it = preset_bundle->bundles.m_bundles.find(bundle_id);
    if (bundle_it != preset_bundle->bundles.m_bundles.end()) {
 
        // Check if remote version is newer using Semver comparison
        auto local_version = Semver::parse(bundle_it->second.version);
        auto remote_version = Semver::parse(version);
        
        BOOST_LOG_TRIVIAL(info) << "sync_bundle: comparing local version: " << local_version << " to remote version: " << remote_version;
 
        if (!local_version || !remote_version) {
            BOOST_LOG_TRIVIAL(warning) << "sync_bundle: failed to parse versions for bundle " << bundle_id
                                    << " (local: " << local_version << ", remote: " << remote_version << ")";
            preset_bundle->bundles.ReadUnlock(); // unlock read when fail
            return -1;
        }
        if (remote_version <= local_version) {
            BOOST_LOG_TRIVIAL(info) << "sync_bundle: bundle " << bundle_id << " is up-to-date (version " << local_version << ")";
            preset_bundle->bundles.ReadUnlock(); // unlock read when fail
            return -1;
        }
        BOOST_LOG_TRIVIAL(info) << "sync_bundle: updating bundle " << bundle_id
                                << " from version " << local_version
                                << " to version " << remote_version;
        is_update = true;
 
    }
    else {
        BOOST_LOG_TRIVIAL(info) << "sync_bundle: pulling newly subscribed bundle " << bundle_id << " at version " << version;
        is_new = true;
    }
 
    preset_bundle->bundles.ReadUnlock(); // yield the read lock after checking for updates 
 
    // if it is an update, we will lock and write
    std::string ver;
    if (is_update) {
        preset_bundle->bundles.WriteLock();
        preset_bundle->bundles.m_bundles[bundle_id].update_available = true;
        preset_bundle->bundles.m_bundles[bundle_id].is_subscribed = true;
        ver = preset_bundle->bundles.m_bundles[bundle_id].version;
        preset_bundle->bundles.WriteUnlock();
    }
 
    const bool auto_update = app_config->get_bool("preset_bundle_auto_update");
 
    if (is_update && !auto_update) {
        return 1;
    }
 
    if (auto_update || is_new) {
        // Fetch the latest bundle data from cloud
        std::map<std::string, std::map<std::string, std::string>> bundle_presets;
        BundleMetadata remote_metadata;
        int result = orca_agent->get_shared_bundle(bundle_id, &bundle_presets, &remote_metadata);
 
        if (result != 0) {
            BOOST_LOG_TRIVIAL(warning) << "sync_bundle: failed to fetch bundle " << bundle_id << ", result=" << result;
            return -1;
        }
 
        // Import the updated bundle on the main thread
        CallAfter(
            [this, bundle_id, bundle_presets, remote_metadata, is_new, is_update, ver]() {
                if (!is_closing() && preset_bundle && app_config) {
                    // Check the presets for any system vendors that need to be installed
                    for (auto data : bundle_presets) {
                        if (!check_preset_parent_available(data)) {
                            add_pending_vendor_preset(data);
                        }
                    }
                    load_pending_vendors();
 
                    // if(!preset_bundle->bundles.pauseReads.load()) // check again if we can actually update so as to not block the main thread
                    // {
                    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << __LINE__ << "ORCA : CallAfter from sync_bundle function actually updating subscribed presets";
                    
                    preset_bundle->bundles.WriteLock();
                    
                    preset_bundle->update_subscribed_presets(*app_config, bundle_presets, remote_metadata, ForwardCompatibilitySubstitutionRule::Enable);
 
                    preset_bundle->bundles.WriteUnlock();
 
                    if(is_new)
                    {
                        std::string text = format(_L("%s has been downloaded."), remote_metadata.name);
                        wxGetApp().plater()->get_notification_manager()->push_notification(NotificationType::CustomNotification,NotificationManager::NotificationLevel::RegularNotificationLevel,text);
                    }
                    else if(is_update)
                    {
                        std::string text = format(_L("%s updated from %s to %s"), remote_metadata.name, ver, remote_metadata.version);
                        wxGetApp().plater()->get_notification_manager()->push_notification(NotificationType::CustomNotification,NotificationManager::NotificationLevel::RegularNotificationLevel,text);
                    }
 
                    auto* evt = new wxCommandEvent(EVT_UPDATE_BUNDLE_COMPLETE);                                                                                                                                                       
                    // evt->SetString(wxString::FromUTF8(bundle_id));               
                    if (m_preset_bundle_dlg)                                                                                                                                                                                                                                                          
                        wxQueueEvent(m_preset_bundle_dlg, evt);                                                                                                                                                                                                                                       
                    else                                                                                                                                                                                                                                                                                 
                        delete evt;
                
                    if (mainframe)
                        mainframe->update_side_preset_ui();
                    BOOST_LOG_TRIVIAL(info) << "sync_bundle: successfully updated bundle " << bundle_id;
                    // }
                }
            });
    }
 
    return 0;
}

References _L, add_pending_vendor_preset(), app_config, check_preset_parent_available(), Slic3r::GUI::CustomNotification, Slic3r::Enable, Slic3r::GUI::format(), is_closing(), load_pending_vendors(), m_agent, m_preset_bundle_dlg, mainframe, Slic3r::BundleMetadata::name, Slic3r::Semver::parse(), preset_bundle, Slic3r::GUI::NotificationManager::RegularNotificationLevel, sync_bundle(), and Slic3r::BundleMetadata::version.

Referenced by start_sync_user_preset(), and sync_bundle().

Here is the call graph for this function:

Here is the caller graph for this function:

sync_preset()

void Slic3r::GUI::GUI_App::sync_preset	(	Preset *	preset,
		bool	force = false )

{
    int result = -1;
    unsigned int http_code = 200;
    std::string updated_info;
    long long update_time = 0;
    // only sync user's preset
    if (!m_agent) return;
    if (!preset->is_user()) return;
 
    auto setting_id = preset->setting_id;
    std::map<std::string, std::string> values_map;
 
    // Check and catch if the file is new and missing .info
    bool needs_init = setting_id.empty() && preset->sync_info.empty();
 
    // Actually process sync info
    if (needs_init || preset->sync_info.compare("create") == 0) {
        if (m_create_preset_blocked[preset->type])
            return;
        int ret = preset_bundle->get_differed_values_to_update(*preset, values_map);
        if (!ret) {
            std::string new_setting_id = m_agent->request_setting_id(preset->name, &values_map, &http_code);
            if (!new_setting_id.empty()) {
                setting_id = new_setting_id;
                result = 0;
                auto update_time_str = values_map[ORCA_JSON_KEY_UPDATE_TIME];
                if (!update_time_str.empty())
                    update_time = std::atoll(update_time_str.c_str());
            }
            else {
                BOOST_LOG_TRIVIAL(trace) << "[sync_preset]init: request_setting_id failed, http code "<<http_code;
                // do not post new preset this time if http code >= 400
                if (http_code >= 400) {
                    result = 0;
                    updated_info = "hold";
                } else
                    result = -1;
            }
        }
        else {
            BOOST_LOG_TRIVIAL(trace) << "[sync_preset]init: can not generate differed key-values";
            result = 0;
            updated_info = "hold";
        }
    }
    else if (preset->sync_info.compare("create") == 0) {
        if (m_create_preset_blocked[preset->type])
            return;
        int ret = preset_bundle->get_differed_values_to_update(*preset, values_map);
        if (!ret) {
            std::string new_setting_id = m_agent->request_setting_id(preset->name, &values_map, &http_code);
            if (!new_setting_id.empty()) {
                setting_id = new_setting_id;
                result = 0;
                auto update_time_str = values_map[ORCA_JSON_KEY_UPDATE_TIME];
                if (!update_time_str.empty())
                    update_time = std::atoll(update_time_str.c_str());
            } else {
                BOOST_LOG_TRIVIAL(trace) << "[sync_preset]create: request_setting_id failed, http code "<<http_code;
                // do not post new preset this time if http code >= 400
                if (http_code >= 400) {
                    result = 0;
                    updated_info = "hold";
                }
            }
        } else {
            BOOST_LOG_TRIVIAL(trace) << "[sync_preset]create: can not generate differed preset";
        }
    } else if (preset->sync_info.compare("update") == 0) {
        if (!setting_id.empty()) {
            int ret = preset_bundle->get_differed_values_to_update(*preset, values_map);
            if (!ret) {
                if (auto iter = values_map.find(BBL_JSON_KEY_BASE_ID); iter != values_map.end() && iter->second == setting_id) {
                    //clear the setting_id in this case ???
                    setting_id.clear();
                    result = 0;
                }
                else {
                    result = m_agent->put_setting(setting_id, preset->name, &values_map, &http_code, ORCA_CLOUD_PROVIDER, force);
                    if (http_code >= 400) {
                        result       = 0;
                        updated_info = "hold";
                        BOOST_LOG_TRIVIAL(error) << "[sync_preset] put setting_id = " << setting_id << " failed, http_code = " << http_code;
                    } else {
                            auto update_time_str = values_map[ORCA_JSON_KEY_UPDATE_TIME];
                            if (!update_time_str.empty())
                                update_time = std::atoll(update_time_str.c_str());
                    }
                }
 
            }
            else {
                BOOST_LOG_TRIVIAL(trace) << "[sync_preset]update: can not generate differed key-values, we need to skip this preset "<< preset->name;
                result = 0;
            }
        }
        else {
            //clear the sync_info
            result = 0;
        }
    }
 
    if (http_code >= 400 && values_map["code"] == "14") { // Limit
        m_create_preset_blocked[preset->type] = true;
        CallAfter([this] {
            plater()->get_notification_manager()->push_notification(NotificationType::BBLUserPresetExceedLimit);
            static bool dialog_notified = false;
            if (dialog_notified)
                return;
            dialog_notified = true;
            if (mainframe == nullptr)
                return;
            auto msg = _L("The number of user presets cached in the cloud has exceeded the upper limit, newly created user presets can only be used locally.");
            MessageDialog(mainframe, msg, _L("Sync user presets"), wxICON_WARNING | wxOK).ShowModal();
        });
        return; // this error not need hold, and should not hold
    }
 
    // Handle HTTP 413 - Payload Too Large
    if (http_code == 413) {
        // Set sync_info to "will_not_sync" so this preset won't be synced again
        updated_info = "will_not_sync";
        result = 0; // Set to 0 so the sync_info gets saved below
 
        // Show user notification
        CallAfter([this, name = preset->name] {
            static bool size_limit_dialog_notified = false;
            if (size_limit_dialog_notified)
                return;
            size_limit_dialog_notified = true;
            if (mainframe == nullptr)
                return;
            auto msg = format_wxstr(_L("The preset \"%s\" is too large to sync to the cloud (exceeds 1MB). Please reduce the preset size by removing custom configurations or use it locally only."), name);
            MessageDialog(mainframe, msg, _L("Sync user presets"), wxICON_WARNING | wxOK).ShowModal();
        });
        // NOTE: Don't return here - let execution continue to save the sync_info
    }
 
    // update sync_info preset info in file
    if (result == 0) {
        //PresetBundle* preset_bundle = wxGetApp().preset_bundle;
        if (!this->preset_bundle) return;
 
        BOOST_LOG_TRIVIAL(trace) << "sync_preset: sync operation: " << preset->sync_info << " success! preset = " << preset->name;
        if (preset->type == Preset::Type::TYPE_FILAMENT) {
            preset_bundle->filaments.set_sync_info_and_save(preset->name, setting_id, updated_info, update_time, m_agent->get_user_id());
        } else if (preset->type == Preset::Type::TYPE_PRINT) {
            preset_bundle->prints.set_sync_info_and_save(preset->name, setting_id, updated_info, update_time, m_agent->get_user_id());
        } else if (preset->type == Preset::Type::TYPE_PRINTER) {
            preset_bundle->printers.set_sync_info_and_save(preset->name, setting_id, updated_info, update_time, m_agent->get_user_id());
        }
    }
}

References _L, BBL_JSON_KEY_BASE_ID, Slic3r::GUI::BBLUserPresetExceedLimit, Slic3r::Preset::is_user(), m_agent, m_create_preset_blocked, mainframe, Slic3r::Preset::name, Slic3r::ORCA_CLOUD_PROVIDER(), ORCA_JSON_KEY_UPDATE_TIME, plater(), preset_bundle, Slic3r::Preset::setting_id, Slic3r::GUI::DPIAware< P >::ShowModal(), Slic3r::Preset::sync_info, sync_preset(), Slic3r::trace(), Slic3r::Preset::type, Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINT, and Slic3r::Preset::TYPE_PRINTER.

Referenced by start_sync_user_preset(), and sync_preset().

Here is the call graph for this function:

Here is the caller graph for this function:

tab_panel()

Notebook * Slic3r::GUI::GUI_App::tab_panel

(

)

const

{
    if (mainframe)
        return mainframe->m_tabpanel;
    return nullptr;
}

References mainframe, and tab_panel().

Referenced by tab_panel().

Here is the call graph for this function:

Here is the caller graph for this function:

tabs_as_menu()

bool Slic3r::GUI::GUI_App::tabs_as_menu

(

)

const

{
    return false;
}

References tabs_as_menu().

Referenced by tabs_as_menu(), and update_mode().

Here is the call graph for this function:

Here is the caller graph for this function:

toggle_canvas_zoom_button()

void Slic3r::GUI::GUI_App::toggle_canvas_zoom_button ( ) const

inline

{ app_config->set_bool("show_canvas_zoom_button", !show_canvas_zoom_button()); }

References app_config, and show_canvas_zoom_button().

Here is the call graph for this function:

toggle_focus_mode()

void Slic3r::GUI::GUI_App::toggle_focus_mode ( ) const

inline

{ app_config->set_bool("focus_mode", !focus_mode()); }

References app_config, and focus_mode().

Here is the call graph for this function:

toggle_show_3d_navigator()

void Slic3r::GUI::GUI_App::toggle_show_3d_navigator ( ) const

inline

{ app_config->set_bool("show_3d_navigator", !show_3d_navigator()); }

References app_config, and show_3d_navigator().

Here is the call graph for this function:

toggle_show_center_of_mass()

void Slic3r::GUI::GUI_App::toggle_show_center_of_mass ( ) const

inline

{ app_config->set_bool("show_center_of_mass", !show_center_of_mass()); }

References app_config, and show_center_of_mass().

Here is the call graph for this function:

toggle_show_gcode_window()

void Slic3r::GUI::GUI_App::toggle_show_gcode_window

(

)

{
    m_show_gcode_window = !m_show_gcode_window;
    app_config->set_bool("show_gcode_window", m_show_gcode_window);
}

References app_config, and m_show_gcode_window.

toggle_show_outline()

void Slic3r::GUI::GUI_App::toggle_show_outline ( ) const

inline

{ app_config->set_bool("show_outline", !show_outline()); }

References app_config, and show_outline().

Here is the call graph for this function:

toggle_show_plate_gridlines()

void Slic3r::GUI::GUI_App::toggle_show_plate_gridlines ( ) const

inline

{ app_config->set_bool("show_plate_gridlines", !show_plate_gridlines()); }

References app_config, and show_plate_gridlines().

Here is the call graph for this function:

toolbar_icon_scale()

float Slic3r::GUI::GUI_App::toolbar_icon_scale

(

const bool

is_limited = false

)

const

{
#ifdef __APPLE__
    const float icon_sc = 1.0f; // for Retina display will be used its own scale
#else
    const float icon_sc = m_em_unit * 0.1f;
#endif // __APPLE__
 
    //return icon_sc;
 
    const std::string& auto_val = app_config->get("toolkit_size");
 
    if (auto_val.empty())
        return icon_sc;
 
    int int_val =  100;
    // correct value in respect to toolkit_size
    int_val = std::min(atoi(auto_val.c_str()), int_val);
 
    if (is_limited && int_val < 50)
        int_val = 50;
 
    return 0.01f * int_val * icon_sc;
}

References app_config, m_em_unit, and toolbar_icon_scale().

Referenced by toolbar_icon_scale().

Here is the call graph for this function:

Here is the caller graph for this function:

transition_tridid()

wxString Slic3r::GUI::GUI_App::transition_tridid

(

int

trid_id

)

const

{
    if (trid_id == VIRTUAL_TRAY_MAIN_ID || trid_id == VIRTUAL_TRAY_DEPUTY_ID)
    {
        assert(0);
        return _L("Ext");
    }
 
    wxString maping_dict[] = { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" };
 
    if (trid_id >= 128 * 4) {
        trid_id -= 128 * 4;
        int id_index = trid_id / 4;
        return wxString::Format("%s", maping_dict[id_index]);
    }
    else if (trid_id >= 0x80 && trid_id <= 0x87) { // n3s
        const char base = 'A' + (trid_id - 128);
        wxString prefix("HT-");
        prefix.append(base);
        return prefix;
    }
    else {
        int id_index = std::clamp((int)ceil(trid_id / 4), 0, 25);
        int id_suffix = trid_id % 4 + 1;
        return wxString::Format("%s%d", maping_dict[id_index], id_suffix);
    }
}

References _L, transition_tridid(), VIRTUAL_TRAY_DEPUTY_ID, and VIRTUAL_TRAY_MAIN_ID.

Referenced by transition_tridid().

Here is the call graph for this function:

Here is the caller graph for this function:

troubleshoot()

void Slic3r::GUI::GUI_App::troubleshoot

(

)

{
    TroubleshootDialog dlg;
    if (dlg.ShowModal() == wxID_REMOVE)
         wxGetApp().mainframe->Close(false);
}

References Slic3r::GUI::DPIAware< P >::ShowModal(), and troubleshoot().

Referenced by troubleshoot().

Here is the call graph for this function:

Here is the caller graph for this function:

unsubscribe_bundle()

bool Slic3r::GUI::GUI_App::unsubscribe_bundle

(

const std::string &

id

)

{
    auto orca_agent = std::dynamic_pointer_cast<OrcaCloudServiceAgent>(m_agent->get_cloud_agent());
    return orca_agent->unsubscribe_bundle(id);
}

References m_agent, and unsubscribe_bundle().

Referenced by unsubscribe_bundle().

Here is the call graph for this function:

Here is the caller graph for this function:

Update_dark_mode_flag()

void Slic3r::GUI::GUI_App::Update_dark_mode_flag

(

)

{
    m_is_dark_mode = dark_mode();
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": switch the current dark mode status to %1% ")%m_is_dark_mode;
}

References dark_mode(), m_is_dark_mode, and Update_dark_mode_flag().

Referenced by on_init_inner(), and Update_dark_mode_flag().

Here is the call graph for this function:

Here is the caller graph for this function:

update_fonts()

void Slic3r::GUI::GUI_App::update_fonts

(

const MainFrame *

main_frame = nullptr

)

{
    /* Only normal and bold fonts are used for an application rescale,
     * because of under MSW small and normal fonts are the same.
     * To avoid same rescaling twice, just fill this values
     * from rescaled MainFrame
     */
  if (main_frame == nullptr)
    main_frame = this->mainframe;
    m_normal_font   = Label::Body_14; // BBS: larger font size
    m_small_font    = m_normal_font;
    m_bold_font     = m_normal_font.Bold();
    m_link_font     = m_bold_font.Underlined();
    m_em_unit       = main_frame->em_unit();
    m_code_font.SetPointSize(m_small_font.GetPointSize());
}

References Label::Body_14, Slic3r::GUI::DPIAware< P >::em_unit(), m_bold_font, m_code_font, m_em_unit, m_link_font, m_normal_font, m_small_font, mainframe, and update_fonts().

Referenced by update_fonts().

Here is the call graph for this function:

Here is the caller graph for this function:

update_internal_development()

void Slic3r::GUI::GUI_App::update_internal_development

(

)

                                          {
    if (WebViewPanel* home = WebViewPanel::if_built())
        home->update_mode();
    if (PrinterWebView* view = PrinterWebView::if_built())
        view->update_mode();
}

References Slic3r::GUI::LazyInstance< PrinterWebView >::if_built(), Slic3r::GUI::LazyInstance< WebViewPanel >::if_built(), and update_internal_development().

Referenced by update_internal_development().

Here is the call graph for this function:

Here is the caller graph for this function:

update_label_colours()

void Slic3r::GUI::GUI_App::update_label_colours

(

)

{
    for (Tab* tab : tabs_list)
        tab->update_label_colours();
}

References tabs_list, and update_label_colours().

Referenced by update_label_colours(), and update_ui_from_settings().

Here is the call graph for this function:

Here is the caller graph for this function:

update_label_colours_from_appconfig()

void Slic3r::GUI::GUI_App::update_label_colours_from_appconfig

(

)

{
    if (app_config->has("label_clr_sys")) {
        auto str = app_config->get("label_clr_sys");
        if (str != "")
            m_color_label_sys = wxColour(str);
    }
 
    if (app_config->has("label_clr_modified")) {
        auto str = app_config->get("label_clr_modified");
        if (str != "")
            m_color_label_modified = wxColour(str);
    }
}

References app_config, m_color_label_modified, m_color_label_sys, and update_label_colours_from_appconfig().

Referenced by update_label_colours_from_appconfig().

Here is the call graph for this function:

Here is the caller graph for this function:

update_mode()

void Slic3r::GUI::GUI_App::update_mode

(

)

{
    sidebar().update_mode();
 
    //BBS: GUI refactor
    if (mainframe->m_param_panel)
        mainframe->m_param_panel->update_mode();
    if (mainframe->m_param_dialog)
        mainframe->m_param_dialog->panel()->update_mode();
    if (PrinterWebView* view = PrinterWebView::if_built())
        view->update_mode();
    if (WebViewPanel* home = WebViewPanel::if_built())
        home->update_mode();
 
#ifdef _MSW_DARK_MODE
    if (!wxGetApp().tabs_as_menu())
        dynamic_cast<Notebook*>(mainframe->m_tabpanel)->UpdateMode();
#endif
 
    for (auto tab : tabs_list)
        tab->update_mode();
    for (auto tab : model_tabs_list)
        tab->update_mode();
 
    //BBS plater()->update_menus();
 
    plater()->canvas3D()->update_gizmos_on_off_state();
}

References Slic3r::GUI::LazyInstance< PrinterWebView >::if_built(), Slic3r::GUI::LazyInstance< WebViewPanel >::if_built(), mainframe, model_tabs_list, plater(), sidebar(), tabs_as_menu(), tabs_list, and update_mode().

Referenced by Slic3r::GUI::anonymous_namespace{NativeCommands.cpp}::build_command_catalog(), enable_developer_mode(), on_init_inner(), recreate_GUI(), Slic3r::GUI::ConfigWizard::run(), Slic3r::GUI::GuideFrame::run(), save_mode(), and update_mode().

Here is the call graph for this function:

Here is the caller graph for this function:

update_publish_status()

void Slic3r::GUI::GUI_App::update_publish_status

(

)

{
    // mainframe->show_publish_button(has_model_mall());
    // if (app_config->get("staff_pick_switch") == "true") {
    //     mainframe->m_webview->SendDesignStaffpick(has_model_mall());
    // }
}

References update_publish_status().

Referenced by on_init_inner(), recreate_GUI(), run_wizard(), ShowUserGuide(), and update_publish_status().

Here is the call graph for this function:

Here is the caller graph for this function:

update_saved_preset_from_current_preset()

void Slic3r::GUI::GUI_App::update_saved_preset_from_current_preset

(

)

{
    PrinterTechnology printer_technology = preset_bundle->printers.get_edited_preset().printer_technology();
    for (Tab* tab : tabs_list) {
        if (tab->supports_printer_technology(printer_technology))
            tab->update_saved_preset_from_current_preset();
    }
}

References preset_bundle, Slic3r::GUI::printer_technology(), tabs_list, and update_saved_preset_from_current_preset().

Referenced by update_saved_preset_from_current_preset().

Here is the call graph for this function:

Here is the caller graph for this function:

update_single_bundle()

void Slic3r::GUI::GUI_App::update_single_bundle

(

wxCommandEvent &

evt

)

{
    if (!m_agent || !m_agent->is_user_login()) return;
    auto orca_agent = std::dynamic_pointer_cast<OrcaCloudServiceAgent>(m_agent->get_cloud_agent());
    if (!orca_agent) return;
 
    const std::string bundle_id = evt.GetString().ToStdString();
 
    // Fetch the latest bundle data from cloud
    std::map<std::string, std::map<std::string, std::string>> bundle_presets;
    BundleMetadata remote_metadata;
    int result = orca_agent->get_shared_bundle(bundle_id, &bundle_presets, &remote_metadata);
 
    if (result != 0) {
        BOOST_LOG_TRIVIAL(warning) << "sync_bundle: failed to fetch bundle " << bundle_id << ", result=" << result;
        return;
    }
 
    // Import the updated bundle on the main thread
    CallAfter([this, bundle_id, bundle_presets, remote_metadata]() {
        if (!is_closing() && preset_bundle && app_config) {
            // Check the presets for any system vendors that need to be installed
            for (auto data : bundle_presets) {
                if (!check_preset_parent_available(data)) {
                    add_pending_vendor_preset(data);
                }
            }
            load_pending_vendors();
 
            preset_bundle->bundles.ReadLock();
            std::string initial_version = preset_bundle->bundles.m_bundles[bundle_id].version;
            preset_bundle->bundles.ReadUnlock();
 
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << __LINE__ << "ORCA : CallAfter from update_single_bundle function actually updating subscribed presets";
            
            preset_bundle->bundles.WriteLock();
            
            preset_bundle->update_subscribed_presets(*app_config, bundle_presets, remote_metadata, ForwardCompatibilitySubstitutionRule::Enable);
 
            preset_bundle->bundles.WriteUnlock();
            
            std::string text = format(_L("%s updated from %s to %s"), remote_metadata.name, initial_version, remote_metadata.version);
            wxGetApp().plater()->get_notification_manager()->push_notification(NotificationType::CustomNotification,NotificationManager::NotificationLevel::RegularNotificationLevel,text);
            
            auto* evt = new wxCommandEvent(EVT_UPDATE_BUNDLE_COMPLETE);                                                                                                                                                       
            // evt->SetString(wxString::FromUTF8(bundle_id));               
            if (m_preset_bundle_dlg)                                                                                                                                                                                                                                                          
                wxQueueEvent(m_preset_bundle_dlg, evt);                                                                                                                                                                                                                                       
            else                                                                                                                                                                                                                                                                                 
                delete evt;                                                                                                                                                                           
            // wxQueueEvent(&wxGetApp(), evt); //  GUI_App -> dialog
        
            if (mainframe)
                mainframe->update_side_preset_ui();
            BOOST_LOG_TRIVIAL(info) << "sync_bundle: successfully updated bundle " << bundle_id;
            
        }
    });
}

References _L, add_pending_vendor_preset(), app_config, check_preset_parent_available(), Slic3r::GUI::CustomNotification, Slic3r::Enable, Slic3r::GUI::format(), is_closing(), load_pending_vendors(), m_agent, m_preset_bundle_dlg, mainframe, Slic3r::BundleMetadata::name, preset_bundle, Slic3r::GUI::NotificationManager::RegularNotificationLevel, update_single_bundle(), and Slic3r::BundleMetadata::version.

Referenced by start_sync_user_preset(), and update_single_bundle().

Here is the call graph for this function:

Here is the caller graph for this function:

update_ui_from_settings()

void Slic3r::GUI::GUI_App::update_ui_from_settings

(

)

{
    update_label_colours();
    // Upadte UI colors before Update UI from settings
    if (m_force_colors_update) {
        m_force_colors_update = false;
        //UpdateDlgDarkUI(&mainframe->m_settings_dialog);
        //mainframe->m_settings_dialog.Refresh();
        //mainframe->m_settings_dialog.Update();
 
        if (mainframe) {
#ifdef __WINDOWS__
            mainframe->force_color_changed();
            update_scrolls(mainframe);
            update_scrolls(&mainframe->m_settings_dialog);
#endif //_MSW_DARK_MODE
            update_dark_children_ui(mainframe);
        }
    }
 
    if (mainframe) {mainframe->update_ui_from_settings();}
}

References m_force_colors_update, mainframe, Slic3r::GUI::update_dark_children_ui(), update_label_colours(), and update_ui_from_settings().

Referenced by update_ui_from_settings().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateAllStaticTextDarkUI()

void Slic3r::GUI::GUI_App::UpdateAllStaticTextDarkUI

(

wxWindow *

parent

)

{
#ifdef __WINDOWS__
    wxGetApp().UpdateDarkUI(parent);
 
    auto children = parent->GetChildren();
    for (auto child : children) {
        if (dynamic_cast<wxStaticText*>(child))
            child->SetForegroundColour(m_color_label_default);
    }
#endif
}

References m_color_label_default, and UpdateAllStaticTextDarkUI().

Referenced by UpdateAllStaticTextDarkUI().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateDarkUI()

void Slic3r::GUI::GUI_App::UpdateDarkUI	(	wxWindow *	window,
		bool	highlited = false,
		bool	just_font = false )

{
    if (wxButton *btn = dynamic_cast<wxButton*>(window)) {
        if (btn->GetWindowStyleFlag() & wxBU_AUTODRAW)
            return;
        else {
#ifdef _WIN32
            if (btn->GetId() == wxID_OK || btn->GetId() == wxID_CANCEL) {
                bool is_focused_button = false;
                bool is_default_button = false;
 
                if (!(btn->GetWindowStyle() & wxNO_BORDER)) {
                    btn->SetWindowStyle(btn->GetWindowStyle() | wxNO_BORDER);
                    highlited = true;
                }
 
                auto mark_button = [this, btn, highlited](const bool mark) {
                    btn->SetBackgroundColour(mark ? m_color_selected_btn_bg : highlited ? m_color_highlight_default : m_color_window_default);
                    btn->SetForegroundColour(mark ? m_color_hovered_btn_label :m_color_default_btn_label);
                    btn->Refresh();
                    btn->Update();
                };
 
                // hovering
                btn->Bind(wxEVT_ENTER_WINDOW, [mark_button](wxMouseEvent& event) { mark_button(true); event.Skip(); });
                btn->Bind(wxEVT_LEAVE_WINDOW, [mark_button, btn](wxMouseEvent& event) { mark_button(is_focused(btn->GetHWND())); event.Skip(); });
                // focusing
                btn->Bind(wxEVT_SET_FOCUS, [mark_button](wxFocusEvent& event) { mark_button(true); event.Skip(); });
                btn->Bind(wxEVT_KILL_FOCUS, [mark_button](wxFocusEvent& event) { mark_button(false); event.Skip(); });
 
                is_focused_button = is_focused(btn->GetHWND());
                is_default_button = is_default(btn);
                mark_button(is_focused_button);
            }
#endif
        }
    }
 
    if (Button* btn = dynamic_cast<Button*>(window)) {
        if (btn->GetWindowStyleFlag() & wxBU_AUTODRAW)
            return;
    }
 
 
    /*if (m_is_dark_mode != dark_mode() )
        m_is_dark_mode = dark_mode();*/
 
    if (m_is_dark_mode) {
 
        auto orig_col = window->GetBackgroundColour();
        auto bg_col = StateColor::darkModeColorFor(orig_col);
        // there are cases where the background color of an item is bright, specifically:
        // * the background color of a button: #009688  -- 73
        if (bg_col != orig_col) {
            window->SetBackgroundColour(bg_col);
        }
 
        orig_col = window->GetForegroundColour();
        auto fg_col = StateColor::darkModeColorFor(orig_col);
        auto fg_l = StateColor::GetLightness(fg_col);
 
        auto color_difference = StateColor::GetColorDifference(bg_col, fg_col);
 
        // fallback and sanity check with LAB
        // color difference of less than 2 or 3 is not normally visible, and even less than 30-40 doesn't stand out
        if (color_difference < 10) {
            fg_col = StateColor::SetLightness(fg_col, 90);
        }
        // some of the stock colors have a lightness of ~49
        if (fg_l < 45) {
            fg_col = StateColor::SetLightness(fg_col, 70);
        }
        // at this point it shouldn't be possible that fg_col is the same as bg_col, but let's be safe
        if (fg_col == bg_col) {
            fg_col = StateColor::SetLightness(fg_col, 70);
        }
 
        window->SetForegroundColour(fg_col);
    }
    else {
        auto original_col = window->GetBackgroundColour();
        auto bg_col = StateColor::lightModeColorFor(original_col);
 
        if (bg_col != original_col) {
            window->SetBackgroundColour(bg_col);
        }
 
        original_col = window->GetForegroundColour();
        auto fg_col = StateColor::lightModeColorFor(original_col);
 
        if (fg_col != original_col) {
            window->SetForegroundColour(fg_col);
        }
    }
}

References StateColor::darkModeColorFor(), StateColor::GetColorDifference(), StateColor::GetLightness(), StateColor::lightModeColorFor(), m_color_default_btn_label, m_color_highlight_default, m_color_hovered_btn_label, m_color_selected_btn_bg, m_color_window_default, m_is_dark_mode, StateColor::SetLightness(), UpdateDarkUI(), and Slic3r::GUI::wxMouseEvent.

Referenced by UpdateDarkUI(), and UpdateDVCDarkUI().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateDarkUIWin()

void Slic3r::GUI::GUI_App::UpdateDarkUIWin

(

wxWindow *

win

)

{
    update_dark_children_ui(win);
}

References Slic3r::GUI::update_dark_children_ui(), and UpdateDarkUIWin().

Referenced by UpdateDarkUIWin().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateDlgDarkUI()

void Slic3r::GUI::GUI_App::UpdateDlgDarkUI

(

wxDialog *

dlg

)

{
#ifdef __WINDOWS__
    NppDarkMode::SetDarkExplorerTheme(dlg->GetHWND());
    NppDarkMode::SetDarkTitleBar(dlg->GetHWND());
#endif
    update_dark_children_ui(dlg);
}

References NppDarkMode::SetDarkExplorerTheme(), NppDarkMode::SetDarkTitleBar(), Slic3r::GUI::update_dark_children_ui(), and UpdateDlgDarkUI().

Referenced by UpdateDlgDarkUI().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateDVCDarkUI()

void Slic3r::GUI::GUI_App::UpdateDVCDarkUI	(	wxDataViewCtrl *	dvc,
		bool	highlited = false )

{
#ifdef __WINDOWS__
    UpdateDarkUI(dvc, highlited ? dark_mode() : false);
#ifdef _MSW_DARK_MODE
    //dvc->RefreshHeaderDarkMode(&m_normal_font);
    HWND hwnd;
    if (!dvc->HasFlag(wxDV_NO_HEADER)) {
        hwnd = (HWND) dvc->GenericGetHeader()->GetHandle();
        hwnd = GetWindow(hwnd, GW_CHILD);
        if (hwnd != NULL)
            NppDarkMode::SetDarkListViewHeader(hwnd);
        wxItemAttr attr;
        attr.SetTextColour(NppDarkMode::GetTextColor());
        attr.SetFont(m_normal_font);
        dvc->SetHeaderAttr(attr);
    }
#endif //_MSW_DARK_MODE
    if (dvc->HasFlag(wxDV_ROW_LINES))
        dvc->SetAlternateRowColour(m_color_highlight_default);
    if (dvc->GetBorder() != wxBORDER_SIMPLE)
        dvc->SetWindowStyle(dvc->GetWindowStyle() | wxBORDER_SIMPLE);
#endif
}

References dark_mode(), NppDarkMode::GetTextColor(), m_color_highlight_default, m_normal_font, NppDarkMode::SetDarkListViewHeader(), UpdateDarkUI(), and UpdateDVCDarkUI().

Referenced by UpdateDVCDarkUI().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateFrameDarkUI()

void Slic3r::GUI::GUI_App::UpdateFrameDarkUI

(

wxFrame *

dlg

)

{
#ifdef __WINDOWS__
    NppDarkMode::SetDarkExplorerTheme(dlg->GetHWND());
    NppDarkMode::SetDarkTitleBar(dlg->GetHWND());
#endif
    update_dark_children_ui(dlg);
}

References NppDarkMode::SetDarkExplorerTheme(), NppDarkMode::SetDarkTitleBar(), Slic3r::GUI::update_dark_children_ui(), and UpdateFrameDarkUI().

Referenced by UpdateFrameDarkUI().

Here is the call graph for this function:

Here is the caller graph for this function:

updating_bambu_networking()

int Slic3r::GUI::GUI_App::updating_bambu_networking ( )

private

{
    DownloadProgressDialog dlg(_L("Downloading Bambu Network Plug-in"));
    dlg.ShowModal();
    return 0;
}

References _L, and Slic3r::GUI::DPIAware< P >::ShowModal().

Here is the call graph for this function:

url_decode()

std::string Slic3r::GUI::GUI_App::url_decode

(

std::string

value

)

                                             {
    return Http::url_decode(value);
}

References url_decode(), and Slic3r::Http::url_decode().

Referenced by handle_web_request(), and url_decode().

Here is the call graph for this function:

Here is the caller graph for this function:

url_encode()

std::string Slic3r::GUI::GUI_App::url_encode

(

std::string

value

)

                                             {
    return Http::url_encode(value);
}

References url_encode(), and Slic3r::Http::url_encode().

Referenced by open_mall_page_dialog(), open_publish_page_dialog(), and url_encode().

Here is the call graph for this function:

Here is the caller graph for this function:

use_legacy_network_plugin()

bool Slic3r::GUI::GUI_App::use_legacy_network_plugin

(

)

const

{
    return app_config && BBLNetworkPlugin::is_legacy_version(app_config->get_network_plugin_version());
}

References app_config, and Slic3r::BBLNetworkPlugin::is_legacy_version().

Referenced by check_networking_version(), download_plugin(), get_plugin_url(), and on_init_inner().

Here is the call graph for this function:

Here is the caller graph for this function:

wait_for_network_idle()

bool Slic3r::GUI::GUI_App::wait_for_network_idle ( int timeout_ms )

private

{
    const auto deadline = std::chrono::steady_clock::now() +
                          std::chrono::milliseconds(timeout_ms);
 
    while (std::chrono::steady_clock::now() < deadline) {
        if (!m_agent) {
            return true;  // Agent already gone
        }
 
        // Verify all operations completed
        bool server_disconnected = !m_agent->is_server_connected();
 
        if (server_disconnected) {
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": network is idle";
            return true;
        }
 
        // Process events while waiting
        if (wxTheApp) {
            wxTheApp->ProcessPendingEvents();
        }
 
        std::this_thread::sleep_for(std::chrono::milliseconds(POLL_INTERVAL_MS));
    }
 
    BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": timeout after " << timeout_ms
                                << "ms, server_connected=" << (m_agent ? m_agent->is_server_connected() : false);
    return false;
}

References m_agent.

Referenced by hot_reload_network_plugin().

Here is the caller graph for this function:

window_pos_center()

void Slic3r::GUI::GUI_App::window_pos_center ( wxTopLevelWindow * window )

private

{
    /*unsigned*/int display_idx = wxDisplay::GetFromWindow(window);
    wxRect display;
    if (display_idx == wxNOT_FOUND) {
        display = wxDisplay(0u).GetClientArea();
        window->Move(display.GetTopLeft());
    } else {
        display = wxDisplay(display_idx).GetClientArea();
    }
 
    auto metrics = WindowMetrics::from_window(window);
    metrics.center_for_display(display);
    if (window->GetScreenRect() != metrics.get_rect()) {
        window->SetSize(metrics.get_rect());
    }
}

References Slic3r::GUI::WindowMetrics::from_window(), and window_pos_center().

Referenced by persist_window_geometry(), and window_pos_center().

Here is the call graph for this function:

Here is the caller graph for this function:

window_pos_restore()

bool Slic3r::GUI::GUI_App::window_pos_restore ( wxTopLevelWindow * window, const std::string & name, bool default_maximized = false )

private

{
    if (name.empty()) { return false; }
    const auto config_key = (boost::format("window_%1%") % name).str();
 
    if (! app_config->has(config_key)) {
        //window->Maximize(default_maximized);
        return false;
    }
 
    auto metrics = WindowMetrics::deserialize(app_config->get(config_key));
    if (! metrics) {
        window->Maximize(default_maximized);
        return true;
    }
 
    const wxRect& rect = metrics->get_rect();
#if defined(__WXGTK__)
    // On Wayland, SetPosition() is a no-op for top-level windows.
    // Only restore size and maximize state.
    if (!Slic3r::GUI::is_running_on_wayland())
#endif
        window->SetPosition(rect.GetPosition());
    window->SetSize(rect.GetSize());
    window->Maximize(metrics->get_maximized());
    return true;
}

References app_config, Slic3r::GUI::WindowMetrics::deserialize(), and window_pos_restore().

Referenced by persist_window_geometry(), and window_pos_restore().

Here is the call graph for this function:

Here is the caller graph for this function:

window_pos_sanitize()

void Slic3r::GUI::GUI_App::window_pos_sanitize ( wxTopLevelWindow * window )

private

{
    /*unsigned*/int display_idx = wxDisplay::GetFromWindow(window);
    wxRect display;
    if (display_idx == wxNOT_FOUND) {
        display = wxDisplay(0u).GetClientArea();
        window->Move(display.GetTopLeft());
    } else {
        display = wxDisplay(display_idx).GetClientArea();
    }
 
    auto metrics = WindowMetrics::from_window(window);
    metrics.sanitize_for_display(display);
    if (window->GetScreenRect() != metrics.get_rect()) {
        window->SetSize(metrics.get_rect());
    }
}

References Slic3r::GUI::WindowMetrics::from_window(), and window_pos_sanitize().

Referenced by persist_window_geometry(), and window_pos_sanitize().

Here is the call graph for this function:

Here is the caller graph for this function:

window_pos_save()

void Slic3r::GUI::GUI_App::window_pos_save ( wxTopLevelWindow * window, const std::string & name )

private

{
    if (name.empty()) { return; }
    const auto config_key = (boost::format("window_%1%") % name).str();
 
    WindowMetrics metrics = WindowMetrics::from_window(window);
    app_config->set(config_key, metrics.serialize());
    app_config->save();
}

References app_config, Slic3r::GUI::WindowMetrics::from_window(), Slic3r::GUI::WindowMetrics::serialize(), and window_pos_save().

Referenced by persist_window_geometry(), and window_pos_save().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

app_config

AppConfig* Slic3r::GUI::GUI_App::app_config { nullptr }

{ nullptr };

Referenced by GUI_App(), ~GUI_App(), Slic3r::anonymous_namespace{PluginHostApp.cpp}::app_info(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::bind_filament_target(), Slic3r::GUI::anonymous_namespace{NativeCommands.cpp}::build_command_catalog(), check_and_keep_current_preset_changes(), check_and_save_current_preset_changes(), check_legacy_user_filament_presets(), check_networking_version(), check_new_version(), check_new_version_sf(), check_privacy_update(), check_privacy_version(), check_updates(), copy_network_if_available(), disassociate_files(), download_plugin(), enable_developer_mode(), enable_user_preset_folder(), focus_mode(), get_mode(), get_plugin_url(), get_saved_mode(), Slic3r::GUI::GUI_Run(), handle_web_request(), has_model_mall(), hot_reload_network_plugin(), import_model(), import_zip(), init_app_config(), init_download_path(), install_network_plugin_from_ota(), install_plugin(), is_enable_multi_machine(), link_to_lan_only_wiki(), link_to_network_check(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::list_bundle_ids(), load_gcode(), load_language(), load_pending_vendors(), load_project(), migrate_network_plugin_config(), on_init_inner(), on_init_network(), on_shortcuts_changed(), on_user_login_handle(), open_mall_page_dialog(), open_preferences(), open_publish_page_dialog(), post_init(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::reload_local_bundle(), reload_settings(), remove_user_presets(), restart_networking(), Slic3r::GUI::ConfigWizard::run(), Slic3r::GUI::GuideFrame::run(), save_mode(), scan_orphaned_info_files(), set_auto_toolbar_icon_scale(), set_mode(), set_skip_version(), show_3d_navigator(), show_canvas_zoom_button(), show_center_of_mass(), show_check_privacy_dlg(), show_network_plugin_download_dialog(), show_outline(), show_plate_gridlines(), start_download(), start_sync_user_preset(), starts_on_prepare(), sync_bundle(), toggle_canvas_zoom_button(), toggle_focus_mode(), toggle_show_3d_navigator(), toggle_show_center_of_mass(), toggle_show_gcode_window(), toggle_show_outline(), toggle_show_plate_gridlines(), toolbar_icon_scale(), update_label_colours_from_appconfig(), update_single_bundle(), use_legacy_network_plugin(), window_pos_restore(), and window_pos_save().

hms_query

HMSQuery* Slic3r::GUI::GUI_App::hms_query { nullptr }

private

{ nullptr };

Referenced by get_hms_query(), post_init(), and recreate_GUI().

init_params

GUI_InitParams* Slic3r::GUI::GUI_App::init_params { nullptr }

{ nullptr };

Referenced by Slic3r::GUI::GUI_Run(), init_glcontext(), on_init_inner(), and post_init().

last_active_point

std::chrono::system_clock::time_point Slic3r::GUI::GUI_App::last_active_point

Referenced by is_studio_active(), and reset_to_active().

login_dlg

ZUserLogin* Slic3r::GUI::GUI_App::login_dlg { nullptr }

private

{ nullptr };

Referenced by request_cloud_web_session(), ShowUserLogin(), and shutdown().

m_action_registry

ActionRegistry Slic3r::GUI::GUI_App::m_action_registry

Referenced by action_registry(), on_init_inner(), and open_preferences().

m_active_language_code

wxString Slic3r::GUI::GUI_App::m_active_language_code

private

Referenced by current_language_code(), and load_language().

m_adding_script_handler

bool Slic3r::GUI::GUI_App::m_adding_script_handler { false }

private

{ false };

Referenced by is_adding_script_handler(), on_init_inner(), and set_adding_script_handler().

m_agent

NetworkAgent* Slic3r::GUI::GUI_App::m_agent { nullptr }

private

{ nullptr };

Referenced by ~GUI_App(), check_bundle_updates(), check_login(), check_track_enable(), CleanUp(), cloud_webview_handoff(), enable_user_preset_folder(), force_push_conflicting_preset(), get_login_info(), getAgent(), handle_script_message(), hot_reload_network_plugin(), init_networking_callbacks(), is_user_login(), maybe_migrate_user_presets_on_login(), mint_cloud_web_session(), on_cloud_web_session_minted(), on_http_error(), on_init_inner(), on_init_network(), on_user_login(), on_user_login_handle(), OnExit(), open_orca_cloud(), post_init(), post_logout_to_webview(), process_delete_presets(), process_network_msg(), reload_settings(), remove_user_presets(), request_cloud_web_session(), request_user_logout(), request_user_unbind(), restart_networking(), set_live_printer_agent(), show_check_privacy_dlg(), ShowUserLogin(), shutdown(), start_sync_user_preset(), switch_printer_agent(), switch_printer_agent_if_pending(), sync_bundle(), sync_preset(), unsubscribe_bundle(), update_single_bundle(), and wait_for_network_idle().

m_app_conf_exists

bool Slic3r::GUI::GUI_App::m_app_conf_exists { false }

private

{ false };

Referenced by check_updates(), config_wizard_startup(), and init_app_config().

m_app_mode

EAppMode Slic3r::GUI::GUI_App::m_app_mode { EAppMode::Editor }

private

{ EAppMode::Editor };

Referenced by GUI_App(), get_app_mode(), is_editor(), and is_gcode_viewer().

m_bold_font

wxFont Slic3r::GUI::GUI_App::m_bold_font

private

Referenced by bold_font(), init_fonts(), and update_fonts().

m_check_network_thread

boost::thread Slic3r::GUI::GUI_App::m_check_network_thread

private

m_cloud_handoff_gen

uint64_t Slic3r::GUI::GUI_App::m_cloud_handoff_gen { 0 }

private

{ 0 };

Referenced by on_cloud_web_session_minted(), on_user_login_handle(), request_cloud_web_session(), and request_user_logout().

m_cloud_handoff_state

std::string Slic3r::GUI::GUI_App::m_cloud_handoff_state

private

Referenced by on_cloud_web_session_minted(), on_user_login_handle(), request_cloud_web_session(), and request_user_logout().

m_cloud_open_path

std::string Slic3r::GUI::GUI_App::m_cloud_open_path

private

Referenced by on_user_login_handle(), and open_orca_cloud().

m_code_font

wxFont Slic3r::GUI::GUI_App::m_code_font

private

Referenced by code_font(), init_fonts(), and update_fonts().

m_color_default_btn_label

wxColour Slic3r::GUI::GUI_App::m_color_default_btn_label

private

Referenced by init_label_colours(), and UpdateDarkUI().

m_color_highlight_default

wxColour Slic3r::GUI::GUI_App::m_color_highlight_default

private

Referenced by get_highlight_default_clr(), init_label_colours(), UpdateDarkUI(), and UpdateDVCDarkUI().

m_color_highlight_label_default

wxColour Slic3r::GUI::GUI_App::m_color_highlight_label_default

private

Referenced by get_label_highlight_clr(), and init_label_colours().

m_color_hovered_btn_label

wxColour Slic3r::GUI::GUI_App::m_color_hovered_btn_label

private

Referenced by get_color_hovered_btn_label(), init_label_colours(), and UpdateDarkUI().

m_color_label_default

wxColour Slic3r::GUI::GUI_App::m_color_label_default

private

Referenced by get_label_clr_default(), init_label_colours(), and UpdateAllStaticTextDarkUI().

m_color_label_modified

wxColour Slic3r::GUI::GUI_App::m_color_label_modified

private

Referenced by get_label_clr_modified(), init_label_colours(), and update_label_colours_from_appconfig().

m_color_label_sys

wxColour Slic3r::GUI::GUI_App::m_color_label_sys

private

Referenced by get_label_clr_sys(), init_label_colours(), and update_label_colours_from_appconfig().

m_color_selected_btn_bg

wxColour Slic3r::GUI::GUI_App::m_color_selected_btn_bg

private

Referenced by get_color_selected_btn_bg(), init_label_colours(), and UpdateDarkUI().

m_color_window_default

wxColour Slic3r::GUI::GUI_App::m_color_window_default

private

Referenced by get_window_default_clr(), init_label_colours(), and UpdateDarkUI().

m_config_corrupted

bool Slic3r::GUI::GUI_App::m_config_corrupted { false }

private

{ false };

Referenced by init_app_config(), and on_init_inner().

m_create_preset_blocked

std::vector<bool> Slic3r::GUI::GUI_App::m_create_preset_blocked { false, false, false, false, false, false }

private

{ false, false, false, false, false, false }; // excceed limit

Referenced by process_delete_presets(), and sync_preset().

m_datadir_redefined

bool Slic3r::GUI::GUI_App::m_datadir_redefined { false }

private

{ false };

Referenced by init_app_config().

m_device_manager

Slic3r::DeviceManager* Slic3r::GUI::GUI_App::m_device_manager { nullptr }

private

{ nullptr };

Referenced by getDeviceManager(), hot_reload_network_plugin(), on_init_network(), OnExit(), post_init(), push_notification(), request_user_logout(), restart_networking(), select_machine(), and switch_printer_agent().

m_downloader

std::unique_ptr<Downloader> Slic3r::GUI::GUI_App::m_downloader

private

Referenced by GUI_App(), downloader(), and start_download().

m_em_unit

int Slic3r::GUI::GUI_App::m_em_unit

private

Referenced by GUI_App(), em_unit(), get_min_size(), set_auto_toolbar_icon_scale(), toolbar_icon_scale(), and update_fonts().

m_filament_color_code_query

FilamentColorCodeQuery* Slic3r::GUI::GUI_App::m_filament_color_code_query { nullptr }

private

{ nullptr };

Referenced by get_filament_color_code_query().

m_force_colors_update

bool Slic3r::GUI::GUI_App::m_force_colors_update { false }

private

{ false };

Referenced by force_colors_update(), and update_ui_from_settings().

m_http_server

HttpServer Slic3r::GUI::GUI_App::m_http_server

private

Referenced by start_http_server(), start_http_server(), and stop_http_server().

m_imgui

std::unique_ptr<ImGuiWrapper> Slic3r::GUI::GUI_App::m_imgui

private

Referenced by GUI_App(), imgui(), and load_language().

m_info_dialog_content

wxString Slic3r::GUI::GUI_App::m_info_dialog_content

private

Referenced by get_inf_dialog_contect(), on_init_inner(), push_notification(), and show_dialog().

m_init_app_config_from_older

bool Slic3r::GUI::GUI_App::m_init_app_config_from_older { false }

private

{ false };

Referenced by on_init_inner().

m_initialized

bool Slic3r::GUI::GUI_App::m_initialized { false }

private

{ false };

Referenced by initialized(), and on_init_inner().

m_instance_hash_int

size_t Slic3r::GUI::GUI_App::m_instance_hash_int

private

Referenced by get_instance_hash_int(), post_init(), and set_instance_hash().

m_instance_hash_string

std::string Slic3r::GUI::GUI_App::m_instance_hash_string

private

Referenced by get_instance_hash_string(), and set_instance_hash().

m_is_closing

std::atomic<bool> Slic3r::GUI::GUI_App::m_is_closing {false}

private

{false};

Referenced by is_closing(), set_closing(), and start_sync_user_preset().

m_is_dark_mode

bool Slic3r::GUI::GUI_App::m_is_dark_mode { false }

private

{ false };

Referenced by Update_dark_mode_flag(), and UpdateDarkUI().

m_is_recreating_gui

bool Slic3r::GUI::GUI_App::m_is_recreating_gui { false }

private

{ false };

Referenced by is_recreating_gui(), recreate_GUI(), and shutdown().

m_language_info_best

const wxLanguageInfo* Slic3r::GUI::GUI_App::m_language_info_best = nullptr

private

Referenced by load_language().

m_language_info_system

const wxLanguageInfo* Slic3r::GUI::GUI_App::m_language_info_system = nullptr

private

Referenced by load_language().

m_last_401_error_time

std::chrono::steady_clock::time_point Slic3r::GUI::GUI_App::m_last_401_error_time

private

Referenced by maybe_migrate_user_presets_on_login(), on_http_error(), and on_user_login_handle().

m_last_config_version

boost::optional<Semver> Slic3r::GUI::GUI_App::m_last_config_version

private

Referenced by init_app_config(), last_config_version(), and post_init().

m_last_input

std::chrono::steady_clock::time_point Slic3r::GUI::GUI_App::m_last_input { std::chrono::steady_clock::now() }

private

{ std::chrono::steady_clock::now() };

Referenced by FilterEvent(), and input_idle_ms().

m_legacy_filament_check_due

bool Slic3r::GUI::GUI_App::m_legacy_filament_check_due {false}

private

{false}; // the startup check waits for that pull

Referenced by check_legacy_user_filament_presets(), and start_sync_user_preset().

m_legacy_filament_check_running

bool Slic3r::GUI::GUI_App::m_legacy_filament_check_running {false}

private

{false}; // a check is in progress, its dialog may be open

Referenced by check_legacy_user_filament_presets().

m_link_font

wxFont Slic3r::GUI::GUI_App::m_link_font

private

Referenced by link_font(), and update_fonts().

m_mall_model_download_name

std::string Slic3r::GUI::GUI_App::m_mall_model_download_name

Referenced by get_download_model_name(), and set_download_model_name().

m_mall_model_download_url

std::string Slic3r::GUI::GUI_App::m_mall_model_download_url

Referenced by get_download_model_url(), and set_download_model_url().

m_mall_publish_dialog

ModelMallDialog* Slic3r::GUI::GUI_App::m_mall_publish_dialog { nullptr }

{ nullptr };

Referenced by remove_mall_system_dialog(), and remove_ping_bind_dialog().

m_migration_retry_pending

std::atomic<bool> Slic3r::GUI::GUI_App::m_migration_retry_pending {false}

private

{false};

Referenced by maybe_migrate_user_presets_on_login().

m_networking_cancel_update

bool Slic3r::GUI::GUI_App::m_networking_cancel_update { false }

private

{ false };

Referenced by cancel_networking_install(), download_plugin(), and install_plugin().

m_networking_compatible

bool Slic3r::GUI::GUI_App::m_networking_compatible { false }

private

{ false };

Referenced by check_networking_version(), is_compatibility_version(), and on_init_network().

m_networking_need_update

bool Slic3r::GUI::GUI_App::m_networking_need_update { false }

private

{ false };

Referenced by on_init_network(), and post_init().

m_normal_font

wxFont Slic3r::GUI::GUI_App::m_normal_font

private

Referenced by init_fonts(), normal_font(), update_fonts(), and UpdateDVCDarkUI().

m_older_data_dir_path

std::string Slic3r::GUI::GUI_App::m_older_data_dir_path

private

Referenced by copy_older_config().

m_open_method

std::string Slic3r::GUI::GUI_App::m_open_method

private

Referenced by post_init().

m_opengl_mgr

OpenGLManager Slic3r::GUI::GUI_App::m_opengl_mgr

private

Referenced by get_current_shader(), get_opengl_manager(), get_shader(), init_glcontext(), init_opengl(), is_gl_version_greater_or_equal_to(), and is_glsl_version_greater_or_equal_to().

m_other_instance_message_handler

std::unique_ptr<OtherInstanceMessageHandler> Slic3r::GUI::GUI_App::m_other_instance_message_handler

private

Referenced by GUI_App(), and other_instance_message_handler().

m_pending_conflict_setting_ids

std::vector<std::string> Slic3r::GUI::GUI_App::m_pending_conflict_setting_ids

private

Referenced by force_push_conflicting_preset(), and start_sync_user_preset().

m_ping_code_binding_dialog

PingCodeBindDialog* Slic3r::GUI::GUI_App::m_ping_code_binding_dialog { nullptr }

{ nullptr };

Referenced by popup_ping_bind_dialog(), and remove_ping_bind_dialog().

m_plugins_dlg

PluginsDialog* Slic3r::GUI::GUI_App::m_plugins_dlg {nullptr}

{nullptr};

Referenced by init_plugin_gui_wiring(), on_user_login_handle(), open_plugins_dialog(), and request_user_logout().

m_post_initialized

bool Slic3r::GUI::GUI_App::m_post_initialized { false }

private

{ false };

Referenced by on_init_inner(), and post_init().

m_preset_bundle_dlg

PresetBundleDialog* Slic3r::GUI::GUI_App::m_preset_bundle_dlg {nullptr}

{nullptr};

Referenced by open_presetbundledialog(), start_sync_user_preset(), sync_bundle(), and update_single_bundle().

m_printhost_job_queue

std::unique_ptr<PrintHostJobQueue> Slic3r::GUI::GUI_App::m_printhost_job_queue

private

Referenced by on_init_inner(), printhost_job_queue(), and recreate_GUI().

m_removable_drive_manager

std::unique_ptr<RemovableDriveManager> Slic3r::GUI::GUI_App::m_removable_drive_manager

private

Referenced by GUI_App(), removable_drive_manager(), and shutdown().

m_restart_sync_pending

std::atomic<bool> Slic3r::GUI::GUI_App::m_restart_sync_pending {false}

private

{false};

Referenced by restart_sync_user_preset().

m_server_error_dialog

NetworkErrorDialog* Slic3r::GUI::GUI_App::m_server_error_dialog { nullptr }

{ nullptr };

m_shortcuts

std::unique_ptr<ShortcutRegistry> Slic3r::GUI::GUI_App::m_shortcuts

private

Referenced by GUI_App(), on_shortcuts_changed(), and shortcuts().

m_show_error_msgdlg

bool Slic3r::GUI::GUI_App::m_show_error_msgdlg {false}

private

{false};

Referenced by process_network_msg().

m_show_gcode_window

bool Slic3r::GUI::GUI_App::m_show_gcode_window {true}

private

{true};

Referenced by post_init(), show_gcode_window(), and toggle_show_gcode_window().

m_show_http_error_msgdlg

bool Slic3r::GUI::GUI_App::m_show_http_error_msgdlg {false}

private

{false};

Referenced by on_http_error().

m_side_popup_status

bool Slic3r::GUI::GUI_App::m_side_popup_status {false}

private

{false};

Referenced by get_side_menu_popup_status(), and set_side_menu_popup_status().

m_single_instance_checker

std::unique_ptr<wxSingleInstanceChecker> Slic3r::GUI::GUI_App::m_single_instance_checker

private

Referenced by init_single_instance_checker(), and single_instance_checker().

m_small_font

wxFont Slic3r::GUI::GUI_App::m_small_font

private

Referenced by init_fonts(), small_font(), and update_fonts().

m_speed_dial_dialog

SpeedDialWebDialog* Slic3r::GUI::GUI_App::m_speed_dial_dialog {nullptr}

{nullptr};

Referenced by open_speed_dial(), and recreate_GUI().

m_studio_active

bool Slic3r::GUI::GUI_App::m_studio_active = true

Referenced by on_init_inner().

m_sync_update_thread

boost::thread Slic3r::GUI::GUI_App::m_sync_update_thread

private

Referenced by hot_reload_network_plugin(), restart_sync_user_preset(), start_sync_user_preset(), and stop_sync_user_preset().

m_sync_user_preset_dlg_active

std::atomic<bool> Slic3r::GUI::GUI_App::m_sync_user_preset_dlg_active {false}

private

{false}; // a manual "Sync Presets" progress dialog is on screen (see restart_sync_user_preset)

Referenced by restart_sync_user_preset(), and start_sync_user_preset().

m_sync_user_presets_now

std::atomic<bool> Slic3r::GUI::GUI_App::m_sync_user_presets_now {false}

private

{false}; // request the sync loop to push user presets on its next tick

Referenced by check_legacy_user_filament_presets(), force_push_conflicting_preset(), and start_sync_user_preset().

m_task_manager

Slic3r::TaskManager* Slic3r::GUI::GUI_App::m_task_manager { nullptr }

private

{ nullptr };

Referenced by getTaskManager(), and on_init_network().

m_terminal_dlg

TerminalDialog* Slic3r::GUI::GUI_App::m_terminal_dlg {nullptr}

{nullptr};

Referenced by open_terminal_dialog().

m_unsigned_plugin_warning_shown

bool Slic3r::GUI::GUI_App::m_unsigned_plugin_warning_shown { false }

private

{ false };

Referenced by process_network_msg(), and reset_unsigned_plugin_warning().

m_upgrade_network_job

std::shared_ptr<UpgradeNetworkJob> Slic3r::GUI::GUI_App::m_upgrade_network_job

private

m_user_manager

Slic3r::UserManager* Slic3r::GUI::GUI_App::m_user_manager { nullptr }

private

{ nullptr };

Referenced by on_init_network(), and OnExit().

m_user_preset_pull_pending

bool Slic3r::GUI::GUI_App::m_user_preset_pull_pending {false}

private

{false}; // set when a sync thread starts, cleared once its pull is applied; a failed pull or a stopped sync leaves it set

Referenced by check_legacy_user_filament_presets(), and start_sync_user_preset().

m_user_sync_token

std::shared_ptr<int> Slic3r::GUI::GUI_App::m_user_sync_token

private

Referenced by hot_reload_network_plugin(), restart_sync_user_preset(), start_sync_user_preset(), and stop_sync_user_preset().

m_wxLocale

std::unique_ptr<wxLocale> Slic3r::GUI::GUI_App::m_wxLocale

private

Referenced by current_language_code(), is_localized(), and load_language().

mainframe

MainFrame* Slic3r::GUI::GUI_App::mainframe { nullptr }

{ nullptr };

Referenced by check_legacy_user_filament_presets(), check_print_host_queue(), check_updates(), FilterEvent(), force_colors_update(), handle_web_request(), hot_reload_network_plugin(), init_plugin_gui_wiring(), install_local_plugin(), keyboard_shortcuts(), load_url(), maybe_migrate_user_presets_on_login(), on_http_error(), on_init_inner(), on_shortcuts_changed(), on_user_login_handle(), open_exportpresetbundledialog(), open_mall_page_dialog(), open_orca_cloud(), open_plugins_dialog(), open_preferences(), open_presetbundledialog(), open_publish_page_dialog(), open_speed_dial(), open_terminal_dialog(), params_dialog(), params_panel(), post_init(), recreate_GUI(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::reload_local_bundle(), reload_settings(), remove_user_presets(), request_open_project(), request_remove_project(), request_user_logout(), restart_networking(), run_script(), run_wizard(), show_check_privacy_dlg(), show_desktop_integration_dialog(), show_network_plugin_download_dialog(), ShowUserGuide(), start_sync_user_preset(), switch_printer_agent(), sync_bundle(), sync_preset(), tab_panel(), update_fonts(), Slic3r::GUI::ProjectDirtyStateManager::update_from_presets(), update_mode(), update_single_bundle(), and update_ui_from_settings().

model_tabs_list

std::vector<Tab *> Slic3r::GUI::GUI_App::model_tabs_list

Referenced by checked_tab(), get_layer_tab(), get_model_tab(), load_current_presets(), and update_mode().

need_add_filaments

std::map<std::string, std::string> Slic3r::GUI::GUI_App::need_add_filaments

private

Referenced by add_pending_vendor_preset(), and load_pending_vendors().

need_add_vendors

std::map<std::string, std::map<std::string, std::set<std::string> > > Slic3r::GUI::GUI_App::need_add_vendors

private

Referenced by add_pending_vendor_preset(), and load_pending_vendors().

need_delete_presets

std::map<std::string, std::string> Slic3r::GUI::GUI_App::need_delete_presets

private

Referenced by delete_preset_from_cloud(), get_delete_cache_presets(), get_delete_cache_presets_lock(), and preset_deleted_from_cloud().

plate_tab

Tab* Slic3r::GUI::GUI_App::plate_tab

Referenced by get_plate_tab().

plater_

Plater* Slic3r::GUI::GUI_App::plater_ { nullptr }

{ nullptr };

Referenced by download_project(), model(), notification_manager(), obj_manipul(), on_init_inner(), open_exportpresetbundledialog(), open_preferences(), open_presetbundledialog(), plater(), plater(), post_init(), recreate_GUI(), reload_settings(), request_model_download(), restart_networking(), sidebar(), start_download(), and switch_printer_agent().

preset_bundle

PresetBundle* Slic3r::GUI::GUI_App::preset_bundle { nullptr }

{ nullptr };

Referenced by ~GUI_App(), apply_keeped_preset_modifications(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::bind_filament_target(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::bind_preset_target(), check_and_keep_current_preset_changes(), check_and_save_current_preset_changes(), check_bundle_updates(), check_legacy_user_filament_presets(), check_preset_parent_available(), check_printer_presets(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::PresetTransaction::commit(), config_wizard_startup(), copy_older_config(), extruders_cnt(), extruders_edited_cnt(), filaments_cnt(), force_push_conflicting_preset(), get_printer_cloud_provider(), get_selected_presets(), global_print_sequence(), has_current_preset_changes(), has_unsaved_preset_changes(), is_blocking_printing(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::list_bundle_ids(), load_current_presets(), load_pending_vendors(), maybe_migrate_user_presets_on_login(), on_http_error(), on_init_inner(), on_user_login_handle(), post_init(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::reload_local_bundle(), reload_settings(), remove_user_presets(), request_user_logout(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::require_gui_app(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::require_tab(), Slic3r::GUI::ProjectDirtyStateManager::reset_initial_presets(), resolve_printer_agent_id(), restart_networking(), Slic3r::GUI::ConfigWizard::run(), Slic3r::GUI::GuideFrame::run(), select_machine(), start_sync_user_preset(), switch_printer_agent(), switch_printer_agent_if_pending(), sync_bundle(), sync_preset(), Slic3r::GUI::ProjectDirtyStateManager::update_from_presets(), update_saved_preset_from_current_preset(), and update_single_bundle().

preset_updater

PresetUpdater* Slic3r::GUI::GUI_App::preset_updater { nullptr }

{ nullptr };

Referenced by ~GUI_App(), check_updates(), get_preset_updater(), on_init_inner(), post_init(), Slic3r::GUI::ConfigWizard::run(), and Slic3r::GUI::GuideFrame::run().

privacy_version_info

VersionInfo Slic3r::GUI::GUI_App::privacy_version_info

private

Referenced by check_privacy_update(), check_privacy_version(), and show_check_privacy_dlg().

tabs_list

std::vector<Tab *> Slic3r::GUI::GUI_App::tabs_list

Referenced by apply_keeped_preset_modifications(), check_and_keep_current_preset_changes(), check_legacy_user_filament_presets(), checked_tab(), get_selected_presets(), get_tab(), has_current_preset_changes(), has_unsaved_preset_changes(), load_current_presets(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::reload_local_bundle(), reload_settings(), update_label_colours(), update_mode(), and update_saved_preset_from_current_preset().

test_url_state

std::map<std::string, bool> Slic3r::GUI::GUI_App::test_url_state

version_display

std::string Slic3r::GUI::GUI_App::version_display = ""

staticprivate

Referenced by format_display_version().

version_info

VersionInfo Slic3r::GUI::GUI_App::version_info

private

Referenced by check_new_version(), check_new_version_sf(), check_update(), on_init_inner(), request_new_version(), and set_skip_version().

---

The documentation for this class was generated from the following files:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/GUI_App.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/GUI_App.cpp