#define MAX_LAYER_SURFACES      256

#define MAX_KEYBOARD_GROUPS     32

#define MAX_POINTER_CONSTRAINTS 256

#define MAX_TEXT_INPUTS         128

#define MAX_INPUT_POPUPS        64

#define MAX_SESSION_LOCKS       4

#define MAX_PENDING_SPAWNS      256

#define MAX_WINDOW_STATES       512

#define MAX_WINDOW_STATE_FIELD  256

#define MAX_WINDOW_STATE_LINE   1024

    struct wl_listener        commit;

    struct wl_listener        disable;

    struct wl_listener        destroy;

} text_input_t;

/* Input-method popup state. */

typedef struct {

    struct wlr_input_popup_surface_v2 *popup;

    struct wlr_scene_tree             *scene;

    struct wl_list                     link;

static void              cleanup_listeners(void);

static void              close_monitor(monitor_t *m);

static void              layer_surface_commit_notify(struct wl_listener *listener, void *data);

static void              commit_notify(struct wl_listener *listener, void *data);

static void              popup_commit(struct wl_listener *listener, void *data);

static void              create_decoration(struct wl_listener *listener, void *data);

static void              create_idle_inhibitor(struct wl_listener *listener, void *data);

static void              create_keyboard(struct wlr_keyboard *keyboard);

static keyboard_group_t *create_keyboard_group(bool is_virtual);

static void              create_layer_surface(struct wl_listener *listener, void *data);

static layer_surface_t      layer_surface_items[MAX_LAYER_SURFACES];

static keyboard_group_t     keyboard_group_items[MAX_KEYBOARD_GROUPS];

static pointer_constraint_t pointer_constraint_items[MAX_POINTER_CONSTRAINTS];

static text_input_t         text_input_items[MAX_TEXT_INPUTS];

static input_popup_t        input_popup_items[MAX_INPUT_POPUPS];

static session_lock_t       session_lock_items[MAX_SESSION_LOCKS];

static pending_spawn_t      pending_spawn_items[MAX_PENDING_SPAWNS];

static window_state_t       window_state_items[MAX_WINDOW_STATES];

static static_listener_t    static_listener_items[MAX_STATIC_LISTENERS];

static workspace_manager_t  workspace_manager_items[MAX_WS_MANAGERS];

static bool client_used[MAX_CLIENTS], monitor_used[MAX_MONITORS];

static bool layer_surface_used[MAX_LAYER_SURFACES], keyboard_group_used[MAX_KEYBOARD_GROUPS];

static bool pointer_constraint_used[MAX_POINTER_CONSTRAINTS], text_input_used[MAX_TEXT_INPUTS];

static bool input_popup_used[MAX_INPUT_POPUPS], session_lock_used[MAX_SESSION_LOCKS];

static bool pending_spawn_used[MAX_PENDING_SPAWNS], window_state_used[MAX_WINDOW_STATES];

static bool static_listener_used[MAX_STATIC_LISTENERS], workspace_manager_used[MAX_WS_MANAGERS];

static bool workspace_handle_used[MAX_WS_HANDLES], metadata_manager_used[MAX_WS_MANAGERS];

static pool_t client_pool = {

static pool_t metadata_manager_pool   = { metadata_manager_items,

                                          metadata_manager_used,

                                          LENGTH(metadata_manager_items),

                                          sizeof *metadata_manager_items,

                                          "metadata_manager" };

/* Backend-specific client operations. */

/* Client helpers shared by the XDG shell and Xwayland implementations. These

 * are inline so unused helpers are omitted for builds that disable a backend. */

        c->resize_edges = WLR_EDGE_NONE;

}

/* Create and constrain a popup after its initial state is committed. */

void popup_commit(struct wl_listener *listener, void *data) {

    struct wlr_box        box;

    int                   type = -1;

    if (!popup->base->initial_commit)

        return;

    type = toplevel_from_wlr_surface(popup->base->surface, &c, &l);

    if ((type == LAYER_SHELL && (!l || !l->mon)) || (type != LAYER_SHELL && (!c || !c->mon)) ||

    popup->base->surface->data = wlr_scene_xdg_surface_create(popup->parent->data, popup->base);

    box    = type == LAYER_SHELL ? l->mon->m : c->mon->w;

    box.x -= (type == LAYER_SHELL ? l->scene->node.x : c->geom.x);

    box.y -= (type == LAYER_SHELL ? l->scene->node.y : c->geom.y);

    wlr_xdg_popup_unconstrain_from_box(popup, &box);

}

/* Attach an event listener from the fixed-capacity listener pool. */

void listen_static(struct wl_signal *signal, wl_notify_func_t notify) {

    static_listener_t *slot = pool_take(&static_listener_pool);

/* Wait for a new popup's initial commit before adding it to the scene. */

void create_popup(struct wl_listener *listener, void *data) {

    /* This event is raised when a client (either xdg-shell or layer-shell)

     * creates a new popup. */

    struct wlr_xdg_popup *popup = data;

}

/* Activate the pointer constraint belonging to the focused surface. */

void cursor_constrain(struct wlr_pointer_constraint_v1 *constraint) {

    if (active_constraint == constraint)

    wl_list_remove(&l->link);

    wl_list_remove(&l->destroy.link);

    wl_list_remove(&l->unmap.link);

    wl_list_remove(&l->surface_commit.link);

    wlr_scene_node_destroy(&l->popups->node);

    if (l->dim)

        wlr_scene_node_destroy(&l->dim->node);

    pool_release(&layer_surface_pool, l);

}

/* Handle a session locker that exits without unlocking cleanly. */

void destroy_lock(session_lock_t *lock, int unlock) {

    wlr_seat_keyboard_notify_clear_focus(seat);

    input_method_set_focus(nullptr);

    locked = !unlock;

    if (unlock) {

    }

    wl_list_remove(&lock->new_surface.link);

    wl_list_remove(&lock->unlock.link);

    wl_list_remove(&lock->destroy.link);

    wlr_scene_node_destroy(&lock->scene->node);

    cur_lock = nullptr;

    pool_release(&session_lock_pool, lock);

}

    monitor_t                          *m = wl_container_of(listener, m, destroy_lock_surface);

    struct wlr_session_lock_surface_v1 *surface, *lock_surface = m->lock_surface;

    m->lock_surface = nullptr;

    wl_list_remove(&m->destroy_lock_surface.link);

    if (lock_surface->surface != seat->keyboard_state.focused_surface)

        return;

    if (locked && cur_lock && !wl_list_empty(&cur_lock->surfaces)) {