#define _POSIX_C_SOURCE 200809L #include #include #include #include #include #include #include #include "sway/commands.h" #include "sway/input/cursor.h" #include "sway/input/seat.h" #include "sway/ipc-server.h" #include "sway/output.h" #include "sway/tree/arrange.h" #include "sway/tree/container.h" #include "sway/tree/root.h" #include "sway/tree/workspace.h" #include "stringop.h" #include "list.h" #include "log.h" #include "util.h" static const char expected_syntax[] = "Expected 'move <[px] px>' or " "'move [--no-auto-back-and-forth] [to] workspace ' or " "'move [to] output ' or " "'move [to] mark '"; static struct sway_output *output_in_direction(const char *direction_string, struct sway_output *reference, int ref_lx, int ref_ly) { if (strcasecmp(direction_string, "current") == 0) { struct sway_workspace *active_ws = seat_get_focused_workspace(config->handler_context.seat); if (!active_ws) { return NULL; } return active_ws->output; } struct { char *name; enum wlr_direction direction; } names[] = { { "up", WLR_DIRECTION_UP }, { "down", WLR_DIRECTION_DOWN }, { "left", WLR_DIRECTION_LEFT }, { "right", WLR_DIRECTION_RIGHT }, }; enum wlr_direction direction = 0; for (size_t i = 0; i < sizeof(names) / sizeof(names[0]); ++i) { if (strcasecmp(names[i].name, direction_string) == 0) { direction = names[i].direction; break; } } if (reference && direction) { struct wlr_output *target = wlr_output_layout_adjacent_output( root->output_layout, direction, reference->wlr_output, ref_lx, ref_ly); if (!target) { target = wlr_output_layout_farthest_output( root->output_layout, opposite_direction(direction), reference->wlr_output, ref_lx, ref_ly); } if (target) { return target->data; } } return output_by_name_or_id(direction_string); } static bool is_parallel(enum sway_container_layout layout, enum wlr_direction dir) { switch (layout) { case L_TABBED: case L_HORIZ: return dir == WLR_DIRECTION_LEFT || dir == WLR_DIRECTION_RIGHT; case L_STACKED: case L_VERT: return dir == WLR_DIRECTION_UP || dir == WLR_DIRECTION_DOWN; default: return false; } } /** * Ensures all seats focus the fullscreen container if needed. */ static void workspace_focus_fullscreen(struct sway_workspace *workspace) { if (!workspace->fullscreen) { return; } struct sway_seat *seat; struct sway_workspace *focus_ws; wl_list_for_each(seat, &server.input->seats, link) { focus_ws = seat_get_focused_workspace(seat); if (focus_ws == workspace) { struct sway_node *new_focus = seat_get_focus_inactive(seat, &workspace->fullscreen->node); seat_set_raw_focus(seat, new_focus); } } } static void container_move_to_container_from_direction( struct sway_container *container, struct sway_container *destination, enum wlr_direction move_dir) { if (destination->view) { if (destination->parent == container->parent && destination->workspace == container->workspace) { sway_log(SWAY_DEBUG, "Swapping siblings"); list_t *siblings = container_get_siblings(container); int container_index = list_find(siblings, container); int destination_index = list_find(siblings, destination); list_swap(siblings, container_index, destination_index); } else { sway_log(SWAY_DEBUG, "Promoting to sibling of cousin"); int offset = move_dir == WLR_DIRECTION_LEFT || move_dir == WLR_DIRECTION_UP; int index = container_sibling_index(destination) + offset; if (destination->parent) { container_insert_child(destination->parent, container, index); } else { workspace_insert_tiling(destination->workspace, container, index); } container->width = container->height = 0; container->width_fraction = container->height_fraction = 0; } return; } if (is_parallel(destination->layout, move_dir)) { sway_log(SWAY_DEBUG, "Reparenting container (parallel)"); int index = move_dir == WLR_DIRECTION_RIGHT || move_dir == WLR_DIRECTION_DOWN ? 0 : destination->children->length; container_insert_child(destination, container, index); container->width = container->height = 0; container->width_fraction = container->height_fraction = 0; return; } sway_log(SWAY_DEBUG, "Reparenting container (perpendicular)"); struct sway_node *focus_inactive = seat_get_active_tiling_child( config->handler_context.seat, &destination->node); if (!focus_inactive || focus_inactive == &destination->node) { // The container has no children container_add_child(destination, container); return; } // Try again but with the child container_move_to_container_from_direction(container, focus_inactive->sway_container, move_dir); } static void container_move_to_workspace_from_direction( struct sway_container *container, struct sway_workspace *workspace, enum wlr_direction move_dir) { container->width = container->height = 0; container->width_fraction = container->height_fraction = 0; if (is_parallel(workspace->layout, move_dir)) { sway_log(SWAY_DEBUG, "Reparenting container (parallel)"); int index = move_dir == WLR_DIRECTION_RIGHT || move_dir == WLR_DIRECTION_DOWN ? 0 : workspace->tiling->length; workspace_insert_tiling(workspace, container, index); return; } sway_log(SWAY_DEBUG, "Reparenting container (perpendicular)"); struct sway_container *focus_inactive = seat_get_focus_inactive_tiling( config->handler_context.seat, workspace); if (!focus_inactive) { // The workspace has no tiling children workspace_add_tiling(workspace, container); return; } while (focus_inactive->parent) { focus_inactive = focus_inactive->parent; } container_move_to_container_from_direction(container, focus_inactive, move_dir); } static void container_move_to_workspace(struct sway_container *container, struct sway_workspace *workspace) { if (container->workspace == workspace) { return; } struct sway_workspace *old_workspace = container->workspace; if (container_is_floating(container)) { struct sway_output *old_output = container->workspace->output; container_detach(container); workspace_add_floating(workspace, container); container_handle_fullscreen_reparent(container); // If changing output, center it within the workspace if (old_output != workspace->output && !container->fullscreen_mode) { container_floating_move_to_center(container); } } else { container_detach(container); container->width = container->height = 0; container->width_fraction = container->height_fraction = 0; workspace_add_tiling(workspace, container); container_update_representation(container); } if (container->view) { ipc_event_window(container, "move"); } workspace_detect_urgent(old_workspace); workspace_detect_urgent(workspace); workspace_focus_fullscreen(workspace); } static void container_move_to_container(struct sway_container *container, struct sway_container *destination) { if (container == destination || container_has_ancestor(container, destination) || container_has_ancestor(destination, container)) { return; } if (container_is_floating(container)) { container_move_to_workspace(container, destination->workspace); return; } struct sway_workspace *old_workspace = container->workspace; container_detach(container); container->width = container->height = 0; container->width_fraction = container->height_fraction = 0; if (destination->view) { container_add_sibling(destination, container, 1); } else { container_add_child(destination, container); } if (container->view) { ipc_event_window(container, "move"); } workspace_focus_fullscreen(destination->workspace); // Update workspace urgent state workspace_detect_urgent(destination->workspace); if (old_workspace && old_workspace != destination->workspace) { workspace_detect_urgent(old_workspace); } } /* 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_workspace *ws, struct sway_container *child, enum wlr_direction move_dir) { if (!child->parent && ws->tiling->length == 1) { ws->layout = move_dir == WLR_DIRECTION_LEFT || move_dir == WLR_DIRECTION_RIGHT ? L_HORIZ : L_VERT; workspace_update_representation(ws); return; } container_detach(child); struct sway_container *new_parent = workspace_wrap_children(ws); int index = move_dir == WLR_DIRECTION_LEFT || move_dir == WLR_DIRECTION_UP ? 0 : 1; workspace_insert_tiling(ws, child, index); container_flatten(new_parent); ws->layout = move_dir == WLR_DIRECTION_LEFT || move_dir == WLR_DIRECTION_RIGHT ? L_HORIZ : L_VERT; workspace_update_representation(ws); child->width = child->height = 0; } // Returns true if moved static bool container_move_in_direction(struct sway_container *container, enum wlr_direction move_dir) { // If moving a fullscreen view, only consider outputs if (container->fullscreen_mode == FULLSCREEN_WORKSPACE) { struct sway_output *new_output = output_get_in_direction(container->workspace->output, move_dir); if (!new_output) { return false; } struct sway_workspace *ws = output_get_active_workspace(new_output); if (!sway_assert(ws, "Expected output to have a workspace")) { return false; } container_move_to_workspace(container, ws); return true; } if (container->fullscreen_mode == FULLSCREEN_GLOBAL) { return false; } // If container is in a split container by itself, move out of the split if (container->parent) { struct sway_container *new_parent = container_flatten(container->parent); if (new_parent != container->parent) { return true; } } // Look for a suitable *container* sibling or parent. // The below loop stops once we hit the workspace because current->parent // is NULL for the topmost containers in a workspace. struct sway_container *current = container; int offs = move_dir == WLR_DIRECTION_LEFT || move_dir == WLR_DIRECTION_UP ? -1 : 1; while (current) { list_t *siblings = container_get_siblings(current); if (siblings) { enum sway_container_layout layout = container_parent_layout(current); int index = list_find(siblings, current); int desired = index + offs; // Don't allow containers to move out of their // fullscreen or floating parent if (current->fullscreen_mode || container_is_floating(current)) { return false; } if (is_parallel(layout, move_dir)) { if (desired == -1 || desired == siblings->length) { if (current->parent == container->parent) { current = current->parent; continue; } else { // Reparenting if (current->parent) { container_insert_child(current->parent, container, index + (offs < 0 ? 0 : 1)); } else { workspace_insert_tiling(current->workspace, container, index + (offs < 0 ? 0 : 1)); } return true; } } else { // Container can move within its siblings container_move_to_container_from_direction(container, siblings->items[desired], move_dir); return true; } } } current = current->parent; } // Maybe rejigger the workspace struct sway_workspace *ws = container->workspace; if (ws) { if (!is_parallel(ws->layout, move_dir)) { workspace_rejigger(ws, container, move_dir); return true; } else if (ws->layout == L_TABBED || ws->layout == L_STACKED) { workspace_rejigger(ws, container, move_dir); return true; } // Try adjacent output struct sway_output *output = output_get_in_direction(container->workspace->output, move_dir); if (output) { struct sway_workspace *ws = output_get_active_workspace(output); if (!sway_assert(ws, "Expected output to have a workspace")) { return false; } container_move_to_workspace_from_direction(container, ws, move_dir); return true; } sway_log(SWAY_DEBUG, "Hit edge of output, nowhere else to go"); } return false; } static struct cmd_results *cmd_move_container(bool no_auto_back_and_forth, int argc, char **argv) { struct cmd_results *error = NULL; if ((error = checkarg(argc, "move container/window", EXPECTED_AT_LEAST, 2))) { return error; } struct sway_node *node = config->handler_context.node; struct sway_workspace *workspace = config->handler_context.workspace; struct sway_container *container = config->handler_context.container; if (node->type == N_WORKSPACE) { if (workspace->tiling->length == 0) { return cmd_results_new(CMD_FAILURE, "Can't move an empty workspace"); } container = workspace_wrap_children(workspace); } if (container->fullscreen_mode == FULLSCREEN_GLOBAL) { return cmd_results_new(CMD_FAILURE, "Can't move fullscreen global container"); } struct sway_seat *seat = config->handler_context.seat; struct sway_container *old_parent = container->parent; struct sway_workspace *old_ws = container->workspace; struct sway_output *old_output = old_ws ? old_ws->output : NULL; struct sway_node *destination = NULL; // determine destination if (strcasecmp(argv[0], "workspace") == 0) { // move container to workspace x struct sway_workspace *ws = NULL; char *ws_name = NULL; if (strcasecmp(argv[1], "next") == 0 || strcasecmp(argv[1], "prev") == 0 || strcasecmp(argv[1], "next_on_output") == 0 || strcasecmp(argv[1], "prev_on_output") == 0 || strcasecmp(argv[1], "current") == 0) { ws = workspace_by_name(argv[1]); } else if (strcasecmp(argv[1], "back_and_forth") == 0) { if (!(ws = workspace_by_name(argv[1]))) { if (seat->prev_workspace_name) { ws_name = strdup(seat->prev_workspace_name); } else { return cmd_results_new(CMD_FAILURE, "No workspace was previously active."); } } } else { if (strcasecmp(argv[1], "number") == 0) { // move [window|container] [to] "workspace number x" if (argc < 3) { return cmd_results_new(CMD_INVALID, expected_syntax); } if (!isdigit(argv[2][0])) { return cmd_results_new(CMD_INVALID, "Invalid workspace number '%s'", argv[2]); } ws_name = join_args(argv + 2, argc - 2); ws = workspace_by_number(ws_name); } else { ws_name = join_args(argv + 1, argc - 1); ws = workspace_by_name(ws_name); } if (!no_auto_back_and_forth && config->auto_back_and_forth && seat->prev_workspace_name) { // auto back and forth move if (old_ws && old_ws->name && strcmp(old_ws->name, ws_name) == 0) { // if target workspace is the current one free(ws_name); ws_name = strdup(seat->prev_workspace_name); ws = workspace_by_name(ws_name); } } } if (!ws) { // We have to create the workspace, but if the container is // sticky and the workspace is going to be created on the same // output, we'll bail out first. if (container->is_sticky && container_is_floating_or_child(container)) { struct sway_output *new_output = workspace_get_initial_output(ws_name); if (old_output == new_output) { free(ws_name); return cmd_results_new(CMD_FAILURE, "Can't move sticky container to another workspace " "on the same output"); } } ws = workspace_create(NULL, ws_name); } free(ws_name); struct sway_container *dst = seat_get_focus_inactive_tiling(seat, ws); destination = dst ? &dst->node : &ws->node; } else if (strcasecmp(argv[0], "output") == 0) { struct sway_output *new_output = output_in_direction(argv[1], old_output, container->x, container->y); if (!new_output) { return cmd_results_new(CMD_FAILURE, "Can't find output with name/direction '%s'", argv[1]); } destination = seat_get_focus_inactive(seat, &new_output->node); } else if (strcasecmp(argv[0], "mark") == 0) { struct sway_container *dest_con = container_find_mark(argv[1]); if (dest_con == NULL) { return cmd_results_new(CMD_FAILURE, "Mark '%s' not found", argv[1]); } destination = &dest_con->node; } else { return cmd_results_new(CMD_INVALID, expected_syntax); } if (container->is_sticky && container_is_floating_or_child(container) && old_output && node_has_ancestor(destination, &old_output->node)) { return cmd_results_new(CMD_FAILURE, "Can't move sticky " "container to another workspace on the same output"); } struct sway_output *new_output = node_get_output(destination); struct sway_workspace *new_output_last_ws = old_output == new_output ? NULL : output_get_active_workspace(new_output); // save focus, in case it needs to be restored struct sway_node *focus = seat_get_focus(seat); // move container if (container->scratchpad) { root_scratchpad_show(container); } switch (destination->type) { case N_WORKSPACE: container_move_to_workspace(container, destination->sway_workspace); break; case N_OUTPUT: { struct sway_output *output = destination->sway_output; struct sway_workspace *ws = output_get_active_workspace(output); if (!sway_assert(ws, "Expected output to have a workspace")) { return cmd_results_new(CMD_FAILURE, "Expected output to have a workspace"); } container_move_to_workspace(container, ws); } break; case N_CONTAINER: container_move_to_container(container, destination->sway_container); break; case N_ROOT: break; } // restore focus on destination output back to its last active workspace struct sway_workspace *new_workspace = output_get_active_workspace(new_output); if (!sway_assert(new_workspace, "Expected output to have a workspace")) { return cmd_results_new(CMD_FAILURE, "Expected output to have a workspace"); } if (new_output_last_ws && new_output_last_ws != new_workspace) { struct sway_node *new_output_last_focus = seat_get_focus_inactive(seat, &new_output_last_ws->node); seat_set_raw_focus(seat, new_output_last_focus); } // restore focus if (focus == &container->node) { focus = NULL; if (old_parent) { focus = seat_get_focus_inactive(seat, &old_parent->node); } if (!focus && old_ws) { focus = seat_get_focus_inactive(seat, &old_ws->node); } } seat_set_focus(seat, focus); // clean-up, destroying parents if the container was the last child if (old_parent) { container_reap_empty(old_parent); } else if (old_ws) { workspace_consider_destroy(old_ws); } // arrange windows if (root->fullscreen_global) { arrange_root(); } else { if (old_ws && !old_ws->node.destroying) { arrange_workspace(old_ws); } arrange_node(node_get_parent(destination)); } return cmd_results_new(CMD_SUCCESS, NULL); } static void workspace_move_to_output(struct sway_workspace *workspace, struct sway_output *output) { if (workspace->output == output) { return; } struct sway_output *old_output = workspace->output; workspace_detach(workspace); struct sway_workspace *new_output_old_ws = output_get_active_workspace(output); if (!sway_assert(new_output_old_ws, "Expected output to have a workspace")) { return; } output_add_workspace(output, workspace); // If moving the last workspace from the old output, create a new workspace // on the old output struct sway_seat *seat = config->handler_context.seat; if (old_output->workspaces->length == 0) { char *ws_name = workspace_next_name(old_output->wlr_output->name); struct sway_workspace *ws = workspace_create(old_output, ws_name); free(ws_name); seat_set_raw_focus(seat, &ws->node); } workspace_consider_destroy(new_output_old_ws); output_sort_workspaces(output); struct sway_node *focus = seat_get_focus_inactive(seat, &workspace->node); seat_set_focus(seat, focus); workspace_output_raise_priority(workspace, old_output, output); ipc_event_workspace(NULL, workspace, "move"); } static struct cmd_results *cmd_move_workspace(int argc, char **argv) { struct cmd_results *error = NULL; if ((error = checkarg(argc, "move workspace", EXPECTED_AT_LEAST, 1))) { return error; } if (strcasecmp(argv[0], "output") == 0) { --argc; ++argv; } if (!argc) { return cmd_results_new(CMD_INVALID, "Expected 'move workspace to [output] '"); } struct sway_workspace *workspace = config->handler_context.workspace; if (!workspace) { return cmd_results_new(CMD_FAILURE, "No workspace to move"); } struct sway_output *old_output = workspace->output; int center_x = workspace->width / 2 + workspace->x, center_y = workspace->height / 2 + workspace->y; struct sway_output *new_output = output_in_direction(argv[0], old_output, center_x, center_y); if (!new_output) { return cmd_results_new(CMD_FAILURE, "Can't find output with name/direction '%s'", argv[0]); } workspace_move_to_output(workspace, new_output); arrange_output(old_output); arrange_output(new_output); return cmd_results_new(CMD_SUCCESS, NULL); } static struct cmd_results *cmd_move_in_direction( enum wlr_direction direction, int argc, char **argv) { int move_amt = 10; if (argc) { char *inv; move_amt = (int)strtol(argv[0], &inv, 10); if (*inv != '\0' && strcasecmp(inv, "px") != 0) { return cmd_results_new(CMD_FAILURE, "Invalid distance specified"); } } struct sway_container *container = config->handler_context.container; if (!container) { return cmd_results_new(CMD_FAILURE, "Cannot move workspaces in a direction"); } if (container_is_floating(container)) { if (container->fullscreen_mode) { return cmd_results_new(CMD_FAILURE, "Cannot move fullscreen floating container"); } double lx = container->x; double ly = container->y; switch (direction) { case WLR_DIRECTION_LEFT: lx -= move_amt; break; case WLR_DIRECTION_RIGHT: lx += move_amt; break; case WLR_DIRECTION_UP: ly -= move_amt; break; case WLR_DIRECTION_DOWN: ly += move_amt; break; } container_floating_move_to(container, lx, ly); return cmd_results_new(CMD_SUCCESS, NULL); } struct sway_workspace *old_ws = container->workspace; if (!container_move_in_direction(container, direction)) { // Container didn't move return cmd_results_new(CMD_SUCCESS, NULL); } struct sway_workspace *new_ws = container->workspace; if (root->fullscreen_global) { arrange_root(); } else { arrange_workspace(old_ws); if (new_ws != old_ws) { arrange_workspace(new_ws); } } if (container->view) { ipc_event_window(container, "move"); } // Hack to re-focus container seat_set_raw_focus(config->handler_context.seat, &new_ws->node); seat_set_focus_container(config->handler_context.seat, container); if (old_ws != new_ws) { ipc_event_workspace(old_ws, new_ws, "focus"); workspace_detect_urgent(old_ws); workspace_detect_urgent(new_ws); } container_end_mouse_operation(container); return cmd_results_new(CMD_SUCCESS, NULL); } static const char expected_position_syntax[] = "Expected 'move [absolute] position [px] [px]' or " "'move [absolute] position center' or " "'move position cursor|mouse|pointer'"; static struct cmd_results *cmd_move_to_position(int argc, char **argv) { struct sway_container *container = config->handler_context.container; if (!container || !container_is_floating(container)) { return cmd_results_new(CMD_FAILURE, "Only floating containers " "can be moved to an absolute position"); } if (!argc) { return cmd_results_new(CMD_INVALID, expected_position_syntax); } bool absolute = false; if (strcmp(argv[0], "absolute") == 0) { absolute = true; --argc; ++argv; } if (!argc) { return cmd_results_new(CMD_INVALID, expected_position_syntax); } if (strcmp(argv[0], "position") == 0) { --argc; ++argv; } if (!argc) { return cmd_results_new(CMD_INVALID, expected_position_syntax); } if (strcmp(argv[0], "cursor") == 0 || strcmp(argv[0], "mouse") == 0 || strcmp(argv[0], "pointer") == 0) { if (absolute) { return cmd_results_new(CMD_INVALID, expected_position_syntax); } struct sway_seat *seat = config->handler_context.seat; if (!seat->cursor) { return cmd_results_new(CMD_FAILURE, "No cursor device"); } double lx = seat->cursor->cursor->x - container->width / 2; double ly = seat->cursor->cursor->y - container->height / 2; container_floating_move_to(container, lx, ly); return cmd_results_new(CMD_SUCCESS, NULL); } else if (strcmp(argv[0], "center") == 0) { double lx, ly; if (absolute) { lx = root->x + (root->width - container->width) / 2; ly = root->y + (root->height - container->height) / 2; } else { struct sway_workspace *ws = container->workspace; if (!ws) { struct sway_seat *seat = config->handler_context.seat; ws = seat_get_focused_workspace(seat); } lx = ws->x + (ws->width - container->width) / 2; ly = ws->y + (ws->height - container->height) / 2; } container_floating_move_to(container, lx, ly); return cmd_results_new(CMD_SUCCESS, NULL); } if (argc < 2) { return cmd_results_new(CMD_FAILURE, expected_position_syntax); } double lx, ly; char *inv; lx = (double)strtol(argv[0], &inv, 10); if (*inv != '\0' && strcasecmp(inv, "px") != 0) { return cmd_results_new(CMD_FAILURE, "Invalid position specified"); } if (strcmp(argv[1], "px") == 0) { --argc; ++argv; } if (argc > 3) { return cmd_results_new(CMD_FAILURE, expected_position_syntax); } ly = (double)strtol(argv[1], &inv, 10); if ((*inv != '\0' && strcasecmp(inv, "px") != 0) || (argc == 3 && strcmp(argv[2], "px") != 0)) { return cmd_results_new(CMD_FAILURE, "Invalid position specified"); } if (!absolute) { struct sway_workspace *ws = container->workspace; if (!ws) { struct sway_seat *seat = config->handler_context.seat; ws = seat_get_focused_workspace(seat); } lx += ws->x; ly += ws->y; } container_floating_move_to(container, lx, ly); return cmd_results_new(CMD_SUCCESS, NULL); } static struct cmd_results *cmd_move_to_scratchpad(void) { struct sway_node *node = config->handler_context.node; struct sway_container *con = config->handler_context.container; struct sway_workspace *ws = config->handler_context.workspace; if (node->type == N_WORKSPACE && ws->tiling->length == 0) { return cmd_results_new(CMD_INVALID, "Can't move an empty workspace to the scratchpad"); } if (node->type == N_WORKSPACE) { // Wrap the workspace's children in a container con = workspace_wrap_children(ws); ws->layout = L_HORIZ; } // If the container is in a floating split container, // operate on the split container instead of the child. if (container_is_floating_or_child(con)) { while (con->parent) { con = con->parent; } } if (!con->scratchpad) { root_scratchpad_add_container(con, NULL); } else if (con->workspace) { root_scratchpad_hide(con); } return cmd_results_new(CMD_SUCCESS, NULL); } static const char expected_full_syntax[] = "Expected " "'move left|right|up|down [ [px]]'" " or 'move [--no-auto-back-and-forth] [window|container] [to] workspace" " |next|prev|next_on_output|prev_on_output|current|(number )'" " or 'move [window|container] [to] output |left|right|up|down'" " or 'move [window|container] [to] mark '" " or 'move [window|container] [to] scratchpad'" " or 'move workspace to [output] |left|right|up|down'" " or 'move [window|container] [to] [absolute] position [px] [px]'" " or 'move [window|container] [to] [absolute] position center'" " or 'move [window|container] [to] position mouse|cursor|pointer'"; struct cmd_results *cmd_move(int argc, char **argv) { struct cmd_results *error = NULL; if ((error = checkarg(argc, "move", EXPECTED_AT_LEAST, 1))) { return error; } if (!root->outputs->length) { return cmd_results_new(CMD_INVALID, "Can't run this command while there's no outputs connected."); } if (strcasecmp(argv[0], "left") == 0) { return cmd_move_in_direction(WLR_DIRECTION_LEFT, --argc, ++argv); } else if (strcasecmp(argv[0], "right") == 0) { return cmd_move_in_direction(WLR_DIRECTION_RIGHT, --argc, ++argv); } else if (strcasecmp(argv[0], "up") == 0) { return cmd_move_in_direction(WLR_DIRECTION_UP, --argc, ++argv); } else if (strcasecmp(argv[0], "down") == 0) { return cmd_move_in_direction(WLR_DIRECTION_DOWN, --argc, ++argv); } else if (strcasecmp(argv[0], "workspace") == 0 && argc >= 2 && (strcasecmp(argv[1], "to") == 0 || strcasecmp(argv[1], "output") == 0)) { argc -= 2; argv += 2; return cmd_move_workspace(argc, argv); } bool no_auto_back_and_forth = false; if (strcasecmp(argv[0], "--no-auto-back-and-forth") == 0) { no_auto_back_and_forth = true; --argc; ++argv; } if (strcasecmp(argv[0], "window") == 0 || strcasecmp(argv[0], "container") == 0) { --argc; ++argv; } if (strcasecmp(argv[0], "to") == 0) { --argc; ++argv; } if (!argc) { return cmd_results_new(CMD_INVALID, expected_full_syntax); } // Only `move [window|container] [to] workspace` supports // `--no-auto-back-and-forth` so treat others as invalid syntax if (no_auto_back_and_forth && strcasecmp(argv[0], "workspace") != 0) { return cmd_results_new(CMD_INVALID, expected_full_syntax); } if (strcasecmp(argv[0], "workspace") == 0 || strcasecmp(argv[0], "output") == 0 || strcasecmp(argv[0], "mark") == 0) { return cmd_move_container(no_auto_back_and_forth, argc, argv); } else if (strcasecmp(argv[0], "scratchpad") == 0) { return cmd_move_to_scratchpad(); } else if (strcasecmp(argv[0], "position") == 0 || (argc > 1 && strcasecmp(argv[0], "absolute") == 0 && strcasecmp(argv[1], "position") == 0)) { return cmd_move_to_position(argc, argv); } return cmd_results_new(CMD_INVALID, expected_full_syntax); }