diyac/seat.c

#define _POSIX_C_SOURCE 200112L
#include <wlr/types/wlr_input_device.h>
#include <wlr/types/wlr_data_device.h>
#include <stdlib.h>
#include <wlr/util/log.h>
#include <assert.h>
#include "seat.h"
#include "view.h"

static void configure_keyboard(struct diyac_seat* seat, struct diyac_input* input, bool force)
{
    struct wlr_input_device *device = input->device;
    assert(device->type == WLR_INPUT_DEVICE_KEYBOARD);
    struct diyac_keyboard *keyboard = (struct diyac_keyboard *)input;
    struct wlr_keyboard *kb = wlr_keyboard_from_input_device(device);

    if(!keyboard->is_virtual || force)
    {
        /*
        * Set layout based on environment variables XKB_DEFAULT_LAYOUT,
        * XKB_DEFAULT_OPTIONS, and friends.
        */
        struct xkb_rule_names rules = { 0 };
        struct xkb_context *context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
        struct xkb_keymap *keymap = xkb_map_new_from_names(context, &rules,XKB_KEYMAP_COMPILE_NO_FLAGS);
        if (keymap) {
            if (!wlr_keyboard_keymaps_match(kb->keymap, keymap)) {
                wlr_keyboard_set_keymap(kb, keymap);
            }
            xkb_keymap_unref(keymap);
        } else {
            wlr_log(WLR_ERROR, "Failed to create xkb keymap");
        }
        xkb_context_unref(context);
    }
    wlr_keyboard_set_repeat_info(kb, 25, 600);
}


static void keyboard_handle_modifiers(
    struct wl_listener *listener, void *data)
{
    /* This event is raised when a modifier key, such as shift or alt, is
     * pressed. We simply communicate this to the client. */
    struct diyac_keyboard *keyboard =
        wl_container_of(listener, keyboard, modifiers);
    /*
     * A seat can only have one keyboard, but this is a limitation of the
     * Wayland protocol - not wlroots. We assign all connected keyboards to the
     * same seat. You can swap out the underlying wlr_keyboard like this and
     * wlr_seat handles this transparently.
     */
    wlr_seat_set_keyboard(keyboard->input.seat->wlr_seat, keyboard->wlr_keyboard);
    /* Send modifiers to the client. */
    wlr_seat_keyboard_notify_modifiers(keyboard->input.seat->wlr_seat,
                                       &keyboard->wlr_keyboard->modifiers);
}

static bool handle_keybinding(struct diyac_server *server, xkb_keysym_t sym)
{
    /*
     * Here we handle compositor keybindings. This is when the compositor is
     * processing keys, rather than passing them on to the client for its own
     * processing.
     *
     * This function assumes Alt is held down.
     */
    switch (sym)
    {
    case XKB_KEY_Escape:
        wl_display_terminate(server->wl_display);
        break;
    case XKB_KEY_F1:
        /* Cycle to the next toplevel */
        if (wl_list_length(&server->views) < 2)
        {
            break;
        }
        struct diyac_view *next_toplevel =
            wl_container_of(server->views.prev, next_toplevel, link);
        diyac_focus_view(next_toplevel, true);
        break;
    default:
        return false;
    }
    return true;
}

static void keyboard_handle_key(
    struct wl_listener *listener, void *data)
{
    /* This event is raised when a key is pressed or released. */
    struct diyac_keyboard *keyboard =
        wl_container_of(listener, keyboard, key);
    struct wlr_keyboard_key_event *event = data;
    struct wlr_seat *seat = keyboard->input.seat->wlr_seat;

    /* Translate libinput keycode -> xkbcommon */
    wlr_log(WLR_INFO, "receive keycode %d", event->keycode);
    uint32_t keycode = event->keycode + 8;
    /* Get a list of keysyms based on the keymap for this keyboard */
    const xkb_keysym_t *syms;
    int nsyms = xkb_state_key_get_syms(
        keyboard->wlr_keyboard->xkb_state, keycode, &syms);

    bool handled = false;
    uint32_t modifiers = wlr_keyboard_get_modifiers(keyboard->wlr_keyboard);
    if ((modifiers & WLR_MODIFIER_ALT) &&
        event->state == WL_KEYBOARD_KEY_STATE_PRESSED)
    {
        /* If alt is held down and this button was _pressed_, we attempt to
         * process it as a compositor keybinding. */
        for (int i = 0; i < nsyms; i++)
        {
            handled = handle_keybinding(keyboard->input.seat->server, syms[i]);
        }
    }

    if (!handled)
    {
        /* Otherwise, we pass it along to the client. */
        wlr_seat_set_keyboard(seat, keyboard->wlr_keyboard);
        wlr_seat_keyboard_notify_key(seat, event->time_msec,
                                     event->keycode, event->state);
    }
}

static void input_handle_destroy(struct wl_listener *listener, void *data)
{
    /* This event is raised by the keyboard base wlr_input_device to signal
     * the destruction of the wlr_keyboard. It will no longer receive events
     * and should be destroyed.
     */
    struct diyac_input *input = wl_container_of(listener, input, destroy);
    wl_list_remove(&input->link);
    wl_list_remove(&input->destroy.link);

    if(input->device->type == WLR_INPUT_DEVICE_KEYBOARD)
    {
        struct diyac_keyboard* keyboard = (struct diyac_keyboard*) input;
        if(keyboard->is_virtual)
        {
            wlr_log(WLR_INFO, "Virtual keyboard destroyed");
        }
        wl_list_remove(&keyboard->modifiers.link);
        wl_list_remove(&keyboard->key.link);
    }
    free(input);
}

static struct diyac_input* server_new_keyboard(struct diyac_seat *seat,
                                struct wlr_input_device *device, bool is_virtual)
{
    struct wlr_keyboard *wlr_keyboard = wlr_keyboard_from_input_device(device);

    struct diyac_keyboard *keyboard = calloc(1, sizeof(*keyboard));
    keyboard->wlr_keyboard = wlr_keyboard;
    keyboard->input.device = device;
    keyboard->input.seat = seat;
    keyboard->is_virtual = is_virtual;

    /**
     * Force configure default keyboard keymap for all new
     * keyboard, including virtual keyboard
     */
    configure_keyboard(seat,&keyboard->input, true);

    /* Here we set up listeners for keyboard events. */
    keyboard->modifiers.notify = keyboard_handle_modifiers;
    wl_signal_add(&wlr_keyboard->events.modifiers, &keyboard->modifiers);
    
    keyboard->key.notify = keyboard_handle_key;
    wl_signal_add(&wlr_keyboard->events.key, &keyboard->key);

    wlr_seat_set_keyboard(seat->wlr_seat, keyboard->wlr_keyboard);

    /* And add the keyboard to our list of keyboards */
    //wl_list_insert(&server->seat.keyboards, &keyboard->link);
    return (struct diyac_input*) keyboard;
}

static struct diyac_input* server_new_pointer(struct diyac_seat *seat,
                               struct wlr_input_device *device)
{
    struct diyac_input *input = calloc(1, sizeof(*input));
    input->device = device;
    /* We don't do anything special with pointers. All of our pointer handling
     * is proxied through wlr_cursor. On another compositor, you might take this
     * opportunity to do libinput configuration on the device to set
     * acceleration, etc. */
    wlr_cursor_attach_input_device(seat->cursor, device);
    return input;
}

static void seat_add_input(struct diyac_seat* seat, struct diyac_input* input)
{
    input->seat = seat;
    input->destroy.notify = input_handle_destroy;
    wl_signal_add(&input->device->events.destroy, &input->destroy);
    wl_list_insert(&seat->inputs, &input->link);
    // update capability

    /* We need to let the wlr_seat know what our capabilities are, which is
     * communiciated to the client. In Diyac we always have a cursor, even if
     * there are no pointer devices, so we always include that capability. */
    uint32_t caps = 0;

    wl_list_for_each(input, &seat->inputs, link) {
        switch (input->device->type) {
        case WLR_INPUT_DEVICE_KEYBOARD:
            caps |= WL_SEAT_CAPABILITY_KEYBOARD;
            break;
        case WLR_INPUT_DEVICE_POINTER:
            caps |= WL_SEAT_CAPABILITY_POINTER;
            break;
        case WLR_INPUT_DEVICE_TOUCH:
            caps |= WL_SEAT_CAPABILITY_TOUCH;
            break;
        default:
            break;
        }
    }
    wlr_seat_set_capabilities(seat->wlr_seat, caps);
}

static void server_new_input(struct wl_listener *listener, void *data)
{
    /* This event is raised by the backend when a new input device becomes
     * available. */
    struct diyac_seat *seat =
        wl_container_of(listener, seat, new_input);
    struct wlr_input_device *device = data;
    struct diyac_input* input = NULL;

    switch (device->type)
    {
    case WLR_INPUT_DEVICE_KEYBOARD:
        input = server_new_keyboard(seat, device, false);
        break;
    case WLR_INPUT_DEVICE_POINTER:
        input = server_new_pointer(seat, device);
        break;
    default:
        break;
        return;
    }
    seat_add_input(seat, input);
}

static void seat_request_cursor(struct wl_listener *listener, void *data)
{
    struct diyac_seat *seat = wl_container_of(
        listener, seat, request_cursor);
    /* This event is raised by the seat when a client provides a cursor image */
    struct wlr_seat_pointer_request_set_cursor_event *event = data;
    struct wlr_seat_client *focused_client =
        seat->wlr_seat->pointer_state.focused_client;
    /* This can be sent by any client, so we check to make sure this one is
     * actually has pointer focus first. */
    if (focused_client == event->seat_client)
    {
        /* Once we've vetted the client, we can tell the cursor to use the
         * provided surface as the cursor image. It will set the hardware cursor
         * on the output that it's currently on and continue to do so as the
         * cursor moves between outputs. */
        wlr_cursor_set_surface(seat->cursor, event->surface,
                               event->hotspot_x, event->hotspot_y);
    }
}

static void seat_request_set_selection(struct wl_listener *listener, void *data)
{
    /* This event is raised by the seat when a client wants to set the selection,
     * usually when the user copies something. wlroots allows compositors to
     * ignore such requests if they so choose, but in diyac we always honor
     */
    struct diyac_seat *seat = wl_container_of(
        listener, seat, request_set_selection);
    struct wlr_seat_request_set_selection_event *event = data;
    wlr_seat_set_selection(seat->wlr_seat, event->source, event->serial);
}

static void request_set_selection_notify(struct wl_listener *listener, void *data)
{
    struct diyac_seat *seat = wl_container_of(
        listener, seat, request_set_selection);
    struct wlr_seat_request_set_selection_event *event = data;
    wlr_seat_set_selection(seat->wlr_seat, event->source,
                           event->serial);
}

static void request_set_primary_selection_notify(struct wl_listener *listener, void *data)
{
    struct diyac_seat *seat = wl_container_of(
        listener, seat, request_set_primary_selection);
    struct wlr_seat_request_set_primary_selection_event *event = data;
    wlr_seat_set_primary_selection(seat->wlr_seat, event->source,
                                   event->serial);
}

static void new_virtual_keyboard(struct wl_listener *listener, void *data)
{
    wlr_log(WLR_INFO, "Create a new virtual keyboard with default layout");
    struct diyac_seat *seat = wl_container_of(listener, seat, virtual_keyboard_new);
    struct wlr_virtual_keyboard_v1 *virtual_keyboard = data;
    struct wlr_input_device *device = &virtual_keyboard->keyboard.base;

    struct diyac_input *input = server_new_keyboard(seat, device, true);
    device->data = input;
    seat_add_input(seat, input);
}

/*
 * Configures a seat, which is a single "seat" at which a user sits and
 * operates the computer. This conceptually includes up to one keyboard,
 * pointer, touch, and drawing tablet device. We also rig up a listener to
 * let us know when new input devices are available on the backend.
 */
void diyac_init_seat(struct diyac_server *server)
{
    // server->seat = calloc(1, sizeof(struct diyac_seat));
    server->seat.server = server;
    server->seat.new_input.notify = server_new_input;
    wl_signal_add(&server->backend->events.new_input, &server->seat.new_input);
    server->seat.wlr_seat = wlr_seat_create(server->wl_display, "seat0");
    server->seat.request_cursor.notify = seat_request_cursor;
    wl_signal_add(&server->seat.wlr_seat->events.request_set_cursor,
                  &server->seat.request_cursor);
    server->seat.request_set_selection.notify = seat_request_set_selection;
    wl_signal_add(&server->seat.wlr_seat->events.request_set_selection,
                  &server->seat.request_set_selection);
        server->seat.request_set_selection.notify = request_set_selection_notify;
    wl_signal_add(&server->seat.wlr_seat->events.request_set_selection,
                  &server->seat.request_set_selection);

    server->seat.request_set_primary_selection.notify =
        request_set_primary_selection_notify;
    wl_signal_add(&server->seat.wlr_seat->events.request_set_primary_selection,
                  &server->seat.request_set_primary_selection);

    // virtual keyboard support
    server->seat.virtual_keyboard_manager = wlr_virtual_keyboard_manager_v1_create(server->wl_display);
    wl_signal_add(&server->seat.virtual_keyboard_manager->events.new_virtual_keyboard,
        &server->seat.virtual_keyboard_new);
    server->seat.virtual_keyboard_new.notify = new_virtual_keyboard;
}

static void seat_focus(struct diyac_seat *seat, struct wlr_surface *surface, bool is_lock_surface)
{
    /*
     * Respect session lock. This check is critical, DO NOT REMOVE.
     * It should also come before the !surface condition, or the
     * lock screen may lose focus and become impossible to unlock.
     */
    struct diyac_server *server = seat->server;
    if (server->lock && !is_lock_surface)
    {
        return;
    }

    if (!surface)
    {
        wlr_seat_keyboard_notify_clear_focus(seat->wlr_seat);
        return;
    }

    /* Respect input inhibit (also used by some lock screens) */
    /*
    if (input_inhibit_blocks_surface(seat, surface->resource)) {
        return;
    }
    */

    struct wlr_keyboard *keyboard = wlr_seat_get_keyboard(seat->wlr_seat);
    if (keyboard)
    {
        wlr_seat_keyboard_notify_enter(seat->wlr_seat, surface,
                                       keyboard->keycodes, keyboard->num_keycodes, &keyboard->modifiers);
    }

    /*
    struct wlr_pointer_constraint_v1 *constraint =
        wlr_pointer_constraints_v1_constraint_for_surface(server->constraints,
                                                          surface, seat->seat);
    constrain_cursor(server, constraint);
    */
}

void diyac_seat_focus_surface(struct diyac_seat *seat, struct wlr_surface *surface)
{
    /* Respect layer-shell exclusive keyboard-interactivity. */
    if (seat->focused_layer && seat->focused_layer->current.keyboard_interactive == ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_EXCLUSIVE)
    {
        return;
    }
    seat_focus(seat, surface, /*is_lock_surface*/ false);
}

void diyac_seat_focus_lock_surface(struct diyac_seat *seat, struct wlr_surface *surface)
{
    seat_focus(seat, surface, /*is_lock_surface*/ true);
}

void diyac_seat_focus_layer(struct diyac_seat *seat, struct wlr_layer_surface_v1 *layer)
{
    if (!layer)
    {
        seat->focused_layer = NULL;
        diyac_focus_topmost_view(seat->server, false);
        return;
    }
    seat_focus(seat, layer->surface, /*is_lock_surface*/ false);
    if (layer->current.layer >= ZWLR_LAYER_SHELL_V1_LAYER_TOP)
    {
        seat->focused_layer = layer;
    }
}

void diyac_seat_configure(struct diyac_server* server)
{
    struct diyac_seat* seat = &server->seat;
    struct diyac_input* input = NULL;

    wl_list_for_each(input, &seat->inputs, link)
    {
        switch (input->device->type) {
        case WLR_INPUT_DEVICE_KEYBOARD:
            configure_keyboard(seat, input, false);
            break;
        case WLR_INPUT_DEVICE_POINTER:
            break;
        case WLR_INPUT_DEVICE_TOUCH:
            break;
        default:
            break;
        }
    }
}