#include <wlr/xwayland.h>

#define WLR_SURFACE(C)          (c->isxdg ? c->xdg_surface->surface : c->xwayland_surface->surface)

	struct wlr_xdg_surface *xdg_surface;

	union {
		struct wlr_xdg_surface *xdg_surface;
		struct wlr_xwayland_surface *xwayland_surface;
	};

	int isxdg;

static void createnotify(struct wl_listener *listener, void *data);

static void createnotifyxdg(struct wl_listener *listener, void *data);
static void createnotifyxwayland(struct wl_listener *listener, void *data);

static struct wlr_compositor *compositor;
static struct wlr_xwayland *xwayland;

static struct wl_listener new_xdg_surface = {.notify = createnotify};

static struct wl_listener new_xdg_surface = {.notify = createnotifyxdg};
static struct wl_listener new_xwayland_surface = {.notify = createnotifyxwayland};

	if (!(appid = c->xdg_surface->toplevel->app_id))
		appid = broken;
	if (!(title = c->xdg_surface->toplevel->title))
		title = broken;

	if (c->isxdg) {
		if (!(appid = c->xdg_surface->toplevel->app_id))
			appid = broken;
		if (!(title = c->xdg_surface->toplevel->title))
			title = broken;
	} else {
		if (!(title = c->xwayland_surface->title))
			title = broken;
	}

			surface = wlr_xdg_surface_surface_at(c->xdg_surface,
					cursor->x - c->geom.x - c->bw,
					cursor->y - c->geom.y - c->bw, NULL, NULL);

			if (c->isxdg)
				surface = wlr_xdg_surface_surface_at(c->xdg_surface,
						cursor->x - c->geom.x - c->bw,
						cursor->y - c->geom.y - c->bw, NULL, NULL);
			else
				surface = wlr_surface_surface_at(c->xwayland_surface->surface,
						cursor->x - c->geom.x - c->bw,
						cursor->y - c->geom.y - c->bw, NULL, NULL);

createnotify(struct wl_listener *listener, void *data)

createnotifyxdg(struct wl_listener *listener, void *data)

	c->isxdg = 1;

}
void
createnotifyxwayland(struct wl_listener *listener, void *data)
{
	struct wlr_xwayland_surface *xwayland_surface = data;
	Client *c;
	/* Allocate a Client for this surface */
	c = xwayland_surface->data = calloc(1, sizeof(*c));
	c->xwayland_surface = xwayland_surface;
	c->isxdg = 0;
	c->bw = borderpx;
	/* Listen to the various events it can emit */
	c->map.notify = maprequest;
	wl_signal_add(&xwayland_surface->events.map, &c->map);
	c->unmap.notify = unmapnotify;
	wl_signal_add(&xwayland_surface->events.unmap, &c->unmap);
	c->destroy.notify = destroynotify;
	wl_signal_add(&xwayland_surface->events.destroy, &c->destroy);

	struct wlr_xdg_surface *ptl = sel ? sel->xdg_surface : NULL;
	struct wlr_xdg_surface *tl = c ? c->xdg_surface : NULL;

	Client *ptl = sel;
	Client *tl = c;

			surface = c->xdg_surface->surface;

			surface = WLR_SURFACE(c);

	if (tl != ptl && ptl)
		wlr_xdg_toplevel_set_activated(ptl, 0);
	if (tl != ptl && tl)
		wlr_xdg_toplevel_set_activated(tl, 1);

	if (tl != ptl && ptl) {
		if (ptl->isxdg)
			wlr_xdg_toplevel_set_activated(ptl->xdg_surface, 0);
		else
			wlr_xwayland_surface_activate(ptl->xwayland_surface, 0);
	}
	if (tl != ptl && tl) {
		if (tl->isxdg)
			wlr_xdg_toplevel_set_activated(tl->xdg_surface, 1);
		else
			wlr_xwayland_surface_activate(tl->xwayland_surface, 1);
	}

	wlr_xdg_surface_get_geometry(c->xdg_surface, &c->geom);
	c->geom.width += 2 * c->bw;
	c->geom.height += 2 * c->bw;

	if (c->isxdg) {
		wlr_xdg_surface_get_geometry(c->xdg_surface, &c->geom);
		c->geom.width += 2 * c->bw;
		c->geom.height += 2 * c->bw;
	} else {
		c->geom.x = c->xwayland_surface->x;
		c->geom.y = c->xwayland_surface->y;
		c->geom.width = c->xwayland_surface->width + 2 * c->bw;
		c->geom.height = c->xwayland_surface->height + 2 * c->bw;
	}

	if ((c = xytoclient(cursor->x, cursor->y)))
		surface = wlr_xdg_surface_surface_at(c->xdg_surface,
				cursor->x - c->geom.x - c->bw,
				cursor->y - c->geom.y - c->bw, &sx, &sy);

	if ((c = xytoclient(cursor->x, cursor->y))) {
		if (c->isxdg)
			surface = wlr_xdg_surface_surface_at(c->xdg_surface,
					cursor->x - c->geom.x - c->bw,
					cursor->y - c->geom.y - c->bw, &sx, &sy);
		else
			surface = wlr_surface_surface_at(c->xwayland_surface->surface,
					cursor->x - c->geom.x - c->bw,
					cursor->y - c->geom.y - c->bw, &sx, &sy);
	}

		surface = c->xdg_surface->surface;

		surface = WLR_SURFACE(c);

	struct wlr_surface *surface;

		surface = WLR_SURFACE(c);

		w = c->xdg_surface->surface->current.width;
		h = c->xdg_surface->surface->current.height;

		w = surface->current.width;
		h = surface->current.height;

		rdata.y = c->geom.y + c->bw,
		wlr_xdg_surface_for_each_surface(c->xdg_surface, render, &rdata);

		rdata.y = c->geom.y + c->bw;
		if (c->isxdg)
			wlr_xdg_surface_for_each_surface(c->xdg_surface, render, &rdata);
		else
			wlr_surface_for_each_surface(c->xwayland_surface->surface, render, &rdata);

	wlr_xdg_toplevel_set_size(c->xdg_surface,
			c->geom.width - 2 * c->bw, c->geom.height - 2 * c->bw);

	if (c->isxdg)
		wlr_xdg_toplevel_set_size(c->xdg_surface,
				c->geom.width - 2 * c->bw, c->geom.height - 2 * c->bw);
	else
		wlr_xwayland_surface_configure(c->xwayland_surface,
				c->geom.x, c->geom.y,
				c->geom.width - 2 * c->bw, c->geom.height - 2 * c->bw);

	struct wlr_surface *surface = WLR_SURFACE(c);

		wlr_surface_send_leave(c->xdg_surface->surface, oldmon->wlr_output);

		wlr_surface_send_leave(surface, oldmon->wlr_output);

		wlr_surface_send_enter(c->xdg_surface->surface, m->wlr_output);

		wlr_surface_send_enter(surface, m->wlr_output);

	wlr_compositor_create(dpy, drw);

	compositor = wlr_compositor_create(dpy, drw);

	/*
	 * Initialise the XWayland X server.
	 * It will be started when the first X client is started.
	 */
	xwayland = wlr_xwayland_create(dpy, compositor, true);
	if (xwayland) {
		wl_signal_add(&xwayland->events.new_surface, &new_xwayland_surface);
		setenv("DISPLAY", xwayland->display_name, true);
	} else {
		fprintf(stderr, "failed to setup XWayland X server, continuing without it\n");
	}

	wlr_xwayland_destroy(xwayland);