void
wlc_view_set_class_ptr(struct wlc_view *view, const char *class_, size_t length)
{
if (view && !chck_cstrneq(view->data._class.data, class_, length) && chck_string_set_cstr_with_length(&view->data._class, class_, length, true)) {
WLC_INTERFACE_EMIT(view.properties_updated, convert_to_wlc_handle(view), WLC_BIT_PROPERTY_CLASS);
}
}
void
wlc_view_set_app_id_ptr(struct wlc_view *view, const char *app_id)
{
if (view && !chck_cstreq(view->data.app_id.data, app_id) && chck_string_set_cstr(&view->data.app_id, app_id, true)) {
WLC_INTERFACE_EMIT(view.properties_updated, convert_to_wlc_handle(view), WLC_BIT_PROPERTY_APP_ID);
}
}
void
wlc_view_set_title_ptr(struct wlc_view *view, const char *title, size_t length)
{
if (view && !chck_cstrneq(view->data.title.data, title, length) && chck_string_set_cstr_with_length(&view->data.title, title, length, true)) {
WLC_INTERFACE_EMIT(view.properties_updated, convert_to_wlc_handle(view), WLC_BIT_PROPERTY_TITLE);
}
}
WLC_API void
wlc_run(void)
{
if (!wlc.display)
return;
wlc.compositor.state.ready = false;
bool emit_ready = true;
const char *xwayland = getenv("WLC_XWAYLAND");
if (!xwayland || !chck_cstreq(xwayland, "0"))
emit_ready = !wlc_xwayland_init();
// Emit ready immediately when no Xwayland
if (emit_ready) {
WLC_INTERFACE_EMIT(compositor.ready);
wlc.compositor.state.ready = true;
}
wlc_set_active(true);
if (wlc_compositor_is_good(&wlc.compositor))
wl_display_run(wlc.display);
wlc_cleanup();
}
void
wlc_view_unmap(struct wlc_view *view)
{
assert(view);
wlc_output_unlink_view(wlc_view_get_output_ptr(view), view);
if (!view->state.created)
return;
WLC_INTERFACE_EMIT(view.destroyed, convert_to_wlc_handle(view));
view->state.created = false;
}
WLC_API void
wlc_run(void)
{
if (!wlc.display)
return;
// Called when no xwayland is requested
if (wlc.set_ready_on_run) {
WLC_INTERFACE_EMIT(compositor.ready);
wlc.set_ready_on_run = false;
}
wl_display_run(wlc.display);
wlc_cleanup();
}
static void
xdg_cb_surface_resize(struct wl_client *client, struct wl_resource *resource, struct wl_resource *seat_resource, uint32_t serial, uint32_t edges)
{
(void)client, (void)resource, (void)serial;
struct wlc_seat *seat;
if (!(seat = wl_resource_get_user_data(seat_resource)))
return;
if (!seat->pointer.focused.view)
return;
const struct wlc_origin o = { seat->pointer.pos.x, seat->pointer.pos.y };
WLC_INTERFACE_EMIT(view.request.resize, seat->pointer.focused.view, edges, &o);
}
static void
wl_cb_shell_surface_resize(struct wl_client *client, struct wl_resource *resource, struct wl_resource *seat_resource, uint32_t serial, uint32_t edges)
{
(void)client, (void)resource, (void)serial;
struct wlc_seat *seat;
if (!(seat = wl_resource_get_user_data(seat_resource)))
return;
if (!seat->pointer.focused.view)
return;
wlc_dlog(WLC_DBG_REQUEST, "(%" PRIuWLC ") requested resize", seat->pointer.focused.view);
const struct wlc_point o = { seat->pointer.pos.x, seat->pointer.pos.y };
WLC_INTERFACE_EMIT(view.request.resize, seat->pointer.focused.view, edges, &o);
}
bool
wlc_view_request_geometry(struct wlc_view *view, const struct wlc_geometry *r)
{
assert(view && r);
wlc_dlog(WLC_DBG_REQUEST, "(%" PRIuWLC ") requested geometry %ux%u+%d,%d", convert_to_wlc_handle(view), r->size.w, r->size.h, r->origin.x, r->origin.y);
if (view->state.created && wlc_interface()->view.request.geometry) {
WLC_INTERFACE_EMIT(view.request.geometry, convert_to_wlc_handle(view), r);
} else {
memcpy(&view->pending.geometry, r, sizeof(view->pending.geometry));
}
configure_view(view, view->pending.edges, &view->pending.geometry);
wlc_dlog(WLC_DBG_REQUEST, "(%" PRIuWLC ") applied geometry %ux%u+%d,%d", convert_to_wlc_handle(view), view->pending.geometry.size.w, view->pending.geometry.size.h, view->pending.geometry.origin.x, view->pending.geometry.origin.y);
return wlc_geometry_equals(r, &view->pending.geometry);
}
bool
wlc_view_request_state(struct wlc_view *view, enum wlc_view_state_bit state, bool toggle)
{
if (!view || !view->state.created)
return false;
if (!!(view->pending.state & state) == toggle) {
// refresh geometry
if (state == WLC_BIT_FULLSCREEN || state == WLC_BIT_MAXIMIZED)
configure_view(view, view->pending.edges, &view->pending.geometry);
return true;
}
wlc_dlog(WLC_DBG_REQUEST, "(%" PRIuWLC ") requested state %d", convert_to_wlc_handle(view), state);
if (wlc_interface()->view.request.state) {
WLC_INTERFACE_EMIT(view.request.state, convert_to_wlc_handle(view), state, toggle);
} else {
wlc_view_set_state_ptr(view, state, toggle);
}
wlc_dlog(WLC_DBG_REQUEST, "(%" PRIuWLC ") applied states %d", convert_to_wlc_handle(view), view->pending.state);
return (!!(view->pending.state & state) == toggle);
}
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;
}