Slic3r::GUI::detail Namespace Reference

Functions
template<typename Run, typename OnFinish>
void	run_off_thread_with_progress (Run &&run, OnFinish &&on_finish, wxWindow *parent, const wxString &title, const wxString &message, int maximum, int style, std::shared_ptr< std::atomic< bool > > alive, bool finish_after_dialog_destroyed, std::function< void()> restore)
template<typename Run>
std::invoke_result_t< std::decay_t< Run > & >	run_wait_with_progress (Run &&run, wxWindow *parent, const wxString &title, const wxString &message, int maximum, int style, std::shared_ptr< std::atomic< bool > > alive, std::function< void()> restore)

Function Documentation

run_off_thread_with_progress()

template<typename Run, typename OnFinish>

void Slic3r::GUI::detail::run_off_thread_with_progress	(	Run &&	run,
		OnFinish &&	on_finish,
		wxWindow *	parent,
		const wxString &	title,
		const wxString &	message,
		int	maximum,
		int	style,
		std::shared_ptr< std::atomic< bool > >	alive,
		bool	finish_after_dialog_destroyed,
		std::function< void()>	restore )

{
    wxProgressDialog* progress = new wxProgressDialog(title, message, maximum, parent, style);
    wxTimer* timer             = new wxTimer();
 
    timer->Bind(wxEVT_TIMER, [alive, progress, message](wxTimerEvent&) {
        if ((!alive || alive->load(std::memory_order_acquire)) && progress)
            progress->Pulse(message);
    });
 
    timer->Start(100);
 
    std::thread([alive,
                 progress,
                 timer,
                 run                                            = std::forward<Run>(run),
                 on_finish                                      = std::forward<OnFinish>(on_finish),
                 finish_after_dialog_destroyed,
                 restore                                        = std::move(restore)]() mutable {
        try {
            run();
        } catch (const std::exception& ex) {
            BOOST_LOG_TRIVIAL(error) << "Plugin dialog worker failed: " << ex.what();
        } catch (...) {
            BOOST_LOG_TRIVIAL(error) << "Plugin dialog worker failed with an unknown exception";
        }
 
        if (wxTheApp == nullptr)
            return;
 
        wxTheApp->CallAfter([alive,
                             progress,
                             timer,
                             on_finish = std::move(on_finish),
                             finish_after_dialog_destroyed,
                             restore   = std::move(restore)]() mutable {
            timer->Stop();
            delete timer;
 
            if (!alive || alive->load(std::memory_order_acquire)) {
                progress->Destroy();
                if (restore)
                    restore();
                on_finish();
            } else if (finish_after_dialog_destroyed) {
                on_finish();
            }
        });
    }).detach();
}

References style.

Referenced by run_wait_with_progress(), and Slic3r::GUI::PluginsDialog::run_with_dialog().

Here is the caller graph for this function:

run_wait_with_progress()

template<typename Run>

std::invoke_result_t< std::decay_t< Run > & > Slic3r::GUI::detail::run_wait_with_progress	(	Run &&	run,
		wxWindow *	parent,
		const wxString &	title,
		const wxString &	message,
		int	maximum,
		int	style,
		std::shared_ptr< std::atomic< bool > >	alive,
		std::function< void()>	restore )

{
    using Result = std::invoke_result_t<std::decay_t<Run>&>;
 
    bool finished = false;
    wxEventLoop loop;
    auto on_finish = [&finished, &loop]() {
        finished = true;
        if (loop.IsRunning())
            loop.Exit();
    };
 
    if constexpr (std::is_void_v<Result>) {
        struct WaitState
        {
            std::mutex mutex;
            std::exception_ptr exception;
        };
 
        auto state = std::make_shared<WaitState>();
        run_off_thread_with_progress(
            [run = std::forward<Run>(run), state]() mutable {
                try {
                    run();
                } catch (...) {
                    std::lock_guard<std::mutex> lock(state->mutex);
                    state->exception = std::current_exception();
                }
            },
            on_finish, parent, title, message, maximum, style, std::move(alive), /*finish_after_dialog_destroyed=*/true, std::move(restore));
 
        if (!finished)
            loop.Run();
 
        std::exception_ptr exception;
        {
            std::lock_guard<std::mutex> lock(state->mutex);
            exception = state->exception;
        }
        if (exception)
            std::rethrow_exception(exception);
    } else {
        using StoredResult = std::decay_t<Result>;
        struct WaitState
        {
            std::mutex mutex;
            std::optional<StoredResult> result;
            std::exception_ptr exception;
        };
 
        auto state = std::make_shared<WaitState>();
        run_off_thread_with_progress(
            [run = std::forward<Run>(run), state]() mutable {
                try {
                    StoredResult result = run();
                    std::lock_guard<std::mutex> lock(state->mutex);
                    state->result.emplace(std::move(result));
                } catch (...) {
                    std::lock_guard<std::mutex> lock(state->mutex);
                    state->exception = std::current_exception();
                }
            },
            on_finish, parent, title, message, maximum, style, std::move(alive), /*finish_after_dialog_destroyed=*/true, std::move(restore));
 
        if (!finished)
            loop.Run();
 
        std::optional<StoredResult> result;
        std::exception_ptr exception;
        {
            std::lock_guard<std::mutex> lock(state->mutex);
            if (state->result)
                result.emplace(std::move(*state->result));
            exception = state->exception;
        }
        if (exception)
            std::rethrow_exception(exception);
        return std::move(*result);
    }
}

References run_off_thread_with_progress(), style, and wxEventLoop.

Referenced by Slic3r::GUI::install_local_plugin_package(), and Slic3r::GUI::PluginsDialog::run_with_dialog_wait().

Here is the call graph for this function:

Here is the caller graph for this function: