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);
}