Implement workspaces

This commit is contained in:
Drew DeVault 2018-01-30 23:09:21 -05:00
parent 8231f99c12
commit b28602aa74
14 changed files with 420 additions and 30 deletions

View file

@ -11,6 +11,7 @@ typedef struct sway_container swayc_t;
extern swayc_t root_container;
struct sway_view;
struct sway_seat;
/**
* Different kinds of containers.
@ -140,11 +141,25 @@ swayc_t *new_view(swayc_t *sibling, struct sway_view *sway_view);
swayc_t *destroy_output(swayc_t *output);
swayc_t *destroy_view(swayc_t *view);
swayc_t *next_view_sibling(struct sway_seat *seat);
/**
* Finds a container based on test criteria. Returns the first container that
* passes the test.
*/
swayc_t *swayc_by_test(swayc_t *container,
bool (*test)(swayc_t *view, void *data), void *data);
/**
* Finds a parent container with the given swayc_type.
*/
swayc_t *swayc_parent_by_type(swayc_t *container, enum swayc_types type);
/**
* Maps a container's children over a function.
*/
void container_map(swayc_t *container,
void (*f)(swayc_t *view, void *data), void *data);
swayc_t *swayc_at(swayc_t *parent, double lx, double ly,
struct wlr_surface **surface, double *sx, double *sy);
void container_map(swayc_t *container, void (*f)(swayc_t *view, void *data), void *data);
#endif

View file

@ -48,4 +48,8 @@ struct sway_seat *sway_input_manager_get_default_seat(
struct sway_seat *input_manager_get_seat(struct sway_input_manager *input,
const char *seat_name);
/** Gets the last seat the user interacted with */
struct sway_seat *input_manager_current_seat(struct sway_input_manager *input);
#endif

View file

@ -1,6 +1,20 @@
#ifndef _SWAY_WORKSPACE_H
#define _SWAY_WORKSPACE_H
struct sway_container;
extern char *prev_workspace_name;
char *workspace_next_name(const char *output_name);
swayc_t *workspace_create(const char *name);
bool workspace_switch(swayc_t *workspace);
struct sway_container *workspace_by_number(const char* name);
swayc_t *workspace_by_name(const char*);
struct sway_container *workspace_output_next(struct sway_container *current);
struct sway_container *workspace_next(struct sway_container *current);
struct sway_container *workspace_output_prev(struct sway_container *current);
struct sway_container *workspace_prev(struct sway_container *current);
#endif

View file

@ -139,6 +139,7 @@ static struct cmd_handler handlers[] = {
{ "reload", cmd_reload },
{ "seat", cmd_seat },
{ "set", cmd_set },
{ "workspace", cmd_workspace },
};
static int handler_compare(const void *_a, const void *_b) {

View file

@ -10,11 +10,10 @@ struct cmd_results *cmd_kill(int argc, char **argv) {
return cmd_results_new(CMD_FAILURE, "kill",
"Command 'kill' cannot be used in the config file");
}
if (!sway_assert(config->handler_context.current_container,
"cmd_kill called without container context")) {
enum swayc_types type = config->handler_context.current_container->type;
if (type != C_VIEW || type != C_CONTAINER) {
return cmd_results_new(CMD_INVALID, NULL,
"cmd_kill called without container context "
"(this is a bug in sway)");
"Can only kill views and containers with this command");
}
// TODO close arbitrary containers without a view
struct sway_view *view =

101
sway/commands/workspace.c Normal file
View file

@ -0,0 +1,101 @@
#define _XOPEN_SOURCE 500
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
#include "sway/config.h"
#include "sway/input/seat.h"
#include "sway/workspace.h"
#include "list.h"
#include "log.h"
#include "stringop.h"
struct cmd_results *cmd_workspace(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "workspace", EXPECTED_AT_LEAST, 1))) {
return error;
}
int output_location = -1;
swayc_t *current_container = config->handler_context.current_container;
swayc_t *old_workspace = NULL, *old_output = NULL;
if (current_container) {
if (current_container->type == C_WORKSPACE) {
old_workspace = current_container;
} else {
old_workspace = swayc_parent_by_type(current_container, C_WORKSPACE);
}
old_output = swayc_parent_by_type(current_container, C_OUTPUT);
}
for (int i = 0; i < argc; ++i) {
if (strcasecmp(argv[i], "output") == 0) {
output_location = i;
break;
}
}
if (output_location >= 0) {
if ((error = checkarg(argc, "workspace", EXPECTED_EQUAL_TO, output_location + 2))) {
return error;
}
struct workspace_output *wso = calloc(1, sizeof(struct workspace_output));
if (!wso) {
return cmd_results_new(CMD_FAILURE, "workspace output",
"Unable to allocate workspace output");
}
wso->workspace = join_args(argv, argc - 2);
wso->output = strdup(argv[output_location + 1]);
int i = -1;
if ((i = list_seq_find(config->workspace_outputs, workspace_output_cmp_workspace, wso)) != -1) {
struct workspace_output *old = config->workspace_outputs->items[i];
free(old); // workspaces can only be assigned to a single output
list_del(config->workspace_outputs, i);
}
wlr_log(L_DEBUG, "Assigning workspace %s to output %s", wso->workspace, wso->output);
list_add(config->workspace_outputs, wso);
} else {
if (config->reading || !config->active) {
return cmd_results_new(CMD_DEFER, "workspace", NULL);
}
swayc_t *ws = NULL;
if (strcasecmp(argv[0], "number") == 0) {
if (!(ws = workspace_by_number(argv[1]))) {
char *name = join_args(argv + 1, argc - 1);
ws = workspace_create(name);
free(name);
}
} else if (strcasecmp(argv[0], "next") == 0) {
ws = workspace_next(old_workspace);
} else if (strcasecmp(argv[0], "prev") == 0) {
ws = workspace_prev(old_workspace);
} else if (strcasecmp(argv[0], "next_on_output") == 0) {
ws = workspace_output_next(old_output);
} else if (strcasecmp(argv[0], "prev_on_output") == 0) {
ws = workspace_output_prev(old_output);
} else if (strcasecmp(argv[0], "back_and_forth") == 0) {
// if auto_back_and_forth is enabled, workspace_switch will swap
// the workspaces. If we created prev_workspace here, workspace_switch
// would put us back on original workspace.
if (config->auto_back_and_forth) {
ws = old_workspace;
} else if (prev_workspace_name
&& !(ws = workspace_by_name(prev_workspace_name))) {
ws = workspace_create(prev_workspace_name);
}
} else {
char *name = join_args(argv, argc);
if (!(ws = workspace_by_name(name))) {
ws = workspace_create(name);
}
free(name);
}
workspace_switch(ws);
current_container = config->handler_context.seat->focus;
swayc_t *new_output = swayc_parent_by_type(current_container, C_OUTPUT);
if (config->mouse_warping && old_output != new_output) {
// TODO: Warp mouse
}
}
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

View file

@ -318,10 +318,6 @@ static bool load_config(const char *path, struct sway_config *config) {
return true;
}
static int qstrcmp(const void* a, const void* b) {
return strcmp(*((char**) a), *((char**) b));
}
bool load_main_config(const char *file, bool is_active) {
char *path;
if (file != NULL) {
@ -349,7 +345,9 @@ bool load_main_config(const char *file, bool is_active) {
config->reading = true;
// Read security configs
// TODO: Security
bool success = true;
/*
DIR *dir = opendir(SYSCONFDIR "/sway/security.d");
if (!dir) {
wlr_log(L_ERROR,
@ -392,6 +390,7 @@ bool load_main_config(const char *file, bool is_active) {
free_flat_list(secconfigs);
}
*/
success = success && load_config(path, config);
@ -717,3 +716,11 @@ char *do_var_replacement(char *str) {
}
return str;
}
// the naming is intentional (albeit long): a workspace_output_cmp function
// would compare two structs in full, while this method only compares the
// workspace.
int workspace_output_cmp_workspace(const void *a, const void *b) {
const struct workspace_output *wsa = a, *wsb = b;
return lenient_strcmp(wsa->workspace, wsb->workspace);
}

View file

@ -219,8 +219,8 @@ static void output_frame_notify(struct wl_listener *listener, void *data) {
wlr_output_make_current(wlr_output);
wlr_renderer_begin(server->renderer, wlr_output);
swayc_descendants_of_type(
&root_container, C_VIEW, output_frame_view, soutput);
swayc_t *workspace = soutput->swayc->focused;
swayc_descendants_of_type(workspace, C_VIEW, output_frame_view, soutput);
// render unmanaged views on top
struct sway_view *view;

View file

@ -124,8 +124,6 @@ void handle_xdg_shell_v6_surface(struct wl_listener *listener, void *data) {
sway_surface->view = sway_view;
// TODO:
// - Wire up listeners
// - Handle popups
// - Look up pid and open on appropriate workspace
// - Set new view to maximized so it behaves nicely
// - Criteria
@ -136,11 +134,8 @@ void handle_xdg_shell_v6_surface(struct wl_listener *listener, void *data) {
sway_surface->destroy.notify = handle_destroy;
wl_signal_add(&xdg_surface->events.destroy, &sway_surface->destroy);
// TODO: actual focus semantics
swayc_t *parent = root_container.children->items[0];
parent = parent->children->items[0]; // workspace
swayc_t *cont = new_view(parent, sway_view);
struct sway_seat *seat = input_manager_current_seat(input_manager);
swayc_t *cont = new_view(seat->focus, sway_view);
sway_view->swayc = cont;
arrange_windows(cont->parent, -1, -1);

View file

@ -23,6 +23,14 @@ struct sway_input_manager *input_manager;
struct input_config *current_input_config = NULL;
struct seat_config *current_seat_config = NULL;
struct sway_seat *input_manager_current_seat(struct sway_input_manager *input) {
struct sway_seat *seat = config->handler_context.seat;
if (!seat) {
seat = sway_input_manager_get_default_seat(input_manager);
}
return seat;
}
struct sway_seat *input_manager_get_seat(
struct sway_input_manager *input, const char *seat_name) {
struct sway_seat *seat = NULL;

View file

@ -1,6 +1,7 @@
#define _XOPEN_SOURCE 700
#include <wlr/types/wlr_cursor.h>
#include <wlr/types/wlr_xcursor_manager.h>
#include "sway/container.h"
#include "sway/input/seat.h"
#include "sway/input/cursor.h"
#include "sway/input/input-manager.h"
@ -81,7 +82,7 @@ static void seat_configure_keyboard(struct sway_seat *seat,
sway_keyboard_configure(seat_device->keyboard);
wlr_seat_set_keyboard(seat->wlr_seat,
seat_device->input_device->wlr_device);
if (seat->focus) {
if (seat->focus && seat->focus->type == C_VIEW) {
// force notify reenter to pick up the new configuration
wlr_seat_keyboard_clear_focus(seat->wlr_seat);
wlr_seat_keyboard_notify_enter(seat->wlr_seat,
@ -205,10 +206,8 @@ void sway_seat_configure_xcursor(struct sway_seat *seat) {
static void handle_focus_destroy(struct wl_listener *listener, void *data) {
struct sway_seat *seat = wl_container_of(listener, seat, focus_destroy);
//swayc_t *container = data;
// TODO set new focus based on the state of the tree
sway_seat_set_focus(seat, NULL);
swayc_t *container = data;
sway_seat_set_focus(seat, container->parent);
}
void sway_seat_set_focus(struct sway_seat *seat, swayc_t *container) {
@ -218,11 +217,11 @@ void sway_seat_set_focus(struct sway_seat *seat, swayc_t *container) {
return;
}
if (last_focus) {
if (last_focus && last_focus->type == C_VIEW) {
wl_list_remove(&seat->focus_destroy.link);
}
if (container) {
if (container && container->type == C_VIEW) {
struct sway_view *view = container->sway_view;
view_set_activated(view, true);
wl_signal_add(&container->events.destroy, &seat->focus_destroy);
@ -241,7 +240,7 @@ void sway_seat_set_focus(struct sway_seat *seat, swayc_t *container) {
seat->focus = container;
if (last_focus &&
if (last_focus && last_focus->type == C_VIEW &&
!sway_input_manager_has_focus(seat->input, last_focus)) {
struct sway_view *view = last_focus->sway_view;
view_set_activated(view, false);

View file

@ -35,6 +35,7 @@ sway_sources = files(
'commands/input/xkb_variant.c',
'commands/output.c',
'commands/reload.c',
'commands/workspace.c',
'config.c',
'config/output.c',
'config/seat.c',

View file

@ -3,10 +3,13 @@
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <wayland-server.h>
#include <wlr/types/wlr_output_layout.h>
#include <wlr/types/wlr_wl_shell.h>
#include "sway/config.h"
#include "sway/container.h"
#include "sway/input/input-manager.h"
#include "sway/input/seat.h"
#include "sway/layout.h"
#include "sway/output.h"
#include "sway/server.h"
@ -14,6 +17,26 @@
#include "sway/workspace.h"
#include "log.h"
swayc_t *swayc_by_test(swayc_t *container,
bool (*test)(swayc_t *view, void *data), void *data) {
if (!container->children) {
return NULL;
}
// TODO: floating windows
for (int i = 0; i < container->children->length; ++i) {
swayc_t *child = container->children->items[i];
if (test(child, data)) {
return child;
} else {
swayc_t *res = swayc_by_test(child, test, data);
if (res) {
return res;
}
}
}
return NULL;
}
void swayc_descendants_of_type(swayc_t *root, enum swayc_types type,
void (*func)(swayc_t *item, void *data), void *data) {
for (int i = 0; i < root->children->length; ++i) {
@ -127,7 +150,19 @@ swayc_t *new_output(struct sway_output *sway_output) {
// Create workspace
char *ws_name = workspace_next_name(output->name);
wlr_log(L_DEBUG, "Creating default workspace %s", ws_name);
new_workspace(output, ws_name);
swayc_t *ws = new_workspace(output, ws_name);
output->focused = ws;
// Set each seat's focus if not already set
// TODO FOCUS: this is probably stupid, we shouldn't define focus in two
// places. We should probably put the active workspace on the sway_output
// struct instead of trying to do focus semantics like this
struct sway_seat *seat = NULL;
wl_list_for_each(seat, &input_manager->seats, link) {
if (!seat->focus) {
seat->focus = ws;
}
}
free(ws_name);
return output;
}
@ -159,8 +194,8 @@ swayc_t *new_view(swayc_t *sibling, struct sway_view *sway_view) {
}
const char *title = view_get_title(sway_view);
swayc_t *swayc = new_swayc(C_VIEW);
wlr_log(L_DEBUG, "Adding new view %p:%s to container %p %d",
swayc, title, sibling, sibling ? sibling->type : 0);
wlr_log(L_DEBUG, "Adding new view %p:%s to container %p %d %s",
swayc, title, sibling, sibling ? sibling->type : 0, sibling->name);
// Setup values
swayc->sway_view = sway_view;
swayc->name = title ? strdup(title) : NULL;

View file

@ -2,8 +2,20 @@
#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
#include <strings.h>
#include "sway/container.h"
#include "sway/input/input-manager.h"
#include "sway/input/seat.h"
#include "sway/workspace.h"
#include "log.h"
#include "util.h"
char *prev_workspace_name = NULL;
struct workspace_by_number_data {
int len;
const char *cset;
const char *name;
};
void next_name_map(swayc_t *ws, void *data) {
int *count = data;
@ -24,3 +36,202 @@ char *workspace_next_name(const char *output_name) {
snprintf(name, len + 1, "%d", count);
return name;
}
static bool _workspace_by_number(swayc_t *view, void *data) {
if (view->type != C_WORKSPACE) {
return false;
}
struct workspace_by_number_data *wbnd = data;
int a = strspn(view->name, wbnd->cset);
return a == wbnd->len && strncmp(view->name, wbnd->name, a) == 0;
}
swayc_t *workspace_by_number(const char* name) {
struct workspace_by_number_data wbnd = {0, "1234567890", name};
wbnd.len = strspn(name, wbnd.cset);
if (wbnd.len <= 0) {
return NULL;
}
return swayc_by_test(&root_container, _workspace_by_number, (void *) &wbnd);
}
static bool _workspace_by_name(swayc_t *view, void *data) {
return (view->type == C_WORKSPACE) &&
(strcasecmp(view->name, (char *) data) == 0);
}
swayc_t *workspace_by_name(const char *name) {
struct sway_seat *seat = input_manager_current_seat(input_manager);
swayc_t *current_workspace = NULL, *current_output = NULL;
if (seat->focus) {
current_workspace = swayc_parent_by_type(seat->focus, C_WORKSPACE);
current_output = swayc_parent_by_type(seat->focus, C_OUTPUT);
}
if (strcmp(name, "prev") == 0) {
return workspace_prev(current_workspace);
} else if (strcmp(name, "prev_on_output") == 0) {
return workspace_output_prev(current_output);
} else if (strcmp(name, "next") == 0) {
return workspace_next(current_workspace);
} else if (strcmp(name, "next_on_output") == 0) {
return workspace_output_next(current_output);
} else if (strcmp(name, "current") == 0) {
return current_workspace;
} else {
return swayc_by_test(&root_container, _workspace_by_name, (void *) name);
}
}
swayc_t *workspace_create(const char *name) {
swayc_t *parent;
// Search for workspace<->output pair
int i, e = config->workspace_outputs->length;
for (i = 0; i < e; ++i) {
struct workspace_output *wso = config->workspace_outputs->items[i];
if (strcasecmp(wso->workspace, name) == 0) {
// Find output to use if it exists
e = root_container.children->length;
for (i = 0; i < e; ++i) {
parent = root_container.children->items[i];
if (strcmp(parent->name, wso->output) == 0) {
return new_workspace(parent, name);
}
}
break;
}
}
// Otherwise create a new one
struct sway_seat *seat = input_manager_current_seat(input_manager);
parent = seat->focus;
parent = swayc_parent_by_type(parent, C_OUTPUT);
return new_workspace(parent, name);
}
/**
* Get the previous or next workspace on the specified output. Wraps around at
* the end and beginning. If next is false, the previous workspace is returned,
* otherwise the next one is returned.
*/
swayc_t *workspace_output_prev_next_impl(swayc_t *output, bool next) {
if (!sway_assert(output->type == C_OUTPUT,
"Argument must be an output, is %d", output->type)) {
return NULL;
}
int i;
for (i = 0; i < output->children->length; i++) {
if (output->children->items[i] == output->focused) {
return output->children->items[
wrap(i + (next ? 1 : -1), output->children->length)];
}
}
// Doesn't happen, at worst the for loop returns the previously active workspace
return NULL;
}
/**
* Get the previous or next workspace. If the first/last workspace on an output
* is active, proceed to the previous/next output's previous/next workspace. If
* next is false, the previous workspace is returned, otherwise the next one is
* returned.
*/
swayc_t *workspace_prev_next_impl(swayc_t *workspace, bool next) {
if (!sway_assert(workspace->type == C_WORKSPACE,
"Argument must be a workspace, is %d", workspace->type)) {
return NULL;
}
swayc_t *current_output = workspace->parent;
int offset = next ? 1 : -1;
int start = next ? 0 : 1;
int end;
if (next) {
end = current_output->children->length - 1;
} else {
end = current_output->children->length;
}
int i;
for (i = start; i < end; i++) {
if (current_output->children->items[i] == workspace) {
return current_output->children->items[i + offset];
}
}
// Given workspace is the first/last on the output, jump to the previous/next output
int num_outputs = root_container.children->length;
for (i = 0; i < num_outputs; i++) {
if (root_container.children->items[i] == current_output) {
swayc_t *next_output = root_container.children->items[
wrap(i + offset, num_outputs)];
return workspace_output_prev_next_impl(next_output, next);
}
}
// Doesn't happen, at worst the for loop returns the previously active workspace on the active output
return NULL;
}
swayc_t *workspace_output_next(swayc_t *current) {
return workspace_output_prev_next_impl(current, true);
}
swayc_t *workspace_next(swayc_t *current) {
return workspace_prev_next_impl(current, true);
}
swayc_t *workspace_output_prev(swayc_t *current) {
return workspace_output_prev_next_impl(current, false);
}
swayc_t *workspace_prev(swayc_t *current) {
return workspace_prev_next_impl(current, false);
}
bool workspace_switch(swayc_t *workspace) {
if (!workspace) {
return false;
}
struct sway_seat *seat = input_manager_current_seat(input_manager);
if (!seat || !seat->focus) {
return false;
}
swayc_t *active_ws = seat->focus;
if (active_ws->type != C_WORKSPACE) {
swayc_parent_by_type(seat->focus, C_WORKSPACE);
}
if (config->auto_back_and_forth
&& active_ws == workspace
&& prev_workspace_name) {
swayc_t *new_ws = workspace_by_name(prev_workspace_name);
workspace = new_ws ? new_ws : workspace_create(prev_workspace_name);
}
if (!prev_workspace_name || (strcmp(prev_workspace_name, active_ws->name)
&& active_ws != workspace)) {
free(prev_workspace_name);
prev_workspace_name = malloc(strlen(active_ws->name) + 1);
if (!prev_workspace_name) {
wlr_log(L_ERROR, "Unable to allocate previous workspace name");
return false;
}
strcpy(prev_workspace_name, active_ws->name);
}
// TODO: Deal with sticky containers
wlr_log(L_DEBUG, "Switching to workspace %p:%s", workspace, workspace->name);
// TODO FOCUS: Focus the last view this seat had focused on this workspace
if (workspace->children->length) {
// TODO FOCUS: This is really fucking stupid
sway_seat_set_focus(seat, workspace->children->items[0]);
} else {
sway_seat_set_focus(seat, workspace);
}
swayc_t *output = swayc_parent_by_type(workspace, C_OUTPUT);
// TODO FOCUS: take a look at this
output->focused = workspace;
arrange_windows(output, -1, -1);
return true;
}