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

Collaboration diagram for Slic3r::GUI::NotificationManager:

Classes
struct	NotificationData
class	NotificationIDProvider
class	PopNotification
class	ObjectIDNotification
class	PlaterWarningNotification
class	ProgressBarNotification
class	URLDownloadNotification
class	PrintHostUploadNotification
class	ProgressIndicatorNotification
class	ExportFinishedNotification
class	UpdatedItemsInfoNotification
class	SharedProfilesNotification
class	OrcaSyncConflictNotification
class	PluginMissingNotification
struct	DelayedNotification
class	SlicingProgressNotification
class	HintNotification

Public Types
enum class	NotificationLevel : int { ProgressBarNotificationLevel = 1 , HintNotificationLevel , RegularNotificationLevel , PrintInfoNotificationLevel , PrintInfoShortNotificationLevel , ImportantNotificationLevel , WarningNotificationLevel , SeriousWarningNotificationLevel , ErrorNotificationLevel }

Public Member Functions
	NotificationManager (wxEvtHandler *evt_handler)
	~NotificationManager ()
void	on_change_color_mode (bool is_dark)
void	init ()
void	push_notification (const NotificationType type, int timestamp=0)
void	push_notification (const std::string &text, int timestamp=0)
void	push_notification (NotificationType type, NotificationLevel level, const std::string &text, const std::string &hypertext="", std::function< bool(wxEvtHandler )> callback=std::function< bool(wxEvtHandler )>(), int timestamp=0)
void	push_delayed_notification (const NotificationType type, std::function< bool(void)> condition_callback, int64_t initial_delay, int64_t delay_interval)
void	stop_delayed_notifications_of_type (const NotificationType type)
void	push_validate_error_notification (StringObjectException const &error)
void	push_upload_job_notification (int id, float filesize, const std::string &filename, const std::string &host, float percentage=0)
void	set_upload_job_notification_percentage (int id, const std::string &filename, const std::string &host, float percentage)
void	upload_job_notification_show_canceled (int id, const std::string &filename, const std::string &host)
void	upload_job_notification_show_error (int id, const std::string &filename, const std::string &host)
void	push_slicing_serious_warning_notification (const std::string &text, std::vector< ModelObject const * > objs)
void	push_slicing_serious_warning_notification (const std::string &text, std::vector< ModelInstance const * > insts)
void	close_slicing_serious_warning_notification (const std::string &text)
void	push_slicing_error_notification (const std::string &text, std::vector< ModelObject const * > objs)
void	push_slicing_warning_notification (const std::string &text, bool gray, ModelObject const *obj, ObjectID oid, int warning_step, int warning_msg_id, NotificationLevel level=NotificationLevel::WarningNotificationLevel)
void	set_all_slicing_errors_gray (bool g)
void	set_all_slicing_warnings_gray (bool g)
void	close_slicing_errors_and_warnings ()
void	close_slicing_error_notification (const std::string &text)
void	remove_slicing_warnings_of_released_objects (const std::vector< ObjectID > &living_oids)
void	push_general_error_notification (const std::string &text)
void	close_general_error_notification (const std::string &text)
void	push_plater_error_notification (const std::string &text)
void	push_plater_warning_notification (const std::string &text)
void	close_plater_error_notification (const std::string &text)
void	close_plater_warning_notification (const std::string &text)
void	push_flushing_volume_error_notification (NotificationType type, NotificationLevel level, const std::string &text, const std::string &hypertext="", std::function< bool(wxEvtHandler )> callback=std::function< bool(wxEvtHandler )>())
void	close_flushing_volume_error_notification (NotificationType type, NotificationLevel level)
void	push_slicing_customize_error_notification (NotificationType type, NotificationLevel level, const std::string &text, const std::string &hypertext="", std::function< bool(wxEvtHandler )> callback=std::function< bool(wxEvtHandler )>())
void	close_slicing_customize_error_notification (NotificationType type, NotificationLevel level)
void	push_simplify_suggestion_notification (const std::string &text, ObjectID object_id, const std::string &hypertext="", std::function< bool(wxEvtHandler )> callback=std::function< bool(wxEvtHandler )>())
void	set_simplify_suggestion_multiline (const ObjectID oid, bool bMulti)
void	remove_simplify_suggestion_of_released_objects (const std::vector< ObjectID > &living_oids)
void	remove_simplify_suggestion_with_id (const ObjectID oid)
void	set_sidebar_collapsed (bool collapsed)
void	set_fff (bool b)
void	set_fdm (bool b)
void	set_sla (bool b)
void	push_exporting_finished_notification (const std::string &path, const std::string &dir_path, bool on_removable)
void	push_import_finished_notification (const std::string &path, const std::string &dir_path, bool on_removable)
void	push_shared_profiles_notification (const std::string &explore_url)
void	push_orca_sync_conflict_notification (const std::string &text, int conflict_code, std::function< bool(wxEvtHandler )> pull_callback, std::function< bool(wxEvtHandler )> force_push_callback)
void	push_plugin_missing_notification (NotificationType type, const std::string &text, const std::string &resolve_label, std::vector< JumpTo > body, std::function< bool(wxEvtHandler *)> resolve_callback)
void	push_download_URL_progress_notification (size_t id, const std::string &text, std::function< bool(DownloaderUserAction, int)> user_action_callback)
void	set_download_URL_progress (size_t id, float percentage)
void	set_download_URL_paused (size_t id)
void	set_download_URL_canceled (size_t id)
void	set_download_URL_error (size_t id, const std::string &text)
void	init_slicing_progress_notification (std::function< bool()> cancel_callback)
void	update_slicing_notif_dailytips (bool need_change)
void	set_slicing_progress_began ()
void	set_slicing_progress_percentage (const std::string &text, float percentage)
void	set_slicing_progress_canceled (const std::string &text)
void	set_slicing_progress_hidden ()
void	set_slicing_complete_print_time (const std::string &info, bool sidebar_colapsed)
void	set_slicing_progress_export_possible ()
void	init_progress_indicator ()
void	progress_indicator_set_range (int range)
void	progress_indicator_set_cancel_callback (CancelFn callback=CancelFn())
void	progress_indicator_set_progress (int pr)
void	progress_indicator_set_status_text (const char *)
int	progress_indicator_get_range () const
void	push_hint_notification (bool open_next)
bool	is_hint_notification_open ()
void	deactivate_loaded_hints ()
void	push_updated_item_info_notification (InfoItemType type)
void	new_export_began (bool on_removable)
void	device_ejected ()
void	render_notifications (GLCanvas3D &canvas, float overlay_width, float bottom_margin, float right_margin)
void	close_notification_of_type (const NotificationType type)
void	remove_notification_of_type (const NotificationType type)
void	clear_all ()
void	set_in_preview (bool preview)
void	apply_in_preview ()
void	set_move_from_overlay (bool move)
bool	update_notifications (GLCanvas3D &canvas)
size_t	get_notification_count () const
void	bbl_show_plateinfo_notification (const std::string &text)
void	bbl_close_plateinfo_notification ()
void	bbl_show_3mf_warn_notification (const std::string &text, NotificationLevel level=NotificationLevel::ErrorNotificationLevel)
void	bbl_close_3mf_warn_notification ()
void	bbl_show_preview_only_notification (const std::string &text)
void	bbl_close_preview_only_notification ()
void	bbl_show_plugin_install_notification (const std::string &text)
void	bbl_close_plugin_install_notification ()
void	bbl_show_objectsinfo_notification (const std::string &text, bool is_warning, bool is_hidden)
void	bbl_close_objectsinfo_notification ()
void	bbl_show_seqprintinfo_notification (const std::string &text)
void	bbl_close_seqprintinfo_notification ()
void	bbl_show_slice_emptylayer_notification (const std::string &text, bool bOverride=true)
void	bbl_show_app_newversion_notification ()
void	bbl_show_need_support_on_notification ()
void	bbl_close_need_support_on_notification ()
void	bbl_show_gcode_overlap_notification ()
void	bbl_close_gcode_overlap_notification ()
void	bbl_show_bed_filament_incompatible_notification (const std::string &text)
void	bbl_close_bed_filament_incompatible_notification ()
void	bbl_show_filament_map_invalid_notification_before_slice (const NotificationType type, const std::string &text)
void	bbl_close_filament_map_invalid_notification_before_slice (const NotificationType type)
void	bbl_show_filament_map_invalid_notification_after_slice (const NotificationType type, const std::string &text)
void	bbl_close_filament_map_invalid_notification_after_slice (const NotificationType type)
void	bbl_show_sole_text_notification (NotificationType sType, const std::string &text, bool bOverride, int level, bool autohide)
void	bbl_chose_sole_text_notification (NotificationType sType)
void	set_scale (float scale=1.0)

Public Attributes
float	m_scale = 1.0f

Private Member Functions
void	close_and_delete_self (PopNotification *)
bool	push_notification_data (const NotificationData &notification_data, int timestamp)
bool	push_notification_data (std::unique_ptr< NotificationManager::PopNotification > notification, int timestamp)
void	push_delayed_notification_data (std::unique_ptr< NotificationManager::PopNotification > notification, std::function< bool(void)> condition_callback, int64_t initial_delay, int64_t delay_interval)
bool	activate_existing (const NotificationManager::PopNotification *notification)
void	sort_notifications ()
bool	has_slicing_error_notification ()
size_t	get_standard_duration (NotificationLevel level)

Private Attributes
bool	m_is_dark = false
bool	m_initialized { false }
bool	m_imgui_ready { false }
wxEvtHandler *	m_evt_handler
NotificationIDProvider	m_id_provider
std::deque< std::unique_ptr< PopNotification > >	m_pop_notifications
PopNotification *	m_to_delete_after_finish_render {nullptr}
std::vector< DelayedNotification >	m_waiting_notifications
std::unordered_set< int >	m_used_timestamps
bool	m_in_preview { false }
int	m_in_view { 0 }
bool	m_move_from_overlay { false }
int64_t	m_last_render { 0LL }
const std::vector< NotificationType >	m_multiple_types
const std::vector< NotificationData >	basic_notifications

Detailed Description

Class Documentation

◆ Slic3r::GUI::NotificationManager::NotificationData

struct Slic3r::GUI::NotificationManager::NotificationData

Collaboration diagram for Slic3r::GUI::NotificationManager::NotificationData:

Class Members
function< bool(wxEvtHandler *)>	callback
const int	duration
const string	hypertext
NotificationLevel	level
string	ori_text
int	sub_msg_id {-1}
const string	text1
const string	text2
NotificationType	type
bool	use_warn_color { false }

Member Enumeration Documentation

◆ NotificationLevel

enum class Slic3r::GUI::NotificationManager::NotificationLevel : int

strong

Enumerator
ProgressBarNotificationLevel
HintNotificationLevel
RegularNotificationLevel
PrintInfoNotificationLevel
PrintInfoShortNotificationLevel
ImportantNotificationLevel
WarningNotificationLevel
SeriousWarningNotificationLevel
ErrorNotificationLevel

  {
    // The notifications will be presented in the order of importance, thus these enum values
    // are sorted by the importance.
    // Important notification with progress bar, no fade-out, might appear again after closing. Position at the bottom.
    ProgressBarNotificationLevel = 1,
    // "Did you know" notification with special icon and buttons, Position close to bottom.
    HintNotificationLevel,
    // "Good to know" notification, usually but not always with a quick fade-out.
    RegularNotificationLevel,
    // Regular level notifiaction containing info about objects or print. Has Icon.
    PrintInfoNotificationLevel,
    // PrintInfoNotificationLevel with shorter time
    PrintInfoShortNotificationLevel,
    // Information notification without a fade-out or with a longer fade-out.
    ImportantNotificationLevel,
    // Warning, no fade-out.
    WarningNotificationLevel,
    // Serious warning, bold reminder
        SeriousWarningNotificationLevel,
    // Error, no fade-out. Top most position.
    ErrorNotificationLevel,
  };

Constructor & Destructor Documentation

◆ NotificationManager()

Slic3r::GUI::NotificationManager::NotificationManager ( wxEvtHandler * evt_handler )

                                                                  :
  m_evt_handler(evt_handler)
{
}

References m_evt_handler.

◆ ~NotificationManager()

Slic3r::GUI::NotificationManager::~NotificationManager ( )

inline

232{}

Member Function Documentation

◆ activate_existing()

bool Slic3r::GUI::NotificationManager::activate_existing ( const NotificationManager::PopNotification * notification )

private

{
  NotificationType   new_type = notification->get_type();
  const std::string &new_text = notification->get_data().text1;
  for (auto it = m_pop_notifications.begin(); it != m_pop_notifications.end(); ++it) {
    if ((*it)->get_type() == new_type && !(*it)->is_finished()) {
      // multiple of one type allowed, but must have different text
      if (std::find(m_multiple_types.begin(), m_multiple_types.end(), new_type) != m_multiple_types.end()) {
        // If found same type and same text, return true - update will be performed on the old notif
        if ((*it)->compare_text(new_text) == false) {
          continue;
        }
      // multiple of one type allowed, but must have different text nad ObjectID
      } else if (new_type == NotificationType::SlicingWarning) {
        auto w1 = dynamic_cast<const ObjectIDNotification*>(notification);
        auto w2 = dynamic_cast<const ObjectIDNotification*>(it->get());
        if (w1 != nullptr && w2 != nullptr) {
          const NotificationData& data1 = w1->get_data();
          const NotificationData& data2 = w2->get_data();
          if (data1.sub_msg_id != data2.sub_msg_id)
            continue;
          //if (!(*it)->compare_text(new_text) || w1->object_id != w2->object_id) {
          //  continue;
          //}
        } else {
          continue;
        }
      }
      if (it != m_pop_notifications.end() - 1)
        std::rotate(it, it + 1, m_pop_notifications.end());
      return true;
    }
  }
  return false;
}

References Slic3r::GUI::NotificationManager::PopNotification::get_data(), Slic3r::GUI::NotificationManager::PopNotification::get_type(), m_multiple_types, m_pop_notifications, Slic3r::GUI::SlicingWarning, Slic3r::GUI::NotificationManager::NotificationData::sub_msg_id, and Slic3r::GUI::NotificationManager::NotificationData::text1.

Referenced by push_notification_data(), and update_notifications().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ apply_in_preview()

void Slic3r::GUI::NotificationManager::apply_in_preview ( )

inline

373{ set_in_preview(m_in_preview); }

Slic3r::GUI::NotificationManager::m_in_preview

bool m_in_preview

Definition NotificationManager.hpp:1081

Slic3r::GUI::NotificationManager::set_in_preview

void set_in_preview(bool preview)

Definition NotificationManager.cpp:3315

References m_in_preview, and set_in_preview().

Referenced by push_plater_warning_notification().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bbl_chose_sole_text_notification()

void Slic3r::GUI::NotificationManager::bbl_chose_sole_text_notification ( NotificationType sType )

{
    for (std::unique_ptr<PopNotification> &notification : m_pop_notifications)
        if (notification->get_type() == sType) { notification->close(); }
}

References m_pop_notifications.

◆ bbl_close_3mf_warn_notification()

void Slic3r::GUI::NotificationManager::bbl_close_3mf_warn_notification ( )

{
    for (std::unique_ptr<PopNotification> &notification : m_pop_notifications)
        if (notification->get_type() == NotificationType::BBL3MFInfo) {
            notification->close();
        }
}

References Slic3r::GUI::BBL3MFInfo, and m_pop_notifications.

Referenced by Slic3r::GUI::Plater::load_project().

Here is the caller graph for this function:

◆ bbl_close_bed_filament_incompatible_notification()

void Slic3r::GUI::NotificationManager::bbl_close_bed_filament_incompatible_notification ( )

{
  close_notification_of_type(NotificationType::BBLBedFilamentIncompatible);
}

References Slic3r::GUI::BBLBedFilamentIncompatible, and close_notification_of_type().

Here is the call graph for this function:

◆ bbl_close_filament_map_invalid_notification_after_slice()

void Slic3r::GUI::NotificationManager::bbl_close_filament_map_invalid_notification_after_slice ( const NotificationType type )

{
    close_notification_of_type(type);
}

References close_notification_of_type().

Here is the call graph for this function:

◆ bbl_close_filament_map_invalid_notification_before_slice()

void Slic3r::GUI::NotificationManager::bbl_close_filament_map_invalid_notification_before_slice ( const NotificationType type )

{
    close_notification_of_type(type);
}

References close_notification_of_type().

Here is the call graph for this function:

◆ bbl_close_gcode_overlap_notification()

void Slic3r::GUI::NotificationManager::bbl_close_gcode_overlap_notification ( )

{
    for (std::unique_ptr<PopNotification> &notification : m_pop_notifications)
        if (notification->get_type() == NotificationType::BBLGcodeOverlap) { notification->close(); }
}

References Slic3r::GUI::BBLGcodeOverlap, and m_pop_notifications.

◆ bbl_close_need_support_on_notification()

void Slic3r::GUI::NotificationManager::bbl_close_need_support_on_notification ( )

{
    for (std::unique_ptr<PopNotification> &notification : m_pop_notifications)
        if (notification->get_type() == NotificationType::BBLNeedSupportON) { notification->close(); }
}

References Slic3r::GUI::BBLNeedSupportON, and m_pop_notifications.

◆ bbl_close_objectsinfo_notification()

void Slic3r::GUI::NotificationManager::bbl_close_objectsinfo_notification ( )

{
    for (std::unique_ptr<PopNotification> &notification : m_pop_notifications)
        if (notification->get_type() == NotificationType::BBLObjectInfo) { notification->close(); }
}

References Slic3r::GUI::BBLObjectInfo, and m_pop_notifications.

Referenced by Slic3r::GUI::Plater::show_object_info().

Here is the caller graph for this function:

◆ bbl_close_plateinfo_notification()

void Slic3r::GUI::NotificationManager::bbl_close_plateinfo_notification ( )

{
    for (std::unique_ptr<PopNotification> &notification : m_pop_notifications)
        if (notification->get_type() == NotificationType::BBLPlateInfo) {
            notification->close();
        }
}

References Slic3r::GUI::BBLPlateInfo, and m_pop_notifications.

Referenced by Slic3r::GUI::Plater::load_project().

Here is the caller graph for this function:

◆ bbl_close_plugin_install_notification()

void Slic3r::GUI::NotificationManager::bbl_close_plugin_install_notification ( )

{
    for (std::unique_ptr<PopNotification> &notification : m_pop_notifications)
        if (notification->get_type() == NotificationType::BBLPluginInstallHint) { notification->close(); }
}

References Slic3r::GUI::BBLPluginInstallHint, and m_pop_notifications.

◆ bbl_close_preview_only_notification()

void Slic3r::GUI::NotificationManager::bbl_close_preview_only_notification ( )

{
    for (std::unique_ptr<PopNotification> &notification : m_pop_notifications)
        if (notification->get_type() == NotificationType::BBLPreviewOnlyMode) {
            notification->close();
        }
}

References Slic3r::GUI::BBLPreviewOnlyMode, and m_pop_notifications.

Referenced by Slic3r::GUI::Plater::load_project().

Here is the caller graph for this function:

◆ bbl_close_seqprintinfo_notification()

void Slic3r::GUI::NotificationManager::bbl_close_seqprintinfo_notification ( )

{
    for (std::unique_ptr<PopNotification> &notification : m_pop_notifications)
        if (notification->get_type() == NotificationType::BBLSeqPrintInfo) { notification->close(); }
}

References Slic3r::GUI::BBLSeqPrintInfo, and m_pop_notifications.

Referenced by Slic3r::GUI::Plater::config_change_notification().

Here is the caller graph for this function:

◆ bbl_show_3mf_warn_notification()

void Slic3r::GUI::NotificationManager::bbl_show_3mf_warn_notification	(	const std::string &	text,
		NotificationLevel	level = NotificationLevel::ErrorNotificationLevel )

{
    NotificationData data{NotificationType::BBL3MFInfo, level, BBL_NOTICE_MAX_INTERVAL, text};
    push_notification_data(data, 0);
}

References Slic3r::GUI::BBL3MFInfo, BBL_NOTICE_MAX_INTERVAL, and push_notification_data().

Referenced by Slic3r::GUI::Plater::priv::load_files().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bbl_show_app_newversion_notification()

void Slic3r::GUI::NotificationManager::bbl_show_app_newversion_notification ( )

{
  push_notification(NotificationType::NewAppAvailable);
}

References Slic3r::GUI::NewAppAvailable, and push_notification().

Here is the call graph for this function:

◆ bbl_show_bed_filament_incompatible_notification()

void Slic3r::GUI::NotificationManager::bbl_show_bed_filament_incompatible_notification ( const std::string & text )

{
  auto callback = [](wxEvtHandler*) {
    const wxString bed_filament_compatibility_wiki = "https://wiki.bambulab.com/en/general/filament-guide-material-table";
    wxGetApp().open_browser_with_warning_dialog(bed_filament_compatibility_wiki);
    return false;
  };
  push_notification_data({ NotificationType::BBLBedFilamentIncompatible,NotificationLevel::ErrorNotificationLevel,0,_u8L("Error:") + "\n" + text,_u8L("Click for more."),callback }, 0);
}

References _u8L, Slic3r::GUI::BBLBedFilamentIncompatible, ErrorNotificationLevel, and push_notification_data().

Here is the call graph for this function:

◆ bbl_show_filament_map_invalid_notification_after_slice()

void Slic3r::GUI::NotificationManager::bbl_show_filament_map_invalid_notification_after_slice	(	const NotificationType	type,
		const std::string &	text )

{
    auto callback = [](wxEvtHandler*) {
        auto plater = wxGetApp().plater();
        wxCommandEvent evt(EVT_OPEN_FILAMENT_MAP_SETTINGS_DIALOG);
        evt.SetEventObject(plater);
        auto canvas_type = plater->canvas3D()->get_canvas_type();
        if (canvas_type == GLCanvas3D::ECanvasType::CanvasPreview)
            evt.SetInt(1); // 1 means from gcode viewer, should do slice right now
        else
            evt.SetInt(0);
        wxPostEvent(plater, evt);
        return false;
    };
 
    push_notification_data({ type,NotificationLevel::ErrorNotificationLevel,0,_u8L("Error:") + "\n" + text,_u8L("Click here to regroup"),callback }, 0);
}

References _u8L, Slic3r::GUI::GLCanvas3D::CanvasPreview, ErrorNotificationLevel, Slic3r::GUI::plater(), and push_notification_data().

Here is the call graph for this function:

◆ bbl_show_filament_map_invalid_notification_before_slice()

void Slic3r::GUI::NotificationManager::bbl_show_filament_map_invalid_notification_before_slice	(	const NotificationType	type,
		const std::string &	text )

{
    auto callback = [](wxEvtHandler*) {
        auto plater = wxGetApp().plater();
        auto partplate = plater->get_partplate_list().get_curr_plate();
        try_pop_up_before_slice(false, plater, partplate, true); // ignore the return value
        return false;
    };
 
    push_notification_data({ type,NotificationLevel::ErrorNotificationLevel,0,_u8L("Error:") + "\n" + text,_u8L("Click here to regroup"),callback }, 0);
}

References _u8L, ErrorNotificationLevel, Slic3r::GUI::plater(), push_notification_data(), and Slic3r::GUI::try_pop_up_before_slice().

Here is the call graph for this function:

◆ bbl_show_gcode_overlap_notification()

void Slic3r::GUI::NotificationManager::bbl_show_gcode_overlap_notification ( )

{
    NotificationData data{NotificationType::BBLGcodeOverlap, NotificationLevel::WarningNotificationLevel, 0,
                          _u8L("Warning:") + "\n" + _u8L("G-code path overlap")};
 
    for (std::unique_ptr<PopNotification> &notification : m_pop_notifications) {
        if (notification->get_type() == NotificationType::BBLGcodeOverlap) {
            notification->reinit();
            notification->update(data);
            return;
        }
    }
 
    auto notification = std::make_unique<NotificationManager::PopNotification>(data, m_id_provider, m_evt_handler);
    push_notification_data(std::move(notification), 0);
}

References _u8L, Slic3r::GUI::BBLGcodeOverlap, m_evt_handler, m_id_provider, m_pop_notifications, push_notification_data(), and WarningNotificationLevel.

Here is the call graph for this function:

◆ bbl_show_need_support_on_notification()

void Slic3r::GUI::NotificationManager::bbl_show_need_support_on_notification ( )

{
    NotificationData data{NotificationType::BBLNeedSupportON, NotificationLevel::WarningNotificationLevel, 0,
                          _u8L("Warning:") + "\n" + _u8L("Your model needs support! Please enable support material.")};
 
    for (std::unique_ptr<PopNotification> &notification : m_pop_notifications) {
        if (notification->get_type() == NotificationType::BBLNeedSupportON) {
            notification->reinit();
            notification->update(data);
            return;
        }
    }
 
    auto notification = std::make_unique<NotificationManager::PopNotification>(data, m_id_provider, m_evt_handler);
    push_notification_data(std::move(notification), 0);
}

References _u8L, Slic3r::GUI::BBLNeedSupportON, m_evt_handler, m_id_provider, m_pop_notifications, push_notification_data(), and WarningNotificationLevel.

Here is the call graph for this function:

◆ bbl_show_objectsinfo_notification()

void Slic3r::GUI::NotificationManager::bbl_show_objectsinfo_notification	(	const std::string &	text,
		bool	is_warning,
		bool	is_hidden )

{
    std::string hyper_text;
    auto callback = std::function<bool(wxEvtHandler *)>();
    if (is_warning) {
        callback =[](wxEvtHandler *) {
            wxCommandEvent *evt = new wxCommandEvent(EVT_REPAIR_MODEL);
            wxQueueEvent(wxGetApp().plater(), evt);
            return false;
        };
        hyper_text =  _u8L(" (Repair)");
    }
    NotificationData data{NotificationType::BBLObjectInfo, NotificationLevel::PrintInfoNotificationLevel, BBL_NOTICE_MAX_INTERVAL, text, hyper_text, callback};
    if (is_warning)
        data.use_warn_color = true;
 
    for (auto it = m_pop_notifications.begin(); it != m_pop_notifications.end();) {
        std::unique_ptr<PopNotification>& notification = *it;
        if (notification->get_type() == NotificationType::BBLObjectInfo) {
            it = m_pop_notifications.erase(it);
            break;
        }
        else
            ++it;
    }
 
    auto notification = std::make_unique<NotificationManager::PopNotification>(data, m_id_provider, m_evt_handler);
    notification->set_Multiline(true);
    if (is_hidden)
        notification->hide(true);
    push_notification_data(std::move(notification), 0);
}

References _u8L, BBL_NOTICE_MAX_INTERVAL, Slic3r::GUI::BBLObjectInfo, m_evt_handler, m_id_provider, m_pop_notifications, Slic3r::GUI::plater(), PrintInfoNotificationLevel, push_notification_data(), and Slic3r::GUI::NotificationManager::NotificationData::use_warn_color.

Referenced by Slic3r::GUI::Plater::show_object_info().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bbl_show_plateinfo_notification()

void Slic3r::GUI::NotificationManager::bbl_show_plateinfo_notification ( const std::string & text )

{
    NotificationData data{NotificationType::BBLPlateInfo, NotificationLevel::PrintInfoNotificationLevel, BBL_NOTICE_MAX_INTERVAL, text};
    push_notification_data(data, 0);
}

References BBL_NOTICE_MAX_INTERVAL, Slic3r::GUI::BBLPlateInfo, PrintInfoNotificationLevel, and push_notification_data().

Here is the call graph for this function:

◆ bbl_show_plugin_install_notification()

void Slic3r::GUI::NotificationManager::bbl_show_plugin_install_notification ( const std::string & text )

{
    std::string hyper_text;
    auto callback = [](wxEvtHandler *) {
        wxCommandEvent *evt = new wxCommandEvent(EVT_INSTALL_PLUGIN_NETWORKING);
        wxQueueEvent(wxGetApp().plater(), evt);
        return false;
    };
    hyper_text =  _u8L(" Click here to install it.");
    NotificationData data{NotificationType::BBLPluginInstallHint, NotificationLevel::WarningNotificationLevel, 0, text, hyper_text, callback};
 
    for (std::unique_ptr<PopNotification> &notification : m_pop_notifications) {
        if (notification->get_type() == NotificationType::BBLPluginInstallHint) {
            notification->reinit();
            notification->update(data);
            return;
        }
    }
 
    auto notification = std::make_unique<NotificationManager::PopNotification>(data, m_id_provider, m_evt_handler);
    notification->set_Multiline(true);
    push_notification_data(std::move(notification), 0);
}

References _u8L, Slic3r::GUI::BBLPluginInstallHint, m_evt_handler, m_id_provider, m_pop_notifications, Slic3r::GUI::plater(), push_notification_data(), and WarningNotificationLevel.

Here is the call graph for this function:

◆ bbl_show_preview_only_notification()

void Slic3r::GUI::NotificationManager::bbl_show_preview_only_notification ( const std::string & text )

{
    NotificationData data{NotificationType::BBLPreviewOnlyMode, NotificationLevel::WarningNotificationLevel, 0, text};
    push_notification_data(data, 0);
}

References Slic3r::GUI::BBLPreviewOnlyMode, push_notification_data(), and WarningNotificationLevel.

Here is the call graph for this function:

◆ bbl_show_seqprintinfo_notification()

void Slic3r::GUI::NotificationManager::bbl_show_seqprintinfo_notification ( const std::string & text )

{
    NotificationData data{NotificationType::BBLSeqPrintInfo, NotificationLevel::PrintInfoNotificationLevel, BBL_NOTICE_MAX_INTERVAL, text};
 
    for (std::unique_ptr<PopNotification> &notification : m_pop_notifications) {
        if (notification->get_type() == NotificationType::BBLSeqPrintInfo) {
            notification->reinit();
            notification->update(data);
            return;
        }
    }
 
    auto notification = std::make_unique<NotificationManager::PopNotification>(data, m_id_provider, m_evt_handler);
    notification->set_Multiline(true);
    push_notification_data(std::move(notification), 0);
}

References BBL_NOTICE_MAX_INTERVAL, Slic3r::GUI::BBLSeqPrintInfo, m_evt_handler, m_id_provider, m_pop_notifications, PrintInfoNotificationLevel, and push_notification_data().

Referenced by Slic3r::GUI::Plater::config_change_notification().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bbl_show_slice_emptylayer_notification()

void Slic3r::GUI::NotificationManager::bbl_show_slice_emptylayer_notification	(	const std::string &	text,
		bool	bOverride = true )

{
    NotificationData data{NotificationType::BBLSliceEmptyLayer, NotificationLevel::WarningNotificationLevel, 0, _u8L("WARNING:") + "\n" + text};
 
    for (std::unique_ptr<PopNotification> &notification : m_pop_notifications) {
        if (notification->get_type() == NotificationType::BBLSliceEmptyLayer) {
            if (bOverride)
                notification->update(data);
            else {
                NotificationData sdata{NotificationType::BBLSliceEmptyLayer, NotificationLevel::WarningNotificationLevel, 0, notification->get_text1() + "\n" + text};
                notification->update(sdata);
            }
 
            return;
        }
    }
 
    auto notification = std::make_unique<NotificationManager::PopNotification>(data, m_id_provider, m_evt_handler);
    notification->set_Multiline(true);
    push_notification_data(std::move(notification), 0);
}

References _u8L, Slic3r::GUI::BBLSliceEmptyLayer, m_evt_handler, m_id_provider, m_pop_notifications, push_notification_data(), and WarningNotificationLevel.

Here is the call graph for this function:

◆ bbl_show_sole_text_notification()

void Slic3r::GUI::NotificationManager::bbl_show_sole_text_notification	(	NotificationType	sType,
		const std::string &	text,
		bool	bOverride,
		int	level,
		bool	autohide )

                                                                                                                                                 {
 
  NotificationLevel nlevel;
    int               nHideTime = 20;
    switch ( level) {
    case 1:
    nlevel = NotificationLevel::WarningNotificationLevel;
    nHideTime = 0;
    break;
    case 2:
    nlevel = NotificationLevel::ErrorNotificationLevel; break;
        nHideTime = 0;
    case 0:
    default:
    nlevel = NotificationLevel::PrintInfoNotificationLevel;
 
    if (autohide == false) nHideTime = BBL_NOTICE_MAX_INTERVAL;
        break;
    }
 
    NotificationData data{sType, nlevel, nHideTime, text};
    for (std::unique_ptr<PopNotification> &notification : m_pop_notifications) {
        if (notification->get_type() == sType) {
            if (bOverride) {
                notification->update(data);
            }
            else {
                NotificationData sdata{sType, nlevel, nHideTime, notification->get_text1() + "\n" + text};
                notification->update(sdata);
            }
 
            return;
        }
    }
 
    auto notification = std::make_unique<NotificationManager::PopNotification>(data, m_id_provider, m_evt_handler);
    notification->set_Multiline(true);
    push_notification_data(std::move(notification), 0);
}

References BBL_NOTICE_MAX_INTERVAL, ErrorNotificationLevel, m_evt_handler, m_id_provider, m_pop_notifications, PrintInfoNotificationLevel, push_notification_data(), and WarningNotificationLevel.

Here is the call graph for this function:

◆ clear_all()

void Slic3r::GUI::NotificationManager::clear_all ( )

{
    for (size_t i = 0; i < size_t(NotificationType::NotificationTypeCount); i++) {
        remove_notification_of_type((NotificationType)i);
    }
}

References Slic3r::GUI::NotificationTypeCount, and remove_notification_of_type().

Referenced by Slic3r::GUI::Plater::new_project().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ close_and_delete_self()

void Slic3r::GUI::NotificationManager::close_and_delete_self ( PopNotification * self )

private

{
    for (auto it = m_pop_notifications.begin(); it != m_pop_notifications.end();) {
        std::unique_ptr<PopNotification> &notification = *it;
        if (notification.get() == self) {
            m_pop_notifications.erase(it);
            break;
        }else
            ++it;
    }
}

References m_pop_notifications.

Referenced by render_notifications().

Here is the caller graph for this function:

◆ close_flushing_volume_error_notification()

void Slic3r::GUI::NotificationManager::close_flushing_volume_error_notification	(	NotificationType	type,
		NotificationLevel	level )

{
    for (std::unique_ptr<PopNotification> &notification : m_pop_notifications) {
        if (notification->get_type() == type && notification->get_data().level == level) { notification->close(); }
    }
}

References m_pop_notifications.

◆ close_general_error_notification()

void Slic3r::GUI::NotificationManager::close_general_error_notification ( const std::string & text )

{
  for (std::unique_ptr<PopNotification> &notification : m_pop_notifications) {
    if (notification->get_type() == NotificationType::BBLGeneralError && notification->compare_text(_u8L("Error:") + "\n" + text)) {
      notification->close();
    }
  }
}

References _u8L, Slic3r::GUI::BBLGeneralError, and m_pop_notifications.

◆ close_notification_of_type()

void Slic3r::GUI::NotificationManager::close_notification_of_type ( const NotificationType type )

{
  for (std::unique_ptr<PopNotification> &notification : m_pop_notifications) {
    if (notification->get_type() == type) {
      notification->close();
    }
  }
}

References m_pop_notifications.

Referenced by bbl_close_bed_filament_incompatible_notification(), bbl_close_filament_map_invalid_notification_after_slice(), bbl_close_filament_map_invalid_notification_before_slice(), Slic3r::GUI::Plater::load_project(), new_export_began(), push_exporting_finished_notification(), push_import_finished_notification(), push_orca_sync_conflict_notification(), and push_shared_profiles_notification().

Here is the caller graph for this function:

◆ close_plater_error_notification()

void Slic3r::GUI::NotificationManager::close_plater_error_notification ( const std::string & text )

{
  for (std::unique_ptr<PopNotification> &notification : m_pop_notifications) {
    if (notification->get_type() == NotificationType::PlaterError) {
      notification->close();
    }
  }
}

References m_pop_notifications, and Slic3r::GUI::PlaterError.

◆ close_plater_warning_notification()

void Slic3r::GUI::NotificationManager::close_plater_warning_notification ( const std::string & text )

{
  for (std::unique_ptr<PopNotification> &notification : m_pop_notifications) {
    if (notification->get_type() == NotificationType::PlaterWarning && notification->compare_text(_u8L("Warning:") + "\n" + text)) {
      dynamic_cast<PlaterWarningNotification*>(notification.get())->real_close();
    }
  }
}

References _u8L, m_pop_notifications, Slic3r::GUI::PlaterWarning, and Slic3r::GUI::NotificationManager::PlaterWarningNotification::real_close().

Here is the call graph for this function:

◆ close_slicing_customize_error_notification()

void Slic3r::GUI::NotificationManager::close_slicing_customize_error_notification	(	NotificationType	type,
		NotificationLevel	level )

{
    for (std::unique_ptr<PopNotification> &notification : m_pop_notifications) {
        if (notification->get_type() == type && notification->get_data().level == level) {
            notification->close();
        }
    }
}

References m_pop_notifications.

◆ close_slicing_error_notification()

void Slic3r::GUI::NotificationManager::close_slicing_error_notification ( const std::string & text )

{
  for (std::unique_ptr<PopNotification>& notification : m_pop_notifications) {
    if (notification->get_type() == NotificationType::SlicingError && notification->compare_text(_u8L("Error:") + "\n" + text)) {
      notification->close();
    }
  }
}

References _u8L, m_pop_notifications, and Slic3r::GUI::SlicingError.

◆ close_slicing_errors_and_warnings()

void Slic3r::GUI::NotificationManager::close_slicing_errors_and_warnings ( )

{
  for (std::unique_ptr<PopNotification> &notification : m_pop_notifications) {
    if (notification->get_type() == NotificationType::SlicingError || notification->get_type() == NotificationType::SlicingWarning) {
      notification->close();
    }
  }
}

References m_pop_notifications, Slic3r::GUI::SlicingError, and Slic3r::GUI::SlicingWarning.

◆ close_slicing_serious_warning_notification()

void Slic3r::GUI::NotificationManager::close_slicing_serious_warning_notification ( const std::string & text )

{
    for (std::unique_ptr<PopNotification> &notification : m_pop_notifications) {
        if (notification->get_type() == NotificationType::SlicingSeriousWarning && notification->compare_text(_u8L("Serious warning:") + "\n" + text)) { notification->close(); }
    }
}

References _u8L, m_pop_notifications, and Slic3r::GUI::SlicingSeriousWarning.

◆ deactivate_loaded_hints()

void Slic3r::GUI::NotificationManager::deactivate_loaded_hints ( )

{
  ;
}

◆ device_ejected()

void Slic3r::GUI::NotificationManager::device_ejected ( )

{
  for (std::unique_ptr<PopNotification>& notification : m_pop_notifications) {
    if (notification->get_type() == NotificationType::ExportFinished && dynamic_cast<ExportFinishedNotification*>(notification.get())->m_to_removable)
      notification->close();
  }
}

References Slic3r::GUI::ExportFinished, m_pop_notifications, and Slic3r::GUI::NotificationManager::ExportFinishedNotification::m_to_removable.

◆ get_notification_count()

size_t Slic3r::GUI::NotificationManager::get_notification_count ( ) const

{
  size_t ret = 0;
  for (const std::unique_ptr<PopNotification>& notification : m_pop_notifications) {
    if (notification->get_state() != PopNotification::EState::Hidden)
      ret++;
  }
  return ret;
}

References Slic3r::GUI::NotificationManager::PopNotification::Hidden, and m_pop_notifications.

◆ get_standard_duration()

size_t Slic3r::GUI::NotificationManager::get_standard_duration ( NotificationLevel level )

inlineprivate

  {
    switch (level) {
 
    case NotificationLevel::ErrorNotificationLevel:       return 0;
    case NotificationLevel::WarningNotificationLevel:     return 0;
    case NotificationLevel::ImportantNotificationLevel:     return 20;
    case NotificationLevel::ProgressBarNotificationLevel:   return 2;
    case NotificationLevel::PrintInfoShortNotificationLevel:  return 5;
    case NotificationLevel::RegularNotificationLevel:       return 10;
    case NotificationLevel::PrintInfoNotificationLevel:     return 10;
    case NotificationLevel::HintNotificationLevel:        return 300;
    default: return 10;
    }
  }

References ErrorNotificationLevel, HintNotificationLevel, ImportantNotificationLevel, PrintInfoNotificationLevel, PrintInfoShortNotificationLevel, ProgressBarNotificationLevel, RegularNotificationLevel, and WarningNotificationLevel.

Referenced by push_notification().

Here is the caller graph for this function:

◆ has_slicing_error_notification()

bool Slic3r::GUI::NotificationManager::has_slicing_error_notification ( )

private

{
  return std::any_of(m_pop_notifications.begin(), m_pop_notifications.end(), [](auto &n) {
      return n->get_type() == NotificationType::SlicingError;
    });
}

References m_pop_notifications.

◆ init()

void Slic3r::GUI::NotificationManager::init ( )

inline

236{ m_initialized = true; }

Slic3r::GUI::NotificationManager::m_initialized

bool m_initialized

Definition NotificationManager.hpp:1064

References m_initialized.

Referenced by Slic3r::GUI::NotificationManager::PopNotification::append(), Slic3r::GUI::NotificationManager::PopNotification::bbl_render_block_notification(), Slic3r::GUI::NotificationManager::PopNotification::render(), Slic3r::GUI::NotificationManager::SlicingProgressNotification::render(), Slic3r::GUI::NotificationManager::PrintHostUploadNotification::set_percentage(), Slic3r::GUI::NotificationManager::PopNotification::update(), and Slic3r::GUI::NotificationManager::PopNotification::update_state().

Here is the caller graph for this function:

◆ init_progress_indicator()

void Slic3r::GUI::NotificationManager::init_progress_indicator ( )

{
  for (std::unique_ptr<PopNotification>& notification : m_pop_notifications) {
    if (notification->get_type() == NotificationType::ProgressIndicator) {
      return;
    }
  }
  NotificationData data{ NotificationType::ProgressIndicator, NotificationLevel::ProgressBarNotificationLevel, 1};
  auto notification = std::make_unique<NotificationManager::ProgressIndicatorNotification>(data, m_id_provider, m_evt_handler);
  push_notification_data(std::move(notification), 0);
}

References m_evt_handler, m_id_provider, m_pop_notifications, ProgressBarNotificationLevel, Slic3r::GUI::ProgressIndicator, and push_notification_data().

Referenced by progress_indicator_set_cancel_callback(), progress_indicator_set_progress(), progress_indicator_set_range(), and progress_indicator_set_status_text().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_slicing_progress_notification()

void Slic3r::GUI::NotificationManager::init_slicing_progress_notification ( std::function< bool()> cancel_callback )

{
  for (std::unique_ptr<PopNotification>& notification : m_pop_notifications) {
    if (notification->get_type() == NotificationType::SlicingProgress) {
      dynamic_cast<SlicingProgressNotification*>(notification.get())->set_cancel_callback(cancel_callback);
      return;
    }
  }
  NotificationData data{ NotificationType::SlicingProgress, NotificationLevel::ProgressBarNotificationLevel, 0,  std::string(),std::string(),
              [](wxEvtHandler* evnthndlr) {
                if (evnthndlr != nullptr)
                  wxPostEvent(evnthndlr, ExportGcodeNotificationClickedEvent(EVT_EXPORT_GCODE_NOTIFICAION_CLICKED));
                return true;
              }
  };
  push_notification_data(std::make_unique<NotificationManager::SlicingProgressNotification>(data, m_id_provider, m_evt_handler, cancel_callback), 0);
}

References m_evt_handler, m_id_provider, m_pop_notifications, ProgressBarNotificationLevel, push_notification_data(), Slic3r::GUI::NotificationManager::SlicingProgressNotification::set_cancel_callback(), and Slic3r::GUI::SlicingProgress.

Here is the call graph for this function:

◆ is_hint_notification_open()

bool Slic3r::GUI::NotificationManager::is_hint_notification_open ( )

{
  for (std::unique_ptr<PopNotification>& notification : m_pop_notifications) {
    if (notification->get_type() == NotificationType::DidYouKnowHint)
      return true;
  }
  return false;
}

References Slic3r::GUI::DidYouKnowHint, and m_pop_notifications.

◆ new_export_began()

void Slic3r::GUI::NotificationManager::new_export_began ( bool on_removable )

{
  close_notification_of_type(NotificationType::ExportFinished);
  // If we want to hold information of ejecting removable on later export finished notifications
  /*
  for (std::unique_ptr<PopNotification>& notification : m_pop_notifications) {
    if (notification->get_type() == NotificationType::ExportToRemovableFinished) {
      if (!on_removable) {
        const NotificationData old_data = notification->get_data();
        notification->update( {old_data.type, old_data.level ,old_data.duration, std::string(), old_data.hypertext} );
      } else {
        notification->close();
      }
      return;
    }
  }
  */
}

References close_notification_of_type(), and Slic3r::GUI::ExportFinished.

Here is the call graph for this function:

◆ on_change_color_mode()

void Slic3r::GUI::NotificationManager::on_change_color_mode ( bool is_dark )

                                                           {
  m_is_dark = is_dark;
  for (std::unique_ptr<PopNotification>& notification : m_pop_notifications){
    notification->on_change_color_mode(is_dark);
  }
}

References is_dark(), m_is_dark, and m_pop_notifications.

Here is the call graph for this function:

◆ progress_indicator_get_range()

int Slic3r::GUI::NotificationManager::progress_indicator_get_range ( ) const

{
  for (const std::unique_ptr<PopNotification>& notification : m_pop_notifications) {
    if (notification->get_type() == NotificationType::ProgressIndicator) {
      return dynamic_cast<ProgressIndicatorNotification*>(notification.get())->get_range();
    }
  }
  return 0;
}

References Slic3r::GUI::NotificationManager::ProgressIndicatorNotification::get_range(), m_pop_notifications, and Slic3r::GUI::ProgressIndicator.

Here is the call graph for this function:

◆ progress_indicator_set_cancel_callback()

void Slic3r::GUI::NotificationManager::progress_indicator_set_cancel_callback ( CancelFn callback = CancelFn() )

{
  for (std::unique_ptr<PopNotification>& notification : m_pop_notifications) {
    if (notification->get_type() == NotificationType::ProgressIndicator) {
      dynamic_cast<ProgressIndicatorNotification*>(notification.get())->set_cancel_callback(callback);
      return;
    }
  }
  init_progress_indicator();
}

References init_progress_indicator(), m_pop_notifications, Slic3r::GUI::ProgressIndicator, and Slic3r::GUI::NotificationManager::ProgressIndicatorNotification::set_cancel_callback().

Here is the call graph for this function:

◆ progress_indicator_set_progress()

void Slic3r::GUI::NotificationManager::progress_indicator_set_progress ( int pr )

{
  for (std::unique_ptr<PopNotification>& notification : m_pop_notifications) {
    if (notification->get_type() == NotificationType::ProgressIndicator) {
      dynamic_cast<ProgressIndicatorNotification*>(notification.get())->set_progress(pr);
      // Ask for rendering - needs to be done on every progress. Calls to here doesnt trigger IDLE event or rendering.
      wxGetApp().plater()->get_current_canvas3D()->schedule_extra_frame(100);
      return;
    }
  }
  init_progress_indicator();
}

References init_progress_indicator(), m_pop_notifications, Slic3r::GUI::ProgressIndicator, and Slic3r::GUI::NotificationManager::ProgressIndicatorNotification::set_progress().

Here is the call graph for this function:

◆ progress_indicator_set_range()

void Slic3r::GUI::NotificationManager::progress_indicator_set_range ( int range )

{
  for (std::unique_ptr<PopNotification>& notification : m_pop_notifications) {
    if (notification->get_type() == NotificationType::ProgressIndicator) {
      dynamic_cast<ProgressIndicatorNotification*>(notification.get())->set_range(range);
      return;
    }
  }
  init_progress_indicator();
}

References init_progress_indicator(), m_pop_notifications, Slic3r::GUI::ProgressIndicator, Slic3r::range(), and Slic3r::GUI::NotificationManager::ProgressIndicatorNotification::set_range().

Here is the call graph for this function:

◆ progress_indicator_set_status_text()

void Slic3r::GUI::NotificationManager::progress_indicator_set_status_text ( const char * text )

{
  for (std::unique_ptr<PopNotification>& notification : m_pop_notifications) {
    if (notification->get_type() == NotificationType::ProgressIndicator) {
      dynamic_cast<ProgressIndicatorNotification*>(notification.get())->set_status_text(text);
      return;
    }
  }
  init_progress_indicator();
}

References init_progress_indicator(), m_pop_notifications, Slic3r::GUI::ProgressIndicator, and Slic3r::GUI::NotificationManager::ProgressIndicatorNotification::set_status_text().

Here is the call graph for this function:

◆ push_delayed_notification()

void Slic3r::GUI::NotificationManager::push_delayed_notification	(	const NotificationType	type,
		std::function< bool(void)>	condition_callback,
		int64_t	initial_delay,
		int64_t	delay_interval )

{
  auto it = std::find_if(std::begin(basic_notifications), std::end(basic_notifications),
    boost::bind(&NotificationData::type, boost::placeholders::_1) == type);
  assert(it != std::end(basic_notifications));
  if (it != std::end(basic_notifications))
    push_delayed_notification_data(std::make_unique<PopNotification>(*it, m_id_provider, m_evt_handler), condition_callback, initial_delay, delay_interval);
}

References basic_notifications, m_evt_handler, m_id_provider, push_delayed_notification_data(), and Slic3r::GUI::NotificationManager::NotificationData::type.

Here is the call graph for this function:

◆ push_delayed_notification_data()

void Slic3r::GUI::NotificationManager::push_delayed_notification_data	(	std::unique_ptr< NotificationManager::PopNotification >	notification,
		std::function< bool(void)>	condition_callback,
		int64_t	initial_delay,
		int64_t	delay_interval )

private

{
  if (initial_delay == 0 && condition_callback()) {
    if( push_notification_data(std::move(notification), 0))
      return;
  }
  m_waiting_notifications.emplace_back(std::move(notification), condition_callback, initial_delay == 0 ? delay_interval : initial_delay, delay_interval);
  wxGetApp().plater()->get_current_canvas3D()->schedule_extra_frame(initial_delay == 0 ? delay_interval : initial_delay);
}

References m_waiting_notifications, and push_notification_data().

Referenced by push_delayed_notification(), and push_hint_notification().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ push_download_URL_progress_notification()

void Slic3r::GUI::NotificationManager::push_download_URL_progress_notification	(	size_t	id,
		const std::string &	text,
		std::function< bool(DownloaderUserAction, int)>	user_action_callback )

{
    // If already exists
    for (std::unique_ptr<PopNotification>& notification : m_pop_notifications) {
        if (notification->get_type() == NotificationType::URLDownload && dynamic_cast<URLDownloadNotification*>(notification.get())->get_download_id() == id) {
            return;
        }
    }
    // push new one
    NotificationData data{ NotificationType::URLDownload, NotificationLevel::ProgressBarNotificationLevel, 5, _u8L("Download") + ": " + text };
    push_notification_data(std::make_unique<NotificationManager::URLDownloadNotification>(data, m_id_provider, m_evt_handler, id, user_action_callback), 0);
}

References _u8L, Slic3r::GUI::NotificationManager::URLDownloadNotification::get_download_id(), m_evt_handler, m_id_provider, m_pop_notifications, ProgressBarNotificationLevel, push_notification_data(), and Slic3r::GUI::URLDownload.

Referenced by Slic3r::GUI::Downloader::start_download().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ push_exporting_finished_notification()

void Slic3r::GUI::NotificationManager::push_exporting_finished_notification	(	const std::string &	path,
		const std::string &	dir_path,
		bool	on_removable )

{
  close_notification_of_type(NotificationType::ExportFinished);
  NotificationData data{ NotificationType::ExportFinished, NotificationLevel::RegularNotificationLevel, on_removable ? 0 : 20,  _u8L("Exported successfully") + "\n" + path };
  push_notification_data(std::make_unique<NotificationManager::ExportFinishedNotification>(data, m_id_provider, m_evt_handler, on_removable, path, dir_path), 0);
  set_slicing_progress_hidden();
}

References _u8L, close_notification_of_type(), Slic3r::GUI::ExportFinished, m_evt_handler, m_id_provider, push_notification_data(), RegularNotificationLevel, and set_slicing_progress_hidden().

Here is the call graph for this function:

◆ push_flushing_volume_error_notification()

void Slic3r::GUI::NotificationManager::push_flushing_volume_error_notification	(	NotificationType	type,
		NotificationLevel	level,
		const std::string &	text,
		const std::string &	hypertext = "",
		std::function< bool(wxEvtHandler *)>	callback = std::function<bool(wxEvtHandler *)>() )

{
    set_all_slicing_errors_gray(false);
    std::string prefix_msg = level == NotificationLevel::WarningNotificationLevel ? _u8L("Warning:") : _u8L("Error:");
    push_notification_data({type, level, 0, prefix_msg + "\n" + text, hypertext, callback}, 0);
}

References _u8L, push_notification_data(), set_all_slicing_errors_gray(), and WarningNotificationLevel.

Here is the call graph for this function:

◆ push_general_error_notification()

void Slic3r::GUI::NotificationManager::push_general_error_notification ( const std::string & text )

{
  push_notification_data({ NotificationType::BBLGeneralError, NotificationLevel::ErrorNotificationLevel, 0,  _u8L("Error:") + "\n" + text }, 0);
}

References _u8L, Slic3r::GUI::BBLGeneralError, ErrorNotificationLevel, and push_notification_data().

Referenced by Slic3r::GUI::Plater::export_stl().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ push_hint_notification()

void Slic3r::GUI::NotificationManager::push_hint_notification ( bool open_next )

{
  return;
  for (std::unique_ptr<PopNotification>& notification : m_pop_notifications) {
    if (notification->get_type() == NotificationType::DidYouKnowHint) {
      (dynamic_cast<HintNotification*>(notification.get()))->open_next();
      return;
    }
  }
 
  NotificationData data{ NotificationType::DidYouKnowHint, NotificationLevel::HintNotificationLevel, 300, "" };
  // from user - open now
  if (!open_next) {
    push_notification_data(std::make_unique<NotificationManager::HintNotification>(data, m_id_provider, m_evt_handler, open_next), 0);
    stop_delayed_notifications_of_type(NotificationType::DidYouKnowHint);
    // at startup - delay for half a second to let other notification pop up, than try every 30 seconds
    // show only if no notifications are shown
  }
  else {
    auto condition = [&self = std::as_const(*this)]() {
      return self.get_notification_count() == 0;
    };
    push_delayed_notification_data(std::make_unique<NotificationManager::HintNotification>(data, m_id_provider, m_evt_handler, open_next), condition, 500, 30000);
  }
}

References Slic3r::GUI::DidYouKnowHint, HintNotificationLevel, m_evt_handler, m_id_provider, m_pop_notifications, push_delayed_notification_data(), push_notification_data(), and stop_delayed_notifications_of_type().

Here is the call graph for this function:

◆ push_import_finished_notification()

void Slic3r::GUI::NotificationManager::push_import_finished_notification	(	const std::string &	path,
		const std::string &	dir_path,
		bool	on_removable )

{
    close_notification_of_type(NotificationType::ExportFinished);
    NotificationData data{ NotificationType::ExportFinished, NotificationLevel::RegularNotificationLevel, on_removable ? 0 : 20,  _u8L("Model file downloaded.") + "\n" + path };
    push_notification_data(std::make_unique<NotificationManager::ExportFinishedNotification>(data, m_id_provider, m_evt_handler, on_removable, path, dir_path), 0);
    set_slicing_progress_hidden();
}

References _u8L, close_notification_of_type(), Slic3r::GUI::ExportFinished, m_evt_handler, m_id_provider, push_notification_data(), RegularNotificationLevel, and set_slicing_progress_hidden().

Here is the call graph for this function:

◆ push_notification() [1/3]

void Slic3r::GUI::NotificationManager::push_notification	(	const NotificationType	type,
		int	timestamp = 0 )

{
  auto it = std::find_if(std::begin(basic_notifications), std::end(basic_notifications),
    boost::bind(&NotificationData::type, boost::placeholders::_1) == type);
  assert(it != std::end(basic_notifications));
  if (it != std::end(basic_notifications))
    push_notification_data(*it, timestamp);
}

References basic_notifications, push_notification_data(), and Slic3r::GUI::NotificationManager::NotificationData::type.

Referenced by Slic3r::GUI::Plater::_calib_pa_pattern(), bbl_show_app_newversion_notification(), Slic3r::PluginManager::fetch_plugins_from_cloud(), Slic3r::GUI::Plater::load_gcode(), Slic3r::GUI::Plater::notify_painting_removed(), and Slic3r::GUI::Downloader::start_download().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ push_notification() [2/3]

void Slic3r::GUI::NotificationManager::push_notification	(	const std::string &	text,
		int	timestamp = 0 )

{
  push_notification_data({ NotificationType::CustomNotification, NotificationLevel::RegularNotificationLevel, 10, text }, timestamp);
}

References Slic3r::GUI::CustomNotification, push_notification_data(), and RegularNotificationLevel.

Here is the call graph for this function:

◆ push_notification() [3/3]

void Slic3r::GUI::NotificationManager::push_notification	(	NotificationType	type,
		NotificationLevel	level,
		const std::string &	text,
		const std::string &	hypertext = "",
		std::function< bool(wxEvtHandler *)>	callback = std::function<bool(wxEvtHandler*)>(),
		int	timestamp = 0 )

{
  int duration = get_standard_duration(level);
    push_notification_data({ type, level, duration, text, hypertext, callback }, timestamp);
}

References get_standard_duration(), and push_notification_data().

Here is the call graph for this function:

◆ push_notification_data() [1/2]

bool Slic3r::GUI::NotificationManager::push_notification_data	(	const NotificationData &	notification_data,
		int	timestamp )

private

{
  return push_notification_data(std::make_unique<PopNotification>(notification_data, m_id_provider, m_evt_handler), timestamp);
}

References m_evt_handler, m_id_provider, and push_notification_data().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ push_notification_data() [2/2]

bool Slic3r::GUI::NotificationManager::push_notification_data	(	std::unique_ptr< NotificationManager::PopNotification >	notification,
		int	timestamp )

private

{
  // if timestamped notif, push only new one
  if (timestamp != 0) {
    if (m_used_timestamps.find(timestamp) == m_used_timestamps.end()) {
      m_used_timestamps.insert(timestamp);
    } else {
      return false;
    }
  }
    if(!notification->is_valid_delete_callback()){
        auto delete_self = [this](NotificationManager::PopNotification* it) {
             m_to_delete_after_finish_render = it;
        };
        notification->set_delete_callback(delete_self);
    }
  bool retval = false;
  if (this->activate_existing(notification.get())) {
    if (m_initialized && m_imgui_ready) {
      // Precise Seam already aggregates all causes; replace it on repeated warning events.
      if (notification->get_type() == NotificationType::SlicingWarning &&
                notification->get_data().sub_msg_id != PrintStateBase::SlicingPreciseSeamWarning) {
        m_pop_notifications.back()->append(notification->get_data().ori_text);
      } else {
                m_pop_notifications.back()->update(notification->get_data());
            }
    }
  } else {
    m_pop_notifications.emplace_back(std::move(notification));
        
    retval = true;
  }
  if (!m_initialized)
    return retval;
  GLCanvas3D& canvas = *wxGetApp().plater()->get_current_canvas3D();
  canvas.schedule_extra_frame(0);
  return retval;
}

References activate_existing(), m_imgui_ready, m_initialized, m_pop_notifications, m_to_delete_after_finish_render, m_used_timestamps, Slic3r::GUI::GLCanvas3D::schedule_extra_frame(), Slic3r::PrintStateBase::SlicingPreciseSeamWarning, and Slic3r::GUI::SlicingWarning.

Here is the call graph for this function:

◆ push_orca_sync_conflict_notification()

void Slic3r::GUI::NotificationManager::push_orca_sync_conflict_notification	(	const std::string &	text,
		int	conflict_code,
		std::function< bool(wxEvtHandler *)>	pull_callback,
		std::function< bool(wxEvtHandler *)>	force_push_callback )

{
  close_notification_of_type(NotificationType::OrcaSyncConflict);
  NotificationData data{ NotificationType::OrcaSyncConflict, NotificationLevel::WarningNotificationLevel, 0, text };
  push_notification_data(std::make_unique<NotificationManager::OrcaSyncConflictNotification>(
    data, m_id_provider, m_evt_handler, std::move(pull_callback), std::move(force_push_callback), conflict_code), 0);
}

References close_notification_of_type(), m_evt_handler, m_id_provider, Slic3r::GUI::OrcaSyncConflict, push_notification_data(), and WarningNotificationLevel.

Here is the call graph for this function:

◆ push_plater_error_notification()

void Slic3r::GUI::NotificationManager::push_plater_error_notification ( const std::string & text )

{
  push_notification_data({ NotificationType::PlaterError, NotificationLevel::ErrorNotificationLevel, 0,  _u8L("Error:") + "\n" + text }, 0);
}

References _u8L, ErrorNotificationLevel, Slic3r::GUI::PlaterError, and push_notification_data().

Referenced by Slic3r::GUI::Plater::export_stl().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ push_plater_warning_notification()

void Slic3r::GUI::NotificationManager::push_plater_warning_notification ( const std::string & text )

{
  // Find if was not hidden
  for (std::unique_ptr<PopNotification>& notification : m_pop_notifications) {
    if (notification->get_type() == NotificationType::PlaterWarning && notification->compare_text(_u8L("Warning:") + "\n" + text)) {
      if (notification->get_state() == PopNotification::EState::Hidden) {
        //dynamic_cast<PlaterWarningNotification*>(notification.get())->show();
        return;
      }
    }
  }
 
  NotificationData data{ NotificationType::PlaterWarning, NotificationLevel::WarningNotificationLevel, 0,  _u8L("Warning:") + "\n" + text };
 
  auto notification = std::make_unique<NotificationManager::PlaterWarningNotification>(data, m_id_provider, m_evt_handler);
  push_notification_data(std::move(notification), 0);
  // dissaper if in preview
  apply_in_preview();
}

References _u8L, apply_in_preview(), Slic3r::GUI::NotificationManager::PopNotification::Hidden, m_evt_handler, m_id_provider, m_pop_notifications, Slic3r::GUI::PlaterWarning, push_notification_data(), and WarningNotificationLevel.

Here is the call graph for this function:

◆ push_plugin_missing_notification()

void Slic3r::GUI::NotificationManager::push_plugin_missing_notification	(	NotificationType	type,
		const std::string &	text,
		const std::string &	resolve_label,
		std::vector< JumpTo >	body,
		std::function< bool(wxEvtHandler *)>	resolve_callback )

{
  m_pop_notifications.erase(std::remove_if(m_pop_notifications.begin(), m_pop_notifications.end(),
    [type](const std::unique_ptr<PopNotification>& notification) {
      return notification && notification->get_type() == type;
    }), m_pop_notifications.end());
  NotificationData data{ type, NotificationLevel::ErrorNotificationLevel, 0, text };
  push_notification_data(std::make_unique<NotificationManager::PluginMissingNotification>(
    data, m_id_provider, m_evt_handler, resolve_label, std::move(body), std::move(resolve_callback)), 0);
}

References ErrorNotificationLevel, m_evt_handler, m_id_provider, m_pop_notifications, and push_notification_data().

Here is the call graph for this function:

◆ push_shared_profiles_notification()

void Slic3r::GUI::NotificationManager::push_shared_profiles_notification ( const std::string & explore_url )

{
  close_notification_of_type(NotificationType::OrcaSharedProfilesAvailable);
  NotificationData data{ NotificationType::OrcaSharedProfilesAvailable, NotificationLevel::RegularNotificationLevel, 0,
    _u8L("Shared profiles may be available for this printer."),
    _u8L("Browse shared profiles") };
  push_notification_data(std::make_unique<NotificationManager::SharedProfilesNotification>(data, m_id_provider, m_evt_handler, explore_url), 0);
}

References _u8L, close_notification_of_type(), m_evt_handler, m_id_provider, Slic3r::GUI::OrcaSharedProfilesAvailable, push_notification_data(), and RegularNotificationLevel.

Here is the call graph for this function:

◆ push_simplify_suggestion_notification()

void Slic3r::GUI::NotificationManager::push_simplify_suggestion_notification	(	const std::string &	text,
		ObjectID	object_id,
		const std::string &	hypertext = "",
		std::function< bool(wxEvtHandler *)>	callback = std::function<bool(wxEvtHandler*)>() )

{
  NotificationData data{ NotificationType::SimplifySuggestion, NotificationLevel::PrintInfoNotificationLevel, 0,  text, hypertext, callback };
  auto notification = std::make_unique<NotificationManager::ObjectIDNotification>(data, m_id_provider, m_evt_handler);
  notification->object_id = object_id;
  push_notification_data(std::move(notification), 0);
}

References m_evt_handler, m_id_provider, PrintInfoNotificationLevel, push_notification_data(), and Slic3r::GUI::SimplifySuggestion.

Referenced by Slic3r::GUI::GLGizmoSimplify::add_simplify_suggestion_notification().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ push_slicing_customize_error_notification()

void Slic3r::GUI::NotificationManager::push_slicing_customize_error_notification	(	NotificationType	type,
		NotificationLevel	level,
		const std::string &	text,
		const std::string &	hypertext = "",
		std::function< bool(wxEvtHandler *)>	callback = std::function<bool(wxEvtHandler*)>() )

{
    set_all_slicing_errors_gray(false);
    std::string prefix_msg = level == NotificationLevel::WarningNotificationLevel ? _u8L("Warning:") : _u8L("Error:");
    push_notification_data({type, level, 0, prefix_msg + "\n" + text, hypertext, callback}, 0);
}

References _u8L, push_notification_data(), set_all_slicing_errors_gray(), and WarningNotificationLevel.

Here is the call graph for this function:

◆ push_slicing_error_notification()

void Slic3r::GUI::NotificationManager::push_slicing_error_notification	(	const std::string &	text,
		std::vector< ModelObject const * >	objs )

{
    std::vector<ObjectID> ids;
    for (auto optr : objs) {
        if (optr)
            ids.push_back(optr->id());
    }
  std::function<bool(wxEvtHandler*)> callback;
  if (!objs.empty()) {
    callback = [ids](wxEvtHandler*) {
      auto& objects = wxGetApp().model().objects;
      std::vector<ObjectVolumeID> ovs;
      for (auto id : ids) {
        auto iter = std::find_if(objects.begin(), objects.end(), [id](auto o) { return o->id() == id; });
        if (iter != objects.end()) { ovs.push_back({ *iter, nullptr }); }
      }
      if (!ovs.empty()) {
        wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
        wxGetApp().obj_list()->select_items(ovs);
      }
      return false;
    };
  }
    auto link     = callback ? _u8L("Jump to") : "";
    if (!objs.empty()) {
        link += " [";
        for (auto obj : objs) {
            if (obj)
                link += obj->name + ", ";
        }
        if (!objs.empty()) {
            link.pop_back();
            link.pop_back();
        }
        link += "] ";
    }
    set_all_slicing_errors_gray(false);
  push_notification_data({ NotificationType::SlicingError, NotificationLevel::ErrorNotificationLevel, 0,  _u8L("Error:") + "\n" + text, link, callback }, 0);
  set_slicing_progress_hidden();
}

References _u8L, ErrorNotificationLevel, push_notification_data(), set_all_slicing_errors_gray(), set_slicing_progress_hidden(), Slic3r::GUI::SlicingError, and TAB_ID_PREPARE.

Here is the call graph for this function:

◆ push_slicing_serious_warning_notification() [1/2]

void Slic3r::GUI::NotificationManager::push_slicing_serious_warning_notification	(	const std::string &	text,
		std::vector< ModelInstance const * >	insts )

{
    std::vector<std::pair<ObjectID, ObjectID>> ids;
    for (auto iptr : insts) {
        if (iptr && iptr->get_object()) {
            ids.push_back({iptr->get_object()->id(), iptr->id()});
        }
    }
    std::function<bool(wxEvtHandler*)> callback;
    if (!insts.empty()) {
        callback = [ids](wxEvtHandler*) {
            auto& objects = wxGetApp().model().objects;
            wxDataViewItemArray sel_items;
            std::vector<ObjectVolumeID> fallback_ovs;
            auto* obj_list = wxGetApp().obj_list();
            if (!obj_list) return false;
            auto* model = obj_list->GetModel();
            if (!model) return false;
 
            for (const auto& pair : ids) {
                ObjectID obj_id = pair.first;
                ObjectID inst_id = pair.second;
                
                auto iter = std::find_if(objects.begin(), objects.end(), [obj_id](auto o) { return o->id() == obj_id; });
                if (iter != objects.end()) {
                    ModelObject* obj = *iter;
                    int inst_idx = -1;
                    for (int i=0; i<obj->instances.size(); ++i) {
                        if (obj->instances[i]->id() == inst_id) {
                            inst_idx = i;
                            break;
                        }
                    }
                    
                    if (inst_idx != -1) {
                        wxDataViewItem item;
                        wxDataViewItem objItem = model->GetObjectItem(obj);
                        if (objItem.IsOk()) {
                             int vm_obj_idx = model->GetIdByItem(objItem);
                             if (vm_obj_idx != -1) {
                                 item = model->GetItemByInstanceId(vm_obj_idx, inst_idx);
                             }
                        }
 
                        if (item.IsOk()) {
                            sel_items.Add(item);
                        } else {
                            fallback_ovs.push_back({obj, nullptr});
                        }
                    } else {
                         fallback_ovs.push_back({obj, nullptr});
                    }
                }
            }
            
            wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
            
            if (!sel_items.empty()) {
                obj_list->select_items(sel_items);
                obj_list->update_selections_on_canvas();
            } else if (!fallback_ovs.empty()) {
                obj_list->select_items(fallback_ovs);
                obj_list->update_selections_on_canvas();
            }
            
            return false;
        };
    }
    auto link     = callback ? _u8L("Jump to") : "";
    std::vector<std::string> names;
    for (auto iptr : insts) {
        if (iptr && iptr->get_object()) {
            names.push_back(iptr->get_object()->name);
        }
    }
    if (!names.empty()) {
        link += " [";
        for (size_t i = 0; i < names.size(); ++i) {
            if (i > 0) link += ", ";
            link += names[i];
        }
        link += "] ";
    }
    set_all_slicing_warnings_gray(false);
    push_notification_data({NotificationType::SlicingSeriousWarning, NotificationLevel::SeriousWarningNotificationLevel, 0, _u8L("Serious warning:") + "\n" + text, link,
                            callback},
                           0);
    set_slicing_progress_hidden();
}

References _u8L, Slic3r::ModelObject::instances, Slic3r::GUI::obj_list(), push_notification_data(), SeriousWarningNotificationLevel, set_all_slicing_warnings_gray(), set_slicing_progress_hidden(), Slic3r::GUI::SlicingSeriousWarning, and TAB_ID_PREPARE.

Here is the call graph for this function:

◆ push_slicing_serious_warning_notification() [2/2]

void Slic3r::GUI::NotificationManager::push_slicing_serious_warning_notification	(	const std::string &	text,
		std::vector< ModelObject const * >	objs )

{
    std::vector<ObjectID> ids;
    for (auto optr : objs) {
        if (optr) ids.push_back(optr->id());
    }
  std::function<bool(wxEvtHandler*)> callback;
  if (!objs.empty()) {
    callback = [ids](wxEvtHandler*) {
      auto& objects = wxGetApp().model().objects;
      std::vector<ObjectVolumeID> ovs;
      for (auto id : ids) {
        auto iter = std::find_if(objects.begin(), objects.end(), [id](auto o) { return o->id() == id; });
        if (iter != objects.end()) { ovs.push_back({ *iter, nullptr }); }
      }
      if (!ovs.empty()) {
        wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
        wxGetApp().obj_list()->select_items(ovs);
        wxGetApp().obj_list()->update_selections_on_canvas();
      }
      return false;
    };
  }
    auto link     = callback ? _u8L("Jump to") : "";
    std::vector<std::string> names;
    for (auto optr : objs) {
        if (optr) {
            names.push_back(optr->name);
        }
    }
    if (!names.empty()) {
        link += " [";
        for (size_t i = 0; i < names.size(); ++i) {
            if (i > 0) link += ", ";
            link += names[i];
        }
        link += "] ";
    }
    set_all_slicing_warnings_gray(false);
    push_notification_data({NotificationType::SlicingSeriousWarning, NotificationLevel::SeriousWarningNotificationLevel, 0, _u8L("Serious warning:") + "\n" + text, link,
                            callback},
                           0);
    set_slicing_progress_hidden();
}

References _u8L, push_notification_data(), SeriousWarningNotificationLevel, set_all_slicing_warnings_gray(), set_slicing_progress_hidden(), Slic3r::GUI::SlicingSeriousWarning, and TAB_ID_PREPARE.

Here is the call graph for this function:

◆ push_slicing_warning_notification()

void Slic3r::GUI::NotificationManager::push_slicing_warning_notification	(	const std::string &	text,
		bool	gray,
		ModelObject const *	obj,
		ObjectID	oid,
		int	warning_step,
		int	warning_msg_id,
		NotificationLevel	level = NotificationLevel::WarningNotificationLevel )

{
  std::function<bool(wxEvtHandler*)> callback;
  if (obj) {
    callback = [id = obj->id()](wxEvtHandler*) {
      auto& objects = wxGetApp().model().objects;
      auto iter = std::find_if(objects.begin(), objects.end(), [id](auto o) { return o->id() == id; });
      if (iter != objects.end()) {
        wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
        wxGetApp().obj_list()->select_items({ {*iter, nullptr} });
      }
      return false;
    };
  }
    auto link = callback ? _u8L("Jump to") : "";
    if (obj) link += std::string(" [") + obj->name + "]";
  NotificationData data { NotificationType::SlicingWarning, level, 0,  _u8L("Warning:") + "\n" + text, link, callback };
 
  data.sub_msg_id = warning_msg_id;
  data.ori_text = text;
 
  auto notification = std::make_unique<NotificationManager::ObjectIDNotification>(data, m_id_provider, m_evt_handler);
  notification->object_id = oid;
  notification->warning_step = warning_step;
  if (push_notification_data(std::move(notification), 0)) {
    m_pop_notifications.back()->set_gray(gray);
  }
}

References _u8L, Slic3r::ObjectBase::id(), m_evt_handler, m_id_provider, m_pop_notifications, Slic3r::ModelObject::name, Slic3r::GUI::NotificationManager::NotificationData::ori_text, push_notification_data(), Slic3r::GUI::SlicingWarning, Slic3r::GUI::NotificationManager::NotificationData::sub_msg_id, and TAB_ID_PREPARE.

Here is the call graph for this function:

◆ push_updated_item_info_notification()

void Slic3r::GUI::NotificationManager::push_updated_item_info_notification ( InfoItemType type )

{
  for (std::unique_ptr<PopNotification>& notification : m_pop_notifications) {
    if (notification->get_type() == NotificationType::UpdatedItemsInfo) {
      (dynamic_cast<UpdatedItemsInfoNotification*>(notification.get()))->add_type(type);
      return;
    }
  }
 
  NotificationData data{ NotificationType::UpdatedItemsInfo, NotificationLevel::PrintInfoNotificationLevel, 10, "" };
  auto notification = std::make_unique<NotificationManager::UpdatedItemsInfoNotification>(data, m_id_provider, m_evt_handler, type);
  if (push_notification_data(std::move(notification), 0)) {
    (dynamic_cast<UpdatedItemsInfoNotification*>(m_pop_notifications.back().get()))->add_type(type);
  }
 
}

References m_evt_handler, m_id_provider, m_pop_notifications, PrintInfoNotificationLevel, push_notification_data(), and Slic3r::GUI::UpdatedItemsInfo.

Here is the call graph for this function:

◆ push_upload_job_notification()

void Slic3r::GUI::NotificationManager::push_upload_job_notification	(	int	id,
		float	filesize,
		const std::string &	filename,
		const std::string &	host,
		float	percentage = 0 )

{
  // find if upload with same id was not already in notification
  // done by compare_jon_id not compare_text thus has to be performed here
  for (std::unique_ptr<PopNotification>& notification : m_pop_notifications) {
    if (notification->get_type() == NotificationType::PrintHostUpload && dynamic_cast<PrintHostUploadNotification*>(notification.get())->compare_job_id(id)) {
      return;
    }
  }
  std::string text = PrintHostUploadNotification::get_upload_job_text(id, filename, host);
  NotificationData data{ NotificationType::PrintHostUpload, NotificationLevel::ProgressBarNotificationLevel, 10, text };
  push_notification_data(std::make_unique<NotificationManager::PrintHostUploadNotification>(data, m_id_provider, m_evt_handler, 0, id, filesize), 0);
}

References Slic3r::GUI::NotificationManager::PrintHostUploadNotification::compare_job_id(), Slic3r::GUI::NotificationManager::PrintHostUploadNotification::get_upload_job_text(), m_evt_handler, m_id_provider, m_pop_notifications, Slic3r::GUI::PrintHostUpload, ProgressBarNotificationLevel, and push_notification_data().

Here is the call graph for this function:

◆ push_validate_error_notification()

void Slic3r::GUI::NotificationManager::push_validate_error_notification ( StringObjectException const & error )

{
    auto po = dynamic_cast<PrintObjectBase const *>(error.object);
    auto mo = po ? po->model_object() : dynamic_cast<ModelObject const *>(error.object);
    //ORCA: Update to handle ModelInstance selection for validation errors with fallback
    /*
  std::function<bool(wxEvtHandler*)> callback;
  if (mo || !error.opt_key.empty()) {
    callback =
      [id = mo ? mo->id() : 0, opt = error.opt_key](wxEvtHandler*) {
      auto& objects = wxGetApp().model().objects;
      auto iter = id.id ? std::find_if(objects.begin(), objects.end(), [id](auto o) { return o->id() == id; }) : objects.end();
      if (iter != objects.end()) {
        wxGetApp().obj_list()->select_items({ {*iter, nullptr} });
                wxGetApp().obj_list()->update_selections_on_canvas();
            }
      if (!opt.empty()) {
        if (iter != objects.end())
          wxGetApp().params_panel()->switch_to_object();
        wxGetApp().sidebar().jump_to_option(opt, Preset::TYPE_PRINT, L"");
      }
      else {
        wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
      }
      return false;
    };
  }
    auto link = (mo || !error.opt_key.empty()) ? _u8L("Jump to") : "";
    if (mo) link += std::string(" [") + mo->name + "]";
    */
    auto mi = dynamic_cast<ModelInstance const *>(error.object);
  std::function<bool(wxEvtHandler*)> callback;
  if (mo || mi || !error.opt_key.empty()) {
    callback =
      [id = mo ? mo->id() : (mi ? mi->id() : 0),
             parent_id = mi ? mi->get_object()->id() : 0,
             is_inst = (mi != nullptr),
             opt = error.opt_key](wxEvtHandler*) {
      auto& objects = wxGetApp().model().objects;
 
            if (is_inst) {
                 bool selected = false;
                 auto iter = std::find_if(objects.begin(), objects.end(), [parent_id](auto o) { return o->id() == parent_id; });
                 if (iter != objects.end()) {
                      ModelObject* obj = *iter;
                      int inst_idx = -1;
                      for(size_t i=0; i<obj->instances.size(); ++i) {
                          if (obj->instances[i]->id() == id) {
                              inst_idx = i;
                              break;
                          }
                      }
                      if (inst_idx != -1) {
                         auto* model = wxGetApp().obj_list()->GetModel();
                         wxDataViewItem item;
                         wxDataViewItem objItem = model->GetObjectItem(obj);
                         if (objItem.IsOk()) {
                             int vm_obj_idx = model->GetIdByItem(objItem);
                             if (vm_obj_idx != -1) {
                                 item = model->GetItemByInstanceId(vm_obj_idx, inst_idx);
                             }
                         }
                         if (item.IsOk()) {
                             wxDataViewItemArray sel_items;
                             sel_items.Add(item);
                             wxGetApp().obj_list()->select_items(sel_items);
                             selected = true;
                         }
                      }
                      
                      if (!selected) {
                           wxGetApp().obj_list()->select_items({ {obj, nullptr} });
                      }
                 }
            } else {
          auto iter = id.id ? std::find_if(objects.begin(), objects.end(), [id](auto o) { return o->id() == id; }) : objects.end();
          if (iter != objects.end())
            wxGetApp().obj_list()->select_items({ {*iter, nullptr} });
            }
 
      if (!opt.empty()) {
        const Preset::Type opt_type = resolve_validation_option_type(opt);
 
        if (opt_type == Preset::TYPE_PRINT && ((!is_inst && id.id) || (is_inst && parent_id.id))) // if object found and it's a print preset option, switch to object first
          wxGetApp().params_panel()->switch_to_object();
 
        wxGetApp().sidebar().jump_to_option(opt, opt_type, L"");
      }
      else {
        wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
      }
      return false;
    };
  }
    auto link = (mo || mi || !error.opt_key.empty()) ? _u8L("Jump to") : "";
    if (mo) link += std::string(" [") + mo->name + "]";
    if (mi) link += std::string(" [") + mi->get_object()->name + "]";
    if (!error.opt_key.empty()) link += std::string(" (") + error.opt_key + ")";
    push_notification_data({NotificationType::ValidateError, NotificationLevel::ErrorNotificationLevel, 0, _u8L("Error:") + "\n" + error.string, link, callback}, 0);
  set_slicing_progress_hidden();
}

References _u8L, ErrorNotificationLevel, Slic3r::ModelObject::instances, L, Slic3r::PrintObjectBase::model_object(), Slic3r::StringObjectException::object, Slic3r::StringObjectException::opt_key, push_notification_data(), set_slicing_progress_hidden(), Slic3r::StringObjectException::string, TAB_ID_PREPARE, Slic3r::Preset::TYPE_PRINT, and Slic3r::GUI::ValidateError.

Here is the call graph for this function:

◆ remove_notification_of_type()

void Slic3r::GUI::NotificationManager::remove_notification_of_type ( const NotificationType type )

                                                                                 {
    for (auto it = m_pop_notifications.begin(); it != m_pop_notifications.end();) {
        std::unique_ptr<PopNotification> &notification = *it;
        if (notification->get_type() == type) {
            it = m_pop_notifications.erase(it);
            break;
        } else
            ++it;
    }
}

References m_pop_notifications.

Referenced by clear_all().

Here is the caller graph for this function:

◆ remove_simplify_suggestion_of_released_objects()

void Slic3r::GUI::NotificationManager::remove_simplify_suggestion_of_released_objects ( const std::vector< ObjectID > & living_oids )

{
  for (std::unique_ptr<PopNotification>& notification : m_pop_notifications)
    if (notification->get_type() == NotificationType::SimplifySuggestion) {
      if (!std::binary_search(living_oids.begin(), living_oids.end(),
        static_cast<ObjectIDNotification*>(notification.get())->object_id))
        notification->close();
    }
}

References m_pop_notifications, Slic3r::GUI::NotificationManager::ObjectIDNotification::object_id, and Slic3r::GUI::SimplifySuggestion.

◆ remove_simplify_suggestion_with_id()

void Slic3r::GUI::NotificationManager::remove_simplify_suggestion_with_id ( const ObjectID oid )

{
  for (std::unique_ptr<PopNotification>& notification : m_pop_notifications)
    if (notification->get_type() == NotificationType::SimplifySuggestion) {
      if (static_cast<ObjectIDNotification*>(notification.get())->object_id == oid)
        notification->close();
    }
}

References m_pop_notifications, Slic3r::GUI::NotificationManager::ObjectIDNotification::object_id, and Slic3r::GUI::SimplifySuggestion.

◆ remove_slicing_warnings_of_released_objects()

void Slic3r::GUI::NotificationManager::remove_slicing_warnings_of_released_objects ( const std::vector< ObjectID > & living_oids )

{
  for (std::unique_ptr<PopNotification> &notification : m_pop_notifications)
    if (notification->get_type() == NotificationType::SlicingWarning) {
      if (! std::binary_search(living_oids.begin(), living_oids.end(),
        static_cast<ObjectIDNotification*>(notification.get())->object_id))
        notification->close();
    }
}

References m_pop_notifications, Slic3r::GUI::NotificationManager::ObjectIDNotification::object_id, and Slic3r::GUI::SlicingWarning.

◆ render_notifications()

void Slic3r::GUI::NotificationManager::render_notifications	(	GLCanvas3D &	canvas,
		float	overlay_width,
		float	bottom_margin,
		float	right_margin )

{
  // Notifications render inside an ImGui frame, so the font atlas is built from this point on
  // and pushed notifications may safely measure their text.
  m_imgui_ready = true;
 
  sort_notifications();
 
  float bottom_up_last_y = bottom_margin; // ORCA dont scale margins
 
  int i = 0;
  for (const auto& notification : m_pop_notifications) {
        if (notification->get_data().level == NotificationLevel::ErrorNotificationLevel || notification->get_data().level == NotificationLevel::SeriousWarningNotificationLevel) {
            notification->bbl_render_block_notification(canvas, bottom_up_last_y, m_move_from_overlay && !m_in_preview, overlay_width * m_scale, right_margin);  // ORCA dont scale margins
            if (notification->get_state() != PopNotification::EState::Finished) 
        bottom_up_last_y = notification->get_top() + GAP_WIDTH;
    }
    else {
      if (notification->get_state() != PopNotification::EState::Hidden && notification->get_state() != PopNotification::EState::Finished) {
        i++;
        notification->render(canvas, bottom_up_last_y, m_move_from_overlay && !m_in_preview, overlay_width * m_scale, right_margin); // ORCA dont scale margins
        if (notification->get_state() != PopNotification::EState::Finished)
          bottom_up_last_y = notification->get_top() + GAP_WIDTH;
      }
    }
  }
  for (const auto& notification : m_pop_notifications) {
    if (notification->get_data().type == NotificationType::SlicingProgress && notification->get_state() != PopNotification::EState::Hidden && notification->get_state() != PopNotification::EState::Finished) {
      ;// assert(i <= 1);
    }
  }
    if (m_to_delete_after_finish_render) {
        close_and_delete_self(m_to_delete_after_finish_render);
        m_to_delete_after_finish_render = nullptr;
    }
  m_last_render = GLCanvas3D::timestamp_now();
}

References close_and_delete_self(), ErrorNotificationLevel, Slic3r::GUI::NotificationManager::PopNotification::Finished, GAP_WIDTH, Slic3r::GUI::NotificationManager::PopNotification::Hidden, m_imgui_ready, m_in_preview, m_last_render, m_move_from_overlay, m_pop_notifications, m_scale, m_to_delete_after_finish_render, SeriousWarningNotificationLevel, Slic3r::GUI::SlicingProgress, sort_notifications(), and Slic3r::GUI::GLCanvas3D::timestamp_now().

Here is the call graph for this function:

◆ set_all_slicing_errors_gray()

void Slic3r::GUI::NotificationManager::set_all_slicing_errors_gray ( bool g )

{
  for (std::unique_ptr<PopNotification> &notification : m_pop_notifications) {
    if (notification->get_type() == NotificationType::SlicingError) {
      notification->set_gray(g);
    }
  }
}

References m_pop_notifications, and Slic3r::GUI::SlicingError.

Referenced by push_flushing_volume_error_notification(), push_slicing_customize_error_notification(), and push_slicing_error_notification().

Here is the caller graph for this function:

◆ set_all_slicing_warnings_gray()

void Slic3r::GUI::NotificationManager::set_all_slicing_warnings_gray ( bool g )

{
  for (std::unique_ptr<PopNotification> &notification : m_pop_notifications) {
    if (notification->get_type() == NotificationType::SlicingWarning) {
      notification->set_gray(g);
    }
  }
}

References m_pop_notifications, and Slic3r::GUI::SlicingWarning.

Referenced by push_slicing_serious_warning_notification(), and push_slicing_serious_warning_notification().

Here is the caller graph for this function:

◆ set_download_URL_canceled()

void Slic3r::GUI::NotificationManager::set_download_URL_canceled ( size_t id )

{
    for (std::unique_ptr<PopNotification>& notification : m_pop_notifications) {
        if (notification->get_type() == NotificationType::URLDownload) {
            URLDownloadNotification* ntf = dynamic_cast<URLDownloadNotification*>(notification.get());
            if (ntf->get_download_id() != id)
                continue;
            ntf->close();
            wxGetApp().plater()->get_current_canvas3D()->schedule_extra_frame(0);
            return;
        }
    }
}

References Slic3r::GUI::NotificationManager::PopNotification::close(), Slic3r::GUI::NotificationManager::URLDownloadNotification::get_download_id(), m_pop_notifications, and Slic3r::GUI::URLDownload.

Referenced by Slic3r::GUI::Downloader::on_canceled().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_download_URL_error()

void Slic3r::GUI::NotificationManager::set_download_URL_error	(	size_t	id,
		const std::string &	text )

{
    for (std::unique_ptr<PopNotification>& notification : m_pop_notifications) {
        if (notification->get_type() == NotificationType::URLDownload) {
            URLDownloadNotification* ntf = dynamic_cast<URLDownloadNotification*>(notification.get());
            if (ntf->get_download_id() != id)
                continue;
            float percent_b4 = ntf->get_percentage();
            ntf->set_percentage(-1.f);
            ntf->set_error_message(text);
            if (ntf->get_percentage() != percent_b4)
                wxGetApp().plater()->get_current_canvas3D()->schedule_extra_frame(0);
            return;
        }
    }
}

References Slic3r::GUI::NotificationManager::URLDownloadNotification::get_download_id(), Slic3r::GUI::NotificationManager::ProgressBarNotification::get_percentage(), m_pop_notifications, Slic3r::GUI::NotificationManager::URLDownloadNotification::set_error_message(), Slic3r::GUI::NotificationManager::URLDownloadNotification::set_percentage(), and Slic3r::GUI::URLDownload.

Referenced by Slic3r::GUI::Downloader::on_error().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_download_URL_paused()

void Slic3r::GUI::NotificationManager::set_download_URL_paused ( size_t id )

{
    for (std::unique_ptr<PopNotification>& notification : m_pop_notifications) {
        if (notification->get_type() == NotificationType::URLDownload) {
            URLDownloadNotification* ntf = dynamic_cast<URLDownloadNotification*>(notification.get());
            if (ntf->get_download_id() != id)
                continue;
            ntf->set_paused(true);
            wxGetApp().plater()->get_current_canvas3D()->schedule_extra_frame(0);
            return;
        }
    }
}

References Slic3r::GUI::NotificationManager::URLDownloadNotification::get_download_id(), m_pop_notifications, Slic3r::GUI::NotificationManager::URLDownloadNotification::set_paused(), and Slic3r::GUI::URLDownload.

Referenced by Slic3r::GUI::Downloader::on_paused().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_download_URL_progress()

void Slic3r::GUI::NotificationManager::set_download_URL_progress	(	size_t	id,
		float	percentage )

{
    for (std::unique_ptr<PopNotification>& notification : m_pop_notifications) {
        if (notification->get_type() == NotificationType::URLDownload) {
            URLDownloadNotification* ntf = dynamic_cast<URLDownloadNotification*>(notification.get());
            if (ntf->get_download_id() != id)
                continue;
            // if this changes the percentage, it should be shown now
            float percent_b4 = ntf->get_percentage();
            ntf->set_percentage(percentage);
            ntf->set_paused(false);
            if (ntf->get_percentage() != percent_b4)
                wxGetApp().plater()->get_current_canvas3D()->schedule_extra_frame(0);
            return;
        }
    }
}

References Slic3r::GUI::NotificationManager::URLDownloadNotification::get_download_id(), Slic3r::GUI::NotificationManager::ProgressBarNotification::get_percentage(), m_pop_notifications, Slic3r::GUI::NotificationManager::URLDownloadNotification::set_paused(), Slic3r::GUI::NotificationManager::URLDownloadNotification::set_percentage(), and Slic3r::GUI::URLDownload.

Referenced by Slic3r::GUI::Downloader::on_progress().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_fdm()

void Slic3r::GUI::NotificationManager::set_fdm ( bool b )

inline

304{ set_fff(b); }

Slic3r::GUI::NotificationManager::set_fff

void set_fff(bool b)

Definition NotificationManager.cpp:2961

References set_fff().

Here is the call graph for this function:

◆ set_fff()

void Slic3r::GUI::NotificationManager::set_fff ( bool b )

{
  for (std::unique_ptr<PopNotification>& notification : m_pop_notifications) {
    if (notification->get_type() == NotificationType::SlicingProgress) {
      dynamic_cast<SlicingProgressNotification*>(notification.get())->set_fff(fff);
      break;
    }
  }
}

References m_pop_notifications, Slic3r::GUI::NotificationManager::SlicingProgressNotification::set_fff(), and Slic3r::GUI::SlicingProgress.

Referenced by set_fdm(), and set_sla().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_in_preview()

void Slic3r::GUI::NotificationManager::set_in_preview ( bool preview )

{
    m_in_preview = preview;
    for (std::unique_ptr<PopNotification> &notification : m_pop_notifications) {
        if (notification->get_type() == NotificationType::PlaterWarning)
            notification->hide(preview);
        if (notification->get_type() == NotificationType::BBLPlateInfo)
            notification->hide(preview);
        if (notification->get_type() == NotificationType::SignDetected)
            notification->hide(!preview);
        if (notification->get_type() == NotificationType::BBLObjectInfo)
            notification->hide(preview);
        if (notification->get_type() == NotificationType::BBLSeqPrintInfo)
            notification->hide(preview);
    if (m_in_preview && notification->get_type() == NotificationType::DidYouKnowHint)
      notification->close();
        if (notification->get_type() == NotificationType::ValidateWarning) 
      notification->hide(preview);
    }
}

References Slic3r::GUI::BBLObjectInfo, Slic3r::GUI::BBLPlateInfo, Slic3r::GUI::BBLSeqPrintInfo, Slic3r::GUI::DidYouKnowHint, m_in_preview, m_pop_notifications, Slic3r::GUI::PlaterWarning, Slic3r::GUI::SignDetected, and Slic3r::GUI::ValidateWarning.

Referenced by apply_in_preview().

Here is the caller graph for this function:

◆ set_move_from_overlay()

void Slic3r::GUI::NotificationManager::set_move_from_overlay ( bool move )

inline

375{ m_move_from_overlay = move; }

References m_move_from_overlay.

◆ set_scale()

void Slic3r::GUI::NotificationManager::set_scale ( float scale = 1.0 )

{
  if(m_scale != scale) m_scale = scale;
  for (auto& notif : m_pop_notifications) {
    notif->set_scale(scale);
  }
}

References m_pop_notifications, m_scale, and scale().

Here is the call graph for this function:

◆ set_sidebar_collapsed()

void Slic3r::GUI::NotificationManager::set_sidebar_collapsed ( bool collapsed )

{
  for (std::unique_ptr<PopNotification>& notification : m_pop_notifications) {
    if (notification->get_type() == NotificationType::SlicingProgress) {
      dynamic_cast<SlicingProgressNotification*>(notification.get())->set_sidebar_collapsed(collapsed);
      break;
    }
  }
}

References m_pop_notifications, Slic3r::GUI::NotificationManager::SlicingProgressNotification::set_sidebar_collapsed(), and Slic3r::GUI::SlicingProgress.

Here is the call graph for this function:

◆ set_simplify_suggestion_multiline()

void Slic3r::GUI::NotificationManager::set_simplify_suggestion_multiline	(	const ObjectID	oid,
		bool	bMulti )

{
    for (std::unique_ptr<PopNotification> &notification : m_pop_notifications)
        if (notification->get_type() == NotificationType::SimplifySuggestion) {
            if (static_cast<ObjectIDNotification *>(notification.get())->object_id == oid)
        notification->set_Multiline(bMulti);
        }
}

References m_pop_notifications, Slic3r::GUI::NotificationManager::ObjectIDNotification::object_id, and Slic3r::GUI::SimplifySuggestion.

◆ set_sla()

void Slic3r::GUI::NotificationManager::set_sla ( bool b )

inline

305{ set_fff(!b); }

References set_fff().

Here is the call graph for this function:

◆ set_slicing_complete_print_time()

void Slic3r::GUI::NotificationManager::set_slicing_complete_print_time	(	const std::string &	info,
		bool	sidebar_colapsed )

{
  for (std::unique_ptr<PopNotification>& notification : m_pop_notifications) {
    if (notification->get_type() == NotificationType::SlicingProgress) {
      dynamic_cast<SlicingProgressNotification*>(notification.get())->set_sidebar_collapsed(sidebar_colapsed);
      dynamic_cast<SlicingProgressNotification*>(notification.get())->set_print_info(info);
      break;
    }
  }
}

References m_pop_notifications, Slic3r::GUI::NotificationManager::SlicingProgressNotification::set_print_info(), Slic3r::GUI::NotificationManager::SlicingProgressNotification::set_sidebar_collapsed(), and Slic3r::GUI::SlicingProgress.

Here is the call graph for this function:

◆ set_slicing_progress_began()

void Slic3r::GUI::NotificationManager::set_slicing_progress_began ( )

{
  auto find_slicing_progress = [this]() -> SlicingProgressNotification* {
    for (std::unique_ptr<PopNotification>& notification : m_pop_notifications) {
      if (notification->get_type() == NotificationType::SlicingProgress)
        return dynamic_cast<SlicingProgressNotification*>(notification.get());
    }
    return nullptr;
  };
 
  SlicingProgressNotification* notification = find_slicing_progress();
  if (notification == nullptr) {
    wxGetApp().plater()->init_notification_manager();
    notification = find_slicing_progress();
  }
  if (notification != nullptr)
    notification->set_progress_state(SlicingProgressNotification::SlicingProgressState::SP_BEGAN);
}

References m_pop_notifications, Slic3r::GUI::NotificationManager::SlicingProgressNotification::set_progress_state(), Slic3r::GUI::SlicingProgress, and Slic3r::GUI::NotificationManager::SlicingProgressNotification::SP_BEGAN.

Here is the call graph for this function:

◆ set_slicing_progress_canceled()

void Slic3r::GUI::NotificationManager::set_slicing_progress_canceled ( const std::string & text )

{
  for (std::unique_ptr<PopNotification>& notification : m_pop_notifications) {
    if (notification->get_type() == NotificationType::SlicingProgress) {
      SlicingProgressNotification* spn = dynamic_cast<SlicingProgressNotification*>(notification.get());
      spn->set_progress_state(SlicingProgressNotification::SlicingProgressState::SP_CANCELLED);
      spn->set_status_text(text);
      wxGetApp().plater()->get_current_canvas3D()->schedule_extra_frame(0);
      return;
    }
  }
  // Slicing progress notification was not found - init it thru plater so correct cancel callback function is appended
  wxGetApp().plater()->init_notification_manager();
}

References m_pop_notifications, Slic3r::GUI::NotificationManager::SlicingProgressNotification::set_progress_state(), Slic3r::GUI::NotificationManager::SlicingProgressNotification::set_status_text(), Slic3r::GUI::SlicingProgress, and Slic3r::GUI::NotificationManager::SlicingProgressNotification::SP_CANCELLED.

Here is the call graph for this function:

◆ set_slicing_progress_export_possible()

void Slic3r::GUI::NotificationManager::set_slicing_progress_export_possible ( )

{
  for (std::unique_ptr<PopNotification>& notification : m_pop_notifications) {
    if (notification->get_type() == NotificationType::SlicingProgress) {
      dynamic_cast<SlicingProgressNotification*>(notification.get())->set_export_possible(true);
      break;
    }
  }
}

References m_pop_notifications, Slic3r::GUI::NotificationManager::SlicingProgressNotification::set_export_possible(), and Slic3r::GUI::SlicingProgress.

Here is the call graph for this function:

◆ set_slicing_progress_hidden()

void Slic3r::GUI::NotificationManager::set_slicing_progress_hidden ( )

{
  for (std::unique_ptr<PopNotification>& notification : m_pop_notifications) {
    if (notification->get_type() == NotificationType::SlicingProgress) {
      SlicingProgressNotification* notif = dynamic_cast<SlicingProgressNotification*>(notification.get());
      notif->set_progress_state(SlicingProgressNotification::SlicingProgressState::SP_NO_SLICING);
      wxGetApp().plater()->get_current_canvas3D()->schedule_extra_frame(0);
      return;
    }
  }
  // Slicing progress notification was not found - init it thru plater so correct cancel callback function is appended
  wxGetApp().plater()->init_notification_manager();
}

References m_pop_notifications, Slic3r::GUI::NotificationManager::SlicingProgressNotification::set_progress_state(), Slic3r::GUI::SlicingProgress, and Slic3r::GUI::NotificationManager::SlicingProgressNotification::SP_NO_SLICING.

Referenced by push_exporting_finished_notification(), push_import_finished_notification(), push_slicing_error_notification(), push_slicing_serious_warning_notification(), push_slicing_serious_warning_notification(), and push_validate_error_notification().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_slicing_progress_percentage()

void Slic3r::GUI::NotificationManager::set_slicing_progress_percentage	(	const std::string &	text,
		float	percentage )

{
  for (std::unique_ptr<PopNotification>& notification : m_pop_notifications) {
    if (notification->get_type() == NotificationType::SlicingProgress) {
      SlicingProgressNotification* spn = dynamic_cast<SlicingProgressNotification*>(notification.get());
      if(spn->set_progress_state(percentage)) {
        spn->set_status_text(text);
        wxGetApp().plater()->get_current_canvas3D()->schedule_extra_frame(0);
      }
      return;
    }
  }
  // Slicing progress notification was not found - init it thru plater so correct cancel callback function is appended
  wxGetApp().plater()->init_notification_manager();
}

References m_pop_notifications, Slic3r::GUI::NotificationManager::SlicingProgressNotification::set_progress_state(), Slic3r::GUI::NotificationManager::SlicingProgressNotification::set_status_text(), and Slic3r::GUI::SlicingProgress.

Here is the call graph for this function:

◆ set_upload_job_notification_percentage()

void Slic3r::GUI::NotificationManager::set_upload_job_notification_percentage	(	int	id,
		const std::string &	filename,
		const std::string &	host,
		float	percentage )

{
  for (std::unique_ptr<PopNotification>& notification : m_pop_notifications) {
    if (notification->get_type() == NotificationType::PrintHostUpload) {
      PrintHostUploadNotification* phun = dynamic_cast<PrintHostUploadNotification*>(notification.get());
      if (phun->compare_job_id(id)) {
        phun->set_percentage(percentage);
        wxGetApp().plater()->get_current_canvas3D()->schedule_extra_frame(0);
        break;
      }
    }
  }
}

References Slic3r::GUI::NotificationManager::PrintHostUploadNotification::compare_job_id(), m_pop_notifications, Slic3r::GUI::PrintHostUpload, and Slic3r::GUI::NotificationManager::PrintHostUploadNotification::set_percentage().

Here is the call graph for this function:

◆ sort_notifications()

void Slic3r::GUI::NotificationManager::sort_notifications ( )

private

{
  // Stable sorting, so that the order of equal ranges is stable.
  std::stable_sort(m_pop_notifications.begin(), m_pop_notifications.end(), [](const std::unique_ptr<PopNotification> &n1, const std::unique_ptr<PopNotification> &n2) {
    int n1l = (int)n1->get_data().level;
    int n2l = (int)n2->get_data().level;
    if (n1l == n2l && n1->is_gray() && !n2->is_gray())
      return true;
    return (n1l < n2l);
    });
}

References m_pop_notifications.

Referenced by render_notifications().

Here is the caller graph for this function:

◆ stop_delayed_notifications_of_type()

void Slic3r::GUI::NotificationManager::stop_delayed_notifications_of_type ( const NotificationType type )

{
  for (auto it = m_waiting_notifications.begin(); it != m_waiting_notifications.end();) {
    if ((*it).notification->get_type() == type) {
      it = m_waiting_notifications.erase(it);
    }
    else {
      ++it;
    }
  }
}

References m_waiting_notifications.

Referenced by push_hint_notification().

Here is the caller graph for this function:

◆ update_notifications()

bool Slic3r::GUI::NotificationManager::update_notifications ( GLCanvas3D & canvas )

{
  // no update if not top window
  wxWindow* p = dynamic_cast<wxWindow*>(wxGetApp().plater());
  while (p->GetParent() != nullptr)
    p = p->GetParent();
  wxTopLevelWindow* top_level_wnd = dynamic_cast<wxTopLevelWindow*>(p);
  if (!top_level_wnd->IsActive())
    return false;
 
  // next_render() returns numeric_limits::max if no need for frame
  const int64_t max = std::numeric_limits<int64_t>::max();
  int64_t       next_render = max;
  const int64_t time_since_render = GLCanvas3D::timestamp_now() - m_last_render;
  bool      request_render = false;
  // During render, each notification detects if its currently hovered and changes its state to EState::Hovered
  // If any notification is hovered, all restarts its countdown
  bool          hover = false;
  for (const std::unique_ptr<PopNotification>& notification : m_pop_notifications) {
    if (notification->is_hovered()) {
      hover = true;
      break;
    }
  }
  // update state of all notif and erase finished
  for (auto it = m_pop_notifications.begin(); it != m_pop_notifications.end();) {
    std::unique_ptr<PopNotification>& notification = *it;
    request_render |= notification->update_state(hover, time_since_render);
    next_render = std::min<int64_t>(next_render, notification->next_render());
    if (notification->get_state() == PopNotification::EState::Finished)
      it = m_pop_notifications.erase(it);
    else
      ++it;
  }
 
  // delayed notifications
  for (auto it = m_waiting_notifications.begin(); it != m_waiting_notifications.end();) {
    // substract time
    if ((*it).remaining_time > 0)
      (*it).remaining_time -= time_since_render;
    if ((*it).remaining_time <= 0) {
      if ((*it).notification && (*it).condition_callback()) { // push notification, erase it from waiting list (frame is scheduled by push)
        (*it).notification->reset_timer();
        // if activate_existing returns false, we expect push to return true.
        if(!this->activate_existing((*it).notification.get()) || (*it).delay_interval == 0) {
          push_notification_data(std::move((*it).notification), 0);
          it = m_waiting_notifications.erase(it);
          continue;
        }
      }
      // not possible to push, delay for delay_interval
      (*it).remaining_time = (*it).delay_interval;
    }
    next_render = std::min<int64_t>(next_render, (*it).remaining_time);
    ++it;
  }
 
  // request next frame in future
  if (next_render < max)
    canvas.schedule_extra_frame(int(next_render));
 
  return request_render;
}

References activate_existing(), Slic3r::GUI::NotificationManager::PopNotification::Finished, m_last_render, m_pop_notifications, m_waiting_notifications, push_notification_data(), Slic3r::GUI::GLCanvas3D::schedule_extra_frame(), and Slic3r::GUI::GLCanvas3D::timestamp_now().

Here is the call graph for this function:

◆ update_slicing_notif_dailytips()

void Slic3r::GUI::NotificationManager::update_slicing_notif_dailytips ( bool need_change )

{
  for (std::unique_ptr<PopNotification>& notification : m_pop_notifications) {
    if (notification->get_type() == NotificationType::SlicingProgress) {
      SlicingProgressNotification* spn = dynamic_cast<SlicingProgressNotification*>(notification.get());
      if (need_change) {
        wxGetApp().plater()->get_dailytips()->close();
        spn->get_dailytips_panel()->retrieve_data_from_hint_database(HintDataNavigation::Random);
        wxGetApp().plater()->get_current_canvas3D()->schedule_extra_frame(0);
      }
      return;
    }
  }
  // Slicing progress notification was not found - init it thru plater so correct cancel callback function is appended
  wxGetApp().plater()->init_notification_manager();
}

References Slic3r::GUI::NotificationManager::SlicingProgressNotification::get_dailytips_panel(), m_pop_notifications, Slic3r::GUI::Random, Slic3r::GUI::DailyTipsPanel::retrieve_data_from_hint_database(), and Slic3r::GUI::SlicingProgress.

Here is the call graph for this function:

◆ upload_job_notification_show_canceled()

void Slic3r::GUI::NotificationManager::upload_job_notification_show_canceled	(	int	id,
		const std::string &	filename,
		const std::string &	host )

{
  for (std::unique_ptr<PopNotification>& notification : m_pop_notifications) {
    if (notification->get_type() == NotificationType::PrintHostUpload) {
      PrintHostUploadNotification* phun = dynamic_cast<PrintHostUploadNotification*>(notification.get());
      if (phun->compare_job_id(id)) {
        phun->cancel();
        wxGetApp().plater()->get_current_canvas3D()->schedule_extra_frame(0);
        break;
      }
    }
  }
}

References Slic3r::GUI::NotificationManager::PrintHostUploadNotification::cancel(), Slic3r::GUI::NotificationManager::PrintHostUploadNotification::compare_job_id(), m_pop_notifications, and Slic3r::GUI::PrintHostUpload.

Here is the call graph for this function:

◆ upload_job_notification_show_error()

void Slic3r::GUI::NotificationManager::upload_job_notification_show_error	(	int	id,
		const std::string &	filename,
		const std::string &	host )

{
  for (std::unique_ptr<PopNotification>& notification : m_pop_notifications) {
    if (notification->get_type() == NotificationType::PrintHostUpload) {
      PrintHostUploadNotification* phun = dynamic_cast<PrintHostUploadNotification*>(notification.get());
      if(phun->compare_job_id(id)) {
        phun->error();
        wxGetApp().plater()->get_current_canvas3D()->schedule_extra_frame(0);
        break;
      }
    }
  }
}

References Slic3r::GUI::NotificationManager::PrintHostUploadNotification::compare_job_id(), Slic3r::GUI::NotificationManager::PrintHostUploadNotification::error(), m_pop_notifications, and Slic3r::GUI::PrintHostUpload.

Here is the call graph for this function:

Member Data Documentation

◆ basic_notifications

const std::vector<NotificationData> Slic3r::GUI::NotificationManager::basic_notifications

private

                                                          {
        NotificationData{NotificationType::Mouse3dDisconnected, NotificationLevel::RegularNotificationLevel, 10, _u8L("3D Mouse disconnected.")},
        NotificationData{NotificationType::PresetUpdateAvailable, NotificationLevel::ImportantNotificationLevel, BBL_NOTICE_MAX_INTERVAL, _u8L("A new configuration is available. Update now\?"), _u8L("More"),
    [](wxEvtHandler* evnthndlr) {
      if (evnthndlr != nullptr)
        wxPostEvent(evnthndlr, PresetUpdateAvailableClickedEvent(EVT_PRESET_UPDATE_AVAILABLE_CLICKED));
      return true;
    }
  },
        NotificationData{NotificationType::EmptyColorChangeCode, NotificationLevel::PrintInfoNotificationLevel, 10,
         std::string(_devL("value can not be empty when you add a G-code for color change.\nPlease check the \"Color Change G-code\" in \"Printer Settings > Custom G-code\"").mb_str())},
        NotificationData{NotificationType::EmptyAutoColorChange, NotificationLevel::PrintInfoNotificationLevel, 10,
                         std::string(_devL("You need add a color change event to the print. The print need look like a sign.").mb_str())},
        NotificationData{NotificationType::DesktopIntegrationSuccess, NotificationLevel::RegularNotificationLevel, 10,
    _u8L("Integration was successful.") },
        NotificationData{NotificationType::DesktopIntegrationFail, NotificationLevel::WarningNotificationLevel, 10,
    _u8L("Integration failed.") },
        NotificationData{NotificationType::UndoDesktopIntegrationSuccess, NotificationLevel::RegularNotificationLevel, 10,
    _u8L("Undo integration was successful.") },
 
        NotificationData{NotificationType::BBLPluginUpdateAvailable, NotificationLevel::ImportantNotificationLevel, BBL_NOTICE_MAX_INTERVAL,
      _u8L("New network plug-in available."),
      _u8L("Details"),
                         [](wxEvtHandler* evnthndlr) {
                //BBS set feishu release page by default
                 wxCommandEvent* evt = new wxCommandEvent(EVT_UPDATE_PLUGINS_WHEN_LAUNCH);
         wxQueueEvent(wxGetApp().plater(), evt);
         return true;
             }},
 
        NotificationData{NotificationType::BBLPrinterConfigUpdateAvailable, NotificationLevel::ImportantNotificationLevel, BBL_NOTICE_MAX_INTERVAL,
                         _u8L("New printer config available."), _u8L("Details"),
                         [](wxEvtHandler *evnthndlr) {
                             if (evnthndlr != nullptr) wxPostEvent(evnthndlr, PrinterConfigUpdateAvailableClickedEvent(EVT_PRINTER_CONFIG_UPDATE_AVAILABLE_CLICKED));
                             return true;
                         }},
 
        NotificationData{NotificationType::BBLUserPresetExceedLimit, NotificationLevel::WarningNotificationLevel, BBL_NOTICE_MAX_INTERVAL,
      _u8L("The number of user presets cached in the cloud has exceeded the upper limit, newly created user presets can only be used locally."), 
      _u8L("Wiki Guide"),
                         [](wxEvtHandler* evnthndlr) {
        wxLaunchDefaultBrowser("https://wiki.bambulab.com/en/software/bambu-studio/3rd-party-printer-profile#cloud-user-presets-limit");
        return false;
             }},
 
        NotificationData{NotificationType::UndoDesktopIntegrationFail, NotificationLevel::WarningNotificationLevel, 10,
    _u8L("Undo integration failed.") },
        NotificationData{NotificationType::ExportOngoing, NotificationLevel::RegularNotificationLevel, 0, _u8L("Exporting")},
        NotificationData{NotificationType::NewAppAvailable, NotificationLevel::ImportantNotificationLevel, 20, _u8L("An update is available!"), _u8L("Go to download page"),
                         [](wxEvtHandler *evnthndlr) {
        //BBS set feishu release page by default
        wxGetApp().open_browser_with_warning_dialog("https://www.thingiverse.com/"); return true;
       }},
      //{NotificationType::NewAppAvailable, NotificationLevel::ImportantNotificationLevel, 20,  _u8L("New vesion of PrusaSlicer is available.",  _u8L("Download page.") },
      //{NotificationType::LoadingFailed, NotificationLevel::RegularNotificationLevel, 20,  _u8L("Loading of model has Failed") },
      //{NotificationType::DeviceEjected, NotificationLevel::RegularNotificationLevel, 10,  _u8L("Removable device has been safely ejected")} // if we want changeble text (like here name of device), we need to do it as CustomNotification
  };

Referenced by push_delayed_notification(), and push_notification().

◆ m_evt_handler

wxEvtHandler* Slic3r::GUI::NotificationManager::m_evt_handler

private

◆ m_id_provider

NotificationIDProvider Slic3r::GUI::NotificationManager::m_id_provider

private

Referenced by bbl_show_gcode_overlap_notification(), bbl_show_need_support_on_notification(), bbl_show_objectsinfo_notification(), bbl_show_plugin_install_notification(), bbl_show_seqprintinfo_notification(), bbl_show_slice_emptylayer_notification(), bbl_show_sole_text_notification(), init_progress_indicator(), init_slicing_progress_notification(), push_delayed_notification(), push_download_URL_progress_notification(), push_exporting_finished_notification(), push_hint_notification(), push_import_finished_notification(), push_notification_data(), push_orca_sync_conflict_notification(), push_plater_warning_notification(), push_plugin_missing_notification(), push_shared_profiles_notification(), push_simplify_suggestion_notification(), push_slicing_warning_notification(), push_updated_item_info_notification(), and push_upload_job_notification().

◆ m_imgui_ready

bool Slic3r::GUI::NotificationManager::m_imgui_ready { false }

private

1069{ false };

Referenced by push_notification_data(), and render_notifications().

◆ m_in_preview

bool Slic3r::GUI::NotificationManager::m_in_preview { false }

private

1081{ false };

Referenced by apply_in_preview(), render_notifications(), and set_in_preview().

◆ m_in_view

int Slic3r::GUI::NotificationManager::m_in_view { 0 }

private

1082{ 0 };

◆ m_initialized

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

private

1064{ false };

Referenced by init(), and push_notification_data().

◆ m_is_dark

bool Slic3r::GUI::NotificationManager::m_is_dark = false

private

Referenced by on_change_color_mode().

◆ m_last_render

int64_t Slic3r::GUI::NotificationManager::m_last_render { 0LL }

private

1086{ 0LL };

Referenced by render_notifications(), and update_notifications().

◆ m_move_from_overlay

bool Slic3r::GUI::NotificationManager::m_move_from_overlay { false }

private

1084{ false };

Referenced by render_notifications(), and set_move_from_overlay().

◆ m_multiple_types

const std::vector<NotificationType> Slic3r::GUI::NotificationManager::m_multiple_types

private

Initial value:

= {
    NotificationType::CustomNotification,
    NotificationType::PlaterWarning,
    NotificationType::ProgressBar,
    NotificationType::PrintHostUpload,
        NotificationType::SimplifySuggestion,
        NotificationType::ValidateWarning,
        
        
        NotificationType::BBL3MFInfo
  }

                                                       {
    NotificationType::CustomNotification,
    NotificationType::PlaterWarning,
    NotificationType::ProgressBar,
    NotificationType::PrintHostUpload,
        NotificationType::SimplifySuggestion,
        NotificationType::ValidateWarning,
        // A published file load can produce several distinct 3MF warnings (invalid values,
        // skipped settings, changed slots); let them stack rather than clobber each other.
        NotificationType::BBL3MFInfo
  };

Referenced by activate_existing().

◆ m_pop_notifications

std::deque<std::unique_ptr<PopNotification> > Slic3r::GUI::NotificationManager::m_pop_notifications

private

◆ m_scale

float Slic3r::GUI::NotificationManager::m_scale = 1.0f

Referenced by render_notifications(), and set_scale().

◆ m_to_delete_after_finish_render

PopNotification* Slic3r::GUI::NotificationManager::m_to_delete_after_finish_render {nullptr}

private

1075{nullptr};

Referenced by push_notification_data(), and render_notifications().

◆ m_used_timestamps

std::unordered_set<int> Slic3r::GUI::NotificationManager::m_used_timestamps

private

Referenced by push_notification_data().

◆ m_waiting_notifications

std::vector<DelayedNotification> Slic3r::GUI::NotificationManager::m_waiting_notifications

private

Referenced by push_delayed_notification_data(), stop_delayed_notifications_of_type(), and update_notifications().

The documentation for this class was generated from the following files:

/home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/NotificationManager.hpp
/home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/NotificationManager.cpp

	OrcaSlicer latest OrcaSlicer

Classes

Public Types

Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Detailed Description

Class Documentation

◆ Slic3r::GUI::NotificationManager::NotificationData

Member Enumeration Documentation

◆ NotificationLevel

Constructor & Destructor Documentation

◆ NotificationManager()

◆ ~NotificationManager()

Member Function Documentation

◆ activate_existing()

◆ apply_in_preview()

◆ bbl_chose_sole_text_notification()

◆ bbl_close_3mf_warn_notification()

◆ bbl_close_bed_filament_incompatible_notification()

◆ bbl_close_filament_map_invalid_notification_after_slice()

◆ bbl_close_filament_map_invalid_notification_before_slice()

◆ bbl_close_gcode_overlap_notification()

◆ bbl_close_need_support_on_notification()

◆ bbl_close_objectsinfo_notification()

◆ bbl_close_plateinfo_notification()

◆ bbl_close_plugin_install_notification()

◆ bbl_close_preview_only_notification()

◆ bbl_close_seqprintinfo_notification()

◆ bbl_show_3mf_warn_notification()

◆ bbl_show_app_newversion_notification()

◆ bbl_show_bed_filament_incompatible_notification()

◆ bbl_show_filament_map_invalid_notification_after_slice()

◆ bbl_show_filament_map_invalid_notification_before_slice()

◆ bbl_show_gcode_overlap_notification()

◆ bbl_show_need_support_on_notification()

◆ bbl_show_objectsinfo_notification()

◆ bbl_show_plateinfo_notification()

◆ bbl_show_plugin_install_notification()

◆ bbl_show_preview_only_notification()

◆ bbl_show_seqprintinfo_notification()

◆ bbl_show_slice_emptylayer_notification()

◆ bbl_show_sole_text_notification()

◆ clear_all()

◆ close_and_delete_self()

◆ close_flushing_volume_error_notification()

◆ close_general_error_notification()

◆ close_notification_of_type()

◆ close_plater_error_notification()

◆ close_plater_warning_notification()

◆ close_slicing_customize_error_notification()

◆ close_slicing_error_notification()

◆ close_slicing_errors_and_warnings()

◆ close_slicing_serious_warning_notification()

◆ deactivate_loaded_hints()

◆ device_ejected()

◆ get_notification_count()

◆ get_standard_duration()

◆ has_slicing_error_notification()

◆ init()

◆ init_progress_indicator()

◆ init_slicing_progress_notification()

◆ is_hint_notification_open()

◆ new_export_began()

◆ on_change_color_mode()

◆ progress_indicator_get_range()

◆ progress_indicator_set_cancel_callback()

◆ progress_indicator_set_progress()

◆ progress_indicator_set_range()

◆ progress_indicator_set_status_text()

◆ push_delayed_notification()

◆ push_delayed_notification_data()

◆ push_download_URL_progress_notification()

◆ push_exporting_finished_notification()

◆ push_flushing_volume_error_notification()

◆ push_general_error_notification()

◆ push_hint_notification()

◆ push_import_finished_notification()

◆ push_notification() [1/3]

◆ push_notification() [2/3]