mirrors
/
sway
mirror of https://github.com/swaywm/sway.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #1700 from swaywm/move-cmd-full 

Implement move [left|right|up|down]
This commit is contained in:
Drew DeVault 2018-04-07 11:19:25 -04:00 committed by GitHub
parent 2c9f0fb784 93ca8919f6
commit f5a9bd5cb7
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
12 changed files with 501 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
include/sway/debug.h Normal file
View File

@ -0,0 +1,7 @@
#ifndef SWAY_DEBUG_H
#define SWAY_DEBUG_H
extern bool enable_debug_tree;
void update_debug_tree();
#endif

7
include/sway/tree/container.h
View File

@ -182,4 +182,11 @@ void container_create_notify(struct sway_container *container);
void container_damage_whole(struct sway_container *container);
bool container_reap_empty(struct sway_container *con);
struct sway_container *container_reap_empty_recursive(
struct sway_container *con);
struct sway_container *container_flatten(struct sway_container *container);
#endif

4
include/sway/tree/layout.h
View File

@ -1,7 +1,7 @@
#ifndef _SWAY_LAYOUT_H
#define _SWAY_LAYOUT_H
#include <wlr/types/wlr_output_layout.h>
#include <wlr/render/wlr_texture.h>
#include "sway/tree/container.h"
enum movement_direction {
@ -29,6 +29,8 @@ struct sway_root {
struct wl_list xwayland_unmanaged; // sway_xwayland_unmanaged::link
struct wlr_texture *debug_tree;
struct {
struct wl_signal new_container;
} events;

4
sway/commands/move.c
View File

@ -82,6 +82,8 @@ static struct cmd_results *cmd_move_container(struct sway_container *current,
config->handler_context.seat, ws);
container_move_to(current, focus);
seat_set_focus(config->handler_context.seat, old_parent);
container_reap_empty(old_parent);
container_reap_empty(focus->parent);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
} else if (strcasecmp(argv[1], "to") == 0
&& strcasecmp(argv[2], "output") == 0) {
@ -109,6 +111,8 @@ static struct cmd_results *cmd_move_container(struct sway_container *current,
struct sway_container *old_parent = current->parent;
container_move_to(current, focus);
seat_set_focus(config->handler_context.seat, old_parent);
container_reap_empty(old_parent);
container_reap_empty(focus->parent);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}
return cmd_results_new(CMD_INVALID, "move", expected_syntax);

119
sway/debug-tree.c Normal file
View File

@ -0,0 +1,119 @@
#include <pango/pangocairo.h>
#include <wlr/backend.h>
#include <wlr/render/wlr_texture.h>
#include <wlr/util/log.h>
#include "config.h"
#include "sway/input/input-manager.h"
#include "sway/input/seat.h"
#include "sway/server.h"
#include "sway/tree/container.h"
#include "sway/tree/layout.h"
#include "cairo.h"
#include "config.h"
#include "pango.h"
static const char *layout_to_str(enum sway_container_layout layout) {
switch (layout) {
case L_HORIZ:
return "L_HORIZ";
case L_VERT:
return "L_VERT";
case L_STACKED:
return "L_STACKED";
case L_TABBED:
return "L_TABBED";
case L_FLOATING:
return "L_FLOATING";
case L_NONE:
default:
return "L_NONE";
}
}
static int draw_container(cairo_t *cairo, struct sway_container *container,
struct sway_container *focus, int x, int y) {
int text_width, text_height;
get_text_size(cairo, "monospace", &text_width, &text_height,
1, false, "%s id:%zd '%s' %s %.fx%.f@%.f,%.f",
container_type_to_str(container->type), container->id, container->name,
layout_to_str(container->layout),
container->width, container->height, container->x, container->y);
cairo_save(cairo);
cairo_rectangle(cairo, x + 2, y, text_width - 2, text_height);
cairo_set_source_u32(cairo, 0xFFFFFFE0);
cairo_fill(cairo);
int height = text_height;
if (container->children) {
for (int i = 0; i < container->children->length; ++i) {
struct sway_container *child = container->children->items[i];
if (child->parent == container) {
cairo_set_source_u32(cairo, 0x000000FF);
} else {
cairo_set_source_u32(cairo, 0xFF0000FF);
}
height += draw_container(cairo, child, focus, x + 10, y + height);
}
}
cairo_set_source_u32(cairo, 0xFFFFFFE0);
cairo_rectangle(cairo, x, y, 2, height);
cairo_fill(cairo);
cairo_restore(cairo);
cairo_move_to(cairo, x, y);
if (focus == container) {
cairo_set_source_u32(cairo, 0x0000FFFF);
}
pango_printf(cairo, "monospace", 1, false, "%s id:%zd '%s' %s %.fx%.f@%.f,%.f",
container_type_to_str(container->type), container->id, container->name,
layout_to_str(container->layout),
container->width, container->height, container->x, container->y);
return height;
}
bool enable_debug_tree = false;
void update_debug_tree() {
if (!enable_debug_tree) {
return;
}
int width = 640, height = 480;
for (int i = 0; i < root_container.children->length; ++i) {
struct sway_container *container = root_container.children->items[i];
if (container->width > width) {
width = container->width;
}
if (container->height > height) {
height = container->height;
}
}
cairo_surface_t *surface =
cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height);
cairo_t *cairo = cairo_create(surface);
PangoContext *pango = pango_cairo_create_context(cairo);
struct sway_seat *seat = NULL;
wl_list_for_each(seat, &input_manager->seats, link) {
break;
}
struct sway_container *focus = NULL;
if (seat != NULL) {
focus = seat_get_focus(seat);
}
cairo_set_source_u32(cairo, 0x000000FF);
draw_container(cairo, &root_container, focus, 0, 0);
cairo_surface_flush(surface);
struct wlr_renderer *renderer = wlr_backend_get_renderer(server.backend);
if (root_container.sway_root->debug_tree) {
wlr_texture_destroy(root_container.sway_root->debug_tree);
}
unsigned char *data = cairo_image_surface_get_data(surface);
int stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, width);
struct wlr_texture *texture = wlr_texture_from_pixels(renderer,
WL_SHM_FORMAT_ARGB8888, stride, width, height, data);
root_container.sway_root->debug_tree = texture;
cairo_surface_destroy(surface);
g_object_unref(pango);
cairo_destroy(cairo);
}

5
sway/desktop/output.c
View File

@ -294,6 +294,11 @@ static void render_output(struct sway_output *output, struct timespec *when,
&output->layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY]);
renderer_end:
if (root_container.sway_root->debug_tree) {
wlr_render_texture(renderer, root_container.sway_root->debug_tree,
wlr_output->transform_matrix, 0, 0, 1);
}
wlr_renderer_end(renderer);
if (!wlr_output_damage_swap_buffers(output->damage, when, damage)) {
return;

3
sway/input/seat.c
View File

@ -5,6 +5,7 @@
#include <wlr/types/wlr_cursor.h>
#include <wlr/types/wlr_output_layout.h>
#include <wlr/types/wlr_xcursor_manager.h>
#include "sway/debug.h"
#include "sway/tree/container.h"
#include "sway/tree/workspace.h"
#include "sway/input/seat.h"
@ -432,6 +433,8 @@ void seat_set_focus_warp(struct sway_seat *seat,
}
seat->has_focus = (container != NULL);
update_debug_tree();
}
void seat_set_focus(struct sway_seat *seat,

6
sway/main.c
View File

@ -17,6 +17,7 @@
#endif
#include <wlr/util/log.h>
#include "sway/config.h"
#include "sway/debug.h"
#include "sway/server.h"
#include "sway/tree/layout.h"
#include "sway/ipc-server.h"
@ -288,7 +289,7 @@ int main(int argc, char **argv) {
int c;
while (1) {
int option_index = 0;
c = getopt_long(argc, argv, "hCdvVc:", long_options, &option_index);
c = getopt_long(argc, argv, "hCdDvVc:", long_options, &option_index);
if (c == -1) {
break;
}
@ -306,6 +307,9 @@ int main(int argc, char **argv) {
case 'd': // debug
debug = 1;
break;
case 'D': // extended debug options
enable_debug_tree = true;
break;
case 'v': // version
fprintf(stdout, "sway version " SWAY_VERSION "\n");
exit(EXIT_SUCCESS);

4
sway/meson.build
View File

@ -4,6 +4,7 @@ sway_sources = files(
'commands.c',
'config.c',
'criteria.c',
'debug-tree.c',
'ipc-json.c',
'ipc-server.c',
'security.c',
@ -102,10 +103,13 @@ sway_sources = files(
)
sway_deps = [
cairo,
gdk_pixbuf,
jsonc,
libcap,
libinput,
math,
pango,
pcre,
pixman,
server_protos,

46
sway/tree/container.c
View File

@ -208,7 +208,7 @@ static void container_root_finish(struct sway_container *con) {
wlr_log(L_ERROR, "TODO: destroy the root container");
}
static bool container_reap_empty(struct sway_container *con) {
bool container_reap_empty(struct sway_container *con) {
switch (con->type) {
case C_ROOT:
case C_OUTPUT:
@ -225,14 +225,6 @@ static bool container_reap_empty(struct sway_container *con) {
if (con->children->length == 0) {
_container_destroy(con);
return true;
} else if (con->children->length == 1) {
struct sway_container *child = con->children->items[0];
if (child->type == C_CONTAINER) {
container_remove_child(child);
container_replace_child(con, child);
_container_destroy(con);
return true;
}
}
case C_VIEW:
break;
@ -245,6 +237,29 @@ static bool container_reap_empty(struct sway_container *con) {
return false;
}
struct sway_container *container_reap_empty_recursive(
struct sway_container *con) {
while (con) {
struct sway_container *next = con->parent;
if (!container_reap_empty(con)) {
break;
}
con = next;
}
return con;
}
struct sway_container *container_flatten(struct sway_container *container) {
while (container->type == C_CONTAINER && container->children->length == 1) {
struct sway_container *child = container->children->items[0];
struct sway_container *parent = container->parent;
container_replace_child(container, child);
container_destroy(container);
container = parent;
}
return container;
}
struct sway_container *container_destroy(struct sway_container *con) {
if (con == NULL) {
return NULL;
@ -283,18 +298,7 @@ struct sway_container *container_destroy(struct sway_container *con) {
break;
}
struct sway_container *tmp = parent;
while (parent) {
tmp = parent->parent;
if (!container_reap_empty(parent)) {
break;
}
parent = tmp;
}
return tmp;
return container_reap_empty_recursive(parent);
}
static void container_close_func(struct sway_container *container, void *data) {

342
sway/tree/layout.c
View File

@ -6,6 +6,7 @@
#include <string.h>
#include <wlr/types/wlr_output.h>
#include <wlr/types/wlr_output_layout.h>
#include "sway/debug.h"
#include "sway/tree/container.h"
#include "sway/tree/layout.h"
#include "sway/output.h"
@ -100,13 +101,31 @@ static int index_child(const struct sway_container *child) {
return i;
}
void container_insert_child(struct sway_container *parent,
struct sway_container *child, int i) {
struct sway_container *old_parent = child->parent;
if (old_parent) {
container_remove_child(child);
}
wlr_log(L_DEBUG, "Inserting id:%zd at index %d", child->id, i);
list_insert(parent->children, i, child);
child->parent = parent;
wl_signal_emit(&child->events.reparent, old_parent);
}
struct sway_container *container_add_sibling(struct sway_container *fixed,
struct sway_container *active) {
// TODO handle floating
struct sway_container *old_parent = NULL;
if (active->parent) {
old_parent = active->parent;
container_remove_child(active);
}
struct sway_container *parent = fixed->parent;
int i = index_child(fixed);
list_insert(parent->children, i + 1, active);
active->parent = parent;
wl_signal_emit(&active->events.reparent, old_parent);
return active->parent;
}
@ -166,9 +185,290 @@ void container_move_to(struct sway_container *container,
arrange_windows(new_parent, -1, -1);
}
static bool sway_dir_to_wlr(enum movement_direction dir,
enum wlr_direction *out) {
switch (dir) {
case MOVE_UP:
*out = WLR_DIRECTION_UP;
break;
case MOVE_DOWN:
*out = WLR_DIRECTION_DOWN;
break;
case MOVE_LEFT:
*out = WLR_DIRECTION_LEFT;
break;
case MOVE_RIGHT:
*out = WLR_DIRECTION_RIGHT;
break;
default:
return false;
}
return true;
}
static bool is_parallel(enum sway_container_layout layout,
enum movement_direction dir) {
switch (layout) {
case L_TABBED:
case L_STACKED:
case L_HORIZ:
return dir == MOVE_LEFT || dir == MOVE_RIGHT;
case L_VERT:
return dir == MOVE_UP || dir == MOVE_DOWN;
default:
return false;
}
}
static enum movement_direction invert_movement(enum movement_direction dir) {
switch (dir) {
case MOVE_LEFT:
return MOVE_RIGHT;
case MOVE_RIGHT:
return MOVE_LEFT;
case MOVE_UP:
return MOVE_DOWN;
case MOVE_DOWN:
return MOVE_UP;
default:
sway_assert(0, "This function expects left|right|up|down");
return MOVE_LEFT;
}
}
static int move_offs(enum movement_direction move_dir) {
return move_dir == MOVE_LEFT || move_dir == MOVE_UP ? -1 : 1;
}
/* Gets the index of the most extreme member based on the movement offset */
static int container_limit(struct sway_container *container,
enum movement_direction move_dir) {
return move_offs(move_dir) < 0 ? 0 : container->children->length;
}
/* Takes one child, sets it aside, wraps the rest of the children in a new
* container, switches the layout of the workspace, and drops the child back in.
* In other words, rejigger it. */
static void workspace_rejigger(struct sway_container *ws,
struct sway_container *child, enum movement_direction move_dir) {
struct sway_container *original_parent = child->parent;
struct sway_container *new_parent =
container_split(ws, ws->layout);
container_remove_child(child);
for (int i = 0; i < ws->children->length; ++i) {
struct sway_container *_child = ws->children->items[i];
container_move_to(new_parent, _child);
}
int index = move_offs(move_dir);
container_insert_child(ws, child, index < 0 ? 0 : 1);
container_set_layout(ws,
move_dir == MOVE_LEFT || move_dir == MOVE_RIGHT ? L_HORIZ : L_VERT);
container_flatten(ws);
container_reap_empty_recursive(original_parent);
wl_signal_emit(&child->events.reparent, original_parent);
arrange_windows(ws, -1, -1);
}
void container_move(struct sway_container *container,
enum movement_direction dir, int move_amt) {
// TODO
enum movement_direction move_dir, int move_amt) {
if (!sway_assert(
container->type != C_CONTAINER || container->type != C_VIEW,
"Can only move containers and views")) {
return;
}
int offs = move_offs(move_dir);
struct sway_container *sibling = NULL;
struct sway_container *current = container;
struct sway_container *parent = current->parent;
if (parent != container_flatten(parent)) {
// Special case: we were the last one in this container, so flatten it
// and leave
update_debug_tree();
return;
}
while (!sibling) {
if (current->type == C_ROOT) {
return;
}
parent = current->parent;
wlr_log(L_DEBUG, "Visiting %p %s '%s'", current,
container_type_to_str(current->type), current->name);
int index = index_child(current);
switch (current->type) {
case C_OUTPUT: {
enum wlr_direction wlr_dir;
sway_dir_to_wlr(move_dir, &wlr_dir);
double ref_lx = current->x + current->width / 2;
double ref_ly = current->y + current->height / 2;
struct wlr_output *next = wlr_output_layout_adjacent_output(
root_container.sway_root->output_layout, wlr_dir,
current->sway_output->wlr_output, ref_lx, ref_ly);
if (!next) {
wlr_log(L_DEBUG, "Hit edge of output, nowhere else to go");
return;
}
struct sway_output *next_output = next->data;
current = next_output->swayc;
wlr_log(L_DEBUG, "Selected next output (%s)", current->name);
// Select workspace and get outta here
current = seat_get_focus_inactive(
config->handler_context.seat, current);
if (current->type != C_WORKSPACE) {
current = container_parent(current, C_WORKSPACE);
}
sibling = current;
break;
}
case C_WORKSPACE:
if (!is_parallel(current->layout, move_dir)) {
if (current->children->length > 2) {
wlr_log(L_DEBUG, "Rejiggering the workspace (%d kiddos)",
current->children->length);
workspace_rejigger(current, container, move_dir);
} else if (current->children->length == 2) {
wlr_log(L_DEBUG, "Changing workspace layout");
container_set_layout(current,
move_dir == MOVE_LEFT || move_dir == MOVE_RIGHT ?
L_HORIZ : L_VERT);
container_insert_child(current, container, offs < 0 ? 0 : 1);
arrange_windows(current, -1, -1);
}
return;
} else {
wlr_log(L_DEBUG, "Selecting output");
current = current->parent;
}
break;
case C_CONTAINER:
case C_VIEW:
if (is_parallel(parent->layout, move_dir)) {
if ((index == parent->children->length - 1 && offs > 0)
|| (index == 0 && offs < 0)) {
if (current->parent == container->parent) {
wlr_log(L_DEBUG, "Hit limit, selecting parent");
current = current->parent;
} else {
wlr_log(L_DEBUG, "Hit limit, "
"promoting descendant to sibling");
// Special case
struct sway_container *old_parent = container->parent;
container_insert_child(current->parent, container,
index + (offs < 0 ? 0 : 1));
container->width = container->height = 0;
arrange_windows(current->parent, -1, -1);
arrange_windows(old_parent, -1, -1);
return;
}
} else {
sibling = parent->children->items[index + offs];
wlr_log(L_DEBUG, "Selecting sibling id:%zd", sibling->id);
}
} else {
wlr_log(L_DEBUG, "Moving up to find a parallel container");
current = current->parent;
}
break;
default:
sway_assert(0, "Not expecting to see container of type %s here",
container_type_to_str(current->type));
return;
}
}
// Part two: move stuff around
int index = index_child(container);
struct sway_container *old_parent = container->parent;
while (sibling) {
switch (sibling->type) {
case C_VIEW:
if (sibling->parent == container->parent) {
wlr_log(L_DEBUG, "Swapping siblings");
sibling->parent->children->items[index + offs] = container;
sibling->parent->children->items[index] = sibling;
arrange_windows(sibling->parent, -1, -1);
} else {
wlr_log(L_DEBUG, "Promoting to sibling of cousin");
container_insert_child(sibling->parent, container,
index_child(sibling) + (offs > 0 ? 0 : 1));
container->width = container->height = 0;
arrange_windows(sibling->parent, -1, -1);
arrange_windows(old_parent, -1, -1);
}
sibling = NULL;
break;
case C_WORKSPACE: // Note: only in the case of moving between outputs
case C_CONTAINER:
if (is_parallel(sibling->layout, move_dir)) {
int limit = container_limit(sibling, invert_movement(move_dir));
wlr_log(L_DEBUG, "limit: %d", limit);
wlr_log(L_DEBUG,
"Reparenting container (parallel) to index %d "
"(move dir: %d)", limit, move_dir);
container_insert_child(sibling, container, limit);
container->width = container->height = 0;
arrange_windows(sibling, -1, -1);
arrange_windows(old_parent, -1, -1);
sibling = NULL;
} else {
wlr_log(L_DEBUG, "Reparenting container (perpendicular)");
container_remove_child(container);
struct sway_container *focus_inactive = seat_get_focus_inactive(
config->handler_context.seat, sibling);
if (focus_inactive) {
while (focus_inactive->parent != sibling) {
focus_inactive = focus_inactive->parent;
}
wlr_log(L_DEBUG, "Focus inactive: id:%zd",
focus_inactive->id);
sibling = focus_inactive;
continue;
} else if (sibling->children->length) {
wlr_log(L_DEBUG, "No focus-inactive, adding arbitrarily");
container_add_sibling(sibling->children->items[0], container);
} else {
wlr_log(L_DEBUG, "No kiddos, adding container alone");
container_add_child(sibling, container);
}
container->width = container->height = 0;
arrange_windows(sibling, -1, -1);
arrange_windows(old_parent, -1, -1);
sibling = NULL;
}
break;
default:
sway_assert(0, "Not expecting to see container of type %s here",
container_type_to_str(sibling->type));
return;
}
}
if (old_parent) {
seat_set_focus(config->handler_context.seat, old_parent);
seat_set_focus(config->handler_context.seat, container);
}
struct sway_container *last_ws = old_parent;
struct sway_container *next_ws = container->parent;
if (last_ws && last_ws->type != C_WORKSPACE) {
last_ws = container_parent(last_ws, C_WORKSPACE);
}
if (next_ws && next_ws->type != C_WORKSPACE) {
next_ws = container_parent(next_ws, C_WORKSPACE);
}
if (last_ws && next_ws && last_ws != next_ws) {
ipc_event_workspace(last_ws, container, "focus");
}
}
enum sway_container_layout container_get_default_layout(
@ -320,6 +620,9 @@ void arrange_windows(struct sway_container *container,
container->children->length);
break;
}
container_damage_whole(container);
// TODO: Make this less shitty
update_debug_tree();
}
static void apply_horiz_layout(struct sway_container *container,
@ -512,28 +815,6 @@ static void get_layout_center_position(struct sway_container *container,
}
}
static bool sway_dir_to_wlr(enum movement_direction dir,
enum wlr_direction *out) {
switch (dir) {
case MOVE_UP:
*out = WLR_DIRECTION_UP;
break;
case MOVE_DOWN:
*out = WLR_DIRECTION_DOWN;
break;
case MOVE_LEFT:
*out = WLR_DIRECTION_LEFT;
break;
case MOVE_RIGHT:
*out = WLR_DIRECTION_RIGHT;
break;
default:
return false;
}
return true;
}
static struct sway_container *sway_output_from_wlr(struct wlr_output *output) {
if (output == NULL) {
return NULL;
@ -673,6 +954,9 @@ struct sway_container *container_replace_child(struct sway_container *child,
int i = index_child(child);
// TODO floating
if (new_child->parent) {
container_remove_child(new_child);
}
parent->children->items[i] = new_child;
new_child->parent = parent;
child->parent = NULL;
@ -696,6 +980,14 @@ struct sway_container *container_split(struct sway_container *child,
if (!sway_assert(child, "child cannot be null")) {
return NULL;
}
if (child->type == C_WORKSPACE && child->children->length == 0) {
// Special case: this just behaves like splitt
child->prev_layout = child->layout;
child->layout = layout;
arrange_windows(child, -1, -1);
return child;
}
struct sway_container *cont = container_create(C_CONTAINER);
wlr_log(L_DEBUG, "creating container %p around %p", cont, child);
@ -718,7 +1010,9 @@ struct sway_container *container_split(struct sway_container *child,
}
container_add_child(workspace, cont);
enum sway_container_layout old_layout = workspace->layout;
container_set_layout(workspace, layout);
cont->layout = old_layout;
if (set_focus) {
seat_set_focus(seat, cont);

2
swaybar/ipc.c
View File

@ -331,7 +331,7 @@ bool handle_ipc_readable(struct swaybar *bar) {
switch (resp->type) {
case IPC_EVENT_WORKSPACE:
ipc_get_workspaces(bar);
break;
return true;
case IPC_EVENT_MODE: {
json_object *result = json_tokener_parse(resp->payload);
if (!result) {