Switch many UI classes to taking a parent pointer

ComputationalBiomechanicsLab · Feb 13, 2025 · 2a3775d · 2a3775d
1 parent fdc9fcf
commit 2a3775d
Show file tree

Hide file tree

Showing 161 changed files with 631 additions and 598 deletions.
diff --git a/libopensimcreator/Documents/Model/UndoableModelActions.cpp b/libopensimcreator/Documents/Model/UndoableModelActions.cpp
@@ -290,7 +290,7 @@ void osc::ActionSaveCurrentModelAs(IModelStatePair& uim)
 
 void osc::ActionNewModel(Widget& api)
 {
-    auto tab = std::make_unique<ModelEditorTab>(api);
+    auto tab = std::make_unique<ModelEditorTab>(&api);
     App::post_event<OpenTabEvent>(api, std::move(tab));
 }
 
@@ -417,7 +417,7 @@ bool osc::ActionLoadSTOFileAgainstModel(
         InitializeState(*modelCopy);
 
         auto simulation = std::make_shared<Simulation>(StoFileSimulation{std::move(modelCopy), stoPath, uim.getFixupScaleFactor(), uim.tryUpdEnvironment()});
-        auto tab = std::make_unique<SimulationTab>(parent, simulation);
+        auto tab = std::make_unique<SimulationTab>(&parent, simulation);
         App::post_event<OpenTabEvent>(parent, std::move(tab));
 
         return true;
@@ -436,7 +436,7 @@ bool osc::ActionStartSimulatingModel(
     ForwardDynamicSimulatorParams params = FromParamBlock(uim.tryUpdEnvironment()->getSimulationParams());
 
     auto simulation = std::make_shared<Simulation>(ForwardDynamicSimulation{std::move(modelState), params});
-    auto tab = std::make_unique<SimulationTab>(parent, std::move(simulation));
+    auto tab = std::make_unique<SimulationTab>(&parent, std::move(simulation));
     App::post_event<OpenTabEvent>(parent, std::move(tab));
 
     return true;

diff --git a/libopensimcreator/UI/FrameDefinition/FrameDefinitionTab.cpp b/libopensimcreator/UI/FrameDefinition/FrameDefinitionTab.cpp
@@ -911,14 +911,16 @@ namespace
 // other panels/widgets
 namespace
 {
-    class FrameDefinitionTabMainMenu final {
+    class FrameDefinitionTabMainMenu final : public Widget {
     public:
         explicit FrameDefinitionTabMainMenu(
+            Widget* parent,
             std::shared_ptr<UndoableModelStatePair> model_,
             std::shared_ptr<PanelManager> panelManager_) :
 
+            Widget{parent},
             m_Model{std::move(model_)},
-            m_WindowMenu{std::move(panelManager_)}
+            m_WindowMenu{this, std::move(panelManager_)}
         {}
 
         void onDraw()
@@ -952,59 +954,59 @@ namespace
 class osc::FrameDefinitionTab::Impl final : public TabPrivate {
 public:
 
-    explicit Impl(FrameDefinitionTab& owner, Widget& parent_) :
-        TabPrivate{owner, &parent_, c_TabStringID},
-        m_Toolbar{&parent_, "##FrameDefinitionToolbar", m_Model}
+    explicit Impl(FrameDefinitionTab& owner, Widget* parent_) :
+        TabPrivate{owner, parent_, c_TabStringID},
+        m_Toolbar{parent_, "##FrameDefinitionToolbar", m_Model}
     {
         m_PanelManager->register_toggleable_panel(
             "Navigator",
-            [this](std::string_view panelName)
+            [this](Widget* parent, std::string_view panelName)
             {
                 return std::make_shared<NavigatorPanel>(
                     panelName,
                     m_Model,
-                    [this](const OpenSim::ComponentPath& rightClickedPath)
+                    [this, parent](const OpenSim::ComponentPath& rightClickedPath)
                     {
                         auto popup = std::make_unique<FrameDefinitionContextMenu>(
                             "##ContextMenu",
                             m_PanelManager,
                             m_Model,
                             rightClickedPath
                         );
-                        App::post_event<OpenPopupEvent>(this->owner(), std::move(popup));
+                        App::post_event<OpenPopupEvent>(*parent, std::move(popup));
                     }
                 );
             }
         );
         m_PanelManager->register_toggleable_panel(
             "Properties",
-            [this](std::string_view panelName)
+            [this](Widget* parent, std::string_view panelName)
             {
-                return std::make_shared<PropertiesPanel>(panelName, this->owner(), m_Model);
+                return std::make_shared<PropertiesPanel>(parent, panelName, m_Model);
             }
         );
         m_PanelManager->register_toggleable_panel(
             "Log",
-            [](std::string_view panelName)
+            [](Widget* parent, std::string_view panelName)
             {
-                return std::make_shared<LogViewerPanel>(panelName);
+                return std::make_shared<LogViewerPanel>(parent, panelName);
             }
         );
         m_PanelManager->register_toggleable_panel(
             "Performance",
-            [](std::string_view panelName)
+            [](Widget* parent, std::string_view panelName)
             {
-                return std::make_shared<PerfPanel>(panelName);
+                return std::make_shared<PerfPanel>(parent, panelName);
             }
         );
         m_PanelManager->register_spawnable_panel(
             "framedef_viewer",
-            [this](std::string_view panelName)
+            [this](Widget* parent, std::string_view panelName)
             {
                 ModelViewerPanelParameters panelParams
                 {
                     m_Model,
-                    [this](const ModelViewerPanelRightClickEvent& e)
+                    [this, parent](const ModelViewerPanelRightClickEvent& e)
                     {
                         auto popup = std::make_unique<FrameDefinitionContextMenu>(
                             "##ContextMenu",
@@ -1013,7 +1015,7 @@ class osc::FrameDefinitionTab::Impl final : public TabPrivate {
                             e.componentAbsPathOrEmpty,
                             e
                         );
-                        App::post_event<OpenPopupEvent>(this->owner(), std::move(popup));
+                        App::post_event<OpenPopupEvent>(*parent, std::move(popup));
                     }
                 };
                 SetupDefault3DViewportRenderingParams(panelParams.updRenderParams());
@@ -1109,16 +1111,16 @@ class osc::FrameDefinitionTab::Impl final : public TabPrivate {
     }
 
     std::shared_ptr<UndoableModelStatePair> m_Model = MakeSharedUndoableFrameDefinitionModel();
-    std::shared_ptr<PanelManager> m_PanelManager = std::make_shared<PanelManager>();
+    std::shared_ptr<PanelManager> m_PanelManager = std::make_shared<PanelManager>(&owner());
     PopupManager m_PopupManager;
-    FrameDefinitionTabMainMenu m_MainMenu{m_Model, m_PanelManager};
+    FrameDefinitionTabMainMenu m_MainMenu{&owner(), m_Model, m_PanelManager};
     FrameDefinitionTabToolbar m_Toolbar;
 };
 
 
 CStringView osc::FrameDefinitionTab::id() { return c_TabStringID; }
 
-osc::FrameDefinitionTab::FrameDefinitionTab(Widget& parent_) :
+osc::FrameDefinitionTab::FrameDefinitionTab(Widget* parent_) :
     Tab{std::make_unique<Impl>(*this, parent_)}
 {}
 void osc::FrameDefinitionTab::impl_on_mount() { private_data().on_mount(); }

diff --git a/libopensimcreator/UI/FrameDefinition/FrameDefinitionTab.h b/libopensimcreator/UI/FrameDefinition/FrameDefinitionTab.h
@@ -10,7 +10,7 @@ namespace osc
     public:
         static CStringView id();
 
-        explicit FrameDefinitionTab(Widget&);
+        explicit FrameDefinitionTab(Widget*);
 
     private:
         void impl_on_mount() final;

diff --git a/libopensimcreator/UI/FrameDefinition/FrameDefinitionUIHelpers.cpp b/libopensimcreator/UI/FrameDefinition/FrameDefinitionUIHelpers.cpp
@@ -90,6 +90,6 @@ void osc::fd::ActionExportFrameDefinitionSceneModelToEditorTab(
     Widget& parent,
     const OpenSim::Model& model)
 {
-    auto tab = std::make_unique<ModelEditorTab>(parent, MakeUndoableModelFromSceneModel(model));
+    auto tab = std::make_unique<ModelEditorTab>(&parent, MakeUndoableModelFromSceneModel(model));
     App::post_event<OpenTabEvent>(parent, std::move(tab));
 }
diff --git a/libopensimcreator/UI/LoadingTab.cpp b/libopensimcreator/UI/LoadingTab.cpp
@@ -94,7 +94,7 @@ class osc::LoadingTab::Impl final : public TabPrivate {
             // there is an existing editor state
             //
             // recycle it so that users can keep their running sims, local edits, etc.
-            App::post_event<OpenTabEvent>(*parent(), std::make_unique<ModelEditorTab>(*parent(), std::move(result)));
+            App::post_event<OpenTabEvent>(*parent(), std::make_unique<ModelEditorTab>(parent(), std::move(result)));
             App::post_event<CloseTabEvent>(*parent(), id());
             m_IsFinishedLoading = true;
         }

diff --git a/libopensimcreator/UI/MainUIScreen.cpp b/libopensimcreator/UI/MainUIScreen.cpp
@@ -59,7 +59,7 @@ namespace
     {
         if (auto maybeRequestedTab = settings.find_value("initial_tab")) {
             if (std::optional<TabRegistryEntry> maybeEntry = tabRegistry.find_by_name(to<std::string>(*maybeRequestedTab))) {
-                return maybeEntry->construct_tab(parent);
+                return maybeEntry->construct_tab(&parent);
             }
 
             log_warn("%s: cannot find a tab with this name in the tab registry: ignoring", to<std::string>(*maybeRequestedTab).c_str());
@@ -536,19 +536,19 @@ class osc::MainUIScreen::Impl final : public ScreenPrivate {
     void drawAddNewTabMenu()
     {
         if (ui::draw_menu_item(OSC_ICON_EDIT " Editor")) {
-            impl_select_tab(addTab(std::make_unique<ModelEditorTab>(owner())));
+            impl_select_tab(addTab(std::make_unique<ModelEditorTab>(&owner())));
         }
 
         if (ui::draw_menu_item(OSC_ICON_CUBE " Mesh Importer")) {
-            impl_select_tab(addTab(std::make_unique<mi::MeshImporterTab>(owner())));
+            impl_select_tab(addTab(std::make_unique<mi::MeshImporterTab>(&owner())));
         }
 
         const std::shared_ptr<const TabRegistry> tabRegistry = App::singleton<TabRegistry>();
         if (not tabRegistry->empty()) {
             if (ui::begin_menu("Experimental Tabs")) {
                 for (auto&& tabRegistryEntry : *tabRegistry) {
                     if (ui::draw_menu_item(tabRegistryEntry.name())) {
-                        impl_select_tab(addTab(tabRegistryEntry.construct_tab(owner())));
+                        impl_select_tab(addTab(tabRegistryEntry.construct_tab(&owner())));
                     }
                 }
                 ui::end_menu();
@@ -728,7 +728,7 @@ class osc::MainUIScreen::Impl final : public ScreenPrivate {
         }
 
         if (m_MaybeScreenshotRequest.valid() and m_MaybeScreenshotRequest.wait_for(std::chrono::seconds{0}) == std::future_status::ready) {
-            const UID tabID = addTab(std::make_unique<ScreenshotTab>(owner(), m_MaybeScreenshotRequest.get()));
+            const UID tabID = addTab(std::make_unique<ScreenshotTab>(&owner(), m_MaybeScreenshotRequest.get()));
             impl_select_tab(tabID);
         }
     }

diff --git a/libopensimcreator/UI/MeshHittestTab.cpp b/libopensimcreator/UI/MeshHittestTab.cpp
@@ -40,8 +40,8 @@ using namespace osc;
 class osc::MeshHittestTab::Impl final : public TabPrivate {
 public:
 
-    explicit Impl(MeshHittestTab& owner, Widget& parent) :
-        TabPrivate{owner, &parent, OSC_ICON_COOKIE " MeshHittestTab"}
+    explicit Impl(MeshHittestTab& owner, Widget* parent) :
+        TabPrivate{owner, parent, OSC_ICON_COOKIE " MeshHittestTab"}
     {
         m_Camera.set_background_color(Color::white());
     }
@@ -170,13 +170,13 @@ class osc::MeshHittestTab::Impl final : public TabPrivate {
     Vec3 m_HitPos = {0.0f, 0.0f, 0.0f};
     Line m_Ray{};
 
-    PerfPanel m_PerfPanel;
+    PerfPanel m_PerfPanel{&owner()};
 };
 
 
 CStringView osc::MeshHittestTab::id() { return "OpenSim/MeshHittest"; }
 
-osc::MeshHittestTab::MeshHittestTab(Widget& parent) :
+osc::MeshHittestTab::MeshHittestTab(Widget* parent) :
     Tab{std::make_unique<Impl>(*this, parent)}
 {}
 void osc::MeshHittestTab::impl_on_tick() { private_data().on_tick(); }

diff --git a/libopensimcreator/UI/MeshHittestTab.h b/libopensimcreator/UI/MeshHittestTab.h
@@ -10,7 +10,7 @@ namespace osc
     public:
         static CStringView id();
 
-        explicit MeshHittestTab(Widget&);
+        explicit MeshHittestTab(Widget*);
 
     private:
         void impl_on_tick() final;

diff --git a/libopensimcreator/UI/MeshImporter/MeshImporterSharedState.h b/libopensimcreator/UI/MeshImporter/MeshImporterSharedState.h
@@ -79,11 +79,13 @@ namespace osc::mi
     // data that's shared between multiple UI states.
     class MeshImporterSharedState final {
     public:
-        MeshImporterSharedState() :
-            MeshImporterSharedState{std::vector<std::filesystem::path>{}}
+        MeshImporterSharedState(Widget* parent) :
+            MeshImporterSharedState{parent, std::vector<std::filesystem::path>{}}
         {}
 
-        explicit MeshImporterSharedState(std::vector<std::filesystem::path> meshFiles)
+        explicit MeshImporterSharedState(Widget* parent, std::vector<std::filesystem::path> meshFiles) :
+            m_Logviewer{parent},
+            m_PerfPanel{parent}
         {
             m_FloorMaterial.set_transparent(true);
             pushMeshLoadRequests(std::move(meshFiles));

diff --git a/libopensimcreator/UI/MeshImporter/MeshImporterTab.cpp b/libopensimcreator/UI/MeshImporter/MeshImporterTab.cpp
@@ -83,19 +83,19 @@ class osc::mi::MeshImporterTab::Impl final :
 public:
     explicit Impl(
         MeshImporterTab& owner,
-        Widget& parent_) :
+        Widget* parent_) :
 
-        TabPrivate{owner, &parent_, "MeshImporterTab"},
-        m_Shared{std::make_shared<MeshImporterSharedState>()}
+        TabPrivate{owner, parent_, "MeshImporterTab"},
+        m_Shared{std::make_shared<MeshImporterSharedState>(&owner)}
     {}
 
     explicit Impl(
         MeshImporterTab& owner,
-        Widget& parent_,
+        Widget* parent_,
         std::vector<std::filesystem::path> meshPaths_) :
 
-        TabPrivate{owner, &parent_, "MeshImporterTab"},
-        m_Shared{std::make_shared<MeshImporterSharedState>(std::move(meshPaths_))}
+        TabPrivate{owner, parent_, "MeshImporterTab"},
+        m_Shared{std::make_shared<MeshImporterSharedState>(&owner, std::move(meshPaths_))}
     {}
 
     bool isUnsaved() const
@@ -162,7 +162,7 @@ class osc::mi::MeshImporterTab::Impl final :
         // if some screen generated an OpenSim::Model, transition to the main editor
         if (m_Shared->hasOutputModel()) {
             auto tab = std::make_unique<ModelEditorTab>(
-                *parent(),
+                parent(),
                 std::move(m_Shared->updOutputModel()),
                 m_Shared->getSceneScaleFactor()
             );
@@ -179,7 +179,7 @@ class osc::mi::MeshImporterTab::Impl final :
 
         if (m_Shared->isNewMeshImpoterTabRequested())
         {
-            App::post_event<OpenTabEvent>(*parent(), std::make_unique<MeshImporterTab>(*parent()));
+            App::post_event<OpenTabEvent>(*parent(), std::make_unique<MeshImporterTab>(parent()));
             m_Shared->resetRequestNewMeshImporter();
         }
     }
@@ -2423,12 +2423,12 @@ class osc::mi::MeshImporterTab::Impl final :
 
 
 osc::mi::MeshImporterTab::MeshImporterTab(
-    Widget& parent_) :
+    Widget* parent_) :
 
     Tab{std::make_unique<Impl>(*this, parent_)}
 {}
 osc::mi::MeshImporterTab::MeshImporterTab(
-    Widget& parent_,
+    Widget* parent_,
     std::vector<std::filesystem::path> files_) :
 
     Tab{std::make_unique<Impl>(*this, parent_, std::move(files_))}

diff --git a/libopensimcreator/UI/MeshImporter/MeshImporterTab.h b/libopensimcreator/UI/MeshImporter/MeshImporterTab.h
@@ -13,8 +13,8 @@ namespace osc::mi
     public:
         static CStringView id() { return "OpenSim/MeshImporter"; }
 
-        explicit MeshImporterTab(Widget&);
-        MeshImporterTab(Widget&, std::vector<std::filesystem::path>);
+        explicit MeshImporterTab(Widget*);
+        explicit MeshImporterTab(Widget*, std::vector<std::filesystem::path>);
 
     private:
         bool impl_is_unsaved() const final;