Slic3r::anonymous_namespace{PluginHostUi.cpp} Namespace Reference

Classes
struct	GilSafeCallable
class	UiRegistry
struct	UiWindowHandle
struct	UiProgressHandle
struct	UiDockPanelHandle
class	PlaterShownWaiter

Typedefs
using	CallablePtr = std::shared_ptr<GilSafeCallable>

Functions
CallablePtr	make_holder (py::object obj)
GUI::WebDialog::MessageHandler	make_message_adapter (py::object on_message)
GUI::WebDialog::SubmitHandler	make_submit_adapter (py::object on_submit)
std::function< void()>	make_close_adapter (const CallablePtr &holder)
bool	app_closing ()
template<typename Fn>
auto	run_on_ui_blocking (Fn &&fn) -> std::invoke_result_t< Fn & >
wxWindow *	ui_parent ()
long	message_style (const std::string &buttons, const std::string &icon)
std::string	button_to_string (int rc)
std::string	ui_message (const std::string &text, const std::string &title, const std::string &buttons, const std::string &icon)
py::object	ui_create_window (const std::string &html, const std::string &title, int width, int height, py::object on_message, py::object on_close, long style, py::object on_submit)
void	run_when_plater_shown (std::function< void(GUI::Plater *)> fn)
py::object	ui_create_dock_panel (const std::string &html, const std::string &title, int width, int height, py::object on_message, py::object on_close, const std::string &dock)
void	handle_post (int id, py::object data)
void	handle_close (int id)
void	handle_show (int id, bool show)
UiProgressHandle	ui_create_progress_dialog (const std::string &title, const std::string &message, int maximum, int style)
UiProgressHandle *	new_progress_dialog (const std::string &title, const std::string &message, int maximum, int style)
bool	progress_is_open (int id)
bool	progress_pulse (int id, const std::string &message)
bool	progress_update (int id, int value, const std::string &message)
void	progress_start_pulse (int id, int interval_ms, const std::string &message)
void	progress_stop_pulse (int id)
void	progress_close (int id)
void	plater_notification (GUI::NotificationManager::NotificationLevel notification_level, const std::string &text, const std::string &hypertext, py::object on_click)

Variables
constexpr long	WINDOW_MODELESS = 0L
constexpr long	WINDOW_MODAL = 1L << 0
constexpr long	PLUGIN_WX_STYLE = wxSYSTEM_MENU | wxCAPTION | wxCLOSE_BOX | wxMAXIMIZE_BOX | wxRESIZE_BORDER
constexpr const char *	DOCK_POSITIONS [] = {"left", "right", "bottom", "float"}

---

Class Documentation

Slic3r::anonymous_namespace{PluginHostUi.cpp}::UiWindowHandle

struct Slic3r::anonymous_namespace{PluginHostUi.cpp}::UiWindowHandle

Class Members
int	id {0}

Slic3r::anonymous_namespace{PluginHostUi.cpp}::UiProgressHandle

struct Slic3r::anonymous_namespace{PluginHostUi.cpp}::UiProgressHandle

Class Members
int	id {0}

Slic3r::anonymous_namespace{PluginHostUi.cpp}::UiDockPanelHandle

struct Slic3r::anonymous_namespace{PluginHostUi.cpp}::UiDockPanelHandle

Class Members
int	id {0}

Typedef Documentation

CallablePtr

using Slic3r::anonymous_namespace{PluginHostUi.cpp}::CallablePtr = std::shared_ptr<GilSafeCallable>

Function Documentation

app_closing()

bool Slic3r::anonymous_namespace{PluginHostUi.cpp}::app_closing

(

)

{ return wxTheApp == nullptr || GUI::wxGetApp().is_closing(); }

References app_closing().

Referenced by app_closing(), and run_on_ui_blocking().

Here is the call graph for this function:

Here is the caller graph for this function:

button_to_string()

std::string Slic3r::anonymous_namespace{PluginHostUi.cpp}::button_to_string

(

int

rc

)

{
    switch (rc) {
    case wxID_OK:  return "ok";
    case wxID_YES: return "yes";
    case wxID_NO:  return "no";
    default:       return "cancel";
    }
}

References button_to_string().

Referenced by button_to_string(), and ui_message().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_close()

void Slic3r::anonymous_namespace{PluginHostUi.cpp}::handle_close

(

int

id

)

{
    if (wxTheApp == nullptr)
        return;
    GUI::wxGetApp().CallAfter([id]() {
        auto* window = UiRegistry::instance().get_as<wxWindow>(id);
        if (auto* panel = dynamic_cast<GUI::DockPanel*>(window))
            panel->request_close();
        else
            GUI::WebDialog::request_close(dynamic_cast<GUI::WebDialog*>(window));
    });
}

References handle_close(), Slic3r::anonymous_namespace{PluginHostUi.cpp}::UiRegistry::instance(), and Slic3r::GUI::WebDialog::request_close().

Referenced by handle_close().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_post()

void Slic3r::anonymous_namespace{PluginHostUi.cpp}::handle_post	(	int	id,
		py::object	data )

{
    if (wxTheApp == nullptr)
        return;
    json j = py_to_json(data); // GIL held (binding body)
    GUI::wxGetApp().CallAfter([id, j = std::move(j)]() {
        auto* window = UiRegistry::instance().get_as<wxWindow>(id);
        if (auto* panel = dynamic_cast<GUI::DockPanel*>(window))
            panel->push_message(j);
        else
            GUI::WebDialog::post_message(dynamic_cast<GUI::WebDialog*>(window), j);
    });
}

References handle_post(), Slic3r::anonymous_namespace{PluginHostUi.cpp}::UiRegistry::instance(), Slic3r::GUI::WebDialog::post_message(), and Slic3r::py_to_json().

Referenced by handle_post().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_show()

void Slic3r::anonymous_namespace{PluginHostUi.cpp}::handle_show	(	int	id,
		bool	show )

{
    if (wxTheApp == nullptr)
        return;
    GUI::wxGetApp().CallAfter([id, show]() {
        auto*        panel  = UiRegistry::instance().get_as<GUI::DockPanel>(id);
        GUI::Plater* plater = GUI::wxGetApp().plater();
        if (panel != nullptr && plater != nullptr)
            plater->show_dock_pane(panel, show);
    });
}

References handle_show(), Slic3r::anonymous_namespace{PluginHostUi.cpp}::UiRegistry::instance(), and Slic3r::GUI::Plater::show_dock_pane().

Referenced by handle_show().

Here is the call graph for this function:

Here is the caller graph for this function:

make_close_adapter()

std::function< void()> Slic3r::anonymous_namespace{PluginHostUi.cpp}::make_close_adapter

(

const CallablePtr &

holder

)

{
    if (!holder)
        return nullptr;
    return [holder]() {
        PythonGILState gil;
        if (!gil)
            return;
        try {
            holder->fn();
        } catch (py::error_already_set& e) {
            BOOST_LOG_TRIVIAL(error) << "orca.host.ui on_close handler raised: " << e.what();
            PyErr_Clear();
        }
    };
}

References make_close_adapter().

Referenced by make_close_adapter(), ui_create_dock_panel(), and ui_create_window().

Here is the call graph for this function:

Here is the caller graph for this function:

make_holder()

CallablePtr Slic3r::anonymous_namespace{PluginHostUi.cpp}::make_holder

(

py::object

obj

)

{
    if (!obj || obj.is_none())
        return nullptr;
    return std::make_shared<GilSafeCallable>(std::move(obj));
}

References make_holder().

Referenced by make_holder(), make_message_adapter(), make_submit_adapter(), plater_notification(), ui_create_dock_panel(), and ui_create_window().

Here is the call graph for this function:

Here is the caller graph for this function:

make_message_adapter()

GUI::WebDialog::MessageHandler Slic3r::anonymous_namespace{PluginHostUi.cpp}::make_message_adapter

(

py::object

on_message

)

{
    CallablePtr holder = make_holder(std::move(on_message));
    if (!holder)
        return nullptr;
    return [holder](const json& data) {
        PythonGILState gil;
        if (!gil)
            return;
        try {
            holder->fn(json_to_py(data));
        } catch (py::error_already_set& e) {
            BOOST_LOG_TRIVIAL(error) << "orca.host.ui on_message handler raised: " << e.what();
            PyErr_Clear();
        }
    };
}

References Slic3r::json_to_py(), make_holder(), and make_message_adapter().

Referenced by make_message_adapter(), ui_create_dock_panel(), and ui_create_window().

Here is the call graph for this function:

Here is the caller graph for this function:

make_submit_adapter()

GUI::WebDialog::SubmitHandler Slic3r::anonymous_namespace{PluginHostUi.cpp}::make_submit_adapter

(

py::object

on_submit

)

{
    CallablePtr holder = make_holder(std::move(on_submit));
    if (!holder)
        return nullptr;
    return [holder](const json& data) {
        PythonGILState gil;
        if (!gil)
            return;
        try {
            holder->fn(json_to_py(data));
        } catch (py::error_already_set& e) {
            BOOST_LOG_TRIVIAL(error) << "orca.host.ui on_submit handler raised: " << e.what();
            PyErr_Clear();
        }
    };
}

References Slic3r::json_to_py(), make_holder(), and make_submit_adapter().

Referenced by make_submit_adapter(), and ui_create_window().

Here is the call graph for this function:

Here is the caller graph for this function:

message_style()

long Slic3r::anonymous_namespace{PluginHostUi.cpp}::message_style	(	const std::string &	buttons,
		const std::string &	icon )

{
    long style = wxOK;
    if (buttons == "ok_cancel")
        style = wxOK | wxCANCEL;
    else if (buttons == "yes_no")
        style = wxYES_NO;
    else if (buttons == "yes_no_cancel")
        style = wxYES_NO | wxCANCEL;
 
    if (icon == "warning")
        style |= wxICON_WARNING;
    else if (icon == "error")
        style |= wxICON_ERROR;
    else if (icon == "question")
        style |= wxICON_QUESTION;
    else
        style |= wxICON_INFORMATION;
    return style;
}

References message_style(), and style.

Referenced by message_style(), and ui_message().

Here is the call graph for this function:

Here is the caller graph for this function:

new_progress_dialog()

UiProgressHandle * Slic3r::anonymous_namespace{PluginHostUi.cpp}::new_progress_dialog	(	const std::string &	title,
		const std::string &	message,
		int	maximum,
		int	style )

{
    return new UiProgressHandle(ui_create_progress_dialog(title, message, maximum, style));
}

References new_progress_dialog(), style, and ui_create_progress_dialog().

Referenced by new_progress_dialog().

Here is the call graph for this function:

Here is the caller graph for this function:

plater_notification()

void Slic3r::anonymous_namespace{PluginHostUi.cpp}::plater_notification	(	GUI::NotificationManager::NotificationLevel	notification_level,
		const std::string &	text,
		const std::string &	hypertext,
		py::object	on_click )

{
    const std::string plugin_key = PluginAuditManager::instance().current_plugin();
    CallablePtr        holder    = make_holder(std::move(on_click));
    if (holder)
        UiRegistry::instance().bind_callback(holder, plugin_key);
 
    std::function<bool(wxEvtHandler*)> callback;
    if (holder) {
        callback = [holder](wxEvtHandler*) -> bool {
            if (!holder->active.load(std::memory_order_acquire))
                return false;
 
            PythonGILState gil;
            if (!gil)
                return false;
            try {
                py::object result = holder->fn();
                return result.is_none() || result.cast<bool>();
            } catch (py::error_already_set& e) {
                BOOST_LOG_TRIVIAL(error) << "orca.host.ui notification callback raised: " << e.what();
                PyErr_Clear();
                return false;
            } catch (const std::exception& e) {
                BOOST_LOG_TRIVIAL(error) << "orca.host.ui notification callback raised: " << e.what();
                return false;
            } catch (...) {
                BOOST_LOG_TRIVIAL(error) << "orca.host.ui notification callback raised an unknown exception";
                return false;
            }
        };
    }
 
    run_on_ui_blocking([notification_level, text, hypertext, callback = std::move(callback)]() mutable {
        GUI::wxGetApp().plater()->get_notification_manager()->push_notification(GUI::NotificationType::CustomNotification, notification_level, text,
                                                                           hypertext, std::move(callback));
    });
}

References Slic3r::PluginAuditManager::current_plugin(), Slic3r::GUI::CustomNotification, Slic3r::anonymous_namespace{PluginHostUi.cpp}::UiRegistry::instance(), Slic3r::PluginAuditManager::instance(), make_holder(), plater_notification(), and run_on_ui_blocking().

Referenced by plater_notification().

Here is the call graph for this function:

Here is the caller graph for this function:

progress_close()

void Slic3r::anonymous_namespace{PluginHostUi.cpp}::progress_close

(

int

id

)

{
    run_on_ui_blocking([&]() {
        auto* d = UiRegistry::instance().get_as<GUI::PluginProgressDialog>(id);
        GUI::PluginProgressDialog::request_close(d);
    });
}

References Slic3r::anonymous_namespace{PluginHostUi.cpp}::UiRegistry::instance(), progress_close(), Slic3r::GUI::PluginProgressDialog::request_close(), and run_on_ui_blocking().

Referenced by progress_close().

Here is the call graph for this function:

Here is the caller graph for this function:

progress_is_open()

bool Slic3r::anonymous_namespace{PluginHostUi.cpp}::progress_is_open

(

int

id

)

{
    return UiRegistry::instance().is_open(id);
}

References Slic3r::anonymous_namespace{PluginHostUi.cpp}::UiRegistry::instance(), and progress_is_open().

Referenced by progress_is_open().

Here is the call graph for this function:

Here is the caller graph for this function:

progress_pulse()

bool Slic3r::anonymous_namespace{PluginHostUi.cpp}::progress_pulse	(	int	id,
		const std::string &	message )

{
    return run_on_ui_blocking([&]() {
        auto* d = UiRegistry::instance().get_as<GUI::PluginProgressDialog>(id);
        return GUI::PluginProgressDialog::pulse(d, wxString::FromUTF8(message));
    });
}

References Slic3r::anonymous_namespace{PluginHostUi.cpp}::UiRegistry::instance(), progress_pulse(), Slic3r::GUI::PluginProgressDialog::pulse(), and run_on_ui_blocking().

Referenced by progress_pulse().

Here is the call graph for this function:

Here is the caller graph for this function:

progress_start_pulse()

void Slic3r::anonymous_namespace{PluginHostUi.cpp}::progress_start_pulse	(	int	id,
		int	interval_ms,
		const std::string &	message )

{
    run_on_ui_blocking([&]() {
        auto* d = UiRegistry::instance().get_as<GUI::PluginProgressDialog>(id);
        GUI::PluginProgressDialog::start_pulse(d, interval_ms, wxString::FromUTF8(message));
    });
}

References Slic3r::anonymous_namespace{PluginHostUi.cpp}::UiRegistry::instance(), progress_start_pulse(), run_on_ui_blocking(), and Slic3r::GUI::PluginProgressDialog::start_pulse().

Referenced by progress_start_pulse().

Here is the call graph for this function:

Here is the caller graph for this function:

progress_stop_pulse()

void Slic3r::anonymous_namespace{PluginHostUi.cpp}::progress_stop_pulse

(

int

id

)

{
    run_on_ui_blocking([&]() {
        auto* d = UiRegistry::instance().get_as<GUI::PluginProgressDialog>(id);
        GUI::PluginProgressDialog::stop_pulse(d);
    });
}

References Slic3r::anonymous_namespace{PluginHostUi.cpp}::UiRegistry::instance(), progress_stop_pulse(), run_on_ui_blocking(), and Slic3r::GUI::PluginProgressDialog::stop_pulse().

Referenced by progress_stop_pulse().

Here is the call graph for this function:

Here is the caller graph for this function:

progress_update()

bool Slic3r::anonymous_namespace{PluginHostUi.cpp}::progress_update	(	int	id,
		int	value,
		const std::string &	message )

{
    return run_on_ui_blocking([&]() {
        auto* d = UiRegistry::instance().get_as<GUI::PluginProgressDialog>(id);
        return GUI::PluginProgressDialog::update(d, value, wxString::FromUTF8(message));
    });
}

References Slic3r::anonymous_namespace{PluginHostUi.cpp}::UiRegistry::instance(), progress_update(), run_on_ui_blocking(), and Slic3r::GUI::PluginProgressDialog::update().

Referenced by progress_update().

Here is the call graph for this function:

Here is the caller graph for this function:

run_on_ui_blocking()

template<typename Fn>

auto Slic3r::anonymous_namespace{PluginHostUi.cpp}::run_on_ui_blocking

(

Fn &&

fn

)

->std::invoke_result_t< Fn & >

{
    using R = std::invoke_result_t<Fn&>;
    if (wxTheApp == nullptr)
        throw std::runtime_error("OrcaSlicer application is not initialized");
 
    if (wxIsMainThread()) {
        py::gil_scoped_release nogil;
        return fn();
    }
 
    if (app_closing())
        throw std::runtime_error("OrcaSlicer is closing");
 
    enum : int { Pending, Claimed, Abandoned };
    // Shared with the queued task, which can outlive an abandoned wait. The task only touches fn
    // after claiming the call, and a claimed call is always waited for, so fn is still alive then.
    struct Call
    {
        std::promise<R>  prom;
        std::atomic<int> state{Pending};
    };
    auto           call = std::make_shared<Call>();
    std::future<R> fut  = call->prom.get_future();
 
    py::gil_scoped_release nogil;
    GUI::wxGetApp().CallAfter([call, &fn]() {
        int expected = Pending;
        if (!call->state.compare_exchange_strong(expected, Claimed))
            return;
        try {
            if constexpr (std::is_void_v<R>) {
                fn();
                call->prom.set_value();
            } else {
                call->prom.set_value(fn());
            }
        } catch (...) {
            call->prom.set_exception(std::current_exception());
        }
    });
    while (fut.wait_for(std::chrono::milliseconds(50)) != std::future_status::ready) {
        int expected = Pending;
        if (app_closing() && call->state.compare_exchange_strong(expected, Abandoned))
            throw std::runtime_error("OrcaSlicer is closing");
    }
    return fut.get();
}

References app_closing(), and run_on_ui_blocking().

Referenced by plater_notification(), progress_close(), progress_pulse(), progress_start_pulse(), progress_stop_pulse(), progress_update(), run_on_ui_blocking(), ui_create_progress_dialog(), and ui_message().

Here is the call graph for this function:

Here is the caller graph for this function:

run_when_plater_shown()

void Slic3r::anonymous_namespace{PluginHostUi.cpp}::run_when_plater_shown

(

std::function< void(GUI::Plater *)>

fn

)

{
    GUI::wxGetApp().CallAfter([fn = std::move(fn)]() mutable {
        auto* waiter = new PlaterShownWaiter(std::move(fn));
        if (!waiter->try_run())
            waiter->Start(100);
    });
}

References run_when_plater_shown().

Referenced by run_when_plater_shown(), and ui_create_dock_panel().

Here is the call graph for this function:

Here is the caller graph for this function:

ui_create_dock_panel()

py::object Slic3r::anonymous_namespace{PluginHostUi.cpp}::ui_create_dock_panel	(	const std::string &	html,
		const std::string &	title,
		int	width,
		int	height,
		py::object	on_message,
		py::object	on_close,
		const std::string &	dock )

{
    if (std::find(std::begin(DOCK_POSITIONS), std::end(DOCK_POSITIONS), dock) == std::end(DOCK_POSITIONS))
        throw std::invalid_argument("orca.host.ui.create_dock_panel dock must be \"left\", \"right\", \"bottom\" or \"float\"");
 
    auto              msg_adapter  = make_message_adapter(std::move(on_message));
    CallablePtr       close_holder = make_holder(std::move(on_close));
    const std::string plugin_key   = PluginAuditManager::instance().current_plugin();
    const int         w            = width > 0 ? width : 320;
    const int         h            = height > 0 ? height : 480;
 
    if (wxTheApp == nullptr)
        throw std::runtime_error("OrcaSlicer application is not initialized");
 
    // Deferred and pre-bound for the same reasons as create_window().
    const int new_id = UiRegistry::instance().reserve_id();
    UiRegistry::instance().bind(new_id, nullptr, plugin_key);
 
    run_when_plater_shown([new_id, plugin_key, html, title, dock, w, h,
                           msg_adapter = std::move(msg_adapter),
                           close_holder = std::move(close_holder)](GUI::Plater* plater) mutable {
        if (!UiRegistry::instance().is_open(new_id))
            return;
 
        if (plater == nullptr) {
            UiRegistry::instance().remove(new_id);
            return;
        }
 
        auto  on_destroyed = [new_id]() { UiRegistry::instance().remove(new_id); };
        auto* panel = new GUI::DockPanel(plater, html, std::move(msg_adapter), make_close_adapter(close_holder),
                                         std::move(on_destroyed));
        UiRegistry::instance().bind(new_id, panel, plugin_key);
        plater->add_dock_pane(panel, GUI::plugin_pane_name(plugin_key, title), wxString::FromUTF8(title), dock,
                              wxSize(w, h), [panel]() { panel->fire_close(); });
    });
 
    return py::cast(UiDockPanelHandle{new_id});
}

References Slic3r::GUI::Plater::add_dock_pane(), Slic3r::PluginAuditManager::current_plugin(), DOCK_POSITIONS, Slic3r::anonymous_namespace{PluginHostUi.cpp}::UiRegistry::instance(), Slic3r::PluginAuditManager::instance(), make_close_adapter(), make_holder(), make_message_adapter(), Slic3r::GUI::plugin_pane_name(), run_when_plater_shown(), and ui_create_dock_panel().

Referenced by ui_create_dock_panel().

Here is the call graph for this function:

Here is the caller graph for this function:

ui_create_progress_dialog()

UiProgressHandle Slic3r::anonymous_namespace{PluginHostUi.cpp}::ui_create_progress_dialog	(	const std::string &	title,
		const std::string &	message,
		int	maximum,
		int	style )

{
    const std::string plugin_key = PluginAuditManager::instance().current_plugin();
    const int         max_value  = maximum > 0 ? maximum : 100;
 
    return run_on_ui_blocking([&]() -> UiProgressHandle {
        const int new_id = UiRegistry::instance().reserve_id();
 
        // Registry cleanup: GIL-free, runs from the dialog destructor on every path.
        auto on_destroyed = [new_id]() { UiRegistry::instance().remove(new_id); };
 
        auto* dlg = GUI::PluginProgressDialog::create_dialog(ui_parent(), wxString::FromUTF8(title),
                                                             wxString::FromUTF8(message), max_value, style,
                                                             std::move(on_destroyed));
        UiRegistry::instance().bind(new_id, dlg, plugin_key);
        return UiProgressHandle{new_id};
    });
}

References Slic3r::GUI::PluginProgressDialog::create_dialog(), Slic3r::PluginAuditManager::current_plugin(), Slic3r::anonymous_namespace{PluginHostUi.cpp}::UiRegistry::instance(), Slic3r::PluginAuditManager::instance(), run_on_ui_blocking(), style, ui_create_progress_dialog(), and ui_parent().

Referenced by new_progress_dialog(), and ui_create_progress_dialog().

Here is the call graph for this function:

Here is the caller graph for this function:

ui_create_window()

py::object Slic3r::anonymous_namespace{PluginHostUi.cpp}::ui_create_window	(	const std::string &	html,
		const std::string &	title,
		int	width,
		int	height,
		py::object	on_message,
		py::object	on_close,
		long	style,
		py::object	on_submit )

{
    auto              msg_adapter    = make_message_adapter(std::move(on_message));
    auto              submit_adapter = make_submit_adapter(std::move(on_submit));
    CallablePtr       close_holder   = make_holder(std::move(on_close));
    const std::string plugin_key     = PluginAuditManager::instance().current_plugin();
    const int         w              = width > 0 ? width : 820;
    const int         h              = height > 0 ? height : 600;
 
    if ((style & ~WINDOW_MODAL) != 0)
        throw std::invalid_argument("unsupported orca.host.ui.create_window style flags");
    const bool modal = (style & WINDOW_MODAL) != 0;
 
    if (wxTheApp == nullptr)
        throw std::runtime_error("OrcaSlicer application is not initialized");
 
    // The whole wxWindow/webview creation is deferred to a clean main-loop iteration.
    // The WebKit backends deliver script messages synchronously from inside the native
    // callback (GTK: HandleWindowEvent in wxgtk_webview_webkit_script_message_received,
    // wx src/gtk/webview_webkit2.cpp; macOS: ProcessWindowEvent in the
    // WKScriptMessageHandler delegate, src/osx/webview_webkit.mm), so a script-triggered
    // create_window otherwise runs with the plugins-dialog webview's signal/delegate
    // frame still on the stack — creating and presenting a second webview window from
    // there crashed on Linux (observed at a since-removed Raise(): gtk_window_present
    // right after a Show() whose real map can still be deferred behind the X11
    // frame-extents handshake, wx src/gtk/toplevel.cpp). WebView2 already queues script
    // messages (AddPendingEvent), so on Windows this deferral merely matches wx's own
    // delivery model.
    //
    // The id is pre-bound with a null window so the returned handle is live at once:
    // is_open() keys on registry presence, post()/close() are CallAfter-marshaled and
    // FIFO-ordered after the creation below, and a plugin teardown claims the pending
    // id (take_for_plugin), which the creation detects and skips — no orphan window.
    const int new_id = UiRegistry::instance().reserve_id();
    UiRegistry::instance().bind(new_id, nullptr, plugin_key);
 
    GUI::wxGetApp().CallAfter([new_id, plugin_key, html, title, w, h,
                               msg_adapter = std::move(msg_adapter),
                               submit_adapter = std::move(submit_adapter),
                               close_holder = std::move(close_holder), modal]() mutable {
        // Torn down (plugin unload / app shutdown) before the window materialized.
        if (!UiRegistry::instance().is_open(new_id))
            return;
 
        GUI::WebDialog::CloseHandler on_close = make_close_adapter(close_holder);
        // Registry cleanup: GIL-free, runs from the dialog destructor on every path.
        auto on_destroyed = [new_id]() { UiRegistry::instance().remove(new_id); };
 
        auto* dlg = new GUI::WebDialog(ui_parent(), wxString::FromUTF8(title), html,
                                       wxSize(w, h), std::move(msg_adapter), std::move(submit_adapter),
                                       std::move(on_close), std::move(on_destroyed), PLUGIN_WX_STYLE);
        UiRegistry::instance().bind(new_id, dlg, plugin_key);
        if (modal) {
            dlg->ShowModal();
            // Plugin teardown may already have removed and destroyed this dialog
            // while its modal loop was running.
            if (UiRegistry::instance().is_open(new_id))
                dlg->Destroy();
        } else {
            dlg->use_normal_window_type();
            dlg->Show();
        }
    });
 
    return py::cast(UiWindowHandle{new_id});
}

References Slic3r::PluginAuditManager::current_plugin(), Slic3r::anonymous_namespace{PluginHostUi.cpp}::UiRegistry::instance(), Slic3r::PluginAuditManager::instance(), make_close_adapter(), make_holder(), make_message_adapter(), make_submit_adapter(), PLUGIN_WX_STYLE, style, ui_create_window(), ui_parent(), and WINDOW_MODAL.

Referenced by ui_create_window().

Here is the call graph for this function:

Here is the caller graph for this function:

ui_message()

std::string Slic3r::anonymous_namespace{PluginHostUi.cpp}::ui_message	(	const std::string &	text,
		const std::string &	title,
		const std::string &	buttons,
		const std::string &	icon )

{
    const long style = message_style(buttons, icon);
    return run_on_ui_blocking([&]() -> std::string {
        GUI::MessageDialog dlg(nullptr, wxString::FromUTF8(text), wxString::FromUTF8(title), style);
        return button_to_string(dlg.ShowModal());
    });
}

References button_to_string(), message_style(), run_on_ui_blocking(), Slic3r::GUI::DPIAware< P >::ShowModal(), style, and ui_message().

Referenced by ui_message().

Here is the call graph for this function:

Here is the caller graph for this function:

ui_parent()

wxWindow * Slic3r::anonymous_namespace{PluginHostUi.cpp}::ui_parent

(

)

{
    return wxTheApp == nullptr ? nullptr : dynamic_cast<wxWindow*>(GUI::wxGetApp().mainframe);
}

References ui_parent().

Referenced by ui_create_progress_dialog(), ui_create_window(), and ui_parent().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

DOCK_POSITIONS

const char* Slic3r::anonymous_namespace{PluginHostUi.cpp}::DOCK_POSITIONS[] = {"left", "right", "bottom", "float"}

constexpr

{"left", "right", "bottom", "float"};

Referenced by ui_create_dock_panel().

PLUGIN_WX_STYLE

long Slic3r::anonymous_namespace{PluginHostUi.cpp}::PLUGIN_WX_STYLE = wxSYSTEM_MENU | wxCAPTION | wxCLOSE_BOX | wxMAXIMIZE_BOX | wxRESIZE_BORDER

constexpr

Referenced by ui_create_window().

WINDOW_MODAL

long Slic3r::anonymous_namespace{PluginHostUi.cpp}::WINDOW_MODAL = 1L << 0

constexpr

Referenced by ui_create_window().

WINDOW_MODELESS

long Slic3r::anonymous_namespace{PluginHostUi.cpp}::WINDOW_MODELESS = 0L

constexpr