Add support for clipboard and file/text drop events

src/engine/app/input-manager.hpp

@@ -11,6 +11,7 @@
 #include <engine/event/dispatcher.hpp>
 #include <map>
 #include <memory>
+#include <string>
 #include <unordered_set>
 
 namespace app {
@@ -21,17 +22,13 @@ namespace app {
 class input_manager
 {
 public:
-	/**
-	 * Allocates and returns an input manager.
-	 */
+	/** Allocates and returns an input manager. */
 	static std::unique_ptr<input_manager> instance();
 
-	/// Destructs an input manager.
+	/** Destructs an input manager. */
 	virtual ~input_manager() = default;
 
-	/**
-	 * Processes input events.
-	 */
+	/** Processes input events. */
 	virtual void update() = 0;
 
 	/**
@@ -49,9 +46,17 @@ class input_manager
 	virtual void set_relative_mouse_mode(bool enabled) = 0;
 
 	/**
-	 * Returns the event dispatcher associated with registered input devices.
+	 * Sets the clipboard text.
+	 *
+	 * @param text UTF-8 text.
 	 */
+	virtual void set_clipboard_text(const std::string& text) = 0;
+
+	/** Returns UTF-8 text from the clipboard. */
+	[[nodiscard]] virtual std::string get_clipboard_text() const = 0;
+
 	/// @{
+	/** Returns the event dispatcher associated with registered input devices. */
 	[[nodiscard]] inline const ::event::dispatcher& get_event_dispatcher() const noexcept
 	{
 		return m_event_dispatcher;
@@ -81,24 +86,24 @@ class input_manager
 	}
 
 protected:
+	/// @{
 	/**
 	 * Registers an input device.
 	 *
 	 * @param device Input device to register.
 	 */
-	/// @{
 	void register_device(input::device& device);
 	void register_gamepad(input::gamepad& device);
 	void register_keyboard(input::keyboard& device);
 	void register_mouse(input::mouse& device);
 	/// @}
 
+	/// @{
 	/**
 	 * Unregisters an input device.
 	 *
 	 * @param device Input device to unregister.
 	 */
-	/// @{
 	void unregister_device(input::device& device);
 	void unregister_gamepad(input::gamepad& device);
 	void unregister_keyboard(input::keyboard& device);

src/engine/app/sdl/sdl-input-manager.cpp

@@ -3,6 +3,7 @@
 
 #include <engine/app/sdl/sdl-input-manager.hpp>
 #include <engine/input/application-events.hpp>
+#include <engine/input/clipboard-events.hpp>
 #include <engine/input/input-update-event.hpp>
 #include <engine/debug/log.hpp>
 #include <engine/math/functions.hpp>
@@ -72,7 +73,7 @@ void sdl_input_manager::update()
 		{
 			case SDL_QUIT:
 				debug::log_debug("Application quit requested");
-				this->m_event_dispatcher.dispatch<input::application_quit_event>({});
+				m_event_dispatcher.dispatch<input::application_quit_event>({});
 				break;
 
 			default:
@@ -85,7 +86,7 @@ void sdl_input_manager::update()
 	{
 		// Get next display or window event
 		SDL_Event event;
-		const int status = SDL_PeepEvents(&event, 1, SDL_GETEVENT, SDL_KEYDOWN, SDL_LASTEVENT);
+		const int status = SDL_PeepEvents(&event, 1, SDL_GETEVENT, SDL_KEYDOWN, SDL_CLIPBOARDUPDATE);
 
 		if (!status)
 		{
@@ -293,13 +294,19 @@ void sdl_input_manager::update()
 				break;
 			}
 
+			[[unlikely]] case SDL_CLIPBOARDUPDATE:
+			{
+				m_event_dispatcher.dispatch<input::clipboard_updated_event>({});
+				break;
+			}
+
 			default:
 				break;
 		}
 	}
 
 	// Dispatch input update event
-	this->m_event_dispatcher.dispatch<input::update_event>({});
+	m_event_dispatcher.dispatch<input::update_event>({});
 }
 
 void sdl_input_manager::set_cursor_visible(bool visible)
@@ -320,4 +327,27 @@ void sdl_input_manager::set_relative_mouse_mode(bool enabled)
 	}
 }
 
+void sdl_input_manager::set_clipboard_text(const std::string& text)
+{
+	if (SDL_SetClipboardText(text.c_str()) != 0)
+	{
+		debug::log_error("Failed to set clipboard text: \"{}\"", SDL_GetError());
+		SDL_ClearError();
+	}
+}
+
+std::string sdl_input_manager::get_clipboard_text() const
+{
+	// Get SDL-allocated text from clipboard
+	auto sdl_clipboard_text = SDL_GetClipboardText();
+
+	// Copy text into string
+	std::string clipboard_text = sdl_clipboard_text;
+
+	// Free SDL-allocated text
+	SDL_free(sdl_clipboard_text);
+
+	return clipboard_text;
+}
+
 } // namespace app

src/engine/app/sdl/sdl-input-manager.hpp

@@ -17,19 +17,17 @@ class sdl_window;
 class sdl_input_manager: public input_manager
 {
 public:
-	/**
-	 * Constructs an SDL input manager.
-	 */
+	/** Constructs an SDL input manager. */
 	sdl_input_manager();
 
-	/**
-	 * Destructs an SDL input manager.
-	 */
+	/** Destructs an SDL input manager. */
 	~sdl_input_manager() override;
 
 	void update() override;
 	void set_cursor_visible(bool visible) override;
 	void set_relative_mouse_mode(bool enabled) override;
+	void set_clipboard_text(const std::string& text) override;
+	[[nodiscard]] std::string get_clipboard_text() const override;
 
 private:
 	input::keyboard m_keyboard;

src/engine/app/sdl/sdl-window-manager.cpp

@@ -21,6 +21,13 @@ sdl_window_manager::sdl_window_manager()
 	}
 	debug::log_trace("Initialized SDL events and video subsystems");
 
+	// Disable unused events
+	SDL_EventState(SDL_AUDIODEVICEADDED, SDL_IGNORE);
+	SDL_EventState(SDL_AUDIODEVICEREMOVED, SDL_IGNORE);
+	SDL_EventState(SDL_RENDER_TARGETS_RESET, SDL_IGNORE);
+	SDL_EventState(SDL_RENDER_DEVICE_RESET, SDL_IGNORE);
+	SDL_EventState(SDL_USEREVENT, SDL_IGNORE);
+
 	// Query displays
 	const int display_count = SDL_GetNumVideoDisplays();
 	if (display_count < 1)
@@ -117,7 +124,7 @@ void sdl_window_manager::update()
 
 	for (;;)
 	{
-		// Get next window or display event
+		// Get next window or displayp event
 		SDL_Event event;
 		int status = SDL_PeepEvents(&event, 1, SDL_GETEVENT, SDL_DISPLAYEVENT, SDL_SYSWMEVENT);
 
@@ -387,6 +394,79 @@ void sdl_window_manager::update()
 			}
 		}
 	}
+
+	for (;;)
+	{
+		// Get next drop event
+		SDL_Event event;
+		int status = SDL_PeepEvents(&event, 1, SDL_GETEVENT, SDL_DROPFILE, SDL_DROPCOMPLETE);
+
+		if (!status)
+		{
+			break;
+		}
+		else if (status < 0)
+		{
+			debug::log_error("Failed to peep SDL events: {}", SDL_GetError());
+			throw std::runtime_error("Failed to peep SDL events");
+		}
+
+		switch (event.type)
+		{
+			case SDL_DROPFILE:
+			{
+				// Get window
+				auto window = get_window(SDL_GetWindowFromID(event.drop.windowID));
+
+				// Publish drop file event
+				window->m_drop_file_publisher.publish({window, std::filesystem::path(event.drop.file)});
+
+				// Free file path
+				SDL_free(event.drop.file);
+
+				break;
+			}
+
+			case SDL_DROPTEXT:
+			{
+				// Get window
+				auto window = get_window(SDL_GetWindowFromID(event.drop.windowID));
+
+				// Publish drop text event
+				window->m_drop_text_publisher.publish({window, std::string(event.drop.file)});
+
+				// Free text
+				SDL_free(event.drop.file);
+
+				break;
+			}
+
+			case SDL_DROPBEGIN:
+			{
+				// Get window
+				auto window = get_window(SDL_GetWindowFromID(event.drop.windowID));
+
+				// Publish drop begin event
+				window->m_drop_begin_publisher.publish({window});
+
+				break;
+			}
+
+			case SDL_DROPCOMPLETE:
+			{
+				// Get window
+				auto window = get_window(SDL_GetWindowFromID(event.drop.windowID));
+
+				// Publish drop end event
+				window->m_drop_end_publisher.publish({window});
+
+				break;
+			}
+
+			default:
+				break;
+		}
+	}
 }
 
 sdl_window* sdl_window_manager::get_window(SDL_Window* internal_window)

src/engine/app/window-events.hpp

@@ -5,6 +5,8 @@
 #define ANTKEEPER_APP_WINDOW_EVENTS_HPP
 
 #include <engine/math/vector.hpp>
+#include <filesystem>
+#include <string>
 
 namespace app {
 
@@ -82,6 +84,48 @@ struct window_resized_event
 	math::ivec2 size{0, 0};
 };
 
+/**
+ * Event generated when data is about to be dropped onto a window.
+ */
+struct window_drop_begin_event
+{
+	/// Pointer to the window onto which data has been dropped.
+	window* window{nullptr};
+};
+
+/**
+ * Event generated when data has finished dropping onto a window.
+ */
+struct window_drop_end_event
+{
+	/// Pointer to the window onto which data has been dropped.
+	window* window{nullptr};
+};
+
+/**
+ * Event generated when a file is dropped onto a window.
+ */
+struct window_drop_file_event
+{
+	/// Pointer to the window onto which a file has been dropped.
+	window* window{nullptr};
+
+	/// Path to the dropped file.
+	std::filesystem::path file_path;
+};
+
+/**
+ * Event generated when text is dropped onto a window.
+ */
+struct window_drop_text_event
+{
+	/// Pointer to the window onto which text has been dropped.
+	window* window{nullptr};
+
+	/// String containing the dropped text.
+	std::string text;
+};
+
 } // namespace app
 
 #endif // ANTKEEPER_APP_WINDOW_EVENTS_HPP