1 files changed, 143 insertions, 146 deletions

diff --git a/platform/linuxbsd/display_server_x11.cpp b/platform/linuxbsd/display_server_x11.cpp
index 8f0742041c..c0e5aac938 100644
--- a/platform/linuxbsd/display_server_x11.cpp
+++ b/platform/linuxbsd/display_server_x11.cpp
@@ -136,70 +136,6 @@ String DisplayServerX11::get_name() const {
 	return "X11";
 }
 
-void DisplayServerX11::alert(const String &p_alert, const String &p_title) {
-	const char *message_programs[] = { "zenity", "kdialog", "Xdialog", "xmessage" };
-
-	String path = OS::get_singleton()->get_environment("PATH");
-	Vector<String> path_elems = path.split(":", false);
-	String program;
-
-	for (int i = 0; i < path_elems.size(); i++) {
-		for (uint64_t k = 0; k < sizeof(message_programs) / sizeof(char *); k++) {
-			String tested_path = path_elems[i].plus_file(message_programs[k]);
-
-			if (FileAccess::exists(tested_path)) {
-				program = tested_path;
-				break;
-			}
-		}
-
-		if (program.length()) {
-			break;
-		}
-	}
-
-	List<String> args;
-
-	if (program.ends_with("zenity")) {
-		args.push_back("--error");
-		args.push_back("--width");
-		args.push_back("500");
-		args.push_back("--title");
-		args.push_back(p_title);
-		args.push_back("--text");
-		args.push_back(p_alert);
-	}
-
-	if (program.ends_with("kdialog")) {
-		args.push_back("--error");
-		args.push_back(p_alert);
-		args.push_back("--title");
-		args.push_back(p_title);
-	}
-
-	if (program.ends_with("Xdialog")) {
-		args.push_back("--title");
-		args.push_back(p_title);
-		args.push_back("--msgbox");
-		args.push_back(p_alert);
-		args.push_back("0");
-		args.push_back("0");
-	}
-
-	if (program.ends_with("xmessage")) {
-		args.push_back("-center");
-		args.push_back("-title");
-		args.push_back(p_title);
-		args.push_back(p_alert);
-	}
-
-	if (program.length()) {
-		OS::get_singleton()->execute(program, args);
-	} else {
-		print_line(p_alert);
-	}
-}
-
 void DisplayServerX11::_update_real_mouse_position(const WindowData &wd) {
 	Window root_return, child_return;
 	int root_x, root_y, win_x, win_y;
@@ -370,11 +306,11 @@ void DisplayServerX11::mouse_set_mode(MouseMode p_mode) {
 	// The only modes that show a cursor are VISIBLE and CONFINED
 	bool showCursor = (p_mode == MOUSE_MODE_VISIBLE || p_mode == MOUSE_MODE_CONFINED);
 
-	for (Map<WindowID, WindowData>::Element *E = windows.front(); E; E = E->next()) {
+	for (const KeyValue<WindowID, WindowData> &E : windows) {
 		if (showCursor) {
-			XDefineCursor(x11_display, E->get().x11_window, cursors[current_cursor]); // show cursor
+			XDefineCursor(x11_display, E.value.x11_window, cursors[current_cursor]); // show cursor
 		} else {
-			XDefineCursor(x11_display, E->get().x11_window, null_cursor); // hide cursor
+			XDefineCursor(x11_display, E.value.x11_window, null_cursor); // hide cursor
 		}
 	}
 	mouse_mode = p_mode;
@@ -470,6 +406,20 @@ void DisplayServerX11::clipboard_set(const String &p_text) {
 	XSetSelectionOwner(x11_display, XInternAtom(x11_display, "CLIPBOARD", 0), windows[MAIN_WINDOW_ID].x11_window, CurrentTime);
 }
 
+void DisplayServerX11::clipboard_set_primary(const String &p_text) {
+	_THREAD_SAFE_METHOD_
+	if (!p_text.is_empty()) {
+		{
+			// The clipboard content can be accessed while polling for events.
+			MutexLock mutex_lock(events_mutex);
+			internal_clipboard_primary = p_text;
+		}
+
+		XSetSelectionOwner(x11_display, XA_PRIMARY, windows[MAIN_WINDOW_ID].x11_window, CurrentTime);
+		XSetSelectionOwner(x11_display, XInternAtom(x11_display, "PRIMARY", 0), windows[MAIN_WINDOW_ID].x11_window, CurrentTime);
+	}
+}
+
 Bool DisplayServerX11::_predicate_clipboard_selection(Display *display, XEvent *event, XPointer arg) {
 	if (event->type == SelectionNotify && event->xselection.requestor == *(Window *)arg) {
 		return True;
@@ -491,7 +441,12 @@ String DisplayServerX11::_clipboard_get_impl(Atom p_source, Window x11_window, A
 
 	Window selection_owner = XGetSelectionOwner(x11_display, p_source);
 	if (selection_owner == x11_window) {
-		return internal_clipboard;
+		static const char *target_type = "PRIMARY";
+		if (p_source != None && String(XGetAtomName(x11_display, p_source)) == target_type) {
+			return internal_clipboard_primary;
+		} else {
+			return internal_clipboard;
+		}
 	}
 
 	if (selection_owner != None) {
@@ -644,6 +599,19 @@ String DisplayServerX11::clipboard_get() const {
 	return ret;
 }
 
+String DisplayServerX11::clipboard_get_primary() const {
+	_THREAD_SAFE_METHOD_
+
+	String ret;
+	ret = _clipboard_get(XInternAtom(x11_display, "PRIMARY", 0), windows[MAIN_WINDOW_ID].x11_window);
+
+	if (ret.is_empty()) {
+		ret = _clipboard_get(XA_PRIMARY, windows[MAIN_WINDOW_ID].x11_window);
+	}
+
+	return ret;
+}
+
 Bool DisplayServerX11::_predicate_clipboard_save_targets(Display *display, XEvent *event, XPointer arg) {
 	if (event->xany.window == *(Window *)arg) {
 		return (event->type == SelectionRequest) ||
@@ -849,8 +817,8 @@ Vector<DisplayServer::WindowID> DisplayServerX11::get_window_list() const {
 	_THREAD_SAFE_METHOD_
 
 	Vector<int> ret;
-	for (Map<WindowID, WindowData>::Element *E = windows.front(); E; E = E->next()) {
-		ret.push_back(E->key());
+	for (const KeyValue<WindowID, WindowData> &E : windows) {
+		ret.push_back(E.key);
 	}
 	return ret;
 }
@@ -871,7 +839,9 @@ DisplayServer::WindowID DisplayServerX11::create_sub_window(WindowMode p_mode, V
 void DisplayServerX11::show_window(WindowID p_id) {
 	_THREAD_SAFE_METHOD_
 
-	WindowData &wd = windows[p_id];
+	const WindowData &wd = windows[p_id];
+
+	DEBUG_LOG_X11("show_window: %lu (%u) \n", wd.x11_window, p_id);
 
 	XMapWindow(x11_display, wd.x11_window);
 }
@@ -926,8 +896,8 @@ DisplayServerX11::WindowID DisplayServerX11::get_window_at_screen_position(const
 	WindowID found_window = INVALID_WINDOW_ID;
 	WindowID parent_window = INVALID_WINDOW_ID;
 	unsigned int focus_order = 0;
-	for (Map<WindowID, WindowData>::Element *E = windows.front(); E; E = E->next()) {
-		const WindowData &wd = E->get();
+	for (const KeyValue<WindowID, WindowData> &E : windows) {
+		const WindowData &wd = E.value;
 
 		// Discard windows with no focus.
 		if (wd.focus_order == 0) {
@@ -935,7 +905,7 @@ DisplayServerX11::WindowID DisplayServerX11::get_window_at_screen_position(const
 		}
 
 		// Find topmost window which contains the given position.
-		WindowID window_id = E->key();
+		WindowID window_id = E.key;
 		Rect2i win_rect = Rect2i(window_get_position(window_id), window_get_size(window_id));
 		if (win_rect.has_point(p_position)) {
 			// For siblings, pick the window which was focused last.
@@ -1095,6 +1065,8 @@ void DisplayServerX11::window_set_transient(WindowID p_window, WindowID p_parent
 	WindowID prev_parent = wd_window.transient_parent;
 	ERR_FAIL_COND(prev_parent == p_parent);
 
+	DEBUG_LOG_X11("window_set_transient: %lu (%u), prev_parent=%u, parent=%u\n", wd_window.x11_window, p_window, prev_parent, p_parent);
+
 	ERR_FAIL_COND_MSG(wd_window.on_top, "Windows with the 'on top' can't become transient.");
 	if (p_parent == INVALID_WINDOW_ID) {
 		//remove transient
@@ -1109,10 +1081,10 @@ void DisplayServerX11::window_set_transient(WindowID p_window, WindowID p_parent
 
 		XSetTransientForHint(x11_display, wd_window.x11_window, None);
 
-		// Set focus to parent sub window to avoid losing all focus with nested menus.
+		// Set focus to parent sub window to avoid losing all focus when closing a nested sub-menu.
 		// RevertToPointerRoot is used to make sure we don't lose all focus in case
 		// a subwindow and its parent are both destroyed.
-		if (wd_window.menu_type && !wd_window.no_focus) {
+		if (wd_window.menu_type && !wd_window.no_focus && wd_window.focused) {
 			if (!wd_parent.no_focus) {
 				XSetInputFocus(x11_display, wd_parent.x11_window, RevertToPointerRoot, CurrentTime);
 			}
@@ -1828,8 +1800,8 @@ bool DisplayServerX11::window_can_draw(WindowID p_window) const {
 bool DisplayServerX11::can_any_window_draw() const {
 	_THREAD_SAFE_METHOD_
 
-	for (Map<WindowID, WindowData>::Element *E = windows.front(); E; E = E->next()) {
-		if (window_get_mode(E->key()) != WINDOW_MODE_MINIMIZED) {
+	for (const KeyValue<WindowID, WindowData> &E : windows) {
+		if (window_get_mode(E.key) != WINDOW_MODE_MINIMIZED) {
 			return true;
 		}
 	}
@@ -1901,12 +1873,12 @@ void DisplayServerX11::cursor_set_shape(CursorShape p_shape) {
 
 	if (mouse_mode == MOUSE_MODE_VISIBLE || mouse_mode == MOUSE_MODE_CONFINED) {
 		if (cursors[p_shape] != None) {
-			for (Map<WindowID, WindowData>::Element *E = windows.front(); E; E = E->next()) {
-				XDefineCursor(x11_display, E->get().x11_window, cursors[p_shape]);
+			for (const KeyValue<WindowID, WindowData> &E : windows) {
+				XDefineCursor(x11_display, E.value.x11_window, cursors[p_shape]);
 			}
 		} else if (cursors[CURSOR_ARROW] != None) {
-			for (Map<WindowID, WindowData>::Element *E = windows.front(); E; E = E->next()) {
-				XDefineCursor(x11_display, E->get().x11_window, cursors[CURSOR_ARROW]);
+			for (const KeyValue<WindowID, WindowData> &E : windows) {
+				XDefineCursor(x11_display, E.value.x11_window, cursors[CURSOR_ARROW]);
 			}
 		}
 	}
@@ -2004,8 +1976,8 @@ void DisplayServerX11::cursor_set_custom_image(const RES &p_cursor, CursorShape
 
 		if (p_shape == current_cursor) {
 			if (mouse_mode == MOUSE_MODE_VISIBLE || mouse_mode == MOUSE_MODE_CONFINED) {
-				for (Map<WindowID, WindowData>::Element *E = windows.front(); E; E = E->next()) {
-					XDefineCursor(x11_display, E->get().x11_window, cursors[p_shape]);
+				for (const KeyValue<WindowID, WindowData> &E : windows) {
+					XDefineCursor(x11_display, E.value.x11_window, cursors[p_shape]);
 				}
 			}
 		}
@@ -2128,6 +2100,24 @@ String DisplayServerX11::keyboard_get_layout_name(int p_index) const {
 	return ret;
 }
 
+Key DisplayServerX11::keyboard_get_keycode_from_physical(Key p_keycode) const {
+	unsigned int modifiers = p_keycode & KEY_MODIFIER_MASK;
+	unsigned int keycode_no_mod = p_keycode & KEY_CODE_MASK;
+	unsigned int xkeycode = KeyMappingX11::get_xlibcode((Key)keycode_no_mod);
+	KeySym xkeysym = XkbKeycodeToKeysym(x11_display, xkeycode, 0, 0);
+	if (xkeysym >= 'a' && xkeysym <= 'z') {
+		xkeysym -= ('a' - 'A');
+	}
+
+	Key key = KeyMappingX11::get_keycode(xkeysym);
+	// If not found, fallback to QWERTY.
+	// This should match the behavior of the event pump
+	if (key == KEY_NONE) {
+		return p_keycode;
+	}
+	return (Key)(key | modifiers);
+}
+
 DisplayServerX11::Property DisplayServerX11::_read_property(Display *p_display, Window p_window, Atom p_property) {
 	Atom actual_type = None;
 	int actual_format = 0;
@@ -2227,7 +2217,7 @@ void DisplayServerX11::_handle_key_event(WindowID p_window, XKeyEvent *p_event,
 	// still works in half the cases. (won't handle deadkeys)
 	// For more complex input methods (deadkeys and more advanced)
 	// you have to use XmbLookupString (??).
-	// So.. then you have to chosse which of both results
+	// So then you have to choose which of both results
 	// you want to keep.
 	// This is a real bizarreness and cpu waster.
 
@@ -2267,7 +2257,7 @@ void DisplayServerX11::_handle_key_event(WindowID p_window, XKeyEvent *p_event,
 
 		if (status == XLookupChars) {
 			bool keypress = xkeyevent->type == KeyPress;
-			unsigned int keycode = KeyMappingX11::get_keycode(keysym_keycode);
+			Key keycode = KeyMappingX11::get_keycode(keysym_keycode);
 			unsigned int physical_keycode = KeyMappingX11::get_scancode(xkeyevent->keycode);
 
 			if (keycode >= 'a' && keycode <= 'z') {
@@ -2284,7 +2274,7 @@ void DisplayServerX11::_handle_key_event(WindowID p_window, XKeyEvent *p_event,
 				}
 
 				if (keycode == 0) {
-					keycode = physical_keycode;
+					keycode = (Key)physical_keycode;
 				}
 
 				_get_key_modifier_state(xkeyevent->state, k);
@@ -2296,7 +2286,7 @@ void DisplayServerX11::_handle_key_event(WindowID p_window, XKeyEvent *p_event,
 
 				k->set_keycode(keycode);
 
-				k->set_physical_keycode(physical_keycode);
+				k->set_physical_keycode((Key)physical_keycode);
 
 				k->set_echo(false);
 
@@ -2307,7 +2297,7 @@ void DisplayServerX11::_handle_key_event(WindowID p_window, XKeyEvent *p_event,
 					k->set_shift_pressed(true);
 				}
 
-				Input::get_singleton()->accumulate_input_event(k);
+				Input::get_singleton()->parse_input_event(k);
 			}
 			memfree(utf8string);
 			return;
@@ -2331,7 +2321,7 @@ void DisplayServerX11::_handle_key_event(WindowID p_window, XKeyEvent *p_event,
 	// KeyMappingX11 just translated the X11 keysym to a PIGUI
 	// keysym, so it works in all platforms the same.
 
-	unsigned int keycode = KeyMappingX11::get_keycode(keysym_keycode);
+	Key keycode = KeyMappingX11::get_keycode(keysym_keycode);
 	unsigned int physical_keycode = KeyMappingX11::get_scancode(xkeyevent->keycode);
 
 	/* Phase 3, obtain a unicode character from the keysym */
@@ -2352,12 +2342,12 @@ void DisplayServerX11::_handle_key_event(WindowID p_window, XKeyEvent *p_event,
 
 	bool keypress = xkeyevent->type == KeyPress;
 
-	if (physical_keycode == 0 && keycode == 0 && unicode == 0) {
+	if (physical_keycode == 0 && keycode == KEY_NONE && unicode == 0) {
 		return;
 	}
 
-	if (keycode == 0) {
-		keycode = physical_keycode;
+	if (keycode == KEY_NONE) {
+		keycode = (Key)physical_keycode;
 	}
 
 	/* Phase 5, determine modifier mask */
@@ -2420,11 +2410,11 @@ void DisplayServerX11::_handle_key_event(WindowID p_window, XKeyEvent *p_event,
 	k->set_pressed(keypress);
 
 	if (keycode >= 'a' && keycode <= 'z') {
-		keycode -= 'a' - 'A';
+		keycode -= int('a' - 'A');
 	}
 
 	k->set_keycode(keycode);
-	k->set_physical_keycode(physical_keycode);
+	k->set_physical_keycode((Key)physical_keycode);
 	k->set_unicode(unicode);
 	k->set_echo(p_echo);
 
@@ -2456,10 +2446,10 @@ void DisplayServerX11::_handle_key_event(WindowID p_window, XKeyEvent *p_event,
 		}
 	}
 
-	Input::get_singleton()->accumulate_input_event(k);
+	Input::get_singleton()->parse_input_event(k);
 }
 
-Atom DisplayServerX11::_process_selection_request_target(Atom p_target, Window p_requestor, Atom p_property) const {
+Atom DisplayServerX11::_process_selection_request_target(Atom p_target, Window p_requestor, Atom p_property, Atom p_selection) const {
 	if (p_target == XInternAtom(x11_display, "TARGETS", 0)) {
 		// Request to list all supported targets.
 		Atom data[9];
@@ -2501,7 +2491,13 @@ Atom DisplayServerX11::_process_selection_request_target(Atom p_target, Window p
 			   p_target == XInternAtom(x11_display, "text/plain", 0)) {
 		// Directly using internal clipboard because we know our window
 		// is the owner during a selection request.
-		CharString clip = internal_clipboard.utf8();
+		CharString clip;
+		static const char *target_type = "PRIMARY";
+		if (p_selection != None && String(XGetAtomName(x11_display, p_selection)) == target_type) {
+			clip = internal_clipboard_primary.utf8();
+		} else {
+			clip = internal_clipboard.utf8();
+		}
 		XChangeProperty(x11_display,
 				p_requestor,
 				p_property,
@@ -2539,7 +2535,7 @@ void DisplayServerX11::_handle_selection_request_event(XSelectionRequestEvent *p
 				for (uint64_t i = 0; i < len; i += 2) {
 					Atom target = targets[i];
 					Atom &property = targets[i + 1];
-					property = _process_selection_request_target(target, p_event->requestor, property);
+					property = _process_selection_request_target(target, p_event->requestor, property, p_event->selection);
 				}
 
 				XChangeProperty(x11_display,
@@ -2557,7 +2553,7 @@ void DisplayServerX11::_handle_selection_request_event(XSelectionRequestEvent *p
 		}
 	} else {
 		// Request for target conversion.
-		respond.xselection.property = _process_selection_request_target(p_event->target, p_event->requestor, p_event->property);
+		respond.xselection.property = _process_selection_request_target(p_event->target, p_event->requestor, p_event->property, p_event->selection);
 	}
 
 	respond.xselection.type = SelectionNotify;
@@ -2577,8 +2573,8 @@ void DisplayServerX11::_xim_destroy_callback(::XIM im, ::XPointer client_data,
 	DisplayServerX11 *ds = reinterpret_cast<DisplayServerX11 *>(client_data);
 	ds->xim = nullptr;
 
-	for (Map<WindowID, WindowData>::Element *E = ds->windows.front(); E; E = E->next()) {
-		E->get().xic = nullptr;
+	for (KeyValue<WindowID, WindowData> &E : ds->windows) {
+		E.value.xic = nullptr;
 	}
 }
 
@@ -2586,9 +2582,9 @@ void DisplayServerX11::_window_changed(XEvent *event) {
 	WindowID window_id = MAIN_WINDOW_ID;
 
 	// Assign the event to the relevant window
-	for (Map<WindowID, WindowData>::Element *E = windows.front(); E; E = E->next()) {
-		if (event->xany.window == E->get().x11_window) {
-			window_id = E->key();
+	for (const KeyValue<WindowID, WindowData> &E : windows) {
+		if (event->xany.window == E.value.x11_window) {
+			window_id = E.key;
 			break;
 		}
 	}
@@ -2662,8 +2658,8 @@ void DisplayServerX11::_dispatch_input_event(const Ref<InputEvent> &p_event) {
 		callable.call((const Variant **)&evp, 1, ret, ce);
 	} else {
 		//send to all windows
-		for (Map<WindowID, WindowData>::Element *E = windows.front(); E; E = E->next()) {
-			Callable callable = E->get().input_event_callback;
+		for (KeyValue<WindowID, WindowData> &E : windows) {
+			Callable callable = E.value.input_event_callback;
 			if (callable.is_null()) {
 				continue;
 			}
@@ -2763,8 +2759,8 @@ void DisplayServerX11::process_events() {
 	if (app_focused) {
 		//verify that one of the windows has focus, else send focus out notification
 		bool focus_found = false;
-		for (Map<WindowID, WindowData>::Element *E = windows.front(); E; E = E->next()) {
-			if (E->get().focused) {
+		for (const KeyValue<WindowID, WindowData> &E : windows) {
+			if (E.value.focused) {
 				focus_found = true;
 				break;
 			}
@@ -2809,9 +2805,9 @@ void DisplayServerX11::process_events() {
 		WindowID window_id = MAIN_WINDOW_ID;
 
 		// Assign the event to the relevant window
-		for (Map<WindowID, WindowData>::Element *E = windows.front(); E; E = E->next()) {
-			if (event.xany.window == E->get().x11_window) {
-				window_id = E->key();
+		for (const KeyValue<WindowID, WindowData> &E : windows) {
+			if (event.xany.window == E.value.x11_window) {
+				window_id = E.key;
 				break;
 			}
 		}
@@ -2943,13 +2939,13 @@ void DisplayServerX11::process_events() {
 								// in a spurious mouse motion event being sent to Godot; remember it to be able to filter it out
 								xi.mouse_pos_to_filter = pos;
 							}
-							Input::get_singleton()->accumulate_input_event(st);
+							Input::get_singleton()->parse_input_event(st);
 						} else {
 							if (!xi.state.has(index)) { // Defensive
 								break;
 							}
 							xi.state.erase(index);
-							Input::get_singleton()->accumulate_input_event(st);
+							Input::get_singleton()->parse_input_event(st);
 						}
 					} break;
 
@@ -2966,7 +2962,7 @@ void DisplayServerX11::process_events() {
 							sd->set_index(index);
 							sd->set_position(pos);
 							sd->set_relative(pos - curr_pos_elem->value());
-							Input::get_singleton()->accumulate_input_event(sd);
+							Input::get_singleton()->parse_input_event(sd);
 
 							curr_pos_elem->value() = pos;
 						}
@@ -3050,17 +3046,17 @@ void DisplayServerX11::process_events() {
 				if (mouse_mode_grab) {
 					// Show and update the cursor if confined and the window regained focus.
 
-					for (Map<WindowID, WindowData>::Element *E = windows.front(); E; E = E->next()) {
+					for (const KeyValue<WindowID, WindowData> &E : windows) {
 						if (mouse_mode == MOUSE_MODE_CONFINED) {
-							XUndefineCursor(x11_display, E->get().x11_window);
+							XUndefineCursor(x11_display, E.value.x11_window);
 						} else if (mouse_mode == MOUSE_MODE_CAPTURED || mouse_mode == MOUSE_MODE_CONFINED_HIDDEN) { // Or re-hide it.
-							XDefineCursor(x11_display, E->get().x11_window, null_cursor);
+							XDefineCursor(x11_display, E.value.x11_window, null_cursor);
 						}
 
 						XGrabPointer(
-								x11_display, E->get().x11_window, True,
+								x11_display, E.value.x11_window, True,
 								ButtonPressMask | ButtonReleaseMask | PointerMotionMask,
-								GrabModeAsync, GrabModeAsync, E->get().x11_window, None, CurrentTime);
+								GrabModeAsync, GrabModeAsync, E.value.x11_window, None, CurrentTime);
 					}
 				}
 #ifdef TOUCH_ENABLED
@@ -3096,11 +3092,11 @@ void DisplayServerX11::process_events() {
 				_send_window_event(wd, WINDOW_EVENT_FOCUS_OUT);
 
 				if (mouse_mode_grab) {
-					for (Map<WindowID, WindowData>::Element *E = windows.front(); E; E = E->next()) {
+					for (const KeyValue<WindowID, WindowData> &E : windows) {
 						//dear X11, I try, I really try, but you never work, you do whathever you want.
 						if (mouse_mode == MOUSE_MODE_CAPTURED) {
 							// Show the cursor if we're in captured mode so it doesn't look weird.
-							XUndefineCursor(x11_display, E->get().x11_window);
+							XUndefineCursor(x11_display, E.value.x11_window);
 						}
 					}
 					XUngrabPointer(x11_display, CurrentTime);
@@ -3112,13 +3108,13 @@ void DisplayServerX11::process_events() {
 				}*/
 
 				// Release every pointer to avoid sticky points
-				for (Map<int, Vector2>::Element *E = xi.state.front(); E; E = E->next()) {
+				for (const KeyValue<int, Vector2> &E : xi.state) {
 					Ref<InputEventScreenTouch> st;
 					st.instantiate();
-					st->set_index(E->key());
+					st->set_index(E.key);
 					st->set_window_id(window_id);
-					st->set_position(E->get());
-					Input::get_singleton()->accumulate_input_event(st);
+					st->set_position(E.value);
+					Input::get_singleton()->parse_input_event(st);
 				}
 				xi.state.clear();
 #endif
@@ -3204,9 +3200,9 @@ void DisplayServerX11::process_events() {
 						// Note: This is needed for drag & drop to work between windows,
 						// because the engine expects events to keep being processed
 						// on the same window dragging started.
-						for (Map<WindowID, WindowData>::Element *E = windows.front(); E; E = E->next()) {
-							const WindowData &wd_other = E->get();
-							WindowID window_id_other = E->key();
+						for (const KeyValue<WindowID, WindowData> &E : windows) {
+							const WindowData &wd_other = E.value;
+							WindowID window_id_other = E.key;
 							if (wd_other.focused) {
 								if (window_id_other != window_id) {
 									int x, y;
@@ -3216,7 +3212,7 @@ void DisplayServerX11::process_events() {
 									mb->set_window_id(window_id_other);
 									mb->set_position(Vector2(x, y));
 									mb->set_global_position(mb->get_position());
-									Input::get_singleton()->accumulate_input_event(mb);
+									Input::get_singleton()->parse_input_event(mb);
 								}
 								break;
 							}
@@ -3224,7 +3220,7 @@ void DisplayServerX11::process_events() {
 					}
 				}
 
-				Input::get_singleton()->accumulate_input_event(mb);
+				Input::get_singleton()->parse_input_event(mb);
 
 			} break;
 			case MotionNotify: {
@@ -3340,15 +3336,15 @@ void DisplayServerX11::process_events() {
 				// this is so that the relative motion doesn't get messed up
 				// after we regain focus.
 				if (focused) {
-					Input::get_singleton()->accumulate_input_event(mm);
+					Input::get_singleton()->parse_input_event(mm);
 				} else {
 					// Propagate the event to the focused window,
 					// because it's received only on the topmost window.
 					// Note: This is needed for drag & drop to work between windows,
 					// because the engine expects events to keep being processed
 					// on the same window dragging started.
-					for (Map<WindowID, WindowData>::Element *E = windows.front(); E; E = E->next()) {
-						const WindowData &wd_other = E->get();
+					for (const KeyValue<WindowID, WindowData> &E : windows) {
+						const WindowData &wd_other = E.value;
 						if (wd_other.focused) {
 							int x, y;
 							Window child;
@@ -3356,11 +3352,11 @@ void DisplayServerX11::process_events() {
 
 							Point2i pos_focused(x, y);
 
-							mm->set_window_id(E->key());
+							mm->set_window_id(E.key);
 							mm->set_position(pos_focused);
 							mm->set_global_position(pos_focused);
 							mm->set_speed(Input::get_singleton()->get_last_mouse_speed());
-							Input::get_singleton()->accumulate_input_event(mm);
+							Input::get_singleton()->parse_input_event(mm);
 
 							break;
 						}
@@ -3493,7 +3489,7 @@ void DisplayServerX11::process_events() {
 		*/
 	}
 
-	Input::get_singleton()->flush_accumulated_events();
+	Input::get_singleton()->flush_buffered_events();
 }
 
 void DisplayServerX11::release_rendering_thread() {
@@ -3547,8 +3543,8 @@ void DisplayServerX11::set_context(Context p_context) {
 
 	context = p_context;
 
-	for (Map<WindowID, WindowData>::Element *E = windows.front(); E; E = E->next()) {
-		_update_context(E->get());
+	for (KeyValue<WindowID, WindowData> &E : windows) {
+		_update_context(E.value);
 	}
 }
 
@@ -3673,8 +3669,9 @@ Vector<String> DisplayServerX11::get_rendering_drivers_func() {
 DisplayServer *DisplayServerX11::create_func(const String &p_rendering_driver, WindowMode p_mode, VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i &p_resolution, Error &r_error) {
 	DisplayServer *ds = memnew(DisplayServerX11(p_rendering_driver, p_mode, p_vsync_mode, p_flags, p_resolution, r_error));
 	if (r_error != OK) {
-		ds->alert("Your video card driver does not support any of the supported Vulkan versions.\n"
-				  "Please update your drivers or if you have a very old or integrated GPU upgrade it.",
+		OS::get_singleton()->alert("Your video card driver does not support any of the supported Vulkan versions.\n"
+								   "Please update your drivers or if you have a very old or integrated GPU, upgrade it.\n"
+								   "If you have updated your graphics drivers recently, try rebooting.",
 				"Unable to initialize Video driver");
 	}
 	return ds;
@@ -3972,8 +3969,8 @@ DisplayServerX11::DisplayServerX11(const String &p_rendering_driver, WindowMode
 	}
 
 	if (!_refresh_device_info()) {
-		alert("Your system does not support XInput 2.\n"
-			  "Please upgrade your distribution.",
+		OS::get_singleton()->alert("Your system does not support XInput 2.\n"
+								   "Please upgrade your distribution.",
 				"Unable to initialize XInput");
 		r_error = ERR_UNAVAILABLE;
 		return;
@@ -4327,14 +4324,14 @@ DisplayServerX11::~DisplayServerX11() {
 	events_thread.wait_to_finish();
 
 	//destroy all windows
-	for (Map<WindowID, WindowData>::Element *E = windows.front(); E; E = E->next()) {
+	for (KeyValue<WindowID, WindowData> &E : windows) {
 #ifdef VULKAN_ENABLED
 		if (rendering_driver == "vulkan") {
-			context_vulkan->window_destroy(E->key());
+			context_vulkan->window_destroy(E.key);
 		}
 #endif
 
-		WindowData &wd = E->get();
+		WindowData &wd = E.value;
 		if (wd.xic) {
 			XDestroyIC(wd.xic);
 			wd.xic = nullptr;