feat: Add layout debugging/inspecting tool (#14919)

* Add wxInspector dep

* Initial intergration of wxInspector

* docs: add wxInspector plugins design spec

Design spec for two wxInspector plugins (DPIAware + CustomWidgets) that expose
OrcaSlicer's custom control properties in the inspector property grid.

Covers: DPIAware scale-factor properties, Button, CheckBox, TextInput,
SwitchButton, ProgressBar, Label, and LabeledStaticBox.

* docs: add wxInspector plugins implementation plan

6-task plan covering: source changes to existing widget headers,
DPIAwarePlugin, CustomWidgetsPlugin, registration helper,
MainFrame/CMake wiring, and build verification.

* feat: add getters/setters for wxInspector plugin access

Add minimal public accessors to DPIAware (set_scale_factor,
set_prev_scale_factor, set_em_unit, force_rescale), Button
(GetStyle, GetType, IsSelected), CheckBox (IsHalfChecked),
TextInput (GetCornerRadius), and LabeledStaticBox
(GetCornerRadius, GetBorderWidth, GetBorderColor, GetScale).

* feat: add wxInspector plugin registration helper

Add RegisterOrcaInspectorPlugins() inline function that creates
and registers the DPIAwarePlugin and CustomWidgetsPlugin as
static instances (matching wxInspector's built-in pattern).

* feat: add DPIAware wxInspector plugin

Exposes DPI scaling properties (scale_factor, prev_scale_factor,
em_unit, normal_font, force_rescale) on DPIFrame and DPIDialog
widgets. Uses dynamic_cast for detection and a template helper
to capture the correct static type for lambda accessors.

* feat: add OrcaCustomWidgets wxInspector plugin

Exposes Orca-specific properties on 7 widget types:
- Button: Style, Type, Selected
- CheckBox: Half Checked
- TextInput: Label, Text Value, Corner Radius
- SwitchButton: Value
- ProgressBar: Proportion, Show Number
- Label: Is Hyperlink, Font Point Size
- LabeledStaticBox: Corner Radius, Border Width, Border Color, Scale

Each widget type uses dynamic_cast for safe detection.

* feat: wire wxInspector plugins into MainFrame and build

Call RegisterOrcaInspectorPlugins() in MainFrame constructor after
SetupInspectorAccelerator(). Add all 5 plugin source files to
SLIC3R_GUI_SOURCES in CMakeLists.txt.

* fix: move plugin registration to GUI_App::on_init_inner

Register plugins once in app init rather than in MainFrame
constructor, which may be recreated during the application
lifetime.

* fix: include plugin headers in Registration.hpp for complete types

Static locals require complete type. Include DPIAwarePlugin.hpp and
CustomWidgetsPlugin.hpp instead of forward-declaring. Also remove
unused include from MainFrame.cpp (registration moved to GUI_App).

* fix: qualify DPIFrame/DPIDialog with Slic3r::GUI namespace

* Make DPIDialog inspectable. For other dialogs, we will add them if necessary later.

* docs: add spec for moving wxInspectable into DPIAware template

Move wxInspector::wxInspectable base class from DPIDialog and MainFrame
into the common DPIAware<P> template, making all DPIAware widgets
automatically visible in the inspector tree.

Co-Authored-By: Claude <noreply@anthropic.com>

* docs: add implementation plan for moving wxInspectable into DPIAware

Co-Authored-By: Claude <noreply@anthropic.com>

* docs: update spec/plan — move SetupInspectorAccelerator into DPIAware too

Co-Authored-By: Claude <noreply@anthropic.com>

* refactor: move wxInspectable and SetupInspectorAccelerator into DPIAware

DPIAware<P> now inherits wxInspector::wxInspectable and calls
SetupInspectorAccelerator in its constructor, making all DPIAware
widgets automatically appear in the inspector tree with the
Ctrl+Shift+I shortcut. DPIDialog now uses 'using' to inherit the
constructor. Remove redundant wxInspectable inheritance and
SetupInspectorAccelerator calls from DPIDialog and MainFrame.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix: use LB_HYPERLINK constant instead of magic number 0x0020

Co-Authored-By: Claude <noreply@anthropic.com>

* Clean up

* Fix Linux build

* Don't build wxInspector sample

* Use shallow clone

* Try fix flatpak build

* Attempt to fix build again

* Fix build failure caused by 436c16135e

* wxWidgets build only download required submodules

* This should fix build on Windows on ARM

* Enable PIC

* Disable layout inspector by default for public release

* Use wxInspector 1.0.0 release

---------

Co-authored-by: Claude <noreply@anthropic.com>

src/CMakeLists.txt

@@ -88,6 +88,10 @@ if (SLIC3R_GUI)
     list(FILTER wxWidgets_LIBRARIES EXCLUDE REGEX OpenGL)
 
 #    list(REMOVE_ITEM wxWidgets_LIBRARIES oleacc)
+
+    find_package(wxInspector REQUIRED)
+    list(APPEND wxWidgets_LIBRARIES "wxInspector::wxInspector")
+
     message(STATUS "wx libs: ${wxWidgets_LIBRARIES}")
 
     add_subdirectory(slic3r)

src/libslic3r/Technologies.hpp

@@ -51,4 +51,9 @@
 // Enable extension of tool position imgui dialog to show actual speed profile
 #define ENABLE_ACTUAL_SPEED_DEBUG 1
 
+// Disable layout inspector for public release
+#if BBL_RELEASE_TO_PUBLIC
+#define WXINSPECTOR_DISABLE
+#endif
+
 #endif // _prusaslicer_technologies_h_

src/slic3r/CMakeLists.txt

@@ -752,6 +752,11 @@ set(SLIC3R_GUI_SOURCES
     Utils/WxFontUtils.hpp
     Utils/FileTransferUtils.cpp
     Utils/FileTransferUtils.hpp
+    Utils/wxInspectorPlugins/DPIAwarePlugin.hpp
+    Utils/wxInspectorPlugins/DPIAwarePlugin.cpp
+    Utils/wxInspectorPlugins/CustomWidgetsPlugin.hpp
+    Utils/wxInspectorPlugins/CustomWidgetsPlugin.cpp
+    Utils/wxInspectorPlugins/Registration.hpp
 )
 
 add_subdirectory(GUI/DeviceCore)

src/slic3r/GUI/DeviceCore/DevUtil.h

@@ -13,6 +13,7 @@
 
 #include <boost/log/trivial.hpp>
 #include <boost/lexical_cast.hpp>
+#include <boost/format.hpp>
 
 #include "nlohmann/json.hpp"
 

src/slic3r/GUI/GUI_App.cpp

@@ -96,6 +96,7 @@
 #include "../Utils/PresetUpdater.hpp"
 #include "../Utils/PrintHost.hpp"
 #include "../Utils/Process.hpp"
+#include "../Utils/wxInspectorPlugins/Registration.hpp"
 #include "../Utils/MacDarkMode.hpp"
 #include "../Utils/Http.hpp"
 #include "../Utils/InstanceID.hpp"
@@ -2835,6 +2836,9 @@ bool GUI_App::on_init_inner()
 
     ::Label::initSysFont();
 
+    // Register wxInspector plugins for Orca custom controls
+    RegisterOrcaInspectorPlugins();
+
     // Set initialization of image handlers before any UI actions - See GH issue #7469
     wxInitAllImageHandlers();
 #ifdef NDEBUG

src/slic3r/GUI/GUI_Utils.hpp

@@ -20,6 +20,7 @@
 #include <wx/settings.h>
 #include <wx/dataview.h>
 #include <wx/statbox.h>
+#include <wx/inspector/inspector.h>
 
 #include <chrono>
 #include "Event.hpp"
@@ -88,7 +89,7 @@ void update_dark_ui(wxWindow* window);
 
 extern std::deque<wxDialog*> dialogStack;
 
-template<class P> class DPIAware : public P
+template<class P> class DPIAware : public P, public wxInspector::wxInspectable
 {
 public:
     DPIAware(wxWindow *parent, wxWindowID id, const wxString &title, const wxPoint &pos=wxDefaultPosition,
@@ -107,6 +108,7 @@ public:
         this->SetFont(m_normal_font);
 #endif
         this->CenterOnParent();
+        SetupInspectorAccelerator(this);
 #ifdef _WIN32
         update_dark_ui(this);
 #endif
@@ -182,6 +184,11 @@ public:
 
     float   scale_factor() const        { return m_scale_factor; }
     float   prev_scale_factor() const   { return m_prev_scale_factor; }
+    // Only meant to be used by inspector, not public API
+    void    set_scale_factor(float v)      { m_scale_factor = v; }
+    void    set_prev_scale_factor(float v) { m_prev_scale_factor = v; }
+    void    set_em_unit(int v)             { m_em_unit = v; }
+    bool    force_rescale() const          { return m_force_rescale; }
 
     int     em_unit() const             { return m_em_unit; }
 //    int     font_size() const           { return m_font_size; }

src/slic3r/GUI/MainFrame.cpp

@@ -739,7 +739,7 @@ DPIFrame(NULL, wxID_ANY, "", wxDefaultPosition, wxDefaultSize, BORDERLESS_FRAME_
             return;
         }
 
-        if (evt.CmdDown() && evt.GetKeyCode() == 'I') {
+        if (evt.CmdDown() && evt.GetKeyCode() == 'I' && !evt.ShiftDown()) {
             if (!can_add_models()) return;
             if (m_plater) { m_plater->add_file(); }
             return;

src/slic3r/GUI/Widgets/Button.hpp

@@ -77,6 +77,11 @@ public:
 
     void SetSelected(bool selected = true) { m_selected = selected; }
 
+    // Only meant to be used by inspector, not public API
+    ButtonStyle GetStyle() const { return m_style; }
+    ButtonType  GetType() const  { return m_type; }
+    bool IsSelected() const      { return m_selected; }
+
     bool Enable(bool enable = true) override;
     void EnableTooltipEvenDisabled();// The tip will be shown even if the button is disabled
 

src/slic3r/GUI/Widgets/CheckBox.hpp

@@ -15,6 +15,9 @@ public:
 
 	void SetHalfChecked(bool value = true);
 
+	// Only meant to be used by inspector, not public API
+	bool IsHalfChecked() const { return m_half_checked; }
+
 	void Rescale();
 
 #ifdef __WXOSX__

src/slic3r/GUI/Widgets/LabeledStaticBox.hpp

@@ -46,6 +46,12 @@ public:
 
     bool Enable(bool enable) override;
 
+    // Only meant to be used by inspector, not public API
+    int        GetCornerRadius() const { return m_radius; }
+    int        GetBorderWidth() const  { return m_border_width; }
+    StateColor GetBorderColor() const  { return border_color; }
+    float      GetScale() const        { return m_scale; }
+
 private:
     void PickDC(wxDC& dc);
 

src/slic3r/GUI/Widgets/TextInput.hpp

@@ -43,6 +43,9 @@ public:
 
     void SetCornerRadius(double radius);
 
+    // Only meant to be used by inspector, not public API
+    int GetCornerRadius() const { return static_cast<int>(radius); }
+
     void SetLabel(const wxString& label);
 
     void SetStaticTips(const wxString& tips, const wxBitmap& bitmap);

src/slic3r/Utils/wxInspectorPlugins/CustomWidgetsPlugin.cpp

@@ -0,0 +1,274 @@
+#include "CustomWidgetsPlugin.hpp"
+
+#include "slic3r/GUI/Widgets/Button.hpp"
+#include "slic3r/GUI/Widgets/CheckBox.hpp"
+#include "slic3r/GUI/Widgets/TextInput.hpp"
+#include "slic3r/GUI/Widgets/SwitchButton.hpp"
+#include "slic3r/GUI/Widgets/ProgressBar.hpp"
+#include "slic3r/GUI/Widgets/Label.hpp"
+#include "slic3r/GUI/Widgets/LabeledStaticBox.hpp"
+
+#include <wx/window.h>
+#include <wx/tglbtn.h>
+
+wxString CustomWidgetsPlugin::GetName() const
+{
+    return "OrcaCustomWidgets";
+}
+
+bool CustomWidgetsPlugin::CanProvideProperties(wxClassInfo* info)
+{
+    return info->IsKindOf(CLASSINFO(wxWindow));
+}
+
+wxVector<wxInspector::PropertyDef> CustomWidgetsPlugin::GetProperties(
+    wxInspector::InspectableObject& obj)
+{
+    wxVector<wxInspector::PropertyDef> props;
+    wxWindow* win = obj.AsWindow();
+    if (!win) return props;
+
+    if (auto* btn = dynamic_cast<Button*>(win))
+        addButtonProps(btn, props);
+    if (auto* cb = dynamic_cast<CheckBox*>(win))
+        addCheckBoxProps(cb, props);
+    if (auto* ti = dynamic_cast<TextInput*>(win))
+        addTextInputProps(ti, props);
+    if (auto* sb = dynamic_cast<SwitchButton*>(win))
+        addSwitchButtonProps(sb, props);
+    if (auto* pb = dynamic_cast<ProgressBar*>(win))
+        addProgressBarProps(pb, props);
+    if (auto* lbl = dynamic_cast<Label*>(win))
+        addLabelProps(lbl, props);
+    if (auto* lsb = dynamic_cast<LabeledStaticBox*>(win))
+        addLabeledStaticBoxProps(lsb, props);
+
+    return props;
+}
+
+void CustomWidgetsPlugin::addButtonProps(Button* btn,
+    wxVector<wxInspector::PropertyDef>& props)
+{
+    using namespace wxInspector;
+
+    wxVector<wxString> styleChoices;
+    styleChoices.push_back("Regular");
+    styleChoices.push_back("Confirm");
+    styleChoices.push_back("Alert");
+    styleChoices.push_back("Disabled");
+
+    auto styleToStr = [](ButtonStyle s) -> wxString {
+        switch (s) {
+            case ButtonStyle::Regular:  return "Regular";
+            case ButtonStyle::Confirm:  return "Confirm";
+            case ButtonStyle::Alert:    return "Alert";
+            case ButtonStyle::Disabled: return "Disabled";
+        }
+        return "Regular";
+    };
+
+    props.push_back({"Button Style", "Orca Button", PropertyType::Choice,
+        styleToStr(btn->GetStyle()), false, styleChoices,
+        [btn, styleToStr]() { return styleToStr(btn->GetStyle()); },
+        [btn](const wxString& v) {
+            ButtonStyle s = ButtonStyle::Regular;
+            if (v == "Confirm")       s = ButtonStyle::Confirm;
+            else if (v == "Alert")    s = ButtonStyle::Alert;
+            else if (v == "Disabled") s = ButtonStyle::Disabled;
+            btn->SetStyle(s, btn->GetType());
+            return true;
+        }});
+
+    wxVector<wxString> typeChoices;
+    typeChoices.push_back("Compact");
+    typeChoices.push_back("Window");
+    typeChoices.push_back("Choice");
+    typeChoices.push_back("Parameter");
+    typeChoices.push_back("Icon");
+    typeChoices.push_back("Expanded");
+
+    auto typeToStr = [](ButtonType t) -> wxString {
+        switch (t) {
+            case ButtonType::Compact:   return "Compact";
+            case ButtonType::Window:    return "Window";
+            case ButtonType::Choice:    return "Choice";
+            case ButtonType::Parameter: return "Parameter";
+            case ButtonType::Icon:      return "Icon";
+            case ButtonType::Expanded:  return "Expanded";
+        }
+        return "Compact";
+    };
+
+    props.push_back({"Button Type", "Orca Button", PropertyType::Choice,
+        typeToStr(btn->GetType()), false, typeChoices,
+        [btn, typeToStr]() { return typeToStr(btn->GetType()); },
+        [btn](const wxString& v) {
+            ButtonType t = ButtonType::Compact;
+            if (v == "Window")       t = ButtonType::Window;
+            else if (v == "Choice")    t = ButtonType::Choice;
+            else if (v == "Parameter") t = ButtonType::Parameter;
+            else if (v == "Icon")      t = ButtonType::Icon;
+            else if (v == "Expanded")  t = ButtonType::Expanded;
+            btn->SetStyle(btn->GetStyle(), t);
+            return true;
+        }});
+
+    props.push_back({"Selected", "Orca Button", PropertyType::Boolean,
+        btn->IsSelected() ? "true" : "false", false, {},
+        [btn]() { return btn->IsSelected() ? "true" : "false"; },
+        [btn](const wxString& v) {
+            btn->SetSelected(v == "true");
+            btn->Refresh();
+            return true;
+        }});
+}
+
+void CustomWidgetsPlugin::addCheckBoxProps(CheckBox* cb,
+    wxVector<wxInspector::PropertyDef>& props)
+{
+    using namespace wxInspector;
+
+    props.push_back({"Half Checked", "Orca CheckBox", PropertyType::Boolean,
+        cb->IsHalfChecked() ? "true" : "false", false, {},
+        [cb]() { return cb->IsHalfChecked() ? "true" : "false"; },
+        [cb](const wxString& v) {
+            cb->SetHalfChecked(v == "true");
+            return true;
+        }});
+}
+
+void CustomWidgetsPlugin::addTextInputProps(TextInput* ti,
+    wxVector<wxInspector::PropertyDef>& props)
+{
+    using namespace wxInspector;
+
+    props.push_back({"Label", "Orca TextInput", PropertyType::String,
+        ti->GetLabel(), false, {},
+        [ti]() { return ti->GetLabel(); },
+        [ti](const wxString& v) { ti->SetLabel(v); return true; }});
+
+    props.push_back({"Text Value", "Orca TextInput", PropertyType::String,
+        ti->GetTextCtrl()->GetValue(), false, {},
+        [ti]() { return ti->GetTextCtrl()->GetValue(); },
+        [ti](const wxString& v) { ti->GetTextCtrl()->SetValue(v); return true; }});
+
+    props.push_back({"Corner Radius", "Orca TextInput", PropertyType::Integer,
+        wxString::Format("%d", ti->GetCornerRadius()), false, {},
+        [ti]() { return wxString::Format("%d", ti->GetCornerRadius()); },
+        [ti](const wxString& v) {
+            long val;
+            if (!v.ToLong(&val)) return false;
+            ti->SetCornerRadius((double) val);
+            ti->Refresh();
+            return true;
+        }});
+}
+
+void CustomWidgetsPlugin::addSwitchButtonProps(SwitchButton* sb,
+    wxVector<wxInspector::PropertyDef>& props)
+{
+    using namespace wxInspector;
+
+    props.push_back({"Value", "Orca SwitchButton", PropertyType::Boolean,
+        sb->GetValue() ? "true" : "false", false, {},
+        [sb]() { return sb->GetValue() ? "true" : "false"; },
+        [sb](const wxString& v) {
+            sb->SetValue(v == "true");
+            return true;
+        }});
+}
+
+void CustomWidgetsPlugin::addProgressBarProps(ProgressBar* pb,
+    wxVector<wxInspector::PropertyDef>& props)
+{
+    using namespace wxInspector;
+
+    props.push_back({"Proportion", "Orca ProgressBar", PropertyType::String,
+        wxString::Format("%.2f", pb->m_proportion), false, {},
+        [pb]() { return wxString::Format("%.2f", pb->m_proportion); },
+        [pb](const wxString& v) {
+            double val;
+            if (wxSscanf(v, "%lf", &val) != 1) return false;
+            pb->m_proportion = val;
+            pb->Refresh();
+            return true;
+        }});
+
+    props.push_back({"Show Number", "Orca ProgressBar", PropertyType::Boolean,
+        pb->m_shownumber ? "true" : "false", false, {},
+        [pb]() { return pb->m_shownumber ? "true" : "false"; },
+        [pb](const wxString& v) {
+            pb->m_shownumber = (v == "true");
+            pb->Refresh();
+            return true;
+        }});
+}
+
+void CustomWidgetsPlugin::addLabelProps(Label* lbl,
+    wxVector<wxInspector::PropertyDef>& props)
+{
+    using namespace wxInspector;
+
+    bool isHyperlink = (lbl->GetWindowStyleFlag() & LB_HYPERLINK) != 0;
+
+    props.push_back({"Is Hyperlink", "Orca Label", PropertyType::Boolean,
+        isHyperlink ? "true" : "false", true, {},
+        [lbl]() {
+            return (lbl->GetWindowStyleFlag() & LB_HYPERLINK) ? "true" : "false";
+        },
+        nullptr});
+
+    props.push_back({"Font Point Size", "Orca Label", PropertyType::ReadOnly,
+        wxString::Format("%d", lbl->GetFont().GetPointSize()), true, {},
+        [lbl]() {
+            return wxString::Format("%d", lbl->GetFont().GetPointSize());
+        },
+        nullptr});
+}
+
+void CustomWidgetsPlugin::addLabeledStaticBoxProps(LabeledStaticBox* lsb,
+    wxVector<wxInspector::PropertyDef>& props)
+{
+    using namespace wxInspector;
+
+    props.push_back({"Corner Radius", "LabeledStaticBox", PropertyType::Integer,
+        wxString::Format("%d", lsb->GetCornerRadius()), false, {},
+        [lsb]() { return wxString::Format("%d", lsb->GetCornerRadius()); },
+        [lsb](const wxString& v) {
+            long val;
+            if (!v.ToLong(&val)) return false;
+            lsb->SetCornerRadius((int) val);
+            return true;
+        }});
+
+    props.push_back({"Border Width", "LabeledStaticBox", PropertyType::Integer,
+        wxString::Format("%d", lsb->GetBorderWidth()), false, {},
+        [lsb]() { return wxString::Format("%d", lsb->GetBorderWidth()); },
+        [lsb](const wxString& v) {
+            long val;
+            if (!v.ToLong(&val)) return false;
+            lsb->SetBorderWidth((int) val);
+            return true;
+        }});
+
+    // Border Color: display as hex string
+    wxColour bc = lsb->GetBorderColor().colorForStates(0);
+    props.push_back({"Border Color", "LabeledStaticBox", PropertyType::String,
+        bc.GetAsString(wxC2S_HTML_SYNTAX), false, {},
+        [lsb]() {
+            return lsb->GetBorderColor()
+                .colorForStates(0)
+                .GetAsString(wxC2S_HTML_SYNTAX);
+        },
+        [lsb](const wxString& v) {
+            wxColour c(v);
+            if (!c.IsOk()) return false;
+            lsb->SetBorderColor(StateColor(c));
+            return true;
+        }});
+
+    props.push_back({"Scale", "LabeledStaticBox", PropertyType::ReadOnly,
+        wxString::Format("%.2f", lsb->GetScale()), true, {},
+        [lsb]() { return wxString::Format("%.2f", lsb->GetScale()); },
+        nullptr});
+}

src/slic3r/Utils/wxInspectorPlugins/CustomWidgetsPlugin.hpp

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <wx/inspector/plugin.h>
+
+class CustomWidgetsPlugin : public wxInspector::wxInspectorPlugin
+{
+public:
+    wxString GetName() const override;
+
+    bool CanProvideProperties(wxClassInfo* info) override;
+
+    wxVector<wxInspector::PropertyDef> GetProperties(
+        wxInspector::InspectableObject& obj) override;
+
+private:
+    void addButtonProps(class Button* btn,
+        wxVector<wxInspector::PropertyDef>& props);
+    void addCheckBoxProps(class CheckBox* cb,
+        wxVector<wxInspector::PropertyDef>& props);
+    void addTextInputProps(class TextInput* ti,
+        wxVector<wxInspector::PropertyDef>& props);
+    void addSwitchButtonProps(class SwitchButton* sb,
+        wxVector<wxInspector::PropertyDef>& props);
+    void addProgressBarProps(class ProgressBar* pb,
+        wxVector<wxInspector::PropertyDef>& props);
+    void addLabelProps(class Label* lbl,
+        wxVector<wxInspector::PropertyDef>& props);
+    void addLabeledStaticBoxProps(class LabeledStaticBox* lsb,
+        wxVector<wxInspector::PropertyDef>& props);
+};

src/slic3r/Utils/wxInspectorPlugins/DPIAwarePlugin.cpp

@@ -0,0 +1,82 @@
+#include "DPIAwarePlugin.hpp"
+
+#include "slic3r/GUI/GUI_Utils.hpp" // DPIFrame, DPIDialog, DPIAware<P>
+
+#include <wx/window.h>
+#include <wx/crt.h>
+
+namespace {
+
+template<typename T>
+void addDPIProps(T* dpi, wxVector<wxInspector::PropertyDef>& props)
+{
+    using namespace wxInspector;
+
+    props.push_back({"Scale Factor", "DPI Scaling", PropertyType::String,
+        wxString::Format("%.2f", dpi->scale_factor()), false, {},
+        [dpi]() { return wxString::Format("%.2f", dpi->scale_factor()); },
+        [dpi](const wxString& v) {
+            double val;
+            if (wxSscanf(v, "%lf", &val) != 1) return false;
+            dpi->set_scale_factor((float) val);
+            return true;
+        }});
+
+    props.push_back({"Prev Scale Factor", "DPI Scaling", PropertyType::String,
+        wxString::Format("%.2f", dpi->prev_scale_factor()), false, {},
+        [dpi]() { return wxString::Format("%.2f", dpi->prev_scale_factor()); },
+        [dpi](const wxString& v) {
+            double val;
+            if (wxSscanf(v, "%lf", &val) != 1) return false;
+            dpi->set_prev_scale_factor((float) val);
+            return true;
+        }});
+
+    props.push_back({"EM Unit", "DPI Scaling", PropertyType::Integer,
+        wxString::Format("%d", dpi->em_unit()), false, {},
+        [dpi]() { return wxString::Format("%d", dpi->em_unit()); },
+        [dpi](const wxString& v) {
+            long val;
+            if (!v.ToLong(&val)) return false;
+            dpi->set_em_unit((int) val);
+            return true;
+        }});
+
+    props.push_back({"Normal Font", "DPI Scaling", PropertyType::ReadOnly,
+        dpi->normal_font().GetNativeFontInfoDesc(), true, {},
+        [dpi]() { return dpi->normal_font().GetNativeFontInfoDesc(); },
+        nullptr});
+
+    props.push_back({"Force Rescale", "DPI Scaling", PropertyType::Boolean,
+        dpi->force_rescale() ? "true" : "false", true, {},
+        [dpi]() { return dpi->force_rescale() ? "true" : "false"; },
+        nullptr});
+}
+
+} // anonymous namespace
+
+wxString DPIAwarePlugin::GetName() const
+{
+    return "OrcaDPIAware";
+}
+
+bool DPIAwarePlugin::CanProvideProperties(wxClassInfo* info)
+{
+    return info->IsKindOf(CLASSINFO(wxWindow));
+}
+
+wxVector<wxInspector::PropertyDef> DPIAwarePlugin::GetProperties(
+    wxInspector::InspectableObject& obj)
+{
+    wxVector<wxInspector::PropertyDef> props;
+    wxWindow* win = obj.AsWindow();
+    if (!win) return props;
+
+    if (auto* frame = dynamic_cast<Slic3r::GUI::DPIFrame*>(win)) {
+        addDPIProps(frame, props);
+    } else if (auto* dlg = dynamic_cast<Slic3r::GUI::DPIDialog*>(win)) {
+        addDPIProps(dlg, props);
+    }
+
+    return props;
+}

src/slic3r/Utils/wxInspectorPlugins/DPIAwarePlugin.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <wx/inspector/plugin.h>
+
+class DPIAwarePlugin : public wxInspector::wxInspectorPlugin
+{
+public:
+    wxString GetName() const override;
+
+    bool CanProvideProperties(wxClassInfo* info) override;
+
+    wxVector<wxInspector::PropertyDef> GetProperties(
+        wxInspector::InspectableObject& obj) override;
+};

src/slic3r/Utils/wxInspectorPlugins/Registration.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "DPIAwarePlugin.hpp"
+#include "CustomWidgetsPlugin.hpp"
+
+#include <wx/inspector/inspector.h>
+
+inline void RegisterOrcaInspectorPlugins()
+{
+    static DPIAwarePlugin          dpiaware;
+    static CustomWidgetsPlugin     customWidgets;
+    wxInspector::RegisterPlugin(&dpiaware);
+    wxInspector::RegisterPlugin(&customWidgets);
+}