types: add wlr_xdg_foreign_v1

Co-authored-by: Jason Francis <cycl0ps@tuta.io>

5 files changed, 486 insertions, 0 deletions

diff --git a/include/meson.build b/include/meson.build
index dbd81a05..a88cd653 100644
--- a/include/meson.build
+++ b/include/meson.build
@@ -9,6 +9,7 @@ if conf_data.get('WLR_HAS_XWAYLAND', 0) != 1
 endif
 if conf_data.get('WLR_HAS_XDG_FOREIGN', 0) != 1
 	exclude_files += [
+    'types/wlr_xdg_foreign_v1.h',
     'types/wlr_xdg_foreign_registry.h',
 	]
 endif
diff --git a/include/wlr/types/wlr_xdg_foreign_v1.h b/include/wlr/types/wlr_xdg_foreign_v1.h
new file mode 100644
index 00000000..d98c7231
--- /dev/null
+++ b/include/wlr/types/wlr_xdg_foreign_v1.h
@@ -0,0 +1,64 @@
+/*
+ * This an unstable interface of wlroots. No guarantees are made regarding the
+ * future consistency of this API.
+ */
+#ifndef WLR_USE_UNSTABLE
+#error "Add -DWLR_USE_UNSTABLE to enable unstable wlroots features"
+#endif
+
+#ifndef WLR_TYPES_WLR_XDG_FOREIGN_V1_H
+#define WLR_TYPES_WLR_XDG_FOREIGN_V1_H
+
+#include <wayland-server-core.h>
+#include <wlr/types/wlr_xdg_foreign_registry.h>
+
+struct wlr_xdg_foreign_v1 {
+	struct {
+		struct wl_global *global;
+		struct wl_list objects; // wlr_xdg_exported_v1::link or wlr_xdg_imported_v1::link
+	} exporter, importer;
+
+	struct wl_listener foreign_registry_destroy;
+	struct wl_listener display_destroy;
+
+	struct wlr_xdg_foreign_registry *registry;
+
+	struct {
+		struct wl_signal destroy;
+	} events;
+
+	void *data;
+};
+
+struct wlr_xdg_exported_v1 {
+	struct wlr_xdg_foreign_exported base;
+
+	struct wl_resource *resource;
+	struct wl_listener xdg_surface_destroy;
+
+	struct wl_list link; // wlr_xdg_foreign_v1::exporter::objects
+};
+
+struct wlr_xdg_imported_v1 {
+	struct wlr_xdg_foreign_exported *exported;
+	struct wl_listener exported_destroyed;
+
+	struct wl_resource *resource;
+	struct wl_list link; // wlr_xdg_foreign_v1::importer::objects
+	struct wl_list children;
+};
+
+struct wlr_xdg_imported_child_v1 {
+	struct wlr_xdg_imported_v1 *imported;
+	struct wlr_surface *surface;
+
+	struct wl_list link; // wlr_xdg_imported_v1::children
+
+	struct wl_listener xdg_surface_unmap;
+	struct wl_listener xdg_toplevel_set_parent;
+};
+
+struct wlr_xdg_foreign_v1 *wlr_xdg_foreign_v1_create(
+		struct wl_display *display, struct wlr_xdg_foreign_registry *registry);
+
+#endif
diff --git a/protocol/meson.build b/protocol/meson.build
index b9b74ca5..1d8709c2 100644
--- a/protocol/meson.build
+++ b/protocol/meson.build
@@ -27,6 +27,7 @@ protocols = {
 	'tablet-unstable-v2': wl_protocol_dir / 'unstable/tablet/tablet-unstable-v2.xml',
 	'text-input-unstable-v3': wl_protocol_dir / 'unstable/text-input/text-input-unstable-v3.xml',
 	'xdg-decoration-unstable-v1': wl_protocol_dir / 'unstable/xdg-decoration/xdg-decoration-unstable-v1.xml',
+	'xdg-foreign-unstable-v1': wl_protocol_dir / 'unstable/xdg-foreign/xdg-foreign-unstable-v1.xml',
 	'xdg-output-unstable-v1': wl_protocol_dir / 'unstable/xdg-output/xdg-output-unstable-v1.xml',
 	# Other protocols
 	'gtk-primary-selection': 'gtk-primary-selection.xml',
diff --git a/types/meson.build b/types/meson.build
index a2052b3a..4023c18e 100644
--- a/types/meson.build
+++ b/types/meson.build
@@ -69,6 +69,7 @@ wlr_files += files(
 
 if conf_data.get('WLR_HAS_XDG_FOREIGN', 0) == 1
 	wlr_files += files(
+		'wlr_xdg_foreign_v1.c',
 		'wlr_xdg_foreign_registry.c',
 	)
 endif
diff --git a/types/wlr_xdg_foreign_v1.c b/types/wlr_xdg_foreign_v1.c
new file mode 100644
index 00000000..2ed125af
--- /dev/null
+++ b/types/wlr_xdg_foreign_v1.c
@@ -0,0 +1,419 @@
+#define _POSIX_C_SOURCE 200809L
+
+#include <assert.h>
+#include <string.h>
+#include <stdlib.h>
+#include <wlr/types/wlr_xdg_foreign_v1.h>
+#include <wlr/types/wlr_xdg_shell.h>
+#include <wlr/util/log.h>
+#include "util/signal.h"
+#include "xdg-foreign-unstable-v1-protocol.h"
+
+#define FOREIGN_V1_VERSION 1
+
+static const struct zxdg_exported_v1_interface xdg_exported_impl;
+static const struct zxdg_imported_v1_interface xdg_imported_impl;
+static const struct zxdg_exporter_v1_interface xdg_exporter_impl;
+static const struct zxdg_importer_v1_interface xdg_importer_impl;
+
+static struct wlr_xdg_imported_v1 *xdg_imported_from_resource(
+		struct wl_resource *resource) {
+	assert(wl_resource_instance_of(resource, &zxdg_imported_v1_interface,
+		&xdg_imported_impl));
+	return wl_resource_get_user_data(resource);
+}
+
+static void xdg_imported_handle_destroy(struct wl_client *client,
+		struct wl_resource *resource) {
+	wl_resource_destroy(resource);
+}
+
+static bool verify_is_toplevel(struct wl_resource *client_resource,
+		struct wlr_surface *surface) {
+	if (wlr_surface_is_xdg_surface(surface)) {
+		struct wlr_xdg_surface *xdg_surface =
+			wlr_xdg_surface_from_wlr_surface(surface);
+		if (xdg_surface->role != WLR_XDG_SURFACE_ROLE_TOPLEVEL) {
+			wl_resource_post_error(client_resource, -1,
+					"surface must be an xdg_toplevel");
+			return false;
+		}
+	} else {
+		wl_resource_post_error(client_resource, -1,
+				"surface must be an xdg_surface");
+		return false;
+	}
+	return true;
+}
+
+static void destroy_imported_child(struct wlr_xdg_imported_child_v1 *child) {
+	wl_list_remove(&child->xdg_toplevel_set_parent.link);
+	wl_list_remove(&child->xdg_surface_unmap.link);
+	wl_list_remove(&child->link);
+	free(child);
+}
+
+static void handle_child_xdg_surface_unmap(
+		struct wl_listener *listener, void *data) {
+	struct wlr_xdg_imported_child_v1 *child =
+		wl_container_of(listener, child, xdg_surface_unmap);
+	destroy_imported_child(child);
+}
+
+static void handle_xdg_toplevel_set_parent(
+		struct wl_listener *listener, void *data) {
+	struct wlr_xdg_imported_child_v1 *child =
+		wl_container_of(listener, child, xdg_toplevel_set_parent);
+	destroy_imported_child(child);
+}
+
+static void xdg_imported_handle_set_parent_of(struct wl_client *client,
+		struct wl_resource *resource,
+		struct wl_resource *child_resource) {
+	struct wlr_xdg_imported_v1 *imported =
+		xdg_imported_from_resource(resource);
+	if (imported == NULL) {
+		return;
+	}
+	struct wlr_surface *wlr_surface = imported->exported->surface;
+	struct wlr_surface *wlr_surface_child =
+		wlr_surface_from_resource(child_resource);
+
+	if (!verify_is_toplevel(resource, wlr_surface_child)) {
+		return;
+	}
+	struct wlr_xdg_imported_child_v1 *child;
+	wl_list_for_each(child, &imported->children, link) {
+		if (child->surface == wlr_surface_child) {
+			return;
+		}
+	}
+
+	child = calloc(1, sizeof(struct wlr_xdg_imported_child_v1));
+	if (child == NULL) {
+		wl_client_post_no_memory(client);
+		return;
+	}
+	child->surface = wlr_surface_child;
+	child->xdg_surface_unmap.notify = handle_child_xdg_surface_unmap;
+	child->xdg_toplevel_set_parent.notify = handle_xdg_toplevel_set_parent;
+
+	struct wlr_xdg_surface *surface =
+		wlr_xdg_surface_from_wlr_surface(wlr_surface);
+	struct wlr_xdg_surface *surface_child =
+		wlr_xdg_surface_from_wlr_surface(wlr_surface_child);
+
+	wlr_xdg_toplevel_set_parent(surface_child, surface);
+	wl_signal_add(&surface_child->events.unmap,
+			&child->xdg_surface_unmap);
+	wl_signal_add(&surface_child->toplevel->events.set_parent,
+			&child->xdg_toplevel_set_parent);
+
+	wl_list_insert(&imported->children, &child->link);
+}
+
+static const struct zxdg_imported_v1_interface xdg_imported_impl = {
+	.destroy = xdg_imported_handle_destroy,
+	.set_parent_of = xdg_imported_handle_set_parent_of
+};
+
+static struct wlr_xdg_exported_v1 *xdg_exported_from_resource(
+		struct wl_resource *resource) {
+	assert(wl_resource_instance_of(resource, &zxdg_exported_v1_interface,
+		&xdg_exported_impl));
+	return wl_resource_get_user_data(resource);
+}
+
+static void xdg_exported_handle_destroy(struct wl_client *client,
+		struct wl_resource *resource) {
+	wl_resource_destroy(resource);
+}
+
+static const struct zxdg_exported_v1_interface xdg_exported_impl = {
+	.destroy = xdg_exported_handle_destroy
+};
+
+static void xdg_exporter_handle_destroy(struct wl_client *client,
+		struct wl_resource *resource) {
+	wl_resource_destroy(resource);
+}
+
+static struct wlr_xdg_foreign_v1 *xdg_foreign_from_exporter_resource(
+		struct wl_resource *resource) {
+	assert(wl_resource_instance_of(resource, &zxdg_exporter_v1_interface,
+		&xdg_exporter_impl));
+	return wl_resource_get_user_data(resource);
+}
+
+static void finish_imported(struct wlr_xdg_imported_v1 *imported) {
+	imported->exported = NULL;
+	struct wlr_xdg_imported_child_v1 *child, *child_tmp;
+	wl_list_for_each_safe(child, child_tmp, &imported->children, link) {
+		struct wlr_xdg_surface *xdg_child =
+			wlr_xdg_surface_from_wlr_surface(child->surface);
+		wlr_xdg_toplevel_set_parent(xdg_child, NULL);
+	}
+
+	wl_list_remove(&imported->exported_destroyed.link);
+	wl_list_init(&imported->exported_destroyed.link);
+
+	wl_list_remove(&imported->link);
+	wl_list_init(&imported->link);
+	free(imported);
+}
+
+static void finish_exported(struct wlr_xdg_exported_v1 *exported) {
+	wlr_xdg_foreign_exported_finish(&exported->base);
+
+	wl_list_remove(&exported->xdg_surface_destroy.link);
+	wl_list_remove(&exported->link);
+	free(exported);
+}
+
+static void xdg_exported_handle_resource_destroy(
+		struct wl_resource *resource) {
+	struct wlr_xdg_exported_v1 *exported =
+		xdg_exported_from_resource(resource);
+
+	if (exported) {
+		finish_exported(exported);
+	}
+}
+
+static void handle_xdg_surface_destroy(
+		struct wl_listener *listener, void *data) {
+	struct wlr_xdg_exported_v1 *exported =
+		wl_container_of(listener, exported, xdg_surface_destroy);
+
+	wl_resource_set_user_data(exported->resource, NULL);
+	finish_exported(exported);
+}
+
+static void xdg_exporter_handle_export(struct wl_client *wl_client,
+		struct wl_resource *client_resource,
+		uint32_t id,
+		struct wl_resource *surface_resource) {
+	struct wlr_xdg_foreign_v1 *foreign =
+		xdg_foreign_from_exporter_resource(client_resource);
+	struct wlr_surface *surface = wlr_surface_from_resource(surface_resource);
+
+	if (!verify_is_toplevel(client_resource, surface)) {
+		return;
+	}
+
+	struct wlr_xdg_exported_v1 *exported =
+		calloc(1, sizeof(struct wlr_xdg_exported_v1));
+	if (exported == NULL) {
+		wl_client_post_no_memory(wl_client);
+		return;
+	}
+
+	if (!wlr_xdg_foreign_exported_init(&exported->base, foreign->registry)) {
+		wl_client_post_no_memory(wl_client);
+		free(exported);
+		return;
+	}
+
+	exported->base.surface = surface;
+	exported->resource = wl_resource_create(wl_client, &zxdg_exported_v1_interface,
+		wl_resource_get_version(client_resource), id);
+	if (exported->resource == NULL) {
+		wlr_xdg_foreign_exported_finish(&exported->base);
+		wl_client_post_no_memory(wl_client);
+		free(exported);
+		return;
+	}
+
+	wl_resource_set_implementation(exported->resource, &xdg_exported_impl,
+			exported, xdg_exported_handle_resource_destroy);
+
+	wl_list_insert(&foreign->exporter.objects, &exported->link);
+
+	zxdg_exported_v1_send_handle(exported->resource, exported->base.handle);
+
+	exported->xdg_surface_destroy.notify = handle_xdg_surface_destroy;
+	struct wlr_xdg_surface *xdg_surface =
+		wlr_xdg_surface_from_wlr_surface(surface);
+	wl_signal_add(&xdg_surface->events.unmap, &exported->xdg_surface_destroy);
+}
+
+static const struct zxdg_exporter_v1_interface xdg_exporter_impl = {
+	.destroy = xdg_exporter_handle_destroy,
+	.export = xdg_exporter_handle_export
+};
+
+static void xdg_exporter_bind(struct wl_client *wl_client, void *data,
+		uint32_t version, uint32_t id) {
+	struct wlr_xdg_foreign_v1 *foreign = data;
+
+	struct wl_resource *exporter_resource =
+		wl_resource_create(wl_client, &zxdg_exporter_v1_interface, version, id);
+	if (exporter_resource == NULL) {
+		wl_client_post_no_memory(wl_client);
+		return;
+	}
+
+	wl_resource_set_implementation(exporter_resource, &xdg_exporter_impl,
+			foreign, NULL);
+}
+
+static struct wlr_xdg_foreign_v1 *xdg_foreign_from_importer_resource(
+		struct wl_resource *resource) {
+	assert(wl_resource_instance_of(resource, &zxdg_importer_v1_interface,
+		&xdg_importer_impl));
+	return wl_resource_get_user_data(resource);
+}
+
+static void xdg_importer_handle_destroy(struct wl_client *client,
+		struct wl_resource *resource) {
+	wl_resource_destroy(resource);
+}
+
+static void xdg_imported_handle_resource_destroy(
+		struct wl_resource *resource) {
+	struct wlr_xdg_imported_v1 *imported = xdg_imported_from_resource(resource);
+	if (!imported) {
+		return;
+	}
+
+	finish_imported(imported);
+}
+
+static void xdg_imported_handle_exported_destroy(struct wl_listener *listener,
+		void *data) {
+	struct wlr_xdg_imported_v1 *imported =
+		wl_container_of(listener, imported, exported_destroyed);
+	zxdg_imported_v1_send_destroyed(imported->resource);
+	finish_imported(imported);
+}
+
+static void xdg_importer_handle_import(struct wl_client *wl_client,
+				struct wl_resource *client_resource,
+				uint32_t id,
+				const char *handle) {
+	struct wlr_xdg_foreign_v1 *foreign =
+		xdg_foreign_from_importer_resource(client_resource);
+
+	struct wlr_xdg_imported_v1 *imported =
+		calloc(1, sizeof(struct wlr_xdg_imported_v1));
+	if (imported == NULL) {
+		wl_client_post_no_memory(wl_client);
+		return;
+	}
+
+	imported->exported = wlr_xdg_foreign_registry_find_by_handle(
+		foreign->registry, handle);
+	imported->resource = wl_resource_create(wl_client, &zxdg_imported_v1_interface,
+			wl_resource_get_version(client_resource), id);
+	if (imported->resource == NULL) {
+		wl_client_post_no_memory(wl_client);
+		free(imported);
+		return;
+	}
+
+	wl_resource_set_implementation(imported->resource, &xdg_imported_impl,
+			imported, xdg_imported_handle_resource_destroy);
+
+	if (imported->exported == NULL) {
+		wl_resource_set_user_data(imported->resource, NULL);
+		zxdg_imported_v1_send_destroyed(imported->resource);
+		free(imported);
+		return;
+	}
+
+	wl_list_init(&imported->children);
+	wl_list_insert(&foreign->importer.objects, &imported->link);
+
+	imported->exported_destroyed.notify = xdg_imported_handle_exported_destroy;
+	wl_signal_add(&imported->exported->events.destroy, &imported->exported_destroyed);
+}
+
+static const struct zxdg_importer_v1_interface xdg_importer_impl = {
+	.destroy = xdg_importer_handle_destroy,
+	.import = xdg_importer_handle_import
+};
+
+static void xdg_importer_bind(struct wl_client *wl_client, void *data,
+		uint32_t version, uint32_t id) {
+	struct wlr_xdg_foreign_v1 *foreign = data;
+
+	struct wl_resource *importer_resource =
+		wl_resource_create(wl_client, &zxdg_importer_v1_interface, version, id);
+
+	if (importer_resource == NULL) {
+		wl_client_post_no_memory(wl_client);
+		return;
+	}
+
+	wl_resource_set_implementation(importer_resource, &xdg_importer_impl,
+			foreign, NULL);
+}
+
+static void xdg_foreign_destroy(struct wlr_xdg_foreign_v1 *foreign) {
+	if (!foreign) {
+		return;
+	}
+
+	wlr_signal_emit_safe(&foreign->events.destroy, NULL);
+	wl_list_remove(&foreign->foreign_registry_destroy.link);
+	wl_list_remove(&foreign->display_destroy.link);
+
+	wl_global_destroy(foreign->exporter.global);
+	wl_global_destroy(foreign->importer.global);
+	free(foreign);
+}
+
+static void handle_display_destroy(struct wl_listener *listener, void *data) {
+	struct wlr_xdg_foreign_v1 *foreign =
+		wl_container_of(listener, foreign, display_destroy);
+	xdg_foreign_destroy(foreign);
+}
+
+static void handle_foreign_registry_destroy(struct wl_listener *listener,
+		void *data) {
+	struct wlr_xdg_foreign_v1 *foreign =
+		wl_container_of(listener, foreign, foreign_registry_destroy);
+	xdg_foreign_destroy(foreign);
+}
+
+struct wlr_xdg_foreign_v1 *wlr_xdg_foreign_v1_create(
+		struct wl_display *display, struct wlr_xdg_foreign_registry *registry) {
+	struct wlr_xdg_foreign_v1 *foreign = calloc(1,
+			sizeof(struct wlr_xdg_foreign_v1));
+	if (!foreign) {
+		return NULL;
+	}
+
+	foreign->exporter.global = wl_global_create(display,
+			&zxdg_exporter_v1_interface,
+			FOREIGN_V1_VERSION, foreign,
+			xdg_exporter_bind);
+	if (!foreign->exporter.global) {
+		free(foreign);
+		return NULL;
+	}
+
+	foreign->importer.global = wl_global_create(display,
+			&zxdg_importer_v1_interface,
+			FOREIGN_V1_VERSION, foreign,
+			xdg_importer_bind);
+	if (!foreign->importer.global) {
+		wl_global_destroy(foreign->exporter.global);
+		free(foreign);
+		return NULL;
+	}
+
+	foreign->registry = registry;
+
+	wl_signal_init(&foreign->events.destroy);
+	wl_list_init(&foreign->exporter.objects);
+	wl_list_init(&foreign->importer.objects);
+
+	foreign->display_destroy.notify = handle_display_destroy;
+	wl_display_add_destroy_listener(display, &foreign->display_destroy);
+
+	foreign->foreign_registry_destroy.notify = handle_foreign_registry_destroy;
+	wl_signal_add(&registry->events.destroy, &foreign->foreign_registry_destroy);
+
+	return foreign;
+}