#include <wlr/types/wlr_single_pixel_buffer_v1.h>
#include <wlr/types/wlr_subcompositor.h>

static void createpointer(struct wlr_pointer *pointer);

createpointer(struct wlr_pointer *pointer)
	for (r = monrules; r < END(monrules); r++) {
	wl_list_insert(&mons, &m->link);
	printstatus();
		if (!xdg_surface->popup->parent)
			return;
		LayerSurface *l = toplevel_from_popup(xdg_surface->popup);
		if (!l || !l->mon)
		/* Probably the check of `l` is useless, the only thing that can be NULL
		 * is its monitor */
	wlr_cursor_attach_input_device(cursor, &pointer->base);
}
void
destroydragicon(struct wl_listener *listener, void *data)
{
	struct wlr_drag_icon *icon = data;
	wlr_scene_node_destroy(icon->data);
	/* Focus enter isn't sent during drag, so refocus the focused node. */
	focusclient(selclient(), 1);
	motionnotify(0);
	wl_list_remove(&c->set_title.link);
		wl_list_remove(&c->set_hints.link);
#endif
	}
		wl_list_remove(&c->activate.link);
	if (c->type != XDGShell) {
		wl_list_remove(&c->configure.link);
#ifdef XWAYLAND
	wl_list_remove(&c->fullscreen.link);
			for (i = 0; i < 4; i++)
				wlr_scene_rect_set_color(c->border[i], focuscolor);
		/* Don't change border color if there is an exclusive focus or we are
		 * handling a drag operation */
		if (!exclusive_focus && !seat->drag)
		client_restack_surface(c);
		c->isurgent = 0;
	}
		wl_list_remove(&c->flink);
		wl_list_insert(&fstack, &c->flink);
		selmon = c->mon;
	if (c && !client_is_unmanaged(c)) {
	/* Put the new client atop the focus stack and select its monitor */
		return;
	if (c && client_surface(c) == old)
		Client *w = client_from_wlr_surface(old);
	checkidleinhibitor(NULL);
/* We probably should change the name of this, it sounds like
 * will focus the topmost client of this mon, when actually will
 * only return that client */
	arrange(selmon);
	int i;
#ifdef XWAYLAND
	/* Handle unmanaged clients first so we can return prior create borders */
#endif
	/* Insert this client into client lists. */
	wl_list_insert(&clients, &c->link);
	wl_list_insert(&fstack, &c->flink);
}
void
maximizenotify(struct wl_listener *listener, void *data)
{
	/* This event is raised when a client would like to maximize itself,
	 * typically because the user clicked on the maximize button on
	 * client-side decorations. dwl doesn't support maximization, but
	 * to conform to xdg-shell protocol we still must send a configure.
	 * wlr_xdg_surface_schedule_configure() is used to send an empty reply. */
	Client *c = wl_container_of(listener, c, maximize);
	wlr_xdg_surface_schedule_configure(c->surface.xdg);
	c->mon->un_map = 1;
	LayerSurface *l;
	/* Update drag icon's position if any */
	if (seat->drag && (icon = seat->drag->icon))
		wlr_scene_node_set_position(icon->data, cursor->x + icon->surface->sx,
				cursor->y + icon->surface->sy);
	}
		/* Update selmon (even while dragging a window) */
		if (sloppyfocus)
			selmon = xytomon(cursor->x, cursor->y);
		IDLE_NOTIFY_ACTIVITY;
	if (time) {
	/* time is 0 in internal calls meant to restore pointer focus. */
	struct wlr_drag_icon *icon;
	struct wlr_surface *surface = NULL;
	Client *c = NULL;
	double sx = 0, sy = 0;
}
void
	outputmgrapplyortest(config, 1);
}
void
outputmgrtest(struct wl_listener *listener, void *data)
{
	struct wlr_output_configuration_v1 *config = data;
	/* TODO: use a wrapper function? */
	updatemons(NULL, NULL);
		wlr_output_configuration_v1_send_failed(config);
	wlr_output_configuration_v1_destroy(config);
	else
		wlr_output_configuration_v1_send_succeeded(config);
	if (ok)
	}
		}
			ok &= wlr_output_commit(wlr_output);
		if (test) {
			ok &= wlr_output_test(wlr_output);
			wlr_output_rollback(wlr_output);
		} else {
apply_or_test:
		wlr_output_enable_adaptive_sync(wlr_output,
				config_head->state.adaptive_sync_enabled);
		wlr_output_set_transform(wlr_output, config_head->state.transform);
		wlr_output_set_scale(wlr_output, config_head->state.scale);
		/* Don't move monitors if position wouldn't change, this to avoid
		 * wlroots marking the output as manually configured */
		if (m->m.x != config_head->state.x || m->m.y != config_head->state.y)
			wlr_output_layout_move(output_layout, wlr_output,
					config_head->state.x, config_head->state.y);
			wlr_output_set_custom_mode(wlr_output,
					config_head->state.custom_mode.width,
					config_head->state.custom_mode.height,
					config_head->state.custom_mode.refresh);
		else
		if (config_head->state.mode)
			wlr_output_set_mode(wlr_output, config_head->state.mode);
		wlr_output_enable(wlr_output, config_head->state.enabled);
		if (!config_head->state.enabled)
			goto apply_or_test;
		Monitor *m = wlr_output->data;
		struct wlr_output *wlr_output = config_head->state.output;
	wl_list_for_each(config_head, &config->heads, link) {
	int ok = 1;
	struct wlr_output_configuration_head_v1 *config_head;
	/*
	 * Called when a client such as wlr-randr requests a change in output
	 * configuration.  This is only one way that the layout can be changed,
	 * so any Monitor information should be updated by updatemons() after an
	 * output_layout.change event, not here.
	 */
{
outputmgrapplyortest(struct wlr_output_configuration_v1 *config, int test)
void
}
	outputmgrapplyortest(config, 0);
outputmgrapply(struct wl_listener *listener, void *data)
{
	struct wlr_output_configuration_v1 *config = data;
	/* Let the client know that the mouse cursor has entered one
	 * of its surfaces, and make keyboard focus follow if desired.
	 * wlroots makes this a no-op if surface is already focused */
	clock_gettime(CLOCK_MONOTONIC, &now);
	client_set_bounds(c, geo.width, geo.height);
	c->geom = geo;
	struct wlr_box *bbox = interact ? &sgeom : &c->mon->w;
	if (c->fullscreen_bg)
		wlr_scene_rect_set_size(c->fullscreen_bg, c->geom.width, c->geom.height);
	wlr_scene_node_set_position(&c->border[3]->node, c->geom.width - c->bw, c->bw);
	wlr_scene_node_set_position(&c->border[2]->node, 0, c->bw);
	wlr_scene_rect_set_size(c->border[0], c->geom.width, c->bw);
	wlr_scene_rect_set_size(c->border[1], c->geom.width, c->bw);
	wlr_scene_rect_set_size(c->border[2], c->bw, c->geom.height - 2 * c->bw);
	wlr_scene_rect_set_size(c->border[3], c->bw, c->geom.height - 2 * c->bw);
	wlr_scene_node_set_position(&c->border[1]->node, 0, c->geom.height - c->bw);
	wlr_scene_node_set_position(&c->scene->node, c->geom.x, c->geom.y);
	wlr_scene_node_set_position(&c->scene_surface->node, c->bw, c->bw);
	/* Update scene-graph, including borders */
}
void
	c->resize = client_set_size(c, c->geom.width - 2 * c->bw,
			c->geom.height - 2 * c->bw);
	/* wlroots makes this a no-op if size hasn't changed */
	applybounds(c, bbox);
{
resize(Client *c, struct wlr_box geo, int interact)
requeststartdrag(struct wl_listener *listener, void *data)
{
	struct wlr_seat_request_start_drag_event *event = data;
	if (wlr_seat_validate_pointer_grab_serial(seat, event->origin,
			event->serial))
		wlr_seat_start_pointer_drag(seat, event->drag, event->serial);
	else
		wlr_data_source_destroy(event->drag->source);
}
void
}
void
	m->un_map = 0;
	wlr_scene_output_send_frame_done(m->scene_output, &now);
	/* Let clients know a frame has been rendered */
	if (!skip && !wlr_scene_output_commit(m->scene_output))
		return;
	 * this monitor. */
	/* Checking m->un_map for every client is not optimal but works */
	wl_list_for_each(c, &clients, link) {
		if ((c->resize && m->un_map) || (c->type == XDGShell
				&& (c->surface.xdg->pending.geometry.width !=
				c->surface.xdg->current.geometry.width
				|| c->surface.xdg->pending.geometry.height !=
				c->surface.xdg->current.geometry.height))) {
			/* Lie */
			wlr_surface_send_frame_done(client_surface(c), &now);
			skip = 1;
		}
	}
	/* Render if no XDG clients have an outstanding resize and are visible on
	/* Start the backend. This will enumerate outputs and inputs, become the DRM
	 * master, etc */
	if (!wlr_backend_start(backend))
		die("startup: backend_start");
	/* Now that the socket exists and the backend is started, run the startup command */
	wlr_xcursor_manager_set_cursor_image(cursor_mgr, cursor_image, cursor);
	 * cursor position, and set default cursor image */
	selmon = xytomon(cursor->x, cursor->y);
	/* TODO hack to get cursor to display in its initial location (100, 100)
	 * instead of (0, 0) and then jumping.  still may not be fully
	 * initialized, as the image/coordinates are not transformed for the
	 * monitor when displayed here */
	wlr_cursor_warp_closest(cursor, NULL, cursor->x, cursor->y);
	/* At this point the outputs are initialized, choose initial selmon based on
	printstatus();
	wl_display_run(dpy);
	wlr_scene_node_reparent(&c->scene->node, layers[c->isfloating ? LyrFloat : LyrTile]);
	printstatus();
		if (!c->fullscreen_bg) {
			c->fullscreen_bg = wlr_scene_rect_create(c->scene,
				c->geom.width, c->geom.height, fullscreen_bg);
			wlr_scene_node_lower_to_bottom(&c->fullscreen_bg->node);
		}
		/* The xdg-protocol specifies:
		 *
		 * If the fullscreened surface is not opaque, the compositor must make
		 * sure that other screen content not part of the same surface tree (made
		 * up of subsurfaces, popups or similarly coupled surfaces) are not
		 * visible below the fullscreened surface.
		 *
		 * For brevity we set a black background for all clients
		 */
		if (c->fullscreen_bg) {
			wlr_scene_node_destroy(&c->fullscreen_bg->node);
			c->fullscreen_bg = NULL;
		}
	}
	arrange(c->mon);
	printstatus();
}
void
		resize(c, c->prev, 0);
	} else {
		/* restore previous size instead of arrange for floating windows since
		 * client positions are set by the user and cannot be recalculated */
		resize(c, c->mon->m, 0);
	c->bw = fullscreen ? 0 : borderpx;
	client_set_fullscreen(c, fullscreen);
	if (fullscreen) {
		c->prev = c->geom;
	if (!c->mon)
		return;
setfullscreen(Client *c, int fullscreen)
{
	c->isfullscreen = fullscreen;
	if (!selmon)
		return;
	printstatus();
	arrange(selmon);
	if (oldmon == m)
		return;
}
void
}
void
setpsel(struct wl_listener *listener, void *data)
{
	/* This event is raised by the seat when a client wants to set the selection,
	 * usually when the user copies something. wlroots allows compositors to
	 * ignore such requests if they so choose, but in dwl we always honor
	 */
	struct wlr_seat_request_set_primary_selection_event *event = data;
	wlr_seat_set_primary_selection(seat, event->source, event->serial);
}
void
setsel(struct wl_listener *listener, void *data)
{
	/* This event is raised by the seat when a client wants to set the selection,
	 * usually when the user copies something. wlroots allows compositors to
	 * ignore such requests if they so choose, but in dwl we always honor
	 */
	struct wlr_seat_request_set_selection_event *event = data;
	wlr_seat_set_selection(seat, event->source, event->serial);
	focusclient(focustop(selmon), 1);
	}
		setfullscreen(c, c->isfullscreen); /* This will call arrange(c->mon) */
		c->tags = newtags ? newtags : m->tagset[m->seltags]; /* assign tags of target monitor */
		wlr_surface_send_enter(client_surface(c), m->wlr_output);
		resize(c, c->geom, 0);
	if (m) {
		/* Make sure window actually overlaps with the monitor */
		arrange(oldmon);
	}
		wlr_surface_send_leave(client_surface(c), oldmon->wlr_output);
	if (oldmon) {
	/* TODO leave/enter is not optimal but works */
	c->prev = c->geom;
	c->mon = m;
	Monitor *oldmon = c->mon;
{
setmon(Client *c, Monitor *m, unsigned int newtags)
}
void
	if (f < 0.1 || f > 0.9)
		return;
	selmon->mfact = f;
	f = arg->f < 1.0 ? arg->f + selmon->mfact : arg->f - 1.0;
		return;
	if (!arg || !selmon || !selmon->lt[selmon->sellt]->arrange)
	float f;
setmfact(const Arg *arg)
{
#ifdef XWAYLAND
	signal(SIGINT, quitsignal);
	signal(SIGTERM, quitsignal);
#else
	signal(SIGCHLD, SIG_IGN);
#endif
	layers[LyrDragIcon] = wlr_scene_tree_create(&scene->tree);
	layers[LyrBg] = wlr_scene_tree_create(&scene->tree);
	layers[LyrBottom] = wlr_scene_tree_create(&scene->tree);
	layers[LyrTile] = wlr_scene_tree_create(&scene->tree);
	layers[LyrFloat] = wlr_scene_tree_create(&scene->tree);
	layers[LyrTop] = wlr_scene_tree_create(&scene->tree);
	layers[LyrOverlay] = wlr_scene_tree_create(&scene->tree);
	/* Initialize the scene graph used to lay out windows */
	scene = wlr_scene_create();
	wlr_data_control_manager_v1_create(dpy);
	wlr_primary_selection_v1_device_manager_create(dpy);
	wlr_single_pixel_buffer_manager_v1_create(dpy);
	wlr_subcompositor_create(dpy);
	wlr_viewporter_create(dpy);
	wlr_gamma_control_manager_v1_create(dpy);
	wl_signal_add(&output_layout->events.change, &layout_change);
	wlr_xdg_output_manager_v1_create(dpy, output_layout);
	idle_inhibit_mgr = wlr_idle_inhibit_v1_create(dpy);
	wl_signal_add(&idle_inhibit_mgr->events.new_inhibitor, &idle_inhibitor_create);
	xdg_shell = wlr_xdg_shell_create(dpy, 4);
	layer_shell = wlr_layer_shell_v1_create(dpy);
	wl_signal_add(&layer_shell->events.new_surface, &new_layer_shell_surface);
	idle_notifier = wlr_idle_notifier_v1_create(dpy);
	idle = wlr_idle_create(dpy);
	input_inhibit_mgr = wlr_input_inhibit_manager_create(dpy);
	/* Use decoration protocols to negotiate server-side decorations */
	wlr_server_decoration_manager_set_default_mode(
			wlr_server_decoration_manager_create(dpy),
			WLR_SERVER_DECORATION_MANAGER_MODE_SERVER);
	wlr_xdg_decoration_manager_v1_create(dpy);
	wl_signal_add(&seat->events.request_start_drag, &request_start_drag);
	wl_signal_add(&seat->events.start_drag, &start_drag);
#endif
	wl_signal_add(&drag->icon->events.destroy, &drag_icon_destroy);
	motionnotify(0);
	drag->icon->data = wlr_scene_subsurface_tree_create(layers[LyrDragIcon], drag->icon->surface);
	if (!drag->icon)
		return;
}
void
startdrag(struct wl_listener *listener, void *data)
{
	struct wlr_drag *drag = data;
togglefullscreen(const Arg *arg)
{
	Client *sel = selclient();
	if (sel)
		setfullscreen(sel, !sel->isfullscreen);
}
void
	printstatus();
	if (layersurface->layer_surface->output
			&& (layersurface->mon = layersurface->layer_surface->output->data))
		arrangelayers(layersurface->mon);
	if (layersurface == exclusive_focus)
		exclusive_focus = NULL;
	LayerSurface *layersurface = wl_container_of(listener, layersurface, unmap);
	layersurface->mapped = 0;
	wlr_scene_node_set_enabled(&layersurface->scene->node, 0);
}
void
	motionnotify(0);
		focusclient(selclient(), 1);
	if (layersurface->layer_surface->surface ==
			seat->keyboard_state.focused_surface)
{
unmaplayersurfacenotify(struct wl_listener *listener, void *data)
}
void
	printstatus();
	}
		arrange(selmon);
		focusclient(focustop(selmon), 1);
	if (newtagset) {
		selmon->tagset[selmon->seltags] = newtagset;
	unsigned int newtagset = selmon ? selmon->tagset[selmon->seltags] ^ (arg->ui & TAGMASK) : 0;
}
void
toggleview(const Arg *arg)
{
	}
		arrange(selmon);
		focusclient(focustop(selmon), 1);
	if (newtags) {
		sel->tags = newtags;
	newtags = sel->tags ^ (arg->ui & TAGMASK);
	Client *sel = selclient();
	if (!sel)
		return;
	unsigned int newtags;
toggletag(const Arg *arg)
{
}
void
	if (sel && !sel->isfullscreen)
		setfloating(sel, !sel->isfloating);
	/* return if fullscreen */
togglefloating(const Arg *arg)
{
	Client *sel = selclient();
	motionnotify(0);
	struct wlr_output_configuration_head_v1 *config_head;
	Client *c;
	struct wlr_output_configuration_v1 *config =
		wlr_output_configuration_v1_create();
	/*
	 * Called whenever the output layout changes: adding or removing a
	 * monitor, changing an output's mode or position, etc.  This is where
	 * the change officially happens and we update geometry, window
	 * positions, focus, and the stored configuration in wlroots'
	 * output-manager implementation.
	 */
	/* First remove from the layout the disabled monitors */
	wl_list_for_each(m, &mons, link) {
		if (m->wlr_output->enabled)
			continue;
		config_head = wlr_output_configuration_head_v1_create(config, m->wlr_output);
		config_head->state.enabled = 0;
		/* Remove this output from the layout to avoid cursor enter inside it */
		wlr_output_layout_remove(output_layout, m->wlr_output);
		closemon(m);
		memset(&m->m, 0, sizeof(m->m));
		memset(&m->w, 0, sizeof(m->w));
	}
	/* Insert outputs that need to */
	wl_list_for_each(m, &mons, link)
		if (m->wlr_output->enabled
				&& !wlr_output_layout_get(output_layout, m->wlr_output))
			wlr_output_layout_add_auto(output_layout, m->wlr_output);
	/* Now that we update the output layout we can get its box */
		if (!m->wlr_output->enabled)
			continue;
		config_head = wlr_output_configuration_head_v1_create(config, m->wlr_output);
		wlr_scene_output_set_position(m->scene_output, m->m.x, m->m.y);
		config_head->state.mode = m->wlr_output->current_mode;
		config_head->state.x = m->m.x;
		config_head->state.y = m->m.y;
		config_head->state.enabled = 1;
		c->isurgent = 1;
		printstatus();
	}
}
void
	if (c && c != selclient()) {
	Client *c = client_from_wlr_surface(event->surface);
urgent(struct wl_listener *listener, void *data)
{
	struct wlr_xdg_activation_v1_request_activate_event *event = data;
updatetitle(struct wl_listener *listener, void *data)
{
	Client *c = wl_container_of(listener, c, set_title);
	if (c == focustop(c->mon))
		printstatus();
}
void
}
void
	wlr_output_manager_v1_set_configuration(output_mgr, config);
	if (selmon && selmon->wlr_output->enabled)
		wl_list_for_each(c, &clients, link)
			if (!c->mon && client_is_mapped(c))
				setmon(c, selmon, c->tags);
	}
		/* Calculate the effective monitor geometry to use for clients */
		arrangelayers(m);
		/* Don't move clients to the left output when plugging monitors */
		arrange(m);
		wlr_output_layout_get_box(output_layout, m->wlr_output, &(m->m));
		wlr_output_layout_get_box(output_layout, m->wlr_output, &(m->w));
		/* Get the effective monitor geometry to use for surfaces */
	wl_list_for_each(m, &mons, link) {
	wlr_output_layout_get_box(output_layout, NULL, &sgeom);
	Monitor *m;
{
updatemons(struct wl_listener *listener, void *data)
	printstatus();
	int focus_order[] = { LyrOverlay, LyrTop, LyrFloat, LyrTile, LyrBottom, LyrBg };
	const int *layer;
	/* TODO: why we unset fullscreen when a xwayland client is created? */
}
#endif
	xcb_disconnect(xc);
	if ((xcursor = wlr_xcursor_manager_get_xcursor(cursor_mgr, "left_ptr", 1)))
		wlr_xwayland_set_cursor(xwayland,
				xcursor->images[0]->buffer, xcursor->images[0]->width * 4,
				xcursor->images[0]->width, xcursor->images[0]->height,
				xcursor->images[0]->hotspot_x, xcursor->images[0]->hotspot_y);
	/* Set the default XWayland cursor to match the rest of dwl. */
	/* assign the one and only seat */
	wlr_xwayland_set_seat(xwayland, seat);
	netatom[NetWMWindowTypeToolbar] = getatom(xc, "_NET_WM_WINDOW_TYPE_TOOLBAR");
	netatom[NetWMWindowTypeUtility] = getatom(xc, "_NET_WM_WINDOW_TYPE_UTILITY");
	xcb_connection_t *xc = xcb_connect(xwayland->display_name, NULL);
	int err = xcb_connection_has_error(xc);
	if (err) {
		fprintf(stderr, "xcb_connect to X server failed with code %d\n. Continuing with degraded functionality.\n", err);
		return;
	}
	/* Collect atoms we are interested in.  If getatom returns 0, we will
	 * not detect that window type. */
	netatom[NetWMWindowTypeDialog] = getatom(xc, "_NET_WM_WINDOW_TYPE_DIALOG");
	netatom[NetWMWindowTypeSplash] = getatom(xc, "_NET_WM_WINDOW_TYPE_SPLASH");
	struct wlr_xcursor *xcursor;
xwaylandready(struct wl_listener *listener, void *data)
{
		else if (c == 'v')
			die("dwl " VERSION);
	wlr_layer_surface->data = layersurface;
	wlr_layer_surface->current = old_state;
	arrangelayers(layersurface->mon);
	layersurface->mapped = 1;
			&layersurface->link);
	/* Temporarily set the layer's current state to pending
	 * so that we can easily arrange it
	 */
	old_state = wlr_layer_surface->current;
	wlr_layer_surface->current = wlr_layer_surface->pending;
	wl_list_insert(&layersurface->mon->layers[wlr_layer_surface->pending.layer],
	layersurface->scene->node.data = layersurface;
	layersurface->scene = layersurface->scene_layer->tree;
	layersurface->popups = wlr_layer_surface->surface->data =
			&wlr_scene_tree_create(layers[wlr_layer_surface->pending.layer])->node;
	layersurface->scene_layer = wlr_scene_layer_surface_v1_create(
			layers[wlr_layer_surface->pending.layer], wlr_layer_surface);
	layersurface->mon = wlr_layer_surface->output->data;
	LISTEN(&wlr_layer_surface->events.destroy, &layersurface->destroy,
			destroylayersurfacenotify);
	LISTEN(&wlr_layer_surface->events.map, &layersurface->map,
			maplayersurfacenotify);
	LISTEN(&wlr_layer_surface->events.unmap, &layersurface->unmap,
			unmaplayersurfacenotify);
	layersurface->layer_surface = wlr_layer_surface;
			&layersurface->surface_commit, commitlayersurfacenotify);
	layersurface = ecalloc(1, sizeof(LayerSurface));
	layersurface->type = LayerShell;
	LISTEN(&wlr_layer_surface->surface->events.commit,
		wlr_layer_surface->output = selmon ? selmon->wlr_output : NULL;
	if (!wlr_layer_surface->output)
		wlr_layer_surface_v1_destroy(wlr_layer_surface);
	if (!wlr_layer_surface->output)
	struct wlr_layer_surface_v1_state old_state;
}
void
createlayersurface(struct wl_listener *listener, void *data)
{
	struct wlr_layer_surface_v1 *wlr_layer_surface = data;
	LayerSurface *layersurface;
	size_t i;
	wlr_output_init_render(wlr_output, alloc, drw);
	m->wlr_output = wlr_output;
	Monitor *m = wlr_output->data = ecalloc(1, sizeof(*m));
	const MonitorRule *r;
	struct wlr_output *wlr_output = data;
	 * monitor) becomes available. */
	/* This event is raised by the backend when a new output (aka a display or
{
createmon(struct wl_listener *listener, void *data)
}
void
	wl_list_insert(&keyboards, &kb->link);
	/* And add the keyboard to our list of keyboards */
	wlr_seat_set_keyboard(seat, keyboard);
	LISTEN(&keyboard->events.modifiers, &kb->modifiers, keypressmod);
	LISTEN(&keyboard->events.key, &kb->key, keypress);
	LISTEN(&keyboard->base.events.destroy, &kb->destroy, cleanupkeyboard);
	/* Here we set up listeners for keyboard events. */
	wlr_keyboard_set_repeat_info(keyboard, repeat_rate, repeat_delay);
	xkb_keymap_unref(keymap);
	xkb_context_unref(context);
	wlr_keyboard_set_keymap(keyboard, keymap);
		XKB_KEYMAP_COMPILE_NO_FLAGS);
	keymap = xkb_keymap_new_from_names(context, &xkb_rules,
	context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
	/* Prepare an XKB keymap and assign it to the keyboard. */
	kb->wlr_keyboard = keyboard;
	Keyboard *kb = keyboard->data = ecalloc(1, sizeof(*kb));
	struct xkb_context *context;
	struct xkb_keymap *keymap;
{
}
	die("Usage: %s [-v] [-s startup command]", argv[0]);
usage:
	return EXIT_SUCCESS;
	cleanup();
	setup();
	run(startup_cmd);
		die("XDG_RUNTIME_DIR must be set");
	if (!getenv("XDG_RUNTIME_DIR"))
	/* Wayland requires XDG_RUNTIME_DIR for creating its communications socket */
	if (optind < argc)
		goto usage;
	}
			goto usage;
		else
			startup_cmd = optarg;
		if (c == 's')
	while ((c = getopt(argc, argv, "s:hv")) != -1) {
	int c;
	char *startup_cmd = NULL;
int
main(int argc, char *argv[])
{
}
void
	/* WNOWAIT leaves the child in a waitable state, in case this is the
	 * XWayland process
	 */
	while (!waitid(P_ALL, 0, &in, WEXITED|WNOHANG|WNOWAIT) && in.si_pid
			&& in.si_pid != xwayland->server->pid)
		waitpid(in.si_pid, NULL, 0);
		die("can't install SIGCHLD handler:");
}
void
sigchld(int unused)
{
	siginfo_t in;
	/* We should be able to remove this function in favor of a simple
	 *     signal(SIGCHLD, SIG_IGN);
	 * but the Xwayland implementation in wlroots currently prevents us from
	 * setting our own disposition for SIGCHLD.
	 */
	if (signal(SIGCHLD, sigchld) == SIG_ERR)
}
void
sethints(struct wl_listener *listener, void *data)
{
	Client *c = wl_container_of(listener, c, set_hints);
	if (c != selclient()) {
		c->isurgent = xcb_icccm_wm_hints_get_urgency(c->surface.xwayland->hints);
		printstatus();
	}
	if ((reply = xcb_intern_atom_reply(xc, cookie, NULL)))
		atom = reply->atom;
	free(reply);
	return atom;
	xcb_intern_atom_cookie_t cookie = xcb_intern_atom(xc, 0, strlen(name), name);
	xcb_intern_atom_reply_t *reply;
}
Atom
getatom(xcb_connection_t *xc, const char *name)
{
	Atom atom = 0;
	LISTEN(&xwayland_surface->events.destroy, &c->destroy, destroynotify);
	LISTEN(&xwayland_surface->events.request_fullscreen, &c->fullscreen,
			fullscreennotify);
	LISTEN(&xwayland_surface->events.set_title, &c->set_title, updatetitle);
	LISTEN(&xwayland_surface->events.set_hints, &c->set_hints, sethints);
	LISTEN(&xwayland_surface->events.request_configure, &c->configure,
			configurex11);
	LISTEN(&xwayland_surface->events.request_activate, &c->activate, activatex11);
	LISTEN(&xwayland_surface->events.map, &c->map, mapnotify);
	LISTEN(&xwayland_surface->events.unmap, &c->unmap, unmapnotify);
	/* Listen to the various events it can emit */
	c->surface.xwayland = xwayland_surface;
	c->type = xwayland_surface->override_redirect ? X11Unmanaged : X11Managed;
	c->bw = borderpx;
	c = xwayland_surface->data = ecalloc(1, sizeof(*c));
	/* Allocate a Client for this surface */
			setfullscreen(c, 0);
	wl_list_for_each(c, &clients, link)
		if (c->isfullscreen && VISIBLEON(c, c->mon))
	Client *c;
	struct wlr_xwayland_surface *xwayland_surface = data;
createnotifyx11(struct wl_listener *listener, void *data)
{
}
void
	struct wlr_xwayland_surface_configure_event *event = data;
	wlr_xwayland_surface_configure(c->surface.xwayland,
			event->x, event->y, event->width, event->height);
configurex11(struct wl_listener *listener, void *data)
{
	Client *c = wl_container_of(listener, c, configure);
}
void
	/* Only "managed" windows can be activated */
	if (c->type == X11Managed)
		wlr_xwayland_surface_activate(c->surface.xwayland, 1);
	Client *c = wl_container_of(listener, c, activate);
}
#ifdef XWAYLAND
void
activatex11(struct wl_listener *listener, void *data)
{
	arrange(selmon);
	focusclient(sel, 1);
	wl_list_remove(&sel->link);
	wl_list_insert(&clients, &sel->link);
	/* If we passed sel, move c to the front; otherwise, move sel to the
	 * front */
	if (!sel)
		sel = c;
		return;
	/* Return if no other tiled window was found */
	if (&c->link == &clients)
		}
			sel = NULL;
				break;
			if (c != sel)
	wl_list_for_each(c, &clients, link)
		if (VISIBLEON(c, selmon) && !c->isfloating) {
	/* Search for the first tiled window that is not sel, marking sel as
	 * NULL if we pass it along the way */
		return;
	if (!sel || !selmon || !selmon->lt[selmon->sellt]->arrange || sel->isfloating)
	Client *c, *sel = selclient();
void
zoom(const Arg *arg)
{
}
	if (psurface) *psurface = surface;
	if (pc) *pc = c;
	if (pl) *pl = l;
	return node;
	}
		if (surface)
			break;
		}
				c = pnode->data;
			if (c && c->type == LayerShell) {
				c = NULL;
				l = pnode->data;
			}
			for (pnode = node; pnode && !c; pnode = &pnode->parent->node)
			/* Walk the tree to find a node that knows the client */
			if (node->type == WLR_SCENE_NODE_BUFFER)
				surface = wlr_scene_surface_from_buffer(
						wlr_scene_buffer_from_node(node))->surface;
		if ((node = wlr_scene_node_at(&layers[*layer]->node, x, y, nx, ny))) {
	for (layer = focus_order; layer < END(focus_order); layer++) {
	struct wlr_scene_node *node, *pnode;
	struct wlr_surface *surface = NULL;
	Client *c = NULL;
	LayerSurface *l = NULL;
{
struct wlr_scene_node *
xytonode(double x, double y, struct wlr_surface **psurface,
		Client **pc, LayerSurface **pl, double *nx, double *ny)
Monitor *
xytomon(double x, double y)
{
	struct wlr_output *o = wlr_output_layout_output_at(output_layout, x, y);
	return o ? o->data : NULL;
}
}
	createkeyboard(&keyboard->keyboard);
void
virtualkeyboard(struct wl_listener *listener, void *data)
{
	struct wlr_virtual_keyboard_v1 *keyboard = data;
}
	arrange(selmon);
	focusclient(focustop(selmon), 1);
		return;
	selmon->seltags ^= 1; /* toggle sel tagset */
	if (arg->ui & TAGMASK)
		selmon->tagset[selmon->seltags] = arg->ui & TAGMASK;
	if (!selmon || (arg->ui & TAGMASK) == selmon->tagset[selmon->seltags])
view(const Arg *arg)
{
}
void
	printstatus();
	wlr_scene_node_destroy(&c->scene->node);
	wl_list_remove(&c->commit.link);
	if (client_is_unmanaged(c)) {
		if (c == exclusive_focus)
			exclusive_focus = NULL;
		if (client_surface(c) == seat->keyboard_state.focused_surface)
			focusclient(selclient(), 1);
	} else {
		wl_list_remove(&c->link);
		setmon(c, NULL, 0);
		wl_list_remove(&c->flink);
	}
	if (c->mon)
		c->mon->un_map = 1;
	if (c == grabc) {
		cursor_mode = CurNormal;
		grabc = NULL;
	}
unmapnotify(struct wl_listener *listener, void *data)
{
	/* Called when the surface is unmapped, and should no longer be shown. */
	Client *c = wl_container_of(listener, c, unmap);
		}
		i++;
	}
}
void
			ty += c->geom.height;
			resize(c, (struct wlr_box){.x = m->w.x + mw, .y = m->w.y + ty,
				.width = m->w.width - mw, .height = (m->w.height - ty) / (n - i)}, 0);
		} else {
			my += c->geom.height;
			resize(c, (struct wlr_box){.x = m->w.x, .y = m->w.y + my, .width = mw,
				.height = (m->w.height - my) / (MIN(n, m->nmaster) - i)}, 0);
		if (i < m->nmaster) {
			continue;
		if (!VISIBLEON(c, m) || c->isfloating || c->isfullscreen)
	i = my = ty = 0;
	wl_list_for_each(c, &clients, link) {
		mw = m->w.width;
	else
		mw = m->nmaster ? m->w.width * m->mfact : 0;
	if (n == 0)
		return;
	if (n > m->nmaster)
			n++;
		if (VISIBLEON(c, m) && !c->isfloating && !c->isfullscreen)
	wl_list_for_each(c, &clients, link)
	Client *c;
	unsigned int i, n = 0, mw, my, ty;
tile(Monitor *m)
{
}
void
	if (sel)
		setmon(sel, dirtomon(arg->i), 0);
tagmon(const Arg *arg)
{
	Client *sel = selclient();
void
}
	printstatus();
	}
		arrange(selmon);
		focusclient(focustop(selmon), 1);
}
void
tag(const Arg *arg)
{
	Client *sel = selclient();
	if (sel && arg->ui & TAGMASK) {
		sel->tags = arg->ui & TAGMASK;
	}
		die("dwl: execvp %s failed:", ((char **)arg->v)[0]);
		setsid();
		execvp(((char **)arg->v)[0], (char **)arg->v);
		dup2(STDERR_FILENO, STDOUT_FILENO);
spawn(const Arg *arg)
{
	if (fork() == 0) {
void
}
	} else {
		fprintf(stderr, "failed to setup XWayland X server, continuing without it\n");
	}
		setenv("DISPLAY", xwayland->display_name, 1);
		wl_signal_add(&xwayland->events.new_surface, &new_xwayland_surface);
		wl_signal_add(&xwayland->events.ready, &xwayland_ready);
	if (xwayland) {
	xwayland = wlr_xwayland_create(dpy, compositor, 1);
	/*
	 * Initialise the XWayland X server.
	 * It will be started when the first X client is started.
	 */
#ifdef XWAYLAND
	wlr_scene_set_presentation(scene, wlr_presentation_create(dpy, backend));
	output_mgr = wlr_output_manager_v1_create(dpy);
	wl_signal_add(&output_mgr->events.apply, &output_mgr_apply);
	wl_signal_add(&output_mgr->events.test, &output_mgr_test);
	wl_signal_add(&seat->events.request_set_cursor, &request_cursor);
	wl_signal_add(&seat->events.request_set_selection, &request_set_sel);
	wl_signal_add(&seat->events.request_set_primary_selection, &request_set_psel);
	seat = wlr_seat_create(dpy, "seat0");
	virtual_keyboard_mgr = wlr_virtual_keyboard_manager_v1_create(dpy);
	wl_signal_add(&virtual_keyboard_mgr->events.new_virtual_keyboard,
			&new_virtual_keyboard);
	wl_signal_add(&backend->events.new_input, &new_input);
	wl_list_init(&keyboards);
	/*
	 * Configures a seat, which is a single "seat" at which a user sits and
	 * operates the computer. This conceptually includes up to one keyboard,
	 * pointer, touch, and drawing tablet device. We also rig up a listener to
	 * let us know when new input devices are available on the backend.
	 */
	wl_signal_add(&cursor->events.frame, &cursor_frame);
	wl_signal_add(&cursor->events.axis, &cursor_axis);
	wl_signal_add(&cursor->events.button, &cursor_button);
	wl_signal_add(&cursor->events.motion_absolute, &cursor_motion_absolute);
	wl_signal_add(&cursor->events.motion, &cursor_motion);
	/*
	 * wlr_cursor *only* displays an image on screen. It does not move around
	 * when the pointer moves. However, we can attach input devices to it, and
	 * it will generate aggregate events for all of them. In these events, we
	 * can choose how we want to process them, forwarding them to clients and
	 * moving the cursor around. More detail on this process is described in my
	 * input handling blog post:
	 *
	 * https://drewdevault.com/2018/07/17/Input-handling-in-wlroots.html
	 *
	 * And more comments are sprinkled throughout the notify functions above.
	 */
	cursor_mgr = wlr_xcursor_manager_create(NULL, 24);
	 * HiDPI support). Scaled cursors will be loaded with each output. */
	/* Creates an xcursor manager, another wlroots utility which loads up
	 * Xcursor themes to source cursor images from and makes sure that cursor
	 * images are available at all scale factors on the screen (necessary for
	cursor = wlr_cursor_create();
	wlr_cursor_attach_output_layout(cursor, output_layout);
	/*
	 * Creates a cursor, which is a wlroots utility for tracking the cursor
	 * image shown on screen.
	 */
	wl_signal_add(&xdg_shell->events.new_surface, &new_xdg_surface);
	wl_list_init(&fstack);
	wl_list_init(&clients);
	 *
	 * https://drewdevault.com/2018/07/29/Wayland-shells.html
	 */
	 * Wayland protocol which is used for application windows. For more
	 * detail on shells, refer to the article:
	/* Set up our client lists and the xdg-shell. The xdg-shell is a
	wl_signal_add(&backend->events.new_output, &new_output);
	wl_list_init(&mons);
	/* Configure a listener to be notified when new outputs are available on the
	 * backend. */
	output_layout = wlr_output_layout_create();
	/* Creates an output layout, which a wlroots utility for working with an
	 * arrangement of screens in a physical layout. */
	/* Initializes the interface used to implement urgency hints */
	activation = wlr_xdg_activation_v1_create(dpy);
	wl_signal_add(&activation->events.request_activate, &request_activate);
	wlr_data_device_manager_create(dpy);
	wlr_screencopy_manager_v1_create(dpy);
	wlr_export_dmabuf_manager_v1_create(dpy);
	compositor = wlr_compositor_create(dpy, drw);
	 * to dig your fingers in and play with their behavior if you want. Note that
	 * the clients cannot set the selection directly without compositor approval,
	 * see the setsel() function. */
	/* This creates some hands-off wlroots interfaces. The compositor is
	 * necessary for clients to allocate surfaces and the data device manager
	 * handles the clipboard. Each of these wlroots interfaces has room for you
		die("couldn't create allocator");
	/* Create a default allocator */
	if (!(alloc = wlr_allocator_autocreate(backend, drw)))
	wlr_renderer_init_wl_display(drw, dpy);
		die("couldn't create renderer");
	/* Create a renderer with the default implementation */
	if (!(drw = wlr_renderer_autocreate(backend)))
		die("couldn't create backend");
	if (!(backend = wlr_backend_autocreate(dpy)))
	/* The backend is a wlroots feature which abstracts the underlying input and
	 * output hardware. The autocreate option will choose the most suitable
	 * backend based on the current environment, such as opening an X11 window
	 * if an X11 server is running. The NULL argument here optionally allows you
	 * to pass in a custom renderer if wlr_renderer doesn't meet your needs. The
	 * backend uses the renderer, for example, to fall back to software cursors
	 * if the backend does not support hardware cursors (some older GPUs
	 * don't). */
	sigchld(0);
	/* Set up signal handlers */
	/* The Wayland display is managed by libwayland. It handles accepting
	 * clients from the Unix socket, manging Wayland globals, and so on. */
	dpy = wl_display_create();
	/* Force line-buffered stdout */
	setvbuf(stdout, NULL, _IOLBF, 0);
{
setup(void)
void
/* arg > 1.0 will set mfact absolutely */
}
	arrange(selmon);
	/* TODO change layout symbol? */
	if (!arg || !arg->v || arg->v != selmon->lt[selmon->sellt])
		selmon->sellt ^= 1;
	if (arg && arg->v)
		selmon->lt[selmon->sellt] = (Layout *)arg->v;
setlayout(const Arg *arg)
{
}
void
	arrange(c->mon);
	c->isfloating = floating;
{
setfloating(Client *c, int floating)
}
void
				event->hotspot_x, event->hotspot_y);
		wlr_cursor_set_surface(cursor, event->surface,
	 * actually has pointer focus first. If so, we can tell the cursor to
	 * use the provided surface as the cursor image. It will set the
	 * hardware cursor on the output that it's currently on and continue to
	 * do so as the cursor moves between outputs. */
	if (event->seat_client == seat->pointer_state.focused_client)
	/* This can be sent by any client, so we check to make sure this one is
	cursor_image = NULL;
		return;
	if (cursor_mode != CurNormal && cursor_mode != CurPressed)
	/* If we're "grabbing" the cursor, don't use the client's image, we will
	 * restore it after "grabbing" sending a leave event, followed by a enter
	 * event, which will result in the client requesting set the cursor surface */
	/* This event is raised by the seat when a client provides a cursor image */
	struct wlr_seat_pointer_request_set_cursor_event *event = data;
setcursor(struct wl_listener *listener, void *data)
{
void
}
Client *
selclient(void)
{
	Client *c = wl_container_of(fstack.next, c, flink);
	if (wl_list_empty(&fstack) || !VISIBLEON(c, selmon))
		return NULL;
	return c;
}
	/* Run the Wayland event loop. This does not return until you exit the
	 * compositor. Starting the backend rigged up all of the necessary event
	 * loop configuration to listen to libinput events, DRM events, generate
	 * frame events at the refresh rate, and so on. */
	/* If nobody is reading the status output, don't terminate */
	signal(SIGPIPE, SIG_IGN);
	}
		close(piperw[0]);
		close(piperw[1]);
		dup2(piperw[1], STDOUT_FILENO);
		}
			die("startup: execl:");
			execl("/bin/sh", "/bin/sh", "-c", startup_cmd, NULL);
			close(piperw[1]);
			close(piperw[0]);
			dup2(piperw[0], STDIN_FILENO);
		if (child_pid == 0) {
			die("startup: fork:");
		if ((child_pid = fork()) < 0)
		if (pipe(piperw) < 0)
			die("startup: pipe:");
		int piperw[2];
	if (startup_cmd) {
	setenv("WAYLAND_DISPLAY", socket, 1);
		die("startup: display_add_socket_auto");
	if (!socket)
	const char *socket = wl_display_add_socket_auto(dpy);
	/* Add a Unix socket to the Wayland display. */
run(char *startup_cmd)
{
	struct timespec now;
	int skip = 0;
	Client *c;
	Monitor *m = wl_container_of(listener, m, frame);
	/* This function is called every time an output is ready to display a frame,
	 * generally at the output's refresh rate (e.g. 60Hz). */
{
rendermon(struct wl_listener *listener, void *data)
}
void
quitsignal(int signo)
{
	quit(NULL);
}
void
	wl_display_terminate(dpy);
{
quit(const Arg *arg)
}
void
		printf("%s layout %s\n", m->wlr_output->name, m->lt[m->sellt]->symbol);
	}
		printf("%s tags %u %u %u %u\n", m->wlr_output->name, occ, m->tagset[m->seltags],
				sel, urg);
		printf("%s selmon %u\n", m->wlr_output->name, m == selmon);
			sel = 0;
		}
			printf("%s fullscreen \n", m->wlr_output->name);
			printf("%s floating \n", m->wlr_output->name);
			printf("%s title \n", m->wlr_output->name);
			sel = c->tags;
		} else {
			printf("%s title %s\n", m->wlr_output->name, client_get_title(c));
			printf("%s fullscreen %u\n", m->wlr_output->name, c->isfullscreen);
			printf("%s floating %u\n", m->wlr_output->name, c->isfloating);
		if ((c = focustop(m))) {
		}
			if (c->mon != m)
				continue;
			occ |= c->tags;
			if (c->isurgent)
				urg |= c->tags;
		wl_list_for_each(c, &clients, link) {
		occ = urg = 0;
	wl_list_for_each(m, &mons, link) {
	Client *c;
	unsigned int occ, urg, sel;
}
void
printstatus(void)
{
	Monitor *m = NULL;
	wlr_seat_pointer_notify_motion(seat, time, sx, sy);
	wlr_seat_pointer_notify_enter(seat, surface, sx, sy);
	}
		clock_gettime(CLOCK_MONOTONIC, &now);
		time = now.tv_sec * 1000 + now.tv_nsec / 1000000;
	if (internal_call) {
		return;
	}
	/* If surface is NULL, clear pointer focus */
	if (!surface) {
		wlr_seat_pointer_notify_clear_focus(seat);
	if (sloppyfocus && !internal_call && c && !client_is_unmanaged(c))
		focusclient(c, 0);
	struct timespec now;
	int internal_call = !time;
{
pointerfocus(Client *c, struct wlr_surface *surface, double sx, double sy,
		uint32_t time)
void
}
		break;
	}
				(cursor_image = "bottom_right_corner"), cursor);
		break;
	case CurResize:
		/* Doesn't work for X11 output - the next absolute motion event
		 * returns the cursor to where it started */
		wlr_cursor_warp_closest(cursor, NULL,
				grabc->geom.x + grabc->geom.width,
				grabc->geom.y + grabc->geom.height);
		wlr_xcursor_manager_set_cursor_image(cursor_mgr,
		wlr_xcursor_manager_set_cursor_image(cursor_mgr, (cursor_image = "fleur"), cursor);
		grabcx = cursor->x - grabc->geom.x;
		grabcy = cursor->y - grabc->geom.y;
	switch (cursor_mode = arg->ui) {
	case CurMove:
	setfloating(grabc, 1);
	/* Float the window and tell motionnotify to grab it */
		return;
	if (!grabc || client_is_unmanaged(grabc))
		return;
	xytonode(cursor->x, cursor->y, NULL, &grabc, NULL, NULL, NULL);
	if (cursor_mode != CurNormal && cursor_mode != CurPressed)
{
moveresize(const Arg *arg)
void
}
	motionnotify(event->time_msec);
	wlr_cursor_move(cursor, &event->pointer->base, event->delta_x, event->delta_y);
	/* The cursor doesn't move unless we tell it to. The cursor automatically
	 * handles constraining the motion to the output layout, as well as any
	 * special configuration applied for the specific input device which
	 * generated the event. You can pass NULL for the device if you want to move
	 * the cursor around without any input. */
	struct wlr_pointer_motion_event *event = data;
	/* This event is forwarded by the cursor when a pointer emits a _relative_
	 * pointer motion event (i.e. a delta) */
motionrelative(struct wl_listener *listener, void *data)
{
void
}
	pointerfocus(c, surface, sx, sy, time);
		wlr_xcursor_manager_set_cursor_image(cursor_mgr, (cursor_image = "left_ptr"), cursor);
	if (!surface && !seat->drag && (!cursor_image || strcmp(cursor_image, "left_ptr")))
	 * off of a client or over its border. */
	 * default. This is what makes the cursor image appear when you move it
	/* If there's no client surface under the cursor, set the cursor image to a
	}
		if ((l = toplevel_from_wlr_layer_surface(
				 seat->pointer_state.focused_surface))) {
			surface = seat->pointer_state.focused_surface;
			sx = cursor->x - l->geom.x;
			sy = cursor->y - l->geom.y;
		}
	if (cursor_mode == CurPressed && !seat->drag) {
	/* Find the client under the pointer and send the event along. */
	xytonode(cursor->x, cursor->y, &surface, &c, NULL, &sx, &sy);
		return;
	}
		resize(grabc, (struct wlr_box){.x = grabc->geom.x, .y = grabc->geom.y,
			.width = cursor->x - grabc->geom.x, .height = cursor->y - grabc->geom.y}, 1);
	} else if (cursor_mode == CurResize) {
		return;
		resize(grabc, (struct wlr_box){.x = cursor->x - grabcx, .y = cursor->y - grabcy,
			.width = grabc->geom.width, .height = grabc->geom.height}, 1);
		/* Move the grabbed client to the new position. */
	if (cursor_mode == CurMove) {
	/* If we are currently grabbing the mouse, handle and return */
{
motionnotify(uint32_t time)
void
}
	motionnotify(event->time_msec);
	struct wlr_pointer_motion_absolute_event *event = data;
	wlr_cursor_warp_absolute(cursor, &event->pointer->base, event->x, event->y);
	/* This event is forwarded by the cursor when a pointer emits an _absolute_
	 * motion event, from 0..1 on each axis. This happens, for example, when
	 * wlroots is running under a Wayland window rather than KMS+DRM, and you
	 * move the mouse over the window. You could enter the window from any edge,
	 * so we have to warp the mouse there. There is also some hardware which
	 * emits these events. */
{
motionabsolute(struct wl_listener *listener, void *data)
}
void
		wlr_scene_node_raise_to_top(&c->scene->node);
	if ((c = focustop(m)))
	}
		resize(c, m->w, 0);
			continue;
		if (!VISIBLEON(c, m) || c->isfloating || c->isfullscreen)
monocle(Monitor *m)
{
	Client *c;
	wl_list_for_each(c, &clients, link) {
void
}
	printstatus();
	} else {
		applyrules(c);
	}
		setmon(c, p->mon, p->tags);
		wlr_scene_node_reparent(&c->scene->node, layers[LyrFloat]);
		c->isfloating = 1;
	if ((p = client_get_parent(c))) {
	/* Set initial monitor, tags, floating status, and focus:
	 * we always consider floating, clients that have parent and thus
	 * we set the same tags and monitor than its parent, if not
	 * try to apply rules for them */
	client_get_geometry(c, &c->geom);
	c->geom.width += 2 * c->bw;
	c->geom.height += 2 * c->bw;
	/* Initialize client geometry with room for border */
	client_set_tiled(c, WLR_EDGE_TOP | WLR_EDGE_BOTTOM | WLR_EDGE_LEFT | WLR_EDGE_RIGHT);
	}
	for (i = 0; i < 4; i++) {
		c->border[i] = wlr_scene_rect_create(c->scene, 0, 0, bordercolor);
		c->border[i]->node.data = c;
		wlr_scene_rect_set_color(c->border[i], bordercolor);
		return;
	}
		if (client_wants_focus(c)) {
			focusclient(c, 1);
			exclusive_focus = c;
		}
			c->geom.y + borderpx);
		wlr_scene_node_reparent(&c->scene->node, layers[LyrFloat]);
		wlr_scene_node_set_position(&c->scene->node, c->geom.x + borderpx,
		/* Unmanaged clients always are floating */
		client_get_geometry(c, &c->geom);
	if (client_is_unmanaged(c)) {
	c->scene->node.data = c->scene_surface->node.data = c;
		LISTEN(&client_surface(c)->events.commit, &c->commit, commitnotify);
	}
		* wlr_xwayland_surface doesn't have wlr_surface yet. */
		/* Ideally we should do this in createnotify{,x11} but at that moment
		client_surface(c)->data = c->scene;
	if (client_surface(c)) {
			? wlr_scene_xdg_surface_create(c->scene, c->surface.xdg)
			: wlr_scene_subsurface_tree_create(c->scene, client_surface(c));
	c->scene_surface = c->type == XDGShell
	c->scene = wlr_scene_tree_create(layers[LyrTile]);
	int i;
	/* Create scene tree for this client and its border */
	Client *p, *c = wl_container_of(listener, c, map);
	/* Called when the surface is mapped, or ready to display on-screen. */
{
mapnotify(struct wl_listener *listener, void *data)
}
void
	motionnotify(0);
	LayerSurface *l = wl_container_of(listener, l, map);
	wlr_surface_send_enter(l->layer_surface->surface, l->mon->wlr_output);
{
maplayersurfacenotify(struct wl_listener *listener, void *data)
void
}
	if (sel)
		client_send_close(sel);
}
void
killclient(const Arg *arg)
{
	Client *sel = selclient();
		&kb->wlr_keyboard->modifiers);
	wlr_seat_keyboard_notify_modifiers(seat,
	/* Send modifiers to the client. */
	wlr_seat_set_keyboard(seat, kb->wlr_keyboard);
	 */
	 * A seat can only have one keyboard, but this is a limitation of the
	 * Wayland protocol - not wlroots. We assign all connected keyboards to the
	 * same seat. You can swap out the underlying wlr_keyboard like this and
	 * wlr_seat handles this transparently.
	/*
	Keyboard *kb = wl_container_of(listener, kb, modifiers);
	/* This event is raised when a modifier key, such as shift or alt, is
	 * pressed. We simply communicate this to the client. */
{
void
keypressmod(struct wl_listener *listener, void *data)
		wlr_seat_keyboard_notify_key(seat, event->time_msec,
			event->keycode, event->state);
	}
}
		wlr_seat_set_keyboard(seat, kb->wlr_keyboard);
		/* Pass unhandled keycodes along to the client. */
	if (!handled) {
			handled = keybinding(mods, syms[i]) || handled;
		for (i = 0; i < nsyms; i++)
	/* On _press_ if there is no active screen locker,
	 * attempt to process a compositor keybinding. */
	if (!input_inhibit_mgr->active_inhibitor
			&& event->state == WL_KEYBOARD_KEY_STATE_PRESSED)
	IDLE_NOTIFY_ACTIVITY;
	uint32_t mods = wlr_keyboard_get_modifiers(kb->wlr_keyboard);
	int handled = 0;
			kb->wlr_keyboard->xkb_state, keycode, &syms);
	/* Translate libinput keycode -> xkbcommon */
	uint32_t keycode = event->keycode + 8;
	/* Get a list of keysyms based on the keymap for this keyboard */
	const xkb_keysym_t *syms;
	int nsyms = xkb_state_key_get_syms(
	struct wlr_keyboard_key_event *event = data;
	Keyboard *kb = wl_container_of(listener, kb, key);
	/* This event is raised when a key is pressed or released. */
keypress(struct wl_listener *listener, void *data)
{
void
}
	return handled;
	}
		}
			handled = 1;
	const Key *k;
	for (k = keys; k < END(keys); k++) {
		if (CLEANMASK(mods) == CLEANMASK(k->mod) &&
				sym == k->keysym && k->func) {
			k->func(&k->arg);
	int handled = 0;
	 */
	/*
	 * Here we handle compositor keybindings. This is when the compositor is
	 * processing keys, rather than passing them on to the client for its own
	 * processing.
{
keybinding(uint32_t mods, xkb_keysym_t sym)
int
}
	wlr_seat_set_capabilities(seat, caps);
		caps |= WL_SEAT_CAPABILITY_KEYBOARD;
	if (!wl_list_empty(&keyboards))
	caps = WL_SEAT_CAPABILITY_POINTER;
	/* TODO do we actually require a cursor? */
	/* We need to let the wlr_seat know what our capabilities are, which is
	 * communiciated to the client. In dwl we always have a cursor, even if
	 * there are no pointer devices, so we always include that capability. */
		break;
	}
		/* TODO handle other input device types */
		break;
	default:
		createpointer(wlr_pointer_from_input_device(device));
		break;
	case WLR_INPUT_DEVICE_POINTER:
		createkeyboard(wlr_keyboard_from_input_device(device));
	switch (device->type) {
	case WLR_INPUT_DEVICE_KEYBOARD:
	uint32_t caps;
	struct wlr_input_device *device = data;
}
void
inputdevice(struct wl_listener *listener, void *data)
{
	/* This event is raised by the backend when a new input device becomes
	 * available. */
	selmon->nmaster = MAX(selmon->nmaster + arg->i, 0);
	if (!arg || !selmon)
		return;
}
void
incnmaster(const Arg *arg)
{
	setfullscreen(c, client_wants_fullscreen(c));
}
void
fullscreennotify(struct wl_listener *listener, void *data)
{
	Client *c = wl_container_of(listener, c, fullscreen);
Client *
focustop(Monitor *m)
{
	Client *c;
	wl_list_for_each(c, &fstack, flink)
		if (VISIBLEON(c, m))
			return c;
	return NULL;
}
	focusclient(c, 1);
	/* If only one client is visible on selmon, then c == sel */
	}
	if (arg->i > 0) {
		wl_list_for_each(c, &sel->link, link) {
			if (&c->link == &clients)
				continue;  /* wrap past the sentinel node */
			if (VISIBLEON(c, selmon))
				break;  /* found it */
		}
	} else {
		wl_list_for_each_reverse(c, &sel->link, link) {
			if (&c->link == &clients)
				continue;  /* wrap past the sentinel node */
			if (VISIBLEON(c, selmon))
				break;  /* found it */
		}
		return;
	if (!sel || (sel->isfullscreen && lockfullscreen))
	Client *c, *sel = selclient();
	/* Focus the next or previous client (in tiling order) on selmon */
{
focusstack(const Arg *arg)
void
}
	focusclient(focustop(selmon), 1);
	int i = 0, nmons = wl_list_length(&mons);
	if (nmons)
		do /* don't switch to disabled mons */
			selmon = dirtomon(arg->i);
		while (!selmon->wlr_output->enabled && i++ < nmons);
}
void
focusmon(const Arg *arg)
{
	client_activate_surface(client_surface(c), 1);
	/* Activate the new client */
	client_notify_enter(client_surface(c), wlr_seat_get_keyboard(seat));
	/* Have a client, so focus its top-level wlr_surface */
	/* Change cursor surface */
	motionnotify(0);
		return;
	}
		wlr_seat_keyboard_notify_clear_focus(seat);
	if (!c) {
		/* With no client, all we have left is to clear focus */
	printstatus();
	}
		}
			client_activate_surface(old, 0);
		} else if (w && w == exclusive_focus && client_wants_focus(w)) {
			return;
		/* Don't deactivate old client if the new one wants focus, as this causes issues with winecfg
		 * and probably other clients */
		} else if (w && !client_is_unmanaged(w) && (!c || !client_wants_focus(c))) {
			for (i = 0; i < 4; i++)
				wlr_scene_rect_set_color(w->border[i], bordercolor);
				return;
			if (wlr_layer_surface && ((LayerSurface *)wlr_layer_surface->data)->mapped
					&& (wlr_layer_surface->current.layer == ZWLR_LAYER_SHELL_V1_LAYER_TOP
					|| wlr_layer_surface->current.layer == ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY))
			struct wlr_layer_surface_v1 *wlr_layer_surface =
				wlr_layer_surface_v1_from_wlr_surface(old);
		if (wlr_surface_is_layer_surface(old)) {
		 * and focus it after the overlay is closed. */
		/* If an overlay is focused, don't focus or activate the client,
		 * but only update its position in fstack to render its border with focuscolor
	if (old && (!c || client_surface(c) != old)) {
	/* Deactivate old client if focus is changing */
		wlr_scene_node_raise_to_top(&c->scene->node);
	if (c && lift)
	/* Raise client in stacking order if requested */
	int i;
	struct wlr_surface *old = seat->keyboard_state.focused_surface;
{
focusclient(Client *c, int lift)
}
void
			dir ^ (WLR_DIRECTION_LEFT|WLR_DIRECTION_RIGHT),
			selmon->wlr_output, selmon->m.x, selmon->m.y)))
		return next->data;
	return selmon;
	if (wlr_output_layout_get(output_layout, selmon->wlr_output)
			&& (next = wlr_output_layout_farthest_output(output_layout,
			dir, selmon->wlr_output, selmon->m.x, selmon->m.y)))
		return next->data;
	if (wlr_output_layout_get(output_layout, selmon->wlr_output)
			&& (next = wlr_output_layout_adjacent_output(output_layout,
	struct wlr_output *next;
{
dirtomon(enum wlr_direction dir)
Monitor *
	free(c);
	wl_list_remove(&c->map.link);
	wl_list_remove(&c->unmap.link);
	wl_list_remove(&c->destroy.link);
	Client *c = wl_container_of(listener, c, destroy);
destroynotify(struct wl_listener *listener, void *data)
{
	/* Called when the surface is destroyed and should never be shown again. */
}
void
	free(layersurface);
	wl_list_remove(&layersurface->link);
	wl_list_remove(&layersurface->destroy.link);
	wl_list_remove(&layersurface->map.link);
	wl_list_remove(&layersurface->unmap.link);
	wl_list_remove(&layersurface->surface_commit.link);
	LayerSurface *layersurface = wl_container_of(listener, layersurface, destroy);
{
destroylayersurfacenotify(struct wl_listener *listener, void *data)
}
void
	/* `data` is the wlr_surface of the idle inhibitor being destroyed,
	 * at this point the idle inhibitor is still in the list of the manager */
	checkidleinhibitor(data);
destroyidleinhibitor(struct wl_listener *listener, void *data)
{
}
void
	wlr_seat_pointer_notify_frame(seat);
	/* Notify the client with pointer focus of the frame event. */
cursorframe(struct wl_listener *listener, void *data)
{
	/* This event is forwarded by the cursor when a pointer emits an frame
	 * event. Frame events are sent after regular pointer events to group
	 * multiple events together. For instance, two axis events may happen at the
	 * same time, in which case a frame event won't be sent in between. */
}
void
	}
		if (libinput_device_config_send_events_get_modes(libinput_device))
			libinput_device_config_send_events_set_mode(libinput_device, send_events_mode);
		if (libinput_device_config_accel_is_available(libinput_device)) {
			libinput_device_config_accel_set_profile(libinput_device, accel_profile);
			libinput_device_config_accel_set_speed(libinput_device, accel_speed);
		}
		if (libinput_device_config_click_get_methods(libinput_device) != LIBINPUT_CONFIG_CLICK_METHOD_NONE)
			libinput_device_config_click_set_method (libinput_device, click_method);
		
		if (libinput_device_config_dwt_is_available(libinput_device))
			libinput_device_config_dwt_set_enabled(libinput_device, disable_while_typing);
		if (libinput_device_config_left_handed_is_available(libinput_device))
			libinput_device_config_left_handed_set(libinput_device, left_handed);
		if (libinput_device_config_middle_emulation_is_available(libinput_device))
			libinput_device_config_middle_emulation_set_enabled(libinput_device, middle_button_emulation);
		if (libinput_device_config_scroll_get_methods(libinput_device) != LIBINPUT_CONFIG_SCROLL_NO_SCROLL)
			libinput_device_config_scroll_set_method (libinput_device, scroll_method);
		if (libinput_device_config_scroll_has_natural_scroll(libinput_device))
			libinput_device_config_scroll_set_natural_scroll_enabled(libinput_device, natural_scrolling);
		}
			libinput_device_config_tap_set_drag_lock_enabled(libinput_device, drag_lock);
		if (libinput_device_config_tap_get_finger_count(libinput_device)) {
			libinput_device_config_tap_set_enabled(libinput_device, tap_to_click);
			libinput_device_config_tap_set_drag_enabled(libinput_device, tap_and_drag);
			wlr_libinput_get_device_handle(&pointer->base);
		struct libinput_device *libinput_device =  (struct libinput_device*)
	if (wlr_input_device_is_libinput(&pointer->base)) {
{
}
void
	LISTEN(&xdg_surface->toplevel->events.request_maximize, &c->maximize,
			maximizenotify);
	LISTEN(&xdg_surface->toplevel->events.request_fullscreen, &c->fullscreen,
			fullscreennotify);
	LISTEN(&xdg_surface->toplevel->events.set_title, &c->set_title, updatetitle);
	LISTEN(&xdg_surface->events.map, &c->map, mapnotify);
	LISTEN(&xdg_surface->events.unmap, &c->unmap, unmapnotify);
	LISTEN(&xdg_surface->events.destroy, &c->destroy, destroynotify);
	c->bw = borderpx;
	c->surface.xdg = xdg_surface;
	c = xdg_surface->data = ecalloc(1, sizeof(*c));
	/* Allocate a Client for this surface */
		return;
		wlr_xdg_popup_unconstrain_from_box(xdg_surface->popup, &box);
		return;
	} else if (xdg_surface->role == WLR_XDG_SURFACE_ROLE_NONE)
		box = l->type == LayerShell ? l->mon->m : l->mon->w;
		box.x -= l->geom.x;
		box.y -= l->geom.y;
			return;
		xdg_surface->surface->data = wlr_scene_xdg_surface_create(
				xdg_surface->popup->parent->data, xdg_surface);
		struct wlr_box box;
	if (xdg_surface->role == WLR_XDG_SURFACE_ROLE_POPUP) {
	Client *c;
	struct wlr_xdg_surface *xdg_surface = data;
	 * client, either a toplevel (application window) or popup,
	 * or when wlr_layer_shell receives a new popup from a layer.
	 * If you want to do something tricky with popups you should check if
	 * its parent is wlr_xdg_shell or wlr_layer_shell */
{
	/* This event is raised when wlr_xdg_shell receives a new xdg surface from a
createnotify(struct wl_listener *listener, void *data)
}
void
	m->scene_output = wlr_scene_output_create(scene, wlr_output);
	wlr_output_layout_add_auto(output_layout, wlr_output);
	 *
	 * The output layout utility automatically adds a wl_output global to the
	 * display, which Wayland clients can see to find out information about the
	 * output (such as DPI, scale factor, manufacturer, etc).
	 */
	/* Adds this to the output layout in the order it was configured in.
	/* Try to enable adaptive sync, note that not all monitors support it.
	 * wlr_output_commit() will deactivate it in case it cannot be enabled */
	wlr_output_enable_adaptive_sync(wlr_output, 1);
	wlr_output_commit(wlr_output);
	if (!wlr_output_commit(wlr_output))
		return;
	wlr_output_enable(wlr_output, 1);
	LISTEN(&wlr_output->events.frame, &m->frame, rendermon);
	LISTEN(&wlr_output->events.destroy, &m->destroy, cleanupmon);
	/* Set up event listeners */
	/* The mode is a tuple of (width, height, refresh rate), and each
	 * monitor supports only a specific set of modes. We just pick the
	 * monitor's preferred mode; a more sophisticated compositor would let
	 * the user configure it. */
	wlr_output_set_mode(wlr_output, wlr_output_preferred_mode(wlr_output));
	}
			break;
		}
			wlr_output_set_transform(wlr_output, r->rr);
			m->lt[0] = m->lt[1] = r->lt;
			m->mfact = r->mfact;
			m->nmaster = r->nmaster;
			wlr_output_set_scale(wlr_output, r->scale);
			wlr_xcursor_manager_load(cursor_mgr, r->scale);
		if (!r->name || strstr(wlr_output->name, r->name)) {
	m->tagset[0] = m->tagset[1] = 1;
		wl_list_init(&m->layers[i]);
	for (i = 0; i < LENGTH(m->layers); i++)
	/* Initialize monitor state using configured rules */