swayfx/sway/tree/container.c

531 lines
14 KiB
C
Raw Normal View History

2017-11-20 09:04:28 +11:00
#define _POSIX_C_SOURCE 200809L
2018-04-03 12:37:21 +10:00
#include <assert.h>
2017-11-20 09:04:28 +11:00
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
2017-12-06 22:36:06 +11:00
#include <strings.h>
2018-01-31 15:09:21 +11:00
#include <wayland-server.h>
2017-12-06 03:02:31 +11:00
#include <wlr/types/wlr_output_layout.h>
2017-12-11 00:48:44 +11:00
#include <wlr/types/wlr_wl_shell.h>
2017-12-06 22:36:06 +11:00
#include "sway/config.h"
2018-01-31 15:09:21 +11:00
#include "sway/input/input-manager.h"
#include "sway/input/seat.h"
2018-03-31 02:58:17 +11:00
#include "sway/ipc-server.h"
2017-11-20 09:04:28 +11:00
#include "sway/output.h"
2017-12-10 01:48:52 +11:00
#include "sway/server.h"
2018-03-31 02:58:17 +11:00
#include "sway/tree/layout.h"
#include "sway/tree/view.h"
#include "sway/tree/workspace.h"
2017-11-23 12:39:27 +11:00
#include "log.h"
2017-11-20 09:04:28 +11:00
2018-02-25 06:30:47 +11:00
static list_t *bfs_queue;
static list_t *get_bfs_queue() {
if (!bfs_queue) {
bfs_queue = create_list();
if (!bfs_queue) {
wlr_log(L_ERROR, "could not allocate list for bfs queue");
return NULL;
}
}
bfs_queue->length = 0;
return bfs_queue;
}
const char *container_type_to_str(enum sway_container_type type) {
switch (type) {
case C_ROOT:
return "C_ROOT";
case C_OUTPUT:
return "C_OUTPUT";
case C_WORKSPACE:
return "C_WORKSPACE";
case C_CONTAINER:
return "C_CONTAINER";
case C_VIEW:
return "C_VIEW";
default:
return "C_UNKNOWN";
}
}
2018-04-04 09:52:17 +10:00
void container_create_notify(struct sway_container *container) {
2018-04-05 04:19:38 +10:00
// TODO send ipc event type based on the container type
2018-02-28 11:53:15 +11:00
wl_signal_emit(&root_container.sway_root->events.new_container, container);
ipc_event_window(container, "new");
}
2018-04-05 04:19:38 +10:00
static void container_close_notify(struct sway_container *container) {
// TODO send ipc event type based on the container type
ipc_event_window(container, "close");
}
2018-03-31 15:44:17 +11:00
struct sway_container *container_create(enum sway_container_type type) {
2017-11-20 09:04:28 +11:00
// next id starts at 1 because 0 is assigned to root_container in layout.c
static size_t next_id = 1;
struct sway_container *c = calloc(1, sizeof(struct sway_container));
2017-11-20 09:04:28 +11:00
if (!c) {
return NULL;
}
c->id = next_id++;
c->layout = L_NONE;
c->workspace_layout = L_NONE;
c->type = type;
if (type != C_VIEW) {
c->children = create_list();
}
2017-12-11 03:11:47 +11:00
wl_signal_init(&c->events.destroy);
wl_signal_init(&c->events.reparent);
2017-12-11 03:11:47 +11:00
2017-11-20 09:04:28 +11:00
return c;
}
static void _container_destroy(struct sway_container *cont) {
if (cont == NULL) {
return;
}
wl_signal_emit(&cont->events.destroy, cont);
2018-04-05 04:19:38 +10:00
container_close_notify(cont);
2018-03-31 02:58:17 +11:00
struct sway_container *parent = cont->parent;
if (cont->children != NULL && cont->children->length) {
// remove children until there are no more, container_destroy calls
// container_remove_child, which removes child from this container
while (cont->children != NULL) {
2018-04-01 08:52:02 +10:00
struct sway_container *child = cont->children->items[0];
container_remove_child(child);
_container_destroy(child);
}
}
if (cont->marks) {
list_foreach(cont->marks, free);
list_free(cont->marks);
}
2018-03-31 02:58:17 +11:00
if (parent) {
parent = container_remove_child(cont);
}
if (cont->name) {
free(cont->name);
}
2018-04-01 08:52:02 +10:00
list_free(cont->children);
cont->children = NULL;
free(cont);
}
2018-04-04 02:34:01 +10:00
2018-04-04 03:08:45 +10:00
static struct sway_container *container_output_destroy(
struct sway_container *output) {
2018-04-04 02:34:01 +10:00
if (!sway_assert(output, "cannot destroy null output")) {
return NULL;
}
if (output->children->length > 0) {
// TODO save workspaces when there are no outputs.
// TODO also check if there will ever be no outputs except for exiting
// program
if (root_container.children->length > 1) {
int p = root_container.children->items[0] == output;
// Move workspace from this output to another output
while (output->children->length) {
struct sway_container *child = output->children->items[0];
container_remove_child(child);
container_add_child(root_container.children->items[p], child);
}
container_sort_workspaces(root_container.children->items[p]);
arrange_windows(root_container.children->items[p],
-1, -1);
}
}
wl_list_remove(&output->sway_output->destroy.link);
wl_list_remove(&output->sway_output->mode.link);
wl_list_remove(&output->sway_output->transform.link);
wl_list_remove(&output->sway_output->scale.link);
wl_list_remove(&output->sway_output->damage_destroy.link);
wl_list_remove(&output->sway_output->damage_frame.link);
wlr_log(L_DEBUG, "OUTPUT: Destroying output '%s'", output->name);
_container_destroy(output);
2018-04-04 02:34:01 +10:00
return &root_container;
}
static struct sway_container *container_workspace_destroy(
struct sway_container *workspace) {
if (!sway_assert(workspace, "cannot destroy null workspace")) {
return NULL;
}
// Do not destroy this if it's the last workspace on this output
struct sway_container *output = container_parent(workspace, C_OUTPUT);
if (output && output->children->length == 1) {
return NULL;
}
struct sway_container *parent = workspace->parent;
if (workspace->children->length == 0) {
// destroy the WS if there are no children (TODO check for floating)
wlr_log(L_DEBUG, "destroying workspace '%s'", workspace->name);
ipc_event_workspace(workspace, NULL, "empty");
} else {
// Move children to a different workspace on this output
struct sway_container *new_workspace = NULL;
// TODO move floating
for (int i = 0; i < output->children->length; i++) {
if (output->children->items[i] != workspace) {
new_workspace = output->children->items[i];
break;
}
}
wlr_log(L_DEBUG, "moving children to different workspace '%s' -> '%s'",
workspace->name, new_workspace->name);
for (int i = 0; i < workspace->children->length; i++) {
container_move_to(workspace->children->items[i], new_workspace);
}
}
_container_destroy(workspace);
output_damage_whole(output->sway_output);
return parent;
}
2018-04-04 09:23:59 +10:00
static void container_root_finish(struct sway_container *con) {
wlr_log(L_ERROR, "TODO: destroy the root container");
}
2018-04-04 09:23:59 +10:00
static bool container_reap_empty(struct sway_container *con) {
2018-04-03 12:37:21 +10:00
switch (con->type) {
2018-04-04 09:23:59 +10:00
case C_ROOT:
case C_OUTPUT:
// dont reap these
break;
case C_WORKSPACE:
if (!workspace_is_visible(con) && con->children->length == 0) {
container_workspace_destroy(con);
return true;
}
break;
case C_CONTAINER:
if (con->children->length == 0) {
_container_destroy(con);
2018-04-04 09:23:59 +10:00
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);
2018-04-04 09:23:59 +10:00
return true;
2018-04-03 12:37:21 +10:00
}
2018-04-04 09:23:59 +10:00
}
case C_VIEW:
break;
case C_TYPES:
sway_assert(false, "container_reap_empty called on an invalid "
"container");
break;
2018-04-03 12:37:21 +10:00
}
2018-04-04 09:23:59 +10:00
return false;
}
struct sway_container *container_destroy(struct sway_container *con) {
if (con == NULL) {
return NULL;
2018-04-03 12:37:21 +10:00
}
2018-04-04 09:23:59 +10:00
struct sway_container *parent = con->parent;
switch (con->type) {
case C_ROOT:
container_root_finish(con);
break;
case C_OUTPUT:
2018-04-04 09:23:59 +10:00
// dont try to reap the root after this
container_output_destroy(con);
break;
case C_WORKSPACE:
2018-04-04 09:23:59 +10:00
// dont try to reap the output after this
container_workspace_destroy(con);
break;
case C_CONTAINER:
2018-04-04 09:23:59 +10:00
if (con->children->length) {
for (int i = 0; i < con->children->length; ++i) {
struct sway_container *child = con->children->items[0];
container_remove_child(child);
container_add_child(parent, child);
}
}
_container_destroy(con);
break;
case C_VIEW:
_container_destroy(con);
break;
case C_TYPES:
2018-04-04 09:23:59 +10:00
wlr_log(L_ERROR, "container_destroy called on an invalid "
"container");
break;
2018-04-03 12:37:21 +10:00
}
2018-04-04 09:23:59 +10:00
struct sway_container *tmp = parent;
while (parent) {
tmp = parent->parent;
if (!container_reap_empty(parent)) {
break;
}
parent = tmp;
}
2018-04-04 09:23:59 +10:00
return tmp;
2018-04-03 12:37:21 +10:00
}
2018-04-03 11:01:33 +10:00
static void container_close_func(struct sway_container *container, void *data) {
if (container->type == C_VIEW) {
view_close(container->sway_view);
}
}
struct sway_container *container_close(struct sway_container *con) {
2018-04-04 03:08:45 +10:00
if (!sway_assert(con != NULL,
2018-04-04 09:23:59 +10:00
"container_close called with a NULL container")) {
2018-04-03 11:01:33 +10:00
return NULL;
}
2018-04-03 12:37:21 +10:00
struct sway_container *parent = con->parent;
2018-04-04 13:59:44 +10:00
if (con->type == C_VIEW) {
2018-04-04 09:23:59 +10:00
view_close(con->sway_view);
2018-04-04 13:59:44 +10:00
} else {
container_for_each_descendant_dfs(con, container_close_func, NULL);
2018-04-03 11:01:33 +10:00
}
2018-04-03 12:37:21 +10:00
return parent;
2018-04-03 11:01:33 +10:00
}
struct sway_container *container_view_create(struct sway_container *sibling,
struct sway_view *sway_view) {
if (!sway_assert(sibling,
"container_view_create called with NULL sibling/parent")) {
2017-11-23 13:06:08 +11:00
return NULL;
}
2018-01-22 01:09:53 +11:00
const char *title = view_get_title(sway_view);
struct sway_container *swayc = container_create(C_VIEW);
2018-01-31 15:09:21 +11:00
wlr_log(L_DEBUG, "Adding new view %p:%s to container %p %d %s",
swayc, title, sibling, sibling ? sibling->type : 0, sibling->name);
2017-11-23 13:06:08 +11:00
// Setup values
swayc->sway_view = sway_view;
swayc->name = title ? strdup(title) : NULL;
swayc->width = 0;
swayc->height = 0;
if (sibling->type == C_WORKSPACE) {
// Case of focused workspace, just create as child of it
container_add_child(sibling, swayc);
2017-11-23 13:06:08 +11:00
} else {
// Regular case, create as sibling of current container
container_add_sibling(sibling, swayc);
2017-11-23 13:06:08 +11:00
}
2018-04-04 09:52:17 +10:00
container_create_notify(swayc);
2017-11-23 13:06:08 +11:00
return swayc;
}
2017-11-26 02:59:49 +11:00
void container_descendants(struct sway_container *root,
enum sway_container_type type,
void (*func)(struct sway_container *item, void *data), void *data) {
for (int i = 0; i < root->children->length; ++i) {
struct sway_container *item = root->children->items[i];
if (item->type == type) {
func(item, data);
}
if (item->children && item->children->length) {
container_descendants(item, type, func, data);
}
}
}
struct sway_container *container_find(struct sway_container *container,
bool (*test)(struct sway_container *view, void *data), void *data) {
if (!container->children) {
return NULL;
}
// TODO: floating windows
for (int i = 0; i < container->children->length; ++i) {
struct sway_container *child = container->children->items[i];
if (test(child, data)) {
return child;
} else {
struct sway_container *res = container_find(child, test, data);
if (res) {
return res;
}
}
}
return NULL;
}
struct sway_container *container_parent(struct sway_container *container,
enum sway_container_type type) {
2017-11-26 02:59:49 +11:00
if (!sway_assert(container, "container is NULL")) {
return NULL;
}
if (!sway_assert(type < C_TYPES && type >= C_ROOT, "invalid type")) {
return NULL;
}
do {
container = container->parent;
} while (container && container->type != type);
return container;
}
2017-12-11 00:48:44 +11:00
struct sway_container *container_at(struct sway_container *parent,
double lx, double ly,
2017-12-11 00:48:44 +11:00
struct wlr_surface **surface, double *sx, double *sy) {
2018-02-25 06:30:47 +11:00
list_t *queue = get_bfs_queue();
if (!queue) {
return NULL;
}
2017-12-11 00:48:44 +11:00
list_add(queue, parent);
struct sway_container *swayc = NULL;
2017-12-11 00:48:44 +11:00
while (queue->length) {
swayc = queue->items[0];
list_del(queue, 0);
if (swayc->type == C_VIEW) {
struct sway_view *sview = swayc->sway_view;
struct sway_container *soutput = container_parent(swayc, C_OUTPUT);
2017-12-11 00:48:44 +11:00
struct wlr_box *output_box =
wlr_output_layout_get_box(
root_container.sway_root->output_layout,
2017-12-11 00:48:44 +11:00
soutput->sway_output->wlr_output);
double ox = lx - output_box->x;
double oy = ly - output_box->y;
double view_sx = ox - swayc->x;
double view_sy = oy - swayc->y;
switch (sview->type) {
case SWAY_WL_SHELL_VIEW:
break;
case SWAY_XDG_SHELL_V6_VIEW:
// the top left corner of the sway container is the
// coordinate of the top left corner of the window geometry
view_sx += sview->wlr_xdg_surface_v6->geometry.x;
view_sy += sview->wlr_xdg_surface_v6->geometry.y;
2018-01-15 02:47:19 +11:00
// check for popups
double popup_sx, popup_sy;
struct wlr_xdg_surface_v6 *popup =
wlr_xdg_surface_v6_popup_at(sview->wlr_xdg_surface_v6,
view_sx, view_sy, &popup_sx, &popup_sy);
if (popup) {
*sx = view_sx - popup_sx;
*sy = view_sy - popup_sy;
*surface = popup->surface;
return swayc;
}
2017-12-11 00:48:44 +11:00
break;
case SWAY_XWAYLAND_VIEW:
break;
default:
break;
}
2018-01-15 02:50:20 +11:00
// check for subsurfaces
double sub_x, sub_y;
struct wlr_subsurface *subsurface =
wlr_surface_subsurface_at(sview->surface,
view_sx, view_sy, &sub_x, &sub_y);
if (subsurface) {
*sx = view_sx - sub_x;
*sy = view_sy - sub_y;
*surface = subsurface->surface;
return swayc;
}
2018-03-31 14:08:24 +11:00
if (wlr_surface_point_accepts_input(
sview->surface, view_sx, view_sy)) {
2017-12-11 00:48:44 +11:00
*sx = view_sx;
*sy = view_sy;
*surface = swayc->sway_view->surface;
return swayc;
}
} else {
list_cat(queue, swayc->children);
}
}
return NULL;
}
2018-01-21 08:21:45 +11:00
void container_for_each_descendant_dfs(struct sway_container *container,
void (*f)(struct sway_container *container, void *data),
void *data) {
2018-01-21 08:21:45 +11:00
if (container) {
if (container->children) {
for (int i = 0; i < container->children->length; ++i) {
struct sway_container *child =
container->children->items[i];
container_for_each_descendant_dfs(child, f, data);
2018-01-21 08:21:45 +11:00
}
}
f(container, data);
}
}
2018-02-05 05:39:10 +11:00
void container_for_each_descendant_bfs(struct sway_container *con,
void (*f)(struct sway_container *con, void *data), void *data) {
2018-02-25 06:30:47 +11:00
list_t *queue = get_bfs_queue();
if (!queue) {
return;
}
if (queue == NULL) {
wlr_log(L_ERROR, "could not allocate list");
return;
}
2018-02-05 05:39:10 +11:00
list_add(queue, con);
struct sway_container *current = NULL;
2018-02-05 05:39:10 +11:00
while (queue->length) {
current = queue->items[0];
list_del(queue, 0);
f(current, data);
2018-02-05 05:39:10 +11:00
// TODO floating containers
list_cat(queue, current->children);
}
}
bool container_has_anscestor(struct sway_container *descendant,
struct sway_container *anscestor) {
while (descendant->type != C_ROOT) {
descendant = descendant->parent;
if (descendant == anscestor) {
return true;
}
}
return false;
}
2018-04-01 05:22:10 +10:00
2018-04-03 04:15:40 +10:00
static bool find_child_func(struct sway_container *con, void *data) {
2018-04-01 05:22:10 +10:00
struct sway_container *child = data;
return con == child;
}
bool container_has_child(struct sway_container *con,
struct sway_container *child) {
2018-04-01 08:52:02 +10:00
if (child == NULL || child->type == C_VIEW ||
child->children->length == 0) {
2018-04-01 05:22:10 +10:00
return false;
}
return container_find(con, find_child_func, child);
}