Sivecano/dwl - Change 24ZMBWYLMODPBAVLT4XNOSETHQXVLXNASYXUIGG2435IT7WIZC5AC

use scene-graph API for Client/LayerSurface

Created by Devin J. Pohly on September 5, 2021

24ZMBWYLMODPBAVLT4XNOSETHQXVLXNASYXUIGG2435IT7WIZC5AC

Dependencies

In channels

main

Change contents

Insertion in dwl.c at line 36 [14.4]
[13.42]
[7.4]
```
#include <wlr/types/wlr_scene.h>
```
Deletion in dwl.c at line 64 [14.4]
B:BD[15.153] → [16.3:52]
```
#define ROUND(X)                ((int)((X)+0.5))
```

Insertion in dwl.c at line 69 [14.4]

[12.80]

[17.1]

enum { LyrBg, LyrBottom, LyrTop, LyrOverlay, LyrTile, LyrFloat, NUM_LAYERS }; /* scene layers */

Insertion in dwl.c at line 93 [14.4]

[12.145]

[14.1960]

	struct wlr_scene_node *scene;
	struct wlr_scene_rect *border[4];
	struct wlr_scene_node *scene_surface;

Deletion in dwl.c at line 98 [14.4]
B:BD[18.24] → [19.1:24]
```
	struct wl_list slink;
```
Replacement in dwl.c at line 149 [14.4]
∅:D[12.204] → [20.14508:14553]
B:BD[21.95] → [20.14508:14553]
```
	struct wlr_layer_surface_v1 *layer_surface;
```
[12.204]
[20.14553]
```
	struct wlr_scene_node *scene;
```
Insertion in dwl.c at line 151 [14.4]
[20.14575]
[20.14575]
```
	struct wlr_layer_surface_v1 *layer_surface;
```
Deletion in dwl.c at line 210 [14.4]
B:BD[22.40] → [23.449:635]
B:BD[23.652] → [23.652:676]
B:BD[23.676] → [24.496:529]
∅:D[25.12] → [23.676:679]
∅:D[24.529] → [23.676:679]
B:BD[23.676] → [23.676:679]
∅:D[22.173] → [21.204:205]
∅:D[23.679] → [21.204:205]
B:BD[21.204] → [21.204:205]
```
/* 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 timespec *when;
	int x, y; /* layout-relative */
};
```
Deletion in dwl.c at line 264 [14.4]
∅:D[26.28] → [27.1726:1803]
∅:D[28.34] → [27.1726:1803]
∅:D[10.39] → [27.1726:1803]
∅:D[29.476] → [27.1726:1803]
B:BD[27.1726] → [27.1726:1803]
B:BD[27.1803] → [30.1:62]
B:BD[30.62] → [31.3:82]
```
static void render(struct wlr_surface *surface, int sx, int sy, void *data);
static void renderclients(Monitor *m, struct timespec *now);
static void renderlayer(struct wl_list *layer_surfaces, struct timespec *now);
```
Deletion in dwl.c at line 267 [14.4]
B:BD[32.37] → [33.1:57]
```
static void scalebox(struct wlr_box *box, float scale);
```

Replacement in dwl.c at line 294 [14.4]

∅:D[34.123] → [35.1:48]

B:BD[15.293] → [35.1:48]

B:BD[35.48] → [36.3:126]

static Client *xytoclient(double x, double y);
static struct wlr_surface *xytolayersurface(struct wl_list *layer_surfaces,
		double x, double y, double *sx, double *sy);

[34.123]

[37.1]

static struct wlr_scene_node *xytonode(double x, double y, struct wlr_surface **psurface,
		Client **pc, LayerSurface **pl, double *nx, double *ny);

Insertion in dwl.c at line 303 [14.4]

[38.75]

[39.484]

static struct wlr_scene *scene;
static struct wlr_scene_node *layers[NUM_LAYERS];

Deletion in dwl.c at line 312 [14.4]
B:BD[18.124] → [19.62:116]
```
static struct wl_list stack;   /* stacking z-order */
```

Deletion in dwl.c at line 361 [14.4]

B:BD[40.488] → [40.488:569]

static void renderindependents(struct wlr_output *output, struct timespec *now);

Deletion in dwl.c at line 362 [14.4]
B:BD[40.679] → [41.1:53]
```
static Client *xytoindependent(double x, double y);
```

Insertion in dwl.c at line 476 [14.4]

[42.809]

	wlr_scene_node_reparent(c->scene, layers[c->isfloating ? LyrFloat : LyrTile]);

Insertion in dwl.c at line 483 [14.4]

[24.702]

	Client *c;
	wl_list_for_each(c, &clients, link)
		wlr_scene_node_set_enabled(c->scene, VISIBLEON(c, c->mon));

Insertion in dwl.c at line 565 [14.4]

[3.1469]

[43.433]

		wlr_scene_node_set_position(layersurface->scene, box.x, box.y);

Replacement in dwl.c at line 649 [14.4]

∅:D[44.1984] → [45.48:94]

B:BD[46.116] → [45.48:94]

		if ((c = xytoclient(cursor->x, cursor->y)))

[46.116]

[39.815]

		xytonode(cursor->x, cursor->y, NULL, &c, NULL, NULL, NULL);
		if (c)

Insertion in dwl.c at line 761 [14.4]

[47.2336]

[20.22958]


	wlr_scene_node_reparent(layersurface->scene,
			layers[wlr_layer_surface->current.layer]);

Insertion in dwl.c at line 935 [14.4]
[43.2063]
[20.24240]
```
	m = wlr_layer_surface->output->data;
```

Replacement in dwl.c at line 937 [14.4]

B:BD[20.24241] → [47.2891:2929]

	m = wlr_layer_surface->output->data;

[20.24241]

[43.2103]

	layersurface->scene = wlr_scene_surface_tree_create(
			layers[wlr_layer_surface->client_pending.layer],
			wlr_layer_surface->surface);
	layersurface->scene->data = layersurface;

Replacement in dwl.c at line 1083 [14.4]

∅:D[48.19] → [49.71:137]

∅:D[50.99] → [49.71:137]

B:BD[49.71] → [49.71:137]

		wl_list_remove(&c->slink);
		wl_list_insert(&stack, &c->slink);

[48.19]

[49.137]

		/* This isn't easy to do via the current API */
		wl_list_remove(&c->scene->state.link);
		wl_list_insert(c->scene->parent->state.children.prev, &c->scene->state.link);

Insertion in dwl.c at line 1312 [14.4]

[5.183]

[51.195]

	int i;
	/* Create scene tree for this client and its border */
	c->scene = &wlr_scene_tree_create(layers[LyrTile])->node;
	c->scene_surface = wlr_scene_surface_tree_create(c->scene, client_surface(c));
	c->scene_surface->data = c;
	for (i = 0; i < 4; i++) {
		c->border[i] = wlr_scene_rect_create(c->scene, 0, 0, bordercolor);
		c->border[i]->node.data = c;
	}

Insertion in dwl.c at line 1324 [14.4]

[52.637]

[51.228]

		/* Floating, no border */
		wlr_scene_node_reparent(c->scene, layers[LyrFloat]);
		c->bw = 0;

Replacement in dwl.c at line 1333 [14.4]

∅:D[51.342] → [42.844:999]

B:BD[23.2985] → [42.844:999]

B:BD[42.999] → [53.2304:2305]

	/* Insert this client into client lists. */
	wl_list_insert(&clients, &c->link);
	wl_list_insert(&fstack, &c->flink);
	wl_list_insert(&stack, &c->slink);

[51.342]

[52.638]

	/* Initialize client geometry with room for border */
	client_set_tiled(c, WLR_EDGE_TOP | WLR_EDGE_BOTTOM | WLR_EDGE_LEFT | WLR_EDGE_RIGHT);

Replacement in dwl.c at line 1339 [14.4]

∅:D[54.222] → [55.5:54]

B:BD[55.5] → [55.5:54]

B:BD[55.54] → [8.4:91]

	/* Tell the client not to try anything fancy */
	client_set_tiled(c, WLR_EDGE_TOP | WLR_EDGE_BOTTOM | WLR_EDGE_LEFT | WLR_EDGE_RIGHT);

[55.5]

[42.1000]

	/* Insert this client into client lists. */
	wl_list_insert(&clients, &c->link);
	wl_list_insert(&fstack, &c->flink);

Insertion in dwl.c at line 1345 [14.4]

[42.1078]

[14.11745]

	resize(c, c->geom.x, c->geom.y, c->geom.width, c->geom.height, 0);

Insertion in dwl.c at line 1378 [14.4]
[47.3182]
[47.3182]
```
	Client *c = NULL;
```
Deletion in dwl.c at line 1380 [14.4]
B:BD[47.3219] → [47.3219:3238]
```
	Client *c = NULL;
```

Replacement in dwl.c at line 1403 [14.4]

∅:D[44.3052] → [36.473:730]

B:BD[14.13393] → [36.473:730]

∅:D[36.730] → [41.54:70]

B:BD[14.13393] → [41.54:70]

∅:D[41.70] → [50.203:274]

B:BD[14.13393] → [50.203:274]

B:BD[50.274] → [36.731:788]

∅:D[36.788] → [50.326:498]

B:BD[50.326] → [50.326:498]

	if ((surface = xytolayersurface(&selmon->layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY],
					cursor->x, cursor->y, &sx, &sy)))
		;
	else if ((surface = xytolayersurface(&selmon->layers[ZWLR_LAYER_SHELL_V1_LAYER_TOP],
					cursor->x, cursor->y, &sx, &sy)))
		;
#ifdef XWAYLAND
	/* Find an independent under the pointer and send the event along. */
	else if ((c = xytoindependent(cursor->x, cursor->y))) {
		surface = wlr_surface_surface_at(c->surface.xwayland->surface,
				cursor->x - c->surface.xwayland->x - c->bw,
				cursor->y - c->surface.xwayland->y - c->bw, &sx, &sy);

[14.13393]

[50.498]

	/* Find the client under the pointer and send the event along. */
	xytonode(cursor->x, cursor->y, &surface, &c, NULL, &sx, &sy);

Deletion in dwl.c at line 1406 [14.4]

∅:D[50.499] → [23.3041:3119]

B:BD[14.13393] → [23.3041:3119]

B:BD[23.3119] → [36.789:792]

∅:D[36.792] → [56.9:16]

B:BD[56.9] → [56.9:16]

B:BD[56.16] → [36.793:845]

B:BD[36.845] → [52.733:843]

∅:D[52.843] → [36.846:977]

B:BD[53.3007] → [36.846:977]

B:BD[36.1153] → [36.1153:1157]

B:BD[36.1157] → [2.3:132]

	/* Otherwise, find the client under the pointer and send the event along. */
	}
#endif
	else if ((c = xytoclient(cursor->x, cursor->y))) {
		surface = client_surface_at(c, cursor->x - c->geom.x - c->bw,
				cursor->y - c->geom.y - c->bw, &sx, &sy);
	}
	else if ((surface = xytolayersurface(&selmon->layers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM],
					cursor->x, cursor->y, &sx, &sy)))
		;
	else
		surface = xytolayersurface(&selmon->layers[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND],
					cursor->x, cursor->y, &sx, &sy);

Replacement in dwl.c at line 1435 [14.4]

B:BD[57.1996] → [6.4:82]

	if (cursor_mode != CurNormal || !(grabc = xytoclient(cursor->x, cursor->y)))

[57.1996]

[27.14160]

	if (cursor_mode != CurNormal)
		return;
	xytonode(cursor->x, cursor->y, NULL, &grabc, NULL, NULL, NULL);
	if (!grabc)

Deletion in dwl.c at line 1603 [14.4]

B:BD[10.77] → [10.77:85]

∅:D[10.85] → [57.2214:2280]

∅:D[19.390] → [57.2214:2280]

∅:D[26.1465] → [57.2214:2280]

∅:D[27.15888] → [57.2214:2280]

B:BD[57.2214] → [57.2214:2280]

∅:D[57.2280] → [14.18751:18862]

B:BD[14.18751] → [14.18751:18862]

∅:D[23.3645] → [14.18900:18944]

B:BD[14.18900] → [14.18900:18944]

B:BD[14.18944] → [47.3349:3450]

∅:D[58.1470] → [14.18944:19385]

∅:D[47.3450] → [14.18944:19385]

B:BD[14.18944] → [14.18944:19385]

B:BD[14.19385] → [59.1457:1472]

∅:D[59.1472] → [14.19409:19419]

B:BD[14.19409] → [14.19409:19419]

B:BD[14.19422] → [14.19422:19423]

B:BD[14.19423] → [23.3646:3804]

∅:D[23.3804] → [14.19577:19698]

B:BD[14.19577] → [14.19577:19698]

∅:D[44.3103] → [60.1:68]

B:BD[14.19698] → [60.1:68]

∅:D[25.56] → [14.19848:19985]

∅:D[60.68] → [14.19848:19985]

∅:D[23.3840] → [14.19848:19985]

B:BD[14.19848] → [14.19848:19985]

B:BD[14.19985] → [47.3451:3589]

∅:D[58.1609] → [33.153:186]

∅:D[44.3259] → [33.153:186]

∅:D[47.3589] → [33.153:186]

B:BD[14.20171] → [33.153:186]

∅:D[33.186] → [14.20171:20176]

B:BD[14.20171] → [14.20171:20176]

B:BD[14.20176] → [61.384:459]

∅:D[61.459] → [23.3841:4135]

B:BD[14.20252] → [23.3841:4135]

∅:D[23.4135] → [14.20544:20700]

B:BD[14.20544] → [14.20544:20700]

B:BD[14.20700] → [47.3590:3660]

∅:D[58.1680] → [62.514:567]

∅:D[44.3377] → [62.514:567]

∅:D[47.3660] → [62.514:567]

B:BD[14.20815] → [62.514:567]

∅:D[62.567] → [14.20867:21004]

B:BD[14.20867] → [14.20867:21004]

B:BD[14.21004] → [39.1854:1912]

∅:D[63.106] → [14.21074:21244]

∅:D[59.1531] → [14.21074:21244]

∅:D[39.1912] → [14.21074:21244]

∅:D[38.2973] → [14.21074:21244]

B:BD[14.21074] → [14.21074:21244]

B:BD[14.21244] → [11.97:174]

∅:D[11.174] → [14.21244:21247]

B:BD[14.21244] → [14.21244:21247]

B:BD[14.21247] → [27.15889:15894]

B:BD[27.15894] → [30.63:113]

B:BD[30.113] → [64.1:33]

B:BD[64.33] → [39.1913:2047]

∅:D[58.1776] → [30.113:271]

∅:D[39.2047] → [30.113:271]

∅:D[53.3071] → [30.113:271]

B:BD[30.113] → [30.113:271]

B:BD[30.283] → [30.283:329]

B:BD[30.329] → [65.1:64]

B:BD[65.151] → [65.151:213]

B:BD[65.213] → [66.770:816]

∅:D[65.256] → [30.522:535]

∅:D[66.816] → [30.522:535]

B:BD[30.522] → [30.522:535]

B:BD[30.535] → [67.1:2]

B:BD[67.2] → [52.912:943]

∅:D[52.943] → [39.2076:2110]

B:BD[39.2076] → [39.2076:2110]

∅:D[66.858] → [67.33:112]

∅:D[58.1811] → [67.33:112]

∅:D[39.2110] → [67.33:112]

∅:D[44.3467] → [67.33:112]

B:BD[67.33] → [67.33:112]

B:BD[68.209] → [68.209:210]

B:BD[68.210] → [69.1:358]

∅:D[69.358] → [64.55:56]

B:BD[67.483] → [64.55:56]

B:BD[64.56] → [69.359:606]

∅:D[69.606] → [67.692:696]

B:BD[67.692] → [67.692:696]

∅:D[67.696] → [30.535:536]

B:BD[30.535] → [30.535:536]

∅:D[70.50] → [30.644:750]

∅:D[71.53] → [30.644:750]

∅:D[68.220] → [30.644:750]

∅:D[72.223] → [30.644:750]

B:BD[30.644] → [30.644:750]

B:BD[30.750] → [39.2111:2225]

B:BD[39.2225] → [52.944:990]

∅:D[52.990] → [30.818:821]

∅:D[73.1041] → [30.818:821]

∅:D[74.1654] → [30.818:821]

∅:D[53.3365] → [30.818:821]

B:BD[30.818] → [30.818:821]

}
void
render(struct wlr_surface *surface, int sx, int sy, void *data)
{
	/* This function is called for every surface that needs to be rendered. */
	struct render_data *rdata = data;
	struct wlr_output *output = rdata->output;
	double ox = 0, oy = 0;
	struct wlr_box obox;
	float matrix[9];
	enum wl_output_transform transform;
	/* We first obtain a wlr_texture, which is a GPU resource. wlroots
	 * automatically handles negotiating these with the client. The underlying
	 * resource could be an opaque handle passed from the client, or the client
	 * could have sent a pixel buffer which we copied to the GPU, or a few other
	 * means. You don't have to worry about this, wlroots takes care of it. */
	struct wlr_texture *texture = wlr_surface_get_texture(surface);
	if (!texture)
		return;
	/* 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
	 * have layout coordinates of 2000,100. We need to translate that to
	 * output-local coordinates, or (2000 - 1920). */
	wlr_output_layout_output_coords(output_layout, output, &ox, &oy);
	/* We also have to apply the scale factor for HiDPI outputs. This is only
	 * part of the puzzle, dwl does not fully support HiDPI. */
	obox.x = ox + rdata->x + sx;
	obox.y = oy + rdata->y + sy;
	obox.width = surface->current.width;
	obox.height = surface->current.height;
	scalebox(&obox, output->scale);
	/*
	 * Those familiar with OpenGL are also familiar with the role of matrices
	 * 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
	 * transforms to produce a model-view-projection matrix.
	 *
	 * Naturally you can do this any way you like, for example to make a 3D
	 * compositor.
	 */
	transform = wlr_output_transform_invert(surface->current.transform);
	wlr_matrix_project_box(matrix, &obox, transform, 0,
		output->transform_matrix);
	/* This takes our matrix, the texture, and an alpha, and performs the actual
	 * rendering on the GPU. */
	wlr_render_texture_with_matrix(drw, texture, matrix, 1);
	/* This lets the client know that we've displayed that frame and it can
	 * prepare another one now if it likes. */
	wlr_surface_send_frame_done(surface, rdata->when);
	wlr_presentation_surface_sampled_on_output(presentation, surface, output);
}
void
renderclients(Monitor *m, struct timespec *now)
{
	Client *c, *sel = selclient();
	const float *color;
	double ox, oy;
	int i, w, h;
	struct render_data rdata;
	struct wlr_box *borders;
	struct wlr_surface *surface;
	/* Each subsequent window we render is rendered on top of the last. Because
	 * our stacking list is ordered front-to-back, we iterate over it backwards. */
	wl_list_for_each_reverse(c, &stack, slink) {
		/* Only render visible clients which show on this monitor */
		if (!VISIBLEON(c, c->mon) || !wlr_output_layout_intersects(
					output_layout, m->wlr_output, &c->geom))
			continue;
		surface = client_surface(c);
		ox = c->geom.x, oy = c->geom.y;
		wlr_output_layout_output_coords(output_layout, m->wlr_output,
				&ox, &oy);
		if (c->bw) {
			w = surface->current.width;
			h = surface->current.height;
			borders = (struct wlr_box[4]) {
				{ox, oy, w + 2 * c->bw, c->bw},             /* top */
				{ox, oy + c->bw, c->bw, h},                 /* left */
				{ox + c->bw + w, oy + c->bw, c->bw, h},     /* right */
				{ox, oy + c->bw + h, w + 2 * c->bw, c->bw}, /* bottom */
			};
			/* Draw window borders */
			color = (c == sel) ? focuscolor : bordercolor;
			for (i = 0; i < 4; i++) {
				scalebox(&borders[i], m->wlr_output->scale);
				wlr_render_rect(drw, &borders[i], color,
						m->wlr_output->transform_matrix);
			}
		}
		/* This calls our render function for each surface among the
		 * xdg_surface's toplevel and popups. */
		rdata.output = m->wlr_output;
		rdata.when = now;
		rdata.x = c->geom.x + c->bw;
		rdata.y = c->geom.y + c->bw;
		client_for_each_surface(c, render, &rdata);
	}

Deletion in dwl.c at line 1606 [14.4]
B:BD[75.170] → [31.83:149]
∅:D[31.149] → [75.226:228]
B:BD[75.226] → [75.226:228]
∅:D[31.177] → [75.228:257]
B:BD[75.228] → [75.228:257]
B:BD[75.257] → [31.178:234]
B:BD[31.234] → [44.3818:3978]
∅:D[31.374] → [75.748:749]
∅:D[44.3978] → [75.748:749]
B:BD[75.748] → [75.748:749]
B:BD[75.749] → [31.375:465]
∅:D[31.465] → [75.776:779]
B:BD[75.776] → [75.776:779]
B:BD[75.1311] → [75.1311:1319]
```
renderlayer(struct wl_list *layer_surfaces, struct timespec *now)
{
	LayerSurface *layersurface;
	wl_list_for_each(layersurface, layer_surfaces, link) {
		struct render_data rdata = {
			.output = layersurface->layer_surface->output,
			.when = now,
			.x = layersurface->geo.x,
			.y = layersurface->geo.y,
		};
		wlr_surface_for_each_surface(layersurface->layer_surface->surface,
				render, &rdata);
	}
}
void
```
Replacement in dwl.c at line 1609 [14.4]
B:BD[47.3673] → [47.3673:3690]
```
	int render = 1;
```
[47.3673]
[47.3690]
```
	int skip = 0;
```
Replacement in dwl.c at line 1618 [14.4]
B:BD[76.528] → [76.528:596]
∅:D[77.1396] → [78.98:155]
∅:D[39.2243] → [78.98:155]
∅:D[44.4008] → [78.98:155]
B:BD[76.596] → [78.98:155]
B:BD[78.155] → [52.991:1048]
∅:D[52.1048] → [39.2244:2259]
B:BD[76.710] → [39.2244:2259]
∅:D[77.1416] → [76.725:732]
∅:D[39.2259] → [76.725:732]
B:BD[76.725] → [76.725:732]
```
	/* Do not render if any XDG clients have an outstanding resize. */
	wl_list_for_each(c, &stack, slink) {
		if (c->resize) {
			wlr_surface_send_frame_done(client_surface(c), &now);
			render = 0;
		}
	}
```
[76.528]
[14.21647]
```
	/* Skip rendering if any XDG clients have an outstanding resize. */
	wl_list_for_each(c, &clients, link)
		skip = skip || c->resize;
```
Replacement in dwl.c at line 1630 [14.4]
B:BD[14.22154] → [9.296:312]
```
		if (render) {
```
[14.22154]
[9.312]
```
		if (!skip) {
```
Deletion in dwl.c at line 1634 [14.4]
∅:D[63.277] → [76.787:788]
∅:D[9.503] → [76.787:788]
∅:D[39.2370] → [76.787:788]
B:BD[76.787] → [76.787:788]
B:BD[76.788] → [9.504:671]
∅:D[9.671] → [40.1362:1378]
∅:D[75.1579] → [40.1362:1378]
B:BD[76.814] → [40.1362:1378]
B:BD[40.1378] → [9.672:716]
∅:D[9.716] → [40.1379:1386]
B:BD[79.44] → [40.1379:1386]
B:BD[40.1386] → [9.717:851]
```
			renderlayer(&m->layers[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND], &now);
			renderlayer(&m->layers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM], &now);
			renderclients(m, &now);
#ifdef XWAYLAND
			renderindependents(m->wlr_output, &now);
#endif
			renderlayer(&m->layers[ZWLR_LAYER_SHELL_V1_LAYER_TOP], &now);
			renderlayer(&m->layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY], &now);
```

Replacement in dwl.c at line 1635 [14.4]

B:BD[15.581] → [9.852:1377]

			/* Hardware cursors are rendered by the GPU on a separate plane, and can be
			 * moved around without re-rendering what's beneath them - which is more
			 * efficient. However, not all hardware supports hardware cursors. For this
			 * reason, wlroots provides a software fallback, which we ask it to render
			 * here. wlr_cursor handles configuring hardware vs software cursors for you,
			 * and this function is a no-op when hardware cursors are in use. */
			wlr_output_render_software_cursors(m->wlr_output, NULL);

[15.581]

[14.23331]

			/* Render the scene at (-mx, -my) to get this monitor's view.
			 * wlroots will not render windows falling outside the box. */
			wlr_scene_render_output(scene, m->wlr_output, -m->m.x, -m->m.y, NULL);

Insertion in dwl.c at line 1643 [14.4]
[9.1499]
[80.788]
```
	} while (!wlr_output_commit(m->wlr_output));
```

Replacement in dwl.c at line 1645 [14.4]

B:BD[80.789] → [9.1500:1546]

	} while (!wlr_output_commit(m->wlr_output));

[80.789]

[14.23488]

	/* Let clients know a frame has been rendered */
	wl_list_for_each(c, &clients, link)
		wlr_surface_send_frame_done(client_surface(c), &now);

Deletion in dwl.c at line 1653 [14.4]

B:BD[24.1316] → [81.1:201]

	/*
	 * Note that I took some shortcuts here. In a more fleshed-out
	 * compositor, you'd wait for the client to prepare a buffer at
	 * the new size, then commit any movement that was prepared.
	 */

Insertion in dwl.c at line 1659 [14.4]

[82.875]

[83.332]


	/* Update scene-graph, including borders */
	wlr_scene_node_set_position(c->scene, c->geom.x, c->geom.y);
	wlr_scene_node_set_position(c->scene_surface, c->bw, 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->border[3]->node, c->geom.width - c->bw, c->bw);

Deletion in dwl.c at line 1732 [14.4]

B:BD[32.1458] → [84.240:243]

B:BD[84.243] → [33.187:237]

B:BD[33.237] → [85.75:297]

}
void
scalebox(struct wlr_box *box, float scale)
{
	box->width =  ROUND((box->x + box->width) * scale) -  ROUND(box->x * scale);
	box->height = ROUND((box->y + box->height) * scale) - ROUND(box->y * scale);
	box->x = ROUND(box->x * scale);
	box->y = ROUND(box->y * scale);

Insertion in dwl.c at line 1766 [14.4]

[86.210]

[87.162]

	wlr_scene_node_reparent(c->scene, layers[c->isfloating ? LyrFloat : LyrTile]);

Replacement in dwl.c at line 1813 [14.4]

B:BD[88.381] → [88.381:406]

		applybounds(c, &m->m);

[88.381]

[52.1207]

		resize(c, c->geom.x, c->geom.y, c->geom.width, c->geom.height, 0);

Insertion in dwl.c at line 1866 [14.4]

[14.30942]

	/* Initialize the scene graph used to lay out windows */
	scene = wlr_scene_create();
	layers[LyrBg] = &wlr_scene_tree_create(&scene->node)->node;
	layers[LyrBottom] = &wlr_scene_tree_create(&scene->node)->node;
	layers[LyrTile] = &wlr_scene_tree_create(&scene->node)->node;
	layers[LyrFloat] = &wlr_scene_tree_create(&scene->node)->node;
	layers[LyrTop] = &wlr_scene_tree_create(&scene->node)->node;
	layers[LyrOverlay] = &wlr_scene_tree_create(&scene->node)->node;

Deletion in dwl.c at line 1919 [14.4]
B:BD[18.492] → [19.587:610]
```
	wl_list_init(&stack);
```
Replacement in dwl.c at line 2166 [14.4]
B:BD[18.521] → [19.611:639]
```
	wl_list_remove(&c->slink);
```
[18.521]
[20.25980]
```
	wlr_scene_node_destroy(c->scene);
```

Replacement in dwl.c at line 2250 [14.4]

∅:D[34.739] → [32.1900:1909]

B:BD[14.35516] → [32.1900:1909]

B:BD[32.1909] → [35.323:354]

Client *
xytoclient(double x, double y)

[34.739]

[32.1998]

struct wlr_scene_node *
xytonode(double x, double y, struct wlr_surface **psurface,
		Client **pc, LayerSurface **pl, double *nx, double *ny)

Replacement in dwl.c at line 2254 [14.4]

B:BD[32.2000] → [35.355:427]

∅:D[35.427] → [89.74:145]

B:BD[89.74] → [89.74:145]

∅:D[89.145] → [32.2150:2162]

∅:D[90.200] → [32.2150:2162]

∅:D[19.710] → [32.2150:2162]

B:BD[32.2150] → [32.2150:2162]

B:BD[32.2162] → [35.428:534]

B:BD[35.534] → [50.561:590]

	/* Find the topmost visible client (if any) at point (x, y), including
	 * borders. This relies on stack being ordered from top to bottom. */
	Client *c;
	wl_list_for_each(c, &stack, slink)
		if (VISIBLEON(c, c->mon) && wlr_box_contains_point(&c->geom, x, y))
			return c;
	return NULL;
}

[32.2000]

[50.590]

	struct wlr_scene_node *node, *pnode;
	struct wlr_surface *surface = NULL;
	Client *c = NULL;
	LayerSurface *l = NULL;

Replacement in dwl.c at line 2259 [14.4]

B:BD[50.591] → [36.1179:1390]

B:BD[36.1390] → [91.55:82]

B:BD[91.82] → [92.93:137]

∅:D[92.137] → [91.113:167]

B:BD[91.113] → [91.113:167]

∅:D[91.167] → [36.1451:1581]

B:BD[36.1451] → [36.1451:1581]

struct wlr_surface *
xytolayersurface(struct wl_list *layer_surfaces, double x, double y,
		double *sx, double *sy)
{
	LayerSurface *layersurface;
	wl_list_for_each_reverse(layersurface, layer_surfaces, link) {
		struct wlr_surface *sub;
		if (!layersurface->layer_surface->mapped)
			continue;
		sub = wlr_layer_surface_v1_surface_at(
				layersurface->layer_surface,
				x - layersurface->geo.x,
				y - layersurface->geo.y,
				sx, sy);
		if (sub)
			return sub;

[50.591]

[36.1581]

	if ((node = wlr_scene_node_at(&scene->node, x, y, nx, ny))) {
		if (node->type == WLR_SCENE_NODE_SURFACE)
			surface = wlr_scene_surface_from_node(node)->surface;
		/* Walk the tree to find a node that knows the client */
		for (pnode = node; pnode && !c; pnode = pnode->parent)
			c = pnode->data;
		if (c && c->type == LayerShell) {
			c = NULL;
			l = pnode->data;
		}
	}

Replacement in dwl.c at line 2271 [14.4]

B:BD[36.1582] → [36.1582:1599]

	}
	return NULL;

[36.1582]

[36.1599]

	if (psurface) *psurface = surface;
	if (pc) *pc = c;
	if (pl) *pl = l;
	return node;

Deletion in dwl.c at line 2376 [14.4]

B:BD[40.2864] → [40.2864:2954]

B:BD[40.2954] → [4.60:109]

∅:D[4.109] → [40.3003:3056]

B:BD[40.3003] → [40.3003:3056]

B:BD[40.3056] → [4.110:268]

∅:D[4.268] → [40.3214:3357]

∅:D[44.4563] → [40.3214:3357]

B:BD[40.3214] → [40.3214:3357]

∅:D[44.4701] → [40.3475:3476]

B:BD[40.3475] → [40.3475:3476]

B:BD[40.3476] → [4.269:386]

∅:D[4.386] → [40.3476:3557]

B:BD[40.3476] → [40.3476:3557]

}
void
renderindependents(struct wlr_output *output, struct timespec *now)
{
	Client *c;
	struct render_data rdata;
	struct wlr_box geom;
	wl_list_for_each_reverse(c, &independents, link) {
		geom.x = c->surface.xwayland->x;
		geom.y = c->surface.xwayland->y;
		geom.width = c->surface.xwayland->width;
		geom.height = c->surface.xwayland->height;
		/* Only render visible clients which show on this output */
		if (!wlr_output_layout_intersects(output_layout, output, &geom))
			continue;
		rdata.output = output;
		rdata.when = now;
		rdata.x = c->surface.xwayland->x;
		rdata.y = c->surface.xwayland->y;
		wlr_surface_for_each_surface(c->surface.xwayland->surface, render, &rdata);
	}

Deletion in dwl.c at line 2407 [14.4]

B:BD[40.4863] → [41.215:581]

B:BD[41.603] → [41.603:655]

B:BD[41.655] → [44.4770:4947]

∅:D[44.4947] → [41.813:886]

B:BD[41.813] → [41.813:886]

}
Client *
xytoindependent(double x, double y)
{
	/* Find the topmost visible independent at point (x, y).
	 * For independents, the most recently created can be used as the "top".
	 * We rely on the X11 convention of unmapping unmanaged when the "owning"
	 * client loses focus, which ensures that unmanaged are only visible on
	 * the current tag. */
	Client *c;
	wl_list_for_each_reverse(c, &independents, link) {
		struct wlr_box geom = {
			.x = c->surface.xwayland->x,
			.y = c->surface.xwayland->y,
			.width = c->surface.xwayland->width,
			.height = c->surface.xwayland->height,
		};
		if (wlr_box_contains_point(&geom, x, y))
			return c;
	}
	return NULL;

use scene-graph API for Client/LayerSurface

Dependencies

In channels

Change contents

Insertion in dwl.c at line 36 [14.4]

Deletion in dwl.c at line 64 [14.4]

Insertion in dwl.c at line 69 [14.4]

Insertion in dwl.c at line 93 [14.4]

Deletion in dwl.c at line 98 [14.4]

Replacement in dwl.c at line 149 [14.4]

Insertion in dwl.c at line 151 [14.4]

Deletion in dwl.c at line 210 [14.4]

Deletion in dwl.c at line 264 [14.4]

Deletion in dwl.c at line 267 [14.4]