Fix for events that should have been consumed by manipulators (#3108)

* fix for events that should have been consumed by manipulators making their way to the main viewport handler

Signed-off-by: hultonha <hultonha@amazon.co.uk>

* add missing include for SANDBOX_API macro

Signed-off-by: hultonha <hultonha@amazon.co.uk>

* add dependency on Qt::Test for AzToolsFrameworkTestCommon

Signed-off-by: hultonha <hultonha@amazon.co.uk>

* fix order of buttons passed to QMouseEvent

Signed-off-by: hultonha <hultonha@amazon.co.uk>

* potential fix for vtable error on linux

Signed-off-by: hultonha <hultonha@amazon.co.uk>

* potential fix for vtable error on linux again

Signed-off-by: hultonha <hultonha@amazon.co.uk>

Code/Editor/CMakeLists.txt

@@ -238,9 +238,13 @@ if(PAL_TRAIT_BUILD_TESTS_SUPPORTED)
                 3rdParty::Qt::Core
                 3rdParty::Qt::Gui
                 3rdParty::Qt::Widgets
+                3rdParty::Qt::Test
                 Legacy::CryCommon
                 AZ::AzToolsFramework
+                AZ::AzToolsFramework.Tests
+                AZ::AzToolsFrameworkTestCommon
                 Legacy::EditorLib
+                Gem::AtomToolsFramework.Static
         RUNTIME_DEPENDENCIES
             Gem::LmbrCentral
     )

Code/Editor/Lib/Tests/test_ViewportManipulatorController.cpp

@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#include <AzFramework/Viewport/CameraInput.h>
+#include <AzFramework/Viewport/ViewportControllerList.h>
+#include <AzToolsFramework/Input/QtEventToAzInputManager.h>
+#include <AzToolsFramework/UnitTest/AzToolsFrameworkTestHelpers.h>
+#include <AzToolsFramework/ViewportSelection/EditorInteractionSystemViewportSelectionRequestBus.h>
+#include <Editor/ViewportManipulatorController.h>
+
+namespace UnitTest
+{
+    using AzToolsFramework::ViewportInteraction::MouseInteractionEvent;
+
+    class EditorInteractionViewportSelectionFake : public AzToolsFramework::EditorInteractionSystemViewportSelectionRequestBus::Handler
+    {
+    public:
+        void Connect();
+        void Disconnect();
+
+        // EditorInteractionSystemViewportSelectionRequestBus overrides ...
+        void SetHandler(const AzToolsFramework::ViewportSelectionRequestsBuilderFn& interactionRequestsBuilder);
+        void SetDefaultHandler();
+        bool InternalHandleMouseViewportInteraction(const MouseInteractionEvent& mouseInteraction);
+        bool InternalHandleMouseManipulatorInteraction(const MouseInteractionEvent& mouseInteraction);
+
+        AZStd::function<bool(const MouseInteractionEvent& mouseInteraction)> m_internalHandleMouseViewportInteraction;
+        AZStd::function<bool(const MouseInteractionEvent& mouseInteraction)> m_internalHandleMouseManipulatorInteraction;
+    };
+
+    void EditorInteractionViewportSelectionFake::Connect()
+    {
+        AzToolsFramework::EditorInteractionSystemViewportSelectionRequestBus::Handler::BusConnect(AzToolsFramework::GetEntityContextId());
+    }
+
+    void EditorInteractionViewportSelectionFake::Disconnect()
+    {
+        AzToolsFramework::EditorInteractionSystemViewportSelectionRequestBus::Handler::BusDisconnect();
+    }
+
+    void EditorInteractionViewportSelectionFake::SetHandler(
+        [[maybe_unused]] const AzToolsFramework::ViewportSelectionRequestsBuilderFn& interactionRequestsBuilder)
+    {
+        // noop
+    }
+
+    void EditorInteractionViewportSelectionFake::SetDefaultHandler()
+    {
+        // noop
+    }
+
+    bool EditorInteractionViewportSelectionFake::InternalHandleMouseViewportInteraction(const MouseInteractionEvent& mouseInteraction)
+    {
+        if (m_internalHandleMouseViewportInteraction)
+        {
+            return m_internalHandleMouseViewportInteraction(mouseInteraction);
+        }
+
+        return false;
+    }
+
+    bool EditorInteractionViewportSelectionFake::InternalHandleMouseManipulatorInteraction(const MouseInteractionEvent& mouseInteraction)
+    {
+        if (m_internalHandleMouseManipulatorInteraction)
+        {
+            return m_internalHandleMouseManipulatorInteraction(mouseInteraction);
+        }
+
+        return false;
+    }
+
+    class ViewportManipulatorControllerFixture : public AllocatorsTestFixture
+    {
+    public:
+        static const AzFramework::ViewportId TestViewportId = AzFramework::ViewportId(0);
+
+        void SetUp() override
+        {
+            AllocatorsTestFixture::SetUp();
+
+            m_rootWidget = AZStd::make_unique<QWidget>();
+            m_rootWidget->setFixedSize(QSize(100, 100));
+
+            m_controllerList = AZStd::make_shared<AzFramework::ViewportControllerList>();
+            m_controllerList->RegisterViewportContext(TestViewportId);
+
+            m_inputChannelMapper = AZStd::make_unique<AzToolsFramework::QtEventToAzInputMapper>(m_rootWidget.get(), TestViewportId);
+        }
+
+        void TearDown()
+        {
+            m_inputChannelMapper.reset();
+
+            m_controllerList->UnregisterViewportContext(TestViewportId);
+            m_controllerList.reset();
+            m_rootWidget.reset();
+
+            AllocatorsTestFixture::TearDown();
+        }
+
+        AZStd::unique_ptr<QWidget> m_rootWidget;
+        AzFramework::ViewportControllerListPtr m_controllerList;
+        AZStd::unique_ptr<AzToolsFramework::QtEventToAzInputMapper> m_inputChannelMapper;
+    };
+
+    TEST_F(ViewportManipulatorControllerFixture, An_event_is_not_propagated_to_the_viewport_when_a_manipulator_handles_it_first)
+    {
+        // forward input events to our controller list
+        QObject::connect(
+            m_inputChannelMapper.get(), &AzToolsFramework::QtEventToAzInputMapper::InputChannelUpdated, m_rootWidget.get(),
+            [this](const AzFramework::InputChannel* inputChannel, [[maybe_unused]] QEvent* event)
+            {
+                m_controllerList->HandleInputChannelEvent(
+                    AzFramework::ViewportControllerInputEvent{ TestViewportId, nullptr, *inputChannel });
+            });
+
+        EditorInteractionViewportSelectionFake editorInteractionViewportFake;
+        editorInteractionViewportFake.m_internalHandleMouseManipulatorInteraction = [](const MouseInteractionEvent&)
+        {
+            // report the event was handled (manipulator was interacted with)
+            return true;
+        };
+
+        bool viewportInteractionCalled = false;
+        editorInteractionViewportFake.m_internalHandleMouseViewportInteraction = [&viewportInteractionCalled](const MouseInteractionEvent&)
+        {
+            // we should not call this as the manipulator will have consumed this event
+            viewportInteractionCalled = true;
+            return true;
+        };
+
+        editorInteractionViewportFake.Connect();
+
+        m_controllerList->Add(AZStd::make_shared<SandboxEditor::ViewportManipulatorController>());
+
+        // simulate a press and move
+        MousePressAndMove(m_rootWidget.get(), QPoint(10, 10), QPoint(10, 10), Qt::MouseButton::LeftButton);
+        MouseMove(m_rootWidget.get(), QPoint(20, 20), QPoint(10, 10), Qt::MouseButton::LeftButton);
+        MouseMove(m_rootWidget.get(), QPoint(30, 30), QPoint(0, 0), Qt::MouseButton::LeftButton);
+        QTest::mouseRelease(m_rootWidget.get(), Qt::MouseButton::LeftButton, Qt::KeyboardModifier::NoModifier, QPoint(30, 30));
+
+        // ensure the viewport did not receive the event when it was intercepted first by the manipulator
+        EXPECT_FALSE(viewportInteractionCalled);
+
+        editorInteractionViewportFake.Disconnect();
+    }
+} // namespace UnitTest

Code/Editor/ViewportManipulatorController.cpp

@@ -28,6 +28,8 @@ namespace SandboxEditor
     {
     }
 
+    ViewportManipulatorControllerInstance::~ViewportManipulatorControllerInstance() = default;
+
     AzToolsFramework::ViewportInteraction::MouseButton ViewportManipulatorControllerInstance::GetMouseButton(
         const AzFramework::InputChannel& inputChannel)
     {
@@ -103,14 +105,21 @@ namespace SandboxEditor
             // Cache the ray trace results when doing manipulator interaction checks, no need to recalculate after
             if (event.m_priority == ManipulatorPriority)
             {
-                AzFramework::ScreenPoint screenPosition = AzFramework::ScreenPoint(0, 0);
-                ViewportMouseCursorRequestBus::EventResult(
-                    screenPosition, GetViewportId(), &ViewportMouseCursorRequestBus::Events::ViewportCursorScreenPosition);
+                const auto* position = event.m_inputChannel.GetCustomData<AzFramework::InputChannel::PositionData2D>();
+                AZ_Assert(position, "Expected PositionData2D but found nullptr");
 
-                m_mouseInteraction.m_mousePick.m_screenCoordinates = screenPosition;
+                AzFramework::WindowSize windowSize;
+                AzFramework::WindowRequestBus::EventResult(
+                    windowSize, event.m_windowHandle, &AzFramework::WindowRequestBus::Events::GetClientAreaSize);
+
+                auto screenPoint = AzFramework::ScreenPoint(
+                    position->m_normalizedPosition.GetX() * windowSize.m_width,
+                    position->m_normalizedPosition.GetY() * windowSize.m_height);
+
+                m_mouseInteraction.m_mousePick.m_screenCoordinates = screenPoint;
                 AZStd::optional<ProjectedViewportRay> ray;
                 ViewportInteractionRequestBus::EventResult(
-                    ray, GetViewportId(), &ViewportInteractionRequestBus::Events::ViewportScreenToWorldRay, screenPosition);
+                    ray, GetViewportId(), &ViewportInteractionRequestBus::Events::ViewportScreenToWorldRay, screenPoint);
 
                 if (ray.has_value())
                 {
@@ -118,6 +127,7 @@ namespace SandboxEditor
                     m_mouseInteraction.m_mousePick.m_rayDirection = ray.value().direction;
                 }
             }
+
             eventType = MouseEvent::Move;
         }
         else if (auto mouseButton = GetMouseButton(event.m_inputChannel); mouseButton != MouseButton::None)
@@ -217,8 +227,7 @@ namespace SandboxEditor
                 interactionHandled, AzToolsFramework::GetEntityContextId(), targetInteractionEvent, mouseInteractionEvent);
         }
 
-        // Only filter button/key press events, not release events
-        return interactionHandled && event.m_inputChannel.IsActive();
+        return interactionHandled;
     }
 
     void ViewportManipulatorControllerInstance::ResetInputChannels()

Code/Editor/ViewportManipulatorController.h

@@ -8,25 +8,29 @@
 
 #pragma once
 
-#include <AzFramework/Viewport/ViewportId.h>
-#include <AzFramework/Viewport/MultiViewportController.h>
 #include <AzFramework/Input/Events/InputChannelEventListener.h>
+#include <AzFramework/Viewport/MultiViewportController.h>
+#include <AzFramework/Viewport/ViewportId.h>
 #include <AzToolsFramework/Viewport/ViewportTypes.h>
 
+#include <SandboxAPI.h>
+
 namespace SandboxEditor
 {
     class ViewportManipulatorControllerInstance;
-    using ViewportManipulatorController = AzFramework::MultiViewportController<ViewportManipulatorControllerInstance, AzFramework::ViewportControllerPriority::DispatchToAllPriorities>;
+    using ViewportManipulatorController = AzFramework::
+        MultiViewportController<ViewportManipulatorControllerInstance, AzFramework::ViewportControllerPriority::DispatchToAllPriorities>;
 
     class ViewportManipulatorControllerInstance final
         : public AzFramework::MultiViewportControllerInstanceInterface<ViewportManipulatorController>
     {
     public:
-        explicit ViewportManipulatorControllerInstance(AzFramework::ViewportId viewport, ViewportManipulatorController* controller);
+        SANDBOX_API ViewportManipulatorControllerInstance(AzFramework::ViewportId viewport, ViewportManipulatorController* controller);
+        SANDBOX_API ~ViewportManipulatorControllerInstance();
 
-        bool HandleInputChannelEvent(const AzFramework::ViewportControllerInputEvent& event) override;
-        void ResetInputChannels() override;
-        void UpdateViewport(const AzFramework::ViewportControllerUpdateEvent& event) override;
+        SANDBOX_API bool HandleInputChannelEvent(const AzFramework::ViewportControllerInputEvent& event) override;
+        SANDBOX_API void ResetInputChannels() override;
+        SANDBOX_API void UpdateViewport(const AzFramework::ViewportControllerUpdateEvent& event) override;
 
     private:
         bool IsDoubleClick(AzToolsFramework::ViewportInteraction::MouseButton) const;
@@ -39,4 +43,4 @@ namespace SandboxEditor
         AZStd::unordered_map<AzToolsFramework::ViewportInteraction::MouseButton, AZ::ScriptTimePoint> m_pendingDoubleClicks;
         AZ::ScriptTimePoint m_curTime;
     };
-} //namespace SandboxEditor
+} // namespace SandboxEditor

Code/Editor/editor_lib_test_files.cmake

@@ -20,6 +20,7 @@ set(FILES
     Lib/Tests/test_ViewPanePythonBindings.cpp
     Lib/Tests/test_ViewportTitleDlgPythonBindings.cpp
     Lib/Tests/test_DisplaySettingsPythonBindings.cpp
+    Lib/Tests/test_ViewportManipulatorController.cpp
     DisplaySettingsPythonFuncs.cpp
     DisplaySettingsPythonFuncs.h
 )

Code/Framework/AzToolsFramework/AzToolsFramework/Input/QtEventToAzInputManager.cpp

@@ -162,7 +162,6 @@ namespace AzToolsFramework
         : QObject(sourceWidget)
         , m_sourceWidget(sourceWidget)
         , m_keyboardModifiers(AZStd::make_shared<AzFramework::ModifierKeyStates>())
-        , m_cursorPosition(AZStd::make_shared<AzFramework::InputChannel::PositionData2D>())
     {
         InitializeKeyMappings();
         InitializeMouseButtonMappings();
@@ -230,24 +229,17 @@ namespace AzToolsFramework
             return false;
         }
 
-        // Because there's no "end" to mouse movement and wheel events, we reset mouse movement channels that have been opened
-        // during the next processed non-mouse event.
-        if (m_mouseChannelsNeedUpdate && event->type() != QEvent::Type::MouseMove && event->type() != QEvent::Type::Wheel)
-        {
-            m_cursorPosition->m_normalizedPositionDelta = AZ::Vector2::CreateZero();
-            ProcessPendingMouseEvents();
-            m_mouseChannelsNeedUpdate = false;
-        }
+        const auto eventType = event->type();
 
         // Only accept mouse & key release events that originate from an object that is not our target widget,
         // as we don't want to erroneously intercept user input meant for another component.
-        if (object != m_sourceWidget && event->type() != QEvent::Type::KeyRelease && event->type() != QEvent::Type::MouseButtonRelease)
+        if (object != m_sourceWidget && eventType != QEvent::Type::KeyRelease && eventType != QEvent::Type::MouseButtonRelease)
         {
             return false;
         }
 
         // If our focus changes, go ahead and reset all input devices.
-        if (event->type() == QEvent::FocusIn || event->type() == QEvent::FocusOut)
+        if (eventType == QEvent::FocusIn || eventType == QEvent::FocusOut)
         {
             HandleFocusChange(event);
         }
@@ -255,27 +247,28 @@ namespace AzToolsFramework
         // ShortcutOverride is used in lieu of KeyPress for high priority input channels like Alt
         // that need to be accepted and stopped before they bubble up and cause unintended behavior.
         else if (
-            event->type() == QEvent::Type::KeyPress || event->type() == QEvent::Type::KeyRelease ||
-            event->type() == QEvent::Type::ShortcutOverride)
+            eventType == QEvent::Type::KeyPress || eventType == QEvent::Type::KeyRelease || eventType == QEvent::Type::ShortcutOverride)
         {
             QKeyEvent* keyEvent = static_cast<QKeyEvent*>(event);
             HandleKeyEvent(keyEvent);
         }
         // Map mouse events to input channels.
-        else if (event->type() == QEvent::Type::MouseButtonPress || event->type() == QEvent::Type::MouseButtonRelease || event->type() == QEvent::Type::MouseButtonDblClick)
+        else if (
+            eventType == QEvent::Type::MouseButtonPress || eventType == QEvent::Type::MouseButtonRelease ||
+            eventType == QEvent::Type::MouseButtonDblClick)
         {
             QMouseEvent* mouseEvent = static_cast<QMouseEvent*>(event);
             HandleMouseButtonEvent(mouseEvent);
         }
         // Map mouse movement to the movement input channels.
         // This includes SystemCursorPosition alongside Movement::X and Movement::Y.
-        else if (event->type() == QEvent::Type::MouseMove)
+        else if (eventType == QEvent::Type::MouseMove)
         {
             QMouseEvent* mouseEvent = static_cast<QMouseEvent*>(event);
             HandleMouseMoveEvent(mouseEvent);
         }
         // Map wheel events to the mouse Z movement channel.
-        else if (event->type() == QEvent::Type::Wheel)
+        else if (eventType == QEvent::Type::Wheel)
         {
             QWheelEvent* wheelEvent = static_cast<QWheelEvent*>(event);
             HandleWheelEvent(wheelEvent);
@@ -303,14 +296,16 @@ namespace AzToolsFramework
         auto mouseWheelChannel =
             GetInputChannel<AzFramework::InputChannelDeltaWithSharedPosition2D>(AzFramework::InputDeviceMouse::Movement::Z);
 
-        systemCursorChannel->ProcessRawInputEvent(m_cursorPosition->m_normalizedPositionDelta.GetLength());
+        systemCursorChannel->ProcessRawInputEvent(m_mouseDevice->m_cursorPositionData2D->m_normalizedPositionDelta.GetLength());
         // Generate movement events based on the pixel delta divided by the DPI scaling factor, to calculate a rough approximation
         // of cursor movement velocity.
         movementXChannel->ProcessRawInputEvent(
-            m_cursorPosition->m_normalizedPositionDelta.GetX() * aznumeric_cast<float>(m_sourceWidget->width()) / m_sourceWidget->devicePixelRatioF());
+            m_mouseDevice->m_cursorPositionData2D->m_normalizedPositionDelta.GetX() * aznumeric_cast<float>(m_sourceWidget->width()) /
+            m_sourceWidget->devicePixelRatioF());
         movementYChannel->ProcessRawInputEvent(
-            m_cursorPosition->m_normalizedPositionDelta.GetY() * aznumeric_cast<float>(m_sourceWidget->height()) / m_sourceWidget->devicePixelRatioF());
-        mouseWheelChannel->ProcessRawInputEvent(0.f);
+            m_mouseDevice->m_cursorPositionData2D->m_normalizedPositionDelta.GetY() * aznumeric_cast<float>(m_sourceWidget->height()) /
+            m_sourceWidget->devicePixelRatioF());
+        mouseWheelChannel->ProcessRawInputEvent(0.0f);
 
         NotifyUpdateChannelIfNotIdle(systemCursorChannel, nullptr);
         NotifyUpdateChannelIfNotIdle(movementXChannel, nullptr);
@@ -358,14 +353,13 @@ namespace AzToolsFramework
 
     void QtEventToAzInputMapper::HandleMouseMoveEvent(QMouseEvent* mouseEvent)
     {
-        AZ::Vector2 lastCursorPosition = m_cursorPosition->m_normalizedPosition;
+        AZ::Vector2 lastCursorPosition = m_mouseDevice->m_cursorPositionData2D->m_normalizedPosition;
 
         const QPoint mousePos = mouseEvent->pos();
         const AZ::Vector2 normalizedPosition = WidgetPositionToNormalizedPosition(mousePos);
-        m_cursorPosition->m_normalizedPositionDelta = normalizedPosition - m_cursorPosition->m_normalizedPosition;
-        m_cursorPosition->m_normalizedPosition = normalizedPosition;
+        m_mouseDevice->m_cursorPositionData2D->m_normalizedPositionDelta = normalizedPosition - m_mouseDevice->m_cursorPositionData2D->m_normalizedPosition;
+        m_mouseDevice->m_cursorPositionData2D->m_normalizedPosition = normalizedPosition;
         ProcessPendingMouseEvents();
-        m_mouseChannelsNeedUpdate = true;
 
         if (m_capturingCursor)
         {
@@ -376,7 +370,7 @@ namespace AzToolsFramework
             // Even though we just set the cursor position, there are edge cases such as remote desktop that will leave
             // the cursor position unchanged. For safety, we re-cache our last cursor position for delta generation.
             QPoint actualWidgetPosition = m_sourceWidget->mapFromGlobal(QCursor::pos());
-            m_cursorPosition->m_normalizedPosition = WidgetPositionToNormalizedPosition(actualWidgetPosition);
+            m_mouseDevice->m_cursorPositionData2D->m_normalizedPosition = WidgetPositionToNormalizedPosition(actualWidgetPosition);
         }
     }
 
@@ -427,21 +421,18 @@ namespace AzToolsFramework
         }
         cursorZChannel->ProcessRawInputEvent(aznumeric_cast<float>(wheelAngle));
         NotifyUpdateChannelIfNotIdle(cursorZChannel, wheelEvent);
-        m_mouseChannelsNeedUpdate = true;
     }
 
     void QtEventToAzInputMapper::HandleFocusChange(QEvent* event)
     {
         for (auto& channelData : m_channels)
         {
-            // If resetting the input device changed the channel state, submit it to the mapped channel list
-            // for processing.
+            // If resetting the input device changed the channel state, submit it to the mapped channel list for processing.
             if (channelData.second->IsActive())
             {
                 channelData.second->UpdateState(false);
                 NotifyUpdateChannelIfNotIdle(channelData.second, event);
             }
         }
-        m_mouseChannelsNeedUpdate = false;
     }
 } // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/Input/QtEventToAzInputManager.h

@@ -138,8 +138,6 @@ namespace AzToolsFramework
 
         // The current keyboard modifier state used by our synthetic key input channels.
         AZStd::shared_ptr<AzFramework::ModifierKeyStates> m_keyboardModifiers;
-        // The current normalized cursor position used by our synthetic system cursor event.
-        AZStd::shared_ptr<AzFramework::InputChannel::PositionData2D> m_cursorPosition;
         // A lookup table for Qt key -> AZ input channel.
         AZStd::unordered_map<Qt::Key, AzFramework::InputChannelId> m_keyMappings;
         // A lookup table for Qt mouse button -> AZ input channel.
@@ -152,8 +150,6 @@ namespace AzToolsFramework
         AZStd::unordered_map<AzFramework::InputChannelId, AzFramework::InputChannel*> m_channels;
         // The source widget to map events from, used to calculate the relative mouse position within the widget bounds.
         QWidget* m_sourceWidget;
-        // Flags when mouse movement channels have been opened and may need to be closed (as there are no movement ended events).
-        bool m_mouseChannelsNeedUpdate = false;
         // Flags whether or not Qt events should currently be processed.
         bool m_enabled = true;
         // Flags whether or not the cursor is being constrained to the source widget (for invisible mouse movement).

Code/Framework/AzToolsFramework/AzToolsFramework/UnitTest/AzToolsFrameworkTestHelpers.cpp

@@ -27,6 +27,35 @@ using namespace AzToolsFramework;
 
 namespace UnitTest
 {
+    void MousePressAndMove(
+        QWidget* widget, const QPoint& initialPositionWidget, const QPoint& mouseDelta, const Qt::MouseButton mouseButton)
+    {
+        QPoint position = widget->mapToGlobal(initialPositionWidget);
+        QTest::mousePress(widget, mouseButton, Qt::NoModifier, position);
+
+        MouseMove(widget, initialPositionWidget, mouseDelta, mouseButton);
+    }
+
+    // Note: There are a series of bugs in Qt that appear to be preventing mouseMove events
+    // firing when sent through the QTest framework. This is a work around for our version
+    // of Qt. In future this can hopefully be simplified. See ^1 for workaround.
+    // More info: Issues with mouse move in Qt
+    // - https://bugreports.qt.io/browse/QTBUG-5232
+    // - https://bugreports.qt.io/browse/QTBUG-69414
+    // - https://lists.qt-project.org/pipermail/development/2019-July/036873.html
+    void MouseMove(QWidget* widget, const QPoint& initialPositionWidget, const QPoint& mouseDelta, const Qt::MouseButton mouseButton)
+    {
+        QPoint nextPosition = widget->mapToGlobal(initialPositionWidget + mouseDelta);
+
+        // ^1 To ensure a mouse move event is fired we must call the test mouse move function
+        // and also send a mouse move event that matches. Each on their own do not appear to
+        // work - please see the links above for more context.
+        QTest::mouseMove(widget, nextPosition);
+        QMouseEvent mouseMoveEvent(
+            QEvent::MouseMove, QPointF(nextPosition), QPointF(nextPosition), Qt::NoButton, mouseButton, Qt::NoModifier);
+        QApplication::sendEvent(widget, &mouseMoveEvent);
+    }
+
     bool TestWidget::eventFilter(QObject* watched, QEvent* event)
     {
         AZ_UNUSED(watched);

Code/Framework/AzToolsFramework/AzToolsFramework/UnitTest/AzToolsFrameworkTestHelpers.h

@@ -59,6 +59,21 @@ namespace UnitTest
 {
     constexpr AZStd::string_view prefabSystemSetting = "/Amazon/Preferences/EnablePrefabSystem";
 
+    /// Performs a mouse press and move event on the provided widget.
+    /// @param widget The widget to perform the mouse press and move on.
+    /// @param initialPositionWidget The position of the mouse relative to the widget (will be remapped to a global position internally).
+    /// @param mouseDelta How far to move the mouse.
+    /// @param mouseButton The button to be used during the press and move.
+    void MousePressAndMove(
+        QWidget* widget, const QPoint& initialPositionWidget, const QPoint& mouseDelta, Qt::MouseButton mouseButton = Qt::LeftButton);
+
+    /// Performs a mouse move event on the provided widget.
+    /// @param widget The widget to perform the mouse move on.
+    /// @param initialPositionWidget The position of the mouse relative to the widget (will be remapped to a global position internally).
+    /// @param mouseDelta How far to move the mouse (note: mouseDelta may be zero and the mouse will only be moved to initialPosition).
+    /// @param mouseButton The button to be held during the move.
+    void MouseMove(QWidget* widget, const QPoint& initialPosition, const QPoint& mouseDelta, Qt::MouseButton mouseButton = Qt::NoButton);
+
     /// Test widget to store QActions generated by EditorTransformComponentSelection.
     class TestWidget : public QWidget
     {

Code/Framework/AzToolsFramework/AzToolsFramework/Viewport/ViewportMessages.h

@@ -313,7 +313,7 @@ namespace AzToolsFramework
     //! Utility function to return EntityContextId.
     inline AzFramework::EntityContextId GetEntityContextId()
     {
-        AzFramework::EntityContextId entityContextId;
+        auto entityContextId = AzFramework::EntityContextId::CreateNull();
         EditorEntityContextRequestBus::BroadcastResult(entityContextId, &EditorEntityContextRequests::GetEditorEntityContextId);
 
         return entityContextId;

Code/Framework/AzToolsFramework/CMakeLists.txt

@@ -60,6 +60,7 @@ if(PAL_TRAIT_BUILD_TESTS_SUPPORTED)
             PUBLIC
                 AZ::AzTestShared
             PRIVATE
+                3rdParty::Qt::Test
                 3rdParty::googletest::GMock
                 3rdParty::GoogleBenchmark
                 AZ::AzToolsFramework
@@ -76,8 +77,9 @@ if(PAL_TRAIT_BUILD_TESTS_SUPPORTED)
             PRIVATE
                 Tests
         BUILD_DEPENDENCIES
-            PRIVATE
+            PUBLIC
                 AZ::AzTestShared
+            PRIVATE
                 3rdParty::Qt::Test
                 AZ::AzFrameworkTestShared
                 AZ::AzToolsFramework

Code/Framework/AzToolsFramework/Tests/SpinBoxTests.cpp

@@ -107,31 +107,6 @@ namespace UnitTest
         EXPECT_THAT(m_doubleSpinBoxWithLineEdit, Ne(nullptr));
     }
 
-    // Note: There are a series of bugs in Qt that appear to be preventing mouseMove events
-    // firing when sent through the QTest framework. This is a work around for our version
-    // of Qt. In future this can hopefully be simplified. See ^1 for workaround.
-    // More info: Issues with mouse move in Qt
-    // - https://bugreports.qt.io/browse/QTBUG-5232
-    // - https://bugreports.qt.io/browse/QTBUG-69414
-    // - https://lists.qt-project.org/pipermail/development/2019-July/036873.html
-    void MousePressAndMove(
-        QWidget* widget, const QPoint& widgetScreenPosition, const QPoint& mouseDelta)
-    {
-        QPoint position = widget->mapToGlobal(widgetScreenPosition);
-        QPoint nextPosition = widget->mapToGlobal(widgetScreenPosition + mouseDelta);
-
-        QTest::mousePress(widget, Qt::LeftButton, Qt::NoModifier, position);
-
-        // ^1 To ensure a mouse move event is fired we must call the test mouse move function
-        // and also send a mouse move event that matches. Each on their own do not appear to
-        // work - please see the links above for more context.
-        QTest::mouseMove(widget, nextPosition);
-        QMouseEvent mouseMoveEvent(
-            QEvent::MouseMove, QPointF(nextPosition), QPointF(nextPosition),
-            Qt::NoButton, Qt::LeftButton, Qt::NoModifier);
-        QApplication::sendEvent(widget, &mouseMoveEvent);
-    }
-
     TEST_F(SpinBoxFixture, SpinBoxMousePressAndMoveRightScrollsValue)
     {
         m_doubleSpinBox->setValue(10.0);