static const int repeat_rate  = 40;

/* Wait this many milliseconds before a held key starts repeating. */

static const int repeat_delay = 180;

/* Pointer and touchpad behavior. Unsupported options are ignored per device. */

/* Tap the touchpad to produce a click. */

static const bool tap_to_click            = true;

/* Keep a tapped item grabbed while the finger moves. */

static const bool tap_and_drag            = true;

/* Keep dragging after the finger is briefly lifted and placed down again. */

#define MAX_COMMAND_SIZE        1024

#define MAX_COMMAND_ARGS        64

#define LISTEN_STATIC(E, H)     listen_static((E), (H))

/* Cursor interaction state. */

/* Master-stack configuration commands. */

enum {

    MASTER_SHRINK,

    MASTER_GROW,

);

static void              arrange_layers(monitor_t *m);

static void              autostart_exec(void);

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

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

static void              change_vt(const arg_t *arg);

static void              check_idle_inhibitor(struct wlr_surface *exclude);

static void              cleanup(void);

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

static void              cleanup_listeners(void);

static client_t         *grabc;

static int               grabcx, grabcy; /* Pointer position within the grabbed window. */

static int               grabx, graby;   /* Pointer position within the display layout. */

static uint32_t          grabedges;

static struct wlr_box    grabgeom;

static struct wlr_output_layout *output_layout;

static struct wlr_box            sgeom;

static struct wl_list            mons;

static struct wl_list            ws_managers;       /* workspace_manager_t.link */

        j++;

    }

    return count;

}

/* Function implementations. */

/* Clamp client geometry to the supplied bounds. */

void apply_bounds(client_t *c, struct wlr_box *bbox) {

    swm_box_apply_bounds((struct swm_box *)&c->geom, (const struct swm_box *)bbox, c->bw);

}

        }

        keyboard = wlr_seat_get_keyboard(seat);

        mods     = keyboard ? wlr_keyboard_get_modifiers(keyboard) : 0;

        for (b = buttons; b < END(buttons); b++) {

            if (CLEANMASK(mods) == CLEANMASK(b->mod) && event->button == b->button && b->func) {

                b->func(&b->arg);

                return;

            }

        break;

    case WL_POINTER_BUTTON_STATE_RELEASED:

        /* Releasing any button ends an interactive move or resize. */

        /* TODO: Restore the cursor requested by the window under the pointer. */

        if (!locked && cursor_mode != CURSOR_NORMAL && cursor_mode != CURSOR_PRESSED) {

            if (cursor_mode == CURSOR_RESIZE)

                client_set_resizing(grabc, 0);

            wlr_cursor_set_xcursor(cursor, cursor_mgr, "default");

            cursor_mode = CURSOR_NORMAL;

            /* Move the window to the workspace on its new display. The

            remember_client(grabc);

            grabc = nullptr;

            return;

        }

        cursor_mode = CURSOR_NORMAL;

        break;

    }

    /* Forward buttons that were not handled here to the application under the pointer. */

    wlr_seat_pointer_notify_button(seat, event->time_msec, event->button, event->state);

}

    keyboard_group_t *group = wl_container_of(listener, group, modifiers);

    wlr_seat_set_keyboard(seat, &group->wlr_group->keyboard);

    /* Forward the new modifier state to the focused application. */

    wlr_seat_keyboard_notify_modifiers(seat, &group->wlr_group->keyboard.modifiers);

}

/* Repeat the active shortcut at the keyboard's configured rate. */

int key_repeat(void *data) {

    keyboard_group_t *group = data;

        );

        if (constraint && constraint->surface != seat->pointer_state.focused_surface)

            constraint = nullptr;

            toplevel_from_wlr_surface(constraint->surface, &c, nullptr);

            if (c) {

                sx = cursor->x - c->geom.x - c->bw;

                sy = cursor->y - c->geom.y - c->bw;

            swm_box_resize((const struct swm_box *)&grabgeom, movedx, movedy, grabedges, grabc->bw);

        struct wlr_box geo  = { pure.x, pure.y, pure.width, pure.height };

        grabc->resize_edges = grabedges;

        resize(grabc, geo, 1);

        return;

    }

    /* Show the default cursor over the background and window borders. */

        wlr_cursor_set_xcursor(cursor, cursor_mgr, "default");

    pointer_focus(c, surface, sx, sy, time, refocus);

}

        event->unaccel_dy,

        1

    );

}

/* Forward touchpad swipe gestures to clients of the focused surface. */

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

    struct wlr_pointer_swipe_begin_event *event = data;

    wlr_idle_notifier_v1_notify_activity(idle_notifier, seat);

    /* An application supplied a new cursor image. */

    struct wlr_seat_pointer_request_set_cursor_event *event = data;

    /* Keep the move or resize cursor until the pointer grab ends. The

     * application will request its cursor again when the pointer re-enters. */

        return;

    /* This can be sent by any client, so we check to make sure this one

     * actually has pointer focus first. If so, 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

/* Use the named cursor shape requested by the application under the pointer. */

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

    struct wlr_cursor_shape_manager_v1_request_set_shape_event *event = data;

        return;

    /* This can be sent by any client, so we check to make sure this one

     * actually has pointer focus first. If so, we can tell the cursor to

     * use the provided cursor shape. */

    if (event->seat_client == seat->pointer_state.focused_client)

    visible[2] = true;

    assert(swm_workspace_next(0, 5, 1, false, visible, occupied) == 4);

    assert(swm_workspace_next(0, 5, 1, true, visible, occupied) == 1);

    assert(swm_stack_configure(&state, SWM_MASTER_SHRINK, SWM_MASTER_LEFT, &side));

    assert(state.msize == 15 && side == SWM_MASTER_LEFT);

    for (int command = SWM_MASTER_GROW; command <= SWM_FLIP_LAYOUT; command++)

        assert(swm_stack_configure(&state, command, SWM_MASTER_LEFT, &side));

    assert(!swm_stack_configure(&state, 99, SWM_MASTER_LEFT, &side));

}