Integrating latest 47acbe8

Gems/ScriptCanvasDeveloper/Code/Editor/Source/AutomationActions/DynamicSlotFullCreation.cpp

@@ -11,6 +11,8 @@
 */
 #include "precompiled.h"
 
+#include <QMenu>
+
 #include <GraphCanvas/Components/GridBus.h>
 #include <GraphCanvas/Components/Nodes/Comment/CommentBus.h>
 #include <GraphCanvas/Components/SceneBus.h>
@@ -42,6 +44,12 @@ namespace ScriptCanvasDeveloperEditor
         {
         public:
 
+            DynamicSlotFullCreationInterface(DeveloperUtils::ConnectionStyle connectionStyle)                
+            {
+                m_chainConfig.m_connectionStyle = connectionStyle;
+                m_chainConfig.m_skipHandlers = true;
+            }
+
             void SetupInterface(const AZ::EntityId& activeGraphCanvasGraphId, const ScriptCanvas::ScriptCanvasId& scriptCanvasId)
             {
                 m_graphCanvasGraphId = activeGraphCanvasGraphId;
@@ -52,6 +60,17 @@ namespace ScriptCanvasDeveloperEditor
 
                 GraphCanvas::GridRequestBus::EventResult(m_minorPitch, m_gridId, &GraphCanvas::GridRequests::GetMinorPitch);
 
+                QGraphicsScene* graphicsScene = nullptr;
+                GraphCanvas::SceneRequestBus::EventResult(graphicsScene, activeGraphCanvasGraphId, &GraphCanvas::SceneRequests::AsQGraphicsScene);
+
+                if (graphicsScene)
+                {
+                    QRectF sceneArea = graphicsScene->sceneRect();
+                    sceneArea.adjust(m_minorPitch.GetX(), m_minorPitch.GetY(), -m_minorPitch.GetX(), -m_minorPitch.GetY());
+                    GraphCanvas::ViewRequestBus::Event(m_viewId, &GraphCanvas::ViewRequests::CenterOnArea, sceneArea);
+                    QApplication::processEvents();
+                }
+
                 GraphCanvas::ViewRequestBus::EventResult(m_nodeCreationPos, m_viewId, &GraphCanvas::ViewRequests::GetViewSceneCenter);
 
                 GraphCanvas::GraphCanvasGraphicsView* graphicsView = nullptr;
@@ -80,6 +99,52 @@ namespace ScriptCanvasDeveloperEditor
                         }
                     }
                 }
+
+                // Temporary work around until the extra automation tools can be merged over that have better ways of doing this.
+                const GraphCanvas::GraphCanvasTreeItem* treeItem = nullptr;
+                ScriptCanvasEditor::AutomationRequestBus::BroadcastResult(treeItem, &ScriptCanvasEditor::AutomationRequests::GetNodePaletteRoot);
+
+                const GraphCanvas::NodePaletteTreeItem* onGraphStartItem = nullptr;
+
+                if (treeItem)
+                {
+                    AZStd::unordered_set< const GraphCanvas::GraphCanvasTreeItem* > unexploredSet = { treeItem };
+
+                    while (!unexploredSet.empty())
+                    {
+                        const GraphCanvas::GraphCanvasTreeItem* treeItem2 = (*unexploredSet.begin());
+                        unexploredSet.erase(unexploredSet.begin());
+
+                        const GraphCanvas::NodePaletteTreeItem* nodePaletteTreeItem = azrtti_cast<const GraphCanvas::NodePaletteTreeItem*>(treeItem2);
+
+                        if (nodePaletteTreeItem && nodePaletteTreeItem->GetName().compare("On Graph Start") == 0)
+                        {
+                            onGraphStartItem = nodePaletteTreeItem;
+                            break;
+                        }
+
+                        for (int i = 0; i < treeItem2->GetChildCount(); ++i)
+                        {
+                            const GraphCanvas::GraphCanvasTreeItem* childItem = treeItem2->FindChildByRow(i);
+
+                            if (childItem)
+                            {
+                                unexploredSet.insert(childItem);
+                            }
+                        }
+                    }
+                }
+
+                if (onGraphStartItem)
+                {
+                    GraphCanvas::GraphCanvasMimeEvent* mimeEvent = onGraphStartItem->CreateMimeEvent();
+
+                    if (mimeEvent)
+                    {
+                        ScriptCanvasEditor::NodeIdPair createdPair = DeveloperUtils::HandleMimeEvent(mimeEvent, m_graphCanvasGraphId, m_viewportRectangle, m_widthOffset, m_heightOffset, m_maxRowHeight, m_minorPitch);
+                        DeveloperUtils::CreateConnectedChain(createdPair, m_chainConfig);
+                    }
+                }
             }
 
             bool ShouldProcessItem([[maybe_unused]] const GraphCanvas::NodePaletteTreeItem* nodePaletteTreeItem) const
@@ -256,6 +321,7 @@ namespace ScriptCanvasDeveloperEditor
                     // If we succeeded, we need to update our offsets, and create a new node.
                     if (i >= slotOrdering.size())
                     {
+                        DeveloperUtils::CreateConnectedChain(nodeIdPair, m_chainConfig);
                         usedGraphCanvasNodeIds.emplace_back(nodeIdPair.m_graphCanvasId);
 
                         DeveloperUtils::UpdateViewportPositionOffsetForNode(nodeIdPair.m_graphCanvasId, m_viewportRectangle, m_widthOffset, m_heightOffset, m_maxRowHeight, m_minorPitch);
@@ -434,6 +500,8 @@ namespace ScriptCanvasDeveloperEditor
 
             ScriptCanvas::Graph* m_graph = nullptr;
 
+            DeveloperUtils::CreateConnectedChainConfig m_chainConfig;
+
             AZStd::vector<ScriptCanvas::VariableId> m_availableVariableIds;
             AZStd::unordered_map<ScriptCanvas::VariableId, ScriptCanvas::Data::Type> m_variableTypeMapping;
         };
@@ -442,28 +510,49 @@ namespace ScriptCanvasDeveloperEditor
         {
             ScriptCanvasEditor::AutomationRequestBus::Broadcast(&ScriptCanvasEditor::AutomationRequests::SignalAutomationBegin);
 
-            DynamicSlotFullCreationInterface fullCreationInterface;
+            DynamicSlotFullCreationInterface fullCreationInterface(DeveloperUtils::NoConnections);
             DeveloperUtils::ProcessNodePalette(fullCreationInterface);
 
             ScriptCanvasEditor::AutomationRequestBus::Broadcast(&ScriptCanvasEditor::AutomationRequests::SignalAutomationEnd);
         }
 
-        QAction* CreateDynamicSlotFullCreationAction(QWidget* mainWindow)
+        void VariablePaletteFullyConnectionCreationAction()
         {
-            QAction* createVariablePaletteAction = nullptr;
+            ScriptCanvasEditor::AutomationRequestBus::Broadcast(&ScriptCanvasEditor::AutomationRequests::SignalAutomationBegin);
 
-            if (mainWindow)
+            DynamicSlotFullCreationInterface fullCreationInterface(DeveloperUtils::SingleExecutionConnection);
+            DeveloperUtils::ProcessNodePalette(fullCreationInterface);
+
+            ScriptCanvasEditor::AutomationRequestBus::Broadcast(&ScriptCanvasEditor::AutomationRequests::SignalAutomationEnd);
+        }
+
+        QAction* CreateDynamicSlotFullCreationAction(QMenu* mainMenu)
+        {
+            QAction* dynamicSlotFullCreationAction = nullptr;
+
+            if (mainMenu)
             {
-                createVariablePaletteAction = new QAction(QAction::tr("Create Dynamic Node Range"), mainWindow);
-                createVariablePaletteAction->setAutoRepeat(false);
-                createVariablePaletteAction->setToolTip("Tries to create every node in the node palette with dynamic slots. And will generate variations of the node with variables assigned to each slot in each combination depending on what variables are available in the Variable Manager.");
-                createVariablePaletteAction->setShortcut(QKeySequence(QAction::tr("Ctrl+Shift+k", "Debug|Create Variable Palette")));
+                mainMenu->addSeparator();
 
-                mainWindow->addAction(createVariablePaletteAction);
-                mainWindow->connect(createVariablePaletteAction, &QAction::triggered, &VariablePaletteFullCreationAction);
+                {
+                    dynamicSlotFullCreationAction = mainMenu->addAction(QAction::tr("Mass Populate Dynamic Nodes"));
+                    dynamicSlotFullCreationAction->setAutoRepeat(false);
+                    dynamicSlotFullCreationAction->setToolTip("Tries to create every node in the node palette with dynamic slots.\nAnd will generate variations of the node with variables assigned to each slot in each combination depending on what variables are available in the Variable Manager.");
+                    dynamicSlotFullCreationAction->setShortcut(QKeySequence(QAction::tr("Ctrl+Shift+k", "Debug|Create Variable Palette")));
+
+                    QObject::connect(dynamicSlotFullCreationAction, &QAction::triggered, &VariablePaletteFullCreationAction);
+                }
+
+                {
+                    dynamicSlotFullCreationAction = mainMenu->addAction(QAction::tr("Mass Populate and Connect Dynamic Nodes"));
+                    dynamicSlotFullCreationAction->setAutoRepeat(false);
+                    dynamicSlotFullCreationAction->setToolTip("Tries to create and connect every node in the node palette with dynamic slots.\nAnd will generate variations of the node with variables assigned to each slot in each combination depending on what variables are available in the Variable Manager.");
+
+                    QObject::connect(dynamicSlotFullCreationAction, &QAction::triggered, &VariablePaletteFullyConnectionCreationAction);
+                }
             }
 
-            return createVariablePaletteAction;
+            return dynamicSlotFullCreationAction;
         }
     }
 }

Gems/ScriptCanvasDeveloper/Code/Editor/Source/AutomationActions/FullyConnectedNodePaletteCreation.cpp

@@ -0,0 +1,247 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+#include "precompiled.h"
+
+#include <QMenu>
+
+#include <GraphCanvas/Components/GridBus.h>
+#include <GraphCanvas/Components/Nodes/NodeBus.h>
+#include <GraphCanvas/Components/SceneBus.h>
+#include <GraphCanvas/Components/VisualBus.h>
+#include <GraphCanvas/Editor/EditorTypes.h>
+#include <GraphCanvas/Utils/GraphUtils.h>
+#include <GraphCanvas/Widgets/GraphCanvasGraphicsView/GraphCanvasGraphicsView.h>
+#include <GraphCanvas/Widgets/NodePalette/NodePaletteWidget.h>
+#include <GraphCanvas/Widgets/NodePalette/NodePaletteDockWidget.h>
+#include <GraphCanvas/Widgets/NodePalette/TreeItems/NodePaletteTreeItem.h>
+
+#include <ScriptCanvas/Bus/RequestBus.h>
+#include <ScriptCanvas/GraphCanvas/NodeDescriptorBus.h>
+#include <Editor/Include/ScriptCanvas/Bus/NodeIdPair.h>
+#include <Editor/View/Widgets/NodePalette/CreateNodeMimeEvent.h>
+#include <Editor/View/Widgets/NodePalette/GeneralNodePaletteTreeItemTypes.h>
+
+#include <ScriptCanvasDeveloperEditor/AutomationActions/NodePaletteFullCreation.h>
+#include <ScriptCanvasDeveloperEditor/DeveloperUtils.h>
+
+namespace ScriptCanvasDeveloperEditor
+{    
+    namespace NodePaletteFullCreation
+    {
+        class CreateFullyConnectedNodePaletteInterface
+            : public ProcessNodePaletteInterface
+        {
+        public:
+
+            CreateFullyConnectedNodePaletteInterface(DeveloperUtils::ConnectionStyle connectionStyle, bool skipHandlers = false)
+            {
+                m_chainConfig.m_connectionStyle = connectionStyle;
+                m_chainConfig.m_skipHandlers = skipHandlers;
+            }
+
+            void SetupInterface(const AZ::EntityId& activeGraphCanvasGraphId, const ScriptCanvas::ScriptCanvasId& scriptCanvasId)
+            {
+                m_graphCanvasGraphId = activeGraphCanvasGraphId;
+                m_scriptCanvasId = scriptCanvasId;
+                
+                GraphCanvas::SceneRequestBus::EventResult(m_viewId, activeGraphCanvasGraphId, &GraphCanvas::SceneRequests::GetViewId);
+                GraphCanvas::SceneRequestBus::EventResult(m_gridId, activeGraphCanvasGraphId, &GraphCanvas::SceneRequests::GetGrid);
+
+                GraphCanvas::GridRequestBus::EventResult(m_minorPitch, m_gridId, &GraphCanvas::GridRequests::GetMinorPitch);
+
+                QGraphicsScene* graphicsScene = nullptr;
+                GraphCanvas::SceneRequestBus::EventResult(graphicsScene, activeGraphCanvasGraphId, &GraphCanvas::SceneRequests::AsQGraphicsScene);
+
+                if (graphicsScene)
+                {
+                    QRectF sceneArea = graphicsScene->sceneRect();
+                    sceneArea.adjust(m_minorPitch.GetX(), m_minorPitch.GetY(), -m_minorPitch.GetX(), -m_minorPitch.GetY());
+                    GraphCanvas::ViewRequestBus::Event(m_viewId, &GraphCanvas::ViewRequests::CenterOnArea, sceneArea);
+                    QApplication::processEvents();
+                }
+
+                GraphCanvas::ViewRequestBus::EventResult(m_nodeCreationPos, m_viewId, &GraphCanvas::ViewRequests::GetViewSceneCenter);
+
+                GraphCanvas::GraphCanvasGraphicsView* graphicsView = nullptr;
+                GraphCanvas::ViewRequestBus::EventResult(graphicsView, m_viewId, &GraphCanvas::ViewRequests::AsGraphicsView);
+
+                m_viewportRectangle = graphicsView->mapToScene(graphicsView->viewport()->geometry()).boundingRect();
+
+                // Temporary work around until the extra automation tools can be merged over that have better ways of doing this.
+                const GraphCanvas::GraphCanvasTreeItem* treeItem = nullptr;
+                ScriptCanvasEditor::AutomationRequestBus::BroadcastResult(treeItem, &ScriptCanvasEditor::AutomationRequests::GetNodePaletteRoot);
+
+                const GraphCanvas::NodePaletteTreeItem* onGraphStartItem = nullptr;
+
+                if (treeItem)
+                {
+                    AZStd::unordered_set< const GraphCanvas::GraphCanvasTreeItem* > unexploredSet = { treeItem };
+
+                    while (!unexploredSet.empty())
+                    {
+                        const GraphCanvas::GraphCanvasTreeItem* treeItem = (*unexploredSet.begin());
+                        unexploredSet.erase(unexploredSet.begin());
+
+                        const GraphCanvas::NodePaletteTreeItem* nodePaletteTreeItem = azrtti_cast<const GraphCanvas::NodePaletteTreeItem*>(treeItem);
+
+                        if (nodePaletteTreeItem && nodePaletteTreeItem->GetName().compare("On Graph Start") == 0)
+                        {
+                            onGraphStartItem = nodePaletteTreeItem;
+                            break;
+                        }
+
+                        for (int i = 0; i < treeItem->GetChildCount(); ++i)
+                        {
+                            const GraphCanvas::GraphCanvasTreeItem* childItem = treeItem->FindChildByRow(i);
+
+                            if (childItem)
+                            {
+                                unexploredSet.insert(childItem);
+                            }
+                        }
+                    }
+                }
+
+                if (onGraphStartItem)
+                {
+                    ProcessItem(onGraphStartItem);
+                }
+            }
+
+            int m_counter = 60;
+            
+            bool ShouldProcessItem(const GraphCanvas::NodePaletteTreeItem* nodePaletteTreeItem) const
+            {
+                return m_counter > 0;
+            }
+            
+            void ProcessItem(const GraphCanvas::NodePaletteTreeItem* nodePaletteTreeItem)
+            {
+                GraphCanvas::GraphCanvasMimeEvent* mimeEvent = nodePaletteTreeItem->CreateMimeEvent();
+
+                if (ScriptCanvasEditor::MultiCreateNodeMimeEvent* multiCreateMimeEvent = azrtti_cast<ScriptCanvasEditor::MultiCreateNodeMimeEvent*>(mimeEvent))
+                {
+                    --m_counter;
+                    AZStd::vector< GraphCanvas::GraphCanvasMimeEvent* > mimeEvents = multiCreateMimeEvent->CreateMimeEvents();
+
+                    for (GraphCanvas::GraphCanvasMimeEvent* currentEvent : mimeEvents)
+                    {
+                        ScriptCanvasEditor::NodeIdPair createdPair = DeveloperUtils::HandleMimeEvent(currentEvent, m_graphCanvasGraphId, m_viewportRectangle, m_widthOffset, m_heightOffset, m_maxRowHeight, m_minorPitch);
+                        delete currentEvent;
+
+                        if (DeveloperUtils::CreateConnectedChain(createdPair, m_chainConfig))
+                        {
+                            m_createdNodes.emplace_back(createdPair);
+                        }
+                        else
+                        {
+                            m_nodesToDelete.insert(GraphCanvas::GraphUtils::FindOutermostNode(createdPair.m_graphCanvasId));
+                        }
+                    }
+                }
+                else if (mimeEvent)
+                {
+                    --m_counter;
+                    ScriptCanvasEditor::NodeIdPair createdPair = DeveloperUtils::HandleMimeEvent(mimeEvent, m_graphCanvasGraphId, m_viewportRectangle, m_widthOffset, m_heightOffset, m_maxRowHeight, m_minorPitch);
+
+                    if (DeveloperUtils::CreateConnectedChain(createdPair, m_chainConfig))
+                    {
+                        m_createdNodes.emplace_back(createdPair);
+                    }
+                    else
+                    {
+                        m_nodesToDelete.insert(GraphCanvas::GraphUtils::FindOutermostNode(createdPair.m_graphCanvasId));
+                    }
+                }
+
+                delete mimeEvent;
+            }
+        
+        private:
+
+            void OnProcessingComplete() override
+            {
+                GraphCanvas::SceneRequestBus::Event(m_graphCanvasGraphId, &GraphCanvas::SceneRequests::Delete, m_nodesToDelete);
+            }
+
+            DeveloperUtils::CreateConnectedChainConfig m_chainConfig;
+
+            AZStd::vector<ScriptCanvasEditor::NodeIdPair> m_createdNodes;
+            AZStd::unordered_set<AZ::EntityId> m_nodesToDelete;
+        
+            AZ::EntityId m_graphCanvasGraphId;
+            ScriptCanvas::ScriptCanvasId m_scriptCanvasId;
+        
+            AZ::Vector2 m_nodeCreationPos = AZ::Vector2::CreateZero();
+            
+            AZ::EntityId m_viewId;
+            AZ::EntityId m_gridId;
+            
+            AZ::Vector2 m_minorPitch = AZ::Vector2::CreateZero();
+            
+            QRectF m_viewportRectangle;
+            
+            int m_widthOffset = 0;
+            int m_heightOffset = 0;
+            
+            int m_maxRowHeight = 0;
+        };
+        
+        void CreateSingleExecutionConnectedNodePaletteAction()
+        {   
+            ScriptCanvasEditor::AutomationRequestBus::Broadcast(&ScriptCanvasEditor::AutomationRequests::SignalAutomationBegin);
+            
+            CreateFullyConnectedNodePaletteInterface nodePaletteInterface(DeveloperUtils::ConnectionStyle::SingleExecutionConnection);
+            DeveloperUtils::ProcessNodePalette(nodePaletteInterface);
+
+            ScriptCanvasEditor::AutomationRequestBus::Broadcast(&ScriptCanvasEditor::AutomationRequests::SignalAutomationEnd);
+        }
+
+        void CreateSingleExecutionConnectedNodePaletteExcludeHandlersAction()
+        {
+            ScriptCanvasEditor::AutomationRequestBus::Broadcast(&ScriptCanvasEditor::AutomationRequests::SignalAutomationBegin);
+
+            CreateFullyConnectedNodePaletteInterface nodePaletteInterface(DeveloperUtils::ConnectionStyle::SingleExecutionConnection, true);
+            DeveloperUtils::ProcessNodePalette(nodePaletteInterface);
+
+            ScriptCanvasEditor::AutomationRequestBus::Broadcast(&ScriptCanvasEditor::AutomationRequests::SignalAutomationEnd);
+        }
+
+        QAction* FullyConnectedNodePaletteCreation(QMenu* mainMenu)
+        {
+            QAction* createNodePaletteAction = nullptr;
+
+            if (mainMenu)
+            {
+                {
+                    createNodePaletteAction = mainMenu->addAction(QAction::tr("Create Execution Connected Node Palette"));
+                    createNodePaletteAction->setAutoRepeat(false);
+                    createNodePaletteAction->setToolTip("Tries to create every node in the node palette and will attempt to create an execution path through them.");
+
+                    QObject::connect(createNodePaletteAction, &QAction::triggered, &CreateSingleExecutionConnectedNodePaletteAction);
+                }
+
+                {
+                    createNodePaletteAction = mainMenu->addAction(QAction::tr("Create Execution Connected Node Palette sans Handlers"));
+                    createNodePaletteAction->setAutoRepeat(false);
+                    createNodePaletteAction->setToolTip("Tries to create every node in the node palette(except EBus Handlers) and attempt to create an execution path through them..");
+
+                    QObject::connect(createNodePaletteAction, &QAction::triggered, &CreateSingleExecutionConnectedNodePaletteExcludeHandlersAction);
+                }
+
+
+            }
+
+            return createNodePaletteAction;
+        }
+    }
+}

Gems/ScriptCanvasDeveloper/Code/Editor/Source/AutomationActions/NodePaletteFullCreation.cpp

@@ -11,6 +11,8 @@
 */
 #include "precompiled.h"
 
+#include <QMenu>
+
 #include <GraphCanvas/Components/SceneBus.h>
 #include <GraphCanvas/Components/GridBus.h>
 #include <GraphCanvas/Components/VisualBus.h>
@@ -109,19 +111,18 @@ namespace ScriptCanvasDeveloperEditor
             ScriptCanvasEditor::AutomationRequestBus::Broadcast(&ScriptCanvasEditor::AutomationRequests::SignalAutomationEnd);
         }
 
-        QAction* CreateNodePaletteFullCreationAction(QWidget* mainWindow)
+        QAction* CreateNodePaletteFullCreationAction(QMenu* mainMenu)
         {
             QAction* createNodePaletteAction = nullptr;
 
-            if (mainWindow)
+            if (mainMenu)
             {
-                createNodePaletteAction = new QAction(QAction::tr("Create Node Palette"), mainWindow);
+                createNodePaletteAction = mainMenu->addAction(QAction::tr("Create Node Palette"));
                 createNodePaletteAction->setAutoRepeat(false);
                 createNodePaletteAction->setToolTip("Tries to create every node in the node palette. All of them. At once.");
                 createNodePaletteAction->setShortcut(QKeySequence(QAction::tr("Ctrl+Shift+h", "Debug|Create Node Palette")));
 
-                mainWindow->addAction(createNodePaletteAction);
-                mainWindow->connect(createNodePaletteAction, &QAction::triggered, &NodePaletteFullCreationAction);
+                QObject::connect(createNodePaletteAction, &QAction::triggered, &NodePaletteFullCreationAction);
             }
 
             return createNodePaletteAction;

Gems/ScriptCanvasDeveloper/Code/Editor/Source/AutomationActions/VariableListFullCreation.cpp

@@ -11,6 +11,8 @@
 */
 #include "precompiled.h"
 
+#include <QMenu>
+
 #include <GraphCanvas/Components/SceneBus.h>
 #include <GraphCanvas/Components/GridBus.h>
 #include <GraphCanvas/Components/VisualBus.h>
@@ -84,19 +86,18 @@ namespace ScriptCanvasDeveloperEditor
             ScriptCanvasEditor::AutomationRequestBus::Broadcast(&ScriptCanvasEditor::AutomationRequests::SignalAutomationEnd);
         }
 
-        QAction* CreateVariablePaletteFullCreationAction(QWidget* mainWindow)
+        QAction* CreateVariablePaletteFullCreationAction(QMenu* mainMenu)
         {
             QAction* createVariablePaletteAction = nullptr;
 
-            if (mainWindow)
+            if (mainMenu)
             {
-                createVariablePaletteAction = new QAction(QAction::tr("Create Node Palette"), mainWindow);
+                createVariablePaletteAction = mainMenu->addAction(QAction::tr("Create All Variables"));
                 createVariablePaletteAction->setAutoRepeat(false);
                 createVariablePaletteAction->setToolTip("Tries to create every variable in the variable palette. All of them. At once.");
                 createVariablePaletteAction->setShortcut(QKeySequence(QAction::tr("Ctrl+Shift+j", "Debug|Create Variable Palette")));
 
-                mainWindow->addAction(createVariablePaletteAction);
-                mainWindow->connect(createVariablePaletteAction, &QAction::triggered, &VariablePaletteFullCreationAction);
+                QObject::connect(createVariablePaletteAction, &QAction::triggered, &VariablePaletteFullCreationAction);
             }
 
             return createVariablePaletteAction;