Rework window event handling to fix bullshit with focus events and mouse binding while in multiscreen fullscreen splitscreen screenscreen screenscreenscreen AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA (followup to d4cd433)

PLS DON'T SHIT SELF UNDER SOME DUMBASS EDGE CASE PLS AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

Author: MaximDude

Main.cpp

@@ -171,7 +171,7 @@ namespace RTE {
 						System::SetQuit(true);
 						return;
 					}
-					g_WindowMan.HandleWindowEvent(sdlEvent);
+					g_WindowMan.QueueWindowEvent(sdlEvent);
 					break;
 				case SDL_KEYUP:
 				case SDL_KEYDOWN:

Managers/WindowMan.cpp

@@ -15,13 +15,16 @@ namespace RTE {
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 	void WindowMan::Clear() {
+		m_EventQueue.clear();
+		m_FocusEventsDispatchedByMovingBetweenWindows = false;
+		m_FocusEventsDispatchedByDisplaySwitchIn = false;
+
 		m_PrimaryTexture.reset();
 		m_PrimaryRenderer.reset();
 		m_PrimaryWindow.reset();
 		ClearMultiDisplayData();
 
 		m_AnyWindowHasFocus = false;
-		m_FocusLostDueToMovingBetweenGameWindows = false;
 		m_ResolutionChanged = false;
 
 		m_NumDisplays = 0;
@@ -506,13 +509,16 @@ namespace RTE {
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-	void WindowMan::DisplaySwitchIn() const {
+	void WindowMan::DisplaySwitchIn(SDL_Window *windowThatShouldTakeInputFocus) const {
 		g_UInputMan.DisableMouseMoving(false);
 		if (!m_MultiDisplayWindows.empty()) {
-			SDL_RaiseWindow(m_PrimaryWindow.get());
-			for (const std::shared_ptr<SDL_Window> &window : m_MultiDisplayWindows) {
+			for (const auto &window : m_MultiDisplayWindows) {
 				SDL_RaiseWindow(window.get());
 			}
+			SDL_RaiseWindow(windowThatShouldTakeInputFocus);
+			SDL_SetWindowInputFocus(windowThatShouldTakeInputFocus);
+		} else {
+			SDL_RaiseWindow(m_PrimaryWindow.get());
 		}
 	}
 
@@ -524,35 +530,59 @@ namespace RTE {
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-	void WindowMan::HandleWindowEvent(const SDL_Event &windowEvent) {
-		switch (windowEvent.window.event) {
-			case SDL_WINDOWEVENT_FOCUS_GAINED:
-				if (!m_FocusLostDueToMovingBetweenGameWindows) {
-					DisplaySwitchIn();
-				}
-				m_AnyWindowHasFocus = true;
-				break;
-			case SDL_WINDOWEVENT_FOCUS_LOST:
-				m_AnyWindowHasFocus = false;
-				m_FocusLostDueToMovingBetweenGameWindows = FullyCoversAllDisplays();
-				DisplaySwitchOut();
-				break;
-			case SDL_WINDOWEVENT_ENTER:
-				if (m_AnyWindowHasFocus && FullyCoversAllDisplays()) {
-					SDL_RaiseWindow(SDL_GetWindowFromID(windowEvent.window.windowID));
-					SDL_SetWindowInputFocus(SDL_GetWindowFromID(windowEvent.window.windowID));
-					m_AnyWindowHasFocus = true;
-				}
-				break;
-			default:
-				break;
-		}
+	void WindowMan::QueueWindowEvent(const SDL_Event &windowEvent) {
+		m_EventQueue.emplace_back(windowEvent);
 	}
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 	void WindowMan::Update() {
-		m_FocusLostDueToMovingBetweenGameWindows = false;
+		// Some bullshit we have to deal with to correctly focus windows in multi-display fullscreen so mouse binding/unbinding works correctly. Not relevant for single window.
+		// This is SDL's fault for not having handling to raise a window so it's top-most without taking focus of it.
+		// Don't process any focus events this update if either of these has been set in the previous one.
+		// Having two flags is a bit redundant but better be safe than recursively raising windows and taking focus and pretty much locking up your whole shit so the only thing you can do about it is sign out to terminate this.
+		// Clearing the queue here is just us not handling the events on our end. Whatever they are and do and wherever they propagate to is handled by SDL_PollEvent earlier.
+		if (m_FocusEventsDispatchedByDisplaySwitchIn || m_FocusEventsDispatchedByMovingBetweenWindows) {
+			m_EventQueue.clear();
+
+			m_FocusEventsDispatchedByDisplaySwitchIn = false;
+			m_FocusEventsDispatchedByMovingBetweenWindows = false;
+			return;
+		}
+
+		SDL_Event windowEvent;
+		for (std::vector<SDL_Event>::const_iterator eventIterator = m_EventQueue.begin(); eventIterator != m_EventQueue.end(); eventIterator++) {
+			windowEvent = *eventIterator;
+			int windowID = windowEvent.window.windowID;
+
+			switch (windowEvent.window.event) {
+				case SDL_WINDOWEVENT_ENTER:
+					if (SDL_GetWindowID(SDL_GetMouseFocus()) > 0 && m_AnyWindowHasFocus && FullyCoversAllDisplays()) {
+						for (const auto &window : m_MultiDisplayWindows) {
+							SDL_RaiseWindow(window.get());
+						}
+						SDL_RaiseWindow(SDL_GetWindowFromID(windowID));
+						SDL_SetWindowInputFocus(SDL_GetWindowFromID(windowID));
+						m_AnyWindowHasFocus = true;
+						m_FocusEventsDispatchedByMovingBetweenWindows = true;
+					}
+					break;
+				case SDL_WINDOWEVENT_FOCUS_GAINED:
+					DisplaySwitchIn(SDL_GetWindowFromID(windowID));
+					m_AnyWindowHasFocus = true;
+					m_FocusEventsDispatchedByDisplaySwitchIn = true;
+					break;
+				case SDL_WINDOWEVENT_FOCUS_LOST:
+					DisplaySwitchOut();
+					m_AnyWindowHasFocus = false;
+					m_FocusEventsDispatchedByDisplaySwitchIn = false;
+					m_FocusEventsDispatchedByMovingBetweenWindows = false;
+					break;
+				default:
+					break;
+			}
+		}
+		m_EventQueue.clear();
 	}
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Managers/WindowMan.h

@@ -193,10 +193,10 @@ namespace RTE {
 
 #pragma region Concrete Methods
 		/// <summary>
-		/// Handles window events coming from the SDL event queue.
+		/// Adds an SDL_Event to the Event queue for processing on Update.
 		/// </summary>
-		/// <param name="windowEvent">The SDL event to handle.</param>
-		void HandleWindowEvent(const SDL_Event &windowEvent);
+		/// <param name="windowEvent">The SDL window event to queue.</param>
+		void QueueWindowEvent(const SDL_Event &windowEvent);
 
 		/// <summary>
 		/// Updates the state of this WindowMan.
@@ -216,6 +216,11 @@ namespace RTE {
 
 	private:
 
+		std::vector<SDL_Event> m_EventQueue; //!< List of incoming window events.
+
+		bool m_FocusEventsDispatchedByMovingBetweenWindows; //!< Whether queued events were dispatched due to raising windows when moving between windows in multi-display fullscreen in the previous update.
+		bool m_FocusEventsDispatchedByDisplaySwitchIn; //!< Whether queued events were dispatched due to raising windows when taking focus of any game window in the previous update.
+
 		std::shared_ptr<SDL_Window> m_PrimaryWindow; //!< The main window.
 		std::shared_ptr<SDL_Renderer> m_PrimaryRenderer; //!< The main window renderer, draws to the main window.
 		std::unique_ptr<SDL_Texture, SDLTextureDeleter> m_PrimaryTexture; //!< The main window renderer's drawing surface.
@@ -226,7 +231,6 @@ namespace RTE {
 		std::vector<SDL_Rect> m_MultiDisplayTextureOffsets; //!< Texture offsets for multi-display fullscreen.
 
 		bool m_AnyWindowHasFocus; //!< Whether any game window has focus.
-		bool m_FocusLostDueToMovingBetweenGameWindows; //!< Whether the focus lost event was due to moving between displays while in multi-display fullscreen.
 		bool m_ResolutionChanged; //!< Whether the resolution was changed through the settings.
 
 		int m_NumDisplays; //!< Number of physical displays.
@@ -311,7 +315,8 @@ namespace RTE {
 		/// <summary>
 		/// Handles focus gain when switching back to the game window.
 		/// </summary>
-		void DisplaySwitchIn() const;
+		/// <param name="windowThatShouldTakeInputFocus">The window that should take focus of input after all the windows are raised. This is only relevant in multi-display fullscreen.</param>
+		void DisplaySwitchIn(SDL_Window *windowThatShouldTakeInputFocus) const;
 
 		/// <summary>
 		/// Handles focus loss when switching away from the game window.