itycodes
/
convince
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove obsolete client code

Browse Source
master
Drew DeVault 7 years ago
parent 53e3763b58
commit e9922ec524
10 changed files with 0 additions and 987 deletions
Show Stats Download Patch File Download Diff File

8
include/client/buffer.h
Unescape View File

@ -1,8 +0,0 @@
#ifndef _BUFFER_H
#define _BUFFER_H
#include "client/window.h"
struct buffer *get_next_buffer(struct window *state);
#endif

17
include/client/cairo.h
Unescape View File

@ -1,17 +0,0 @@
#ifndef _SWAY_CAIRO_H
#define _SWAY_CAIRO_H
#include <stdint.h>
#include <cairo/cairo.h>
void cairo_set_source_u32(cairo_t *cairo, uint32_t color);
cairo_surface_t *cairo_image_surface_scale(cairo_surface_t *image, int width, int height);
#ifdef WITH_GDK_PIXBUF
#include <gdk-pixbuf/gdk-pixbuf.h>
cairo_surface_t* gdk_cairo_image_surface_create_from_pixbuf(const GdkPixbuf *gdkbuf);
#endif //WITH_GDK_PIXBUF
#endif

16
include/client/pango.h
Unescape View File

@ -1,16 +0,0 @@
#ifndef _SWAY_CLIENT_PANGO_H
#define _SWAY_CLIENT_PANGO_H
#include <cairo/cairo.h>
#include <pango/pangocairo.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdint.h>
PangoLayout *get_pango_layout(cairo_t *cairo, const char *font, const char *text,
int32_t scale, bool markup);
void get_text_size(cairo_t *cairo, const char *font, int *width, int *height,
int32_t scale, bool markup, const char *fmt, ...);
void pango_printf(cairo_t *cairo, const char *font, int32_t scale, bool markup, const char *fmt, ...);
#endif

75
include/client/registry.h
Unescape View File

@ -1,75 +0,0 @@
#ifndef _SWAY_CLIENT_REGISTRY_H
#define _SWAY_CLIENT_REGISTRY_H
#include <wayland-client.h>
#include <xkbcommon/xkbcommon.h>
#include "wayland-desktop-shell-client-protocol.h"
#include "wayland-swaylock-client-protocol.h"
#include "list.h"
enum mod_bit {
MOD_SHIFT = 1<<0,
MOD_CAPS = 1<<1,
MOD_CTRL = 1<<2,
MOD_ALT = 1<<3,
MOD_MOD2 = 1<<4,
MOD_MOD3 = 1<<5,
MOD_LOGO = 1<<6,
MOD_MOD5 = 1<<7,
};
enum mask {
MASK_SHIFT,
MASK_CAPS,
MASK_CTRL,
MASK_ALT,
MASK_MOD2,
MASK_MOD3,
MASK_LOGO,
MASK_MOD5,
MASK_LAST
};
struct output_state {
struct wl_output *output;
uint32_t flags;
uint32_t width, height;
uint32_t scale;
};
struct xkb {
struct xkb_state *state;
struct xkb_context *context;
struct xkb_keymap *keymap;
xkb_mod_mask_t masks[MASK_LAST];
};
struct input {
struct xkb xkb;
xkb_keysym_t sym;
uint32_t code;
uint32_t last_code;
uint32_t modifiers;
void (*notify)(enum wl_keyboard_key_state state, xkb_keysym_t sym, uint32_t code, uint32_t codepoint);
};
struct registry {
struct wl_compositor *compositor;
struct wl_display *display;
struct wl_pointer *pointer;
struct wl_keyboard *keyboard;
struct wl_seat *seat;
struct wl_shell *shell;
struct wl_shm *shm;
struct desktop_shell *desktop_shell;
struct lock *swaylock;
struct input *input;
list_t *outputs;
};
struct registry *registry_poll(void);
void registry_teardown(struct registry *registry);
#endif

67
include/client/window.h
Unescape View File

@ -1,67 +0,0 @@
#ifndef _CLIENT_H
#define _CLIENT_H
#include <wayland-client.h>
#include "wayland-desktop-shell-client-protocol.h"
#include <cairo/cairo.h>
#include <pango/pangocairo.h>
#include <stdbool.h>
#include "list.h"
#include "client/registry.h"
struct window;
struct buffer {
struct wl_buffer *buffer;
cairo_surface_t *surface;
cairo_t *cairo;
PangoContext *pango;
uint32_t width, height;
bool busy;
};
struct cursor {
struct wl_surface *surface;
struct wl_cursor_theme *cursor_theme;
struct wl_cursor *cursor;
struct wl_pointer *pointer;
};
enum scroll_direction {
SCROLL_UP,
SCROLL_DOWN,
SCROLL_LEFT,
SCROLL_RIGHT,
};
struct pointer_input {
int last_x;
int last_y;
void (*notify_button)(struct window *window, int x, int y, uint32_t button, uint32_t state_w);
void (*notify_scroll)(struct window *window, enum scroll_direction direction);
};
struct window {
struct registry *registry;
struct buffer buffers[2];
struct buffer *buffer;
struct wl_surface *surface;
struct wl_shell_surface *shell_surface;
struct wl_callback *frame_cb;
struct cursor cursor;
uint32_t width, height;
int32_t scale;
char *font;
cairo_t *cairo;
struct pointer_input pointer_input;
};
struct window *window_setup(struct registry *registry, uint32_t width, uint32_t height,
int32_t scale, bool shell_surface);
void window_teardown(struct window *state);
int window_prerender(struct window *state);
int window_render(struct window *state);
void window_make_shell(struct window *window);
#endif

127
wayland/buffers.c
Unescape View File

@ -1,127 +0,0 @@
#define _XOPEN_SOURCE 500
#include <wayland-client.h>
#include <cairo/cairo.h>
#include <pango/pangocairo.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <sys/mman.h>
#include "client/buffer.h"
#include "list.h"
#include "log.h"
static int create_pool_file(size_t size, char **name) {
static const char template[] = "sway-client-XXXXXX";
const char *path = getenv("XDG_RUNTIME_DIR");
if (!path) {
return -1;
}
int ts = (path[strlen(path) - 1] == '/');
*name = malloc(
strlen(template) +
strlen(path) +
(ts ? 0 : 1) + 1);
sprintf(*name, "%s%s%s", path, ts ? "" : "/", template);
int fd = mkstemp(*name);
if (fd < 0) {
return -1;
}
if (ftruncate(fd, size) < 0) {
close(fd);
return -1;
}
return fd;
}
static void buffer_release(void *data, struct wl_buffer *wl_buffer) {
struct buffer *buffer = data;
buffer->busy = false;
}
static const struct wl_buffer_listener buffer_listener = {
.release = buffer_release
};
static struct buffer *create_buffer(struct wl_shm *shm, struct buffer *buf,
int32_t width, int32_t height, uint32_t format) {
uint32_t stride = width * 4;
uint32_t size = stride * height;
char *name;
int fd = create_pool_file(size, &name);
if (fd == -1) {
sway_abort("Unable to allocate buffer");
return NULL; // never reached
}
void *data = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
struct wl_shm_pool *pool = wl_shm_create_pool(shm, fd, size);
buf->buffer = wl_shm_pool_create_buffer(pool, 0,
width, height, stride, format);
wl_shm_pool_destroy(pool);
close(fd);
unlink(name);
free(name);
fd = -1;
buf->width = width;
buf->height = height;
buf->surface = cairo_image_surface_create_for_data(data,
CAIRO_FORMAT_ARGB32, width, height, stride);
buf->cairo = cairo_create(buf->surface);
buf->pango = pango_cairo_create_context(buf->cairo);
wl_buffer_add_listener(buf->buffer, &buffer_listener, buf);
return buf;
}
static void destroy_buffer(struct buffer *buffer) {
if (buffer->buffer) {
wl_buffer_destroy(buffer->buffer);
}
if (buffer->cairo) {
cairo_destroy(buffer->cairo);
}
if (buffer->surface) {
cairo_surface_destroy(buffer->surface);
}
if (buffer->pango) {
g_object_unref(buffer->pango);
}
memset(buffer, 0, sizeof(struct buffer));
}
struct pool_buffer *get_next_buffer(struct wl_shm *shm,
struct pool_buffer pool[2], uint32_t width, uint32_t height) {
struct buffer *buffer = NULL;
for (size_t i = 0; i < sizeof(pool) / sizeof(pool[0]); ++i) {
if (buffers[i].busy) {
continue;
}
buffer = &buffers[i];
}
if (!buffer) {
return NULL;
}
if (buffer->width != width || buffer->height != height) {
destroy_buffer(buffer);
}
if (!buffer->buffer) {
if (!create_buffer(shm, buffer, width, height,
WL_SHM_FORMAT_ARGB8888)) {
return NULL;
}
}
return buffer;
}

134
wayland/cairo.c
Unescape View File

@ -1,134 +0,0 @@
#include "client/cairo.h"
void cairo_set_source_u32(cairo_t *cairo, uint32_t color) {
cairo_set_source_rgba(cairo,
(color >> (3*8) & 0xFF) / 255.0,
(color >> (2*8) & 0xFF) / 255.0,
(color >> (1*8) & 0xFF) / 255.0,
(color >> (0*8) & 0xFF) / 255.0);
}
cairo_surface_t *cairo_image_surface_scale(cairo_surface_t *image, int width, int height) {
int image_width = cairo_image_surface_get_width(image);
int image_height = cairo_image_surface_get_height(image);
cairo_surface_t *new =
cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height);
cairo_t *cairo = cairo_create(new);
cairo_scale(cairo, (double) width / image_width, (double) height / image_height);
cairo_set_source_surface(cairo, image, 0, 0);
cairo_paint(cairo);
cairo_destroy(cairo);
return new;
}
#ifdef WITH_GDK_PIXBUF
#include <gdk-pixbuf/gdk-pixbuf.h>
#ifndef GDK_PIXBUF_CHECK_VERSION
#define GDK_PIXBUF_CHECK_VERSION(major,minor,micro) \
(GDK_PIXBUF_MAJOR > (major) || \
(GDK_PIXBUF_MAJOR == (major) && GDK_PIXBUF_MINOR > (minor)) || \
(GDK_PIXBUF_MAJOR == (major) && GDK_PIXBUF_MINOR == (minor) && \
GDK_PIXBUF_MICRO >= (micro)))
#endif
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;
#if GDK_PIXBUF_CHECK_VERSION(2,32,0)
const guint8* gdkpix = gdk_pixbuf_read_pixels(gdkbuf);
#else
const guint8* gdkpix = gdk_pixbuf_get_pixels(gdkbuf);
#endif
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 //WITH_GDK_PIXBUF

73
wayland/pango.c
Unescape View File

@ -1,73 +0,0 @@
#include <cairo/cairo.h>
#include <pango/pangocairo.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <stdbool.h>
#include <stdint.h>
#include "log.h"
PangoLayout *get_pango_layout(cairo_t *cairo, const char *font, const char *text,
int32_t scale, bool markup) {
PangoLayout *layout = pango_cairo_create_layout(cairo);
PangoAttrList *attrs;
if (markup) {
char *buf;
pango_parse_markup(text, -1, 0, &attrs, &buf, NULL, NULL);
pango_layout_set_markup(layout, buf, -1);
free(buf);
} else {
attrs = pango_attr_list_new();
pango_layout_set_text(layout, text, -1);
}
pango_attr_list_insert(attrs, pango_attr_scale_new(scale));
PangoFontDescription *desc = pango_font_description_from_string(font);
pango_layout_set_font_description(layout, desc);
pango_layout_set_single_paragraph_mode(layout, 1);
pango_layout_set_attributes(layout, attrs);
pango_attr_list_unref(attrs);
pango_font_description_free(desc);
return layout;
}
void get_text_size(cairo_t *cairo, const char *font, int *width, int *height,
int32_t scale, bool markup, const char *fmt, ...) {
char *buf = malloc(2048);
va_list args;
va_start(args, fmt);
if (vsnprintf(buf, 2048, fmt, args) >= 2048) {
strcpy(buf, "[buffer overflow]");
}
va_end(args);
PangoLayout *layout = get_pango_layout(cairo, font, buf, scale, markup);
pango_cairo_update_layout(cairo, layout);
pango_layout_get_pixel_size(layout, width, height);
g_object_unref(layout);
free(buf);
}
void pango_printf(cairo_t *cairo, const char *font, int32_t scale, bool markup, const char *fmt, ...) {
char *buf = malloc(2048);
va_list args;
va_start(args, fmt);
if (vsnprintf(buf, 2048, fmt, args) >= 2048) {
strcpy(buf, "[buffer overflow]");
}
va_end(args);
PangoLayout *layout = get_pango_layout(cairo, font, buf, scale, markup);
pango_cairo_update_layout(cairo, layout);
pango_cairo_show_layout(cairo, layout);
g_object_unref(layout);
free(buf);
}

293
wayland/registry.c
Unescape View File

@ -1,293 +0,0 @@
#include <wayland-client.h>
#include <xkbcommon/xkbcommon.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/timerfd.h>
#include "wayland-desktop-shell-client-protocol.h"
#include "wayland-swaylock-client-protocol.h"
#include "client/registry.h"
#include "stringop.h"
#include "log.h"
static void display_handle_mode(void *data, struct wl_output *wl_output,
uint32_t flags, int32_t width, int32_t height, int32_t refresh) {
struct output_state *state = data;
if (flags & WL_OUTPUT_MODE_CURRENT) {
state->flags = flags;
state->width = width;
state->height = height;
sway_log(L_DEBUG, "Got mode %dx%d:0x%X for output %p",
width, height, flags, data);
}
}
static void display_handle_geometry(void *data, struct wl_output *wl_output,
int32_t x, int32_t y, int32_t physical_width, int32_t physical_height,
int32_t subpixel, const char *make, const char *model, int32_t transform) {
// this space intentionally left blank
}
static void display_handle_done(void *data, struct wl_output *wl_output) {
// this space intentionally left blank
}
static void display_handle_scale(void *data, struct wl_output *wl_output, int32_t factor) {
struct output_state *state = data;
state->scale = factor;
sway_log(L_DEBUG, "Got scale factor %d for output %p", factor, data);
}
static const struct wl_output_listener output_listener = {
.mode = display_handle_mode,
.geometry = display_handle_geometry,
.done = display_handle_done,
.scale = display_handle_scale
};
const char *XKB_MASK_NAMES[MASK_LAST] = {
XKB_MOD_NAME_SHIFT,
XKB_MOD_NAME_CAPS,
XKB_MOD_NAME_CTRL,
XKB_MOD_NAME_ALT,
"Mod2",
"Mod3",
XKB_MOD_NAME_LOGO,
"Mod5",
};
const enum mod_bit XKB_MODS[MASK_LAST] = {
MOD_SHIFT,
MOD_CAPS,
MOD_CTRL,
MOD_ALT,
MOD_MOD2,
MOD_MOD3,
MOD_LOGO,
MOD_MOD5
};
static void keyboard_handle_keymap(void *data, struct wl_keyboard *keyboard,
uint32_t format, int fd, uint32_t size) {
// Keyboard errors are abort-worthy because you wouldn't be able to unlock your screen otherwise.
struct registry *registry = data;
if (!data) {
close(fd);
return;
}
if (format != WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1) {
close(fd);
sway_abort("Unknown keymap format %d, aborting", format);
}
char *map_str = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);
if (map_str == MAP_FAILED) {
close(fd);
sway_abort("Unable to initialized shared keyboard memory, aborting");
}
struct xkb_keymap *keymap = xkb_keymap_new_from_string(registry->input->xkb.context,
map_str, XKB_KEYMAP_FORMAT_TEXT_V1, 0);
munmap(map_str, size);
close(fd);
if (!keymap) {
sway_abort("Failed to compile keymap, aborting");
}
struct xkb_state *state = xkb_state_new(keymap);
if (!state) {
xkb_keymap_unref(keymap);
sway_abort("Failed to create xkb state, aborting");
}
xkb_keymap_unref(registry->input->xkb.keymap);
xkb_state_unref(registry->input->xkb.state);
registry->input->xkb.keymap = keymap;
registry->input->xkb.state = state;
int i;
for (i = 0; i < MASK_LAST; ++i) {
registry->input->xkb.masks[i] = 1 << xkb_keymap_mod_get_index(registry->input->xkb.keymap, XKB_MASK_NAMES[i]);
}
}
static void keyboard_handle_enter(void *data, struct wl_keyboard *keyboard,
uint32_t serial, struct wl_surface *surface, struct wl_array *keys) {
// this space intentionally left blank
}
static void keyboard_handle_leave(void *data, struct wl_keyboard *keyboard,
uint32_t serial, struct wl_surface *surface) {
// this space intentionally left blank
}
static void keyboard_handle_key(void *data, struct wl_keyboard *keyboard,
uint32_t serial, uint32_t time, uint32_t key, uint32_t state_w) {
struct registry *registry = data;
enum wl_keyboard_key_state state = state_w;
if (!registry->input->xkb.state) {
return;
}
xkb_keysym_t sym = xkb_state_key_get_one_sym(registry->input->xkb.state, key + 8);
registry->input->sym = (state == WL_KEYBOARD_KEY_STATE_PRESSED ? sym : XKB_KEY_NoSymbol);
registry->input->code = (state == WL_KEYBOARD_KEY_STATE_PRESSED ? key + 8 : 0);
uint32_t codepoint = xkb_state_key_get_utf32(registry->input->xkb.state, registry->input->code);
if (registry->input->notify) {
registry->input->notify(state, sym, key, codepoint);
}
}
static void keyboard_handle_modifiers(void *data, struct wl_keyboard *keyboard,
uint32_t serial, uint32_t mods_depressed, uint32_t mods_latched,
uint32_t mods_locked, uint32_t group) {
struct registry *registry = data;
if (!registry->input->xkb.keymap) {
return;
}
xkb_state_update_mask(registry->input->xkb.state, mods_depressed, mods_latched, mods_locked, 0, 0, group);
xkb_mod_mask_t mask = xkb_state_serialize_mods(registry->input->xkb.state,
XKB_STATE_MODS_DEPRESSED | XKB_STATE_MODS_LATCHED);
registry->input->modifiers = 0;
for (uint32_t i = 0; i < MASK_LAST; ++i) {
if (mask & registry->input->xkb.masks[i]) {
registry->input->modifiers |= XKB_MODS[i];
}
}
}
static void keyboard_handle_repeat_info(void *data, struct wl_keyboard *keyboard,
int32_t rate, int32_t delay) {
// this space intentionally left blank
}
static const struct wl_keyboard_listener keyboard_listener = {
.keymap = keyboard_handle_keymap,
.enter = keyboard_handle_enter,
.leave = keyboard_handle_leave,
.key = keyboard_handle_key,
.modifiers = keyboard_handle_modifiers,
.repeat_info = keyboard_handle_repeat_info
};
static void seat_handle_capabilities(void *data, struct wl_seat *seat,
enum wl_seat_capability caps) {
struct registry *reg = data;
if ((caps & WL_SEAT_CAPABILITY_POINTER) && !reg->pointer) {
reg->pointer = wl_seat_get_pointer(reg->seat);
} else if (!(caps & WL_SEAT_CAPABILITY_POINTER) && reg->pointer) {
wl_pointer_destroy(reg->pointer);
reg->pointer = NULL;
}
if ((caps & WL_SEAT_CAPABILITY_KEYBOARD) && !reg->keyboard) {
reg->keyboard = wl_seat_get_keyboard(reg->seat);
wl_keyboard_add_listener(reg->keyboard, &keyboard_listener, reg);
} else if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD) && reg->keyboard) {
wl_keyboard_destroy(reg->keyboard);
reg->keyboard = NULL;
}
}
static void seat_handle_name(void *data, struct wl_seat *seat, const char *name) {
// this space intentionally left blank
}
static const struct wl_seat_listener seat_listener = {
.capabilities = seat_handle_capabilities,
.name = seat_handle_name,
};
static void registry_global(void *data, struct wl_registry *registry,
uint32_t name, const char *interface, uint32_t version) {
struct registry *reg = data;
if (strcmp(interface, wl_compositor_interface.name) == 0) {
reg->compositor = wl_registry_bind(registry, name, &wl_compositor_interface, version);
} else if (strcmp(interface, wl_shm_interface.name) == 0) {
reg->shm = wl_registry_bind(registry, name, &wl_shm_interface, version);
} else if (strcmp(interface, wl_shell_interface.name) == 0) {
reg->shell = wl_registry_bind(registry, name, &wl_shell_interface, version);
} else if (strcmp(interface, wl_seat_interface.name) == 0) {
reg->seat = wl_registry_bind(registry, name, &wl_seat_interface, version);
wl_seat_add_listener(reg->seat, &seat_listener, reg);
} else if (strcmp(interface, wl_output_interface.name) == 0) {
struct wl_output *output = wl_registry_bind(registry, name, &wl_output_interface, version);
struct output_state *ostate = malloc(sizeof(struct output_state));
ostate->output = output;
ostate->scale = 1;
wl_output_add_listener(output, &output_listener, ostate);
list_add(reg->outputs, ostate);
} else if (strcmp(interface, desktop_shell_interface.name) == 0) {
reg->desktop_shell = wl_registry_bind(registry, name, &desktop_shell_interface, version);
} else if (strcmp(interface, lock_interface.name) == 0) {
reg->swaylock = wl_registry_bind(registry, name, &lock_interface, version);
}
}
static void registry_global_remove(void *data, struct wl_registry *registry, uint32_t name) {
// this space intentionally left blank
}
static const struct wl_registry_listener registry_listener = {
.global = registry_global,
.global_remove = registry_global_remove
};
struct registry *registry_poll(void) {
struct registry *registry = malloc(sizeof(struct registry));
memset(registry, 0, sizeof(struct registry));
registry->outputs = create_list();
registry->input = calloc(sizeof(struct input), 1);
registry->input->xkb.context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
registry->display = wl_display_connect(NULL);
if (!registry->display) {
sway_log(L_ERROR, "Error opening display");
registry_teardown(registry);
return NULL;
}
struct wl_registry *reg = wl_display_get_registry(registry->display);
wl_registry_add_listener(reg, &registry_listener, registry);
wl_display_dispatch(registry->display);
wl_display_roundtrip(registry->display);
wl_registry_destroy(reg);
return registry;
}
void registry_teardown(struct registry *registry) {
if (registry->pointer) {
wl_pointer_destroy(registry->pointer);
}
if (registry->seat) {
wl_seat_destroy(registry->seat);
}
if (registry->shell) {
wl_shell_destroy(registry->shell);
}
if (registry->shm) {
wl_shm_destroy(registry->shm);
}
if (registry->compositor) {
wl_compositor_destroy(registry->compositor);
}
if (registry->display) {
wl_display_disconnect(registry->display);
}
if (registry->outputs) {
free_flat_list(registry->outputs);
}
free(registry);
}

177
wayland/window.c
Unescape View File

@ -1,177 +0,0 @@
#include <wayland-client.h>
#include <wayland-cursor.h>
#include "wayland-xdg-shell-client-protocol.h"
#include "wayland-desktop-shell-client-protocol.h"
#include <cairo/cairo.h>
#include <pango/pangocairo.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <sys/mman.h>
#include "client/window.h"
#include "client/buffer.h"
#include "list.h"
#include "log.h"
static void pointer_handle_enter(void *data, struct wl_pointer *pointer,
uint32_t serial, struct wl_surface *surface, wl_fixed_t sx_w, wl_fixed_t sy_w) {
struct window *window = data;
if (window->registry->pointer) {
struct wl_cursor_image *image = window->cursor.cursor->images[0];
wl_pointer_set_cursor(pointer, serial, window->cursor.surface, image->hotspot_x, image->hotspot_y);
}
}
static void pointer_handle_leave(void *data, struct wl_pointer *pointer,
uint32_t serial, struct wl_surface *surface) {
}
static void pointer_handle_motion(void *data, struct wl_pointer *pointer,
uint32_t time, wl_fixed_t sx_w, wl_fixed_t sy_w) {
struct window *window = data;
window->pointer_input.last_x = wl_fixed_to_int(sx_w);
window->pointer_input.last_y = wl_fixed_to_int(sy_w);
}
static void pointer_handle_button(void *data, struct wl_pointer *pointer, uint32_t serial,
uint32_t time, uint32_t button, uint32_t state_w) {
struct window *window = data;
struct pointer_input *input = &window->pointer_input;
if (window->pointer_input.notify_button) {
window->pointer_input.notify_button(window, input->last_x, input->last_y, button, state_w);
}
}
static void pointer_handle_axis(void *data, struct wl_pointer *pointer,
uint32_t time, uint32_t axis, wl_fixed_t value) {
struct window *window = data;
enum scroll_direction direction;
switch (axis) {
case 0:
direction = wl_fixed_to_double(value) < 0 ? SCROLL_UP : SCROLL_DOWN;
break;
case 1:
direction = wl_fixed_to_double(value) < 0 ? SCROLL_LEFT : SCROLL_RIGHT;
break;
default:
sway_log(L_DEBUG, "Unexpected axis value on mouse scroll");
return;
}
if (window->pointer_input.notify_scroll) {
window->pointer_input.notify_scroll(window, direction);
}
}
static const struct wl_pointer_listener pointer_listener = {
.enter = pointer_handle_enter,
.leave = pointer_handle_leave,
.motion = pointer_handle_motion,
.button = pointer_handle_button,
.axis = pointer_handle_axis
};
void shell_surface_configure(void *data, struct wl_shell_surface *wl_shell_surface,
uint32_t edges, int32_t width, int32_t height) {
struct window *window = data;
window->width = width;
window->height = height;
}
static const struct wl_shell_surface_listener surface_listener = {
.configure = shell_surface_configure
};
void window_make_shell(struct window *window) {
window->shell_surface = wl_shell_get_shell_surface(window->registry->shell, window->surface);
wl_shell_surface_add_listener(window->shell_surface, &surface_listener, window);
wl_shell_surface_set_toplevel(window->shell_surface);
}
struct window *window_setup(struct registry *registry, uint32_t width, uint32_t height,
int32_t scale, bool shell_surface) {
struct window *window = malloc(sizeof(struct window));
memset(window, 0, sizeof(struct window));
window->width = width;
window->height = height;
window->scale = scale;
window->registry = registry;
window->font = "monospace 10";
window->surface = wl_compositor_create_surface(registry->compositor);
if (shell_surface) {
window_make_shell(window);
}
if (registry->pointer) {
wl_pointer_add_listener(registry->pointer, &pointer_listener, window);
}
get_next_buffer(window);
if (registry->pointer) {
char *cursor_theme = getenv("SWAY_CURSOR_THEME");
if (!cursor_theme) {
cursor_theme = "default";
}
char *cursor_size = getenv("SWAY_CURSOR_SIZE");
if (!cursor_size) {
cursor_size = "16";
}
sway_log(L_DEBUG, "Cursor scale: %d", scale);
window->cursor.cursor_theme = wl_cursor_theme_load(cursor_theme,
atoi(cursor_size) * scale, registry->shm);
window->cursor.cursor = wl_cursor_theme_get_cursor(window->cursor.cursor_theme, "left_ptr");
window->cursor.surface = wl_compositor_create_surface(registry->compositor);
struct wl_cursor_image *image = window->cursor.cursor->images[0];
struct wl_buffer *cursor_buf = wl_cursor_image_get_buffer(image);
wl_surface_attach(window->cursor.surface, cursor_buf, 0, 0);
wl_surface_set_buffer_scale(window->cursor.surface, scale);
wl_surface_damage(window->cursor.surface, 0, 0,
image->width, image->height);
wl_surface_commit(window->cursor.surface);
}
return window;
}
static void frame_callback(void *data, struct wl_callback *callback, uint32_t time) {
struct window *window = data;
wl_callback_destroy(callback);
window->frame_cb = NULL;
}
static const struct wl_callback_listener listener = {
frame_callback
};
int window_prerender(struct window *window) {
if (window->frame_cb) {
return 0;
}
get_next_buffer(window);
return 1;
}
int window_render(struct window *window) {
window->frame_cb = wl_surface_frame(window->surface);
wl_callback_add_listener(window->frame_cb, &listener, window);
wl_surface_attach(window->surface, window->buffer->buffer, 0, 0);
wl_surface_set_buffer_scale(window->surface, window->scale);
wl_surface_damage(window->surface, 0, 0, window->width, window->height);
wl_surface_commit(window->surface);
return 1;
}
void window_teardown(struct window *window) {
// TODO
}
Write Preview
Loading…
Cancel
Save