Offer the Sliced Objects as a Solid Model While Dragging

The G-code preview draws every toolpath segment as an instanced box, and its frame cost is
linear in the number of segments drawn. On a plate of large objects that is enough that
dragging the camera or a preview slider cannot keep up, and no amount of per-segment work
changes that; only drawing fewer segments does.

The objects themselves are cheaper: a mesh costs its triangles once, however many layers it
has, and the preview already loads the objects as shells for its translucent ghost. A new
preference, "Only render solid model when dragging" (off by default), draws those shells
opaque in their filament colours instead of the toolpaths while the user drags.

The visible layer range still holds. The shells are cut at the range's top and bottom through
the gouraud shader's z range, and libvgcode keeps a second index buffer holding just the
range's bottom and top layers, filled in the same walk as the full one, which is drawn
afterwards so that it caps the cut with what was really printed there. Switching between the
two sets is a buffer binding, never a rebuild. The prime tower is added to the shells from its
sliced mesh while the preference is on, positioned as the print placed it; it keeps its opaque
colour and so stays out of the translucent ghost. Supports have no mesh and are not shown.

Dragging is the camera, the navigator or either slider being held; a slider reports it from
ImGui's active id, since its dirty flag is raised and consumed inside one frame. A wheel step
holds the solid model for a 150 ms settle time, with the frame that restores the toolpaths
scheduled for when it runs out. The switch is decided at the top of the frame, before the
cached scene is consulted, and a frame that switches redraws the scene. A drag cut short by
focus or capture loss is ended explicitly, and a button release wakes the idle loop, since on
some platforms no idle event follows it until the next input.

With the preference off, nothing is built and the preview is unchanged.

.claude/skills/orca-profiles/SKILL.md

@@ -58,9 +58,6 @@ Paths below are relative to this skill. Commands run from the repository root.
 9. **Run the full profile checks before reporting completion.** A vendor-scoped pass is only a
    development loop. Review also covers version bumps, assets, non-default processes and hardware
    tuning that CI cannot establish.
-10. **One all-printer preset per product; color is a runtime property, never a preset.** Never ship
-    presets that differ only by color — CI accepts them, so this is a review call. See
-    [color is a runtime property](references/filament-profiles.md#color-is-a-runtime-property).
 
 ## Creating or modifying a profile
 
@@ -110,7 +107,6 @@ Paths below are relative to this skill. Commands run from the repository root.
 | A setting has no effect | Key spelling/type, `handle_legacy`, or a config key placed on a `machine_model` |
 | A preset exists but is not selectable | Index registration, `instantiation`, installation and compatibility |
 | A filament is missing, duplicated, or matches the wrong spool | [Compatibility and alias shadowing](references/filament-profiles.md#compatible_printers); [ids](references/ids.md) |
-| Presets differ only by color, or an all-printer library preset lacks `@System` | [Color is a runtime property](references/filament-profiles.md#color-is-a-runtime-property) |
 | A bed temperature is ignored | [Plate-specific temperature keys](references/filament-profiles.md#bed-temperature-is-twelve-keys-not-one) |
 | A change is absent from the running app | Version bump and [installed profile location](references/validation.md#testing-in-the-app) |
 | A check fails | [Error → remedy](references/validation.md#error--remedy) |

.claude/skills/orca-profiles/references/filament-profiles.md

@@ -52,15 +52,6 @@ a brand means adding a folder here; the folder name is a directory label only
   collection, so there is no duplicate-name error.
 - You may inherit from an instantiated preset as well as from a base; it is common.
 
-## Color is a runtime property
-
-`filament_id` identifies a product, not a color; filament sync/AMS reads the color from the spool at
-runtime. A product ships one all-printer preset and the color is chosen at runtime — never a sibling
-preset that differs only by color. A material family (PLA vs PLA Matte vs PLA Silk) is a new product; a
-color is not. A printer tune keeps the product alias and does not multiply per color either.
-
-CI does not catch this — per-color presets pass `check` — so it is a review call.
-
 ## The two most common contributions
 
 **A printer vendor tuning a generic.** Keep the `Generic X` base name so the alias shadows the library

.claude/skills/orca-profiles/references/naming.md

@@ -46,17 +46,12 @@ to the first `@`; the target half is a label except for reserved forms:
 
 - `@base` — a non-instantiated product root. `@base` is convention; a base is really identified by
   `instantiation: "false"` and no `setting_id` ([the three-part shape](filament-profiles.md#the-three-part-shape)).
-- `@System` — the OrcaFilamentLibrary selectable shim, and the convention for an all-printer product
-  (`<Product> @System`, empty `compatible_printers`); not enforced, so a deviation is worth a review
-  comment. The literal `Generic <mat> @System` is load-bearing for 3MF/project recovery, beyond the
-  alias rule ([alias shadowing](filament-profiles.md#alias-shadowing)).
+- `@System` — the OrcaFilamentLibrary selectable shim. The literal `Generic <mat> @System` is
+  load-bearing for 3MF/project recovery, beyond the alias rule ([alias shadowing](filament-profiles.md#alias-shadowing)).
 - `@<Vendor>`, `@<Vendor> <Model>`, `@<Vendor> <Model> <nozzle> nozzle` — printer tunes, BBL's shape.
   Other vendors differ (a bare model, a printer serial, Creality's `@<Model>-all`). Specificity is judged
   from `compatible_printers`, not the name
   ([one variant, one profile](filament-profiles.md#overlapping-coverage-one-variant-one-profile-per-product)).
-- Color is not part of the product name: `<Product> <Color>` presets are not authored; the color is
-  chosen at runtime
-  ([color is a runtime property](filament-profiles.md#color-is-a-runtime-property)).
 
 ## Not the same as the filename
 

.claude/skills/orca-profiles/references/review-checklist.md

@@ -15,7 +15,6 @@ The table highlights gaps that need human review. What CI *does* run:
 | Whether the intended default survived compatibility selection | The sweep can select a different compatible preset |
 | A dangling `compatible_printers` inside an `instantiation: "false"` base | A base never becomes a `Preset`, so the reference check never sees it (a bad `inherits` in a base *is* caught) |
 | A `renamed_from` whose old name is still a live preset | The redirect is inert while a live preset carries that name |
-| A preset differentiated only by color, or an all-printer library preset without `@System` | Per-color presets split one product across ids and the selector fills with near-duplicates; CI stays green |
 | Per-extruder vector length on a multi-nozzle printer | Silently padded (with the **first** value) or truncated |
 
 ## 1. Was the vendor `version` bumped?

docs/HLSD/gcode-preview-dragging.md

@@ -0,0 +1,62 @@
+# G-code preview while dragging
+
+The sliced preview draws every toolpath segment of the plate as an instanced box. On a large
+plate that is tens of millions of segments, and the frame is GPU-bound: the cost is the number of
+instances drawn, not anything the CPU does per frame. Dragging the camera over such a plate cannot
+keep up. With the `preview_solid_model_while_dragging` preference (*Graphics > G-code Preview*,
+off by default), the preview draws the sliced objects as solid meshes while the user drags and
+puts the toolpaths back when they let go. A mesh costs its triangles once, however many layers it
+has.
+
+`GCodeViewer` draws the solid model, libvgcode (`src/libvgcode`) keeps the toolpaths that cap it,
+and `GLCanvas3D` decides when the user is dragging. The OpenGL ES path ignores the preference.
+
+## The solid model
+
+The preview already loads the sliced objects as shells for its translucent ghost.
+`GCodeViewer::render_solid_model()` draws those shells opaque, in their filament colours, with the
+`gouraud` shader, whose z range cuts them to the visible layer range. The shells hold only the
+objects, so while the preference is on the prime tower is added from its sliced mesh, positioned
+as the print placed it. It is added or removed on its own when the preference changes, without
+reloading the objects, keeps its opaque colour so that it never appears among the translucent
+shells, and stays out of their bounding box. Supports have no mesh and are not shown.
+
+A plate whose shells are not loaded keeps drawing toolpaths, since the solid model would leave
+only the end layers.
+
+## End-layer set
+
+The cut faces of the solid model are capped with what was really printed there: the toolpaths of
+the bottom and top layers of the visible range. While the preference is on,
+`ViewerImpl::update_enabled_entities()` fills a second, **reduced** index buffer holding just those
+two layers, in the same walk that fills the full one. Building both together is what makes
+switching free: starting or ending a drag is a buffer binding, never a rebuild.
+
+## Deciding that the user is dragging
+
+`GLCanvas3D::_update_preview_interaction()` runs at the top of every preview frame, before the
+canvas decides whether to reuse its cached scene, so that the switch lands in that frame. Dragging
+is the camera, the navigator or either slider being held; a slider reports this from ImGui's active
+id rather than its dirty flag, which is raised and consumed inside one frame. A wheel step has no
+duration, so it holds the solid model for a 150 ms settle time instead, and the frame that restores
+the toolpaths is scheduled for when that time runs out, since the render timer only wakes the idle
+loop. A drag cut short by focus or capture loss is ended explicitly, and a button release wakes the
+idle loop, because on some platforms nothing else would until the next input.
+
+## Reused scene frames
+
+`GLCanvas3D` keeps its last scene pass for frames that only rebuild the overlay (`SceneCache`). Its
+key covers the canvas size, the camera and hover state, not what the toolpath sets draw, so a frame
+that reuses the scene must never be one on which the solid model is switched.
+`_update_preview_interaction()` therefore reports whether the bound set changed, and a frame on
+which it did redraws the scene. The canvas neither captures nor reuses the scene while the user
+drags, so no solid-model frame outlives a drag, and the frame that ends a wheel's settle time is
+requested as a full frame.
+
+## Per-frame lookups
+
+The segment template draws its box from 8 corners through an index buffer, so the vertex shader
+runs at most once per corner. `get_estimated_time_at()`, which the tool marker tooltip calls every
+frame, starts from the running time at the first vertex of the vertex's layer, kept per layer at
+load, and adds only that layer's vertices. The sum runs in vertex order, so it matches a full
+accumulation exactly while costing memory per layer rather than per vertex.

resources/web/dialog/PluginWebDialog/blank.html

@@ -1,5 +1,5 @@
 <!DOCTYPE html>
-<!-- Bootstrap page for WebDialog. The real plugin HTML is loaded via
+<!-- Bootstrap page for PluginWebDialog. The real plugin HTML is loaded via
      wxWebView::SetPage once this page finishes loading; this file only exists
      to bring the webview up. -->
 <html>

sandboxes/orca_dock_panel_plugin_any.py

@@ -1,146 +0,0 @@
-# /// 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/libslic3r/AppConfig.cpp

@@ -205,6 +205,10 @@ void AppConfig::set_defaults()
     if (get("seq_top_layer_only").empty())
         set("seq_top_layer_only", "1");
 
+    // draw the sliced objects instead of their toolpaths while the user drags the preview
+    if (get("preview_solid_model_while_dragging").empty())
+        set_bool("preview_solid_model_while_dragging", false);
+
     // ORCA: darken the layers the preview layer slider is not scrubbed to
     if (get("preview_dim_previous_layers").empty())
         set_bool("preview_dim_previous_layers", false);

src/libvgcode/include/Viewer.hpp

@@ -98,6 +98,15 @@ public:
     //
     bool is_dim_previous_layers() const;
     void set_dim_previous_layers(bool value);
+    //
+    // The reduced set holds only the bottom and top layers of the visible range, for a caller that
+    // draws the print itself some other way while the user drags. While enabled it is built
+    // alongside the full set, so set_reduced_detail() rebuilds nothing. Ignored on the OpenGL ES path.
+    //
+    void set_reduced_detail_enabled(bool value);
+    bool is_reduced_detail_enabled() const;
+    void set_reduced_detail(bool value);
+    bool is_reduced_detail() const;
     float get_dim_previous_layers_brightness() const;
     void set_dim_previous_layers_brightness(float value);
     //

src/libvgcode/src/SegmentTemplate.cpp

@@ -15,7 +15,12 @@ namespace libvgcode {
 //|   2--0-------5--7   |
 //|    \ |       | /    |
 //|      3-------4      | 
-static constexpr const std::array<uint8_t, 24> VERTEX_DATA = {
+// The eight corners the vertex shader knows how to place. Each is sent once and
+// referenced by INDEX_DATA below, so the post-transform cache can reuse it across
+// the triangles that share it: the shader runs 8 times per segment instead of 24.
+static constexpr const std::array<uint8_t, 8> VERTEX_DATA = { 0, 1, 2, 3, 4, 5, 6, 7 };
+
+static constexpr const std::array<uint8_t, 24> INDEX_DATA = {
     0, 1, 2, // front spike
     0, 2, 3, // front spike
     0, 3, 4, // right/bottom body 
@@ -31,7 +36,7 @@ void SegmentTemplate::init()
     if (m_vao_id != 0)
         return;
 
-    m_size_in_bytes_gpu += VERTEX_DATA.size() * sizeof(uint8_t);
+    m_size_in_bytes_gpu += (VERTEX_DATA.size() + INDEX_DATA.size()) * sizeof(uint8_t);
 
     int curr_vertex_array;
     glsafe(glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &curr_vertex_array));
@@ -51,12 +56,22 @@ void SegmentTemplate::init()
     glsafe(glVertexAttribIPointer(0, 1, GL_UNSIGNED_BYTE, 0, (const void*)0));
 #endif // ENABLE_OPENGL_ES
 
+    // The element buffer binding is part of the vao state, so it is left bound here
+    // and restored together with the vao.
+    glsafe(glGenBuffers(1, &m_ibo_id));
+    glsafe(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ibo_id));
+    glsafe(glBufferData(GL_ELEMENT_ARRAY_BUFFER, INDEX_DATA.size() * sizeof(uint8_t), INDEX_DATA.data(), GL_STATIC_DRAW));
+
     glsafe(glBindBuffer(GL_ARRAY_BUFFER, curr_array_buffer));
     glsafe(glBindVertexArray(curr_vertex_array));
 }
 
 void SegmentTemplate::shutdown()
 {
+    if (m_ibo_id != 0) {
+        glsafe(glDeleteBuffers(1, &m_ibo_id));
+        m_ibo_id = 0;
+    }
     if (m_vbo_id != 0) {
         glsafe(glDeleteBuffers(1, &m_vbo_id));
         m_vbo_id = 0;
@@ -71,14 +86,15 @@ void SegmentTemplate::shutdown()
 
 void SegmentTemplate::render(size_t count)
 {
-    if (m_vao_id == 0 || m_vbo_id == 0 || count == 0)
+    if (m_vao_id == 0 || m_vbo_id == 0 || m_ibo_id == 0 || count == 0)
         return;
 
     int curr_vertex_array;
     glsafe(glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &curr_vertex_array));
 
     glsafe(glBindVertexArray(m_vao_id));
-    glsafe(glDrawArraysInstanced(GL_TRIANGLES, 0, static_cast<GLsizei>(VERTEX_DATA.size()), static_cast<GLsizei>(count)));
+    glsafe(glDrawElementsInstanced(GL_TRIANGLES, static_cast<GLsizei>(INDEX_DATA.size()), GL_UNSIGNED_BYTE,
+                                   nullptr, static_cast<GLsizei>(count)));
     glsafe(glBindVertexArray(curr_vertex_array));
 }
 

src/libvgcode/src/SegmentTemplate.hpp

@@ -40,6 +40,7 @@ private:
     //
     unsigned int m_vao_id{ 0 };
     unsigned int m_vbo_id{ 0 };
+    unsigned int m_ibo_id{ 0 };
     //
     // Size of the data sent to gpu, in bytes.
     //

src/libvgcode/src/Settings.hpp

@@ -25,6 +25,10 @@ struct Settings
 		// ORCA: how bright those darkened layers are rendered, 1.0 = unchanged, 0.0 = black
 		float dim_previous_layers_brightness{ 0.4f };
 		bool spiral_vase_mode{ false };
+		// whether the reduced set (the visible range's end layers) is built, and whether it is drawn.
+		// Ignored on the OpenGL ES path.
+		bool reduced_detail_enabled{ false };
+		bool reduced_detail{ false };
 		//
 		// Required update flags
 		//

src/libvgcode/src/Viewer.cpp

@@ -77,6 +77,26 @@ bool Viewer::is_dim_previous_layers() const
     return m_impl->is_dim_previous_layers();
 }
 
+void Viewer::set_reduced_detail(bool value)
+{
+    m_impl->set_reduced_detail(value);
+}
+
+bool Viewer::is_reduced_detail() const
+{
+    return m_impl->is_reduced_detail();
+}
+
+void Viewer::set_reduced_detail_enabled(bool value)
+{
+    m_impl->set_reduced_detail_enabled(value);
+}
+
+bool Viewer::is_reduced_detail_enabled() const
+{
+    return m_impl->is_reduced_detail_enabled();
+}
+
 void Viewer::set_dim_previous_layers(bool value)
 {
     m_impl->set_dim_previous_layers(value);

src/libvgcode/src/ViewerImpl.cpp

@@ -875,6 +875,12 @@ void ViewerImpl::reset()
     m_travels_time = { 0.0f, 0.0f };
     m_vertices.clear();
     m_vertices_colors.clear();
+    // swap rather than clear: these are sized by the print, and a reset means the memory
+    // should go back, not sit reserved until the next load
+    for (std::vector<float>& times : m_layer_start_times)
+        std::vector<float>().swap(times);
+    std::vector<uint32_t>().swap(m_layer_first_vertex);
+    std::vector<float>().swap(m_colors_scratch);
     m_valid_lines_bitset.clear();
 #if VGCODE_ENABLE_COG_AND_TOOL_MARKERS
     m_cog_marker.reset();
@@ -885,9 +891,15 @@ void ViewerImpl::reset()
 #else
     m_enabled_segments_count = 0;
     m_enabled_options_count = 0;
+    m_enabled_segments_reduced_count = 0;
+    m_enabled_options_reduced_count = 0;
 
     m_settings_used_for_ranges = std::nullopt;
 
+    delete_textures(m_enabled_options_reduced_tex_id);
+    delete_buffers(m_enabled_options_reduced_buf_id);
+    delete_textures(m_enabled_segments_reduced_tex_id);
+    delete_buffers(m_enabled_segments_reduced_buf_id);
     delete_textures(m_enabled_options_tex_id);
     delete_buffers(m_enabled_options_buf_id);
     delete_textures(m_enabled_segments_tex_id);
@@ -1048,6 +1060,37 @@ void ViewerImpl::load(GCodeInputData&& gcode_data)
         v.layer_duration = m_layers.get_layer_time(m_settings.time_mode, static_cast<size_t>(v.layer_id));
     }
 
+    // Index of the first vertex of each layer, walked back to front so that a layer with no
+    // vertex of its own inherits the next layer's index and the array stays non-decreasing.
+    if (!m_layers.empty()) {
+        const uint32_t vertices_count = static_cast<uint32_t>(m_vertices.size());
+        m_layer_first_vertex.assign(m_layers.count(), vertices_count);
+        for (uint32_t i = vertices_count; i > 0; --i) {
+            const uint32_t layer_id = m_vertices[i - 1].layer_id;
+            if (layer_id < m_layer_first_vertex.size())
+                m_layer_first_vertex[layer_id] = i - 1;
+        }
+        for (size_t i = m_layer_first_vertex.size() - 1; i > 0; --i)
+            m_layer_first_vertex[i - 1] = std::min(m_layer_first_vertex[i - 1], m_layer_first_vertex[i]);
+
+        // the running time at each layer's first vertex, summed in vertex order so that
+        // get_estimated_time_at() matches a full accumulation exactly
+        std::array<float, TIME_MODES_COUNT> running{};
+        for (std::vector<float>& times : m_layer_start_times)
+            times.assign(m_layer_first_vertex.size(), 0.0f);
+        size_t layer = 0;
+        for (size_t i = 0; i <= m_vertices.size(); ++i) {
+            for (; layer < m_layer_first_vertex.size() && m_layer_first_vertex[layer] == i; ++layer) {
+                for (size_t j = 0; j < TIME_MODES_COUNT; ++j)
+                    m_layer_start_times[j][layer] = running[j];
+            }
+            if (i < m_vertices.size()) {
+                for (size_t j = 0; j < TIME_MODES_COUNT; ++j)
+                    running[j] += m_vertices[i].times[j];
+            }
+        }
+    }
+
     if (!m_layers.empty())
         m_layers.set_view_range(0, static_cast<uint32_t>(m_layers.count()) - 1);
 
@@ -1116,6 +1159,17 @@ void ViewerImpl::load(GCodeInputData&& gcode_data)
         glsafe(glGenTextures(1, &m_enabled_options_tex_id));
         glsafe(glBindTexture(GL_TEXTURE_BUFFER, m_enabled_options_tex_id));
 
+        // create (but do not fill) the reduced counterparts of the two buffers above
+        glsafe(glGenBuffers(1, &m_enabled_segments_reduced_buf_id));
+        glsafe(glBindBuffer(GL_TEXTURE_BUFFER, m_enabled_segments_reduced_buf_id));
+        glsafe(glGenTextures(1, &m_enabled_segments_reduced_tex_id));
+        glsafe(glBindTexture(GL_TEXTURE_BUFFER, m_enabled_segments_reduced_tex_id));
+
+        glsafe(glGenBuffers(1, &m_enabled_options_reduced_buf_id));
+        glsafe(glBindBuffer(GL_TEXTURE_BUFFER, m_enabled_options_reduced_buf_id));
+        glsafe(glGenTextures(1, &m_enabled_options_reduced_tex_id));
+        glsafe(glBindTexture(GL_TEXTURE_BUFFER, m_enabled_options_reduced_tex_id));
+
         glsafe(glBindBuffer(GL_TEXTURE_BUFFER, 0));
         glsafe(glBindTexture(GL_TEXTURE_BUFFER, old_bound_texture));
 #endif // ENABLE_OPENGL_ES
@@ -1134,6 +1188,14 @@ void ViewerImpl::update_enabled_entities()
 
     std::vector<uint32_t> enabled_segments;
     std::vector<uint32_t> enabled_options;
+#ifndef ENABLE_OPENGL_ES
+    // the reduced set is filled by the same walk, so switching to it costs no rebuild. It keeps the
+    // bottom and top layers of the visible range: the surfaces the range cuts open
+    const bool build_reduced = m_settings.reduced_detail_enabled;
+    std::vector<uint32_t> enabled_segments_reduced;
+    std::vector<uint32_t> enabled_options_reduced;
+    const Interval& layers_range = m_layers.get_view_range();
+#endif // ENABLE_OPENGL_ES
     Interval range = m_view_range.get_visible();
 
     // when top layer only visualization is enabled, we need to render
@@ -1181,6 +1243,11 @@ void ViewerImpl::update_enabled_entities()
             enabled_options.push_back(static_cast<uint32_t>(i));
         else
             enabled_segments.push_back(static_cast<uint32_t>(i));
+
+#ifndef ENABLE_OPENGL_ES
+        if (build_reduced && (v.layer_id == layers_range[0] || v.layer_id == layers_range[1]))
+            (v.is_option() ? enabled_options_reduced : enabled_segments_reduced).push_back(static_cast<uint32_t>(i));
+#endif // ENABLE_OPENGL_ES
     }
 
 #ifdef ENABLE_OPENGL_ES
@@ -1209,6 +1276,21 @@ void ViewerImpl::update_enabled_entities()
     else
         glsafe(glBufferData(GL_TEXTURE_BUFFER, 0, nullptr, GL_STATIC_DRAW));
 
+    m_enabled_segments_reduced_count = enabled_segments_reduced.size();
+    m_enabled_options_reduced_count = enabled_options_reduced.size();
+
+    if (build_reduced) {
+        assert(m_enabled_segments_reduced_buf_id > 0);
+        glsafe(glBindBuffer(GL_TEXTURE_BUFFER, m_enabled_segments_reduced_buf_id));
+        glsafe(glBufferData(GL_TEXTURE_BUFFER, enabled_segments_reduced.size() * sizeof(uint32_t),
+                            enabled_segments_reduced.empty() ? nullptr : enabled_segments_reduced.data(), GL_STATIC_DRAW));
+
+        assert(m_enabled_options_reduced_buf_id > 0);
+        glsafe(glBindBuffer(GL_TEXTURE_BUFFER, m_enabled_options_reduced_buf_id));
+        glsafe(glBufferData(GL_TEXTURE_BUFFER, enabled_options_reduced.size() * sizeof(uint32_t),
+                            enabled_options_reduced.empty() ? nullptr : enabled_options_reduced.data(), GL_STATIC_DRAW));
+    }
+
     glsafe(glBindBuffer(GL_TEXTURE_BUFFER, 0));
 #endif // ENABLE_OPENGL_ES
 
@@ -1261,7 +1343,10 @@ void ViewerImpl::update_colors_texture()
 
     // Based on current settings and slider position, we might want to render some
     // vertices as dark grey (or darkened, see above). Use either that or the normal color (from the cache).
-    std::vector<float> colors(m_vertices_colors.size());
+    // Reused across calls: this runs on every slider tick, and the allocation alone is
+    // 4 bytes per vertex of the whole print each time.
+    std::vector<float>& colors = m_colors_scratch;
+    colors.resize(m_vertices_colors.size());
     assert(colors.size() == m_vertices.size() && m_vertices_colors.size() == m_vertices.size());
     for (size_t i=0; i<m_vertices.size(); ++i) {
         const PathVertex& v = m_vertices[i];
@@ -1384,6 +1469,14 @@ void ViewerImpl::toggle_top_layer_only_view_range()
     update_colors_texture();
 }
 
+void ViewerImpl::set_reduced_detail_enabled(bool value)
+{
+    if (m_settings.reduced_detail_enabled == value)
+        return;
+    m_settings.reduced_detail_enabled = value;
+    m_settings.update_enabled_entities = true;
+}
+
 // ORCA: enable/disable darkening of the layers the layer slider is not scrubbed to
 void ViewerImpl::set_dim_previous_layers(bool value)
 {
@@ -1516,8 +1609,19 @@ void ViewerImpl::set_view_visible_range(Interval::value_type min, Interval::valu
 
 float ViewerImpl::get_estimated_time_at(size_t id) const
 {
-    return std::accumulate(m_vertices.begin(), m_vertices.begin() + id + 1, 0.0f, 
-        [this](float a, const PathVertex& v) { return a + v.times[static_cast<size_t>(m_settings.time_mode)]; });
+    const size_t mode = static_cast<size_t>(m_settings.time_mode);
+    if (mode >= TIME_MODES_COUNT || id >= m_vertices.size())
+        return 0.0f;
+    size_t first = 0;
+    float time = 0.0f;
+    const size_t layer = static_cast<size_t>(m_vertices[id].layer_id);
+    if (layer < m_layer_first_vertex.size() && m_layer_first_vertex[layer] <= id) {
+        first = m_layer_first_vertex[layer];
+        time = m_layer_start_times[mode][layer];
+    }
+    for (size_t i = first; i <= id; ++i)
+        time += m_vertices[i].times[mode];
+    return time;
 }
 
 Color ViewerImpl::get_vertex_color(const PathVertex& v) const
@@ -1722,6 +1826,10 @@ size_t ViewerImpl::get_used_cpu_memory() const
     ret += sizeof(m_extrusion_roles_colors);
     ret += sizeof(m_options_colors);
     ret += STDVEC_MEMSIZE(m_vertices, PathVertex);
+    for (const std::vector<float>& times : m_layer_start_times)
+        ret += STDVEC_MEMSIZE(times, float);
+    ret += STDVEC_MEMSIZE(m_layer_first_vertex, uint32_t);
+    ret += STDVEC_MEMSIZE(m_colors_scratch, float);
     ret += m_valid_lines_bitset.size_in_bytes_cpu();
     ret += m_height_range.size_in_bytes_cpu();
     ret += m_width_range.size_in_bytes_cpu();
@@ -1787,7 +1895,11 @@ void ViewerImpl::update_view_full_range()
     const bool travels_visible = m_settings.options_visibility[size_t(EOptionType::Travels)];
     const bool wipes_visible   = m_settings.options_visibility[size_t(EOptionType::Wipes)];
 
+    // every vertex before m_layer_first_vertex[layers_range[0]] has a smaller layer_id, so the loop
+    // below would skip all of them anyway
     auto first_it = m_vertices.begin();
+    if (layers_range[0] < m_layer_first_vertex.size())
+        first_it += m_layer_first_vertex[layers_range[0]];
     while (first_it != m_vertices.end() &&
            (first_it->layer_id < layers_range[0] || !is_visible(*first_it, m_settings))) {
         ++first_it;
@@ -1974,7 +2086,8 @@ void ViewerImpl::render_segments(const Mat4x4& view_matrix, const Mat4x4& projec
 #ifdef ENABLE_OPENGL_ES
     if (m_texture_data.get_enabled_segments_count() == 0)
 #else
-    if (m_enabled_segments_count == 0)
+    const ActiveSet segments = active_segments();
+    if (segments.count == 0)
 #endif // ENABLE_OPENGL_ES
         return;
 
@@ -2033,10 +2146,10 @@ void ViewerImpl::render_segments(const Mat4x4& view_matrix, const Mat4x4& projec
     glsafe(glBindTexture(GL_TEXTURE_BUFFER, m_colors_tex_id));
     glsafe(glTexBuffer(GL_TEXTURE_BUFFER, GL_R32F, m_colors_buf_id));
     glsafe(glActiveTexture(GL_TEXTURE3));
-    glsafe(glBindTexture(GL_TEXTURE_BUFFER, m_enabled_segments_tex_id));
-    glsafe(glTexBuffer(GL_TEXTURE_BUFFER, GL_R32UI, m_enabled_segments_buf_id));
+    glsafe(glBindTexture(GL_TEXTURE_BUFFER, segments.tex_id));
+    glsafe(glTexBuffer(GL_TEXTURE_BUFFER, GL_R32UI, segments.buf_id));
 
-    m_segment_template.render(m_enabled_segments_count);
+    m_segment_template.render(segments.count);
 #endif // ENABLE_OPENGL_ES
 
     if (curr_cull_face)
@@ -2062,7 +2175,8 @@ void ViewerImpl::render_options(const Mat4x4& view_matrix, const Mat4x4& project
 #ifdef ENABLE_OPENGL_ES
     if (m_texture_data.get_enabled_options_count() == 0)
 #else
-    if (m_enabled_options_count == 0)
+    const ActiveSet options = active_options();
+    if (options.count == 0)
 #endif // ENABLE_OPENGL_ES
         return;
 
@@ -2120,10 +2234,10 @@ void ViewerImpl::render_options(const Mat4x4& view_matrix, const Mat4x4& project
     glsafe(glBindTexture(GL_TEXTURE_BUFFER, m_colors_tex_id));
     glsafe(glTexBuffer(GL_TEXTURE_BUFFER, GL_R32F, m_colors_buf_id));
     glsafe(glActiveTexture(GL_TEXTURE3));
-    glsafe(glBindTexture(GL_TEXTURE_BUFFER, m_enabled_options_tex_id));
-    glsafe(glTexBuffer(GL_TEXTURE_BUFFER, GL_R32UI, m_enabled_options_buf_id));
+    glsafe(glBindTexture(GL_TEXTURE_BUFFER, options.tex_id));
+    glsafe(glTexBuffer(GL_TEXTURE_BUFFER, GL_R32UI, options.buf_id));
 
-    m_option_template.render(m_enabled_options_count);
+    m_option_template.render(options.count);
 #endif // ENABLE_OPENGL_ES
 
     if (!curr_cull_face)

src/libvgcode/src/ViewerImpl.hpp

@@ -91,6 +91,19 @@ public:
     // 0.0 = black
     bool is_dim_previous_layers() const { return m_settings.dim_previous_layers; }
     void set_dim_previous_layers(bool value);
+    //
+    // Draw from the reduced set; it is already built, so this is just a buffer binding.
+    //
+    void set_reduced_detail(bool value) {
+#ifdef ENABLE_OPENGL_ES
+        // no reduced set is built on OpenGL ES
+        value = false;
+#endif // ENABLE_OPENGL_ES
+        m_settings.reduced_detail = value;
+    }
+    bool is_reduced_detail() const { return m_settings.reduced_detail; }
+    bool is_reduced_detail_enabled() const { return m_settings.reduced_detail_enabled; }
+    void set_reduced_detail_enabled(bool value);
     float get_dim_previous_layers_brightness() const { return m_settings.dim_previous_layers_brightness; }
     void set_dim_previous_layers_brightness(float value);
 
@@ -234,6 +247,20 @@ private:
     //
     std::array<float, TIME_MODES_COUNT> m_total_time{ 0.0f, 0.0f };
     //
+    // Running sum of the vertex estimated times at each layer's first vertex, for each time mode,
+    // so that get_estimated_time_at() only accumulates the vertices of one layer.
+    //
+    std::array<std::vector<float>, TIME_MODES_COUNT> m_layer_start_times;
+    //
+    // For each layer L, the index of the first vertex whose layer_id is >= L (m_vertices.size()
+    // if there is none). Derived from the vertices, so it stays exact whatever order they arrive in.
+    //
+    std::vector<uint32_t> m_layer_first_vertex;
+    //
+    // Scratch buffer for update_colors_texture(), kept alive across slider steps
+    //
+    std::vector<float> m_colors_scratch;
+    //
     // Detected travel moves times
     //
     std::array<float, TIME_MODES_COUNT> m_travels_time{ 0.0f, 0.0f };
@@ -460,6 +487,15 @@ private:
     unsigned int m_enabled_options_tex_id{ 0 };
     size_t m_enabled_options_count{ 0 };
     //
+    // OpenGL buffers to store the reduced set drawn while Settings::reduced_detail is set
+    //
+    unsigned int m_enabled_segments_reduced_buf_id{ 0 };
+    unsigned int m_enabled_segments_reduced_tex_id{ 0 };
+    size_t m_enabled_segments_reduced_count{ 0 };
+    unsigned int m_enabled_options_reduced_buf_id{ 0 };
+    unsigned int m_enabled_options_reduced_tex_id{ 0 };
+    size_t m_enabled_options_reduced_count{ 0 };
+    //
     // Caches for size of data sent to gpu, in bytes
     //
     size_t m_positions_tex_size{ 0 };
@@ -467,6 +503,25 @@ private:
     size_t m_colors_tex_size{ 0 };
     size_t m_enabled_segments_tex_size{ 0 };
     size_t m_enabled_options_tex_size{ 0 };
+
+    // The set the next draw reads from: the reduced one while dragging, if one is built.
+    bool use_reduced_set() const { return m_settings.reduced_detail && m_settings.reduced_detail_enabled; }
+    struct ActiveSet
+    {
+        size_t count{ 0 };
+        unsigned int buf_id{ 0 };
+        unsigned int tex_id{ 0 };
+    };
+    ActiveSet active_segments() const {
+        if (use_reduced_set())
+            return { m_enabled_segments_reduced_count, m_enabled_segments_reduced_buf_id, m_enabled_segments_reduced_tex_id };
+        return { m_enabled_segments_count, m_enabled_segments_buf_id, m_enabled_segments_tex_id };
+    }
+    ActiveSet active_options() const {
+        if (use_reduced_set())
+            return { m_enabled_options_reduced_count, m_enabled_options_reduced_buf_id, m_enabled_options_reduced_tex_id };
+        return { m_enabled_options_count, m_enabled_options_buf_id, m_enabled_options_tex_id };
+    }
 #endif // ENABLE_OPENGL_ES
 
     void update_view_full_range();

src/slic3r/CMakeLists.txt

@@ -139,16 +139,8 @@ set(SLIC3R_GUI_SOURCES
     GUI/TerminalDialog.hpp
     GUI/PluginProgressDialog.cpp
     GUI/PluginProgressDialog.hpp
-    GUI/WebDialog.cpp
-    GUI/WebDialog.hpp
-    GUI/DockPanel.cpp
-    GUI/DockPanel.hpp
-    GUI/WebPanel.cpp
-    GUI/WebPanel.hpp
-    GUI/Widgets/WebHosting.cpp
-    GUI/Widgets/WebHosting.hpp
-    GUI/AuiPaneLayout.cpp
-    GUI/AuiPaneLayout.hpp
+    GUI/PluginWebDialog.cpp
+    GUI/PluginWebDialog.hpp
     GUI/DragCanvas.cpp
     GUI/DragCanvas.hpp
     GUI/EditGCodeDialog.cpp

src/slic3r/GUI/AuiPaneLayout.cpp

@@ -1,20 +0,0 @@
-#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/AuiPaneLayout.hpp

@@ -1,11 +0,0 @@
-#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/DockPanel.cpp

@@ -1,103 +0,0 @@
-#include "DockPanel.hpp"
-
-#include "GUI_App.hpp"
-#include "Plater.hpp"
-#include "Widgets/WebHosting.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;
-}
-
-DockPanel::DockPanel(wxWindow*          parent,
-                     const std::string& html,
-                     MessageHandler     on_message,
-                     CloseHandler       on_close,
-                     CloseHandler       on_destroyed)
-    : WebPanel(parent, web_hosting::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(); });
-}
-
-DockPanel::~DockPanel()
-{
-    if (m_on_destroyed)
-        m_on_destroyed();
-}
-
-bool DockPanel::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 DockPanel::push_message(const nlohmann::json& data)
-{
-    if (!m_closing)
-        post_to_page(data.dump(-1, ' ', false, nlohmann::json::error_handler_t::replace));
-}
-
-void DockPanel::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 DockPanel::request_close()
-{
-    if (m_closing)
-        return;
-    fire_close();
-    // A page-requested close arrives inside the web view's script callback, so destroy later; another
-    // close path may have destroyed the panel by then.
-    wxWeakRef<DockPanel> self(this);
-    CallAfter([self]() {
-        if (self)
-            self->remove_pane();
-    });
-}
-
-void DockPanel::destroy_silently()
-{
-    m_closing  = true;
-    m_on_close = nullptr;
-    remove_pane();
-}
-
-void DockPanel::remove_pane()
-{
-    if (Plater* plater = wxGetApp().plater())
-        plater->remove_dock_pane(this);
-    else
-        Destroy();
-}
-
-}} // namespace Slic3r::GUI

src/slic3r/GUI/DockPanel.hpp

@@ -1,54 +0,0 @@
-#pragma once
-
-#include "WebPanel.hpp"
-
-#include <functional>
-#include <string>
-
-namespace Slic3r { namespace GUI {
-
-// Stable across sessions so the saved layout finds the pane; free of wxAuiManager layout delimiters.
-std::string plugin_pane_name(const std::string& plugin_key, const std::string& title);
-
-// A WebPanel docked in the Plater, on the plugin-window bridge minus submit. It can be destroyed
-// without the GIL, so its hooks must not capture pybind11 objects.
-class DockPanel : public WebPanel
-{
-public:
-    using MessageHandler = std::function<void(const nlohmann::json& data)>;
-    using CloseHandler   = std::function<void()>;
-
-    // on_close fires once, on a user or page close. on_destroyed runs on every destruction and must
-    // touch host-side state only.
-    DockPanel(wxWindow*          parent,
-              const std::string& html,
-              MessageHandler     on_message,
-              CloseHandler       on_close,
-              CloseHandler       on_destroyed);
-    ~DockPanel() 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 on_close, for plugin unload. Destroys at once: unload always comes from
-    // the host, never from this panel's own callbacks.
-    void destroy_silently();
-    // Fires on_close at most once; also run by the pane's own close button.
-    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/GCodeViewer.cpp

@@ -1177,6 +1177,8 @@ void GCodeViewer::load_as_gcode(const GCodeProcessorResult& gcode_result, const
     if (current_top_layer_only != required_top_layer_only)
         m_viewer.toggle_top_layer_only_view_range();
 
+    read_solid_model_preference();
+
     // ORCA: darken the layers the preview layer slider is not scrubbed to
     m_viewer.set_dim_previous_layers(get_app_config()->get_bool("preview_dim_previous_layers"));
     m_viewer.set_dim_previous_layers_brightness(0.01f * std::stoi(get_app_config()->get("preview_dim_previous_layers_brightness")));
@@ -1589,6 +1591,7 @@ void GCodeViewer::reset_shell()
 {
     m_shells.volumes.clear();
     m_shells.print_id = -1;
+    m_shells.with_wipe_tower = false;
     m_shell_bounding_box = BoundingBoxf3();
 }
 
@@ -1625,9 +1628,14 @@ void GCodeViewer::reset()
 void GCodeViewer::render_scene(int canvas_width, int canvas_height)
 {
     glsafe(::glEnable(GL_DEPTH_TEST));
-    render_shells(canvas_width, canvas_height);
+    // while dragging with the solid model on, the objects stand in for their toolpaths, cut to the
+    // visible layer range; the toolpath set then holds only the range's bottom and top layers
+    if (m_viewer.is_reduced_detail())
+        render_solid_model(canvas_width, canvas_height);
+    else
+        render_shells(canvas_width, canvas_height);
 
-    if (m_viewer.get_extrusion_roles().empty())
+    if (m_viewer.get_extrusion_roles_count() == 0)
         return;
 
     render_toolpaths();
@@ -1925,6 +1933,41 @@ void GCodeViewer::update_layers_slider_mode()
     // TODO m_layers_slider->SetModeAndOnlyExtruder(one_extruder_printed_model, only_extruder);
 }
 
+void GCodeViewer::set_interacting(bool interacting)
+{
+    // with no shells to stand in for the toolpaths, the solid model would leave only the end layers
+    m_viewer.set_reduced_detail(m_solid_model_while_dragging && interacting && !m_shells.volumes.empty());
+}
+
+void GCodeViewer::set_solid_model_while_dragging(bool value)
+{
+    const bool was_enabled = m_solid_model_while_dragging;
+    m_solid_model_while_dragging = value;
+    m_viewer.set_reduced_detail_enabled(value);
+    reload_shells_if_solid_model_changed(was_enabled);
+}
+
+void GCodeViewer::read_solid_model_preference()
+{
+    m_solid_model_while_dragging = get_app_config()->get_bool("preview_solid_model_while_dragging");
+    m_viewer.set_reduced_detail_enabled(m_solid_model_while_dragging);
+}
+
+void GCodeViewer::reload_shells_if_solid_model_changed(bool was_enabled)
+{
+    if (was_enabled == m_solid_model_while_dragging || m_shells.print_id == -1)
+        return;
+    // only the prime tower comes and goes with the mode: a full reload would drop the shells
+    // whenever the print has moved on since they were loaded, leaving the solid model nothing to draw
+    if (wxGetApp().plater() == nullptr)
+        return;
+    // the shells are loaded from the current plate's print, which is not the plater's own
+    const Print& print = wxGetApp().plater()->get_partplate_list().get_current_fff_print();
+    if (static_cast<int>(print.id().id) != m_shells.print_id)
+        return;
+    update_shell_wipe_tower(print, m_gl_data_initialized);
+}
+
 void GCodeViewer::set_layers_z_range(const std::array<unsigned int, 2>& layers_z_range)
 {
     m_viewer.set_layers_view_range(static_cast<uint32_t>(layers_z_range[0]), static_cast<uint32_t>(layers_z_range[1]));
@@ -2249,7 +2292,11 @@ void GCodeViewer::export_toolpaths_to_obj(const char* filename) const
 void GCodeViewer::load_shells(const Print& print, bool initialized, bool force_previewing)
 {
     BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": initialized=%1%, force_previewing=%2%")%initialized %force_previewing;
+    // the shells can load before the first G-code does, so the preferences are read here as well
+    read_solid_model_preference();
     if ((print.id().id == m_shells.print_id)&&(print.get_modified_count() == m_shells.print_modify_count)) {
+        // the prime tower comes and goes on its own, without reloading the objects
+        update_shell_wipe_tower(print, initialized);
         //BBS: update force previewing logic
         if (force_previewing)
             m_shells.previewing = force_previewing;
@@ -2358,10 +2405,45 @@ void GCodeViewer::load_shells(const Print& print, bool initialized, bool force_p
     m_shells.print_id = print.id().id;
     m_shells.print_modify_count = print.get_modified_count();
     m_shells.previewing = true;
+    update_shell_wipe_tower(print, initialized);
     BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": shell loaded, id change to %1%, modify_count %2%, object count %3%, glvolume count %4%")
         % m_shells.print_id % m_shells.print_modify_count % object_count %m_shells.volumes.volumes.size();
 }
 
+// The prime tower as it was sliced, so that the solid model shows what the print shows. It keeps its
+// opaque colour, so it never appears among the translucent shells, and stays out of their bounding box.
+void GCodeViewer::update_shell_wipe_tower(const Print& print, bool initialized)
+{
+    const bool with_wipe_tower = m_solid_model_while_dragging && print.is_step_done(psWipeTower) && print.wipe_tower_data().wipe_tower_mesh_data;
+    if (with_wipe_tower == m_shells.with_wipe_tower)
+        return;
+    m_shells.with_wipe_tower = with_wipe_tower;
+    GLVolumePtrs& volumes = m_shells.volumes.volumes;
+    if (!with_wipe_tower) {
+        volumes.erase(std::remove_if(volumes.begin(), volumes.end(), [](GLVolume* volume) {
+            if (!volume->is_wipe_tower)
+                return false;
+            delete volume;
+            return true;
+        }), volumes.end());
+        return;
+    }
+    const PrintConfig& config = print.config();
+    const int plate_idx = print.get_plate_index();
+    const Vec3d plate_origin = print.get_plate_origin();
+    const float x = static_cast<float>(config.wipe_tower_x.get_at(plate_idx) + plate_origin.x());
+    const float y = static_cast<float>(config.wipe_tower_y.get_at(plate_idx) + plate_origin.y());
+    const size_t first_new = volumes.size();
+    m_shells.volumes.load_real_wipe_tower_preview(1000 + plate_idx, x, y, print.wipe_tower_data().wipe_tower_mesh_data->real_wipe_tower_mesh,
+                                                  print.wipe_tower_data().wipe_tower_mesh_data->real_brim_mesh, true,
+                                                  static_cast<float>(config.wipe_tower_rotation_angle), false, initialized);
+    for (size_t i = first_new; i < volumes.size(); ++i) {
+        volumes[i]->zoom_to_volumes = false;
+        volumes[i]->force_native_color = true;
+        volumes[i]->set_render_color();
+    }
+}
+
 void GCodeViewer::render_toolpaths()
 {
     const Camera& camera = wxGetApp().plater()->get_camera();
@@ -2562,6 +2644,50 @@ void GCodeViewer::render_shells(int canvas_width, int canvas_height)
     glsafe(::glDepthMask(GL_TRUE));
 }
 
+// The sliced objects and the prime tower drawn opaque, in their filament colours, cut to the
+// visible layer range by the shader's z range. The toolpaths of the range's bottom and top layers
+// are drawn afterwards and cap the cut.
+void GCodeViewer::render_solid_model(int canvas_width, int canvas_height)
+{
+    if (m_shells.volumes.empty())
+        return;
+    // gouraud_light has no z range, so it could not cut the model
+    GLShaderProgram* shader = wxGetApp().get_shader("gouraud");
+    if (shader == nullptr)
+        return;
+
+    const libvgcode::Interval& layers = m_viewer.get_layers_view_range();
+    const float z_top = m_viewer.get_layer_z(layers[1]) - m_z_offset + 0.001f;
+    const float z_bottom = (layers[0] > 0) ? m_viewer.get_layer_z(layers[0] - 1) - m_z_offset - 0.001f : -FLT_MAX;
+
+    std::vector<float> alphas;
+    alphas.reserve(m_shells.volumes.volumes.size());
+    for (GLVolume* volume : m_shells.volumes.volumes) {
+        alphas.push_back(volume->color.a());
+        volume->color.a(1.0f);
+        volume->set_render_color();
+    }
+    m_shells.volumes.set_z_range(z_bottom, z_top);
+    // gouraud also clips by this plane, which nothing else sets on the shells
+    m_shells.volumes.set_clipping_plane(ClippingPlane::ClipsNothing().get_data());
+
+    shader->start_using();
+    // the 3D view leaves its shadow settings on the shared program
+    shader->set_uniform("shadow_intensity", 0.0f);
+    const Camera& camera = wxGetApp().plater()->get_camera();
+    shader->set_uniform("z_far", camera.get_far_z());
+    shader->set_uniform("z_near", camera.get_near_z());
+    m_shells.volumes.render(GLVolumeCollection::ERenderType::Opaque, false, camera.get_view_matrix(), camera.get_projection_matrix(), {canvas_width, canvas_height});
+    shader->stop_using();
+
+    m_shells.volumes.set_z_range(-FLT_MAX, FLT_MAX);
+    size_t k = 0;
+    for (GLVolume* volume : m_shells.volumes.volumes) {
+        volume->color.a(alphas[k++]);
+        volume->set_render_color();
+    }
+}
+
 //BBS
 void GCodeViewer::render_all_plates_stats(const std::vector<const GCodeProcessorResult*>& gcode_result_list, bool show /*= true*/) const {
     if (!show)
@@ -3426,6 +3552,12 @@ void GCodeViewer::render_legend(float &legend_height, int canvas_width, int canv
         std::vector<std::pair<ColorRGBA, std::pair<double, double>>> ret;
         ret.reserve(custom_gcode_per_print_z.size());
 
+        // Loop invariant, but built lazily: this lambda runs once per extruder on every frame
+        // and most prints reach neither colour change below, so fetching it up front would cost
+        // more than the per-item fetch it replaces.
+        std::vector<float> zs;
+        bool zs_built = false;
+
         for (const auto& item : custom_gcode_per_print_z) {
             if (extruder_id + 1 != static_cast<unsigned char>(item.extruder))
                 continue;
@@ -3433,7 +3565,10 @@ void GCodeViewer::render_legend(float &legend_height, int canvas_width, int canv
             if (item.type != ColorChange)
                 continue;
 
-            const std::vector<float> zs = m_viewer.get_layers_zs();
+            if (!zs_built) {
+                zs = m_viewer.get_layers_zs();
+                zs_built = true;
+            }
             auto lower_b = std::lower_bound(zs.begin(), zs.end(),
                 static_cast<float>(item.print_z - epsilon()));
             if (lower_b == zs.end())
@@ -4582,6 +4717,8 @@ void GCodeViewer::render_legend(float &legend_height, int canvas_width, int canv
 
         // ORCA: Get layer Zs as doubles
         std::vector<double> layer_zs = get_layers_zs();
+        // loop invariant, same reason as the layer Zs above
+        const std::vector<float> layer_times = m_viewer.get_layers_estimated_times();
 
         for (Slic3r::CustomGCode::Item custom_gcode : custom_gcode_per_print_z) {
             ImGui::Dummy({window_padding, window_padding});
@@ -4601,7 +4738,6 @@ void GCodeViewer::render_legend(float &legend_height, int canvas_width, int canv
             imgui.text(buf);
             ImGui::SameLine(max_len * 1.5);
 
-            std::vector<float> layer_times = m_viewer.get_layers_estimated_times();
             float custom_gcode_time = 0;
             if (layer > 0)
             {
@@ -4650,7 +4786,7 @@ void GCodeViewer::render_legend(float &legend_height, int canvas_width, int canv
     std::string print_str = _u8L("Model printing time");
     std::string total_str = _u8L("Total time");
     float max_len = window_padding + 2 * ImGui::GetStyle().ItemSpacing.x;
-    if (m_viewer.get_layers_estimated_times().empty())
+    if (m_viewer.get_layers_count() == 0)
         max_len += ImGui::CalcTextSize(total_str.c_str()).x;
     else {
         if (m_viewer.get_view_type() == libvgcode::EViewType::FeatureType)

src/slic3r/GUI/GCodeViewer.hpp

@@ -174,6 +174,8 @@ public:
         int  print_id{-1};
         int  print_modify_count{-1};
         bool previewing{false};
+        // the prime tower was loaded with the objects, for the solid model
+        bool with_wipe_tower{false};
     };
     //BBS
     ConflictResultOpt m_conflict_result;
@@ -233,6 +235,13 @@ private:
 
     bool m_legend_visible{ true };
     bool m_legend_enabled{ true };
+    // while dragging, the sliced objects are drawn as solid shapes instead of toolpaths
+    bool m_solid_model_while_dragging{ false };
+    void read_solid_model_preference();
+    void render_solid_model(int canvas_width, int canvas_height);
+    // the prime tower is only among the shells for the solid model, so it is added or removed when that changes
+    void reload_shells_if_solid_model_changed(bool was_enabled);
+    void update_shell_wipe_tower(const Print& print, bool initialized);
 
     float m_legend_height;
     PrintEstimatedStatistics m_print_statistics;
@@ -283,7 +292,7 @@ public:
     // void _render_calibration_thumbnail_internal(ThumbnailData& thumbnail_data, const ThumbnailsParams& thumbnail_params, PartPlateList& partplate_list, OpenGLManager& opengl_manager);
     // void _render_calibration_thumbnail_framebuffer(ThumbnailData& thumbnail_data, unsigned int w, unsigned int h, const ThumbnailsParams& thumbnail_params, PartPlateList& partplate_list, OpenGLManager& opengl_manager);
     // void render_calibration_thumbnail(ThumbnailData& thumbnail_data, unsigned int w, unsigned int h, const ThumbnailsParams& thumbnail_params, PartPlateList& partplate_list, OpenGLManager& opengl_manager);
-    bool has_data() const { return !m_viewer.get_extrusion_roles().empty(); }
+    bool has_data() const { return m_viewer.get_extrusion_roles_count() != 0; }
 
     bool can_export_toolpaths() const;
     std::vector<int> get_plater_extruder();
@@ -345,6 +354,11 @@ public:
     void set_dim_previous_layers_brightness(float value) { m_viewer.set_dim_previous_layers_brightness(value); }
     float get_dim_previous_layers_brightness() const { return m_viewer.get_dim_previous_layers_brightness(); }
 
+    // while the user drags the camera or a slider, draw the solid model, if the preference asks for it
+    void set_interacting(bool interacting);
+    bool is_reduced_detail() const { return m_viewer.is_reduced_detail(); }
+    void set_solid_model_while_dragging(bool value);
+
     void set_layers_z_range(const std::array<unsigned int, 2>& layers_z_range);
 
     bool is_legend_shown() const { return m_legend_visible && m_legend_enabled; }

src/slic3r/GUI/GLCanvas3D.cpp

@@ -2054,6 +2054,11 @@ void GLCanvas3D::_render_frame(bool scene_dirty, bool only_init)
     const bool overlay_tick = m_fps_overlay_tick;
     m_fps_overlay_tick = false;
 
+    // Whether the preview draws the solid model is decided before the cached scene is consulted,
+    // since switching changes what the scene pass draws.
+    if (m_canvas_type == ECanvasType::CanvasPreview && m_render_preview && m_gcode_viewer.has_data() && _update_preview_interaction())
+        scene_dirty = true;
+
     // An overlay-only frame reuses the last scene pass. The overlay is rebuilt either way, and drawn
     // below once it is known whether the frame differs from the one on screen.
     const bool reuse_scene = !scene_dirty && _can_reuse_cached_scene(camera);
@@ -3233,9 +3238,16 @@ void GLCanvas3D::bind_event_handlers()
                 if (m_selection_edit.kind != SelectionEdit::None)
                     finish_selection_edit();
                 ImGui::SetWindowFocus(nullptr);
+                // a drag cut short never sees its button release, which would leave the solid model drawn
+                if (m_canvas_type == CanvasPreview && m_mouse.dragging && m_gcode_viewer.is_reduced_detail())
+                    mouse_up_cleanup();
                 render();
                 evt.Skip();
             });
+        m_canvas->Bind(wxEVT_MOUSE_CAPTURE_LOST, [this](wxMouseCaptureLostEvent&) {
+                if (m_canvas_type == CanvasPreview && m_mouse.dragging && m_gcode_viewer.is_reduced_detail())
+                    mouse_up_cleanup();
+            });
         m_event_handlers_bound = true;
 
         m_canvas->Bind(wxEVT_GESTURE_PAN, &GLCanvas3D::on_gesture, this);
@@ -3308,6 +3320,17 @@ void GLCanvas3D::on_idle(wxIdleEvent& evt)
     m_overlay_dirty |= imgui_requires_extra_frame;
 #endif // ENABLE_ENHANCED_IMGUI_SLIDER_FLOAT
     m_dirty |= GLTexture::Compressor::has_compressed_texture_to_refresh();
+    // the render timer only wakes the idle loop; the frame that puts the preview's toolpaths back
+    // after a wheel burst has to be asked for here, once the settle time is really up
+    if (m_preview_settle_pending) {
+        const auto now = std::chrono::steady_clock::now();
+        if (now >= m_preview_interaction_until) {
+            m_preview_settle_pending = false;
+            m_dirty = true;
+        }
+        else // the timer fired early
+            schedule_extra_frame(static_cast<int>(std::chrono::duration_cast<std::chrono::milliseconds>(m_preview_interaction_until - now).count()) + 1);
+    }
 
     if (!m_dirty && !m_overlay_dirty)
         return;
@@ -3838,6 +3861,10 @@ void GLCanvas3D::on_mouse_wheel(wxMouseEvent& evt)
         return;
     }
 
+    // only a wheel the panels did not take moves the camera
+    if (m_canvas_type == CanvasPreview)
+        note_preview_interaction();
+
 #ifdef __WXMSW__
 	// For some reason the Idle event is not being generated after the mouse scroll event in case of scrolling with the two fingers on the touch pad,
 	// if the event is not allowed to be passed further.
@@ -3938,6 +3965,11 @@ void GLCanvas3D::on_fps_overlay_timer(wxTimerEvent& evt)
     wxWakeUpIdle();
 }
 
+void GLCanvas3D::note_preview_interaction()
+{
+    m_preview_interaction_until = std::chrono::steady_clock::now() + std::chrono::milliseconds(150);
+}
+
 void GLCanvas3D::schedule_extra_frame(int milliseconds)
 {
     // Schedule idle event right now
@@ -5554,6 +5586,9 @@ void GLCanvas3D::mouse_up_cleanup()
     m_mouse.ignore_left_up = false;
     m_mouse.ignore_right_up = false;
     m_dirty = true;
+    // the frame that follows a release puts the preview's toolpaths back, and on some platforms
+    // no idle event follows a button release until the next input
+    wxWakeUpIdle();
 
     if (m_canvas->HasCapture())
         m_canvas->ReleaseMouse();
@@ -8738,6 +8773,26 @@ void GLCanvas3D::_render_wireframe_overlay()
     shader->stop_using();
 }
 
+// The solid model is drawn while the camera, the navigator or either slider is dragged. A wheel
+// step has no duration, so it holds the solid model for a settle time instead, and the frame that
+// restores the toolpaths is scheduled for when that time runs out. Returns whether what the scene
+// pass draws changed, since a frame that reuses the cached scene would hide the change.
+bool GLCanvas3D::_update_preview_interaction()
+{
+    IMSlider* layers_slider = m_gcode_viewer.get_layers_slider();
+    IMSlider* moves_slider  = m_gcode_viewer.get_moves_slider();
+    const auto now = std::chrono::steady_clock::now();
+    const bool settling = now < m_preview_interaction_until;
+    const bool dragging = m_mouse.dragging || m_navigator_dragging || layers_slider->is_dragging() || moves_slider->is_dragging();
+    const bool was_reduced = m_gcode_viewer.is_reduced_detail();
+    m_gcode_viewer.set_interacting(dragging || settling);
+    if (settling && !dragging && m_gcode_viewer.is_reduced_detail()) {
+        m_preview_settle_pending = true;
+        schedule_extra_frame(static_cast<int>(std::chrono::duration_cast<std::chrono::milliseconds>(m_preview_interaction_until - now).count()) + 1);
+    }
+    return m_gcode_viewer.is_reduced_detail() != was_reduced;
+}
+
 //BBS: GUI refactor: add canvas size as parameters
 void GLCanvas3D::_render_gcode(int canvas_width, int canvas_height)
 {

src/slic3r/GUI/GLCanvas3D.hpp

@@ -649,6 +649,10 @@ private:
     ECursorType m_cursor_type;
     GLSelectionRectangle m_rectangle_selection;
     bool m_navigator_dragging{ false };
+    // until when a wheel step keeps the preview's solid model drawn
+    std::chrono::time_point<std::chrono::steady_clock> m_preview_interaction_until{};
+    // whether the frame that restores the toolpaths once that time is up is still owed
+    bool m_preview_settle_pending{ false };
 
     //BBS:add plate related logic
     mutable std::vector<int> m_hover_volume_idxs;
@@ -1215,6 +1219,8 @@ public:
     void msw_rescale() { m_gcode_viewer.invalidate_legend(); }
 
     void request_extra_frame() { m_extra_frame_requested = true; }
+    // a wheel step is over before the next frame, so it holds the preview's solid model for a settle time
+    void note_preview_interaction();
 
     void schedule_extra_frame(int milliseconds);
 
@@ -1361,6 +1367,9 @@ private:
     //BBS: GUI refactor: add canvas size as parameters
     void _render_gcode(int canvas_width, int canvas_height);
     void _render_gcode_overlay(int canvas_width, int canvas_height);
+    // decides whether the preview draws its solid model this frame and returns whether what the scene
+    // pass draws changed; runs before the cached scene is consulted
+    bool _update_preview_interaction();
     //BBS: render a plane for assemble
     void _render_plane() const;
     void _render_selection();

src/slic3r/GUI/IMSlider.cpp

@@ -483,6 +483,11 @@ void IMSlider::draw_background_and_groove(const ImRect& bg_rect, const ImRect& g
     ImGui::RenderFrame(groove.Min, groove.Max, groove_col, false, 0.5 * groove.GetWidth());
 }
 
+bool IMSlider::is_dragging() const
+{
+    return GImGui != nullptr && m_imgui_id != 0 && GImGui->ActiveId == m_imgui_id && GImGui->IO.MouseDown[0];
+}
+
 bool IMSlider::horizontal_slider(const char* str_id, int* value, int v_min, int v_max, const ImVec2& size, float scale)
 {
     ImGuiWindow* window = ImGui::GetCurrentWindow();
@@ -491,6 +496,7 @@ bool IMSlider::horizontal_slider(const char* str_id, int* value, int v_min, int
 
     ImGuiContext& context = *GImGui;
     const ImGuiID id = window->GetID(str_id);
+    m_imgui_id = id;
 
     const ImVec2 pos = window->DC.CursorPos;
     const ImRect draw_region(pos, pos + size);
@@ -883,6 +889,7 @@ bool IMSlider::vertical_slider(const char* str_id, int* higher_value, int* lower
 
     ImGuiContext& context = *GImGui;
     const ImGuiID id = window->GetID(str_id);
+    m_imgui_id = id;
 
     const ImVec2 pos = window->DC.CursorPos;
     const ImRect draw_region(pos, pos + size);

src/slic3r/GUI/IMSlider.hpp

@@ -118,6 +118,9 @@ public:
 
     //BBS update scroll value changed
     bool is_dirty() { return m_dirty; }
+    // whether the mouse is holding this slider's handle, read from ImGui's active id rather than
+    // from the dirty flag, which is raised and consumed inside a single frame
+    bool is_dragging() const;
     void set_as_dirty(bool dirty = true) { m_dirty = dirty; }
     bool is_need_post_tick_event() { return m_is_need_post_tick_changed_event; }
     void reset_post_tick_event(bool val = false) {
@@ -182,6 +185,8 @@ private:
     int  m_higher_value;
     int  m_one_layer_value; // ORCA
     bool m_dirty = false;
+    // the ImGui id of the slider widget, as of its last render
+    unsigned int m_imgui_id = 0;
 
     bool m_render_as_disabled{ false };
 

src/slic3r/GUI/MainFrame.cpp

@@ -1189,8 +1189,6 @@ void MainFrame::shutdown()
     if (m_project != nullptr)
         m_project->shutdown();
     m_plugin_pages.shutdown();
-    if (m_plater != nullptr)
-        m_plater->remove_dock_panes();
 #ifdef __WXGTK__
     // Edge panels are child windows — wxWidgets destroys them automatically.
     m_edge_bottom = nullptr;
@@ -3426,6 +3424,11 @@ void MainFrame::init_menubar_as_editor()
             wxGetApp().open_preferences();
         },
         "", nullptr, []() { return true; }, this, 1);
+    parent_menu->AppendSeparator();
+    append_shortcut_item(
+        parent_menu, Shortcut::SpeedDial, false, _L("Open speed dial"), "",
+        [](wxCommandEvent &) { wxGetApp().open_speed_dial(); },
+        "", nullptr, []() { return true; }, this);
     //parent_menu->Insert(1, preference_item);
 #endif
     // Help menu

src/slic3r/GUI/Plater.cpp

@@ -87,7 +87,6 @@
 #ifdef __WXGTK__
 #include "LinuxDisplayBackend.hpp"
 #endif
-#include "AuiPaneLayout.hpp"
 #include "GUI_Utils.hpp"
 #include "GUI_Factories.hpp"
 #include "wxExtensions.hpp"
@@ -6749,14 +6748,6 @@ struct Plater::priv
 
     // GUI elements
     AuiMgr m_aui_mgr;
-    // Live dock panes. `on_close` runs when the user closes one from its close button; `shown` is
-    // what the owner asked for.
-    struct DockPane
-    {
-        std::function<void()> on_close;
-        bool                  shown{true};
-    };
-    std::map<wxWindow*, DockPane> m_dock_panes;
     wxString m_default_window_layout;
     wxPanel* current_panel{ nullptr };
     std::vector<wxPanel*> panels;
@@ -6929,11 +6920,6 @@ struct Plater::priv
     void update_sidebar(bool force_update = false);
     void reset_window_layout();
     Sidebar::DockingState get_sidebar_docking_state();
-    void add_dock_pane(wxWindow* window, const std::string& name, const wxString& caption, const std::string& dock,
-                       const wxSize& size, std::function<void()> on_close);
-    void remove_dock_pane(wxWindow* window);
-    void show_dock_pane(wxWindow* window, bool show);
-    bool dock_pane_visible(const DockPane& dock_pane, const wxAuiPaneInfo& pane) const;
 
     bool is_view3D_layers_editing_enabled() const { return (current_panel == view3D) && view3D->get_canvas3d()->is_layers_editing_enabled(); }
 
@@ -7514,18 +7500,6 @@ 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_dock_panes.find(pane->window) : m_dock_panes.end();
-        if (it != m_dock_panes.end()) {
-            const std::function<void()> on_close = std::move(it->second.on_close);
-            m_dock_panes.erase(it);
-            if (on_close)
-                on_close();
-        }
-        evt.Skip();
-    });
-
     m_default_window_layout = m_aui_mgr.SavePerspective();
 
     {
@@ -8191,14 +8165,6 @@ void Plater::priv::update_sidebar(bool force_update) {
         }
     }
 
-    for (const auto& [window, dock_pane] : m_dock_panes) {
-        wxAuiPaneInfo& pane = m_aui_mgr.GetPane(window);
-        if (pane.IsOk() && pane.IsShown() != dock_pane_visible(dock_pane, pane)) {
-            pane.Show(!pane.IsShown());
-            needs_update = true;
-        }
-    }
-
     if (needs_update) {
         notification_manager->set_sidebar_collapsed(sidebar.IsShown());
         m_aui_mgr.Update();
@@ -8208,96 +8174,10 @@ 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
-    // dock panes: a floating dock pane is docked again, like the rest of the window.
-    for (const auto& [window, dock_pane] : m_dock_panes)
-        if (wxAuiPaneInfo& pane = m_aui_mgr.GetPane(window); pane.IsOk())
-            pane.Show(dock_pane_visible(dock_pane, pane));
     sidebar_layout.is_collapsed = false;
     update_sidebar(true);
 }
 
-bool Plater::priv::dock_pane_visible(const DockPane& dock_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 dock_pane.shown && (!pane.IsFloating() || sidebar_layout.show);
-}
-
-void Plater::priv::add_dock_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 DockPane& dock_pane = m_dock_panes[window] = DockPane{std::move(on_close)};
-    info.Show(dock_pane_visible(dock_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_dock_pane(wxWindow* window)
-{
-    m_dock_panes.erase(window);
-    if (m_aui_mgr.DetachPane(window))
-        m_aui_mgr.Update();
-    window->Destroy();
-}
-
-void Plater::priv::show_dock_pane(wxWindow* window, bool show)
-{
-    const auto     it   = m_dock_panes.find(window);
-    wxAuiPaneInfo& pane = m_aui_mgr.GetPane(window);
-    if (it == m_dock_panes.end() || !pane.IsOk())
-        return;
-    it->second.shown = show;
-    if (pane.IsShown() == dock_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;
@@ -17892,19 +17772,6 @@ Sidebar::DockingState Plater::get_sidebar_docking_state() const { return p->get_
 
 void Plater::reset_window_layout() { p->reset_window_layout(); }
 
-void Plater::add_dock_pane(wxWindow* window, const std::string& name, const wxString& caption, const std::string& dock,
-                           const wxSize& size, std::function<void()> on_close)
-{
-    p->add_dock_pane(window, name, caption, dock, size, std::move(on_close));
-}
-void Plater::remove_dock_pane(wxWindow* window) { p->remove_dock_pane(window); }
-void Plater::remove_dock_panes()
-{
-    while (!p->m_dock_panes.empty())
-        p->remove_dock_pane(p->m_dock_panes.begin()->first);
-}
-void Plater::show_dock_pane(wxWindow* window, bool show) { p->show_dock_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

@@ -476,17 +476,6 @@ public:
 
     void reset_window_layout();
 
-    // Dock panes sit 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_dock_pane() destroys it without calling on_close.
-    void add_dock_pane(wxWindow* window, const std::string& name, const wxString& caption, const std::string& dock,
-                       const wxSize& size, std::function<void()> on_close);
-    void remove_dock_pane(wxWindow* window);
-    void show_dock_pane(wxWindow* window, bool show);
-    // Removes every dock 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_dock_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/PluginWebDialog.cpp

@@ -1,23 +1,80 @@
-#include "WebDialog.hpp"
+#include "PluginWebDialog.hpp"
 
+#include "slic3r/GUI/GUI.hpp"
 #include "slic3r/GUI/GUI_App.hpp"
-#include "slic3r/GUI/Widgets/WebHosting.hpp"
+
+#include <libslic3r/Utils.hpp>
+
+#include <boost/filesystem.hpp>
 
 #include <wx/event.h>
+#include <wx/uri.h>
 
 #include <utility>
 
 namespace Slic3r { namespace GUI {
 
-WebDialog::WebDialog(wxWindow*          parent,
-                     const wxString&    title,
-                     const std::string& html,
-                     const wxSize&      size,
-                     MessageHandler     on_message,
-                     SubmitHandler      on_submit,
-                     CloseHandler       on_close,
-                     CloseHandler       on_destroyed,
-                     long               wx_style)
+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,
+                                 const wxSize&      size,
+                                 MessageHandler     on_message,
+                                 SubmitHandler      on_submit,
+                                 CloseHandler       on_close,
+                                 CloseHandler       on_destroyed,
+                                 long               wx_style)
     : WebViewHostDialog(parent, wxID_ANY, title, wxDefaultPosition, size, wx_style)
     , m_html(html)
     , m_on_message(std::move(on_message))
@@ -27,7 +84,7 @@ WebDialog::WebDialog(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_hosting::BOOTSTRAP_PAGE, title, size, wxSize(320, 240));
+    create_webview("web/dialog/PluginWebDialog/blank.html", 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.
@@ -39,22 +96,22 @@ WebDialog::WebDialog(wxWindow*          parent,
         // create_webview() via add_user_scripts(); nothing to add here.
         // Swap in the plugin HTML once the bootstrap page settles. Bind ERROR too so a
         // missing/blocked bootstrap resource (e.g. a packaged build) still triggers it.
-        Bind(wxEVT_WEBVIEW_LOADED, &WebDialog::on_bootstrap_event, this, wv->GetId());
-        Bind(wxEVT_WEBVIEW_ERROR, &WebDialog::on_bootstrap_event, this, wv->GetId());
-        Bind(wxEVT_WEBVIEW_NAVIGATED, &WebDialog::on_navigated, this, wv->GetId());
+        Bind(wxEVT_WEBVIEW_LOADED, &PluginWebDialog::on_bootstrap_event, this, wv->GetId());
+        Bind(wxEVT_WEBVIEW_ERROR, &PluginWebDialog::on_bootstrap_event, this, wv->GetId());
+        Bind(wxEVT_WEBVIEW_NAVIGATED, &PluginWebDialog::on_navigated, this, wv->GetId());
     }
-    Bind(wxEVT_CLOSE_WINDOW, &WebDialog::on_close_window, this);
+    Bind(wxEVT_CLOSE_WINDOW, &PluginWebDialog::on_close_window, this);
 }
 
-void WebDialog::add_user_scripts()
+void PluginWebDialog::add_user_scripts()
 {
     if (wxWebView* wv = browser()) {
-        wv->AddUserScript(wxString::FromUTF8(WebViewHostDialog::element_defaults_user_script()));
-        wv->AddUserScript(wxString::FromUTF8(web_hosting::orca_bridge_script()));
+        wv->AddUserScript(wxString::FromUTF8(WebViewHostDialog::plugin_defaults_user_script()));
+        wv->AddUserScript(ORCA_BRIDGE_JS);
     }
 }
 
-WebDialog::~WebDialog()
+PluginWebDialog::~PluginWebDialog()
 {
     // Runs on every destruction path. Deliberately NOT a wxEVT_DESTROY handler:
     // that event is sent from the base ~wxDialog(), after this subclass's members
@@ -64,19 +121,19 @@ WebDialog::~WebDialog()
         m_on_destroyed();
 }
 
-void WebDialog::post_message(WebDialog* dialog, const nlohmann::json& data)
+void PluginWebDialog::post_message(PluginWebDialog* dialog, const nlohmann::json& data)
 {
     if (dialog != nullptr && dialog->is_open())
         dialog->push_message(data);
 }
 
-void WebDialog::request_close(WebDialog* dialog)
+void PluginWebDialog::request_close(PluginWebDialog* dialog)
 {
     if (dialog != nullptr)
         dialog->Close();
 }
 
-void WebDialog::destroy_silently(WebDialog* dialog)
+void PluginWebDialog::destroy_for_plugin(PluginWebDialog* dialog)
 {
     if (dialog == nullptr)
         return;
@@ -90,42 +147,42 @@ void WebDialog::destroy_silently(WebDialog* dialog)
     dialog->Destroy();
 }
 
-void WebDialog::on_bootstrap_event(wxWebViewEvent& event)
+void PluginWebDialog::on_bootstrap_event(wxWebViewEvent& event)
 {
     const bool loaded = event.GetEventType() == wxEVT_WEBVIEW_LOADED;
     // The first bootstrap load (or its error) triggers the swap to plugin HTML.
     if (!m_content_loaded)
-        load_page_html();
+        load_plugin_content();
     // WebKit reloads the SetPage base URL, so a committed load of it that we did not start is a reload.
     // A failed navigation is reported against the page that stayed but never commits. Edge ignores the
     // base URL and restores SetPage content itself, so nothing matches there.
-    else if (web_hosting::is_content_url(event.GetURL())) {
+    else if (is_content_url(event.GetURL())) {
         if (m_own_page_load)
             m_own_page_load = false;
         else if (loaded && m_content_navigated)
-            load_page_html();
+            load_plugin_content();
     }
     if (loaded)
         m_content_navigated = false;
     event.Skip();
 }
 
-void WebDialog::on_navigated(wxWebViewEvent& event)
+void PluginWebDialog::on_navigated(wxWebViewEvent& event)
 {
-    m_content_navigated = web_hosting::is_content_url(event.GetURL());
+    m_content_navigated = is_content_url(event.GetURL());
     event.Skip();
 }
 
-void WebDialog::load_page_html()
+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_hosting::content_base_url());
+        wv->SetPage(wxString::FromUTF8(m_html), web_base_url());
     }
 }
 
-void WebDialog::on_script_message(const nlohmann::json& payload)
+void PluginWebDialog::on_script_message(const nlohmann::json& payload)
 {
     if (payload.value("channel", std::string()) == "orca") {
         const std::string    kind = payload.value("kind", std::string());
@@ -145,7 +202,7 @@ void WebDialog::on_script_message(const nlohmann::json& payload)
     handle_common_script_command(payload);
 }
 
-void WebDialog::push_message(const nlohmann::json& data)
+void PluginWebDialog::push_message(const nlohmann::json& data)
 {
     if (!m_open)
         return;
@@ -154,7 +211,7 @@ void WebDialog::push_message(const nlohmann::json& data)
     call_web_handler(envelope, wxT("__orcaDispatch"));
 }
 
-void WebDialog::finish(bool submitted, const nlohmann::json& data)
+void PluginWebDialog::finish(bool submitted, const nlohmann::json& data)
 {
     if (!m_open)
         return;
@@ -173,7 +230,7 @@ void WebDialog::finish(bool submitted, const nlohmann::json& data)
         Close();
 }
 
-void WebDialog::on_close_window(wxCloseEvent&)
+void PluginWebDialog::on_close_window(wxCloseEvent&)
 {
     if (!m_open) {
         // finish() already dispatched submit/close and requested the close.
@@ -193,7 +250,7 @@ void WebDialog::on_close_window(wxCloseEvent&)
     Destroy();
 }
 
-void WebDialog::fire_submit(const nlohmann::json& data)
+void PluginWebDialog::fire_submit(const nlohmann::json& data)
 {
     if (m_on_submit) {
         SubmitHandler cb = std::move(m_on_submit);
@@ -201,7 +258,7 @@ void WebDialog::fire_submit(const nlohmann::json& data)
     }
 }
 
-void WebDialog::fire_close()
+void PluginWebDialog::fire_close()
 {
     if (m_close_fired)
         return;

src/slic3r/GUI/PluginWebDialog.hpp

@@ -1,5 +1,5 @@
-#ifndef slic3r_GUI_WebDialog_hpp_
-#define slic3r_GUI_WebDialog_hpp_
+#ifndef slic3r_GUI_PluginWebDialog_hpp_
+#define slic3r_GUI_PluginWebDialog_hpp_
 
 #include "Widgets/WebViewHostDialog.hpp"
 
@@ -21,7 +21,7 @@ namespace Slic3r { namespace GUI {
 // GIL held; the plugin layer wraps any Python callables in a GIL-safe holder.
 //
 // Usable both modally (ShowModal -> read result()) and modelessly (Show()).
-class WebDialog : public Slic3r::GUI::WebViewHostDialog
+class PluginWebDialog : public Slic3r::GUI::WebViewHostDialog
 {
 public:
     using MessageHandler = std::function<void(const nlohmann::json& data)>;
@@ -32,20 +32,20 @@ public:
     // user/JS-initiated close (while the window is alive). on_destroyed runs from
     // the destructor on every path and must touch host-side state only (no Python
     // / no derived members).
-    WebDialog(wxWindow*          parent,
-              const wxString&    title,
-              const std::string& html,
-              const wxSize&      size,
-              MessageHandler     on_message,
-              SubmitHandler      on_submit,
-              CloseHandler       on_close,
-              CloseHandler       on_destroyed,
-              long               wx_style = wxSYSTEM_MENU | wxCAPTION | wxCLOSE_BOX | wxMAXIMIZE_BOX | wxRESIZE_BORDER);
-    ~WebDialog() override;
+    PluginWebDialog(wxWindow*          parent,
+                    const wxString&    title,
+                    const std::string& html,
+                    const wxSize&      size,
+                    MessageHandler     on_message,
+                    SubmitHandler      on_submit,
+                    CloseHandler       on_close,
+                    CloseHandler       on_destroyed,
+                    long               wx_style = wxSYSTEM_MENU | wxCAPTION | wxCLOSE_BOX | wxMAXIMIZE_BOX | wxRESIZE_BORDER);
+    ~PluginWebDialog() override;
 
-    static void post_message(WebDialog* dialog, const nlohmann::json& data);
-    static void request_close(WebDialog* dialog);
-    static void destroy_silently(WebDialog* dialog);
+    static void post_message(PluginWebDialog* dialog, const nlohmann::json& data);
+    static void request_close(PluginWebDialog* dialog);
+    static void destroy_for_plugin(PluginWebDialog* dialog);
 
     // Push a payload to the page; delivered to handlers registered via
     // window.orca.onMessage(). MAIN-THREAD ONLY (the plugin layer marshals).
@@ -65,7 +65,7 @@ protected:
 private:
     void on_bootstrap_event(wxWebViewEvent& event);
     void on_navigated(wxWebViewEvent& event);
-    void load_page_html();
+    void load_plugin_content();
     void on_close_window(wxCloseEvent& event);
     void fire_submit(const nlohmann::json& data);
     void fire_close();
@@ -86,4 +86,4 @@ private:
 
 }} // namespace Slic3r::GUI
 
-#endif // slic3r_GUI_WebDialog_hpp_
+#endif // slic3r_GUI_PluginWebDialog_hpp_

src/slic3r/GUI/Preferences.cpp

@@ -1049,6 +1049,16 @@ wxBoxSizer *PreferencesDialog::create_item_checkbox(wxString title, wxString too
             }
         }
         // ORCA: apply the preview dimming change immediately to the currently loaded preview
+        // apply the solid model preference immediately to the currently loaded preview
+        else if (param == "preview_solid_model_while_dragging") {
+            if (Plater* plater = wxGetApp().plater()) {
+                if (GLCanvas3D* canvas = plater->get_preview_canvas3D()) {
+                    canvas->get_gcode_viewer().set_solid_model_while_dragging(app_config->get_bool(param));
+                    canvas->set_as_dirty();
+                    canvas->request_extra_frame();
+                }
+            }
+        }
         else if (param == "preview_dim_previous_layers") {
             if (m_dim_previous_layers_brightness_input)
                 m_dim_previous_layers_brightness_input->Enable(app_config->get_bool(param));
@@ -2019,6 +2029,15 @@ void PreferencesDialog::create_items()
     //// GRAPHICS > G-code Preview
     g_sizer->Add(create_item_title(_L("G-code Preview")), 1, wxEXPAND);
 
+    auto item_solid_model_while_dragging = create_item_checkbox(
+        _L("Only render solid model when dragging"),
+        _L("While dragging the camera or a preview slider, or zooming with the mouse wheel, draw the sliced objects and the prime tower as solid shapes "
+           "in their filament colours instead of toolpaths, so that large prints stay responsive. They are cut to the visible layer range, with its bottom "
+           "and top layers drawn as toolpaths. Supports are not shown. The toolpaths are restored as soon as you let go."),
+        "preview_solid_model_while_dragging"
+    );
+    g_sizer->Add(item_solid_model_while_dragging);
+
     auto item_dim_previous_layers = create_item_checkbox(
         _L("Dim lower layers"),
         _L("When scrubbing the layer slider in the sliced preview, render the layers below the current one darkened so that only the layer being viewed is shown at full brightness."),

src/slic3r/GUI/WebPanel.cpp

@@ -1,111 +0,0 @@
-#include "WebPanel.hpp"
-
-#include "GUI_App.hpp"
-#include "Widgets/WebHosting.hpp"
-#include "Widgets/WebView.hpp"
-#include "Widgets/WebViewHostDialog.hpp"
-
-#include <boost/log/trivial.hpp>
-
-#include <wx/sizer.h>
-
-namespace Slic3r { namespace GUI {
-
-WebPanel::WebPanel(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.
-    m_browser = WebView::CreateWebView(this, web_hosting::bootstrap_url());
-    m_browser->SetBackgroundColour(GetBackgroundColour());
-    m_browser->AddUserScript(wxString::FromUTF8(WebViewHostDialog::theme_user_script()));
-    m_browser->AddUserScript(wxString::FromUTF8(WebViewHostDialog::element_defaults_user_script()));
-    m_browser->AddUserScript(wxString::FromUTF8(bridge_script));
-    m_browser->Bind(wxEVT_WEBVIEW_LOADED, &WebPanel::on_load_event, this);
-    m_browser->Bind(wxEVT_WEBVIEW_ERROR, &WebPanel::on_load_event, this);
-    m_browser->Bind(wxEVT_WEBVIEW_NAVIGATED, &WebPanel::on_navigated, this);
-    m_browser->Bind(wxEVT_WEBVIEW_SCRIPT_MESSAGE_RECEIVED, &WebPanel::on_script_message, this);
-    m_browser->Bind(EVT_WEBVIEW_RECREATED, &WebPanel::on_webview_recreated, this);
-    sizer->Add(m_browser, 1, wxEXPAND);
-}
-
-void WebPanel::on_load_event(wxWebViewEvent& event)
-{
-    const bool loaded = event.GetEventType() == wxEVT_WEBVIEW_LOADED;
-    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 (!web_hosting::is_content_url(event.GetURL())) {
-        // Not our document (a linked page, a substituted error page), or any document on Edge, which ignores
-        // the base URL and restores SetPage content on a reload itself; either way it takes the app theme.
-        if (loaded)
-            apply_theme();
-    } else if (m_own_page_load) {
-        m_own_page_load = false;
-        // The document-start theme script is fixed at creation, so re-apply the app theme.
-        if (loaded)
-            apply_theme();
-    } else if (loaded && m_content_navigated) {
-        // WebKit reloads the SetPage base URL, so a committed load of it that we did not start is a
-        // reload. A failed navigation is reported against the page that stayed but never commits.
-        load_page_html();
-    }
-    if (loaded)
-        m_content_navigated = false;
-    event.Skip();
-}
-
-void WebPanel::on_navigated(wxWebViewEvent& event)
-{
-    m_content_navigated = web_hosting::is_content_url(event.GetURL());
-    event.Skip();
-}
-
-void WebPanel::load_page_html()
-{
-    if (const std::optional<std::string> html = page_html()) {
-        m_own_page_load = true;
-        m_browser->SetPage(wxString::FromUTF8(*html), web_hosting::content_base_url());
-    }
-}
-
-void WebPanel::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) << "WebPanel ignored a window.orca '" << kind << "' call; this host does not support it";
-}
-
-void WebPanel::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 WebPanel::apply_theme()
-{
-    WebView::RunScript(m_browser, wxString::FromUTF8(WebViewHostDialog::theme_apply_script()));
-}
-
-void WebPanel::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/WebPanel.hpp

@@ -1,48 +0,0 @@
-#pragma once
-
-#include <nlohmann/json.hpp>
-
-#include <wx/panel.h>
-#include <wx/webview.h>
-
-#include <optional>
-#include <string>
-
-namespace Slic3r { namespace GUI {
-
-// Host-supplied HTML in a web view panel, for any window that embeds or derives from it (today plugin
-// Pages tabs and docked panels): bootstrap page and swap, theme and bridge scripts, live re-theming, and
-// window.orca messages routed to on_page_message().
-class WebPanel : public wxPanel
-{
-public:
-    WebPanel(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, and again when WebKit reloads it;
-    // std::nullopt leaves it blank.
-    virtual std::optional<std::string> page_html() = 0;
-    // A window.orca message from the page; false for a kind this host does not handle (logged).
-    virtual bool on_page_message(const std::string& kind, const nlohmann::json& data) = 0;
-
-private:
-    void on_load_event(wxWebViewEvent& event);
-    void on_navigated(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
-    bool       m_content_navigated{false}; // a navigation to the base URL has committed
-};
-
-}} // namespace Slic3r::GUI

src/slic3r/GUI/Widgets/WebHosting.cpp

@@ -1,69 +0,0 @@
-#include "WebHosting.hpp"
-
-#include "slic3r/GUI/GUI.hpp"
-
-#include <libslic3r/Utils.hpp>
-
-#include <boost/filesystem.hpp>
-
-#include <wx/uri.h>
-
-namespace Slic3r { namespace GUI { namespace web_hosting {
-
-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 bootstrap_url()
-{
-    return wxString("file://") + from_u8((boost::filesystem::path(resources_dir()) / BOOTSTRAP_PAGE).make_preferred().string());
-}
-
-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::web_hosting

src/slic3r/GUI/Widgets/WebHosting.hpp

@@ -1,25 +0,0 @@
-#pragma once
-
-#include <wx/string.h>
-
-namespace Slic3r { namespace GUI { namespace web_hosting {
-
-// Shared by the hosts that show plugin HTML: WebDialog and WebPanel.
-
-// The bundled blank page a plugin web view loads before the plugin HTML is swapped in.
-constexpr const char* BOOTSTRAP_PAGE = "web/dialog/WebDialog/blank.html";
-
-// The file:// URL of BOOTSTRAP_PAGE.
-wxString bootstrap_url();
-
-// The file:// base URL plugin HTML is loaded against, so relative URLs resolve to bundled resources.
-wxString content_base_url();
-
-// Whether `url` is the plugin HTML's base URL, ignoring any fragment. WebKit reports it for the
-// injected page, a reload and a failed navigation alike, so a match alone is not a new document.
-bool is_content_url(const wxString& url);
-
-// The window.orca bridge of plugin windows and docked panels. Pages tabs ship their own.
-const char* orca_bridge_script();
-
-}}} // namespace Slic3r::GUI::web_hosting

src/slic3r/GUI/Widgets/WebViewHostDialog.cpp

@@ -75,8 +75,6 @@ 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().
@@ -89,7 +87,7 @@ std::string WebViewHostDialog::theme_user_script()
         "if(document.documentElement)document.documentElement.setAttribute('data-orca-theme',theme);");
 }
 
-std::string WebViewHostDialog::element_defaults_user_script()
+std::string WebViewHostDialog::plugin_defaults_user_script()
 {
     std::string css;
     css += "<style id=\"orca-plugin-defaults\">";

src/slic3r/GUI/Widgets/WebViewHostDialog.hpp

@@ -49,11 +49,9 @@ public:
                                                const std::string& prelude   = {},
                                                const std::string& on_inject = {});
 
-    // Shared by WebPanel hosts and WebDialog.
+    // Shared by modeless Pages tabs and PluginWebDialog.
     static std::string theme_user_script();
-    static std::string element_defaults_user_script();
-    // Re-themes an already-loaded page in place, for web views hosted outside a dialog.
-    static std::string theme_apply_script();
+    static std::string plugin_defaults_user_script();
 
 protected:
     wxWebView* browser() const { return m_browser; }

src/slic3r/plugin/host/PluginHostUi.cpp

@@ -7,10 +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/DockPanel.hpp>
 #include <slic3r/GUI/PluginProgressDialog.hpp>
-#include <slic3r/GUI/WebDialog.hpp>
+#include <slic3r/GUI/PluginWebDialog.hpp>
 #include <slic3r/GUI/NotificationManager.hpp>
 
 #include <nlohmann/json.hpp>
@@ -22,7 +20,6 @@
 #include <wx/defs.h>
 #include <wx/window.h>
 
-#include <algorithm>
 #include <atomic>
 #include <cstdint>
 #include <future>
@@ -76,7 +73,7 @@ CallablePtr make_holder(py::object obj)
 
 // Adapt a Python callable to a GUI message handler that acquires the GIL and
 // swallows/logs exceptions (a raising handler must not escape into wx events).
-GUI::WebDialog::MessageHandler make_message_adapter(py::object on_message)
+GUI::PluginWebDialog::MessageHandler make_message_adapter(py::object on_message)
 {
     CallablePtr holder = make_holder(std::move(on_message));
     if (!holder)
@@ -94,7 +91,7 @@ GUI::WebDialog::MessageHandler make_message_adapter(py::object on_message)
     };
 }
 
-GUI::WebDialog::SubmitHandler make_submit_adapter(py::object on_submit)
+GUI::PluginWebDialog::SubmitHandler make_submit_adapter(py::object on_submit)
 {
     CallablePtr holder = make_holder(std::move(on_submit));
     if (!holder)
@@ -112,25 +109,6 @@ GUI::WebDialog::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.
@@ -372,13 +350,28 @@ py::object ui_create_window(const std::string& html, const std::string& title, i
         if (!UiRegistry::instance().is_open(new_id))
             return;
 
-        GUI::WebDialog::CloseHandler on_close = make_close_adapter(close_holder);
+        // Plugin's on_close: fired only on a user/JS-initiated close (not forced
+        // 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); };
 
-        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);
+        auto* dlg = new GUI::PluginWebDialog(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();
@@ -394,69 +387,14 @@ 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::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});
-}
-
 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* 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);
+        auto* d = UiRegistry::instance().get_as<GUI::PluginWebDialog>(id);
+        GUI::PluginWebDialog::post_message(d, j);
     });
 }
 
@@ -465,23 +403,8 @@ void 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));
-    });
-}
-
-void 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);
+        auto* d = UiRegistry::instance().get_as<GUI::PluginWebDialog>(id);
+        GUI::PluginWebDialog::request_close(d);
     });
 }
 
@@ -640,31 +563,6 @@ 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)
@@ -732,10 +630,8 @@ void PluginHostUi::close_windows_for_plugin(const std::string& plugin_key)
         // Destroy() bypasses wxEVT_CLOSE, so the plugin's on_close is not fired on
         // forced teardown (intended); the resource destructor still cleans the registry.
         for (auto* window : UiRegistry::instance().take_for_plugin(plugin_key)) {
-            if (auto* dialog = dynamic_cast<GUI::WebDialog*>(window))
-                GUI::WebDialog::destroy_silently(dialog);
-            else if (auto* panel = dynamic_cast<GUI::DockPanel*>(window))
-                panel->destroy_silently();
+            if (auto* dialog = dynamic_cast<GUI::PluginWebDialog*>(window))
+                GUI::PluginWebDialog::destroy_for_plugin(dialog);
             else if (window != nullptr)
                 window->Destroy();
         }

src/slic3r/plugin/host/PluginPages.cpp

@@ -1,12 +1,17 @@
 #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>
@@ -61,11 +66,27 @@ constexpr char PLUGIN_PAGE_BRIDGE_JS[] = R"JS(
 } // namespace
 
 PluginPage::PluginPage(wxWindow* parent, std::shared_ptr<PagesPluginCapability> capability)
-    : GUI::WebPanel(parent, PLUGIN_PAGE_BRIDGE_JS)
+    : wxPanel(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize)
     , m_cap(std::move(capability))
     , m_lifetime(std::make_shared<std::atomic<PluginPage*>>(this))
 {
-    browser()->Bind(wxEVT_WEBVIEW_NEWWINDOW, &PluginPage::on_new_window, this);
+    auto* topsizer = new wxBoxSizer(wxVERTICAL);
+    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) {
@@ -96,54 +117,89 @@ void PluginPage::detach_capability()
     m_cap.reset();
 }
 
-std::optional<std::string> PluginPage::page_html()
+wxString PluginPage::web_base_url() const
 {
-    if (m_cap == nullptr)
-        return std::nullopt;
+    const auto path = (boost::filesystem::path(resources_dir()) / "web").make_preferred().string();
+    return wxString("file://") + GUI::from_u8(path) + "/";
+}
 
+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 {
-        return m_cap->get_ui();
+        m_browser->SetPage(wxString::FromUTF8(m_cap->get_ui()), web_base_url());
     } 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())
-        browser()->LoadURL(url);
+    if (!url.empty() && m_browser != nullptr)
+        m_browser->LoadURL(url);
     event.Veto();
 }
 
-bool PluginPage::on_page_message(const std::string& kind, const nlohmann::json& data)
+void PluginPage::on_script_message(wxWebViewEvent& event)
 {
-    if (kind != "message")
-        return false;
     if (!m_cap)
-        return true;
+        return;
 
+    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.dump(-1, ' ', false, nlohmann::json::error_handler_t::replace));
+        m_cap->on_message(data == root.end()
+                              ? "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.
-    post_to_page(nlohmann::json::accept(message)
-                     ? message
-                     : nlohmann::json(message).dump(-1, ' ', false, nlohmann::json::error_handler_t::replace));
+    const std::string payload = nlohmann::json::accept(message)
+                                    ? message
+                                    : 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()
@@ -212,6 +268,10 @@ 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,6 +1,5 @@
 #pragma once
 
-#include <slic3r/GUI/WebPanel.hpp>
 #include <slic3r/plugin/PythonPluginInterface.hpp>
 #include <slic3r/plugin/pluginTypes/pages/PagesPluginCapability.hpp>
 
@@ -12,13 +11,14 @@
 #include <vector>
 
 #include <wx/bitmap.h>
+#include <wx/panel.h>
 #include <wx/webview.h>
 
 class Notebook;
 
 namespace Slic3r {
 
-class PluginPage : public GUI::WebPanel
+class PluginPage : public wxPanel
 {
 public:
     PluginPage(wxWindow* parent, std::shared_ptr<PagesPluginCapability> capability);
@@ -26,20 +26,24 @@ 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 on_new_window(wxWebViewEvent& event);
+    void load_plugin_content();
+    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,12 +3,8 @@
 #include <libslic3r/Model.hpp>
 #include <libslic3r/PresetBundle.hpp>
 #include <libslic3r/TriangleMesh.hpp>
-#include <slic3r/GUI/DockPanel.hpp>
-#include <slic3r/GUI/AuiPaneLayout.hpp>
-#include <slic3r/GUI/Widgets/WebHosting.hpp>
 #include <slic3r/plugin/PythonPluginBridge.hpp>
 
-#include "plugin_test_utils.hpp"
 #include "python_test_support.hpp"
 
 #include <pybind11/embed.h>
@@ -145,8 +141,6 @@ 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.
@@ -157,74 +151,6 @@ 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::web_hosting;
-
-    // A resources path holding a space, which the web view reports escaped.
-    const Slic3r::ScopedResourcesDir resources("web content check");
-
-    // The swapped-in page, then after an in-page anchor and a reload.
-    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]")