struct dwl_output {
	struct wl_list link;
	struct wlr_output *wlr_output;
	struct wl_listener frame;
};

typedef union {
	int i;
	unsigned int ui;
	float f;
	const void *v;
} Arg;

struct dwl_view {

typedef struct {
	unsigned int mod;
	unsigned int button;
	void (*func)(const Arg *);
	const Arg arg;
} Button;
typedef struct {

};

} Client;
typedef struct {
	uint32_t mod;
	xkb_keysym_t keysym;
	void (*func)(const Arg *);
	const Arg arg;
} Key;

struct dwl_keyboard {

typedef struct {

};

} Keyboard;

typedef union {
	int i;
	unsigned int ui;
	float f;
	const void *v;
} Arg;

	uint32_t mod;
	xkb_keysym_t keysym;
	void (*func)(const Arg *);
	const Arg arg;
} Key;

	struct wl_list link;
	struct wlr_output *wlr_output;
	struct wl_listener frame;
} Monitor;

typedef struct {
	unsigned int mod;
	unsigned int button;
	void (*func)(const Arg *);
	const Arg arg;
} Button;

/* Used to move all of the data necessary to render a surface from the top-level
 * frame handler to the per-surface render function. */
struct render_data {
	struct wlr_output *output;
	Client *client;
	struct timespec *when;
};

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

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

static void focus(struct dwl_view *view, struct wlr_surface *surface);

static void focus(Client *c, struct wlr_surface *surface);

static void moveresize(struct dwl_view *view, unsigned int mode);

static void moveresize(Client *c, unsigned int mode);

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

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

static bool xytosurface(struct dwl_view *view, double lx, double ly,

static bool xytosurface(Client *c, double lx, double ly,

static struct dwl_view * xytoview(double lx, double ly,

static Client * xytoclient(double lx, double ly,

static struct wl_list views;

static struct wl_list clients;

static struct dwl_view *grabbed_view;

static Client *grabbed_client;

static struct wl_list outputs;

static struct wl_list mons;

/* Used to move all of the data necessary to render a surface from the top-level
 * frame handler to the per-surface render function. */
struct render_data {
	struct wlr_output *output;
	struct dwl_view *view;
	struct timespec *when;
};

	struct dwl_view *view = xytoview(cursor->x, cursor->y,

	Client *c = xytoclient(cursor->x, cursor->y,

		focus(view, surface);

		focus(c, surface);

	struct dwl_keyboard *keyboard = calloc(1, sizeof(*keyboard));

	Keyboard *keyboard = calloc(1, sizeof(*keyboard));

	/* Allocate a dwl_view for this surface */
	struct dwl_view *view = calloc(1, sizeof(*view));
	view->xdg_surface = xdg_surface;

	/* Allocate a Client for this surface */
	Client *c = calloc(1, sizeof(*c));
	c->xdg_surface = xdg_surface;

	view->map.notify = maprequest;
	wl_signal_add(&xdg_surface->events.map, &view->map);
	view->unmap.notify = unmapnotify;
	wl_signal_add(&xdg_surface->events.unmap, &view->unmap);
	view->destroy.notify = destroynotify;
	wl_signal_add(&xdg_surface->events.destroy, &view->destroy);

	c->map.notify = maprequest;
	wl_signal_add(&xdg_surface->events.map, &c->map);
	c->unmap.notify = unmapnotify;
	wl_signal_add(&xdg_surface->events.unmap, &c->unmap);
	c->destroy.notify = destroynotify;
	wl_signal_add(&xdg_surface->events.destroy, &c->destroy);

	/* Add it to the list of views. */
	wl_list_insert(&views, &view->link);

	/* Add it to the list of clients. */
	wl_list_insert(&clients, &c->link);

createoutput(struct wl_listener *listener, void *data)

createmon(struct wl_listener *listener, void *data)

	struct dwl_output *output = calloc(1, sizeof(*output));
	output->wlr_output = wlr_output;

	Monitor *m = calloc(1, sizeof(*m));
	m->wlr_output = wlr_output;

	output->frame.notify = renderoutput;
	wl_signal_add(&wlr_output->events.frame, &output->frame);
	wl_list_insert(&outputs, &output->link);

	m->frame.notify = rendermon;
	wl_signal_add(&wlr_output->events.frame, &m->frame);
	wl_list_insert(&mons, &m->link);

	struct dwl_view *view = wl_container_of(listener, view, destroy);
	wl_list_remove(&view->link);
	free(view);

	Client *c = wl_container_of(listener, c, destroy);
	wl_list_remove(&c->link);
	free(c);

focus(struct dwl_view *view, struct wlr_surface *surface)

focus(Client *c, struct wlr_surface *surface)

	if (view == NULL) {

	if (c == NULL) {

	/* Move the view to the front */
	wl_list_remove(&view->link);
	wl_list_insert(&views, &view->link);

	/* Move the client to the front */
	wl_list_remove(&c->link);
	wl_list_insert(&clients, &c->link);

	wlr_xdg_toplevel_set_activated(view->xdg_surface, true);

	wlr_xdg_toplevel_set_activated(c->xdg_surface, true);

	wlr_seat_keyboard_notify_enter(seat, view->xdg_surface->surface,

	wlr_seat_keyboard_notify_enter(seat, c->xdg_surface->surface,

	/* Cycle to the next view */
	if (wl_list_length(&views) < 2) {

	/* Cycle to the next client */
	if (wl_list_length(&clients) < 2) {

	struct dwl_view *current_view = wl_container_of(
		views.next, current_view, link);
	struct dwl_view *next_view = wl_container_of(
		current_view->link.next, next_view, link);
	focus(next_view, next_view->xdg_surface->surface);
	/* Move the previous view to the end of the list */
	wl_list_remove(&current_view->link);
	wl_list_insert(views.prev, &current_view->link);

	Client *c = wl_container_of(clients.next, c, link);
	Client *n = wl_container_of(c->link.next, n, link);
	focus(n, n->xdg_surface->surface);
	/* Move the previous client to the end of the list */
	wl_list_remove(&c->link);
	wl_list_insert(clients.prev, &c->link);

	/* Move the grabbed view to the new position. */
	grabbed_view->x = cursor->x - grab_x;
	grabbed_view->y = cursor->y - grab_y;

	/* Move the grabbed client to the new position. */
	grabbed_client->x = cursor->x - grab_x;
	grabbed_client->y = cursor->y - grab_y;

	wlr_xdg_toplevel_set_size(grabbed_view->xdg_surface,

	wlr_xdg_toplevel_set_size(grabbed_client->xdg_surface,

	struct dwl_keyboard *keyboard =

	Keyboard *keyboard =

	struct dwl_keyboard *keyboard =
		wl_container_of(listener, keyboard, modifiers);

	Keyboard *keyboard = wl_container_of(listener, keyboard, modifiers);

	struct dwl_view *view = wl_container_of(listener, view, map);
	view->mapped = true;
	focus(view, view->xdg_surface->surface);

	Client *c = wl_container_of(listener, c, map);
	c->mapped = true;
	focus(c, c->xdg_surface->surface);

	/* Otherwise, find the view under the pointer and send the event along. */

	/* Otherwise, find the client under the pointer and send the event along. */

	struct dwl_view *view = xytoview(cursor->x, cursor->y,

	Client *c = xytoclient(cursor->x, cursor->y,

	if (!view) {
		/* If there's no view under the cursor, set the cursor image to a

	if (!c) {
		/* If there's no client under the cursor, set the cursor image to a

		 * around the screen, not over any views. */

		 * around the screen, not over any clients. */

	struct dwl_view *view = xytoview(cursor->x, cursor->y,

	Client *c = xytoclient(cursor->x, cursor->y,

	if (!view) {

	if (!c) {

	moveresize(view, CurMove);

	moveresize(c, CurMove);

moveresize(struct dwl_view *view, unsigned int mode)

moveresize(Client *c, unsigned int mode)

	if (view->xdg_surface->surface != focused_surface) {

	if (c->xdg_surface->surface != focused_surface) {

	grabbed_view = view;

	grabbed_client = c;

	wlr_xdg_surface_get_geometry(view->xdg_surface, &geo_box);

	wlr_xdg_surface_get_geometry(c->xdg_surface, &geo_box);

		grab_x = cursor->x - view->x;
		grab_y = cursor->y - view->y;

		grab_x = cursor->x - c->x;
		grab_y = cursor->y - c->y;

	struct dwl_view *view = rdata->view;

	Client *c = rdata->client;

	/* The view has a position in layout coordinates. If you have two displays,
	 * one next to the other, both 1080p, a view on the rightmost display might

	/* The client has a position in layout coordinates. If you have two displays,
	 * one next to the other, both 1080p, a client on the rightmost display might

	ox += view->x + sx, oy += view->y + sy;

	ox += c->x + sx, oy += c->y + sy;

	 * in graphics programming. We need to prepare a matrix to render the view
	 * with. wlr_matrix_project_box is a helper which takes a box with a desired
	 * x, y coordinates, width and height, and an output geometry, then
	 * prepares an orthographic projection and multiplies the necessary

	 * in graphics programming. We need to prepare a matrix to render the
	 * client with. wlr_matrix_project_box is a helper which takes a box with
	 * a desired x, y coordinates, width and height, and an output geometry,
	 * then prepares an orthographic projection and multiplies the necessary

renderoutput(struct wl_listener *listener, void *data)

rendermon(struct wl_listener *listener, void *data)

	struct dwl_output *output =
		wl_container_of(listener, output, frame);

	Monitor *m = wl_container_of(listener, m, frame);

	if (!wlr_output_attach_render(output->wlr_output, NULL)) {

	if (!wlr_output_attach_render(m->wlr_output, NULL)) {

	wlr_output_effective_resolution(output->wlr_output, &width, &height);

	wlr_output_effective_resolution(m->wlr_output, &width, &height);

	 * our view list is ordered front-to-back, we iterate over it backwards. */
	struct dwl_view *view;
	wl_list_for_each_reverse(view, &views, link) {
		if (!view->mapped) {
			/* An unmapped view should not be rendered. */

	 * our client list is ordered front-to-back, we iterate over it backwards. */
	Client *c;
	wl_list_for_each_reverse(c, &clients, link) {
		if (!c->mapped) {
			/* An unmapped client should not be rendered. */

			.output = output->wlr_output,
			.view = view,

			.output = m->wlr_output,
			.client = c,

		wlr_xdg_surface_for_each_surface(view->xdg_surface,

		wlr_xdg_surface_for_each_surface(c->xdg_surface,

	wlr_output_render_software_cursors(output->wlr_output, NULL);

	wlr_output_render_software_cursors(m->wlr_output, NULL);

	wlr_output_commit(output->wlr_output);

	wlr_output_commit(m->wlr_output);

	struct dwl_view *view = xytoview(cursor->x, cursor->y,

	Client *c = xytoclient(cursor->x, cursor->y,

	if (!view) {

	if (!c) {

	wlr_xdg_surface_get_geometry(view->xdg_surface, &geo_box);

	wlr_xdg_surface_get_geometry(c->xdg_surface, &geo_box);

			view->x + geo_box.x + geo_box.width,
			view->y + geo_box.y + geo_box.height);
	moveresize(view, CurResize);

			c->x + geo_box.x + geo_box.width,
			c->y + geo_box.y + geo_box.height);
	moveresize(c, CurResize);

	struct dwl_view *view = wl_container_of(listener, view, unmap);
	view->mapped = false;

	Client *c = wl_container_of(listener, c, unmap);
	c->mapped = false;

xytosurface(struct dwl_view *view, double lx, double ly,

xytosurface(Client *c, double lx, double ly,

	double view_sx = lx - view->x;
	double view_sy = ly - view->y;

	double client_sx = lx - c->x;
	double client_sy = ly - c->y;

	struct wlr_surface_state *state = &view->xdg_surface->surface->current;

	struct wlr_surface_state *state = &c->xdg_surface->surface->current;

			view->xdg_surface, view_sx, view_sy, &_sx, &_sy);

			c->xdg_surface, client_sx, client_sy, &_sx, &_sy);

struct dwl_view *
xytoview(double lx, double ly,

Client *
xytoclient(double lx, double ly,

	 * cursor. This relies on views being ordered from top-to-bottom. */
	struct dwl_view *view;
	wl_list_for_each(view, &views, link) {
		if (xytosurface(view, lx, ly, surface, sx, sy)) {
			return view;

	 * cursor. This relies on clients being ordered from top-to-bottom. */
	Client *c;
	wl_list_for_each(c, &clients, link) {
		if (xytosurface(c, lx, ly, surface, sx, sy)) {
			return c;

	wl_list_init(&outputs);
	new_output.notify = createoutput;

	wl_list_init(&mons);
	new_output.notify = createmon;

	/* Set up our list of views and the xdg-shell. The xdg-shell is a Wayland

	/* Set up our list of clients and the xdg-shell. The xdg-shell is a Wayland

	wl_list_init(&views);

	wl_list_init(&clients);