#include <wlr/types/wlr_virtual_keyboard_v1.h>

#include <wlr/types/wlr_virtual_pointer_v1.h>

#include <wlr/types/wlr_xcursor_manager.h>

#include <wlr/types/wlr_xdg_activation_v1.h>

#include <wlr/types/wlr_xdg_decoration_v1.h>

#include <wlr/types/wlr_xdg_output_v1.h>

#include <wlr/types/wlr_xdg_shell.h>

#include <wlr/util/log.h>

#include <wlr/util/region.h>

#include <wlr/xwayland.h>

    struct wl_listener                         set_title;

    struct wl_listener                         set_appid;

    struct wl_listener                         fullscreen;

    struct wl_listener                         set_decoration_mode;

    struct wl_listener                         destroy_decoration;

    struct wl_listener                         activate;

    struct wl_listener                         associate;

    struct wl_listener                         dissociate;

    struct wl_listener                         configure;

    struct wl_listener                         set_hints;

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

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

static void      focus_monitor(const arg_t *arg);

static void      focus_stack(const arg_t *arg);

static client_t *focus_top(monitor_t *m);

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

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

static int       handle_signal(int signo, void *data);

static void      master_bottom(monitor_t *m);

static void      master_left(monitor_t *m);

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

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

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

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

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

static void       view(const arg_t *arg);

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

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

static monitor_t *point_to_monitor(double x, double y);

static void       point_to_node(

static struct wlr_allocator  *alloc;

static struct wlr_compositor *compositor;

static struct wlr_session    *session;

static struct wlr_xdg_shell                             *xdg_shell;

static struct wlr_xdg_activation_v1                     *activation;

static struct wlr_xdg_decoration_manager_v1             *xdg_decoration_mgr;

static struct wl_list                                    clients; /* tiling order */

static struct wl_list                                    fstack;  /* focus order */

static struct wlr_idle_notifier_v1                      *idle_notifier;

static struct wl_listener new_output                       = { .notify = create_monitor };

static struct wl_listener new_xdg_toplevel                 = { .notify = create_notify };

static struct wl_listener new_text_input                   = { .notify = text_input_create_notify };

static struct wl_listener new_xdg_popup                    = { .notify = create_popup };

static struct wl_listener new_xdg_decoration               = { .notify = create_decoration };

static struct wl_listener new_layer_surface                = { .notify = create_layer_surface };

static struct wl_listener output_mgr_apply                 = { .notify = output_manager_apply };

static struct wl_listener output_mgr_test                  = { .notify = output_manager_test };

static struct wl_listener output_power_mgr_set_mode        = { .notify = power_manager_set_mode };

static struct wl_listener request_activate                 = { .notify = urgent };

    wl_list_remove(&new_shortcuts_inhibitor_listener.link);

    wl_list_remove(&new_output.link);

    wl_list_remove(&new_xdg_toplevel.link);

    wl_list_remove(&new_text_input.link);

    wl_list_remove(&new_xdg_decoration.link);

    wl_list_remove(&new_xdg_popup.link);

    wl_list_remove(&new_layer_surface.link);

    wl_list_remove(&ext_ftl_capture_request.link);

    wl_list_remove(&output_mgr_apply.link);

    wl_list_remove(&output_mgr_test.link);

    LISTEN(&toplevel->events.destroy, &c->destroy, destroy_notify);

    LISTEN(&toplevel->events.request_fullscreen, &c->fullscreen, fullscreen_notify);

    LISTEN(&toplevel->events.request_maximize, &c->maximize, maximize_notify);

    LISTEN(&toplevel->events.set_title, &c->set_title, update_title);

    LISTEN(&toplevel->events.set_app_id, &c->set_appid, update_app_id);

}

/* Attach a pointer device and apply its configured input settings. */

void create_pointer(struct wlr_pointer *pointer) {

    struct libinput_device *device;

    } else {

        wl_list_remove(&c->commit.link);

        wl_list_remove(&c->map.link);

        wl_list_remove(&c->unmap.link);

        wl_list_remove(&c->maximize.link);

        if (c->decoration) {

            wl_list_remove(&c->destroy_decoration.link);

            wl_list_remove(&c->set_decoration_mode.link);

            c->decoration = nullptr;

    layer_surface_t    *old_l = nullptr;

    if (locked)

        return;

    /* Raise the window when requested. */

    if (c && lift)

        wlr_scene_node_raise_to_top(&c->scene->node);

    if (c && client_surface(c) == old)

    while (c && (p = client_get_parent(c)) && p != c)

        c = p;

    return c;

}

/* Return whether two clients belong to one group. */

bool clients_related(client_t *a, client_t *b) {

    return a && b && client_main(a) == client_main(b);

}

    struct wl_list *node;

    if (!c || !c->mon)

        return nullptr;

        return p;

    for (node = c->link.prev; node != &c->link; node = node->prev) {

        if (node == &clients)

            continue;

        p = wl_container_of(node, p, link);

            return p;

    }

    return nullptr;

}

         node = arg->i > 0 ? node->next : node->prev) {

        if (node == &clients)

            continue;

        c = wl_container_of(node, c, link);

            bool fullscreen = sel->is_fullscreen;

            if (fullscreen)

                set_fullscreen(sel, 0);

            focus_client(c, 1);

    /* focus the main (first tiled) window; if it

     * already has focus, return focus to the previously focused window. */

    client_t *c, *sel = focus_top(selmon);

    wl_list_for_each(c, &clients, link) {

            if (c != sel) {

                focus_client(c, 1);

            } else {

                client_t *p;

                wl_list_for_each(p, &fstack, flink) {

                        focus_client(p, 1);

                        break;

                    }

                }

            }

/* Return the most recently focused visible window. */

client_t *focus_top(monitor_t *m) {

    client_t *c;

    wl_list_for_each(c, &fstack, flink) {

            return c;

    }

    return nullptr;

}

    xdg_shell = wlr_xdg_shell_create(dpy, 6);

    wl_signal_add(&xdg_shell->events.new_toplevel, &new_xdg_toplevel);

    wl_signal_add(&xdg_shell->events.new_popup, &new_xdg_popup);

    layer_shell = wlr_layer_shell_v1_create(dpy, 3);

    wl_signal_add(&layer_shell->events.new_surface, &new_layer_surface);

    idle_notifier = wlr_idle_notifier_v1_create(dpy);

        }

        if (c && c->type == LAYER_SHELL) {

            c = nullptr;

            l = pnode->data;

        }

    }

    if (psurface)

        *psurface = surface;

    if (pc)

        *pc = c;