1 files changed, 278 insertions, 98 deletions

diff --git a/platform/linuxbsd/freedesktop_portal_desktop.cpp b/platform/linuxbsd/freedesktop_portal_desktop.cpp
index 91c14e0e91..e65404a531 100644
--- a/platform/linuxbsd/freedesktop_portal_desktop.cpp
+++ b/platform/linuxbsd/freedesktop_portal_desktop.cpp
@@ -142,36 +142,88 @@ void FreeDesktopPortalDesktop::append_dbus_string(DBusMessageIter *p_iter, const
 	}
 }
 
-void FreeDesktopPortalDesktop::append_dbus_dict_filters(DBusMessageIter *p_iter, const Vector<String> &p_filters) {
+void FreeDesktopPortalDesktop::append_dbus_dict_options(DBusMessageIter *p_iter, const TypedArray<Dictionary> &p_options) {
+	DBusMessageIter dict_iter;
+	DBusMessageIter var_iter;
+	DBusMessageIter arr_iter;
+	const char *choices_key = "choices";
+
+	dbus_message_iter_open_container(p_iter, DBUS_TYPE_DICT_ENTRY, nullptr, &dict_iter);
+	dbus_message_iter_append_basic(&dict_iter, DBUS_TYPE_STRING, &choices_key);
+	dbus_message_iter_open_container(&dict_iter, DBUS_TYPE_VARIANT, "a(ssa(ss)s)", &var_iter);
+	dbus_message_iter_open_container(&var_iter, DBUS_TYPE_ARRAY, "(ss(ss)s)", &arr_iter);
+
+	for (int i = 0; i < p_options.size(); i++) {
+		const Dictionary &item = p_options[i];
+		if (!item.has("name") || !item.has("values") || !item.has("default")) {
+			continue;
+		}
+		const String &name = item["name"];
+		const Vector<String> &options = item["values"];
+		int default_idx = item["default"];
+
+		DBusMessageIter struct_iter;
+		DBusMessageIter array_iter;
+		DBusMessageIter array_struct_iter;
+		dbus_message_iter_open_container(&arr_iter, DBUS_TYPE_STRUCT, nullptr, &struct_iter);
+		append_dbus_string(&struct_iter, name); // ID.
+		append_dbus_string(&struct_iter, name); // User visible name.
+
+		dbus_message_iter_open_container(&struct_iter, DBUS_TYPE_ARRAY, "(ss)", &array_iter);
+		for (int j = 0; j < options.size(); j++) {
+			dbus_message_iter_open_container(&array_iter, DBUS_TYPE_STRUCT, nullptr, &array_struct_iter);
+			append_dbus_string(&array_struct_iter, itos(j));
+			append_dbus_string(&array_struct_iter, options[j]);
+			dbus_message_iter_close_container(&array_iter, &array_struct_iter);
+		}
+		dbus_message_iter_close_container(&struct_iter, &array_iter);
+		if (options.is_empty()) {
+			append_dbus_string(&struct_iter, (default_idx) ? "true" : "false"); // Default selection.
+		} else {
+			append_dbus_string(&struct_iter, itos(default_idx)); // Default selection.
+		}
+
+		dbus_message_iter_close_container(&arr_iter, &struct_iter);
+	}
+	dbus_message_iter_close_container(&var_iter, &arr_iter);
+	dbus_message_iter_close_container(&dict_iter, &var_iter);
+	dbus_message_iter_close_container(p_iter, &dict_iter);
+}
+
+void FreeDesktopPortalDesktop::append_dbus_dict_filters(DBusMessageIter *p_iter, const Vector<String> &p_filter_names, const Vector<String> &p_filter_exts) {
 	DBusMessageIter dict_iter;
 	DBusMessageIter var_iter;
 	DBusMessageIter arr_iter;
 	const char *filters_key = "filters";
 
+	ERR_FAIL_COND(p_filter_names.size() != p_filter_exts.size());
+
 	dbus_message_iter_open_container(p_iter, DBUS_TYPE_DICT_ENTRY, nullptr, &dict_iter);
 	dbus_message_iter_append_basic(&dict_iter, DBUS_TYPE_STRING, &filters_key);
 	dbus_message_iter_open_container(&dict_iter, DBUS_TYPE_VARIANT, "a(sa(us))", &var_iter);
 	dbus_message_iter_open_container(&var_iter, DBUS_TYPE_ARRAY, "(sa(us))", &arr_iter);
-	for (int i = 0; i < p_filters.size(); i++) {
-		Vector<String> tokens = p_filters[i].split(";");
-		if (tokens.size() == 2) {
-			DBusMessageIter struct_iter;
-			DBusMessageIter array_iter;
-			DBusMessageIter array_struct_iter;
-			dbus_message_iter_open_container(&arr_iter, DBUS_TYPE_STRUCT, nullptr, &struct_iter);
-			append_dbus_string(&struct_iter, tokens[0]);
-
-			dbus_message_iter_open_container(&struct_iter, DBUS_TYPE_ARRAY, "(us)", &array_iter);
+	for (int i = 0; i < p_filter_names.size(); i++) {
+		DBusMessageIter struct_iter;
+		DBusMessageIter array_iter;
+		DBusMessageIter array_struct_iter;
+		dbus_message_iter_open_container(&arr_iter, DBUS_TYPE_STRUCT, nullptr, &struct_iter);
+		append_dbus_string(&struct_iter, p_filter_names[i]);
+
+		dbus_message_iter_open_container(&struct_iter, DBUS_TYPE_ARRAY, "(us)", &array_iter);
+		const String &flt = p_filter_exts[i];
+		int filter_slice_count = flt.get_slice_count(",");
+		for (int j = 0; j < filter_slice_count; j++) {
 			dbus_message_iter_open_container(&array_iter, DBUS_TYPE_STRUCT, nullptr, &array_struct_iter);
+			String str = (flt.get_slice(",", j).strip_edges());
 			{
 				const unsigned nil = 0;
 				dbus_message_iter_append_basic(&array_struct_iter, DBUS_TYPE_UINT32, &nil);
 			}
-			append_dbus_string(&array_struct_iter, tokens[1]);
+			append_dbus_string(&array_struct_iter, str);
 			dbus_message_iter_close_container(&array_iter, &array_struct_iter);
-			dbus_message_iter_close_container(&struct_iter, &array_iter);
-			dbus_message_iter_close_container(&arr_iter, &struct_iter);
 		}
+		dbus_message_iter_close_container(&struct_iter, &array_iter);
+		dbus_message_iter_close_container(&arr_iter, &struct_iter);
 	}
 	dbus_message_iter_close_container(&var_iter, &arr_iter);
 	dbus_message_iter_close_container(&dict_iter, &var_iter);
@@ -219,7 +271,7 @@ void FreeDesktopPortalDesktop::append_dbus_dict_bool(DBusMessageIter *p_iter, co
 	dbus_message_iter_close_container(p_iter, &dict_iter);
 }
 
-bool FreeDesktopPortalDesktop::file_chooser_parse_response(DBusMessageIter *p_iter, bool &r_cancel, Vector<String> &r_urls) {
+bool FreeDesktopPortalDesktop::file_chooser_parse_response(DBusMessageIter *p_iter, const Vector<String> &p_names, bool &r_cancel, Vector<String> &r_urls, int &r_index, Dictionary &r_options) {
 	ERR_FAIL_COND_V(dbus_message_iter_get_arg_type(p_iter) != DBUS_TYPE_UINT32, false);
 
 	dbus_uint32_t resp_code;
@@ -243,7 +295,50 @@ bool FreeDesktopPortalDesktop::file_chooser_parse_response(DBusMessageIter *p_it
 
 				DBusMessageIter var_iter;
 				dbus_message_iter_recurse(&iter, &var_iter);
-				if (strcmp(key, "uris") == 0) {
+				if (strcmp(key, "current_filter") == 0) { // (sa(us))
+					if (dbus_message_iter_get_arg_type(&var_iter) == DBUS_TYPE_STRUCT) {
+						DBusMessageIter struct_iter;
+						dbus_message_iter_recurse(&var_iter, &struct_iter);
+						while (dbus_message_iter_get_arg_type(&struct_iter) == DBUS_TYPE_STRING) {
+							const char *value;
+							dbus_message_iter_get_basic(&struct_iter, &value);
+							String name = String::utf8(value);
+
+							r_index = p_names.find(name);
+							if (!dbus_message_iter_next(&struct_iter)) {
+								break;
+							}
+						}
+					}
+				} else if (strcmp(key, "choices") == 0) { // a(ss) {
+					if (dbus_message_iter_get_arg_type(&var_iter) == DBUS_TYPE_ARRAY) {
+						DBusMessageIter struct_iter;
+						dbus_message_iter_recurse(&var_iter, &struct_iter);
+						while (dbus_message_iter_get_arg_type(&struct_iter) == DBUS_TYPE_STRUCT) {
+							DBusMessageIter opt_iter;
+							dbus_message_iter_recurse(&struct_iter, &opt_iter);
+							const char *opt_key = nullptr;
+							dbus_message_iter_get_basic(&opt_iter, &opt_key);
+							String opt_skey = String::utf8(opt_key);
+
+							dbus_message_iter_next(&opt_iter);
+							const char *opt_val = nullptr;
+							dbus_message_iter_get_basic(&opt_iter, &opt_val);
+							String opt_sval = String::utf8(opt_val);
+							if (opt_sval == "true") {
+								r_options[opt_skey] = true;
+							} else if (opt_sval == "false") {
+								r_options[opt_skey] = false;
+							} else {
+								r_options[opt_skey] = opt_sval.to_int();
+							}
+
+							if (!dbus_message_iter_next(&struct_iter)) {
+								break;
+							}
+						}
+					}
+				} else if (strcmp(key, "uris") == 0) { // as
 					if (dbus_message_iter_get_arg_type(&var_iter) == DBUS_TYPE_ARRAY) {
 						DBusMessageIter uri_iter;
 						dbus_message_iter_recurse(&var_iter, &uri_iter);
@@ -266,17 +361,45 @@ bool FreeDesktopPortalDesktop::file_chooser_parse_response(DBusMessageIter *p_it
 	return true;
 }
 
-Error FreeDesktopPortalDesktop::file_dialog_show(const String &p_xid, const String &p_title, const String &p_current_directory, const String &p_filename, DisplayServer::FileDialogMode p_mode, const Vector<String> &p_filters, const Callable &p_callback) {
+Error FreeDesktopPortalDesktop::file_dialog_show(DisplayServer::WindowID p_window_id, const String &p_xid, const String &p_title, const String &p_current_directory, const String &p_root, const String &p_filename, DisplayServer::FileDialogMode p_mode, const Vector<String> &p_filters, const TypedArray<Dictionary> &p_options, const Callable &p_callback, bool p_options_in_cb) {
 	if (unsupported) {
 		return FAILED;
 	}
 
+	ERR_FAIL_INDEX_V(int(p_mode), DisplayServer::FILE_DIALOG_MODE_SAVE_MAX, FAILED);
+	ERR_FAIL_NULL_V(monitor_connection, FAILED);
+
+	Vector<String> filter_names;
+	Vector<String> filter_exts;
+	for (int i = 0; i < p_filters.size(); i++) {
+		Vector<String> tokens = p_filters[i].split(";");
+		if (tokens.size() >= 1) {
+			String flt = tokens[0].strip_edges();
+			if (!flt.is_empty()) {
+				if (tokens.size() == 2) {
+					filter_exts.push_back(flt);
+					filter_names.push_back(tokens[1]);
+				} else {
+					filter_exts.push_back(flt);
+					filter_names.push_back(flt);
+				}
+			}
+		}
+	}
+	if (filter_names.is_empty()) {
+		filter_exts.push_back("*.*");
+		filter_names.push_back(RTR("All Files"));
+	}
+
 	DBusError err;
 	dbus_error_init(&err);
 
 	// Open connection and add signal handler.
 	FileDialogData fd;
 	fd.callback = p_callback;
+	fd.prev_focus = p_window_id;
+	fd.filter_names = filter_names;
+	fd.opt_in_cb = p_options_in_cb;
 
 	CryptoCore::RandomGenerator rng;
 	ERR_FAIL_COND_V_MSG(rng.init(), FAILED, "Failed to initialize random number generator.");
@@ -284,39 +407,25 @@ Error FreeDesktopPortalDesktop::file_dialog_show(const String &p_xid, const Stri
 	Error rng_err = rng.get_random_bytes(uuid, 64);
 	ERR_FAIL_COND_V_MSG(rng_err, rng_err, "Failed to generate unique token.");
 
-	fd.connection = dbus_bus_get(DBUS_BUS_SESSION, &err);
-	if (dbus_error_is_set(&err)) {
-		ERR_PRINT(vformat("Failed to open DBus connection: %s", err.message));
-		dbus_error_free(&err);
-		unsupported = true;
-		return FAILED;
-	}
-
-	String dbus_unique_name = String::utf8(dbus_bus_get_unique_name(fd.connection));
+	String dbus_unique_name = String::utf8(dbus_bus_get_unique_name(monitor_connection));
 	String token = String::hex_encode_buffer(uuid, 64);
 	String path = vformat("/org/freedesktop/portal/desktop/request/%s/%s", dbus_unique_name.replace(".", "_").replace(":", ""), token);
 
-	fd.path = vformat("type='signal',sender='org.freedesktop.portal.Desktop',path='%s',interface='org.freedesktop.portal.Request',member='Response',destination='%s'", path, dbus_unique_name);
-	dbus_bus_add_match(fd.connection, fd.path.utf8().get_data(), &err);
+	fd.path = path;
+	fd.filter = vformat("type='signal',sender='org.freedesktop.portal.Desktop',path='%s',interface='org.freedesktop.portal.Request',member='Response',destination='%s'", path, dbus_unique_name);
+	dbus_bus_add_match(monitor_connection, fd.filter.utf8().get_data(), &err);
 	if (dbus_error_is_set(&err)) {
 		ERR_PRINT(vformat("Failed to add DBus match: %s", err.message));
 		dbus_error_free(&err);
-		dbus_connection_unref(fd.connection);
 		return FAILED;
 	}
 
 	// Generate FileChooser message.
 	const char *method = nullptr;
-	switch (p_mode) {
-		case DisplayServer::FILE_DIALOG_MODE_SAVE_FILE: {
-			method = "SaveFile";
-		} break;
-		case DisplayServer::FILE_DIALOG_MODE_OPEN_ANY:
-		case DisplayServer::FILE_DIALOG_MODE_OPEN_FILE:
-		case DisplayServer::FILE_DIALOG_MODE_OPEN_DIR:
-		case DisplayServer::FILE_DIALOG_MODE_OPEN_FILES: {
-			method = "OpenFile";
-		} break;
+	if (p_mode == DisplayServer::FILE_DIALOG_MODE_SAVE_FILE) {
+		method = "SaveFile";
+	} else {
+		method = "OpenFile";
 	}
 
 	DBusMessage *message = dbus_message_new_method_call(BUS_OBJECT_NAME, BUS_OBJECT_PATH, BUS_INTERFACE_FILE_CHOOSER, method);
@@ -333,7 +442,9 @@ Error FreeDesktopPortalDesktop::file_dialog_show(const String &p_xid, const Stri
 		append_dbus_dict_string(&arr_iter, "handle_token", token);
 		append_dbus_dict_bool(&arr_iter, "multiple", p_mode == DisplayServer::FILE_DIALOG_MODE_OPEN_FILES);
 		append_dbus_dict_bool(&arr_iter, "directory", p_mode == DisplayServer::FILE_DIALOG_MODE_OPEN_DIR);
-		append_dbus_dict_filters(&arr_iter, p_filters);
+		append_dbus_dict_filters(&arr_iter, filter_names, filter_exts);
+
+		append_dbus_dict_options(&arr_iter, p_options);
 		append_dbus_dict_string(&arr_iter, "current_folder", p_current_directory, true);
 		if (p_mode == DisplayServer::FILE_DIALOG_MODE_SAVE_FILE) {
 			append_dbus_dict_string(&arr_iter, "current_name", p_filename);
@@ -342,14 +453,13 @@ Error FreeDesktopPortalDesktop::file_dialog_show(const String &p_xid, const Stri
 		dbus_message_iter_close_container(&iter, &arr_iter);
 	}
 
-	DBusMessage *reply = dbus_connection_send_with_reply_and_block(fd.connection, message, DBUS_TIMEOUT_INFINITE, &err);
+	DBusMessage *reply = dbus_connection_send_with_reply_and_block(monitor_connection, message, DBUS_TIMEOUT_INFINITE, &err);
 	dbus_message_unref(message);
 
 	if (!reply || dbus_error_is_set(&err)) {
 		ERR_PRINT(vformat("Failed to send DBus message: %s", err.message));
 		dbus_error_free(&err);
-		dbus_bus_remove_match(fd.connection, fd.path.utf8().get_data(), &err);
-		dbus_connection_unref(fd.connection);
+		dbus_bus_remove_match(monitor_connection, fd.filter.utf8().get_data(), &err);
 		return FAILED;
 	}
 
@@ -361,19 +471,17 @@ Error FreeDesktopPortalDesktop::file_dialog_show(const String &p_xid, const Stri
 				const char *new_path = nullptr;
 				dbus_message_iter_get_basic(&iter, &new_path);
 				if (String::utf8(new_path) != path) {
-					dbus_bus_remove_match(fd.connection, fd.path.utf8().get_data(), &err);
+					dbus_bus_remove_match(monitor_connection, fd.filter.utf8().get_data(), &err);
 					if (dbus_error_is_set(&err)) {
 						ERR_PRINT(vformat("Failed to remove DBus match: %s", err.message));
 						dbus_error_free(&err);
-						dbus_connection_unref(fd.connection);
 						return FAILED;
 					}
-					fd.path = String::utf8(new_path);
-					dbus_bus_add_match(fd.connection, fd.path.utf8().get_data(), &err);
+					fd.filter = String::utf8(new_path);
+					dbus_bus_add_match(monitor_connection, fd.filter.utf8().get_data(), &err);
 					if (dbus_error_is_set(&err)) {
 						ERR_PRINT(vformat("Failed to add DBus match: %s", err.message));
 						dbus_error_free(&err);
-						dbus_connection_unref(fd.connection);
 						return FAILED;
 					}
 				}
@@ -388,59 +496,111 @@ Error FreeDesktopPortalDesktop::file_dialog_show(const String &p_xid, const Stri
 	return OK;
 }
 
-void FreeDesktopPortalDesktop::_thread_file_dialog_monitor(void *p_ud) {
+void FreeDesktopPortalDesktop::process_file_dialog_callbacks() {
+	MutexLock lock(file_dialog_mutex);
+	while (!pending_cbs.is_empty()) {
+		FileDialogCallback cb = pending_cbs.front()->get();
+		pending_cbs.pop_front();
+
+		if (cb.opt_in_cb) {
+			Variant ret;
+			Callable::CallError ce;
+			const Variant *args[4] = { &cb.status, &cb.files, &cb.index, &cb.options };
+
+			cb.callback.callp(args, 4, ret, ce);
+			if (ce.error != Callable::CallError::CALL_OK) {
+				ERR_PRINT(vformat("Failed to execute file dialog callback: %s.", Variant::get_callable_error_text(cb.callback, args, 4, ce)));
+			}
+		} else {
+			Variant ret;
+			Callable::CallError ce;
+			const Variant *args[3] = { &cb.status, &cb.files, &cb.index };
+
+			cb.callback.callp(args, 3, ret, ce);
+			if (ce.error != Callable::CallError::CALL_OK) {
+				ERR_PRINT(vformat("Failed to execute file dialog callback: %s.", Variant::get_callable_error_text(cb.callback, args, 3, ce)));
+			}
+		}
+	}
+}
+
+void FreeDesktopPortalDesktop::_thread_monitor(void *p_ud) {
 	FreeDesktopPortalDesktop *portal = (FreeDesktopPortalDesktop *)p_ud;
 
-	while (!portal->file_dialog_thread_abort.is_set()) {
-		{
-			MutexLock lock(portal->file_dialog_mutex);
-			for (int i = portal->file_dialogs.size() - 1; i >= 0; i--) {
-				bool remove = false;
-				{
-					FreeDesktopPortalDesktop::FileDialogData &fd = portal->file_dialogs.write[i];
-					if (fd.connection) {
-						while (true) {
-							DBusMessage *msg = dbus_connection_pop_message(fd.connection);
-							if (!msg) {
-								break;
-							} else if (dbus_message_is_signal(msg, "org.freedesktop.portal.Request", "Response")) {
-								DBusMessageIter iter;
-								if (dbus_message_iter_init(msg, &iter)) {
-									bool cancel = false;
-									Vector<String> uris;
-									file_chooser_parse_response(&iter, cancel, uris);
-
-									if (fd.callback.is_valid()) {
-										Variant v_status = !cancel;
-										Variant v_files = uris;
-										Variant *v_args[2] = { &v_status, &v_files };
-										fd.callback.call_deferredp((const Variant **)&v_args, 2);
-									}
+	while (!portal->monitor_thread_abort.is_set()) {
+		if (portal->monitor_connection) {
+			while (true) {
+				DBusMessage *msg = dbus_connection_pop_message(portal->monitor_connection);
+				if (!msg) {
+					break;
+				} else if (dbus_message_is_signal(msg, "org.freedesktop.portal.Settings", "SettingChanged")) {
+					DBusMessageIter iter;
+					if (dbus_message_iter_init(msg, &iter)) {
+						const char *value;
+						dbus_message_iter_get_basic(&iter, &value);
+						String name_space = String::utf8(value);
+						dbus_message_iter_next(&iter);
+						dbus_message_iter_get_basic(&iter, &value);
+						String key = String::utf8(value);
+
+						if (name_space == "org.freedesktop.appearance" && key == "color-scheme") {
+							callable_mp(portal, &FreeDesktopPortalDesktop::_system_theme_changed_callback).call_deferred();
+						}
+					}
+				} else if (dbus_message_is_signal(msg, "org.freedesktop.portal.Request", "Response")) {
+					String path = String::utf8(dbus_message_get_path(msg));
+					MutexLock lock(portal->file_dialog_mutex);
+					for (int i = 0; i < portal->file_dialogs.size(); i++) {
+						FreeDesktopPortalDesktop::FileDialogData &fd = portal->file_dialogs.write[i];
+						if (fd.path == path) {
+							DBusMessageIter iter;
+							if (dbus_message_iter_init(msg, &iter)) {
+								bool cancel = false;
+								Vector<String> uris;
+								Dictionary options;
+								int index = 0;
+								file_chooser_parse_response(&iter, fd.filter_names, cancel, uris, index, options);
+
+								if (fd.callback.is_valid()) {
+									FileDialogCallback cb;
+									cb.callback = fd.callback;
+									cb.status = !cancel;
+									cb.files = uris;
+									cb.index = index;
+									cb.options = options;
+									cb.opt_in_cb = fd.opt_in_cb;
+									portal->pending_cbs.push_back(cb);
+								}
+								if (fd.prev_focus != DisplayServer::INVALID_WINDOW_ID) {
+									callable_mp(DisplayServer::get_singleton(), &DisplayServer::window_move_to_foreground).call_deferred(fd.prev_focus);
 								}
-								dbus_message_unref(msg);
-
-								DBusError err;
-								dbus_error_init(&err);
-								dbus_bus_remove_match(fd.connection, fd.path.utf8().get_data(), &err);
-								dbus_error_free(&err);
-								dbus_connection_unref(fd.connection);
-								remove = true;
-								break;
 							}
-							dbus_message_unref(msg);
+
+							DBusError err;
+							dbus_error_init(&err);
+							dbus_bus_remove_match(portal->monitor_connection, fd.filter.utf8().get_data(), &err);
+							dbus_error_free(&err);
+
+							portal->file_dialogs.remove_at(i);
+							break;
 						}
-						dbus_connection_read_write(fd.connection, 0);
 					}
 				}
-				if (remove) {
-					portal->file_dialogs.remove_at(i);
-				}
+				dbus_message_unref(msg);
 			}
+			dbus_connection_read_write(portal->monitor_connection, 0);
 		}
+
 		usleep(50000);
 	}
 }
 
+void FreeDesktopPortalDesktop::_system_theme_changed_callback() {
+	if (system_theme_changed.is_valid()) {
+		system_theme_changed.call();
+	}
+}
+
 FreeDesktopPortalDesktop::FreeDesktopPortalDesktop() {
 #ifdef SOWRAP_ENABLED
 #ifdef DEBUG_ENABLED
@@ -469,25 +629,45 @@ FreeDesktopPortalDesktop::FreeDesktopPortalDesktop() {
 		unsupported = true;
 	}
 
+	DBusError err;
+	dbus_error_init(&err);
+	monitor_connection = dbus_bus_get(DBUS_BUS_SESSION, &err);
+	if (dbus_error_is_set(&err)) {
+		dbus_error_free(&err);
+	} else {
+		theme_path = "type='signal',sender='org.freedesktop.portal.Desktop',interface='org.freedesktop.portal.Settings',member='SettingChanged'";
+		dbus_bus_add_match(monitor_connection, theme_path.utf8().get_data(), &err);
+		if (dbus_error_is_set(&err)) {
+			dbus_error_free(&err);
+			dbus_connection_unref(monitor_connection);
+			monitor_connection = nullptr;
+		}
+		dbus_connection_read_write(monitor_connection, 0);
+	}
+
 	if (!unsupported) {
-		file_dialog_thread_abort.clear();
-		file_dialog_thread.start(FreeDesktopPortalDesktop::_thread_file_dialog_monitor, this);
+		monitor_thread_abort.clear();
+		monitor_thread.start(FreeDesktopPortalDesktop::_thread_monitor, this);
 	}
 }
 
 FreeDesktopPortalDesktop::~FreeDesktopPortalDesktop() {
-	file_dialog_thread_abort.set();
-	if (file_dialog_thread.is_started()) {
-		file_dialog_thread.wait_to_finish();
+	monitor_thread_abort.set();
+	if (monitor_thread.is_started()) {
+		monitor_thread.wait_to_finish();
 	}
-	for (FreeDesktopPortalDesktop::FileDialogData &fd : file_dialogs) {
-		if (fd.connection) {
-			DBusError err;
+
+	if (monitor_connection) {
+		DBusError err;
+		for (FreeDesktopPortalDesktop::FileDialogData &fd : file_dialogs) {
 			dbus_error_init(&err);
-			dbus_bus_remove_match(fd.connection, fd.path.utf8().get_data(), &err);
+			dbus_bus_remove_match(monitor_connection, fd.filter.utf8().get_data(), &err);
 			dbus_error_free(&err);
-			dbus_connection_unref(fd.connection);
 		}
+		dbus_error_init(&err);
+		dbus_bus_remove_match(monitor_connection, theme_path.utf8().get_data(), &err);
+		dbus_error_free(&err);
+		dbus_connection_unref(monitor_connection);
 	}
 }