blankie
/
wlroots
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge branch 'master' into heghe/wl_list

This commit is contained in:
Drew DeVault 2017-10-21 22:03:29 -04:00
parent 169b68b17c d4e311a1ad
commit 16f35ecbea
41 changed files with 263 additions and 157 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
backend/drm/backend.c
View File

@ -11,7 +11,7 @@
#include <wlr/interfaces/wlr_output.h> #include <wlr/interfaces/wlr_output.h>
#include <wlr/types/wlr_list.h> #include <wlr/types/wlr_list.h>
#include <wlr/util/log.h> #include <wlr/util/log.h>
#include <wlr/egl.h> #include <wlr/render/egl.h>
#include "backend/drm/drm.h" #include "backend/drm/drm.h"
static bool wlr_drm_backend_start(struct wlr_backend *backend) { static bool wlr_drm_backend_start(struct wlr_backend *backend) {

34
backend/drm/drm.c
View File

@ -177,9 +177,6 @@ void wlr_drm_resources_free(struct wlr_drm_backend *drm) {
if (plane->wlr_tex) { if (plane->wlr_tex) {
wlr_texture_destroy(plane->wlr_tex); wlr_texture_destroy(plane->wlr_tex);
} }
if (plane->wlr_rend) {
wlr_renderer_destroy(plane->wlr_rend);
}
} }
free(drm->crtcs); free(drm->crtcs);
@ -193,7 +190,7 @@ static void wlr_drm_connector_make_current(struct wlr_output *output) {
static void wlr_drm_connector_swap_buffers(struct wlr_output *output) { static void wlr_drm_connector_swap_buffers(struct wlr_output *output) {
struct wlr_drm_connector *conn = (struct wlr_drm_connector *)output; struct wlr_drm_connector *conn = (struct wlr_drm_connector *)output;
struct wlr_drm_backend *drm = conn->drm; struct wlr_drm_backend *drm = (struct wlr_drm_backend *)output->backend;
struct wlr_drm_crtc *crtc = conn->crtc; struct wlr_drm_crtc *crtc = conn->crtc;
struct wlr_drm_plane *plane = crtc->primary; struct wlr_drm_plane *plane = crtc->primary;
@ -216,7 +213,8 @@ static void wlr_drm_connector_swap_buffers(struct wlr_output *output) {
static void wlr_drm_connector_set_gamma(struct wlr_output *output, static void wlr_drm_connector_set_gamma(struct wlr_output *output,
uint16_t size, uint16_t *r, uint16_t *g, uint16_t *b) { uint16_t size, uint16_t *r, uint16_t *g, uint16_t *b) {
struct wlr_drm_connector *conn = (struct wlr_drm_connector *)output; struct wlr_drm_connector *conn = (struct wlr_drm_connector *)output;
drmModeCrtcSetGamma(conn->drm->fd, conn->crtc->id, size, r, g, b); struct wlr_drm_backend *drm = (struct wlr_drm_backend *)output->backend;
drmModeCrtcSetGamma(drm->fd, conn->crtc->id, size, r, g, b);
} }
static uint16_t wlr_drm_connector_get_gamma_size(struct wlr_output *output) { static uint16_t wlr_drm_connector_get_gamma_size(struct wlr_output *output) {
@ -230,7 +228,7 @@ void wlr_drm_connector_start_renderer(struct wlr_drm_connector *conn) {
return; return;
} }
struct wlr_drm_backend *drm = conn->drm; struct wlr_drm_backend *drm = (struct wlr_drm_backend *)conn->output.backend;
struct wlr_drm_crtc *crtc = conn->crtc; struct wlr_drm_crtc *crtc = conn->crtc;
struct wlr_drm_plane *plane = crtc->primary; struct wlr_drm_plane *plane = crtc->primary;
@ -253,7 +251,7 @@ static void wlr_drm_connector_enable(struct wlr_output *output, bool enable) {
return; return;
} }
struct wlr_drm_backend *drm = conn->drm; struct wlr_drm_backend *drm = (struct wlr_drm_backend *)output->backend;
drm->iface->conn_enable(drm, conn, enable); drm->iface->conn_enable(drm, conn, enable);
if (enable) { if (enable) {
@ -414,7 +412,7 @@ error_conn:
static bool wlr_drm_connector_set_mode(struct wlr_output *output, static bool wlr_drm_connector_set_mode(struct wlr_output *output,
struct wlr_output_mode *mode) { struct wlr_output_mode *mode) {
struct wlr_drm_connector *conn = (struct wlr_drm_connector *)output; struct wlr_drm_connector *conn = (struct wlr_drm_connector *)output;
struct wlr_drm_backend *drm = conn->drm; struct wlr_drm_backend *drm = (struct wlr_drm_backend *)output->backend;
wlr_log(L_INFO, "Modesetting '%s' with '%ux%u@%u mHz'", conn->output.name, wlr_log(L_INFO, "Modesetting '%s' with '%ux%u@%u mHz'", conn->output.name,
mode->width, mode->height, mode->refresh); mode->width, mode->height, mode->refresh);
@ -479,7 +477,7 @@ static bool wlr_drm_connector_set_cursor(struct wlr_output *output,
const uint8_t *buf, int32_t stride, uint32_t width, uint32_t height, const uint8_t *buf, int32_t stride, uint32_t width, uint32_t height,
int32_t hotspot_x, int32_t hotspot_y, bool update_pixels) { int32_t hotspot_x, int32_t hotspot_y, bool update_pixels) {
struct wlr_drm_connector *conn = (struct wlr_drm_connector *)output; struct wlr_drm_connector *conn = (struct wlr_drm_connector *)output;
struct wlr_drm_backend *drm = conn->drm; struct wlr_drm_backend *drm = (struct wlr_drm_backend *)output->backend;
struct wlr_drm_renderer *renderer = &drm->renderer; struct wlr_drm_renderer *renderer = &drm->renderer;
struct wlr_drm_crtc *crtc = conn->crtc; struct wlr_drm_crtc *crtc = conn->crtc;
@ -532,12 +530,7 @@ static bool wlr_drm_connector_set_cursor(struct wlr_output *output,
// TODO the image needs to be rotated depending on the output rotation // TODO the image needs to be rotated depending on the output rotation
plane->wlr_rend = wlr_gles2_renderer_create(&drm->backend); plane->wlr_tex = wlr_render_texture_create(plane->surf.renderer->wlr_rend);
if (!plane->wlr_rend) {
return false;
}
plane->wlr_tex = wlr_render_texture_create(plane->wlr_rend);
if (!plane->wlr_tex) { if (!plane->wlr_tex) {
return false; return false;
} }
@ -602,7 +595,7 @@ static bool wlr_drm_connector_set_cursor(struct wlr_output *output,
float matrix[16]; float matrix[16];
wlr_texture_get_matrix(plane->wlr_tex, &matrix, &plane->matrix, 0, 0); wlr_texture_get_matrix(plane->wlr_tex, &matrix, &plane->matrix, 0, 0);
wlr_render_with_matrix(plane->wlr_rend, plane->wlr_tex, &matrix); wlr_render_with_matrix(plane->surf.renderer->wlr_rend, plane->wlr_tex, &matrix);
glFinish(); glFinish();
glPixelStorei(GL_UNPACK_ROW_LENGTH_EXT, bo_stride); glPixelStorei(GL_UNPACK_ROW_LENGTH_EXT, bo_stride);
@ -619,7 +612,7 @@ static bool wlr_drm_connector_set_cursor(struct wlr_output *output,
static bool wlr_drm_connector_move_cursor(struct wlr_output *output, static bool wlr_drm_connector_move_cursor(struct wlr_output *output,
int x, int y) { int x, int y) {
struct wlr_drm_connector *conn = (struct wlr_drm_connector *)output; struct wlr_drm_connector *conn = (struct wlr_drm_connector *)output;
struct wlr_drm_backend *drm = conn->drm; struct wlr_drm_backend *drm = (struct wlr_drm_backend *)output->backend;
int width, height, tmp; int width, height, tmp;
wlr_output_effective_resolution(output, &width, &height); wlr_output_effective_resolution(output, &width, &height);
@ -720,14 +713,13 @@ void wlr_drm_scan_connectors(struct wlr_drm_backend *drm) {
drmModeFreeConnector(drm_conn); drmModeFreeConnector(drm_conn);
continue; continue;
} }
wlr_output_init(&wlr_conn->output, &output_impl); wlr_output_init(&wlr_conn->output, &drm->backend, &output_impl);
struct wl_event_loop *ev = wl_display_get_event_loop(drm->display); struct wl_event_loop *ev = wl_display_get_event_loop(drm->display);
wlr_conn->retry_pageflip = wl_event_loop_add_timer(ev, retry_pageflip, wlr_conn->retry_pageflip = wl_event_loop_add_timer(ev, retry_pageflip,
wlr_conn); wlr_conn);
wlr_conn->drm = drm;
wlr_conn->state = WLR_DRM_CONN_DISCONNECTED; wlr_conn->state = WLR_DRM_CONN_DISCONNECTED;
wlr_conn->id = drm_conn->connector_id; wlr_conn->id = drm_conn->connector_id;
@ -822,7 +814,7 @@ void wlr_drm_scan_connectors(struct wlr_drm_backend *drm) {
static void page_flip_handler(int fd, unsigned seq, static void page_flip_handler(int fd, unsigned seq,
unsigned tv_sec, unsigned tv_usec, void *user) { unsigned tv_sec, unsigned tv_usec, void *user) {
struct wlr_drm_connector *conn = user; struct wlr_drm_connector *conn = user;
struct wlr_drm_backend *drm = conn->drm; struct wlr_drm_backend *drm = (struct wlr_drm_backend *)conn->output.backend;
conn->pageflip_pending = false; conn->pageflip_pending = false;
if (conn->state != WLR_DRM_CONN_CONNECTED) { if (conn->state != WLR_DRM_CONN_CONNECTED) {
@ -894,7 +886,7 @@ void wlr_drm_connector_cleanup(struct wlr_drm_connector *conn) {
return; return;
} }
struct wlr_drm_backend *drm = conn->drm; struct wlr_drm_backend *drm = (struct wlr_drm_backend *)conn->output.backend;
switch (conn->state) { switch (conn->state) {
case WLR_DRM_CONN_CONNECTED: case WLR_DRM_CONN_CONNECTED:

2
backend/drm/renderer.c
View File

@ -8,8 +8,8 @@
#include <EGL/eglext.h> #include <EGL/eglext.h>
#include <wayland-util.h> #include <wayland-util.h>
#include <wlr/egl.h>
#include <wlr/util/log.h> #include <wlr/util/log.h>
#include <wlr/render/egl.h>
#include <wlr/render/matrix.h> #include <wlr/render/matrix.h>
#include <wlr/render/gles2.h> #include <wlr/render/gles2.h>
#include <wlr/render.h> #include <wlr/render.h>

5
backend/multi/backend.c
View File

@ -120,11 +120,6 @@ void wlr_multi_backend_add(struct wlr_backend *_multi,
sub->output_add.notify = output_add_reemit; sub->output_add.notify = output_add_reemit;
sub->output_remove.notify = output_remove_reemit; sub->output_remove.notify = output_remove_reemit;
wl_list_init(&sub->input_add.link);
wl_list_init(&sub->input_remove.link);
wl_list_init(&sub->output_add.link);
wl_list_init(&sub->output_remove.link);
wl_signal_add(&backend->events.input_add, &sub->input_add); wl_signal_add(&backend->events.input_add, &sub->input_add);
wl_signal_add(&backend->events.input_remove, &sub->input_remove); wl_signal_add(&backend->events.input_remove, &sub->input_remove);
wl_signal_add(&backend->events.output_add, &sub->output_add); wl_signal_add(&backend->events.output_add, &sub->output_add);

2
backend/wayland/backend.c
View File

@ -4,7 +4,7 @@
#include <EGL/egl.h> #include <EGL/egl.h>
#include <EGL/eglext.h> #include <EGL/eglext.h>
#include <wayland-server.h> #include <wayland-server.h>
#include <wlr/egl.h> #include <wlr/render/egl.h>
#include <wlr/backend/interface.h> #include <wlr/backend/interface.h>
#include <wlr/interfaces/wlr_output.h> #include <wlr/interfaces/wlr_output.h>
#include <wlr/interfaces/wlr_input_device.h> #include <wlr/interfaces/wlr_input_device.h>

2
backend/wayland/output.c
View File

@ -241,7 +241,7 @@ struct wlr_output *wlr_wl_output_create(struct wlr_backend *_backend) {
wlr_log(L_ERROR, "Failed to allocate wlr_wl_backend_output"); wlr_log(L_ERROR, "Failed to allocate wlr_wl_backend_output");
return NULL; return NULL;
} }
wlr_output_init(&output->wlr_output, &output_impl); wlr_output_init(&output->wlr_output, &backend->backend, &output_impl);
struct wlr_output *wlr_output = &output->wlr_output; struct wlr_output *wlr_output = &output->wlr_output;
wlr_output->width = 640; wlr_output->width = 640;

4
backend/x11/backend.c
View File

@ -15,7 +15,7 @@
#endif #endif
#include <wlr/backend/interface.h> #include <wlr/backend/interface.h>
#include <wlr/backend/x11.h> #include <wlr/backend/x11.h>
#include <wlr/egl.h> #include <wlr/render/egl.h>
#include <wlr/interfaces/wlr_output.h> #include <wlr/interfaces/wlr_output.h>
#include <wlr/interfaces/wlr_input_device.h> #include <wlr/interfaces/wlr_input_device.h>
#include <wlr/interfaces/wlr_keyboard.h> #include <wlr/interfaces/wlr_keyboard.h>
@ -264,7 +264,7 @@ static bool wlr_x11_backend_start(struct wlr_backend *backend) {
output->x11 = x11; output->x11 = x11;
wlr_output_init(&output->wlr_output, &output_impl); wlr_output_init(&output->wlr_output, &x11->backend, &output_impl);
snprintf(output->wlr_output.name, sizeof(output->wlr_output.name), "X11-1"); snprintf(output->wlr_output.name, sizeof(output->wlr_output.name), "X11-1");
output->win = xcb_generate_id(x11->xcb_conn); output->win = xcb_generate_id(x11->xcb_conn);

4
examples/pointer.c
View File

@ -285,7 +285,7 @@ int main(int argc, char *argv[]) {
state.cursor_motion.notify = handle_cursor_motion; state.cursor_motion.notify = handle_cursor_motion;
wl_signal_add(&state.cursor->events.motion_absolute, wl_signal_add(&state.cursor->events.motion_absolute,
&state.cursor_motion_absolute); &state.cursor_motion_absolute);
state.cursor_motion_absolute.notify = handle_cursor_motion_absolute; state.cursor_motion_absolute.notify = handle_cursor_motion_absolute;
wl_signal_add(&state.cursor->events.button, &state.cursor_button); wl_signal_add(&state.cursor->events.button, &state.cursor_button);
@ -309,7 +309,7 @@ int main(int argc, char *argv[]) {
// tool events // tool events
wl_signal_add(&state.cursor->events.tablet_tool_axis, wl_signal_add(&state.cursor->events.tablet_tool_axis,
&state.tablet_tool_axis); &state.tablet_tool_axis);
state.tablet_tool_axis.notify = handle_tablet_tool_axis; state.tablet_tool_axis.notify = handle_tablet_tool_axis;
struct compositor_state compositor = { 0 }; struct compositor_state compositor = { 0 };

19
examples/shared.c
View File

@ -60,7 +60,6 @@ static void keyboard_add(struct wlr_input_device *device, struct compositor_stat
struct keyboard_state *kbstate = calloc(sizeof(struct keyboard_state), 1); struct keyboard_state *kbstate = calloc(sizeof(struct keyboard_state), 1);
kbstate->device = device; kbstate->device = device;
kbstate->compositor = state; kbstate->compositor = state;
wl_list_init(&kbstate->key.link);
kbstate->key.notify = keyboard_key_notify; kbstate->key.notify = keyboard_key_notify;
wl_signal_add(&device->keyboard->events.key, &kbstate->key); wl_signal_add(&device->keyboard->events.key, &kbstate->key);
wl_list_insert(&state->keyboards, &kbstate->link); wl_list_insert(&state->keyboards, &kbstate->link);
@ -122,10 +121,6 @@ static void pointer_add(struct wlr_input_device *device, struct compositor_state
struct pointer_state *pstate = calloc(sizeof(struct pointer_state), 1); struct pointer_state *pstate = calloc(sizeof(struct pointer_state), 1);
pstate->device = device; pstate->device = device;
pstate->compositor = state; pstate->compositor = state;
wl_list_init(&pstate->motion.link);
wl_list_init(&pstate->motion_absolute.link);
wl_list_init(&pstate->button.link);
wl_list_init(&pstate->axis.link);
pstate->motion.notify = pointer_motion_notify; pstate->motion.notify = pointer_motion_notify;
pstate->motion_absolute.notify = pointer_motion_absolute_notify; pstate->motion_absolute.notify = pointer_motion_absolute_notify;
pstate->button.notify = pointer_button_notify; pstate->button.notify = pointer_button_notify;
@ -175,10 +170,6 @@ static void touch_add(struct wlr_input_device *device, struct compositor_state *
struct touch_state *tstate = calloc(sizeof(struct touch_state), 1); struct touch_state *tstate = calloc(sizeof(struct touch_state), 1);
tstate->device = device; tstate->device = device;
tstate->compositor = state; tstate->compositor = state;
wl_list_init(&tstate->down.link);
wl_list_init(&tstate->motion.link);
wl_list_init(&tstate->up.link);
wl_list_init(&tstate->cancel.link);
tstate->down.notify = touch_down_notify; tstate->down.notify = touch_down_notify;
tstate->motion.notify = touch_motion_notify; tstate->motion.notify = touch_motion_notify;
tstate->up.notify = touch_up_notify; tstate->up.notify = touch_up_notify;
@ -219,10 +210,6 @@ static void tablet_tool_add(struct wlr_input_device *device,
struct tablet_tool_state *tstate = calloc(sizeof(struct tablet_tool_state), 1); struct tablet_tool_state *tstate = calloc(sizeof(struct tablet_tool_state), 1);
tstate->device = device; tstate->device = device;
tstate->compositor = state; tstate->compositor = state;
wl_list_init(&tstate->axis.link);
wl_list_init(&tstate->proximity.link);
wl_list_init(&tstate->tip.link);
wl_list_init(&tstate->button.link);
tstate->axis.notify = tablet_tool_axis_notify; tstate->axis.notify = tablet_tool_axis_notify;
tstate->proximity.notify = tablet_tool_proximity_notify; tstate->proximity.notify = tablet_tool_proximity_notify;
//tstate->tip.notify = tablet_tool_tip_notify; //tstate->tip.notify = tablet_tool_tip_notify;
@ -247,7 +234,6 @@ static void tablet_pad_add(struct wlr_input_device *device,
struct tablet_pad_state *pstate = calloc(sizeof(struct tablet_pad_state), 1); struct tablet_pad_state *pstate = calloc(sizeof(struct tablet_pad_state), 1);
pstate->device = device; pstate->device = device;
pstate->compositor = state; pstate->compositor = state;
wl_list_init(&pstate->button.link);
pstate->button.notify = tablet_pad_button_notify; pstate->button.notify = tablet_pad_button_notify;
wl_signal_add(&device->tablet_pad->events.button, &pstate->button); wl_signal_add(&device->tablet_pad->events.button, &pstate->button);
wl_list_insert(&state->tablet_pads, &pstate->link); wl_list_insert(&state->tablet_pads, &pstate->link);
@ -438,7 +424,6 @@ static void output_add_notify(struct wl_listener *listener, void *data) {
ostate->compositor = state; ostate->compositor = state;
ostate->frame.notify = output_frame_notify; ostate->frame.notify = output_frame_notify;
ostate->resolution.notify = output_resolution_notify; ostate->resolution.notify = output_resolution_notify;
wl_list_init(&ostate->frame.link);
wl_signal_add(&output->events.frame, &ostate->frame); wl_signal_add(&output->events.frame, &ostate->frame);
wl_signal_add(&output->events.resolution, &ostate->resolution); wl_signal_add(&output->events.resolution, &ostate->resolution);
wl_list_insert(&state->outputs, &ostate->link); wl_list_insert(&state->outputs, &ostate->link);
@ -478,15 +463,11 @@ void compositor_init(struct compositor_state *state) {
wl_list_init(&state->touch); wl_list_init(&state->touch);
wl_list_init(&state->tablet_tools); wl_list_init(&state->tablet_tools);
wl_list_init(&state->tablet_pads); wl_list_init(&state->tablet_pads);
wl_list_init(&state->input_add.link);
state->input_add.notify = input_add_notify; state->input_add.notify = input_add_notify;
wl_list_init(&state->input_remove.link);
state->input_remove.notify = input_remove_notify; state->input_remove.notify = input_remove_notify;
wl_list_init(&state->outputs); wl_list_init(&state->outputs);
wl_list_init(&state->output_add.link);
state->output_add.notify = output_add_notify; state->output_add.notify = output_add_notify;
wl_list_init(&state->output_remove.link);
state->output_remove.notify = output_remove_notify; state->output_remove.notify = output_remove_notify;
struct wlr_backend *wlr = wlr_backend_autocreate(state->display); struct wlr_backend *wlr = wlr_backend_autocreate(state->display);

5
include/backend/drm/drm.h
View File

@ -13,7 +13,8 @@
#include <wlr/backend/session.h> #include <wlr/backend/session.h>
#include <wlr/backend/drm.h> #include <wlr/backend/drm.h>
#include <wlr/types/wlr_output.h> #include <wlr/types/wlr_output.h>
#include <wlr/egl.h> #include <wlr/render/egl.h>
#include <wlr/types/wlr_list.h>
#include "iface.h" #include "iface.h"
#include "properties.h" #include "properties.h"
@ -30,7 +31,6 @@ struct wlr_drm_plane {
// Only used by cursor // Only used by cursor
float matrix[16]; float matrix[16];
struct wlr_renderer *wlr_rend;
struct wlr_texture *wlr_tex; struct wlr_texture *wlr_tex;
struct gbm_bo *cursor_bo; struct gbm_bo *cursor_bo;
@ -113,7 +113,6 @@ struct wlr_drm_mode {
struct wlr_drm_connector { struct wlr_drm_connector {
struct wlr_output output; struct wlr_output output;
struct wlr_drm_backend *drm;
enum wlr_drm_connector_state state; enum wlr_drm_connector_state state;
uint32_t id; uint32_t id;

2
include/backend/wayland.h
View File

@ -5,7 +5,7 @@
#include <wayland-client.h> #include <wayland-client.h>
#include <wayland-server.h> #include <wayland-server.h>
#include <wayland-egl.h> #include <wayland-egl.h>
#include <wlr/egl.h> #include <wlr/render/egl.h>
#include <wlr/backend/wayland.h> #include <wlr/backend/wayland.h>
#include <wlr/types/wlr_output.h> #include <wlr/types/wlr_output.h>
#include <wlr/types/wlr_input_device.h> #include <wlr/types/wlr_input_device.h>

2
include/backend/x11.h
View File

@ -5,7 +5,7 @@
#include <xcb/xcb.h> #include <xcb/xcb.h>
#include <X11/Xlib-xcb.h> #include <X11/Xlib-xcb.h>
#include <wayland-server.h> #include <wayland-server.h>
#include <wlr/egl.h> #include <wlr/render/egl.h>
#include <wlr/types/wlr_output.h> #include <wlr/types/wlr_output.h>
#include <wlr/types/wlr_input_device.h> #include <wlr/types/wlr_input_device.h>

2
include/render/gles2.h
View File

@ -8,9 +8,9 @@
#include <GLES2/gl2ext.h> #include <GLES2/gl2ext.h>
#include <EGL/egl.h> #include <EGL/egl.h>
#include <EGL/eglext.h> #include <EGL/eglext.h>
#include <wlr/egl.h>
#include <wlr/backend.h> #include <wlr/backend.h>
#include <wlr/render.h> #include <wlr/render.h>
#include <wlr/render/egl.h>
#include <wlr/render/interface.h> #include <wlr/render/interface.h>
#include <wlr/util/log.h> #include <wlr/util/log.h>

1
include/rootston/config.h
View File

@ -42,6 +42,7 @@ struct roots_config {
struct wl_list devices; struct wl_list devices;
struct wl_list bindings; struct wl_list bindings;
char *config_path; char *config_path;
char *startup_cmd;
}; };
struct roots_config *parse_args(int argc, char *argv[]); struct roots_config *parse_args(int argc, char *argv[]);

22
include/rootston/input.h
View File

@ -24,18 +24,12 @@ struct roots_keyboard {
struct roots_pointer { struct roots_pointer {
struct roots_input *input; struct roots_input *input;
struct wlr_input_device *device; struct wlr_input_device *device;
// We don't listen to any pointer events directly - they go through
// wlr_cursor
struct wl_list link; struct wl_list link;
}; };
struct roots_touch { struct roots_touch {
struct roots_input *input; struct roots_input *input;
struct wlr_input_device *device; struct wlr_input_device *device;
struct wl_listener down;
struct wl_listener up;
struct wl_listener motion;
struct wl_listener cancel;
struct wl_list link; struct wl_list link;
}; };
@ -70,6 +64,13 @@ struct roots_input_event {
struct wlr_input_device *device; struct wlr_input_device *device;
}; };
struct roots_touch_point {
struct roots_touch *device;
int32_t slot;
double x, y;
struct wl_list link;
};
struct roots_input { struct roots_input {
struct roots_config *config; struct roots_config *config;
struct roots_server *server; struct roots_server *server;
@ -104,9 +105,16 @@ struct roots_input {
struct wl_listener cursor_motion_absolute; struct wl_listener cursor_motion_absolute;
struct wl_listener cursor_button; struct wl_listener cursor_button;
struct wl_listener cursor_axis; struct wl_listener cursor_axis;
struct wl_listener cursor_touch_down;
struct wl_listener cursor_touch_up;
struct wl_listener cursor_touch_motion;
struct wl_listener cursor_tool_axis; struct wl_listener cursor_tool_axis;
struct wl_listener cursor_tool_tip; struct wl_listener cursor_tool_tip;
struct wl_list touch_points;
struct wl_listener pointer_grab_end; struct wl_listener pointer_grab_end;
struct wl_listener request_set_cursor; struct wl_listener request_set_cursor;
@ -120,6 +128,8 @@ void pointer_add(struct wlr_input_device *device, struct roots_input *input);
void pointer_remove(struct wlr_input_device *device, struct roots_input *input); void pointer_remove(struct wlr_input_device *device, struct roots_input *input);
void keyboard_add(struct wlr_input_device *device, struct roots_input *input); void keyboard_add(struct wlr_input_device *device, struct roots_input *input);
void keyboard_remove(struct wlr_input_device *device, struct roots_input *input); void keyboard_remove(struct wlr_input_device *device, struct roots_input *input);
void touch_add(struct wlr_input_device *device, struct roots_input *input);
void touch_remove(struct wlr_input_device *device, struct roots_input *input);
void tablet_tool_add(struct wlr_input_device *device, struct roots_input *input); void tablet_tool_add(struct wlr_input_device *device, struct roots_input *input);
void tablet_tool_remove(struct wlr_input_device *device, struct roots_input *input); void tablet_tool_remove(struct wlr_input_device *device, struct roots_input *input);

7
include/rootston/view.h
View File

@ -8,13 +8,12 @@
struct roots_wl_shell_surface { struct roots_wl_shell_surface {
struct roots_view *view; struct roots_view *view;
// TODO: Maybe destroy listener should go in roots_view // TODO: Maybe destroy listener should go in roots_view
struct wl_listener destroy; struct wl_listener destroy;
struct wl_listener ping_timeout; struct wl_listener ping_timeout;
struct wl_listener request_move; struct wl_listener request_move;
struct wl_listener request_resize; struct wl_listener request_resize;
struct wl_listener request_set_fullscreen;
struct wl_listener request_set_maximized;
struct wl_listener surface_commit; struct wl_listener surface_commit;
}; };
@ -25,15 +24,13 @@ struct roots_xdg_surface_v6 {
// TODO: Maybe destroy listener should go in roots_view // TODO: Maybe destroy listener should go in roots_view
struct wl_listener commit; struct wl_listener commit;
struct wl_listener destroy; struct wl_listener destroy;
struct wl_listener ping_timeout;
struct wl_listener request_minimize;
struct wl_listener request_move; struct wl_listener request_move;
struct wl_listener request_resize; struct wl_listener request_resize;
struct wl_listener request_show_window_menu;
}; };
struct roots_xwayland_surface { struct roots_xwayland_surface {
struct roots_view *view; struct roots_view *view;
// TODO: Maybe destroy listener should go in roots_view // TODO: Maybe destroy listener should go in roots_view
struct wl_listener destroy; struct wl_listener destroy;
struct wl_listener request_configure; struct wl_listener request_configure;

2
include/wlr/backend.h
View File

@ -3,7 +3,7 @@
#include <wayland-server.h> #include <wayland-server.h>
#include <wlr/backend/session.h> #include <wlr/backend/session.h>
#include <wlr/egl.h> #include <wlr/render/egl.h>
struct wlr_backend_impl; struct wlr_backend_impl;

2
include/wlr/backend/interface.h
View File

@ -3,7 +3,7 @@
#include <stdbool.h> #include <stdbool.h>
#include <wlr/backend.h> #include <wlr/backend.h>
#include <wlr/egl.h> #include <wlr/render/egl.h>
struct wlr_backend_impl { struct wlr_backend_impl {
bool (*start)(struct wlr_backend *backend); bool (*start)(struct wlr_backend *backend);

6
include/wlr/interfaces/wlr_output.h
View File

@ -1,8 +1,9 @@
#ifndef WLR_INTERFACES_WLR_OUTPUT_H #ifndef WLR_INTERFACES_WLR_OUTPUT_H
#define WLR_INTERFACES_WLR_OUTPUT_H #define WLR_INTERFACES_WLR_OUTPUT_H
#include <wlr/types/wlr_output.h>
#include <stdbool.h> #include <stdbool.h>
#include <wlr/types/wlr_output.h>
#include <wlr/backend.h>
struct wlr_output_impl { struct wlr_output_impl {
void (*enable)(struct wlr_output *output, bool enable); void (*enable)(struct wlr_output *output, bool enable);
@ -21,7 +22,8 @@ struct wlr_output_impl {
uint16_t (*get_gamma_size)(struct wlr_output *output); uint16_t (*get_gamma_size)(struct wlr_output *output);
}; };
void wlr_output_init(struct wlr_output *output, const struct wlr_output_impl *impl); void wlr_output_init(struct wlr_output *output, struct wlr_backend *backend,
const struct wlr_output_impl *impl);
void wlr_output_free(struct wlr_output *output); void wlr_output_free(struct wlr_output *output);
void wlr_output_update_matrix(struct wlr_output *output); void wlr_output_update_matrix(struct wlr_output *output);
struct wl_global *wlr_output_create_global( struct wl_global *wlr_output_create_global(

0
include/wlr/egl.h → include/wlr/render/egl.h
View File

5
include/wlr/types/wlr_output.h
View File

@ -16,6 +16,7 @@ struct wlr_output_impl;
struct wlr_output { struct wlr_output {
const struct wlr_output_impl *impl; const struct wlr_output_impl *impl;
struct wlr_backend *backend;
struct wl_global *wl_global; struct wl_global *wl_global;
struct wl_list wl_resources; struct wl_list wl_resources;
@ -57,6 +58,9 @@ struct wlr_output {
struct wl_listener surface_destroy; struct wl_listener surface_destroy;
} cursor; } cursor;
// the output position in layout space reported to clients
int32_t lx, ly;
void *data; void *data;
}; };
@ -67,6 +71,7 @@ bool wlr_output_set_mode(struct wlr_output *output,
struct wlr_output_mode *mode); struct wlr_output_mode *mode);
void wlr_output_transform(struct wlr_output *output, void wlr_output_transform(struct wlr_output *output,
enum wl_output_transform transform); enum wl_output_transform transform);
void wlr_output_set_position(struct wlr_output *output, int32_t lx, int32_t ly);
bool wlr_output_set_cursor(struct wlr_output *output, bool wlr_output_set_cursor(struct wlr_output *output,
const uint8_t *buf, int32_t stride, uint32_t width, uint32_t height, const uint8_t *buf, int32_t stride, uint32_t width, uint32_t height,
int32_t hotspot_x, int32_t hotspot_y); int32_t hotspot_x, int32_t hotspot_y);

2
render/egl.c
View File

@ -3,7 +3,7 @@
#include <GLES2/gl2.h> #include <GLES2/gl2.h>
#include <stdlib.h> #include <stdlib.h>
#include <wlr/util/log.h> #include <wlr/util/log.h>
#include <wlr/egl.h> #include <wlr/render/egl.h>
#include "render/glapi.h" #include "render/glapi.h"
// Extension documentation // Extension documentation

9
render/gles2/renderer.c
View File

@ -5,9 +5,9 @@
#include <GLES2/gl2ext.h> #include <GLES2/gl2ext.h>
#include <wayland-util.h> #include <wayland-util.h>
#include <wayland-server-protocol.h> #include <wayland-server-protocol.h>
#include <wlr/egl.h>
#include <wlr/backend.h> #include <wlr/backend.h>
#include <wlr/render.h> #include <wlr/render.h>
#include <wlr/render/egl.h>
#include <wlr/render/interface.h> #include <wlr/render/interface.h>
#include <wlr/render/matrix.h> #include <wlr/render/matrix.h>
#include <wlr/util/log.h> #include <wlr/util/log.h>
@ -246,9 +246,8 @@ struct wlr_renderer *wlr_gles2_renderer_create(struct wlr_backend *backend) {
return NULL; return NULL;
} }
wlr_renderer_init(&renderer->wlr_renderer, &wlr_renderer_impl); wlr_renderer_init(&renderer->wlr_renderer, &wlr_renderer_impl);
if (backend) {
struct wlr_egl *egl = wlr_backend_get_egl(backend); renderer->egl = wlr_backend_get_egl(backend);
renderer->egl = egl;
}
return &renderer->wlr_renderer; return &renderer->wlr_renderer;
} }

2
render/gles2/texture.c
View File

@ -5,8 +5,8 @@
#include <GLES2/gl2ext.h> #include <GLES2/gl2ext.h>
#include <wayland-util.h> #include <wayland-util.h>
#include <wayland-server-protocol.h> #include <wayland-server-protocol.h>
#include <wlr/egl.h>
#include <wlr/render.h> #include <wlr/render.h>
#include <wlr/render/egl.h>
#include <wlr/render/interface.h> #include <wlr/render/interface.h>
#include <wlr/render/matrix.h> #include <wlr/render/matrix.h>
#include <wlr/util/log.h> #include <wlr/util/log.h>

12
rootston/config.c
View File

@ -16,12 +16,13 @@
static void usage(const char *name, int ret) { static void usage(const char *name, int ret) {
fprintf(stderr, fprintf(stderr,
"usage: %s [-C <FILE>]\n" "usage: %s [-C <FILE>] [-E <COMMAND>]\n"
"\n" "\n"
" -C <FILE> Path to the configuration file\n" " -C <FILE> Path to the configuration file\n"
" (default: rootston.ini).\n" " (default: rootston.ini).\n"
" See `rootston.ini.example` for config\n" " See `rootston.ini.example` for config\n"
" file documentation.\n", name); " file documentation.\n"
" -E <COMMAND> Command that will be ran at startup.\n" , name);
exit(ret); exit(ret);
} }
@ -273,11 +274,14 @@ struct roots_config *parse_args(int argc, char *argv[]) {
wl_list_init(&config->bindings); wl_list_init(&config->bindings);
int c; int c;
while ((c = getopt(argc, argv, "C:h")) != -1) { while ((c = getopt(argc, argv, "C:E:h")) != -1) {
switch (c) { switch (c) {
case 'C': case 'C':
config->config_path = strdup(optarg); config->config_path = strdup(optarg);
break; break;
case 'E':
config->startup_cmd = strdup(optarg);
break;
case 'h': case 'h':
case '?': case '?':
usage(argv[0], c != 'h'); usage(argv[0], c != 'h');
@ -302,7 +306,7 @@ struct roots_config *parse_args(int argc, char *argv[]) {
if (result == -1) { if (result == -1) {
wlr_log(L_DEBUG, "No config file found. Using sensible defaults."); wlr_log(L_DEBUG, "No config file found. Using sensible defaults.");
config->keyboard.meta_key = WLR_MODIFIER_LOGO; config->keyboard.meta_key = WLR_MODIFIER_LOGO;
add_binding_config(&config->bindings, "Logo+Shift+e", "exit"); add_binding_config(&config->bindings, "Logo+Shift+E", "exit");
add_binding_config(&config->bindings, "Ctrl+q", "close"); add_binding_config(&config->bindings, "Ctrl+q", "close");
add_binding_config(&config->bindings, "Alt+Tab", "next_window"); add_binding_config(&config->bindings, "Alt+Tab", "next_window");
} else if (result == -2) { } else if (result == -2) {

74
rootston/cursor.c
View File

@ -1,4 +1,5 @@
#define _XOPEN_SOURCE 700 #define _XOPEN_SOURCE 700
#include <stdlib.h>
#include <stdbool.h> #include <stdbool.h>
#include <stdint.h> #include <stdint.h>
#include <string.h> #include <string.h>
@ -82,8 +83,8 @@ void cursor_update_position(struct roots_input *input, uint32_t time) {
double sx, sy; double sx, sy;
switch (input->mode) { switch (input->mode) {
case ROOTS_CURSOR_PASSTHROUGH: case ROOTS_CURSOR_PASSTHROUGH:
view = view_at(desktop, input->cursor->x, input->cursor->y, &surface, view = view_at(desktop, input->cursor->x, input->cursor->y,
&sx, &sy); &surface, &sx, &sy);
bool set_compositor_cursor = !view && input->cursor_client; bool set_compositor_cursor = !view && input->cursor_client;
if (view) { if (view) {
struct wl_client *view_client = struct wl_client *view_client =
@ -286,6 +287,56 @@ static void handle_cursor_button(struct wl_listener *listener, void *data) {
(uint32_t)(event->time_usec / 1000), event->button, event->state); (uint32_t)(event->time_usec / 1000), event->button, event->state);
} }
static void handle_touch_down(struct wl_listener *listener, void *data) {
struct wlr_event_touch_down *event = data;
struct roots_input *input =
wl_container_of(listener, input, cursor_touch_down);
struct roots_touch_point *point =
calloc(1, sizeof(struct roots_touch_point));
point->device = event->device->data;
point->slot = event->slot;
point->x = event->x_mm / event->width_mm;
point->y = event->y_mm / event->height_mm;
wlr_cursor_warp_absolute(input->cursor, event->device, point->x, point->y);
cursor_update_position(input, (uint32_t)(event->time_usec / 1000));
wl_list_insert(&input->touch_points, &point->link);
do_cursor_button_press(input, input->cursor, event->device,
(uint32_t)(event->time_usec / 1000), BTN_LEFT, 1);
}
static void handle_touch_up(struct wl_listener *listener, void *data) {
struct wlr_event_touch_up *event = data;
struct roots_input *input =
wl_container_of(listener, input, cursor_touch_up);
struct roots_touch_point *point;
wl_list_for_each(point, &input->touch_points, link) {
if (point->slot == event->slot) {
wl_list_remove(&point->link);
break;
}
}
do_cursor_button_press(input, input->cursor, event->device,
(uint32_t)(event->time_usec / 1000), BTN_LEFT, 0);
}
static void handle_touch_motion(struct wl_listener *listener, void *data) {
struct wlr_event_touch_motion *event = data;
struct roots_input *input =
wl_container_of(listener, input, cursor_touch_motion);
struct roots_touch_point *point;
wl_list_for_each(point, &input->touch_points, link) {
if (point->slot == event->slot) {
point->x = event->x_mm / event->width_mm;
point->y = event->y_mm / event->height_mm;
wlr_cursor_warp_absolute(input->cursor, event->device,
point->x, point->y);
cursor_update_position(input,
(uint32_t)(event->time_usec / 1000));
break;
}
}
}
static void handle_tool_axis(struct wl_listener *listener, void *data) { static void handle_tool_axis(struct wl_listener *listener, void *data) {
struct roots_input *input = wl_container_of(listener, input, cursor_tool_axis); struct roots_input *input = wl_container_of(listener, input, cursor_tool_axis);
struct wlr_event_tablet_tool_axis *event = data; struct wlr_event_tablet_tool_axis *event = data;
@ -343,35 +394,40 @@ static void handle_request_set_cursor(struct wl_listener *listener,
void cursor_initialize(struct roots_input *input) { void cursor_initialize(struct roots_input *input) {
struct wlr_cursor *cursor = input->cursor; struct wlr_cursor *cursor = input->cursor;
wl_list_init(&input->cursor_motion.link); // TODO: Does this belong here
wl_list_init(&input->touch_points);
wl_signal_add(&cursor->events.motion, &input->cursor_motion); wl_signal_add(&cursor->events.motion, &input->cursor_motion);
input->cursor_motion.notify = handle_cursor_motion; input->cursor_motion.notify = handle_cursor_motion;
wl_list_init(&input->cursor_motion_absolute.link);
wl_signal_add(&cursor->events.motion_absolute, wl_signal_add(&cursor->events.motion_absolute,
&input->cursor_motion_absolute); &input->cursor_motion_absolute);
input->cursor_motion_absolute.notify = handle_cursor_motion_absolute; input->cursor_motion_absolute.notify = handle_cursor_motion_absolute;
wl_list_init(&input->cursor_button.link);
wl_signal_add(&cursor->events.button, &input->cursor_button); wl_signal_add(&cursor->events.button, &input->cursor_button);
input->cursor_button.notify = handle_cursor_button; input->cursor_button.notify = handle_cursor_button;
wl_list_init(&input->cursor_axis.link);
wl_signal_add(&cursor->events.axis, &input->cursor_axis); wl_signal_add(&cursor->events.axis, &input->cursor_axis);
input->cursor_axis.notify = handle_cursor_axis; input->cursor_axis.notify = handle_cursor_axis;
wl_list_init(&input->cursor_tool_axis.link); wl_signal_add(&cursor->events.touch_down, &input->cursor_touch_down);
input->cursor_touch_down.notify = handle_touch_down;
wl_signal_add(&cursor->events.touch_up, &input->cursor_touch_up);
input->cursor_touch_up.notify = handle_touch_up;
wl_signal_add(&cursor->events.touch_motion, &input->cursor_touch_motion);
input->cursor_touch_motion.notify = handle_touch_motion;
wl_signal_add(&cursor->events.tablet_tool_axis, &input->cursor_tool_axis); wl_signal_add(&cursor->events.tablet_tool_axis, &input->cursor_tool_axis);
input->cursor_tool_axis.notify = handle_tool_axis; input->cursor_tool_axis.notify = handle_tool_axis;
wl_list_init(&input->cursor_tool_tip.link);
wl_signal_add(&cursor->events.tablet_tool_tip, &input->cursor_tool_tip); wl_signal_add(&cursor->events.tablet_tool_tip, &input->cursor_tool_tip);
input->cursor_tool_tip.notify = handle_tool_tip; input->cursor_tool_tip.notify = handle_tool_tip;
wl_signal_add(&input->wl_seat->events.pointer_grab_end, &input->pointer_grab_end); wl_signal_add(&input->wl_seat->events.pointer_grab_end, &input->pointer_grab_end);
input->pointer_grab_end.notify = handle_pointer_grab_end; input->pointer_grab_end.notify = handle_pointer_grab_end;
wl_list_init(&input->request_set_cursor.link);
wl_signal_add(&input->wl_seat->events.request_set_cursor, wl_signal_add(&input->wl_seat->events.request_set_cursor,
&input->request_set_cursor); &input->request_set_cursor);
input->request_set_cursor.notify = handle_request_set_cursor; input->request_set_cursor.notify = handle_request_set_cursor;

20
rootston/desktop.c
View File

@ -202,17 +202,23 @@ struct roots_view *view_at(struct roots_desktop *desktop, double lx, double ly,
struct roots_desktop *desktop_create(struct roots_server *server, struct roots_desktop *desktop_create(struct roots_server *server,
struct roots_config *config) { struct roots_config *config) {
struct roots_desktop *desktop = calloc(1, sizeof(struct roots_desktop));
wlr_log(L_DEBUG, "Initializing roots desktop"); wlr_log(L_DEBUG, "Initializing roots desktop");
assert(desktop->views = list_create()); struct roots_desktop *desktop = calloc(1, sizeof(struct roots_desktop));
wl_list_init(&desktop->outputs); if (desktop == NULL) {
wl_list_init(&desktop->output_add.link); return NULL;
desktop->output_add.notify = output_add_notify; }
wl_list_init(&desktop->output_remove.link);
desktop->output_remove.notify = output_remove_notify;
desktop->views = list_create();
if (desktop->views == NULL) {
free(desktop);
return NULL;
}
wl_list_init(&desktop->outputs);
desktop->output_add.notify = output_add_notify;
wl_signal_add(&server->backend->events.output_add, &desktop->output_add); wl_signal_add(&server->backend->events.output_add, &desktop->output_add);
desktop->output_remove.notify = output_remove_notify;
wl_signal_add(&server->backend->events.output_remove, wl_signal_add(&server->backend->events.output_remove,
&desktop->output_remove); &desktop->output_remove);

40
rootston/input.c
View File

@ -37,7 +37,7 @@ static void input_add_notify(struct wl_listener *listener, void *data) {
pointer_add(device, input); pointer_add(device, input);
break; break;
case WLR_INPUT_DEVICE_TOUCH: case WLR_INPUT_DEVICE_TOUCH:
//touch_add(device, input); touch_add(device, input);
break; break;
case WLR_INPUT_DEVICE_TABLET_TOOL: case WLR_INPUT_DEVICE_TABLET_TOOL:
tablet_tool_add(device, input); tablet_tool_add(device, input);
@ -58,7 +58,7 @@ static void input_remove_notify(struct wl_listener *listener, void *data) {
pointer_remove(device, input); pointer_remove(device, input);
break; break;
case WLR_INPUT_DEVICE_TOUCH: case WLR_INPUT_DEVICE_TOUCH:
//touch_remove(device, input); touch_remove(device, input);
break; break;
case WLR_INPUT_DEVICE_TABLET_TOOL: case WLR_INPUT_DEVICE_TABLET_TOOL:
tablet_tool_remove(device, input); tablet_tool_remove(device, input);
@ -74,15 +74,34 @@ struct roots_input *input_create(struct roots_server *server,
assert(server->desktop); assert(server->desktop);
struct roots_input *input = calloc(1, sizeof(struct roots_input)); struct roots_input *input = calloc(1, sizeof(struct roots_input));
assert(input); if (input == NULL) {
return NULL;
}
input->config = config; input->config = config;
input->server = server; input->server = server;
assert(input->theme = wlr_xcursor_theme_load("default", 16)); input->theme = wlr_xcursor_theme_load("default", 16);
assert(input->xcursor = wlr_xcursor_theme_get_cursor(input->theme, "left_ptr")); if (input->theme == NULL) {
wlr_log(L_ERROR, "Cannot load xcursor theme");
free(input);
return NULL;
}
input->xcursor = wlr_xcursor_theme_get_cursor(input->theme, "left_ptr");
if (input->xcursor == NULL) {
wlr_log(L_ERROR, "Cannot load xcursor from theme");
wlr_xcursor_theme_destroy(input->theme);
free(input);
return NULL;
}
assert(input->wl_seat = wlr_seat_create(server->wl_display, "seat0")); input->wl_seat = wlr_seat_create(server->wl_display, "seat0");
if (input->wl_seat == NULL) {
wlr_log(L_ERROR, "Cannot create seat");
wlr_xcursor_theme_destroy(input->theme);
free(input);
return NULL;
}
wlr_seat_set_capabilities(input->wl_seat, WL_SEAT_CAPABILITY_KEYBOARD wlr_seat_set_capabilities(input->wl_seat, WL_SEAT_CAPABILITY_KEYBOARD
| WL_SEAT_CAPABILITY_POINTER | WL_SEAT_CAPABILITY_TOUCH); | WL_SEAT_CAPABILITY_POINTER | WL_SEAT_CAPABILITY_TOUCH);
@ -91,15 +110,10 @@ struct roots_input *input_create(struct roots_server *server,
wl_list_init(&input->touch); wl_list_init(&input->touch);
wl_list_init(&input->tablet_tools); wl_list_init(&input->tablet_tools);
wl_list_init(&input->input_add.link);
input->input_add.notify = input_add_notify; input->input_add.notify = input_add_notify;
wl_list_init(&input->input_remove.link); wl_signal_add(&server->backend->events.input_add, &input->input_add);
input->input_remove.notify = input_remove_notify; input->input_remove.notify = input_remove_notify;
wl_signal_add(&server->backend->events.input_remove, &input->input_remove);
wl_signal_add(&server->backend->events.input_add,
&input->input_add);
wl_signal_add(&server->backend->events.input_remove,
&input->input_remove);
input->cursor = wlr_cursor_create(); input->cursor = wlr_cursor_create();
cursor_initialize(input); cursor_initialize(input);

14
rootston/keyboard.c
View File

@ -127,10 +127,12 @@ static void keyboard_key_notify(struct wl_listener *listener, void *data) {
void keyboard_add(struct wlr_input_device *device, struct roots_input *input) { void keyboard_add(struct wlr_input_device *device, struct roots_input *input) {
struct roots_keyboard *keyboard = calloc(sizeof(struct roots_keyboard), 1); struct roots_keyboard *keyboard = calloc(sizeof(struct roots_keyboard), 1);
if (keyboard == NULL) {
return;
}
device->data = keyboard; device->data = keyboard;
keyboard->device = device; keyboard->device = device;
keyboard->input = input; keyboard->input = input;
wl_list_init(&keyboard->key.link);
keyboard->key.notify = keyboard_key_notify; keyboard->key.notify = keyboard_key_notify;
wl_signal_add(&device->keyboard->events.key, &keyboard->key); wl_signal_add(&device->keyboard->events.key, &keyboard->key);
wl_list_insert(&input->keyboards, &keyboard->link); wl_list_insert(&input->keyboards, &keyboard->link);
@ -142,11 +144,15 @@ void keyboard_add(struct wlr_input_device *device, struct roots_input *input) {
rules.layout = getenv("XKB_DEFAULT_LAYOUT"); rules.layout = getenv("XKB_DEFAULT_LAYOUT");
rules.variant = getenv("XKB_DEFAULT_VARIANT"); rules.variant = getenv("XKB_DEFAULT_VARIANT");
rules.options = getenv("XKB_DEFAULT_OPTIONS"); rules.options = getenv("XKB_DEFAULT_OPTIONS");
struct xkb_context *context; struct xkb_context *context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
assert(context = xkb_context_new(XKB_CONTEXT_NO_FLAGS)); if (context == NULL) {
wlr_log(L_ERROR, "Cannot create XKB context");
return;
}
wlr_keyboard_set_keymap(device->keyboard, xkb_map_new_from_names(context, wlr_keyboard_set_keymap(device->keyboard, xkb_map_new_from_names(context,
&rules, XKB_KEYMAP_COMPILE_NO_FLAGS)); &rules, XKB_KEYMAP_COMPILE_NO_FLAGS));
xkb_context_unref(context); xkb_context_unref(context);
wlr_seat_attach_keyboard(input->wl_seat, device); wlr_seat_attach_keyboard(input->wl_seat, device);
} }

13
rootston/main.c
View File

@ -1,6 +1,7 @@
#define _POSIX_C_SOURCE 200112L #define _POSIX_C_SOURCE 200112L
#include <assert.h> #include <assert.h>
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h>
#include <wayland-server.h> #include <wayland-server.h>
#include <wlr/backend.h> #include <wlr/backend.h>
#include <wlr/render.h> #include <wlr/render.h>
@ -42,6 +43,18 @@ int main(int argc, char **argv) {
} }
setenv("WAYLAND_DISPLAY", socket, true); setenv("WAYLAND_DISPLAY", socket, true);
if (server.config->startup_cmd != NULL) {
const char *cmd = server.config->startup_cmd;
pid_t pid = fork();
if (pid < 0) {
wlr_log(L_ERROR, "cannot execute binding command: fork() failed");
return 1;
} else if (pid == 0) {
execl("/bin/sh", "/bin/sh", "-c", cmd, (void *)NULL);
}
}
wl_display_run(server.wl_display); wl_display_run(server.wl_display);
wlr_backend_destroy(server.backend); wlr_backend_destroy(server.backend);
return 0; return 0;

1
rootston/meson.build
View File

@ -9,6 +9,7 @@ sources = [
'output.c', 'output.c',
'pointer.c', 'pointer.c',
'tablet_tool.c', 'tablet_tool.c',
'touch.c',
'xdg_shell_v6.c', 'xdg_shell_v6.c',
'wl_shell.c', 'wl_shell.c',
] ]

1
rootston/output.c
View File

@ -177,7 +177,6 @@ void output_add_notify(struct wl_listener *listener, void *data) {
output->desktop = desktop; output->desktop = desktop;
output->wlr_output = wlr_output; output->wlr_output = wlr_output;
output->frame.notify = output_frame_notify; output->frame.notify = output_frame_notify;
wl_list_init(&output->frame.link);
wl_signal_add(&wlr_output->events.frame, &output->frame); wl_signal_add(&wlr_output->events.frame, &output->frame);
wl_list_insert(&desktop->outputs, &output->link); wl_list_insert(&desktop->outputs, &output->link);

12
rootston/rootston.ini.example
View File

@ -34,8 +34,12 @@ meta-key = Logo
# Keybindings # Keybindings
# Maps key combinations with commands to execute # Maps key combinations with commands to execute
# Use the prefix "exec" to execute a shell command # Commands include:
# - "exit" to stop the compositor
# - "exec" to execute a shell command
# - "close" to close the current view
# - "next_window" to cycle through windows
[bindings] [bindings]
Logo+Shift+e = exit # Stop the compositor Logo+Shift+E = exit
Logo+q = close # Close the current view Logo+q = close
Alt+Tab = next_window # Cycle through windows Alt+Tab = next_window

26
rootston/touch.c Normal file
View File

@ -0,0 +1,26 @@
#include <stdlib.h>
#include <wayland-server.h>
#include <wlr/types/wlr_input_device.h>
#include <wlr/types/wlr_pointer.h>
#include "rootston/input.h"
// TODO: we'll likely want touch events to both control the cursor *and* be
// submitted directly to the seat.
void touch_add(struct wlr_input_device *device, struct roots_input *input) {
struct roots_touch *touch = calloc(sizeof(struct roots_touch), 1);
device->data = touch;
touch->device = device;
touch->input = input;
wl_list_insert(&input->touch, &touch->link);
wlr_cursor_attach_input_device(input->cursor, device);
cursor_load_config(input->server->config, input->cursor,
input, input->server->desktop);
}
void touch_remove(struct wlr_input_device *device, struct roots_input *input) {
struct roots_touch *touch = device->data;
wlr_cursor_detach_input_device(input->cursor, device);
wl_list_remove(&touch->link);
free(touch);
}

19
rootston/wl_shell.c
View File

@ -57,11 +57,8 @@ static void handle_destroy(struct wl_listener *listener, void *data) {
struct roots_wl_shell_surface *roots_surface = struct roots_wl_shell_surface *roots_surface =
wl_container_of(listener, roots_surface, destroy); wl_container_of(listener, roots_surface, destroy);
wl_list_remove(&roots_surface->destroy.link); wl_list_remove(&roots_surface->destroy.link);
wl_list_remove(&roots_surface->ping_timeout.link);
wl_list_remove(&roots_surface->request_move.link); wl_list_remove(&roots_surface->request_move.link);
wl_list_remove(&roots_surface->request_resize.link); wl_list_remove(&roots_surface->request_resize.link);
wl_list_remove(&roots_surface->request_set_fullscreen.link);
wl_list_remove(&roots_surface->request_set_maximized.link);
view_destroy(roots_surface->view); view_destroy(roots_surface->view);
free(roots_surface); free(roots_surface);
} }
@ -88,25 +85,22 @@ void handle_wl_shell_surface(struct wl_listener *listener, void *data) {
if (!roots_surface) { if (!roots_surface) {
return; return;
} }
wl_list_init(&roots_surface->destroy.link);
roots_surface->destroy.notify = handle_destroy; roots_surface->destroy.notify = handle_destroy;
wl_signal_add(&surface->events.destroy, &roots_surface->destroy); wl_signal_add(&surface->events.destroy, &roots_surface->destroy);
wl_list_init(&roots_surface->ping_timeout.link);
wl_list_init(&roots_surface->request_move.link);
roots_surface->request_move.notify = handle_request_move; roots_surface->request_move.notify = handle_request_move;
wl_signal_add(&surface->events.request_move, &roots_surface->request_move); wl_signal_add(&surface->events.request_move, &roots_surface->request_move);
wl_list_init(&roots_surface->request_resize.link);
roots_surface->request_resize.notify = handle_request_resize; roots_surface->request_resize.notify = handle_request_resize;
wl_signal_add(&surface->events.request_resize, wl_signal_add(&surface->events.request_resize,
&roots_surface->request_resize); &roots_surface->request_resize);
wl_list_init(&roots_surface->request_set_fullscreen.link);
wl_list_init(&roots_surface->request_set_maximized.link);
wl_list_init(&roots_surface->surface_commit.link);
roots_surface->surface_commit.notify = handle_surface_commit; roots_surface->surface_commit.notify = handle_surface_commit;
wl_signal_add(&surface->surface->events.commit, wl_signal_add(&surface->surface->events.commit,
&roots_surface->surface_commit); &roots_surface->surface_commit);
struct roots_view *view = calloc(1, sizeof(struct roots_view)); struct roots_view *view = calloc(1, sizeof(struct roots_view));
if (!view) {
free(roots_surface);
return;
}
view->type = ROOTS_WL_SHELL_VIEW; view->type = ROOTS_WL_SHELL_VIEW;
view->wl_shell_surface = surface; view->wl_shell_surface = surface;
@ -121,9 +115,8 @@ void handle_wl_shell_surface(struct wl_listener *listener, void *data) {
if (surface->state == WLR_WL_SHELL_SURFACE_STATE_TRANSIENT) { if (surface->state == WLR_WL_SHELL_SURFACE_STATE_TRANSIENT) {
// we need to map it relative to the parent // we need to map it relative to the parent
int i = int i = list_seq_find(desktop->views, shell_surface_compare_equals,
list_seq_find(desktop->views, surface->parent);
shell_surface_compare_equals, surface->parent);
if (i != -1) { if (i != -1) {
struct roots_view *parent = desktop->views->items[i]; struct roots_view *parent = desktop->views->items[i];
view_set_position(view, view_set_position(view,

11
rootston/xdg_shell_v6.c
View File

@ -74,12 +74,10 @@ static void handle_commit(struct wl_listener *listener, void *data) {
static void handle_destroy(struct wl_listener *listener, void *data) { static void handle_destroy(struct wl_listener *listener, void *data) {
struct roots_xdg_surface_v6 *roots_xdg_surface = struct roots_xdg_surface_v6 *roots_xdg_surface =
wl_container_of(listener, roots_xdg_surface, destroy); wl_container_of(listener, roots_xdg_surface, destroy);
wl_list_remove(&roots_xdg_surface->commit.link);
wl_list_remove(&roots_xdg_surface->destroy.link); wl_list_remove(&roots_xdg_surface->destroy.link);
wl_list_remove(&roots_xdg_surface->ping_timeout.link);
wl_list_remove(&roots_xdg_surface->request_move.link); wl_list_remove(&roots_xdg_surface->request_move.link);
wl_list_remove(&roots_xdg_surface->request_resize.link); wl_list_remove(&roots_xdg_surface->request_resize.link);
wl_list_remove(&roots_xdg_surface->request_show_window_menu.link);
wl_list_remove(&roots_xdg_surface->request_minimize.link);
view_destroy(roots_xdg_surface->view); view_destroy(roots_xdg_surface->view);
free(roots_xdg_surface); free(roots_xdg_surface);
} }
@ -105,22 +103,15 @@ void handle_xdg_shell_v6_surface(struct wl_listener *listener, void *data) {
if (!roots_surface) { if (!roots_surface) {
return; return;
} }
wl_list_init(&roots_surface->commit.link);
roots_surface->commit.notify = handle_commit; roots_surface->commit.notify = handle_commit;
wl_signal_add(&surface->events.commit, &roots_surface->commit); wl_signal_add(&surface->events.commit, &roots_surface->commit);
wl_list_init(&roots_surface->destroy.link);
roots_surface->destroy.notify = handle_destroy; roots_surface->destroy.notify = handle_destroy;
wl_signal_add(&surface->events.destroy, &roots_surface->destroy); wl_signal_add(&surface->events.destroy, &roots_surface->destroy);
wl_list_init(&roots_surface->ping_timeout.link);
wl_list_init(&roots_surface->request_minimize.link);
wl_list_init(&roots_surface->request_move.link);
roots_surface->request_move.notify = handle_request_move; roots_surface->request_move.notify = handle_request_move;
wl_signal_add(&surface->events.request_move, &roots_surface->request_move); wl_signal_add(&surface->events.request_move, &roots_surface->request_move);
wl_list_init(&roots_surface->request_resize.link);
roots_surface->request_resize.notify = handle_request_resize; roots_surface->request_resize.notify = handle_request_resize;
wl_signal_add(&surface->events.request_resize, wl_signal_add(&surface->events.request_resize,
&roots_surface->request_resize); &roots_surface->request_resize);
wl_list_init(&roots_surface->request_show_window_menu.link);
struct roots_view *view = calloc(1, sizeof(struct roots_view)); struct roots_view *view = calloc(1, sizeof(struct roots_view));
view->type = ROOTS_XDG_SHELL_V6_VIEW; view->type = ROOTS_XDG_SHELL_V6_VIEW;

2
rootston/xwayland.c
View File

@ -75,10 +75,8 @@ void handle_xwayland_surface(struct wl_listener *listener, void *data) {
if (roots_surface == NULL) { if (roots_surface == NULL) {
return; return;
} }
wl_list_init(&roots_surface->destroy.link);
roots_surface->destroy.notify = handle_destroy; roots_surface->destroy.notify = handle_destroy;
wl_signal_add(&surface->events.destroy, &roots_surface->destroy); wl_signal_add(&surface->events.destroy, &roots_surface->destroy);
wl_list_init(&roots_surface->request_configure.link);
roots_surface->request_configure.notify = handle_request_configure; roots_surface->request_configure.notify = handle_request_configure;
wl_signal_add(&surface->events.request_configure, wl_signal_add(&surface->events.request_configure,
&roots_surface->request_configure); &roots_surface->request_configure);

22
types/wlr_output.c
View File

@ -21,7 +21,7 @@ static void wl_output_send_to_resource(struct wl_resource *resource) {
assert(output); assert(output);
const uint32_t version = wl_resource_get_version(resource); const uint32_t version = wl_resource_get_version(resource);
if (version >= WL_OUTPUT_GEOMETRY_SINCE_VERSION) { if (version >= WL_OUTPUT_GEOMETRY_SINCE_VERSION) {
wl_output_send_geometry(resource, 0, 0, // TODO: get position from layout? wl_output_send_geometry(resource, output->lx, output->ly,
output->phys_width, output->phys_height, output->subpixel, output->phys_width, output->phys_height, output->subpixel,
output->make, output->model, output->transform); output->make, output->model, output->transform);
} }
@ -122,6 +122,20 @@ void wlr_output_transform(struct wlr_output *output,
wlr_output_update_matrix(output); wlr_output_update_matrix(output);
} }
void wlr_output_set_position(struct wlr_output *output, int32_t lx, int32_t ly) {
if (lx == output->lx && ly == output->ly) {
return;
}
output->lx = lx;
output->ly = ly;
struct wl_resource *resource;
wl_resource_for_each(resource, &output->wl_resources) {
wl_output_send_to_resource(resource);
}
}
static bool set_cursor(struct wlr_output *output, const uint8_t *buf, static bool set_cursor(struct wlr_output *output, const uint8_t *buf,
int32_t stride, uint32_t width, uint32_t height, int32_t hotspot_x, int32_t stride, uint32_t width, uint32_t height, int32_t hotspot_x,
int32_t hotspot_y) { int32_t hotspot_y) {
@ -139,8 +153,7 @@ static bool set_cursor(struct wlr_output *output, const uint8_t *buf,
output->cursor.height = height; output->cursor.height = height;
if (!output->cursor.renderer) { if (!output->cursor.renderer) {
/* NULL egl is okay given that we are only using pixel buffers */ output->cursor.renderer = wlr_gles2_renderer_create(output->backend);
output->cursor.renderer = wlr_gles2_renderer_create(NULL);
if (!output->cursor.renderer) { if (!output->cursor.renderer) {
return false; return false;
} }
@ -293,8 +306,9 @@ bool wlr_output_move_cursor(struct wlr_output *output, int x, int y) {
return output->impl->move_cursor(output, x, y); return output->impl->move_cursor(output, x, y);
} }
void wlr_output_init(struct wlr_output *output, void wlr_output_init(struct wlr_output *output, struct wlr_backend *backend,
const struct wlr_output_impl *impl) { const struct wlr_output_impl *impl) {
output->backend = backend;
output->impl = impl; output->impl = impl;
wl_list_init(&output->modes); wl_list_init(&output->modes);
output->transform = WL_OUTPUT_TRANSFORM_NORMAL; output->transform = WL_OUTPUT_TRANSFORM_NORMAL;

4
types/wlr_output_layout.c
View File

@ -115,6 +115,10 @@ static void wlr_output_layout_reconfigure(struct wlr_output_layout *layout) {
max_x += box->width; max_x += box->width;
} }
wl_list_for_each(l_output, &layout->outputs, link) {
wlr_output_set_position(l_output->output, l_output->x, l_output->y);
}
wl_signal_emit(&layout->events.change, layout); wl_signal_emit(&layout->events.change, layout);
} }

4
types/wlr_seat.c
View File

@ -635,17 +635,13 @@ void wlr_seat_attach_keyboard(struct wlr_seat *seat,
calloc(1, sizeof(struct wlr_seat_keyboard)); calloc(1, sizeof(struct wlr_seat_keyboard));
seat_kb->keyboard = kb; seat_kb->keyboard = kb;
seat_kb->seat = seat; seat_kb->seat = seat;
wl_list_init(&seat_kb->key.link);
seat_kb->key.notify = keyboard_key_notify; seat_kb->key.notify = keyboard_key_notify;
wl_signal_add(&kb->events.key, &seat_kb->key); wl_signal_add(&kb->events.key, &seat_kb->key);
wl_list_init(&seat_kb->modifiers.link);
seat_kb->modifiers.notify = keyboard_modifiers_notify; seat_kb->modifiers.notify = keyboard_modifiers_notify;
wl_signal_add(&kb->events.modifiers, &seat_kb->modifiers); wl_signal_add(&kb->events.modifiers, &seat_kb->modifiers);
wl_list_init(&seat_kb->keymap.link);
seat_kb->keymap.notify = keyboard_keymap_notify; seat_kb->keymap.notify = keyboard_keymap_notify;
wl_signal_add(&kb->events.keymap, &seat_kb->keymap); wl_signal_add(&kb->events.keymap, &seat_kb->keymap);
// TODO: update keymap as necessary // TODO: update keymap as necessary
wl_list_init(&seat_kb->destroy.link);
seat_kb->destroy.notify = keyboard_destroy_notify; seat_kb->destroy.notify = keyboard_destroy_notify;
wl_signal_add(&dev->events.destroy, &seat_kb->destroy); wl_signal_add(&dev->events.destroy, &seat_kb->destroy);
wl_list_insert(&seat->keyboards, &seat_kb->link); wl_list_insert(&seat->keyboards, &seat_kb->link);

2
types/wlr_surface.c
View File

@ -2,9 +2,9 @@
#include <stdlib.h> #include <stdlib.h>
#include <wayland-server.h> #include <wayland-server.h>
#include <wlr/util/log.h> #include <wlr/util/log.h>
#include <wlr/egl.h>
#include <wlr/render/interface.h> #include <wlr/render/interface.h>
#include <wlr/types/wlr_surface.h> #include <wlr/types/wlr_surface.h>
#include <wlr/render/egl.h>
#include <wlr/render/matrix.h> #include <wlr/render/matrix.h>
static void wlr_surface_state_reset_buffer(struct wlr_surface_state *state) { static void wlr_surface_state_reset_buffer(struct wlr_surface_state *state) {