Script Canvas node translation system and naming consistency

Signed-off-by: lsemp3d <58790905+lsemp3d@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

@@ -61,6 +61,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

@@ -1078,9 +1078,11 @@ namespace ScriptCanvasEditor
         return CanCreateConnectionBetween(scSourceEndpoint, scTargetEndpoint).IsSuccess();
     }
 
-    AZStd::string Graph::GetDataTypeString(const AZ::Uuid& typeId)
+    AZStd::string Graph::GetDataTypeString(const AZ::Uuid&)
     {
-        return TranslationHelper::GetSafeTypeName(ScriptCanvas::Data::FromAZType(typeId));
+        // This is used by the default tooltip setting in GraphCanvas, returning an empty string
+        // in order for tooltips to be fully controlled by ScriptCanvas
+        return {};
     }
 
     void Graph::OnRemoveUnusedNodes()
@@ -1932,7 +1934,7 @@ namespace ScriptCanvasEditor
             }
 
             OnSaveDataDirtied(graphCanvasNodeId);
-            Nodes::CopySlotTranslationKeyedNamesToDatums(graphCanvasNodeId);
+            Nodes::UpdateSlotDatumLabels(graphCanvasNodeId);
         }
 
         m_wrappedNodeGroupings.clear();
@@ -1950,7 +1952,7 @@ namespace ScriptCanvasEditor
 
         for (AZ::EntityId graphCanvasNodeId : graphCanvasNodeIds)
         {
-            Nodes::CopySlotTranslationKeyedNamesToDatums(graphCanvasNodeId);
+            Nodes::UpdateSlotDatumLabels(graphCanvasNodeId);
         }
 
         GraphCanvas::ViewId viewId;

Gems/ScriptCanvas/Code/Editor/GraphCanvas/Components/DynamicSlotComponent.cpp

@@ -11,6 +11,7 @@
 
 #include <GraphCanvas/Components/Nodes/NodeBus.h>
 
+#include <ScriptCanvas/Core/Slot.h>
 #include <ScriptCanvas/GraphCanvas/NodeDescriptorBus.h>
 
 #include <Editor/GraphCanvas/Components/DynamicSlotComponent.h>

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,64 @@ namespace ScriptCanvasEditor
 
                         if (scriptCanvasSlot && scriptCanvasSlot->IsVisible())
                         {
-                            AZ::EntityId slotId = Nodes::DisplayScriptCanvasSlot(GetEntityId(), (*scriptCanvasSlot));
+                            auto graphCanvasSlotId = Nodes::DisplayScriptCanvasSlot(GetEntityId(), (*scriptCanvasSlot), 0);
 
-                            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));
+                                int& index = (scriptCanvasSlot->IsData() && scriptCanvasSlot->IsOutput()) ? paramIndex : outputIndex;
 
-                                TranslationItemType itemType = TranslationHelper::GetItemType(scriptCanvasSlot->GetDescriptor());
+                                auto graphCanvasSlotId = Nodes::DisplayScriptCanvasSlot(GetEntityId(), (*scriptCanvasSlot), index);
 
-                                GraphCanvas::TranslationKeyedString slotNameKeyedString(scriptCanvasSlot->GetName());
-                                slotNameKeyedString.m_context = ebusContextName;
+                                GraphCanvas::TranslationRequests::Details details;
 
-                                GraphCanvas::TranslationKeyedString slotTooltipKeyedString(scriptCanvasSlot->GetToolTip());
-                                slotTooltipKeyedString.m_context = ebusContextName;
+                                if (scriptCanvasSlot->IsData())
+                                {
+                                    GraphCanvas::TranslationKey key;
+                                    key = "EBusHandler";
+                                    key << eventHandler->GetEBusName() << "methods" << m_eventName << "params" << index << "details";
 
-                                slotNameKeyedString.SetFallback(scriptCanvasSlot->GetName());
-                                slotTooltipKeyedString.SetFallback(scriptCanvasSlot->GetToolTip());
+                                    details.m_name = scriptCanvasSlot->GetName();
+
+                                    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 +255,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), 0);
                             }
                         }
                         
@@ -345,9 +344,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,50 +177,27 @@ 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), 0);
                     }
 
+                    int paramIndex = 0;
+                    int outputIndex = 0;
                     //
                     // 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);
 
+                        int& index = (scriptCanvasSlot->IsData() && scriptCanvasSlot->IsInput()) ? paramIndex : outputIndex;
+
                         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), index);
                         }
+
+                        ++index;
                     }
 
                     if (myEvent.m_resultSlotId.IsValid())
@@ -231,18 +206,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), 0);
                         }
                     }
 
@@ -367,9 +331,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,10 +104,11 @@ 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();
+        GraphCanvas::TranslationRequests::Details details;
+        GraphCanvas::TranslationRequestBus::BroadcastResult(details, &GraphCanvas::TranslationRequests::GetDetails, key, details);
 
         int paramIndex = 0;
         int outputIndex = 0;
@@ -112,27 +116,52 @@ namespace ScriptCanvasEditor::Nodes
         // Create the GraphCanvas slots
         for (const auto& slot : node->GetSlots())
         {
+            GraphCanvas::TranslationKey slotKey;
+            slotKey << "ScriptCanvas::Node" << azrtti_typeid(node).ToString<AZStd::string>() << "slots";
+
+            int& index = (slot.IsData() && slot.IsInput()) ? paramIndex : outputIndex;
+
             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, index);
+
+                GraphCanvas::SlotRequestBus::Event(graphCanvasSlotId, &GraphCanvas::SlotRequests::SetName, slotDetails.m_name);
+                GraphCanvas::SlotRequestBus::Event(graphCanvasSlotId, &GraphCanvas::SlotRequests::SetTooltip, slotDetails.m_tooltip);
             }
+
+            ++index;
         }
 
         const auto& visualExtensions = node->GetVisualExtensions();
@@ -142,25 +171,25 @@ 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::SetTitle, details.m_name);
+        GraphCanvas::NodeTitleRequestBus::Event(graphCanvasEntity->GetId(), &GraphCanvas::NodeTitleRequests::SetSubTitle, details.m_category);
 
-        GraphCanvas::NodeTitleRequestBus::Event(graphCanvasEntity->GetId(), &GraphCanvas::NodeTitleRequests::SetTranslationKeyedTitle, nodeKeyedString);
-        GraphCanvas::NodeTitleRequestBus::Event(graphCanvasEntity->GetId(), &GraphCanvas::NodeTitleRequests::SetTranslationKeyedSubTitle, subtitleKeyedString);
+        // Add to the tooltip the C++ class for reference
+        if (!details.m_tooltip.empty())
+        {
+            details.m_tooltip.append("\n");
+        }
+        details.m_tooltip.append(AZStd::string::format("[C++] %s", node->GetNodeTypeName().c_str()));
+
+        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 +222,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 +273,19 @@ namespace ScriptCanvasEditor::Nodes
         graphCanvasEntity->CreateComponent<SlotMappingComponent>(methodNode->GetEntityId());
         graphCanvasEntity->CreateComponent<SceneMemberMappingComponent>(methodNode->GetEntityId());
 
-        TranslationContextGroup contextGroup = TranslationContextGroup::Invalid;
-
+        bool isAccessor = false;
         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:
+            isAccessor = true;
+        case ScriptCanvas::MethodType::Member:
             graphCanvasEntity->CreateComponent<ClassMethodNodeDescriptorComponent>();
-            contextGroup = TranslationContextGroup::ClassMethod;
+            break;
             break;
         default:
             AZ_Error("ScriptCanvas", false, "Invalid method node type, node creation failed. This node needs to be deleted.");
@@ -292,19 +304,75 @@ 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 methodName = methodNode->GetName();
 
-        AZStd::string translationContext = TranslationHelper::GetContextName(contextGroup, className);
+        GraphCanvas::TranslationKey key;
 
-        GraphCanvas::TranslationKeyedString nodeKeyedString(methodName, translationContext);
-        nodeKeyedString.m_key = TranslationHelper::GetKey(contextGroup, className, methodName, TranslationItemType::Node, TranslationKeyId::Name);
+        if (isAccessor)
+        {
+            AZ::StringFunc::Replace(methodName, "::Getter", "");
+            AZ::StringFunc::Replace(methodName, "::Setter", "");
+        }
 
-        GraphCanvas::TranslationKeyedString classKeyedString(className, translationContext);
-        classKeyedString.m_key = TranslationHelper::GetClassKey(contextGroup, className, TranslationKeyId::Name);
+        GraphCanvas::TranslationRequests::Details details;
+        details.m_name = methodName;
 
-        GraphCanvas::TranslationKeyedString tooltipKeyedString(AZStd::string(), translationContext);
-        tooltipKeyedString.m_key = TranslationHelper::GetKey(contextGroup, className, methodName, TranslationItemType::Node, TranslationKeyId::Tooltip);
+        AZStd::string context;
+        if (methodNode->GetMethodType() == ScriptCanvas::MethodType::Free)
+        {
+            context = "Constant";
+        }
+        else
+        {
+            context = isEBusSender ? "EBusSender" : "BehaviorClass";
+        }
+        key << context << className;
+
+        GraphCanvas::TranslationRequestBus::BroadcastResult(details, &GraphCanvas::TranslationRequests::GetDetails, key + ".details", details);
+
+        // Set the class' name as the subtitle fallback
+        details.m_subtitle = details.m_name;
+
+        AZStd::string methodContext;
+        // Get the method's text data
+        GraphCanvas::TranslationRequests::Details methodDetails;
+        methodDetails.m_name = details.m_name; // fallback
+        key << "methods";
+        AZStd::string updatedMethodName = methodName;
+        if (isAccessor)
+        {
+            if (methodNode->GetMethodType() == ScriptCanvas::MethodType::Getter || methodNode->GetMethodType() == ScriptCanvas::MethodType::Free)
+            {
+                updatedMethodName = "Get";
+                methodContext = "Getter";
+            }
+            else
+            {
+                updatedMethodName = "Set";
+                methodContext = "Setter";
+            }
+            updatedMethodName.append(methodName);
+        }
+        key << methodContext << updatedMethodName;
+        GraphCanvas::TranslationRequestBus::BroadcastResult(methodDetails, &GraphCanvas::TranslationRequests::GetDetails, key + ".details", methodDetails);
+
+
+        if (methodDetails.m_subtitle.empty())
+        {
+            methodDetails.m_subtitle = details.m_category;
+        }
+
+        // Add to the tooltip the C++ class for reference
+        if (!methodDetails.m_tooltip.empty())
+        {
+            methodDetails.m_tooltip.append("\n");
+        }
+        methodDetails.m_tooltip.append(AZStd::string::format("[C++] %s", className.c_str()));
+
+        GraphCanvas::NodeTitleRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeTitleRequests::SetDetails, methodDetails.m_name, methodDetails.m_subtitle);
+        GraphCanvas::NodeRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeRequests::SetTooltip, methodDetails.m_tooltip);
 
         int paramIndex = 0;
         int outputIndex = 0;
@@ -312,48 +380,62 @@ namespace ScriptCanvasEditor::Nodes
         auto busId = methodNode->GetBusSlotId();
         for (const auto& slot : methodNode->GetSlots())
         {
+            GraphCanvas::TranslationKey slotKey = key;
+
+            int& index = (slot.IsData() && slot.IsInput()) ? paramIndex : outputIndex;
+
             if (slot.IsVisible())
             {
-                AZ::EntityId graphCanvasSlotId = DisplayScriptCanvasSlot(graphCanvasNodeId, slot);
+                AZ::EntityId graphCanvasSlotId = DisplayScriptCanvasSlot(graphCanvasNodeId, slot, index);
 
-                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 = (itemType == TranslationItemType::ParamDataSlot) ? paramIndex : outputIndex;
-
-                    slotNameKeyedString.m_key = TranslationHelper::GetKey(contextGroup, className, methodName, itemType, TranslationKeyId::Name, index);
-                    slotTooltipKeyedString.m_key = TranslationHelper::GetKey(contextGroup, className, methodName, itemType, TranslationKeyId::Tooltip, index);
-
-                    if ((itemType == TranslationItemType::ParamDataSlot) || (itemType == TranslationItemType::ReturnDataSlot))
+                    if (slot.IsData())
                     {
+                        key.clear();
+                        key << context << className << "methods" << updatedMethodName;
+                        if (slot.IsData() && slot.IsInput())
+                        {
+                            key << "params";
+                        }
+                        else
+                        {
+                            key << "results";
+                        }
+                        key << index;
+
+                        GraphCanvas::TranslationRequestBus::BroadcastResult(details, &GraphCanvas::TranslationRequests::GetDetails, key + ".details", details);
+                    }
+
+                    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);
             }
+
+            ++index;
         }
 
         // Set the name
         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
@@ -403,6 +485,9 @@ namespace ScriptCanvasEditor::Nodes
 
         AZStd::vector< ScriptCanvas::SlotId > scriptCanvasSlots = busNode->GetNonEventSlotIds();
 
+        int paramIndex = 0;
+        int outputIndex = 0;
+
         for (const auto& slotId : scriptCanvasSlots)
         {
             ScriptCanvas::Slot* slot = busNode->GetSlot(slotId);
@@ -416,28 +501,45 @@ namespace ScriptCanvasEditor::Nodes
 
             if (slot->IsVisible())
             {
+                int& index = (slot->IsData() && slot->IsInput()) ? paramIndex : outputIndex;
+
                 AZ::EntityId gcSlotId = DisplayScriptCanvasSlot(graphCanvasNodeId, (*slot), group);
 
                 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);
                 }
+
+                ++index;
             }
         }
 
-        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);
+
+        // Add to the tooltip the C++ class for reference
+        if (!details.m_tooltip.empty())
+        {
+            details.m_tooltip.append("\n");
+        }
+        details.m_tooltip.append(AZStd::string::format("[C++] %s", busName.c_str()));
+
+        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 +564,27 @@ 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);
+        // Add to the tooltip the C++ class for reference
+        if (!details.m_tooltip.empty())
+        {
+            details.m_tooltip.append("\n");
+        }
+        details.m_tooltip.append(AZStd::string::format("[C++] %s", busName.c_str()));
 
-        GraphCanvas::NodeTitleRequestBus::Event(graphCanvasNodeId, &GraphCanvas::NodeTitleRequests::SetTranslationKeyedTitle, nodeKeyedString);
+        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::SetPaletteOverride, "HandlerNodeTitlePalette");
 
         return graphCanvasNodeId;
@@ -505,83 +615,41 @@ namespace ScriptCanvasEditor::Nodes
             *graphCanvasUserData = azEventNode->GetEntityId();
         }
 
+        int paramIndex = 0;
+        int outputIndex = 0;
+
         for (const ScriptCanvas::Slot& slot: azEventNode->GetSlots())
         {
             GraphCanvas::SlotGroup group = GraphCanvas::SlotGroups::Invalid;
 
             if (slot.IsVisible())
             {
+                int& index = (slot.IsData() && slot.IsInput()) ? paramIndex : outputIndex;
+
                 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);;
+
+                ++index;
             }
         }
 
-        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");
@@ -635,6 +703,9 @@ namespace ScriptCanvasEditor::Nodes
 
         AZStd::vector< ScriptCanvas::SlotId > scriptCanvasSlots = busNode->GetNonEventSlotIds();
 
+        int paramIndex = 0;
+        int outputIndex = 0;
+
         for (const auto& slotId : scriptCanvasSlots)
         {
             ScriptCanvas::Slot* slot = busNode->GetSlot(slotId);
@@ -648,13 +719,20 @@ namespace ScriptCanvasEditor::Nodes
 
             if (slot->IsVisible())
             {
+                int& index = (slot->IsData() && slot->IsInput()) ? paramIndex : outputIndex;
+
                 AZ::EntityId gcSlotId = DisplayScriptCanvasSlot(graphCanvasNodeId, (*slot), group);
 
                 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);
                 }
+
+                ++index;
             }
         }
 
@@ -718,11 +796,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();
@@ -744,17 +818,24 @@ namespace ScriptCanvasEditor::Nodes
             return graphCanvasNodeId;
         }
 
+        int paramIndex = 0;
+        int outputIndex = 0;
+
         for (const auto& slot : senderNode->GetSlots())
         {
+            int& index = (slot.IsData() && slot.IsInput()) ? paramIndex : outputIndex;
+
             if (slot.IsVisible())
             {
-                AZ::EntityId graphCanvasSlotId = DisplayScriptCanvasSlot(graphCanvasNodeId, slot);
+                AZ::EntityId graphCanvasSlotId = DisplayScriptCanvasSlot(graphCanvasNodeId, slot, index);
 
                 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());
             }
+
+            ++index;
         }
 
         // Set the name
@@ -766,7 +847,7 @@ namespace ScriptCanvasEditor::Nodes
         return graphCanvasNodeId;
     }
 
-// Function Nodes
+    // Function Nodes
     AZ::EntityId DisplayFunctionNode(AZ::EntityId graphCanvasGraphId, const ScriptCanvas::Nodes::Core::FunctionCallNode* functionNode)
     {
         return DisplayFunctionNode(graphCanvasGraphId, const_cast<ScriptCanvas::Nodes::Core::FunctionCallNode*>(functionNode));
@@ -811,23 +892,42 @@ 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;
         }
 
+        int paramIndex = 0;
+        int outputIndex = 0;
+
         for (const auto& slot : functionNode->GetSlots())
         {
-            AZ::EntityId graphCanvasSlotId = DisplayScriptCanvasSlot(graphCanvasNodeId, slot);
+            int& index = (slot.IsData() && slot.IsInput()) ? paramIndex : outputIndex;
+
+            AZ::EntityId graphCanvasSlotId = DisplayScriptCanvasSlot(graphCanvasNodeId, slot, index);
 
             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());
+
+            ++index;
         }
 
         if (asset)
@@ -866,31 +966,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 +988,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 +1037,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 +1054,6 @@ namespace ScriptCanvasEditor::Nodes
             }
         }
 
-        nodeConfiguration.m_subtitleFallback = "";
-
         return DisplayGeneralScriptCanvasNode(graphCanvasGraphId, nodeling, nodeConfiguration);
     }
 
@@ -1008,19 +1067,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 +1086,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));
@@ -1158,7 +1190,7 @@ namespace ScriptCanvasEditor::Nodes
         return graphCanvasConnectionType;
     }
 
-    AZ::EntityId DisplayScriptCanvasSlot(AZ::EntityId graphCanvasNodeId, const ScriptCanvas::Slot& slot, GraphCanvas::SlotGroup slotGroup)
+    AZ::EntityId DisplayScriptCanvasSlot(AZ::EntityId graphCanvasNodeId, const ScriptCanvas::Slot& slot, int slotIndex, GraphCanvas::SlotGroup slotGroup)
     {
         if (!slot.IsVisible())
         {
@@ -1242,8 +1274,46 @@ 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());
+            slotKeyStr.append(AZStd::string::format("_%d", slotIndex));
+            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/NodeDisplayUtils.h

@@ -63,5 +63,5 @@ namespace ScriptCanvasEditor::Nodes
 
     // SlotGroup will control how elements are grouped.
     // Invalid will cause the slots to put themselves into whatever category they belong to by default.
-    AZ::EntityId DisplayScriptCanvasSlot(AZ::EntityId graphCanvasNodeId, const ScriptCanvas::Slot& slot, GraphCanvas::SlotGroup group = GraphCanvas::SlotGroups::Invalid);
+    AZ::EntityId DisplayScriptCanvasSlot(AZ::EntityId graphCanvasNodeId, const ScriptCanvas::Slot& slot, int slotIndex, GraphCanvas::SlotGroup group = GraphCanvas::SlotGroups::Invalid);
 }

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

@@ -12,22 +12,13 @@
 #include <GraphCanvas/Components/Slots/SlotBus.h>
 #include <GraphCanvas/Components/DynamicOrderingDynamicSlotComponent.h>
 
+#include <ScriptCanvas/Core/ModifiableDatumView.h>
 #include <ScriptCanvas/Core/NodeBus.h>
 
 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 +27,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 +42,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/Settings.cpp

@@ -395,6 +395,7 @@ namespace ScriptCanvasEditor
                     ->Field("ShowUpgradeDialog", &ScriptCanvasEditorSettings::m_showUpgradeDialog)
                     ->Field("ZoomSettings", &ScriptCanvasEditorSettings::m_zoomSettings)
                     ->Field("ExperimentalSettings", &ScriptCanvasEditorSettings::m_experimentalSettings)
+                    ->Field("SceneContextMenuNodePaletteWidth", &ScriptCanvasEditorSettings::m_sceneContextMenuNodePaletteWidth)
                     ;
 
                 AZ::EditContext* editContext = serialize->GetEditContext();
@@ -467,13 +468,13 @@ namespace ScriptCanvasEditor
                             ->Attribute(AZ::Edit::Attributes::Visibility, AZ_CRC("PropertyVisibility_ShowChildrenOnly", 0xef428f20))
                         ->DataElement(AZ::Edit::UIHandlers::Default, &ScriptCanvasEditorSettings::m_snapDistance, "Connection Snap Distance", "The distance from a slot under which connections will snap to it.")
                             ->Attribute(AZ::Edit::Attributes::Min, 10.0)
-                        ->DataElement(AZ::Edit::UIHandlers::Default, &ScriptCanvasEditorSettings::m_enableGroupDoubleClickCollapse, "Double Click to Collapse/Uncollapse Group", "Enables the user to decide whether you can double click on a group to collapse/uncollapse a group.")
+                        ->DataElement(AZ::Edit::UIHandlers::Default, &ScriptCanvasEditorSettings::m_enableGroupDoubleClickCollapse, "Double Click to Collapse/Expand Group", "Enables the user to decide whether you can double click on a group to collapse/expand a group.")
                         ->DataElement(AZ::Edit::UIHandlers::Default, &ScriptCanvasEditorSettings::m_allowBookmarkViewpointControl, "Bookmark Zooming", "Will cause the bookmarks to force the viewport into the state determined by the bookmark type\nBookmark Anchors - The viewport that exists when the bookmark is created.\nNode Groups - The area the Node Group covers")
                         ->DataElement(AZ::Edit::UIHandlers::Default, &ScriptCanvasEditorSettings::m_dragNodeCouplingConfig, "Node Coupling Configuration", "Controls for managing Node Coupling.\nNode Coupling is when you are dragging a node and leave it hovered over another Node, we will try to connect the sides you overlapped with each other.")
                         ->DataElement(AZ::Edit::UIHandlers::Default, &ScriptCanvasEditorSettings::m_dragNodeSplicingConfig, "Drag Node Splicing Configuration", "Controls for managing Node Splicing on a Drag.\nNode Splicing on a Drag will let you drag a node onto a connection, and splice that node onto the specified connection.")
                         ->DataElement(AZ::Edit::UIHandlers::Default, &ScriptCanvasEditorSettings::m_dropNodeSplicingConfig, "Drop Node Splicing Configuration", "Controls for managing Node Splicing on a Drag.\nNode Splicing on a drop will let you drop a node onto a connection from the Node Palette, and splice that node onto the specified connection.")
                         ->DataElement(AZ::Edit::UIHandlers::Default, &ScriptCanvasEditorSettings::m_autoSaveConfig, "AutoSave Configuration", "Controls for managing Auto Saving.\nAuto Saving will occur after the specified time of inactivity on a graph.")
-                        ->DataElement(AZ::Edit::UIHandlers::Default, &ScriptCanvasEditorSettings::m_shakeDespliceConfig, "Shake To Desplice", "Settings that controls various parameters of the Shake to Desplice feature")
+                        ->DataElement(AZ::Edit::UIHandlers::Default, &ScriptCanvasEditorSettings::m_shakeDespliceConfig, "Shake To De-splice", "Settings that controls various parameters of the Shake to De-splice feature")
                         ->DataElement(AZ::Edit::UIHandlers::Default, &ScriptCanvasEditorSettings::m_allowNodeNudging, "Allow Node Nudging", "Controls whether or not nodes will attempt to nudge each other out of the way under various interactions.")
                         ->DataElement(AZ::Edit::UIHandlers::Default, &ScriptCanvasEditorSettings::m_alignmentTimeMS, "Alignment Time", "Controls the amount of time nodes will take to slide into place when performing alignment commands")
                             ->Attribute(AZ::Edit::Attributes::Min, 0)
@@ -485,8 +486,10 @@ namespace ScriptCanvasEditor
                         ->DataElement(AZ::Edit::UIHandlers::Default, &ScriptCanvasEditorSettings::m_experimentalSettings, "Experimental Settings", "Settings that will control elements that are under development and may not work as expected")
                         ->DataElement(AZ::Edit::UIHandlers::Default, &ScriptCanvasEditorSettings::m_saveRawTranslationOuputToFile, "Save Translation File", "Save out the raw result of translation for debug purposes")
                             ->Attribute(AZ::Edit::Attributes::ChangeNotify, &SettingsCpp::UpdateProcessingSettings)
-                        ->DataElement(AZ::Edit::UIHandlers::Default, &ScriptCanvasEditorSettings::m_printAbstractCodeModel, "Print Abstract Modeld", "Print out the Abstract Code Model to the console at the end of parsing for debug purposes")
+                        ->DataElement(AZ::Edit::UIHandlers::Default, &ScriptCanvasEditorSettings::m_printAbstractCodeModel, "Print Abstract Model", "Print out the Abstract Code Model to the console at the end of parsing for debug purposes")
                             ->Attribute(AZ::Edit::Attributes::ChangeNotify, &SettingsCpp::UpdateProcessingSettings)
+                        ->DataElement(AZ::Edit::UIHandlers::Default, &ScriptCanvasEditorSettings::m_sceneContextMenuNodePaletteWidth, "Context Menu Width", "Allows you to configure the width of the context menu that opens on a Script Canvas graph")
+                            ->Attribute(AZ::Edit::Attributes::Min, 120)
                         ;
 
                     editContext->Class<ExperimentalSettings>("Experimental", "Settings for features under development that may not behave as expected yet.")

Gems/ScriptCanvas/Code/Editor/Settings.h

@@ -357,6 +357,8 @@ namespace ScriptCanvasEditor
             AZ::u32 m_alignmentTimeMS;
 
             StylingSettings m_stylingSettings;
+
+            AZ::u32 m_sceneContextMenuNodePaletteWidth = 300;
         };
     }
 }

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

@@ -8,507 +8,44 @@
 
 #pragma once
 
-#include <QCoreApplication>
+#include <Source/Translation/TranslationBus.h>
+#include <ScriptCanvas/Data/Data.h>
 
-#include <AzCore/Serialization/Json/StackedString.h>
-#include <AzCore/std/string/conversions.h>
-
-#include <ScriptCanvas/Core/Slot.h>
-#include <GraphCanvas/Types/TranslationTypes.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";
+    }
+}
 
 namespace ScriptCanvasEditor
 {
-    enum class TranslationContextGroup : AZ::u32
+    namespace TranslationHelper
     {
-        EbusSender,
-        EbusHandler,
-        ClassMethod,
-        GlobalMethod,
-        Invalid
-    };
-
-    enum class TranslationItemType : AZ::u32
-    {
-        Node,
-        Wrapper,
-        ExecutionInSlot,
-        ExecutionOutSlot,
-        ParamDataSlot,
-        ReturnDataSlot,
-        BusIdSlot,
-        Invalid
-    };
-
-    enum class TranslationKeyId : AZ::u32
-    {
-        Name,
-        Tooltip,
-        Category,
-        Invalid
-    };
-
-    namespace TranslationContextGroupParts
-    {
-        const char* const ebusSender  = "EBus";
-        const char* const ebusHandler = "Handler";
-        const char* const classMethod = "Method";
-        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
-    {
-    public:
-        static AZStd::string GetContextName(TranslationContextGroup group, AZStd::string_view keyBase)
-        {
-            if (group == TranslationContextGroup::Invalid || keyBase.empty())
-            {
-                // Missing information
-                return AZStd::string();
-            }
-
-            const char* groupPart;
-
-            switch (group)
-            {
-            case TranslationContextGroup::EbusSender:
-                groupPart = TranslationContextGroupParts::ebusSender;
-                break;
-            case TranslationContextGroup::EbusHandler:
-                groupPart = TranslationContextGroupParts::ebusHandler;
-                break;
-            case TranslationContextGroup::ClassMethod:
-                groupPart = TranslationContextGroupParts::classMethod;
-                break;
-            case TranslationContextGroup::GlobalMethod:
-                groupPart = TranslationContextGroupParts::globalMethod;
-                break;
-            default:
-                AZ_Warning("TranslationComponent", false, "Invalid translation group ID.");
-                groupPart = "";
-            }
-
-            AZStd::string fullKey = AZStd::string::format("%s: %.*s", groupPart,
-                aznumeric_cast<int>(keyBase.size()), keyBase.data());
-
-            return fullKey;
-        }
-        
-        // 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)
-        {
-            if (group == TranslationContextGroup::Invalid || keyBase.empty()
-                || type == TranslationItemType::Invalid || keyId == TranslationKeyId::Invalid)
-            {
-                // Missing information
-                return AZStd::string();
-            }
-
-            if (type != TranslationItemType::Wrapper && keyName.empty())
-            {
-                // Missing information
-                return AZStd::string();
-            }
-
-            AZStd::string fullKey;
-
-            const char* prefix = "";
-            if (group == TranslationContextGroup::EbusHandler)
-            {
-                prefix = TranslationKeyParts::handler;
-            }
-
-            const char* keyPart = GetKeyPart(keyId);
-
-            switch (type)
-            {
-            case TranslationItemType::Node:
-                fullKey = AZStd::string::format("%s%.*s_%.*s_%s",
-                    prefix,
-                    aznumeric_cast<int>(keyBase.size()),
-                    keyBase.data(),
-                    aznumeric_cast<int>(keyName.size()),
-                    keyName.data(),
-                    keyPart
-                );
-                break;
-            case TranslationItemType::Wrapper:
-                fullKey = GetClassKey(group, keyBase, keyId);
-                break;
-            case TranslationItemType::ExecutionInSlot:
-                fullKey = AZStd::string::format("%s%.*s_%.*s_%s_%s",
-                    prefix,
-                    aznumeric_cast<int>(keyBase.size()),
-                    keyBase.data(),
-                    aznumeric_cast<int>(keyName.size()),
-                    keyName.data(),
-                    TranslationKeyParts::in,
-                    keyPart
-                );
-                break;
-            case TranslationItemType::ExecutionOutSlot:
-                fullKey = AZStd::string::format("%s%.*s_%.*s_%s_%s",
-                    prefix,
-                    aznumeric_cast<int>(keyBase.size()),
-                    keyBase.data(),
-                    aznumeric_cast<int>(keyName.size()),
-                    keyName.data(),
-                    TranslationKeyParts::out,
-                    keyPart
-                );
-                break;
-            case TranslationItemType::ParamDataSlot:
-                fullKey = AZStd::string::format("%s%.*s_%.*s_%s%d_%s",
-                    prefix,
-                    aznumeric_cast<int>(keyBase.size()),
-                    keyBase.data(),
-                    aznumeric_cast<int>(keyName.size()),
-                    keyName.data(),
-                    TranslationKeyParts::param,
-                    paramIndex,
-                    keyPart
-                );
-                break;
-            case TranslationItemType::ReturnDataSlot:
-                fullKey = AZStd::string::format("%s%.*s_%.*s_%s%d_%s",
-                    prefix,
-                    aznumeric_cast<int>(keyBase.size()),
-                    keyBase.data(),
-                    aznumeric_cast<int>(keyName.size()),
-                    keyName.data(),
-                    TranslationKeyParts::output,
-                    paramIndex,
-                    keyPart
-                );
-                break;
-            case TranslationItemType::BusIdSlot:
-                fullKey = AZStd::string::format("%s%.*s_%.*s_%s_%s",
-                    prefix,
-                    aznumeric_cast<int>(keyBase.size()),
-                    keyBase.data(),
-                    aznumeric_cast<int>(keyName.size()),
-                    keyName.data(),
-                    TranslationKeyParts::busid,
-                    keyPart
-                );
-                break;
-            default:
-                AZ_Warning("ScriptCanvas TranslationHelper", false, "Invalid translation item type.");
-            }
-
-            AZStd::to_upper(fullKey.begin(), fullKey.end());
-
-            return fullKey;
-        }
-
-        static AZStd::string GetClassKey(TranslationContextGroup group, AZStd::string_view keyBase, TranslationKeyId keyId)
-        {
-            const char* prefix = "";
-            if (group == TranslationContextGroup::EbusHandler)
-            {
-                prefix = TranslationKeyParts::handler;
-            }
-
-            const char* keyPart = GetKeyPart(keyId);
-
-            AZStd::string fullKey = AZStd::string::format("%s%.*s_%s",
-                prefix,
-                aznumeric_cast<int>(keyBase.size()),
-                keyBase.data(),
-                keyPart
-            );
-
-            AZStd::to_upper(fullKey.begin(), fullKey.end());
-
-            return fullKey;
-        }
-
-        static AZStd::string GetGlobalMethodKey(AZStd::string_view keyName, TranslationItemType keyType,
-            TranslationKeyId keyId, int paramIndex = 0)
-        {
-            const char* keyPart = GetKeyPart(keyId);
-
-            AZStd::string fullKey;
-            switch (keyType)
-            {
-            case TranslationItemType::Node:
-                fullKey = AZStd::string::format("%.*s_%s",
-                    aznumeric_cast<int>(keyName.size()),
-                    keyName.data(),
-                    keyPart
-                );
-                break;
-            case TranslationItemType::ExecutionInSlot:
-                fullKey = AZStd::string::format("%.*s_%s_%s",
-                    aznumeric_cast<int>(keyName.size()),
-                    keyName.data(),
-                    TranslationKeyParts::in,
-                    keyPart
-                );
-                break;
-            case TranslationItemType::ExecutionOutSlot:
-                fullKey = AZStd::string::format("%.*s_%s_%s",
-                    aznumeric_cast<int>(keyName.size()),
-                    keyName.data(),
-                    TranslationKeyParts::out,
-                    keyPart
-                );
-                break;
-            case TranslationItemType::ParamDataSlot:
-                fullKey = AZStd::string::format("%.*s_%s%d_%s",
-                    aznumeric_cast<int>(keyName.size()),
-                    keyName.data(),
-                    TranslationKeyParts::param,
-                    paramIndex,
-                    keyPart
-                );
-                break;
-            case TranslationItemType::ReturnDataSlot:
-                fullKey = AZStd::string::format("%.*s_%s%d_%s",
-                    aznumeric_cast<int>(keyName.size()),
-                    keyName.data(),
-                    TranslationKeyParts::output,
-                    paramIndex,
-                    keyPart
-                );
-                break;
-            default:
-                AZ_Warning("ScriptCanvas TranslationHelper", false, "Invalid translation item type.");
-            }
-
-            AZStd::to_upper(fullKey.begin(), fullKey.end());
-
-            return fullKey;
-        }
-
-        static const char* GetKeyPart(TranslationKeyId keyId)
-        {
-            const char* keyPart = "";
-
-            switch (keyId)
-            {
-            case TranslationKeyId::Name:
-                keyPart = TranslationKeyParts::name;
-                break;
-            case TranslationKeyId::Tooltip:
-                keyPart = TranslationKeyParts::tooltip;
-                break;
-            case TranslationKeyId::Category:
-                keyPart = TranslationKeyParts::category;
-                break;
-
-
-            default:
-                AZ_Warning("ScriptCanvas TranslationHelper", false, "Invalid translation key ID.");
-            }
-
-            return keyPart;
-        }
-
-        static TranslationItemType GetItemType(ScriptCanvas::SlotDescriptor slotDescriptor)
-        {
-            if (slotDescriptor == ScriptCanvas::SlotDescriptors::ExecutionIn())
-            {
-                return TranslationItemType::ExecutionInSlot;
-            }
-            else if (slotDescriptor == ScriptCanvas::SlotDescriptors::ExecutionOut())
-            {
-                return TranslationItemType::ExecutionOutSlot;
-            }
-            else if (slotDescriptor == ScriptCanvas::SlotDescriptors::DataIn())
-            {
-                return TranslationItemType::ParamDataSlot;
-            }
-            else if (slotDescriptor == ScriptCanvas::SlotDescriptors::DataOut())
-            {
-                return TranslationItemType::ReturnDataSlot;
-            }
-
-            return TranslationItemType::Invalid;
-        }
-
-        static AZStd::string GetSafeTypeName(ScriptCanvas::Data::Type dataType)
+        inline AZStd::string GetSafeTypeName(ScriptCanvas::Data::Type dataType)
         {
             if (!dataType.IsValid())
             {
                 return "";
             }
 
-            return ScriptCanvas::Data::GetName(dataType);
+            AZStd::string azType = dataType.GetAZType().ToString<AZStd::string>();
+
+            GraphCanvas::TranslationKey key;
+            key << "BehaviorType" << azType << "details";
+
+            GraphCanvas::TranslationRequests::Details details;
+
+            details.m_name = ScriptCanvas::Data::GetName(dataType);
+
+            GraphCanvas::TranslationRequestBus::BroadcastResult(details, &GraphCanvas::TranslationRequests::GetDetails, key, details);
+
+            return details.m_name;
         }
-
-        static AZStd::string GetKeyTranslation(TranslationContextGroup group, AZStd::string_view keyBase, AZStd::string_view keyName, TranslationItemType type, TranslationKeyId keyId, int paramIndex = 0)
-        {
-            AZStd::string translationContext = TranslationHelper::GetContextName(group, keyBase);
-            AZStd::string translationKey = TranslationHelper::GetKey(group, keyBase, keyName, type, keyId, paramIndex);
-            AZStd::string translated = QCoreApplication::translate(translationContext.c_str(), translationKey.c_str()).toUtf8().data();
-
-            if (translated == translationKey)
-            {
-                return AZStd::string();
-            }
-
-            return translated;
-        }
-
-        static AZStd::string GetClassKeyTranslation(TranslationContextGroup group, AZStd::string_view keyBase, TranslationKeyId keyId)
-        {
-            AZStd::string translationContext = TranslationHelper::GetContextName(group, keyBase);
-            AZStd::string translationKey = TranslationHelper::GetClassKey(group, keyBase, keyId);
-            AZStd::string translated = QCoreApplication::translate(translationContext.c_str(), translationKey.c_str()).toUtf8().data();
-
-            if (translated == translationKey)
-            {
-                return AZStd::string();
-            }
-
-            return translated;
-        }
-
-        static AZStd::string GetGlobalMethodKeyTranslation(AZStd::string_view keyName,
-            TranslationItemType keyType, TranslationKeyId keyId, int paramIndex = 0)
-        {
-            AZStd::string translationKey = TranslationHelper::GetGlobalMethodKey(keyName, keyType, keyId, paramIndex);
-            AZStd::string translated = QCoreApplication::translate(TranslationContextGroupParts::globalMethod, translationKey.c_str()).toUtf8().data();
-
-            if (translated == translationKey)
-            {
-                return AZStd::string();
-            }
-
-            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)
-        {
-            AZ::StackedString path(AZ::StackedString::Format::JsonPointer);
-            path.Push(eventName);
-
-            return path;
-        }
-    };
+    }
 }
+

Gems/ScriptCanvas/Code/Editor/View/Widgets/DataTypePalette/DataTypePaletteModel.cpp

@@ -16,7 +16,6 @@
 #include <AzCore/Serialization/Utils.h>
 #include <AzCore/UserSettings/UserSettings.h>
 
-#include <GraphCanvas/Types/TranslationTypes.h>
 #include <GraphCanvas/Components/SceneBus.h>
 #include <GraphCanvas/Components/StyleBus.h>
 
@@ -244,7 +243,16 @@ namespace ScriptCanvasEditor
 
     AZStd::string DataTypePaletteModel::FindTypeNameForTypeId(const AZ::TypeId& typeId) const
     {
-        return TranslationHelper::GetSafeTypeName(ScriptCanvas::Data::FromAZType(typeId));
+        GraphCanvas::TranslationKey key;
+        key << "BehaviorType" << typeId.ToString<AZStd::string>() << "details";
+
+        GraphCanvas::TranslationRequests::Details details;
+
+        details.m_name = TranslationHelper::GetSafeTypeName(ScriptCanvas::Data::FromAZType(typeId));
+
+        GraphCanvas::TranslationRequestBus::BroadcastResult(details, &GraphCanvas::TranslationRequests::GetDetails, key, details);
+
+        return details.m_name;
     }
 
     void DataTypePaletteModel::TogglePendingPinChange(const AZ::Uuid& azVarType)

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,32 +82,26 @@ 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;
 
-        if (displayMethodName.empty())
-        {
-            SetName(m_methodName);
-        }
-        else
-        {
-            SetName(displayMethodName.c_str());
-        }
 
-        if (propertyStatus == ScriptCanvas::PropertyStatus::Getter)
+        AZStd::string updatedMethodName;
+        if (propertyStatus != ScriptCanvas::PropertyStatus::None)
         {
-            SetName(AZStd::string::format("Get %s", GetName().toUtf8().data()).data());
-        }
-        else if (propertyStatus == ScriptCanvas::PropertyStatus::Setter)
-        {
-            SetName(AZStd::string::format("Set %s", GetName().toUtf8().data()).data());
+            updatedMethodName = (propertyStatus == ScriptCanvas::PropertyStatus::Getter) ? "Get" : "Set";
         }
+        updatedMethodName.append(methodName);
 
-        AZStd::string displayEventTooltip = TranslationHelper::GetKeyTranslation(TranslationContextGroup::ClassMethod, m_className.toUtf8().data(), m_methodName.toUtf8().data(), TranslationItemType::Node, TranslationKeyId::Tooltip);
+        key << "BehaviorClass" << className << "methods" << updatedMethodName << "details";
 
-        if (!displayEventTooltip.empty())
-        {
-            SetToolTip(displayEventTooltip.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());
 
         SetTitlePalette("MethodNodeTitlePalette");
     }
@@ -166,13 +160,14 @@ namespace ScriptCanvasEditor
         : DraggableNodePaletteTreeItem(nodeModelInformation.m_methodName, ScriptCanvasEditor::AssetEditorId)
         , m_methodName{ nodeModelInformation.m_methodName }
     {
-        SetToolTip(QString::fromUtf8(nodeModelInformation.m_displayName.data(),
-            aznumeric_cast<int>(nodeModelInformation.m_displayName.size())));
-
         SetToolTip(QString::fromUtf8(nodeModelInformation.m_toolTip.data(),
             aznumeric_cast<int>(nodeModelInformation.m_toolTip.size())));
 
         SetTitlePalette("MethodNodeTitlePalette");
+        if (!nodeModelInformation.m_displayName.empty())
+        {
+            SetName(nodeModelInformation.m_displayName.c_str());
+        }
     }
 
     GraphCanvas::GraphCanvasMimeEvent* GlobalMethodEventPaletteTreeItem::CreateMimeEvent() const
@@ -186,6 +181,27 @@ namespace ScriptCanvasEditor
         return m_methodName;
     }
 
+    AZ::IO::Path GlobalMethodEventPaletteTreeItem::GetTranslationDataPath() const
+    {
+        AZStd::string propertyName = m_methodName;
+        AZ::StringFunc::Replace(propertyName, "::Getter", "");
+        AZ::StringFunc::Replace(propertyName, "::Setter", "");
+
+        AZStd::string filename = GraphCanvas::TranslationKey::Sanitize(propertyName);
+
+        return AZ::IO::Path("Properties") / filename;
+    }
+
+    void GlobalMethodEventPaletteTreeItem::GenerateTranslationData()
+    {
+        AZStd::string propertyName = m_methodName;
+        AZ::StringFunc::Replace(propertyName, "::Getter", "");
+        AZ::StringFunc::Replace(propertyName, "::Setter", "");
+
+        ScriptCanvasEditorTools::TranslationGeneration translation;
+        translation.TranslateBehaviorProperty(propertyName);
+    }
+
     //////////////////////////////
     // CreateCustomNodeMimeEvent
     //////////////////////////////
@@ -230,9 +246,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,26 @@ 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();
+            if (behaviorContext->m_classes.contains(className))
+            {
+                auto behaviorClass = behaviorContext->m_classes.find(className);
+
+                ScriptCanvasEditorTools::TranslationGeneration translation;
+                translation.TranslateBehaviorClass(behaviorClass->second);
+            }
+        }
+
     private:
         bool m_isOverload = false;
         QString m_className;
@@ -101,6 +124,10 @@ namespace ScriptCanvasEditor
 
         const AZStd::string& GetMethodName() const;
 
+        AZ::IO::Path GetTranslationDataPath() const override;
+        void GenerateTranslationData() override;
+
+
     private:
         AZStd::string m_methodName;
     };
@@ -137,15 +164,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,12 +607,13 @@ namespace
                         categoryPath = "Other/";
                     }
 
-                    if (translatedName != translationKey)
+                    if (!details.m_name.empty())
                     {
-                        categoryPath.append(translatedName.c_str());
+                        categoryPath.append(details.m_name.c_str());
                     }
-                    else
+                    else if (categoryPath.contains("Other"))
                     {
+                        // Use the BehaviorEBus name to categorize within the 'Other' category
                         categoryPath.append(behaviorEbus.m_name.c_str());
                     }
                 }
@@ -629,31 +629,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 +654,19 @@ 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
+            else if (categoryPath.contains("Other"))
             {
-                categoryPath.append(displayName.c_str());
+                // Use the behavior EBus name to categorize within the 'Other' category
+                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 +692,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 +751,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 +787,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);
     }
@@ -896,6 +894,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);
@@ -906,47 +906,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)
@@ -1004,11 +995,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);
@@ -1023,44 +1016,43 @@ 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())
+            GraphCanvas::TranslationKey key;
+
+            AZStd::string context;
+            AZStd::string updatedMethodName;
+            if (propertyStatus != ScriptCanvas::PropertyStatus::None)
             {
-                methodModelInformation->m_displayName = methodName;
+                updatedMethodName = (propertyStatus == ScriptCanvas::PropertyStatus::Getter) ? "Get" : "Set";
+                context = (propertyStatus == ScriptCanvas::PropertyStatus::Getter) ? "Getter" : "Setter";
             }
+            updatedMethodName += methodName;
+            key << "BehaviorClass" << context << methodClass << "methods" << updatedMethodName << "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() ? updatedMethodName : 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);
@@ -1069,40 +1061,39 @@ namespace ScriptCanvasEditor
         if (auto registerIter = m_registeredNodes.find(nodeIdentifier); registerIter == m_registeredNodes.end())
         {
             auto  methodModelInformation = AZStd::make_unique<GlobalMethodNodeModelInformation>();
-            methodModelInformation->m_methodName = behaviorMethod.m_name;
             methodModelInformation->m_nodeIdentifier = nodeIdentifier;
+            methodModelInformation->m_methodName = behaviorMethod.m_name;
 
             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);
+            AZStd::string name = behaviorProperty->m_name;
+            AZ::StringFunc::Replace(name, "::Getter", "");
+            AZ::StringFunc::Replace(name, "::Setter", "");
 
-            if (methodModelInformation->m_displayName.empty())
-            {
-                methodModelInformation->m_displayName = methodModelInformation->m_methodName;
-            }
+            GraphCanvas::TranslationKey key;
+            key << "Constant" << name << "details";
+
+            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);
@@ -1113,31 +1104,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());
         }
@@ -1145,6 +1122,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);
@@ -1162,18 +1141,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));
         }
@@ -1189,6 +1164,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);
@@ -1208,18 +1185,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));
         }
@@ -1227,6 +1200,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();
@@ -1237,7 +1212,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)
@@ -1445,6 +1420,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

@@ -26,12 +26,18 @@
 #include <AzCore/Serialization/SerializeContext.h>
 #include <AzCore/UserSettings/UserSettings.h>
 #include <AzCore/std/containers/map.h>
+
+#include <AzFramework/Gem/GemInfo.h>
 #include <AzFramework/StringFunc/StringFunc.h>
+
 #include <AzToolsFramework/API/EditorAssetSystemAPI.h>
 #include <AzToolsFramework/AssetBrowser/Entries/ProductAssetBrowserEntry.h>
 #include <AzToolsFramework/AssetBrowser/Entries/SourceAssetBrowserEntry.h>
 #include <AzToolsFramework/AssetEditor/AssetEditorUtils.h>
 #include <AzToolsFramework/ToolsComponents/EditorComponentBase.h>
+
+#include <AzQtComponents/Utilities/DesktopUtilities.h>
+
 #include <Editor/Assets/ScriptCanvasAssetHelpers.h>
 #include <Editor/Components/IconComponent.h>
 #include <Editor/GraphCanvas/GraphCanvasEditorNotificationBusId.h>
@@ -50,9 +56,11 @@
 #include <Editor/View/Widgets/NodePalette/VariableNodePaletteTreeItemTypes.h>
 #include <Editor/View/Widgets/ScriptCanvasNodePaletteDockWidget.h>
 #include <Editor/View/Widgets/ui_ScriptCanvasNodePaletteToolbar.h>
+
 #include <GraphCanvas/Widgets/NodePalette/NodePaletteTreeView.h>
 #include <GraphCanvas/Widgets/NodePalette/NodePaletteWidget.h>
 #include <GraphCanvas/Widgets/NodePalette/TreeItems/NodePaletteTreeItem.h>
+
 #include <ScriptCanvas/Asset/RuntimeAsset.h>
 #include <ScriptCanvas/Core/Attributes.h>
 #include <ScriptCanvas/Core/SubgraphInterfaceUtility.h>
@@ -99,7 +107,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))
@@ -638,7 +646,7 @@ namespace ScriptCanvasEditor
             m_mimeType = NodePaletteDockWidget::GetMimeType();
             m_isInContextMenu = isInContextMenu;
             m_allowArrowKeyNavigation = isInContextMenu;
-            m_saveIdentifier = m_isInContextMenu ? "ScriptCanvas" : "ScriptCnavas_ContextMenu";
+            m_saveIdentifier = m_isInContextMenu ? "ScriptCanvas" : "ScriptCanvas_ContextMenu";
 
             m_rootTreeItem = Widget::NodePaletteWidget::ExternalCreateNodePaletteRoot(nodePaletteModel, assetModel);
         }
@@ -660,6 +668,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 +690,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 +704,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 +714,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("Explore 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 +813,7 @@ namespace ScriptCanvasEditor
             {
                 m_nextCycleAction->setEnabled(true);
                 m_previousCycleAction->setEnabled(true);
+                m_openTranslationData->setEnabled(true);
             }
         }
 
@@ -793,6 +826,7 @@ namespace ScriptCanvasEditor
             {
                 m_nextCycleAction->setEnabled(false);
                 m_previousCycleAction->setEnabled(false);
+                m_openTranslationData->setEnabled(false);
             }
         }
 
@@ -816,6 +850,81 @@ 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();
+
+            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/UnitTestPanel/UnitTestTreeView.cpp

@@ -19,7 +19,6 @@
 
 #include <AzToolsFramework/ToolsComponents/EditorComponentBase.h>
 
-#include <GraphCanvas/Types/TranslationTypes.h>
 #include <GraphCanvas/Components/SceneBus.h>
 #include <GraphCanvas/Components/StyleBus.h>
 

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/Widgets/VariablePanel/VariablePaletteTableView.cpp

@@ -18,7 +18,6 @@
 
 #include <AzToolsFramework/ToolsComponents/EditorComponentBase.h>
 
-#include <GraphCanvas/Types/TranslationTypes.h>
 #include <GraphCanvas/Components/SceneBus.h>
 #include <GraphCanvas/Components/StyleBus.h>
 

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;
             

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

@@ -12,6 +12,8 @@
 #include <QMimeData>
 #include <QInputDialog>
 
+#include <AzCore/UserSettings/UserSettings.h>
+
 #include <AzToolsFramework/API/ToolsApplicationAPI.h>
 
 #include <Editor/Nodes/NodeUtils.h>
@@ -41,6 +43,8 @@
 #include <Editor/View/Widgets/NodePalette/VariableNodePaletteTreeItemTypes.h>
 
 #include "ScriptCanvasContextMenus.h"
+#include "Settings.h"
+
 #include <ScriptCanvas/Core/NodeBus.h>
 #include <ScriptCanvas/Core/Slot.h>
 #include <GraphCanvas/Editor/EditorTypes.h>
@@ -53,6 +57,7 @@
 #include <GraphCanvas/Components/Nodes/NodeTitleBus.h>
 #include <GraphCanvas/Components/NodeDescriptors/FunctionDefinitionNodeDescriptorComponent.h>
 
+
 namespace ScriptCanvasEditor
 {
     ////////////////////////////
@@ -805,6 +810,13 @@ namespace ScriptCanvasEditor
     SceneContextMenu::SceneContextMenu(const NodePaletteModel& paletteModel, AzToolsFramework::AssetBrowser::AssetBrowserFilterModel* assetModel)
         : GraphCanvas::SceneContextMenu(ScriptCanvasEditor::AssetEditorId)
     {
+
+        auto userSettings = AZ::UserSettings::CreateFind<EditorSettings::ScriptCanvasEditorSettings>(AZ_CRC("ScriptCanvasPreviewSettings", 0x1c5a2965), AZ::UserSettings::CT_LOCAL);
+        if (userSettings)
+        {
+            m_userNodePaletteWidth = userSettings->m_sceneContextMenuNodePaletteWidth;
+        }
+
         const bool inContextMenu = true;
         Widget::ScriptCanvasNodePaletteConfig paletteConfig(paletteModel, assetModel, inContextMenu);
         AddNodePaletteMenuAction(paletteConfig);