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

tree-wide: auto-replace of (struct server *)

Browse source 
#!/bin/bash
    read -r -d '' EXPRS << EOF
    s/xwayland->server/xwayland->svr/g;

    s/\t*struct server \*server;\n//g;
    s/\t*struct server \*server =.*?;\n//gs;
    s/\t*.* = ([a-z_]*->)*server[;,]\n//g;
    s/\{\n\n/\{\n/g;
    s/\n\n+/\n\n/g;

    s/\(\s*struct server \*server\)/(void)/g;
    s/\(\s*struct server \*server,\s*/(/g;
    s/,\s*struct server \*server\)/)/g;
    s/,\s*struct server \*server,\s*/, /g;

    s/\(\s*([a-z_]*->)*server\)/()/g;
    s/\(\s*([a-z_]*->)*server,\s*/(/g;
    s/,\s*([a-z_]*->)*server\)/)/g;
    s/,\s*([a-z_]*->)*server,\s*/, /g;

    s/([a-z_]*->)*server->/g_server./g;

    s/xwayland->svr/xwayland->server/g;
    EOF

    find src include \( -name \*.c -o -name \*.h \) -exec \
        perl -0777 -i -pe "$EXPRS" \{\} \;
This commit is contained in:
John Lindgren 2026-02-23 11:56:39 -05:00 • committed by Johan Malm
parent 60ac8f07bb
commit cb49bddf63
81 changed files with 1522 additions and 1682 deletions
Download patch file Download diff file Expand all files Collapse all files

188
src/cycle/cycle.c
View file

@ -18,17 +18,16 @@
#include "theme.h"
#include "view.h"
static bool init_cycle(struct server *server, struct cycle_filter filter);
static void update_cycle(struct server *server);
static void destroy_cycle(struct server *server);
static bool init_cycle(struct cycle_filter filter);
static void update_cycle(void);
static void destroy_cycle(void);
static void
update_preview_outlines(struct view *view)
{
/* Create / Update preview outline tree */
struct server *server = view->server;
struct theme *theme = server->theme;
struct lab_scene_rect *rect = view->server->cycle.preview_outline;
struct theme *theme = g_server.theme;
struct lab_scene_rect *rect = g_server.cycle.preview_outline;
if (!rect) {
struct lab_scene_rect_options opts = {
.border_colors = (float *[3]) {
@ -39,10 +38,10 @@ update_preview_outlines(struct view *view)
.nr_borders = 3,
.border_width = theme->osd_window_switcher_preview_border_width,
};
rect = lab_scene_rect_create(&server->scene->tree, &opts);
rect = lab_scene_rect_create(&g_server.scene->tree, &opts);
wlr_scene_node_place_above(&rect->tree->node,
&server->cycle_preview_tree->node);
server->cycle.preview_outline = rect;
&g_server.cycle_preview_tree->node);
g_server.cycle.preview_outline = rect;
}
struct wlr_box geo = ssd_max_extents(view);
@ -52,21 +51,21 @@ update_preview_outlines(struct view *view)
/* Returns the view to select next in the window switcher. */
static struct view *
get_next_selected_view(struct server *server, enum lab_cycle_dir dir)
get_next_selected_view(enum lab_cycle_dir dir)
{
struct cycle_state *cycle = &server->cycle;
struct cycle_state *cycle = &g_server.cycle;
assert(cycle->selected_view);
assert(!wl_list_empty(&server->cycle.views));
assert(!wl_list_empty(&g_server.cycle.views));
struct wl_list *link;
if (dir == LAB_CYCLE_DIR_FORWARD) {
link = cycle->selected_view->cycle_link.next;
if (link == &server->cycle.views) {
if (link == &g_server.cycle.views) {
link = link->next;
}
} else {
link = cycle->selected_view->cycle_link.prev;
if (link == &server->cycle.views) {
if (link == &g_server.cycle.views) {
link = link->prev;
}
}
@ -83,22 +82,22 @@ get_first_view(struct wl_list *views)
}
void
cycle_reinitialize(struct server *server)
cycle_reinitialize(void)
{
struct cycle_state *cycle = &server->cycle;
struct cycle_state *cycle = &g_server.cycle;
if (server->input_mode != LAB_INPUT_STATE_CYCLE) {
if (g_server.input_mode != LAB_INPUT_STATE_CYCLE) {
/* OSD not active, no need for clean up */
return;
}
struct view *selected_view = cycle->selected_view;
struct view *selected_view_prev =
get_next_selected_view(server, LAB_CYCLE_DIR_BACKWARD);
get_next_selected_view(LAB_CYCLE_DIR_BACKWARD);
struct cycle_filter filter = cycle->filter;
destroy_cycle(server);
if (init_cycle(server, filter)) {
destroy_cycle();
if (init_cycle(filter)) {
/*
* Preserve the selected view (or its previous view) if it's
* still in the cycle list
@ -110,104 +109,104 @@ cycle_reinitialize(struct server *server)
} else {
/* should be unreachable */
wlr_log(WLR_ERROR, "could not find view to select");
cycle->selected_view = get_first_view(&server->cycle.views);
cycle->selected_view = get_first_view(&g_server.cycle.views);
}
update_cycle(server);
update_cycle();
} else {
/* Failed to re-init window switcher, exit */
cycle_finish(server, /*switch_focus*/ false);
cycle_finish(/*switch_focus*/ false);
}
}
void
cycle_on_cursor_release(struct server *server, struct wlr_scene_node *node)
cycle_on_cursor_release(struct wlr_scene_node *node)
{
assert(server->input_mode == LAB_INPUT_STATE_CYCLE);
assert(g_server.input_mode == LAB_INPUT_STATE_CYCLE);
struct cycle_osd_item *item = node_cycle_osd_item_from_node(node);
server->cycle.selected_view = item->view;
cycle_finish(server, /*switch_focus*/ true);
g_server.cycle.selected_view = item->view;
cycle_finish(/*switch_focus*/ true);
}
static void
restore_preview_node(struct server *server)
restore_preview_node(void)
{
if (server->cycle.preview_node) {
wlr_scene_node_reparent(server->cycle.preview_node,
server->cycle.preview_dummy->parent);
wlr_scene_node_place_above(server->cycle.preview_node,
server->cycle.preview_dummy);
wlr_scene_node_destroy(server->cycle.preview_dummy);
if (g_server.cycle.preview_node) {
wlr_scene_node_reparent(g_server.cycle.preview_node,
g_server.cycle.preview_dummy->parent);
wlr_scene_node_place_above(g_server.cycle.preview_node,
g_server.cycle.preview_dummy);
wlr_scene_node_destroy(g_server.cycle.preview_dummy);
/* Node was disabled / minimized before, disable again */
if (!server->cycle.preview_was_enabled) {
wlr_scene_node_set_enabled(server->cycle.preview_node, false);
if (!g_server.cycle.preview_was_enabled) {
wlr_scene_node_set_enabled(g_server.cycle.preview_node, false);
}
if (server->cycle.preview_was_shaded) {
struct view *view = node_view_from_node(server->cycle.preview_node);
if (g_server.cycle.preview_was_shaded) {
struct view *view = node_view_from_node(g_server.cycle.preview_node);
view_set_shade(view, true);
}
server->cycle.preview_node = NULL;
server->cycle.preview_dummy = NULL;
server->cycle.preview_was_enabled = false;
server->cycle.preview_was_shaded = false;
g_server.cycle.preview_node = NULL;
g_server.cycle.preview_dummy = NULL;
g_server.cycle.preview_was_enabled = false;
g_server.cycle.preview_was_shaded = false;
}
}
void
cycle_begin(struct server *server, enum lab_cycle_dir direction,
cycle_begin(enum lab_cycle_dir direction,
struct cycle_filter filter)
{
if (server->input_mode != LAB_INPUT_STATE_PASSTHROUGH) {
if (g_server.input_mode != LAB_INPUT_STATE_PASSTHROUGH) {
return;
}
if (!init_cycle(server, filter)) {
if (!init_cycle(filter)) {
return;
}
struct view *active_view = server->active_view;
struct view *active_view = g_server.active_view;
if (active_view && active_view->cycle_link.next) {
/* Select the active view it's in the cycle list */
server->cycle.selected_view = active_view;
g_server.cycle.selected_view = active_view;
} else {
/* Otherwise, select the first view in the cycle list */
server->cycle.selected_view = get_first_view(&server->cycle.views);
g_server.cycle.selected_view = get_first_view(&g_server.cycle.views);
}
/* Pre-select the next view in the given direction */
server->cycle.selected_view = get_next_selected_view(server, direction);
g_server.cycle.selected_view = get_next_selected_view(direction);
seat_focus_override_begin(&server->seat,
seat_focus_override_begin(&g_server.seat,
LAB_INPUT_STATE_CYCLE, LAB_CURSOR_DEFAULT);
update_cycle(server);
update_cycle();
/* Update cursor, in case it is within the area covered by OSD */
cursor_update_focus(server);
cursor_update_focus();
}
void
cycle_step(struct server *server, enum lab_cycle_dir direction)
cycle_step(enum lab_cycle_dir direction)
{
assert(server->input_mode == LAB_INPUT_STATE_CYCLE);
assert(g_server.input_mode == LAB_INPUT_STATE_CYCLE);
server->cycle.selected_view = get_next_selected_view(server, direction);
update_cycle(server);
g_server.cycle.selected_view = get_next_selected_view(direction);
update_cycle();
}
void
cycle_finish(struct server *server, bool switch_focus)
cycle_finish(bool switch_focus)
{
if (server->input_mode != LAB_INPUT_STATE_CYCLE) {
if (g_server.input_mode != LAB_INPUT_STATE_CYCLE) {
return;
}
struct view *selected_view = server->cycle.selected_view;
destroy_cycle(server);
struct view *selected_view = g_server.cycle.selected_view;
destroy_cycle();
seat_focus_override_end(&server->seat, /*restore_focus*/ false);
seat_focus_override_end(&g_server.seat, /*restore_focus*/ false);
/* Hiding OSD may need a cursor change */
cursor_update_focus(server);
cursor_update_focus();
if (switch_focus && selected_view) {
if (rc.window_switcher.unshade) {
@ -222,11 +221,10 @@ preview_selected_view(struct view *view)
{
assert(view);
assert(view->scene_tree);
struct server *server = view->server;
struct cycle_state *cycle = &server->cycle;
struct cycle_state *cycle = &g_server.cycle;
/* Move previous selected node back to its original place */
restore_preview_node(server);
restore_preview_node();
cycle->preview_node = &view->scene_tree->node;
@ -246,7 +244,7 @@ preview_selected_view(struct view *view)
}
wlr_scene_node_reparent(cycle->preview_node,
view->server->cycle_preview_tree);
g_server.cycle_preview_tree);
/* Finally raise selected node to the top */
wlr_scene_node_raise_to_top(cycle->preview_node);
@ -265,8 +263,7 @@ get_osd_impl(void)
}
static uint64_t
get_outputs_by_filter(struct server *server,
enum cycle_output_filter output_filter)
get_outputs_by_filter(enum cycle_output_filter output_filter)
{
struct output *output = NULL;
@ -274,15 +271,15 @@ get_outputs_by_filter(struct server *server,
case CYCLE_OUTPUT_ALL:
break;
case CYCLE_OUTPUT_CURSOR:
output = output_nearest_to_cursor(server);
output = output_nearest_to_cursor();
break;
case CYCLE_OUTPUT_FOCUSED: {
struct view *view = server->active_view;
struct view *view = g_server.active_view;
if (view && output_is_usable(view->output)) {
output = view->output;
} else {
/* Fallback to pointer */
output = output_nearest_to_cursor(server);
output = output_nearest_to_cursor();
}
break;
}
@ -327,7 +324,7 @@ handle_osd_tree_destroy(struct wl_listener *listener, void *data)
/* Return false on failure */
static bool
init_cycle(struct server *server, struct cycle_filter filter)
init_cycle(struct cycle_filter filter)
{
enum lab_view_criteria criteria =
LAB_VIEW_CRITERIA_NO_SKIP_WINDOW_SWITCHER
@ -337,15 +334,15 @@ init_cycle(struct server *server, struct cycle_filter filter)
}
uint64_t cycle_outputs =
get_outputs_by_filter(server, filter.output);
get_outputs_by_filter(filter.output);
const char *cycle_app_id = NULL;
if (filter.app_id == CYCLE_APP_ID_CURRENT && server->active_view) {
cycle_app_id = server->active_view->app_id;
if (filter.app_id == CYCLE_APP_ID_CURRENT && g_server.active_view) {
cycle_app_id = g_server.active_view->app_id;
}
struct view *view;
for_each_view(view, &server->views, criteria) {
for_each_view(view, &g_server.views, criteria) {
if (filter.output != CYCLE_OUTPUT_ALL) {
if (!view->output || !(cycle_outputs & view->output->id_bit)) {
continue;
@ -356,23 +353,22 @@ init_cycle(struct server *server, struct cycle_filter filter)
}
if (rc.window_switcher.order == WINDOW_SWITCHER_ORDER_AGE) {
insert_view_ordered_by_age(&server->cycle.views, view);
insert_view_ordered_by_age(&g_server.cycle.views, view);
} else {
wl_list_append(&server->cycle.views, &view->cycle_link);
wl_list_append(&g_server.cycle.views, &view->cycle_link);
}
}
if (wl_list_empty(&server->cycle.views)) {
if (wl_list_empty(&g_server.cycle.views)) {
wlr_log(WLR_DEBUG, "no views to switch between");
return false;
}
server->cycle.filter = filter;
g_server.cycle.filter = filter;
if (rc.window_switcher.osd.show) {
/* Create OSD */
uint64_t osd_outputs = get_outputs_by_filter(server,
rc.window_switcher.osd.output_filter);
uint64_t osd_outputs = get_outputs_by_filter(rc.window_switcher.osd.output_filter);
struct output *output;
wl_list_for_each(output, &server->outputs, link) {
wl_list_for_each(output, &g_server.outputs, link) {
if (!(osd_outputs & output->id_bit)) {
continue;
}
@ -381,7 +377,7 @@ init_cycle(struct server *server, struct cycle_filter filter)
}
struct cycle_osd_output *osd_output = znew(*osd_output);
wl_list_append(&server->cycle.osd_outputs, &osd_output->link);
wl_list_append(&g_server.cycle.osd_outputs, &osd_output->link);
osd_output->output = output;
wl_list_init(&osd_output->items);
@ -397,9 +393,9 @@ init_cycle(struct server *server, struct cycle_filter filter)
}
static void
update_cycle(struct server *server)
update_cycle(void)
{
struct cycle_state *cycle = &server->cycle;
struct cycle_state *cycle = &g_server.cycle;
if (rc.window_switcher.osd.show) {
struct cycle_osd_output *osd_output;
@ -420,29 +416,29 @@ update_cycle(struct server *server)
}
}
/* Resets all the states in server->cycle */
/* Resets all the states in g_server.cycle */
static void
destroy_cycle(struct server *server)
destroy_cycle(void)
{
struct cycle_osd_output *osd_output, *tmp;
wl_list_for_each_safe(osd_output, tmp, &server->cycle.osd_outputs, link) {
wl_list_for_each_safe(osd_output, tmp, &g_server.cycle.osd_outputs, link) {
/* calls handle_osd_tree_destroy() */
wlr_scene_node_destroy(&osd_output->tree->node);
}
restore_preview_node(server);
restore_preview_node();
if (server->cycle.preview_outline) {
wlr_scene_node_destroy(&server->cycle.preview_outline->tree->node);
if (g_server.cycle.preview_outline) {
wlr_scene_node_destroy(&g_server.cycle.preview_outline->tree->node);
}
struct view *view, *tmp2;
wl_list_for_each_safe(view, tmp2, &server->cycle.views, cycle_link) {
wl_list_for_each_safe(view, tmp2, &g_server.cycle.views, cycle_link) {
wl_list_remove(&view->cycle_link);
view->cycle_link = (struct wl_list){0};
}
server->cycle = (struct cycle_state){0};
wl_list_init(&server->cycle.views);
wl_list_init(&server->cycle.osd_outputs);
g_server.cycle = (struct cycle_state){0};
wl_list_init(&g_server.cycle.views);
wl_list_init(&g_server.cycle.osd_outputs);
}

25
src/cycle/osd-classic.c
View file

@ -28,11 +28,11 @@ struct cycle_osd_classic_item {
};
static void
create_fields_scene(struct server *server, struct view *view,
create_fields_scene(struct view *view,
struct wlr_scene_tree *parent, const float *text_color,
const float *bg_color, int field_widths_sum, int x, int y)
{
struct theme *theme = server->theme;
struct theme *theme = g_server.theme;
struct window_switcher_classic_theme *switcher_theme =
&theme->osd_window_switcher_classic;
@ -46,8 +46,7 @@ create_fields_scene(struct server *server, struct view *view,
int icon_size = MIN(field_width,
switcher_theme->item_icon_size);
struct scaled_icon_buffer *icon_buffer =
scaled_icon_buffer_create(parent,
server, icon_size, icon_size);
scaled_icon_buffer_create(parent, icon_size, icon_size);
scaled_icon_buffer_set_view(icon_buffer, view);
node = &icon_buffer->scene_buffer->node;
height = icon_size;
@ -81,17 +80,16 @@ static void
cycle_osd_classic_init(struct cycle_osd_output *osd_output)
{
struct output *output = osd_output->output;
struct server *server = output->server;
struct theme *theme = server->theme;
struct theme *theme = g_server.theme;
struct window_switcher_classic_theme *switcher_theme =
&theme->osd_window_switcher_classic;
int padding = theme->osd_border_width + switcher_theme->padding;
bool show_workspace = wl_list_length(&rc.workspace_config.workspaces) > 1;
const char *workspace_name = server->workspaces.current->name;
int nr_views = wl_list_length(&server->cycle.views);
const char *workspace_name = g_server.workspaces.current->name;
int nr_views = wl_list_length(&g_server.cycle.views);
struct wlr_box output_box;
wlr_output_layout_get_box(server->output_layout, output->wlr_output,
wlr_output_layout_get_box(g_server.output_layout, output->wlr_output,
&output_box);
int w = switcher_theme->width;
@ -166,7 +164,7 @@ cycle_osd_classic_init(struct cycle_osd_output *osd_output)
/* Draw text for each node */
struct view *view;
wl_list_for_each(view, &server->cycle.views, cycle_link) {
wl_list_for_each(view, &g_server.cycle.views, cycle_link) {
struct cycle_osd_classic_item *item = znew(*item);
wl_list_append(&osd_output->items, &item->base.link);
item->base.view = view;
@ -214,9 +212,9 @@ cycle_osd_classic_init(struct cycle_osd_output *osd_output)
w - 2 * padding, switcher_theme->item_height, (float[4]) {0});
wlr_scene_node_set_position(&hitbox->node, padding, y);
create_fields_scene(server, view, item->normal_tree,
create_fields_scene(view, item->normal_tree,
text_color, bg_color, field_widths_sum, x, y);
create_fields_scene(server, view, item->active_tree,
create_fields_scene(view, item->active_tree,
text_color, active_bg_color, field_widths_sum, x, y);
y += switcher_theme->item_height;
@ -243,12 +241,11 @@ error:;
static void
cycle_osd_classic_update(struct cycle_osd_output *osd_output)
{
struct server *server = osd_output->output->server;
cycle_osd_scroll_update(osd_output);
struct cycle_osd_classic_item *item;
wl_list_for_each(item, &osd_output->items, base.link) {
bool active = item->base.view == server->cycle.selected_view;
bool active = item->base.view == g_server.cycle.selected_view;
wlr_scene_node_set_enabled(&item->normal_tree->node, !active);
wlr_scene_node_set_enabled(&item->active_tree->node, active);
}

4
src/cycle/osd-field.c
View file

@ -45,7 +45,7 @@ static const char *
get_desktop_name(struct view *view)
{
#if HAVE_LIBSFDO
const char *name = desktop_entry_name_lookup(view->server, view->app_id);
const char *name = desktop_entry_name_lookup(view->app_id);
if (name) {
return name;
}
@ -148,7 +148,7 @@ static void
field_set_output_short(struct buf *buf, struct view *view, const char *format)
{
/* custom type conversion-specifier: o */
if (wl_list_length(&view->server->outputs) > 1 &&
if (wl_list_length(&g_server.outputs) > 1 &&
output_is_usable(view->output)) {
buf_add(buf, view->output->wlr_output->name);
}

4
src/cycle/osd-scroll.c
View file

@ -42,12 +42,10 @@ cycle_osd_scroll_init(struct cycle_osd_output *osd_output, struct wlr_box bar_ar
static int
get_cycle_idx(struct cycle_osd_output *osd_output)
{
struct server *server = osd_output->output->server;
int idx = 0;
struct cycle_osd_item *item;
wl_list_for_each(item, &osd_output->items, link) {
if (item->view == server->cycle.selected_view) {
if (item->view == g_server.cycle.selected_view) {
return idx;
}
idx++;

32
src/cycle/osd-thumbnail.c
View file

@ -28,7 +28,7 @@ struct cycle_osd_thumbnail_item {
};
static void
render_node(struct server *server, struct wlr_render_pass *pass,
render_node(struct wlr_render_pass *pass,
struct wlr_scene_node *node, int x, int y)
{
switch (node->type) {
@ -36,7 +36,7 @@ render_node(struct server *server, struct wlr_render_pass *pass,
struct wlr_scene_tree *tree = wlr_scene_tree_from_node(node);
struct wlr_scene_node *child;
wl_list_for_each(child, &tree->children, link) {
render_node(server, pass, child, x + node->x, y + node->y);
render_node(pass, child, x + node->x, y + node->y);
}
break;
}
@ -47,7 +47,7 @@ render_node(struct server *server, struct wlr_render_pass *pass,
break;
}
struct wlr_texture *texture = wlr_texture_from_buffer(
server->renderer, scene_buffer->buffer);
g_server.renderer, scene_buffer->buffer);
if (!texture) {
break;
}
@ -82,13 +82,12 @@ render_thumb(struct output *output, struct view *view)
*/
return NULL;
}
struct server *server = output->server;
struct wlr_buffer *buffer = wlr_allocator_create_buffer(server->allocator,
struct wlr_buffer *buffer = wlr_allocator_create_buffer(g_server.allocator,
view->current.width, view->current.height,
&output->wlr_output->swapchain->format);
struct wlr_render_pass *pass = wlr_renderer_begin_buffer_pass(
server->renderer, buffer, NULL);
render_node(server, pass, &view->content_tree->node, 0, 0);
g_server.renderer, buffer, NULL);
render_node(pass, &view->content_tree->node, 0, 0);
if (!wlr_render_pass_submit(pass)) {
wlr_log(WLR_ERROR, "failed to submit render pass");
wlr_buffer_drop(buffer);
@ -120,8 +119,7 @@ static struct cycle_osd_thumbnail_item *
create_item_scene(struct wlr_scene_tree *parent, struct view *view,
struct cycle_osd_output *osd_output)
{
struct server *server = osd_output->output->server;
struct theme *theme = server->theme;
struct theme *theme = g_server.theme;
struct window_switcher_thumbnail_theme *switcher_theme =
&theme->osd_window_switcher_thumbnail;
int padding = theme->border_width + switcher_theme->item_padding;
@ -185,7 +183,7 @@ create_item_scene(struct wlr_scene_tree *parent, struct view *view,
/* icon */
int icon_size = switcher_theme->item_icon_size;
struct scaled_icon_buffer *icon_buffer =
scaled_icon_buffer_create(tree, server, icon_size, icon_size);
scaled_icon_buffer_create(tree, icon_size, icon_size);
scaled_icon_buffer_set_view(icon_buffer, view);
int x = (switcher_theme->item_width - icon_size) / 2;
int y = title_y - padding - icon_size + 10; /* slide by 10px */
@ -198,7 +196,7 @@ static void
get_items_geometry(struct output *output, int nr_thumbs,
int *nr_cols, int *nr_rows, int *nr_visible_rows)
{
struct theme *theme = output->server->theme;
struct theme *theme = g_server.theme;
struct window_switcher_thumbnail_theme *switcher_theme =
&theme->osd_window_switcher_thumbnail;
int output_width, output_height;
@ -234,8 +232,7 @@ static void
cycle_osd_thumbnail_init(struct cycle_osd_output *osd_output)
{
struct output *output = osd_output->output;
struct server *server = output->server;
struct theme *theme = server->theme;
struct theme *theme = g_server.theme;
struct window_switcher_thumbnail_theme *switcher_theme =
&theme->osd_window_switcher_thumbnail;
int padding = theme->osd_border_width + switcher_theme->padding;
@ -243,7 +240,7 @@ cycle_osd_thumbnail_init(struct cycle_osd_output *osd_output)
osd_output->tree = lab_wlr_scene_tree_create(output->cycle_osd_tree);
osd_output->items_tree = lab_wlr_scene_tree_create(osd_output->tree);
int nr_views = wl_list_length(&server->cycle.views);
int nr_views = wl_list_length(&g_server.cycle.views);
assert(nr_views > 0);
int nr_cols, nr_rows, nr_visible_rows;
get_items_geometry(output, nr_views, &nr_cols, &nr_rows, &nr_visible_rows);
@ -251,7 +248,7 @@ cycle_osd_thumbnail_init(struct cycle_osd_output *osd_output)
/* items */
struct view *view;
int index = 0;
wl_list_for_each(view, &server->cycle.views, cycle_link) {
wl_list_for_each(view, &g_server.cycle.views, cycle_link) {
struct cycle_osd_thumbnail_item *item = create_item_scene(
osd_output->items_tree, view, osd_output);
if (!item) {
@ -292,7 +289,7 @@ cycle_osd_thumbnail_init(struct cycle_osd_output *osd_output)
/* center */
struct wlr_box output_box;
wlr_output_layout_get_box(server->output_layout, output->wlr_output,
wlr_output_layout_get_box(g_server.output_layout, output->wlr_output,
&output_box);
int lx = output_box.x + (output_box.width - bg_opts.width) / 2;
int ly = output_box.y + (output_box.height - bg_opts.height) / 2;
@ -302,12 +299,11 @@ cycle_osd_thumbnail_init(struct cycle_osd_output *osd_output)
static void
cycle_osd_thumbnail_update(struct cycle_osd_output *osd_output)
{
struct server *server = osd_output->output->server;
cycle_osd_scroll_update(osd_output);
struct cycle_osd_thumbnail_item *item;
wl_list_for_each(item, &osd_output->items, base.link) {
bool active = (item->base.view == server->cycle.selected_view);
bool active = (item->base.view == g_server.cycle.selected_view);
wlr_scene_node_set_enabled(&item->active_bg->tree->node, active);
wlr_scene_node_set_enabled(
&item->active_label->scene_buffer->node, active);