hyprwm/wlroots-hyprland
1
0
Fork 0
mirror of https://github.com/hyprwm/wlroots-hyprland.git synced 2024-11-05 05:05:57 +01:00
Code Issues Projects Releases Packages Wiki Activity

Merge pull request #29 from ascent12/session

Browse source 
Moved session into backend/session and changed ownership
This commit is contained in:
Drew DeVault 2017-08-05 23:11:26 -04:00 committed by GitHub
commit f95c02eebe
36 changed files with 123 additions and 72 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

47
backend/backend.c
View file

@ -4,7 +4,7 @@
#include <string.h> #include <string.h>
#include <errno.h> #include <errno.h>
#include <libinput.h> #include <libinput.h>
#include <wlr/session.h> #include <wlr/backend/session.h>
#include <wlr/backend/interface.h> #include <wlr/backend/interface.h>
#include <wlr/backend/drm.h> #include <wlr/backend/drm.h>
#include <wlr/backend/libinput.h> #include <wlr/backend/libinput.h>
@ -62,8 +62,7 @@ static struct wlr_backend *attempt_wl_backend(struct wl_display *display) {
return backend; return backend;
} }
struct wlr_backend *wlr_backend_autocreate(struct wl_display *display, struct wlr_backend *wlr_backend_autocreate(struct wl_display *display) {
struct wlr_session *session) {
struct wlr_backend *backend; struct wlr_backend *backend;
if (getenv("WAYLAND_DISPLAY") || getenv("_WAYLAND_DISPLAY")) { if (getenv("WAYLAND_DISPLAY") || getenv("_WAYLAND_DISPLAY")) {
backend = attempt_wl_backend(display); backend = attempt_wl_backend(display);
@ -71,43 +70,61 @@ struct wlr_backend *wlr_backend_autocreate(struct wl_display *display,
return backend; return backend;
} }
} }
// Attempt DRM+libinput
struct wlr_udev *udev; if (getenv("DISPLAY")) {
if (!(udev = wlr_udev_create(display))) { wlr_log(L_ERROR, "X11 backend is not implemented"); // TODO
wlr_log(L_ERROR, "Failed to start udev"); return NULL;
goto error;
} }
// Attempt DRM+libinput
struct wlr_session *session = wlr_session_start(display);
if (!session) {
wlr_log(L_ERROR, "Failed to start a DRM session");
return NULL;
}
struct wlr_udev *udev = wlr_udev_create(display);
if (!udev) {
wlr_log(L_ERROR, "Failed to start udev");
goto error_session;
}
int gpu = wlr_udev_find_gpu(udev, session); int gpu = wlr_udev_find_gpu(udev, session);
if (gpu == -1) { if (gpu == -1) {
wlr_log(L_ERROR, "Failed to open DRM device"); wlr_log(L_ERROR, "Failed to open DRM device");
goto error_udev; goto error_udev;
} }
backend = wlr_multi_backend_create();
backend = wlr_multi_backend_create(session, udev);
if (!backend) { if (!backend) {
goto error_gpu; goto error_gpu;
} }
struct wlr_backend *libinput =
wlr_libinput_backend_create(display, session, udev); struct wlr_backend *libinput = wlr_libinput_backend_create(display, session, udev);
if (!libinput) { if (!libinput) {
goto error_multi; goto error_multi;
} }
struct wlr_backend *drm =
wlr_drm_backend_create(display, session, udev, gpu); struct wlr_backend *drm = wlr_drm_backend_create(display, session, udev, gpu);
if (!drm) { if (!drm) {
goto error_libinput; goto error_libinput;
} }
wlr_multi_backend_add(backend, libinput); wlr_multi_backend_add(backend, libinput);
wlr_multi_backend_add(backend, drm); wlr_multi_backend_add(backend, drm);
return backend; return backend;
error_libinput: error_libinput:
wlr_backend_destroy(libinput); wlr_backend_destroy(libinput);
error_multi: error_multi:
wlr_backend_destroy(backend); wlr_backend_destroy(backend);
error_gpu: error_gpu:
close(gpu); wlr_session_close_file(session, gpu);
error_udev: error_udev:
wlr_udev_destroy(udev); wlr_udev_destroy(udev);
error: error_session:
wlr_session_finish(session);
return NULL; return NULL;
} }

2
backend/drm/backend.c
View file

@ -7,7 +7,7 @@
#include <wayland-server.h> #include <wayland-server.h>
#include <xf86drm.h> #include <xf86drm.h>
#include <sys/stat.h> #include <sys/stat.h>
#include <wlr/session.h> #include <wlr/backend/session.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/util/list.h> #include <wlr/util/list.h>

2
backend/libinput/backend.c
View file

@ -1,7 +1,7 @@
#include <stdlib.h> #include <stdlib.h>
#include <assert.h> #include <assert.h>
#include <libinput.h> #include <libinput.h>
#include <wlr/session.h> #include <wlr/backend/session.h>
#include <wlr/backend/interface.h> #include <wlr/backend/interface.h>
#include <wlr/util/log.h> #include <wlr/util/log.h>
#include "backend/udev.h" #include "backend/udev.h"

2
backend/libinput/events.c
View file

@ -1,7 +1,7 @@
#include <stdlib.h> #include <stdlib.h>
#include <assert.h> #include <assert.h>
#include <libinput.h> #include <libinput.h>
#include <wlr/session.h> #include <wlr/backend/session.h>
#include <wlr/interfaces/wlr_input_device.h> #include <wlr/interfaces/wlr_input_device.h>
#include <wlr/util/list.h> #include <wlr/util/list.h>
#include <wlr/util/log.h> #include <wlr/util/log.h>

2
backend/libinput/keyboard.c
View file

@ -1,7 +1,7 @@
#include <stdlib.h> #include <stdlib.h>
#include <assert.h> #include <assert.h>
#include <libinput.h> #include <libinput.h>
#include <wlr/session.h> #include <wlr/backend/session.h>
#include <wlr/types/wlr_input_device.h> #include <wlr/types/wlr_input_device.h>
#include <wlr/interfaces/wlr_keyboard.h> #include <wlr/interfaces/wlr_keyboard.h>
#include <wlr/util/log.h> #include <wlr/util/log.h>

2
backend/libinput/pointer.c
View file

@ -1,7 +1,7 @@
#include <stdlib.h> #include <stdlib.h>
#include <assert.h> #include <assert.h>
#include <libinput.h> #include <libinput.h>
#include <wlr/session.h> #include <wlr/backend/session.h>
#include <wlr/types/wlr_input_device.h> #include <wlr/types/wlr_input_device.h>
#include <wlr/interfaces/wlr_pointer.h> #include <wlr/interfaces/wlr_pointer.h>
#include <wlr/util/log.h> #include <wlr/util/log.h>

2
backend/libinput/tablet_pad.c
View file

@ -1,7 +1,7 @@
#include <stdlib.h> #include <stdlib.h>
#include <assert.h> #include <assert.h>
#include <libinput.h> #include <libinput.h>
#include <wlr/session.h> #include <wlr/backend/session.h>
#include <wlr/types/wlr_input_device.h> #include <wlr/types/wlr_input_device.h>
#include <wlr/interfaces/wlr_tablet_pad.h> #include <wlr/interfaces/wlr_tablet_pad.h>
#include <wlr/util/log.h> #include <wlr/util/log.h>

2
backend/libinput/tablet_tool.c
View file

@ -1,7 +1,7 @@
#include <stdlib.h> #include <stdlib.h>
#include <assert.h> #include <assert.h>
#include <libinput.h> #include <libinput.h>
#include <wlr/session.h> #include <wlr/backend/session.h>
#include <wlr/types/wlr_input_device.h> #include <wlr/types/wlr_input_device.h>
#include <wlr/interfaces/wlr_tablet_tool.h> #include <wlr/interfaces/wlr_tablet_tool.h>
#include <wlr/util/log.h> #include <wlr/util/log.h>

2
backend/libinput/touch.c
View file

@ -1,7 +1,7 @@
#include <stdlib.h> #include <stdlib.h>
#include <assert.h> #include <assert.h>
#include <libinput.h> #include <libinput.h>
#include <wlr/session.h> #include <wlr/backend/session.h>
#include <wlr/types/wlr_input_device.h> #include <wlr/types/wlr_input_device.h>
#include <wlr/interfaces/wlr_touch.h> #include <wlr/interfaces/wlr_touch.h>
#include <wlr/util/log.h> #include <wlr/util/log.h>

7
backend/meson.build
View file

@ -2,6 +2,9 @@ wlr_files += files(
'backend.c', 'backend.c',
'egl.c', 'egl.c',
'udev.c', 'udev.c',
'session/direct-ipc.c',
'session/direct.c',
'session/session.c',
'drm/backend.c', 'drm/backend.c',
'drm/drm.c', 'drm/drm.c',
'libinput/backend.c', 'libinput/backend.c',
@ -17,3 +20,7 @@ wlr_files += files(
'wayland/registry.c', 'wayland/registry.c',
'wayland/wl_seat.c', 'wayland/wl_seat.c',
) )
if dep_systemd.found()
wlr_files += files('session/logind.c')
endif

23
backend/multi/backend.c
View file

@ -1,6 +1,8 @@
#include <stdbool.h> #include <stdbool.h>
#include <stdlib.h> #include <stdlib.h>
#include <wlr/backend/interface.h> #include <wlr/backend/interface.h>
#include <wlr/backend/udev.h>
#include <wlr/backend/session.h>
#include <wlr/util/log.h> #include <wlr/util/log.h>
#include "backend/multi.h" #include "backend/multi.h"
@ -31,6 +33,8 @@ static void multi_backend_destroy(struct wlr_backend_state *state) {
free(sub); free(sub);
} }
list_free(state->backends); list_free(state->backends);
wlr_session_finish(state->session);
wlr_udev_destroy(state->udev);
free(state); free(state);
} }
@ -39,24 +43,33 @@ struct wlr_backend_impl backend_impl = {
.destroy = multi_backend_destroy .destroy = multi_backend_destroy
}; };
struct wlr_backend *wlr_multi_backend_create() { struct wlr_backend *wlr_multi_backend_create(struct wlr_session *session,
struct wlr_udev *udev) {
struct wlr_backend_state *state = struct wlr_backend_state *state =
calloc(1, sizeof(struct wlr_backend_state)); calloc(1, sizeof(struct wlr_backend_state));
if (!state) { if (!state) {
wlr_log(L_ERROR, "Backend allocation failed"); wlr_log(L_ERROR, "Backend allocation failed");
return NULL; return NULL;
} }
state->backends = list_create(); state->backends = list_create();
if (!state->backends) { if (!state->backends) {
free(state); free(state);
wlr_log(L_ERROR, "Backend allocation failed"); wlr_log(L_ERROR, "Backend allocation failed");
return NULL; return NULL;
} }
struct wlr_backend *backend = wlr_backend_create(&backend_impl, state); struct wlr_backend *backend = wlr_backend_create(&backend_impl, state);
state->backend = backend; state->backend = backend;
state->session = session;
state->udev = udev;
return backend; return backend;
} }
bool wlr_backend_is_multi(struct wlr_backend *b) {
return b->impl == &backend_impl;
}
static void input_add_reemit(struct wl_listener *listener, void *data) { static void input_add_reemit(struct wl_listener *listener, void *data) {
struct subbackend_state *state = wl_container_of(listener, struct subbackend_state *state = wl_container_of(listener,
state, input_add); state, input_add);
@ -104,3 +117,11 @@ void wlr_multi_backend_add(struct wlr_backend *multi,
list_add(multi->state->backends, sub); list_add(multi->state->backends, sub);
} }
struct wlr_session *wlr_multi_get_session(struct wlr_backend *base) {
if (base->impl != &backend_impl)
return NULL;
struct wlr_backend_state *multi = base->state;
return multi->session;
}

2
session/direct-ipc.c → backend/session/direct-ipc.c
View file

@ -13,7 +13,7 @@
#include <xf86drm.h> #include <xf86drm.h>
#include <linux/major.h> #include <linux/major.h>
#include <wlr/util/log.h> #include <wlr/util/log.h>
#include "session/direct-ipc.h" #include "backend/session/direct-ipc.h"
enum { DRM_MAJOR = 226 }; enum { DRM_MAJOR = 226 };

4
session/direct.c → backend/session/direct.c
View file

@ -13,9 +13,9 @@
#include <linux/input.h> #include <linux/input.h>
#include <linux/vt.h> #include <linux/vt.h>
#include <wayland-server.h> #include <wayland-server.h>
#include <wlr/session/interface.h> #include <wlr/backend/session/interface.h>
#include <wlr/util/log.h> #include <wlr/util/log.h>
#include "session/direct-ipc.h" #include "backend/session/direct-ipc.h"
enum { DRM_MAJOR = 226 }; enum { DRM_MAJOR = 226 };

2
session/logind.c → backend/session/logind.c
View file

@ -11,7 +11,7 @@
#include <sys/stat.h> #include <sys/stat.h>
#include <fcntl.h> #include <fcntl.h>
#include <wayland-server.h> #include <wayland-server.h>
#include <wlr/session/interface.h> #include <wlr/backend/session/interface.h>
#include <wlr/util/log.h> #include <wlr/util/log.h>
enum { DRM_MAJOR = 226 }; enum { DRM_MAJOR = 226 };

12
session/session.c → backend/session/session.c
View file

@ -1,7 +1,7 @@
#include <stddef.h> #include <stddef.h>
#include <stdarg.h> #include <stdarg.h>
#include <wlr/session.h> #include <wlr/backend/session.h>
#include <wlr/session/interface.h> #include <wlr/backend/session/interface.h>
#include <wlr/util/log.h> #include <wlr/util/log.h>
extern const struct session_impl session_logind; extern const struct session_impl session_logind;
@ -30,6 +30,10 @@ struct wlr_session *wlr_session_start(struct wl_display *disp) {
} }
void wlr_session_finish(struct wlr_session *session) { void wlr_session_finish(struct wlr_session *session) {
if (!session) {
return;
}
session->impl->finish(session); session->impl->finish(session);
}; };
@ -42,5 +46,9 @@ void wlr_session_close_file(struct wlr_session *session, int fd) {
} }
bool wlr_session_change_vt(struct wlr_session *session, unsigned vt) { bool wlr_session_change_vt(struct wlr_session *session, unsigned vt) {
if (!session) {
return false;
}
return session->impl->change_vt(session, vt); return session->impl->change_vt(session, vt);
} }

2
backend/udev.c
View file

@ -8,7 +8,7 @@
#include <xf86drm.h> #include <xf86drm.h>
#include <xf86drmMode.h> #include <xf86drmMode.h>
#include <wayland-server.h> #include <wayland-server.h>
#include <wlr/session.h> #include <wlr/backend/session.h>
#include <wlr/util/log.h> #include <wlr/util/log.h>
#include "backend/udev.h" #include "backend/udev.h"

2
examples/compositor/main.c
View file

@ -6,7 +6,7 @@
#include <inttypes.h> #include <inttypes.h>
#include <wayland-server.h> #include <wayland-server.h>
#include <wlr/backend.h> #include <wlr/backend.h>
#include <wlr/session.h> #include <wlr/backend/session.h>
#include <wlr/render.h> #include <wlr/render.h>
#include <wlr/render/gles2.h> #include <wlr/render/gles2.h>
#include <wlr/types/wlr_output.h> #include <wlr/types/wlr_output.h>

2
examples/pointer.c
View file

@ -14,7 +14,7 @@
#include <wlr/render/gles2.h> #include <wlr/render/gles2.h>
#include <wlr/render.h> #include <wlr/render.h>
#include <wlr/backend.h> #include <wlr/backend.h>
#include <wlr/session.h> #include <wlr/backend/session.h>
#include <wlr/types/wlr_keyboard.h> #include <wlr/types/wlr_keyboard.h>
#include <wlr/util/log.h> #include <wlr/util/log.h>
#include "shared.h" #include "shared.h"

2
examples/rotation.c
View file

@ -14,7 +14,7 @@
#include <wlr/render/gles2.h> #include <wlr/render/gles2.h>
#include <wlr/render.h> #include <wlr/render.h>
#include <wlr/backend.h> #include <wlr/backend.h>
#include <wlr/session.h> #include <wlr/backend/session.h>
#include <wlr/types/wlr_keyboard.h> #include <wlr/types/wlr_keyboard.h>
#include <math.h> #include <math.h>
#include "shared.h" #include "shared.h"

28
examples/shared.c
View file

@ -8,7 +8,8 @@
#include <xkbcommon/xkbcommon.h> #include <xkbcommon/xkbcommon.h>
#include <wayland-server-protocol.h> #include <wayland-server-protocol.h>
#include <wlr/backend.h> #include <wlr/backend.h>
#include <wlr/session.h> #include <wlr/backend/session.h>
#include <wlr/backend/multi.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>
#include <wlr/util/log.h> #include <wlr/util/log.h>
@ -44,8 +45,16 @@ static void keyboard_key_notify(struct wl_listener *listener, void *data) {
} }
if (sym == XKB_KEY_Escape) { if (sym == XKB_KEY_Escape) {
wl_display_terminate(kbstate->compositor->display); wl_display_terminate(kbstate->compositor->display);
} else if (key_state == WLR_KEY_PRESSED && sym >= XKB_KEY_F1 && sym <= XKB_KEY_F12) { } else if (key_state == WLR_KEY_PRESSED &&
wlr_session_change_vt(kbstate->compositor->session, sym - XKB_KEY_F1 + 1); sym >= XKB_KEY_XF86Switch_VT_1 &&
sym <= XKB_KEY_XF86Switch_VT_12) {
if (wlr_backend_is_multi(kbstate->compositor->backend)) {
struct wlr_session *session =
wlr_multi_get_session(kbstate->compositor->backend);
if (session) {
wlr_session_change_vt(session, sym - XKB_KEY_XF86Switch_VT_1 + 1);
}
}
} }
} }
xkb_state_update_key(kbstate->xkb_state, keycode, xkb_state_update_key(kbstate->xkb_state, keycode,
@ -440,12 +449,6 @@ static void output_remove_notify(struct wl_listener *listener, void *data) {
void compositor_init(struct compositor_state *state) { void compositor_init(struct compositor_state *state) {
state->display = wl_display_create(); state->display = wl_display_create();
state->event_loop = wl_display_get_event_loop(state->display); state->event_loop = wl_display_get_event_loop(state->display);
state->session = wlr_session_start(state->display);
if (!state->session
|| !state->display
|| !state->event_loop) {
exit(1);
}
wl_list_init(&state->keyboards); wl_list_init(&state->keyboards);
wl_list_init(&state->pointers); wl_list_init(&state->pointers);
@ -463,10 +466,8 @@ void compositor_init(struct compositor_state *state) {
wl_list_init(&state->output_remove.link); 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( struct wlr_backend *wlr = wlr_backend_autocreate(state->display);
state->display, state->session);
if (!wlr) { if (!wlr) {
wlr_session_finish(state->session);
exit(1); exit(1);
} }
wl_signal_add(&wlr->events.input_add, &state->input_add); wl_signal_add(&wlr->events.input_add, &state->input_add);
@ -481,7 +482,6 @@ void compositor_init(struct compositor_state *state) {
if (!socket) { if (!socket) {
wlr_log_errno(L_ERROR, "Unable to open wayland socket"); wlr_log_errno(L_ERROR, "Unable to open wayland socket");
wlr_backend_destroy(wlr); wlr_backend_destroy(wlr);
wlr_session_finish(state->session);
exit(1); exit(1);
} }
@ -490,7 +490,6 @@ void compositor_init(struct compositor_state *state) {
if (!wlr_backend_init(state->backend)) { if (!wlr_backend_init(state->backend)) {
wlr_log(L_ERROR, "Failed to initialize backend"); wlr_log(L_ERROR, "Failed to initialize backend");
wlr_backend_destroy(wlr); wlr_backend_destroy(wlr);
wlr_session_finish(state->session);
exit(1); exit(1);
} }
} }
@ -498,6 +497,5 @@ void compositor_init(struct compositor_state *state) {
void compositor_run(struct compositor_state *state) { void compositor_run(struct compositor_state *state) {
wl_display_run(state->display); wl_display_run(state->display);
wlr_backend_destroy(state->backend); wlr_backend_destroy(state->backend);
wlr_session_finish(state->session);
wl_display_destroy(state->display); wl_display_destroy(state->display);
} }

2
examples/shared.h
View file

@ -8,7 +8,7 @@
#include <xkbcommon/xkbcommon.h> #include <xkbcommon/xkbcommon.h>
#include <wayland-server-protocol.h> #include <wayland-server-protocol.h>
#include <wlr/backend.h> #include <wlr/backend.h>
#include <wlr/session.h> #include <wlr/backend/session.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
examples/simple.c
View file

@ -7,7 +7,7 @@
#include <wayland-server.h> #include <wayland-server.h>
#include <GLES2/gl2.h> #include <GLES2/gl2.h>
#include <wlr/backend.h> #include <wlr/backend.h>
#include <wlr/session.h> #include <wlr/backend/session.h>
#include <wlr/types/wlr_output.h> #include <wlr/types/wlr_output.h>
#include <xkbcommon/xkbcommon.h> #include <xkbcommon/xkbcommon.h>
#include "shared.h" #include "shared.h"

2
examples/tablet.c
View file

@ -13,7 +13,7 @@
#include <wlr/render/gles2.h> #include <wlr/render/gles2.h>
#include <wlr/render.h> #include <wlr/render.h>
#include <wlr/backend.h> #include <wlr/backend.h>
#include <wlr/session.h> #include <wlr/backend/session.h>
#include <wlr/types/wlr_output.h> #include <wlr/types/wlr_output.h>
#include <wlr/types/wlr_tablet_tool.h> #include <wlr/types/wlr_tablet_tool.h>
#include <wlr/types/wlr_tablet_pad.h> #include <wlr/types/wlr_tablet_pad.h>

2
examples/touch.c
View file

@ -15,7 +15,7 @@
#include <wlr/render/gles2.h> #include <wlr/render/gles2.h>
#include <wlr/render.h> #include <wlr/render.h>
#include <wlr/backend.h> #include <wlr/backend.h>
#include <wlr/session.h> #include <wlr/backend/session.h>
#include <wlr/util/list.h> #include <wlr/util/list.h>
#include "shared.h" #include "shared.h"
#include "cat.h" #include "cat.h"

2
include/backend/drm.h
View file

@ -10,7 +10,7 @@
#include <libudev.h> #include <libudev.h>
#include <gbm.h> #include <gbm.h>
#include <wlr/session.h> #include <wlr/backend/session.h>
#include <wlr/backend/drm.h> #include <wlr/backend/drm.h>
#include <wlr/util/list.h> #include <wlr/util/list.h>

4
include/backend/multi.h
View file

@ -3,10 +3,14 @@
#include <wlr/backend/interface.h> #include <wlr/backend/interface.h>
#include <wlr/backend/multi.h> #include <wlr/backend/multi.h>
#include <wlr/backend/udev.h>
#include <wlr/util/list.h> #include <wlr/util/list.h>
#include <wlr/backend/session.h>
struct wlr_backend_state { struct wlr_backend_state {
struct wlr_backend *backend; struct wlr_backend *backend;
struct wlr_session *session;
struct wlr_udev *udev;
list_t *backends; list_t *backends;
}; };

0
include/session/direct-ipc.h → include/backend/session/direct-ipc.h
View file

2
include/backend/udev.h
View file

@ -3,7 +3,7 @@
#include <sys/types.h> #include <sys/types.h>
#include <libudev.h> #include <libudev.h>
#include <wlr/session.h> #include <wlr/backend/session.h>
#include <wayland-server.h> #include <wayland-server.h>
#include <wlr/backend/udev.h> #include <wlr/backend/udev.h>

5
include/wlr/backend.h
View file

@ -2,7 +2,7 @@
#define _WLR_BACKEND_H #define _WLR_BACKEND_H
#include <wayland-server.h> #include <wayland-server.h>
#include <wlr/session.h> #include <wlr/backend/session.h>
struct wlr_backend_impl; struct wlr_backend_impl;
struct wlr_backend_state; struct wlr_backend_state;
@ -19,8 +19,7 @@ struct wlr_backend {
} events; } events;
}; };
struct wlr_backend *wlr_backend_autocreate(struct wl_display *display, struct wlr_backend *wlr_backend_autocreate(struct wl_display *display);
struct wlr_session *session);
bool wlr_backend_init(struct wlr_backend *backend); bool wlr_backend_init(struct wlr_backend *backend);
void wlr_backend_destroy(struct wlr_backend *backend); void wlr_backend_destroy(struct wlr_backend *backend);

2
include/wlr/backend/drm.h
View file

@ -2,7 +2,7 @@
#define WLR_BACKEND_DRM_H #define WLR_BACKEND_DRM_H
#include <wayland-server.h> #include <wayland-server.h>
#include <wlr/session.h> #include <wlr/backend/session.h>
#include <wlr/backend.h> #include <wlr/backend.h>
#include <wlr/backend/udev.h> #include <wlr/backend/udev.h>

2
include/wlr/backend/libinput.h
View file

@ -3,7 +3,7 @@
#include <libinput.h> #include <libinput.h>
#include <wayland-server.h> #include <wayland-server.h>
#include <wlr/session.h> #include <wlr/backend/session.h>
#include <wlr/backend.h> #include <wlr/backend.h>
#include <wlr/backend/udev.h> #include <wlr/backend/udev.h>
#include <wlr/types/wlr_input_device.h> #include <wlr/types/wlr_input_device.h>

9
include/wlr/backend/multi.h
View file

@ -2,9 +2,16 @@
#define _WLR_BACKEND_MULTI_H #define _WLR_BACKEND_MULTI_H
#include <wlr/backend.h> #include <wlr/backend.h>
#include <wlr/backend/udev.h>
#include <wlr/backend/session.h>
struct wlr_backend *wlr_multi_backend_create(); struct wlr_backend *wlr_multi_backend_create(struct wlr_session *session,
struct wlr_udev *udev);
void wlr_multi_backend_add(struct wlr_backend *multi, void wlr_multi_backend_add(struct wlr_backend *multi,
struct wlr_backend *backend); struct wlr_backend *backend);
bool wlr_backend_is_multi(struct wlr_backend *backend);
struct wlr_session *wlr_multi_get_session(struct wlr_backend *base);
#endif #endif

0
include/wlr/session.h → include/wlr/backend/session.h
View file

2
include/wlr/session/interface.h → include/wlr/backend/session/interface.h
View file

@ -1,7 +1,7 @@
#ifndef WLR_SESSION_INTERFACE_H #ifndef WLR_SESSION_INTERFACE_H
#define WLR_SESSION_INTERFACE_H #define WLR_SESSION_INTERFACE_H
#include <wlr/session.h> #include <wlr/backend/session.h>
struct session_impl { struct session_impl {
struct wlr_session *(*start)(struct wl_display *disp); struct wlr_session *(*start)(struct wl_display *disp);

1
meson.build
View file

@ -63,7 +63,6 @@ wlr_files = []
subdir('backend') subdir('backend')
subdir('render') subdir('render')
subdir('session')
subdir('types') subdir('types')
subdir('util') subdir('util')

9
session/meson.build
View file

@ -1,9 +0,0 @@
wlr_files += files(
'direct-ipc.c',
'direct.c',
'session.c',
)
if dep_systemd.found()
wlr_files += files('logind.c')
endif