499 lines
15 KiB
C
499 lines
15 KiB
C
#include <errno.h>
|
||
#include <fcntl.h>
|
||
#include <limits.h>
|
||
#include <stdbool.h>
|
||
#include <stdio.h>
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
#include <sys/mman.h>
|
||
#include <time.h>
|
||
#include <unistd.h>
|
||
#include <getopt.h>
|
||
#include <wayland-client.h>
|
||
#include <cairo/cairo.h>
|
||
#include <pango/pangocairo.h>
|
||
#include "wlr-layer-shell-protocol.h"
|
||
|
||
#define STR_EQUAL 0
|
||
|
||
#define DEFAULT_BORDER_RADIUS 15
|
||
#define DEFAULT_PADDING 10
|
||
#define DEFAULT_WIDTH 256
|
||
#define DEFAULT_HEIGHT 256
|
||
#define DEFAULT_FONT "Fira Sans 17"
|
||
#define DEFAULT_BACKDROP_COLOR \
|
||
((struct color_argb){0.85, 0x11 / 255.0, 0x11 / 255.0, 0x11 / 255.0})
|
||
|
||
/* Shared memory support code */
|
||
static void
|
||
randname(char *buf)
|
||
{
|
||
struct timespec ts;
|
||
clock_gettime(CLOCK_REALTIME, &ts);
|
||
long r = ts.tv_nsec;
|
||
for (int i = 0; i < 6; ++i) {
|
||
buf[i] = 'A'+(r&15)+(r&16)*2;
|
||
r >>= 5;
|
||
}
|
||
}
|
||
|
||
static int
|
||
create_shm_file(void)
|
||
{
|
||
int retries = 100;
|
||
do {
|
||
char name[] = "/wl_shm-XXXXXX";
|
||
randname(name + sizeof(name) - 7);
|
||
--retries;
|
||
int fd = shm_open(name, O_RDWR | O_CREAT | O_EXCL, 0600);
|
||
if (fd >= 0) {
|
||
shm_unlink(name);
|
||
return fd;
|
||
}
|
||
} while (retries > 0 && errno == EEXIST);
|
||
return -1;
|
||
}
|
||
|
||
static int
|
||
allocate_shm_file(size_t size)
|
||
{
|
||
int fd = create_shm_file();
|
||
if (fd < 0)
|
||
return -1;
|
||
int ret;
|
||
do {
|
||
ret = ftruncate(fd, size);
|
||
} while (ret < 0 && errno == EINTR);
|
||
if (ret < 0) {
|
||
close(fd);
|
||
return -1;
|
||
}
|
||
return fd;
|
||
}
|
||
|
||
/* Wayland code */
|
||
struct color_argb {
|
||
double a;
|
||
double r;
|
||
double g;
|
||
double b;
|
||
};
|
||
static struct color_argb color_transparent_black = { 0.0, 0.0, 0.0, 0.0 };
|
||
|
||
static bool
|
||
color_argb_equal(struct color_argb *a, struct color_argb *b)
|
||
{
|
||
return a->a == b->a && a->r == b->r && a->g == b->g && a->b == b->b;
|
||
}
|
||
|
||
static bool
|
||
color_argb_invalid(struct color_argb *a)
|
||
{
|
||
return !(
|
||
(0.0 <= a->a) && (a->a <= 1.0) &&
|
||
(0.0 <= a->r) && (a->r <= 1.0) &&
|
||
(0.0 <= a->g) && (a->g <= 1.0) &&
|
||
(0.0 <= a->b) && (a->b <= 1.0)
|
||
);
|
||
}
|
||
|
||
static void
|
||
set_source_argb_cairo(cairo_t *cairo, struct color_argb *color) {
|
||
cairo_set_source_rgba(cairo, color->r, color->g, color->b, color->a);
|
||
}
|
||
|
||
struct user_request {
|
||
char *graphics_filename;
|
||
char *text;
|
||
char *font;
|
||
struct color_argb backdrop;
|
||
struct color_argb text_color;
|
||
int border_radius;
|
||
int width;
|
||
int height;
|
||
int padding;
|
||
};
|
||
|
||
struct client_state {
|
||
struct user_request user_request;
|
||
bool stop;
|
||
|
||
/* Globals */
|
||
struct wl_registry *wl_registry;
|
||
struct wl_display *wl_display;
|
||
struct wl_shm *wl_shm;
|
||
struct wl_compositor *wl_compositor;
|
||
struct zwlr_layer_shell_v1 *layer_shell;
|
||
|
||
struct wl_seat *wl_seat;
|
||
/* Objects */
|
||
struct wl_surface *wl_surface;
|
||
struct zwlr_layer_surface_v1 *zwlr_surface;
|
||
};
|
||
|
||
static void
|
||
wl_buffer_release(void *data, struct wl_buffer *wl_buffer)
|
||
{
|
||
/* Sent by the compositor when it's no longer using this buffer */
|
||
wl_buffer_destroy(wl_buffer);
|
||
}
|
||
|
||
static const struct wl_buffer_listener wl_buffer_listener = {
|
||
.release = wl_buffer_release,
|
||
};
|
||
|
||
static void
|
||
draw_rounded_rectangle(cairo_t *cr, int x, int y, int width, int height, int radius)
|
||
{
|
||
cairo_new_sub_path(cr);
|
||
cairo_arc(cr, x + radius, y + radius, radius, M_PI, 3*M_PI/2);
|
||
cairo_arc(cr, x + width - radius, y + radius, radius, 3*M_PI/2, 0);
|
||
cairo_arc(cr, x + width - radius, y + height - radius, radius, 0, M_PI/2);
|
||
cairo_arc(cr, x + radius, y + height - radius, radius, M_PI/2, M_PI);
|
||
cairo_close_path(cr);
|
||
}
|
||
|
||
static struct wl_buffer *
|
||
draw_frame(struct client_state *state, const int width, const int height)
|
||
{
|
||
int stride = width * 4;
|
||
int size = stride * height;
|
||
|
||
int fd = allocate_shm_file(size);
|
||
if (fd == -1) {
|
||
return NULL;
|
||
}
|
||
|
||
uint32_t *data = mmap(NULL, size,
|
||
PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
|
||
if (data == MAP_FAILED) {
|
||
close(fd);
|
||
return NULL;
|
||
}
|
||
|
||
struct wl_shm_pool *pool = wl_shm_create_pool(state->wl_shm, fd, size);
|
||
struct wl_buffer *buffer = wl_shm_pool_create_buffer(pool, 0,
|
||
width, height, stride, WL_SHM_FORMAT_ARGB8888);
|
||
wl_shm_pool_destroy(pool);
|
||
close(fd);
|
||
|
||
cairo_surface_t *cairo_target_surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height);
|
||
cairo_t *cairo = cairo_create(cairo_target_surface);
|
||
memset(cairo_image_surface_get_data(cairo_target_surface), 0, size);
|
||
|
||
/* Draw background */
|
||
if (!color_argb_equal(&state->user_request.backdrop, &color_transparent_black)) {
|
||
set_source_argb_cairo(cairo, &state->user_request.backdrop);
|
||
draw_rounded_rectangle(cairo, 0, 0, width, height, state->user_request.border_radius);
|
||
cairo_fill(cairo);
|
||
}
|
||
|
||
/* Load and draw PNG */
|
||
if (strcmp("", state->user_request.graphics_filename) != STR_EQUAL) {
|
||
cairo_save(cairo);
|
||
cairo_surface_t *cairo_png_surface = cairo_image_surface_create_from_png(state->user_request.graphics_filename);
|
||
if (cairo_surface_status(cairo_png_surface) != CAIRO_STATUS_SUCCESS) {
|
||
fprintf(stderr, "Failed to open PNG image.\n");
|
||
exit(1);
|
||
}
|
||
|
||
/* Set transformations to fit image in box */
|
||
int img_width = cairo_image_surface_get_width(cairo_png_surface);
|
||
int img_height = cairo_image_surface_get_height(cairo_png_surface);
|
||
double width_scale = ((double)width - 2*state->user_request.padding) / img_width;
|
||
double height_scale = (((double)height - 2*state->user_request.padding) * 3 / 4.0) / img_height;
|
||
double scale = MIN(width_scale, height_scale);
|
||
if (scale > 1.0) scale = 1.0;
|
||
cairo_translate(cairo,
|
||
(width - img_width *scale)/2.0,
|
||
(3*height/4.0 - img_height*scale)/2.0);
|
||
cairo_scale(cairo, scale, scale);
|
||
|
||
cairo_set_source_surface(cairo, cairo_png_surface, 0.0, 0.0);
|
||
cairo_paint(cairo);
|
||
cairo_surface_destroy(cairo_png_surface);
|
||
cairo_restore(cairo);
|
||
}
|
||
|
||
/* Draw text */
|
||
if (state->user_request.text) {
|
||
PangoLayout *layout = pango_cairo_create_layout(cairo);
|
||
pango_layout_set_text(layout, state->user_request.text, -1);
|
||
pango_layout_set_alignment(layout, PANGO_ALIGN_CENTER);
|
||
pango_layout_set_width(layout, (width - 2*state->user_request.padding) * PANGO_SCALE);
|
||
PangoFontDescription *desc = pango_font_description_from_string(
|
||
state->user_request.font != NULL ? state->user_request.font : DEFAULT_FONT);
|
||
pango_layout_set_font_description(layout, desc);
|
||
pango_font_description_free(desc);
|
||
set_source_argb_cairo(cairo, &state->user_request.text_color);
|
||
int text_width = 0, text_height = 0;
|
||
pango_layout_get_size(layout, &text_width, &text_height);
|
||
cairo_move_to(cairo, state->user_request.padding, 3*height/4.0);
|
||
pango_cairo_show_layout(cairo, layout);
|
||
g_object_unref(layout);
|
||
}
|
||
|
||
memcpy(data, cairo_image_surface_get_data(cairo_target_surface), size);
|
||
cairo_surface_destroy(cairo_target_surface);
|
||
cairo_destroy(cairo);
|
||
|
||
munmap(data, size);
|
||
wl_buffer_add_listener(buffer, &wl_buffer_listener, NULL);
|
||
|
||
return buffer;
|
||
}
|
||
|
||
static void
|
||
zwlr_layer_surface_configure(void *data,
|
||
struct zwlr_layer_surface_v1 *zwlr_layer_surface_v1,
|
||
uint32_t serial, uint32_t width, uint32_t height)
|
||
{
|
||
struct client_state *state = data;
|
||
zwlr_layer_surface_v1_ack_configure(zwlr_layer_surface_v1, serial);
|
||
|
||
struct wl_buffer *buffer = draw_frame(state, width, height);
|
||
wl_surface_attach(state->wl_surface, buffer, 0, 0);
|
||
wl_surface_commit(state->wl_surface);
|
||
}
|
||
|
||
static const struct zwlr_layer_surface_v1_listener zwlr_layer_surface_listener = {
|
||
.configure = zwlr_layer_surface_configure,
|
||
};
|
||
|
||
static void
|
||
wl_pointer_button(void *data, struct wl_pointer *wl_pointer,
|
||
uint32_t serial, uint32_t time, uint32_t button, uint32_t button_state)
|
||
{
|
||
struct client_state *state = data;
|
||
state->stop = true;
|
||
}
|
||
|
||
void wl_pointer_enter(void *data, struct wl_pointer *wl_pointer,
|
||
uint32_t serial, struct wl_surface *surface, wl_fixed_t surface_x, wl_fixed_t surface_y) {}
|
||
void wl_pointer_leave(void *data, struct wl_pointer *wl_pointer,
|
||
uint32_t serial, struct wl_surface *surface) {}
|
||
void wl_pointer_motion(void *data, struct wl_pointer *wl_pointer,
|
||
uint32_t time, wl_fixed_t surface_x, wl_fixed_t surface_y) {}
|
||
void wl_pointer_axis(void *data, struct wl_pointer *wl_pointer,
|
||
uint32_t time, uint32_t axis, wl_fixed_t value) {}
|
||
void wl_pointer_frame(void *data, struct wl_pointer *wl_pointer) {}
|
||
void wl_pointer_axis_source(void *data, struct wl_pointer *wl_pointer,
|
||
uint32_t axis_source) {}
|
||
void wl_pointer_axis_stop(void *data, struct wl_pointer *wl_pointer,
|
||
uint32_t time, uint32_t axis) {}
|
||
void wl_pointer_axis_discrete(void *data, struct wl_pointer *wl_pointer,
|
||
uint32_t axis, int32_t discrete) {}
|
||
void wl_pointer_axis_value120(void *data, struct wl_pointer *wl_pointer,
|
||
uint32_t axis, int32_t value120) {}
|
||
|
||
|
||
static const struct wl_pointer_listener wl_pointer_listener = {
|
||
.button = wl_pointer_button,
|
||
.enter = wl_pointer_enter,
|
||
.leave = wl_pointer_leave,
|
||
.motion = wl_pointer_motion,
|
||
.axis = wl_pointer_axis,
|
||
.frame = wl_pointer_frame,
|
||
.axis_source = wl_pointer_axis_source,
|
||
.axis_stop = wl_pointer_axis_stop,
|
||
.axis_discrete = wl_pointer_axis_discrete,
|
||
.axis_value120 = wl_pointer_axis_value120,
|
||
};
|
||
|
||
static void
|
||
registry_global(void *data, struct wl_registry *wl_registry,
|
||
uint32_t name, const char *interface, uint32_t version)
|
||
{
|
||
struct client_state *state = data;
|
||
if (strcmp(interface, wl_shm_interface.name) == STR_EQUAL) {
|
||
state->wl_shm = wl_registry_bind(
|
||
wl_registry, name, &wl_shm_interface, 1);
|
||
|
||
} else if (strcmp(interface, wl_compositor_interface.name) == STR_EQUAL) {
|
||
state->wl_compositor = wl_registry_bind(
|
||
wl_registry, name, &wl_compositor_interface, 4);
|
||
|
||
} else if (strcmp(interface, zwlr_layer_shell_v1_interface.name) == STR_EQUAL) {
|
||
state->layer_shell = wl_registry_bind(
|
||
wl_registry, name, &zwlr_layer_shell_v1_interface, 1);
|
||
|
||
} else if (strcmp(interface, wl_seat_interface.name) == STR_EQUAL) {
|
||
state->wl_seat = wl_registry_bind(
|
||
wl_registry, name, &wl_seat_interface, 7);
|
||
}
|
||
}
|
||
|
||
static void
|
||
registry_global_remove(void *data,
|
||
struct wl_registry *wl_registry, uint32_t name)
|
||
{
|
||
/* This space deliberately left blank */
|
||
}
|
||
|
||
static const struct wl_registry_listener wl_registry_listener = {
|
||
.global = registry_global,
|
||
.global_remove = registry_global_remove,
|
||
};
|
||
|
||
|
||
|
||
|
||
static void
|
||
parse_hex(char *hex, struct color_argb *result_color) {
|
||
if (strlen(hex) != 4 * 2) {
|
||
// Invalid
|
||
result_color->a = -1.0;
|
||
return;
|
||
}
|
||
int a, r, g, b;
|
||
sscanf(hex, "%02x%02x%02x%02x", &a, &r, &g, &b);
|
||
result_color->a = a / 255.0;
|
||
result_color->r = r / 255.0;
|
||
result_color->g = g / 255.0;
|
||
result_color->b = b / 255.0;
|
||
}
|
||
|
||
static void
|
||
print_usage()
|
||
{
|
||
fprintf(stderr, "Usage: wl-overlay [options...] <image.png> [text]\n\n"
|
||
"image.png must be the path to a valid PNG image or may be the empty string for "
|
||
"no image. text is the text to show.\n\n"
|
||
"Options:\n"
|
||
" -h --help Show this help text and exit\n"
|
||
" --backdrop=<aarrggbb> Set backdrop colour (default d9111111, set to 00000000 to disable backdrop)\n"
|
||
" --color=<aarrggbb> Set text colour (default ffffffff)\n"
|
||
" --border-radius=<int> Give the backdrop rounded corners with specified radius (default %d)\n"
|
||
" --font=<str> Set font of text (default ‘" DEFAULT_FONT "’)\n"
|
||
" --width=<int> \n"
|
||
" --height=<int> Set width and height (default %d×%d)\n"
|
||
" --padding=<int> Set padding around image and text (default %d)\n",
|
||
DEFAULT_BORDER_RADIUS,
|
||
DEFAULT_WIDTH, DEFAULT_HEIGHT,
|
||
DEFAULT_PADDING);
|
||
}
|
||
|
||
int
|
||
main(int argc, char *argv[])
|
||
{
|
||
struct client_state state = { 0 };
|
||
state.user_request.text_color = (struct color_argb){1.0, 1.0, 1.0, 1.0};
|
||
state.user_request.border_radius = DEFAULT_BORDER_RADIUS;
|
||
state.user_request.backdrop = DEFAULT_BACKDROP_COLOR;
|
||
state.user_request.width = DEFAULT_WIDTH;
|
||
state.user_request.height = DEFAULT_HEIGHT;
|
||
state.user_request.padding = DEFAULT_PADDING;
|
||
|
||
int c;
|
||
|
||
while (1) {
|
||
int option_index = 0;
|
||
static struct option long_options[] = {
|
||
{"help", no_argument, 0, 'h'},
|
||
{"backdrop", required_argument, 0, 0 },
|
||
{"color", required_argument, 0, 0 },
|
||
{"colour", required_argument, 0, 0 },
|
||
{"border-radius", required_argument, 0, 0 },
|
||
{"font", required_argument, 0, 0 },
|
||
{"width", required_argument, 0, 0 },
|
||
{"height", required_argument, 0, 0 },
|
||
{"padding", required_argument, 0, 0 },
|
||
{0, 0, 0, 0 }
|
||
};
|
||
|
||
c = getopt_long(argc, argv, "h", long_options, &option_index);
|
||
if (c == -1)
|
||
break;
|
||
|
||
switch (c) {
|
||
case 0:
|
||
switch (option_index) {
|
||
case 1: parse_hex(optarg, &state.user_request.backdrop); break;
|
||
case 2: case 3: parse_hex(optarg, &state.user_request.text_color); break;
|
||
case 4: state.user_request.border_radius = atoi(optarg); break;
|
||
case 5: state.user_request.font = strdup(optarg); break;
|
||
case 6: state.user_request.width = atoi(optarg); break;
|
||
case 7: state.user_request.height = atoi(optarg); break;
|
||
case 8: state.user_request.padding = atoi(optarg); break;
|
||
default: break;
|
||
}
|
||
break;
|
||
case 'h':
|
||
print_usage();
|
||
exit(0);
|
||
break;
|
||
default: break;
|
||
}
|
||
}
|
||
|
||
if (optind < argc) {
|
||
state.user_request.graphics_filename = strdup(argv[optind]);
|
||
} else {
|
||
print_usage();
|
||
exit(1);
|
||
}
|
||
optind++;
|
||
if (optind < argc) {
|
||
state.user_request.text = strdup(argv[optind]);
|
||
} else {
|
||
state.user_request.text = NULL;
|
||
}
|
||
|
||
if (color_argb_invalid(&state.user_request.backdrop)) {
|
||
fprintf(stderr, "Invalid --backdrop color, must be hexadecimal aarrggbb\n");
|
||
exit(1);
|
||
}
|
||
if (color_argb_invalid(&state.user_request.text_color)) {
|
||
fprintf(stderr, "Invalid --font color, must be hexadecimal aarrggbb\n");
|
||
exit(1);
|
||
}
|
||
|
||
|
||
|
||
state.wl_display = wl_display_connect(NULL);
|
||
if (!state.wl_display) {
|
||
fprintf(stderr, "Could not connect to Wayland server\n");
|
||
exit(1);
|
||
}
|
||
state.wl_registry = wl_display_get_registry(state.wl_display);
|
||
wl_registry_add_listener(state.wl_registry, &wl_registry_listener, &state);
|
||
wl_display_roundtrip(state.wl_display);
|
||
|
||
if (state.layer_shell == NULL) {
|
||
fprintf(stderr, "Wayland compositor does not support wlr-layer-shell protocol\n");
|
||
exit(1);
|
||
}
|
||
|
||
state.wl_surface = wl_compositor_create_surface(state.wl_compositor);
|
||
state.zwlr_surface = zwlr_layer_shell_v1_get_layer_surface(
|
||
state.layer_shell, state.wl_surface, NULL, ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY, "wl-overlay");
|
||
zwlr_layer_surface_v1_set_size(state.zwlr_surface, state.user_request.width, state.user_request.height);
|
||
zwlr_layer_surface_v1_set_anchor(state.zwlr_surface, ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM);
|
||
zwlr_layer_surface_v1_set_margin(state.zwlr_surface, 50, 50, 50, 50);
|
||
|
||
zwlr_layer_surface_v1_add_listener(state.zwlr_surface, &zwlr_layer_surface_listener, &state);
|
||
|
||
struct wl_pointer *pointer = wl_seat_get_pointer(state.wl_seat);
|
||
wl_pointer_add_listener(pointer, &wl_pointer_listener, &state);
|
||
|
||
wl_surface_commit(state.wl_surface);
|
||
|
||
while (wl_display_dispatch(state.wl_display) && !state.stop) {
|
||
/* This space deliberately left blank */
|
||
}
|
||
|
||
if (state.wl_surface != NULL) {
|
||
wl_surface_destroy(state.wl_surface);
|
||
state.wl_surface = NULL;
|
||
}
|
||
|
||
free(state.user_request.graphics_filename);
|
||
if (state.user_request.text != NULL) {
|
||
free(state.user_request.text);
|
||
}
|
||
if (state.user_request.font != NULL) {
|
||
free(state.user_request.font);
|
||
}
|
||
|
||
return 0;
|
||
}
|