mirror of
https://github.com/swaywm/sway.git
synced 2026-04-26 06:46:26 -04:00
Move client helpers from common/ to client/
The sway binary doesn't need to load images nor use the event loop.
This commit is contained in:
Simon Ser
parent
96102184ab
commit
307ba09b41
4 changed files with 4 additions and 4 deletions
|
|
@ -1,220 +0,0 @@
|
|||
#include <assert.h>
|
||||
#include "background-image.h"
|
||||
#include "cairo_util.h"
|
||||
#include "log.h"
|
||||
#if HAVE_GDK_PIXBUF
|
||||
#include <gdk-pixbuf/gdk-pixbuf.h>
|
||||
#endif
|
||||
|
||||
enum background_mode parse_background_mode(const char *mode) {
|
||||
if (strcmp(mode, "stretch") == 0) {
|
||||
return BACKGROUND_MODE_STRETCH;
|
||||
} else if (strcmp(mode, "fill") == 0) {
|
||||
return BACKGROUND_MODE_FILL;
|
||||
} else if (strcmp(mode, "fit") == 0) {
|
||||
return BACKGROUND_MODE_FIT;
|
||||
} else if (strcmp(mode, "center") == 0) {
|
||||
return BACKGROUND_MODE_CENTER;
|
||||
} else if (strcmp(mode, "tile") == 0) {
|
||||
return BACKGROUND_MODE_TILE;
|
||||
} else if (strcmp(mode, "solid_color") == 0) {
|
||||
return BACKGROUND_MODE_SOLID_COLOR;
|
||||
}
|
||||
sway_log(SWAY_ERROR, "Unsupported background mode: %s", mode);
|
||||
return BACKGROUND_MODE_INVALID;
|
||||
}
|
||||
|
||||
#if HAVE_GDK_PIXBUF
|
||||
static cairo_surface_t* gdk_cairo_image_surface_create_from_pixbuf(
|
||||
const GdkPixbuf *gdkbuf) {
|
||||
int chan = gdk_pixbuf_get_n_channels(gdkbuf);
|
||||
if (chan < 3) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const guint8* gdkpix = gdk_pixbuf_read_pixels(gdkbuf);
|
||||
if (!gdkpix) {
|
||||
return NULL;
|
||||
}
|
||||
gint w = gdk_pixbuf_get_width(gdkbuf);
|
||||
gint h = gdk_pixbuf_get_height(gdkbuf);
|
||||
int stride = gdk_pixbuf_get_rowstride(gdkbuf);
|
||||
|
||||
cairo_format_t fmt = (chan == 3) ? CAIRO_FORMAT_RGB24 : CAIRO_FORMAT_ARGB32;
|
||||
cairo_surface_t * cs = cairo_image_surface_create (fmt, w, h);
|
||||
cairo_surface_flush (cs);
|
||||
if ( !cs || cairo_surface_status(cs) != CAIRO_STATUS_SUCCESS) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int cstride = cairo_image_surface_get_stride(cs);
|
||||
unsigned char * cpix = cairo_image_surface_get_data(cs);
|
||||
|
||||
if (chan == 3) {
|
||||
int i;
|
||||
for (i = h; i; --i) {
|
||||
const guint8 *gp = gdkpix;
|
||||
unsigned char *cp = cpix;
|
||||
const guint8* end = gp + 3*w;
|
||||
while (gp < end) {
|
||||
#if G_BYTE_ORDER == G_LITTLE_ENDIAN
|
||||
cp[0] = gp[2];
|
||||
cp[1] = gp[1];
|
||||
cp[2] = gp[0];
|
||||
#else
|
||||
cp[1] = gp[0];
|
||||
cp[2] = gp[1];
|
||||
cp[3] = gp[2];
|
||||
#endif
|
||||
gp += 3;
|
||||
cp += 4;
|
||||
}
|
||||
gdkpix += stride;
|
||||
cpix += cstride;
|
||||
}
|
||||
} else {
|
||||
/* premul-color = alpha/255 * color/255 * 255 = (alpha*color)/255
|
||||
* (z/255) = z/256 * 256/255 = z/256 (1 + 1/255)
|
||||
* = z/256 + (z/256)/255 = (z + z/255)/256
|
||||
* # recurse once
|
||||
* = (z + (z + z/255)/256)/256
|
||||
* = (z + z/256 + z/256/255) / 256
|
||||
* # only use 16bit uint operations, loose some precision,
|
||||
* # result is floored.
|
||||
* -> (z + z>>8)>>8
|
||||
* # add 0x80/255 = 0.5 to convert floor to round
|
||||
* => (z+0x80 + (z+0x80)>>8 ) >> 8
|
||||
* ------
|
||||
* tested as equal to lround(z/255.0) for uint z in [0..0xfe02]
|
||||
*/
|
||||
#define PREMUL_ALPHA(x,a,b,z) \
|
||||
G_STMT_START { z = a * b + 0x80; x = (z + (z >> 8)) >> 8; } \
|
||||
G_STMT_END
|
||||
int i;
|
||||
for (i = h; i; --i) {
|
||||
const guint8 *gp = gdkpix;
|
||||
unsigned char *cp = cpix;
|
||||
const guint8* end = gp + 4*w;
|
||||
guint z1, z2, z3;
|
||||
while (gp < end) {
|
||||
#if G_BYTE_ORDER == G_LITTLE_ENDIAN
|
||||
PREMUL_ALPHA(cp[0], gp[2], gp[3], z1);
|
||||
PREMUL_ALPHA(cp[1], gp[1], gp[3], z2);
|
||||
PREMUL_ALPHA(cp[2], gp[0], gp[3], z3);
|
||||
cp[3] = gp[3];
|
||||
#else
|
||||
PREMUL_ALPHA(cp[1], gp[0], gp[3], z1);
|
||||
PREMUL_ALPHA(cp[2], gp[1], gp[3], z2);
|
||||
PREMUL_ALPHA(cp[3], gp[2], gp[3], z3);
|
||||
cp[0] = gp[3];
|
||||
#endif
|
||||
gp += 4;
|
||||
cp += 4;
|
||||
}
|
||||
gdkpix += stride;
|
||||
cpix += cstride;
|
||||
}
|
||||
#undef PREMUL_ALPHA
|
||||
}
|
||||
cairo_surface_mark_dirty(cs);
|
||||
return cs;
|
||||
}
|
||||
#endif // HAVE_GDK_PIXBUF
|
||||
|
||||
cairo_surface_t *load_background_image(const char *path) {
|
||||
cairo_surface_t *image;
|
||||
#if HAVE_GDK_PIXBUF
|
||||
GError *err = NULL;
|
||||
GdkPixbuf *pixbuf = gdk_pixbuf_new_from_file(path, &err);
|
||||
if (!pixbuf) {
|
||||
sway_log(SWAY_ERROR, "Failed to load background image (%s).",
|
||||
err->message);
|
||||
return NULL;
|
||||
}
|
||||
image = gdk_cairo_image_surface_create_from_pixbuf(pixbuf);
|
||||
g_object_unref(pixbuf);
|
||||
#else
|
||||
image = cairo_image_surface_create_from_png(path);
|
||||
#endif // HAVE_GDK_PIXBUF
|
||||
if (!image) {
|
||||
sway_log(SWAY_ERROR, "Failed to read background image.");
|
||||
return NULL;
|
||||
}
|
||||
if (cairo_surface_status(image) != CAIRO_STATUS_SUCCESS) {
|
||||
sway_log(SWAY_ERROR, "Failed to read background image: %s."
|
||||
#if !HAVE_GDK_PIXBUF
|
||||
"\nSway was compiled without gdk_pixbuf support, so only"
|
||||
"\nPNG images can be loaded. This is the likely cause."
|
||||
#endif // !HAVE_GDK_PIXBUF
|
||||
, cairo_status_to_string(cairo_surface_status(image)));
|
||||
return NULL;
|
||||
}
|
||||
return image;
|
||||
}
|
||||
|
||||
void render_background_image(cairo_t *cairo, cairo_surface_t *image,
|
||||
enum background_mode mode, int buffer_width, int buffer_height) {
|
||||
double width = cairo_image_surface_get_width(image);
|
||||
double height = cairo_image_surface_get_height(image);
|
||||
|
||||
cairo_save(cairo);
|
||||
switch (mode) {
|
||||
case BACKGROUND_MODE_STRETCH:
|
||||
cairo_scale(cairo,
|
||||
(double)buffer_width / width,
|
||||
(double)buffer_height / height);
|
||||
cairo_set_source_surface(cairo, image, 0, 0);
|
||||
break;
|
||||
case BACKGROUND_MODE_FILL: {
|
||||
double window_ratio = (double)buffer_width / buffer_height;
|
||||
double bg_ratio = width / height;
|
||||
|
||||
if (window_ratio > bg_ratio) {
|
||||
double scale = (double)buffer_width / width;
|
||||
cairo_scale(cairo, scale, scale);
|
||||
cairo_set_source_surface(cairo, image,
|
||||
0, (double)buffer_height / 2 / scale - height / 2);
|
||||
} else {
|
||||
double scale = (double)buffer_height / height;
|
||||
cairo_scale(cairo, scale, scale);
|
||||
cairo_set_source_surface(cairo, image,
|
||||
(double)buffer_width / 2 / scale - width / 2, 0);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case BACKGROUND_MODE_FIT: {
|
||||
double window_ratio = (double)buffer_width / buffer_height;
|
||||
double bg_ratio = width / height;
|
||||
|
||||
if (window_ratio > bg_ratio) {
|
||||
double scale = (double)buffer_height / height;
|
||||
cairo_scale(cairo, scale, scale);
|
||||
cairo_set_source_surface(cairo, image,
|
||||
(double)buffer_width / 2 / scale - width / 2, 0);
|
||||
} else {
|
||||
double scale = (double)buffer_width / width;
|
||||
cairo_scale(cairo, scale, scale);
|
||||
cairo_set_source_surface(cairo, image,
|
||||
0, (double)buffer_height / 2 / scale - height / 2);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case BACKGROUND_MODE_CENTER:
|
||||
cairo_set_source_surface(cairo, image,
|
||||
(double)buffer_width / 2 - width / 2,
|
||||
(double)buffer_height / 2 - height / 2);
|
||||
break;
|
||||
case BACKGROUND_MODE_TILE: {
|
||||
cairo_pattern_t *pattern = cairo_pattern_create_for_surface(image);
|
||||
cairo_pattern_set_extend(pattern, CAIRO_EXTEND_REPEAT);
|
||||
cairo_set_source(cairo, pattern);
|
||||
break;
|
||||
}
|
||||
case BACKGROUND_MODE_SOLID_COLOR:
|
||||
case BACKGROUND_MODE_INVALID:
|
||||
assert(0);
|
||||
break;
|
||||
}
|
||||
cairo_paint(cairo);
|
||||
cairo_restore(cairo);
|
||||
}
|
||||
184
common/loop.c
184
common/loop.c
|
|
@ -1,184 +0,0 @@
|
|||
#define _POSIX_C_SOURCE 200112L
|
||||
#include <limits.h>
|
||||
#include <string.h>
|
||||
#include <stdbool.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <poll.h>
|
||||
#include <time.h>
|
||||
#include <unistd.h>
|
||||
#include "list.h"
|
||||
#include "log.h"
|
||||
#include "loop.h"
|
||||
|
||||
struct loop_fd_event {
|
||||
void (*callback)(int fd, short mask, void *data);
|
||||
void *data;
|
||||
};
|
||||
|
||||
struct loop_timer {
|
||||
void (*callback)(void *data);
|
||||
void *data;
|
||||
struct timespec expiry;
|
||||
};
|
||||
|
||||
struct loop {
|
||||
struct pollfd *fds;
|
||||
int fd_length;
|
||||
int fd_capacity;
|
||||
|
||||
list_t *fd_events; // struct loop_fd_event
|
||||
list_t *timers; // struct loop_timer
|
||||
};
|
||||
|
||||
struct loop *loop_create(void) {
|
||||
struct loop *loop = calloc(1, sizeof(struct loop));
|
||||
if (!loop) {
|
||||
sway_log(SWAY_ERROR, "Unable to allocate memory for loop");
|
||||
return NULL;
|
||||
}
|
||||
loop->fd_capacity = 10;
|
||||
loop->fds = malloc(sizeof(struct pollfd) * loop->fd_capacity);
|
||||
loop->fd_events = create_list();
|
||||
loop->timers = create_list();
|
||||
return loop;
|
||||
}
|
||||
|
||||
void loop_destroy(struct loop *loop) {
|
||||
list_free_items_and_destroy(loop->fd_events);
|
||||
list_free_items_and_destroy(loop->timers);
|
||||
free(loop->fds);
|
||||
free(loop);
|
||||
}
|
||||
|
||||
void loop_poll(struct loop *loop) {
|
||||
// Calculate next timer in ms
|
||||
int ms = INT_MAX;
|
||||
if (loop->timers->length) {
|
||||
struct timespec now;
|
||||
clock_gettime(CLOCK_MONOTONIC, &now);
|
||||
for (int i = 0; i < loop->timers->length; ++i) {
|
||||
struct loop_timer *timer = loop->timers->items[i];
|
||||
int timer_ms = (timer->expiry.tv_sec - now.tv_sec) * 1000;
|
||||
timer_ms += (timer->expiry.tv_nsec - now.tv_nsec) / 1000000;
|
||||
if (timer_ms < ms) {
|
||||
ms = timer_ms;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (ms < 0) {
|
||||
ms = 0;
|
||||
}
|
||||
|
||||
poll(loop->fds, loop->fd_length, ms);
|
||||
|
||||
// Dispatch fds
|
||||
for (int i = 0; i < loop->fd_length; ++i) {
|
||||
struct pollfd pfd = loop->fds[i];
|
||||
struct loop_fd_event *event = loop->fd_events->items[i];
|
||||
|
||||
// Always send these events
|
||||
unsigned events = pfd.events | POLLHUP | POLLERR;
|
||||
|
||||
if (pfd.revents & events) {
|
||||
event->callback(pfd.fd, pfd.revents, event->data);
|
||||
}
|
||||
}
|
||||
|
||||
// Dispatch timers
|
||||
if (loop->timers->length) {
|
||||
struct timespec now;
|
||||
clock_gettime(CLOCK_MONOTONIC, &now);
|
||||
for (int i = 0; i < loop->timers->length; ++i) {
|
||||
struct loop_timer *timer = loop->timers->items[i];
|
||||
bool expired = timer->expiry.tv_sec < now.tv_sec ||
|
||||
(timer->expiry.tv_sec == now.tv_sec &&
|
||||
timer->expiry.tv_nsec < now.tv_nsec);
|
||||
if (expired) {
|
||||
timer->callback(timer->data);
|
||||
loop_remove_timer(loop, timer);
|
||||
--i;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void loop_add_fd(struct loop *loop, int fd, short mask,
|
||||
void (*callback)(int fd, short mask, void *data), void *data) {
|
||||
struct loop_fd_event *event = calloc(1, sizeof(struct loop_fd_event));
|
||||
if (!event) {
|
||||
sway_log(SWAY_ERROR, "Unable to allocate memory for event");
|
||||
return;
|
||||
}
|
||||
event->callback = callback;
|
||||
event->data = data;
|
||||
list_add(loop->fd_events, event);
|
||||
|
||||
struct pollfd pfd = {fd, mask, 0};
|
||||
|
||||
if (loop->fd_length == loop->fd_capacity) {
|
||||
int capacity = loop->fd_capacity + 10;
|
||||
struct pollfd *tmp = realloc(loop->fds,
|
||||
sizeof(struct pollfd) * capacity);
|
||||
if (!tmp) {
|
||||
sway_log(SWAY_ERROR, "Unable to allocate memory for pollfd");
|
||||
return;
|
||||
}
|
||||
loop->fds = tmp;
|
||||
loop->fd_capacity = capacity;
|
||||
}
|
||||
|
||||
loop->fds[loop->fd_length++] = pfd;
|
||||
}
|
||||
|
||||
struct loop_timer *loop_add_timer(struct loop *loop, int ms,
|
||||
void (*callback)(void *data), void *data) {
|
||||
struct loop_timer *timer = calloc(1, sizeof(struct loop_timer));
|
||||
if (!timer) {
|
||||
sway_log(SWAY_ERROR, "Unable to allocate memory for timer");
|
||||
return NULL;
|
||||
}
|
||||
timer->callback = callback;
|
||||
timer->data = data;
|
||||
|
||||
clock_gettime(CLOCK_MONOTONIC, &timer->expiry);
|
||||
timer->expiry.tv_sec += ms / 1000;
|
||||
|
||||
long int nsec = (ms % 1000) * 1000000;
|
||||
if (timer->expiry.tv_nsec + nsec >= 1000000000) {
|
||||
timer->expiry.tv_sec++;
|
||||
nsec -= 1000000000;
|
||||
}
|
||||
timer->expiry.tv_nsec += nsec;
|
||||
|
||||
list_add(loop->timers, timer);
|
||||
|
||||
return timer;
|
||||
}
|
||||
|
||||
bool loop_remove_fd(struct loop *loop, int fd) {
|
||||
for (int i = 0; i < loop->fd_length; ++i) {
|
||||
if (loop->fds[i].fd == fd) {
|
||||
free(loop->fd_events->items[i]);
|
||||
list_del(loop->fd_events, i);
|
||||
|
||||
loop->fd_length--;
|
||||
memmove(&loop->fds[i], &loop->fds[i + 1],
|
||||
sizeof(struct pollfd) * (loop->fd_length - i));
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool loop_remove_timer(struct loop *loop, struct loop_timer *timer) {
|
||||
for (int i = 0; i < loop->timers->length; ++i) {
|
||||
if (loop->timers->items[i] == timer) {
|
||||
list_del(loop->timers, i);
|
||||
free(timer);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
|
@ -1,11 +1,9 @@
|
|||
lib_sway_common = static_library(
|
||||
'sway-common',
|
||||
files(
|
||||
'background-image.c',
|
||||
'cairo.c',
|
||||
'ipc-client.c',
|
||||
'log.c',
|
||||
'loop.c',
|
||||
'list.c',
|
||||
'pango.c',
|
||||
'stringop.c',
|
||||
|
|
@ -13,7 +11,6 @@ lib_sway_common = static_library(
|
|||
),
|
||||
dependencies: [
|
||||
cairo,
|
||||
gdk_pixbuf,
|
||||
pango,
|
||||
pangocairo,
|
||||
wayland_client.partial_dependency(compile_args: true)
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue