alex/swayfx
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

Merge pull request #2445 from RyanDwyer/resize-tiling-via-cursor

Browse source 
Implement resizing tiled containers via cursor
This commit is contained in:
Drew DeVault 2018-08-14 09:07:59 -04:00 committed by GitHub
parent d0fb2d9a53 4b8e3a885b
commit b4887ba154
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
11 changed files with 360 additions and 150 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
common/list.c
View file

@ -77,6 +77,15 @@ int list_seq_find(list_t *list, int compare(const void *item, const void *data),
return -1;
}
int list_find(list_t *list, void *item) {
for (int i = 0; i < list->length; i++) {
if (list->items[i] == item) {
return i;
}
}
return -1;
}
void list_swap(list_t *list, int src, int dest) {
void *tmp = list->items[src];
list->items[src] = list->items[dest];

1
include/list.h
View file

@ -20,6 +20,7 @@ void list_qsort(list_t *list, int compare(const void *left, const void *right));
// Return index for first item in list that returns 0 for given compare
// function or -1 if none matches.
int list_seq_find(list_t *list, int compare(const void *item, const void *cmp_to), const void *cmp_to);
int list_find(list_t *list, void *item);
// stable sort since qsort is not guaranteed to be stable
void list_stable_sort(list_t *list, int compare(const void *a, const void *b));
// swap two elements in a list

7
include/sway/commands.h
View file

@ -1,6 +1,7 @@
#ifndef _SWAY_COMMANDS_H
#define _SWAY_COMMANDS_H
#include <wlr/util/edges.h>
#include "config.h"
typedef struct cmd_results *sway_cmd(int argc, char **argv);
@ -84,6 +85,12 @@ char *cmd_results_to_json(struct cmd_results *results);
struct cmd_results *add_color(const char *name,
char *buffer, const char *color);
/**
* TODO: Move this function and its dependent functions to container.c.
*/
void container_resize_tiled(struct sway_container *parent, enum wlr_edges edge,
int amount);
sway_cmd cmd_assign;
sway_cmd cmd_bar;
sway_cmd cmd_bindcode;

10
include/sway/input/seat.h
View file

@ -57,7 +57,8 @@ struct sway_seat {
enum {
OP_NONE,
OP_MOVE,
OP_RESIZE,
OP_RESIZE_FLOATING,
OP_RESIZE_TILING,
} operation;
struct sway_container *op_container;
@ -159,8 +160,11 @@ void drag_icon_update_position(struct sway_drag_icon *icon);
void seat_begin_move(struct sway_seat *seat, struct sway_container *con,
uint32_t button);
void seat_begin_resize(struct sway_seat *seat, struct sway_container *con,
uint32_t button, enum wlr_edges edge);
void seat_begin_resize_floating(struct sway_seat *seat,
struct sway_container *con, uint32_t button, enum wlr_edges edge);
void seat_begin_resize_tiling(struct sway_seat *seat,
struct sway_container *con, uint32_t button, enum wlr_edges edge);
void seat_end_mouse_operation(struct sway_seat *seat);

34
sway/commands/resize.c
View file

@ -158,8 +158,8 @@ static int parallel_size(struct sway_container *c, enum resize_axis a) {
return normalize_axis(a) == RESIZE_AXIS_HORIZONTAL ? c->width : c->height;
}
static void resize_tiled(int amount, enum resize_axis axis) {
struct sway_container *parent = config->handler_context.current_container;
static void resize_tiled(struct sway_container *parent, int amount,
enum resize_axis axis) {
struct sway_container *focused = parent;
if (!parent) {
return;
@ -297,6 +297,28 @@ static void resize_tiled(int amount, enum resize_axis axis) {
arrange_windows(parent->parent);
}
void container_resize_tiled(struct sway_container *parent,
enum wlr_edges edge, int amount) {
enum resize_axis axis = RESIZE_AXIS_INVALID;
switch (edge) {
case WLR_EDGE_TOP:
axis = RESIZE_AXIS_UP;
break;
case WLR_EDGE_RIGHT:
axis = RESIZE_AXIS_RIGHT;
break;
case WLR_EDGE_BOTTOM:
axis = RESIZE_AXIS_DOWN;
break;
case WLR_EDGE_LEFT:
axis = RESIZE_AXIS_LEFT;
break;
case WLR_EDGE_NONE:
break;
}
resize_tiled(parent, amount, axis);
}
/**
* Implement `resize <grow|shrink>` for a floating container.
*/
@ -398,7 +420,7 @@ static struct cmd_results *resize_adjust_tiled(enum resize_axis axis,
}
}
resize_tiled(amount->amount, axis);
resize_tiled(current, amount->amount, axis);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}
@ -421,7 +443,8 @@ static struct cmd_results *resize_set_tiled(struct sway_container *con,
}
}
if (width->unit == RESIZE_UNIT_PX) {
resize_tiled(width->amount - con->width, RESIZE_AXIS_HORIZONTAL);
resize_tiled(con, width->amount - con->width,
RESIZE_AXIS_HORIZONTAL);
}
}
@ -439,7 +462,8 @@ static struct cmd_results *resize_set_tiled(struct sway_container *con,
}
}
if (height->unit == RESIZE_UNIT_PX) {
resize_tiled(height->amount - con->height, RESIZE_AXIS_VERTICAL);
resize_tiled(con, height->amount - con->height,
RESIZE_AXIS_HORIZONTAL);
}
}

72
sway/desktop/transaction.c
View file

@ -33,6 +33,7 @@ struct sway_transaction {
list_t *instructions; // struct sway_transaction_instruction *
size_t num_waiting;
size_t num_configures;
uint32_t con_ids; // Bitwise XOR of view container IDs
struct timespec create_time;
struct timespec commit_time;
};
@ -212,17 +213,43 @@ static void transaction_apply(struct sway_transaction *transaction) {
}
}
static void transaction_commit(struct sway_transaction *transaction);
static void transaction_progress_queue() {
while (server.transactions->length) {
struct sway_transaction *transaction = server.transactions->items[0];
if (transaction->num_waiting) {
return;
}
transaction_apply(transaction);
transaction_destroy(transaction);
list_del(server.transactions, 0);
if (!server.transactions->length) {
return;
}
idle_inhibit_v1_check_active(server.idle_inhibit_manager_v1);
// There's only ever one committed transaction,
// and it's the first one in the queue.
struct sway_transaction *transaction = server.transactions->items[0];
if (transaction->num_waiting) {
return;
}
transaction_apply(transaction);
transaction_destroy(transaction);
list_del(server.transactions, 0);
if (!server.transactions->length) {
idle_inhibit_v1_check_active(server.idle_inhibit_manager_v1);
return;
}
// If there's a bunch of consecutive transactions which all apply to the
// same views, skip all except the last one.
while (server.transactions->length >= 2) {
struct sway_transaction *a = server.transactions->items[0];
struct sway_transaction *b = server.transactions->items[1];
if (a->con_ids == b->con_ids) {
list_del(server.transactions, 0);
transaction_destroy(a);
} else {
break;
}
}
transaction = server.transactions->items[0];
transaction_commit(transaction);
transaction_progress_queue();
}
static int handle_timeout(void *data) {
@ -276,6 +303,7 @@ static void transaction_commit(struct sway_transaction *transaction) {
instruction->state.view_width,
instruction->state.view_height);
++transaction->num_waiting;
transaction->con_ids ^= con->id;
// From here on we are rendering a saved buffer of the view, which
// means we can send a frame done event to make the client redraw it
@ -293,17 +321,6 @@ static void transaction_commit(struct sway_transaction *transaction) {
if (server.debug_txn_timings) {
clock_gettime(CLOCK_MONOTONIC, &transaction->commit_time);
}
if (server.transactions->length || transaction->num_waiting) {
list_add(server.transactions, transaction);
} else {
// There are no other transactions in progress, and this one has nothing
// to wait for, so we can skip the queue.
wlr_log(WLR_DEBUG, "Transaction %p has nothing to wait for", transaction);
transaction_apply(transaction);
transaction_destroy(transaction);
idle_inhibit_v1_check_active(server.idle_inhibit_manager_v1);
return;
}
if (transaction->num_waiting) {
// Set up a timer which the views must respond within
@ -317,6 +334,9 @@ static void transaction_commit(struct sway_transaction *transaction) {
strerror(errno));
handle_timeout(transaction);
}
} else {
wlr_log(WLR_DEBUG,
"Transaction %p has nothing to wait for", transaction);
}
// The debug tree shows the pending/live tree. Here is a good place to
@ -403,5 +423,15 @@ void transaction_commit_dirty(void) {
container->dirty = false;
}
server.dirty_containers->length = 0;
transaction_commit(transaction);
list_add(server.transactions, transaction);
// There's only ever one committed transaction,
// and it's the first one in the queue.
if (server.transactions->length == 1) {
transaction_commit(transaction);
// Attempting to progress the queue here is useful
// if the transaction has nothing to wait for.
transaction_progress_queue();
}
}

3
sway/desktop/xdg_shell.c
View file

@ -331,7 +331,8 @@ static void handle_request_resize(struct wl_listener *listener, void *data) {
struct wlr_xdg_toplevel_resize_event *e = data;
struct sway_seat *seat = e->seat->seat->data;
if (e->serial == seat->last_button_serial) {
seat_begin_resize(seat, view->swayc, seat->last_button, e->edges);
seat_begin_resize_floating(seat, view->swayc,
seat->last_button, e->edges);
}
}

3
sway/desktop/xdg_shell_v6.c
View file

@ -327,7 +327,8 @@ static void handle_request_resize(struct wl_listener *listener, void *data) {
struct wlr_xdg_toplevel_v6_resize_event *e = data;
struct sway_seat *seat = e->seat->seat->data;
if (e->serial == seat->last_button_serial) {
seat_begin_resize(seat, view->swayc, seat->last_button, e->edges);
seat_begin_resize_floating(seat, view->swayc,
seat->last_button, e->edges);
}
}

2
sway/desktop/xwayland.c
View file

@ -432,7 +432,7 @@ static void handle_request_resize(struct wl_listener *listener, void *data) {
}
struct wlr_xwayland_resize_event *e = data;
struct sway_seat *seat = input_manager_current_seat(input_manager);
seat_begin_resize(seat, view->swayc, seat->last_button, e->edges);
seat_begin_resize_floating(seat, view->swayc, seat->last_button, e->edges);
}
static void handle_set_title(struct wl_listener *listener, void *data) {

331
sway/input/cursor.c
View file

@ -12,6 +12,7 @@
#include "list.h"
#include "log.h"
#include "config.h"
#include "sway/commands.h"
#include "sway/desktop.h"
#include "sway/desktop/transaction.h"
#include "sway/input/cursor.h"
@ -136,7 +137,45 @@ static struct sway_container *container_at_coords(
return output->swayc;
}
static enum wlr_edges find_resize_edge(struct sway_container *cont,
/**
* Determine if the edge of the given container is on the edge of the
* workspace/output.
*/
static bool edge_is_external(struct sway_container *cont, enum wlr_edges edge) {
enum sway_container_layout layout = L_NONE;
switch (edge) {
case WLR_EDGE_TOP:
case WLR_EDGE_BOTTOM:
layout = L_VERT;
break;
case WLR_EDGE_LEFT:
case WLR_EDGE_RIGHT:
layout = L_HORIZ;
break;
case WLR_EDGE_NONE:
sway_assert(false, "Never reached");
return false;
}
// Iterate the parents until we find one with the layout we want,
// then check if the child has siblings between it and the edge.
while (cont->type != C_OUTPUT) {
if (cont->parent->layout == layout) {
int index = list_find(cont->parent->children, cont);
if (index > 0 && (edge == WLR_EDGE_LEFT || edge == WLR_EDGE_TOP)) {
return false;
}
if (index < cont->parent->children->length - 1 &&
(edge == WLR_EDGE_RIGHT || edge == WLR_EDGE_BOTTOM)) {
return false;
}
}
cont = cont->parent;
}
return true;
}
static enum wlr_edges find_edge(struct sway_container *cont,
struct sway_cursor *cursor) {
if (cont->type != C_VIEW) {
return WLR_EDGE_NONE;
@ -159,6 +198,20 @@ static enum wlr_edges find_resize_edge(struct sway_container *cont,
if (cursor->cursor->y >= cont->y + cont->height - view->border_thickness) {
edge |= WLR_EDGE_BOTTOM;
}
return edge;
}
/**
* If the cursor is over a _resizable_ edge, return the edge.
* Edges that can't be resized are edges of the workspace.
*/
static enum wlr_edges find_resize_edge(struct sway_container *cont,
struct sway_cursor *cursor) {
enum wlr_edges edge = find_edge(cont, cursor);
if (edge && !container_is_floating(cont) && edge_is_external(cont, edge)) {
return WLR_EDGE_NONE;
}
return edge;
}
@ -209,7 +262,7 @@ static void calculate_floating_constraints(struct sway_container *con,
}
}
static void handle_resize_motion(struct sway_seat *seat,
static void handle_resize_floating_motion(struct sway_seat *seat,
struct sway_cursor *cursor) {
struct sway_container *con = seat->op_container;
enum wlr_edges edge = seat->op_resize_edge;
@ -301,6 +354,39 @@ static void handle_resize_motion(struct sway_seat *seat,
arrange_windows(con);
}
static void handle_resize_tiling_motion(struct sway_seat *seat,
struct sway_cursor *cursor) {
int amount_x = 0;
int amount_y = 0;
int moved_x = cursor->cursor->x - seat->op_ref_lx;
int moved_y = cursor->cursor->y - seat->op_ref_ly;
enum wlr_edges edge_x = WLR_EDGE_NONE;
enum wlr_edges edge_y = WLR_EDGE_NONE;
struct sway_container *con = seat->op_container;
if (seat->op_resize_edge & WLR_EDGE_TOP) {
amount_y = (seat->op_ref_height - moved_y) - con->height;
edge_y = WLR_EDGE_TOP;
} else if (seat->op_resize_edge & WLR_EDGE_BOTTOM) {
amount_y = (seat->op_ref_height + moved_y) - con->height;
edge_y = WLR_EDGE_BOTTOM;
}
if (seat->op_resize_edge & WLR_EDGE_LEFT) {
amount_x = (seat->op_ref_width - moved_x) - con->width;
edge_x = WLR_EDGE_LEFT;
} else if (seat->op_resize_edge & WLR_EDGE_RIGHT) {
amount_x = (seat->op_ref_width + moved_x) - con->width;
edge_x = WLR_EDGE_RIGHT;
}
if (amount_x != 0) {
container_resize_tiled(seat->op_container, edge_x, amount_x);
}
if (amount_y != 0) {
container_resize_tiled(seat->op_container, edge_y, amount_y);
}
}
void cursor_send_pointer_motion(struct sway_cursor *cursor, uint32_t time_msec,
bool allow_refocusing) {
if (time_msec == 0) {
@ -310,10 +396,18 @@ void cursor_send_pointer_motion(struct sway_cursor *cursor, uint32_t time_msec,
struct sway_seat *seat = cursor->seat;
if (seat->operation != OP_NONE) {
if (seat->operation == OP_MOVE) {
switch (seat->operation) {
case OP_MOVE:
handle_move_motion(seat, cursor);
} else {
handle_resize_motion(seat, cursor);
break;
case OP_RESIZE_FLOATING:
handle_resize_floating_motion(seat, cursor);
break;
case OP_RESIZE_TILING:
handle_resize_tiling_motion(seat, cursor);
break;
case OP_NONE:
break;
}
cursor->previous.x = cursor->cursor->x;
cursor->previous.y = cursor->cursor->y;
@ -375,12 +469,20 @@ void cursor_send_pointer_motion(struct sway_cursor *cursor, uint32_t time_msec,
if (client != cursor->image_client) {
cursor_set_image(cursor, "left_ptr", client);
}
} else if (c && container_is_floating(c)) {
// Try a floating container's resize edge
} else if (c) {
// Try a container's resize edge
enum wlr_edges edge = find_resize_edge(c, cursor);
const char *image = edge == WLR_EDGE_NONE ?
"left_ptr" : wlr_xcursor_get_resize_name(edge);
cursor_set_image(cursor, image, NULL);
if (edge == WLR_EDGE_NONE) {
cursor_set_image(cursor, "left_ptr", NULL);
} else if (container_is_floating(c)) {
cursor_set_image(cursor, wlr_xcursor_get_resize_name(edge), NULL);
} else {
if (edge & (WLR_EDGE_LEFT | WLR_EDGE_RIGHT)) {
cursor_set_image(cursor, "col-resize", NULL);
} else {
cursor_set_image(cursor, "row-resize", NULL);
}
}
} else {
cursor_set_image(cursor, "left_ptr", NULL);
}
@ -423,57 +525,6 @@ static void handle_cursor_motion_absolute(
transaction_commit_dirty();
}
static void dispatch_cursor_button_floating(struct sway_cursor *cursor,
uint32_t time_msec, uint32_t button, enum wlr_button_state state,
struct wlr_surface *surface, double sx, double sy,
struct sway_container *cont) {
struct sway_seat *seat = cursor->seat;
seat_set_focus(seat, cont);
// Deny moving or resizing a fullscreen container
if (container_is_fullscreen_or_child(cont)) {
seat_pointer_notify_button(seat, time_msec, button, state);
return;
}
struct sway_container *floater = cont;
while (floater->parent->layout != L_FLOATING) {
floater = floater->parent;
}
struct wlr_keyboard *keyboard = wlr_seat_get_keyboard(seat->wlr_seat);
bool mod_pressed = keyboard &&
(wlr_keyboard_get_modifiers(keyboard) & config->floating_mod);
enum wlr_edges edge = find_resize_edge(floater, cursor);
bool over_title = edge == WLR_EDGE_NONE && !surface;
// Check for beginning move
uint32_t btn_move = config->floating_mod_inverse ? BTN_RIGHT : BTN_LEFT;
if (button == btn_move && state == WLR_BUTTON_PRESSED &&
(mod_pressed || over_title)) {
seat_begin_move(seat, floater, button);
return;
}
// Check for beginning resize
bool resizing_via_border = button == BTN_LEFT && edge != WLR_EDGE_NONE;
uint32_t btn_resize = config->floating_mod_inverse ? BTN_LEFT : BTN_RIGHT;
bool resizing_via_mod = button == btn_resize && mod_pressed;
if ((resizing_via_border || resizing_via_mod) &&
state == WLR_BUTTON_PRESSED) {
if (edge == WLR_EDGE_NONE) {
edge |= cursor->cursor->x > floater->x + floater->width / 2 ?
WLR_EDGE_RIGHT : WLR_EDGE_LEFT;
edge |= cursor->cursor->y > floater->y + floater->height / 2 ?
WLR_EDGE_BOTTOM : WLR_EDGE_TOP;
}
seat_begin_resize(seat, floater, button, edge);
return;
}
seat_pointer_notify_button(seat, time_msec, button, state);
}
/**
* Remove a button (and duplicates) to the sorted list of currently pressed buttons
*/
@ -553,26 +604,36 @@ static struct sway_binding* get_active_mouse_binding(const struct sway_cursor *c
void dispatch_cursor_button(struct sway_cursor *cursor,
uint32_t time_msec, uint32_t button, enum wlr_button_state state) {
if (cursor->seat->operation != OP_NONE &&
button == cursor->seat->op_button && state == WLR_BUTTON_RELEASED) {
seat_end_mouse_operation(cursor->seat);
seat_pointer_notify_button(cursor->seat, time_msec, button, state);
return;
}
if (time_msec == 0) {
time_msec = get_current_time_msec();
}
struct sway_seat *seat = cursor->seat;
// Handle ending seat operation
if (cursor->seat->operation != OP_NONE &&
button == cursor->seat->op_button && state == WLR_BUTTON_RELEASED) {
seat_end_mouse_operation(seat);
seat_pointer_notify_button(seat, time_msec, button, state);
return;
}
// Determine what's under the cursor
struct wlr_surface *surface = NULL;
double sx, sy;
struct sway_container *cont = container_at_coords(cursor->seat,
struct sway_container *cont = container_at_coords(seat,
cursor->cursor->x, cursor->cursor->y, &surface, &sx, &sy);
bool is_floating = cont && container_is_floating(cont);
bool is_floating_or_child = cont && container_is_floating_or_child(cont);
bool is_fullscreen_or_child = cont && container_is_fullscreen_or_child(cont);
enum wlr_edges edge = cont ? find_edge(cont, cursor) : WLR_EDGE_NONE;
enum wlr_edges resize_edge = edge ?
find_resize_edge(cont, cursor) : WLR_EDGE_NONE;
bool on_border = edge != WLR_EDGE_NONE;
bool on_contents = cont && !on_border && surface;
bool on_titlebar = cont && !on_border && !surface;
// Handle mouse bindings
bool on_border = cont && (find_resize_edge(cont, cursor) != WLR_EDGE_NONE);
bool on_contents = !on_border && surface;
bool on_titlebar = !on_border && !surface;
struct wlr_keyboard *keyboard = wlr_seat_get_keyboard(cursor->seat->wlr_seat);
struct wlr_keyboard *keyboard = wlr_seat_get_keyboard(seat->wlr_seat);
uint32_t modifiers = keyboard ? wlr_keyboard_get_modifiers(keyboard) : 0;
struct sway_binding *binding = NULL;
@ -588,45 +649,108 @@ void dispatch_cursor_button(struct sway_cursor *cursor,
state_erase_button(cursor, button);
}
if (binding) {
seat_execute_command(cursor->seat, binding);
// TODO: do we want to pass on the event?
seat_execute_command(seat, binding);
return;
}
// Handle clicking a layer surface
if (surface && wlr_surface_is_layer_surface(surface)) {
struct wlr_layer_surface *layer =
wlr_layer_surface_from_wlr_surface(surface);
if (layer->current.keyboard_interactive) {
seat_set_focus_layer(cursor->seat, layer);
seat_set_focus_layer(seat, layer);
}
seat_pointer_notify_button(cursor->seat, time_msec, button, state);
} else if (cont && container_is_floating_or_child(cont)) {
dispatch_cursor_button_floating(cursor, time_msec, button, state,
surface, sx, sy, cont);
} else if (surface && cont && cont->type != C_VIEW) {
// Avoid moving keyboard focus from a surface that accepts it to one
// that does not unless the change would move us to a new workspace.
//
// This prevents, for example, losing focus when clicking on swaybar.
struct sway_container *new_ws = cont;
if (new_ws && new_ws->type != C_WORKSPACE) {
new_ws = container_parent(new_ws, C_WORKSPACE);
}
struct sway_container *old_ws = seat_get_focus(cursor->seat);
if (old_ws && old_ws->type != C_WORKSPACE) {
old_ws = container_parent(old_ws, C_WORKSPACE);
}
if (new_ws != old_ws) {
seat_set_focus(cursor->seat, cont);
}
seat_pointer_notify_button(cursor->seat, time_msec, button, state);
} else if (cont) {
seat_set_focus(cursor->seat, cont);
seat_pointer_notify_button(cursor->seat, time_msec, button, state);
} else {
seat_pointer_notify_button(cursor->seat, time_msec, button, state);
seat_pointer_notify_button(seat, time_msec, button, state);
return;
}
transaction_commit_dirty();
// Handle tiling resize via border
if (resize_edge && button == BTN_LEFT && state == WLR_BUTTON_PRESSED &&
!is_floating) {
seat_set_focus(seat, cont);
seat_begin_resize_tiling(seat, cont, button, edge);
return;
}
// Handle tiling resize via mod
bool mod_pressed = keyboard &&
(wlr_keyboard_get_modifiers(keyboard) & config->floating_mod);
if (!is_floating_or_child && mod_pressed && state == WLR_BUTTON_PRESSED) {
uint32_t btn_resize = config->floating_mod_inverse ?
BTN_LEFT : BTN_RIGHT;
if (button == btn_resize) {
edge = 0;
edge |= cursor->cursor->x > cont->x + cont->width / 2 ?
WLR_EDGE_RIGHT : WLR_EDGE_LEFT;
edge |= cursor->cursor->y > cont->y + cont->height / 2 ?
WLR_EDGE_BOTTOM : WLR_EDGE_TOP;
const char *image = NULL;
if (edge == (WLR_EDGE_LEFT | WLR_EDGE_TOP)) {
image = "nw-resize";
} else if (edge == (WLR_EDGE_TOP | WLR_EDGE_RIGHT)) {
image = "ne-resize";
} else if (edge == (WLR_EDGE_RIGHT | WLR_EDGE_BOTTOM)) {
image = "se-resize";
} else if (edge == (WLR_EDGE_BOTTOM | WLR_EDGE_LEFT)) {
image = "sw-resize";
}
cursor_set_image(seat->cursor, image, NULL);
seat_set_focus(seat, cont);
seat_begin_resize_tiling(seat, cont, button, edge);
return;
}
}
// Handle beginning floating move
if (is_floating_or_child && !is_fullscreen_or_child &&
state == WLR_BUTTON_PRESSED) {
uint32_t btn_move = config->floating_mod_inverse ? BTN_RIGHT : BTN_LEFT;
if (button == btn_move && state == WLR_BUTTON_PRESSED &&
(mod_pressed || on_titlebar)) {
while (cont->parent->layout != L_FLOATING) {
cont = cont->parent;
}
seat_begin_move(seat, cont, button);
return;
}
}
// Handle beginning floating resize
if (is_floating_or_child && !is_fullscreen_or_child &&
state == WLR_BUTTON_PRESSED) {
// Via border
if (button == BTN_LEFT && resize_edge != WLR_EDGE_NONE) {
seat_begin_resize_floating(seat, cont, button, resize_edge);
return;
}
// Via mod+click
struct sway_container *floater = cont;
while (floater->parent->layout != L_FLOATING) {
floater = floater->parent;
}
uint32_t btn_resize = config->floating_mod_inverse ?
BTN_LEFT : BTN_RIGHT;
if (button == btn_resize) {
edge = 0;
edge |= cursor->cursor->x > floater->x + floater->width / 2 ?
WLR_EDGE_RIGHT : WLR_EDGE_LEFT;
edge |= cursor->cursor->y > floater->y + floater->height / 2 ?
WLR_EDGE_BOTTOM : WLR_EDGE_TOP;
seat_begin_resize_floating(seat, floater, button, edge);
return;
}
}
// Handle clicking a container surface
if (cont) {
seat_set_focus(seat, cont);
seat_pointer_notify_button(seat, time_msec, button, state);
return;
}
seat_pointer_notify_button(seat, time_msec, button, state);
}
static void handle_cursor_button(struct wl_listener *listener, void *data) {
@ -635,6 +759,7 @@ static void handle_cursor_button(struct wl_listener *listener, void *data) {
struct wlr_event_pointer_button *event = data;
dispatch_cursor_button(cursor,
event->time_msec, event->button, event->state);
transaction_commit_dirty();
}
static void handle_cursor_axis(struct wl_listener *listener, void *data) {
@ -782,6 +907,7 @@ static void handle_tool_tip(struct wl_listener *listener, void *data) {
dispatch_cursor_button(cursor, event->time_msec,
BTN_LEFT, event->state == WLR_TABLET_TOOL_TIP_DOWN ?
WLR_BUTTON_PRESSED : WLR_BUTTON_RELEASED);
transaction_commit_dirty();
}
static void handle_tool_button(struct wl_listener *listener, void *data) {
@ -806,6 +932,7 @@ static void handle_tool_button(struct wl_listener *listener, void *data) {
cursor->tool_buttons--;
break;
}
transaction_commit_dirty();
}
static void handle_request_set_cursor(struct wl_listener *listener,

38
sway/input/seat.c
View file

@ -942,14 +942,14 @@ void seat_begin_move(struct sway_seat *seat, struct sway_container *con,
cursor_set_image(seat->cursor, "grab", NULL);
}
void seat_begin_resize(struct sway_seat *seat, struct sway_container *con,
uint32_t button, enum wlr_edges edge) {
void seat_begin_resize_floating(struct sway_seat *seat,
struct sway_container *con, uint32_t button, enum wlr_edges edge) {
if (!seat->cursor) {
wlr_log(WLR_DEBUG, "Ignoring resize request due to no cursor device");
return;
}
struct wlr_keyboard *keyboard = wlr_seat_get_keyboard(seat->wlr_seat);
seat->operation = OP_RESIZE;
seat->operation = OP_RESIZE_FLOATING;
seat->op_container = con;
seat->op_resize_preserve_ratio = keyboard &&
(wlr_keyboard_get_modifiers(keyboard) & WLR_MODIFIER_SHIFT);
@ -968,20 +968,26 @@ void seat_begin_resize(struct sway_seat *seat, struct sway_container *con,
cursor_set_image(seat->cursor, image, NULL);
}
void seat_begin_resize_tiling(struct sway_seat *seat,
struct sway_container *con, uint32_t button, enum wlr_edges edge) {
seat->operation = OP_RESIZE_TILING;
seat->op_container = con;
seat->op_resize_edge = edge;
seat->op_button = button;
seat->op_ref_lx = seat->cursor->cursor->x;
seat->op_ref_ly = seat->cursor->cursor->y;
seat->op_ref_con_lx = con->x;
seat->op_ref_con_ly = con->y;
seat->op_ref_width = con->width;
seat->op_ref_height = con->height;
}
void seat_end_mouse_operation(struct sway_seat *seat) {
switch (seat->operation) {
case OP_MOVE:
{
// We "move" the container to its own location so it discovers its
// output again.
struct sway_container *con = seat->op_container;
container_floating_move_to(con, con->x, con->y);
}
case OP_RESIZE:
// Don't need to do anything here.
break;
case OP_NONE:
break;
if (seat->operation == OP_MOVE) {
// We "move" the container to its own location so it discovers its
// output again.
struct sway_container *con = seat->op_container;
container_floating_move_to(con, con->x, con->y);
}
seat->operation = OP_NONE;
seat->op_container = NULL;