Add a Dockable HTML Panel API for Plugins

orca.host.ui.create_dock_panel(html, title, width, height, on_message,
on_close, dock) hosts plugin HTML in a pane of the Plater's dock manager,
next to the sidebar, and returns a UiDockPanel handle
(post/show/hide/close/is_open). The arguments follow create_window(). The
panel uses the window.orca bridge of plugin windows, restores its position
and size from the saved window layout, hides with the Plater off the Prepare
and Preview tabs when floating, and is closed with its plugin; plugin panes
are removed in MainFrame::shutdown().

The web view hosting moves out of PluginPage into a shared PluginWebPanel
base: bootstrap page and swap to the plugin HTML, theme, element-default and
bridge scripts, window.orca message parsing, delivery to the page, and live
re-theming, also re-applied on every load after the swap. Pages tabs and
docked panels both derive from it. Pages tabs now re-theme in place on a
theme change instead of being reloaded, and a window.orca call a host does
not support is logged.

What the hosts share no longer lives in one of them: the bootstrap page, the
base URL and the plugin-window bridge move to Widgets/PluginWebContent, used
by PluginWebDialog and PluginWebPanel alike, and the saved-layout parser
moves to Widgets/AuiPaneLayout, so the Plater does not depend on a plugin
widget.

Includes a sample plugin (sandboxes/orca_dock_panel_plugin_any.py) and
binding and layout-helper tests in slic3rutils.

sandboxes/orca_dock_panel_plugin_any.py

@@ -0,0 +1,146 @@
+# /// script
+# requires-python = ">=3.12"
+#
+# [tool.orcaslicer.plugin]
+# name = "Dock Panel Demo"
+# description = "Opens a dockable panel beside the 3D view that lists the objects on the plate."
+# author = "OrcaSlicer"
+# version = "0.0.1"
+# ///
+"""Dock Panel Demo -- orca.host.ui.create_dock_panel().
+
+Run it from the Plugins dialog. It opens an HTML panel docked on the right of the 3D view, in the
+same dock area as the sidebar. Drag its caption to dock it on another side (or float it, where the
+platform allows), hide it from the page and run the plugin again to bring it back, or close it with
+its close button or from the page.
+
+  page   --orca.postMessage({command: 'refresh'})-->  plugin.on_message()
+  page   --orca.postMessage({command: 'hide'})-->     plugin.on_message() -> panel.hide()
+  page   --orca.close()-->                            panel closes, plugin.on_close()
+  plugin --panel.post({command: 'objects', ...})-->   page (orca.onMessage)
+"""
+import orca
+
+PAGE = """
+<style>
+  body { margin: 0; padding: 12px; font-size: 13px; }
+  h3 { margin: 0 0 4px; font-size: 14px; }
+  .note { margin: 0 0 12px; color: var(--orca-muted); font-size: 12px; }
+  .actions { display: flex; flex-wrap: wrap; gap: 6px; margin-bottom: 12px; }
+  .actions button.quiet { background: transparent; color: var(--orca-fg); border-color: var(--orca-border); }
+  table { width: 100%; border-collapse: collapse; }
+  td.count { text-align: right; font-variant-numeric: tabular-nums; }
+  #status { margin-top: 10px; color: var(--orca-muted); font-size: 12px; }
+</style>
+
+<h3>Objects on the plate</h3>
+<p class="note">Docked beside the 3D view. Drag the caption to move it.</p>
+
+<div class="actions">
+  <button type="button" id="refresh">Refresh</button>
+  <button type="button" id="hide" class="quiet">Hide</button>
+  <button type="button" id="close" class="quiet">Close</button>
+</div>
+
+<table>
+  <thead><tr><th>Name</th><th>Parts</th><th>Copies</th></tr></thead>
+  <tbody id="rows"></tbody>
+</table>
+<p id="status">Waiting for the plugin...</p>
+
+<script>
+(function () {
+  function text(value) {
+    var span = document.createElement("span");
+    span.textContent = value;
+    return span.innerHTML;
+  }
+
+  function render(message) {
+    var rows = document.getElementById("rows");
+    var status = document.getElementById("status");
+    if (message.error) {
+      rows.innerHTML = "";
+      status.textContent = message.error;
+      return;
+    }
+    rows.innerHTML = message.objects.map(function (object) {
+      return "<tr><td>" + text(object.name) + "</td><td class=\\"count\\">" + object.volumes +
+             "</td><td class=\\"count\\">" + object.instances + "</td></tr>";
+    }).join("");
+    status.textContent = message.objects.length + " object(s), refreshed " + new Date().toLocaleTimeString();
+  }
+
+  orca.onMessage(function (message) {
+    if (message && message.command === "objects")
+      render(message);
+  });
+
+  document.getElementById("refresh").addEventListener("click", function () {
+    orca.postMessage({ command: "refresh" });
+  });
+  document.getElementById("hide").addEventListener("click", function () {
+    orca.postMessage({ command: "hide" });
+  });
+  document.getElementById("close").addEventListener("click", function () {
+    orca.close();
+  });
+
+  orca.postMessage({ command: "refresh" });
+})();
+</script>
+"""
+
+
+def plate_objects():
+    try:
+        model = orca.host.model()
+    except RuntimeError as error:
+        return {"command": "objects", "error": str(error)}
+    return {
+        "command": "objects",
+        "objects": [
+            {"name": obj.name or "(unnamed)", "volumes": obj.volume_count(), "instances": obj.instance_count()}
+            for obj in model.objects()
+        ],
+    }
+
+
+class DockPanelDemo(orca.script.ScriptPluginCapabilityBase):
+    panel = None
+
+    def get_name(self):
+        return "Dock Panel Demo"
+
+    def execute(self):
+        # The capability instance lives as long as the plugin, so a second run finds the open panel.
+        if self.panel is not None and self.panel.is_open():
+            self.panel.show()
+            return orca.ExecutionResult.success("Dock Panel Demo is already open.")
+        self.panel = orca.host.ui.create_dock_panel(
+            html=PAGE,
+            title="Dock Panel Demo",
+            width=320,
+            height=480,
+            on_message=self.on_message,
+            on_close=self.on_close,
+            dock="right",
+        )
+        return orca.ExecutionResult.success("Dock Panel Demo opened.")
+
+    # Called on the UI thread when the page posts.
+    def on_message(self, message):
+        command = (message or {}).get("command")
+        if command == "refresh":
+            self.panel.post(plate_objects())
+        elif command == "hide":
+            self.panel.hide()
+
+    def on_close(self):
+        self.panel = None
+
+
+@orca.plugin
+class DockPanelDemoPlugin(orca.base):
+    def register_capabilities(self):
+        orca.register_capability(DockPanelDemo)

src/slic3r/CMakeLists.txt

@@ -139,6 +139,14 @@ set(SLIC3R_GUI_SOURCES
     GUI/PluginProgressDialog.hpp
     GUI/PluginWebDialog.cpp
     GUI/PluginWebDialog.hpp
+    GUI/PluginDockPanel.cpp
+    GUI/PluginDockPanel.hpp
+    GUI/PluginWebPanel.cpp
+    GUI/PluginWebPanel.hpp
+    GUI/Widgets/PluginWebContent.cpp
+    GUI/Widgets/PluginWebContent.hpp
+    GUI/Widgets/AuiPaneLayout.cpp
+    GUI/Widgets/AuiPaneLayout.hpp
     GUI/DragCanvas.cpp
     GUI/DragCanvas.hpp
     GUI/EditGCodeDialog.cpp

src/slic3r/GUI/MainFrame.cpp

@@ -1126,6 +1126,8 @@ void MainFrame::shutdown()
     if (m_project != nullptr)
         m_project->shutdown();
     m_plugin_pages.shutdown();
+    if (m_plater != nullptr)
+        m_plater->remove_plugin_panes();
 #ifdef __WXGTK__
     // Edge panels are child windows — wxWidgets destroys them automatically.
     m_edge_bottom = nullptr;

src/slic3r/GUI/Plater.cpp

@@ -86,6 +86,7 @@
 #ifdef __WXGTK__
 #include "LinuxDisplayBackend.hpp"
 #endif
+#include "Widgets/AuiPaneLayout.hpp"
 #include "GUI_Utils.hpp"
 #include "GUI_Factories.hpp"
 #include "wxExtensions.hpp"
@@ -6723,6 +6724,14 @@ struct Plater::priv
 
     // GUI elements
     AuiMgr m_aui_mgr;
+    // Live plugin panes. `on_close` runs when the user closes one from its close button; `shown` is
+    // what the plugin asked for.
+    struct PluginPane
+    {
+        std::function<void()> on_close;
+        bool                  shown{true};
+    };
+    std::map<wxWindow*, PluginPane> m_plugin_panes;
     wxString m_default_window_layout;
     wxPanel* current_panel{ nullptr };
     std::vector<wxPanel*> panels;
@@ -6894,6 +6903,11 @@ struct Plater::priv
     void update_sidebar(bool force_update = false);
     void reset_window_layout();
     Sidebar::DockingState get_sidebar_docking_state();
+    void add_plugin_pane(wxWindow* window, const std::string& name, const wxString& caption, const std::string& dock,
+                         const wxSize& size, std::function<void()> on_close);
+    void remove_plugin_pane(wxWindow* window);
+    void show_plugin_pane(wxWindow* window, bool show);
+    bool plugin_pane_visible(const PluginPane& plugin_pane, const wxAuiPaneInfo& pane) const;
 
     bool is_view3D_layers_editing_enabled() const { return (current_panel == view3D) && view3D->get_canvas3d()->is_layers_editing_enabled(); }
 
@@ -7474,6 +7488,18 @@ Plater::priv::priv(Plater *q, MainFrame *main_frame)
     panel_3d->SetSizer(panel_sizer);
     m_aui_mgr.AddPane(panel_3d, wxAuiPaneInfo().Name("main").CenterPane().PaneBorder(false));
 
+    q->Bind(wxEVT_AUI_PANE_CLOSE, [this](wxAuiManagerEvent& evt) {
+        const wxAuiPaneInfo* pane = evt.GetPane();
+        auto                 it   = pane != nullptr ? m_plugin_panes.find(pane->window) : m_plugin_panes.end();
+        if (it != m_plugin_panes.end()) {
+            const std::function<void()> on_close = std::move(it->second.on_close);
+            m_plugin_panes.erase(it);
+            if (on_close)
+                on_close();
+        }
+        evt.Skip();
+    });
+
     m_default_window_layout = m_aui_mgr.SavePerspective();
 
     {
@@ -8144,6 +8170,14 @@ void Plater::priv::update_sidebar(bool force_update) {
         }
     }
 
+    for (const auto& [window, plugin_pane] : m_plugin_panes) {
+        wxAuiPaneInfo& pane = m_aui_mgr.GetPane(window);
+        if (pane.IsOk() && pane.IsShown() != plugin_pane_visible(plugin_pane, pane)) {
+            pane.Show(!pane.IsShown());
+            needs_update = true;
+        }
+    }
+
     if (needs_update) {
         notification_manager->set_sidebar_collapsed(sidebar.IsShown());
         m_aui_mgr.Update();
@@ -8153,10 +8187,96 @@ void Plater::priv::update_sidebar(bool force_update) {
 void Plater::priv::reset_window_layout()
 {
     m_aui_mgr.LoadPerspective(m_default_window_layout, false);
+    // Loading a layout docks and hides every pane it does not list, and the default layout lists no
+    // plugin panes: a floating plugin pane is docked again, like the rest of the window.
+    for (const auto& [window, plugin_pane] : m_plugin_panes)
+        if (wxAuiPaneInfo& pane = m_aui_mgr.GetPane(window); pane.IsOk())
+            pane.Show(plugin_pane_visible(plugin_pane, pane));
     sidebar_layout.is_collapsed = false;
     update_sidebar(true);
 }
 
+bool Plater::priv::plugin_pane_visible(const PluginPane& plugin_pane, const wxAuiPaneInfo& pane) const
+{
+    // A floating pane is a top-level window, so it does not hide with the Plater on other tabs.
+    return plugin_pane.shown && (!pane.IsFloating() || sidebar_layout.show);
+}
+
+void Plater::priv::add_plugin_pane(wxWindow* window, const std::string& name, const wxString& caption, const std::string& dock,
+                                   const wxSize& size, std::function<void()> on_close)
+{
+    const wxString base_name   = wxString::FromUTF8(name);
+    wxString       unique_name = base_name;
+    for (int i = 2; m_aui_mgr.GetPane(unique_name).IsOk(); ++i)
+        unique_name = base_name + wxString::Format("#%d", i);
+
+    // A restored layout below already holds pixels.
+    const wxSize  pixels = q->FromDIP(size);
+    wxAuiPaneInfo info;
+    info.Name(unique_name).Caption(caption).BestSize(pixels).FloatingSize(pixels).DestroyOnClose(true);
+    if (dock == "left")
+        info.Left();
+    else if (dock == "bottom")
+        info.Bottom();
+    else
+        info.Right();
+    if (dock == "float")
+        info.Float();
+
+    // Put the pane back where it was the last time the window layout was saved with it open.
+    const std::string saved = aui_pane_layout_entry(wxGetApp().app_config->get("window_layout"), unique_name.utf8_string());
+    if (!saved.empty()) {
+        m_aui_mgr.LoadPaneInfo(wxString::FromUTF8(saved), info);
+        info.Caption(caption).DestroyOnClose(true).Show();
+    }
+
+    // Floating is disabled on Wayland.
+    if ((m_aui_mgr.GetFlags() & wxAUI_MGR_ALLOW_FLOATING) == 0) {
+        info.Dock().Floatable(false);
+        if (info.dock_direction == wxAUI_DOCK_NONE)
+            info.Right();
+    }
+
+    const PluginPane& plugin_pane = m_plugin_panes[window] = PluginPane{std::move(on_close)};
+    info.Show(plugin_pane_visible(plugin_pane, info));
+    m_aui_mgr.AddPane(window, info);
+
+    // wxAUI does not record a dragged sash in best_size, so track the docked size like the sidebar
+    // does, for the saved layout.
+    window->Bind(wxEVT_IDLE, [this, window](wxIdleEvent& evt) {
+        wxAuiPaneInfo& pane = m_aui_mgr.GetPane(window);
+        if (pane.IsOk() && pane.IsShown() && pane.IsDocked() && pane.rect.GetWidth() > 0 && pane.rect.GetHeight() > 0) {
+            const bool horizontal = pane.dock_direction == wxAUI_DOCK_TOP || pane.dock_direction == wxAUI_DOCK_BOTTOM;
+            pane.BestSize(horizontal ? pane.best_size.GetWidth() : pane.rect.GetWidth(),
+                          horizontal ? pane.rect.GetHeight() : pane.best_size.GetHeight());
+        }
+        evt.Skip();
+    });
+
+    m_aui_mgr.Update();
+}
+
+void Plater::priv::remove_plugin_pane(wxWindow* window)
+{
+    m_plugin_panes.erase(window);
+    if (m_aui_mgr.DetachPane(window))
+        m_aui_mgr.Update();
+    window->Destroy();
+}
+
+void Plater::priv::show_plugin_pane(wxWindow* window, bool show)
+{
+    const auto     it   = m_plugin_panes.find(window);
+    wxAuiPaneInfo& pane = m_aui_mgr.GetPane(window);
+    if (it == m_plugin_panes.end() || !pane.IsOk())
+        return;
+    it->second.shown = show;
+    if (pane.IsShown() == plugin_pane_visible(it->second, pane))
+        return;
+    pane.Show(!pane.IsShown());
+    m_aui_mgr.Update();
+}
+
 Sidebar::DockingState Plater::priv::get_sidebar_docking_state() {
     if (!sidebar_layout.is_enabled) {
         return Sidebar::None;
@@ -17760,6 +17880,19 @@ Sidebar::DockingState Plater::get_sidebar_docking_state() const { return p->get_
 
 void Plater::reset_window_layout() { p->reset_window_layout(); }
 
+void Plater::add_plugin_pane(wxWindow* window, const std::string& name, const wxString& caption, const std::string& dock,
+                             const wxSize& size, std::function<void()> on_close)
+{
+    p->add_plugin_pane(window, name, caption, dock, size, std::move(on_close));
+}
+void Plater::remove_plugin_pane(wxWindow* window) { p->remove_plugin_pane(window); }
+void Plater::remove_plugin_panes()
+{
+    while (!p->m_plugin_panes.empty())
+        p->remove_plugin_pane(p->m_plugin_panes.begin()->first);
+}
+void Plater::show_plugin_pane(wxWindow* window, bool show) { p->show_plugin_pane(window, show); }
+
 //BBS
 void Plater::select_curr_plate_all() { p->select_curr_plate_all(); }
 void Plater::remove_curr_plate_all() { p->remove_curr_plate_all(); }

src/slic3r/GUI/Plater.hpp

@@ -475,6 +475,17 @@ public:
 
     void reset_window_layout();
 
+    // Plugin panes dock alongside the sidebar; `window` must be a child of the Plater. `dock` is
+    // "left", "right", "bottom" or "float", and `size` is in DIPs. A pane closed from its own close
+    // button is destroyed after on_close runs; remove_plugin_pane() destroys it without calling on_close.
+    void add_plugin_pane(wxWindow* window, const std::string& name, const wxString& caption, const std::string& dock,
+                         const wxSize& size, std::function<void()> on_close);
+    void remove_plugin_pane(wxWindow* window);
+    void show_plugin_pane(wxWindow* window, bool show);
+    // Removes every plugin pane without calling on_close, for MainFrame::shutdown() (app exit and a
+    // language switch), while the Plater and any floating frames still exist.
+    void remove_plugin_panes();
+
     // Called after the Preferences dialog is closed and the program settings are saved.
     // Update the UI based on the current preferences.
     void update_ui_from_settings();

src/slic3r/GUI/PluginDockPanel.cpp

@@ -0,0 +1,104 @@
+#include "PluginDockPanel.hpp"
+
+#include "GUI_App.hpp"
+#include "Plater.hpp"
+#include "Widgets/PluginWebContent.hpp"
+
+#include <wx/weakref.h>
+
+#include <algorithm>
+#include <utility>
+
+namespace Slic3r { namespace GUI {
+
+std::string plugin_pane_name(const std::string& plugin_key, const std::string& title)
+{
+    std::string name = "plugin:" + plugin_key + ":" + title;
+    std::replace_if(name.begin(), name.end(), [](char c) { return c == '|' || c == ';' || c == '=' || c == '\\'; }, '_');
+    return name;
+}
+
+PluginDockPanel::PluginDockPanel(wxWindow*          parent,
+                                 const std::string& html,
+                                 MessageHandler     on_message,
+                                 CloseHandler       on_close,
+                                 CloseHandler       on_destroyed)
+    : PluginWebPanel(parent, plugin_web::orca_bridge_script())
+    , m_html(html)
+    , m_on_message(std::move(on_message))
+    , m_on_close(std::move(on_close))
+    , m_on_destroyed(std::move(on_destroyed))
+{
+    // A link asking for a new window has nowhere to open from a docked panel.
+    browser()->Bind(wxEVT_WEBVIEW_NEWWINDOW, [](wxWebViewEvent& event) { event.Veto(); });
+}
+
+PluginDockPanel::~PluginDockPanel()
+{
+    if (m_on_destroyed)
+        m_on_destroyed();
+}
+
+bool PluginDockPanel::on_page_message(const std::string& kind, const nlohmann::json& data)
+{
+    if (kind == "message") {
+        if (m_on_message)
+            m_on_message(data);
+        return true;
+    }
+    if (kind == "close") {
+        request_close();
+        return true;
+    }
+    return false;
+}
+
+void PluginDockPanel::push_message(const nlohmann::json& data)
+{
+    if (!m_closing)
+        post_to_page(data.dump(-1, ' ', false, nlohmann::json::error_handler_t::replace));
+}
+
+void PluginDockPanel::fire_close()
+{
+    if (m_closing)
+        return;
+    m_closing = true;
+    if (m_on_close) {
+        CloseHandler on_close = std::move(m_on_close);
+        m_on_close            = nullptr;
+        on_close();
+    }
+}
+
+void PluginDockPanel::request_close()
+{
+    if (m_closing)
+        return;
+    fire_close();
+    // A close requested by the page arrives inside the web view's own script-message callback,
+    // which must return before the web view is destroyed. Every other close path destroys the panel
+    // at once, so it can be gone by the time this runs.
+    wxWeakRef<PluginDockPanel> self(this);
+    CallAfter([self]() {
+        if (self)
+            self->remove_pane();
+    });
+}
+
+void PluginDockPanel::destroy_for_plugin()
+{
+    m_closing  = true;
+    m_on_close = nullptr;
+    remove_pane();
+}
+
+void PluginDockPanel::remove_pane()
+{
+    if (Plater* plater = wxGetApp().plater())
+        plater->remove_plugin_pane(this);
+    else
+        Destroy();
+}
+
+}} // namespace Slic3r::GUI

src/slic3r/GUI/PluginDockPanel.hpp

@@ -0,0 +1,59 @@
+#pragma once
+
+#include "PluginWebPanel.hpp"
+
+#include <functional>
+#include <string>
+
+namespace Slic3r { namespace GUI {
+
+// Name of a plugin's pane in the Plater's dock manager. It stays the same across sessions, so the
+// saved window layout can put the pane back, and it never contains a wxAuiManager layout delimiter.
+std::string plugin_pane_name(const std::string& plugin_key, const std::string& title);
+
+// A PluginWebPanel docked in the Plater's dock manager, using the same window.orca bridge as
+// PluginWebDialog (without submit, which only a plugin window handles). Python-agnostic for the same
+// reason: it can be destroyed on the main thread without the GIL, so its hooks must not capture
+// pybind11 objects.
+class PluginDockPanel : public PluginWebPanel
+{
+public:
+    using MessageHandler = std::function<void(const nlohmann::json& data)>;
+    using CloseHandler   = std::function<void()>;
+
+    // on_close fires once, on a user or page initiated close. on_destroyed runs from the destructor
+    // on every path and must touch host-side state only.
+    PluginDockPanel(wxWindow*          parent,
+                    const std::string& html,
+                    MessageHandler     on_message,
+                    CloseHandler       on_close,
+                    CloseHandler       on_destroyed);
+    ~PluginDockPanel() override;
+
+    // Main thread only.
+    void push_message(const nlohmann::json& data);
+    // Fires on_close, then removes the pane.
+    void request_close();
+    // Removes the pane without firing on_close, for plugin unload. Unlike request_close() it destroys
+    // the panel at once, which is safe because nothing a plugin page can call unloads a plugin: unload
+    // comes from the host (Plugins dialog, install, logout), never from this panel's own callbacks.
+    void destroy_for_plugin();
+    // Fires on_close at most once. Runs when the pane's own close button is used, through the handler
+    // the panel is registered with.
+    void fire_close();
+
+protected:
+    std::optional<std::string> page_html() override { return m_html; }
+    bool on_page_message(const std::string& kind, const nlohmann::json& data) override;
+
+private:
+    void remove_pane();
+
+    std::string    m_html;
+    bool           m_closing{false};
+    MessageHandler m_on_message;
+    CloseHandler   m_on_close;
+    CloseHandler   m_on_destroyed;
+};
+
+}} // namespace Slic3r::GUI

src/slic3r/GUI/PluginWebDialog.cpp

@@ -1,71 +1,14 @@
 #include "PluginWebDialog.hpp"
 
-#include "slic3r/GUI/GUI.hpp"
 #include "slic3r/GUI/GUI_App.hpp"
-
+#include "slic3r/GUI/Widgets/PluginWebContent.hpp"
-#include <libslic3r/Utils.hpp>
-
-#include <boost/filesystem.hpp>
 
 #include <wx/event.h>
-#include <wx/uri.h>
 
 #include <utility>
 
 namespace Slic3r { namespace GUI {
 
-namespace {
-
-// Injected into the top-level page at document start (before the plugin's own
-// scripts). Defines window.orca as the only host surface the page may use. It
-// references window.wx lazily (at call time) so it never races the backend's
-// deferred registration of the "wx" message handler. Guarded against
-// double-injection so it is harmless if also prepended.
-constexpr char ORCA_BRIDGE_JS[] = R"JS(
-(function () {
-  if (window.top !== window.self) return;
-  if (window.orca) return;
-  var handlers = [];
-  function send(kind, data) {
-    try {
-      window.wx.postMessage(JSON.stringify({
-        channel: 'orca', kind: kind, data: (data === undefined ? null : data)
-      }));
-    } catch (e) { /* bridge not ready yet */ }
-  }
-  window.orca = {
-    postMessage: function (d) { send('message', d); },
-    submit:      function (d) { send('submit', d); },
-    close:       function ()  { send('close'); },
-    onMessage:   function (cb) { if (typeof cb === 'function') handlers.push(cb); }
-  };
-  window.__orcaDispatch = function (payload) {
-    var data = payload ? payload.data : null;
-    for (var i = 0; i < handlers.length; i++) {
-      try { handlers[i](data); } catch (e) {}
-    }
-  };
-})();
-)JS";
-
-// file:// base URL for plugin HTML loaded via SetPage, so self-referencing
-// relative URLs resolve against the bundled web resources directory.
-wxString web_base_url()
-{
-    const std::string dir = (boost::filesystem::path(resources_dir()) / "web").make_preferred().string();
-    return wxString("file://") + from_u8(dir) + "/";
-}
-
-// Whether a loaded document is the plugin HTML's own base URL. The web view reports the URL it
-// parsed, so any fragment the page navigated to is ignored and the escaping it applies to what the
-// resources path holds (a space, a non-ASCII character) is undone first.
-bool is_content_url(const wxString& url)
-{
-    return wxURI::Unescape(url.BeforeFirst('#')) == web_base_url();
-}
-
-} // namespace
-
 PluginWebDialog::PluginWebDialog(wxWindow*          parent,
                                  const wxString&    title,
                                  const std::string& html,
@@ -84,7 +27,7 @@ PluginWebDialog::PluginWebDialog(wxWindow*          parent,
 {
     // A tiny bundled bootstrap page brings the webview up; the real plugin HTML
     // is swapped in via SetPage once the bootstrap finishes loading.
-    create_webview("web/dialog/PluginWebDialog/blank.html", title, size, wxSize(320, 240));
+    create_webview(plugin_web::BOOTSTRAP_PAGE, title, size, wxSize(320, 240));
 
     // Paint the window/webview in the themed background so there is no white
     // flash before the (transparent) bootstrap page and plugin HTML render.
@@ -106,7 +49,7 @@ void PluginWebDialog::add_user_scripts()
 {
     if (wxWebView* wv = browser()) {
         wv->AddUserScript(wxString::FromUTF8(WebViewHostDialog::plugin_defaults_user_script()));
-        wv->AddUserScript(ORCA_BRIDGE_JS);
+        wv->AddUserScript(wxString::FromUTF8(plugin_web::orca_bridge_script()));
     }
 }
 
@@ -160,7 +103,7 @@ void PluginWebDialog::on_bootstrap_event(wxWebViewEvent& event)
     else if (event.GetEventType() == wxEVT_WEBVIEW_LOADED) {
         if (m_own_page_load)
             m_own_page_load = false;
-        else if (is_content_url(event.GetURL()))
+        else if (plugin_web::is_content_url(event.GetURL()))
             load_plugin_content();
     }
     event.Skip();
@@ -171,7 +114,7 @@ void PluginWebDialog::load_plugin_content()
     m_content_loaded = true;
     if (wxWebView* wv = browser()) {
         m_own_page_load = true;
-        wv->SetPage(wxString::FromUTF8(m_html), web_base_url());
+        wv->SetPage(wxString::FromUTF8(m_html), plugin_web::content_base_url());
     }
 }
 

src/slic3r/GUI/PluginWebPanel.cpp

@@ -0,0 +1,109 @@
+#include "PluginWebPanel.hpp"
+
+#include "GUI.hpp"
+#include "GUI_App.hpp"
+#include "Widgets/PluginWebContent.hpp"
+#include "Widgets/WebView.hpp"
+#include "Widgets/WebViewHostDialog.hpp"
+
+#include <libslic3r/Utils.hpp>
+
+#include <boost/filesystem.hpp>
+#include <boost/log/trivial.hpp>
+
+#include <wx/sizer.h>
+
+namespace Slic3r { namespace GUI {
+
+PluginWebPanel::PluginWebPanel(wxWindow* parent, const char* bridge_script)
+    : wxPanel(parent, wxID_ANY)
+{
+    SetBackgroundColour(wxGetApp().get_window_default_clr());
+    auto* sizer = new wxBoxSizer(wxVERTICAL);
+    SetSizer(sizer);
+
+    // Never null: WebView::CreateWebView substitutes a placeholder view when no backend is available.
+    const std::string bootstrap = (boost::filesystem::path(resources_dir()) / plugin_web::BOOTSTRAP_PAGE).make_preferred().string();
+    m_browser = WebView::CreateWebView(this, wxString("file://") + from_u8(bootstrap));
+    m_browser->SetBackgroundColour(GetBackgroundColour());
+    m_browser->AddUserScript(wxString::FromUTF8(WebViewHostDialog::theme_user_script()));
+    m_browser->AddUserScript(wxString::FromUTF8(WebViewHostDialog::plugin_defaults_user_script()));
+    m_browser->AddUserScript(wxString::FromUTF8(bridge_script));
+    m_browser->Bind(wxEVT_WEBVIEW_LOADED, &PluginWebPanel::on_load_event, this);
+    m_browser->Bind(wxEVT_WEBVIEW_ERROR, &PluginWebPanel::on_load_event, this);
+    m_browser->Bind(wxEVT_WEBVIEW_SCRIPT_MESSAGE_RECEIVED, &PluginWebPanel::on_script_message, this);
+    m_browser->Bind(EVT_WEBVIEW_RECREATED, &PluginWebPanel::on_webview_recreated, this);
+    sizer->Add(m_browser, 1, wxEXPAND);
+}
+
+void PluginWebPanel::on_load_event(wxWebViewEvent& event)
+{
+    if (!m_content_loaded) {
+        // The first bootstrap load (or its error) triggers the swap to the plugin HTML.
+        m_content_loaded = true;
+        load_page_html();
+    } else if (event.GetEventType() != wxEVT_WEBVIEW_LOADED) {
+        // A failed load has no document to theme, but it does end the swap it belonged to: leaving
+        // the flag set would make the next reload look like our own load and be swallowed.
+        m_own_page_load = false;
+    } else {
+        // WebKit reloads the SetPage base URL rather than the injected page, and the injected
+        // document reports that same URL, so a load of it that is not the swap we started is a
+        // browser reload and the plugin HTML has to be put back. A page a link loaded arrives
+        // under its own URL. The Edge backend ignores the base URL, so this never matches there.
+        if (!m_own_page_load && plugin_web::is_content_url(event.GetURL())) {
+            load_page_html();
+        } else {
+            m_own_page_load = false;
+            // The document-start theme script keeps the theme the web view was created with, so
+            // bring every later document (the plugin page, or one a link loaded) onto the app theme.
+            apply_theme();
+        }
+    }
+    event.Skip();
+}
+
+void PluginWebPanel::load_page_html()
+{
+    if (const std::optional<std::string> html = page_html()) {
+        m_own_page_load = true;
+        m_browser->SetPage(wxString::FromUTF8(*html), plugin_web::content_base_url());
+    }
+}
+
+void PluginWebPanel::on_script_message(wxWebViewEvent& event)
+{
+    const nlohmann::json payload = nlohmann::json::parse(event.GetString().utf8_string(), nullptr, false);
+    if (!payload.is_object() || payload.value("channel", std::string()) != "orca")
+        return;
+
+    const std::string kind = payload.value("kind", std::string());
+    if (!on_page_message(kind, payload.contains("data") ? payload["data"] : nlohmann::json()))
+        BOOST_LOG_TRIVIAL(warning) << "Plugin web panel ignored a window.orca '" << kind << "' call; this host does not support it";
+}
+
+void PluginWebPanel::on_webview_recreated(wxCommandEvent&)
+{
+    SetBackgroundColour(wxGetApp().get_window_default_clr());
+    m_browser->SetBackgroundColour(GetBackgroundColour());
+    Refresh();
+    // Handled without Skip(), so WebView::RecreateAll() does not reload the plugin page.
+    apply_theme();
+}
+
+void PluginWebPanel::apply_theme()
+{
+    WebView::RunScript(m_browser, wxString::FromUTF8(WebViewHostDialog::theme_apply_script()));
+}
+
+void PluginWebPanel::post_to_page(const std::string& json)
+{
+    WebView::RunScript(m_browser, wxString::Format(
+        "(function dispatch(payload, attempts) {\n"
+        "  if (typeof window.__orcaDispatch === 'function') { window.__orcaDispatch(payload); return; }\n"
+        "  if (attempts < 100) window.setTimeout(function() { dispatch(payload, attempts + 1); }, 25);\n"
+        "})({data: %s}, 0);",
+        wxString::FromUTF8(json)));
+}
+
+}} // namespace Slic3r::GUI

src/slic3r/GUI/PluginWebPanel.hpp

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <nlohmann/json.hpp>
+
+#include <wx/panel.h>
+#include <wx/webview.h>
+
+#include <optional>
+#include <string>
+
+namespace Slic3r { namespace GUI {
+
+// A panel hosting plugin-supplied HTML in a web view, shared by plugin Pages tabs and docked panels.
+// It loads the bundled bootstrap page, swaps the plugin HTML in once that has loaded, registers the
+// host theme, the plugin element defaults and the given window.orca bridge, keeps the page on the
+// app theme, and routes the bridge's messages to on_page_message().
+class PluginWebPanel : public wxPanel
+{
+public:
+    PluginWebPanel(wxWindow* parent, const char* bridge_script);
+
+protected:
+    wxWebView* browser() const { return m_browser; }
+
+    // Delivers an already serialised JSON value to the page's window.orca.onMessage handlers,
+    // waiting briefly for the bridge while the page is still loading. Main thread only.
+    void post_to_page(const std::string& json);
+
+    // The plugin HTML to show once the bootstrap page has loaded; std::nullopt leaves it blank.
+    virtual std::optional<std::string> page_html() = 0;
+    // A window.orca message from the page. Returns false for a kind this host does not handle,
+    // which is logged so a dropped call is diagnosable.
+    virtual bool on_page_message(const std::string& kind, const nlohmann::json& data) = 0;
+
+private:
+    void on_load_event(wxWebViewEvent& event);
+    void on_script_message(wxWebViewEvent& event);
+    void on_webview_recreated(wxCommandEvent& event);
+    void apply_theme();
+    void load_page_html();
+
+    wxWebView* m_browser{nullptr};
+    bool       m_content_loaded{false};
+    bool       m_own_page_load{false}; // a SetPage of the plugin HTML is in flight
+};
+
+}} // namespace Slic3r::GUI

src/slic3r/GUI/Widgets/AuiPaneLayout.cpp

@@ -0,0 +1,20 @@
+#include "AuiPaneLayout.hpp"
+
+namespace Slic3r { namespace GUI {
+
+std::string aui_pane_layout_entry(const std::string& layout, const std::string& pane_name)
+{
+    // Panes are separated by '|'; SavePerspective() escapes a '|' inside a caption as "\|".
+    const std::string prefix = "name=" + pane_name + ";";
+    size_t            begin  = 0;
+    for (size_t i = 0; i <= layout.size(); ++i) {
+        if (i < layout.size() && (layout[i] != '|' || (i > 0 && layout[i - 1] == '\\')))
+            continue;
+        if (layout.compare(begin, prefix.size(), prefix) == 0)
+            return layout.substr(begin, i - begin);
+        begin = i + 1;
+    }
+    return {};
+}
+
+}} // namespace Slic3r::GUI

src/slic3r/GUI/Widgets/AuiPaneLayout.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <string>
+
+namespace Slic3r { namespace GUI {
+
+// The part a wxAuiManager layout string (wxAuiManager::SavePerspective) holds for `pane_name`, in the
+// form wxAuiManager::LoadPaneInfo() takes, or empty when the layout has no such pane.
+std::string aui_pane_layout_entry(const std::string& layout, const std::string& pane_name);
+
+}} // namespace Slic3r::GUI

src/slic3r/GUI/Widgets/PluginWebContent.cpp

@@ -0,0 +1,64 @@
+#include "PluginWebContent.hpp"
+
+#include "slic3r/GUI/GUI.hpp"
+
+#include <libslic3r/Utils.hpp>
+
+#include <boost/filesystem.hpp>
+
+#include <wx/uri.h>
+
+namespace Slic3r { namespace GUI { namespace plugin_web {
+
+namespace {
+
+// Injected into the top-level page at document start (before the plugin's own
+// scripts). Defines window.orca as the only host surface the page may use. It
+// references window.wx lazily (at call time) so it never races the backend's
+// deferred registration of the "wx" message handler. Guarded against
+// double-injection so it is harmless if also prepended.
+constexpr char ORCA_BRIDGE_JS[] = R"JS(
+(function () {
+  if (window.top !== window.self) return;
+  if (window.orca) return;
+  var handlers = [];
+  function send(kind, data) {
+    try {
+      window.wx.postMessage(JSON.stringify({
+        channel: 'orca', kind: kind, data: (data === undefined ? null : data)
+      }));
+    } catch (e) { /* bridge not ready yet */ }
+  }
+  window.orca = {
+    postMessage: function (d) { send('message', d); },
+    submit:      function (d) { send('submit', d); },
+    close:       function ()  { send('close'); },
+    onMessage:   function (cb) { if (typeof cb === 'function') handlers.push(cb); }
+  };
+  window.__orcaDispatch = function (payload) {
+    var data = payload ? payload.data : null;
+    for (var i = 0; i < handlers.length; i++) {
+      try { handlers[i](data); } catch (e) {}
+    }
+  };
+})();
+)JS";
+
+} // namespace
+
+wxString content_base_url()
+{
+    const std::string dir = (boost::filesystem::path(resources_dir()) / "web").make_preferred().string();
+    return wxString("file://") + from_u8(dir) + "/";
+}
+
+bool is_content_url(const wxString& url)
+{
+    // The web view reports the URL it parsed, which escapes anything the resources path holds
+    // (a space, a non-ASCII character), while content_base_url() is the raw path.
+    return wxURI::Unescape(url.BeforeFirst('#')) == content_base_url();
+}
+
+const char* orca_bridge_script() { return ORCA_BRIDGE_JS; }
+
+}}} // namespace Slic3r::GUI::plugin_web

src/slic3r/GUI/Widgets/PluginWebContent.hpp

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <wx/string.h>
+
+namespace Slic3r { namespace GUI { namespace plugin_web {
+
+// What every plugin web view is built from, shared by the hosts that show plugin HTML
+// (PluginWebDialog, PluginWebPanel and its subclasses) without either of them owning it.
+
+// The bundled blank page a plugin web view loads before the plugin HTML is swapped in.
+constexpr const char* BOOTSTRAP_PAGE = "web/dialog/PluginWebDialog/blank.html";
+
+// The file:// base URL plugin HTML is loaded against, so relative URLs resolve against the bundled
+// web resources.
+wxString content_base_url();
+
+// Whether a loaded document is the plugin HTML's own base URL, ignoring any fragment the page
+// navigated to. WebKit reports that URL both for the injected page and for the reload that
+// replaces it with the directory itself, so a load of any other URL is a page the plugin linked to.
+bool is_content_url(const wxString& url);
+
+// The window.orca bridge of plugin windows and docked panels: postMessage, submit, close and
+// onMessage. Each host acts only on the message kinds it supports; Pages tabs ship their own bridge.
+const char* orca_bridge_script();
+
+}}} // namespace Slic3r::GUI::plugin_web

src/slic3r/GUI/Widgets/WebViewHostDialog.cpp

@@ -75,6 +75,8 @@ if(document.documentElement)
 
 } // namespace
 
+std::string WebViewHostDialog::theme_apply_script() { return host_theme_apply_js(); }
+
 // Document-start user script: injects the contract <style>, stamps data-orca-theme before
 // first paint, and raises a JS flag so the legacy globalapi.js dark.css poll stands down for
 // host-themed pages. The WebView2 timing guard lives in document_start_injector().

src/slic3r/GUI/Widgets/WebViewHostDialog.hpp

@@ -52,6 +52,8 @@ public:
     // Shared by modeless Pages tabs and PluginWebDialog.
     static std::string theme_user_script();
     static std::string plugin_defaults_user_script();
+    // Re-themes an already-loaded page in place, for web views hosted outside a dialog.
+    static std::string theme_apply_script();
 
 protected:
     wxWebView* browser() const { return m_browser; }

src/slic3r/plugin/host/PluginHostUi.cpp

@@ -7,6 +7,8 @@
 #include <slic3r/GUI/GUI_App.hpp>
 #include <slic3r/GUI/MainFrame.hpp>
 #include <slic3r/GUI/MsgDialog.hpp>
+#include <slic3r/GUI/Plater.hpp>
+#include <slic3r/GUI/PluginDockPanel.hpp>
 #include <slic3r/GUI/PluginProgressDialog.hpp>
 #include <slic3r/GUI/PluginWebDialog.hpp>
 #include <slic3r/GUI/NotificationManager.hpp>
@@ -20,6 +22,7 @@
 #include <wx/defs.h>
 #include <wx/window.h>
 
+#include <algorithm>
 #include <atomic>
 #include <cstdint>
 #include <future>
@@ -109,6 +112,25 @@ GUI::PluginWebDialog::SubmitHandler make_submit_adapter(py::object on_submit)
     };
 }
 
+// The plugin's on_close: fired only on a user/JS-initiated close (not forced teardown), while the
+// window is alive. Empty if the plugin passed None.
+std::function<void()> 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();
+        }
+    };
+}
+
 // --------------------------------------------------------------------------
 // Registry of live plugin UI resources. Keyed by an opaque id; tracks the
 // owning plugin so all of a plugin's UI can be torn down on unload.
@@ -350,22 +372,7 @@ py::object ui_create_window(const std::string& html, const std::string& title, i
         if (!UiRegistry::instance().is_open(new_id))
             return;
 
-        // Plugin's on_close: fired only on a user/JS-initiated close (not forced
+        GUI::PluginWebDialog::CloseHandler on_close = make_close_adapter(close_holder);
-        // teardown), while the dialog is alive. Empty if the plugin passed None.
-        GUI::PluginWebDialog::CloseHandler on_close;
-        if (close_holder) {
-            on_close = [close_holder]() {
-                PythonGILState gil;
-                if (!gil)
-                    return;
-                try {
-                    close_holder->fn();
-                } catch (py::error_already_set& e) {
-                    BOOST_LOG_TRIVIAL(error) << "orca.host.ui on_close handler raised: " << e.what();
-                    PyErr_Clear();
-                }
-            };
-        }
         // Registry cleanup: GIL-free, runs from the dialog destructor on every path.
         auto on_destroyed = [new_id]() { UiRegistry::instance().remove(new_id); };
 
@@ -387,14 +394,69 @@ py::object ui_create_window(const std::string& html, const std::string& title, i
     return py::cast(UiWindowHandle{new_id});
 }
 
+// --------------------------------------------------------------------------
+// orca.host.ui.create_dock_panel + UiDockPanel handle
+// --------------------------------------------------------------------------
+constexpr const char* DOCK_POSITIONS[] = {"left", "right", "bottom", "float"};
+
+struct UiDockPanelHandle
+{
+    int id{0};
+};
+
+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)
+{
+    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);
+
+    GUI::wxGetApp().CallAfter([new_id, plugin_key, html, title, dock, w, h,
+                               msg_adapter = std::move(msg_adapter),
+                               close_holder = std::move(close_holder)]() mutable {
+        if (!UiRegistry::instance().is_open(new_id))
+            return;
+
+        GUI::Plater* plater = GUI::wxGetApp().plater();
+        if (plater == nullptr || GUI::wxGetApp().is_closing()) {
+            UiRegistry::instance().remove(new_id);
+            return;
+        }
+
+        auto  on_destroyed = [new_id]() { UiRegistry::instance().remove(new_id); };
+        auto* panel = new GUI::PluginDockPanel(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_plugin_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});
+}
+
 void 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* d = UiRegistry::instance().get_as<GUI::PluginWebDialog>(id);
+        auto* window = UiRegistry::instance().get_as<wxWindow>(id);
-        GUI::PluginWebDialog::post_message(d, j);
+        if (auto* panel = dynamic_cast<GUI::PluginDockPanel*>(window))
+            panel->push_message(j);
+        else
+            GUI::PluginWebDialog::post_message(dynamic_cast<GUI::PluginWebDialog*>(window), j);
     });
 }
 
@@ -403,8 +465,23 @@ void handle_close(int id)
     if (wxTheApp == nullptr)
         return;
     GUI::wxGetApp().CallAfter([id]() {
-        auto* d = UiRegistry::instance().get_as<GUI::PluginWebDialog>(id);
+        auto* window = UiRegistry::instance().get_as<wxWindow>(id);
-        GUI::PluginWebDialog::request_close(d);
+        if (auto* panel = dynamic_cast<GUI::PluginDockPanel*>(window))
+            panel->request_close();
+        else
+            GUI::PluginWebDialog::request_close(dynamic_cast<GUI::PluginWebDialog*>(window));
+    });
+}
+
+void handle_show(int id, bool show)
+{
+    if (wxTheApp == nullptr)
+        return;
+    GUI::wxGetApp().CallAfter([id, show]() {
+        auto*        panel  = UiRegistry::instance().get_as<GUI::PluginDockPanel>(id);
+        GUI::Plater* plater = GUI::wxGetApp().plater();
+        if (panel != nullptr && plater != nullptr)
+            plater->show_plugin_pane(panel, show);
     });
 }
 
@@ -563,6 +640,31 @@ void PluginHostUi::RegisterBindings(pybind11::module_& host)
            "or WINDOW_MODAL. on_message(data) is called on the UI thread when the page posts; on_submit(data) "
            "is called when the page submits; offload heavy work to a thread and push results back with window.post().");
 
+    py::class_<UiDockPanelHandle>(ui, "UiDockPanel", "Handle to a dockable plugin HTML panel created by create_dock_panel().")
+        .def_property_readonly("id", [](const UiDockPanelHandle& h) { return h.id; })
+        .def(
+            "post", [](const UiDockPanelHandle& h, py::object data) { handle_post(h.id, std::move(data)); },
+            py::arg("data"), "Send a payload to the page (delivered to window.orca.onMessage handlers).")
+        .def(
+            "show", [](const UiDockPanelHandle& h) { handle_show(h.id, true); }, "Show the panel again after hide().")
+        .def(
+            "hide", [](const UiDockPanelHandle& h) { handle_show(h.id, false); }, "Hide the panel without closing it.")
+        .def(
+            "close", [](const UiDockPanelHandle& h) { handle_close(h.id); }, "Close the panel (fires on_close).")
+        .def(
+            "is_open", [](const UiDockPanelHandle& h) { return UiRegistry::instance().is_open(h.id); },
+            "Return True until the panel is closed; a hidden panel is still open.");
+
+    ui.def("create_dock_panel", &ui_create_dock_panel, py::arg("html"), py::arg("title") = "OrcaSlicer",
+           py::arg("width") = 320, py::arg("height") = 480, py::arg("on_message") = py::none(),
+           py::arg("on_close") = py::none(), py::arg("dock") = "right",
+           "Open an HTML panel docked beside the 3D view and return a UiDockPanel. dock is \"left\", \"right\", "
+           "\"bottom\" or \"float\", and width/height are in DIPs; the user can move and resize the panel, and a panel "
+           "opened again comes back where the window layout was last saved. The panel belongs to the Prepare and "
+           "Preview tabs. on_message(data) is called on the UI thread when the page posts; window.orca.close() "
+           "or the panel's close button closes it and calls on_close(). A post() made before the page has "
+           "loaded can be dropped, so have the page request its first data.");
+
     py::class_<UiProgressHandle>(ui, "ProgressDialog", "Handle to a native progress dialog.")
         .def(py::init(&new_progress_dialog), py::arg("title"), py::arg("message"), py::arg("maximum") = 100,
              py::arg("style") = wxPD_APP_MODAL | wxPD_AUTO_HIDE)
@@ -632,6 +734,8 @@ void PluginHostUi::close_windows_for_plugin(const std::string& plugin_key)
         for (auto* window : UiRegistry::instance().take_for_plugin(plugin_key)) {
             if (auto* dialog = dynamic_cast<GUI::PluginWebDialog*>(window))
                 GUI::PluginWebDialog::destroy_for_plugin(dialog);
+            else if (auto* panel = dynamic_cast<GUI::PluginDockPanel*>(window))
+                panel->destroy_for_plugin();
             else if (window != nullptr)
                 window->Destroy();
         }

src/slic3r/plugin/host/PluginPages.cpp

@@ -1,17 +1,12 @@
 #include "PluginPages.hpp"
 
 #include "libslic3r/AppConfig.hpp"
-#include "slic3r/GUI/GUI.hpp"
 #include "slic3r/GUI/Notebook.hpp"
 #include "slic3r/GUI/GUI_App.hpp"
 #include "slic3r/GUI/Widgets/Button.hpp"
-#include "slic3r/GUI/Widgets/WebView.hpp"
-#include "slic3r/GUI/Widgets/WebViewHostDialog.hpp"
 #include "slic3r/GUI/wxExtensions.hpp"
 #include "slic3r/plugin/PluginManager.hpp"
 
-#include <libslic3r/Utils.hpp>
-
 #include <algorithm>
 
 #include <boost/filesystem/path.hpp>
@@ -66,27 +61,11 @@ constexpr char PLUGIN_PAGE_BRIDGE_JS[] = R"JS(
 } // namespace
 
 PluginPage::PluginPage(wxWindow* parent, std::shared_ptr<PagesPluginCapability> capability)
-    : wxPanel(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize)
+    : GUI::PluginWebPanel(parent, PLUGIN_PAGE_BRIDGE_JS)
     , m_cap(std::move(capability))
     , m_lifetime(std::make_shared<std::atomic<PluginPage*>>(this))
 {
-    auto* topsizer = new wxBoxSizer(wxVERTICAL);
+    browser()->Bind(wxEVT_WEBVIEW_NEWWINDOW, &PluginPage::on_new_window, this);
-    SetSizer(topsizer);
-
-    m_browser = WebView::CreateWebView(this, bootstrap_url());
-    if (m_browser == nullptr) {
-        wxLogError("Could not initialize plugin page web view");
-        return;
-    }
-
-    topsizer->Add(m_browser, wxSizerFlags().Expand().Proportion(1));
-    m_browser->Bind(wxEVT_WEBVIEW_LOADED, &PluginPage::on_bootstrap_event, this);
-    m_browser->Bind(wxEVT_WEBVIEW_ERROR, &PluginPage::on_bootstrap_event, this);
-    m_browser->Bind(wxEVT_WEBVIEW_NEWWINDOW, &PluginPage::on_new_window, this);
-    m_browser->Bind(wxEVT_WEBVIEW_SCRIPT_MESSAGE_RECEIVED, &PluginPage::on_script_message, this);
-    m_browser->AddUserScript(wxString::FromUTF8(GUI::WebViewHostDialog::theme_user_script()));
-    m_browser->AddUserScript(wxString::FromUTF8(GUI::WebViewHostDialog::plugin_defaults_user_script()));
-    m_browser->AddUserScript(PLUGIN_PAGE_BRIDGE_JS);
 
     const std::shared_ptr<std::atomic<PluginPage*>> lifetime = m_lifetime;
     m_cap->set_message_sender([lifetime](const std::string& message) {
@@ -117,89 +96,54 @@ void PluginPage::detach_capability()
     m_cap.reset();
 }
 
-wxString PluginPage::web_base_url() const
+std::optional<std::string> PluginPage::page_html()
 {
-    const auto path = (boost::filesystem::path(resources_dir()) / "web").make_preferred().string();
+    if (m_cap == nullptr)
-    return wxString("file://") + GUI::from_u8(path) + "/";
+        return std::nullopt;
-}
 
-wxString PluginPage::bootstrap_url() const
-{
-    const auto path = (boost::filesystem::path(resources_dir()) / "web/dialog/PluginWebDialog/blank.html").make_preferred().string();
-    return wxString("file://") + GUI::from_u8(path);
-}
-
-void PluginPage::on_bootstrap_event(wxWebViewEvent& event)
-{
-    load_plugin_content();
-    event.Skip();
-}
-
-void PluginPage::load_plugin_content()
-{
-    if (m_content_loaded || m_browser == nullptr || m_cap == nullptr)
-        return;
-
-    m_content_loaded = true;
     try {
-        m_browser->SetPage(wxString::FromUTF8(m_cap->get_ui()), web_base_url());
+        return m_cap->get_ui();
     } catch (const std::exception& error) {
         BOOST_LOG_TRIVIAL(error) << "Failed to load plugin page '" << m_cap->name() << "': " << error.what();
-        detach_capability();
     } catch (...) {
         BOOST_LOG_TRIVIAL(error) << "Failed to load plugin page '" << m_cap->name() << "'";
-        detach_capability();
     }
+    detach_capability();
+    return std::nullopt;
 }
 
 void PluginPage::on_new_window(wxWebViewEvent& event)
 {
     const wxString url = event.GetURL();
-    if (!url.empty() && m_browser != nullptr)
+    if (!url.empty())
-        m_browser->LoadURL(url);
+        browser()->LoadURL(url);
     event.Veto();
 }
 
-void PluginPage::on_script_message(wxWebViewEvent& event)
+bool PluginPage::on_page_message(const std::string& kind, const nlohmann::json& data)
 {
+    if (kind != "message")
+        return false;
     if (!m_cap)
-        return;
+        return true;
 
-    const wxString payload = event.GetString();
-    nlohmann::json root    = nlohmann::json::parse(payload.utf8_string(), nullptr, false);
-    if (root.is_discarded() || root.value("channel", std::string()) != "orca" ||
-        root.value("kind", std::string()) != "message")
-        return;
-
-    const auto data = root.find("data");
     try {
-        m_cap->on_message(data == root.end()
+        m_cap->on_message(data.dump(-1, ' ', false, nlohmann::json::error_handler_t::replace));
-                              ? "null"
-                              : data->dump(-1, ' ', false, nlohmann::json::error_handler_t::replace));
     } catch (const std::exception& error) {
         BOOST_LOG_TRIVIAL(error) << "Plugin page message handler failed for '" << m_cap->name() << "': " << error.what();
     } catch (...) {
         BOOST_LOG_TRIVIAL(error) << "Plugin page message handler failed for '" << m_cap->name() << "'";
     }
+    return true;
 }
 
 void PluginPage::push_message(const std::string& message)
 {
-    if (m_browser == nullptr)
-        return;
-
     // PagesPluginCapability::post_message() already dumps JSON, so accept it as-is; only a
     // non-JSON payload needs wrapping as a string literal.
-    const std::string payload = nlohmann::json::accept(message)
+    post_to_page(nlohmann::json::accept(message)
                      ? message
-                                    : nlohmann::json(message).dump(-1, ' ', false, nlohmann::json::error_handler_t::replace);
+                     : nlohmann::json(message).dump(-1, ' ', false, nlohmann::json::error_handler_t::replace));
-
-    WebView::RunScript(m_browser, wxString::Format(
-        "(function dispatch(payload, attempts) {\n"
-        "  if (typeof window.__orcaDispatch === 'function') { window.__orcaDispatch(payload); return; }\n"
-        "  if (attempts < 100) window.setTimeout(function() { dispatch(payload, attempts + 1); }, 25);\n"
-        "})({data: %s}, 0);",
-        wxString::FromUTF8(payload)));
 }
 
 PluginPages::~PluginPages()
@@ -268,10 +212,6 @@ bool PluginPages::create_page(const PluginCapabilityId& id)
     }
 
     auto* page = new PluginPage(m_parent, std::move(capability));
-    if (!page->is_valid()) {
-        page->Destroy();
-        return false;
-    }
 
     if (!icon.empty()) {
         try {

src/slic3r/plugin/host/PluginPages.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <slic3r/GUI/PluginWebPanel.hpp>
 #include <slic3r/plugin/PythonPluginInterface.hpp>
 #include <slic3r/plugin/pluginTypes/pages/PagesPluginCapability.hpp>
 
@@ -11,14 +12,13 @@
 #include <vector>
 
 #include <wx/bitmap.h>
-#include <wx/panel.h>
 #include <wx/webview.h>
 
 class Notebook;
 
 namespace Slic3r {
 
-class PluginPage : public wxPanel
+class PluginPage : public GUI::PluginWebPanel
 {
 public:
     PluginPage(wxWindow* parent, std::shared_ptr<PagesPluginCapability> capability);
@@ -26,24 +26,20 @@ public:
 
     PluginPage() = delete;
 
-    bool is_valid() const { return m_browser != nullptr && m_cap != nullptr; }
     void detach_capability();
-    void on_bootstrap_event(wxWebViewEvent& event);
-    void on_new_window(wxWebViewEvent& event);
-    void on_script_message(wxWebViewEvent& event);
     void push_message(const std::string& message);
     void set_icon(const wxBitmap& icon) { m_icon = icon; }
     const wxBitmap& icon() const { return m_icon; }
 
+protected:
+    std::optional<std::string> page_html() override;
+    bool on_page_message(const std::string& kind, const nlohmann::json& data) override;
+
 private:
-    void load_plugin_content();
+    void on_new_window(wxWebViewEvent& event);
-    wxString bootstrap_url() const;
-    wxString web_base_url() const;
 
-    wxWebView* m_browser{nullptr};
     std::shared_ptr<PagesPluginCapability> m_cap;
     std::shared_ptr<std::atomic<PluginPage*>> m_lifetime;
-    bool m_content_loaded{false};
     wxBitmap m_icon;
 };
 

tests/slic3rutils/test_plugin_host_api.cpp

@@ -3,8 +3,12 @@
 #include <libslic3r/Model.hpp>
 #include <libslic3r/PresetBundle.hpp>
 #include <libslic3r/TriangleMesh.hpp>
+#include <slic3r/GUI/PluginDockPanel.hpp>
+#include <slic3r/GUI/Widgets/AuiPaneLayout.hpp>
+#include <slic3r/GUI/Widgets/PluginWebContent.hpp>
 #include <slic3r/plugin/PythonPluginBridge.hpp>
 
+#include "plugin_test_utils.hpp"
 #include "python_test_support.hpp"
 
 #include <pybind11/embed.h>
@@ -141,6 +145,8 @@ TEST_CASE("Plugin host API exposes the UI module and guards it before Orca app i
     CHECK(ui.attr("WINDOW_MODELESS").cast<long>() == 0);
     CHECK(ui.attr("WINDOW_MODAL").cast<long>() == 1);
     CHECK(has_attr(ui, "UiWindow"));
+    CHECK(has_attr(ui, "create_dock_panel"));
+    CHECK(has_attr(ui, "UiDockPanel"));
 
     // With no wx application the UI calls marshal to a main thread that does not
     // exist here; they must fail cleanly with a clear error, not crash.
@@ -151,6 +157,75 @@ TEST_CASE("Plugin host API exposes the UI module and guards it before Orca app i
         CHECK(error.matches(PyExc_RuntimeError));
         CHECK(std::string(error.what()).find("OrcaSlicer application is not initialized") != std::string::npos);
     }
+
+    try {
+        ui.attr("create_dock_panel")("<p>panel</p>");
+        FAIL("orca.host.ui.create_dock_panel unexpectedly succeeded without a wx application");
+    } catch (const py::error_already_set& error) {
+        CHECK(error.matches(PyExc_RuntimeError));
+        CHECK(std::string(error.what()).find("OrcaSlicer application is not initialized") != std::string::npos);
+    }
+
+    // Positional arguments follow create_window(): width and height come straight after the title.
+    try {
+        ui.attr("create_dock_panel")("<p>panel</p>", "Panel", 400, 300);
+        FAIL("orca.host.ui.create_dock_panel unexpectedly succeeded without a wx application");
+    } catch (const py::error_already_set& error) {
+        CHECK(error.matches(PyExc_RuntimeError));
+    }
+
+    // An unknown dock position is rejected before the application is needed.
+    try {
+        ui.attr("create_dock_panel")("<p>panel</p>", py::arg("dock") = "top");
+        FAIL("orca.host.ui.create_dock_panel accepted an unknown dock position");
+    } catch (const py::error_already_set& error) {
+        CHECK(error.matches(PyExc_ValueError));
+    }
+}
+
+TEST_CASE("Plugin pane names identify the plugin and title without layout delimiters", "[PluginHost]")
+{
+    using Slic3r::GUI::plugin_pane_name;
+
+    CHECK(plugin_pane_name("dock_demo", "Scene") == "plugin:dock_demo:Scene");
+    CHECK(plugin_pane_name("key", "a|b;c=d\\e").find_first_of("|;=\\") == std::string::npos);
+}
+
+TEST_CASE("A pane's saved layout entry is found by pane name", "[PluginHost]")
+{
+    using Slic3r::GUI::aui_pane_layout_entry;
+
+    const std::string sidebar = "name=sidebar;caption=;state=2099196;dir=4;layer=0;row=0;pos=0;bestw=390;besth=900";
+    // The caption holds an escaped '|', which must not end the entry.
+    const std::string plugin  = "name=plugin:demo:Scene;caption=Scene \\| stats;state=2099198;dir=2;layer=0;row=1;pos=0;bestw=320;besth=480";
+    const std::string layout  = "layout3|" + sidebar + "|" + plugin + "|dock_size(4,0,0)=392|";
+
+    CHECK(aui_pane_layout_entry(layout, "plugin:demo:Scene") == plugin);
+    CHECK(aui_pane_layout_entry(layout, "sidebar") == sidebar);
+    CHECK(aui_pane_layout_entry(layout, "plugin:demo").empty());
+    CHECK(aui_pane_layout_entry("", "plugin:demo:Scene").empty());
+}
+
+TEST_CASE("A reloaded plugin page is recognised by its base URL, fragment aside", "[PluginHost]")
+{
+    using namespace Slic3r::GUI::plugin_web;
+
+    // A resources path holding a space, which the web view reports escaped.
+    const Slic3r::ScopedResourcesDir resources("web content check");
+
+    // What a plugin page reports after the host swapped it in, and after the page moved to an
+    // anchor within it and the user reloaded.
+    CHECK(is_content_url(content_base_url()));
+    CHECK(is_content_url(content_base_url() + "#tab2"));
+    wxString escaped = content_base_url();
+    escaped.Replace(" ", "%20");
+    REQUIRE(escaped != content_base_url());
+    CHECK(is_content_url(escaped));
+    CHECK(is_content_url(escaped + "#tab2"));
+    // A page the plugin linked to keeps its own URL and must be left alone.
+    CHECK_FALSE(is_content_url(content_base_url() + "guide.html"));
+    CHECK_FALSE(is_content_url("https://example.com/"));
+    CHECK_FALSE(is_content_url(""));
 }
 
 TEST_CASE("Plugin host API exposes model geometry and structure to Python", "[PluginHost][Python]")