2020-04-11 15:27:19 -07:00
|
|
|
/*
|
|
|
|
* See LICENSE file for copyright and license details.
|
|
|
|
*/
|
2020-05-02 13:21:36 -07:00
|
|
|
#define _POSIX_C_SOURCE 200809L
|
2020-04-11 15:27:19 -07:00
|
|
|
#include <getopt.h>
|
2022-04-05 20:07:20 -07:00
|
|
|
#include <libinput.h>
|
2020-05-02 13:24:18 -07:00
|
|
|
#include <linux/input-event-codes.h>
|
|
|
|
#include <signal.h>
|
2020-04-11 15:27:19 -07:00
|
|
|
#include <stdio.h>
|
2020-05-02 13:24:18 -07:00
|
|
|
#include <stdlib.h>
|
|
|
|
#include <sys/wait.h>
|
2020-04-11 15:27:19 -07:00
|
|
|
#include <time.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <wayland-server-core.h>
|
|
|
|
#include <wlr/backend.h>
|
2022-04-05 20:07:20 -07:00
|
|
|
#include <wlr/backend/libinput.h>
|
2021-12-16 09:50:11 -08:00
|
|
|
#include <wlr/render/allocator.h>
|
2020-04-11 15:27:19 -07:00
|
|
|
#include <wlr/render/wlr_renderer.h>
|
|
|
|
#include <wlr/types/wlr_compositor.h>
|
2020-05-02 13:24:18 -07:00
|
|
|
#include <wlr/types/wlr_cursor.h>
|
2020-12-10 03:56:35 -08:00
|
|
|
#include <wlr/types/wlr_data_control_v1.h>
|
2020-04-11 15:27:19 -07:00
|
|
|
#include <wlr/types/wlr_data_device.h>
|
2020-08-03 09:20:12 -07:00
|
|
|
#include <wlr/types/wlr_export_dmabuf_v1.h>
|
2020-08-22 09:09:38 -07:00
|
|
|
#include <wlr/types/wlr_gamma_control_v1.h>
|
2020-08-28 11:18:42 -07:00
|
|
|
#include <wlr/types/wlr_idle.h>
|
2021-07-12 17:58:55 -07:00
|
|
|
#include <wlr/types/wlr_idle_inhibit_v1.h>
|
2022-04-05 20:07:20 -07:00
|
|
|
#include <wlr/types/wlr_input_device.h>
|
|
|
|
#include <wlr/types/wlr_input_inhibitor.h>
|
2020-04-11 15:27:19 -07:00
|
|
|
#include <wlr/types/wlr_keyboard.h>
|
2022-04-05 20:07:20 -07:00
|
|
|
#include <wlr/types/wlr_layer_shell_v1.h>
|
2020-04-11 15:27:19 -07:00
|
|
|
#include <wlr/types/wlr_output.h>
|
|
|
|
#include <wlr/types/wlr_output_layout.h>
|
2020-10-17 11:11:31 -07:00
|
|
|
#include <wlr/types/wlr_output_management_v1.h>
|
2020-04-11 15:27:19 -07:00
|
|
|
#include <wlr/types/wlr_pointer.h>
|
2021-08-02 07:33:38 -07:00
|
|
|
#include <wlr/types/wlr_presentation_time.h>
|
2020-05-09 20:45:22 -07:00
|
|
|
#include <wlr/types/wlr_primary_selection.h>
|
|
|
|
#include <wlr/types/wlr_primary_selection_v1.h>
|
2021-09-05 14:07:28 -07:00
|
|
|
#include <wlr/types/wlr_scene.h>
|
2022-04-05 20:07:20 -07:00
|
|
|
#include <wlr/types/wlr_screencopy_v1.h>
|
2020-04-11 15:27:19 -07:00
|
|
|
#include <wlr/types/wlr_seat.h>
|
2022-04-05 20:07:20 -07:00
|
|
|
#include <wlr/types/wlr_server_decoration.h>
|
2020-08-03 09:20:12 -07:00
|
|
|
#include <wlr/types/wlr_viewporter.h>
|
2020-12-08 03:17:14 -08:00
|
|
|
#include <wlr/types/wlr_virtual_keyboard_v1.h>
|
2020-04-11 15:27:19 -07:00
|
|
|
#include <wlr/types/wlr_xcursor_manager.h>
|
2021-05-22 19:18:48 -07:00
|
|
|
#include <wlr/types/wlr_xdg_activation_v1.h>
|
2020-06-04 21:36:04 -07:00
|
|
|
#include <wlr/types/wlr_xdg_decoration_v1.h>
|
2020-05-09 21:01:30 -07:00
|
|
|
#include <wlr/types/wlr_xdg_output_v1.h>
|
2020-04-11 15:27:19 -07:00
|
|
|
#include <wlr/types/wlr_xdg_shell.h>
|
|
|
|
#include <wlr/util/log.h>
|
|
|
|
#include <xkbcommon/xkbcommon.h>
|
2020-08-10 10:50:56 -07:00
|
|
|
#ifdef XWAYLAND
|
|
|
|
#include <X11/Xlib.h>
|
|
|
|
#include <wlr/xwayland.h>
|
|
|
|
#endif
|
2020-04-11 15:27:19 -07:00
|
|
|
|
2022-03-15 14:52:26 -07:00
|
|
|
#include "util.h"
|
|
|
|
|
2020-04-22 06:25:43 -07:00
|
|
|
/* macros */
|
2020-04-23 18:14:11 -07:00
|
|
|
#define MAX(A, B) ((A) > (B) ? (A) : (B))
|
2020-04-22 06:25:43 -07:00
|
|
|
#define MIN(A, B) ((A) < (B) ? (A) : (B))
|
2020-04-11 17:46:51 -07:00
|
|
|
#define CLEANMASK(mask) (mask & ~WLR_MODIFIER_CAPS)
|
2021-11-04 07:19:13 -07:00
|
|
|
#define VISIBLEON(C, M) ((M) && (C)->mon == (M) && ((C)->tags & (M)->tagset[(M)->seltags]))
|
2020-04-11 17:41:32 -07:00
|
|
|
#define LENGTH(X) (sizeof X / sizeof X[0])
|
2020-05-02 22:41:37 -07:00
|
|
|
#define END(A) ((A) + LENGTH(A))
|
2020-04-23 17:53:49 -07:00
|
|
|
#define TAGMASK ((1 << LENGTH(tags)) - 1)
|
2020-12-27 10:28:37 -08:00
|
|
|
#define LISTEN(E, L, H) wl_signal_add((E), ((L)->notify = (H), (L)))
|
2020-04-11 17:41:32 -07:00
|
|
|
|
2020-04-21 12:00:18 -07:00
|
|
|
/* enums */
|
|
|
|
enum { CurNormal, CurMove, CurResize }; /* cursor */
|
2021-09-05 13:55:36 -07:00
|
|
|
enum { XDGShell, LayerShell, X11Managed, X11Unmanaged }; /* client types */
|
2022-03-23 12:50:08 -07:00
|
|
|
enum { LyrBg, LyrBottom, LyrTop, LyrOverlay, LyrTile, LyrFloat, LyrNoFocus, NUM_LAYERS }; /* scene layers */
|
2020-08-15 23:14:54 -07:00
|
|
|
#ifdef XWAYLAND
|
2020-07-24 21:40:04 -07:00
|
|
|
enum { NetWMWindowTypeDialog, NetWMWindowTypeSplash, NetWMWindowTypeToolbar,
|
|
|
|
NetWMWindowTypeUtility, NetLast }; /* EWMH atoms */
|
2020-08-10 10:50:56 -07:00
|
|
|
#endif
|
2020-04-11 15:27:19 -07:00
|
|
|
|
2020-04-21 12:47:59 -07:00
|
|
|
typedef union {
|
|
|
|
int i;
|
|
|
|
unsigned int ui;
|
|
|
|
float f;
|
|
|
|
const void *v;
|
|
|
|
} Arg;
|
2020-04-11 15:27:19 -07:00
|
|
|
|
2020-04-21 12:47:59 -07:00
|
|
|
typedef struct {
|
|
|
|
unsigned int mod;
|
|
|
|
unsigned int button;
|
|
|
|
void (*func)(const Arg *);
|
|
|
|
const Arg arg;
|
|
|
|
} Button;
|
|
|
|
|
2020-04-22 06:25:43 -07:00
|
|
|
typedef struct Monitor Monitor;
|
2020-04-21 12:47:59 -07:00
|
|
|
typedef struct {
|
2021-09-05 13:55:36 -07:00
|
|
|
/* Must be first */
|
|
|
|
unsigned int type; /* XDGShell or X11* */
|
2021-09-05 14:07:28 -07:00
|
|
|
struct wlr_scene_node *scene;
|
2022-02-15 15:38:56 -08:00
|
|
|
struct wlr_scene_rect *border[4]; /* top, bottom, left, right */
|
2021-09-05 14:07:28 -07:00
|
|
|
struct wlr_scene_node *scene_surface;
|
2020-04-11 15:27:19 -07:00
|
|
|
struct wl_list link;
|
2020-04-22 08:42:40 -07:00
|
|
|
struct wl_list flink;
|
2020-07-21 15:35:46 -07:00
|
|
|
union {
|
2020-08-02 07:16:07 -07:00
|
|
|
struct wlr_xdg_surface *xdg;
|
|
|
|
struct wlr_xwayland_surface *xwayland;
|
|
|
|
} surface;
|
2020-07-29 20:03:40 -07:00
|
|
|
struct wl_listener commit;
|
2020-04-11 15:27:19 -07:00
|
|
|
struct wl_listener map;
|
|
|
|
struct wl_listener unmap;
|
|
|
|
struct wl_listener destroy;
|
2021-04-15 11:05:05 -07:00
|
|
|
struct wl_listener set_title;
|
2020-09-04 03:44:09 -07:00
|
|
|
struct wl_listener fullscreen;
|
2022-03-10 12:48:14 -08:00
|
|
|
struct wlr_box geom, prev; /* layout-relative, includes border */
|
2020-04-22 06:25:43 -07:00
|
|
|
Monitor *mon;
|
2020-08-10 10:50:56 -07:00
|
|
|
#ifdef XWAYLAND
|
2020-12-24 22:33:55 -08:00
|
|
|
struct wl_listener activate;
|
|
|
|
struct wl_listener configure;
|
2022-05-17 12:38:18 -07:00
|
|
|
struct wl_listener set_hints;
|
2020-08-10 10:50:56 -07:00
|
|
|
#endif
|
2020-04-23 20:56:27 -07:00
|
|
|
int bw;
|
2020-04-23 17:53:49 -07:00
|
|
|
unsigned int tags;
|
2021-05-22 19:18:48 -07:00
|
|
|
int isfloating, isurgent;
|
2020-07-29 20:03:40 -07:00
|
|
|
uint32_t resize; /* configure serial of a pending resize */
|
2020-09-04 10:58:00 -07:00
|
|
|
int isfullscreen;
|
2020-04-21 12:47:59 -07:00
|
|
|
} Client;
|
2020-04-11 17:05:27 -07:00
|
|
|
|
2022-04-05 20:15:46 -07:00
|
|
|
typedef struct {
|
|
|
|
uint32_t singular_anchor;
|
|
|
|
uint32_t anchor_triplet;
|
|
|
|
int *positive_axis;
|
|
|
|
int *negative_axis;
|
|
|
|
int margin;
|
|
|
|
} Edge;
|
|
|
|
|
2020-04-11 17:05:27 -07:00
|
|
|
typedef struct {
|
|
|
|
uint32_t mod;
|
|
|
|
xkb_keysym_t keysym;
|
2020-04-21 12:08:33 -07:00
|
|
|
void (*func)(const Arg *);
|
2020-04-11 17:05:27 -07:00
|
|
|
const Arg arg;
|
|
|
|
} Key;
|
|
|
|
|
2020-04-11 19:29:27 -07:00
|
|
|
typedef struct {
|
2020-04-21 12:47:59 -07:00
|
|
|
struct wl_list link;
|
|
|
|
struct wlr_input_device *device;
|
|
|
|
|
|
|
|
struct wl_listener modifiers;
|
|
|
|
struct wl_listener key;
|
2020-07-23 15:13:42 -07:00
|
|
|
struct wl_listener destroy;
|
2020-04-21 12:47:59 -07:00
|
|
|
} Keyboard;
|
|
|
|
|
2020-08-23 22:04:34 -07:00
|
|
|
typedef struct {
|
2021-09-05 13:55:36 -07:00
|
|
|
/* Must be first */
|
|
|
|
unsigned int type; /* LayerShell */
|
2021-11-06 11:51:17 -07:00
|
|
|
int mapped;
|
2021-09-05 14:07:28 -07:00
|
|
|
struct wlr_scene_node *scene;
|
2020-08-23 22:04:34 -07:00
|
|
|
struct wl_list link;
|
2021-09-05 14:07:28 -07:00
|
|
|
struct wlr_layer_surface_v1 *layer_surface;
|
2020-08-23 22:04:34 -07:00
|
|
|
|
|
|
|
struct wl_listener destroy;
|
|
|
|
struct wl_listener map;
|
|
|
|
struct wl_listener unmap;
|
|
|
|
struct wl_listener surface_commit;
|
|
|
|
|
|
|
|
struct wlr_box geo;
|
2020-08-26 08:33:17 -07:00
|
|
|
} LayerSurface;
|
2020-08-23 22:04:34 -07:00
|
|
|
|
2020-04-21 12:47:59 -07:00
|
|
|
typedef struct {
|
2020-04-22 06:25:43 -07:00
|
|
|
const char *symbol;
|
|
|
|
void (*arrange)(Monitor *);
|
|
|
|
} Layout;
|
|
|
|
|
|
|
|
struct Monitor {
|
2020-04-21 12:47:59 -07:00
|
|
|
struct wl_list link;
|
|
|
|
struct wlr_output *wlr_output;
|
2021-09-05 20:35:07 -07:00
|
|
|
struct wlr_scene_output *scene_output;
|
2020-04-21 12:47:59 -07:00
|
|
|
struct wl_listener frame;
|
2020-07-23 15:03:13 -07:00
|
|
|
struct wl_listener destroy;
|
2020-04-26 10:41:33 -07:00
|
|
|
struct wlr_box m; /* monitor area, layout-relative */
|
|
|
|
struct wlr_box w; /* window area, layout-relative */
|
2022-03-11 16:52:22 -08:00
|
|
|
struct wl_list layers[4]; /* LayerSurface::link */
|
2020-04-22 06:25:43 -07:00
|
|
|
const Layout *lt[2];
|
2020-04-23 17:53:49 -07:00
|
|
|
unsigned int seltags;
|
2020-04-22 06:25:43 -07:00
|
|
|
unsigned int sellt;
|
2020-04-23 17:53:49 -07:00
|
|
|
unsigned int tagset[2];
|
2020-04-22 06:25:43 -07:00
|
|
|
double mfact;
|
|
|
|
int nmaster;
|
2022-02-28 14:46:24 -08:00
|
|
|
int un_map; /* If a map/unmap happened on this monitor, then this should be true */
|
2020-04-22 06:25:43 -07:00
|
|
|
};
|
2020-04-21 12:47:59 -07:00
|
|
|
|
2020-04-21 19:53:25 -07:00
|
|
|
typedef struct {
|
|
|
|
const char *name;
|
2020-04-22 06:25:43 -07:00
|
|
|
float mfact;
|
|
|
|
int nmaster;
|
2020-04-21 19:53:25 -07:00
|
|
|
float scale;
|
2020-04-22 06:25:43 -07:00
|
|
|
const Layout *lt;
|
2020-04-23 21:44:24 -07:00
|
|
|
enum wl_output_transform rr;
|
2020-04-21 19:53:25 -07:00
|
|
|
} MonitorRule;
|
|
|
|
|
2020-05-02 22:48:12 -07:00
|
|
|
typedef struct {
|
|
|
|
const char *id;
|
|
|
|
const char *title;
|
|
|
|
unsigned int tags;
|
|
|
|
int isfloating;
|
|
|
|
int monitor;
|
|
|
|
} Rule;
|
|
|
|
|
2020-04-21 11:48:27 -07:00
|
|
|
/* function declarations */
|
2020-04-26 12:08:47 -07:00
|
|
|
static void applybounds(Client *c, struct wlr_box *bbox);
|
2020-08-23 22:04:34 -07:00
|
|
|
static void applyexclusive(struct wlr_box *usable_area, uint32_t anchor,
|
|
|
|
int32_t exclusive, int32_t margin_top, int32_t margin_right,
|
|
|
|
int32_t margin_bottom, int32_t margin_left);
|
2020-05-02 22:48:12 -07:00
|
|
|
static void applyrules(Client *c);
|
2020-04-22 06:25:43 -07:00
|
|
|
static void arrange(Monitor *m);
|
2020-08-23 22:04:34 -07:00
|
|
|
static void arrangelayer(Monitor *m, struct wl_list *list,
|
2020-12-24 18:56:41 -08:00
|
|
|
struct wlr_box *usable_area, int exclusive);
|
2020-08-23 22:04:34 -07:00
|
|
|
static void arrangelayers(Monitor *m);
|
2020-04-21 11:48:27 -07:00
|
|
|
static void axisnotify(struct wl_listener *listener, void *data);
|
|
|
|
static void buttonpress(struct wl_listener *listener, void *data);
|
2020-04-23 21:14:15 -07:00
|
|
|
static void chvt(const Arg *arg);
|
2020-08-18 22:32:57 -07:00
|
|
|
static void cleanup(void);
|
2020-07-23 15:13:42 -07:00
|
|
|
static void cleanupkeyboard(struct wl_listener *listener, void *data);
|
2020-07-23 15:03:13 -07:00
|
|
|
static void cleanupmon(struct wl_listener *listener, void *data);
|
2020-10-31 05:19:31 -07:00
|
|
|
static void closemon(Monitor *m);
|
2020-08-26 10:41:45 -07:00
|
|
|
static void commitlayersurfacenotify(struct wl_listener *listener, void *data);
|
2020-08-15 07:47:22 -07:00
|
|
|
static void commitnotify(struct wl_listener *listener, void *data);
|
2021-07-12 17:58:55 -07:00
|
|
|
static void createidleinhibitor(struct wl_listener *listener, void *data);
|
2020-04-21 12:08:33 -07:00
|
|
|
static void createkeyboard(struct wlr_input_device *device);
|
2022-04-05 21:04:04 -07:00
|
|
|
static void createlayersurface(struct wl_listener *listener, void *data);
|
2020-04-21 12:47:59 -07:00
|
|
|
static void createmon(struct wl_listener *listener, void *data);
|
2020-07-22 17:54:12 -07:00
|
|
|
static void createnotify(struct wl_listener *listener, void *data);
|
2020-04-21 12:08:33 -07:00
|
|
|
static void createpointer(struct wlr_input_device *device);
|
2020-04-21 11:48:27 -07:00
|
|
|
static void cursorframe(struct wl_listener *listener, void *data);
|
2021-07-12 17:58:55 -07:00
|
|
|
static void destroyidleinhibitor(struct wl_listener *listener, void *data);
|
2020-08-26 10:41:45 -07:00
|
|
|
static void destroylayersurfacenotify(struct wl_listener *listener, void *data);
|
2020-04-21 11:48:27 -07:00
|
|
|
static void destroynotify(struct wl_listener *listener, void *data);
|
2021-01-06 14:19:44 -08:00
|
|
|
static Monitor *dirtomon(enum wlr_direction dir);
|
2022-03-21 15:03:52 -07:00
|
|
|
static void dragicondestroy(struct wl_listener *listener, void *data);
|
2020-12-24 18:56:41 -08:00
|
|
|
static void focusclient(Client *c, int lift);
|
2020-04-23 18:40:02 -07:00
|
|
|
static void focusmon(const Arg *arg);
|
2020-04-22 22:47:15 -07:00
|
|
|
static void focusstack(const Arg *arg);
|
2020-08-02 16:40:33 -07:00
|
|
|
static Client *focustop(Monitor *m);
|
2022-04-05 21:04:04 -07:00
|
|
|
static void fullscreennotify(struct wl_listener *listener, void *data);
|
2020-04-23 18:14:11 -07:00
|
|
|
static void incnmaster(const Arg *arg);
|
2020-04-21 11:48:27 -07:00
|
|
|
static void inputdevice(struct wl_listener *listener, void *data);
|
2020-05-02 12:32:23 -07:00
|
|
|
static int keybinding(uint32_t mods, xkb_keysym_t sym);
|
2020-04-21 11:48:27 -07:00
|
|
|
static void keypress(struct wl_listener *listener, void *data);
|
|
|
|
static void keypressmod(struct wl_listener *listener, void *data);
|
2020-07-23 11:30:25 -07:00
|
|
|
static void killclient(const Arg *arg);
|
2020-08-26 10:41:45 -07:00
|
|
|
static void maplayersurfacenotify(struct wl_listener *listener, void *data);
|
2020-12-19 09:51:22 -08:00
|
|
|
static void mapnotify(struct wl_listener *listener, void *data);
|
2020-08-03 10:44:47 -07:00
|
|
|
static void monocle(Monitor *m);
|
2020-04-21 11:48:27 -07:00
|
|
|
static void motionabsolute(struct wl_listener *listener, void *data);
|
2020-04-21 12:08:33 -07:00
|
|
|
static void motionnotify(uint32_t time);
|
2020-04-21 11:48:27 -07:00
|
|
|
static void motionrelative(struct wl_listener *listener, void *data);
|
2020-04-30 08:25:37 -07:00
|
|
|
static void moveresize(const Arg *arg);
|
2020-10-17 11:11:31 -07:00
|
|
|
static void outputmgrapply(struct wl_listener *listener, void *data);
|
2020-12-24 18:56:41 -08:00
|
|
|
static void outputmgrapplyortest(struct wlr_output_configuration_v1 *config, int test);
|
2020-10-17 11:11:31 -07:00
|
|
|
static void outputmgrtest(struct wl_listener *listener, void *data);
|
2020-04-23 22:12:11 -07:00
|
|
|
static void pointerfocus(Client *c, struct wlr_surface *surface,
|
2020-04-26 12:47:23 -07:00
|
|
|
double sx, double sy, uint32_t time);
|
2021-03-13 09:20:33 -08:00
|
|
|
static void printstatus(void);
|
2020-04-21 12:08:33 -07:00
|
|
|
static void quit(const Arg *arg);
|
2021-05-26 21:30:49 -07:00
|
|
|
static void quitsignal(int signo);
|
2020-04-21 12:47:59 -07:00
|
|
|
static void rendermon(struct wl_listener *listener, void *data);
|
2022-03-21 15:03:52 -07:00
|
|
|
static void requeststartdrag(struct wl_listener *listener, void *data);
|
2020-04-26 12:08:47 -07:00
|
|
|
static void resize(Client *c, int x, int y, int w, int h, int interact);
|
2020-04-21 16:57:04 -07:00
|
|
|
static void run(char *startup_cmd);
|
2020-04-22 22:27:53 -07:00
|
|
|
static Client *selclient(void);
|
2020-04-21 11:48:27 -07:00
|
|
|
static void setcursor(struct wl_listener *listener, void *data);
|
2020-04-26 19:55:49 -07:00
|
|
|
static void setfloating(Client *c, int floating);
|
2020-09-05 02:22:24 -07:00
|
|
|
static void setfullscreen(Client *c, int fullscreen);
|
2020-04-22 09:20:08 -07:00
|
|
|
static void setlayout(const Arg *arg);
|
2020-04-23 18:14:11 -07:00
|
|
|
static void setmfact(const Arg *arg);
|
2020-05-02 22:44:16 -07:00
|
|
|
static void setmon(Client *c, Monitor *m, unsigned int newtags);
|
2022-04-05 21:04:04 -07:00
|
|
|
static void setpsel(struct wl_listener *listener, void *data);
|
|
|
|
static void setsel(struct wl_listener *listener, void *data);
|
2020-04-21 16:57:04 -07:00
|
|
|
static void setup(void);
|
2021-03-13 08:42:33 -08:00
|
|
|
static void sigchld(int unused);
|
2020-04-21 12:08:33 -07:00
|
|
|
static void spawn(const Arg *arg);
|
2022-03-21 15:03:52 -07:00
|
|
|
static void startdrag(struct wl_listener *listener, void *data);
|
2020-04-23 17:53:49 -07:00
|
|
|
static void tag(const Arg *arg);
|
2020-04-23 18:40:02 -07:00
|
|
|
static void tagmon(const Arg *arg);
|
2020-04-22 06:25:43 -07:00
|
|
|
static void tile(Monitor *m);
|
2020-04-23 17:23:57 -07:00
|
|
|
static void togglefloating(const Arg *arg);
|
2020-09-05 02:22:24 -07:00
|
|
|
static void togglefullscreen(const Arg *arg);
|
2020-04-23 18:02:17 -07:00
|
|
|
static void toggletag(const Arg *arg);
|
|
|
|
static void toggleview(const Arg *arg);
|
2020-08-26 10:41:45 -07:00
|
|
|
static void unmaplayersurface(LayerSurface *layersurface);
|
|
|
|
static void unmaplayersurfacenotify(struct wl_listener *listener, void *data);
|
2020-04-21 11:48:27 -07:00
|
|
|
static void unmapnotify(struct wl_listener *listener, void *data);
|
2021-01-18 12:34:05 -08:00
|
|
|
static void updatemons(struct wl_listener *listener, void *data);
|
2021-04-15 11:05:05 -07:00
|
|
|
static void updatetitle(struct wl_listener *listener, void *data);
|
2021-05-22 19:18:48 -07:00
|
|
|
static void urgent(struct wl_listener *listener, void *data);
|
2020-04-23 17:53:49 -07:00
|
|
|
static void view(const Arg *arg);
|
2020-12-08 03:17:14 -08:00
|
|
|
static void virtualkeyboard(struct wl_listener *listener, void *data);
|
2022-04-05 21:04:04 -07:00
|
|
|
static Monitor *xytomon(double x, double y);
|
2021-09-05 14:07:28 -07:00
|
|
|
static struct wlr_scene_node *xytonode(double x, double y, struct wlr_surface **psurface,
|
|
|
|
Client **pc, LayerSurface **pl, double *nx, double *ny);
|
2020-07-24 08:12:41 -07:00
|
|
|
static void zoom(const Arg *arg);
|
2020-04-11 17:05:27 -07:00
|
|
|
|
2020-04-21 12:08:33 -07:00
|
|
|
/* variables */
|
2020-05-02 22:48:12 -07:00
|
|
|
static const char broken[] = "broken";
|
2020-04-23 19:16:01 -07:00
|
|
|
static struct wl_display *dpy;
|
2020-04-21 12:15:19 -07:00
|
|
|
static struct wlr_backend *backend;
|
2021-09-05 14:07:28 -07:00
|
|
|
static struct wlr_scene *scene;
|
|
|
|
static struct wlr_scene_node *layers[NUM_LAYERS];
|
2020-04-23 19:16:01 -07:00
|
|
|
static struct wlr_renderer *drw;
|
2021-12-16 09:50:11 -08:00
|
|
|
static struct wlr_allocator *alloc;
|
2020-07-21 15:35:46 -07:00
|
|
|
static struct wlr_compositor *compositor;
|
2020-04-21 12:15:19 -07:00
|
|
|
|
|
|
|
static struct wlr_xdg_shell *xdg_shell;
|
2021-05-22 19:18:48 -07:00
|
|
|
static struct wlr_xdg_activation_v1 *activation;
|
2020-04-22 08:42:40 -07:00
|
|
|
static struct wl_list clients; /* tiling order */
|
|
|
|
static struct wl_list fstack; /* focus order */
|
2020-08-28 11:18:42 -07:00
|
|
|
static struct wlr_idle *idle;
|
2021-07-12 17:58:55 -07:00
|
|
|
static struct wlr_idle_inhibit_manager_v1 *idle_inhibit_mgr;
|
2021-07-03 13:48:40 -07:00
|
|
|
static struct wlr_input_inhibit_manager *input_inhibit_mgr;
|
2020-08-23 22:04:34 -07:00
|
|
|
static struct wlr_layer_shell_v1 *layer_shell;
|
2020-10-17 11:11:31 -07:00
|
|
|
static struct wlr_output_manager_v1 *output_mgr;
|
2020-12-08 03:17:14 -08:00
|
|
|
static struct wlr_virtual_keyboard_manager_v1 *virtual_keyboard_mgr;
|
2020-04-21 12:15:19 -07:00
|
|
|
|
|
|
|
static struct wlr_cursor *cursor;
|
|
|
|
static struct wlr_xcursor_manager *cursor_mgr;
|
|
|
|
|
|
|
|
static struct wlr_seat *seat;
|
|
|
|
static struct wl_list keyboards;
|
|
|
|
static unsigned int cursor_mode;
|
2020-04-22 20:37:11 -07:00
|
|
|
static Client *grabc;
|
2020-04-30 09:33:32 -07:00
|
|
|
static int grabcx, grabcy; /* client-relative */
|
2020-04-21 12:15:19 -07:00
|
|
|
|
|
|
|
static struct wlr_output_layout *output_layout;
|
2020-04-26 12:08:47 -07:00
|
|
|
static struct wlr_box sgeom;
|
2020-04-21 12:47:59 -07:00
|
|
|
static struct wl_list mons;
|
2020-04-22 06:25:43 -07:00
|
|
|
static Monitor *selmon;
|
2020-04-21 12:08:33 -07:00
|
|
|
|
2020-05-09 08:05:34 -07:00
|
|
|
/* global event handlers */
|
|
|
|
static struct wl_listener cursor_axis = {.notify = axisnotify};
|
|
|
|
static struct wl_listener cursor_button = {.notify = buttonpress};
|
|
|
|
static struct wl_listener cursor_frame = {.notify = cursorframe};
|
|
|
|
static struct wl_listener cursor_motion = {.notify = motionrelative};
|
|
|
|
static struct wl_listener cursor_motion_absolute = {.notify = motionabsolute};
|
2021-07-12 17:58:55 -07:00
|
|
|
static struct wl_listener idle_inhibitor_create = {.notify = createidleinhibitor};
|
|
|
|
static struct wl_listener idle_inhibitor_destroy = {.notify = destroyidleinhibitor};
|
2021-01-18 12:34:05 -08:00
|
|
|
static struct wl_listener layout_change = {.notify = updatemons};
|
2020-05-09 08:05:34 -07:00
|
|
|
static struct wl_listener new_input = {.notify = inputdevice};
|
2020-12-08 03:17:14 -08:00
|
|
|
static struct wl_listener new_virtual_keyboard = {.notify = virtualkeyboard};
|
2020-05-09 08:05:34 -07:00
|
|
|
static struct wl_listener new_output = {.notify = createmon};
|
2020-07-22 17:54:12 -07:00
|
|
|
static struct wl_listener new_xdg_surface = {.notify = createnotify};
|
2020-08-26 10:41:45 -07:00
|
|
|
static struct wl_listener new_layer_shell_surface = {.notify = createlayersurface};
|
2020-10-17 11:11:31 -07:00
|
|
|
static struct wl_listener output_mgr_apply = {.notify = outputmgrapply};
|
|
|
|
static struct wl_listener output_mgr_test = {.notify = outputmgrtest};
|
2021-05-22 19:18:48 -07:00
|
|
|
static struct wl_listener request_activate = {.notify = urgent};
|
2020-05-09 08:05:34 -07:00
|
|
|
static struct wl_listener request_cursor = {.notify = setcursor};
|
2020-05-09 20:45:22 -07:00
|
|
|
static struct wl_listener request_set_psel = {.notify = setpsel};
|
2020-05-09 20:30:20 -07:00
|
|
|
static struct wl_listener request_set_sel = {.notify = setsel};
|
2022-03-21 15:03:52 -07:00
|
|
|
static struct wl_listener request_start_drag = {.notify = requeststartdrag};
|
|
|
|
static struct wl_listener start_drag = {.notify = startdrag};
|
|
|
|
static struct wl_listener drag_icon_destroy = {.notify = dragicondestroy};
|
2020-08-10 10:50:56 -07:00
|
|
|
|
|
|
|
#ifdef XWAYLAND
|
|
|
|
static void activatex11(struct wl_listener *listener, void *data);
|
2020-12-08 06:10:41 -08:00
|
|
|
static void configurex11(struct wl_listener *listener, void *data);
|
2020-08-10 10:50:56 -07:00
|
|
|
static void createnotifyx11(struct wl_listener *listener, void *data);
|
|
|
|
static Atom getatom(xcb_connection_t *xc, const char *name);
|
2022-05-17 12:38:18 -07:00
|
|
|
static void sethints(struct wl_listener *listener, void *data);
|
2020-08-10 10:50:56 -07:00
|
|
|
static void xwaylandready(struct wl_listener *listener, void *data);
|
|
|
|
static struct wl_listener new_xwayland_surface = {.notify = createnotifyx11};
|
2020-07-24 21:40:04 -07:00
|
|
|
static struct wl_listener xwayland_ready = {.notify = xwaylandready};
|
2020-08-10 10:50:56 -07:00
|
|
|
static struct wlr_xwayland *xwayland;
|
|
|
|
static Atom netatom[NetLast];
|
|
|
|
#endif
|
2020-05-09 08:05:34 -07:00
|
|
|
|
2020-04-23 20:20:44 -07:00
|
|
|
/* configuration, allows nested code to access above variables */
|
2020-04-11 15:27:19 -07:00
|
|
|
#include "config.h"
|
|
|
|
|
2020-12-24 22:33:55 -08:00
|
|
|
/* attempt to encapsulate suck into one file */
|
|
|
|
#include "client.h"
|
|
|
|
|
2020-07-31 07:57:59 -07:00
|
|
|
/* compile-time check if all tags fit into an unsigned int bit array. */
|
|
|
|
struct NumTags { char limitexceeded[LENGTH(tags) > 31 ? -1 : 1]; };
|
|
|
|
|
2020-05-02 22:48:12 -07:00
|
|
|
/* function implementations */
|
2020-04-26 12:08:47 -07:00
|
|
|
void
|
|
|
|
applybounds(Client *c, struct wlr_box *bbox)
|
|
|
|
{
|
|
|
|
/* set minimum possible */
|
2020-04-26 20:12:08 -07:00
|
|
|
c->geom.width = MAX(1, c->geom.width);
|
|
|
|
c->geom.height = MAX(1, c->geom.height);
|
|
|
|
|
|
|
|
if (c->geom.x >= bbox->x + bbox->width)
|
|
|
|
c->geom.x = bbox->x + bbox->width - c->geom.width;
|
|
|
|
if (c->geom.y >= bbox->y + bbox->height)
|
|
|
|
c->geom.y = bbox->y + bbox->height - c->geom.height;
|
|
|
|
if (c->geom.x + c->geom.width + 2 * c->bw <= bbox->x)
|
|
|
|
c->geom.x = bbox->x;
|
|
|
|
if (c->geom.y + c->geom.height + 2 * c->bw <= bbox->y)
|
|
|
|
c->geom.y = bbox->y;
|
2020-04-26 12:08:47 -07:00
|
|
|
}
|
|
|
|
|
2020-08-23 22:04:34 -07:00
|
|
|
void
|
|
|
|
applyexclusive(struct wlr_box *usable_area,
|
|
|
|
uint32_t anchor, int32_t exclusive,
|
|
|
|
int32_t margin_top, int32_t margin_right,
|
|
|
|
int32_t margin_bottom, int32_t margin_left) {
|
2020-12-24 19:26:44 -08:00
|
|
|
Edge edges[] = {
|
2022-03-11 16:52:22 -08:00
|
|
|
{ /* Top */
|
2020-12-24 19:26:44 -08:00
|
|
|
.singular_anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP,
|
|
|
|
.anchor_triplet = ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT |
|
|
|
|
ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT |
|
|
|
|
ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP,
|
|
|
|
.positive_axis = &usable_area->y,
|
|
|
|
.negative_axis = &usable_area->height,
|
|
|
|
.margin = margin_top,
|
|
|
|
},
|
2022-03-11 16:52:22 -08:00
|
|
|
{ /* Bottom */
|
2020-12-24 19:26:44 -08:00
|
|
|
.singular_anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM,
|
|
|
|
.anchor_triplet = ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT |
|
|
|
|
ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT |
|
|
|
|
ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM,
|
|
|
|
.positive_axis = NULL,
|
|
|
|
.negative_axis = &usable_area->height,
|
|
|
|
.margin = margin_bottom,
|
|
|
|
},
|
2022-03-11 16:52:22 -08:00
|
|
|
{ /* Left */
|
2020-12-24 19:26:44 -08:00
|
|
|
.singular_anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT,
|
|
|
|
.anchor_triplet = ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT |
|
|
|
|
ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP |
|
|
|
|
ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM,
|
|
|
|
.positive_axis = &usable_area->x,
|
|
|
|
.negative_axis = &usable_area->width,
|
|
|
|
.margin = margin_left,
|
|
|
|
},
|
2022-03-11 16:52:22 -08:00
|
|
|
{ /* Right */
|
2020-12-24 19:26:44 -08:00
|
|
|
.singular_anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT,
|
|
|
|
.anchor_triplet = ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT |
|
|
|
|
ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP |
|
|
|
|
ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM,
|
|
|
|
.positive_axis = NULL,
|
|
|
|
.negative_axis = &usable_area->width,
|
|
|
|
.margin = margin_right,
|
|
|
|
}
|
|
|
|
};
|
2021-01-18 12:14:19 -08:00
|
|
|
for (size_t i = 0; i < LENGTH(edges); i++) {
|
2020-08-26 10:16:13 -07:00
|
|
|
if ((anchor == edges[i].singular_anchor || anchor == edges[i].anchor_triplet)
|
2020-08-23 22:04:34 -07:00
|
|
|
&& exclusive + edges[i].margin > 0) {
|
|
|
|
if (edges[i].positive_axis)
|
|
|
|
*edges[i].positive_axis += exclusive + edges[i].margin;
|
|
|
|
if (edges[i].negative_axis)
|
|
|
|
*edges[i].negative_axis -= exclusive + edges[i].margin;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-02 22:48:12 -07:00
|
|
|
void
|
|
|
|
applyrules(Client *c)
|
|
|
|
{
|
|
|
|
/* rule matching */
|
2020-12-19 10:50:01 -08:00
|
|
|
const char *appid, *title;
|
2020-12-24 19:21:00 -08:00
|
|
|
unsigned int i, newtags = 0;
|
|
|
|
const Rule *r;
|
|
|
|
Monitor *mon = selmon, *m;
|
2020-12-24 22:33:55 -08:00
|
|
|
|
|
|
|
c->isfloating = client_is_float_type(c);
|
|
|
|
if (!(appid = client_get_appid(c)))
|
2020-07-21 15:47:30 -07:00
|
|
|
appid = broken;
|
2020-12-24 22:33:55 -08:00
|
|
|
if (!(title = client_get_title(c)))
|
2020-07-21 15:47:30 -07:00
|
|
|
title = broken;
|
2020-05-02 22:48:12 -07:00
|
|
|
|
|
|
|
for (r = rules; r < END(rules); r++) {
|
|
|
|
if ((!r->title || strstr(title, r->title))
|
2020-07-30 19:55:49 -07:00
|
|
|
&& (!r->id || strstr(appid, r->id))) {
|
2020-05-02 22:48:12 -07:00
|
|
|
c->isfloating = r->isfloating;
|
|
|
|
newtags |= r->tags;
|
|
|
|
i = 0;
|
|
|
|
wl_list_for_each(m, &mons, link)
|
|
|
|
if (r->monitor == i++)
|
|
|
|
mon = m;
|
|
|
|
}
|
|
|
|
}
|
2021-09-05 14:07:28 -07:00
|
|
|
wlr_scene_node_reparent(c->scene, layers[c->isfloating ? LyrFloat : LyrTile]);
|
2020-05-02 22:48:12 -07:00
|
|
|
setmon(c, mon, newtags);
|
|
|
|
}
|
|
|
|
|
2020-04-22 06:25:43 -07:00
|
|
|
void
|
|
|
|
arrange(Monitor *m)
|
|
|
|
{
|
2021-09-05 14:07:28 -07:00
|
|
|
Client *c;
|
|
|
|
wl_list_for_each(c, &clients, link)
|
|
|
|
wlr_scene_node_set_enabled(c->scene, VISIBLEON(c, c->mon));
|
|
|
|
|
2020-04-22 06:25:43 -07:00
|
|
|
if (m->lt[m->sellt]->arrange)
|
|
|
|
m->lt[m->sellt]->arrange(m);
|
2020-12-20 07:07:12 -08:00
|
|
|
/* TODO recheck pointer focus here... or in resize()? */
|
2020-04-22 06:25:43 -07:00
|
|
|
}
|
|
|
|
|
2020-08-23 22:04:34 -07:00
|
|
|
void
|
2020-12-24 18:56:41 -08:00
|
|
|
arrangelayer(Monitor *m, struct wl_list *list, struct wlr_box *usable_area, int exclusive)
|
2020-08-23 22:04:34 -07:00
|
|
|
{
|
2020-08-26 08:33:17 -07:00
|
|
|
LayerSurface *layersurface;
|
2020-09-11 04:09:18 -07:00
|
|
|
struct wlr_box full_area = m->m;
|
2020-08-23 22:04:34 -07:00
|
|
|
|
2020-08-26 08:33:17 -07:00
|
|
|
wl_list_for_each(layersurface, list, link) {
|
|
|
|
struct wlr_layer_surface_v1 *wlr_layer_surface = layersurface->layer_surface;
|
|
|
|
struct wlr_layer_surface_v1_state *state = &wlr_layer_surface->current;
|
2020-12-24 19:21:00 -08:00
|
|
|
struct wlr_box bounds;
|
2020-08-23 22:04:34 -07:00
|
|
|
struct wlr_box box = {
|
|
|
|
.width = state->desired_width,
|
|
|
|
.height = state->desired_height
|
|
|
|
};
|
2020-12-24 19:21:00 -08:00
|
|
|
const uint32_t both_horiz = ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT
|
|
|
|
| ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT;
|
|
|
|
const uint32_t both_vert = ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP
|
|
|
|
| ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM;
|
2020-08-23 22:04:34 -07:00
|
|
|
|
|
|
|
if (exclusive != (state->exclusive_zone > 0))
|
|
|
|
continue;
|
|
|
|
|
2020-12-24 19:21:00 -08:00
|
|
|
bounds = state->exclusive_zone == -1 ? full_area : *usable_area;
|
2020-08-23 22:04:34 -07:00
|
|
|
|
2022-03-11 16:52:22 -08:00
|
|
|
/* Horizontal axis */
|
2020-08-23 22:04:34 -07:00
|
|
|
if ((state->anchor & both_horiz) && box.width == 0) {
|
|
|
|
box.x = bounds.x;
|
|
|
|
box.width = bounds.width;
|
|
|
|
} else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT)) {
|
|
|
|
box.x = bounds.x;
|
|
|
|
} else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT)) {
|
|
|
|
box.x = bounds.x + (bounds.width - box.width);
|
|
|
|
} else {
|
|
|
|
box.x = bounds.x + ((bounds.width / 2) - (box.width / 2));
|
|
|
|
}
|
2022-03-11 16:52:22 -08:00
|
|
|
/* Vertical axis */
|
2020-08-23 22:04:34 -07:00
|
|
|
if ((state->anchor & both_vert) && box.height == 0) {
|
|
|
|
box.y = bounds.y;
|
|
|
|
box.height = bounds.height;
|
|
|
|
} else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP)) {
|
|
|
|
box.y = bounds.y;
|
|
|
|
} else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM)) {
|
|
|
|
box.y = bounds.y + (bounds.height - box.height);
|
|
|
|
} else {
|
|
|
|
box.y = bounds.y + ((bounds.height / 2) - (box.height / 2));
|
|
|
|
}
|
2022-03-11 16:52:22 -08:00
|
|
|
/* Margin */
|
2020-08-23 22:04:34 -07:00
|
|
|
if ((state->anchor & both_horiz) == both_horiz) {
|
|
|
|
box.x += state->margin.left;
|
|
|
|
box.width -= state->margin.left + state->margin.right;
|
|
|
|
} else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT)) {
|
|
|
|
box.x += state->margin.left;
|
|
|
|
} else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT)) {
|
|
|
|
box.x -= state->margin.right;
|
|
|
|
}
|
|
|
|
if ((state->anchor & both_vert) == both_vert) {
|
|
|
|
box.y += state->margin.top;
|
|
|
|
box.height -= state->margin.top + state->margin.bottom;
|
|
|
|
} else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP)) {
|
|
|
|
box.y += state->margin.top;
|
|
|
|
} else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM)) {
|
|
|
|
box.y -= state->margin.bottom;
|
|
|
|
}
|
|
|
|
if (box.width < 0 || box.height < 0) {
|
2021-08-20 16:53:38 -07:00
|
|
|
wlr_layer_surface_v1_destroy(wlr_layer_surface);
|
2020-08-23 22:04:34 -07:00
|
|
|
continue;
|
|
|
|
}
|
2020-08-26 08:33:17 -07:00
|
|
|
layersurface->geo = box;
|
2020-08-23 22:04:34 -07:00
|
|
|
|
2020-12-24 19:26:44 -08:00
|
|
|
if (state->exclusive_zone > 0)
|
|
|
|
applyexclusive(usable_area, state->anchor, state->exclusive_zone,
|
|
|
|
state->margin.top, state->margin.right,
|
|
|
|
state->margin.bottom, state->margin.left);
|
2021-09-05 14:07:28 -07:00
|
|
|
wlr_scene_node_set_position(layersurface->scene, box.x, box.y);
|
2020-08-26 08:33:17 -07:00
|
|
|
wlr_layer_surface_v1_configure(wlr_layer_surface, box.width, box.height);
|
2020-08-23 22:04:34 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
arrangelayers(Monitor *m)
|
|
|
|
{
|
2022-01-25 22:54:00 -08:00
|
|
|
int i;
|
2020-09-11 04:09:18 -07:00
|
|
|
struct wlr_box usable_area = m->m;
|
2020-12-24 19:21:00 -08:00
|
|
|
uint32_t layers_above_shell[] = {
|
|
|
|
ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY,
|
|
|
|
ZWLR_LAYER_SHELL_V1_LAYER_TOP,
|
|
|
|
};
|
|
|
|
LayerSurface *layersurface;
|
|
|
|
struct wlr_keyboard *kb = wlr_seat_get_keyboard(seat);
|
2020-08-23 22:04:34 -07:00
|
|
|
|
2022-01-25 22:54:00 -08:00
|
|
|
/* Arrange exclusive surfaces from top->bottom */
|
|
|
|
for (i = 3; i >= 0; i--)
|
|
|
|
arrangelayer(m, &m->layers[i], &usable_area, 1);
|
2020-08-23 22:04:34 -07:00
|
|
|
|
|
|
|
if (memcmp(&usable_area, &m->w, sizeof(struct wlr_box))) {
|
2020-09-09 21:01:18 -07:00
|
|
|
m->w = usable_area;
|
2020-08-23 22:04:34 -07:00
|
|
|
arrange(m);
|
|
|
|
}
|
|
|
|
|
2022-01-25 22:54:00 -08:00
|
|
|
/* Arrange non-exlusive surfaces from top->bottom */
|
|
|
|
for (i = 3; i >= 0; i--)
|
|
|
|
arrangelayer(m, &m->layers[i], &usable_area, 0);
|
2020-08-23 22:04:34 -07:00
|
|
|
|
2022-03-11 16:52:22 -08:00
|
|
|
/* Find topmost keyboard interactive layer, if such a layer exists */
|
2021-01-18 12:14:19 -08:00
|
|
|
for (size_t i = 0; i < LENGTH(layers_above_shell); i++) {
|
2020-08-26 08:33:17 -07:00
|
|
|
wl_list_for_each_reverse(layersurface,
|
2020-08-23 22:04:34 -07:00
|
|
|
&m->layers[layers_above_shell[i]], link) {
|
2020-08-26 08:33:17 -07:00
|
|
|
if (layersurface->layer_surface->current.keyboard_interactive &&
|
|
|
|
layersurface->layer_surface->mapped) {
|
2022-03-11 16:52:22 -08:00
|
|
|
/* Deactivate the focused client. */
|
2020-12-24 18:56:41 -08:00
|
|
|
focusclient(NULL, 0);
|
2022-05-10 09:42:40 -07:00
|
|
|
if (kb)
|
2022-04-05 23:22:15 -07:00
|
|
|
wlr_seat_keyboard_notify_enter(seat, layersurface->layer_surface->surface,
|
|
|
|
kb->keycodes, kb->num_keycodes, &kb->modifiers);
|
2022-05-10 09:42:40 -07:00
|
|
|
else
|
2022-04-05 23:22:15 -07:00
|
|
|
wlr_seat_keyboard_notify_enter(seat, layersurface->layer_surface->surface, NULL, 0, NULL);
|
2020-09-04 21:58:54 -07:00
|
|
|
return;
|
2020-08-23 22:04:34 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-04-21 11:48:27 -07:00
|
|
|
void
|
|
|
|
axisnotify(struct wl_listener *listener, void *data)
|
2020-04-21 11:18:38 -07:00
|
|
|
{
|
2020-04-21 11:48:27 -07:00
|
|
|
/* This event is forwarded by the cursor when a pointer emits an axis event,
|
|
|
|
* for example when you move the scroll wheel. */
|
|
|
|
struct wlr_event_pointer_axis *event = data;
|
2020-08-28 11:18:42 -07:00
|
|
|
wlr_idle_notify_activity(idle, seat);
|
2020-04-21 11:48:27 -07:00
|
|
|
/* Notify the client with pointer focus of the axis event. */
|
2020-04-21 12:15:19 -07:00
|
|
|
wlr_seat_pointer_notify_axis(seat,
|
2020-04-21 11:48:27 -07:00
|
|
|
event->time_msec, event->orientation, event->delta,
|
|
|
|
event->delta_discrete, event->source);
|
2020-04-11 15:27:19 -07:00
|
|
|
}
|
|
|
|
|
2020-04-21 11:48:27 -07:00
|
|
|
void
|
|
|
|
buttonpress(struct wl_listener *listener, void *data)
|
2020-04-21 11:18:38 -07:00
|
|
|
{
|
2020-04-21 11:48:27 -07:00
|
|
|
struct wlr_event_pointer_button *event = data;
|
2020-12-24 19:21:00 -08:00
|
|
|
struct wlr_keyboard *keyboard;
|
|
|
|
uint32_t mods;
|
|
|
|
Client *c;
|
|
|
|
const Button *b;
|
2020-05-02 13:21:36 -07:00
|
|
|
|
2020-08-28 11:18:42 -07:00
|
|
|
wlr_idle_notify_activity(idle, seat);
|
2020-05-02 13:21:36 -07:00
|
|
|
|
2020-04-26 18:12:54 -07:00
|
|
|
switch (event->state) {
|
2022-03-11 21:02:37 -08:00
|
|
|
case WLR_BUTTON_PRESSED:
|
2020-04-26 18:12:54 -07:00
|
|
|
/* Change focus if the button was _pressed_ over a client */
|
2021-09-05 14:07:28 -07:00
|
|
|
xytonode(cursor->x, cursor->y, NULL, &c, NULL, NULL, NULL);
|
2022-01-31 12:02:59 -08:00
|
|
|
/* Don't focus unmanaged clients */
|
|
|
|
if (c && !client_is_unmanaged(c))
|
2020-12-24 18:56:41 -08:00
|
|
|
focusclient(c, 1);
|
2020-04-26 18:12:54 -07:00
|
|
|
|
2020-12-24 19:21:00 -08:00
|
|
|
keyboard = wlr_seat_get_keyboard(seat);
|
2022-04-05 23:22:15 -07:00
|
|
|
mods = keyboard ? wlr_keyboard_get_modifiers(keyboard) : 0;
|
2020-05-02 22:41:37 -07:00
|
|
|
for (b = buttons; b < END(buttons); b++) {
|
|
|
|
if (CLEANMASK(mods) == CLEANMASK(b->mod) &&
|
|
|
|
event->button == b->button && b->func) {
|
|
|
|
b->func(&b->arg);
|
2020-04-26 18:12:54 -07:00
|
|
|
return;
|
|
|
|
}
|
2020-05-02 13:21:36 -07:00
|
|
|
}
|
2020-04-26 18:12:54 -07:00
|
|
|
break;
|
|
|
|
case WLR_BUTTON_RELEASED:
|
2020-04-21 11:48:27 -07:00
|
|
|
/* If you released any buttons, we exit interactive move/resize mode. */
|
2020-12-20 07:07:12 -08:00
|
|
|
/* TODO should reset to the pointer focus's current setcursor */
|
2020-04-26 18:12:54 -07:00
|
|
|
if (cursor_mode != CurNormal) {
|
2022-03-11 21:02:37 -08:00
|
|
|
wlr_xcursor_manager_set_cursor_image(cursor_mgr, "left_ptr", cursor);
|
2020-04-26 18:12:54 -07:00
|
|
|
cursor_mode = CurNormal;
|
2020-04-26 19:35:21 -07:00
|
|
|
/* Drop the window off on its new monitor */
|
|
|
|
selmon = xytomon(cursor->x, cursor->y);
|
2020-05-02 22:44:16 -07:00
|
|
|
setmon(grabc, selmon, 0);
|
2020-04-26 18:12:54 -07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
break;
|
2020-04-11 15:27:19 -07:00
|
|
|
}
|
2020-04-26 18:12:54 -07:00
|
|
|
/* If the event wasn't handled by the compositor, notify the client with
|
|
|
|
* pointer focus that a button press has occurred */
|
|
|
|
wlr_seat_pointer_notify_button(seat,
|
|
|
|
event->time_msec, event->button, event->state);
|
2020-04-11 15:27:19 -07:00
|
|
|
}
|
|
|
|
|
2020-05-03 11:18:53 -07:00
|
|
|
void
|
|
|
|
chvt(const Arg *arg)
|
|
|
|
{
|
2020-08-16 09:32:45 -07:00
|
|
|
wlr_session_change_vt(wlr_backend_get_session(backend), arg->ui);
|
2020-05-03 11:18:53 -07:00
|
|
|
}
|
|
|
|
|
2020-08-18 22:32:57 -07:00
|
|
|
void
|
|
|
|
cleanup(void)
|
|
|
|
{
|
|
|
|
#ifdef XWAYLAND
|
|
|
|
wlr_xwayland_destroy(xwayland);
|
|
|
|
#endif
|
|
|
|
wl_display_destroy_clients(dpy);
|
|
|
|
|
2020-12-27 17:04:05 -08:00
|
|
|
wlr_backend_destroy(backend);
|
2020-08-18 22:32:57 -07:00
|
|
|
wlr_xcursor_manager_destroy(cursor_mgr);
|
|
|
|
wlr_cursor_destroy(cursor);
|
|
|
|
wlr_output_layout_destroy(output_layout);
|
2020-12-27 17:04:05 -08:00
|
|
|
wlr_seat_destroy(seat);
|
|
|
|
wl_display_destroy(dpy);
|
2020-08-18 22:32:57 -07:00
|
|
|
}
|
|
|
|
|
2020-07-23 15:13:42 -07:00
|
|
|
void
|
|
|
|
cleanupkeyboard(struct wl_listener *listener, void *data)
|
|
|
|
{
|
|
|
|
struct wlr_input_device *device = data;
|
|
|
|
Keyboard *kb = device->data;
|
|
|
|
|
2020-12-08 03:17:14 -08:00
|
|
|
wl_list_remove(&kb->link);
|
|
|
|
wl_list_remove(&kb->modifiers.link);
|
|
|
|
wl_list_remove(&kb->key.link);
|
2020-07-23 15:13:42 -07:00
|
|
|
wl_list_remove(&kb->destroy.link);
|
|
|
|
free(kb);
|
|
|
|
}
|
|
|
|
|
2020-07-23 15:03:13 -07:00
|
|
|
void
|
|
|
|
cleanupmon(struct wl_listener *listener, void *data)
|
|
|
|
{
|
|
|
|
struct wlr_output *wlr_output = data;
|
|
|
|
Monitor *m = wlr_output->data;
|
2020-12-24 19:21:00 -08:00
|
|
|
int nmons, i = 0;
|
2020-07-23 15:03:13 -07:00
|
|
|
|
|
|
|
wl_list_remove(&m->destroy.link);
|
2020-09-14 08:40:14 -07:00
|
|
|
wl_list_remove(&m->frame.link);
|
|
|
|
wl_list_remove(&m->link);
|
|
|
|
wlr_output_layout_remove(output_layout, m->wlr_output);
|
2022-03-20 18:09:28 -07:00
|
|
|
wlr_scene_output_destroy(m->scene_output);
|
2020-10-31 05:19:31 -07:00
|
|
|
|
2021-11-04 07:19:13 -07:00
|
|
|
if ((nmons = wl_list_length(&mons)))
|
2022-03-11 16:52:22 -08:00
|
|
|
do /* don't switch to disabled mons */
|
2021-11-04 07:19:13 -07:00
|
|
|
selmon = wl_container_of(mons.prev, selmon, link);
|
|
|
|
while (!selmon->wlr_output->enabled && i++ < nmons);
|
|
|
|
|
2020-12-24 18:56:41 -08:00
|
|
|
focusclient(focustop(selmon), 1);
|
2020-10-31 05:19:31 -07:00
|
|
|
closemon(m);
|
2020-07-23 15:03:13 -07:00
|
|
|
free(m);
|
2020-10-24 14:40:19 -07:00
|
|
|
}
|
2020-09-11 04:09:18 -07:00
|
|
|
|
2020-10-24 14:40:19 -07:00
|
|
|
void
|
2020-10-31 05:19:31 -07:00
|
|
|
closemon(Monitor *m)
|
2020-10-24 14:40:19 -07:00
|
|
|
{
|
2022-03-11 16:52:22 -08:00
|
|
|
/* move closed monitor's clients to the focused one */
|
2020-10-24 14:40:19 -07:00
|
|
|
Client *c;
|
2020-09-14 08:40:14 -07:00
|
|
|
|
2020-10-30 15:22:55 -07:00
|
|
|
wl_list_for_each(c, &clients, link) {
|
|
|
|
if (c->isfloating && c->geom.x > m->m.width)
|
|
|
|
resize(c, c->geom.x - m->w.width, c->geom.y,
|
2020-12-24 18:56:41 -08:00
|
|
|
c->geom.width, c->geom.height, 0);
|
2020-10-30 15:22:55 -07:00
|
|
|
if (c->mon == m)
|
2020-10-31 05:19:31 -07:00
|
|
|
setmon(c, selmon, c->tags);
|
2020-09-14 08:40:14 -07:00
|
|
|
}
|
2022-04-25 13:48:41 -07:00
|
|
|
printstatus();
|
2020-07-23 15:03:13 -07:00
|
|
|
}
|
|
|
|
|
2020-08-23 22:04:34 -07:00
|
|
|
void
|
2020-08-26 10:41:45 -07:00
|
|
|
commitlayersurfacenotify(struct wl_listener *listener, void *data)
|
2020-08-23 22:04:34 -07:00
|
|
|
{
|
2020-08-26 08:33:17 -07:00
|
|
|
LayerSurface *layersurface = wl_container_of(listener, layersurface, surface_commit);
|
|
|
|
struct wlr_layer_surface_v1 *wlr_layer_surface = layersurface->layer_surface;
|
|
|
|
struct wlr_output *wlr_output = wlr_layer_surface->output;
|
2020-12-24 19:21:00 -08:00
|
|
|
Monitor *m;
|
2020-08-23 22:04:34 -07:00
|
|
|
|
2021-09-05 14:07:28 -07:00
|
|
|
wlr_scene_node_reparent(layersurface->scene,
|
|
|
|
layers[wlr_layer_surface->current.layer]);
|
|
|
|
|
2022-03-24 13:19:08 -07:00
|
|
|
if (!wlr_output || !(m = wlr_output->data))
|
2020-08-23 22:04:34 -07:00
|
|
|
return;
|
|
|
|
|
2021-11-06 11:51:17 -07:00
|
|
|
if (wlr_layer_surface->current.committed == 0
|
|
|
|
&& layersurface->mapped == wlr_layer_surface->mapped)
|
|
|
|
return;
|
|
|
|
|
|
|
|
layersurface->mapped = wlr_layer_surface->mapped;
|
|
|
|
|
2021-09-05 14:09:26 -07:00
|
|
|
if (layers[wlr_layer_surface->current.layer] != layersurface->scene) {
|
2020-08-26 08:33:17 -07:00
|
|
|
wl_list_remove(&layersurface->link);
|
|
|
|
wl_list_insert(&m->layers[wlr_layer_surface->current.layer],
|
|
|
|
&layersurface->link);
|
2020-08-23 22:04:34 -07:00
|
|
|
}
|
2021-09-05 14:09:26 -07:00
|
|
|
arrangelayers(m);
|
2020-07-23 15:03:13 -07:00
|
|
|
}
|
|
|
|
|
2020-07-29 20:03:40 -07:00
|
|
|
void
|
|
|
|
commitnotify(struct wl_listener *listener, void *data)
|
|
|
|
{
|
|
|
|
Client *c = wl_container_of(listener, c, commit);
|
|
|
|
|
|
|
|
/* mark a pending resize as completed */
|
2021-10-03 20:08:00 -07:00
|
|
|
if (c->resize && c->resize <= c->surface.xdg->current.configure_serial)
|
2020-07-29 20:03:40 -07:00
|
|
|
c->resize = 0;
|
|
|
|
}
|
|
|
|
|
2021-07-12 17:58:55 -07:00
|
|
|
void
|
|
|
|
createidleinhibitor(struct wl_listener *listener, void *data)
|
|
|
|
{
|
|
|
|
struct wlr_idle_inhibitor_v1 *idle_inhibitor = data;
|
|
|
|
wl_signal_add(&idle_inhibitor->events.destroy, &idle_inhibitor_destroy);
|
|
|
|
|
|
|
|
wlr_idle_set_enabled(idle, seat, 0);
|
|
|
|
}
|
|
|
|
|
2020-04-21 11:48:27 -07:00
|
|
|
void
|
2020-04-21 12:08:33 -07:00
|
|
|
createkeyboard(struct wlr_input_device *device)
|
2020-04-21 11:18:38 -07:00
|
|
|
{
|
2020-12-24 19:21:00 -08:00
|
|
|
struct xkb_context *context;
|
|
|
|
struct xkb_keymap *keymap;
|
2022-03-15 14:52:26 -07:00
|
|
|
Keyboard *kb = device->data = ecalloc(1, sizeof(*kb));
|
2020-04-23 19:16:01 -07:00
|
|
|
kb->device = device;
|
2020-04-11 15:27:19 -07:00
|
|
|
|
2020-04-21 17:09:36 -07:00
|
|
|
/* Prepare an XKB keymap and assign it to the keyboard. */
|
2020-12-24 19:21:00 -08:00
|
|
|
context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
|
2021-08-23 16:59:31 -07:00
|
|
|
keymap = xkb_keymap_new_from_names(context, &xkb_rules,
|
2020-04-11 15:27:19 -07:00
|
|
|
XKB_KEYMAP_COMPILE_NO_FLAGS);
|
|
|
|
|
|
|
|
wlr_keyboard_set_keymap(device->keyboard, keymap);
|
|
|
|
xkb_keymap_unref(keymap);
|
|
|
|
xkb_context_unref(context);
|
2020-07-02 13:41:12 -07:00
|
|
|
wlr_keyboard_set_repeat_info(device->keyboard, repeat_rate, repeat_delay);
|
2020-04-11 15:27:19 -07:00
|
|
|
|
|
|
|
/* Here we set up listeners for keyboard events. */
|
2020-12-27 10:28:37 -08:00
|
|
|
LISTEN(&device->keyboard->events.modifiers, &kb->modifiers, keypressmod);
|
|
|
|
LISTEN(&device->keyboard->events.key, &kb->key, keypress);
|
|
|
|
LISTEN(&device->events.destroy, &kb->destroy, cleanupkeyboard);
|
2020-04-11 15:27:19 -07:00
|
|
|
|
2020-04-21 12:15:19 -07:00
|
|
|
wlr_seat_set_keyboard(seat, device);
|
2020-04-11 15:27:19 -07:00
|
|
|
|
|
|
|
/* And add the keyboard to our list of keyboards */
|
2020-04-23 19:16:01 -07:00
|
|
|
wl_list_insert(&keyboards, &kb->link);
|
2020-04-11 15:27:19 -07:00
|
|
|
}
|
|
|
|
|
2022-04-05 21:04:04 -07:00
|
|
|
void
|
|
|
|
createlayersurface(struct wl_listener *listener, void *data)
|
|
|
|
{
|
|
|
|
struct wlr_layer_surface_v1 *wlr_layer_surface = data;
|
|
|
|
LayerSurface *layersurface;
|
|
|
|
Monitor *m;
|
|
|
|
struct wlr_layer_surface_v1_state old_state;
|
|
|
|
|
|
|
|
if (!wlr_layer_surface->output) {
|
|
|
|
wlr_layer_surface->output = selmon->wlr_output;
|
|
|
|
}
|
|
|
|
|
|
|
|
layersurface = ecalloc(1, sizeof(LayerSurface));
|
|
|
|
layersurface->type = LayerShell;
|
|
|
|
LISTEN(&wlr_layer_surface->surface->events.commit,
|
|
|
|
&layersurface->surface_commit, commitlayersurfacenotify);
|
|
|
|
LISTEN(&wlr_layer_surface->events.destroy, &layersurface->destroy,
|
|
|
|
destroylayersurfacenotify);
|
|
|
|
LISTEN(&wlr_layer_surface->events.map, &layersurface->map,
|
|
|
|
maplayersurfacenotify);
|
|
|
|
LISTEN(&wlr_layer_surface->events.unmap, &layersurface->unmap,
|
|
|
|
unmaplayersurfacenotify);
|
|
|
|
|
|
|
|
layersurface->layer_surface = wlr_layer_surface;
|
|
|
|
wlr_layer_surface->data = layersurface;
|
|
|
|
m = wlr_layer_surface->output->data;
|
|
|
|
|
|
|
|
layersurface->scene = wlr_layer_surface->surface->data =
|
|
|
|
wlr_scene_subsurface_tree_create(layers[wlr_layer_surface->pending.layer],
|
|
|
|
wlr_layer_surface->surface);
|
|
|
|
layersurface->scene->data = layersurface;
|
|
|
|
|
|
|
|
wl_list_insert(&m->layers[wlr_layer_surface->pending.layer],
|
|
|
|
&layersurface->link);
|
|
|
|
|
|
|
|
/* Temporarily set the layer's current state to pending
|
|
|
|
* so that we can easily arrange it
|
|
|
|
*/
|
|
|
|
old_state = wlr_layer_surface->current;
|
|
|
|
wlr_layer_surface->current = wlr_layer_surface->pending;
|
|
|
|
arrangelayers(m);
|
|
|
|
wlr_layer_surface->current = old_state;
|
|
|
|
}
|
|
|
|
|
2020-04-21 11:48:27 -07:00
|
|
|
void
|
2020-04-21 12:47:59 -07:00
|
|
|
createmon(struct wl_listener *listener, void *data)
|
2020-04-21 11:48:27 -07:00
|
|
|
{
|
2020-04-21 17:09:36 -07:00
|
|
|
/* This event is raised by the backend when a new output (aka a display or
|
2020-04-21 11:48:27 -07:00
|
|
|
* monitor) becomes available. */
|
|
|
|
struct wlr_output *wlr_output = data;
|
2020-12-24 19:21:00 -08:00
|
|
|
const MonitorRule *r;
|
2022-03-15 14:52:26 -07:00
|
|
|
Monitor *m = wlr_output->data = ecalloc(1, sizeof(*m));
|
2020-04-21 12:47:59 -07:00
|
|
|
m->wlr_output = wlr_output;
|
2021-01-18 12:12:00 -08:00
|
|
|
|
2021-12-16 09:50:11 -08:00
|
|
|
wlr_output_init_render(wlr_output, alloc, drw);
|
|
|
|
|
2021-01-18 12:12:00 -08:00
|
|
|
/* Initialize monitor state using configured rules */
|
2021-01-18 12:14:19 -08:00
|
|
|
for (size_t i = 0; i < LENGTH(m->layers); i++)
|
2021-01-18 12:12:00 -08:00
|
|
|
wl_list_init(&m->layers[i]);
|
2020-04-23 17:53:49 -07:00
|
|
|
m->tagset[0] = m->tagset[1] = 1;
|
2020-12-24 19:21:00 -08:00
|
|
|
for (r = monrules; r < END(monrules); r++) {
|
2020-05-03 09:39:48 -07:00
|
|
|
if (!r->name || strstr(wlr_output->name, r->name)) {
|
2020-05-02 22:41:37 -07:00
|
|
|
m->mfact = r->mfact;
|
|
|
|
m->nmaster = r->nmaster;
|
|
|
|
wlr_output_set_scale(wlr_output, r->scale);
|
|
|
|
wlr_xcursor_manager_load(cursor_mgr, r->scale);
|
2020-12-28 12:51:04 -08:00
|
|
|
m->lt[0] = m->lt[1] = r->lt;
|
2020-05-02 22:41:37 -07:00
|
|
|
wlr_output_set_transform(wlr_output, r->rr);
|
2020-04-21 19:53:25 -07:00
|
|
|
break;
|
|
|
|
}
|
2020-05-02 13:21:36 -07:00
|
|
|
}
|
2021-01-18 12:12:00 -08:00
|
|
|
|
|
|
|
/* The mode is a tuple of (width, height, refresh rate), and each
|
|
|
|
* monitor supports only a specific set of modes. We just pick the
|
|
|
|
* monitor's preferred mode; a more sophisticated compositor would let
|
|
|
|
* the user configure it. */
|
|
|
|
wlr_output_set_mode(wlr_output, wlr_output_preferred_mode(wlr_output));
|
2020-12-24 18:56:41 -08:00
|
|
|
wlr_output_enable_adaptive_sync(wlr_output, 1);
|
2021-01-18 12:12:00 -08:00
|
|
|
|
2020-07-23 15:03:13 -07:00
|
|
|
/* Set up event listeners */
|
2020-12-27 10:28:37 -08:00
|
|
|
LISTEN(&wlr_output->events.frame, &m->frame, rendermon);
|
|
|
|
LISTEN(&wlr_output->events.destroy, &m->destroy, cleanupmon);
|
2020-07-23 15:14:33 -07:00
|
|
|
|
2020-05-03 09:45:47 -07:00
|
|
|
wlr_output_enable(wlr_output, 1);
|
|
|
|
if (!wlr_output_commit(wlr_output))
|
|
|
|
return;
|
|
|
|
|
2021-05-24 20:03:39 -07:00
|
|
|
wl_list_insert(&mons, &m->link);
|
|
|
|
printstatus();
|
|
|
|
|
2020-12-21 02:21:59 -08:00
|
|
|
/* Adds this to the output layout in the order it was configured in.
|
2020-04-21 15:26:52 -07:00
|
|
|
*
|
|
|
|
* The output layout utility automatically adds a wl_output global to the
|
|
|
|
* display, which Wayland clients can see to find out information about the
|
|
|
|
* output (such as DPI, scale factor, manufacturer, etc).
|
|
|
|
*/
|
2021-09-05 20:35:07 -07:00
|
|
|
m->scene_output = wlr_scene_output_create(scene, wlr_output);
|
|
|
|
wlr_output_layout_add_auto(output_layout, wlr_output);
|
2020-08-23 22:04:34 -07:00
|
|
|
|
2021-11-04 07:19:13 -07:00
|
|
|
/* If length == 1 we need update selmon.
|
|
|
|
* Maybe it will change in run(). */
|
|
|
|
if (wl_list_length(&mons) == 1) {
|
|
|
|
Client *c;
|
|
|
|
selmon = m;
|
|
|
|
/* If there is any client, set c->mon to this monitor */
|
|
|
|
wl_list_for_each(c, &clients, link)
|
|
|
|
setmon(c, m, c->tags);
|
|
|
|
}
|
2020-04-21 11:48:27 -07:00
|
|
|
}
|
|
|
|
|
2020-04-21 12:53:35 -07:00
|
|
|
void
|
2020-07-22 17:54:12 -07:00
|
|
|
createnotify(struct wl_listener *listener, void *data)
|
2020-04-21 12:53:35 -07:00
|
|
|
{
|
|
|
|
/* This event is raised when wlr_xdg_shell receives a new xdg surface from a
|
2022-01-31 23:16:56 -08:00
|
|
|
* client, either a toplevel (application window) or popup,
|
|
|
|
* or when wlr_layer_shell receives a new popup from a layer.
|
|
|
|
* If you want to do something tricky with popups you should check if
|
|
|
|
* its parent is wlr_xdg_shell or wlr_layer_shell */
|
2020-04-21 12:53:35 -07:00
|
|
|
struct wlr_xdg_surface *xdg_surface = data;
|
2020-05-02 13:21:36 -07:00
|
|
|
Client *c;
|
|
|
|
|
2021-10-29 16:38:24 -07:00
|
|
|
if (xdg_surface->role == WLR_XDG_SURFACE_ROLE_POPUP) {
|
2022-03-16 22:08:17 -07:00
|
|
|
struct wlr_box box;
|
2021-10-29 16:38:24 -07:00
|
|
|
xdg_surface->surface->data = wlr_scene_xdg_surface_create(
|
|
|
|
xdg_surface->popup->parent->data, xdg_surface);
|
2022-03-17 16:02:03 -07:00
|
|
|
if (!(c = client_from_popup(xdg_surface->popup)) || !c->mon)
|
2022-03-16 22:08:17 -07:00
|
|
|
return;
|
2022-03-17 16:02:03 -07:00
|
|
|
box = c->mon->m;
|
|
|
|
box.x -= c->geom.x;
|
|
|
|
box.y -= c->geom.y;
|
2022-03-16 22:08:17 -07:00
|
|
|
wlr_xdg_popup_unconstrain_from_box(xdg_surface->popup, &box);
|
2021-10-29 16:38:24 -07:00
|
|
|
return;
|
|
|
|
} else if (xdg_surface->role == WLR_XDG_SURFACE_ROLE_NONE)
|
2020-04-21 12:53:35 -07:00
|
|
|
return;
|
|
|
|
|
|
|
|
/* Allocate a Client for this surface */
|
2022-03-15 14:52:26 -07:00
|
|
|
c = xdg_surface->data = ecalloc(1, sizeof(*c));
|
2020-08-02 07:16:07 -07:00
|
|
|
c->surface.xdg = xdg_surface;
|
2020-04-23 20:56:27 -07:00
|
|
|
c->bw = borderpx;
|
2020-04-21 12:53:35 -07:00
|
|
|
|
2020-12-27 10:28:37 -08:00
|
|
|
LISTEN(&xdg_surface->surface->events.commit, &c->commit, commitnotify);
|
|
|
|
LISTEN(&xdg_surface->events.map, &c->map, mapnotify);
|
|
|
|
LISTEN(&xdg_surface->events.unmap, &c->unmap, unmapnotify);
|
|
|
|
LISTEN(&xdg_surface->events.destroy, &c->destroy, destroynotify);
|
2021-04-15 11:05:05 -07:00
|
|
|
LISTEN(&xdg_surface->toplevel->events.set_title, &c->set_title, updatetitle);
|
2020-12-27 10:28:37 -08:00
|
|
|
LISTEN(&xdg_surface->toplevel->events.request_fullscreen, &c->fullscreen,
|
|
|
|
fullscreennotify);
|
2020-09-04 10:58:00 -07:00
|
|
|
c->isfullscreen = 0;
|
2020-04-21 12:53:35 -07:00
|
|
|
}
|
|
|
|
|
2020-04-21 11:48:27 -07:00
|
|
|
void
|
2020-04-21 12:08:33 -07:00
|
|
|
createpointer(struct wlr_input_device *device)
|
2020-04-21 11:18:38 -07:00
|
|
|
{
|
2020-12-24 18:15:40 -08:00
|
|
|
if (wlr_input_device_is_libinput(device)) {
|
|
|
|
struct libinput_device *libinput_device = (struct libinput_device*)
|
2020-10-17 04:52:53 -07:00
|
|
|
wlr_libinput_get_device_handle(device);
|
2020-10-17 07:18:44 -07:00
|
|
|
|
2022-03-27 17:04:41 -07:00
|
|
|
if (libinput_device_config_tap_get_finger_count(libinput_device)) {
|
|
|
|
libinput_device_config_tap_set_enabled(libinput_device, tap_to_click);
|
|
|
|
libinput_device_config_tap_set_drag_enabled(libinput_device, tap_and_drag);
|
2022-05-25 13:01:38 -07:00
|
|
|
libinput_device_config_tap_set_drag_lock_enabled(libinput_device, drag_lock);
|
2022-03-27 17:04:41 -07:00
|
|
|
}
|
2020-10-17 07:18:44 -07:00
|
|
|
|
2020-12-24 18:15:40 -08:00
|
|
|
if (libinput_device_config_scroll_has_natural_scroll(libinput_device))
|
|
|
|
libinput_device_config_scroll_set_natural_scroll_enabled(libinput_device, natural_scrolling);
|
2022-03-27 17:04:41 -07:00
|
|
|
|
|
|
|
if (libinput_device_config_dwt_is_available(libinput_device))
|
|
|
|
libinput_device_config_dwt_set_enabled(libinput_device, disable_while_typing);
|
|
|
|
|
|
|
|
if (libinput_device_config_left_handed_is_available(libinput_device))
|
|
|
|
libinput_device_config_left_handed_set(libinput_device, left_handed);
|
|
|
|
|
|
|
|
if (libinput_device_config_middle_emulation_is_available(libinput_device))
|
|
|
|
libinput_device_config_middle_emulation_set_enabled(libinput_device, middle_button_emulation);
|
|
|
|
|
|
|
|
if (libinput_device_config_scroll_get_methods(libinput_device) != LIBINPUT_CONFIG_SCROLL_NO_SCROLL)
|
|
|
|
libinput_device_config_scroll_set_method (libinput_device, scroll_method);
|
|
|
|
|
|
|
|
if (libinput_device_config_send_events_get_modes(libinput_device))
|
|
|
|
libinput_device_config_send_events_set_mode(libinput_device, send_events_mode);
|
|
|
|
|
|
|
|
if (libinput_device_config_accel_is_available(libinput_device)) {
|
|
|
|
libinput_device_config_accel_set_profile(libinput_device, accel_profile);
|
|
|
|
libinput_device_config_accel_set_speed(libinput_device, accel_speed);
|
|
|
|
}
|
2020-12-24 18:15:40 -08:00
|
|
|
}
|
2020-10-17 07:18:44 -07:00
|
|
|
|
2020-04-21 12:15:19 -07:00
|
|
|
wlr_cursor_attach_input_device(cursor, device);
|
2020-04-11 15:27:19 -07:00
|
|
|
}
|
|
|
|
|
2020-04-21 11:48:27 -07:00
|
|
|
void
|
|
|
|
cursorframe(struct wl_listener *listener, void *data)
|
2020-04-21 11:18:38 -07:00
|
|
|
{
|
2020-04-21 11:48:27 -07:00
|
|
|
/* This event is forwarded by the cursor when a pointer emits an frame
|
|
|
|
* event. Frame events are sent after regular pointer events to group
|
|
|
|
* multiple events together. For instance, two axis events may happen at the
|
|
|
|
* same time, in which case a frame event won't be sent in between. */
|
|
|
|
/* Notify the client with pointer focus of the frame event. */
|
2020-04-21 12:15:19 -07:00
|
|
|
wlr_seat_pointer_notify_frame(seat);
|
2020-04-11 15:27:19 -07:00
|
|
|
}
|
|
|
|
|
2021-07-12 17:58:55 -07:00
|
|
|
void
|
|
|
|
destroyidleinhibitor(struct wl_listener *listener, void *data)
|
|
|
|
{
|
|
|
|
/* I've been testing and at this point the inhibitor has not yet been
|
|
|
|
* removed from the list, checking if it has at least one item. */
|
|
|
|
wlr_idle_set_enabled(idle, seat, wl_list_length(&idle_inhibit_mgr->inhibitors) <= 1);
|
|
|
|
}
|
|
|
|
|
2020-08-23 22:04:34 -07:00
|
|
|
void
|
2020-08-26 10:41:45 -07:00
|
|
|
destroylayersurfacenotify(struct wl_listener *listener, void *data)
|
2020-08-23 22:04:34 -07:00
|
|
|
{
|
2020-08-26 08:33:17 -07:00
|
|
|
LayerSurface *layersurface = wl_container_of(listener, layersurface, destroy);
|
2020-08-23 22:04:34 -07:00
|
|
|
|
2020-08-26 08:33:17 -07:00
|
|
|
if (layersurface->layer_surface->mapped)
|
2020-08-26 10:41:45 -07:00
|
|
|
unmaplayersurface(layersurface);
|
2020-08-26 08:33:17 -07:00
|
|
|
wl_list_remove(&layersurface->link);
|
|
|
|
wl_list_remove(&layersurface->destroy.link);
|
|
|
|
wl_list_remove(&layersurface->map.link);
|
|
|
|
wl_list_remove(&layersurface->unmap.link);
|
|
|
|
wl_list_remove(&layersurface->surface_commit.link);
|
2022-05-25 12:49:32 -07:00
|
|
|
wlr_scene_node_destroy(layersurface->scene);
|
2020-08-26 08:33:17 -07:00
|
|
|
if (layersurface->layer_surface->output) {
|
2020-12-19 10:50:01 -08:00
|
|
|
Monitor *m = layersurface->layer_surface->output->data;
|
2020-08-23 22:04:34 -07:00
|
|
|
if (m)
|
|
|
|
arrangelayers(m);
|
2020-08-26 08:33:17 -07:00
|
|
|
layersurface->layer_surface->output = NULL;
|
2020-08-23 22:04:34 -07:00
|
|
|
}
|
2020-08-26 08:33:17 -07:00
|
|
|
free(layersurface);
|
2020-08-23 22:04:34 -07:00
|
|
|
}
|
|
|
|
|
2020-04-21 11:48:27 -07:00
|
|
|
void
|
|
|
|
destroynotify(struct wl_listener *listener, void *data)
|
2020-04-21 11:18:38 -07:00
|
|
|
{
|
2020-04-21 11:48:27 -07:00
|
|
|
/* Called when the surface is destroyed and should never be shown again. */
|
2020-04-21 12:47:59 -07:00
|
|
|
Client *c = wl_container_of(listener, c, destroy);
|
2020-05-09 23:04:31 -07:00
|
|
|
wl_list_remove(&c->map.link);
|
|
|
|
wl_list_remove(&c->unmap.link);
|
|
|
|
wl_list_remove(&c->destroy.link);
|
2021-04-15 11:05:05 -07:00
|
|
|
wl_list_remove(&c->set_title.link);
|
2020-09-05 01:37:59 -07:00
|
|
|
wl_list_remove(&c->fullscreen.link);
|
2020-08-10 10:50:56 -07:00
|
|
|
#ifdef XWAYLAND
|
2022-03-16 20:42:45 -07:00
|
|
|
if (c->type != XDGShell) {
|
|
|
|
wl_list_remove(&c->configure.link);
|
2022-05-17 12:38:18 -07:00
|
|
|
wl_list_remove(&c->set_hints.link);
|
2020-07-28 22:05:24 -07:00
|
|
|
wl_list_remove(&c->activate.link);
|
2022-03-16 20:42:45 -07:00
|
|
|
} else
|
2020-08-10 10:50:56 -07:00
|
|
|
#endif
|
|
|
|
wl_list_remove(&c->commit.link);
|
2020-04-21 12:47:59 -07:00
|
|
|
free(c);
|
2020-04-11 15:27:19 -07:00
|
|
|
}
|
|
|
|
|
2020-04-23 18:40:02 -07:00
|
|
|
Monitor *
|
2021-01-06 14:19:44 -08:00
|
|
|
dirtomon(enum wlr_direction dir)
|
2020-04-23 18:40:02 -07:00
|
|
|
{
|
2021-01-06 14:19:44 -08:00
|
|
|
struct wlr_output *next;
|
|
|
|
if ((next = wlr_output_layout_adjacent_output(output_layout,
|
|
|
|
dir, selmon->wlr_output, selmon->m.x, selmon->m.y)))
|
|
|
|
return next->data;
|
|
|
|
if ((next = wlr_output_layout_farthest_output(output_layout,
|
|
|
|
dir ^ (WLR_DIRECTION_LEFT|WLR_DIRECTION_RIGHT),
|
|
|
|
selmon->wlr_output, selmon->m.x, selmon->m.y)))
|
|
|
|
return next->data;
|
|
|
|
return selmon;
|
2020-04-23 18:40:02 -07:00
|
|
|
}
|
|
|
|
|
2022-04-05 21:04:04 -07:00
|
|
|
void
|
|
|
|
dragicondestroy(struct wl_listener *listener, void *data)
|
|
|
|
{
|
|
|
|
struct wlr_drag_icon *icon = data;
|
|
|
|
wlr_scene_node_destroy(icon->data);
|
|
|
|
// Focus enter isn't sent during drag, so refocus the focused node.
|
|
|
|
focusclient(selclient(), 1);
|
|
|
|
motionnotify(0);
|
|
|
|
}
|
|
|
|
|
2020-04-26 18:17:47 -07:00
|
|
|
void
|
2020-12-24 18:56:41 -08:00
|
|
|
focusclient(Client *c, int lift)
|
2020-04-26 18:17:47 -07:00
|
|
|
{
|
2020-12-24 19:21:00 -08:00
|
|
|
struct wlr_surface *old = seat->keyboard_state.focused_surface;
|
|
|
|
struct wlr_keyboard *kb;
|
2021-10-31 14:32:49 -07:00
|
|
|
int i;
|
2020-12-24 19:21:00 -08:00
|
|
|
|
2020-08-02 16:43:29 -07:00
|
|
|
/* Raise client in stacking order if requested */
|
2021-10-31 16:05:40 -07:00
|
|
|
if (c && lift)
|
|
|
|
wlr_scene_node_raise_to_top(c->scene);
|
2020-08-02 16:43:29 -07:00
|
|
|
|
2020-12-24 22:33:55 -08:00
|
|
|
if (c && client_surface(c) == old)
|
2020-08-02 16:43:29 -07:00
|
|
|
return;
|
|
|
|
|
2020-12-20 06:19:34 -08:00
|
|
|
/* Put the new client atop the focus stack and select its monitor */
|
|
|
|
if (c) {
|
|
|
|
wl_list_remove(&c->flink);
|
|
|
|
wl_list_insert(&fstack, &c->flink);
|
|
|
|
selmon = c->mon;
|
2021-05-22 19:18:48 -07:00
|
|
|
c->isurgent = 0;
|
2021-10-31 14:32:49 -07:00
|
|
|
|
|
|
|
for (i = 0; i < 4; i++)
|
|
|
|
wlr_scene_rect_set_color(c->border[i], focuscolor);
|
2020-12-20 06:19:34 -08:00
|
|
|
}
|
|
|
|
|
2020-07-31 11:53:33 -07:00
|
|
|
/* Deactivate old client if focus is changing */
|
2020-12-24 22:33:55 -08:00
|
|
|
if (old && (!c || client_surface(c) != old)) {
|
2020-12-20 06:19:34 -08:00
|
|
|
/* If an overlay is focused, don't focus or activate the client,
|
|
|
|
* but only update its position in fstack to render its border with focuscolor
|
|
|
|
* and focus it after the overlay is closed.
|
|
|
|
* It's probably pointless to check if old is a layer surface
|
|
|
|
* since it can't be anything else at this point. */
|
2020-12-24 22:33:55 -08:00
|
|
|
if (wlr_surface_is_layer_surface(old)) {
|
2020-12-20 06:19:34 -08:00
|
|
|
struct wlr_layer_surface_v1 *wlr_layer_surface =
|
|
|
|
wlr_layer_surface_v1_from_wlr_surface(old);
|
|
|
|
|
|
|
|
if (wlr_layer_surface->mapped && (
|
|
|
|
wlr_layer_surface->current.layer == ZWLR_LAYER_SHELL_V1_LAYER_TOP ||
|
|
|
|
wlr_layer_surface->current.layer == ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY
|
|
|
|
))
|
|
|
|
return;
|
2020-12-24 22:33:55 -08:00
|
|
|
} else {
|
2022-03-17 23:49:47 -07:00
|
|
|
Client *w;
|
2022-05-23 07:14:21 -07:00
|
|
|
if (old->role_data && (w = client_from_wlr_surface(old)))
|
2022-03-17 23:49:47 -07:00
|
|
|
for (i = 0; i < 4; i++)
|
|
|
|
wlr_scene_rect_set_color(w->border[i], bordercolor);
|
2021-10-31 14:32:49 -07:00
|
|
|
|
2020-12-24 22:33:55 -08:00
|
|
|
client_activate_surface(old, 0);
|
2020-12-20 06:19:34 -08:00
|
|
|
}
|
2020-04-26 18:17:47 -07:00
|
|
|
}
|
2020-06-03 17:45:40 -07:00
|
|
|
|
2021-07-01 13:20:30 -07:00
|
|
|
printstatus();
|
2021-07-12 17:58:55 -07:00
|
|
|
wlr_idle_set_enabled(idle, seat, wl_list_empty(&idle_inhibit_mgr->inhibitors));
|
2021-07-01 13:20:30 -07:00
|
|
|
|
2020-07-31 11:53:33 -07:00
|
|
|
if (!c) {
|
|
|
|
/* With no client, all we have left is to clear focus */
|
2020-06-15 07:22:25 -07:00
|
|
|
wlr_seat_keyboard_notify_clear_focus(seat);
|
2020-07-31 11:53:33 -07:00
|
|
|
return;
|
|
|
|
}
|
2020-08-02 16:26:58 -07:00
|
|
|
|
2022-04-03 15:18:05 -07:00
|
|
|
#ifdef XWAYLAND
|
|
|
|
/* This resolves an issue where the last spawned xwayland client
|
|
|
|
* receives all pointer activity.
|
|
|
|
*/
|
|
|
|
if (c->type == X11Managed)
|
|
|
|
wlr_xwayland_surface_restack(c->surface.xwayland, NULL,
|
|
|
|
XCB_STACK_MODE_ABOVE);
|
|
|
|
#endif
|
|
|
|
|
2020-08-02 16:26:58 -07:00
|
|
|
/* Have a client, so focus its top-level wlr_surface */
|
2020-12-24 19:21:00 -08:00
|
|
|
kb = wlr_seat_get_keyboard(seat);
|
2022-05-10 09:42:40 -07:00
|
|
|
if (kb)
|
2022-04-05 23:22:15 -07:00
|
|
|
wlr_seat_keyboard_notify_enter(seat, client_surface(c),
|
|
|
|
kb->keycodes, kb->num_keycodes, &kb->modifiers);
|
2022-05-10 09:42:40 -07:00
|
|
|
else
|
2022-04-05 23:22:15 -07:00
|
|
|
wlr_seat_keyboard_notify_enter(seat, client_surface(c), NULL, 0, NULL);
|
2020-07-31 11:53:33 -07:00
|
|
|
|
|
|
|
/* Activate the new client */
|
2020-12-24 22:33:55 -08:00
|
|
|
client_activate_surface(client_surface(c), 1);
|
2020-04-26 18:17:47 -07:00
|
|
|
}
|
|
|
|
|
2020-04-23 18:40:02 -07:00
|
|
|
void
|
|
|
|
focusmon(const Arg *arg)
|
|
|
|
{
|
2020-10-31 10:29:33 -07:00
|
|
|
do
|
2020-10-30 15:49:01 -07:00
|
|
|
selmon = dirtomon(arg->i);
|
2020-10-31 10:29:33 -07:00
|
|
|
while (!selmon->wlr_output->enabled);
|
2020-12-24 18:56:41 -08:00
|
|
|
focusclient(focustop(selmon), 1);
|
2020-04-23 18:40:02 -07:00
|
|
|
}
|
|
|
|
|
2020-04-21 11:48:27 -07:00
|
|
|
void
|
2020-04-22 22:47:15 -07:00
|
|
|
focusstack(const Arg *arg)
|
2020-04-21 11:18:38 -07:00
|
|
|
{
|
2020-04-22 22:47:15 -07:00
|
|
|
/* Focus the next or previous client (in tiling order) on selmon */
|
2020-05-02 13:21:36 -07:00
|
|
|
Client *c, *sel = selclient();
|
2021-07-12 14:44:16 -07:00
|
|
|
if (!sel || (sel->isfullscreen && lockfullscreen))
|
2020-04-21 11:48:27 -07:00
|
|
|
return;
|
2020-04-22 22:47:15 -07:00
|
|
|
if (arg->i > 0) {
|
|
|
|
wl_list_for_each(c, &sel->link, link) {
|
|
|
|
if (&c->link == &clients)
|
|
|
|
continue; /* wrap past the sentinel node */
|
|
|
|
if (VISIBLEON(c, selmon))
|
|
|
|
break; /* found it */
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
wl_list_for_each_reverse(c, &sel->link, link) {
|
|
|
|
if (&c->link == &clients)
|
|
|
|
continue; /* wrap past the sentinel node */
|
|
|
|
if (VISIBLEON(c, selmon))
|
|
|
|
break; /* found it */
|
|
|
|
}
|
2020-04-22 22:38:09 -07:00
|
|
|
}
|
2020-04-22 22:47:15 -07:00
|
|
|
/* If only one client is visible on selmon, then c == sel */
|
2020-12-24 18:56:41 -08:00
|
|
|
focusclient(c, 1);
|
2020-04-11 15:27:19 -07:00
|
|
|
}
|
|
|
|
|
2020-08-02 16:40:33 -07:00
|
|
|
Client *
|
|
|
|
focustop(Monitor *m)
|
|
|
|
{
|
|
|
|
Client *c;
|
|
|
|
wl_list_for_each(c, &fstack, flink)
|
|
|
|
if (VISIBLEON(c, m))
|
|
|
|
return c;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2022-04-05 21:04:04 -07:00
|
|
|
void
|
|
|
|
fullscreennotify(struct wl_listener *listener, void *data)
|
|
|
|
{
|
|
|
|
Client *c = wl_container_of(listener, c, fullscreen);
|
|
|
|
int fullscreen = client_wants_fullscreen(c);
|
|
|
|
|
|
|
|
if (!c->mon) {
|
|
|
|
/* if the client is not mapped yet, let mapnotify() call setfullscreen() */
|
|
|
|
c->isfullscreen = fullscreen;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
setfullscreen(c, fullscreen);
|
|
|
|
}
|
|
|
|
|
2020-04-23 18:14:11 -07:00
|
|
|
void
|
|
|
|
incnmaster(const Arg *arg)
|
|
|
|
{
|
|
|
|
selmon->nmaster = MAX(selmon->nmaster + arg->i, 0);
|
2020-04-26 20:02:47 -07:00
|
|
|
arrange(selmon);
|
2020-04-23 18:14:11 -07:00
|
|
|
}
|
|
|
|
|
2020-04-21 11:48:27 -07:00
|
|
|
void
|
|
|
|
inputdevice(struct wl_listener *listener, void *data)
|
|
|
|
{
|
|
|
|
/* This event is raised by the backend when a new input device becomes
|
|
|
|
* available. */
|
|
|
|
struct wlr_input_device *device = data;
|
2020-12-24 19:21:00 -08:00
|
|
|
uint32_t caps;
|
|
|
|
|
2020-04-21 11:48:27 -07:00
|
|
|
switch (device->type) {
|
|
|
|
case WLR_INPUT_DEVICE_KEYBOARD:
|
2020-04-21 12:08:33 -07:00
|
|
|
createkeyboard(device);
|
2020-04-21 11:48:27 -07:00
|
|
|
break;
|
|
|
|
case WLR_INPUT_DEVICE_POINTER:
|
2020-04-21 12:08:33 -07:00
|
|
|
createpointer(device);
|
2020-04-21 11:48:27 -07:00
|
|
|
break;
|
|
|
|
default:
|
2020-12-20 07:07:12 -08:00
|
|
|
/* TODO handle other input device types */
|
2020-04-21 11:48:27 -07:00
|
|
|
break;
|
|
|
|
}
|
2020-12-24 19:21:00 -08:00
|
|
|
|
2020-04-21 11:48:27 -07:00
|
|
|
/* We need to let the wlr_seat know what our capabilities are, which is
|
|
|
|
* communiciated to the client. In dwl we always have a cursor, even if
|
|
|
|
* there are no pointer devices, so we always include that capability. */
|
2020-12-20 07:07:12 -08:00
|
|
|
/* TODO do we actually require a cursor? */
|
2020-12-24 19:21:00 -08:00
|
|
|
caps = WL_SEAT_CAPABILITY_POINTER;
|
2020-04-23 19:16:01 -07:00
|
|
|
if (!wl_list_empty(&keyboards))
|
2020-04-21 11:48:27 -07:00
|
|
|
caps |= WL_SEAT_CAPABILITY_KEYBOARD;
|
2020-04-21 12:15:19 -07:00
|
|
|
wlr_seat_set_capabilities(seat, caps);
|
2020-04-21 11:48:27 -07:00
|
|
|
}
|
|
|
|
|
2020-05-02 12:32:23 -07:00
|
|
|
int
|
2020-04-21 12:08:33 -07:00
|
|
|
keybinding(uint32_t mods, xkb_keysym_t sym)
|
2020-04-21 11:48:27 -07:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2020-05-02 12:32:23 -07:00
|
|
|
int handled = 0;
|
2020-05-02 22:41:37 -07:00
|
|
|
const Key *k;
|
|
|
|
for (k = keys; k < END(keys); k++) {
|
|
|
|
if (CLEANMASK(mods) == CLEANMASK(k->mod) &&
|
|
|
|
sym == k->keysym && k->func) {
|
|
|
|
k->func(&k->arg);
|
2020-05-02 12:32:23 -07:00
|
|
|
handled = 1;
|
2020-04-21 11:48:27 -07:00
|
|
|
}
|
2020-05-02 13:21:36 -07:00
|
|
|
}
|
2020-04-21 11:48:27 -07:00
|
|
|
return handled;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
keypress(struct wl_listener *listener, void *data)
|
|
|
|
{
|
2020-12-24 18:56:41 -08:00
|
|
|
int i;
|
2020-04-21 11:48:27 -07:00
|
|
|
/* This event is raised when a key is pressed or released. */
|
2020-04-23 19:16:01 -07:00
|
|
|
Keyboard *kb = wl_container_of(listener, kb, key);
|
2020-04-21 11:48:27 -07:00
|
|
|
struct wlr_event_keyboard_key *event = data;
|
|
|
|
|
|
|
|
/* Translate libinput keycode -> xkbcommon */
|
|
|
|
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(
|
2020-04-23 19:16:01 -07:00
|
|
|
kb->device->keyboard->xkb_state, keycode, &syms);
|
2020-04-21 11:48:27 -07:00
|
|
|
|
2020-05-02 12:32:23 -07:00
|
|
|
int handled = 0;
|
2020-04-23 19:16:01 -07:00
|
|
|
uint32_t mods = wlr_keyboard_get_modifiers(kb->device->keyboard);
|
2020-08-28 11:18:42 -07:00
|
|
|
|
|
|
|
wlr_idle_notify_activity(idle, seat);
|
|
|
|
|
2021-07-03 13:48:40 -07:00
|
|
|
/* On _press_ if there is no active screen locker,
|
|
|
|
* attempt to process a compositor keybinding. */
|
|
|
|
if (!input_inhibit_mgr->active_inhibitor
|
|
|
|
&& event->state == WL_KEYBOARD_KEY_STATE_PRESSED)
|
2020-05-02 13:21:36 -07:00
|
|
|
for (i = 0; i < nsyms; i++)
|
2020-04-21 12:08:33 -07:00
|
|
|
handled = keybinding(mods, syms[i]) || handled;
|
2020-04-21 11:48:27 -07:00
|
|
|
|
|
|
|
if (!handled) {
|
2020-04-23 20:20:44 -07:00
|
|
|
/* Pass unhandled keycodes along to the client. */
|
2020-04-23 19:16:01 -07:00
|
|
|
wlr_seat_set_keyboard(seat, kb->device);
|
2020-04-21 11:48:27 -07:00
|
|
|
wlr_seat_keyboard_notify_key(seat, event->time_msec,
|
|
|
|
event->keycode, event->state);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
keypressmod(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. */
|
2020-04-23 19:16:01 -07:00
|
|
|
Keyboard *kb = wl_container_of(listener, kb, modifiers);
|
2020-04-21 11:48:27 -07:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2020-04-23 19:16:01 -07:00
|
|
|
wlr_seat_set_keyboard(seat, kb->device);
|
2020-04-21 11:48:27 -07:00
|
|
|
/* Send modifiers to the client. */
|
2020-04-21 12:15:19 -07:00
|
|
|
wlr_seat_keyboard_notify_modifiers(seat,
|
2020-04-23 19:16:01 -07:00
|
|
|
&kb->device->keyboard->modifiers);
|
2020-04-21 11:48:27 -07:00
|
|
|
}
|
|
|
|
|
2020-07-23 11:30:25 -07:00
|
|
|
void
|
|
|
|
killclient(const Arg *arg)
|
|
|
|
{
|
|
|
|
Client *sel = selclient();
|
2022-03-11 21:02:37 -08:00
|
|
|
if (sel)
|
|
|
|
client_send_close(sel);
|
2020-07-23 11:30:25 -07:00
|
|
|
}
|
|
|
|
|
2020-08-23 22:04:34 -07:00
|
|
|
void
|
2020-08-26 10:41:45 -07:00
|
|
|
maplayersurfacenotify(struct wl_listener *listener, void *data)
|
2020-08-23 22:04:34 -07:00
|
|
|
{
|
2020-08-26 08:33:17 -07:00
|
|
|
LayerSurface *layersurface = wl_container_of(listener, layersurface, map);
|
2022-03-11 21:02:37 -08:00
|
|
|
wlr_surface_send_enter(layersurface->layer_surface->surface,
|
|
|
|
layersurface->layer_surface->output);
|
2020-09-04 06:35:04 -07:00
|
|
|
motionnotify(0);
|
2020-08-23 22:04:34 -07:00
|
|
|
}
|
|
|
|
|
2020-04-21 11:48:27 -07:00
|
|
|
void
|
2020-12-19 09:51:22 -08:00
|
|
|
mapnotify(struct wl_listener *listener, void *data)
|
2020-04-21 11:48:27 -07:00
|
|
|
{
|
|
|
|
/* Called when the surface is mapped, or ready to display on-screen. */
|
2021-03-25 08:05:12 -07:00
|
|
|
Client *c = wl_container_of(listener, c, map);
|
2021-09-05 14:07:28 -07:00
|
|
|
int i;
|
|
|
|
|
|
|
|
/* Create scene tree for this client and its border */
|
|
|
|
c->scene = &wlr_scene_tree_create(layers[LyrTile])->node;
|
2022-05-24 12:37:55 -07:00
|
|
|
c->scene_surface = c->type == XDGShell
|
2022-03-17 23:52:21 -07:00
|
|
|
? wlr_scene_xdg_surface_create(c->scene, c->surface.xdg)
|
|
|
|
: wlr_scene_subsurface_tree_create(c->scene, client_surface(c));
|
2022-05-24 12:37:55 -07:00
|
|
|
if (client_surface(c))
|
|
|
|
client_surface(c)->data = c->scene;
|
|
|
|
c->scene->data = c->scene_surface->data = c;
|
2020-07-25 08:55:18 -07:00
|
|
|
|
2020-12-24 22:33:55 -08:00
|
|
|
if (client_is_unmanaged(c)) {
|
2022-01-31 12:02:59 -08:00
|
|
|
client_get_geometry(c, &c->geom);
|
2022-03-18 00:02:50 -07:00
|
|
|
/* Floating */
|
2021-09-05 14:07:28 -07:00
|
|
|
wlr_scene_node_reparent(c->scene, layers[LyrFloat]);
|
2022-01-31 12:02:59 -08:00
|
|
|
wlr_scene_node_set_position(c->scene, c->geom.x + borderpx,
|
|
|
|
c->geom.y + borderpx);
|
2020-07-25 08:55:18 -07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2022-03-18 00:02:50 -07:00
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
|
c->border[i] = wlr_scene_rect_create(c->scene, 0, 0, bordercolor);
|
|
|
|
c->border[i]->node.data = c;
|
|
|
|
wlr_scene_rect_set_color(c->border[i], bordercolor);
|
|
|
|
}
|
|
|
|
|
2021-09-05 14:07:28 -07:00
|
|
|
/* Initialize client geometry with room for border */
|
|
|
|
client_set_tiled(c, WLR_EDGE_TOP | WLR_EDGE_BOTTOM | WLR_EDGE_LEFT | WLR_EDGE_RIGHT);
|
2020-12-24 22:33:55 -08:00
|
|
|
client_get_geometry(c, &c->geom);
|
|
|
|
c->geom.width += 2 * c->bw;
|
|
|
|
c->geom.height += 2 * c->bw;
|
2020-05-02 22:48:12 -07:00
|
|
|
|
2021-09-05 14:07:28 -07:00
|
|
|
/* Insert this client into client lists. */
|
|
|
|
wl_list_insert(&clients, &c->link);
|
|
|
|
wl_list_insert(&fstack, &c->flink);
|
2021-05-22 12:22:37 -07:00
|
|
|
|
2020-05-02 22:48:12 -07:00
|
|
|
/* Set initial monitor, tags, floating status, and focus */
|
|
|
|
applyrules(c);
|
2021-12-31 12:51:50 -08:00
|
|
|
printstatus();
|
2021-11-13 08:22:52 -08:00
|
|
|
|
|
|
|
if (c->isfullscreen)
|
|
|
|
setfullscreen(c, 1);
|
2022-02-28 14:46:24 -08:00
|
|
|
|
|
|
|
c->mon->un_map = 1;
|
2020-04-21 11:48:27 -07:00
|
|
|
}
|
|
|
|
|
2020-08-03 10:44:47 -07:00
|
|
|
void
|
|
|
|
monocle(Monitor *m)
|
|
|
|
{
|
|
|
|
Client *c;
|
|
|
|
|
|
|
|
wl_list_for_each(c, &clients, link) {
|
2021-03-25 08:05:12 -07:00
|
|
|
if (!VISIBLEON(c, m) || c->isfloating || c->isfullscreen)
|
2020-08-03 10:44:47 -07:00
|
|
|
continue;
|
2021-03-25 08:05:12 -07:00
|
|
|
resize(c, m->w.x, m->w.y, m->w.width, m->w.height, 0);
|
2020-08-03 10:44:47 -07:00
|
|
|
}
|
2022-05-11 05:30:10 -07:00
|
|
|
focusclient(focustop(m), 1);
|
2020-08-03 10:44:47 -07:00
|
|
|
}
|
|
|
|
|
2020-04-21 11:48:27 -07:00
|
|
|
void
|
|
|
|
motionabsolute(struct wl_listener *listener, void *data)
|
|
|
|
{
|
|
|
|
/* This event is forwarded by the cursor when a pointer emits an _absolute_
|
|
|
|
* motion event, from 0..1 on each axis. This happens, for example, when
|
|
|
|
* wlroots is running under a Wayland window rather than KMS+DRM, and you
|
|
|
|
* move the mouse over the window. You could enter the window from any edge,
|
|
|
|
* so we have to warp the mouse there. There is also some hardware which
|
|
|
|
* emits these events. */
|
|
|
|
struct wlr_event_pointer_motion_absolute *event = data;
|
2020-04-21 12:15:19 -07:00
|
|
|
wlr_cursor_warp_absolute(cursor, event->device, event->x, event->y);
|
2020-04-21 12:08:33 -07:00
|
|
|
motionnotify(event->time_msec);
|
2020-04-21 11:48:27 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2020-04-21 12:08:33 -07:00
|
|
|
motionnotify(uint32_t time)
|
2020-04-21 11:18:38 -07:00
|
|
|
{
|
2020-12-24 19:21:00 -08:00
|
|
|
double sx = 0, sy = 0;
|
|
|
|
Client *c = NULL;
|
2021-09-05 14:07:28 -07:00
|
|
|
struct wlr_surface *surface = NULL;
|
2022-03-23 13:18:38 -07:00
|
|
|
struct wlr_drag_icon *icon;
|
2020-12-24 19:21:00 -08:00
|
|
|
|
2022-03-11 16:52:22 -08:00
|
|
|
/* time is 0 in internal calls meant to restore pointer focus. */
|
2020-12-20 07:04:13 -08:00
|
|
|
if (time) {
|
|
|
|
wlr_idle_notify_activity(idle, seat);
|
2020-05-02 13:21:36 -07:00
|
|
|
|
2020-12-20 07:04:13 -08:00
|
|
|
/* Update selmon (even while dragging a window) */
|
|
|
|
if (sloppyfocus)
|
|
|
|
selmon = xytomon(cursor->x, cursor->y);
|
|
|
|
}
|
2020-04-22 20:56:24 -07:00
|
|
|
|
2022-03-23 13:18:38 -07:00
|
|
|
if (seat->drag && (icon = seat->drag->icon))
|
|
|
|
wlr_scene_node_set_position(icon->data, cursor->x + icon->surface->sx,
|
|
|
|
cursor->y + icon->surface->sy);
|
2020-04-21 17:09:36 -07:00
|
|
|
/* If we are currently grabbing the mouse, handle and return */
|
2020-04-21 12:15:19 -07:00
|
|
|
if (cursor_mode == CurMove) {
|
2020-04-21 12:59:32 -07:00
|
|
|
/* Move the grabbed client to the new position. */
|
2020-04-30 09:33:32 -07:00
|
|
|
resize(grabc, cursor->x - grabcx, cursor->y - grabcy,
|
2020-04-26 20:12:08 -07:00
|
|
|
grabc->geom.width, grabc->geom.height, 1);
|
2020-04-11 15:27:19 -07:00
|
|
|
return;
|
2020-04-21 12:15:19 -07:00
|
|
|
} else if (cursor_mode == CurResize) {
|
2020-04-26 20:12:08 -07:00
|
|
|
resize(grabc, grabc->geom.x, grabc->geom.y,
|
2020-04-26 20:19:48 -07:00
|
|
|
cursor->x - grabc->geom.x,
|
|
|
|
cursor->y - grabc->geom.y, 1);
|
2020-04-11 15:27:19 -07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-09-05 14:07:28 -07:00
|
|
|
/* Find the client under the pointer and send the event along. */
|
|
|
|
xytonode(cursor->x, cursor->y, &surface, &c, NULL, &sx, &sy);
|
2020-09-04 09:36:27 -07:00
|
|
|
|
2020-05-02 13:22:07 -07:00
|
|
|
/* If there's no client surface under the cursor, set the cursor image to a
|
2020-04-23 19:16:01 -07:00
|
|
|
* default. This is what makes the cursor image appear when you move it
|
2020-05-02 13:22:07 -07:00
|
|
|
* off of a client or over its border. */
|
2020-12-20 23:05:40 -08:00
|
|
|
if (!surface && time)
|
2022-03-11 21:02:37 -08:00
|
|
|
wlr_xcursor_manager_set_cursor_image(cursor_mgr, "left_ptr", cursor);
|
2020-04-23 18:29:26 -07:00
|
|
|
|
2020-04-26 12:47:23 -07:00
|
|
|
pointerfocus(c, surface, sx, sy, time);
|
2020-04-11 15:27:19 -07:00
|
|
|
}
|
|
|
|
|
2020-04-21 11:48:27 -07:00
|
|
|
void
|
2020-04-21 11:18:38 -07:00
|
|
|
motionrelative(struct wl_listener *listener, void *data)
|
|
|
|
{
|
2020-04-11 15:27:19 -07:00
|
|
|
/* This event is forwarded by the cursor when a pointer emits a _relative_
|
|
|
|
* pointer motion event (i.e. a delta) */
|
|
|
|
struct wlr_event_pointer_motion *event = data;
|
|
|
|
/* The cursor doesn't move unless we tell it to. The cursor automatically
|
|
|
|
* handles constraining the motion to the output layout, as well as any
|
|
|
|
* special configuration applied for the specific input device which
|
|
|
|
* generated the event. You can pass NULL for the device if you want to move
|
|
|
|
* the cursor around without any input. */
|
2022-03-11 21:02:37 -08:00
|
|
|
wlr_cursor_move(cursor, event->device, event->delta_x, event->delta_y);
|
2020-04-21 12:08:33 -07:00
|
|
|
motionnotify(event->time_msec);
|
2020-04-11 15:27:19 -07:00
|
|
|
}
|
|
|
|
|
2020-04-21 11:48:27 -07:00
|
|
|
void
|
2020-04-30 08:25:37 -07:00
|
|
|
moveresize(const Arg *arg)
|
2020-04-21 11:18:38 -07:00
|
|
|
{
|
2021-09-05 14:07:28 -07:00
|
|
|
if (cursor_mode != CurNormal)
|
|
|
|
return;
|
|
|
|
xytonode(cursor->x, cursor->y, NULL, &grabc, NULL, NULL, NULL);
|
2022-01-31 12:02:59 -08:00
|
|
|
if (!grabc || client_is_unmanaged(grabc))
|
2020-04-21 11:48:27 -07:00
|
|
|
return;
|
2020-04-11 19:29:27 -07:00
|
|
|
|
2020-04-23 20:26:43 -07:00
|
|
|
/* Float the window and tell motionnotify to grab it */
|
2020-04-26 19:55:49 -07:00
|
|
|
setfloating(grabc, 1);
|
2020-04-30 08:25:37 -07:00
|
|
|
switch (cursor_mode = arg->ui) {
|
|
|
|
case CurMove:
|
2020-04-30 09:33:32 -07:00
|
|
|
grabcx = cursor->x - grabc->geom.x;
|
|
|
|
grabcy = cursor->y - grabc->geom.y;
|
2020-04-30 08:25:37 -07:00
|
|
|
wlr_xcursor_manager_set_cursor_image(cursor_mgr, "fleur", cursor);
|
|
|
|
break;
|
|
|
|
case CurResize:
|
|
|
|
/* Doesn't work for X11 output - the next absolute motion event
|
|
|
|
* returns the cursor to where it started */
|
|
|
|
wlr_cursor_warp_closest(cursor, NULL,
|
|
|
|
grabc->geom.x + grabc->geom.width,
|
|
|
|
grabc->geom.y + grabc->geom.height);
|
|
|
|
wlr_xcursor_manager_set_cursor_image(cursor_mgr,
|
|
|
|
"bottom_right_corner", cursor);
|
|
|
|
break;
|
|
|
|
}
|
2020-04-11 15:27:19 -07:00
|
|
|
}
|
|
|
|
|
2020-10-17 11:11:31 -07:00
|
|
|
void
|
|
|
|
outputmgrapply(struct wl_listener *listener, void *data)
|
|
|
|
{
|
|
|
|
struct wlr_output_configuration_v1 *config = data;
|
2020-12-24 18:56:41 -08:00
|
|
|
outputmgrapplyortest(config, 0);
|
2020-10-17 11:11:31 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2020-12-24 18:56:41 -08:00
|
|
|
outputmgrapplyortest(struct wlr_output_configuration_v1 *config, int test)
|
2020-10-17 11:11:31 -07:00
|
|
|
{
|
2021-01-18 13:51:32 -08:00
|
|
|
/*
|
|
|
|
* Called when a client such as wlr-randr requests a change in output
|
|
|
|
* configuration. This is only one way that the layout can be changed,
|
|
|
|
* so any Monitor information should be updated by updatemons() after an
|
|
|
|
* output_layout.change event, not here.
|
|
|
|
*/
|
2020-10-17 11:11:31 -07:00
|
|
|
struct wlr_output_configuration_head_v1 *config_head;
|
2020-12-24 18:56:41 -08:00
|
|
|
int ok = 1;
|
2020-10-17 11:11:31 -07:00
|
|
|
|
|
|
|
wl_list_for_each(config_head, &config->heads, link) {
|
|
|
|
struct wlr_output *wlr_output = config_head->state.output;
|
|
|
|
|
2020-10-31 05:00:54 -07:00
|
|
|
wlr_output_enable(wlr_output, config_head->state.enabled);
|
2020-10-17 11:11:31 -07:00
|
|
|
if (config_head->state.enabled) {
|
|
|
|
if (config_head->state.mode)
|
|
|
|
wlr_output_set_mode(wlr_output, config_head->state.mode);
|
|
|
|
else
|
|
|
|
wlr_output_set_custom_mode(wlr_output,
|
|
|
|
config_head->state.custom_mode.width,
|
|
|
|
config_head->state.custom_mode.height,
|
|
|
|
config_head->state.custom_mode.refresh);
|
|
|
|
|
|
|
|
wlr_output_layout_move(output_layout, wlr_output,
|
|
|
|
config_head->state.x, config_head->state.y);
|
|
|
|
wlr_output_set_transform(wlr_output, config_head->state.transform);
|
|
|
|
wlr_output_set_scale(wlr_output, config_head->state.scale);
|
|
|
|
}
|
|
|
|
|
2021-01-18 13:02:15 -08:00
|
|
|
if (!(ok = wlr_output_test(wlr_output)))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
wl_list_for_each(config_head, &config->heads, link) {
|
|
|
|
if (ok && !test)
|
|
|
|
wlr_output_commit(config_head->state.output);
|
|
|
|
else
|
|
|
|
wlr_output_rollback(config_head->state.output);
|
2020-10-17 11:11:31 -07:00
|
|
|
}
|
2021-01-18 12:34:05 -08:00
|
|
|
if (ok)
|
2020-10-17 11:11:31 -07:00
|
|
|
wlr_output_configuration_v1_send_succeeded(config);
|
2021-01-18 12:34:05 -08:00
|
|
|
else
|
2020-10-17 11:11:31 -07:00
|
|
|
wlr_output_configuration_v1_send_failed(config);
|
|
|
|
wlr_output_configuration_v1_destroy(config);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
outputmgrtest(struct wl_listener *listener, void *data)
|
|
|
|
{
|
|
|
|
struct wlr_output_configuration_v1 *config = data;
|
2020-12-24 18:56:41 -08:00
|
|
|
outputmgrapplyortest(config, 1);
|
2020-10-17 11:11:31 -07:00
|
|
|
}
|
|
|
|
|
2020-04-23 22:12:11 -07:00
|
|
|
void
|
2020-04-26 12:47:23 -07:00
|
|
|
pointerfocus(Client *c, struct wlr_surface *surface, double sx, double sy,
|
|
|
|
uint32_t time)
|
2020-04-23 22:12:11 -07:00
|
|
|
{
|
2020-12-24 19:21:00 -08:00
|
|
|
struct timespec now;
|
|
|
|
int internal_call = !time;
|
|
|
|
|
2022-03-17 23:59:52 -07:00
|
|
|
if (sloppyfocus && !internal_call && c && !client_is_unmanaged(c))
|
|
|
|
focusclient(c, 0);
|
2020-07-21 15:35:46 -07:00
|
|
|
|
2020-07-31 12:00:00 -07:00
|
|
|
/* If surface is NULL, clear pointer focus */
|
|
|
|
if (!surface) {
|
|
|
|
wlr_seat_pointer_notify_clear_focus(seat);
|
2020-04-26 12:47:23 -07:00
|
|
|
return;
|
|
|
|
}
|
2020-06-14 02:05:21 -07:00
|
|
|
|
2020-12-24 19:21:00 -08:00
|
|
|
if (internal_call) {
|
2020-12-20 06:34:36 -08:00
|
|
|
clock_gettime(CLOCK_MONOTONIC, &now);
|
|
|
|
time = now.tv_sec * 1000 + now.tv_nsec / 1000000;
|
|
|
|
}
|
|
|
|
|
2022-03-17 23:59:52 -07:00
|
|
|
/* Let the client know that the mouse cursor has entered one
|
|
|
|
* of its surfaces, and make keyboard focus follow if desired.
|
|
|
|
* wlroots makes this a no-op if surface is already focused */
|
2020-04-26 12:47:23 -07:00
|
|
|
wlr_seat_pointer_notify_enter(seat, surface, sx, sy);
|
2022-03-17 23:59:52 -07:00
|
|
|
wlr_seat_pointer_notify_motion(seat, time, sx, sy);
|
2020-08-10 18:42:02 -07:00
|
|
|
|
2020-04-23 22:12:11 -07:00
|
|
|
}
|
|
|
|
|
2021-03-13 09:20:33 -08:00
|
|
|
void
|
|
|
|
printstatus(void)
|
|
|
|
{
|
|
|
|
Monitor *m = NULL;
|
2021-05-22 19:18:48 -07:00
|
|
|
Client *c;
|
|
|
|
unsigned int occ, urg, sel;
|
2021-03-13 09:20:33 -08:00
|
|
|
|
|
|
|
wl_list_for_each(m, &mons, link) {
|
2021-05-22 19:18:48 -07:00
|
|
|
occ = urg = 0;
|
2021-03-13 09:20:33 -08:00
|
|
|
wl_list_for_each(c, &clients, link) {
|
2021-05-22 19:18:48 -07:00
|
|
|
if (c->mon != m)
|
|
|
|
continue;
|
|
|
|
occ |= c->tags;
|
|
|
|
if (c->isurgent)
|
|
|
|
urg |= c->tags;
|
2021-03-13 09:20:33 -08:00
|
|
|
}
|
2021-05-22 19:18:48 -07:00
|
|
|
if ((c = focustop(m))) {
|
2022-03-13 14:16:06 -07:00
|
|
|
printf("%s title %s\n", m->wlr_output->name, client_get_title(c));
|
|
|
|
printf("%s fullscreen %u\n", m->wlr_output->name, c->isfullscreen);
|
|
|
|
printf("%s floating %u\n", m->wlr_output->name, c->isfloating);
|
2021-05-22 19:18:48 -07:00
|
|
|
sel = c->tags;
|
|
|
|
} else {
|
2021-03-13 09:20:33 -08:00
|
|
|
printf("%s title \n", m->wlr_output->name);
|
2022-03-13 14:16:06 -07:00
|
|
|
printf("%s fullscreen \n", m->wlr_output->name);
|
|
|
|
printf("%s floating \n", m->wlr_output->name);
|
2021-05-22 19:18:48 -07:00
|
|
|
sel = 0;
|
|
|
|
}
|
2021-03-13 09:20:33 -08:00
|
|
|
|
|
|
|
printf("%s selmon %u\n", m->wlr_output->name, m == selmon);
|
2021-05-22 19:18:48 -07:00
|
|
|
printf("%s tags %u %u %u %u\n", m->wlr_output->name, occ, m->tagset[m->seltags],
|
|
|
|
sel, urg);
|
2021-03-13 09:20:33 -08:00
|
|
|
printf("%s layout %s\n", m->wlr_output->name, m->lt[m->sellt]->symbol);
|
|
|
|
}
|
|
|
|
fflush(stdout);
|
|
|
|
}
|
|
|
|
|
2020-04-21 11:48:27 -07:00
|
|
|
void
|
2020-04-21 12:08:33 -07:00
|
|
|
quit(const Arg *arg)
|
2020-04-21 11:18:38 -07:00
|
|
|
{
|
2020-04-23 19:16:01 -07:00
|
|
|
wl_display_terminate(dpy);
|
2020-04-11 15:27:19 -07:00
|
|
|
}
|
|
|
|
|
2021-05-26 21:30:49 -07:00
|
|
|
void
|
|
|
|
quitsignal(int signo)
|
|
|
|
{
|
|
|
|
quit(NULL);
|
|
|
|
}
|
|
|
|
|
2020-04-21 11:48:27 -07:00
|
|
|
void
|
2020-04-21 12:47:59 -07:00
|
|
|
rendermon(struct wl_listener *listener, void *data)
|
2020-04-21 11:18:38 -07:00
|
|
|
{
|
2020-04-11 15:27:19 -07:00
|
|
|
/* This function is called every time an output is ready to display a frame,
|
|
|
|
* generally at the output's refresh rate (e.g. 60Hz). */
|
2020-04-21 12:47:59 -07:00
|
|
|
Monitor *m = wl_container_of(listener, m, frame);
|
2021-09-05 20:35:07 -07:00
|
|
|
Client *c;
|
2022-03-18 10:04:34 -07:00
|
|
|
int skip = 0;
|
2020-04-11 15:27:19 -07:00
|
|
|
struct timespec now;
|
|
|
|
|
2022-02-28 14:46:24 -08:00
|
|
|
clock_gettime(CLOCK_MONOTONIC, &now);
|
|
|
|
|
2022-03-21 20:17:58 -07:00
|
|
|
/* Render if no XDG clients have an outstanding resize and are visible on
|
2022-02-28 14:46:24 -08:00
|
|
|
* this monitor. */
|
|
|
|
/* Checking m->un_map for every client is not optimal but works */
|
|
|
|
wl_list_for_each(c, &clients, link) {
|
|
|
|
if ((c->resize && m->un_map) || (c->type == XDGShell
|
|
|
|
&& (c->surface.xdg->pending.geometry.width !=
|
|
|
|
c->surface.xdg->current.geometry.width
|
|
|
|
|| c->surface.xdg->pending.geometry.height !=
|
|
|
|
c->surface.xdg->current.geometry.height))) {
|
|
|
|
/* Lie */
|
|
|
|
wlr_surface_send_frame_done(client_surface(c), &now);
|
|
|
|
skip = 1;
|
|
|
|
}
|
|
|
|
}
|
2021-09-05 20:35:07 -07:00
|
|
|
if (!skip && !wlr_scene_output_commit(m->scene_output))
|
|
|
|
return;
|
2021-09-05 14:07:28 -07:00
|
|
|
/* Let clients know a frame has been rendered */
|
2021-09-24 14:07:06 -07:00
|
|
|
wlr_scene_output_send_frame_done(m->scene_output, &now);
|
2022-02-28 14:46:24 -08:00
|
|
|
m->un_map = 0;
|
2020-04-11 15:27:19 -07:00
|
|
|
}
|
|
|
|
|
2022-04-05 21:04:04 -07:00
|
|
|
void
|
|
|
|
requeststartdrag(struct wl_listener *listener, void *data)
|
|
|
|
{
|
|
|
|
struct wlr_seat_request_start_drag_event *event = data;
|
|
|
|
|
|
|
|
if (wlr_seat_validate_pointer_grab_serial(seat, event->origin,
|
|
|
|
event->serial))
|
|
|
|
wlr_seat_start_pointer_drag(seat, event->drag, event->serial);
|
|
|
|
else
|
|
|
|
wlr_data_source_destroy(event->drag->source);
|
|
|
|
}
|
|
|
|
|
2020-04-22 06:25:43 -07:00
|
|
|
void
|
2020-04-26 12:08:47 -07:00
|
|
|
resize(Client *c, int x, int y, int w, int h, int interact)
|
2020-04-22 06:25:43 -07:00
|
|
|
{
|
2022-03-18 00:25:53 -07:00
|
|
|
int min_width = 0, min_height = 0;
|
2020-12-24 19:21:00 -08:00
|
|
|
struct wlr_box *bbox = interact ? &sgeom : &c->mon->w;
|
2022-03-18 00:25:53 -07:00
|
|
|
client_min_size(c, &min_width, &min_height);
|
2020-04-26 20:12:08 -07:00
|
|
|
c->geom.x = x;
|
|
|
|
c->geom.y = y;
|
2022-03-18 00:25:53 -07:00
|
|
|
c->geom.width = MAX(min_width + 2 * c->bw, w);
|
|
|
|
c->geom.height = MAX(min_height + 2 * c->bw, h);
|
2020-04-26 12:08:47 -07:00
|
|
|
applybounds(c, bbox);
|
2021-09-05 14:07:28 -07:00
|
|
|
|
|
|
|
/* Update scene-graph, including borders */
|
|
|
|
wlr_scene_node_set_position(c->scene, c->geom.x, c->geom.y);
|
|
|
|
wlr_scene_node_set_position(c->scene_surface, c->bw, c->bw);
|
|
|
|
wlr_scene_rect_set_size(c->border[0], c->geom.width, c->bw);
|
|
|
|
wlr_scene_rect_set_size(c->border[1], c->geom.width, c->bw);
|
|
|
|
wlr_scene_rect_set_size(c->border[2], c->bw, c->geom.height - 2 * c->bw);
|
|
|
|
wlr_scene_rect_set_size(c->border[3], c->bw, c->geom.height - 2 * c->bw);
|
|
|
|
wlr_scene_node_set_position(&c->border[1]->node, 0, c->geom.height - c->bw);
|
2022-02-15 15:38:56 -08:00
|
|
|
wlr_scene_node_set_position(&c->border[2]->node, 0, c->bw);
|
2021-09-05 14:07:28 -07:00
|
|
|
wlr_scene_node_set_position(&c->border[3]->node, c->geom.width - c->bw, c->bw);
|
|
|
|
|
2020-04-26 11:18:20 -07:00
|
|
|
/* wlroots makes this a no-op if size hasn't changed */
|
2020-12-24 22:33:55 -08:00
|
|
|
c->resize = client_set_size(c, c->geom.width - 2 * c->bw,
|
|
|
|
c->geom.height - 2 * c->bw);
|
2020-04-22 06:25:43 -07:00
|
|
|
}
|
|
|
|
|
2020-04-21 16:57:04 -07:00
|
|
|
void
|
|
|
|
run(char *startup_cmd)
|
|
|
|
{
|
2020-12-24 19:21:00 -08:00
|
|
|
pid_t startup_pid = -1;
|
|
|
|
|
2020-04-21 16:57:04 -07:00
|
|
|
/* Add a Unix socket to the Wayland display. */
|
2020-04-23 19:16:01 -07:00
|
|
|
const char *socket = wl_display_add_socket_auto(dpy);
|
2020-08-18 17:39:34 -07:00
|
|
|
if (!socket)
|
2022-03-15 14:52:26 -07:00
|
|
|
die("startup: display_add_socket_auto");
|
2020-05-02 12:32:23 -07:00
|
|
|
setenv("WAYLAND_DISPLAY", socket, 1);
|
2020-12-19 10:50:01 -08:00
|
|
|
|
2021-05-24 20:03:39 -07:00
|
|
|
/* Now that the socket exists, run the startup command */
|
2020-04-21 16:57:04 -07:00
|
|
|
if (startup_cmd) {
|
2021-04-14 09:15:26 -07:00
|
|
|
int piperw[2];
|
2022-03-31 11:24:09 -07:00
|
|
|
if (pipe(piperw) < 0)
|
|
|
|
die("startup: pipe:");
|
|
|
|
if ((startup_pid = fork()) < 0)
|
2022-03-15 14:52:26 -07:00
|
|
|
die("startup: fork:");
|
2020-04-21 16:57:04 -07:00
|
|
|
if (startup_pid == 0) {
|
2021-04-14 09:15:26 -07:00
|
|
|
dup2(piperw[0], STDIN_FILENO);
|
2021-10-13 14:11:40 -07:00
|
|
|
close(piperw[0]);
|
2021-04-14 09:15:26 -07:00
|
|
|
close(piperw[1]);
|
2020-12-24 22:38:24 -08:00
|
|
|
execl("/bin/sh", "/bin/sh", "-c", startup_cmd, NULL);
|
2022-03-15 14:52:26 -07:00
|
|
|
die("startup: execl:");
|
2020-04-21 16:57:04 -07:00
|
|
|
}
|
2021-04-14 09:15:26 -07:00
|
|
|
dup2(piperw[1], STDOUT_FILENO);
|
2021-10-13 14:11:40 -07:00
|
|
|
close(piperw[1]);
|
2021-04-14 09:15:26 -07:00
|
|
|
close(piperw[0]);
|
2020-04-21 16:57:04 -07:00
|
|
|
}
|
2021-04-14 09:15:26 -07:00
|
|
|
/* If nobody is reading the status output, don't terminate */
|
|
|
|
signal(SIGPIPE, SIG_IGN);
|
2021-05-22 19:18:48 -07:00
|
|
|
printstatus();
|
2020-12-19 10:50:01 -08:00
|
|
|
|
2021-05-24 20:03:39 -07:00
|
|
|
/* Start the backend. This will enumerate outputs and inputs, become the DRM
|
|
|
|
* master, etc */
|
|
|
|
if (!wlr_backend_start(backend))
|
2022-03-15 14:52:26 -07:00
|
|
|
die("startup: backend_start");
|
2021-05-24 20:03:39 -07:00
|
|
|
|
|
|
|
/* Now that outputs are initialized, choose initial selmon based on
|
|
|
|
* cursor position, and set default cursor image */
|
|
|
|
selmon = xytomon(cursor->x, cursor->y);
|
|
|
|
|
|
|
|
/* TODO hack to get cursor to display in its initial location (100, 100)
|
|
|
|
* instead of (0, 0) and then jumping. still may not be fully
|
|
|
|
* initialized, as the image/coordinates are not transformed for the
|
|
|
|
* monitor when displayed here */
|
|
|
|
wlr_cursor_warp_closest(cursor, NULL, cursor->x, cursor->y);
|
|
|
|
wlr_xcursor_manager_set_cursor_image(cursor_mgr, "left_ptr", cursor);
|
|
|
|
|
2020-04-21 16:57:04 -07:00
|
|
|
/* Run the Wayland event loop. This does not return until you exit the
|
|
|
|
* compositor. Starting the backend rigged up all of the necessary event
|
|
|
|
* loop configuration to listen to libinput events, DRM events, generate
|
|
|
|
* frame events at the refresh rate, and so on. */
|
2020-04-23 19:16:01 -07:00
|
|
|
wl_display_run(dpy);
|
2020-04-21 16:57:04 -07:00
|
|
|
|
|
|
|
if (startup_cmd) {
|
|
|
|
kill(startup_pid, SIGTERM);
|
|
|
|
waitpid(startup_pid, NULL, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-04-22 22:27:53 -07:00
|
|
|
Client *
|
|
|
|
selclient(void)
|
|
|
|
{
|
|
|
|
Client *c = wl_container_of(fstack.next, c, flink);
|
|
|
|
if (wl_list_empty(&fstack) || !VISIBLEON(c, selmon))
|
|
|
|
return NULL;
|
|
|
|
return c;
|
|
|
|
}
|
|
|
|
|
2020-04-21 11:48:27 -07:00
|
|
|
void
|
|
|
|
setcursor(struct wl_listener *listener, void *data)
|
2020-04-21 11:18:38 -07:00
|
|
|
{
|
2020-05-02 13:21:36 -07:00
|
|
|
/* This event is raised by the seat when a client provides a cursor image */
|
|
|
|
struct wlr_seat_pointer_request_set_cursor_event *event = data;
|
2020-04-23 20:38:06 -07:00
|
|
|
/* If we're "grabbing" the cursor, don't use the client's image */
|
2020-12-20 07:07:12 -08:00
|
|
|
/* TODO still need to save the provided surface to restore later */
|
2020-04-23 20:38:06 -07:00
|
|
|
if (cursor_mode != CurNormal)
|
|
|
|
return;
|
2020-04-21 11:48:27 -07:00
|
|
|
/* This can be sent by any client, so we check to make sure this one is
|
2020-04-23 19:16:01 -07:00
|
|
|
* 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
|
|
|
|
* do so as the cursor moves between outputs. */
|
|
|
|
if (event->seat_client == seat->pointer_state.focused_client)
|
2020-04-21 12:15:19 -07:00
|
|
|
wlr_cursor_set_surface(cursor, event->surface,
|
2020-04-21 11:48:27 -07:00
|
|
|
event->hotspot_x, event->hotspot_y);
|
|
|
|
}
|
2020-04-11 15:27:19 -07:00
|
|
|
|
2020-04-26 19:55:49 -07:00
|
|
|
void
|
|
|
|
setfloating(Client *c, int floating)
|
|
|
|
{
|
|
|
|
c->isfloating = floating;
|
2021-09-05 14:07:28 -07:00
|
|
|
wlr_scene_node_reparent(c->scene, layers[c->isfloating ? LyrFloat : LyrTile]);
|
2020-04-26 20:02:47 -07:00
|
|
|
arrange(c->mon);
|
2022-03-13 14:16:06 -07:00
|
|
|
printstatus();
|
2020-04-26 19:55:49 -07:00
|
|
|
}
|
|
|
|
|
2022-04-05 21:04:04 -07:00
|
|
|
void
|
|
|
|
setfullscreen(Client *c, int fullscreen)
|
|
|
|
{
|
|
|
|
c->isfullscreen = fullscreen;
|
|
|
|
c->bw = fullscreen ? 0 : borderpx;
|
|
|
|
client_set_fullscreen(c, fullscreen);
|
|
|
|
|
|
|
|
if (fullscreen) {
|
|
|
|
c->prev = c->geom;
|
|
|
|
resize(c, c->mon->m.x, c->mon->m.y, c->mon->m.width, c->mon->m.height, 0);
|
|
|
|
} else {
|
|
|
|
/* restore previous size instead of arrange for floating windows since
|
|
|
|
* client positions are set by the user and cannot be recalculated */
|
|
|
|
resize(c, c->prev.x, c->prev.y, c->prev.width, c->prev.height, 0);
|
|
|
|
}
|
|
|
|
arrange(c->mon);
|
|
|
|
printstatus();
|
|
|
|
}
|
|
|
|
|
2020-04-22 09:20:08 -07:00
|
|
|
void
|
|
|
|
setlayout(const Arg *arg)
|
|
|
|
{
|
|
|
|
if (!arg || !arg->v || arg->v != selmon->lt[selmon->sellt])
|
|
|
|
selmon->sellt ^= 1;
|
|
|
|
if (arg && arg->v)
|
|
|
|
selmon->lt[selmon->sellt] = (Layout *)arg->v;
|
2020-12-20 07:07:12 -08:00
|
|
|
/* TODO change layout symbol? */
|
2020-04-26 20:02:47 -07:00
|
|
|
arrange(selmon);
|
2021-03-13 09:20:33 -08:00
|
|
|
printstatus();
|
2020-04-22 09:20:08 -07:00
|
|
|
}
|
|
|
|
|
2020-04-23 18:14:11 -07:00
|
|
|
/* arg > 1.0 will set mfact absolutely */
|
|
|
|
void
|
|
|
|
setmfact(const Arg *arg)
|
|
|
|
{
|
2020-12-24 19:21:00 -08:00
|
|
|
float f;
|
|
|
|
|
2020-04-23 18:14:11 -07:00
|
|
|
if (!arg || !selmon->lt[selmon->sellt]->arrange)
|
|
|
|
return;
|
2020-12-24 19:21:00 -08:00
|
|
|
f = arg->f < 1.0 ? arg->f + selmon->mfact : arg->f - 1.0;
|
2020-04-23 18:14:11 -07:00
|
|
|
if (f < 0.1 || f > 0.9)
|
|
|
|
return;
|
|
|
|
selmon->mfact = f;
|
2020-04-26 20:02:47 -07:00
|
|
|
arrange(selmon);
|
2020-04-23 18:14:11 -07:00
|
|
|
}
|
|
|
|
|
2020-04-26 17:48:28 -07:00
|
|
|
void
|
2020-05-02 22:44:16 -07:00
|
|
|
setmon(Client *c, Monitor *m, unsigned int newtags)
|
2020-04-26 17:48:28 -07:00
|
|
|
{
|
2020-04-26 20:02:47 -07:00
|
|
|
Monitor *oldmon = c->mon;
|
2020-08-01 22:35:26 -07:00
|
|
|
|
2020-05-02 13:21:36 -07:00
|
|
|
if (oldmon == m)
|
|
|
|
return;
|
2020-04-26 17:48:28 -07:00
|
|
|
c->mon = m;
|
2020-08-01 22:35:26 -07:00
|
|
|
|
2020-12-20 07:07:12 -08:00
|
|
|
/* TODO leave/enter is not optimal but works */
|
2020-04-26 20:02:47 -07:00
|
|
|
if (oldmon) {
|
2020-12-24 22:33:55 -08:00
|
|
|
wlr_surface_send_leave(client_surface(c), oldmon->wlr_output);
|
2020-04-26 20:02:47 -07:00
|
|
|
arrange(oldmon);
|
|
|
|
}
|
2020-04-26 17:48:28 -07:00
|
|
|
if (m) {
|
|
|
|
/* Make sure window actually overlaps with the monitor */
|
2021-09-05 14:07:28 -07:00
|
|
|
resize(c, c->geom.x, c->geom.y, c->geom.width, c->geom.height, 0);
|
2020-12-24 22:33:55 -08:00
|
|
|
wlr_surface_send_enter(client_surface(c), m->wlr_output);
|
2020-05-02 22:44:16 -07:00
|
|
|
c->tags = newtags ? newtags : m->tagset[m->seltags]; /* assign tags of target monitor */
|
2020-04-26 20:02:47 -07:00
|
|
|
arrange(m);
|
2020-04-26 17:48:28 -07:00
|
|
|
}
|
2020-12-24 18:56:41 -08:00
|
|
|
focusclient(focustop(selmon), 1);
|
2020-04-26 17:48:28 -07:00
|
|
|
}
|
|
|
|
|
2020-05-09 20:45:22 -07:00
|
|
|
void
|
|
|
|
setpsel(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 dwl we always honor
|
|
|
|
*/
|
|
|
|
struct wlr_seat_request_set_primary_selection_event *event = data;
|
|
|
|
wlr_seat_set_primary_selection(seat, event->source, event->serial);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
setsel(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 dwl we always honor
|
|
|
|
*/
|
|
|
|
struct wlr_seat_request_set_selection_event *event = data;
|
|
|
|
wlr_seat_set_selection(seat, event->source, event->serial);
|
|
|
|
}
|
|
|
|
|
2020-04-21 11:48:27 -07:00
|
|
|
void
|
2020-04-21 16:57:04 -07:00
|
|
|
setup(void)
|
2020-04-21 11:18:38 -07:00
|
|
|
{
|
2020-08-18 22:32:57 -07:00
|
|
|
/* The Wayland display is managed by libwayland. It handles accepting
|
|
|
|
* clients from the Unix socket, manging Wayland globals, and so on. */
|
|
|
|
dpy = wl_display_create();
|
|
|
|
|
2021-05-26 21:30:49 -07:00
|
|
|
/* Set up signal handlers */
|
2021-03-13 08:42:33 -08:00
|
|
|
sigchld(0);
|
2021-05-26 21:30:49 -07:00
|
|
|
signal(SIGINT, quitsignal);
|
|
|
|
signal(SIGTERM, quitsignal);
|
2020-08-18 16:22:44 -07:00
|
|
|
|
2020-04-11 15:27:19 -07:00
|
|
|
/* The backend is a wlroots feature which abstracts the underlying input and
|
|
|
|
* output hardware. The autocreate option will choose the most suitable
|
|
|
|
* backend based on the current environment, such as opening an X11 window
|
|
|
|
* if an X11 server is running. The NULL argument here optionally allows you
|
|
|
|
* to pass in a custom renderer if wlr_renderer doesn't meet your needs. The
|
|
|
|
* backend uses the renderer, for example, to fall back to software cursors
|
|
|
|
* if the backend does not support hardware cursors (some older GPUs
|
|
|
|
* don't). */
|
2021-02-16 11:13:49 -08:00
|
|
|
if (!(backend = wlr_backend_autocreate(dpy)))
|
2022-03-15 14:52:26 -07:00
|
|
|
die("couldn't create backend");
|
2020-04-11 15:27:19 -07:00
|
|
|
|
2021-09-05 14:07:28 -07:00
|
|
|
/* Initialize the scene graph used to lay out windows */
|
|
|
|
scene = wlr_scene_create();
|
|
|
|
layers[LyrBg] = &wlr_scene_tree_create(&scene->node)->node;
|
|
|
|
layers[LyrBottom] = &wlr_scene_tree_create(&scene->node)->node;
|
|
|
|
layers[LyrTile] = &wlr_scene_tree_create(&scene->node)->node;
|
|
|
|
layers[LyrFloat] = &wlr_scene_tree_create(&scene->node)->node;
|
|
|
|
layers[LyrTop] = &wlr_scene_tree_create(&scene->node)->node;
|
|
|
|
layers[LyrOverlay] = &wlr_scene_tree_create(&scene->node)->node;
|
2022-03-23 12:50:08 -07:00
|
|
|
layers[LyrNoFocus] = &wlr_scene_tree_create(&scene->node)->node;
|
2021-09-05 14:07:28 -07:00
|
|
|
|
2021-12-16 09:50:11 -08:00
|
|
|
/* Create a renderer with the default implementation */
|
|
|
|
if (!(drw = wlr_renderer_autocreate(backend)))
|
2022-03-15 14:52:26 -07:00
|
|
|
die("couldn't create renderer");
|
2020-04-23 19:16:01 -07:00
|
|
|
wlr_renderer_init_wl_display(drw, dpy);
|
2020-04-11 15:27:19 -07:00
|
|
|
|
2021-12-16 09:50:11 -08:00
|
|
|
/* Create a default allocator */
|
|
|
|
if (!(alloc = wlr_allocator_autocreate(backend, drw)))
|
2022-03-15 14:52:26 -07:00
|
|
|
die("couldn't create allocator");
|
2021-12-16 09:50:11 -08:00
|
|
|
|
2020-04-11 15:27:19 -07:00
|
|
|
/* This creates some hands-off wlroots interfaces. The compositor is
|
|
|
|
* necessary for clients to allocate surfaces and the data device manager
|
|
|
|
* handles the clipboard. Each of these wlroots interfaces has room for you
|
2020-05-09 20:30:20 -07:00
|
|
|
* to dig your fingers in and play with their behavior if you want. Note that
|
|
|
|
* the clients cannot set the selection directly without compositor approval,
|
|
|
|
* see the setsel() function. */
|
2020-07-21 15:35:46 -07:00
|
|
|
compositor = wlr_compositor_create(dpy, drw);
|
2020-08-03 09:20:12 -07:00
|
|
|
wlr_export_dmabuf_manager_v1_create(dpy);
|
2020-05-09 20:48:19 -07:00
|
|
|
wlr_screencopy_manager_v1_create(dpy);
|
2020-12-10 03:56:35 -08:00
|
|
|
wlr_data_control_manager_v1_create(dpy);
|
2020-04-23 19:16:01 -07:00
|
|
|
wlr_data_device_manager_create(dpy);
|
2020-08-22 09:09:38 -07:00
|
|
|
wlr_gamma_control_manager_v1_create(dpy);
|
2020-08-23 08:01:39 -07:00
|
|
|
wlr_primary_selection_v1_device_manager_create(dpy);
|
2020-08-03 09:20:12 -07:00
|
|
|
wlr_viewporter_create(dpy);
|
2020-04-11 15:27:19 -07:00
|
|
|
|
2021-05-22 19:18:48 -07:00
|
|
|
/* Initializes the interface used to implement urgency hints */
|
|
|
|
activation = wlr_xdg_activation_v1_create(dpy);
|
|
|
|
wl_signal_add(&activation->events.request_activate, &request_activate);
|
|
|
|
|
2020-04-11 15:27:19 -07:00
|
|
|
/* Creates an output layout, which a wlroots utility for working with an
|
|
|
|
* arrangement of screens in a physical layout. */
|
2020-04-21 12:15:19 -07:00
|
|
|
output_layout = wlr_output_layout_create();
|
2021-01-18 12:34:05 -08:00
|
|
|
wl_signal_add(&output_layout->events.change, &layout_change);
|
2020-05-09 21:01:30 -07:00
|
|
|
wlr_xdg_output_manager_v1_create(dpy, output_layout);
|
2020-04-11 15:27:19 -07:00
|
|
|
|
|
|
|
/* Configure a listener to be notified when new outputs are available on the
|
|
|
|
* backend. */
|
2020-04-21 12:47:59 -07:00
|
|
|
wl_list_init(&mons);
|
2020-04-21 12:15:19 -07:00
|
|
|
wl_signal_add(&backend->events.new_output, &new_output);
|
2020-04-11 15:27:19 -07:00
|
|
|
|
2020-04-23 19:45:43 -07:00
|
|
|
/* Set up our client lists and the xdg-shell. The xdg-shell is a
|
2020-04-22 08:42:40 -07:00
|
|
|
* Wayland protocol which is used for application windows. For more
|
|
|
|
* detail on shells, refer to the article:
|
2020-04-11 15:27:19 -07:00
|
|
|
*
|
|
|
|
* https://drewdevault.com/2018/07/29/Wayland-shells.html
|
|
|
|
*/
|
2020-04-21 12:47:59 -07:00
|
|
|
wl_list_init(&clients);
|
2020-04-22 08:42:40 -07:00
|
|
|
wl_list_init(&fstack);
|
2020-08-23 22:04:34 -07:00
|
|
|
|
2020-08-28 11:18:42 -07:00
|
|
|
idle = wlr_idle_create(dpy);
|
|
|
|
|
2021-07-12 17:58:55 -07:00
|
|
|
idle_inhibit_mgr = wlr_idle_inhibit_v1_create(dpy);
|
|
|
|
wl_signal_add(&idle_inhibit_mgr->events.new_inhibitor, &idle_inhibitor_create);
|
|
|
|
|
2020-08-23 22:04:34 -07:00
|
|
|
layer_shell = wlr_layer_shell_v1_create(dpy);
|
|
|
|
wl_signal_add(&layer_shell->events.new_surface, &new_layer_shell_surface);
|
|
|
|
|
2020-04-23 19:16:01 -07:00
|
|
|
xdg_shell = wlr_xdg_shell_create(dpy);
|
2020-05-09 08:05:34 -07:00
|
|
|
wl_signal_add(&xdg_shell->events.new_surface, &new_xdg_surface);
|
2020-04-11 15:27:19 -07:00
|
|
|
|
2021-07-03 13:48:40 -07:00
|
|
|
input_inhibit_mgr = wlr_input_inhibit_manager_create(dpy);
|
|
|
|
|
2021-04-09 10:37:49 -07:00
|
|
|
/* Use decoration protocols to negotiate server-side decorations */
|
|
|
|
wlr_server_decoration_manager_set_default_mode(
|
|
|
|
wlr_server_decoration_manager_create(dpy),
|
|
|
|
WLR_SERVER_DECORATION_MANAGER_MODE_SERVER);
|
|
|
|
wlr_xdg_decoration_manager_v1_create(dpy);
|
2020-06-04 21:36:04 -07:00
|
|
|
|
2020-04-11 15:27:19 -07:00
|
|
|
/*
|
|
|
|
* Creates a cursor, which is a wlroots utility for tracking the cursor
|
|
|
|
* image shown on screen.
|
|
|
|
*/
|
2020-04-21 12:15:19 -07:00
|
|
|
cursor = wlr_cursor_create();
|
|
|
|
wlr_cursor_attach_output_layout(cursor, output_layout);
|
2020-04-11 15:27:19 -07:00
|
|
|
|
|
|
|
/* Creates an xcursor manager, another wlroots utility which loads up
|
|
|
|
* Xcursor themes to source cursor images from and makes sure that cursor
|
|
|
|
* images are available at all scale factors on the screen (necessary for
|
2020-04-23 17:12:58 -07:00
|
|
|
* HiDPI support). Scaled cursors will be loaded with each output. */
|
2020-04-21 12:15:19 -07:00
|
|
|
cursor_mgr = wlr_xcursor_manager_create(NULL, 24);
|
2020-04-11 15:27:19 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* wlr_cursor *only* displays an image on screen. It does not move around
|
|
|
|
* when the pointer moves. However, we can attach input devices to it, and
|
|
|
|
* it will generate aggregate events for all of them. In these events, we
|
|
|
|
* can choose how we want to process them, forwarding them to clients and
|
|
|
|
* moving the cursor around. More detail on this process is described in my
|
|
|
|
* input handling blog post:
|
|
|
|
*
|
|
|
|
* https://drewdevault.com/2018/07/17/Input-handling-in-wlroots.html
|
|
|
|
*
|
|
|
|
* And more comments are sprinkled throughout the notify functions above.
|
|
|
|
*/
|
2020-04-21 12:15:19 -07:00
|
|
|
wl_signal_add(&cursor->events.motion, &cursor_motion);
|
2020-12-27 10:28:37 -08:00
|
|
|
wl_signal_add(&cursor->events.motion_absolute, &cursor_motion_absolute);
|
2020-04-21 12:15:19 -07:00
|
|
|
wl_signal_add(&cursor->events.button, &cursor_button);
|
|
|
|
wl_signal_add(&cursor->events.axis, &cursor_axis);
|
|
|
|
wl_signal_add(&cursor->events.frame, &cursor_frame);
|
2020-04-11 15:27:19 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2020-04-21 12:15:19 -07:00
|
|
|
wl_list_init(&keyboards);
|
|
|
|
wl_signal_add(&backend->events.new_input, &new_input);
|
2020-12-08 03:17:14 -08:00
|
|
|
virtual_keyboard_mgr = wlr_virtual_keyboard_manager_v1_create(dpy);
|
|
|
|
wl_signal_add(&virtual_keyboard_mgr->events.new_virtual_keyboard,
|
|
|
|
&new_virtual_keyboard);
|
2020-04-23 19:16:01 -07:00
|
|
|
seat = wlr_seat_create(dpy, "seat0");
|
2022-03-11 21:02:37 -08:00
|
|
|
wl_signal_add(&seat->events.request_set_cursor, &request_cursor);
|
|
|
|
wl_signal_add(&seat->events.request_set_selection, &request_set_sel);
|
|
|
|
wl_signal_add(&seat->events.request_set_primary_selection, &request_set_psel);
|
2022-03-21 15:03:52 -07:00
|
|
|
wl_signal_add(&seat->events.request_start_drag, &request_start_drag);
|
|
|
|
wl_signal_add(&seat->events.start_drag, &start_drag);
|
2020-07-21 15:35:46 -07:00
|
|
|
|
2020-10-17 11:11:31 -07:00
|
|
|
output_mgr = wlr_output_manager_v1_create(dpy);
|
|
|
|
wl_signal_add(&output_mgr->events.apply, &output_mgr_apply);
|
|
|
|
wl_signal_add(&output_mgr->events.test, &output_mgr_test);
|
|
|
|
|
2022-03-23 14:01:04 -07:00
|
|
|
wlr_scene_set_presentation(scene, wlr_presentation_create(dpy, backend));
|
2021-08-02 07:33:38 -07:00
|
|
|
|
2020-08-10 10:50:56 -07:00
|
|
|
#ifdef XWAYLAND
|
2020-07-21 15:35:46 -07:00
|
|
|
/*
|
|
|
|
* Initialise the XWayland X server.
|
|
|
|
* It will be started when the first X client is started.
|
|
|
|
*/
|
2020-12-24 18:56:41 -08:00
|
|
|
xwayland = wlr_xwayland_create(dpy, compositor, 1);
|
2020-07-21 15:35:46 -07:00
|
|
|
if (xwayland) {
|
2020-07-24 21:40:04 -07:00
|
|
|
wl_signal_add(&xwayland->events.ready, &xwayland_ready);
|
2020-07-21 15:35:46 -07:00
|
|
|
wl_signal_add(&xwayland->events.new_surface, &new_xwayland_surface);
|
|
|
|
|
2020-12-24 18:56:41 -08:00
|
|
|
setenv("DISPLAY", xwayland->display_name, 1);
|
2020-07-21 15:35:46 -07:00
|
|
|
} else {
|
|
|
|
fprintf(stderr, "failed to setup XWayland X server, continuing without it\n");
|
|
|
|
}
|
2020-08-10 10:50:56 -07:00
|
|
|
#endif
|
2020-04-21 16:57:04 -07:00
|
|
|
}
|
2020-04-11 15:27:19 -07:00
|
|
|
|
2021-03-13 08:42:33 -08:00
|
|
|
void
|
|
|
|
sigchld(int unused)
|
|
|
|
{
|
|
|
|
/* We should be able to remove this function in favor of a simple
|
|
|
|
* signal(SIGCHLD, SIG_IGN);
|
|
|
|
* but the Xwayland implementation in wlroots currently prevents us from
|
|
|
|
* setting our own disposition for SIGCHLD.
|
|
|
|
*/
|
|
|
|
if (signal(SIGCHLD, sigchld) == SIG_ERR)
|
2022-03-15 14:52:26 -07:00
|
|
|
die("can't install SIGCHLD handler:");
|
2021-03-13 08:42:33 -08:00
|
|
|
while (0 < waitpid(-1, NULL, WNOHANG))
|
|
|
|
;
|
|
|
|
}
|
|
|
|
|
2020-04-21 16:57:04 -07:00
|
|
|
void
|
|
|
|
spawn(const Arg *arg)
|
|
|
|
{
|
|
|
|
if (fork() == 0) {
|
2021-03-06 10:20:56 -08:00
|
|
|
dup2(STDERR_FILENO, STDOUT_FILENO);
|
2020-04-21 16:57:04 -07:00
|
|
|
setsid();
|
|
|
|
execvp(((char **)arg->v)[0], (char **)arg->v);
|
2022-03-15 14:52:26 -07:00
|
|
|
die("dwl: execvp %s failed:", ((char **)arg->v)[0]);
|
2020-04-11 15:27:19 -07:00
|
|
|
}
|
2020-04-21 16:57:04 -07:00
|
|
|
}
|
2020-04-11 15:27:19 -07:00
|
|
|
|
2022-03-21 15:03:52 -07:00
|
|
|
void
|
|
|
|
startdrag(struct wl_listener *listener, void *data)
|
|
|
|
{
|
|
|
|
struct wlr_drag *drag = data;
|
|
|
|
|
|
|
|
if (!drag->icon)
|
|
|
|
return;
|
|
|
|
|
2022-03-23 12:50:08 -07:00
|
|
|
drag->icon->data = wlr_scene_subsurface_tree_create(layers[LyrNoFocus], drag->icon->surface);
|
2022-03-23 13:18:38 -07:00
|
|
|
motionnotify(0);
|
2022-03-21 15:03:52 -07:00
|
|
|
wl_signal_add(&drag->icon->events.destroy, &drag_icon_destroy);
|
|
|
|
}
|
|
|
|
|
2020-04-23 17:53:49 -07:00
|
|
|
void
|
|
|
|
tag(const Arg *arg)
|
|
|
|
{
|
|
|
|
Client *sel = selclient();
|
|
|
|
if (sel && arg->ui & TAGMASK) {
|
|
|
|
sel->tags = arg->ui & TAGMASK;
|
2020-12-24 18:56:41 -08:00
|
|
|
focusclient(focustop(selmon), 1);
|
2020-04-26 20:02:47 -07:00
|
|
|
arrange(selmon);
|
2020-04-23 17:53:49 -07:00
|
|
|
}
|
2021-03-13 09:20:33 -08:00
|
|
|
printstatus();
|
2020-04-23 17:53:49 -07:00
|
|
|
}
|
|
|
|
|
2020-04-23 18:40:02 -07:00
|
|
|
void
|
|
|
|
tagmon(const Arg *arg)
|
|
|
|
{
|
|
|
|
Client *sel = selclient();
|
|
|
|
if (!sel)
|
|
|
|
return;
|
2020-05-02 22:44:16 -07:00
|
|
|
setmon(sel, dirtomon(arg->i), 0);
|
2020-04-23 18:40:02 -07:00
|
|
|
}
|
|
|
|
|
2020-04-22 06:25:43 -07:00
|
|
|
void
|
|
|
|
tile(Monitor *m)
|
|
|
|
{
|
|
|
|
unsigned int i, n = 0, h, mw, my, ty;
|
|
|
|
Client *c;
|
|
|
|
|
2020-05-03 09:23:51 -07:00
|
|
|
wl_list_for_each(c, &clients, link)
|
2022-03-13 16:11:52 -07:00
|
|
|
if (VISIBLEON(c, m) && !c->isfloating && !c->isfullscreen)
|
2020-04-22 06:25:43 -07:00
|
|
|
n++;
|
|
|
|
if (n == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (n > m->nmaster)
|
2020-04-26 10:41:33 -07:00
|
|
|
mw = m->nmaster ? m->w.width * m->mfact : 0;
|
2020-04-22 06:25:43 -07:00
|
|
|
else
|
2020-04-26 10:41:33 -07:00
|
|
|
mw = m->w.width;
|
2020-04-22 06:25:43 -07:00
|
|
|
i = my = ty = 0;
|
|
|
|
wl_list_for_each(c, &clients, link) {
|
2021-03-25 08:05:12 -07:00
|
|
|
if (!VISIBLEON(c, m) || c->isfloating || c->isfullscreen)
|
2020-04-22 06:25:43 -07:00
|
|
|
continue;
|
2021-03-25 08:05:12 -07:00
|
|
|
if (i < m->nmaster) {
|
2020-04-26 10:41:33 -07:00
|
|
|
h = (m->w.height - my) / (MIN(n, m->nmaster) - i);
|
2020-04-26 11:18:20 -07:00
|
|
|
resize(c, m->w.x, m->w.y + my, mw, h, 0);
|
2020-04-26 20:12:08 -07:00
|
|
|
my += c->geom.height;
|
2020-04-22 06:25:43 -07:00
|
|
|
} else {
|
2020-04-26 10:41:33 -07:00
|
|
|
h = (m->w.height - ty) / (n - i);
|
2020-04-26 11:18:20 -07:00
|
|
|
resize(c, m->w.x + mw, m->w.y + ty, m->w.width - mw, h, 0);
|
2020-04-26 20:12:08 -07:00
|
|
|
ty += c->geom.height;
|
2020-04-22 06:25:43 -07:00
|
|
|
}
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-04-23 17:23:57 -07:00
|
|
|
void
|
|
|
|
togglefloating(const Arg *arg)
|
|
|
|
{
|
|
|
|
Client *sel = selclient();
|
|
|
|
/* return if fullscreen */
|
2022-03-11 21:02:37 -08:00
|
|
|
if (sel && !sel->isfullscreen)
|
|
|
|
setfloating(sel, !sel->isfloating);
|
2020-04-23 17:23:57 -07:00
|
|
|
}
|
|
|
|
|
2022-04-05 21:04:04 -07:00
|
|
|
void
|
|
|
|
togglefullscreen(const Arg *arg)
|
|
|
|
{
|
|
|
|
Client *sel = selclient();
|
|
|
|
if (sel)
|
|
|
|
setfullscreen(sel, !sel->isfullscreen);
|
|
|
|
}
|
|
|
|
|
2020-04-23 18:02:17 -07:00
|
|
|
void
|
|
|
|
toggletag(const Arg *arg)
|
|
|
|
{
|
2020-12-24 19:21:00 -08:00
|
|
|
unsigned int newtags;
|
2020-04-23 18:02:17 -07:00
|
|
|
Client *sel = selclient();
|
|
|
|
if (!sel)
|
|
|
|
return;
|
2020-12-24 19:21:00 -08:00
|
|
|
newtags = sel->tags ^ (arg->ui & TAGMASK);
|
2020-04-23 18:02:17 -07:00
|
|
|
if (newtags) {
|
|
|
|
sel->tags = newtags;
|
2020-12-24 18:56:41 -08:00
|
|
|
focusclient(focustop(selmon), 1);
|
2020-04-26 20:02:47 -07:00
|
|
|
arrange(selmon);
|
2020-04-23 18:02:17 -07:00
|
|
|
}
|
2021-03-13 09:20:33 -08:00
|
|
|
printstatus();
|
2020-04-23 18:02:17 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
toggleview(const Arg *arg)
|
|
|
|
{
|
|
|
|
unsigned int newtagset = selmon->tagset[selmon->seltags] ^ (arg->ui & TAGMASK);
|
|
|
|
|
|
|
|
if (newtagset) {
|
|
|
|
selmon->tagset[selmon->seltags] = newtagset;
|
2020-12-24 18:56:41 -08:00
|
|
|
focusclient(focustop(selmon), 1);
|
2020-04-26 20:02:47 -07:00
|
|
|
arrange(selmon);
|
2020-04-23 18:02:17 -07:00
|
|
|
}
|
2021-03-13 09:20:33 -08:00
|
|
|
printstatus();
|
2020-04-23 18:02:17 -07:00
|
|
|
}
|
|
|
|
|
2020-08-23 22:04:34 -07:00
|
|
|
void
|
2020-08-26 10:41:45 -07:00
|
|
|
unmaplayersurface(LayerSurface *layersurface)
|
2020-08-23 22:04:34 -07:00
|
|
|
{
|
2020-12-24 18:56:41 -08:00
|
|
|
layersurface->layer_surface->mapped = 0;
|
2020-09-04 07:37:22 -07:00
|
|
|
if (layersurface->layer_surface->surface ==
|
|
|
|
seat->keyboard_state.focused_surface)
|
2020-12-24 18:56:41 -08:00
|
|
|
focusclient(selclient(), 1);
|
2020-09-04 08:58:53 -07:00
|
|
|
motionnotify(0);
|
2020-08-23 22:04:34 -07:00
|
|
|
}
|
|
|
|
|
2020-09-04 08:01:34 -07:00
|
|
|
void
|
|
|
|
unmaplayersurfacenotify(struct wl_listener *listener, void *data)
|
|
|
|
{
|
|
|
|
LayerSurface *layersurface = wl_container_of(listener, layersurface, unmap);
|
|
|
|
unmaplayersurface(layersurface);
|
|
|
|
}
|
|
|
|
|
2020-04-21 16:57:04 -07:00
|
|
|
void
|
|
|
|
unmapnotify(struct wl_listener *listener, void *data)
|
|
|
|
{
|
|
|
|
/* Called when the surface is unmapped, and should no longer be shown. */
|
|
|
|
Client *c = wl_container_of(listener, c, unmap);
|
2021-09-04 04:46:58 -07:00
|
|
|
if (c == grabc) {
|
|
|
|
cursor_mode = CurNormal;
|
|
|
|
grabc = NULL;
|
|
|
|
}
|
2022-03-20 11:32:44 -07:00
|
|
|
|
2022-02-28 14:46:24 -08:00
|
|
|
if (c->mon)
|
|
|
|
c->mon->un_map = 1;
|
|
|
|
|
2022-03-18 00:03:33 -07:00
|
|
|
if (client_is_unmanaged(c)) {
|
|
|
|
wlr_scene_node_destroy(c->scene);
|
2020-07-25 08:55:18 -07:00
|
|
|
return;
|
2022-03-18 00:03:33 -07:00
|
|
|
}
|
2020-12-24 22:33:55 -08:00
|
|
|
|
2022-03-20 11:32:44 -07:00
|
|
|
wl_list_remove(&c->link);
|
2020-07-25 08:55:18 -07:00
|
|
|
setmon(c, NULL, 0);
|
2020-04-22 08:42:40 -07:00
|
|
|
wl_list_remove(&c->flink);
|
2021-09-05 14:07:28 -07:00
|
|
|
wlr_scene_node_destroy(c->scene);
|
2021-12-31 12:51:50 -08:00
|
|
|
printstatus();
|
2020-04-21 16:57:04 -07:00
|
|
|
}
|
2020-04-11 15:27:19 -07:00
|
|
|
|
2020-09-11 05:24:39 -07:00
|
|
|
void
|
2021-01-18 12:34:05 -08:00
|
|
|
updatemons(struct wl_listener *listener, void *data)
|
2020-09-11 05:24:39 -07:00
|
|
|
{
|
2021-01-18 13:51:32 -08:00
|
|
|
/*
|
|
|
|
* Called whenever the output layout changes: adding or removing a
|
|
|
|
* monitor, changing an output's mode or position, etc. This is where
|
|
|
|
* the change officially happens and we update geometry, window
|
|
|
|
* positions, focus, and the stored configuration in wlroots'
|
|
|
|
* output-manager implementation.
|
|
|
|
*/
|
2020-10-17 11:11:31 -07:00
|
|
|
struct wlr_output_configuration_v1 *config =
|
|
|
|
wlr_output_configuration_v1_create();
|
2020-09-11 05:24:39 -07:00
|
|
|
Monitor *m;
|
2020-10-18 09:37:55 -07:00
|
|
|
sgeom = *wlr_output_layout_get_box(output_layout, NULL);
|
2020-09-11 05:24:39 -07:00
|
|
|
wl_list_for_each(m, &mons, link) {
|
2020-10-17 11:11:31 -07:00
|
|
|
struct wlr_output_configuration_head_v1 *config_head =
|
|
|
|
wlr_output_configuration_head_v1_create(config, m->wlr_output);
|
|
|
|
|
2021-01-18 13:38:25 -08:00
|
|
|
/* TODO: move clients off disabled monitors */
|
|
|
|
/* TODO: move focus if selmon is disabled */
|
|
|
|
|
2020-09-11 05:24:39 -07:00
|
|
|
/* Get the effective monitor geometry to use for surfaces */
|
|
|
|
m->m = m->w = *wlr_output_layout_get_box(output_layout, m->wlr_output);
|
2021-09-05 20:35:07 -07:00
|
|
|
wlr_scene_output_set_position(m->scene_output, m->m.x, m->m.y);
|
2020-09-11 05:24:39 -07:00
|
|
|
/* Calculate the effective monitor geometry to use for clients */
|
|
|
|
arrangelayers(m);
|
|
|
|
/* Don't move clients to the left output when plugging monitors */
|
|
|
|
arrange(m);
|
2020-10-17 11:11:31 -07:00
|
|
|
|
|
|
|
config_head->state.enabled = m->wlr_output->enabled;
|
|
|
|
config_head->state.mode = m->wlr_output->current_mode;
|
|
|
|
config_head->state.x = m->m.x;
|
|
|
|
config_head->state.y = m->m.y;
|
2020-09-11 05:24:39 -07:00
|
|
|
}
|
2020-10-17 11:11:31 -07:00
|
|
|
|
|
|
|
wlr_output_manager_v1_set_configuration(output_mgr, config);
|
2020-09-11 05:24:39 -07:00
|
|
|
}
|
|
|
|
|
2021-04-15 11:05:05 -07:00
|
|
|
void
|
|
|
|
updatetitle(struct wl_listener *listener, void *data)
|
|
|
|
{
|
|
|
|
Client *c = wl_container_of(listener, c, set_title);
|
|
|
|
if (c == focustop(c->mon))
|
|
|
|
printstatus();
|
|
|
|
}
|
|
|
|
|
2020-04-23 17:53:49 -07:00
|
|
|
void
|
2021-05-22 19:18:48 -07:00
|
|
|
urgent(struct wl_listener *listener, void *data)
|
|
|
|
{
|
|
|
|
struct wlr_xdg_activation_v1_request_activate_event *event = data;
|
2022-05-23 07:14:21 -07:00
|
|
|
Client *c = client_from_wlr_surface(event->surface);
|
2021-05-22 19:18:48 -07:00
|
|
|
if (c != selclient()) {
|
|
|
|
c->isurgent = 1;
|
|
|
|
printstatus();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2020-04-23 17:53:49 -07:00
|
|
|
view(const Arg *arg)
|
|
|
|
{
|
|
|
|
if ((arg->ui & TAGMASK) == selmon->tagset[selmon->seltags])
|
|
|
|
return;
|
|
|
|
selmon->seltags ^= 1; /* toggle sel tagset */
|
|
|
|
if (arg->ui & TAGMASK)
|
|
|
|
selmon->tagset[selmon->seltags] = arg->ui & TAGMASK;
|
2020-12-24 18:56:41 -08:00
|
|
|
focusclient(focustop(selmon), 1);
|
2020-04-26 20:02:47 -07:00
|
|
|
arrange(selmon);
|
2021-03-13 09:20:33 -08:00
|
|
|
printstatus();
|
2020-04-23 17:53:49 -07:00
|
|
|
}
|
|
|
|
|
2020-12-08 03:17:14 -08:00
|
|
|
void
|
|
|
|
virtualkeyboard(struct wl_listener *listener, void *data)
|
|
|
|
{
|
|
|
|
struct wlr_virtual_keyboard_v1 *keyboard = data;
|
|
|
|
struct wlr_input_device *device = &keyboard->input_device;
|
|
|
|
createkeyboard(device);
|
|
|
|
}
|
|
|
|
|
2022-04-05 21:04:04 -07:00
|
|
|
Monitor *
|
|
|
|
xytomon(double x, double y)
|
|
|
|
{
|
|
|
|
struct wlr_output *o = wlr_output_layout_output_at(output_layout, x, y);
|
|
|
|
return o ? o->data : NULL;
|
|
|
|
}
|
|
|
|
|
2021-09-05 14:07:28 -07:00
|
|
|
struct wlr_scene_node *
|
|
|
|
xytonode(double x, double y, struct wlr_surface **psurface,
|
|
|
|
Client **pc, LayerSurface **pl, double *nx, double *ny)
|
2020-09-03 22:38:14 -07:00
|
|
|
{
|
2021-09-05 14:07:28 -07:00
|
|
|
struct wlr_scene_node *node, *pnode;
|
|
|
|
struct wlr_surface *surface = NULL;
|
|
|
|
Client *c = NULL;
|
|
|
|
LayerSurface *l = NULL;
|
2022-04-15 15:40:02 -07:00
|
|
|
const int *layer;
|
2022-03-23 12:50:08 -07:00
|
|
|
int focus_order[] = { LyrOverlay, LyrTop, LyrFloat, LyrTile, LyrBottom, LyrBg };
|
|
|
|
|
2022-04-15 15:40:02 -07:00
|
|
|
for (layer = focus_order; layer < END(focus_order); layer++) {
|
|
|
|
if ((node = wlr_scene_node_at(layers[*layer], x, y, nx, ny))) {
|
2022-03-23 12:50:08 -07:00
|
|
|
if (node->type == WLR_SCENE_NODE_SURFACE)
|
|
|
|
surface = wlr_scene_surface_from_node(node)->surface;
|
|
|
|
/* Walk the tree to find a node that knows the client */
|
|
|
|
for (pnode = node; pnode && !c; pnode = pnode->parent)
|
|
|
|
c = pnode->data;
|
|
|
|
if (c && c->type == LayerShell) {
|
|
|
|
c = NULL;
|
|
|
|
l = pnode->data;
|
|
|
|
}
|
2021-09-05 14:07:28 -07:00
|
|
|
}
|
2022-03-23 12:50:08 -07:00
|
|
|
if (surface)
|
|
|
|
break;
|
2020-09-03 22:38:14 -07:00
|
|
|
}
|
2021-09-05 14:07:28 -07:00
|
|
|
|
|
|
|
if (psurface) *psurface = surface;
|
|
|
|
if (pc) *pc = c;
|
|
|
|
if (pl) *pl = l;
|
|
|
|
return node;
|
2020-09-03 22:38:14 -07:00
|
|
|
}
|
|
|
|
|
2020-07-24 08:12:41 -07:00
|
|
|
void
|
|
|
|
zoom(const Arg *arg)
|
|
|
|
{
|
deactivate focused client when spawning a new one
Because maprequest immediately calls wl_list_insert(&fstack, &c->flink),
in the following call to setmon(), the selclient() which is passed to
focusclient() as the old client is actually the newly mapped client, and
the real old one is never deactivated. You can see this by, for example,
opening Chromium's devtools, then spawning a terminal. The background of
the focused line in the devtools doesn't change from light blue to grey.
We can't just remove wl_list_insert(&fstack, &c->flink) from maprequest,
because calling wl_list_remove in focusclient() with a client that has
not been added to the list causes a segmentation fault.
Therefore we fix the focusclient call by not passing it the old client
every time, but instead using the wlroots function that gets the focused
surface and deactivate that, like in TinyWL.
This also avoids getting the selected client and passing it to
focusclient() on every call unnecessarily, and will allow removing
shouldfocusclients in a future commit by checking if old is a layer
surface instead.
2020-12-18 21:57:14 -08:00
|
|
|
Client *c, *sel = selclient();
|
2020-07-24 08:12:41 -07:00
|
|
|
|
|
|
|
if (!sel || !selmon->lt[selmon->sellt]->arrange || sel->isfloating)
|
|
|
|
return;
|
|
|
|
|
2020-07-24 14:35:19 -07:00
|
|
|
/* Search for the first tiled window that is not sel, marking sel as
|
|
|
|
* NULL if we pass it along the way */
|
2020-07-24 08:12:41 -07:00
|
|
|
wl_list_for_each(c, &clients, link)
|
|
|
|
if (VISIBLEON(c, selmon) && !c->isfloating) {
|
2020-07-24 14:35:19 -07:00
|
|
|
if (c != sel)
|
2020-07-24 08:12:41 -07:00
|
|
|
break;
|
2020-07-24 14:35:19 -07:00
|
|
|
sel = NULL;
|
2020-07-24 08:12:41 -07:00
|
|
|
}
|
|
|
|
|
2020-07-24 14:35:19 -07:00
|
|
|
/* Return if no other tiled window was found */
|
|
|
|
if (&c->link == &clients)
|
2020-07-24 08:12:41 -07:00
|
|
|
return;
|
|
|
|
|
2020-07-24 14:35:19 -07:00
|
|
|
/* If we passed sel, move c to the front; otherwise, move sel to the
|
|
|
|
* front */
|
|
|
|
if (!sel)
|
|
|
|
sel = c;
|
2020-07-24 08:12:41 -07:00
|
|
|
wl_list_remove(&sel->link);
|
|
|
|
wl_list_insert(&clients, &sel->link);
|
2020-07-24 14:35:19 -07:00
|
|
|
|
2020-12-24 18:56:41 -08:00
|
|
|
focusclient(sel, 1);
|
2020-07-24 08:12:41 -07:00
|
|
|
arrange(selmon);
|
|
|
|
}
|
|
|
|
|
2020-08-10 10:50:56 -07:00
|
|
|
#ifdef XWAYLAND
|
|
|
|
void
|
|
|
|
activatex11(struct wl_listener *listener, void *data)
|
|
|
|
{
|
2021-02-14 10:43:10 -08:00
|
|
|
Client *c = wl_container_of(listener, c, activate);
|
2020-08-10 10:50:56 -07:00
|
|
|
|
2021-02-14 10:43:10 -08:00
|
|
|
/* Only "managed" windows can be activated */
|
|
|
|
if (c->type == X11Managed)
|
|
|
|
wlr_xwayland_surface_activate(c->surface.xwayland, 1);
|
2020-08-10 10:50:56 -07:00
|
|
|
}
|
|
|
|
|
2020-12-08 06:10:41 -08:00
|
|
|
void
|
|
|
|
configurex11(struct wl_listener *listener, void *data)
|
|
|
|
{
|
|
|
|
Client *c = wl_container_of(listener, c, configure);
|
|
|
|
struct wlr_xwayland_surface_configure_event *event = data;
|
|
|
|
wlr_xwayland_surface_configure(c->surface.xwayland,
|
|
|
|
event->x, event->y, event->width, event->height);
|
|
|
|
}
|
|
|
|
|
2020-08-10 10:50:56 -07:00
|
|
|
void
|
|
|
|
createnotifyx11(struct wl_listener *listener, void *data)
|
|
|
|
{
|
2020-12-24 19:39:45 -08:00
|
|
|
struct wlr_xwayland_surface *xwayland_surface = data;
|
2020-08-10 10:50:56 -07:00
|
|
|
Client *c;
|
2020-10-14 08:28:51 -07:00
|
|
|
wl_list_for_each(c, &clients, link)
|
|
|
|
if (c->isfullscreen && VISIBLEON(c, c->mon))
|
2020-12-24 18:56:41 -08:00
|
|
|
setfullscreen(c, 0);
|
2020-08-10 10:50:56 -07:00
|
|
|
|
|
|
|
/* Allocate a Client for this surface */
|
2022-03-15 14:52:26 -07:00
|
|
|
c = xwayland_surface->data = ecalloc(1, sizeof(*c));
|
2020-08-10 10:50:56 -07:00
|
|
|
c->surface.xwayland = xwayland_surface;
|
|
|
|
c->type = xwayland_surface->override_redirect ? X11Unmanaged : X11Managed;
|
|
|
|
c->bw = borderpx;
|
2020-12-27 10:28:37 -08:00
|
|
|
c->isfullscreen = 0;
|
2020-08-10 10:50:56 -07:00
|
|
|
|
|
|
|
/* Listen to the various events it can emit */
|
2020-12-27 10:28:37 -08:00
|
|
|
LISTEN(&xwayland_surface->events.map, &c->map, mapnotify);
|
|
|
|
LISTEN(&xwayland_surface->events.unmap, &c->unmap, unmapnotify);
|
2022-03-11 21:02:37 -08:00
|
|
|
LISTEN(&xwayland_surface->events.request_activate, &c->activate, activatex11);
|
2020-12-27 10:28:37 -08:00
|
|
|
LISTEN(&xwayland_surface->events.request_configure, &c->configure,
|
|
|
|
configurex11);
|
2022-05-17 12:38:18 -07:00
|
|
|
LISTEN(&xwayland_surface->events.set_hints, &c->set_hints, sethints);
|
2021-04-15 11:05:05 -07:00
|
|
|
LISTEN(&xwayland_surface->events.set_title, &c->set_title, updatetitle);
|
2020-12-27 10:28:37 -08:00
|
|
|
LISTEN(&xwayland_surface->events.destroy, &c->destroy, destroynotify);
|
|
|
|
LISTEN(&xwayland_surface->events.request_fullscreen, &c->fullscreen,
|
|
|
|
fullscreennotify);
|
2020-08-10 10:50:56 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
Atom
|
|
|
|
getatom(xcb_connection_t *xc, const char *name)
|
|
|
|
{
|
|
|
|
Atom atom = 0;
|
|
|
|
xcb_intern_atom_reply_t *reply;
|
2020-12-19 10:50:01 -08:00
|
|
|
xcb_intern_atom_cookie_t cookie = xcb_intern_atom(xc, 0, strlen(name), name);
|
2020-08-10 10:50:56 -07:00
|
|
|
if ((reply = xcb_intern_atom_reply(xc, cookie, NULL)))
|
|
|
|
atom = reply->atom;
|
|
|
|
free(reply);
|
|
|
|
|
|
|
|
return atom;
|
|
|
|
}
|
|
|
|
|
2022-05-17 12:38:18 -07:00
|
|
|
void
|
|
|
|
sethints(struct wl_listener *listener, void *data)
|
|
|
|
{
|
|
|
|
Client *c = wl_container_of(listener, c, set_hints);
|
|
|
|
if (c != selclient()) {
|
|
|
|
c->isurgent = c->surface.xwayland->hints_urgency;
|
|
|
|
printstatus();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-08-10 10:50:56 -07:00
|
|
|
void
|
|
|
|
xwaylandready(struct wl_listener *listener, void *data)
|
|
|
|
{
|
2020-12-24 19:39:45 -08:00
|
|
|
struct wlr_xcursor *xcursor;
|
2020-08-10 10:50:56 -07:00
|
|
|
xcb_connection_t *xc = xcb_connect(xwayland->display_name, NULL);
|
|
|
|
int err = xcb_connection_has_error(xc);
|
|
|
|
if (err) {
|
|
|
|
fprintf(stderr, "xcb_connect to X server failed with code %d\n. Continuing with degraded functionality.\n", err);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Collect atoms we are interested in. If getatom returns 0, we will
|
|
|
|
* not detect that window type. */
|
|
|
|
netatom[NetWMWindowTypeDialog] = getatom(xc, "_NET_WM_WINDOW_TYPE_DIALOG");
|
|
|
|
netatom[NetWMWindowTypeSplash] = getatom(xc, "_NET_WM_WINDOW_TYPE_SPLASH");
|
2021-01-11 04:47:04 -08:00
|
|
|
netatom[NetWMWindowTypeToolbar] = getatom(xc, "_NET_WM_WINDOW_TYPE_TOOLBAR");
|
|
|
|
netatom[NetWMWindowTypeUtility] = getatom(xc, "_NET_WM_WINDOW_TYPE_UTILITY");
|
2020-08-10 10:50:56 -07:00
|
|
|
|
|
|
|
/* assign the one and only seat */
|
|
|
|
wlr_xwayland_set_seat(xwayland, seat);
|
|
|
|
|
2020-12-20 05:29:45 -08:00
|
|
|
/* Set the default XWayland cursor to match the rest of dwl. */
|
2020-12-27 11:00:07 -08:00
|
|
|
if ((xcursor = wlr_xcursor_manager_get_xcursor(cursor_mgr, "left_ptr", 1)))
|
|
|
|
wlr_xwayland_set_cursor(xwayland,
|
|
|
|
xcursor->images[0]->buffer, xcursor->images[0]->width * 4,
|
|
|
|
xcursor->images[0]->width, xcursor->images[0]->height,
|
|
|
|
xcursor->images[0]->hotspot_x, xcursor->images[0]->hotspot_y);
|
2020-12-20 05:29:45 -08:00
|
|
|
|
2020-08-10 10:50:56 -07:00
|
|
|
xcb_disconnect(xc);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2020-04-21 16:57:04 -07:00
|
|
|
int
|
|
|
|
main(int argc, char *argv[])
|
|
|
|
{
|
|
|
|
char *startup_cmd = NULL;
|
|
|
|
int c;
|
2020-08-18 22:30:00 -07:00
|
|
|
|
2022-05-09 12:52:03 -07:00
|
|
|
while ((c = getopt(argc, argv, "s:hv")) != -1) {
|
2020-08-18 22:30:00 -07:00
|
|
|
if (c == 's')
|
2020-04-21 16:57:04 -07:00
|
|
|
startup_cmd = optarg;
|
2022-05-09 12:52:03 -07:00
|
|
|
else if (c == 'v')
|
|
|
|
die("dwl " VERSION);
|
2020-08-18 22:30:00 -07:00
|
|
|
else
|
2020-06-03 13:05:12 -07:00
|
|
|
goto usage;
|
2020-04-21 16:57:04 -07:00
|
|
|
}
|
2020-06-03 13:05:12 -07:00
|
|
|
if (optind < argc)
|
|
|
|
goto usage;
|
2020-04-21 16:57:04 -07:00
|
|
|
|
2022-03-11 16:52:22 -08:00
|
|
|
/* Wayland requires XDG_RUNTIME_DIR for creating its communications socket */
|
2020-08-18 17:39:34 -07:00
|
|
|
if (!getenv("XDG_RUNTIME_DIR"))
|
2022-03-15 14:52:26 -07:00
|
|
|
die("XDG_RUNTIME_DIR must be set");
|
2020-04-21 16:57:04 -07:00
|
|
|
setup();
|
|
|
|
run(startup_cmd);
|
2020-08-18 22:32:57 -07:00
|
|
|
cleanup();
|
2020-04-23 20:20:54 -07:00
|
|
|
return EXIT_SUCCESS;
|
2020-06-03 13:05:12 -07:00
|
|
|
|
|
|
|
usage:
|
2022-05-10 09:39:33 -07:00
|
|
|
die("Usage: %s [-v] [-s startup command]", argv[0]);
|
2020-04-11 15:27:19 -07:00
|
|
|
}
|