Merge branch 'development' of https://github.com/o3de/o3de into sc-editor-asset-redux

Signed-off-by: chcurran <82187351+carlitosan@users.noreply.github.com>

Gems/ScriptCanvas/Code/Editor/Assets/ScriptCanvasAssetTracker.cpp

@@ -252,6 +252,17 @@ namespace ScriptCanvasEditor
         m_assetsInUse.erase(assetId);
     }
 
+    void AssetTracker::RefreshAll()
+    {
+        for (const auto& asset : m_assetsInUse)
+        {
+            auto id = asset.second->GetScriptCanvasId();
+            ScriptCanvasEditor::EditorGraphRequestBus::Event(id, &ScriptCanvasEditor::EditorGraphRequests::ClearGraphCanvasScene);
+            ScriptCanvasEditor::EditorGraphRequestBus::Event(id, &ScriptCanvasEditor::EditorGraphRequests::CreateGraphCanvasScene);
+            ScriptCanvasEditor::EditorGraphRequestBus::Event(id, &ScriptCanvasEditor::EditorGraphRequests::DisplayGraphCanvasScene);
+        }
+    }
+
     void AssetTracker::CreateView(AZ::Data::AssetId assetId, QWidget* parent)
     {
         assetId = CheckAssetId(assetId);

Gems/ScriptCanvas/Code/Editor/Assets/ScriptCanvasAssetTracker.h

@@ -64,6 +64,7 @@ namespace ScriptCanvasEditor
         void CreateView(AZ::Data::AssetId assetId, QWidget* parent) override;
         void ClearView(AZ::Data::AssetId assetId) override;
         void UntrackAsset(AZ::Data::AssetId assetId) override;
+        void RefreshAll() override;
 
         // Getters
 

Gems/ScriptCanvas/Code/Editor/Assets/ScriptCanvasAssetTrackerBus.h

@@ -79,6 +79,9 @@ namespace ScriptCanvasEditor
         //! Used to make sure assets that are unloaded also get removed from tracking
         virtual void UntrackAsset([[maybe_unused]] AZ::Data::AssetId assetId) {}
 
+        //! Recreates the view for all tracked assets
+        virtual void RefreshAll() {}
+
         using AssetList = AZStd::vector<ScriptCanvasMemoryAsset::pointer>;
 
         // Accessors

Gems/ScriptCanvas/Code/Editor/Components/EditorGraph.cpp

@@ -1966,7 +1966,7 @@ namespace ScriptCanvasEditor
             }
 
             OnSaveDataDirtied(graphCanvasNodeId);
-            Nodes::CopySlotTranslationKeyedNamesToDatums(graphCanvasNodeId);
+            Nodes::UpdateSlotDatumLabels(graphCanvasNodeId);
         }
 
         m_wrappedNodeGroupings.clear();
@@ -1984,7 +1984,7 @@ namespace ScriptCanvasEditor
 
         for (AZ::EntityId graphCanvasNodeId : graphCanvasNodeIds)
         {
-            Nodes::CopySlotTranslationKeyedNamesToDatums(graphCanvasNodeId);
+            Nodes::UpdateSlotDatumLabels(graphCanvasNodeId);
         }
 
         GraphCanvas::ViewId viewId;

Gems/ScriptCanvas/Code/Editor/GraphCanvas/Components/NodeDescriptors/EBusHandlerEventNodeDescriptorComponent.cpp

@@ -148,8 +148,6 @@ namespace ScriptCanvasEditor
             AZ::Entity* entity = nullptr;
             AZ::ComponentApplicationBus::BroadcastResult(entity, &AZ::ComponentApplicationBus::Events::FindEntity, scriptCanvasId);
 
-            AZStd::string ebusContextName = TranslationHelper::GetEbusHandlerContext(m_busName);
-
             if (entity)
             {
                 ScriptCanvas::Nodes::Core::EBusEventHandler* eventHandler = AZ::EntityUtils::FindFirstDerivedComponent<ScriptCanvas::Nodes::Core::EBusEventHandler>(entity);
@@ -190,52 +188,63 @@ namespace ScriptCanvasEditor
 
                         if (scriptCanvasSlot && scriptCanvasSlot->IsVisible())
                         {
-                            AZ::EntityId slotId = Nodes::DisplayScriptCanvasSlot(GetEntityId(), (*scriptCanvasSlot));
+                            auto graphCanvasSlotId = Nodes::DisplayScriptCanvasSlot(GetEntityId(), (*scriptCanvasSlot));
 
-                            GraphCanvas::SlotRequestBus::Event(slotId, &GraphCanvas::SlotRequests::SetTranslationKeyedName, TranslationHelper::GetEBusHandlerOnEventTriggeredNameKey());
-                            GraphCanvas::SlotRequestBus::Event(slotId, &GraphCanvas::SlotRequests::SetTranslationKeyedTooltip, TranslationHelper::GetEBusHandlerOnEventTriggeredTooltipKey());
+                            GraphCanvas::TranslationKey key;
+                            key << "EBusHandler" << eventHandler->GetEBusName() << "methods" << m_eventName;
+                            if (scriptCanvasSlot->IsExecution() && scriptCanvasSlot->IsOutput())
+                            {
+                                key << "exit";
+                            }
+                            else
+                            {
+                                key << "details";
+                            }
+
+                            GraphCanvas::TranslationRequests::Details details;
+                            GraphCanvas::TranslationRequestBus::BroadcastResult(details, &GraphCanvas::TranslationRequests::GetDetails, key, details);
+                            GraphCanvas::SlotRequestBus::Event(graphCanvasSlotId, &GraphCanvas::SlotRequests::SetName, details.m_name);
+                            GraphCanvas::SlotRequestBus::Event(graphCanvasSlotId, &GraphCanvas::SlotRequests::SetTooltip, details.m_tooltip);
                         }
 
                         //
                         // inputCount and outputCount work because the order of the slots is maintained from the BehaviorContext, if this changes
                         // in the future then we should consider storing the actual offset or key name at that time.
                         //
-                        int inputCount = 0;
-                        int outputCount = 0;
+                        int paramIndex = 0;
+                        int outputIndex = 0;
                         for (const auto& slotId : myEvent.m_parameterSlotIds)
                         {
                             scriptCanvasSlot = eventHandler->GetSlot(slotId);
 
                             if (scriptCanvasSlot && scriptCanvasSlot->IsVisible())
                             {
-                                AZ::EntityId graphCanvasSlotId = Nodes::DisplayScriptCanvasSlot(GetEntityId(), (*scriptCanvasSlot));
+                                auto graphCanvasSlotId = Nodes::DisplayScriptCanvasSlot(GetEntityId(), (*scriptCanvasSlot));
+                                int& index = (scriptCanvasSlot->IsData() && scriptCanvasSlot->IsOutput()) ? paramIndex : outputIndex;
 
-                                TranslationItemType itemType = TranslationHelper::GetItemType(scriptCanvasSlot->GetDescriptor());
+                                GraphCanvas::TranslationRequests::Details details;
 
-                                GraphCanvas::TranslationKeyedString slotNameKeyedString(scriptCanvasSlot->GetName());
-                                slotNameKeyedString.m_context = ebusContextName;
+                                if (scriptCanvasSlot->IsData())
+                                {
+                                    GraphCanvas::TranslationKey key;
+                                    key = "EBusHandler";
+                                    key << eventHandler->GetEBusName() << "methods" << m_eventName << "params" << index << "details";
 
-                                GraphCanvas::TranslationKeyedString slotTooltipKeyedString(scriptCanvasSlot->GetToolTip());
-                                slotTooltipKeyedString.m_context = ebusContextName;
+                                    details.m_name = scriptCanvasSlot->GetName();
 
-                                slotNameKeyedString.SetFallback(scriptCanvasSlot->GetName());
-                                slotTooltipKeyedString.SetFallback(scriptCanvasSlot->GetToolTip());
+                                    GraphCanvas::TranslationRequestBus::BroadcastResult(details, &GraphCanvas::TranslationRequests::GetDetails, key, details);
+                                    GraphCanvas::SlotRequestBus::Event(graphCanvasSlotId, &GraphCanvas::SlotRequests::SetName, details.m_name);
+                                    GraphCanvas::SlotRequestBus::Event(graphCanvasSlotId, &GraphCanvas::SlotRequests::SetTooltip, details.m_tooltip);
+                                }
 
                                 if (scriptCanvasSlot->GetDescriptor() == ScriptCanvas::SlotDescriptors::DataOut())
                                 {
-                                    slotNameKeyedString.m_key = TranslationHelper::GetEBusHandlerSlotKey(m_busName, m_eventName, itemType, TranslationKeyId::Name, outputCount);
-                                    slotTooltipKeyedString.m_key = TranslationHelper::GetEBusHandlerSlotKey(m_busName, m_eventName, itemType, TranslationKeyId::Tooltip, outputCount);
-                                    ++outputCount;
+                                    ++outputIndex;
                                 }
                                 else
                                 {
-                                    slotNameKeyedString.m_key = TranslationHelper::GetEBusHandlerSlotKey(m_busName, m_eventName, itemType, TranslationKeyId::Name, inputCount);
-                                    slotTooltipKeyedString.m_key = TranslationHelper::GetEBusHandlerSlotKey(m_busName, m_eventName, itemType, TranslationKeyId::Tooltip, inputCount);
-                                    ++inputCount;
+                                    ++paramIndex;
                                 }
-
-                                GraphCanvas::SlotRequestBus::Event(graphCanvasSlotId, &GraphCanvas::SlotRequests::SetTranslationKeyedName, slotNameKeyedString);
-                                GraphCanvas::SlotRequestBus::Event(graphCanvasSlotId, &GraphCanvas::SlotRequests::SetTranslationKeyedTooltip, slotTooltipKeyedString);
                             }
                         }
 
@@ -245,18 +254,7 @@ namespace ScriptCanvasEditor
 
                             if (scriptCanvasSlot && scriptCanvasSlot->IsVisible())
                             {
-                                AZ::EntityId graphCanvasSlotId = Nodes::DisplayScriptCanvasSlot(GetEntityId(), (*scriptCanvasSlot));
-
-                                TranslationItemType itemType = TranslationHelper::GetItemType(scriptCanvasSlot->GetDescriptor());
-
-                                GraphCanvas::TranslationKeyedString slotNameKeyedString(scriptCanvasSlot->GetName(), ebusContextName);
-                                slotNameKeyedString.m_key = slotNameKeyedString.m_key = TranslationHelper::GetKey(TranslationContextGroup::EbusHandler, m_busName, m_eventName, itemType, TranslationKeyId::Name);
-
-                                GraphCanvas::TranslationKeyedString slotTooltipKeyedString(TranslationHelper::GetSafeTypeName(scriptCanvasSlot->GetDataType()), ebusContextName);
-                                slotTooltipKeyedString.m_key = TranslationHelper::GetKey(TranslationContextGroup::EbusHandler, m_busName, m_eventName, itemType, TranslationKeyId::Tooltip);
-
-                                GraphCanvas::SlotRequestBus::Event(graphCanvasSlotId, &GraphCanvas::SlotRequests::SetTranslationKeyedName, slotNameKeyedString);
-                                GraphCanvas::SlotRequestBus::Event(graphCanvasSlotId, &GraphCanvas::SlotRequests::SetTranslationKeyedTooltip, slotTooltipKeyedString);
+                                Nodes::DisplayScriptCanvasSlot(GetEntityId(), (*scriptCanvasSlot));
                             }
                         }
                         
@@ -345,9 +343,6 @@ namespace ScriptCanvasEditor
 
                 if (connectionType == GraphCanvas::ConnectionType::CT_Output)
                 {
-                    GraphCanvas::SlotRequestBus::Event(slotId, &GraphCanvas::SlotRequests::SetTranslationKeyedName, TranslationHelper::GetEBusHandlerOnEventTriggeredNameKey());
-                    GraphCanvas::SlotRequestBus::Event(slotId, &GraphCanvas::SlotRequests::SetTranslationKeyedTooltip, TranslationHelper::GetEBusHandlerOnEventTriggeredTooltipKey());
-
                     break;
                 }
             }

Gems/ScriptCanvas/Code/Editor/GraphCanvas/Components/NodeDescriptors/EBusHandlerNodeDescriptorComponent.cpp

@@ -210,10 +210,10 @@ namespace ScriptCanvasEditor
         {
             if (m_eventTypeToId.find(eventId) == m_eventTypeToId.end())
             {
-                AZStd::string eventName;                
+                AZStd::string eventName;
 
                 for (const HandlerEventConfiguration& testEventConfiguration : eventConfigurations)
-                {                    
+                {
                     if (testEventConfiguration.m_eventId == eventId)
                     {
                         eventName = testEventConfiguration.m_eventName;
@@ -540,8 +540,11 @@ namespace ScriptCanvasEditor
 
                         if (slotType == GraphCanvas::SlotTypes::DataSlot)
                         {
-                            GraphCanvas::SlotRequestBus::Event(testSlotId, &GraphCanvas::SlotRequests::SetTranslationKeyedName, TranslationHelper::GetEBusHandlerBusIdNameKey());
-                            GraphCanvas::SlotRequestBus::Event(testSlotId, &GraphCanvas::SlotRequests::SetTranslationKeyedTooltip, TranslationHelper::GetEBusHandlerBusIdTooltipKey());
+                            GraphCanvas::TranslationKey key;
+                            key << Translation::GlobalKeys::EBusHandlerIDKey << ".details";
+                            GraphCanvas::TranslationRequests::Details details;
+                            GraphCanvas::TranslationRequestBus::BroadcastResult(details, &GraphCanvas::TranslationRequests::GetDetails, key, details);
+                            GraphCanvas::SlotRequestBus::Event(testSlotId, &GraphCanvas::SlotRequests::SetDetails, details.m_name, details.m_tooltip);
                             break;
                         }
                     }

Gems/ScriptCanvas/Code/Editor/GraphCanvas/Components/NodeDescriptors/EBusSenderNodeDescriptorComponent.cpp

@@ -68,9 +68,6 @@ namespace ScriptCanvasEditor
 
                             if (currentSlotId == slotId)
                             {
-                                GraphCanvas::SlotRequestBus::Event(graphCanvasId, &GraphCanvas::SlotRequests::SetTranslationKeyedName, TranslationHelper::GetEBusSenderBusIdNameKey());
-                                GraphCanvas::SlotRequestBus::Event(graphCanvasId, &GraphCanvas::SlotRequests::SetTranslationKeyedTooltip, TranslationHelper::GetEBusSenderBusIdTooltipKey());
-
                                 break;
                             }
                         }

Gems/ScriptCanvas/Code/Editor/GraphCanvas/Components/NodeDescriptors/ScriptEventReceiverEventNodeDescriptorComponent.cpp

@@ -142,8 +142,6 @@ namespace ScriptCanvasEditor
             m_ebusWrapper.m_graphCanvasId = wrappingNode;
             m_ebusWrapper.m_scriptCanvasId = scriptCanvasId;
 
-            AZStd::string ebusContextName = TranslationHelper::GetEbusHandlerContext(m_busName);
-
             ScriptCanvas::Nodes::Core::ReceiveScriptEvent* eventHandler = AZ::EntityUtils::FindFirstDerivedComponent<ScriptCanvas::Nodes::Core::ReceiveScriptEvent>(scriptCanvasId);
             if (eventHandler)
             {
@@ -179,49 +177,20 @@ namespace ScriptCanvasEditor
 
                     if (scriptCanvasSlot && scriptCanvasSlot->IsVisible())
                     {
-                        AZ::EntityId slotId = Nodes::DisplayScriptCanvasSlot(GetEntityId(), (*scriptCanvasSlot));
-
-                        GraphCanvas::SlotRequestBus::Event(slotId, &GraphCanvas::SlotRequests::SetTranslationKeyedName, TranslationHelper::GetEBusHandlerOnEventTriggeredNameKey());
-                        GraphCanvas::SlotRequestBus::Event(slotId, &GraphCanvas::SlotRequests::SetTranslationKeyedTooltip, TranslationHelper::GetEBusHandlerOnEventTriggeredTooltipKey());
+                        Nodes::DisplayScriptCanvasSlot(GetEntityId(), (*scriptCanvasSlot));
                     }
 
                     //
                     // inputCount and outputCount work because the order of the slots is maintained from the BehaviorContext, if this changes
                     // in the future then we should consider storing the actual offset or key name at that time.
                     //
-                    int inputCount = 0;
-                    int outputCount = 0;
                     for (const auto& slotId : myEvent.m_parameterSlotIds)
                     {
                         scriptCanvasSlot = eventHandler->GetSlot(slotId);
 
                         if (scriptCanvasSlot && scriptCanvasSlot->IsVisible())
                         {
-                            AZ::EntityId graphCanvasSlotId = Nodes::DisplayScriptCanvasSlot(GetEntityId(), (*scriptCanvasSlot));
-
-                            TranslationItemType itemType = TranslationHelper::GetItemType(scriptCanvasSlot->GetDescriptor());
-
-                            GraphCanvas::TranslationKeyedString slotNameKeyedString(scriptCanvasSlot->GetName());
-                            slotNameKeyedString.m_context = ebusContextName;
-
-                            GraphCanvas::TranslationKeyedString slotTooltipKeyedString(scriptCanvasSlot->GetToolTip());
-                            slotTooltipKeyedString.m_context = ebusContextName;
-
-                            if (scriptCanvasSlot->GetDescriptor() == ScriptCanvas::SlotDescriptors::DataOut())
-                            {
-                                slotNameKeyedString.m_key = TranslationHelper::GetEBusHandlerSlotKey(m_busName, m_eventName, itemType, TranslationKeyId::Name, outputCount);
-                                slotTooltipKeyedString.m_key = TranslationHelper::GetEBusHandlerSlotKey(m_busName, m_eventName, itemType, TranslationKeyId::Tooltip, outputCount);
-                                ++outputCount;
-                            }
-                            else
-                            {
-                                slotNameKeyedString.m_key = TranslationHelper::GetEBusHandlerSlotKey(m_busName, m_eventName, itemType, TranslationKeyId::Name, inputCount);
-                                slotTooltipKeyedString.m_key = TranslationHelper::GetEBusHandlerSlotKey(m_busName, m_eventName, itemType, TranslationKeyId::Tooltip, inputCount);
-                                ++inputCount;
-                            }
-
-                            GraphCanvas::SlotRequestBus::Event(graphCanvasSlotId, &GraphCanvas::SlotRequests::SetTranslationKeyedName, slotNameKeyedString);
-                            GraphCanvas::SlotRequestBus::Event(graphCanvasSlotId, &GraphCanvas::SlotRequests::SetTranslationKeyedTooltip, slotTooltipKeyedString);
+                            Nodes::DisplayScriptCanvasSlot(GetEntityId(), (*scriptCanvasSlot));
                         }
                     }
 
@@ -231,18 +200,7 @@ namespace ScriptCanvasEditor
 
                         if (scriptCanvasSlot && scriptCanvasSlot->IsVisible())
                         {
-                            AZ::EntityId graphCanvasSlotId = Nodes::DisplayScriptCanvasSlot(GetEntityId(), (*scriptCanvasSlot));
-
-                            TranslationItemType itemType = TranslationHelper::GetItemType(scriptCanvasSlot->GetDescriptor());
-
-                            GraphCanvas::TranslationKeyedString slotNameKeyedString(scriptCanvasSlot->GetName(), ebusContextName);
-                            slotNameKeyedString.m_key = slotNameKeyedString.m_key = TranslationHelper::GetKey(TranslationContextGroup::EbusHandler, m_busName, m_eventName, itemType, TranslationKeyId::Name);
-
-                            GraphCanvas::TranslationKeyedString slotTooltipKeyedString(TranslationHelper::GetSafeTypeName(scriptCanvasSlot->GetDataType()), ebusContextName);
-                            slotTooltipKeyedString.m_key = TranslationHelper::GetKey(TranslationContextGroup::EbusHandler, m_busName, m_eventName, itemType, TranslationKeyId::Tooltip);
-
-                            GraphCanvas::SlotRequestBus::Event(graphCanvasSlotId, &GraphCanvas::SlotRequests::SetTranslationKeyedName, slotNameKeyedString);
-                            GraphCanvas::SlotRequestBus::Event(graphCanvasSlotId, &GraphCanvas::SlotRequests::SetTranslationKeyedTooltip, slotTooltipKeyedString);
+                            Nodes::DisplayScriptCanvasSlot(GetEntityId(), (*scriptCanvasSlot));
                         }
                     }
 
@@ -367,9 +325,6 @@ namespace ScriptCanvasEditor
 
                 if (connectionType == GraphCanvas::ConnectionType::CT_Output)
                 {
-                    GraphCanvas::SlotRequestBus::Event(slotId, &GraphCanvas::SlotRequests::SetTranslationKeyedName, TranslationHelper::GetEBusHandlerOnEventTriggeredNameKey());
-                    GraphCanvas::SlotRequestBus::Event(slotId, &GraphCanvas::SlotRequests::SetTranslationKeyedTooltip, TranslationHelper::GetEBusHandlerOnEventTriggeredTooltipKey());
-
                     break;
                 }
             }

Gems/ScriptCanvas/Code/Editor/GraphCanvas/Components/NodeDescriptors/ScriptEventReceiverNodeDescriptorComponent.cpp

@@ -560,8 +560,11 @@ namespace ScriptCanvasEditor
 
                         if (slotType == GraphCanvas::SlotTypes::DataSlot)
                         {
-                            GraphCanvas::SlotRequestBus::Event(testSlotId, &GraphCanvas::SlotRequests::SetTranslationKeyedName, TranslationHelper::GetEBusHandlerBusIdNameKey());
-                            GraphCanvas::SlotRequestBus::Event(testSlotId, &GraphCanvas::SlotRequests::SetTranslationKeyedTooltip, TranslationHelper::GetEBusHandlerBusIdTooltipKey());
+                            GraphCanvas::TranslationKey key;
+                            key << Translation::GlobalKeys::EBusHandlerIDKey << "details";
+                            GraphCanvas::TranslationRequests::Details details;
+                            GraphCanvas::TranslationRequestBus::BroadcastResult(details, &GraphCanvas::TranslationRequests::GetDetails, key, details);
+                            GraphCanvas::SlotRequestBus::Event(testSlotId, &GraphCanvas::SlotRequests::SetDetails, details.m_name, details.m_tooltip);
                             break;
                         }
                     }

Gems/ScriptCanvas/Code/Editor/GraphCanvas/Components/NodeDescriptors/ScriptEventSenderNodeDescriptorComponent.cpp

@@ -118,9 +118,6 @@ namespace ScriptCanvasEditor
 
                         if (currentSlotId == slotId)
                         {
-                            GraphCanvas::SlotRequestBus::Event(graphCanvasId, &GraphCanvas::SlotRequests::SetTranslationKeyedName, TranslationHelper::GetEBusSenderBusIdNameKey());
-                            GraphCanvas::SlotRequestBus::Event(graphCanvasId, &GraphCanvas::SlotRequests::SetTranslationKeyedTooltip, TranslationHelper::GetEBusSenderBusIdTooltipKey());
-
                             break;
                         }
                     }

Gems/ScriptCanvas/Code/Editor/Nodes/NodeDisplayUtils.cpp

@@ -28,6 +28,7 @@
 #include <GraphCanvas/Components/NodeDescriptors/ScriptEventSenderNodeDescriptorComponent.h>
 #include <GraphCanvas/Components/NodeDescriptors/UserDefinedNodeDescriptorComponent.h>
 #include <GraphCanvas/Components/NodeDescriptors/FunctionDefinitionNodeDescriptorComponent.h>
+#include <GraphCanvas/Components/Slots/SlotBus.h>
 
 #include <GraphCanvas/Components/Nodes/NodeTitleBus.h>
 #include <GraphCanvas/GraphCanvasBus.h>
@@ -45,6 +46,8 @@
 #include <ScriptCanvas/Libraries/Core/SendScriptEvent.h>
 #include <ScriptCanvas/Libraries/Core/SetVariable.h>
 
+#include <Source/Translation/TranslationBus.h>
+
 namespace ScriptCanvasEditor::Nodes::SlotDisplayHelper
 {
     AZ::EntityId DisplayPropertySlot(AZ::EntityId graphCanvasNodeId, const ScriptCanvas::VisualExtensionSlotConfiguration& propertyConfiguration);
@@ -101,37 +104,56 @@ namespace ScriptCanvasEditor::Nodes
             *graphCanvasUserData = node->GetEntityId();
         }
 
-        GraphCanvas::TranslationKeyedString nodeKeyedString(nodeConfiguration.m_titleFallback, nodeConfiguration.m_translationContext);
-        nodeKeyedString.m_key = TranslationHelper::GetKey(nodeConfiguration.m_translationGroup, nodeConfiguration.m_translationKeyContext, nodeConfiguration.m_translationKeyName, TranslationItemType::Node, TranslationKeyId::Name);
+        GraphCanvas::TranslationKey key;
+        key << "ScriptCanvas::Node" << azrtti_typeid(node).ToString<AZStd::string>() << "details";
 
-        AZStd::string nodeName = nodeKeyedString.GetDisplayString();
-
-        int paramIndex = 0;
-        int outputIndex = 0;
+        GraphCanvas::TranslationRequests::Details details;
+        GraphCanvas::TranslationRequestBus::BroadcastResult(details, &GraphCanvas::TranslationRequests::GetDetails, key, details);
 
         // Create the GraphCanvas slots
         for (const auto& slot : node->GetSlots())
         {
+            GraphCanvas::TranslationKey slotKey;
+            slotKey << "ScriptCanvas::Node" << azrtti_typeid(node).ToString<AZStd::string>() << "slots";
+
             if (slot.IsVisible())
             {
-                AZ::EntityId graphCanvasSlotId = DisplayScriptCanvasSlot(graphCanvasEntity->GetId(), slot);
-
-                GraphCanvas::TranslationKeyedString slotNameKeyedString(slot.GetName(), nodeKeyedString.m_context);
-                GraphCanvas::TranslationKeyedString slotTooltipKeyedString(slot.GetToolTip(), nodeKeyedString.m_context);
-
-                TranslationItemType itemType = TranslationHelper::GetItemType(slot.GetDescriptor());
-
-                if (itemType == TranslationItemType::ParamDataSlot || itemType == TranslationItemType::ReturnDataSlot)
+                AZStd::string slotKeyStr;
+                if (slot.IsData())
                 {
-                    int& index = (itemType == TranslationItemType::ParamDataSlot) ? paramIndex : outputIndex;
-
-                    slotNameKeyedString.m_key = TranslationHelper::GetKey(nodeConfiguration.m_translationGroup, nodeConfiguration.m_translationKeyContext, nodeConfiguration.m_translationKeyName, itemType, TranslationKeyId::Name, index);
-                    slotTooltipKeyedString.m_key = TranslationHelper::GetKey(nodeConfiguration.m_translationGroup, nodeConfiguration.m_translationKeyContext, nodeConfiguration.m_translationKeyName, itemType, TranslationKeyId::Tooltip, index);
-                    index++;
+                    slotKeyStr.append("Data");
                 }
 
-                GraphCanvas::SlotRequestBus::Event(graphCanvasSlotId, &GraphCanvas::SlotRequests::SetTranslationKeyedName, slotNameKeyedString);
-                GraphCanvas::SlotRequestBus::Event(graphCanvasSlotId, &GraphCanvas::SlotRequests::SetTranslationKeyedTooltip, slotTooltipKeyedString);
+                if (slot.GetConnectionType() == ScriptCanvas::ConnectionType::Input)
+                {
+                    slotKeyStr.append("Input_");
+                }
+                else
+                {
+                    slotKeyStr.append("Output_");
+                }
+
+                slotKeyStr.append(slot.GetName());
+
+                slotKey << slotKeyStr << "details";
+
+                GraphCanvas::TranslationRequests::Details slotDetails;
+                GraphCanvas::TranslationRequestBus::BroadcastResult(slotDetails, &GraphCanvas::TranslationRequests::GetDetails, slotKey, slotDetails);
+
+                if (slotDetails.m_name.empty())
+                {
+                    slotDetails.m_name = slot.GetName();
+                }
+
+                if (slotDetails.m_tooltip.empty())
+                {
+                    slotDetails.m_tooltip = slot.GetToolTip();
+                }
+
+                AZ::EntityId graphCanvasSlotId = DisplayScriptCanvasSlot(graphCanvasEntity->GetId(), slot);
+
+                GraphCanvas::SlotRequestBus::Event(graphCanvasSlotId, &GraphCanvas::SlotRequests::SetName, slotDetails.m_name);
+                GraphCanvas::SlotRequestBus::Event(graphCanvasSlotId, &GraphCanvas::SlotRequests::SetTooltip, slotDetails.m_tooltip);
             }
         }
 
@@ -142,25 +164,17 @@ namespace ScriptCanvasEditor::Nodes
             SlotDisplayHelper::DisplayVisualExtensionSlot(graphCanvasEntity->GetId(), extensionConfiguration);
         }
 
-        GraphCanvas::TranslationKeyedString subtitleKeyedString(nodeConfiguration.m_subtitleFallback, nodeConfiguration.m_translationContext);
-        subtitleKeyedString.m_key = TranslationHelper::GetKey(nodeConfiguration.m_translationGroup, nodeConfiguration.m_translationKeyContext, nodeConfiguration.m_translationKeyName, TranslationItemType::Node, TranslationKeyId::Category);
+        graphCanvasEntity->SetName(AZStd::string::format("GC-Node(%s)", details.m_name.c_str()));
 
-        graphCanvasEntity->SetName(AZStd::string::format("GC-Node(%s)", nodeKeyedString.GetDisplayString().c_str()));
-
-        GraphCanvas::NodeTitleRequestBus::Event(graphCanvasEntity->GetId(), &GraphCanvas::NodeTitleRequests::SetTranslationKeyedTitle, nodeKeyedString);
-        GraphCanvas::NodeTitleRequestBus::Event(graphCanvasEntity->GetId(), &GraphCanvas::NodeTitleRequests::SetTranslationKeyedSubTitle, subtitleKeyedString);
+        GraphCanvas::NodeTitleRequestBus::Event(graphCanvasEntity->GetId(), &GraphCanvas::NodeTitleRequests::SetTitle, details.m_name);
+        GraphCanvas::NodeTitleRequestBus::Event(graphCanvasEntity->GetId(), &GraphCanvas::NodeTitleRequests::SetSubTitle, details.m_category);
+        GraphCanvas::NodeRequestBus::Event(graphCanvasEntity->GetId(), &GraphCanvas::NodeRequests::SetTooltip, details.m_tooltip);
 
         if (!nodeConfiguration.m_titlePalette.empty())
         {
             GraphCanvas::NodeTitleRequestBus::Event(graphCanvasEntity->GetId(), &GraphCanvas::NodeTitleRequests::SetPaletteOverride, nodeConfiguration.m_titlePalette);
         }
 
-        // Set the name
-        GraphCanvas::TranslationKeyedString tooltipKeyedString(nodeConfiguration.m_tooltipFallback, nodeConfiguration.m_translationContext);
-        tooltipKeyedString.m_key = TranslationHelper::GetKey(TranslationContextGroup::ClassMethod, nodeConfiguration.m_translationKeyContext, nodeConfiguration.m_translationKeyName, TranslationItemType::Node, TranslationKeyId::Tooltip);
-
-        GraphCanvas::NodeRequestBus::Event(graphCanvasEntity->GetId(), &GraphCanvas::NodeRequests::SetTranslationKeyedTooltip, tooltipKeyedString);
-
         EditorNodeNotificationBus::Event(node->GetEntityId(), &EditorNodeNotifications::OnGraphCanvasNodeDisplayed, graphCanvasEntity->GetId());
 
         return graphCanvasEntity->GetId();
@@ -193,22 +207,6 @@ namespace ScriptCanvasEditor::Nodes
 
         if (classData)
         {
-            AZStd::string nodeContext = GetContextName(*classData);
-            nodeConfiguration.m_translationContext = TranslationHelper::GetUserDefinedContext(nodeContext);
-
-            nodeConfiguration.m_titleFallback = (classData->m_editData && classData->m_editData->m_name) ? classData->m_editData->m_name : classData->m_name;
-            nodeConfiguration.m_tooltipFallback = (classData->m_editData && classData->m_editData->m_description) ? classData->m_editData->m_description : "";
-
-            GraphCanvas::TranslationKeyedString subtitleKeyedString(nodeContext, nodeConfiguration.m_translationContext);
-            subtitleKeyedString.m_key = TranslationHelper::GetUserDefinedNodeKey(nodeContext, nodeConfiguration.m_titleFallback, ScriptCanvasEditor::TranslationKeyId::Category);
-
-            nodeConfiguration.m_subtitleFallback = subtitleKeyedString.GetDisplayString();
-
-            nodeConfiguration.m_translationKeyName = nodeConfiguration.m_titleFallback;
-            nodeConfiguration.m_translationKeyContext = nodeContext;
-
-            nodeConfiguration.m_translationGroup = TranslationContextGroup::ClassMethod;
-
             if (classData->m_editData)
             {
                 const AZ::Edit::ElementData* elementData = classData->m_editData->FindElementData(AZ::Edit::ClassElements::EditorData);
@@ -260,20 +258,16 @@ namespace ScriptCanvasEditor::Nodes
         graphCanvasEntity->CreateComponent<SlotMappingComponent>(methodNode->GetEntityId());
         graphCanvasEntity->CreateComponent<SceneMemberMappingComponent>(methodNode->GetEntityId());
 
-        TranslationContextGroup contextGroup = TranslationContextGroup::Invalid;
-
         switch (methodNode->GetMethodType())
         {
         case ScriptCanvas::MethodType::Event:
             graphCanvasEntity->CreateComponent<EBusSenderNodeDescriptorComponent>();
-            contextGroup = TranslationContextGroup::EbusSender;
             break;
         case ScriptCanvas::MethodType::Member:
         case ScriptCanvas::MethodType::Getter:
         case ScriptCanvas::MethodType::Setter:
         case ScriptCanvas::MethodType::Free:
             graphCanvasEntity->CreateComponent<ClassMethodNodeDescriptorComponent>();
-            contextGroup = TranslationContextGroup::ClassMethod;
             break;
         default:
             AZ_Error("ScriptCanvas", false, "Invalid method node type, node creation failed. This node needs to be deleted.");
@@ -292,19 +286,22 @@ namespace ScriptCanvasEditor::Nodes
             *graphCanvasUserData = methodNode->GetEntityId();
         }
 
+        const bool isEBusSender = (methodNode->GetMethodType() == ScriptCanvas::MethodType::Event);
         const AZStd::string& className = methodNode->GetMethodClassName();
         const AZStd::string& methodName = methodNode->GetName();
 
-        AZStd::string translationContext = TranslationHelper::GetContextName(contextGroup, className);
+        GraphCanvas::TranslationKey key;
+        key = isEBusSender ? "EBusSender" : "BehaviorClass";
+        key << className;
+        key << "methods" << methodName;
 
-        GraphCanvas::TranslationKeyedString nodeKeyedString(methodName, translationContext);
-        nodeKeyedString.m_key = TranslationHelper::GetKey(contextGroup, className, methodName, TranslationItemType::Node, TranslationKeyId::Name);
+        GraphCanvas::TranslationRequests::Details details;
+        details.m_name = methodName;
 
-        GraphCanvas::TranslationKeyedString classKeyedString(className, translationContext);
-        classKeyedString.m_key = TranslationHelper::GetClassKey(contextGroup, className, TranslationKeyId::Name);
+        GraphCanvas::TranslationRequestBus::BroadcastResult(details, &GraphCanvas::TranslationRequests::GetDetails, key + ".details", details);
 
-        GraphCanvas::TranslationKeyedString tooltipKeyedString(AZStd::string(), translationContext);
-        tooltipKeyedString.m_key = TranslationHelper::GetKey(contextGroup, className, methodName, TranslationItemType::Node, TranslationKeyId::Tooltip);
+        GraphCanvas::NodeTitleRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeTitleRequests::SetDetails, details.m_name, details.m_subtitle);
+        GraphCanvas::NodeRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeRequests::SetTooltip, details.m_tooltip);
 
         int paramIndex = 0;
         int outputIndex = 0;
@@ -312,37 +309,51 @@ namespace ScriptCanvasEditor::Nodes
         auto busId = methodNode->GetBusSlotId();
         for (const auto& slot : methodNode->GetSlots())
         {
+            GraphCanvas::TranslationKey slotKey = key;
+
             if (slot.IsVisible())
             {
                 AZ::EntityId graphCanvasSlotId = DisplayScriptCanvasSlot(graphCanvasNodeId, slot);
 
-                GraphCanvas::TranslationKeyedString slotNameKeyedString(slot.GetName(), translationContext);
-                GraphCanvas::TranslationKeyedString slotTooltipKeyedString(slot.GetToolTip(), translationContext);
+                details.m_name = slot.GetName();
+                details.m_tooltip = slot.GetToolTip();
 
                 if (methodNode->HasBusID() && busId == slot.GetId() && slot.GetDescriptor() == ScriptCanvas::SlotDescriptors::DataIn())
                 {
-                    slotNameKeyedString = TranslationHelper::GetEBusSenderBusIdNameKey();
-                    slotTooltipKeyedString = TranslationHelper::GetEBusSenderBusIdTooltipKey();
+                    key = Translation::GlobalKeys::EBusSenderIDKey;
+                    GraphCanvas::TranslationRequestBus::BroadcastResult(details, &GraphCanvas::TranslationRequests::GetDetails, key + ".details", details);
                 }
                 else
                 {
-                    TranslationItemType itemType = TranslationHelper::GetItemType(slot.GetDescriptor());
+                    int& index = (slot.IsData() && slot.IsInput()) ? paramIndex : outputIndex;
 
-                    int& index = (itemType == TranslationItemType::ParamDataSlot) ? paramIndex : outputIndex;
+                    if (slot.IsData())
+                    {
+                        key = isEBusSender ? "EBusSender" : "BehaviorClass";
+                        key << className << "methods" << methodName;
+                        if (slot.IsData() && slot.IsInput())
+                        {
+                            key << "params";
+                        }
+                        else
+                        {
+                            key << "results";
+                        }
+                        key << index;
 
-                    slotNameKeyedString.m_key = TranslationHelper::GetKey(contextGroup, className, methodName, itemType, TranslationKeyId::Name, index);
-                    slotTooltipKeyedString.m_key = TranslationHelper::GetKey(contextGroup, className, methodName, itemType, TranslationKeyId::Tooltip, index);
+                        GraphCanvas::TranslationRequestBus::BroadcastResult(details, &GraphCanvas::TranslationRequests::GetDetails, key + ".details", details);
+                    }
 
-                    if ((itemType == TranslationItemType::ParamDataSlot) || (itemType == TranslationItemType::ReturnDataSlot))
+                    if (slot.IsData())
                     {
                         index++;
                     }
                 }
 
-                GraphCanvas::SlotRequestBus::Event(graphCanvasSlotId, &GraphCanvas::SlotRequests::SetTranslationKeyedName, slotNameKeyedString);
-                GraphCanvas::SlotRequestBus::Event(graphCanvasSlotId, &GraphCanvas::SlotRequests::SetTranslationKeyedTooltip, slotTooltipKeyedString);
+                GraphCanvas::SlotRequestBus::Event(graphCanvasSlotId, &GraphCanvas::SlotRequests::SetDetails, details.m_name, details.m_tooltip);
+
+                UpdateSlotDatumLabel(graphCanvasNodeId, slot.GetId(), details.m_name);
 
-                CopyTranslationKeyedNameToDatumLabel(graphCanvasNodeId, slot.GetId(), graphCanvasSlotId);
             }
         }
 
@@ -350,10 +361,6 @@ namespace ScriptCanvasEditor::Nodes
         AZStd::string displayName = methodNode->GetName();
         graphCanvasEntity->SetName(AZStd::string::format("GC-Node(%s)", displayName.c_str()));
 
-        GraphCanvas::NodeRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeRequests::SetTranslationKeyedTooltip, tooltipKeyedString);
-
-        GraphCanvas::NodeTitleRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeTitleRequests::SetTranslationKeyedTitle, nodeKeyedString);
-        GraphCanvas::NodeTitleRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeTitleRequests::SetTranslationKeyedSubTitle, classKeyedString);
         GraphCanvas::NodeTitleRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeTitleRequests::SetPaletteOverride, "MethodNodeTitlePalette");
 
         // Override the title if it has the Setter or Getter suffixes
@@ -420,24 +427,30 @@ namespace ScriptCanvasEditor::Nodes
 
                 if (busNode->IsIDRequired() && slot->GetDescriptor() == ScriptCanvas::SlotDescriptors::DataIn())
                 {
-                    GraphCanvas::SlotRequestBus::Event(gcSlotId, &GraphCanvas::SlotRequests::SetTranslationKeyedName, TranslationHelper::GetEBusHandlerBusIdNameKey());
-                    GraphCanvas::SlotRequestBus::Event(gcSlotId, &GraphCanvas::SlotRequests::SetTranslationKeyedTooltip, TranslationHelper::GetEBusHandlerBusIdTooltipKey());
+                    GraphCanvas::TranslationKey key;
+                    key << Translation::GlobalKeys::EBusHandlerIDKey << "details";
+                    GraphCanvas::TranslationRequests::Details details;
+                    details.m_name = slot->GetName();
+                    details.m_tooltip = slot->GetToolTip();
+                    GraphCanvas::TranslationRequestBus::BroadcastResult(details, &GraphCanvas::TranslationRequests::GetDetails, key, details);
+
+                    GraphCanvas::SlotRequestBus::Event(gcSlotId, &GraphCanvas::SlotRequests::SetDetails, details.m_name, details.m_tooltip);
                 }
             }
         }
 
-        GraphCanvas::TranslationKeyedString nodeKeyedString(busName);
-        nodeKeyedString.m_context = TranslationHelper::GetEbusHandlerContext(busName);
-        nodeKeyedString.m_key = TranslationHelper::GetEbusHandlerKey(busName, TranslationKeyId::Name);
-
-        GraphCanvas::TranslationKeyedString tooltipKeyedString(AZStd::string(), nodeKeyedString.m_context);
-        tooltipKeyedString.m_key = TranslationHelper::GetEbusHandlerKey(busName, TranslationKeyId::Tooltip);
-
         // Set the name
         graphCanvasEntity->SetName(AZStd::string::format("GC-BusNode: %s", busName.data()));
 
-        GraphCanvas::NodeRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeRequests::SetTranslationKeyedTooltip, tooltipKeyedString);
-        GraphCanvas::NodeTitleRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeTitleRequests::SetTranslationKeyedTitle, nodeKeyedString);
+        GraphCanvas::TranslationKey key;
+        key << "EBusHandler" << busName << "details";
+
+        GraphCanvas::TranslationRequests::Details details;
+        details.m_name = busName;
+        GraphCanvas::TranslationRequestBus::BroadcastResult(details, &GraphCanvas::TranslationRequests::GetDetails, key, details);
+
+        GraphCanvas::NodeRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeRequests::SetTooltip, details.m_tooltip);
+        GraphCanvas::NodeTitleRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeTitleRequests::SetTitle, details.m_name);
         GraphCanvas::NodeTitleRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeTitleRequests::SetDefaultPalette, "HandlerWrapperNodeTitlePalette");
 
         return graphCanvasNodeId;
@@ -462,19 +475,20 @@ namespace ScriptCanvasEditor::Nodes
 
         AZStd::string decoratedName = AZStd::string::format("%s::%s", busName.c_str(), eventName.c_str());
 
-        GraphCanvas::TranslationKeyedString nodeKeyedString(eventName);
-        nodeKeyedString.m_context = TranslationHelper::GetEbusHandlerContext(busName);
-        nodeKeyedString.m_key = TranslationHelper::GetEbusHandlerEventKey(busName, eventName, TranslationKeyId::Name);
+        GraphCanvas::TranslationKey key;
+        key << "EBusHandler" << busName << "methods" << eventName << "details";
 
-        GraphCanvas::TranslationKeyedString tooltipKeyedString(AZStd::string(), nodeKeyedString.m_context);
-        tooltipKeyedString.m_key = TranslationHelper::GetEbusHandlerEventKey(busName, eventName, TranslationKeyId::Tooltip);
+        GraphCanvas::TranslationRequests::Details details;
+        details.m_name = eventName;
+        details.m_subtitle = busName;
+        GraphCanvas::TranslationRequestBus::BroadcastResult(details, &GraphCanvas::TranslationRequests::GetDetails, key, details);
 
         // Set the name
         graphCanvasEntity->SetName(AZStd::string::format("GC-Node(%s)", decoratedName.c_str()));
 
-        GraphCanvas::NodeRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeRequests::SetTranslationKeyedTooltip, tooltipKeyedString);
+        GraphCanvas::NodeRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeRequests::SetTooltip, details.m_tooltip);
 
-        GraphCanvas::NodeTitleRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeTitleRequests::SetTranslationKeyedTitle, nodeKeyedString);
+        GraphCanvas::NodeTitleRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeTitleRequests::SetTitle, details.m_name);
         GraphCanvas::NodeTitleRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeTitleRequests::SetPaletteOverride, "HandlerNodeTitlePalette");
 
         return graphCanvasNodeId;
@@ -512,76 +526,27 @@ namespace ScriptCanvasEditor::Nodes
             if (slot.IsVisible())
             {
                 AZ::EntityId gcSlotId = DisplayScriptCanvasSlot(graphCanvasNodeId, slot, group);
-                if (slot.GetId() == azEventEntry.m_azEventInputSlotId)
-                {
-                    GraphCanvas::TranslationKeyedString slotTranslationEntry(azEventEntry.m_eventName);
-                    slotTranslationEntry.m_context = TranslationHelper::GetAzEventHandlerContextKey();
-                    // The translation key in this case acts like a json pointer referencing a particular
-                    // json string within a hypothetical json document
-                    AZ::StackedString azEventHandlerNodeKey = TranslationHelper::GetAzEventHandlerRootPointer(azEventEntry.m_eventName);
 
-                    azEventHandlerNodeKey.Push("Name");
-                    slotTranslationEntry.m_key = AZStd::string_view{ azEventHandlerNodeKey };
-                    GraphCanvas::SlotRequestBus::Event(gcSlotId, &GraphCanvas::SlotRequests::SetTranslationKeyedName, slotTranslationEntry);
-                    azEventHandlerNodeKey.Pop();
-                    azEventHandlerNodeKey.Push("Tooltip");
-                    slotTranslationEntry.m_key = AZStd::string_view{ azEventHandlerNodeKey };
-                    GraphCanvas::SlotRequestBus::Event(gcSlotId, &GraphCanvas::SlotRequests::SetTranslationKeyedTooltip, slotTranslationEntry);
-                }
-                else
-                {
-                    GraphCanvas::TranslationKeyedString slotTranslationEntry(slot.GetName());
-                    slotTranslationEntry.m_context = TranslationHelper::GetAzEventHandlerContextKey();
-                    // The translation key in this case acts like a json pointer referencing a particular
-                    // json string within a hypothetical json document
-                    // translation key is rooted at /AzEventHandler/${EventName}/Slots/${SlotName}/{In,Out,Param,Return}
-                    AZ::StackedString azEventHandlerNodeKey = TranslationHelper::GetAzEventHandlerRootPointer(azEventEntry.m_eventName);
-                    azEventHandlerNodeKey.Push("Slots");
-                    azEventHandlerNodeKey.Push(slot.GetName());
-                    switch(TranslationHelper::GetItemType(slot.GetDescriptor()))
-                    {
-                    case TranslationItemType::ExecutionInSlot:
-                        azEventHandlerNodeKey.Push("In");
-                        break;
-                    case TranslationItemType::ExecutionOutSlot:
-                        azEventHandlerNodeKey.Push("Out");
-                        break;
-                    case TranslationItemType::ParamDataSlot:
-                        azEventHandlerNodeKey.Push("Param");
-                        break;
-                    case TranslationItemType::ReturnDataSlot:
-                        azEventHandlerNodeKey.Push("Return");
-                        break;
-                    default:
-                        // Slot is not an execution or data slot, do nothing
-                        break;
-                    }
+                GraphCanvas::TranslationKey key;
+                key << "AZEventHandler" << azEventNode->GetNodeName() << "slots" << slot.GetName() << "details";
 
-                    azEventHandlerNodeKey.Push("Name");
-                    slotTranslationEntry.m_key = AZStd::string_view{ azEventHandlerNodeKey };
-                    GraphCanvas::SlotRequestBus::Event(gcSlotId, &GraphCanvas::SlotRequests::SetTranslationKeyedName, slotTranslationEntry);
-                    azEventHandlerNodeKey.Pop();
-                    azEventHandlerNodeKey.Push("Tooltip");
-                    slotTranslationEntry.m_key = AZStd::string_view{ azEventHandlerNodeKey };
-                    GraphCanvas::SlotRequestBus::Event(gcSlotId, &GraphCanvas::SlotRequests::SetTranslationKeyedTooltip, slotTranslationEntry);
-                }
+                GraphCanvas::TranslationRequests::Details details;
+                GraphCanvas::TranslationRequestBus::BroadcastResult(details, &GraphCanvas::TranslationRequests::GetDetails, key, details);
+
+                GraphCanvas::SlotRequestBus::Event(gcSlotId, &GraphCanvas::SlotRequests::SetName, details.m_name);
+                GraphCanvas::SlotRequestBus::Event(gcSlotId, &GraphCanvas::SlotRequests::SetTooltip, details.m_tooltip);;
             }
         }
 
-        GraphCanvas::TranslationKeyedString nodeTranslationEntry(azEventEntry.m_eventName);
-        nodeTranslationEntry.m_context = TranslationHelper::GetAzEventHandlerContextKey();
-        // The translation key in this case acts like a json pointer referencing a particular
-        // json string within a hypothetical json document
-        AZ::StackedString azEventHandlerNodeKey = TranslationHelper::GetAzEventHandlerRootPointer(azEventEntry.m_eventName);
-        azEventHandlerNodeKey.Push("Name");
-        nodeTranslationEntry.m_key = AZStd::string_view{ azEventHandlerNodeKey };
-        GraphCanvas::NodeTitleRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeTitleRequests::SetTranslationKeyedTitle, nodeTranslationEntry);
-        azEventHandlerNodeKey.Pop();
-        azEventHandlerNodeKey.Push("Tooltip");
-        nodeTranslationEntry.m_key = AZStd::string_view{ azEventHandlerNodeKey };
-        GraphCanvas::NodeRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeRequests::SetTranslationKeyedTooltip, nodeTranslationEntry);
+        GraphCanvas::TranslationKey key;
+        key << "AZEventHandler" << azEventEntry.m_eventName << "details";
+
+        GraphCanvas::TranslationRequests::Details details;
+        GraphCanvas::TranslationRequestBus::BroadcastResult(details, &GraphCanvas::TranslationRequests::GetDetails, key, details);
+
+        GraphCanvas::NodeTitleRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeTitleRequests::SetTitle, details.m_name);
+        GraphCanvas::NodeRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeRequests::SetTooltip, details.m_tooltip);
 
-        // Set the name
         graphCanvasEntity->SetName(AZStd::string::format("GC-EventNode: %s", azEventEntry.m_eventName.c_str()));
 
         GraphCanvas::NodeTitleRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeTitleRequests::SetPaletteOverride, "HandlerNodeTitlePalette");
@@ -652,8 +617,11 @@ namespace ScriptCanvasEditor::Nodes
 
                 if (busNode->IsIDRequired() && slot->GetDescriptor() == ScriptCanvas::SlotDescriptors::DataIn())
                 {
-                    GraphCanvas::SlotRequestBus::Event(gcSlotId, &GraphCanvas::SlotRequests::SetTranslationKeyedName, TranslationHelper::GetEBusHandlerBusIdNameKey());
-                    GraphCanvas::SlotRequestBus::Event(gcSlotId, &GraphCanvas::SlotRequests::SetTranslationKeyedTooltip, TranslationHelper::GetEBusHandlerBusIdTooltipKey());
+                    GraphCanvas::TranslationKey key;
+                    key << Translation::GlobalKeys::EBusHandlerIDKey << "details";
+                    GraphCanvas::TranslationRequests::Details details;
+                    GraphCanvas::TranslationRequestBus::BroadcastResult(details, &GraphCanvas::TranslationRequests::GetDetails, key, details);
+                    GraphCanvas::SlotRequestBus::Event(gcSlotId, &GraphCanvas::SlotRequests::SetDetails, details.m_name, details.m_tooltip);
                 }
             }
         }
@@ -718,11 +686,7 @@ namespace ScriptCanvasEditor::Nodes
         graphCanvasEntity->CreateComponent<IconComponent>(ScriptCanvas::Nodes::Core::Method::RTTI_Type());
         graphCanvasEntity->CreateComponent<SlotMappingComponent>(senderNode->GetEntityId());
         graphCanvasEntity->CreateComponent<SceneMemberMappingComponent>(senderNode->GetEntityId());
-
-        TranslationContextGroup contextGroup = TranslationContextGroup::Invalid;
-
         graphCanvasEntity->CreateComponent<ScriptEventSenderNodeDescriptorComponent>(senderNode->GetAssetId(), senderNode->GetEventId());
-        contextGroup = TranslationContextGroup::EbusSender;
 
         graphCanvasEntity->Init();
         graphCanvasEntity->Activate();
@@ -753,7 +717,7 @@ namespace ScriptCanvasEditor::Nodes
                 GraphCanvas::SlotRequestBus::Event(graphCanvasSlotId, &GraphCanvas::SlotRequests::SetName, slot.GetName());
                 GraphCanvas::SlotRequestBus::Event(graphCanvasSlotId, &GraphCanvas::SlotRequests::SetTooltip, slot.GetToolTip());
 
-                CopyTranslationKeyedNameToDatumLabel(graphCanvasNodeId, slot.GetId(), graphCanvasSlotId);
+                UpdateSlotDatumLabel(graphCanvasNodeId, slot.GetId(), slot.GetName());
             }
         }
 
@@ -811,11 +775,23 @@ namespace ScriptCanvasEditor::Nodes
         {
             AZ_Error("Script Canvas", false, "Script Canvas Function asset (%s) is not loaded, unable to display the node.", functionNode->GetAssetId().ToString<AZStd::string>().c_str());
 
-            GraphCanvas::TranslationKeyedString errorTitle("ERROR!");
-            GraphCanvas::TranslationKeyedString errorSubstring("Missing Script Canvas Function Asset!");
+            GraphCanvas::TranslationKey key;
+            key = "Globals.MissingFunctionAsset.Title.details.m_name";
 
-            GraphCanvas::NodeTitleRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeTitleRequests::SetTranslationKeyedTitle, errorTitle);
-            GraphCanvas::NodeTitleRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeTitleRequests::SetTranslationKeyedSubTitle, errorSubstring);
+            bool success = false;
+            AZStd::string result = "Error!";
+            GraphCanvas::TranslationRequestBus::BroadcastResult(success, &GraphCanvas::TranslationRequests::Get, key = "Globals.MissingFunctionAsset.Title.details.m_name", result);
+            if (success)
+            {
+                GraphCanvas::NodeTitleRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeTitleRequests::SetTitle, result);
+            }
+
+            result = "Missing Script Canvas Function Asset";
+            GraphCanvas::TranslationRequestBus::BroadcastResult(success, &GraphCanvas::TranslationRequests::Get, key = "Globals.MissingFunctionAsset.Title.details.tooltip", result);
+            if (success)
+            {
+                GraphCanvas::NodeTitleRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeTitleRequests::SetSubTitle, result);
+            }
 
             return graphCanvasNodeId;
         }
@@ -827,7 +803,7 @@ namespace ScriptCanvasEditor::Nodes
             GraphCanvas::SlotRequestBus::Event(graphCanvasSlotId, &GraphCanvas::SlotRequests::SetName, slot.GetName());
             GraphCanvas::SlotRequestBus::Event(graphCanvasSlotId, &GraphCanvas::SlotRequests::SetTooltip, slot.GetToolTip());
 
-            CopyTranslationKeyedNameToDatumLabel(graphCanvasNodeId, slot.GetId(), graphCanvasSlotId);
+            UpdateSlotDatumLabel(graphCanvasNodeId, slot.GetId(), slot.GetName());
         }
 
         if (asset)
@@ -866,31 +842,11 @@ namespace ScriptCanvasEditor::Nodes
 
         if (const AZ::SerializeContext::ClassData* classData = serializeContext->FindClassData(azrtti_typeid(functionDefinitionNode)))
         {
-            AZStd::string nodeContext = GetContextName(*classData);
-            nodeConfiguration.m_translationContext = TranslationHelper::GetUserDefinedContext(nodeContext);
-
-            nodeConfiguration.m_titleFallback = (classData->m_editData && classData->m_editData->m_name) ? classData->m_editData->m_name : classData->m_name;
-            nodeConfiguration.m_tooltipFallback = (classData->m_editData && classData->m_editData->m_description) ? classData->m_editData->m_description : "";
-
-            GraphCanvas::TranslationKeyedString subtitleKeyedString(nodeContext, nodeConfiguration.m_translationContext);
-            subtitleKeyedString.m_key = TranslationHelper::GetUserDefinedNodeKey(nodeContext, nodeConfiguration.m_titleFallback, ScriptCanvasEditor::TranslationKeyId::Category);
-
-            nodeConfiguration.m_subtitleFallback = subtitleKeyedString.GetDisplayString();
-
-            nodeConfiguration.m_translationKeyName = nodeConfiguration.m_titleFallback;
-            nodeConfiguration.m_translationKeyContext = nodeContext;
-
-            nodeConfiguration.m_translationGroup = TranslationContextGroup::ClassMethod;
-
-
             ScriptCanvas::GraphScopedNodeId nodelingId;
 
             nodelingId.m_identifier = nodeConfiguration.m_scriptCanvasId;
             nodelingId.m_scriptCanvasId = functionDefinitionNode->GetOwningScriptCanvasId();
 
-            AZStd::string nodelingName;
-            ScriptCanvas::NodelingRequestBus::EventResult(nodelingName, nodelingId, &ScriptCanvas::NodelingRequests::GetDisplayName);
-
             if (classData->m_editData)
             {
                 const AZ::Edit::ElementData* elementData = classData->m_editData->FindElementData(AZ::Edit::ClassElements::EditorData);
@@ -908,15 +864,12 @@ namespace ScriptCanvasEditor::Nodes
             }
         }
 
-        nodeConfiguration.m_subtitleFallback = "";
-
         // Because of how the extender slots are registered, there isn't an easy way to only create one or the other based on
         // the type of nodeling, so instead they both get created and we need to remove the inapplicable one
         GraphCanvas::ConnectionType typeToRemove = (functionDefinitionNode->IsExecutionEntry()) ? GraphCanvas::CT_Input : GraphCanvas::CT_Output;
 
         AZ::EntityId graphCanvasNodeId = DisplayGeneralScriptCanvasNode(graphCanvasGraphId, functionDefinitionNode, nodeConfiguration);
 
-
         AZStd::vector<GraphCanvas::SlotId> extenderSlotIds, executionSlotIds;
         GraphCanvas::NodeRequestBus::EventResult(extenderSlotIds, graphCanvasNodeId, &GraphCanvas::NodeRequests::FindVisibleSlotIdsByType, typeToRemove, GraphCanvas::SlotTypes::ExtenderSlot);
         if (!extenderSlotIds.empty())
@@ -960,22 +913,6 @@ namespace ScriptCanvasEditor::Nodes
 
         if (classData)
         {
-            AZStd::string nodeContext = GetContextName(*classData);
-            nodeConfiguration.m_translationContext = TranslationHelper::GetUserDefinedContext(nodeContext);
-
-            nodeConfiguration.m_titleFallback = (classData->m_editData && classData->m_editData->m_name) ? classData->m_editData->m_name : classData->m_name;
-            nodeConfiguration.m_tooltipFallback = (classData->m_editData && classData->m_editData->m_description) ? classData->m_editData->m_description : "";
-
-            GraphCanvas::TranslationKeyedString subtitleKeyedString(nodeContext, nodeConfiguration.m_translationContext);
-            subtitleKeyedString.m_key = TranslationHelper::GetUserDefinedNodeKey(nodeContext, nodeConfiguration.m_titleFallback, ScriptCanvasEditor::TranslationKeyId::Category);
-
-            nodeConfiguration.m_subtitleFallback = subtitleKeyedString.GetDisplayString();
-
-            nodeConfiguration.m_translationKeyName = nodeConfiguration.m_titleFallback;
-            nodeConfiguration.m_translationKeyContext = nodeContext;
-
-            nodeConfiguration.m_translationGroup = TranslationContextGroup::ClassMethod;
-
             if (classData->m_editData)
             {
                 const AZ::Edit::ElementData* elementData = classData->m_editData->FindElementData(AZ::Edit::ClassElements::EditorData);
@@ -993,8 +930,6 @@ namespace ScriptCanvasEditor::Nodes
             }
         }
 
-        nodeConfiguration.m_subtitleFallback = "";
-
         return DisplayGeneralScriptCanvasNode(graphCanvasGraphId, nodeling, nodeConfiguration);
     }
 
@@ -1008,19 +943,6 @@ namespace ScriptCanvasEditor::Nodes
         nodeConfiguration.m_titlePalette = "GetVariableNodeTitlePalette";
         nodeConfiguration.m_scriptCanvasId = variableNode->GetEntityId();
 
-        // <Translation>
-        nodeConfiguration.m_translationContext = TranslationHelper::GetContextName(TranslationContextGroup::ClassMethod, "CORE");
-
-        nodeConfiguration.m_translationKeyContext = "CORE";
-        nodeConfiguration.m_translationKeyName = "GETVARIABLE";
-
-        nodeConfiguration.m_titleFallback = "Get Variable";
-        nodeConfiguration.m_subtitleFallback = "";
-        nodeConfiguration.m_tooltipFallback = "Gets the specified Variable or one of it's properties.";
-
-        nodeConfiguration.m_translationGroup = TranslationContextGroup::ClassMethod;
-        // </Translation>
-
         AZ::EntityId graphCanvasNodeId = DisplayGeneralScriptCanvasNode(graphCanvasGraphId, variableNode, nodeConfiguration);
 
         GraphCanvas::SlotLayoutRequestBus::Event(graphCanvasNodeId, &GraphCanvas::SlotLayoutRequests::ConfigureSlotGroup, GraphCanvas::SlotGroups::ExecutionGroup, GraphCanvas::SlotGroupConfiguration(0));
@@ -1040,20 +962,6 @@ namespace ScriptCanvasEditor::Nodes
         nodeConfiguration.m_titlePalette = "SetVariableNodeTitlePalette";
         nodeConfiguration.m_scriptCanvasId = variableNode->GetEntityId();
 
-        // <Translation>
-
-        nodeConfiguration.m_translationContext = TranslationHelper::GetContextName(TranslationContextGroup::ClassMethod, "CORE");
-
-        nodeConfiguration.m_translationKeyContext = "CORE";
-        nodeConfiguration.m_translationKeyName = "SETVARIABLE";
-
-        nodeConfiguration.m_titleFallback = "Set Variable";
-        nodeConfiguration.m_subtitleFallback = "";
-        nodeConfiguration.m_tooltipFallback = "Sets the specified Variable.";
-
-        nodeConfiguration.m_translationGroup = TranslationContextGroup::ClassMethod;
-        // </Translation>
-
         AZ::EntityId graphCanvasId = DisplayGeneralScriptCanvasNode(graphCanvasGraphId, variableNode, nodeConfiguration);
 
         GraphCanvas::SlotLayoutRequestBus::Event(graphCanvasId, &GraphCanvas::SlotLayoutRequests::ConfigureSlotGroup, GraphCanvas::SlotGroups::ExecutionGroup, GraphCanvas::SlotGroupConfiguration(0));
@@ -1242,8 +1150,45 @@ namespace ScriptCanvasEditor::Nodes
 
         if (slotEntity)
         {
+            GraphCanvas::TranslationKey slotKey;
+            slotKey << "ScriptCanvas::Node" << azrtti_typeid(slot.GetNode()).ToString<AZStd::string>() << "slots";
+
+            AZStd::string slotKeyStr;
+            if (slot.IsData())
+            {
+                slotKeyStr.append("Data");
+            }
+
+            if (slot.GetConnectionType() == ScriptCanvas::ConnectionType::Input)
+            {
+                slotKeyStr.append("Input_");
+            }
+            else
+            {
+                slotKeyStr.append("Output_");
+            }
+
+            slotKeyStr.append(slot.GetName());
+            slotKey << slotKeyStr << "details";
+
+            GraphCanvas::TranslationRequests::Details slotDetails;
+            GraphCanvas::TranslationRequestBus::BroadcastResult(slotDetails, &GraphCanvas::TranslationRequests::GetDetails, slotKey, slotDetails);
+
+            if (slotDetails.m_name.empty())
+            {
+                slotDetails.m_name = slot.GetName();
+            }
+
+            if (slotDetails.m_tooltip.empty())
+            {
+                slotDetails.m_tooltip = slot.GetToolTip();
+            }
+
+            GraphCanvas::SlotRequestBus::Event(slotEntity->GetId(), &GraphCanvas::SlotRequests::SetName, slotDetails.m_name);
+            GraphCanvas::SlotRequestBus::Event(slotEntity->GetId(), &GraphCanvas::SlotRequests::SetTooltip, slotDetails.m_tooltip);
+
             RegisterAndActivateGraphCanvasSlot(graphCanvasNodeId, slot.GetId(), slotEntity);
-            CopyTranslationKeyedNameToDatumLabel(graphCanvasNodeId, slot.GetId(), slotEntity->GetId());
+            UpdateSlotDatumLabel(graphCanvasNodeId, slot.GetId(), slot.GetName());
             return slotEntity->GetId();
         }
         else

Gems/ScriptCanvas/Code/Editor/Nodes/NodeUtils.cpp

@@ -16,18 +16,8 @@
 
 namespace ScriptCanvasEditor::Nodes
 {
-    void CopyTranslationKeyedNameToDatumLabel(const AZ::EntityId& graphCanvasNodeId,
-        ScriptCanvas::SlotId scSlotId,
-        const AZ::EntityId& graphCanvasSlotId)
+    void UpdateSlotDatumLabel(const AZ::EntityId& graphCanvasNodeId, ScriptCanvas::SlotId scSlotId, const AZStd::string& name)
     {
-        GraphCanvas::TranslationKeyedString name;
-        GraphCanvas::SlotRequestBus::EventResult(name, graphCanvasSlotId, &GraphCanvas::SlotRequests::GetTranslationKeyedName);
-        if (name.GetDisplayString().empty())
-        {
-            return;
-        }
-
-        // GC node -> SC node.
         AZStd::any* userData = nullptr;
         GraphCanvas::NodeRequestBus::EventResult(userData, graphCanvasNodeId, &GraphCanvas::NodeRequests::GetUserData);
         AZ::EntityId scNodeEntityId = userData && userData->is<AZ::EntityId>() ? *AZStd::any_cast<AZ::EntityId>(userData) : AZ::EntityId();
@@ -36,11 +26,11 @@ namespace ScriptCanvasEditor::Nodes
             ScriptCanvas::ModifiableDatumView datumView;
             ScriptCanvas::NodeRequestBus::Event(scNodeEntityId, &ScriptCanvas::NodeRequests::FindModifiableDatumView, scSlotId, datumView);
 
-            datumView.RelabelDatum(name.GetDisplayString());
+            datumView.RelabelDatum(name);
         }
     }
 
-    void CopySlotTranslationKeyedNamesToDatums(AZ::EntityId graphCanvasNodeId)
+    void UpdateSlotDatumLabels(AZ::EntityId graphCanvasNodeId)
     {
         AZStd::vector<AZ::EntityId> graphCanvasSlotIds;
         GraphCanvas::NodeRequestBus::EventResult(graphCanvasSlotIds, graphCanvasNodeId, &GraphCanvas::NodeRequests::GetSlotIds);
@@ -51,47 +41,10 @@ namespace ScriptCanvasEditor::Nodes
 
             if (auto scriptCanvasSlotId = AZStd::any_cast<ScriptCanvas::SlotId>(slotUserData))
             {
-                CopyTranslationKeyedNameToDatumLabel(graphCanvasNodeId, *scriptCanvasSlotId, graphCanvasSlotId);
+                AZStd::string slotName;
+                GraphCanvas::SlotRequestBus::EventResult(slotName, graphCanvasSlotId, &GraphCanvas::SlotRequests::GetName);
+                UpdateSlotDatumLabel(graphCanvasNodeId, *scriptCanvasSlotId, slotName);
             }
         }
     }
-
-    //////////////////////
-    // NodeConfiguration
-    //////////////////////
-    AZStd::string GetCategoryName(const AZ::SerializeContext::ClassData& classData)
-    {
-        if (auto editorDataElement = classData.m_editData->FindElementData(AZ::Edit::ClassElements::EditorData))
-        {
-            if (auto attribute = editorDataElement->FindAttribute(AZ::Edit::Attributes::Category))
-            {
-                if (auto data = azrtti_cast<AZ::Edit::AttributeData<const char*>*>(attribute))
-                {
-                    return data->Get(nullptr);
-                }
-            }
-        }
-
-        return {};
-    }
-
-    AZStd::string GetContextName(const AZ::SerializeContext::ClassData& classData)
-    {
-        if (auto editorDataElement = classData.m_editData ? classData.m_editData->FindElementData(AZ::Edit::ClassElements::EditorData) : nullptr)
-        {
-            if (auto attribute = editorDataElement->FindAttribute(AZ::Edit::Attributes::Category))
-            {
-                if (auto data = azrtti_cast<AZ::Edit::AttributeData<const char*>*>(attribute))
-                {
-                    AZStd::string fullCategoryName = data->Get(nullptr);
-                    AZStd::string delimiter = "/";
-                    AZStd::vector<AZStd::string> results;
-                    AZStd::tokenize(fullCategoryName, delimiter, results);
-                    return results.back();
-                }
-            }
-        }
-
-        return {};
-    }
 }

Gems/ScriptCanvas/Code/Editor/Nodes/NodeUtils.h

@@ -71,18 +71,6 @@ namespace ScriptCanvasEditor
             AZStd::string m_titlePalette;
             AZStd::vector< AZ::Uuid > m_customComponents;
 
-            // Translation Information for the Node
-            AZStd::string m_translationContext;
-
-            AZStd::string m_translationKeyName;
-            AZStd::string m_translationKeyContext;
-
-            TranslationContextGroup m_translationGroup;
-
-            AZStd::string m_titleFallback;
-            AZStd::string m_subtitleFallback;
-            AZStd::string m_tooltipFallback;
-
             AZ::EntityId  m_scriptCanvasId;
         };
 
@@ -92,16 +80,9 @@ namespace ScriptCanvasEditor
             AZStd::string m_titlePalette;
         };
 
-        AZStd::string GetContextName(const AZ::SerializeContext::ClassData& classData);
-        AZStd::string GetCategoryName(const AZ::SerializeContext::ClassData& classData);
-
-        void CopySlotTranslationKeyedNamesToDatums(AZ::EntityId graphCanvasNodeId);
-
-        // Copies the the translated key name to the ScriptCanvas Data Slot which matches
-        // the scSlotId
-        void CopyTranslationKeyedNameToDatumLabel(const AZ::EntityId& graphCanvasNodeId,
-            ScriptCanvas::SlotId scSlotId,
-            const AZ::EntityId& graphCanvasSlotId);
+        // Copies the slot name to the underlying ScriptCanvas Data Slot which matches the slot Id
+        void UpdateSlotDatumLabels(AZ::EntityId graphCanvasNodeId);
+        void UpdateSlotDatumLabel(const AZ::EntityId& graphCanvasNodeId, ScriptCanvas::SlotId scSlotId, const AZStd::string& name);
 
         template <typename NodeType>
         NodeType* GetNode(AZ::EntityId scriptCanvasGraphId, NodeIdPair nodeIdPair)

Gems/ScriptCanvas/Code/Editor/Translation/TranslationHelper.h

@@ -15,6 +15,63 @@
 
 #include <ScriptCanvas/Core/Slot.h>
 #include <GraphCanvas/Types/TranslationTypes.h>
+#include <Source/Translation/TranslationBus.h>
+#include <AzFramework/Gem/GemInfo.h>
+#include <AzCore/Settings/SettingsRegistry.h>
+
+namespace Translation
+{
+    namespace GlobalKeys
+    {
+        static constexpr const char* EBusSenderIDKey = "Globals.EBusSenderBusId";
+        static constexpr const char* EBusHandlerIDKey = "Globals.EBusHandlerBusId";
+        static constexpr const char* MissingFunctionKey = "Globals.MissingFunction";
+        static constexpr const char* EBusHandlerOutSlot = "Globals.EBusHandler.OutSlot";
+    }
+
+    static inline bool GetValue(const AZStd::string key, AZStd::string& value)
+    {
+        GraphCanvas::TranslationKey tkey;
+        tkey = key;
+
+        bool result = false;
+        GraphCanvas::TranslationRequestBus::BroadcastResult(result, &GraphCanvas::TranslationRequests::Get, key, value);
+        return result;
+    }
+}
+
+
+namespace GraphCanvasAttributeHelper
+{
+    template <typename T>
+    AZStd::string GetStringAttribute(const T* source, const AZ::Crc32& attribute)
+    {
+        AZStd::string attributeValue = "";
+        if (auto attributeItem = azrtti_cast<AZ::AttributeData<AZStd::string>*>(AZ::FindAttribute(attribute, source->m_attributes)))
+        {
+            attributeValue = attributeItem->Get(nullptr);
+        }
+        return attributeValue;
+    }
+
+    inline AZStd::string ReadStringAttribute(const AZ::AttributeArray& attributes, const AZ::Crc32& attribute)
+    {
+        AZStd::string attributeValue = "";
+        if (auto attributeItem = azrtti_cast<AZ::AttributeData<AZStd::string>*>(AZ::FindAttribute(attribute, attributes)))
+        {
+            attributeValue = attributeItem->Get(nullptr);
+            return attributeValue;
+        }
+
+        if (auto attributeItem = azrtti_cast<AZ::AttributeData<const char*>*>(AZ::FindAttribute(attribute, attributes)))
+        {
+            attributeValue = attributeItem->Get(nullptr);
+            return attributeValue;
+        }
+
+        return {};
+    }
+}
 
 namespace ScriptCanvasEditor
 {
@@ -47,6 +104,20 @@ namespace ScriptCanvasEditor
         Invalid
     };
 
+
+    namespace TranslationKeyParts
+    {
+        const char* const handler = "HANDLER_";
+        const char* const name = "NAME";
+        const char* const tooltip = "TOOLTIP";
+        const char* const category = "CATEGORY";
+        const char* const in = "IN";
+        const char* const out = "OUT";
+        const char* const param = "PARAM";
+        const char* const output = "OUTPUT";
+        const char* const busid = "BUSID";
+    }
+
     namespace TranslationContextGroupParts
     {
         const char* const ebusSender  = "EBus";
@@ -55,19 +126,6 @@ namespace ScriptCanvasEditor
         constexpr const char* const globalMethod = "GlobalMethod";
     };
 
-    namespace TranslationKeyParts
-    {
-        const char* const handler   = "HANDLER_";
-        const char* const name      = "NAME";
-        const char* const tooltip   = "TOOLTIP";
-        const char* const category  = "CATEGORY";
-        const char* const in        = "IN";
-        const char* const out       = "OUT";
-        const char* const param     = "PARAM";
-        const char* const output    = "OUTPUT";
-        const char* const busid     = "BUSID";
-    }
-
     // The context name and keys generated by TranslationHelper should match the keys
     // being exported by the TSGenerateAction.cpp in the ScriptCanvasDeveloper Gem.
     class TranslationHelper
@@ -109,47 +167,10 @@ namespace ScriptCanvasEditor
         }
         
         // UserDefined
-        static AZStd::string GetUserDefinedContext(AZStd::string_view contextName)
-        {
-            return GetContextName(TranslationContextGroup::ClassMethod, contextName);
-        }
-
-        static AZStd::string GetUserDefinedKey(AZStd::string_view contextName, TranslationKeyId keyId)
-        {
-            return GetClassKey(TranslationContextGroup::ClassMethod, contextName, keyId);
-        }
-
         static AZStd::string GetUserDefinedNodeKey(AZStd::string_view contextName, AZStd::string_view nodeName, TranslationKeyId keyId)
         {
             return GetKey(TranslationContextGroup::ClassMethod, contextName, nodeName, TranslationItemType::Node, keyId);
         }
-
-        static AZStd::string GetUserDefinedNodeSlotKey(AZStd::string_view contextName, AZStd::string_view nodeName, TranslationItemType itemType, TranslationKeyId keyId, int slotIndex)
-        {
-            return GetKey(TranslationContextGroup::ClassMethod, contextName, nodeName, itemType, keyId, slotIndex);
-        }
-        ////
-
-        // EBusEvent
-        static AZStd::string GetEbusHandlerContext(AZStd::string_view busName)
-        {
-            return GetContextName(TranslationContextGroup::EbusHandler, busName);
-        }
-
-        static AZStd::string GetEbusHandlerKey(AZStd::string_view busName, TranslationKeyId keyId)
-        {
-            return GetClassKey(TranslationContextGroup::EbusHandler, busName, keyId);
-        }
-
-        static AZStd::string GetEbusHandlerEventKey(AZStd::string_view busName, AZStd::string_view eventName, TranslationKeyId keyId)
-        {
-            return GetKey(TranslationContextGroup::EbusHandler, busName, eventName, TranslationItemType::Node, keyId);
-        }
-
-        static AZStd::string GetEBusHandlerSlotKey(AZStd::string_view busName, AZStd::string_view eventName, TranslationItemType type, TranslationKeyId keyId, int paramIndex)
-        {
-            return GetKey(TranslationContextGroup::EbusHandler, busName, eventName, type, keyId, paramIndex);
-        }
         ////
 
         static AZStd::string GetKey(TranslationContextGroup group, AZStd::string_view keyBase, AZStd::string_view keyName, TranslationItemType type, TranslationKeyId keyId, int paramIndex = 0)
@@ -436,72 +457,6 @@ namespace ScriptCanvasEditor
             return translated;
         }
 
-        static GraphCanvas::TranslationKeyedString GetEBusHandlerBusIdNameKey()
-        {
-            GraphCanvas::TranslationKeyedString keyedString;
-            keyedString.m_context = "Globals";
-            keyedString.m_key = "DEFAULTS_EBUSHANDLER_BUSID_NAME";
-            keyedString.SetFallback("BusId");
-
-            return keyedString;
-        }
-
-        static GraphCanvas::TranslationKeyedString GetEBusHandlerBusIdTooltipKey()
-        {
-            GraphCanvas::TranslationKeyedString keyedString;
-            keyedString.m_context = "Globals";
-            keyedString.m_key = "DEFAULTS_EBUSHANDLER_BUSID_TOOLTIP";
-            keyedString.SetFallback("BusId");
-
-            return keyedString;
-        }
-
-        static GraphCanvas::TranslationKeyedString GetEBusHandlerOnEventTriggeredNameKey()
-        {
-            GraphCanvas::TranslationKeyedString keyedString;
-            keyedString.m_context = "Globals";
-            keyedString.m_key = "DEFAULTS_EBUSHANDLER_ONTRIGGERED_NAME";
-            keyedString.SetFallback("Out");
-
-            return keyedString;
-        }
-
-        static GraphCanvas::TranslationKeyedString GetEBusHandlerOnEventTriggeredTooltipKey()
-        {
-            GraphCanvas::TranslationKeyedString keyedString;
-            keyedString.m_context = "Globals";
-            keyedString.m_key = "DEFAULTS_EBUSHANDLER_ONTRIGGERED_TOOLTIP";
-            keyedString.SetFallback("Out");
-
-            return keyedString;
-        }
-
-        static GraphCanvas::TranslationKeyedString GetEBusSenderBusIdNameKey()
-        {
-            GraphCanvas::TranslationKeyedString keyedString;
-            keyedString.m_context = "Globals";
-            keyedString.m_key = "DEFAULTS_EBUSSENDER_BUSID_NAME";
-            keyedString.SetFallback("BusId");
-
-            return keyedString;
-        }
-
-        static GraphCanvas::TranslationKeyedString GetEBusSenderBusIdTooltipKey()
-        {
-            GraphCanvas::TranslationKeyedString keyedString;
-            keyedString.m_context = "Globals";
-            keyedString.m_key = "DEFAULTS_EBUSSENDER_BUSID_TOOLTIP";
-            keyedString.SetFallback("BusId");
-
-            return keyedString;
-        }
-
-        // Use the StackedString to index the translation keys as a Json Pointer
-        static constexpr AZStd::string_view GetAzEventHandlerContextKey()
-        {
-            return { "AzEventHandler" };
-        }
-
         // Use the StackedString to index the translation keys as a Json Pointer
         static AZ::StackedString GetAzEventHandlerRootPointer(AZStd::string_view eventName)
         {
@@ -510,5 +465,10 @@ namespace ScriptCanvasEditor
 
             return path;
         }
+
+        
+
     };
+
+
 }

Gems/ScriptCanvas/Code/Editor/View/Widgets/NodePalette/EBusNodePaletteTreeItemTypes.cpp

@@ -97,23 +97,17 @@ namespace ScriptCanvasEditor
         , m_isOverload(isOverload)
         , m_propertyStatus(propertyStatus)
     {
-        AZStd::string displayEventName = TranslationHelper::GetKeyTranslation(TranslationContextGroup::EbusSender, m_busName.toUtf8().data(), m_eventName.toUtf8().data(), TranslationItemType::Node, TranslationKeyId::Name);
+        GraphCanvas::TranslationKey key;
+        key << "EBusSender" << busName << "methods" << eventName << "details";
 
-        if (displayEventName.empty())
-        {
-            SetName(m_eventName);
-        }
-        else
-        {
-            SetName(displayEventName.c_str());
-        }
+        GraphCanvas::TranslationRequests::Details details;
+        details.m_name = eventName;
+        details.m_subtitle = busName;
 
-        AZStd::string displayEventTooltip = TranslationHelper::GetKeyTranslation(TranslationContextGroup::EbusSender, m_busName.toUtf8().data(), m_eventName.toUtf8().data(), TranslationItemType::Node, TranslationKeyId::Tooltip);
+        GraphCanvas::TranslationRequestBus::BroadcastResult(details, &GraphCanvas::TranslationRequests::GetDetails, key, details);
 
-        if (!displayEventTooltip.empty())
-        {
-            SetToolTip(displayEventTooltip.c_str());
-        }
+        SetName(details.m_name.c_str());
+        SetToolTip(details.m_tooltip.c_str());
 
         SetTitlePalette("MethodNodeTitlePalette");
     }
@@ -302,23 +296,19 @@ namespace ScriptCanvasEditor
         , m_busId(busId)
         , m_eventId(eventId)
     {
-        AZStd::string displayEventName = TranslationHelper::GetKeyTranslation(TranslationContextGroup::EbusHandler, m_busName.c_str(), m_eventName.c_str(), TranslationItemType::Node, TranslationKeyId::Name);
+        GraphCanvas::TranslationKey key;
+        key << "EBusHandler" << busName << "methods" << eventName << "details";
 
-        if (displayEventName.empty())
+        GraphCanvas::TranslationRequests::Details details;
+        details.m_name = m_eventName;
+        GraphCanvas::TranslationRequestBus::BroadcastResult(details, &GraphCanvas::TranslationRequests::GetDetails, key, details);
+        if (details.m_name.empty())
         {
-            SetName(m_eventName.c_str());
-        }
-        else
-        {
-            SetName(displayEventName.c_str());
+            details.m_name = m_eventName;
         }
 
-        AZStd::string displayEventTooltip = TranslationHelper::GetKeyTranslation(TranslationContextGroup::EbusHandler, m_busName.c_str(), m_eventName.c_str(), TranslationItemType::Node, TranslationKeyId::Tooltip);
-
-        if (!displayEventTooltip.empty())
-        {
-            SetToolTip(displayEventTooltip.c_str());
-        }
+        SetName(details.m_name.c_str());
+        SetToolTip(details.m_tooltip.c_str());
 
         SetTitlePalette("HandlerNodeTitlePalette");
     }

Gems/ScriptCanvas/Code/Editor/View/Widgets/NodePalette/EBusNodePaletteTreeItemTypes.h

@@ -11,6 +11,7 @@
 #include "CreateNodeMimeEvent.h"
 
 #include <ScriptCanvas/GraphCanvas/NodeDescriptorBus.h>
+#include "TranslationGeneration.h"
 
 namespace ScriptCanvasEditor
 {
@@ -62,6 +63,24 @@ namespace ScriptCanvasEditor
 
         ScriptCanvas::PropertyStatus GetPropertyStatus() const;
 
+        AZ::IO::Path GetTranslationDataPath() const override
+        {
+            return AZ::IO::Path("EBus\\Senders") / GetBusName();
+        }
+
+        void GenerateTranslationData() override
+        {
+            AZ::BehaviorContext* behaviorContext{};
+            AZ::ComponentApplicationBus::BroadcastResult(behaviorContext, &AZ::ComponentApplicationRequests::GetBehaviorContext);
+
+            const char* ebusName = m_busName.toUtf8().data();
+            auto behaviorEbus = behaviorContext->m_ebuses.find(ebusName);
+
+            ScriptCanvasEditorTools::TranslationGeneration translation;
+            translation.TranslateEBus(behaviorEbus->second);
+        }
+
+
     private:
         bool m_isOverload;
         QString m_busName;
@@ -154,6 +173,22 @@ namespace ScriptCanvasEditor
         ScriptCanvas::EBusBusId GetBusId() const;
         ScriptCanvas::EBusEventId GetEventId() const;
 
+        AZ::IO::Path GetTranslationDataPath() const override
+        {
+            return AZ::IO::Path("EBus\\Handlers") / GetBusName();
+        }
+
+        void GenerateTranslationData() override
+        {
+            AZ::BehaviorContext* behaviorContext{};
+            AZ::ComponentApplicationBus::BroadcastResult(behaviorContext, &AZ::ComponentApplicationRequests::GetBehaviorContext);
+
+            auto behaviorEbus = behaviorContext->m_ebuses.find(m_busName.c_str());
+
+            ScriptCanvasEditorTools::TranslationGeneration translation;
+            translation.TranslateEBus(behaviorEbus->second);
+        }
+
     private:
         AZStd::string m_busName;
         AZStd::string m_eventName;

Gems/ScriptCanvas/Code/Editor/View/Widgets/NodePalette/GeneralNodePaletteTreeItemTypes.cpp

@@ -82,16 +82,17 @@ namespace ScriptCanvasEditor
         , m_isOverload(isOverload)
         , m_propertyStatus(propertyStatus)
     {
-        AZStd::string displayMethodName = TranslationHelper::GetKeyTranslation(TranslationContextGroup::ClassMethod, m_className.toUtf8().data(), m_methodName.toUtf8().data(), TranslationItemType::Node, TranslationKeyId::Name);
+        GraphCanvas::TranslationKey key;
+        key << "BehaviorClass" << className << "methods" << methodName << "details";
 
-        if (displayMethodName.empty())
-        {
-            SetName(m_methodName);
-        }
-        else
-        {
-            SetName(displayMethodName.c_str());
-        }
+        GraphCanvas::TranslationRequests::Details details;
+        details.m_name = methodName;
+        details.m_subtitle = className;
+
+        GraphCanvas::TranslationRequestBus::BroadcastResult(details, &GraphCanvas::TranslationRequests::GetDetails, key, details);
+
+        SetName(details.m_name.c_str());
+        SetToolTip(details.m_tooltip.c_str());
 
         if (propertyStatus == ScriptCanvas::PropertyStatus::Getter)
         {
@@ -102,13 +103,6 @@ namespace ScriptCanvasEditor
             SetName(AZStd::string::format("Set %s", GetName().toUtf8().data()).data());
         }
 
-        AZStd::string displayEventTooltip = TranslationHelper::GetKeyTranslation(TranslationContextGroup::ClassMethod, m_className.toUtf8().data(), m_methodName.toUtf8().data(), TranslationItemType::Node, TranslationKeyId::Tooltip);
-
-        if (!displayEventTooltip.empty())
-        {
-            SetToolTip(displayEventTooltip.c_str());
-        }
-
         SetTitlePalette("MethodNodeTitlePalette");
     }
 
@@ -230,9 +224,10 @@ namespace ScriptCanvasEditor
     // CustomNodePaletteTreeItem
     //////////////////////////////
 
-    CustomNodePaletteTreeItem::CustomNodePaletteTreeItem(const AZ::Uuid& typeId, AZStd::string_view nodeName)
-        : DraggableNodePaletteTreeItem(nodeName, ScriptCanvasEditor::AssetEditorId)
-        , m_typeId(typeId)
+    CustomNodePaletteTreeItem::CustomNodePaletteTreeItem(const ScriptCanvasEditor::CustomNodeModelInformation& info)
+        : DraggableNodePaletteTreeItem(info.m_displayName, ScriptCanvasEditor::AssetEditorId)
+        , m_info(info)
+        , m_typeId(info.m_typeId)
     {
     }
 

Gems/ScriptCanvas/Code/Editor/View/Widgets/NodePalette/GeneralNodePaletteTreeItemTypes.h

@@ -10,6 +10,9 @@
 #include <GraphCanvas/Widgets/NodePalette/TreeItems/DraggableNodePaletteTreeItem.h>
 
 #include "CreateNodeMimeEvent.h"
+#include "NodePaletteModel.h"
+#include <Source/Translation/TranslationBus.h>
+#include "TranslationGeneration.h"
 
 namespace ScriptCanvasEditor
 {
@@ -56,6 +59,23 @@ namespace ScriptCanvasEditor
         bool IsOverload() const;
         ScriptCanvas::PropertyStatus GetPropertyStatus() const;
 
+        AZ::IO::Path GetTranslationDataPath() const override
+        {
+            return AZ::IO::Path("Classes") / GetClassMethodName();
+        }
+
+        void GenerateTranslationData() override
+        {
+            AZ::BehaviorContext* behaviorContext{};
+            AZ::ComponentApplicationBus::BroadcastResult(behaviorContext, &AZ::ComponentApplicationRequests::GetBehaviorContext);
+
+            const char* className = m_className.toUtf8().data();
+            auto behaviorClass = behaviorContext->m_classes.find(className);
+
+            ScriptCanvasEditorTools::TranslationGeneration translation;
+            translation.TranslateBehaviorClass(behaviorClass->second);
+        }
+
     private:
         bool m_isOverload = false;
         QString m_className;
@@ -137,15 +157,31 @@ namespace ScriptCanvasEditor
         AZ_CLASS_ALLOCATOR(CustomNodePaletteTreeItem, AZ::SystemAllocator, 0);
         AZ_RTTI(CustomNodePaletteTreeItem, "{50E75C4D-F59C-4AF6-A6A3-5BAD557E335C}", GraphCanvas::DraggableNodePaletteTreeItem);
 
-        CustomNodePaletteTreeItem(const AZ::Uuid& typeId, AZStd::string_view nodeName);
+        explicit CustomNodePaletteTreeItem(const ScriptCanvasEditor::CustomNodeModelInformation&);
         ~CustomNodePaletteTreeItem() = default;
 
         GraphCanvas::GraphCanvasMimeEvent* CreateMimeEvent() const override;
 
         AZ::Uuid GetTypeId() const;
+        const ScriptCanvasEditor::CustomNodeModelInformation& GetInfo() const { return m_info; }
+
+        AZ::IO::Path GetTranslationDataPath() const override
+        {
+            AZStd::string filename = AZStd::string::format("%s_%s", GetInfo().m_categoryPath.c_str(), GetName().toUtf8().data());
+            filename = GraphCanvas::TranslationKey::Sanitize(filename);
+
+            return AZ::IO::Path("Nodes") / filename;
+        }
+
+        void GenerateTranslationData() override
+        {
+            ScriptCanvasEditorTools::TranslationGeneration translation;
+            translation.TranslateNode(m_typeId);
+        }
 
     private:
         AZ::Uuid m_typeId;
+        ScriptCanvasEditor::CustomNodeModelInformation m_info;
     };
 
     // </CustomNode>

Gems/ScriptCanvas/Code/Editor/View/Widgets/NodePalette/NodePaletteModel.cpp

@@ -32,6 +32,8 @@
 
 #include <ScriptCanvas/Data/Traits.h>
 
+AZ_DEFINE_BUDGET(NodePaletteModel);
+
 namespace
 {
     // Various Helper Methods
@@ -82,11 +84,6 @@ namespace
         return false;
     }
 
-    bool MethodHasAttribute(const AZ::BehaviorMethod* method, AZ::Crc32 attribute)
-    {
-        return AZ::FindAttribute(attribute, method->m_attributes) != nullptr; // warning C4800: 'AZ::Attribute *': forcing value to bool 'true' or 'false' (performance warning)
-    }
-
     // Checks for and returns the Category attribute from an AZ::AttributeArray
     AZStd::string GetCategoryPath(const AZ::AttributeArray& attributes, const AZ::BehaviorContext& behaviorContext)
     {
@@ -116,6 +113,9 @@ namespace
         , ScriptCanvas::PropertyStatus propertyStatus
         , bool isOverloaded)
     {
+
+        AZ_PROFILE_SCOPE(NodePaletteModel, "RegisterMethod");
+
         if (IsDeprecated(method.m_attributes))
         {
             return;
@@ -150,6 +150,9 @@ namespace
     void RegisterGlobalMethod(ScriptCanvasEditor::NodePaletteModel& nodePaletteModel, const AZ::BehaviorContext& behaviorContext,
         const AZ::BehaviorMethod& behaviorMethod)
     {
+
+        AZ_PROFILE_SCOPE(NodePaletteModel, "RegisterGlobalMethod");
+
         const auto isExposableOutcome = ScriptCanvas::IsExposable(behaviorMethod);
         if (!isExposableOutcome.IsSuccess())
         {
@@ -176,6 +179,8 @@ namespace
     //! Retrieve the list of EBuses t hat should not be exposed in the ScriptCanvasEditor Node Palette
     AZStd::unordered_set<AZ::Crc32> GetEBusExcludeSet(const AZ::BehaviorContext& behaviorContext)
     {
+        AZ_PROFILE_SCOPE(NodePaletteModel, "GetEBusExcludeSet");
+
         // We will skip buses that are ONLY registered on classes that derive from EditorComponentBase,
         // because they don't have a runtime implementation. Buses such as the TransformComponent which
         // is implemented by both an EditorComponentBase derived class and a Component derived class
@@ -252,6 +257,8 @@ namespace
     void PopulateScriptCanvasDerivedNodes(ScriptCanvasEditor::NodePaletteModel& nodePaletteModel,
         const AZ::SerializeContext& serializeContext)
     {
+        AZ_PROFILE_SCOPE(NodePaletteModel, "PopulateScriptCanvasDerivedNodes");
+
         // Get all the types.
         auto EnumerateLibraryDefintionNodes = [&nodePaletteModel, &serializeContext](
             const AZ::SerializeContext::ClassData* classData, const AZ::Uuid&) -> bool
@@ -333,6 +340,8 @@ namespace
 
     void PopulateVariablePalette()
     {
+        AZ_PROFILE_SCOPE(NodePaletteModel, "PopulateVariablePalette");
+
         auto dataRegistry = ScriptCanvas::GetDataRegistry();
 
         for (auto& type : dataRegistry->m_creatableTypes)
@@ -347,6 +356,8 @@ namespace
     void PopulateBehaviorContextGlobalMethods(ScriptCanvasEditor::NodePaletteModel& nodePaletteModel,
         const AZ::BehaviorContext& behaviorContext)
     {
+        AZ_PROFILE_SCOPE(NodePaletteModel, "PopulateBehaviorContextGlobalMethods");
+
         // BehaviorMethods are not associated with a class
         // therefore the Uuid is set to Null
         const AZ::Uuid behaviorMethodUuid = AZ::Uuid::CreateNull();
@@ -377,6 +388,8 @@ namespace
     void PopulateBehaviorContextGlobalProperties(ScriptCanvasEditor::NodePaletteModel& nodePaletteModel,
         const AZ::BehaviorContext& behaviorContext)
     {
+        AZ_PROFILE_SCOPE(NodePaletteModel, "PopulateBehaviorContextGlobalProperties");
+
         const AZ::Uuid behaviorMethodUuid = AZ::Uuid::CreateNull();
         for (const auto& [propertyName, behaviorProperty] : behaviorContext.m_properties)
         {
@@ -398,7 +411,7 @@ namespace
 
             if (behaviorProperty->m_getter && !behaviorProperty->m_setter)
             {
-                nodePaletteModel.RegisterGlobalConstant(behaviorContext, *behaviorProperty->m_getter);
+                nodePaletteModel.RegisterGlobalConstant(behaviorContext, behaviorProperty , *behaviorProperty->m_getter);
             }
             else
             {
@@ -419,6 +432,8 @@ namespace
     void PopulateBehaviorContextClassMethods(ScriptCanvasEditor::NodePaletteModel& nodePaletteModel,
         const AZ::BehaviorContext& behaviorContext)
     {
+        AZ_PROFILE_SCOPE(NodePaletteModel, "PopulateBehaviorContextClassMethods");
+
         AZ::SerializeContext* serializeContext{};
         AZ::ComponentApplicationBus::BroadcastResult(serializeContext, &AZ::ComponentApplicationRequests::GetSerializeContext);
 
@@ -456,21 +471,17 @@ namespace
             {
                 AZStd::string categoryPath;
 
-                AZStd::string translationContext = ScriptCanvasEditor::TranslationHelper::GetContextName(ScriptCanvasEditor::TranslationContextGroup::ClassMethod, behaviorClass->m_name);
-                AZStd::string translationKey = ScriptCanvasEditor::TranslationHelper::GetClassKey(ScriptCanvasEditor::TranslationContextGroup::ClassMethod, behaviorClass->m_name, ScriptCanvasEditor::TranslationKeyId::Category);
-                AZStd::string translatedCategory = QCoreApplication::translate(translationContext.c_str(), translationKey.c_str()).toUtf8().data();
+                GraphCanvas::TranslationKey key;
+                key << "BehaviorClass" << behaviorClass->m_name.c_str() << "details";
 
-                if (translatedCategory != translationKey)
+                GraphCanvas::TranslationRequests::Details details;
+                GraphCanvas::TranslationRequestBus::BroadcastResult(details, &GraphCanvas::TranslationRequests::GetDetails, key, details);
+
+                categoryPath = details.m_category;
+
+                if (categoryPath.empty())
                 {
-                    categoryPath = translatedCategory;
-                }
-                else
-                {
-                    AZStd::string behaviorContextCategory = GetCategoryPath(behaviorClass->m_attributes, behaviorContext);
-                    if (!behaviorContextCategory.empty())
-                    {
-                        categoryPath = behaviorContextCategory;
-                    }
+                    categoryPath = GetCategoryPath(behaviorClass->m_attributes, behaviorContext);
                 }
 
                 auto dataRegistry = ScriptCanvas::GetDataRegistry();
@@ -507,15 +518,13 @@ namespace
 
                 categoryPath.append("/");
 
-                AZStd::string displayName = ScriptCanvasEditor::TranslationHelper::GetClassKeyTranslation(ScriptCanvasEditor::TranslationContextGroup::ClassMethod, classIter.first, ScriptCanvasEditor::TranslationKeyId::Name);
-
-                if (displayName.empty())
+                if (details.m_name.empty())
                 {
                     categoryPath.append(classNamePretty.c_str());
                 }
                 else
                 {
-                    categoryPath.append(displayName.c_str());
+                    categoryPath.append(details.m_name.c_str());
                 }
 
                 for (auto property : behaviorClass->m_properties)
@@ -552,6 +561,9 @@ namespace
     void PopulateBehaviorContextOverloadedMethods(ScriptCanvasEditor::NodePaletteModel& nodePaletteModel,
         const AZ::BehaviorContext& behaviorContext)
     {
+        AZ_PROFILE_SCOPE(NodePaletteModel, "PopulateBehaviorContextOverloadedMethods");
+
+
         for (const AZ::ExplicitOverloadInfo& explicitOverload : behaviorContext.m_explicitOverloads)
         {
             RegisterMethod(nodePaletteModel, behaviorContext, explicitOverload.m_categoryPath, nullptr, explicitOverload.m_name, *explicitOverload.m_overloads.begin()->first, ScriptCanvas::PropertyStatus::None, true);
@@ -561,6 +573,8 @@ namespace
     void PopulateBehaviorContextEBusHandler(ScriptCanvasEditor::NodePaletteModel& nodePaletteModel,
         const AZ::BehaviorContext& behaviorContext, const AZ::BehaviorEBus& behaviorEbus)
     {
+        AZ_PROFILE_SCOPE(NodePaletteModel, "PopulateBehaviorContextEBusHandler");
+
         if (AZ::ScopedBehaviorEBusHandler handler{ behaviorEbus }; handler)
         {
             auto excludeEbusAttributeData = azdynamic_cast<const AZ::Edit::AttributeData<AZ::Script::Attributes::ExcludeFlags>*>(
@@ -573,32 +587,17 @@ namespace
             const AZ::BehaviorEBusHandler::EventArray& events(handler->GetEvents());
             if (!events.empty())
             {
-                AZStd::string translationContext = ScriptCanvasEditor::TranslationHelper::GetContextName(ScriptCanvasEditor::TranslationContextGroup::EbusHandler, behaviorEbus.m_name);
-                AZStd::string categoryPath;
 
+                GraphCanvas::TranslationKey key;
+                key << "EBusHandler" << behaviorEbus.m_name.c_str() << "details";
+
+                GraphCanvas::TranslationRequests::Details details;
+                GraphCanvas::TranslationRequestBus::BroadcastResult(details, &GraphCanvas::TranslationRequests::GetDetails, key, details);
+
+                AZStd::string categoryPath = details.m_category.empty() ? GetCategoryPath(behaviorEbus.m_attributes, behaviorContext) : details.m_category;
+
+                // Treat the EBusHandler name as a Category key in order to allow multiple buses to be merged into a single Category.
                 {
-                    AZStd::string translationKey = ScriptCanvasEditor::TranslationHelper::GetClassKey(ScriptCanvasEditor::TranslationContextGroup::EbusHandler, behaviorEbus.m_name, ScriptCanvasEditor::TranslationKeyId::Category);
-                    AZStd::string translatedCategory = QCoreApplication::translate(translationContext.c_str(), translationKey.c_str()).toUtf8().data();
-
-                    if (translatedCategory != translationKey)
-                    {
-                        categoryPath = translatedCategory;
-                    }
-                    else
-                    {
-                        AZStd::string behaviourContextCategory = GetCategoryPath(behaviorEbus.m_attributes, behaviorContext);
-                        if (!behaviourContextCategory.empty())
-                        {
-                            categoryPath = behaviourContextCategory;
-                        }
-                    }
-                }
-
-                // Treat the EBusHandler name as a Category key in order to allow multiple busses to be merged into a single Category.
-                {
-                    AZStd::string translationKey = ScriptCanvasEditor::TranslationHelper::GetClassKey(ScriptCanvasEditor::TranslationContextGroup::EbusHandler, behaviorEbus.m_name, ScriptCanvasEditor::TranslationKeyId::Name);
-                    AZStd::string translatedName = QCoreApplication::translate(translationContext.c_str(), translationKey.c_str()).toUtf8().data();
-
                     if (!categoryPath.empty())
                     {
                         categoryPath.append("/");
@@ -608,9 +607,9 @@ namespace
                         categoryPath = "Other/";
                     }
 
-                    if (translatedName != translationKey)
+                    if (!details.m_name.empty())
                     {
-                        categoryPath.append(translatedName.c_str());
+                        categoryPath.append(details.m_name.c_str());
                     }
                     else
                     {
@@ -629,31 +628,22 @@ namespace
     void PopulateBehaviorContextEBusEventMethods(ScriptCanvasEditor::NodePaletteModel& nodePaletteModel,
         const AZ::BehaviorContext& behaviorContext, const AZ::BehaviorEBus& behaviorEbus)
     {
+        AZ_PROFILE_SCOPE(NodePaletteModel, "PopulateBehaviorContextEBusEventMethods");
+
         if (!behaviorEbus.m_events.empty())
         {
-            AZStd::string categoryPath;
+            GraphCanvas::TranslationKey key;
+            key << "EBusSender" << behaviorEbus.m_name.c_str() << "details";
 
-            AZStd::string translationContext = ScriptCanvasEditor::TranslationHelper::GetContextName(ScriptCanvasEditor::TranslationContextGroup::EbusSender, behaviorEbus.m_name);
-            AZStd::string translationKey = ScriptCanvasEditor::TranslationHelper::GetClassKey(ScriptCanvasEditor::TranslationContextGroup::EbusSender, behaviorEbus.m_name, ScriptCanvasEditor::TranslationKeyId::Category);
-            AZStd::string translatedCategory = QCoreApplication::translate(translationContext.c_str(), translationKey.c_str()).toUtf8().data();
+            GraphCanvas::TranslationRequests::Details details;
+            GraphCanvas::TranslationRequestBus::BroadcastResult(details, &GraphCanvas::TranslationRequests::GetDetails, key, details);
 
-            if (translatedCategory != translationKey)
-            {
-                categoryPath = translatedCategory;
-            }
-            else
-            {
-                AZStd::string behaviourContextCategory = GetCategoryPath(behaviorEbus.m_attributes, behaviorContext);
-                if (!behaviourContextCategory.empty())
-                {
-                    categoryPath = behaviourContextCategory;
-                }
-            }
+            AZStd::string categoryPath = details.m_category.empty() ? GetCategoryPath(behaviorEbus.m_attributes, behaviorContext) : details.m_category;
 
             // Parent
-            AZStd::string displayName = ScriptCanvasEditor::TranslationHelper::GetClassKeyTranslation(ScriptCanvasEditor::TranslationContextGroup::EbusSender, behaviorEbus.m_name, ScriptCanvasEditor::TranslationKeyId::Name);
+            AZStd::string displayName = details.m_name;
 
-            // Treat the EBus name as a Category key in order to allow multiple busses to be merged into a single Category.
+            // Treat the EBus name as a Category key in order to allow multiple buses to be merged into a single Category.
             if (!categoryPath.empty())
             {
                 categoryPath.append("/");
@@ -663,18 +653,18 @@ namespace
                 categoryPath = "Other/";
             }
 
-            if (displayName.empty())
+            if (!details.m_name.empty())
             {
-                categoryPath.append(behaviorEbus.m_name.c_str());
+                categoryPath.append(details.m_name.c_str());
             }
             else
             {
-                categoryPath.append(displayName.c_str());
+                categoryPath.append(behaviorEbus.m_name.c_str());
             }
 
             ScriptCanvasEditor::CategoryInformation ebusCategoryInformation;
 
-            ebusCategoryInformation.m_tooltip = ScriptCanvasEditor::TranslationHelper::GetClassKeyTranslation(ScriptCanvasEditor::TranslationContextGroup::EbusSender, behaviorEbus.m_name, ScriptCanvasEditor::TranslationKeyId::Tooltip);
+            ebusCategoryInformation.m_tooltip = details.m_tooltip;
 
             nodePaletteModel.RegisterCategoryInformation(categoryPath, ebusCategoryInformation);
 
@@ -700,6 +690,7 @@ namespace
     void PopulateBehaviorContextEBuses(ScriptCanvasEditor::NodePaletteModel& nodePaletteModel,
         const AZ::BehaviorContext& behaviorContext)
     {
+        AZ_PROFILE_SCOPE(NodePaletteModel, "PopulateBehaviorContextEBuses");
         AZStd::unordered_set<AZ::Crc32> skipBuses = GetEBusExcludeSet(behaviorContext);
 
         for (const auto& [ebusName, behaviorEbus] : behaviorContext.m_ebuses)
@@ -758,10 +749,13 @@ namespace
         }
     }
 
+
     // Helper function for populating the node palette model.
     // Pulled out just to make the tabbing a bit nicer, since it's a huge method.
     void PopulateNodePaletteModel(ScriptCanvasEditor::NodePaletteModel& nodePaletteModel)
     {
+        AZ_PROFILE_SCOPE(NodePaletteModel, "PopulateNodePaletteModel");
+
         AZ::SerializeContext* serializeContext = nullptr;
         AZ::ComponentApplicationBus::BroadcastResult(serializeContext, &AZ::ComponentApplicationRequests::GetSerializeContext);
 
@@ -791,8 +785,10 @@ namespace
 
         // Populates the NodePalette with EBus Event method nodes and EBus Event handler nodes
         PopulateBehaviorContextEBuses(nodePaletteModel, *behaviorContext);
+
         // Populates the NodePalette with Methods reflected directly on the BehaviorContext
         PopulateBehaviorContextGlobalMethods(nodePaletteModel, *behaviorContext);
+
         // Populates the NodePalette with Properties reflected directly on the BehaviorContext
         PopulateBehaviorContextGlobalProperties(nodePaletteModel, *behaviorContext);
     }
@@ -895,6 +891,8 @@ namespace ScriptCanvasEditor
 
     void NodePaletteModel::RegisterCustomNode(AZStd::string_view categoryPath, const AZ::Uuid& uuid, AZStd::string_view name, const AZ::SerializeContext::ClassData* classData)
     {
+
+        AZ_PROFILE_SCOPE(NodePaletteModel, "NodePaletteModel::RegisterCustomNode");
         ScriptCanvas::NodeTypeIdentifier nodeIdentifier = ScriptCanvas::NodeUtils::ConstructCustomNodeIdentifier(uuid);
 
         auto mapIter = m_registeredNodes.find(nodeIdentifier);
@@ -905,47 +903,38 @@ namespace ScriptCanvasEditor
 
             customNodeInformation->m_nodeIdentifier = nodeIdentifier;
             customNodeInformation->m_typeId = uuid;
-
             customNodeInformation->m_displayName = name;
+            customNodeInformation->m_categoryPath = categoryPath;
 
             bool isDeprecated(false);
 
             if (classData && classData->m_editData && classData->m_editData->m_name)
             {
-                auto nodeContextName = ScriptCanvasEditor::Nodes::GetContextName(*classData);
-                auto contextName = ScriptCanvasEditor::TranslationHelper::GetContextName(ScriptCanvasEditor::TranslationContextGroup::ClassMethod, nodeContextName);
+                GraphCanvas::TranslationKey key;
+                key << "ScriptCanvas::Node" << classData->m_typeId.ToString<AZStd::string>().c_str() << "details";
 
-                GraphCanvas::TranslationKeyedString nodeKeyedString({}, contextName);
-                nodeKeyedString.m_key = ScriptCanvasEditor::TranslationHelper::GetKey(ScriptCanvasEditor::TranslationContextGroup::ClassMethod, nodeContextName, classData->m_editData->m_name, ScriptCanvasEditor::TranslationItemType::Node, ScriptCanvasEditor::TranslationKeyId::Name);
-                customNodeInformation->m_displayName = nodeKeyedString.GetDisplayString();
+                GraphCanvas::TranslationRequests::Details details;
+                GraphCanvas::TranslationRequestBus::BroadcastResult(details, &GraphCanvas::TranslationRequests::GetDetails, key, details);
 
-                GraphCanvas::TranslationKeyedString tooltipKeyedString(AZStd::string(), nodeKeyedString.m_context);
-                tooltipKeyedString.m_key = ScriptCanvasEditor::TranslationHelper::GetKey(ScriptCanvasEditor::TranslationContextGroup::ClassMethod, nodeContextName, classData->m_editData->m_name, ScriptCanvasEditor::TranslationItemType::Node, ScriptCanvasEditor::TranslationKeyId::Tooltip);
+                if (details.m_name.empty())
+                {
+                    details.m_name = classData->m_editData->m_name;
+                    details.m_tooltip = classData->m_editData->m_description;
+                }
 
-                customNodeInformation->m_toolTip = tooltipKeyedString.GetDisplayString();
+                customNodeInformation->m_displayName = details.m_name;
+                customNodeInformation->m_toolTip = details.m_tooltip;
+
+                if (!details.m_category.empty())
+                {
+                    customNodeInformation->m_categoryPath = details.m_category;
+                }
 
                 if (customNodeInformation->m_displayName.empty())
                 {
                     customNodeInformation->m_displayName = classData->m_editData->m_name;
                 }
 
-                GraphCanvas::TranslationKeyedString categoryKeyedString(ScriptCanvasEditor::Nodes::GetCategoryName(*classData), nodeKeyedString.m_context);
-                categoryKeyedString.m_key = ScriptCanvasEditor::TranslationHelper::GetKey(ScriptCanvasEditor::TranslationContextGroup::ClassMethod, nodeContextName, classData->m_editData->m_name, ScriptCanvasEditor::TranslationItemType::Node, ScriptCanvasEditor::TranslationKeyId::Category);
-
-                customNodeInformation->m_categoryPath = categoryKeyedString.GetDisplayString();
-
-                if (customNodeInformation->m_categoryPath.empty())
-                {
-                    if (contextName.empty())
-                    {
-                        customNodeInformation->m_categoryPath = categoryPath;
-                    }
-                    else
-                    {
-                        customNodeInformation->m_categoryPath = contextName;
-                    }
-                }
-
                 auto editorDataElement = classData->m_editData->FindElementData(AZ::Edit::ClassElements::EditorData);
 
                 if (editorDataElement)
@@ -1003,11 +992,13 @@ namespace ScriptCanvasEditor
         ( const AZStd::string& categoryPath
         , const AZStd::string& methodClass
         , const AZStd::string& methodName
-        , const AZ::BehaviorMethod* behaviorMethod
-        , const AZ::BehaviorContext* behaviorContext
+        , const AZ::BehaviorMethod*
+        , const AZ::BehaviorContext*
         , ScriptCanvas::PropertyStatus propertyStatus
         , bool isOverload)
     {
+        AZ_PROFILE_SCOPE(NodePaletteModel, "NodePaletteModel::RegisterClassNode");
+
         ScriptCanvas::NodeTypeIdentifier nodeIdentifier = isOverload ? ScriptCanvas::NodeUtils::ConstructMethodOverloadedNodeIdentifier(methodName) : ScriptCanvas::NodeUtils::ConstructMethodNodeIdentifier(methodClass, methodName, propertyStatus);
 
         auto registerIter = m_registeredNodes.find(nodeIdentifier);
@@ -1022,44 +1013,34 @@ namespace ScriptCanvasEditor
             methodModelInformation->m_propertyStatus = propertyStatus;
             methodModelInformation->m_titlePaletteOverride = "MethodNodeTitlePalette";
 
-            methodModelInformation->m_displayName = TranslationHelper::GetKeyTranslation(TranslationContextGroup::ClassMethod, methodClass.c_str(), methodName.c_str(), TranslationItemType::Node, TranslationKeyId::Name);
+            GraphCanvas::TranslationKey catkey;
+            catkey << "BehaviorClass" << methodClass.c_str() << "details";
+            GraphCanvas::TranslationRequests::Details catdetails;
+            GraphCanvas::TranslationRequestBus::BroadcastResult(catdetails, &GraphCanvas::TranslationRequests::GetDetails, catkey, catdetails);
 
-            if (methodModelInformation->m_displayName.empty())
-            {
-                methodModelInformation->m_displayName = methodName;
-            }
+            GraphCanvas::TranslationKey key;
+            key << "BehaviorClass" << methodClass.c_str() << "methods" << methodName.c_str() << "details";
 
-            methodModelInformation->m_toolTip = TranslationHelper::GetKeyTranslation(TranslationContextGroup::ClassMethod, methodClass.c_str(), methodName.c_str(), TranslationItemType::Node, TranslationKeyId::Tooltip);            
+            GraphCanvas::TranslationRequests::Details details;
+            GraphCanvas::TranslationRequestBus::BroadcastResult(details, &GraphCanvas::TranslationRequests::GetDetails, key, details);
 
-            GraphCanvas::TranslationKeyedString methodCategoryString;
-            methodCategoryString.m_context = ScriptCanvasEditor::TranslationHelper::GetContextName(ScriptCanvasEditor::TranslationContextGroup::ClassMethod, methodClass.c_str());
-            methodCategoryString.m_key = ScriptCanvasEditor::TranslationHelper::GetKey(ScriptCanvasEditor::TranslationContextGroup::ClassMethod, methodClass.c_str(), methodName.c_str(), ScriptCanvasEditor::TranslationItemType::Node, ScriptCanvasEditor::TranslationKeyId::Category);
-
-            methodModelInformation->m_categoryPath = methodCategoryString.GetDisplayString();
+            methodModelInformation->m_displayName = details.m_name.empty() ? methodName : details.m_name;
+            methodModelInformation->m_toolTip = details.m_tooltip;
+            methodModelInformation->m_categoryPath = categoryPath;
 
             if (methodModelInformation->m_categoryPath.empty())
             {
-                if (!MethodHasAttribute(behaviorMethod, AZ::ScriptCanvasAttributes::FloatingFunction))
-                {    
-                    methodModelInformation->m_categoryPath = categoryPath;
-                }   
-                else if (MethodHasAttribute(behaviorMethod, AZ::Script::Attributes::Category))
-                {
-                    methodModelInformation->m_categoryPath = GetCategoryPath(behaviorMethod->m_attributes, (*behaviorContext));                    
-                }                
-
-                if (methodModelInformation->m_categoryPath.empty())
-                {
-                    methodModelInformation->m_categoryPath = "Other";
-                }
+                methodModelInformation->m_categoryPath = "Other";
             }
 
             m_registeredNodes.emplace(AZStd::make_pair(nodeIdentifier, methodModelInformation));
         }        
     }
 
-    void NodePaletteModel::RegisterGlobalConstant(const AZ::BehaviorContext& behaviorContext, const AZ::BehaviorMethod& behaviorMethod)
+    void NodePaletteModel::RegisterGlobalConstant(const AZ::BehaviorContext&, const AZ::BehaviorProperty* behaviorProperty, const AZ::BehaviorMethod& behaviorMethod)
     {
+        AZ_PROFILE_SCOPE(NodePaletteModel, "NodePaletteModel::RegisterGlobalConstant");
+
         // Construct Node Identifier using the BehaviorMethod name and the ScriptCanvas Method typeid
         ScriptCanvas::NodeTypeIdentifier nodeIdentifier =
             ScriptCanvas::NodeUtils::ConstructGlobalMethodNodeIdentifier(behaviorMethod.m_name);
@@ -1073,35 +1054,29 @@ namespace ScriptCanvasEditor
 
             methodModelInformation->m_titlePaletteOverride = "MethodNodeTitlePalette";
 
-            methodModelInformation->m_displayName = TranslationHelper::GetGlobalMethodKeyTranslation(methodModelInformation->m_methodName,
-                TranslationItemType::Node, TranslationKeyId::Name);
-            methodModelInformation->m_toolTip = TranslationHelper::GetGlobalMethodKeyTranslation(methodModelInformation->m_methodName,
-                TranslationItemType::Node, TranslationKeyId::Tooltip);
-            methodModelInformation->m_categoryPath = TranslationHelper::GetGlobalMethodKeyTranslation(methodModelInformation->m_methodName,
-                TranslationItemType::Node, TranslationKeyId::Category);
+            GraphCanvas::TranslationKey key;
+            key << "Constant" << behaviorProperty->m_name.c_str() << "details";
 
-            if (methodModelInformation->m_displayName.empty())
-            {
-                methodModelInformation->m_displayName = methodModelInformation->m_methodName;
-            }
+            GraphCanvas::TranslationRequests::Details details;
+            GraphCanvas::TranslationRequestBus::BroadcastResult(details, &GraphCanvas::TranslationRequests::GetDetails, key, details);
+
+            methodModelInformation->m_displayName = details.m_name;
+            methodModelInformation->m_toolTip = details.m_tooltip;
+            methodModelInformation->m_categoryPath = details.m_category;
 
             if (methodModelInformation->m_categoryPath.empty())
             {
-                methodModelInformation->m_categoryPath = GetCategoryPath(behaviorMethod.m_attributes, behaviorContext);
-                // Default to making the Category for Global Methods to be informative that the method
-                // is registered with the Behavior Context
-                if (methodModelInformation->m_categoryPath.empty())
-                {
-                    methodModelInformation->m_categoryPath = "Constants";
-                }
+                methodModelInformation->m_categoryPath = "Constants";
             }
 
             m_registeredNodes.emplace(nodeIdentifier, methodModelInformation.release());
         }
     }
 
-    void NodePaletteModel::RegisterMethodNode(const AZ::BehaviorContext& behaviorContext, const AZ::BehaviorMethod& behaviorMethod)
+    void NodePaletteModel::RegisterMethodNode(const AZ::BehaviorContext&, const AZ::BehaviorMethod& behaviorMethod)
     {
+        AZ_PROFILE_SCOPE(NodePaletteModel, "NodePaletteModel::RegisterMethodNode");
+
         // Construct Node Identifier using the BehaviorMethod name and the ScriptCanvas Method typeid
         ScriptCanvas::NodeTypeIdentifier nodeIdentifier =
             ScriptCanvas::NodeUtils::ConstructGlobalMethodNodeIdentifier(behaviorMethod.m_name);
@@ -1112,31 +1087,17 @@ namespace ScriptCanvasEditor
             auto  methodModelInformation = AZStd::make_unique<GlobalMethodNodeModelInformation>();
             methodModelInformation->m_methodName = behaviorMethod.m_name;
             methodModelInformation->m_nodeIdentifier = nodeIdentifier;
-
             methodModelInformation->m_titlePaletteOverride = "MethodNodeTitlePalette";
 
-            methodModelInformation->m_displayName = TranslationHelper::GetGlobalMethodKeyTranslation(methodModelInformation->m_methodName,
-                TranslationItemType::Node, TranslationKeyId::Name);
-            methodModelInformation->m_toolTip = TranslationHelper::GetGlobalMethodKeyTranslation(methodModelInformation->m_methodName,
-                TranslationItemType::Node, TranslationKeyId::Tooltip);
-            methodModelInformation->m_categoryPath = TranslationHelper::GetGlobalMethodKeyTranslation(methodModelInformation->m_methodName,
-                TranslationItemType::Node, TranslationKeyId::Category);
+            GraphCanvas::TranslationKey key;
+            key << "BehaviorMethod" << behaviorMethod.m_name.c_str() << "details";
 
-            if (methodModelInformation->m_displayName.empty())
-            {
-                methodModelInformation->m_displayName = methodModelInformation->m_methodName;
-            }
+            GraphCanvas::TranslationRequests::Details details;
+            GraphCanvas::TranslationRequestBus::BroadcastResult(details, &GraphCanvas::TranslationRequests::GetDetails, key, details);
 
-            if (methodModelInformation->m_categoryPath.empty())
-            {
-                methodModelInformation->m_categoryPath = GetCategoryPath(behaviorMethod.m_attributes, behaviorContext);
-                // Default to making the Category for Global Methods to be informative that the method
-                // is registered with the Behavior Context
-                if (methodModelInformation->m_categoryPath.empty())
-                {
-                    methodModelInformation->m_categoryPath = "Behavior Context: Global Methods";
-                }
-            }
+            methodModelInformation->m_displayName = details.m_name.empty() ? behaviorMethod.m_name : details.m_name;
+            methodModelInformation->m_toolTip = details.m_tooltip.empty() ? "" : details.m_tooltip;
+            methodModelInformation->m_categoryPath = details.m_category.empty() ? "Behavior Context: Global Methods" : details.m_category;
 
             m_registeredNodes.emplace(nodeIdentifier, methodModelInformation.release());
         }
@@ -1144,6 +1105,8 @@ namespace ScriptCanvasEditor
 
     void NodePaletteModel::RegisterEBusHandlerNodeModelInformation(AZStd::string_view categoryPath, AZStd::string_view busName, AZStd::string_view eventName, const ScriptCanvas::EBusBusId& busId, const AZ::BehaviorEBusHandler::BusForwarderEvent& forwardEvent)
     {
+
+        AZ_PROFILE_SCOPE(NodePaletteModel, "NodePaletteModel::RegisterEBusHandlerNodeModelInformation");
         ScriptCanvas::NodeTypeIdentifier nodeIdentifier = ScriptCanvas::NodeUtils::ConstructEBusEventReceiverIdentifier(busId, forwardEvent.m_eventId);
 
         auto nodeIter = m_registeredNodes.find(nodeIdentifier);
@@ -1161,18 +1124,14 @@ namespace ScriptCanvasEditor
             handlerInformation->m_busId = busId;
             handlerInformation->m_eventId = forwardEvent.m_eventId;
 
-            AZStd::string displayEventName = TranslationHelper::GetKeyTranslation(TranslationContextGroup::EbusHandler, busName.data(), eventName.data(), TranslationItemType::Node, TranslationKeyId::Name);
+            GraphCanvas::TranslationKey key;
+            key << "EBusHandler" << busName << "methods" << eventName << "details";
 
-            if (displayEventName.empty())
-            {
-                handlerInformation->m_displayName = eventName;
-            }
-            else
-            {
-                handlerInformation->m_displayName = displayEventName;
-            }
+            GraphCanvas::TranslationRequests::Details details;
+            GraphCanvas::TranslationRequestBus::BroadcastResult(details, &GraphCanvas::TranslationRequests::GetDetails, key, details);
 
-            handlerInformation->m_toolTip = TranslationHelper::GetKeyTranslation(TranslationContextGroup::EbusHandler, busName.data(), eventName.data(), TranslationItemType::Node, TranslationKeyId::Tooltip);            
+            handlerInformation->m_displayName = details.m_name.empty() ? eventName : details.m_name.c_str();
+            handlerInformation->m_toolTip = details.m_tooltip.empty() ? "" : details.m_tooltip;
 
             m_registeredNodes.emplace(AZStd::make_pair(nodeIdentifier, handlerInformation));
         }
@@ -1188,6 +1147,8 @@ namespace ScriptCanvasEditor
         , ScriptCanvas::PropertyStatus propertyStatus
         , bool isOverload)
     {
+        AZ_PROFILE_SCOPE(NodePaletteModel, "NodePaletteModel::RegisterEBusSenderNodeModelInformation");
+
         ScriptCanvas::NodeTypeIdentifier nodeIdentifier = isOverload ? ScriptCanvas::NodeUtils::ConstructEBusEventSenderOverloadedIdentifier(busId, eventId) : ScriptCanvas::NodeUtils::ConstructEBusEventSenderIdentifier(busId, eventId);
 
         auto nodeIter = m_registeredNodes.find(nodeIdentifier);
@@ -1207,18 +1168,14 @@ namespace ScriptCanvasEditor
             senderInformation->m_busId = busId;
             senderInformation->m_eventId = eventId;
 
-            AZStd::string displayEventName = TranslationHelper::GetKeyTranslation(TranslationContextGroup::EbusSender, busName.data(), eventName.data(), TranslationItemType::Node, TranslationKeyId::Name);
+            GraphCanvas::TranslationKey key;
+            key << "EBusSender" << busName << "methods" << eventName << "details";
 
-            if (displayEventName.empty())
-            {
-                senderInformation->m_displayName = eventName;
-            }
-            else
-            {
-                senderInformation->m_displayName = displayEventName;
-            }
+            GraphCanvas::TranslationRequests::Details details;
+            GraphCanvas::TranslationRequestBus::BroadcastResult(details, &GraphCanvas::TranslationRequests::GetDetails, key, details);
 
-            senderInformation->m_toolTip = TranslationHelper::GetKeyTranslation(TranslationContextGroup::EbusSender, busName.data(), eventName.data(), TranslationItemType::Node, TranslationKeyId::Tooltip);
+            senderInformation->m_displayName = details.m_name.empty() ? eventName : details.m_name.c_str();
+            senderInformation->m_toolTip = details.m_tooltip.empty() ? "" : details.m_tooltip;
 
             m_registeredNodes.emplace(AZStd::make_pair(nodeIdentifier, senderInformation));
         }
@@ -1226,6 +1183,8 @@ namespace ScriptCanvasEditor
 
     AZStd::vector<ScriptCanvas::NodeTypeIdentifier> NodePaletteModel::RegisterScriptEvent(ScriptEvents::ScriptEventsAsset* scriptEventAsset)
     {
+
+        AZ_PROFILE_SCOPE(NodePaletteModel, "NodePaletteModel::RegisterScriptEvent");
         const ScriptEvents::ScriptEvent& scriptEvent = scriptEventAsset->m_definition;
 
         ScriptCanvas::EBusBusId busId = scriptEventAsset->GetBusId();
@@ -1236,7 +1195,7 @@ namespace ScriptCanvasEditor
 
         AZStd::vector<ScriptCanvas::NodeTypeIdentifier> identifiers;
 
-        // Each event has a handler and a reciever
+        // Each event has a handler and a receiver
         identifiers.reserve(methods.size() * 2);
 
         for (const auto& method : methods)
@@ -1444,6 +1403,8 @@ namespace ScriptCanvasEditor
 
     AZStd::vector<ScriptCanvas::NodeTypeIdentifier> NodePaletteModel::ProcessAsset(AzToolsFramework::AssetBrowser::AssetBrowserEntry* entry)
     {
+        AZ_PROFILE_SCOPE(NodePaletteModel, "NodePaletteModel::RegisterScriptEvent");
+
         AZStd::lock_guard<AZStd::recursive_mutex> myLocker(m_mutex);
 
         if (entry)

Gems/ScriptCanvas/Code/Editor/View/Widgets/NodePalette/NodePaletteModel.h

@@ -80,7 +80,8 @@ namespace ScriptCanvasEditor
         void RegisterCustomNode(AZStd::string_view categoryPath, const AZ::Uuid& uuid, AZStd::string_view name, const AZ::SerializeContext::ClassData* classData);
         void RegisterClassNode(const AZStd::string& categoryPath, const AZStd::string& methodClass, const AZStd::string& methodName, const AZ::BehaviorMethod* behaviorMethod, const AZ::BehaviorContext* behaviorContext, ScriptCanvas::PropertyStatus propertyStatus, bool isOverload);
         void RegisterMethodNode(const AZ::BehaviorContext& behaviorContext, const AZ::BehaviorMethod& behaviorMethod);
-        void RegisterGlobalConstant(const AZ::BehaviorContext& behaviorContext, const AZ::BehaviorMethod& behaviorMethod);
+        void RegisterGlobalConstant(const AZ::BehaviorContext& behaviorContext, const AZ::BehaviorProperty* behaviorProperty, const AZ::BehaviorMethod& behaviorMethod);
+
 
         void RegisterEBusHandlerNodeModelInformation(AZStd::string_view categoryPath, AZStd::string_view busName, AZStd::string_view eventName, const ScriptCanvas::EBusBusId& busId, const AZ::BehaviorEBusHandler::BusForwarderEvent& forwardEvent);
         void RegisterEBusSenderNodeModelInformation(AZStd::string_view categoryPath, AZStd::string_view busName, AZStd::string_view eventName, const ScriptCanvas::EBusBusId& busId, const ScriptCanvas::EBusEventId& eventId, const AZ::BehaviorEBusEventSender& eventSender, ScriptCanvas::PropertyStatus propertyStatus, bool isOverload);

Gems/ScriptCanvas/Code/Editor/View/Widgets/ScriptCanvasNodePaletteDockWidget.cpp

@@ -63,6 +63,7 @@
 #include <ScriptCanvas/Libraries/Libraries.h>
 #include <ScriptCanvas/Utils/NodeUtils.h>
 #include <ScriptEvents/ScriptEventsAsset.h>
+#include "AzQtComponents/Utilities/DesktopUtilities.h"
 
 namespace ScriptCanvasEditor
 {
@@ -99,7 +100,7 @@ namespace ScriptCanvasEditor
 
                 if (auto customModelInformation = azrtti_cast<const CustomNodeModelInformation*>(modelInformation))
                 {
-                    createdItem = parentItem->CreateChildNode<CustomNodePaletteTreeItem>(customModelInformation->m_typeId, customModelInformation->m_displayName);
+                    createdItem = parentItem->CreateChildNode<CustomNodePaletteTreeItem>(*customModelInformation);
                     createdItem->SetToolTip(QString(customModelInformation->m_toolTip.c_str()));
                 }
                 else if (auto methodNodeModelInformation = azrtti_cast<const MethodNodeModelInformation*>(modelInformation))
@@ -660,6 +661,11 @@ namespace ScriptCanvasEditor
             , m_previousCycleAction(nullptr)
             , m_ignoreSelectionChanged(false)
         {
+            
+            GraphCanvas::NodePaletteTreeView* treeView = GetTreeView();
+
+            treeView->setContextMenuPolicy(Qt::ContextMenuPolicy::ActionsContextMenu);
+
             if (!paletteConfig.m_isInContextMenu)
             {
                 QMenu* creationMenu = new QMenu();
@@ -677,10 +683,11 @@ namespace ScriptCanvasEditor
 
                 AddSearchCustomizationWidget(m_newCustomEvent);
 
-                GraphCanvas::NodePaletteTreeView* treeView = GetTreeView();
+                
 
                 {
                     m_nextCycleAction = new QAction(treeView);
+                    m_nextCycleAction->setText(tr("Next Instance in Graph"));
 
                     m_nextCycleAction->setShortcut(QKeySequence(Qt::Key_F8));
                     treeView->addAction(m_nextCycleAction);
@@ -690,6 +697,7 @@ namespace ScriptCanvasEditor
 
                 {
                     m_previousCycleAction = new QAction(treeView);
+                    m_previousCycleAction->setText(tr("Previous Instance in Graph"));
 
                     m_previousCycleAction->setShortcut(QKeySequence(Qt::Key_F7));
                     treeView->addAction(m_previousCycleAction);
@@ -699,6 +707,23 @@ namespace ScriptCanvasEditor
 
                 QObject::connect(treeView->selectionModel(), &QItemSelectionModel::selectionChanged, this, &NodePaletteDockWidget::OnTreeSelectionChanged);
                 QObject::connect(treeView, &GraphCanvas::NodePaletteTreeView::OnTreeItemDoubleClicked, this, &NodePaletteDockWidget::HandleTreeItemDoubleClicked);
+
+                {
+                    m_openTranslationData = new QAction(treeView);
+                    m_openTranslationData->setText("Open Translation Data");
+                    treeView->addAction(m_openTranslationData);
+
+                    QObject::connect(m_openTranslationData, &QAction::triggered, this, &NodePaletteDockWidget::OpenTranslationData);
+                }
+
+                {
+                    m_generateTranslation = new QAction(treeView);
+                    m_generateTranslation->setText("Generate Translation");
+                    treeView->addAction(m_generateTranslation);
+
+                    QObject::connect(m_generateTranslation, &QAction::triggered, this, &NodePaletteDockWidget::GenerateTranslation);
+                }
+
             }
 
             ConfigureSearchCustomizationMargins(QMargins(0, 0, 0, 0), 0);
@@ -781,6 +806,7 @@ namespace ScriptCanvasEditor
             {
                 m_nextCycleAction->setEnabled(true);
                 m_previousCycleAction->setEnabled(true);
+                m_openTranslationData->setEnabled(true);
             }
         }
 
@@ -793,6 +819,7 @@ namespace ScriptCanvasEditor
             {
                 m_nextCycleAction->setEnabled(false);
                 m_previousCycleAction->setEnabled(false);
+                m_openTranslationData->setEnabled(false);
             }
         }
 
@@ -816,6 +843,84 @@ namespace ScriptCanvasEditor
             CycleToNextNode();
         }
 
+        static AZStd::string GetGemPath(const AZStd::string& gemName)
+        {
+            if (auto settingsRegistry = AZ::Interface<AZ::SettingsRegistryInterface>::Get(); settingsRegistry != nullptr)
+            {
+                AZ::IO::Path gemSourceAssetDirectories;
+                AZStd::vector<AzFramework::GemInfo> gemInfos;
+                if (AzFramework::GetGemsInfo(gemInfos, *settingsRegistry))
+                {
+                    auto FindGemByName = [gemName](const AzFramework::GemInfo& gemInfo)
+                    {
+                        return gemInfo.m_gemName == gemName;
+                    };
+                    // Gather unique list of Gem Paths from the Settings Registry
+
+                    auto foundIt = AZStd::find_if(gemInfos.begin(), gemInfos.end(), FindGemByName);
+                    if (foundIt != gemInfos.end())
+                    {
+                        const AzFramework::GemInfo& gemInfo = *foundIt;
+                        for (const AZ::IO::Path& absoluteSourcePath : gemInfo.m_absoluteSourcePaths)
+                        {
+                            gemSourceAssetDirectories = (absoluteSourcePath / gemInfo.GetGemAssetFolder());
+                        }
+
+                        return gemSourceAssetDirectories.c_str();
+                    }
+                }
+            }
+            return "";
+        }
+
+        void NodePaletteDockWidget::GenerateTranslation()
+        {
+            QModelIndexList indexList = GetTreeView()->selectionModel()->selectedRows();
+
+            if (indexList.size() == 1)
+            {
+                QSortFilterProxyModel* filterModel = static_cast<QSortFilterProxyModel*>(GetTreeView()->model());
+
+                for (const QModelIndex& index : indexList)
+                {
+                    QModelIndex sourceIndex = filterModel->mapToSource(index);
+
+                    GraphCanvas::NodePaletteTreeItem* nodePaletteItem = static_cast<GraphCanvas::NodePaletteTreeItem*>(sourceIndex.internalPointer());
+                    nodePaletteItem->GenerateTranslationData();
+                }
+            }
+        }
+
+        void NodePaletteDockWidget::OpenTranslationData()
+        {
+            QModelIndexList indexList = GetTreeView()->selectionModel()->selectedRows();
+
+            if (indexList.size() == 1)
+            {
+                QSortFilterProxyModel* filterModel = static_cast<QSortFilterProxyModel*>(GetTreeView()->model());
+
+                for (const QModelIndex& index : indexList)
+                {
+                    QModelIndex sourceIndex = filterModel->mapToSource(index);
+
+                    GraphCanvas::NodePaletteTreeItem* nodePaletteItem = static_cast<GraphCanvas::NodePaletteTreeItem*>(sourceIndex.internalPointer());
+                    if (nodePaletteItem)
+                    {
+                        AZ::IO::Path gemPath = GetGemPath("ScriptCanvas.Editor");
+                        gemPath = gemPath / AZ::IO::Path("TranslationAssets");
+                        gemPath = gemPath / nodePaletteItem->GetTranslationDataPath();
+                        gemPath.ReplaceExtension(".names");
+
+                        AZ::IO::FileIOBase* fileIO = AZ::IO::FileIOBase::GetInstance();
+                        if (fileIO->Exists(gemPath.c_str()))
+                        {
+                            AzQtComponents::ShowFileOnDesktop(gemPath.c_str());
+                        }
+                    }
+                }
+            }
+        }
+
         void NodePaletteDockWidget::ConfigureHelper()
         {
             if (!m_cyclingHelper.IsConfigured() && !m_cyclingIdentifiers.empty())

Gems/ScriptCanvas/Code/Editor/View/Widgets/ScriptCanvasNodePaletteDockWidget.h

@@ -193,8 +193,6 @@ namespace ScriptCanvasEditor
             void OnSelectionChanged() override;
             ////
 
-            
-
         protected:
 
             GraphCanvas::GraphCanvasTreeItem* CreatePaletteRoot() const override;
@@ -209,6 +207,8 @@ namespace ScriptCanvasEditor
         private:
 
             void HandleTreeItemDoubleClicked(GraphCanvas::GraphCanvasTreeItem* treeItem);
+            void OpenTranslationData();
+            void GenerateTranslation();
 
             void ConfigureHelper();
             void ParseCycleTargets(GraphCanvas::GraphCanvasTreeItem* treeItem);
@@ -225,6 +225,10 @@ namespace ScriptCanvasEditor
             QAction* m_previousCycleAction;
 
             bool     m_ignoreSelectionChanged;
+
+            QMenu* m_contextMenu;
+            QAction* m_openTranslationData;
+            QAction* m_generateTranslation;
         };
     }    
 }

Gems/ScriptCanvas/Code/Editor/View/Widgets/VariablePanel/VariableDockWidget.cpp

@@ -52,6 +52,7 @@
 #include <ScriptCanvas/Data/DataRegistry.h>
 #include <ScriptCanvas/GraphCanvas/NodeDescriptorBus.h>
 #include <ScriptCanvas/Asset/RuntimeAsset.h>
+#include "GraphCanvas/Components/Slots/Data/DataSlotBus.h"
 
 namespace ScriptCanvasEditor
 {
@@ -886,6 +887,7 @@ namespace ScriptCanvasEditor
 
                     ScriptCanvas::NodeRequestBus::EventResult(removedReferences, memberPair.m_scriptCanvasId, &ScriptCanvas::NodeRequests::RemoveVariableReferences, variableIds);
 
+
                     // If we didn't remove the references. Just delete the node.
                     if (!removedReferences)
                     {

Gems/ScriptCanvas/Code/Editor/View/Windows/EBusHandlerActionMenu.cpp

@@ -113,16 +113,14 @@ namespace ScriptCanvasEditor
             actionItem.m_name = QString(eventConfigurations[i].m_eventName.c_str());
             actionItem.m_eventId = eventConfigurations[i].m_eventId;
 
-            AZStd::string translatedName = TranslationHelper::GetKeyTranslation(TranslationContextGroup::EbusHandler, m_busName, eventConfigurations[i].m_eventName, TranslationItemType::Node, TranslationKeyId::Name);
+            GraphCanvas::TranslationKey key;
+            key << "EBusHandler" << m_busName.c_str() << "methods" << eventConfigurations[i].m_eventName << "details";
 
-            if (translatedName.empty())
-            {
-                actionItem.m_displayName = actionItem.m_name;
-            }
-            else
-            {
-                actionItem.m_displayName = QString(translatedName.c_str());
-            }
+            GraphCanvas::TranslationRequests::Details details;
+            details.m_name = actionItem.m_name.toUtf8().data();
+            GraphCanvas::TranslationRequestBus::BroadcastResult(details, &GraphCanvas::TranslationRequests::GetDetails, key, details);
+
+            actionItem.m_displayName = QString(details.m_name.c_str());
             
             actionItem.m_index = i;