static void
sigusr_handler(int signal_number)
{
assert(signal_number == SIGUSR1);
wlc_log(WLC_LOG_INFO, "Xwayland started (DISPLAY %s)", xserver.display_name);
sigaction(signal_number, &xserver.old_sigusr1, NULL);
setenv("DISPLAY", xserver.display_name, true);
wl_signal_emit(&wlc_system_signals()->xwayland, &(bool){true});
void
wlc_view_focus_ptr(struct wlc_view *view)
{
if (view && (view->type & WLC_BIT_UNMANAGED))
return;
if (view)
wlc_x11_window_set_active(&view->x11, true);
struct wlc_focus_event ev = { .view = view, .type = WLC_FOCUS_EVENT_VIEW };
wl_signal_emit(&wlc_system_signals()->focus, &ev);
}
static int
udev_event(int fd, uint32_t mask, void *data)
{
(void)fd, (void)mask;
struct udev *udev = data;
struct udev_device *device;
if (!(device = udev_monitor_receive_device(udev->monitor)))
return 0;
wlc_log(WLC_LOG_INFO, "udev: got device %s", udev_device_get_sysname(device));
// FIXME: pass correct drm id
if (is_hotplug(0, device)) {
wlc_log(WLC_LOG_INFO, "udev: hotplug");
struct wlc_output_event ev = { .type = WLC_OUTPUT_EVENT_UPDATE };
wl_signal_emit(&wlc_system_signals()->output, &ev);
goto out;
}
static int
input_event(int fd, uint32_t mask, void *data)
{
(void)fd, (void)mask;
struct input *input = data;
if (libinput_dispatch(input->handle) != 0)
wlc_log(WLC_LOG_WARN, "Failed to dispatch libinput");
struct libinput_event *event;
while ((event = libinput_get_event(input->handle))) {
struct libinput *handle = libinput_event_get_context(event);
struct libinput_device *device = libinput_event_get_device(event);
(void)handle;
switch (libinput_event_get_type(event)) {
case LIBINPUT_EVENT_DEVICE_ADDED:
WLC_INTERFACE_EMIT(input.created, device);
break;
case LIBINPUT_EVENT_DEVICE_REMOVED:
WLC_INTERFACE_EMIT(input.destroyed, device);
break;
case LIBINPUT_EVENT_POINTER_MOTION:
{
struct libinput_event_pointer *pev = libinput_event_get_pointer_event(event);
struct wlc_input_event ev = {0};
ev.type = WLC_INPUT_EVENT_MOTION;
ev.time = libinput_event_pointer_get_time(pev);
ev.motion.dx = libinput_event_pointer_get_dx(pev);
ev.motion.dy = libinput_event_pointer_get_dy(pev);
wl_signal_emit(&wlc_system_signals()->input, &ev);
}
break;
case LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE:
{
struct libinput_event_pointer *pev = libinput_event_get_pointer_event(event);
struct wlc_input_event ev = {0};
ev.type = WLC_INPUT_EVENT_MOTION_ABSOLUTE;
ev.time = libinput_event_pointer_get_time(pev);
ev.motion_abs.x = pointer_abs_x;
ev.motion_abs.y = pointer_abs_y;
ev.motion_abs.internal = pev;
wl_signal_emit(&wlc_system_signals()->input, &ev);
}
break;
case LIBINPUT_EVENT_POINTER_BUTTON:
{
struct libinput_event_pointer *pev = libinput_event_get_pointer_event(event);
struct wlc_input_event ev = {0};
ev.type = WLC_INPUT_EVENT_BUTTON;
ev.time = libinput_event_pointer_get_time(pev);
ev.button.code = libinput_event_pointer_get_button(pev);
ev.button.state = (enum wl_pointer_button_state)libinput_event_pointer_get_button_state(pev);
wl_signal_emit(&wlc_system_signals()->input, &ev);
}
break;
case LIBINPUT_EVENT_POINTER_AXIS:
{
struct libinput_event_pointer *pev = libinput_event_get_pointer_event(event);
struct wlc_input_event ev = {0};
ev.type = WLC_INPUT_EVENT_SCROLL;
ev.time = libinput_event_pointer_get_time(pev);
#if LIBINPUT_VERSION_MAJOR == 0 && LIBINPUT_VERSION_MINOR < 8
/* < libinput 0.8.x (at least to 0.6.x) */
const enum wl_pointer_axis axis = libinput_event_pointer_get_axis(pev);
ev.scroll.amount[(axis == LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL)] = libinput_event_pointer_get_axis_value(pev);
ev.scroll.axis_bits |= (axis == LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL ? WLC_SCROLL_AXIS_HORIZONTAL : WLC_SCROLL_AXIS_VERTICAL);
#else
/* > libinput 0.8.0 */
if (libinput_event_pointer_has_axis(pev, LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL)) {
ev.scroll.amount[0] = libinput_event_pointer_get_axis_value(pev, LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL);
ev.scroll.axis_bits |= WLC_SCROLL_AXIS_VERTICAL;
}
if (libinput_event_pointer_has_axis(pev, LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL)) {
ev.scroll.amount[1] = libinput_event_pointer_get_axis_value(pev, LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL);
ev.scroll.axis_bits |= WLC_SCROLL_AXIS_HORIZONTAL;
}
#endif
// We should get other axis information from libinput as well, like source (finger, wheel) (v0.8)
wl_signal_emit(&wlc_system_signals()->input, &ev);
}
break;
case LIBINPUT_EVENT_KEYBOARD_KEY:
{
struct libinput_event_keyboard *kev = libinput_event_get_keyboard_event(event);
struct wlc_input_event ev = {0};
ev.type = WLC_INPUT_EVENT_KEY;
ev.time = libinput_event_keyboard_get_time(kev);
ev.key.code = libinput_event_keyboard_get_key(kev);
ev.key.state = (enum wl_keyboard_key_state)libinput_event_keyboard_get_key_state(kev);
ev.device = device;
wl_signal_emit(&wlc_system_signals()->input, &ev);
}
break;
case LIBINPUT_EVENT_TOUCH_UP:
{
struct libinput_event_touch *tev = libinput_event_get_touch_event(event);
struct wlc_input_event ev = {0};
ev.type = WLC_INPUT_EVENT_TOUCH;
ev.time = libinput_event_touch_get_time(tev);
ev.touch.type = wlc_touch_type_for_libinput_type(libinput_event_get_type(event));
ev.touch.slot = libinput_event_touch_get_seat_slot(tev);
wl_signal_emit(&wlc_system_signals()->input, &ev);
}
break;
case LIBINPUT_EVENT_TOUCH_DOWN:
case LIBINPUT_EVENT_TOUCH_MOTION:
{
struct libinput_event_touch *tev = libinput_event_get_touch_event(event);
struct wlc_input_event ev = {0};
ev.type = WLC_INPUT_EVENT_TOUCH;
ev.time = libinput_event_touch_get_time(tev);
ev.touch.type = wlc_touch_type_for_libinput_type(libinput_event_get_type(event));
ev.touch.x = touch_abs_x;
ev.touch.y = touch_abs_y;
ev.touch.internal = tev;
ev.touch.slot = libinput_event_touch_get_seat_slot(tev);
wl_signal_emit(&wlc_system_signals()->input, &ev);
}
break;
case LIBINPUT_EVENT_TOUCH_FRAME:
case LIBINPUT_EVENT_TOUCH_CANCEL:
{
struct libinput_event_touch *tev = libinput_event_get_touch_event(event);
struct wlc_input_event ev = {0};
ev.type = WLC_INPUT_EVENT_TOUCH;
ev.time = libinput_event_touch_get_time(tev);
ev.touch.type = wlc_touch_type_for_libinput_type(libinput_event_get_type(event));
wl_signal_emit(&wlc_system_signals()->input, &ev);
}
break;
default: break;
}
libinput_event_destroy(event);
}
return 0;
}
static void
wl_cb_shell_get_shell_surface(struct wl_client *client, struct wl_resource *resource, uint32_t id, struct wl_resource *surface_resource)
{
struct wlc_shell *shell;
struct wlc_surface *surface;
if (!(shell = wl_resource_get_user_data(resource)) || !(surface = convert_from_wl_resource(surface_resource, "surface")))
return;
wlc_resource r;
if (!(r = wlc_resource_create(&shell->surfaces, client, &wl_shell_surface_interface, wl_resource_get_version(resource), 1, id)))
return;
wlc_resource_implement(r, &wl_shell_surface_implementation, NULL);
struct wlc_surface_event ev = { .attach = { .type = WLC_SHELL_SURFACE, .shell_surface = r }, .surface = surface, .type = WLC_SURFACE_EVENT_REQUEST_VIEW_ATTACH };
wl_signal_emit(&wlc_system_signals()->surface, &ev);
}
static const struct wl_shell_interface wl_shell_implementation = {
.get_shell_surface = wl_cb_shell_get_shell_surface
};
static void
wl_shell_bind(struct wl_client *client, void *data, uint32_t version, uint32_t id)
{
struct wl_resource *resource;
if (!(resource = wl_resource_create_checked(client, &wl_shell_interface, version, 1, id)))
return;
wl_resource_set_implementation(resource, &wl_shell_implementation, data, NULL);
}
x11.api.xcb_destroy_window(x11.connection, bsurface->window);
}
static bool
add_output(xcb_window_t window, struct wlc_output_information *info)
{
struct wlc_backend_surface bsurface;
if (!wlc_backend_surface(&bsurface, surface_release, 0))
return false;
bsurface.window = window;
bsurface.display = x11.display;
bsurface.api.page_flip = page_flip;
struct wlc_output_event ev = { .add = { &bsurface, info }, .type = WLC_OUTPUT_EVENT_ADD };
wl_signal_emit(&wlc_system_signals()->output, &ev);
return true;
}
static struct wlc_output*
output_for_window(struct chck_pool *outputs, xcb_window_t window)
{
struct wlc_output *o;
chck_pool_for_each(outputs, o) {
if (o->bsurface.window == window)
return o;
}
return NULL;
}
static size_t
