mirrors/labwc
1
0
Fork 0
mirror of https://github.com/labwc/labwc.git synced 2026-03-29 07:58:10 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Handle layers under the scene-graph API

Browse source 
This excludes popups.
This commit is contained in:
Johan Malm 2022-02-20 13:15:58 +00:00
parent 9fed8e0998
commit 688abf7db1
5 changed files with 249 additions and 438 deletions
Download patch file Download diff file Expand all files Collapse all files

1
include/labwc.h
View file

@ -185,6 +185,7 @@ struct output {
struct wlr_output *wlr_output; struct wlr_output *wlr_output;
struct wlr_scene_output *scene_output; struct wlr_scene_output *scene_output;
struct wl_list layers[4]; struct wl_list layers[4];
struct wlr_scene_tree *layer_tree[4];
struct wlr_box usable_area; struct wlr_box usable_area;
struct lab_data_buffer *osd_buffer; struct lab_data_buffer *osd_buffer;

4
include/layers.h
View file

@ -12,8 +12,8 @@ enum layer_parent {
}; };
struct lab_layer_surface { struct lab_layer_surface {
struct wlr_layer_surface_v1 *layer_surface; struct wl_list link; /* output::layers[] */
struct wl_list link; struct wlr_scene_layer_surface_v1 *scene_layer_surface;
struct wl_listener destroy; struct wl_listener destroy;
struct wl_listener map; struct wl_listener map;

30
src/debug.c
View file

@ -1,4 +1,5 @@
// SPDX-License-Identifier: GPL-2.0-only // SPDX-License-Identifier: GPL-2.0-only
#include <wlr/types/wlr_layer_shell_v1.h>
#include <wlr/types/wlr_scene.h> #include <wlr/types/wlr_scene.h>
#include "buffer.h" #include "buffer.h"
#include "labwc.h" #include "labwc.h"
@ -40,6 +41,23 @@ dump_tree(struct wlr_scene_node *node, int pos, int x, int y)
} }
} }
static char *
get_layer_name(uint32_t layer)
{
switch (layer) {
case ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND:
return "background";
case ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM:
return "bottom";
case ZWLR_LAYER_SHELL_V1_LAYER_TOP:
return "top";
case ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY:
return "overlay";
default:
abort();
}
}
void void
debug_dump_scene(struct server *server) debug_dump_scene(struct server *server)
{ {
@ -49,7 +67,13 @@ debug_dump_scene(struct server *server)
node = &server->view_tree->node; node = &server->view_tree->node;
dump_tree(node, 0, node->state.x, node->state.y); dump_tree(node, 0, node->state.x, node->state.y);
printf(":: osd_tree ::\n"); printf(":: layer_tree ::\n");
node = &server->osd_tree->node; struct output *output;
dump_tree(node, 0, node->state.x, node->state.y); wl_list_for_each(output, &server->outputs, link) {
for (int i = 0; i < 4; i++) {
node = &output->layer_tree[i]->node;
printf("layer-%s\n", get_layer_name(i));
dump_tree(node, 0, node->state.x, node->state.y);
}
}
} }

621
src/layers.c
View file

@ -17,195 +17,38 @@
#include "layers.h" #include "layers.h"
#include "labwc.h" #include "labwc.h"
static void
apply_exclusive(struct wlr_box *usable_area, uint32_t anchor, int32_t exclusive,
int32_t margin_top, int32_t margin_right, int32_t margin_bottom,
int32_t margin_left)
{
if (exclusive <= 0) {
return;
}
struct {
uint32_t anchors;
int *positive_axis;
int *negative_axis;
int margin;
} edges[] = {
{
.anchors =
ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT |
ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT |
ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP,
.positive_axis = &usable_area->y,
.negative_axis = &usable_area->height,
.margin = margin_top,
},
{
.anchors =
ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT |
ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT |
ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM,
.positive_axis = NULL,
.negative_axis = &usable_area->height,
.margin = margin_bottom,
},
{
.anchors =
ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT |
ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP |
ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM,
.positive_axis = &usable_area->x,
.negative_axis = &usable_area->width,
.margin = margin_left,
},
{
.anchors =
ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT |
ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP |
ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM,
.positive_axis = NULL,
.negative_axis = &usable_area->width,
.margin = margin_right,
},
};
for (size_t i = 0; i < sizeof(edges) / sizeof(edges[0]); ++i) {
if ((anchor & edges[i].anchors) == edges[i].anchors) {
if (edges[i].positive_axis) {
*edges[i].positive_axis +=
exclusive + edges[i].margin;
}
if (edges[i].negative_axis) {
*edges[i].negative_axis -=
exclusive + edges[i].margin;
}
}
}
}
/**
* @list: struct lab_layer_surface
*/
static void
arrange_layer(struct wlr_output *output, struct wl_list *list,
struct wlr_box *usable_area, bool exclusive)
{
struct lab_layer_surface *surface;
struct wlr_box full_area = { 0 };
wlr_output_effective_resolution(output, &full_area.width,
&full_area.height);
wl_list_for_each_reverse(surface, list, link) {
struct wlr_layer_surface_v1 *layer = surface->layer_surface;
struct wlr_layer_surface_v1_state *state = &layer->current;
if (exclusive != (state->exclusive_zone > 0)) {
continue;
}
struct wlr_box bounds;
if (state->exclusive_zone == -1) {
bounds = full_area;
} else {
bounds = *usable_area;
}
struct wlr_box box = {
.width = state->desired_width,
.height = state->desired_height
};
/* Horizontal axis */
const uint32_t both_horiz = ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT
| ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT;
if ((state->anchor & both_horiz) && box.width == 0) {
box.x = bounds.x;
box.width = bounds.width;
} else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT)) {
box.x = bounds.x;
} else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT)) {
box.x = bounds.x + (bounds.width - box.width);
} else {
box.x = bounds.x + ((bounds.width / 2) - (box.width / 2));
}
/* Vertical axis */
const uint32_t both_vert = ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP
| ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM;
if ((state->anchor & both_vert) && box.height == 0) {
box.y = bounds.y;
box.height = bounds.height;
} else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP)) {
box.y = bounds.y;
} else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM)) {
box.y = bounds.y + (bounds.height - box.height);
} else {
box.y = bounds.y + ((bounds.height / 2) - (box.height / 2));
}
/* Margin */
if ((state->anchor & both_horiz) == both_horiz) {
box.x += state->margin.left;
box.width -= state->margin.left + state->margin.right;
} else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT)) {
box.x += state->margin.left;
} else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT)) {
box.x -= state->margin.right;
}
if ((state->anchor & both_vert) == both_vert) {
box.y += state->margin.top;
box.height -= state->margin.top + state->margin.bottom;
} else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP)) {
box.y += state->margin.top;
} else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM)) {
box.y -= state->margin.bottom;
}
if (box.width < 0 || box.height < 0) {
wlr_log(WLR_ERROR, "surface has no positive size");
continue;
}
/* Apply */
surface->geo = box;
apply_exclusive(usable_area, state->anchor,
state->exclusive_zone, state->margin.top,
state->margin.right, state->margin.bottom,
state->margin.left);
wlr_layer_surface_v1_configure(layer, box.width, box.height);
}
}
void void
arrange_layers(struct output *output) arrange_layers(struct output *output)
{ {
assert(output); struct server *server = output->server;
struct wlr_scene_output *scene_output =
wlr_scene_get_scene_output(server->scene, output->wlr_output);
struct wlr_box usable_area = { 0 }; struct wlr_box full_area = { 0 };
wlr_output_effective_resolution(output->wlr_output, wlr_output_effective_resolution(output->wlr_output,
&usable_area.width, &usable_area.height); &full_area.width, &full_area.height);
struct wlr_box usable_area = full_area;
/* Exclusive surfaces */ for (int i = 0; i < 4; i++) {
arrange_layer(output->wlr_output, struct lab_layer_surface *lab_layer_surface;
&output->layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY], wl_list_for_each(lab_layer_surface, &output->layers[i], link) {
&usable_area, true); struct wlr_scene_layer_surface_v1 *scene_layer_surface =
arrange_layer(output->wlr_output, lab_layer_surface->scene_layer_surface;
&output->layers[ZWLR_LAYER_SHELL_V1_LAYER_TOP], wlr_scene_layer_surface_v1_configure(
&usable_area, true); scene_layer_surface, &full_area, &usable_area);
arrange_layer(output->wlr_output, }
&output->layers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM], }
&usable_area, true);
arrange_layer(output->wlr_output,
&output->layers[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND],
&usable_area, true);
memcpy(&output->usable_area, &usable_area, sizeof(struct wlr_box));
/* TODO: re-arrange all views taking into account updated usable_area */ for (int i = 0; i < 4; i++) {
struct wlr_scene_node *node = &output->layer_tree[i]->node;
wlr_scene_node_set_position(node,
scene_output->x + usable_area.x,
scene_output->y + usable_area.y);
}
/* Non-exclusive surfaces */
arrange_layer(output->wlr_output, /* TODO: workout how we set this */
&output->layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY], // memcpy(&output->usable_area, &usable_area, sizeof(struct wlr_box));
&usable_area, false);
arrange_layer(output->wlr_output,
&output->layers[ZWLR_LAYER_SHELL_V1_LAYER_TOP],
&usable_area, false);
arrange_layer(output->wlr_output,
&output->layers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM],
&usable_area, false);
arrange_layer(output->wlr_output,
&output->layers[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND],
&usable_area, false);
/* Find topmost keyboard interactive layer, if such a layer exists */ /* Find topmost keyboard interactive layer, if such a layer exists */
uint32_t layers_above_shell[] = { uint32_t layers_above_shell[] = {
@ -217,7 +60,7 @@ arrange_layers(struct output *output)
for (size_t i = 0; i < nlayers; ++i) { for (size_t i = 0; i < nlayers; ++i) {
wl_list_for_each_reverse (layer, wl_list_for_each_reverse (layer,
&output->layers[layers_above_shell[i]], link) { &output->layers[layers_above_shell[i]], link) {
if (layer->layer_surface->current.keyboard_interactive) { if (layer->scene_layer_surface->layer_surface->current.keyboard_interactive) {
topmost = layer; topmost = layer;
break; break;
} }
@ -228,7 +71,8 @@ arrange_layers(struct output *output)
} }
struct seat *seat = &output->server->seat; struct seat *seat = &output->server->seat;
if (topmost) { if (topmost) {
seat_set_focus_layer(seat, topmost->layer_surface); seat_set_focus_layer(seat,
topmost->scene_layer_surface->layer_surface);
} else if (seat->focused_layer && } else if (seat->focused_layer &&
!seat->focused_layer->current.keyboard_interactive) { !seat->focused_layer->current.keyboard_interactive) {
seat_set_focus_layer(seat, NULL); seat_set_focus_layer(seat, NULL);
@ -240,9 +84,8 @@ output_destroy_notify(struct wl_listener *listener, void *data)
{ {
struct lab_layer_surface *layer = struct lab_layer_surface *layer =
wl_container_of(listener, layer, output_destroy); wl_container_of(listener, layer, output_destroy);
layer->layer_surface->output = NULL;
wl_list_remove(&layer->output_destroy.link); wl_list_remove(&layer->output_destroy.link);
wlr_layer_surface_v1_destroy(layer->layer_surface); wlr_layer_surface_v1_destroy(layer->scene_layer_surface->layer_surface);
} }
static void static void
@ -250,8 +93,10 @@ surface_commit_notify(struct wl_listener *listener, void *data)
{ {
struct lab_layer_surface *layer = struct lab_layer_surface *layer =
wl_container_of(listener, layer, surface_commit); wl_container_of(listener, layer, surface_commit);
struct wlr_layer_surface_v1 *layer_surface = layer->layer_surface; struct wlr_layer_surface_v1 *layer_surface =
struct wlr_output *wlr_output = layer->layer_surface->output; layer->scene_layer_surface->layer_surface;
struct wlr_output *wlr_output =
layer->scene_layer_surface->layer_surface->output;
if (!wlr_output) { if (!wlr_output) {
return; return;
@ -264,14 +109,13 @@ surface_commit_notify(struct wl_listener *listener, void *data)
output_from_wlr_output(layer->server, wlr_output); output_from_wlr_output(layer->server, wlr_output);
arrange_layers(output); arrange_layers(output);
} }
damage_all_outputs(layer->server);
} }
static void static void
unmap(struct lab_layer_surface *layer) unmap(struct lab_layer_surface *layer)
{ {
struct seat *seat = &layer->server->seat; struct seat *seat = &layer->server->seat;
if (seat->focused_layer == layer->layer_surface) { if (seat->focused_layer == layer->scene_layer_surface->layer_surface) {
seat_set_focus_layer(seat, NULL); seat_set_focus_layer(seat, NULL);
} }
damage_all_outputs(layer->server); damage_all_outputs(layer->server);
@ -282,17 +126,19 @@ destroy_notify(struct wl_listener *listener, void *data)
{ {
struct lab_layer_surface *layer = wl_container_of( struct lab_layer_surface *layer = wl_container_of(
listener, layer, destroy); listener, layer, destroy);
if (layer->layer_surface->mapped) { if (layer->scene_layer_surface->layer_surface->mapped) {
unmap(layer); unmap(layer);
} }
/* TODO: sort this out properly */
wl_list_remove(&layer->link); wl_list_remove(&layer->link);
wl_list_remove(&layer->destroy.link); wl_list_remove(&layer->destroy.link);
wl_list_remove(&layer->map.link); wl_list_remove(&layer->map.link);
wl_list_remove(&layer->surface_commit.link); wl_list_remove(&layer->surface_commit.link);
if (layer->layer_surface->output) { if (layer->scene_layer_surface->layer_surface->output) {
wl_list_remove(&layer->output_destroy.link); wl_list_remove(&layer->output_destroy.link);
struct output *output = output_from_wlr_output( struct output *output = output_from_wlr_output(
layer->server, layer->layer_surface->output); layer->server, layer->scene_layer_surface->layer_surface->output);
arrange_layers(output); arrange_layers(output);
} }
free(layer); free(layer);
@ -312,224 +158,149 @@ map_notify(struct wl_listener *listener, void *data)
wlr_surface_send_enter(l->surface, l->output); wlr_surface_send_enter(l->surface, l->output);
} }
static void //static struct
subsurface_damage(struct lab_layer_subsurface *subsurface, bool whole) //lab_layer_surface *popup_get_layer(struct lab_layer_popup *popup)
{ //{
struct lab_layer_surface *layer = subsurface->layer_surface; // while (popup->parent_type == LAYER_PARENT_POPUP) {
struct wlr_output *wlr_output = layer->layer_surface->output; // popup = popup->parent_popup;
if (!wlr_output) { // }
return; // return popup->parent_layer;
} //}
// struct output *output = wlr_output->data; //
// int ox = subsurface->wlr_subsurface->current.x + layer->geo.x; //static void
// int oy = subsurface->wlr_subsurface->current.y + layer->geo.y; //popup_damage(struct lab_layer_popup *layer_popup, bool whole)
damage_all_outputs(layer->server); //{
} // struct lab_layer_surface *layer;
// while (true) {
static void // if (layer_popup->parent_type == LAYER_PARENT_POPUP) {
subsurface_handle_unmap(struct wl_listener *listener, void *data) // layer_popup = layer_popup->parent_popup;
{ // } else {
struct lab_layer_subsurface *subsurface = // layer = layer_popup->parent_layer;
wl_container_of(listener, subsurface, unmap); // break;
subsurface_damage(subsurface, true); // }
} // }
// damage_all_outputs(layer->server);
static void //}
subsurface_handle_map(struct wl_listener *listener, void *data) //
{ //static void
struct lab_layer_subsurface *subsurface = //popup_handle_map(struct wl_listener *listener, void *data)
wl_container_of(listener, subsurface, map); //{
subsurface_damage(subsurface, true); // struct lab_layer_popup *popup = wl_container_of(listener, popup, map);
} // struct lab_layer_surface *layer = popup_get_layer(popup);
// struct wlr_output *wlr_output = layer->scene_layer_surface->layer_surface->output;
static void // wlr_surface_send_enter(popup->wlr_popup->base->surface, wlr_output);
subsurface_handle_commit(struct wl_listener *listener, void *data) // popup_damage(popup, true);
{ //}
struct lab_layer_subsurface *subsurface = //
wl_container_of(listener, subsurface, commit); //static void
subsurface_damage(subsurface, false); //popup_handle_unmap(struct wl_listener *listener, void *data)
} //{
// struct lab_layer_popup *popup = wl_container_of(listener, popup, unmap);
static void // popup_damage(popup, true);
subsurface_handle_destroy(struct wl_listener *listener, void *data) //}
{ //
struct lab_layer_subsurface *subsurface = //static void
wl_container_of(listener, subsurface, destroy); //popup_handle_commit(struct wl_listener *listener, void *data)
//{
wl_list_remove(&subsurface->map.link); // struct lab_layer_popup *popup = wl_container_of(listener, popup, commit);
wl_list_remove(&subsurface->unmap.link); // popup_damage(popup, false);
wl_list_remove(&subsurface->destroy.link); //}
wl_list_remove(&subsurface->commit.link); //
free(subsurface); //static void
} //popup_handle_destroy(struct wl_listener *listener, void *data)
//{
static struct // struct lab_layer_popup *popup =
lab_layer_subsurface *create_subsurface(struct wlr_subsurface *wlr_subsurface, // wl_container_of(listener, popup, destroy);
struct lab_layer_surface *layer_surface) // wl_list_remove(&popup->destroy.link);
{ // free(popup);
struct lab_layer_subsurface *subsurface = //}
calloc(1, sizeof(struct lab_layer_subsurface)); //
if (!subsurface) { //static void
return NULL; //popup_unconstrain(struct lab_layer_popup *popup)
} //{
// struct lab_layer_surface *layer = popup_get_layer(popup);
subsurface->wlr_subsurface = wlr_subsurface; // struct wlr_xdg_popup *wlr_popup = popup->wlr_popup;
subsurface->layer_surface = layer_surface; // struct output *output = layer->scene_layer_surface->layer_surface->output->data;
//
subsurface->map.notify = subsurface_handle_map; // struct wlr_box output_box = { 0 };
wl_signal_add(&wlr_subsurface->events.map, &subsurface->map); // wlr_output_effective_resolution(output->wlr_output, &output_box.width,
subsurface->unmap.notify = subsurface_handle_unmap; // &output_box.height);
wl_signal_add(&wlr_subsurface->events.unmap, &subsurface->unmap); //
subsurface->destroy.notify = subsurface_handle_destroy; // struct wlr_box output_toplevel_sx_box = {
wl_signal_add(&wlr_subsurface->events.destroy, &subsurface->destroy); // .x = -layer->geo.x,
subsurface->commit.notify = subsurface_handle_commit; // .y = -layer->geo.y,
wl_signal_add(&wlr_subsurface->surface->events.commit, // .width = output_box.width,
&subsurface->commit); // .height = output_box.height,
// };
return subsurface; //
} // wlr_xdg_popup_unconstrain_from_box(wlr_popup, &output_toplevel_sx_box);
//}
static void //
new_subsurface_notify(struct wl_listener *listener, void *data) //static void popup_handle_new_popup(struct wl_listener *listener, void *data);
{ //
struct lab_layer_surface *lab_layer_surface = //static struct lab_layer_popup *
wl_container_of(listener, lab_layer_surface, new_subsurface); //create_popup(struct wlr_xdg_popup *wlr_popup,
struct wlr_subsurface *wlr_subsurface = data; // enum layer_parent parent_type, void *parent)
create_subsurface(wlr_subsurface, lab_layer_surface); //{
} // struct lab_layer_popup *popup =
// calloc(1, sizeof(struct lab_layer_popup));
// if (!popup) {
static struct // return NULL;
lab_layer_surface *popup_get_layer(struct lab_layer_popup *popup) // }
{ //
while (popup->parent_type == LAYER_PARENT_POPUP) { // struct lab_layer_surface *layer = parent_type == LAYER_PARENT_LAYER
popup = popup->parent_popup; // ? (struct lab_layer_surface *)parent
} // : (struct lab_layer_popup *)parent;
return popup->parent_layer; // struct server *server = layer->server;
} //
// popup->wlr_popup = wlr_popup;
static void // popup->parent_type = parent_type;
popup_damage(struct lab_layer_popup *layer_popup, bool whole) // popup->parent_layer = parent;
{ //
struct lab_layer_surface *layer; // popup->destroy.notify = popup_handle_destroy;
while (true) { // wl_signal_add(&wlr_popup->base->events.destroy, &popup->destroy);
if (layer_popup->parent_type == LAYER_PARENT_POPUP) { // popup->new_popup.notify = popup_handle_new_popup;
layer_popup = layer_popup->parent_popup; // wl_signal_add(&wlr_popup->base->events.new_popup, &popup->new_popup);
} else { //
layer = layer_popup->parent_layer; // if (!wlr_surface_is_layer_surface(wlr_popup->base->surface)) {
break; // wlr_log(WLR_ERROR, "xdg_surface is not layer surface");
} // return;
} // }
damage_all_outputs(layer->server); //
} // struct wlr_output *wlr_output =
// layer->scene_layer_surface->layer_surface->data;
static void // struct output *output = output_from_wlr_output(server, wlr_output);
popup_handle_map(struct wl_listener *listener, void *data) //
{ // struct wlr_scene_tree *selected_layer =
struct lab_layer_popup *popup = wl_container_of(listener, popup, map); // output->layer_tree[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY];
struct lab_layer_surface *layer = popup_get_layer(popup); // struct wlr_scene_node *node =
struct wlr_output *wlr_output = layer->layer_surface->output; // wlr_scene_layer_surface_v1_create(&server->view_tree->node,
wlr_surface_send_enter(popup->wlr_popup->base->surface, wlr_output); // wlr_popup->base->surface->data);
popup_damage(popup, true); // wlr_popup->base->surface->data =
} // wlr_scene_xdg_surface_create(&selected_layer->node, wlr_popup->base);
//
static void // popup_unconstrain(popup);
popup_handle_unmap(struct wl_listener *listener, void *data) //
{ // return popup;
struct lab_layer_popup *popup = wl_container_of(listener, popup, unmap); //}
popup_damage(popup, true); //
} //static void
//popup_handle_new_popup(struct wl_listener *listener, void *data)
static void //{
popup_handle_commit(struct wl_listener *listener, void *data) // struct lab_layer_popup *lab_layer_popup =
{ // wl_container_of(listener, lab_layer_popup, new_popup);
struct lab_layer_popup *popup = wl_container_of(listener, popup, commit); // struct wlr_xdg_popup *wlr_popup = data;
popup_damage(popup, false); // create_popup(wlr_popup, LAYER_PARENT_POPUP, lab_layer_popup);
} //}
//
static void //static void
popup_handle_destroy(struct wl_listener *listener, void *data) //new_popup_notify(struct wl_listener *listener, void *data)
{ //{
struct lab_layer_popup *popup = // struct lab_layer_surface *lab_layer_surface =
wl_container_of(listener, popup, destroy); // wl_container_of(listener, lab_layer_surface, new_popup);
// struct wlr_xdg_popup *wlr_popup = data;
wl_list_remove(&popup->map.link); // create_popup(wlr_popup, LAYER_PARENT_LAYER, lab_layer_surface);
wl_list_remove(&popup->unmap.link); //}
wl_list_remove(&popup->destroy.link);
wl_list_remove(&popup->commit.link);
free(popup);
}
static void
popup_unconstrain(struct lab_layer_popup *popup)
{
struct lab_layer_surface *layer = popup_get_layer(popup);
struct wlr_xdg_popup *wlr_popup = popup->wlr_popup;
struct output *output = layer->layer_surface->output->data;
struct wlr_box output_box = { 0 };
wlr_output_effective_resolution(output->wlr_output, &output_box.width,
&output_box.height);
struct wlr_box output_toplevel_sx_box = {
.x = -layer->geo.x,
.y = -layer->geo.y,
.width = output_box.width,
.height = output_box.height,
};
wlr_xdg_popup_unconstrain_from_box(wlr_popup, &output_toplevel_sx_box);
}
static void popup_handle_new_popup(struct wl_listener *listener, void *data);
static struct lab_layer_popup *
create_popup(struct wlr_xdg_popup *wlr_popup,
enum layer_parent parent_type, void *parent)
{
struct lab_layer_popup *popup =
calloc(1, sizeof(struct lab_layer_popup));
if (!popup) {
return NULL;
}
popup->wlr_popup = wlr_popup;
popup->parent_type = parent_type;
popup->parent_layer = parent;
popup->map.notify = popup_handle_map;
wl_signal_add(&wlr_popup->base->events.map, &popup->map);
popup->unmap.notify = popup_handle_unmap;
wl_signal_add(&wlr_popup->base->events.unmap, &popup->unmap);
popup->destroy.notify = popup_handle_destroy;
wl_signal_add(&wlr_popup->base->events.destroy, &popup->destroy);
popup->commit.notify = popup_handle_commit;
wl_signal_add(&wlr_popup->base->surface->events.commit, &popup->commit);
popup->new_popup.notify = popup_handle_new_popup;
wl_signal_add(&wlr_popup->base->events.new_popup, &popup->new_popup);
popup_unconstrain(popup);
return popup;
}
static void
popup_handle_new_popup(struct wl_listener *listener, void *data)
{
struct lab_layer_popup *lab_layer_popup =
wl_container_of(listener, lab_layer_popup, new_popup);
struct wlr_xdg_popup *wlr_popup = data;
create_popup(wlr_popup, LAYER_PARENT_POPUP, lab_layer_popup);
}
static void
new_popup_notify(struct wl_listener *listener, void *data)
{
struct lab_layer_surface *lab_layer_surface =
wl_container_of(listener, lab_layer_surface, new_popup);
struct wlr_xdg_popup *wlr_popup = data;
create_popup(wlr_popup, LAYER_PARENT_LAYER, lab_layer_surface);
}
static void static void
new_layer_surface_notify(struct wl_listener *listener, void *data) new_layer_surface_notify(struct wl_listener *listener, void *data)
@ -564,18 +335,28 @@ new_layer_surface_notify(struct wl_listener *listener, void *data)
surface->unmap.notify = unmap_notify; surface->unmap.notify = unmap_notify;
wl_signal_add(&layer_surface->events.unmap, &surface->unmap); wl_signal_add(&layer_surface->events.unmap, &surface->unmap);
surface->new_popup.notify = new_popup_notify; /* TODO: support popups */
wl_signal_add(&layer_surface->events.new_popup, &surface->new_popup); // surface->new_popup.notify = new_popup_notify;
// wl_signal_add(&layer_surface->events.new_popup, &surface->new_popup);
surface->new_subsurface.notify = new_subsurface_notify; //
wl_signal_add(&layer_surface->surface->events.new_subsurface, // surface->new_subsurface.notify = new_subsurface_notify;
&surface->new_subsurface); // wl_signal_add(&layer_surface->surface->events.new_subsurface,
// &surface->new_subsurface);
surface->layer_surface = layer_surface;
layer_surface->data = surface;
surface->server = server;
struct output *output = layer_surface->output->data; struct output *output = layer_surface->output->data;
struct wlr_scene_tree *selected_layer =
output->layer_tree[layer_surface->current.layer];
surface->scene_layer_surface = wlr_scene_layer_surface_v1_create(
&selected_layer->node, layer_surface);
surface->server = server;
surface->scene_layer_surface->layer_surface = layer_surface;
/* wlr_surface->data needed to find parent in xdg_surface_new() */
layer_surface->surface->data = surface->scene_layer_surface->node;
surface->output_destroy.notify = output_destroy_notify; surface->output_destroy.notify = output_destroy_notify;
wl_signal_add(&layer_surface->output->events.destroy, wl_signal_add(&layer_surface->output->events.destroy,
&surface->output_destroy); &surface->output_destroy);

31
src/output.c
View file

@ -12,6 +12,7 @@
#include <wlr/types/wlr_buffer.h> #include <wlr/types/wlr_buffer.h>
#include <wlr/types/wlr_xdg_output_v1.h> #include <wlr/types/wlr_xdg_output_v1.h>
#include <wlr/types/wlr_output_damage.h> #include <wlr/types/wlr_output_damage.h>
#include <wlr/types/wlr_scene.h>
#include <wlr/util/region.h> #include <wlr/util/region.h>
#include <wlr/util/log.h> #include <wlr/util/log.h>
#include "buffer.h" #include "buffer.h"
@ -110,14 +111,16 @@ new_output_notify(struct wl_listener *listener, void *data)
output->frame.notify = output_frame_notify; output->frame.notify = output_frame_notify;
wl_signal_add(&wlr_output->events.frame, &output->frame); wl_signal_add(&wlr_output->events.frame, &output->frame);
wl_list_init(&output->layers[0]); for (int i = 0; i < 4; i++) {
wl_list_init(&output->layers[1]); wl_list_init(&output->layers[i]);
wl_list_init(&output->layers[2]); output->layer_tree[i] =
wl_list_init(&output->layers[3]); wlr_scene_tree_create(&server->scene->node);
/* output->layer_tree[i]->node.data = output->wlr_output;
* Arrange outputs from left-to-right in the order they appear. }
* TODO: support configuration in run-time wlr_scene_node_lower_to_bottom(&output->layer_tree[1]->node);
*/ wlr_scene_node_lower_to_bottom(&output->layer_tree[0]->node);
wlr_scene_node_raise_to_top(&output->layer_tree[2]->node);
wlr_scene_node_raise_to_top(&output->layer_tree[3]->node);
if (rc.adaptive_sync) { if (rc.adaptive_sync) {
wlr_log(WLR_INFO, "enable adaptive sync on %s", wlr_log(WLR_INFO, "enable adaptive sync on %s",
@ -318,11 +321,13 @@ handle_output_layout_change(struct wl_listener *listener, void *data)
"wlr_output_manager_v1_set_configuration()"); "wlr_output_manager_v1_set_configuration()");
} }
struct output *output; struct output *output;
wl_list_for_each(output, &server->outputs, link) {
if (output) { /* FIXME: Sort this out */
arrange_layers(output); // wl_list_for_each(output, &server->outputs, link) {
} // if (output) {
} // arrange_layers(output);
// }
// }
output_update_for_layout_change(server); output_update_for_layout_change(server);
} }
} }