Create UI event handling infrastructure

Author: v-rob

builtin/ui/window.lua

@@ -54,6 +54,13 @@ function ui.Window:new(props)
 	self._style = props.style or ui.Style{}
 
 	self._root = props.root
+	self._focused = props.focused
+
+	self._uncloseable = props.uncloseable
+
+	self._on_close  = props.on_close
+	self._on_submit = props.on_submit
+	self._on_focus_change = props.on_focus_change
 
 	assert(ui._window_types[self._type], "Invalid window type")
 	assert(core.is_instance(self._root, ui.Root),
@@ -71,18 +78,35 @@ function ui.Window:new(props)
 		assert(elem._window == nil, "Element already has window")
 		elem._window = self
 	end
+
+	if self._focused and self._focused ~= "" then
+		assert(self._elems_by_id[self._focused],
+				"Invalid focused element: '" .. self._focused .. "'")
+	end
 end
 
 function ui.Window:_encode(player, opening)
 	local enc_styles = self:_encode_styles()
 	local enc_elems = self:_encode_elems()
 
+	local fl = ui._make_flags()
+
+	if ui._shift_flag(fl, self._focused) then
+		ui._encode_flag(fl, "z", self._focused)
+	end
+	if opening then
+		ui._shift_flag(fl, self._uncloseable)
+	end
+
+	ui._shift_flag(fl, self._on_submit)
+	ui._shift_flag(fl, self._on_focus_change)
+
 	local data = ui._encode("ZzZ", enc_elems, self._root._id, enc_styles)
 	if opening then
 		data = ui._encode("ZB", data, ui._window_types[self._type])
 	end
 
-	return data
+	return ui._encode("ZZ", data, ui._encode_flags(fl))
 end
 
 function ui.Window:_encode_styles()
@@ -215,6 +239,68 @@ function ui.Window:_encode_elems()
 	return ui._encode_array("Z", enc_elems)
 end
 
+local event_handlers = {
+	[0x00] = function(window, ev, data)
+		-- We should never receive an event for an uncloseable window. If we
+		-- did, this player might be trying to cheat.
+		if window._uncloseable then
+			core.log("action", "Player '" .. open_windows[window._id].player ..
+					"' closed uncloseable window")
+			return
+		end
+
+		-- Since the window is now closed, remove the open window data.
+		open_windows[window._id] = nil
+		return window._on_close
+	end,
+
+	[0x01] = function(window, ev, data)
+		return window._on_submit
+	end,
+
+	[0x02] = function(window, ev, data)
+		ev.target = ui._decode("z", data)
+
+		-- If the ID for this element doesn't exist, we probably updated the
+		-- window to remove the element. Assume nothing is focused then.
+		if not window._elems_by_id[ev.target] then
+			ev.target = ""
+		end
+
+		return window._on_focus_change
+	end,
+}
+
+function ui.Window:_on_window_event(event, data)
+	-- There are no events that should fire for non-GUI windows.
+	if self._type ~= "gui" then
+		core.log("info", "Non-GUI window received event: " .. event)
+		return
+	end
+
+	-- Prepare the basic window event table.
+	local info = open_windows[self._id]
+	local ev = {
+		window = self._id,
+		player = info.player,
+		context = info.context,
+	}
+
+	-- Get the handler function for this event if we recognize it.
+	local handler = event_handlers[event]
+	if not handler then
+		core.log("info", "Invalid window event: " .. event)
+		return
+	end
+
+	-- If the event handler returned a callback function for the user, call it
+	-- with the event table.
+	local callback = handler(self, ev, data)
+	if callback then
+		callback(ev)
+	end
+end
+
 local OPEN_WINDOW   = 0x00
 local REOPEN_WINDOW = 0x01
 local UPDATE_WINDOW = 0x02
@@ -305,3 +391,35 @@ function ui.get_open_windows()
 	end
 	return ids
 end
+
+local WINDOW_EVENT = 0x00
+local ELEM_EVENT   = 0x01
+
+function core.receive_ui_message(player, data)
+	local action, id, data = ui._decode("BL Z", data, -1)
+
+	local info = open_windows[id]
+	if not info then
+		-- Discard events for any window that isn't currently open, since
+		-- it's probably due to network latency and events coming late.
+		core.log("info", "Window " .. id .. " is not open")
+		return
+	end
+
+	if info.player ~= player then
+		-- The player doesn't match up with what we expected, so ignore the
+		-- (probably malicious) event.
+		core.log("action", "Window " .. id .. " has player '" .. info.player ..
+				"', but received event from player '" .. player .. "'")
+		return
+	end
+
+	if action == WINDOW_EVENT then
+		local event, data = ui._decode("BZ", data, -1)
+		info.window:_on_window_event(event, data)
+	elseif action == ELEM_EVENT then
+		-- TODO
+	else
+		core.log("info", "Invalid window action: " .. action)
+	end
+end

src/client/client.cpp

@@ -1290,6 +1290,14 @@ void Client::sendInventoryFields(const std::string &formname,
 	Send(&pkt);
 }
 
+void Client::sendUiMessage(const char *data, size_t len)
+{
+	NetworkPacket pkt(TOSERVER_UI_MESSAGE, 0);
+	pkt.putRawString(data, len);
+
+	Send(&pkt);
+}
+
 void Client::sendInventoryAction(InventoryAction *a)
 {
 	std::ostringstream os(std::ios_base::binary);

src/client/client.h

@@ -242,6 +242,7 @@ class Client : public con::PeerHandler, public InventoryManager, public IGameDef
 		const StringMap &fields);
 	void sendInventoryFields(const std::string &formname,
 		const StringMap &fields);
+	void sendUiMessage(const char *data, size_t len);
 	void sendInventoryAction(InventoryAction *a);
 	void sendChatMessage(const std::wstring &message);
 	void clearOutChatQueue();

src/client/clientlauncher.cpp

@@ -22,6 +22,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "server.h"
 #include "filesys.h"
 #include "gui/guiMainMenu.h"
+#include "gui/manager.h"
 #include "game.h"
 #include "player.h"
 #include "chat.h"
@@ -48,7 +49,7 @@ MainMenuManager g_menumgr;
 
 bool isMenuActive()
 {
-	return g_menumgr.menuCount() != 0;
+	return g_menumgr.menuCount() != 0 || ui::g_manager.isFocused();
 }
 
 // Passed to menus to allow disconnecting and exiting

src/client/gameui.cpp

@@ -175,7 +175,7 @@ void GameUI::update(const RunStats &stats, Client *client, MapDrawControl *draw_
 	m_guitext2->setVisible(m_flags.show_basic_debug);
 
 	setStaticText(m_guitext_info, m_infotext.c_str());
-	m_guitext_info->setVisible(m_flags.show_hud && g_menumgr.menuCount() == 0);
+	m_guitext_info->setVisible(m_flags.show_hud && !isMenuActive());
 
 	static const float statustext_time_max = 1.5f;
 

src/gui/box.cpp

@@ -27,6 +27,8 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "gui/window.h"
 #include "util/serialize.h"
 
+#include <SDL2/SDL.h>
+
 namespace ui
 {
 	Align toAlign(u8 align)
@@ -186,6 +188,11 @@ namespace ui
 		return m_elem.getWindow();
 	}
 
+	bool Box::isFocused() const
+	{
+		return m_elem.isFocused();
+	}
+
 	void Box::reset()
 	{
 		m_style.reset();
@@ -302,6 +309,148 @@ namespace ui
 		drawForeground(canvas);
 	}
 
+	bool Box::isPointerInside() const
+	{
+		return rect_contains(m_clip_rect, getWindow().getPointerPos());
+	}
+
+	bool Box::processInput(const SDL_Event &event)
+	{
+		// If this is a static box, we ignore events entirely.
+		if (!(m_flags & DYNAMIC)) {
+			return false;
+		}
+
+		// If the box was triggered after the last event, it isn't anymore.
+		m_was_triggered = false;
+
+		switch (event.type) {
+		case SDL_KEYDOWN:
+		case SDL_KEYUP:
+			// If the spacebar should be detected, change the pressed state
+			// based on whether the spacebar was pressed or released. Ignore
+			// key repeats to avoid immediately pressing a box again when the
+			// mouse was released to unpress it.
+			if (m_flags & USE_SPACE &&
+					event.key.keysym.sym == SDLK_SPACE && !event.key.repeat) {
+				setPressed(event.type == SDL_KEYDOWN, event.type == SDL_KEYUP);
+				return true;
+			}
+			return false;
+
+		case SDL_MOUSEMOTION:
+			// Peek at the event to see if it affected whether we're pressed.
+			updatePressed();
+			return false;
+
+		case SDL_MOUSEBUTTONDOWN:
+			// If the left mouse button was pressed while this box was hovered,
+			// this box is now a pressed box.
+			if (isHovered() && event.button.button == SDL_BUTTON_LEFT) {
+				setPressed(true, false);
+				return true;
+			}
+			return false;
+
+		case SDL_MOUSEBUTTONUP:
+			// If the left mouse button was released anywhere (not just inside
+			// this box), then we're no longer pressed. The press only counts
+			// as a trigger if the box is hovered by the mouse.
+			if (event.button.button == SDL_BUTTON_LEFT) {
+				setPressed(false, isHovered());
+
+				// If the box is hovered when released, handle the event.
+				// Otherwise, we're just peeking.
+				return isHovered();
+			}
+			return false;
+
+		case SDL_USEREVENT:
+			switch (event.user.code) {
+			case UI_FOCUS_REQUEST:
+				// We're a dynamic box, so we can be focused.
+				return true;
+
+			case UI_FOCUS_CHANGED:
+				// If focus was lost, unpress this box. If focus was gained,
+				// it's possible for a non-holdable box to become pressed.
+				if (event.user.data1 == &m_elem) {
+					setPressed(false, false);
+				}
+				updatePressed();
+				return false;
+
+			case UI_FOCUS_SUBVERTED:
+				// If focus was subverted by another element or window, unpress
+				// this box. For non-holdable boxes, this will only unpress if
+				// a window subverted the focus, not an element.
+				setPressed(false, false);
+				return false;
+
+			case UI_HOVER_REQUEST:
+				// If the mouse is inside this specific box, accept the hover.
+				return isPointerInside();
+
+			case UI_HOVER_CHANGED:
+				// If the hovered element changed, make ourself hovered if the
+				// mouse is inside this box and our parent element is the newly
+				// hovered element. For non-holdable boxes, this may also cause
+				// the element to become pressed.
+				m_is_hovered = isPointerInside() && event.user.data2 == &m_elem;
+				updatePressed();
+				return true;
+
+			default:
+				break;
+			}
+			return false;
+
+		default:
+			break;
+		}
+
+		return false;
+	}
+
+	void Box::setPressed(bool press, bool trigger)
+	{
+		if (m_flags & HOLDABLE) {
+			// If the box was already pressed and is being unpressed, and if
+			// the last event was a trigger, then the box has been triggered.
+			if (m_is_pressed && !press && trigger) {
+				m_was_triggered = trigger;
+			}
+
+			// Then, update whether the box is actually pressed.
+			m_is_pressed = press;
+		}
+
+		updatePressed();
+	}
+
+	void Box::updatePressed()
+	{
+		if (!(m_flags & HOLDABLE)) {
+			bool was_pressed = m_is_pressed;
+
+			// The box must be focused to be pressed. If the left mouse button
+			// is pressed while the box is hovered, the box is pressed.
+			// Alternatively, the box is pressed if the spacebar is down when
+			// the spacebar is set to be detected.
+			bool mouse_down = g_manager.isPointerPressed();
+			bool space_down = SDL_GetKeyboardState(nullptr)[SDL_SCANCODE_SPACE];
+
+			m_is_pressed = isFocused() &&
+				((isHovered() && mouse_down) || (m_flags & USE_SPACE && space_down));
+
+			// If the box went from not being pressed to being pressed, then
+			// the box has been triggered.
+			if (!was_pressed && m_is_pressed) {
+				m_was_triggered = true;
+			}
+		}
+	}
+
 	void Box::drawForeground(Canvas &canvas)
 	{
 		// It makes no sense to draw a foreground when there's no image, since
@@ -469,6 +618,13 @@ namespace ui
 		m_style.reset();
 		State state = STATE_NONE;
 
+		if (isFocused())
+			state |= STATE_FOCUSED;
+		if (isHovered())
+			state |= STATE_HOVERED;
+		if (isPressed())
+			state |= STATE_PRESSED;
+
 		// Loop over each style state from lowest precedence to highest since
 		// they should be applied in that order.
 		for (State i = 0; i < m_style_refs.size(); i++) {