@@ 3,6 3,7 @@
*/
#include <getopt.h>
#include <libinput.h>
+#include <limits.h>
#include <linux/input-event-codes.h>
#include <math.h>
#include <signal.h>
@@ 16,6 17,7 @@
#include <wlr/backend.h>
#include <wlr/backend/libinput.h>
#include <wlr/render/allocator.h>
+#include <wlr/render/swapchain.h>
#include <wlr/render/wlr_renderer.h>
#include <wlr/types/wlr_alpha_modifier_v1.h>
#include <wlr/types/wlr_compositor.h>
@@ 25,6 27,10 @@
#include <wlr/types/wlr_data_device.h>
#include <wlr/types/wlr_drm.h>
#include <wlr/types/wlr_export_dmabuf_v1.h>
+#include <wlr/types/wlr_ext_data_control_v1.h>
+#include <wlr/types/wlr_ext_image_capture_source_v1.h>
+#include <wlr/types/wlr_ext_image_copy_capture_v1.h>
+#include <wlr/types/wlr_ext_foreign_toplevel_list_v1.h>
#include <wlr/types/wlr_fractional_scale_v1.h>
#include <wlr/types/wlr_gamma_control_v1.h>
#include <wlr/types/wlr_idle_inhibit_v1.h>
@@ 40,6 46,7 @@
#include <wlr/types/wlr_output_layout.h>
#include <wlr/types/wlr_output_management_v1.h>
#include <wlr/types/wlr_output_power_management_v1.h>
+#include <wlr/types/wlr_output_swapchain_manager.h>
#include <wlr/types/wlr_pointer.h>
#include <wlr/types/wlr_pointer_constraints_v1.h>
#include <wlr/types/wlr_presentation_time.h>
@@ 72,16 79,13 @@
#endif
#include "dwl-ipc-unstable-v2-protocol.h"
+#include "xdg-shell-protocol.h"
#include "util.h"
/* macros */
-#define MAX(A, B) ((A) > (B) ? (A) : (B))
-#define MIN(A, B) ((A) < (B) ? (A) : (B))
#define CLEANMASK(mask) (mask & ~WLR_MODIFIER_CAPS)
#define VISIBLEON(C, M) ((M) && (C)->mon == (M) && ((((C)->tags & (M)->tagset[(M)->seltags])) || (C)->issticky))
#define SVISIBLEON(C, M) ((M) && (C)->mon && (((C)->tags & (M)->tagset[(M)->seltags]) && !(C)->issticky) || ((C)->issticky && (C)->mon == (M)))
-#define LENGTH(X) (sizeof X / sizeof X[0])
-#define END(A) ((A) + LENGTH(A))
#define TAGMASK ((1u << TAGCOUNT) - 1)
#define LISTEN(E, L, H) wl_signal_add((E), ((L)->notify = (H), (L)))
#define LISTEN_STATIC(E, H) do { struct wl_listener *_l = ecalloc(1, sizeof(*_l)); _l->notify = (H); wl_signal_add((E), _l); } while (0)
@@ 89,7 93,9 @@
/* enums */
enum { CurNormal, CurPressed, CurMove, CurResize }; /* cursor */
enum { XDGShell, LayerShell, X11 }; /* client types */
-enum { LyrBg, LyrBottom, LyrTile, LyrFloat, LyrTop, LyrFS, LyrOverlay, LyrBlock, NUM_LAYERS }; /* scene layers */
+enum { LyrBg, LyrBottom, LyrTile, LyrFloat, LyrTop, LyrFS, LyrUnmanaged, LyrOverlay,
+ LyrIMPopup, LyrBlock, NUM_LAYERS }; /* scene layers */
+enum { AxisUp, AxisRight, AxisDown, AxisLeft };
typedef union {
int i;
@@ 100,6 106,13 @@ typedef union {
typedef struct {
unsigned int mod;
+ unsigned int dir;
+ void (*func)(const Arg *);
+ const Arg arg;
+} Axis;
+
+typedef struct {
+ unsigned int mod;
unsigned int button;
void (*func)(const Arg *);
const Arg arg;
@@ 111,20 124,32 @@ typedef struct Client Client;
struct Client {
/* Must keep this field first */
unsigned int type; /* XDGShell or X11* */
- /* Must keep these three elements in this order */
- struct wlr_box geom; /* layout-relative, includes border */
- Monitor *mon;
+ Monitor *mon;
struct wlr_scene_tree *scene;
struct wlr_scene_rect *border[4]; /* top, bottom, left, right */
struct wlr_scene_tree *scene_surface;
struct wl_list link;
struct wl_list flink;
+ struct wlr_box geom; /* layout-relative, includes border */
+ struct wlr_box prev; /* layout-relative, includes border */
+ struct wlr_box current; /* geom currently shown in the scene graph */
+ struct wlr_scene_node *snapshot; /* content shown while resizing */
+ uint32_t resize_serial; /* nonzero while waiting for a resized buffer */
+ struct wlr_box bounds; /* only width and height are used */
+ struct wlr_box prev_bounds;
union {
struct wlr_xdg_surface *xdg;
struct wlr_xwayland_surface *xwayland;
} surface;
struct wlr_xdg_toplevel_decoration_v1 *decoration;
+ struct wlr_ext_foreign_toplevel_handle_v1 *foreign_toplevel_handle;
+ struct wlr_scene *image_capture_scene;
+ struct wlr_ext_image_capture_source_v1 *image_capture_source;
+ union {
+ struct wlr_scene_tree *image_capture_tree;
+ struct wlr_scene_surface *image_capture_scene_surface;
+ } capture;
struct wl_listener commit;
struct wl_listener map;
struct wl_listener maximize;
@@ 134,22 159,19 @@ struct Client {
struct wl_listener fullscreen;
struct wl_listener set_decoration_mode;
struct wl_listener destroy_decoration;
- struct wlr_box prev; /* layout-relative, includes border */
- struct wlr_box bounds;
- struct wlr_box prev_bounds;
#ifdef XWAYLAND
struct wl_listener activate;
struct wl_listener associate;
struct wl_listener dissociate;
struct wl_listener configure;
+ struct wl_listener set_geometry;
struct wl_listener set_hints;
#endif
unsigned int bw;
uint32_t tags;
- int isfloating, isurgent, isfullscreen, issticky, isterm, noswallow;
+ int isfloating, isurgent, isfullscreen, issticky, isterm, noswallow;
char scratchkey;
int allow_activation;
- uint32_t resize; /* configure serial of a pending resize */
pid_t pid;
Client *swallowing, *swallowedby;
};
@@ 175,6 197,7 @@ typedef struct {
typedef struct {
struct wl_list link;
struct wlr_keyboard_group *wlr_group;
+ struct wlr_keyboard *virtual_keyboard;
xkb_keycode_t keycode;
uint32_t mods; /* invalid if keycode == 0 */
@@ 216,6 239,7 @@ struct Monitor {
struct wl_listener frame;
struct wl_listener destroy;
struct wl_listener request_state;
+ struct wl_listener commit_lock_surface;
struct wl_listener destroy_lock_surface;
struct wlr_session_lock_surface_v1 *lock_surface;
struct wlr_box m; /* monitor area, layout-relative */
@@ 275,6 299,7 @@ typedef struct {
/* function declarations */
static void applybounds(Client *c, struct wlr_box *bbox);
+static void applygeom(Client *c);
static void applypertag(Monitor *m);
static void applyrules(Client *c);
static void arrange(Monitor *m);
@@ 284,6 309,7 @@ static void arrangelayers(Monitor *m);
static void attachclients(Monitor *m);
static void axisnotify(struct wl_listener *listener, void *data);
static void buttonpress(struct wl_listener *listener, void *data);
+static void capturerequest(struct wl_listener *listener, void *data);
static void chvt(const Arg *arg);
static void checkidleinhibitor(struct wlr_surface *exclude);
static void cleanup(void);
@@ 291,6 317,7 @@ static void cleanupmon(struct wl_listener *listener, void *data);
static void cleanuplisteners(void);
static void closemon(Monitor *m);
static void commitlayersurfacenotify(struct wl_listener *listener, void *data);
+static void commitlocksurface(struct wl_listener *listener, void *data);
static void commitnotify(struct wl_listener *listener, void *data);
static void commitpopup(struct wl_listener *listener, void *data);
static void createdecoration(struct wl_listener *listener, void *data);
@@ 331,7 358,7 @@ static void dwl_ipc_output_set_client_tags(struct wl_client *client, struct wl_r
static void dwl_ipc_output_set_layout(struct wl_client *client, struct wl_resource *resource, uint32_t index);
static void dwl_ipc_output_set_tags(struct wl_client *client, struct wl_resource *resource, uint32_t tagmask, uint32_t toggle_tagset);
static void dwl_ipc_output_release(struct wl_client *client, struct wl_resource *resource);
-static void focusclient(Client *c, int lift);
+static void focusclient(Client *c, LayerSurface *l, int lift);
static void focusmon(const Arg *arg);
static void focusortogglematchingscratch(const Arg *arg);
static void focusortogglescratch(const Arg *arg);
@@ 348,8 375,7 @@ static void handlesig(int signo);
static void incnmaster(const Arg *arg);
static void inputdevice(struct wl_listener *listener, void *data);
static int keybinding(uint32_t mods, xkb_keycode_t keycode);
-static int modekeybinding(uint32_t mods, xkb_keysym_t sym);
-static int modekeybinding(uint32_t mods, xkb_keycode_t sym);
+static int modekeybinding(uint32_t mods, xkb_keycode_t keycode);
static int is_inbounds(struct wlr_box *box, struct wlr_box *bounds);
static void keypress(struct wl_listener *listener, void *data);
static void keypressmod(struct wl_listener *listener, void *data);
@@ 361,6 387,7 @@ static void maximizenotify(struct wl_listener *listener, void *data);
static void monocle(Monitor *m);
static void movestack(const Arg *arg);
static void motionabsolute(struct wl_listener *listener, void *data);
+static char **monoff(struct wlr_output *wlr_output);
static void motionnotify(uint32_t time, struct wlr_input_device *device, double sx,
double sy, double sx_unaccel, double sy_unaccel);
static void motionrelative(struct wl_listener *listener, void *data);
@@ 368,7 395,7 @@ static void moveresize(const Arg *arg);
static void outputmgrapply(struct wl_listener *listener, void *data);
static void outputmgrapplyortest(struct wlr_output_configuration_v1 *config, int test);
static void outputmgrtest(struct wl_listener *listener, void *data);
-static void pointerfocus(Client *c, struct wlr_surface *surface,
+static void pointerfocus(Client *c, LayerSurface* l, struct wlr_surface *surface,
double sx, double sy, uint32_t time);
static void printstatus(void);
static void powermgrsetmode(struct wl_listener *listener, void *data);
@@ 388,9 415,12 @@ static void setgamma(struct wl_listener *listener, void *data);
static void setlayout(const Arg *arg);
static void setmfact(const Arg *arg);
static void setmon(Client *c, Monitor *m, uint32_t newtags);
+static void setmonoff(struct wlr_output *wlr_output, int off);
static void setpsel(struct wl_listener *listener, void *data);
static void setsel(struct wl_listener *listener, void *data);
static void setup(void);
+static struct wlr_scene_node *snapshot(struct wlr_scene_node *node,
+ struct wlr_scene_tree *parent, void *data);
static void spawn(const Arg *arg);
static void spawnscratch(const Arg *arg);
static void startdrag(struct wl_listener *listener, void *data);
@@ 405,6 435,11 @@ static void togglefullscreen(const Arg *arg);
static void togglescratch(const Arg *arg);
static void toggletag(const Arg *arg);
static void toggleview(const Arg *arg);
+static void transactionapply(void);
+static void transactioncheck(void *data);
+static void transactioncommit(Client *c, int ready);
+static void transactionschedule(void);
+static int transactiontimeout(void *data);
static void unlocksession(struct wl_listener *listener, void *data);
static void unmaplayersurfacenotify(struct wl_listener *listener, void *data);
static void unmapnotify(struct wl_listener *listener, void *data);
@@ 430,7 465,7 @@ static void entermode(const Arg *arg);
static const char broken[] = "broken";
static pid_t child_pid = -1;
static int locked;
-static void *exclusive_focus;
+static Client *focused_client;
static struct wl_display *dpy;
static struct wl_event_loop *event_loop;
static struct wlr_backend *backend;
@@ 458,6 493,8 @@ static struct wlr_virtual_keyboard_manager_v1 *virtual_keyboard_mgr;
static struct wlr_virtual_pointer_manager_v1 *virtual_pointer_mgr;
static struct wlr_cursor_shape_manager_v1 *cursor_shape_mgr;
static struct wlr_output_power_manager_v1 *power_mgr;
+static struct wlr_ext_foreign_toplevel_list_v1 *foreign_toplevel_list;
+static struct wlr_ext_foreign_toplevel_image_capture_source_manager_v1 *ext_foreign_toplevel_image_capture_source_manager_v1;
static struct wlr_pointer_constraints_v1 *pointer_constraints;
static struct wlr_relative_pointer_manager_v1 *relative_pointer_mgr;
@@ 491,6 528,17 @@ static struct zdwl_ipc_output_v2_interface dwl_output_implementation = {.release
static const int NORMAL = -1;
static int active_mode_index = NORMAL;
+static int consumed[KEY_MAX + 1];
+
+/* Transactions: the scene graph is updated only once all visible clients have
+ * committed buffers with their new size, or after TRANSACTION_TIMEOUT ms */
+#define TRANSACTION_TIMEOUT 100
+static struct wl_event_source *transaction_idle;
+static struct wl_event_source *transaction_timer;
+static int transaction_waiting;
+static struct wl_array ghosts; /* struct wlr_scene_node *, unmapped clients */
+static struct wl_array offmons; /* char *, names of outputs turned off by clients */
+
/* global event handlers */
static struct wl_listener cursor_axis = {.notify = axisnotify};
static struct wl_listener cursor_button = {.notify = buttonpress};
@@ 519,14 567,18 @@ static struct wl_listener request_set_sel = {.notify = setsel};
static struct wl_listener request_set_cursor_shape = {.notify = setcursorshape};
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 = destroydragicon};
static struct wl_listener new_session_lock = {.notify = locksession};
+static struct wl_listener new_foreign_toplevel_capture_request = {.notify = capturerequest};
#ifdef XWAYLAND
static void activatex11(struct wl_listener *listener, void *data);
static void associatex11(struct wl_listener *listener, void *data);
+static void commitx11(struct wl_listener *listener, void *data);
static void configurex11(struct wl_listener *listener, void *data);
static void createnotifyx11(struct wl_listener *listener, void *data);
static void dissociatex11(struct wl_listener *listener, void *data);
+static void setgeometryx11(struct wl_listener *listener, void *data);
static void sethints(struct wl_listener *listener, void *data);
static void xwaylandready(struct wl_listener *listener, void *data);
static struct wl_listener new_xwayland_surface = {.notify = createnotifyx11};
@@ 554,14 606,29 @@ is_inbounds(struct wlr_box *box, struct wlr_box *bounds)
box->x + box->width <= bounds->x + bounds->width && box->y + box->height <= bounds->y + bounds->height;
}
+#include "ime.h"
+
/* function implementations */
void
applybounds(Client *c, struct wlr_box *bbox)
{
- /* set minimum possible */
+ /* set minimum client size to 1 */
c->geom.width = MAX(1 + 2 * (int)c->bw, c->geom.width);
c->geom.height = MAX(1 + 2 * (int)c->bw, c->geom.height);
+ if (!c->isfullscreen) {
+ struct wlr_box min = {0}, max = {0};
+ client_get_size_hints(c, &max, &min);
+ c->geom.width = MAX(min.width + 2 * (int)c->bw, c->geom.width);
+ c->geom.height = MAX(min.height + 2 * (int)c->bw, c->geom.height);
+ /* Some clients set their max size to INT_MAX, which does not violate the
+ * protocol but it's unnecesary, as they can set their max size to zero. */
+ if (max.width > 0 && 2 * (int)c->bw <= INT_MAX - max.width) /* Checks for overflow */
+ c->geom.width = MIN(max.width + 2 * (int)c->bw, c->geom.width);
+ if (max.height > 0 && 2 * (int)c->bw <= INT_MAX - max.height) /* Checks for overflow */
+ c->geom.height = MIN(max.height + 2 * (int)c->bw, c->geom.height);
+ }
+
if (c->isfloating && c->prev_bounds.width && c->prev_bounds.height &&
is_inbounds(&c->geom, &c->prev_bounds) && !is_inbounds(&c->geom, bbox)) {
c->geom.x = bbox->x + (c->geom.x - c->prev_bounds.x) * (bbox->width / c->prev_bounds.width);
@@ 579,6 646,41 @@ applybounds(Client *c, struct wlr_box *bbox)
}
void
+applygeom(Client *c)
+{
+ struct wlr_box clip;
+ Client *p = client_get_parent(c);
+
+ /* We move all floating clients to LyrTile while in floating layout
+ * to avoid "real" floating clients be always on top */
+ wlr_scene_node_reparent(&c->scene->node, layers[c->isfullscreen
+ || (p && p->isfullscreen) ? LyrFS
+ : c->isfloating && c->mon->lt[c->mon->sellt]->arrange ? LyrFloat
+ : LyrTile]);
+
+ c->current = c->geom;
+ if (c->snapshot) {
+ wlr_scene_node_destroy(c->snapshot);
+ c->snapshot = NULL;
+ wlr_scene_node_set_enabled(&c->scene_surface->node, 1);
+ }
+
+ /* Update scene-graph, including borders */
+ wlr_scene_node_set_position(&c->scene->node, c->geom.x, c->geom.y);
+ wlr_scene_node_set_position(&c->scene_surface->node, 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);
+ wlr_scene_node_set_position(&c->border[2]->node, 0, c->bw);
+ wlr_scene_node_set_position(&c->border[3]->node, c->geom.width - c->bw, c->bw);
+
+ client_get_clip(c, &clip);
+ wlr_scene_subsurface_tree_set_clip(&c->scene_surface->node, &clip);
+}
+
+void
applyrules(Client *c)
{
/* rule matching */
@@ 664,35 766,18 @@ arrange(Monitor *m)
return;
wl_list_for_each(c, &clients, link) {
- if (c->mon == m) {
- wlr_scene_node_set_enabled(&c->scene->node, VISIBLEON(c, m));
- client_set_suspended(c, !VISIBLEON(c, m));
- }
+ if (c->mon == m)
+ client_set_suspended(c, !VISIBLEON(c, m)
+ && (!c->image_capture_source
+ || wl_list_empty(&c->image_capture_source->resources)));
}
- wlr_scene_node_set_enabled(&m->fullscreen_bg->node,
- (c = focustop(m)) && c->isfullscreen);
-
strncpy(m->ltsymbol, m->lt[m->sellt]->symbol, LENGTH(m->ltsymbol));
- /* We move all clients (except fullscreen and unmanaged) to LyrTile while
- * in floating layout to avoid "real" floating clients be always on top */
- wl_list_for_each(c, &clients, link) {
- if (c->mon != m || c->scene->node.parent == layers[LyrFS])
- continue;
-
- wlr_scene_node_reparent(&c->scene->node,
- (!m->lt[m->sellt]->arrange && c->isfloating)
- ? layers[LyrTile]
- : (m->lt[m->sellt]->arrange && c->isfloating)
- ? layers[LyrFloat]
- : c->scene->node.parent);
- }
-
if (m->lt[m->sellt]->arrange)
m->lt[m->sellt]->arrange(m);
- motionnotify(0, NULL, 0, 0, 0, 0);
- checkidleinhibitor(NULL);
+
+ transactionschedule();
}
void
@@ 737,19 822,19 @@ arrangelayers(Monitor *m)
arrange(m);
}
- /* Arrange non-exlusive surfaces from top->bottom */
+ /* Arrange non-exclusive surfaces from top->bottom */
for (i = 3; i >= 0; i--)
arrangelayer(m, &m->layers[i], &usable_area, 0);
- /* Find topmost keyboard interactive layer, if such a layer exists */
+ /* Find topmost keyboard interactive layer that has indicated it wants
+ * exclusive access to the keyboard, if such a layer exists */
for (i = 0; i < (int)LENGTH(layers_above_shell); i++) {
wl_list_for_each_reverse(l, &m->layers[layers_above_shell[i]], link) {
- if (locked || !l->layer_surface->current.keyboard_interactive || !l->mapped)
+ if (locked ||
+ l->layer_surface->current.keyboard_interactive != ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_EXCLUSIVE ||
+ !l->mapped)
continue;
- /* Deactivate the focused client. */
- focusclient(NULL, 0);
- exclusive_focus = l;
- client_notify_enter(l->layer_surface->surface, wlr_seat_get_keyboard(seat));
+ focusclient(NULL, l, 0);
return;
}
}
@@ 800,9 885,28 @@ axisnotify(struct wl_listener *listener, void *data)
/* This event is forwarded by the cursor when a pointer emits an axis event,
* for example when you move the scroll wheel. */
struct wlr_pointer_axis_event *event = data;
+ const Axis *a;
+ unsigned int adir;
+ struct wlr_keyboard *keyboard;
+ uint32_t mods;
+
wlr_idle_notifier_v1_notify_activity(idle_notifier, seat);
- /* TODO: allow usage of scroll wheel for mousebindings, it can be implemented
- * by checking the event's orientation and the delta of the event */
+
+ if (!locked) {
+ if (event->orientation == WL_POINTER_AXIS_VERTICAL_SCROLL)
+ adir = event->delta > 0 ? AxisDown : AxisUp;
+ else
+ adir = event->delta > 0 ? AxisRight : AxisLeft;
+ keyboard = wlr_seat_get_keyboard(seat);
+ mods = keyboard ? wlr_keyboard_get_modifiers(keyboard) : 0;
+ for (a = axes; a < END(axes); a++) {
+ if (CLEANMASK(mods) == CLEANMASK(a->mod) && adir == a->dir && a->func) {
+ a->func(&a->arg);
+ return;
+ }
+ }
+ }
+
/* Notify the client with pointer focus of the axis event. */
wlr_seat_pointer_notify_axis(seat,
event->time_msec, event->orientation, event->delta,
@@ 815,7 919,8 @@ buttonpress(struct wl_listener *listener, void *data)
struct wlr_pointer_button_event *event = data;
struct wlr_keyboard *keyboard;
uint32_t mods;
- Client *c;
+ Client *c = NULL;
+ LayerSurface *l = NULL;
const Button *b;
wlr_idle_notifier_v1_notify_activity(idle_notifier, seat);
@@ 827,10 932,14 @@ buttonpress(struct wl_listener *listener, void *data)
if (locked)
break;
- /* Change focus if the button was _pressed_ over a client */
- xytonode(cursor->x, cursor->y, NULL, &c, NULL, NULL, NULL);
- if (c && (!client_is_unmanaged(c) || client_wants_focus(c)))
- focusclient(c, 1);
+ /* Change focus if the button was _pressed_ over a client
+ or a layer surface with on-demand keyboard interactivity */
+ xytonode(cursor->x, cursor->y, NULL, &c, &l, NULL, NULL);
+ if (c && (!client_is_unmanaged(c) || client_wants_focus(c))) {
+ focusclient(c, NULL, 1);
+ } else if (l && l->layer_surface->current.keyboard_interactive) {
+ focusclient(NULL, l, 0);
+ }
keyboard = wlr_seat_get_keyboard(seat);
mods = keyboard ? wlr_keyboard_get_modifiers(keyboard) : 0;
@@ 844,10 953,11 @@ buttonpress(struct wl_listener *listener, void *data)
break;
case WL_POINTER_BUTTON_STATE_RELEASED:
/* If you released any buttons, we exit interactive move/resize mode. */
- /* TODO: should reset to the pointer focus's current setcursor */
if (!locked && cursor_mode != CurNormal && cursor_mode != CurPressed) {
- wlr_cursor_set_xcursor(cursor, cursor_mgr, "default");
cursor_mode = CurNormal;
+ /* Update the cursor */
+ wlr_seat_pointer_clear_focus(seat);
+ motionnotify(0, NULL, 0, 0, 0, 0);
/* Drop the window off on its new monitor */
selmon = xytomon(cursor->x, cursor->y);
setmon(grabc, selmon, 0);
@@ 864,6 974,25 @@ buttonpress(struct wl_listener *listener, void *data)
}
void
+capturerequest(struct wl_listener *listener, void *data)
+{
+ struct wlr_ext_foreign_toplevel_image_capture_source_manager_v1_request *request = data;
+ Client *view = request->toplevel_handle->data;
+
+ if (!view->image_capture_source) {
+ view->image_capture_source = wlr_ext_image_capture_source_v1_create_with_scene_node(
+ &view->image_capture_scene->tree.node, event_loop, alloc, drw);
+ if (!view->image_capture_source)
+ return;
+ }
+
+ wlr_ext_foreign_toplevel_image_capture_source_manager_v1_request_accept(
+ request, view->image_capture_source);
+
+ client_set_suspended(view, 0);
+}
+
+void
chvt(const Arg *arg)
{
wlr_session_change_vt(session, arg->ui);
@@ 890,6 1019,8 @@ checkidleinhibitor(struct wlr_surface *exclude)
void
cleanup(void)
{
+ char **name;
+
cleanuplisteners();
#ifdef XWAYLAND
wlr_xwayland_destroy(xwayland);
@@ 904,10 1035,21 @@ cleanup(void)
destroykeyboardgroup(&kb_group->destroy, NULL);
+ input_method_relay_finish(input_method_relay);
+ input_method_relay = NULL;
+
/* If it's not destroyed manually, it will cause a use-after-free of wlr_seat.
* Destroy it until it's fixed on the wlroots side */
wlr_backend_destroy(backend);
+ if (transaction_idle)
+ wl_event_source_remove(transaction_idle);
+ wl_event_source_remove(transaction_timer);
+ wl_array_release(&ghosts);
+ wl_array_for_each(name, &offmons)
+ free(*name);
+ wl_array_release(&offmons);
+
wl_display_destroy(dpy);
/* Destroy after the wayland display (when the monitors are already destroyed)
to avoid destroying them with an invalid scene output. */
@@ 977,9 1119,12 @@ cleanuplisteners(void)
wl_list_remove(&request_start_drag.link);
wl_list_remove(&start_drag.link);
wl_list_remove(&new_session_lock.link);
+ wl_list_remove(&new_foreign_toplevel_capture_request.link);
#ifdef XWAYLAND
- wl_list_remove(&new_xwayland_surface.link);
- wl_list_remove(&xwayland_ready.link);
+ if (xwayland) {
+ wl_list_remove(&new_xwayland_surface.link);
+ wl_list_remove(&xwayland_ready.link);
+ }
#endif
}
@@ 1009,9 1154,9 @@ closemon(Monitor *m)
setmon(c, selmon, c->tags);
}
- m->tagset[0] = m->tagset[1] = 0;
+ m->tagset[0] = m->tagset[1] = 0;
- focusclient(focustop(selmon), 1);
+ focusclient(focustop(selmon), NULL, 1);
printstatus();
}
@@ 1051,6 1196,20 @@ commitlayersurfacenotify(struct wl_listener *listener, void *data)
}
void
+commitlocksurface(struct wl_listener *listener, void *data)
+{
+ Monitor *m = wl_container_of(listener, m, commit_lock_surface);
+
+ if (!m->lock_surface->surface->mapped)
+ return;
+
+ wl_list_remove(&m->commit_lock_surface.link);
+ wl_list_init(&m->commit_lock_surface.link);
+
+ motionnotify(0, NULL, 0, 0, 0, 0);
+}
+
+void
commitnotify(struct wl_listener *listener, void *data)
{
Client *c = wl_container_of(listener, c, commit);
@@ 1073,14 1232,15 @@ commitnotify(struct wl_listener *listener, void *data)
if (c->decoration)
requestdecorationmode(&c->set_decoration_mode, c->decoration);
wlr_xdg_toplevel_set_size(c->surface.xdg->toplevel, 0, 0);
+ if (!c->isfloating)
+ client_set_tiled(c, WLR_EDGE_TOP | WLR_EDGE_BOTTOM | WLR_EDGE_LEFT |
+ WLR_EDGE_RIGHT);
return;
}
+ transactioncommit(c, c->resize_serial && c->surface.xdg->current.configure_serial
+ >= c->resize_serial);
resize(c, c->geom, (c->isfloating && !c->isfullscreen));
-
- /* mark a pending resize as completed */
- if (c->resize && c->resize <= c->surface.xdg->current.configure_serial)
- c->resize = 0;
}
void
@@ 1106,8 1266,8 @@ commitpopup(struct wl_listener *listener, void *data)
return;
}
box = type == LayerShell ? l->mon->m : c->mon->w;
- box.x -= (type == LayerShell ? l->scene->node.x : c->geom.x);
- box.y -= (type == LayerShell ? l->scene->node.y : c->geom.y);
+ box.x -= (type == LayerShell ? l->scene->node.x : c->geom.x - c->surface.xdg->geometry.x);
+ box.y -= (type == LayerShell ? l->scene->node.y : c->geom.y - c->surface.xdg->geometry.y);
wlr_xdg_popup_unconstrain_from_box(popup, &box);
wl_list_remove(&listener->link);
free(listener);
@@ 1228,6 1388,7 @@ createlocksurface(struct wl_listener *listener, void *data)
wlr_session_lock_surface_v1_configure(lock_surface, m->m.width, m->m.height);
LISTEN(&lock_surface->events.destroy, &m->destroy_lock_surface, destroylocksurface);
+ LISTEN(&lock_surface->surface->events.commit, &m->commit_lock_surface, commitlocksurface);
if (m == selmon)
client_notify_enter(lock_surface->surface, wlr_seat_get_keyboard(seat));
@@ 1302,14 1463,17 @@ createmon(struct wl_listener *listener, void *data)
* 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_state_set_mode(&state, wlr_output_preferred_mode(wlr_output));
-
/* Set up event listeners */
LISTEN(&wlr_output->events.frame, &m->frame, rendermon);
LISTEN(&wlr_output->events.destroy, &m->destroy, cleanupmon);
LISTEN(&wlr_output->events.request_state, &m->request_state, requestmonstate);
- wlr_output_state_set_enabled(&state, 1);
+ /* Some monitors disconnect when they are turned off and reconnect shortly
+ * after, so keep outputs that were turned off disabled. */
+ if (!monoff(wlr_output)) {
+ wlr_output_state_set_mode(&state, wlr_output_preferred_mode(wlr_output));
+ wlr_output_state_set_enabled(&state, 1);
+ }
wlr_output_commit_state(wlr_output, &state);
wlr_output_state_finish(&state);
@@ 1335,6 1499,12 @@ createmon(struct wl_listener *listener, void *data)
* output (such as DPI, scale factor, manufacturer, etc).
*/
m->scene_output = wlr_scene_output_create(scene, wlr_output);
+
+ if (!wlr_output->enabled) {
+ updatemons(NULL, NULL);
+ return;
+ }
+
if (m->m.x == -1 && m->m.y == -1)
wlr_output_layout_add_auto(output_layout, wlr_output);
else
@@ 1469,6 1639,7 @@ void
destroydecoration(struct wl_listener *listener, void *data)
{
Client *c = wl_container_of(listener, c, destroy_decoration);
+ c->decoration = NULL;
wl_list_remove(&c->destroy_decoration.link);
wl_list_remove(&c->set_decoration_mode.link);
@@ 1478,10 1649,9 @@ void
destroydragicon(struct wl_listener *listener, void *data)
{
/* Focus enter isn't sent during drag, so refocus the focused node. */
- focusclient(focustop(selmon), 1);
+ focusclient(focustop(selmon), NULL, 1);
motionnotify(0, NULL, 0, 0, 0, 0);
wl_list_remove(&listener->link);
- free(listener);
}
void
@@ 1517,7 1687,7 @@ destroylock(SessionLock *lock, int unlock)
wlr_scene_node_set_enabled(&locked_bg->node, 0);
- focusclient(focustop(selmon), 0);
+ focusclient(focustop(selmon), NULL, 0);
motionnotify(0, NULL, 0, 0, 0, 0);
destroy:
@@ 1538,6 1708,7 @@ destroylocksurface(struct wl_listener *listener, void *data)
m->lock_surface = NULL;
wl_list_remove(&m->destroy_lock_surface.link);
+ wl_list_remove(&m->commit_lock_surface.link);
if (lock_surface->surface != seat->keyboard_state.focused_surface)
return;
@@ 1546,7 1717,7 @@ destroylocksurface(struct wl_listener *listener, void *data)
surface = wl_container_of(cur_lock->surfaces.next, surface, link);
client_notify_enter(surface->surface, wlr_seat_get_keyboard(seat));
} else if (!locked) {
- focusclient(focustop(selmon), 1);
+ focusclient(focustop(selmon), NULL, 1);
} else {
wlr_seat_keyboard_clear_focus(seat);
}
@@ 1566,6 1737,7 @@ destroynotify(struct wl_listener *listener, void *data)
wl_list_remove(&c->associate.link);
wl_list_remove(&c->configure.link);
wl_list_remove(&c->dissociate.link);
+ wl_list_remove(&c->set_geometry.link);
wl_list_remove(&c->set_hints.link);
} else
#endif
@@ 1574,6 1746,10 @@ destroynotify(struct wl_listener *listener, void *data)
wl_list_remove(&c->map.link);
wl_list_remove(&c->unmap.link);
wl_list_remove(&c->maximize.link);
+ if (c->decoration) {
+ wl_list_remove(&c->set_decoration_mode.link);
+ wl_list_remove(&c->destroy_decoration.link);
+ }
}
free(c);
}
@@ 1626,7 1802,8 @@ dirtomon(enum wlr_direction dir)
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),
+ dir ^ (WLR_DIRECTION_LEFT | WLR_DIRECTION_RIGHT |
+ WLR_DIRECTION_UP | WLR_DIRECTION_DOWN),
selmon->wlr_output, selmon->m.x, selmon->m.y)))
return next->data;
return selmon;
@@ 1718,13 1895,13 @@ dwl_ipc_output_printstatus_to(DwlIpcOutput *ipc_output)
Monitor *monitor = ipc_output->mon;
Monitor *m;
Client *c, *focused;
- int tagmask, state, numclients, focused_client, tag;
+ int tagmask, state, numclients, tagfocused, tag;
const char *title, *appid;
focused = focustop(monitor);
zdwl_ipc_output_v2_send_active(ipc_output->resource, monitor == selmon);
for (tag = 0 ; tag < TAGCOUNT; tag++) {
- numclients = state = focused_client = 0;
+ numclients = state = tagfocused = 0;
tagmask = 1 << tag;
if ((tagmask & monitor->tagset[monitor->seltags]) != 0)
state |= ZDWL_IPC_OUTPUT_V2_TAG_STATE_ACTIVE;
@@ 1738,13 1915,13 @@ dwl_ipc_output_printstatus_to(DwlIpcOutput *ipc_output)
if (!(c->tags & tagmask))
continue;
if (c == focused)
- focused_client = 1;
+ tagfocused = 1;
if (c->isurgent)
state |= ZDWL_IPC_OUTPUT_V2_TAG_STATE_URGENT;
numclients++;
}
- zdwl_ipc_output_v2_send_tag(ipc_output->resource, tag, state, numclients, focused_client);
+ zdwl_ipc_output_v2_send_tag(ipc_output->resource, tag, state, numclients, tagfocused);
}
title = focused ? client_get_title(focused) : "";
appid = focused ? client_get_appid(focused) : "";
@@ 1784,7 1961,7 @@ dwl_ipc_output_set_client_tags(struct wl_client *client, struct wl_resource *res
return;
selected_client->tags = newtags;
- focusclient(focustop(selmon), 1);
+ focusclient(focustop(selmon), NULL, 1);
arrange(selmon);
printstatus();
}
@@ 1806,7 1983,7 @@ dwl_ipc_output_set_layout(struct wl_client *client, struct wl_resource *resource
selmon = ipc_output->mon;
setlayout(&(Arg){.v = &layouts[index]});
selmon = monitor;
- focusclient(focustop(selmon), 1);
+ focusclient(focustop(selmon), NULL, 1);
}
void
@@ 1830,7 2007,7 @@ dwl_ipc_output_set_tags(struct wl_client *client, struct wl_resource *resource,
selmon = ipc_output->mon;
view(&(Arg){.ui = newtags});
selmon = monitor;
- focusclient(focustop(selmon), 1);
+ focusclient(focustop(selmon), NULL, 1);
}
void
@@ 1840,9 2017,9 @@ dwl_ipc_output_release(struct wl_client *client, struct wl_resource *resource)
}
void
-focusclient(Client *c, int lift)
+focusclient(Client *c, LayerSurface *l, int lift)
{
- struct wlr_surface *old = seat->keyboard_state.focused_surface;
+ struct wlr_surface *surface, *old = seat->keyboard_state.focused_surface;
int unused_lx, unused_ly, old_client_type;
Client *old_c = NULL;
LayerSurface *old_l = NULL;
@@ 1872,45 2049,50 @@ focusclient(Client *c, int lift)
/* Don't change border color if there is an exclusive focus or we are
* handling a drag operation */
- if (!exclusive_focus && !seat->drag)
+ if (!(old_l && old_l->layer_surface->current.keyboard_interactive == ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_EXCLUSIVE)
+ && !seat->drag)
client_set_border_color(c, focuscolor);
}
- /* Deactivate old client if focus is changing */
- if (old && (!c || client_surface(c) != old)) {
- /* 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. */
- if (old_client_type == LayerShell && wlr_scene_node_coords(
- &old_l->scene->node, &unused_lx, &unused_ly)
- && old_l->layer_surface->current.layer >= ZWLR_LAYER_SHELL_V1_LAYER_TOP) {
- return;
- } else if (old_c && old_c == exclusive_focus && client_wants_focus(old_c)) {
- return;
- /* Don't deactivate old client if the new one wants focus, as this causes issues with winecfg
- * and probably other clients */
- } else if (old_c && !client_is_unmanaged(old_c) && (!c || !client_wants_focus(c))) {
- client_set_border_color(old_c, bordercolor);
+ /* 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. */
+ if (!l && old && (!c || client_surface(c) != old)
+ && old_client_type == LayerShell && wlr_scene_node_coords(
+ &old_l->scene->node, &unused_lx, &unused_ly)
+ && old_l->layer_surface->current.layer >= ZWLR_LAYER_SHELL_V1_LAYER_TOP
+ && old_l->layer_surface->current.keyboard_interactive == ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_EXCLUSIVE)
+ return;
- client_activate_surface(old, 0);
- }
+ if (focused_client && focused_client != c && !(c && client_is_unmanaged(c))) {
+ struct wlr_surface *s = client_surface(focused_client);
+ if (c)
+ client_set_border_color(focused_client, bordercolor);
+ if (s && s->mapped)
+ client_activate_surface(s, 0);
+ focused_client = NULL;
}
printstatus();
- if (!c) {
+ if (!c && !l) {
/* With no client, all we have left is to clear focus */
+ input_method_relay_set_focus(input_method_relay, NULL);
wlr_seat_keyboard_notify_clear_focus(seat);
return;
}
- /* Change cursor surface */
- motionnotify(0, NULL, 0, 0, 0, 0);
+ surface = c ? client_surface(c) : l->layer_surface->surface;
+ input_method_relay_set_focus(input_method_relay, surface);
+ client_notify_enter(surface, wlr_seat_get_keyboard(seat));
- /* Have a client, so focus its top-level wlr_surface */
- client_notify_enter(client_surface(c), wlr_seat_get_keyboard(seat));
+ if (l)
+ return;
+
+ client_activate_surface(surface, 1);
+ motionnotify(0, NULL, 0, 0, 0, 0);
- /* Activate the new client */
- client_activate_surface(client_surface(c), 1);
+ if (!client_is_unmanaged(c))
+ focused_client = c;
}
void
@@ 1922,7 2104,7 @@ focusmon(const Arg *arg)
selmon = dirtomon(arg->i);
while (!selmon->wlr_output->enabled && i++ < nmons);
}
- focusclient(focustop(selmon), 1);
+ focusclient(focustop(selmon), NULL, 1);
}
void
@@ 1941,18 2123,18 @@ focusortogglematchingscratch(const Arg *arg)
if (found == 1) {
if (hide == 1) {
c->tags = 0;
- focusclient(focustop(selmon), 1);
+ focusclient(focustop(selmon), NULL, 1);
}
continue;
}
if (focustop(selmon) == c) {
// hide
c->tags = 0;
- focusclient(focustop(selmon), 1);
+ focusclient(focustop(selmon), NULL, 1);
hide = 1;
} else {
// focus
- focusclient(c, 1);
+ focusclient(c, NULL, 1);
}
} else {
// show
@@ 1961,7 2143,7 @@ focusortogglematchingscratch(const Arg *arg)
else
setmon(c, selmon, 0);
// focus
- focusclient(c, 1);
+ focusclient(c, NULL, 1);
}
found = 1;
continue;
@@ 1997,10 2179,10 @@ focusortogglescratch(const Arg *arg)
if (focustop(selmon) == c) {
// hide
c->tags = 0;
- focusclient(focustop(selmon), 1);
+ focusclient(focustop(selmon), NULL, 1);
} else {
// focus
- focusclient(c, 1);
+ focusclient(c, NULL, 1);
}
} else {
// show
@@ 2008,7 2190,7 @@ focusortogglescratch(const Arg *arg)
c->tags = selmon->tagset[selmon->seltags];
else
setmon(c, selmon, 0);
- focusclient(c, 1);
+ focusclient(c, NULL, 1);
}
arrange(selmon);
} else{
@@ 2031,7 2213,7 @@ focusnthmon(const Arg *arg)
}
selmon = m;
- focusclient(focustop(selmon), 1);
+ focusclient(focustop(selmon), NULL, 1);
}
void
@@ 2057,7 2239,7 @@ focusstack(const Arg *arg)
}
}
/* If only one client is visible on selmon, then c == sel */
- focusclient(c, 1);
+ focusclient(c, NULL, 1);
}
/* We probably should change the name of this: it sounds like it
@@ 2299,9 2481,11 @@ keypress(struct wl_listener *listener, void *data)
/* On _press_ if there is no active screen locker,
* attempt to process a compositor keybinding. */
if (!locked
- && event->state == WL_KEYBOARD_KEY_STATE_PRESSED
- && wl_list_empty(&shortcuts_inhibit_mgr->inhibitors)) {
+ && event->state == WL_KEYBOARD_KEY_STATE_PRESSED
+ && wl_list_empty(&shortcuts_inhibit_mgr->inhibitors)) {
handled = keybinding(mods, keycode);
+ if (handled)
+ consumed[event->keycode] = 1;
}
if (handled && group->wlr_group->keyboard.repeat_info.delay > 0) {
@@ 2314,9 2498,14 @@ keypress(struct wl_listener *listener, void *data)
wl_event_source_timer_update(group->key_repeat_source, 0);
}
- if (handled)
+ if (handled || input_method_keyboard_grab_forward_key(group, event))
return;
+ if (consumed[event->keycode]) {
+ if (event->state == WL_KEYBOARD_KEY_STATE_RELEASED)
+ consumed[event->keycode] = 0;
+ return; /* Don't pass to the client the release event of a handled key-press */
+ }
wlr_seat_set_keyboard(seat, &group->wlr_group->keyboard);
/* Pass unhandled keycodes along to the client. */
wlr_seat_keyboard_notify_key(seat, event->time_msec,
@@ 2330,6 2519,9 @@ keypressmod(struct wl_listener *listener, void *data)
* pressed. We simply communicate this to the client. */
KeyboardGroup *group = wl_container_of(listener, group, modifiers);
+ if (input_method_keyboard_grab_forward_modifiers(group))
+ return;
+
wlr_seat_set_keyboard(seat, &group->wlr_group->keyboard);
/* Send modifiers to the client. */
wlr_seat_keyboard_notify_modifiers(seat,
@@ 2340,7 2532,7 @@ int
keyrepeat(void *data)
{
KeyboardGroup *group = data;
- if (!group->keycode || group->wlr_group->keyboard.repeat_info.rate <= 0)
+ if (locked || !group->keycode || group->wlr_group->keyboard.repeat_info.rate <= 0)
return 0;
wl_event_source_timer_update(group->key_repeat_source,
@@ 2370,12 2562,18 @@ locksession(struct wl_listener *listener, void *data)
return;
}
lock = session_lock->data = ecalloc(1, sizeof(*lock));
- focusclient(NULL, 0);
+ focusclient(NULL, NULL, 0);
lock->scene = wlr_scene_tree_create(layers[LyrBlock]);
cur_lock = lock->lock = session_lock;
locked = 1;
+ /* Cancel any interactive move/resize and take the pointer focus away
+ * from the clients below the lock screen */
+ cursor_mode = CurNormal;
+ grabc = NULL;
+ motionnotify(0, NULL, 0, 0, 0, 0);
+
LISTEN(&session_lock->events.new_surface, &lock->new_surface, createlocksurface);
LISTEN(&session_lock->events.destroy, &lock->destroy, destroysessionlock);
LISTEN(&session_lock->events.unlock, &lock->unlock, unlocksession);
@@ 2392,6 2590,11 @@ mapnotify(struct wl_listener *listener, void *data)
Monitor *m;
int i;
+ struct wlr_ext_foreign_toplevel_handle_v1_state foreign_toplevel_state = {
+ .app_id = client_get_appid(c),
+ .title = client_get_title(c),
+ };
+
/* Create scene tree for this client and its border */
c->scene = client_surface(c)->data = wlr_scene_tree_create(layers[LyrTile]);
/* Enabled later by a call to arrange() */
@@ 2406,13 2609,10 @@ mapnotify(struct wl_listener *listener, void *data)
/* Handle unmanaged clients first so we can return prior create borders */
if (client_is_unmanaged(c)) {
/* Unmanaged clients always are floating */
- wlr_scene_node_reparent(&c->scene->node, layers[LyrFloat]);
+ wlr_scene_node_reparent(&c->scene->node, layers[LyrUnmanaged]);
wlr_scene_node_set_position(&c->scene->node, c->geom.x, c->geom.y);
- client_set_size(c, c->geom.width, c->geom.height);
- if (client_wants_focus(c)) {
- focusclient(c, 1);
- exclusive_focus = c;
- }
+ if (client_wants_focus(c))
+ focusclient(c, NULL, 1);
goto unset_fullscreen;
}
@@ 2423,14 2623,32 @@ mapnotify(struct wl_listener *listener, void *data)
}
/* Initialize client geometry with room for border */
- client_set_tiled(c, WLR_EDGE_TOP | WLR_EDGE_BOTTOM | WLR_EDGE_LEFT | WLR_EDGE_RIGHT);
+ client_set_tiled(c, WLR_EDGE_TOP | WLR_EDGE_BOTTOM | WLR_EDGE_LEFT |
+ WLR_EDGE_RIGHT);
c->geom.width += 2 * c->bw;
c->geom.height += 2 * c->bw;
+ if (client_is_x11(c)) {
+ int x = c->geom.x - (int)c->bw, y = c->geom.y - (int)c->bw;
+ c->geom.x = c->geom.x < sgeom.x ? x : MAX(x, sgeom.x);
+ c->geom.y = c->geom.y < sgeom.y ? y : MAX(y, sgeom.y);
+ }
/* Insert this client into client lists. */
wl_list_insert(&clients, &c->link);
wl_list_insert(&fstack, &c->flink);
+ c->foreign_toplevel_handle = wlr_ext_foreign_toplevel_handle_v1_create(
+ foreign_toplevel_list, &foreign_toplevel_state);
+ c->foreign_toplevel_handle->data = c;
+ c->image_capture_scene = wlr_scene_create();
+ if (c->type == XDGShell)
+ c->capture.image_capture_tree = wlr_scene_xdg_surface_create(&c->image_capture_scene->tree, c->surface.xdg);
+#ifdef XWAYLAND
+ else
+ c->capture.image_capture_scene_surface = wlr_scene_surface_create(&c->image_capture_scene->tree, c->surface.xwayland->surface);
+#endif
+
+
/* Set initial monitor, tags, floating status, and focus:
* we always consider floating, clients that have parent and thus
* we set the same tags and monitor as its parent.
@@ 2545,26 2763,38 @@ motionabsolute(struct wl_listener *listener, void *data)
motionnotify(event->time_msec, &event->pointer->base, dx, dy, dx, dy);
}
+char **
+monoff(struct wlr_output *wlr_output)
+{
+ char **name;
+ wl_array_for_each(name, &offmons) {
+ if (!strcmp(*name, wlr_output->name))
+ return name;
+ }
+ return NULL;
+}
+
void
motionnotify(uint32_t time, struct wlr_input_device *device, double dx, double dy,
double dx_unaccel, double dy_unaccel)
{
+ int nx, ny;
double sx = 0, sy = 0, sx_confined, sy_confined;
Client *c = NULL, *w = NULL;
- LayerSurface *l = NULL;
+ LayerSurface *l = NULL, *focusedl = NULL;
struct wlr_surface *surface = NULL;
struct wlr_pointer_constraint_v1 *constraint;
/* Find the client under the pointer and send the event along. */
- xytonode(cursor->x, cursor->y, &surface, &c, NULL, &sx, &sy);
+ xytonode(cursor->x, cursor->y, &surface, &c, &l, &sx, &sy);
if (cursor_mode == CurPressed && !seat->drag
&& surface != seat->pointer_state.focused_surface
- && toplevel_from_wlr_surface(seat->pointer_state.focused_surface, &w, &l) >= 0) {
+ && toplevel_from_wlr_surface(seat->pointer_state.focused_surface, &w, &focusedl) >= 0) {
c = w;
surface = seat->pointer_state.focused_surface;
- sx = cursor->x - (l ? l->scene->node.x : w->geom.x);
- sy = cursor->y - (l ? l->scene->node.y : w->geom.y);
+ sx = cursor->x - (focusedl ? focusedl->scene->node.x : w->geom.x);
+ sy = cursor->y - (focusedl ? focusedl->scene->node.y : w->geom.y);
}
/* time is 0 in internal calls meant to restore pointer focus. */
@@ 2606,7 2836,17 @@ motionnotify(uint32_t time, struct wlr_input_device *device, double dx, double d
/* If we are currently grabbing the mouse, handle and return */
if (cursor_mode == CurMove) {
/* Move the grabbed client to the new position. */
- resize(grabc, (struct wlr_box){.x = (int)round(cursor->x) - grabcx, .y = (int)round(cursor->y) - grabcy,
+ nx = (int)round(cursor->x) - grabcx;
+ ny = (int)round(cursor->y) - grabcy;
+ if (abs(selmon->w.x - nx) < (int)snap)
+ nx = selmon->w.x;
+ else if (abs((selmon->w.x + selmon->w.width) - (nx + grabc->geom.width)) < (int)snap)
+ nx = selmon->w.x + selmon->w.width - grabc->geom.width;
+ if (abs(selmon->w.y - ny) < (int)snap)
+ ny = selmon->w.y;
+ else if (abs((selmon->w.y + selmon->w.height) - (ny + grabc->geom.height)) < (int)snap)
+ ny = selmon->w.y + selmon->w.height - grabc->geom.height;
+ resize(grabc, (struct wlr_box){.x = nx, .y = ny,
.width = grabc->geom.width, .height = grabc->geom.height}, 1);
return;
} else if (cursor_mode == CurResize) {
@@ 2621,7 2861,7 @@ motionnotify(uint32_t time, struct wlr_input_device *device, double dx, double d
if (!surface && !seat->drag)
wlr_cursor_set_xcursor(cursor, cursor_mgr, "default");
- pointerfocus(c, surface, sx, sy, time);
+ pointerfocus(c, l, surface, sx, sy, time);
}
void
@@ 2684,49 2924,62 @@ outputmgrapplyortest(struct wlr_output_configuration_v1 *config, int test)
* output_layout.change event, not here.
*/
struct wlr_output_configuration_head_v1 *config_head;
- int ok = 1;
+ size_t states_len, i;
+ struct wlr_output_swapchain_manager swapchain_manager;
+ struct wlr_backend_output_state *states =
+ wlr_output_configuration_v1_build_state(config, &states_len);
+ int ok = 0;
+
+ if (!states) {
+ wlr_output_configuration_v1_send_failed(config);
+ return;
+ }
+
+ wlr_output_swapchain_manager_init(&swapchain_manager, backend);
+
+ ok = wlr_output_swapchain_manager_prepare(&swapchain_manager, states, states_len);
+ if (!ok || test)
+ goto out;
+
+ for (i = 0; i < states_len; i++) {
+ struct wlr_swapchain *swapchain = wlr_output_swapchain_manager_get_swapchain(
+ &swapchain_manager, states[i].output);
+ if (swapchain && !states[i].output->enabled)
+ wlr_output_state_set_buffer(&states[i].base, wlr_swapchain_acquire(swapchain));
+ }
+
+ if (!(ok = wlr_backend_commit(backend, states, states_len)))
+ goto out;
+
+ wlr_output_swapchain_manager_apply(&swapchain_manager);
wl_list_for_each(config_head, &config->heads, link) {
struct wlr_output *wlr_output = config_head->state.output;
Monitor *m = wlr_output->data;
- struct wlr_output_state state;
/* Ensure displays previously disabled by wlr-output-power-management-v1
* are properly handled*/
m->asleep = 0;
-
- wlr_output_state_init(&state);
- wlr_output_state_set_enabled(&state, config_head->state.enabled);
- if (!config_head->state.enabled)
- goto apply_or_test;
-
- if (config_head->state.mode)
- wlr_output_state_set_mode(&state, config_head->state.mode);
- else
- wlr_output_state_set_custom_mode(&state,
- config_head->state.custom_mode.width,
- config_head->state.custom_mode.height,
- config_head->state.custom_mode.refresh);
-
- wlr_output_state_set_transform(&state, config_head->state.transform);
- wlr_output_state_set_scale(&state, config_head->state.scale);
- wlr_output_state_set_adaptive_sync_enabled(&state,
- config_head->state.adaptive_sync_enabled);
-
-apply_or_test:
- ok &= test ? wlr_output_test_state(wlr_output, &state)
- : wlr_output_commit_state(wlr_output, &state);
+ setmonoff(wlr_output, !config_head->state.enabled);
/* Don't move monitors if position wouldn't change. This avoids
* wlroots marking the output as manually configured.
* wlr_output_layout_add does not like disabled outputs */
- if (!test && wlr_output->enabled && (m->m.x != config_head->state.x || m->m.y != config_head->state.y))
+ if (config_head->state.enabled
+ && (m->m.x != config_head->state.x || m->m.y != config_head->state.y
+ || !wlr_output_layout_get(output_layout, wlr_output))) {
wlr_output_layout_add(output_layout, wlr_output,
config_head->state.x, config_head->state.y);
-
- wlr_output_state_finish(&state);
+ }
}
+out:
+ wlr_output_swapchain_manager_finish(&swapchain_manager);
+ for (i = 0; i < states_len; i++)
+ wlr_output_state_finish(&states[i].base);
+
+ free(states);
+
if (ok)
wlr_output_configuration_v1_send_succeeded(config);
else
@@ 2745,14 2998,18 @@ outputmgrtest(struct wl_listener *listener, void *data)
}
void
-pointerfocus(Client *c, struct wlr_surface *surface, double sx, double sy,
+pointerfocus(Client *c, LayerSurface *l, struct wlr_surface *surface, double sx, double sy,
uint32_t time)
{
struct timespec now;
- if (surface != seat->pointer_state.focused_surface &&
- sloppyfocus && time && c && !client_is_unmanaged(c))
- focusclient(c, 0);
+ if (surface != seat->pointer_state.focused_surface && sloppyfocus && time) {
+ if (c && (!client_is_unmanaged(c) || client_wants_focus(c))) {
+ focusclient(c, NULL, 0);
+ } else if (l && l->layer_surface->current.keyboard_interactive) {
+ focusclient(NULL, l, 0);
+ }
+ }
/* If surface is NULL, clear pointer focus */
if (!surface) {
@@ 2791,8 3048,12 @@ powermgrsetmode(struct wl_listener *listener, void *data)
if (!m)
return;
- m->gamma_lut_changed = 1; /* Reapply gamma LUT when re-enabling the ouput */
+ m->gamma_lut_changed = 1; /* Reapply gamma LUT when re-enabling the output */
wlr_output_state_set_enabled(&state, event->mode);
+ /* The output was reconnected while off and was never modeset */
+ if (event->mode && !m->wlr_output->current_mode)
+ wlr_output_state_set_mode(&state, wlr_output_preferred_mode(m->wlr_output));
+ setmonoff(m->wlr_output, !event->mode);
wlr_output_commit_state(m->wlr_output, &state);
m->asleep = !event->mode;
@@ 2811,24 3072,15 @@ rendermon(struct wl_listener *listener, void *data)
/* This function is called every time an output is ready to display a frame,
* generally at the output's refresh rate (e.g. 60Hz). */
Monitor *m = wl_container_of(listener, m, frame);
- Client *c;
- struct wlr_output_state pending = {0};
struct timespec now;
- /* Render if no XDG clients have an outstanding resize and are visible on
- * this monitor. */
- wl_list_for_each(c, &clients, link) {
- if (c->resize && !c->isfloating && client_is_rendered_on_mon(c, m) && !client_is_stopped(c))
- goto skip;
+ if (!wlr_scene_output_needs_frame(m->scene_output)) {
+ return;
}
wlr_scene_output_commit(m->scene_output, NULL);
-
-skip:
- /* Let clients know a frame has been rendered */
clock_gettime(CLOCK_MONOTONIC, &now);
wlr_scene_output_send_frame_done(m->scene_output, &now);
- wlr_output_state_finish(&pending);
}
void
@@ 2864,7 3116,7 @@ void
resize(Client *c, struct wlr_box geo, int interact)
{
struct wlr_box *bbox;
- struct wlr_box clip;
+ uint32_t serial;
if (!c->mon || !client_surface(c)->mapped)
return;
@@ 2875,22 3127,27 @@ resize(Client *c, struct wlr_box geo, int interact)
c->geom = geo;
applybounds(c, bbox);
- /* Update scene-graph, including borders */
- wlr_scene_node_set_position(&c->scene->node, c->geom.x, c->geom.y);
- wlr_scene_node_set_position(&c->scene_surface->node, 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);
- wlr_scene_node_set_position(&c->border[2]->node, 0, c->bw);
- wlr_scene_node_set_position(&c->border[3]->node, c->geom.width - c->bw, c->bw);
+ if ((serial = client_set_size(c, c->geom.width - 2 * c->bw,
+ c->geom.height - 2 * c->bw)))
+ c->resize_serial = serial;
- /* this is a no-op if size hasn't changed */
- c->resize = client_set_size(c, c->geom.width - 2 * c->bw,
- c->geom.height - 2 * c->bw);
- client_get_clip(c, &clip);
- wlr_scene_subsurface_tree_set_clip(&c->scene_surface->node, &clip);
+ if (interact || (!c->resize_serial && wlr_box_equal(&c->geom, &c->current))) {
+ c->resize_serial = 0;
+ applygeom(c);
+ return;
+ }
+
+ /* Until the transaction is applied, keep showing the current content
+ * instead of buffers with the new size at the old position. */
+ if (c->resize_serial) {
+ if (!c->snapshot && c->scene->node.enabled
+ && (c->snapshot = snapshot(&c->scene_surface->node, c->scene, c)))
+ wlr_scene_node_set_enabled(&c->scene_surface->node, 0);
+ /* The scene graph doesn't send frame done events to hidden
+ * surfaces, but the client may be waiting for one to redraw */
+ client_send_frame_done(c);
+ }
+ transactionschedule();
}
void
@@ 2991,14 3248,10 @@ setcursorshape(struct wl_listener *listener, void *data)
void
setfloating(Client *c, int floating)
{
- Client *p = client_get_parent(c);
c->isfloating = floating;
/* If in floating layout do not change the client's layer */
if (!c->mon || !client_surface(c)->mapped || !c->mon->lt[c->mon->sellt]->arrange)
return;
- wlr_scene_node_reparent(&c->scene->node, layers[c->isfullscreen ||
- (p && p->isfullscreen) ? LyrFS
- : c->isfloating ? LyrFloat : LyrTile]);
arrange(c->mon);
printstatus();
}
@@ 3011,8 3264,6 @@ setfullscreen(Client *c, int fullscreen)
return;
c->bw = fullscreen ? 0 : borderpx;
client_set_fullscreen(c, fullscreen);
- wlr_scene_node_reparent(&c->scene->node, layers[c->isfullscreen
- ? LyrFS : c->isfloating ? LyrFloat : LyrTile]);
if (fullscreen) {
c->prev = c->geom;
@@ 3101,7 3352,23 @@ setmon(Client *c, Monitor *m, uint32_t newtags)
setfloating(c, c->isfloating);
}
c->prev_bounds = (struct wlr_box){.x = 0, .y = 0, .width = 0, .height = 0};
- focusclient(focustop(selmon), 1);
+ focusclient(focustop(selmon), NULL, 1);
+}
+
+void
+setmonoff(struct wlr_output *wlr_output, int off)
+{
+ char **name = monoff(wlr_output), **last;
+
+ if (off && !name && (name = wl_array_add(&offmons, sizeof(*name)))) {
+ if (!(*name = strdup(wlr_output->name)))
+ offmons.size -= sizeof(*name);
+ } else if (!off && name) {
+ free(*name);
+ last = (char **)((char *)offmons.data + offmons.size) - 1;
+ *name = *last;
+ offmons.size -= sizeof(*name);
+ }
}
void
@@ 3143,7 3410,7 @@ setup(void)
wlr_log_init(log_level, NULL);
/* The Wayland display is managed by libwayland. It handles accepting
- * clients from the Unix socket, manging Wayland globals, and so on. */
+ * clients from the Unix socket, managing Wayland globals, and so on. */
dpy = wl_display_create();
event_loop = wl_display_get_event_loop(dpy);
@@ 3205,7 3472,10 @@ setup(void)
wlr_data_device_manager_create(dpy);
wlr_export_dmabuf_manager_v1_create(dpy);
wlr_screencopy_manager_v1_create(dpy);
+ wlr_ext_image_copy_capture_manager_v1_create(dpy, 1);
+ wlr_ext_output_image_capture_source_manager_v1_create(dpy, 1);
wlr_data_control_manager_v1_create(dpy);
+ wlr_ext_data_control_manager_v1_create(dpy, 1);
wlr_primary_selection_v1_device_manager_create(dpy);
wlr_viewporter_create(dpy);
wlr_single_pixel_buffer_manager_v1_create(dpy);
@@ 3256,11 3526,15 @@ setup(void)
wl_list_init(&clients);
wl_list_init(&fstack);
+ transaction_timer = wl_event_loop_add_timer(event_loop, transactiontimeout, NULL);
+ wl_array_init(&ghosts);
+ wl_array_init(&offmons);
+
xdg_shell = wlr_xdg_shell_create(dpy, 6);
wl_signal_add(&xdg_shell->events.new_toplevel, &new_xdg_toplevel);
wl_signal_add(&xdg_shell->events.new_popup, &new_xdg_popup);
- layer_shell = wlr_layer_shell_v1_create(dpy, 3);
+ layer_shell = wlr_layer_shell_v1_create(dpy, 4);
wl_signal_add(&layer_shell->events.new_surface, &new_layer_surface);
idle_notifier = wlr_idle_notifier_v1_create(dpy);
@@ 3274,9 3548,15 @@ setup(void)
(float [4]){0.1f, 0.1f, 0.1f, 1.0f});
wlr_scene_node_set_enabled(&locked_bg->node, 0);
- shortcuts_inhibit_mgr = wlr_keyboard_shortcuts_inhibit_v1_create(dpy);
- wl_signal_add(&shortcuts_inhibit_mgr->events.new_inhibitor, &new_shortcuts_inhibitor);
- LISTEN_STATIC(&shortcuts_inhibit_mgr->events.destroy, destroyshortcutsinhibitmgr);
+ shortcuts_inhibit_mgr = wlr_keyboard_shortcuts_inhibit_v1_create(dpy);
+ wl_signal_add(&shortcuts_inhibit_mgr->events.new_inhibitor, &new_shortcuts_inhibitor);
+ LISTEN_STATIC(&shortcuts_inhibit_mgr->events.destroy, destroyshortcutsinhibitmgr);
+
+ foreign_toplevel_list = wlr_ext_foreign_toplevel_list_v1_create(dpy,1);
+ ext_foreign_toplevel_image_capture_source_manager_v1 =
+ wlr_ext_foreign_toplevel_image_capture_source_manager_v1_create(dpy, 1);
+ wl_signal_add(&ext_foreign_toplevel_image_capture_source_manager_v1->events.new_request,
+ &new_foreign_toplevel_capture_request);
/* Use decoration protocols to negotiate server-side decorations */
wlr_server_decoration_manager_set_default_mode(
@@ 3352,6 3632,9 @@ setup(void)
wl_signal_add(&output_mgr->events.test, &output_mgr_test);
wl_global_create(dpy, &zdwl_ipc_manager_v2_interface, 2, NULL, dwl_ipc_manager_bind);
+ input_method_manager = wlr_input_method_manager_v2_create(dpy);
+ text_input_manager = wlr_text_input_manager_v3_create(dpy);
+ input_method_relay = input_method_relay_create();
/* Make sure XWayland clients don't connect to the parent X server,
* e.g when running in the x11 backend or the wayland backend and the
@@ 3373,6 3656,57 @@ setup(void)
#endif
}
+struct wlr_scene_node *
+snapshot(struct wlr_scene_node *node, struct wlr_scene_tree *parent, void *data)
+{
+ /* Copy the visible part of a scene graph subtree, keeping references to
+ * the buffers so that they can be shown after the client changes them */
+ struct wlr_scene_node *child, *copy;
+ struct wlr_scene_tree *tree;
+ struct wlr_scene_rect *rect;
+ struct wlr_scene_buffer *src, *buffer;
+
+ if (!node->enabled)
+ return NULL;
+
+ switch (node->type) {
+ case WLR_SCENE_NODE_TREE:
+ tree = wlr_scene_tree_create(parent);
+ wl_list_for_each(child, &wlr_scene_tree_from_node(node)->children, link)
+ snapshot(child, tree, data);
+ copy = &tree->node;
+ break;
+ case WLR_SCENE_NODE_RECT:
+ rect = wlr_scene_rect_from_node(node);
+ copy = &wlr_scene_rect_create(parent, rect->width, rect->height, rect->color)->node;
+ break;
+ case WLR_SCENE_NODE_BUFFER:
+ src = wlr_scene_buffer_from_node(node);
+ buffer = wlr_scene_buffer_create(parent, NULL);
+ wlr_scene_buffer_set_dest_size(buffer, src->dst_width, src->dst_height);
+ wlr_scene_buffer_set_opaque_region(buffer, &src->opaque_region);
+ wlr_scene_buffer_set_opacity(buffer, src->opacity);
+ wlr_scene_buffer_set_filter_mode(buffer, src->filter_mode);
+ wlr_scene_buffer_set_transfer_function(buffer, src->transfer_function);
+ wlr_scene_buffer_set_primaries(buffer, src->primaries);
+ wlr_scene_buffer_set_color_encoding(buffer, src->color_encoding);
+ wlr_scene_buffer_set_color_range(buffer, src->color_range);
+ wlr_scene_buffer_set_source_box(buffer, &src->src_box);
+ wlr_scene_buffer_set_transform(buffer, src->transform);
+ wlr_scene_buffer_set_buffer(buffer, src->buffer);
+ copy = &buffer->node;
+ break;
+ default:
+ return NULL;
+ }
+
+ copy->data = data;
+ wlr_scene_node_set_position(copy, node->x, node->y);
+ if (node->parent == parent)
+ wlr_scene_node_place_above(copy, node);
+ return copy;
+}
+
void
spawn(const Arg *arg)
{
@@ 3402,7 3736,7 @@ startdrag(struct wl_listener *listener, void *data)
return;
drag->icon->data = &wlr_scene_drag_icon_create(drag_icon, drag->icon)->node;
- LISTEN_STATIC(&drag->icon->events.destroy, destroydragicon);
+ wl_signal_add(&drag->icon->events.destroy, &drag_icon_destroy);
}
void
@@ 3414,7 3748,7 @@ tag(const Arg *arg)
return;
sel->tags = arg->ui & TAGMASK;
- focusclient(focustop(selmon), 1);
+ focusclient(focustop(selmon), NULL, 1);
arrange(selmon);
wl_list_for_each(m, &mons, link) {
attachclients(m);
@@ 3433,7 3767,7 @@ tagmon(const Arg *arg)
wl_list_for_each(m, &mons, link) {
arrange(m);
}
- focusclient(focustop(sel->mon), 1);
+ focusclient(focustop(sel->mon), NULL, 1);
}
}
@@ 3462,7 3796,7 @@ focusnthclient(const Arg *arg)
}
if (i == 0) {
- focusclient(c, 1);
+ focusclient(c, NULL, 1);
return;
}
@@ 3554,7 3888,7 @@ togglescratch(const Arg *arg)
if (found) {
c->tags = VISIBLEON(c, selmon) ? 0 : selmon->tagset[selmon->seltags];
- focusclient(c->tags == 0 ? focustop(selmon) : c, 1);
+ focusclient(c->tags == 0 ? focustop(selmon) : c, NULL, 1);
arrange(selmon);
} else{
spawnscratch(arg);
@@ 3576,7 3910,7 @@ toggletag(const Arg *arg)
sel->tags = newtags;
attachclients(selmon);
- focusclient(focustop(selmon), 1);
+ focusclient(focustop(selmon), NULL, 1);
arrange(selmon);
printstatus();
}
@@ 3601,12 3935,94 @@ toggleview(const Arg *arg)
applypertag(selmon);
selmon->tagset[selmon->seltags] = newtagset;
attachclients(selmon);
- focusclient(focustop(selmon), 1);
+ focusclient(focustop(selmon), NULL, 1);
arrange(selmon);
printstatus();
}
void
+transactionapply(void)
+{
+ struct wlr_scene_node **ghost;
+ Client *c;
+ Monitor *m;
+
+ wl_event_source_timer_update(transaction_timer, 0);
+ transaction_waiting = 0;
+
+ wl_array_for_each(ghost, &ghosts)
+ wlr_scene_node_destroy(*ghost);
+ ghosts.size = 0;
+
+ wl_list_for_each(c, &clients, link) {
+ c->resize_serial = 0;
+ if (!c->mon)
+ continue;
+ if (c->mon->wlr_output->enabled)
+ wlr_scene_node_set_enabled(&c->scene->node, VISIBLEON(c, c->mon));
+ applygeom(c);
+ }
+
+ wl_list_for_each(m, &mons, link) {
+ if (m->wlr_output->enabled)
+ wlr_scene_node_set_enabled(&m->fullscreen_bg->node,
+ (c = focustop(m)) && c->isfullscreen);
+ }
+
+ motionnotify(0, NULL, 0, 0, 0, 0);
+ checkidleinhibitor(NULL);
+}
+
+void
+transactioncheck(void *data)
+{
+ Client *c;
+
+ transaction_idle = NULL;
+
+ /* Hidden clients don't have to redraw before the layout is shown */
+ wl_list_for_each(c, &clients, link) {
+ if (c->resize_serial && VISIBLEON(c, c->mon) && c->mon->wlr_output->enabled) {
+ if (!transaction_waiting) {
+ /* Don't restart the timer on updates of the pending
+ * layout, so the delay is bounded */
+ wl_event_source_timer_update(transaction_timer, TRANSACTION_TIMEOUT);
+ transaction_waiting = 1;
+ }
+ return;
+ }
+ }
+
+ transactionapply();
+}
+
+void
+transactioncommit(Client *c, int ready)
+{
+ if (c->resize_serial && ready) {
+ c->resize_serial = 0;
+ transactionschedule();
+ } else if (c->snapshot) {
+ /* This buffer is not shown, let the client draw again */
+ client_send_frame_done(c);
+ }
+}
+
+void
+transactionschedule(void)
+{
+ if (!transaction_idle)
+ transaction_idle = wl_event_loop_add_idle(event_loop, transactioncheck, NULL);
+}
+
+int
+transactiontimeout(void *data)
+{
+ transactionapply();
+ return 0;
+}
+
+void
unlocksession(struct wl_listener *listener, void *data)
{
SessionLock *lock = wl_container_of(listener, lock, unlock);
@@ 3620,12 4036,10 @@ unmaplayersurfacenotify(struct wl_listener *listener, void *data)
l->mapped = 0;
wlr_scene_node_set_enabled(&l->scene->node, 0);
- if (l == exclusive_focus)
- exclusive_focus = NULL;
if (l->layer_surface->output && (l->mon = l->layer_surface->output->data))
arrangelayers(l->mon);
if (l->layer_surface->surface == seat->keyboard_state.focused_surface)
- focusclient(focustop(selmon), 1);
+ focusclient(focustop(selmon), NULL, 1);
motionnotify(0, NULL, 0, 0, 0, 0);
}
@@ 3634,25 4048,36 @@ 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);
+ struct wlr_scene_node *ghost, **slot;
if (c == grabc) {
cursor_mode = CurNormal;
grabc = NULL;
}
+ if (c == focused_client)
+ focused_client = NULL;
if (c->swallowedby)
swallow(c->swallowedby, c);
- if (client_is_unmanaged(c)) {
- if (c == exclusive_focus) {
- exclusive_focus = NULL;
- focusclient(focustop(selmon), 1);
+ if (!client_is_unmanaged(c)) {
+ /* Keep showing the client until the transaction rearranging the
+ * remaining ones is applied, to not show a gap. A swallowed client
+ * is replaced by its swallower, so there is no gap to hide. */
+ if (!c->swallowing && !c->swallowedby
+ && (ghost = snapshot(&c->scene->node, c->scene->node.parent, NULL))) {
+ if ((slot = wl_array_add(&ghosts, sizeof(ghost))))
+ *slot = ghost;
+ else
+ wlr_scene_node_destroy(ghost);
+ transactionschedule();
}
- } else {
if (!c->swallowing)
wl_list_remove(&c->link);
setmon(c, NULL, 0);
if (!c->swallowing)
wl_list_remove(&c->flink);
+ } else if (client_wants_focus(c)) {
+ focusclient(focustop(selmon), NULL, 1);
}
if (c->swallowedby) {
@@ 3667,7 4092,25 @@ unmapnotify(struct wl_listener *listener, void *data)
c->swallowing = NULL;
}
+ if (c->foreign_toplevel_handle) {
+ wlr_ext_foreign_toplevel_handle_v1_destroy(c->foreign_toplevel_handle);
+ c->foreign_toplevel_handle = NULL;
+ }
+#ifdef XWAYLAND
+ if (c->type != XDGShell && c->capture.image_capture_scene_surface) {
+ wlr_scene_node_destroy(&c->capture.image_capture_scene_surface->buffer->node);
+ c->capture.image_capture_scene_surface = NULL;
+ }
+#endif
+
+ wlr_scene_node_destroy(&c->image_capture_scene->tree.node);
+ c->image_capture_scene = NULL;
+ c->image_capture_source = NULL;
wlr_scene_node_destroy(&c->scene->node);
+ client_surface(c)->data = NULL;
+ c->snapshot = NULL;
+ c->resize_serial = 0;
+ c->current = (struct wlr_box){0};
printstatus();
motionnotify(0, NULL, 0, 0, 0, 0);
}
@@ 3690,10 4133,13 @@ updatemons(struct wl_listener *listener, void *data)
/* First remove from the layout the disabled monitors */
wl_list_for_each(m, &mons, link) {
- if (m->wlr_output->enabled || m->asleep)
+ if (m->wlr_output->enabled)
continue;
config_head = wlr_output_configuration_head_v1_create(config, m->wlr_output);
config_head->state.enabled = 0;
+ if (m->asleep)
+ continue;
+
/* Remove this output from the layout to avoid cursor enter inside it */
wlr_output_layout_remove(output_layout, m->wlr_output);
closemon(m);
@@ 3764,7 4210,7 @@ updatemons(struct wl_listener *listener, void *data)
if (!c->mon && client_surface(c)->mapped)
setmon(c, selmon, c->tags);
}
- focusclient(focustop(selmon), 1);
+ focusclient(focustop(selmon), NULL, 1);
if (selmon->lock_surface) {
client_notify_enter(selmon->lock_surface->surface,
wlr_seat_get_keyboard(seat));
@@ 3788,6 4234,15 @@ updatetitle(struct wl_listener *listener, void *data)
Client *c = wl_container_of(listener, c, set_title);
if (c == focustop(c->mon))
printstatus();
+
+ if (c->foreign_toplevel_handle) {
+ struct wlr_ext_foreign_toplevel_handle_v1_state foreign_toplevel_state = {
+ .app_id = client_get_appid(c),
+ .title = client_get_title(c),
+ };
+ wlr_ext_foreign_toplevel_handle_v1_update_state(c->foreign_toplevel_handle,
+ &foreign_toplevel_state);
+ }
}
void
@@ 3809,7 4264,7 @@ urgent(struct wl_listener *listener, void *data)
selmon = c->mon;
if (!VISIBLEON(c, c->mon))
view(&((Arg){.ui = c->tags}));
- focusclient(c, 1);
+ focusclient(c, NULL, 1);
} else {
client_set_border_color(c, urgentcolor);
printstatus();
@@ 3845,7 4300,7 @@ view(const Arg *arg)
applypertag(m);
attachclients(m);
/* Beware: this changes selmon */
- focusclient(focustop(m), 1);
+ focusclient(focustop(m), NULL, 1);
arrange(m);
break;
}
@@ 3862,7 4317,7 @@ view(const Arg *arg)
selmon = origm;
applypertag(origm);
attachclients(origm);
- focusclient(focustop(origm), 1);
+ focusclient(focustop(origm), NULL, 1);
arrange(origm);
printstatus();
}
@@ 3873,12 4328,14 @@ virtualkeyboard(struct wl_listener *listener, void *data)
struct wlr_virtual_keyboard_v1 *kb = data;
/* virtual keyboards shouldn't share keyboard group */
KeyboardGroup *group = createkeyboardgroup();
+ group->virtual_keyboard = &kb->keyboard;
/* Set the keymap to match the group keymap */
wlr_keyboard_set_keymap(&kb->keyboard, group->wlr_group->keyboard.keymap);
LISTEN(&kb->keyboard.base.events.destroy, &group->destroy, destroykeyboardgroup);
/* Add the new keyboard to the group */
wlr_keyboard_group_add_keyboard(group->wlr_group, &kb->keyboard);
+ wlr_seat_set_capabilities(seat, seat->capabilities | WL_SEAT_CAPABILITY_KEYBOARD);
}
void
@@ 3890,6 4347,7 @@ virtualpointer(struct wl_listener *listener, void *data)
wlr_cursor_attach_input_device(cursor, device);
if (event->suggested_output)
wlr_cursor_map_input_to_output(cursor, device, event->suggested_output);
+ wlr_seat_set_capabilities(seat, seat->capabilities | WL_SEAT_CAPABILITY_POINTER);
}
Monitor *
@@ 3903,31 4361,28 @@ void
xytonode(double x, double y, struct wlr_surface **psurface,
Client **pc, LayerSurface **pl, double *nx, double *ny)
{
- struct wlr_scene_node *node, *pnode;
+ struct wlr_scene_node *node;
+ struct wlr_scene_surface *scene_surface;
struct wlr_surface *surface = NULL;
Client *c = NULL;
- LayerSurface *l = NULL;
int layer;
- for (layer = NUM_LAYERS - 1; !surface && layer >= 0; layer--) {
- if (!(node = wlr_scene_node_at(&layers[layer]->node, x, y, nx, ny)))
+ for (layer = NUM_LAYERS - 1; !surface && !c && layer >= (locked ? LyrBlock : 0); layer--) {
+ if (layer == LyrIMPopup ||
+ !(node = wlr_scene_node_at(&layers[layer]->node, x, y, nx, ny))
+ || node->type != WLR_SCENE_NODE_BUFFER)
continue;
- if (node->type == WLR_SCENE_NODE_BUFFER)
- surface = wlr_scene_surface_try_from_buffer(
- wlr_scene_buffer_from_node(node))->surface;
- /* Walk the tree to find a node that knows the client */
- for (pnode = node; pnode && !c; pnode = &pnode->parent->node)
- c = pnode->data;
- if (c && c->type == LayerShell) {
- c = NULL;
- l = pnode->data;
- }
+ if ((scene_surface = wlr_scene_surface_try_from_buffer(
+ wlr_scene_buffer_from_node(node))))
+ surface = scene_surface->surface;
+ else /* snapshot of a client during a transaction */
+ c = node->data;
}
if (psurface) *psurface = surface;
if (pc) *pc = c;
- if (pl) *pl = l;
+ toplevel_from_wlr_surface(surface, pc, pl);
}
void
@@ 3959,7 4414,7 @@ zoom(const Arg *arg)
wl_list_remove(&sel->link);
wl_list_insert(&clients, &sel->link);
- focusclient(sel, 1);
+ focusclient(sel, NULL, 1);
arrange(selmon);
}
@@ 3987,22 4442,28 @@ associatex11(struct wl_listener *listener, void *data)
{
Client *c = wl_container_of(listener, c, associate);
+ LISTEN(&client_surface(c)->events.commit, &c->commit, commitx11);
LISTEN(&client_surface(c)->events.map, &c->map, mapnotify);
LISTEN(&client_surface(c)->events.unmap, &c->unmap, unmapnotify);
}
void
+commitx11(struct wl_listener *listener, void *data)
+{
+ Client *c = wl_container_of(listener, c, commit);
+ struct wlr_surface *surface = client_surface(c);
+
+ transactioncommit(c, surface->current.width == c->geom.width - 2 * (int)c->bw
+ && surface->current.height == c->geom.height - 2 * (int)c->bw);
+}
+
+void
configurex11(struct wl_listener *listener, void *data)
{
Client *c = wl_container_of(listener, c, configure);
struct wlr_xwayland_surface_configure_event *event = data;
- if (!client_surface(c) || !client_surface(c)->mapped) {
- wlr_xwayland_surface_configure(c->surface.xwayland,
- event->x, event->y, event->width, event->height);
- return;
- }
- if (client_is_unmanaged(c)) {
- wlr_scene_node_set_position(&c->scene->node, event->x, event->y);
+ if (!client_surface(c) || !client_surface(c)->mapped
+ || client_is_unmanaged(c)) {
wlr_xwayland_surface_configure(c->surface.xwayland,
event->x, event->y, event->width, event->height);
return;
@@ 4035,6 4496,7 @@ createnotifyx11(struct wl_listener *listener, void *data)
LISTEN(&xsurface->events.request_activate, &c->activate, activatex11);
LISTEN(&xsurface->events.request_configure, &c->configure, configurex11);
LISTEN(&xsurface->events.request_fullscreen, &c->fullscreen, fullscreennotify);
+ LISTEN(&xsurface->events.set_geometry, &c->set_geometry, setgeometryx11);
LISTEN(&xsurface->events.set_hints, &c->set_hints, sethints);
LISTEN(&xsurface->events.set_title, &c->set_title, updatetitle);
}
@@ 4043,11 4505,25 @@ void
dissociatex11(struct wl_listener *listener, void *data)
{
Client *c = wl_container_of(listener, c, dissociate);
+ wl_list_remove(&c->commit.link);
wl_list_remove(&c->map.link);
wl_list_remove(&c->unmap.link);
}
void
+setgeometryx11(struct wl_listener *listener, void *data)
+{
+ Client *c = wl_container_of(listener, c, set_geometry);
+
+ if (!client_is_unmanaged(c) || !client_surface(c)
+ || !client_surface(c)->mapped)
+ return;
+
+ client_get_geometry(c, &c->geom);
+ wlr_scene_node_set_position(&c->scene->node, c->geom.x, c->geom.y);
+}
+
+void
sethints(struct wl_listener *listener, void *data)
{
Client *c = wl_container_of(listener, c, set_hints);
@@ 4066,7 4542,7 @@ sethints(struct wl_listener *listener, void *data)
selmon = c->mon;
if (!VISIBLEON(c, c->mon))
view(&((Arg){.ui = c->tags}));
- focusclient(c, 1);
+ focusclient(c, NULL, 1);
} else {
client_set_border_color(c, urgentcolor);
printstatus();
@@ 4084,9 4560,7 @@ xwaylandready(struct wl_listener *listener, void *data)
/* Set the default XWayland cursor to match the rest of dwl. */
if ((xcursor = wlr_xcursor_manager_get_xcursor(cursor_mgr, "default", 1)))
- wlr_xwayland_set_cursor(xwayland,
- xcursor->images[0]->buffer, xcursor->images[0]->width * 4,
- xcursor->images[0]->width, xcursor->images[0]->height,
+ wlr_xwayland_set_cursor(xwayland, wlr_xcursor_image_get_buffer(xcursor->images[0]),
xcursor->images[0]->hotspot_x, xcursor->images[0]->hotspot_y);
}
#endif