swayfx/swaybar/bar.c

525 lines
14 KiB
C
Raw Normal View History

#define _POSIX_C_SOURCE 200809L
#include <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <poll.h>
#include <signal.h>
#include <stdbool.h>
2016-01-24 12:34:20 +11:00
#include <stdlib.h>
#include <string.h>
2016-01-24 12:34:20 +11:00
#include <sys/wait.h>
#include <unistd.h>
#include <wayland-client.h>
2018-03-31 12:38:28 +11:00
#include <wayland-cursor.h>
2018-12-10 02:10:41 +11:00
#include "config.h"
#include "swaybar/bar.h"
2016-09-01 22:18:37 +10:00
#include "swaybar/config.h"
#include "swaybar/i3bar.h"
#include "swaybar/input.h"
2018-03-29 14:56:02 +11:00
#include "swaybar/ipc.h"
#include "swaybar/status_line.h"
#include "swaybar/render.h"
2018-10-28 21:25:47 +11:00
#if HAVE_TRAY
#include "swaybar/tray/tray.h"
#endif
2018-03-29 14:56:02 +11:00
#include "ipc-client.h"
2016-01-24 12:34:20 +11:00
#include "list.h"
#include "log.h"
#include "loop.h"
#include "pool-buffer.h"
#include "wlr-layer-shell-unstable-v1-client-protocol.h"
#include "xdg-output-unstable-v1-client-protocol.h"
2016-01-24 12:34:20 +11:00
2018-04-25 07:04:19 +10:00
void free_workspaces(struct wl_list *list) {
struct swaybar_workspace *ws, *tmp;
wl_list_for_each_safe(ws, tmp, list, link) {
wl_list_remove(&ws->link);
free(ws->name);
2018-11-18 03:11:28 +11:00
free(ws->label);
2018-04-25 07:04:19 +10:00
free(ws);
}
}
2018-04-06 05:39:57 +10:00
static void swaybar_output_free(struct swaybar_output *output) {
if (!output) {
return;
}
sway_log(SWAY_DEBUG, "Removing output %s", output->name);
if (output->layer_surface != NULL) {
zwlr_layer_surface_v1_destroy(output->layer_surface);
}
if (output->surface != NULL) {
wl_surface_destroy(output->surface);
}
if (output->input_region != NULL) {
wl_region_destroy(output->input_region);
}
zxdg_output_v1_destroy(output->xdg_output);
2018-04-06 05:39:57 +10:00
wl_output_destroy(output->output);
destroy_buffer(&output->buffers[0]);
destroy_buffer(&output->buffers[1]);
free_hotspots(&output->hotspots);
2018-04-25 07:04:19 +10:00
free_workspaces(&output->workspaces);
2018-04-06 05:39:57 +10:00
wl_list_remove(&output->link);
free(output->name);
free(output->identifier);
2018-04-06 05:39:57 +10:00
free(output);
}
static void set_output_dirty(struct swaybar_output *output) {
if (output->frame_scheduled) {
output->dirty = true;
} else if (output->surface) {
render_frame(output);
}
}
static void layer_surface_configure(void *data,
struct zwlr_layer_surface_v1 *surface,
uint32_t serial, uint32_t width, uint32_t height) {
struct swaybar_output *output = data;
output->width = width;
output->height = height;
zwlr_layer_surface_v1_ack_configure(surface, serial);
set_output_dirty(output);
}
static void layer_surface_closed(void *_output,
struct zwlr_layer_surface_v1 *surface) {
2018-03-30 13:25:25 +11:00
struct swaybar_output *output = _output;
2018-04-06 05:39:57 +10:00
swaybar_output_free(output);
}
struct zwlr_layer_surface_v1_listener layer_surface_listener = {
.configure = layer_surface_configure,
.closed = layer_surface_closed,
};
static void add_layer_surface(struct swaybar_output *output) {
if (output->layer_surface) {
return;
}
struct swaybar *bar = output->bar;
struct swaybar_config *config = bar->config;
bool hidden = strcmp(config->mode, "hide") == 0;
bool overlay = !hidden && strcmp(config->mode, "overlay") == 0;
output->layer_surface = zwlr_layer_shell_v1_get_layer_surface(
bar->layer_shell, output->surface, output->output,
hidden || overlay ? ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY :
ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM, "panel");
assert(output->layer_surface);
zwlr_layer_surface_v1_add_listener(output->layer_surface,
&layer_surface_listener, output);
if (overlay) {
// Empty input region
output->input_region = wl_compositor_create_region(bar->compositor);
assert(output->input_region);
wl_surface_set_input_region(output->surface, output->input_region);
}
zwlr_layer_surface_v1_set_anchor(output->layer_surface, config->position);
if (hidden || overlay) {
zwlr_layer_surface_v1_set_exclusive_zone(output->layer_surface, -1);
}
}
static void destroy_layer_surface(struct swaybar_output *output) {
if (!output->layer_surface) {
return;
}
zwlr_layer_surface_v1_destroy(output->layer_surface);
wl_surface_attach(output->surface, NULL, 0, 0); // detach buffer
output->layer_surface = NULL;
output->width = 0;
output->frame_scheduled = false;
}
2018-12-07 23:40:45 +11:00
void set_bar_dirty(struct swaybar *bar) {
2018-10-22 02:46:40 +11:00
struct swaybar_output *output;
wl_list_for_each(output, &bar->outputs, link) {
set_output_dirty(output);
}
}
bool determine_bar_visibility(struct swaybar *bar, bool moving_layer) {
struct swaybar_config *config = bar->config;
bool visible = !(strcmp(config->mode, "invisible") == 0 ||
(strcmp(config->mode, config->hidden_state) == 0 // both "hide"
&& !bar->visible_by_modifier && !bar->visible_by_urgency
&& !bar->visible_by_mode));
2018-10-22 02:46:40 +11:00
// Create/destroy layer surfaces as needed
struct swaybar_output *output;
2018-10-22 02:46:40 +11:00
wl_list_for_each(output, &bar->outputs, link) {
// When moving to a different layer, we need to destroy and re-create
// the layer surface
if (!visible || moving_layer) {
destroy_layer_surface(output);
}
2018-10-22 02:46:40 +11:00
if (visible) {
add_layer_surface(output);
}
2018-10-22 02:46:40 +11:00
}
set_bar_dirty(bar);
if (visible != bar->visible) {
bar->visible = visible;
if (bar->status) {
sway_log(SWAY_DEBUG, "Sending %s signal to status command",
visible ? "cont" : "stop");
kill(bar->status->pid, visible ?
bar->status->cont_signal : bar->status->stop_signal);
}
}
2018-10-22 02:46:40 +11:00
return visible;
}
static bool bar_uses_output(struct swaybar_output *output) {
if (output->bar->config->all_outputs) {
return true;
}
char *identifier = output->identifier;
struct config_output *coutput;
wl_list_for_each(coutput, &output->bar->config->outputs, link) {
if (strcmp(coutput->name, output->name) == 0 ||
(identifier && strcmp(coutput->name, identifier) == 0)) {
return true;
}
}
return false;
}
static void output_geometry(void *data, struct wl_output *wl_output, int32_t x,
2018-04-04 11:06:28 +10:00
int32_t y, int32_t width_mm, int32_t height_mm, int32_t subpixel,
const char *make, const char *model, int32_t transform) {
struct swaybar_output *output = data;
output->subpixel = subpixel;
2018-04-04 11:06:28 +10:00
}
static void output_mode(void *data, struct wl_output *wl_output, uint32_t flags,
2018-04-04 11:06:28 +10:00
int32_t width, int32_t height, int32_t refresh) {
// Who cares
}
static void output_done(void *data, struct wl_output *wl_output) {
struct swaybar_output *output = data;
set_output_dirty(output);
2018-04-04 11:06:28 +10:00
}
static void output_scale(void *data, struct wl_output *wl_output,
int32_t factor) {
struct swaybar_output *output = data;
output->scale = factor;
bool render = false;
struct swaybar_seat *seat;
wl_list_for_each(seat, &output->bar->seats, link) {
if (output == seat->pointer.current) {
update_cursor(seat);
render = true;
}
};
if (render) {
render_frame(output);
}
2018-04-04 11:06:28 +10:00
}
struct wl_output_listener output_listener = {
.geometry = output_geometry,
.mode = output_mode,
.done = output_done,
.scale = output_scale,
};
static void xdg_output_handle_logical_position(void *data,
struct zxdg_output_v1 *xdg_output, int32_t x, int32_t y) {
struct swaybar_output *output = data;
output->output_x = x;
output->output_y = y;
}
static void xdg_output_handle_logical_size(void *data,
struct zxdg_output_v1 *xdg_output, int32_t width, int32_t height) {
struct swaybar_output *output = data;
output->output_height = height;
output->output_width = width;
}
static void xdg_output_handle_done(void *data,
struct zxdg_output_v1 *xdg_output) {
struct swaybar_output *output = data;
struct swaybar *bar = output->bar;
assert(output->name != NULL);
if (!bar_uses_output(output)) {
swaybar_output_free(output);
return;
}
if (wl_list_empty(&output->link)) {
wl_list_remove(&output->link);
wl_list_insert(&bar->outputs, &output->link);
output->surface = wl_compositor_create_surface(bar->compositor);
assert(output->surface);
2018-10-22 02:46:40 +11:00
determine_bar_visibility(bar, false);
}
}
static void xdg_output_handle_name(void *data,
struct zxdg_output_v1 *xdg_output, const char *name) {
struct swaybar_output *output = data;
free(output->name);
output->name = strdup(name);
}
static void xdg_output_handle_description(void *data,
struct zxdg_output_v1 *xdg_output, const char *description) {
// wlroots currently sets the description to `make model serial (name)`
// If this changes in the future, this will need to be modified.
struct swaybar_output *output = data;
free(output->identifier);
output->identifier = NULL;
char *paren = strrchr(description, '(');
if (paren) {
size_t length = paren - description;
output->identifier = malloc(length);
if (!output->identifier) {
sway_log(SWAY_ERROR, "Failed to allocate output identifier");
return;
}
strncpy(output->identifier, description, length);
output->identifier[length - 1] = '\0';
}
}
struct zxdg_output_v1_listener xdg_output_listener = {
.logical_position = xdg_output_handle_logical_position,
.logical_size = xdg_output_handle_logical_size,
.done = xdg_output_handle_done,
.name = xdg_output_handle_name,
.description = xdg_output_handle_description,
};
static void add_xdg_output(struct swaybar_output *output) {
if (output->xdg_output != NULL) {
return;
2018-04-10 13:38:15 +10:00
}
assert(output->bar->xdg_output_manager != NULL);
output->xdg_output = zxdg_output_manager_v1_get_xdg_output(
output->bar->xdg_output_manager, output->output);
zxdg_output_v1_add_listener(output->xdg_output, &xdg_output_listener,
output);
2018-04-10 13:38:15 +10:00
}
static void handle_global(void *data, struct wl_registry *registry,
uint32_t name, const char *interface, uint32_t version) {
struct swaybar *bar = data;
if (strcmp(interface, wl_compositor_interface.name) == 0) {
bar->compositor = wl_registry_bind(registry, name,
&wl_compositor_interface, 4);
2018-03-31 12:38:28 +11:00
} else if (strcmp(interface, wl_seat_interface.name) == 0) {
struct swaybar_seat *seat = calloc(1, sizeof(struct swaybar_seat));
if (!seat) {
sway_abort("Failed to allocate swaybar_seat");
return;
}
seat->bar = bar;
seat->wl_name = name;
seat->wl_seat = wl_registry_bind(registry, name, &wl_seat_interface, 3);
wl_seat_add_listener(seat->wl_seat, &seat_listener, seat);
wl_list_insert(&bar->seats, &seat->link);
} else if (strcmp(interface, wl_shm_interface.name) == 0) {
bar->shm = wl_registry_bind(registry, name,
&wl_shm_interface, 1);
} else if (strcmp(interface, wl_output_interface.name) == 0) {
struct swaybar_output *output =
calloc(1, sizeof(struct swaybar_output));
output->bar = bar;
output->output = wl_registry_bind(registry, name,
&wl_output_interface, 3);
wl_output_add_listener(output->output, &output_listener, output);
output->scale = 1;
output->wl_name = name;
wl_list_init(&output->workspaces);
wl_list_init(&output->hotspots);
wl_list_init(&output->link);
if (bar->xdg_output_manager != NULL) {
add_xdg_output(output);
}
} else if (strcmp(interface, zwlr_layer_shell_v1_interface.name) == 0) {
bar->layer_shell = wl_registry_bind(
registry, name, &zwlr_layer_shell_v1_interface, 1);
} else if (strcmp(interface, zxdg_output_manager_v1_interface.name) == 0) {
bar->xdg_output_manager = wl_registry_bind(registry, name,
&zxdg_output_manager_v1_interface, 2);
}
}
static void handle_global_remove(void *data, struct wl_registry *registry,
uint32_t name) {
2018-04-06 05:39:57 +10:00
struct swaybar *bar = data;
struct swaybar_output *output, *tmp;
wl_list_for_each_safe(output, tmp, &bar->outputs, link) {
if (output->wl_name == name) {
swaybar_output_free(output);
return;
}
}
struct swaybar_seat *seat, *tmp_seat;
wl_list_for_each_safe(seat, tmp_seat, &bar->seats, link) {
if (seat->wl_name == name) {
swaybar_seat_free(seat);
return;
2018-04-06 05:39:57 +10:00
}
}
}
static const struct wl_registry_listener registry_listener = {
.global = handle_global,
.global_remove = handle_global_remove,
};
2016-01-24 12:34:20 +11:00
bool bar_setup(struct swaybar *bar, const char *socket_path) {
bar->visible = true;
bar->config = init_config();
wl_list_init(&bar->outputs);
wl_list_init(&bar->seats);
bar->eventloop = loop_create();
2018-03-29 14:56:02 +11:00
bar->ipc_socketfd = ipc_open_socket(socket_path);
bar->ipc_event_socketfd = ipc_open_socket(socket_path);
if (!ipc_initialize(bar)) {
2018-09-25 03:42:25 +10:00
return false;
}
if (bar->config->status_command) {
bar->status = status_line_init(bar->config->status_command);
bar->status->bar = bar;
}
2018-03-29 14:56:02 +11:00
2018-04-04 11:29:43 +10:00
bar->display = wl_display_connect(NULL);
if (!bar->display) {
sway_abort("Unable to connect to the compositor. "
"If your compositor is running, check or set the "
"WAYLAND_DISPLAY environment variable.");
}
struct wl_registry *registry = wl_display_get_registry(bar->display);
wl_registry_add_listener(registry, &registry_listener, bar);
wl_display_roundtrip(bar->display);
assert(bar->compositor && bar->layer_shell && bar->shm &&
bar->xdg_output_manager);
2018-10-22 02:46:40 +11:00
// Second roundtrip for xdg-output
2018-04-04 11:06:28 +10:00
wl_display_roundtrip(bar->display);
struct swaybar_seat *seat;
wl_list_for_each(seat, &bar->seats, link) {
struct swaybar_pointer *pointer = &seat->pointer;
if (!pointer) {
continue;
}
pointer->cursor_surface =
wl_compositor_create_surface(bar->compositor);
assert(pointer->cursor_surface);
}
2018-10-28 21:25:47 +11:00
#if HAVE_TRAY
2018-12-12 03:27:39 +11:00
if (!bar->config->tray_hidden) {
bar->tray = create_tray(bar);
}
2018-10-28 21:25:47 +11:00
#endif
if (bar->config->workspace_buttons) {
ipc_get_workspaces(bar);
}
2018-10-22 02:46:40 +11:00
determine_bar_visibility(bar, false);
2018-09-25 03:42:25 +10:00
return true;
}
2018-04-21 12:45:34 +10:00
static void display_in(int fd, short mask, void *data) {
struct swaybar *bar = data;
if (wl_display_dispatch(bar->display) == -1) {
bar->running = false;
}
}
2018-04-21 12:45:34 +10:00
static void ipc_in(int fd, short mask, void *data) {
struct swaybar *bar = data;
2018-04-01 04:39:18 +10:00
if (handle_ipc_readable(bar)) {
set_bar_dirty(bar);
}
}
2018-04-21 12:45:34 +10:00
static void status_in(int fd, short mask, void *data) {
struct swaybar *bar = data;
if (mask & (POLLHUP | POLLERR)) {
status_error(bar->status, "[error reading from status command]");
set_bar_dirty(bar);
loop_remove_fd(bar->eventloop, fd);
} else if (status_handle_readable(bar->status)) {
set_bar_dirty(bar);
2018-03-30 01:38:17 +11:00
}
2018-03-29 14:56:02 +11:00
}
void bar_run(struct swaybar *bar) {
loop_add_fd(bar->eventloop, wl_display_get_fd(bar->display), POLLIN,
display_in, bar);
loop_add_fd(bar->eventloop, bar->ipc_event_socketfd, POLLIN, ipc_in, bar);
if (bar->status) {
loop_add_fd(bar->eventloop, bar->status->read_fd, POLLIN,
status_in, bar);
}
2018-10-28 21:25:47 +11:00
#if HAVE_TRAY
if (bar->tray) {
loop_add_fd(bar->eventloop, bar->tray->fd, POLLIN, tray_in, bar->tray->bus);
}
#endif
while (bar->running) {
2018-10-23 22:22:51 +11:00
errno = 0;
if (wl_display_flush(bar->display) == -1 && errno != EAGAIN) {
break;
}
loop_poll(bar->eventloop);
2016-01-24 12:34:20 +11:00
}
}
static void free_outputs(struct wl_list *list) {
struct swaybar_output *output, *tmp;
wl_list_for_each_safe(output, tmp, list, link) {
2018-04-25 07:04:19 +10:00
swaybar_output_free(output);
2016-01-24 12:34:20 +11:00
}
}
static void free_seats(struct wl_list *list) {
struct swaybar_seat *seat, *tmp;
wl_list_for_each_safe(seat, tmp, list, link) {
swaybar_seat_free(seat);
}
}
void bar_teardown(struct swaybar *bar) {
2018-10-28 21:25:47 +11:00
#if HAVE_TRAY
destroy_tray(bar->tray);
#endif
free_outputs(&bar->outputs);
free_seats(&bar->seats);
2016-03-31 20:50:07 +11:00
if (bar->config) {
free_config(bar->config);
}
2018-03-30 06:19:42 +11:00
close(bar->ipc_event_socketfd);
close(bar->ipc_socketfd);
if (bar->status) {
status_line_free(bar->status);
}
free(bar->id);
free(bar->mode);
2016-01-24 12:34:20 +11:00
}