#define MAX_WINDOW_STATE_LINE   1024

#define MAX_STATE_PATH          4096

#define MAX_WORKSPACE_TITLE     256

#define MAX_WS_ID               16

#define MAX_STATIC_LISTENERS    512

#define MAX_WS_MANAGERS         64

#define MAX_WS_HANDLES          (MAX_WS_MANAGERS * WSCOUNT)

#define MAX_AUTOSTART           64

#define MAX_COMMAND_SIZE        1024

#define MAX_COMMAND_ARGS        64

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

static void      load_window_states(void);

static int       key_repeat(void *data);

static void      kill_client(const arg_t *arg);

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

static void      listen_static(struct wl_signal *signal, wl_notify_func_t notify);

static void      listener_release(struct wl_listener *listener);

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

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

static void      max_stack(monitor_t *m);

static bool                    locked;

static void                   *exclusive_focus;

static struct wl_display      *dpy;

static struct wl_event_loop   *event_loop;

static struct wl_event_source *signal_sources[3];

static sigset_t                original_signal_mask;

static struct wlr_backend     *backend;

static struct wlr_scene       *scene;

static struct wlr_scene_tree  *layers[NUM_LAYERS];

static struct wlr_scene_tree  *drag_icon;

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

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

static struct wl_listener   new_xwayland_surface    = { .notify = create_notify_x11 };

static struct wl_listener   xwayland_ready_listener = { .notify = xwayland_ready };

static struct wlr_xwayland *xwayland;

/* Load configuration after declaring the types and state it may use. */

#include "config.h"

static_assert(WSCOUNT > 0 && WSCOUNT <= 32, "WSCOUNT must be between 1 and 32");

    close_monitor(m);

    wlr_scene_node_destroy(&m->fullscreen_bg->node);

    pool_release(&monitor_pool, m);

}

/* Detach global event listeners before their event sources are destroyed. */

void cleanup_listeners(void) {

}

/* Hide a display's workspace and move its windows to a valid display. */

void close_monitor(monitor_t *m) {

    /* If the selected display closes, select another one. Its workspace

    wlr_scene_node_place_below(&drag_icon->node, &layers[LAYER_BLOCK]->node);

    /* Choose a renderer. WLR_RENDERER can override the automatic choice. */

    if (!(drw = wlr_renderer_autocreate(backend)))

        die("couldn't create renderer");

    /* Advertise the buffer types supported by both the renderer and scene code. */

    wlr_renderer_init_wl_shm(drw, dpy);

    if (wlr_renderer_get_texture_formats(drw, WLR_BUFFER_CAP_DMABUF)) {

    wlr_presentation_create(dpy, backend, 2);

    wlr_alpha_modifier_v1_create(dpy);

    /* Accept application requests for attention. */

    activation = wlr_xdg_activation_v1_create(dpy);

    system_bell = wlr_xdg_system_bell_v1_create(dpy, 1);

    wlr_scene_set_gamma_control_manager_v1(scene, wlr_gamma_control_manager_v1_create(dpy));

    power_mgr = wlr_output_power_manager_v1_create(dpy);

    /* Track the position of each display in the combined desktop. */

    output_layout = wlr_output_layout_create(dpy);

    wlr_xdg_output_manager_v1_create(dpy, output_layout);

    /* Workspaces are global and independent of outputs. */

    for (i = 0; i < WSCOUNT; i++) {

    /* Publish window lists for taskbars and switchers. */

    ftl_mgr      = wlr_foreign_toplevel_manager_v1_create(dpy);

    ext_ftl_list = wlr_ext_foreign_toplevel_list_v1_create(dpy, 1);

    wlr_ext_image_copy_capture_manager_v1_create(dpy, 1);

    ext_ftl_capture_mgr = wlr_ext_foreign_toplevel_image_capture_source_manager_v1_create(dpy, 1);

    /* Let virtual machines and remote desktops capture window-manager shortcuts. */

    kb_inhibit_mgr = wlr_keyboard_shortcuts_inhibit_v1_create(dpy);

    /* Listen for newly connected displays. */

    wl_list_init(&mons);

    /* Set up application windows, panels, backgrounds, and other desktop surfaces. */

    wl_list_init(&clients);

    wl_list_init(&fstack);

    xdg_shell = wlr_xdg_shell_create(dpy, 6);

    xdg_dialog_mgr = wlr_xdg_wm_dialog_v1_create(dpy, 1);

    layer_shell = wlr_layer_shell_v1_create(dpy, 4);

    idle_notifier = wlr_idle_notifier_v1_create(dpy);

    idle_inhibit_mgr = wlr_idle_inhibit_v1_create(dpy);

    session_lock_mgr = wlr_session_lock_manager_v1_create(dpy);

    locked_bg = wlr_scene_rect_create(

        layers[LAYER_BLOCK], sgeom.width, sgeom.height, (float[4]){ 0.1f, 0.1f, 0.1f, 1.0f }

    );

    if (!locked_bg)

    /* Prefer window borders drawn by the compositor. */

    wlr_server_decoration_manager_set_default_mode(

        wlr_server_decoration_manager_create(dpy), WLR_SERVER_DECORATION_MANAGER_MODE_SERVER

    );

    xdg_decoration_mgr = wlr_xdg_decoration_manager_v1_create(dpy);

    pointer_constraints = wlr_pointer_constraints_v1_create(dpy);

    relative_pointer_mgr = wlr_relative_pointer_manager_v1_create(dpy);

    pointer_gestures     = wlr_pointer_gestures_v1_create(dpy);

    /* Track the pointer across all displays. */

    /* Load cursor images at the scales required by connected displays. */

    cursor_mgr = wlr_xcursor_manager_create(nullptr, 24);

    setenv("XCURSOR_SIZE", "24", 1);

    /* Combine pointer devices and handle their movement, buttons, scrolling, and frames. */

    cursor_shape_mgr = wlr_cursor_shape_manager_v1_create(dpy, 1);

    /* A seat groups the input devices controlled by one user. */

    virtual_keyboard_mgr = wlr_virtual_keyboard_manager_v1_create(dpy);

    virtual_pointer_mgr = wlr_virtual_pointer_manager_v1_create(dpy);

    seat = wlr_seat_create(dpy, "seat0");

    /* Connect applications to an input method such as fcitx5. */

    im_mgr = wlr_input_method_manager_v2_create(dpy);

    ti_mgr = wlr_text_input_manager_v3_create(dpy);

    kb_group = create_keyboard_group(false);

    if (!kb_group)

        die("failed to allocate primary keyboard group");

    wl_list_init(&kb_group->destroy.link);

    output_mgr = wlr_output_manager_v1_create(dpy);

    /* Keep XWayland applications on this compositor rather than a parent X server. */

    unsetenv("DISPLAY");

    /* Create the XWayland server; it starts when the first X11 application opens. */

    if ((xwayland = wlr_xwayland_create(dpy, compositor, 1))) {

        setenv("DISPLAY", xwayland->display_name, 1);

    } else {

        fprintf(stderr, "failed to setup XWayland X server, continuing without it\n");

    }