mirrors/sway
1
0
Fork 0
mirror of https://github.com/swaywm/sway.git synced 2024-11-23 00:11:28 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove sway/old/

Browse source
This commit is contained in:
Drew DeVault 2018-01-21 12:21:57 -05:00
parent c933781fac
commit a6bc46eea9
104 changed files with 0 additions and 14614 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

510
sway/old/border.c
View file

@ -1,510 +0,0 @@
#define _XOPEN_SOURCE 700
#include <wlc/wlc-render.h>
#include <cairo/cairo.h>
#include <pango/pangocairo.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <strings.h>
#include <arpa/inet.h>
#include "sway/border.h"
#include "sway/container.h"
#include "sway/config.h"
#include "client/pango.h"
void cairo_set_source_u32(cairo_t *cairo, uint32_t color) {
color = htonl(color);
cairo_set_source_rgba(cairo,
(color >> (2*8) & 0xFF) / 255.0,
(color >> (1*8) & 0xFF) / 255.0,
(color >> (0*8) & 0xFF) / 255.0,
(color >> (3*8) & 0xFF) / 255.0);
}
void border_clear(struct border *border) {
if (border && border->buffer) {
free(border->buffer);
border->buffer = NULL;
}
}
static cairo_t *create_border_buffer(swayc_t *view, struct wlc_geometry g, cairo_surface_t **surface) {
if (view->border == NULL) {
view->border = malloc(sizeof(struct border));
if (!view->border) {
sway_log(L_ERROR, "Unable to allocate window border information");
return NULL;
}
}
cairo_t *cr;
int stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, g.size.w);
view->border->buffer = calloc(stride * g.size.h, sizeof(unsigned char));
view->border->geometry = g;
if (!view->border->buffer) {
sway_log(L_ERROR, "Unable to allocate window border buffer");
return NULL;
}
*surface = cairo_image_surface_create_for_data(view->border->buffer,
CAIRO_FORMAT_ARGB32, g.size.w, g.size.h, stride);
if (cairo_surface_status(*surface) != CAIRO_STATUS_SUCCESS) {
border_clear(view->border);
sway_log(L_ERROR, "Unable to allocate window border surface");
return NULL;
}
cr = cairo_create(*surface);
cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
if (cairo_status(cr) != CAIRO_STATUS_SUCCESS) {
cairo_surface_destroy(*surface);
border_clear(view->border);
sway_log(L_ERROR, "Unable to create cairo context");
return NULL;
}
return cr;
}
// TODO: move to client/cairo.h when local set_source_u32 is fixed.
/**
* Renders a sharp line of any width and height.
*
* The line is drawn from (x,y) to (x+width,y+height) where width/height is 0
* if the line has a width/height of one pixel, respectively.
*/
static void render_sharp_line(cairo_t *cairo, uint32_t color, double x, double y, double width, double height) {
cairo_set_source_u32(cairo, color);
if (width > 1 && height > 1) {
cairo_rectangle(cairo, x, y, width, height);
cairo_fill(cairo);
} else {
if (width == 1) {
x += 0.5;
height += y;
width = x;
}
if (height == 1) {
y += 0.5;
width += x;
height = y;
}
cairo_move_to(cairo, x, y);
cairo_set_line_width(cairo, 1.0);
cairo_line_to(cairo, width, height);
cairo_stroke(cairo);
}
}
int get_font_text_height(const char *font) {
cairo_surface_t *surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 200, 200);
cairo_t *cr = cairo_create(surface);
int width, height;
get_text_size(cr, font, &width, &height, 1, false, "Gg");
cairo_surface_destroy(surface);
cairo_destroy(cr);
return height;
}
static void render_borders(swayc_t *view, cairo_t *cr, struct border_colors *colors, bool top) {
struct wlc_geometry *g = &view->border->geometry;
struct wlc_geometry *b = &view->border_geometry;
struct wlc_geometry *v = &view->actual_geometry;
enum swayc_layouts layout = view->parent->layout;
uint32_t color;
int x = b->origin.x - g->origin.x;
int y = b->origin.y - g->origin.y;
// draw vertical/horizontal indicator if container is the only child of its parent container
bool is_only_child = view->parent && view->parent->children && view->parent->children->length == 1;
// left border
int left_border = v->origin.x - b->origin.x;
if (left_border > 0) {
render_sharp_line(cr,
colors->child_border,
x, y,
left_border,
b->size.h);
}
// right border
int right_border = b->size.w - v->size.w - left_border;
if (right_border > 0) {
if (is_only_child && layout == L_HORIZ && !view->is_floating) {
color = colors->indicator;
} else {
color = colors->child_border;
}
render_sharp_line(cr,
color,
x + b->size.w - right_border,
y,
right_border,
b->size.h);
}
// top border
int top_border = v->origin.y - b->origin.y;
if (top && top_border > 0) {
render_sharp_line(cr,
colors->child_border,
x, y,
b->size.w,
top_border);
}
// bottom border
int bottom_border = b->size.h - (top_border + v->size.h);
if (bottom_border > 0) {
if (is_only_child && layout == L_VERT && !view->is_floating) {
color = colors->indicator;
} else {
color = colors->child_border;
}
render_sharp_line(cr,
color,
x,
y + b->size.h - bottom_border,
b->size.w,
bottom_border);
}
}
static void render_title_bar(swayc_t *view, cairo_t *cr, struct wlc_geometry *b, struct border_colors *colors) {
struct wlc_geometry *tb = &view->title_bar_geometry;
int x = MIN(tb->origin.x, tb->origin.x - b->origin.x);
int y = MIN(tb->origin.y, tb->origin.y - b->origin.y);
// title bar background
cairo_set_source_u32(cr, colors->background);
cairo_rectangle(cr, x, y, tb->size.w, tb->size.h);
cairo_fill(cr);
// header top line
render_sharp_line(cr, colors->border, x, y, tb->size.w, 1);
// text
if (view->name) {
int width, height;
get_text_size(cr, config->font, &width, &height, 1, false, "%s", view->name);
cairo_move_to(cr, x + 2, y + 2);
cairo_set_source_u32(cr, colors->text);
pango_printf(cr, config->font, 1, false, "%s", view->name);
}
// Marks
if (config->show_marks && view->marks) {
int total_len = 0;
for(int i = view->marks->length - 1; i >= 0; --i) {
char *mark = (char *)view->marks->items[i];
if (*mark != '_') {
int width, height;
get_text_size(cr, config->font, &width, &height, 1, false, "[%s]", mark);
total_len += width;
if ((int)tb->size.w + x - (total_len + 2) < x + 2) {
break;
} else {
cairo_move_to(cr, (int)tb->size.w + x - (total_len + 2), y + 2);
cairo_set_source_u32(cr, colors->text);
pango_printf(cr, config->font, 1, false, "[%s]", mark);
}
}
}
}
// titlebars has a border all around for tabbed layouts
if (view->parent->layout == L_TABBED) {
// header bottom line
render_sharp_line(cr, colors->border, x, y + tb->size.h - 1,
tb->size.w, 1);
// left border
render_sharp_line(cr, colors->border, x, y, 1, tb->size.h);
// right border
render_sharp_line(cr, colors->border, x + tb->size.w - 1, y,
1, tb->size.h);
return;
}
if ((uint32_t)(view->actual_geometry.origin.y - tb->origin.y) == tb->size.h) {
// header bottom line
render_sharp_line(cr, colors->border,
x + view->actual_geometry.origin.x - tb->origin.x,
y + tb->size.h - 1,
view->actual_geometry.size.w, 1);
} else {
// header bottom line
render_sharp_line(cr, colors->border, x,
y + tb->size.h - 1,
tb->size.w, 1);
}
}
/**
* Generate nested container title for tabbed/stacked layouts
*/
static char *generate_container_title(swayc_t *container) {
char layout = 'H';
char *name, *prev_name = NULL;
switch (container->layout) {
case L_TABBED:
layout = 'T';
break;
case L_STACKED:
layout = 'S';
break;
case L_VERT:
layout = 'V';
break;
default:
layout = 'H';
}
int len = 9;
name = malloc(len * sizeof(char));
if (!name) {
sway_log(L_ERROR, "Unable to allocate container title");
return NULL;
}
snprintf(name, len, "sway: %c[", layout);
int i;
for (i = 0; i < container->children->length; ++i) {
prev_name = name;
swayc_t* child = container->children->items[i];
const char *title = NULL;
if (child->type == C_VIEW) {
title = child->app_id ? child->app_id :
(child->instance ? child->instance :
(child->class ? child->class :"(null)"));
} else { //child->type == C_CONTAINER
title = generate_container_title(child);
}
len = strlen(name) + strlen(title) + 1;
if (i < container->children->length-1) {
len++;
}
name = malloc(len * sizeof(char));
if (!name) {
free(prev_name);
sway_log(L_ERROR, "Unable to allocate container title");
return NULL;
}
if (i < container->children->length-1) {
snprintf(name, len, "%s%s ", prev_name, title);
} else {
snprintf(name, len, "%s%s", prev_name, title);
}
free(prev_name);
}
prev_name = name;
len = strlen(name) + 2;
name = malloc(len * sizeof(char));
if (!name) {
free(prev_name);
sway_log(L_ERROR, "Unable to allocate container title");
return NULL;
}
snprintf(name, len, "%s]", prev_name);
free(prev_name);
free(container->name);
container->name = name;
return container->name + 6; // don't include "sway: "
}
void update_tabbed_stacked_titlebars(swayc_t *c, cairo_t *cr, struct wlc_geometry *g, swayc_t *focused, swayc_t *focused_inactive) {
if (c->type == C_CONTAINER) {
if (c->parent->focused == c) {
render_title_bar(c, cr, g, &config->border_colors.focused_inactive);
} else {
render_title_bar(c, cr, g, &config->border_colors.unfocused);
}
if (!c->visible) {
return;
}
int i;
for (i = 0; i < c->children->length; ++i) {
swayc_t *child = c->children->items[i];
update_tabbed_stacked_titlebars(child, cr, g, focused, focused_inactive);
}
} else {
bool is_child_of_focused = swayc_is_child_of(c, get_focused_container(&root_container));
if (focused == c || is_child_of_focused) {
render_title_bar(c, cr, g, &config->border_colors.focused);
} else if (focused_inactive == c) {
render_title_bar(c, cr, g, &config->border_colors.focused_inactive);
} else {
render_title_bar(c, cr, g, &config->border_colors.unfocused);
}
}
}
static void update_view_border(swayc_t *view) {
if (!view->visible) {
return;
}
cairo_t *cr = NULL;
cairo_surface_t *surface = NULL;
// clear previous border buffer.
border_clear(view->border);
// get focused and focused_inactive views
swayc_t *focused = get_focused_view(&root_container);
swayc_t *container = swayc_parent_by_type(view, C_CONTAINER);
swayc_t *focused_inactive = NULL;
bool is_child_of_focused = swayc_is_parent_of(get_focused_container(&root_container), view);
if (container) {
focused_inactive = swayc_focus_by_type(container, C_VIEW);
} else {
container = swayc_parent_by_type(view, C_WORKSPACE);
if (container) {
focused_inactive = swayc_focus_by_type(container, C_VIEW);
}
}
// for tabbed/stacked layouts the focused view has to draw all the
// titlebars of the hidden views.
swayc_t *p = NULL;
if (view->parent->focused == view && (p = swayc_tabbed_stacked_ancestor(view))) {
struct wlc_geometry g = {
.origin = {
.x = p->x,
.y = p->y
},
.size = {
.w = p->width,
.h = p->height
}
};
cr = create_border_buffer(view, g, &surface);
if (!cr) {
goto cleanup;
}
bool render_top = !should_hide_top_border(view, view->y);
if (view == focused || is_child_of_focused) {
render_borders(view, cr, &config->border_colors.focused, render_top);
} else {
render_borders(view, cr, &config->border_colors.focused_inactive, render_top);
}
// generate container titles
int i;
for (i = 0; i < p->children->length; ++i) {
swayc_t *child = p->children->items[i];
if (child->type == C_CONTAINER) {
generate_container_title(child);
}
}
update_tabbed_stacked_titlebars(p, cr, &g, focused, focused_inactive);
} else {
switch (view->border_type) {
case B_NONE:
break;
case B_PIXEL:
cr = create_border_buffer(view, view->border_geometry, &surface);
if (!cr) {
break;
}
if (focused == view || is_child_of_focused) {
render_borders(view, cr, &config->border_colors.focused, true);
} else if (focused_inactive == view) {
render_borders(view, cr, &config->border_colors.focused_inactive, true);
} else {
render_borders(view, cr, &config->border_colors.unfocused, true);
}
break;
case B_NORMAL:
cr = create_border_buffer(view, view->border_geometry, &surface);
if (!cr) {
break;
}
if (focused == view || is_child_of_focused) {
render_borders(view, cr, &config->border_colors.focused, false);
render_title_bar(view, cr, &view->border_geometry,
&config->border_colors.focused);
} else if (focused_inactive == view) {
render_borders(view, cr, &config->border_colors.focused_inactive, false);
render_title_bar(view, cr, &view->border_geometry,
&config->border_colors.focused_inactive);
} else {
render_borders(view, cr, &config->border_colors.unfocused, false);
render_title_bar(view, cr, &view->border_geometry,
&config->border_colors.unfocused);
}
break;
}
}
cleanup:
if (surface) {
cairo_surface_flush(surface);
cairo_surface_destroy(surface);
}
if (cr) {
cairo_destroy(cr);
}
}
void update_container_border(swayc_t *container) {
if (container->type == C_VIEW) {
update_view_border(container);
return;
} else {
for (int i = 0; i < container->children->length; ++i) {
update_container_border(container->children->items[i]);
}
}
}
void render_view_borders(wlc_handle view) {
swayc_t *c = swayc_by_handle(view);
// emulate i3 behavior for drawing borders for tabbed and stacked layouts:
// if we are not the only child in the container, always draw borders,
// regardless of the border setting on the individual view
if (!c || (c->border_type == B_NONE
&& !((c->parent->layout == L_TABBED || c->parent->layout == L_STACKED)
&& c->parent->children->length > 1))) {
return;
}
if (c->border && c->border->buffer) {
wlc_pixels_write(WLC_RGBA8888, &c->border->geometry, c->border->buffer);
}
}
bool should_hide_top_border(swayc_t *con, double y) {
// returns true if container is child of tabbed/stacked layout and is
// sharing top border with tabbed titlebar
swayc_t *par = con->parent;
while (par->type != C_WORKSPACE) {
if (par->layout == L_TABBED || par->layout == L_STACKED) {
return con->y == y;
}
con = par;
par = par->parent;
}
return false;
}

686
sway/old/commands.c
View file

@ -1,686 +0,0 @@
#define _XOPEN_SOURCE 700
#include <xkbcommon/xkbcommon.h>
#include <xkbcommon/xkbcommon-names.h>
#include <wlc/wlc.h>
#include <wlc/wlc-render.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <strings.h>
#include <unistd.h>
#include <ctype.h>
#include <wordexp.h>
#include <libgen.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <limits.h>
#include <float.h>
#include <libinput.h>
#include "sway/layout.h"
#include "sway/focus.h"
#include "sway/workspace.h"
#include "sway/commands.h"
#include "sway/container.h"
#include "sway/output.h"
#include "sway/handlers.h"
#include "sway/input_state.h"
#include "sway/criteria.h"
#include "sway/ipc-server.h"
#include "sway/security.h"
#include "sway/input.h"
#include "sway/border.h"
#include "stringop.h"
#include "sway.h"
#include "util.h"
#include "list.h"
#include "log.h"
struct cmd_handler {
char *command;
sway_cmd *handle;
};
int sp_index = 0;
swayc_t *current_container = NULL;
// Returns error object, or NULL if check succeeds.
struct cmd_results *checkarg(int argc, const char *name, enum expected_args type, int val) {
struct cmd_results *error = NULL;
switch (type) {
case EXPECTED_MORE_THAN:
if (argc > val) {
return NULL;
}
error = cmd_results_new(CMD_INVALID, name, "Invalid %s command "
"(expected more than %d argument%s, got %d)",
name, val, (char*[2]){"s", ""}[argc==1], argc);
break;
case EXPECTED_AT_LEAST:
if (argc >= val) {
return NULL;
}
error = cmd_results_new(CMD_INVALID, name, "Invalid %s command "
"(expected at least %d argument%s, got %d)",
name, val, (char*[2]){"s", ""}[argc==1], argc);
break;
case EXPECTED_LESS_THAN:
if (argc < val) {
return NULL;
};
error = cmd_results_new(CMD_INVALID, name, "Invalid %s command "
"(expected less than %d argument%s, got %d)",
name, val, (char*[2]){"s", ""}[argc==1], argc);
break;
case EXPECTED_EQUAL_TO:
if (argc == val) {
return NULL;
};
error = cmd_results_new(CMD_INVALID, name, "Invalid %s command "
"(expected %d arguments, got %d)", name, val, argc);
break;
}
return error;
}
void hide_view_in_scratchpad(swayc_t *sp_view) {
if (sp_view == NULL) {
return;
}
wlc_view_set_mask(sp_view->handle, 0);
sp_view->visible = false;
swayc_t *ws = sp_view->parent;
remove_child(sp_view);
if (swayc_active_workspace() != ws && ws->floating->length == 0 && ws->children->length == 0) {
destroy_workspace(ws);
} else {
arrange_windows(ws, -1, -1);
}
set_focused_container(container_under_pointer());
}
void input_cmd_apply(struct input_config *input) {
int i;
i = list_seq_find(config->input_configs, input_identifier_cmp, input->identifier);
if (i >= 0) {
// merge existing config
struct input_config *ic = config->input_configs->items[i];
merge_input_config(ic, input);
free_input_config(input);
input = ic;
} else {
list_add(config->input_configs, input);
}
current_input_config = input;
if (input->identifier) {
// Try to find the input device and apply configuration now. If
// this is during startup then there will be no container and config
// will be applied during normal "new input" event from wlc.
/* TODO WLR
struct libinput_device *device = NULL;
for (int i = 0; i < input_devices->length; ++i) {
device = input_devices->items[i];
char* dev_identifier = libinput_dev_unique_id(device);
if (!dev_identifier) {
break;
}
int match = dev_identifier && strcmp(dev_identifier, input->identifier) == 0;
free(dev_identifier);
if (match) {
apply_input_config(input, device);
break;
}
}
*/
}
}
void remove_view_from_scratchpad(swayc_t *view) {
int i;
for (i = 0; i < scratchpad->length; i++) {
if (scratchpad->items[i] == view) {
if (sp_index == 0) {
sp_index = scratchpad->length - 1;
} else {
sp_index--;
}
list_del(scratchpad, sp_index);
sp_view = NULL;
}
}
}
/* Keep alphabetized */
static struct cmd_handler handlers[] = {
{ "assign", cmd_assign },
{ "bar", cmd_bar },
{ "bindcode", cmd_bindcode },
{ "bindsym", cmd_bindsym },
{ "border", cmd_border },
{ "client.background", cmd_client_background },
{ "client.focused", cmd_client_focused },
{ "client.focused_inactive", cmd_client_focused_inactive },
{ "client.placeholder", cmd_client_placeholder },
{ "client.unfocused", cmd_client_unfocused },
{ "client.urgent", cmd_client_urgent },
{ "clipboard", cmd_clipboard },
{ "commands", cmd_commands },
{ "debuglog", cmd_debuglog },
{ "default_border", cmd_default_border },
{ "default_floating_border", cmd_default_floating_border },
{ "default_orientation", cmd_orientation },
{ "exec", cmd_exec },
{ "exec_always", cmd_exec_always },
{ "exit", cmd_exit },
{ "floating", cmd_floating },
{ "floating_maximum_size", cmd_floating_maximum_size },
{ "floating_minimum_size", cmd_floating_minimum_size },
{ "floating_modifier", cmd_floating_mod },
{ "floating_scroll", cmd_floating_scroll },
{ "focus", cmd_focus },
{ "focus_follows_mouse", cmd_focus_follows_mouse },
{ "font", cmd_font },
{ "for_window", cmd_for_window },
{ "force_focus_wrapping", cmd_force_focus_wrapping },
{ "fullscreen", cmd_fullscreen },
{ "gaps", cmd_gaps },
{ "hide_edge_borders", cmd_hide_edge_borders },
{ "include", cmd_include },
{ "input", cmd_input },
{ "ipc", cmd_ipc },
{ "kill", cmd_kill },
{ "layout", cmd_layout },
{ "log_colors", cmd_log_colors },
{ "mark", cmd_mark },
{ "mode", cmd_mode },
{ "mouse_warping", cmd_mouse_warping },
{ "move", cmd_move },
{ "new_float", cmd_new_float },
{ "new_window", cmd_new_window },
{ "no_focus", cmd_no_focus },
{ "output", cmd_output },
{ "permit", cmd_permit },
{ "reject", cmd_reject },
{ "reload", cmd_reload },
{ "resize", cmd_resize },
{ "scratchpad", cmd_scratchpad },
{ "seamless_mouse", cmd_seamless_mouse },
{ "set", cmd_set },
{ "show_marks", cmd_show_marks },
{ "smart_gaps", cmd_smart_gaps },
{ "split", cmd_split },
{ "splith", cmd_splith },
{ "splitt", cmd_splitt },
{ "splitv", cmd_splitv },
{ "sticky", cmd_sticky },
{ "unmark", cmd_unmark },
{ "workspace", cmd_workspace },
{ "workspace_auto_back_and_forth", cmd_ws_auto_back_and_forth },
{ "workspace_layout", cmd_workspace_layout },
};
static struct cmd_handler bar_handlers[] = {
{ "activate_button", bar_cmd_activate_button },
{ "binding_mode_indicator", bar_cmd_binding_mode_indicator },
{ "bindsym", bar_cmd_bindsym },
{ "colors", bar_cmd_colors },
{ "context_button", bar_cmd_context_button },
{ "font", bar_cmd_font },
{ "height", bar_cmd_height },
{ "hidden_state", bar_cmd_hidden_state },
{ "icon_theme", bar_cmd_icon_theme },
{ "id", bar_cmd_id },
{ "mode", bar_cmd_mode },
{ "modifier", bar_cmd_modifier },
{ "output", bar_cmd_output },
{ "pango_markup", bar_cmd_pango_markup },
{ "position", bar_cmd_position },
{ "secondary_button", bar_cmd_secondary_button },
{ "separator_symbol", bar_cmd_separator_symbol },
{ "status_command", bar_cmd_status_command },
{ "strip_workspace_numbers", bar_cmd_strip_workspace_numbers },
{ "swaybar_command", bar_cmd_swaybar_command },
{ "tray_output", bar_cmd_tray_output },
{ "tray_padding", bar_cmd_tray_padding },
{ "workspace_buttons", bar_cmd_workspace_buttons },
{ "wrap_scroll", bar_cmd_wrap_scroll },
};
/**
* Check and add color to buffer.
*
* return error object, or NULL if color is valid.
*/
struct cmd_results *add_color(const char *name, char *buffer, const char *color) {
int len = strlen(color);
if (len != 7 && len != 9) {
return cmd_results_new(CMD_INVALID, name, "Invalid color definition %s", color);
}
if (color[0] != '#') {
return cmd_results_new(CMD_INVALID, name, "Invalid color definition %s", color);
}
int i;
for (i = 1; i < len; ++i) {
if (!isxdigit(color[i])) {
return cmd_results_new(CMD_INVALID, name, "Invalid color definition %s", color);
}
}
// copy color to buffer
strncpy(buffer, color, len);
// add default alpha channel if color was defined without it
if (len == 7) {
buffer[7] = 'f';
buffer[8] = 'f';
}
buffer[9] = '\0';
return NULL;
}
static struct cmd_handler input_handlers[] = {
{ "accel_profile", input_cmd_accel_profile },
{ "click_method", input_cmd_click_method },
{ "drag_lock", input_cmd_drag_lock },
{ "dwt", input_cmd_dwt },
{ "events", input_cmd_events },
{ "left_handed", input_cmd_left_handed },
{ "middle_emulation", input_cmd_middle_emulation },
{ "natural_scroll", input_cmd_natural_scroll },
{ "pointer_accel", input_cmd_pointer_accel },
{ "scroll_method", input_cmd_scroll_method },
{ "tap", input_cmd_tap },
};
static struct cmd_handler bar_colors_handlers[] = {
{ "active_workspace", bar_colors_cmd_active_workspace },
{ "background", bar_colors_cmd_background },
{ "binding_mode", bar_colors_cmd_binding_mode },
{ "focused_background", bar_colors_cmd_focused_background },
{ "focused_separator", bar_colors_cmd_focused_separator },
{ "focused_statusline", bar_colors_cmd_focused_statusline },
{ "focused_workspace", bar_colors_cmd_focused_workspace },
{ "inactive_workspace", bar_colors_cmd_inactive_workspace },
{ "separator", bar_colors_cmd_separator },
{ "statusline", bar_colors_cmd_statusline },
{ "urgent_workspace", bar_colors_cmd_urgent_workspace },
};
static struct cmd_handler ipc_handlers[] = {
{ "*", cmd_ipc_cmd },
{ "bar-config", cmd_ipc_cmd },
{ "command", cmd_ipc_cmd },
{ "events", cmd_ipc_events },
{ "inputs", cmd_ipc_cmd },
{ "marks", cmd_ipc_cmd },
{ "outputs", cmd_ipc_cmd },
{ "tree", cmd_ipc_cmd },
{ "workspaces", cmd_ipc_cmd },
};
static struct cmd_handler ipc_event_handlers[] = {
{ "*", cmd_ipc_event_cmd },
{ "binding", cmd_ipc_event_cmd },
{ "input", cmd_ipc_event_cmd },
{ "mode", cmd_ipc_event_cmd },
{ "output", cmd_ipc_event_cmd },
{ "window", cmd_ipc_event_cmd },
{ "workspace", cmd_ipc_event_cmd },
};
static int handler_compare(const void *_a, const void *_b) {
const struct cmd_handler *a = _a;
const struct cmd_handler *b = _b;
return strcasecmp(a->command, b->command);
}
static struct cmd_handler *find_handler(char *line, enum cmd_status block) {
struct cmd_handler d = { .command=line };
struct cmd_handler *res = NULL;
sway_log(L_DEBUG, "find_handler(%s) %d", line, block == CMD_BLOCK_INPUT);
if (block == CMD_BLOCK_BAR) {
res = bsearch(&d, bar_handlers,
sizeof(bar_handlers) / sizeof(struct cmd_handler),
sizeof(struct cmd_handler), handler_compare);
} else if (block == CMD_BLOCK_BAR_COLORS){
res = bsearch(&d, bar_colors_handlers,
sizeof(bar_colors_handlers) / sizeof(struct cmd_handler),
sizeof(struct cmd_handler), handler_compare);
} else if (block == CMD_BLOCK_INPUT) {
res = bsearch(&d, input_handlers,
sizeof(input_handlers) / sizeof(struct cmd_handler),
sizeof(struct cmd_handler), handler_compare);
} else if (block == CMD_BLOCK_IPC) {
res = bsearch(&d, ipc_handlers,
sizeof(ipc_handlers) / sizeof(struct cmd_handler),
sizeof(struct cmd_handler), handler_compare);
} else if (block == CMD_BLOCK_IPC_EVENTS) {
res = bsearch(&d, ipc_event_handlers,
sizeof(ipc_event_handlers) / sizeof(struct cmd_handler),
sizeof(struct cmd_handler), handler_compare);
} else {
res = bsearch(&d, handlers,
sizeof(handlers) / sizeof(struct cmd_handler),
sizeof(struct cmd_handler), handler_compare);
}
return res;
}
struct cmd_results *handle_command(char *_exec, enum command_context context) {
// Even though this function will process multiple commands we will only
// return the last error, if any (for now). (Since we have access to an
// error string we could e.g. concatonate all errors there.)
struct cmd_results *results = NULL;
char *exec = strdup(_exec);
char *head = exec;
char *cmdlist;
char *cmd;
list_t *containers = NULL;
head = exec;
do {
// Extract criteria (valid for this command list only).
if (*head == '[') {
++head;
char *criteria_string = argsep(&head, "]");
if (head) {
++head;
list_t *tokens = create_list();
char *error;
if ((error = extract_crit_tokens(tokens, criteria_string))) {
results = cmd_results_new(CMD_INVALID, criteria_string,
"Can't parse criteria string: %s", error);
free(error);
free(tokens);
goto cleanup;
}
containers = container_for(tokens);
free(tokens);
} else {
if (!results) {
results = cmd_results_new(CMD_INVALID, criteria_string, "Unmatched [");
}
goto cleanup;
}
// Skip leading whitespace
head += strspn(head, whitespace);
}
// Split command list
cmdlist = argsep(&head, ";");
cmdlist += strspn(cmdlist, whitespace);
do {
// Split commands
cmd = argsep(&cmdlist, ",");
cmd += strspn(cmd, whitespace);
if (strcmp(cmd, "") == 0) {
sway_log(L_INFO, "Ignoring empty command.");
continue;
}
sway_log(L_INFO, "Handling command '%s'", cmd);
//TODO better handling of argv
int argc;
char **argv = split_args(cmd, &argc);
if (strcmp(argv[0], "exec") != 0) {
int i;
for (i = 1; i < argc; ++i) {
if (*argv[i] == '\"' || *argv[i] == '\'') {
strip_quotes(argv[i]);
}
}
}
struct cmd_handler *handler = find_handler(argv[0], CMD_BLOCK_END);
if (!handler) {
if (results) {
free_cmd_results(results);
}
results = cmd_results_new(CMD_INVALID, cmd, "Unknown/invalid command");
free_argv(argc, argv);
goto cleanup;
}
if (!(get_command_policy_mask(argv[0]) & context)) {
if (results) {
free_cmd_results(results);
}
results = cmd_results_new(CMD_INVALID, cmd,
"Permission denied for %s via %s", cmd,
command_policy_str(context));
free_argv(argc, argv);
goto cleanup;
}
int i = 0;
do {
if (!containers) {
current_container = get_focused_container(&root_container);
} else if (containers->length == 0) {
if (results) {
free_cmd_results(results);
}
results = cmd_results_new(CMD_FAILURE, argv[0], "No matching container");
goto cleanup;
} else {
current_container = (swayc_t *)containers->items[i];
}
sway_log(L_INFO, "Running on container '%s'", current_container->name);
struct cmd_results *res = handler->handle(argc-1, argv+1);
if (res->status != CMD_SUCCESS) {
free_argv(argc, argv);
if (results) {
free_cmd_results(results);
}
results = res;
goto cleanup;
}
free_cmd_results(res);
++i;
} while(containers && i < containers->length);
free_argv(argc, argv);
} while(cmdlist);
if (containers) {
list_free(containers);
containers = NULL;
}
} while(head);
cleanup:
free(exec);
if (containers) {
free(containers);
}
if (!results) {
results = cmd_results_new(CMD_SUCCESS, NULL, NULL);
}
return results;
}
// this is like handle_command above, except:
// 1) it ignores empty commands (empty lines)
// 2) it does variable substitution
// 3) it doesn't split commands (because the multiple commands are supposed to
// be chained together)
// 4) handle_command handles all state internally while config_command has some
// state handled outside (notably the block mode, in read_config)
struct cmd_results *config_command(char *exec, enum cmd_status block) {
struct cmd_results *results = NULL;
int argc;
char **argv = split_args(exec, &argc);
if (!argc) {
results = cmd_results_new(CMD_SUCCESS, NULL, NULL);
goto cleanup;
}
sway_log(L_INFO, "handling config command '%s'", exec);
// Endblock
if (**argv == '}') {
results = cmd_results_new(CMD_BLOCK_END, NULL, NULL);
goto cleanup;
}
struct cmd_handler *handler = find_handler(argv[0], block);
if (!handler) {
char *input = argv[0] ? argv[0] : "(empty)";
results = cmd_results_new(CMD_INVALID, input, "Unknown/invalid command");
goto cleanup;
}
int i;
// Var replacement, for all but first argument of set
for (i = handler->handle == cmd_set ? 2 : 1; i < argc; ++i) {
argv[i] = do_var_replacement(argv[i]);
unescape_string(argv[i]);
}
/* Strip quotes for first argument.
* TODO This part needs to be handled much better */
if (argc>1 && (*argv[1] == '\"' || *argv[1] == '\'')) {
strip_quotes(argv[1]);
}
if (handler->handle) {
results = handler->handle(argc-1, argv+1);
} else {
results = cmd_results_new(CMD_INVALID, argv[0], "This command is shimmed, but unimplemented");
}
cleanup:
free_argv(argc, argv);
return results;
}
struct cmd_results *config_commands_command(char *exec) {
struct cmd_results *results = NULL;
int argc;
char **argv = split_args(exec, &argc);
if (!argc) {
results = cmd_results_new(CMD_SUCCESS, NULL, NULL);
goto cleanup;
}
// Find handler for the command this is setting a policy for
char *cmd = argv[0];
if (strcmp(cmd, "}") == 0) {
results = cmd_results_new(CMD_BLOCK_END, NULL, NULL);
goto cleanup;
}
struct cmd_handler *handler = find_handler(cmd, CMD_BLOCK_END);
if (!handler && strcmp(cmd, "*") != 0) {
char *input = cmd ? cmd : "(empty)";
results = cmd_results_new(CMD_INVALID, input, "Unknown/invalid command");
goto cleanup;
}
enum command_context context = 0;
struct {
char *name;
enum command_context context;
} context_names[] = {
{ "config", CONTEXT_CONFIG },
{ "binding", CONTEXT_BINDING },
{ "ipc", CONTEXT_IPC },
{ "criteria", CONTEXT_CRITERIA },
{ "all", CONTEXT_ALL },
};
for (int i = 1; i < argc; ++i) {
size_t j;
for (j = 0; j < sizeof(context_names) / sizeof(context_names[0]); ++j) {
if (strcmp(context_names[j].name, argv[i]) == 0) {
break;
}
}
if (j == sizeof(context_names) / sizeof(context_names[0])) {
results = cmd_results_new(CMD_INVALID, cmd,
"Invalid command context %s", argv[i]);
goto cleanup;
}
context |= context_names[j].context;
}
struct command_policy *policy = NULL;
for (int i = 0; i < config->command_policies->length; ++i) {
struct command_policy *p = config->command_policies->items[i];
if (strcmp(p->command, cmd) == 0) {
policy = p;
break;
}
}
if (!policy) {
policy = alloc_command_policy(cmd);
sway_assert(policy, "Unable to allocate security policy");
if (policy) {
list_add(config->command_policies, policy);
}
}
policy->context = context;
sway_log(L_INFO, "Set command policy for %s to %d",
policy->command, policy->context);
results = cmd_results_new(CMD_SUCCESS, NULL, NULL);
cleanup:
free_argv(argc, argv);
return results;
}
struct cmd_results *cmd_results_new(enum cmd_status status, const char* input, const char *format, ...) {
struct cmd_results *results = malloc(sizeof(struct cmd_results));
if (!results) {
sway_log(L_ERROR, "Unable to allocate command results");
return NULL;
}
results->status = status;
if (input) {
results->input = strdup(input); // input is the command name
} else {
results->input = NULL;
}
if (format) {
char *error = malloc(256);
va_list args;
va_start(args, format);
if (error) {
vsnprintf(error, 256, format, args);
}
va_end(args);
results->error = error;
} else {
results->error = NULL;
}
return results;
}
void free_cmd_results(struct cmd_results *results) {
if (results->input) {
free(results->input);
}
if (results->error) {
free(results->error);
}
free(results);
}
const char *cmd_results_to_json(struct cmd_results *results) {
json_object *result_array = json_object_new_array();
json_object *root = json_object_new_object();
json_object_object_add(root, "success", json_object_new_boolean(results->status == CMD_SUCCESS));
if (results->input) {
json_object_object_add(root, "input", json_object_new_string(results->input));
}
if (results->error) {
json_object_object_add(root, "error", json_object_new_string(results->error));
}
json_object_array_add(result_array, root);
const char *json = json_object_to_json_string(result_array);
free(result_array);
free(root);
return json;
}

57
sway/old/commands/assign.c
View file

@ -1,57 +0,0 @@
#define _XOPEN_SOURCE 700
#include <stdio.h>
#include <string.h>
#include "sway/commands.h"
#include "sway/criteria.h"
#include "list.h"
#include "log.h"
struct cmd_results *cmd_assign(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "assign", EXPECTED_AT_LEAST, 2))) {
return error;
}
char *criteria = *argv++;
if (strncmp(*argv, "→", strlen("→")) == 0) {
if (argc < 3) {
return cmd_results_new(CMD_INVALID, "assign", "Missing workspace");
}
argv++;
}
char *movecmd = "move container to workspace ";
int arglen = strlen(movecmd) + strlen(*argv) + 1;
char *cmdlist = calloc(1, arglen);
if (!cmdlist) {
return cmd_results_new(CMD_FAILURE, "assign", "Unable to allocate command list");
}
snprintf(cmdlist, arglen, "%s%s", movecmd, *argv);
struct criteria *crit = malloc(sizeof(struct criteria));
if (!crit) {
free(cmdlist);
return cmd_results_new(CMD_FAILURE, "assign", "Unable to allocate criteria");
}
crit->crit_raw = strdup(criteria);
crit->cmdlist = cmdlist;
crit->tokens = create_list();
char *err_str = extract_crit_tokens(crit->tokens, crit->crit_raw);
if (err_str) {
error = cmd_results_new(CMD_INVALID, "assign", err_str);
free(err_str);
free_criteria(crit);
} else if (crit->tokens->length == 0) {
error = cmd_results_new(CMD_INVALID, "assign", "Found no name/value pairs in criteria");
free_criteria(crit);
} else if (list_seq_find(config->criteria, criteria_cmp, crit) != -1) {
sway_log(L_DEBUG, "assign: Duplicate, skipping.");
free_criteria(crit);
} else {
sway_log(L_DEBUG, "assign: '%s' -> '%s' added", crit->crit_raw, crit->cmdlist);
list_add(config->criteria, crit);
}
return error ? error : cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

59
sway/old/commands/bar.c
View file

@ -1,59 +0,0 @@
#include <stdio.h>
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
#include "sway/config.h"
#include "log.h"
#include "util.h"
struct cmd_results *cmd_bar(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "bar", EXPECTED_AT_LEAST, 1))) {
return error;
}
if (config->reading && strcmp("{", argv[0]) != 0) {
return cmd_results_new(CMD_INVALID, "bar",
"Expected '{' at start of bar config definition.");
}
if (!config->reading) {
if (argc > 1) {
if (strcasecmp("mode", argv[0]) == 0) {
return bar_cmd_mode(argc-1, argv + 1);
}
if (strcasecmp("hidden_state", argv[0]) == 0) {
return bar_cmd_hidden_state(argc-1, argv + 1);
}
}
return cmd_results_new(CMD_FAILURE, "bar", "Can only be used in config file.");
}
// Create new bar with default values
struct bar_config *bar = default_bar_config();
if (!bar) {
return cmd_results_new(CMD_FAILURE, "bar", "Unable to allocate bar state");
}
// set bar id
int i;
for (i = 0; i < config->bars->length; ++i) {
if (bar == config->bars->items[i]) {
const int len = 5 + numlen(i); // "bar-" + i + \0
bar->id = malloc(len * sizeof(char));
if (bar->id) {
snprintf(bar->id, len, "bar-%d", i);
} else {
return cmd_results_new(CMD_FAILURE, "bar", "Unable to allocate bar ID");
}
break;
}
}
// Set current bar
config->current_bar = bar;
sway_log(L_DEBUG, "Configuring bar %s", bar->id);
return cmd_results_new(CMD_BLOCK_BAR, NULL, NULL);
}

26
sway/old/commands/bar/activate_button.c
View file

@ -1,26 +0,0 @@
#include <stdlib.h>
#include "sway/commands.h"
#include "log.h"
struct cmd_results *bar_cmd_activate_button(int argc, char **argv) {
const char *cmd_name = "activate_button";
#ifndef ENABLE_TRAY
return cmd_results_new(CMD_INVALID, cmd_name, "Invalid %s command "
"%s called, but sway was compiled without tray support",
cmd_name, cmd_name);
#else
struct cmd_results *error = NULL;
if ((error = checkarg(argc, cmd_name, EXPECTED_EQUAL_TO, 1))) {
return error;
}
if (!config->current_bar) {
return cmd_results_new(CMD_FAILURE, cmd_name, "No bar defined.");
}
// User should be able to prefix with 0x or whatever they want
config->current_bar->secondary_button = strtoul(argv[0], NULL, 0);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
#endif
}

27
sway/old/commands/bar/binding_mode_indicator.c
View file

@ -1,27 +0,0 @@
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
#include "log.h"
struct cmd_results *bar_cmd_binding_mode_indicator(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "binding_mode_indicator", EXPECTED_EQUAL_TO, 1))) {
return error;
}
if (!config->current_bar) {
return cmd_results_new(CMD_FAILURE, "binding_mode_indicator", "No bar defined.");
}
if (strcasecmp("yes", argv[0]) == 0) {
config->current_bar->binding_mode_indicator = true;
sway_log(L_DEBUG, "Enabling binding mode indicator on bar: %s", config->current_bar->id);
} else if (strcasecmp("no", argv[0]) == 0) {
config->current_bar->binding_mode_indicator = false;
sway_log(L_DEBUG, "Disabling binding mode indicator on bar: %s", config->current_bar->id);
} else {
error = cmd_results_new(CMD_INVALID, "binding_mode_indicator", "Invalid value %s", argv[0]);
return error;
}
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

48
sway/old/commands/bar/bindsym.c
View file

@ -1,48 +0,0 @@
#include <stdlib.h>
#include <string.h>
#include "sway/commands.h"
#include "sway/config.h"
#include "list.h"
#include "log.h"
#include "stringop.h"
struct cmd_results *bar_cmd_bindsym(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "bindsym", EXPECTED_MORE_THAN, 1))) {
return error;
} else if (!config->reading) {
return cmd_results_new(CMD_FAILURE, "bindsym", "Can only be used in config file.");
}
if (!config->current_bar) {
return cmd_results_new(CMD_FAILURE, "bindsym", "No bar defined.");
}
if (strlen(argv[1]) != 7) {
return cmd_results_new(CMD_INVALID, "bindsym", "Invalid mouse binding %s", argv[1]);
}
uint32_t numbutton = (uint32_t)atoi(argv[1] + 6);
if (numbutton < 1 || numbutton > 5 || strncmp(argv[1], "button", 6) != 0) {
return cmd_results_new(CMD_INVALID, "bindsym", "Invalid mouse binding %s", argv[1]);
}
struct sway_mouse_binding *binding = malloc(sizeof(struct sway_mouse_binding));
if (!binding) {
return cmd_results_new(CMD_FAILURE, "bindsym", "Unable to allocate binding");
}
binding->button = numbutton;
binding->command = join_args(argv + 1, argc - 1);
struct bar_config *bar = config->current_bar;
int i = list_seq_find(bar->bindings, sway_mouse_binding_cmp_buttons, binding);
if (i > -1) {
sway_log(L_DEBUG, "bindsym - '%s' for swaybar already exists, overwriting", argv[0]);
struct sway_mouse_binding *dup = bar->bindings->items[i];
free_sway_mouse_binding(dup);
list_del(bar->bindings, i);
}
list_add(bar->bindings, binding);
list_qsort(bar->bindings, sway_mouse_binding_cmp_qsort);
sway_log(L_DEBUG, "bindsym - Bound %s to command %s when clicking swaybar", argv[0], binding->command);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

129
sway/old/commands/bar/colors.c
View file

@ -1,129 +0,0 @@
#include <string.h>
#include "sway/commands.h"
static struct cmd_results *parse_single_color(char **color, const char *cmd_name, int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, cmd_name, EXPECTED_EQUAL_TO, 1))) {
return error;
}
if (!*color) {
*color = malloc(10);
if (!*color) {
return cmd_results_new(CMD_FAILURE, cmd_name, "Unable to allocate color");
}
}
error = add_color(cmd_name, *color, argv[0]);
if (error) {
return error;
}
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}
static struct cmd_results *parse_three_colors(char ***colors, const char *cmd_name, int argc, char **argv) {
struct cmd_results *error = NULL;
if (argc != 3) {
return cmd_results_new(CMD_INVALID, cmd_name, "Requires exactly three color values");
}
int i;
for (i = 0; i < 3; i++) {
if (!*colors[i]) {
*(colors[i]) = malloc(10);
if (!*(colors[i])) {
return cmd_results_new(CMD_FAILURE, cmd_name, "Unable to allocate color");
}
}
error = add_color(cmd_name, *(colors[i]), argv[i]);
if (error) {
return error;
}
}
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}
struct cmd_results *bar_cmd_colors(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "colors", EXPECTED_EQUAL_TO, 1))) {
return error;
}
if (strcmp("{", argv[0]) != 0) {
return cmd_results_new(CMD_INVALID, "colors",
"Expected '{' at the start of colors config definition.");
}
return cmd_results_new(CMD_BLOCK_BAR_COLORS, NULL, NULL);
}
struct cmd_results *bar_colors_cmd_active_workspace(int argc, char **argv) {
char **colors[3] = {
&(config->current_bar->colors.active_workspace_border),
&(config->current_bar->colors.active_workspace_bg),
&(config->current_bar->colors.active_workspace_text)
};
return parse_three_colors(colors, "active_workspace", argc, argv);
}
struct cmd_results *bar_colors_cmd_background(int argc, char **argv) {
return parse_single_color(&(config->current_bar->colors.background), "background", argc, argv);
}
struct cmd_results *bar_colors_cmd_focused_background(int argc, char **argv) {
return parse_single_color(&(config->current_bar->colors.focused_background), "focused_background", argc, argv);
}
struct cmd_results *bar_colors_cmd_binding_mode(int argc, char **argv) {
char **colors[3] = {
&(config->current_bar->colors.binding_mode_border),
&(config->current_bar->colors.binding_mode_bg),
&(config->current_bar->colors.binding_mode_text)
};
return parse_three_colors(colors, "binding_mode", argc, argv);
}
struct cmd_results *bar_colors_cmd_focused_workspace(int argc, char **argv) {
char **colors[3] = {
&(config->current_bar->colors.focused_workspace_border),
&(config->current_bar->colors.focused_workspace_bg),
&(config->current_bar->colors.focused_workspace_text)
};
return parse_three_colors(colors, "focused_workspace", argc, argv);
}
struct cmd_results *bar_colors_cmd_inactive_workspace(int argc, char **argv) {
char **colors[3] = {
&(config->current_bar->colors.inactive_workspace_border),
&(config->current_bar->colors.inactive_workspace_bg),
&(config->current_bar->colors.inactive_workspace_text)
};
return parse_three_colors(colors, "inactive_workspace", argc, argv);
}
struct cmd_results *bar_colors_cmd_separator(int argc, char **argv) {
return parse_single_color(&(config->current_bar->colors.separator), "separator", argc, argv);
}
struct cmd_results *bar_colors_cmd_focused_separator(int argc, char **argv) {
return parse_single_color(&(config->current_bar->colors.focused_separator), "focused_separator", argc, argv);
}
struct cmd_results *bar_colors_cmd_statusline(int argc, char **argv) {
return parse_single_color(&(config->current_bar->colors.statusline), "statusline", argc, argv);
}
struct cmd_results *bar_colors_cmd_focused_statusline(int argc, char **argv) {
return parse_single_color(&(config->current_bar->colors.focused_separator), "focused_separator", argc, argv);
}
struct cmd_results *bar_colors_cmd_urgent_workspace(int argc, char **argv) {
char **colors[3] = {
&(config->current_bar->colors.urgent_workspace_border),
&(config->current_bar->colors.urgent_workspace_bg),
&(config->current_bar->colors.urgent_workspace_text)
};
return parse_three_colors(colors, "urgent_workspace", argc, argv);
}

26
sway/old/commands/bar/context_button.c
View file

@ -1,26 +0,0 @@
#include <stdlib.h>
#include "sway/commands.h"
#include "log.h"
struct cmd_results *bar_cmd_context_button(int argc, char **argv) {
const char *cmd_name = "context_button";
#ifndef ENABLE_TRAY
return cmd_results_new(CMD_INVALID, cmd_name, "Invalid %s command "
"%s called, but sway was compiled without tray support",
cmd_name, cmd_name);
#else
struct cmd_results *error = NULL;
if ((error = checkarg(argc, cmd_name, EXPECTED_EQUAL_TO, 1))) {
return error;
}
if (!config->current_bar) {
return cmd_results_new(CMD_FAILURE, cmd_name, "No bar defined.");
}
// User should be able to prefix with 0x or whatever they want
config->current_bar->context_button = strtoul(argv[0], NULL, 0);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
#endif
}

26
sway/old/commands/bar/font.c
View file

@ -1,26 +0,0 @@
#include <string.h>
#include "sway/commands.h"
#include "log.h"
#include "stringop.h"
struct cmd_results *bar_cmd_font(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "font", EXPECTED_AT_LEAST, 1))) {
return error;
}
if (!config->current_bar) {
return cmd_results_new(CMD_FAILURE, "font", "No bar defined.");
}
char *font = join_args(argv, argc);
free(config->current_bar->font);
if (strlen(font) > 6 && strncmp("pango:", font, 6) == 0) {
config->current_bar->font = font;
} else {
config->current_bar->font = font;
}
sway_log(L_DEBUG, "Settings font '%s' for bar: %s", config->current_bar->font, config->current_bar->id);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

21
sway/old/commands/bar/height.c
View file

@ -1,21 +0,0 @@
#include <stdlib.h>
#include <string.h>
#include "sway/commands.h"
#include "log.h"
struct cmd_results *bar_cmd_height(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "height", EXPECTED_EQUAL_TO, 1))) {
return error;
}
int height = atoi(argv[0]);
if (height < 0) {
return cmd_results_new(CMD_INVALID, "height",
"Invalid height value: %s", argv[0]);
}
config->current_bar->height = height;
sway_log(L_DEBUG, "Setting bar height to %d on bar: %s", height, config->current_bar->id);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

79
sway/old/commands/bar/hidden_state.c
View file

@ -1,79 +0,0 @@
#define _XOPEN_SOURCE 500
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
#include "sway/config.h"
#include "sway/ipc-server.h"
#include "log.h"
static struct cmd_results *bar_set_hidden_state(struct bar_config *bar, const char *hidden_state) {
char *old_state = bar->hidden_state;
if (strcasecmp("toggle", hidden_state) == 0 && !config->reading) {
if (strcasecmp("hide", bar->hidden_state) == 0) {
bar->hidden_state = strdup("show");
} else if (strcasecmp("show", bar->hidden_state) == 0) {
bar->hidden_state = strdup("hide");
}
} else if (strcasecmp("hide", hidden_state) == 0) {
bar->hidden_state = strdup("hide");
} else if (strcasecmp("show", hidden_state) == 0) {
bar->hidden_state = strdup("show");
} else {
return cmd_results_new(CMD_INVALID, "hidden_state", "Invalid value %s", hidden_state);
}
if (strcmp(old_state, bar->hidden_state) != 0) {
if (!config->reading) {
ipc_event_barconfig_update(bar);
}
sway_log(L_DEBUG, "Setting hidden_state: '%s' for bar: %s", bar->hidden_state, bar->id);
}
// free old mode
free(old_state);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}
struct cmd_results *bar_cmd_hidden_state(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "hidden_state", EXPECTED_AT_LEAST, 1))) {
return error;
}
if ((error = checkarg(argc, "hidden_state", EXPECTED_LESS_THAN, 3))) {
return error;
}
if (config->reading && argc > 1) {
return cmd_results_new(CMD_INVALID, "hidden_state", "Unexpected value %s in config mode", argv[1]);
}
const char *state = argv[0];
if (config->reading) {
return bar_set_hidden_state(config->current_bar, state);
}
const char *id = NULL;
if (argc == 2) {
id = argv[1];
}
int i;
struct bar_config *bar;
for (i = 0; i < config->bars->length; ++i) {
bar = config->bars->items[i];
if (id && strcmp(id, bar->id) == 0) {
return bar_set_hidden_state(bar, state);
}
error = bar_set_hidden_state(bar, state);
if (error) {
return error;
}
}
// active bar modifiers might have changed.
update_active_bar_modifiers();
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

25
sway/old/commands/bar/icon_theme.c
View file

@ -1,25 +0,0 @@
#define _XOPEN_SOURCE 500
#include <string.h>
#include "sway/commands.h"
struct cmd_results *bar_cmd_icon_theme(int argc, char **argv) {
const char *cmd_name = "tray_output";
#ifndef ENABLE_TRAY
return cmd_results_new(CMD_INVALID, cmd_name, "Invalid %s command "
"%s called, but sway was compiled without tray support",
cmd_name, cmd_name);
#else
struct cmd_results *error = NULL;
if ((error = checkarg(argc, cmd_name, EXPECTED_EQUAL_TO, 1))) {
return error;
}
if (!config->current_bar) {
return cmd_results_new(CMD_FAILURE, cmd_name, "No bar defined.");
}
config->current_bar->icon_theme = strdup(argv[0]);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
#endif
}

33
sway/old/commands/bar/id.c
View file

@ -1,33 +0,0 @@
#define _XOPEN_SOURCE 500
#include <string.h>
#include "sway/commands.h"
#include "log.h"
struct cmd_results *bar_cmd_id(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "id", EXPECTED_EQUAL_TO, 1))) {
return error;
}
const char *name = argv[0];
const char *oldname = config->current_bar->id;
// check if id is used by a previously defined bar
int i;
for (i = 0; i < config->bars->length; ++i) {
struct bar_config *find = config->bars->items[i];
if (strcmp(name, find->id) == 0 && config->current_bar != find) {
return cmd_results_new(CMD_FAILURE, "id",
"Id '%s' already defined for another bar. Id unchanged (%s).",
name, oldname);
}
}
sway_log(L_DEBUG, "Renaming bar: '%s' to '%s'", oldname, name);
// free old bar id
free(config->current_bar->id);
config->current_bar->id = strdup(name);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

81
sway/old/commands/bar/mode.c
View file

@ -1,81 +0,0 @@
#define _XOPEN_SOURCE 500
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
#include "sway/config.h"
#include "sway/ipc-server.h"
#include "log.h"
static struct cmd_results *bar_set_mode(struct bar_config *bar, const char *mode) {
char *old_mode = bar->mode;
if (strcasecmp("toggle", mode) == 0 && !config->reading) {
if (strcasecmp("dock", bar->mode) == 0) {
bar->mode = strdup("hide");
} else if (strcasecmp("hide", bar->mode) == 0) {
bar->mode = strdup("dock");
}
} else if (strcasecmp("dock", mode) == 0) {
bar->mode = strdup("dock");
} else if (strcasecmp("hide", mode) == 0) {
bar->mode = strdup("hide");
} else if (strcasecmp("invisible", mode) == 0) {
bar->mode = strdup("invisible");
} else {
return cmd_results_new(CMD_INVALID, "mode", "Invalid value %s", mode);
}
if (strcmp(old_mode, bar->mode) != 0) {
if (!config->reading) {
ipc_event_barconfig_update(bar);
// active bar modifiers might have changed.
update_active_bar_modifiers();
}
sway_log(L_DEBUG, "Setting mode: '%s' for bar: %s", bar->mode, bar->id);
}
// free old mode
free(old_mode);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}
struct cmd_results *bar_cmd_mode(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "mode", EXPECTED_AT_LEAST, 1))) {
return error;
}
if ((error = checkarg(argc, "mode", EXPECTED_LESS_THAN, 3))) {
return error;
}
if (config->reading && argc > 1) {
return cmd_results_new(CMD_INVALID, "mode", "Unexpected value %s in config mode", argv[1]);
}
const char *mode = argv[0];
if (config->reading) {
return bar_set_mode(config->current_bar, mode);
}
const char *id = NULL;
if (argc == 2) {
id = argv[1];
}
int i;
struct bar_config *bar;
for (i = 0; i < config->bars->length; ++i) {
bar = config->bars->items[i];
if (id && strcmp(id, bar->id) == 0) {
return bar_set_mode(bar, mode);
}
error = bar_set_mode(bar, mode);
if (error) {
return error;
}
}
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

35
sway/old/commands/bar/modifier.c
View file

@ -1,35 +0,0 @@
#include <string.h>
#include "sway/commands.h"
#include "log.h"
#include "stringop.h"
#include "util.h"
struct cmd_results *bar_cmd_modifier(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "modifier", EXPECTED_EQUAL_TO, 1))) {
return error;
}
if (!config->current_bar) {
return cmd_results_new(CMD_FAILURE, "modifier", "No bar defined.");
}
uint32_t mod = 0;
list_t *split = split_string(argv[0], "+");
for (int i = 0; i < split->length; ++i) {
uint32_t tmp_mod;
if ((tmp_mod = get_modifier_mask_by_name(split->items[i])) > 0) {
mod |= tmp_mod;
continue;
} else {
free_flat_list(split);
return cmd_results_new(CMD_INVALID, "modifier", "Unknown modifier '%s'", split->items[i]);
}
}
free_flat_list(split);
config->current_bar->modifier = mod;
sway_log(L_DEBUG, "Show/Hide the bar when pressing '%s' in hide mode.", argv[0]);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

50
sway/old/commands/bar/output.c
View file

@ -1,50 +0,0 @@
#define _XOPEN_SOURCE 500
#include <string.h>
#include "sway/commands.h"
#include "list.h"
#include "log.h"
struct cmd_results *bar_cmd_output(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "output", EXPECTED_EQUAL_TO, 1))) {
return error;
}
if (!config->current_bar) {
return cmd_results_new(CMD_FAILURE, "output", "No bar defined.");
}
const char *output = argv[0];
list_t *outputs = config->current_bar->outputs;
if (!outputs) {
outputs = create_list();
config->current_bar->outputs = outputs;
}
int i;
int add_output = 1;
if (strcmp("*", output) == 0) {
// remove all previous defined outputs and replace with '*'
for (i = 0; i < outputs->length; ++i) {
free(outputs->items[i]);
list_del(outputs, i);
}
} else {
// only add output if not already defined with either the same
// name or as '*'
for (i = 0; i < outputs->length; ++i) {
const char *find = outputs->items[i];
if (strcmp("*", find) == 0 || strcmp(output, find) == 0) {
add_output = 0;
break;
}
}
}
if (add_output) {
list_add(outputs, strdup(output));
sway_log(L_DEBUG, "Adding bar: '%s' to output '%s'", config->current_bar->id, output);
}
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

27
sway/old/commands/bar/pango_markup.c
View file

@ -1,27 +0,0 @@
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
#include "log.h"
struct cmd_results *bar_cmd_pango_markup(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "pango_markup", EXPECTED_EQUAL_TO, 1))) {
return error;
}
if (!config->current_bar) {
return cmd_results_new(CMD_FAILURE, "pango_markup", "No bar defined.");
}
if (strcasecmp("enabled", argv[0]) == 0) {
config->current_bar->pango_markup = true;
sway_log(L_DEBUG, "Enabling pango markup for bar: %s", config->current_bar->id);
} else if (strcasecmp("disabled", argv[0]) == 0) {
config->current_bar->pango_markup = false;
sway_log(L_DEBUG, "Disabling pango markup for bar: %s", config->current_bar->id);
} else {
error = cmd_results_new(CMD_INVALID, "pango_markup", "Invalid value %s", argv[0]);
return error;
}
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

33
sway/old/commands/bar/position.c
View file

@ -1,33 +0,0 @@
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
#include "log.h"
struct cmd_results *bar_cmd_position(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "position", EXPECTED_EQUAL_TO, 1))) {
return error;
}
if (!config->current_bar) {
return cmd_results_new(CMD_FAILURE, "position", "No bar defined.");
}
if (strcasecmp("top", argv[0]) == 0) {
config->current_bar->position = DESKTOP_SHELL_PANEL_POSITION_TOP;
} else if (strcasecmp("bottom", argv[0]) == 0) {
config->current_bar->position = DESKTOP_SHELL_PANEL_POSITION_BOTTOM;
} else if (strcasecmp("left", argv[0]) == 0) {
sway_log(L_INFO, "Warning: swaybar currently only supports top and bottom positioning. YMMV");
config->current_bar->position = DESKTOP_SHELL_PANEL_POSITION_LEFT;
} else if (strcasecmp("right", argv[0]) == 0) {
sway_log(L_INFO, "Warning: swaybar currently only supports top and bottom positioning. YMMV");
config->current_bar->position = DESKTOP_SHELL_PANEL_POSITION_RIGHT;
} else {
error = cmd_results_new(CMD_INVALID, "position", "Invalid value %s", argv[0]);
return error;
}
sway_log(L_DEBUG, "Setting bar position '%s' for bar: %s", argv[0], config->current_bar->id);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

26
sway/old/commands/bar/secondary_button.c
View file

@ -1,26 +0,0 @@
#include <stdlib.h>
#include "sway/commands.h"
#include "log.h"
struct cmd_results *bar_cmd_secondary_button(int argc, char **argv) {
const char *cmd_name = "secondary_button";
#ifndef ENABLE_TRAY
return cmd_results_new(CMD_INVALID, cmd_name, "Invalid %s command "
"%s called, but sway was compiled without tray support",
cmd_name, cmd_name);
#else
struct cmd_results *error = NULL;
if ((error = checkarg(argc, cmd_name, EXPECTED_EQUAL_TO, 1))) {
return error;
}
if (!config->current_bar) {
return cmd_results_new(CMD_FAILURE, cmd_name, "No bar defined.");
}
// User should be able to prefix with 0x or whatever they want
config->current_bar->secondary_button = strtoul(argv[0], NULL, 0);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
#endif
}

21
sway/old/commands/bar/separator_symbol.c
View file

@ -1,21 +0,0 @@
#define _XOPEN_SOURCE 500
#include <string.h>
#include "sway/commands.h"
#include "log.h"
struct cmd_results *bar_cmd_separator_symbol(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "separator_symbol", EXPECTED_EQUAL_TO, 1))) {
return error;
}
if (!config->current_bar) {
return cmd_results_new(CMD_FAILURE, "separator_symbol", "No bar defined.");
}
free(config->current_bar->separator_symbol);
config->current_bar->separator_symbol = strdup(argv[0]);
sway_log(L_DEBUG, "Settings separator_symbol '%s' for bar: %s", config->current_bar->separator_symbol, config->current_bar->id);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

21
sway/old/commands/bar/status_command.c
View file

@ -1,21 +0,0 @@
#include <string.h>
#include "sway/commands.h"
#include "log.h"
#include "stringop.h"
struct cmd_results *bar_cmd_status_command(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "status_command", EXPECTED_AT_LEAST, 1))) {
return error;
}
if (!config->current_bar) {
return cmd_results_new(CMD_FAILURE, "status_command", "No bar defined.");
}
free(config->current_bar->status_command);
config->current_bar->status_command = join_args(argv, argc);
sway_log(L_DEBUG, "Feeding bar with status command: %s", config->current_bar->status_command);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

27
sway/old/commands/bar/strip_workspace_numbers.c
View file

@ -1,27 +0,0 @@
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
#include "log.h"
struct cmd_results *bar_cmd_strip_workspace_numbers(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "strip_workspace_numbers", EXPECTED_EQUAL_TO, 1))) {
return error;
}
if (!config->current_bar) {
return cmd_results_new(CMD_FAILURE, "strip_workspace_numbers", "No bar defined.");
}
if (strcasecmp("yes", argv[0]) == 0) {
config->current_bar->strip_workspace_numbers = true;
sway_log(L_DEBUG, "Stripping workspace numbers on bar: %s", config->current_bar->id);
} else if (strcasecmp("no", argv[0]) == 0) {
config->current_bar->strip_workspace_numbers = false;
sway_log(L_DEBUG, "Enabling workspace numbers on bar: %s", config->current_bar->id);
} else {
error = cmd_results_new(CMD_INVALID, "strip_workspace_numbers", "Invalid value %s", argv[0]);
return error;
}
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

21
sway/old/commands/bar/swaybar_command.c
View file

@ -1,21 +0,0 @@
#include <string.h>
#include "sway/commands.h"
#include "log.h"
#include "stringop.h"
struct cmd_results *bar_cmd_swaybar_command(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "swaybar_command", EXPECTED_AT_LEAST, 1))) {
return error;
}
if (!config->current_bar) {
return cmd_results_new(CMD_FAILURE, "swaybar_command", "No bar defined.");
}
free(config->current_bar->swaybar_command);
config->current_bar->swaybar_command = join_args(argv, argc);
sway_log(L_DEBUG, "Using custom swaybar command: %s", config->current_bar->swaybar_command);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

29
sway/old/commands/bar/tray_output.c
View file

@ -1,29 +0,0 @@
#define _XOPEN_SOURCE 500
#include <string.h>
#include "sway/commands.h"
struct cmd_results *bar_cmd_tray_output(int argc, char **argv) {
const char *cmd_name = "tray_output";
#ifndef ENABLE_TRAY
return cmd_results_new(CMD_INVALID, cmd_name, "Invalid %s command "
"%s called, but sway was compiled without tray support",
cmd_name, cmd_name);
#else
struct cmd_results *error = NULL;
if ((error = checkarg(argc, cmd_name, EXPECTED_EQUAL_TO, 1))) {
return error;
}
if (!config->current_bar) {
return cmd_results_new(CMD_FAILURE, cmd_name, "No bar defined.");
}
if (strcmp(argv[0], "all") == 0) {
// Default behaviour
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}
config->current_bar->tray_output = strdup(argv[0]);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
#endif
}

34
sway/old/commands/bar/tray_padding.c
View file

@ -1,34 +0,0 @@
#include <stdlib.h>
#include <strings.h>
#include "sway/commands.h"
#include "log.h"
struct cmd_results *bar_cmd_tray_padding(int argc, char **argv) {
const char *cmd_name = "tray_padding";
#ifndef ENABLE_TRAY
return cmd_results_new(CMD_INVALID, cmd_name, "Invalid %s command"
"%s called, but sway was compiled without tray support",
cmd_name, cmd_name);
#else
struct cmd_results *error = NULL;
if ((error = checkarg(argc, cmd_name, EXPECTED_AT_LEAST, 1))) {
return error;
}
if (!config->current_bar) {
return cmd_results_new(CMD_FAILURE, cmd_name, "No bar defined.");
}
if (argc == 1 || (argc == 2 && strcasecmp("px", argv[1]) == 0)) {
char *inv;
uint32_t padding = strtoul(argv[0], &inv, 10);
if (*inv == '\0' || strcasecmp(inv, "px") == 0) {
config->current_bar->tray_padding = padding;
sway_log(L_DEBUG, "Enabling tray padding of %d px on bar: %s", padding, config->current_bar->id);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}
}
return cmd_results_new(CMD_FAILURE, cmd_name,
"Expected 'tray_padding <padding>[px]'");
#endif
}

27
sway/old/commands/bar/workspace_buttons.c
View file

@ -1,27 +0,0 @@
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
#include "log.h"
struct cmd_results *bar_cmd_workspace_buttons(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "workspace_buttons", EXPECTED_EQUAL_TO, 1))) {
return error;
}
if (!config->current_bar) {
return cmd_results_new(CMD_FAILURE, "workspace_buttons", "No bar defined.");
}
if (strcasecmp("yes", argv[0]) == 0) {
config->current_bar->workspace_buttons = true;
sway_log(L_DEBUG, "Enabling workspace buttons on bar: %s", config->current_bar->id);
} else if (strcasecmp("no", argv[0]) == 0) {
config->current_bar->workspace_buttons = false;
sway_log(L_DEBUG, "Disabling workspace buttons on bar: %s", config->current_bar->id);
} else {
error = cmd_results_new(CMD_INVALID, "workspace_buttons", "Invalid value %s", argv[0]);
return error;
}
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

27
sway/old/commands/bar/wrap_scroll.c
View file

@ -1,27 +0,0 @@
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
#include "log.h"
struct cmd_results *bar_cmd_wrap_scroll(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "wrap_scroll", EXPECTED_EQUAL_TO, 1))) {
return error;
}
if (!config->current_bar) {
return cmd_results_new(CMD_FAILURE, "wrap_scroll", "No bar defined.");
}
if (strcasecmp("yes", argv[0]) == 0) {
config->current_bar->wrap_scroll = true;
sway_log(L_DEBUG, "Enabling wrap scroll on bar: %s", config->current_bar->id);
} else if (strcasecmp("no", argv[0]) == 0) {
config->current_bar->wrap_scroll = false;
sway_log(L_DEBUG, "Disabling wrap scroll on bar: %s", config->current_bar->id);
} else {
error = cmd_results_new(CMD_INVALID, "wrap_scroll", "Invalid value %s", argv[0]);
return error;
}
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

170
sway/old/commands/bind.c
View file

@ -1,170 +0,0 @@
#include <xkbcommon/xkbcommon.h>
#include <xkbcommon/xkbcommon-names.h>
#include <strings.h>
#include "sway/commands.h"
#include "sway/config.h"
#include "sway/input_state.h"
#include "list.h"
#include "log.h"
#include "stringop.h"
#include "util.h"
int binding_order = 0;
struct cmd_results *cmd_bindsym(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "bindsym", EXPECTED_MORE_THAN, 1))) {
return error;
}
struct sway_binding *binding = malloc(sizeof(struct sway_binding));
if (!binding) {
return cmd_results_new(CMD_FAILURE, "bindsym",
"Unable to allocate binding");
}
binding->keys = create_list();
binding->modifiers = 0;
binding->release = false;
binding->bindcode = false;
// Handle --release
if (strcmp("--release", argv[0]) == 0) {
if (argc >= 3) {
binding->release = true;
argv++;
argc--;
} else {
free_sway_binding(binding);
return cmd_results_new(CMD_FAILURE, "bindsym",
"Invalid bindsym command "
"(expected more than 2 arguments, got %d)", argc);
}
}
binding->command = join_args(argv + 1, argc - 1);
list_t *split = split_string(argv[0], "+");
for (int i = 0; i < split->length; ++i) {
// Check for a modifier key
uint32_t mod;
if ((mod = get_modifier_mask_by_name(split->items[i])) > 0) {
binding->modifiers |= mod;
continue;
}
// Check for xkb key
xkb_keysym_t sym = xkb_keysym_from_name(split->items[i],
XKB_KEYSYM_CASE_INSENSITIVE);
// Check for mouse binding
if (strncasecmp(split->items[i], "button", strlen("button")) == 0 &&
strlen(split->items[i]) == strlen("button0")) {
sym = ((char *)split->items[i])[strlen("button")] - '1' + M_LEFT_CLICK;
}
if (!sym) {
struct cmd_results *ret = cmd_results_new(CMD_INVALID, "bindsym",
"Unknown key '%s'", (char *)split->items[i]);
free_sway_binding(binding);
free_flat_list(split);
return ret;
}
xkb_keysym_t *key = malloc(sizeof(xkb_keysym_t));
if (!key) {
free_sway_binding(binding);
free_flat_list(split);
return cmd_results_new(CMD_FAILURE, "bindsym",
"Unable to allocate binding");
}
*key = sym;
list_add(binding->keys, key);
}
free_flat_list(split);
struct sway_mode *mode = config->current_mode;
int i = list_seq_find(mode->bindings, sway_binding_cmp_keys, binding);
if (i > -1) {
sway_log(L_DEBUG, "bindsym - '%s' already exists, overwriting", argv[0]);
struct sway_binding *dup = mode->bindings->items[i];
free_sway_binding(dup);
list_del(mode->bindings, i);
}
binding->order = binding_order++;
list_add(mode->bindings, binding);
list_qsort(mode->bindings, sway_binding_cmp_qsort);
sway_log(L_DEBUG, "bindsym - Bound %s to command %s", argv[0], binding->command);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}
struct cmd_results *cmd_bindcode(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "bindcode", EXPECTED_MORE_THAN, 1))) {
return error;
}
struct sway_binding *binding = malloc(sizeof(struct sway_binding));
if (!binding) {
return cmd_results_new(CMD_FAILURE, "bindsym",
"Unable to allocate binding");
}
binding->keys = create_list();
binding->modifiers = 0;
binding->release = false;
binding->bindcode = true;
// Handle --release
if (strcmp("--release", argv[0]) == 0) {
if (argc >= 3) {
binding->release = true;
argv++;
argc--;
} else {
free_sway_binding(binding);
return cmd_results_new(CMD_FAILURE, "bindcode",
"Invalid bindcode command "
"(expected more than 2 arguments, got %d)", argc);
}
}
binding->command = join_args(argv + 1, argc - 1);
list_t *split = split_string(argv[0], "+");
for (int i = 0; i < split->length; ++i) {
// Check for a modifier key
uint32_t mod;
if ((mod = get_modifier_mask_by_name(split->items[i])) > 0) {
binding->modifiers |= mod;
continue;
}
// parse keycode
xkb_keycode_t keycode = (int)strtol(split->items[i], NULL, 10);
if (!xkb_keycode_is_legal_ext(keycode)) {
error = cmd_results_new(CMD_INVALID, "bindcode", "Invalid keycode '%s'", (char *)split->items[i]);
free_sway_binding(binding);
list_free(split);
return error;
}
xkb_keycode_t *key = malloc(sizeof(xkb_keycode_t));
*key = keycode - 8;
list_add(binding->keys, key);
}
free_flat_list(split);
struct sway_mode *mode = config->current_mode;
int i = list_seq_find(mode->bindings, sway_binding_cmp_keys, binding);
if (i > -1) {
struct sway_binding *dup = mode->bindings->items[i];
if (dup->bindcode) {
sway_log(L_DEBUG, "bindcode - '%s' already exists, overwriting", argv[0]);
} else {
sway_log(L_DEBUG, "bindcode - '%s' already exists as bindsym, overwriting", argv[0]);
}
free_sway_binding(dup);
list_del(mode->bindings, i);
}
binding->order = binding_order++;
list_add(mode->bindings, binding);
list_qsort(mode->bindings, sway_binding_cmp_qsort);
sway_log(L_DEBUG, "bindcode - Bound %s to command %s", argv[0], binding->command);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

65
sway/old/commands/border.c
View file

@ -1,65 +0,0 @@
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
#include "sway/container.h"
#include "sway/focus.h"
struct cmd_results *cmd_border(int argc, char **argv) {
struct cmd_results *error = NULL;
if (!config->active) {
return cmd_results_new(CMD_FAILURE, "border", "Can only be used when sway is running.");
}
if ((error = checkarg(argc, "border", EXPECTED_AT_LEAST, 1))) {
return error;
}
if (argc > 2) {
return cmd_results_new(CMD_INVALID, "border",
"Expected 'border <normal|pixel|none|toggle> [<n>]");
}
swayc_t *view = current_container;
enum swayc_border_types border = view->border_type;
int thickness = view->border_thickness;
if (strcasecmp(argv[0], "none") == 0) {
border = B_NONE;
} else if (strcasecmp(argv[0], "normal") == 0) {
border = B_NORMAL;
} else if (strcasecmp(argv[0], "pixel") == 0) {
border = B_PIXEL;
} else if (strcasecmp(argv[0], "toggle") == 0) {
switch (border) {
case B_NONE:
border = B_PIXEL;
break;
case B_NORMAL:
border = B_NONE;
break;
case B_PIXEL:
border = B_NORMAL;
break;
}
} else {
return cmd_results_new(CMD_INVALID, "border",
"Expected 'border <normal|pixel|none|toggle>");
}
if (argc == 2 && (border == B_NORMAL || border == B_PIXEL)) {
thickness = (int)strtol(argv[1], NULL, 10);
if (errno == ERANGE || thickness < 0) {
errno = 0;
return cmd_results_new(CMD_INVALID, "border", "Number is out of range.");
}
}
if (view) {
view->border_type = border;
view->border_thickness = thickness;
update_geometry(view);
}
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

72
sway/old/commands/client.c
View file

@ -1,72 +0,0 @@
#include <stdlib.h>
#include <string.h>
#include "sway/commands.h"
static struct cmd_results *parse_border_color(struct border_colors *border_colors, const char *cmd_name, int argc, char **argv) {
struct cmd_results *error = NULL;
if (argc < 3 || argc > 5) {
return cmd_results_new(CMD_INVALID, cmd_name, "Requires between three and five color values");
}
uint32_t *colors[5] = {
&border_colors->border,
&border_colors->background,
&border_colors->text,
&border_colors->indicator,
&border_colors->child_border
};
int i;
for (i = 0; i < argc; i++) {
char buffer[10];
error = add_color(cmd_name, buffer, argv[i]);
if (error) {
return error;
}
*colors[i] = strtoul(buffer + 1, NULL, 16);
}
if (argc < 5) {
border_colors->child_border = border_colors->background;
}
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}
struct cmd_results *cmd_client_focused(int argc, char **argv) {
return parse_border_color(&config->border_colors.focused, "client.focused", argc, argv);
}
struct cmd_results *cmd_client_focused_inactive(int argc, char **argv) {
return parse_border_color(&config->border_colors.focused_inactive, "client.focused_inactive", argc, argv);
}
struct cmd_results *cmd_client_unfocused(int argc, char **argv) {
return parse_border_color(&config->border_colors.unfocused, "client.unfocused", argc, argv);
}
struct cmd_results *cmd_client_urgent(int argc, char **argv) {
return parse_border_color(&config->border_colors.urgent, "client.urgent", argc, argv);
}
struct cmd_results *cmd_client_placeholder(int argc, char **argv) {
return parse_border_color(&config->border_colors.placeholder, "client.placeholder", argc, argv);
}
struct cmd_results *cmd_client_background(int argc, char **argv) {
char buffer[10];
struct cmd_results *error = NULL;
uint32_t background;
if (argc != 1) {
return cmd_results_new(CMD_INVALID, "client.background", "Requires exactly one color value");
}
error = add_color("client.background", buffer, argv[0]);
if (error) {
return error;
}
background = strtoul(buffer+1, NULL, 16);
config->border_colors.background = background;
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

38
sway/old/commands/clipboard.c
View file

@ -1,38 +0,0 @@
#include <wlc/wlc.h>
#include <unistd.h>
#include <string.h>
#include "sway/commands.h"
#include "stringop.h"
static void send_clipboard(void *data, const char *type, int fd) {
if (strcmp(type, "text/plain") != 0
&& strcmp(type, "text/plain;charset=utf-8") != 0) {
close(fd);
return;
}
const char *str = data;
write(fd, str, strlen(str));
close(fd);
}
struct cmd_results *cmd_clipboard(int argc, char **argv) {
static char *current_data = NULL;
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "clipboard", EXPECTED_AT_LEAST, 1))) {
return error;
}
static const char *types[2] = {
"text/plain",
"text/plain;charset=utf-8"
};
char *str = join_args(argv, argc);
wlc_set_selection(str, types, 2, &send_clipboard);
free(current_data);
current_data = str;
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

26
sway/old/commands/commands.c
View file

@ -1,26 +0,0 @@
#include <stdbool.h>
#include <string.h>
#include "sway/commands.h"
#include "sway/config.h"
#include "list.h"
#include "log.h"
struct cmd_results *cmd_commands(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "commands", EXPECTED_EQUAL_TO, 1))) {
return error;
}
if ((error = check_security_config())) {
return error;
}
if (strcmp(argv[0], "{") != 0) {
return cmd_results_new(CMD_FAILURE, "commands", "Expected block declaration");
}
if (!config->reading) {
return cmd_results_new(CMD_FAILURE, "commands", "Can only be used in config file.");
}
return cmd_results_new(CMD_BLOCK_COMMANDS, NULL, NULL);
}

27
sway/old/commands/debuglog.c
View file

@ -1,27 +0,0 @@
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
#include "log.h"
struct cmd_results *cmd_debuglog(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "debuglog", EXPECTED_EQUAL_TO, 1))) {
return error;
} else if (strcasecmp(argv[0], "toggle") == 0) {
if (config->reading) {
return cmd_results_new(CMD_FAILURE, "debuglog toggle", "Can't be used in config file.");
}
if (toggle_debug_logging()) {
sway_log(L_DEBUG, "Debuglog turned on.");
}
} else if (strcasecmp(argv[0], "on") == 0) {
set_log_level(L_DEBUG);
sway_log(L_DEBUG, "Debuglog turned on.");
} else if (strcasecmp(argv[0], "off") == 0) {
reset_log_level();
} else {
return cmd_results_new(CMD_FAILURE, "debuglog", "Expected 'debuglog on|off|toggle'");
}
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

44
sway/old/commands/default_border.c
View file

@ -1,44 +0,0 @@
#include <errno.h>
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
#include "sway/container.h"
struct cmd_results *cmd_default_border(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "default_border", EXPECTED_AT_LEAST, 1))) {
return error;
}
if (argc > 2) {
return cmd_results_new(CMD_INVALID, "default_border",
"Expected 'default_border <normal|none|pixel> [<n>]");
}
enum swayc_border_types border = config->border;
int thickness = config->border_thickness;
if (strcasecmp(argv[0], "none") == 0) {
border = B_NONE;
} else if (strcasecmp(argv[0], "normal") == 0) {
border = B_NORMAL;
} else if (strcasecmp(argv[0], "pixel") == 0) {
border = B_PIXEL;
} else {
return cmd_results_new(CMD_INVALID, "default_border",
"Expected 'default_border <normal|none|pixel> [<n>]");
}
if (argc == 2 && (border == B_NORMAL || border == B_PIXEL)) {
thickness = (int)strtol(argv[1], NULL, 10);
if (errno == ERANGE || thickness < 0) {
errno = 0;
return cmd_results_new(CMD_INVALID, "default_border", "Number is out out of range.");
}
}
config->border = border;
config->border_thickness = thickness;
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

45
sway/old/commands/default_floating_border.c
View file

@ -1,45 +0,0 @@
#include <errno.h>
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
#include "sway/container.h"
struct cmd_results *cmd_default_floating_border(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "default_floating_border", EXPECTED_AT_LEAST, 1))) {
return error;
}
if (argc > 2) {
return cmd_results_new(CMD_INVALID, "default_floating_border",
"Expected 'default_floating_border <normal|none|pixel> [<n>]");
}
enum swayc_border_types border = config->floating_border;
int thickness = config->floating_border_thickness;
if (strcasecmp(argv[0], "none") == 0) {
border = B_NONE;
} else if (strcasecmp(argv[0], "normal") == 0) {
border = B_NORMAL;
} else if (strcasecmp(argv[0], "pixel") == 0) {
border = B_PIXEL;
} else {
return cmd_results_new(CMD_INVALID, "default_floating_border",
"Expected 'default_floating_border <normal|none|pixel> [<n>]");
}
if (argc == 2 && (border == B_NORMAL || border == B_PIXEL)) {
thickness = (int)strtol(argv[1], NULL, 10);
if (errno == ERANGE || thickness < 0) {
errno = 0;
return cmd_results_new(CMD_INVALID, "default_floating_border",
"Number is out out of range.");
}
}
config->floating_border = border;
config->floating_border_thickness = thickness;
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

16
sway/old/commands/exec.c
View file

@ -1,16 +0,0 @@
#include <string.h>
#include "sway/commands.h"
#include "log.h"
#include "stringop.h"
struct cmd_results *cmd_exec(int argc, char **argv) {
if (!config->active) return cmd_results_new(CMD_DEFER, "exec", NULL);
if (config->reloading) {
char *args = join_args(argv, argc);
sway_log(L_DEBUG, "Ignoring 'exec %s' due to reload", args);
free(args);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}
return cmd_exec_always(argc, argv);
}

85
sway/old/commands/exec_always.c
View file

@ -1,85 +0,0 @@
#define _XOPEN_SOURCE 500
#include <string.h>
#include <sys/wait.h>
#include <unistd.h>
#include "sway/commands.h"
#include "sway/config.h"
#include "log.h"
#include "stringop.h"
struct cmd_results *cmd_exec_always(int argc, char **argv) {
struct cmd_results *error = NULL;
if (!config->active) return cmd_results_new(CMD_DEFER, NULL, NULL);
if ((error = checkarg(argc, "exec_always", EXPECTED_MORE_THAN, 0))) {
return error;
}
char *tmp = NULL;
if (strcmp((char*)*argv, "--no-startup-id") == 0) {
sway_log(L_INFO, "exec switch '--no-startup-id' not supported, ignored.");
if ((error = checkarg(argc - 1, "exec_always", EXPECTED_MORE_THAN, 0))) {
return error;
}
tmp = join_args(argv + 1, argc - 1);
} else {
tmp = join_args(argv, argc);
}
// Put argument into cmd array
char cmd[4096];
strncpy(cmd, tmp, sizeof(cmd));
cmd[sizeof(cmd) - 1] = 0;
free(tmp);
sway_log(L_DEBUG, "Executing %s", cmd);
int fd[2];
if (pipe(fd) != 0) {
sway_log(L_ERROR, "Unable to create pipe for fork");
}
pid_t pid;
pid_t *child = malloc(sizeof(pid_t)); // malloc'd so that Linux can avoid copying the process space
if (!child) {
return cmd_results_new(CMD_FAILURE, "exec_always", "Unable to allocate child pid");
}
// Fork process
if ((pid = fork()) == 0) {
// Fork child process again
setsid();
if ((*child = fork()) == 0) {
execl("/bin/sh", "/bin/sh", "-c", cmd, (void *)NULL);
/* Not reached */
}
close(fd[0]);
ssize_t s = 0;
while ((size_t)s < sizeof(pid_t)) {
s += write(fd[1], ((uint8_t *)child) + s, sizeof(pid_t) - s);
}
close(fd[1]);
_exit(0); // Close child process
} else if (pid < 0) {
free(child);
return cmd_results_new(CMD_FAILURE, "exec_always", "fork() failed");
}
close(fd[1]); // close write
ssize_t s = 0;
while ((size_t)s < sizeof(pid_t)) {
s += read(fd[0], ((uint8_t *)child) + s, sizeof(pid_t) - s);
}
close(fd[0]);
// cleanup child process
wait(0);
swayc_t *ws = swayc_active_workspace();
if (*child > 0 && ws) {
sway_log(L_DEBUG, "Child process created with pid %d for workspace %s", *child, ws->name);
struct pid_workspace *pw = malloc(sizeof(struct pid_workspace));
pw->pid = child;
pw->workspace = strdup(ws->name);
pid_workspace_add(pw);
} else {
free(child);
}
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

17
sway/old/commands/exit.c
View file

@ -1,17 +0,0 @@
#include "sway/commands.h"
#include "sway/container.h"
void sway_terminate(int exit_code);
struct cmd_results *cmd_exit(int argc, char **argv) {
struct cmd_results *error = NULL;
if (config->reading) return cmd_results_new(CMD_FAILURE, "exit", "Can't be used in config file.");
if ((error = checkarg(argc, "exit", EXPECTED_EQUAL_TO, 0))) {
return error;
}
// Close all views
close_views(&root_container);
sway_terminate(EXIT_SUCCESS);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

81
sway/old/commands/floating.c
View file

@ -1,81 +0,0 @@
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
#include "sway/container.h"
#include "sway/ipc-server.h"
#include "sway/layout.h"
#include "list.h"
#include "log.h"
struct cmd_results *cmd_floating(int argc, char **argv) {
struct cmd_results *error = NULL;
if (config->reading) return cmd_results_new(CMD_FAILURE, "floating", "Can't be used in config file.");
if ((error = checkarg(argc, "floating", EXPECTED_EQUAL_TO, 1))) {
return error;
}
swayc_t *view = current_container;
bool wants_floating;
if (strcasecmp(argv[0], "enable") == 0) {
wants_floating = true;
} else if (strcasecmp(argv[0], "disable") == 0) {
wants_floating = false;
} else if (strcasecmp(argv[0], "toggle") == 0) {
wants_floating = !view->is_floating;
} else {
return cmd_results_new(CMD_FAILURE, "floating",
"Expected 'floating <enable|disable|toggle>");
}
// Prevent running floating commands on things like workspaces
if (view->type != C_VIEW) {
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}
// Change from nonfloating to floating
if (!view->is_floating && wants_floating) {
// Remove view from its current location
destroy_container(remove_child(view));
// and move it into workspace floating
add_floating(swayc_active_workspace(), view);
view->x = (swayc_active_workspace()->width - view->width)/2;
view->y = (swayc_active_workspace()->height - view->height)/2;
if (view->desired_width != -1) {
view->width = view->desired_width;
}
if (view->desired_height != -1) {
view->height = view->desired_height;
}
arrange_windows(swayc_active_workspace(), -1, -1);
} else if (view->is_floating && !wants_floating) {
// Delete the view from the floating list and unset its is_floating flag
remove_child(view);
view->is_floating = false;
// Get the properly focused container, and add in the view there
swayc_t *focused = container_under_pointer();
// If focused is null, it's because the currently focused container is a workspace
if (focused == NULL || focused->is_floating) {
focused = swayc_active_workspace();
}
set_focused_container(focused);
sway_log(L_DEBUG, "Non-floating focused container is %p", focused);
// Case of focused workspace, just create as child of it
if (focused->type == C_WORKSPACE) {
add_child(focused, view);
}
// Regular case, create as sibling of current container
else {
add_sibling(focused, view);
}
// Refocus on the view once its been put back into the layout
view->width = view->height = 0;
arrange_windows(swayc_active_workspace(), -1, -1);
remove_view_from_scratchpad(view);
ipc_event_window(view, "floating");
}
set_focused_container(view);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

38
sway/old/commands/floating_maximum_size.c
View file

@ -1,38 +0,0 @@
#include <stdlib.h>
#include <string.h>
#include "sway/commands.h"
#include "log.h"
struct cmd_results *cmd_floating_maximum_size(int argc, char **argv) {
struct cmd_results *error = NULL;
int32_t width;
int32_t height;
char *ptr;
if ((error = checkarg(argc, "floating_maximum_size", EXPECTED_EQUAL_TO, 3))) {
return error;
}
width = strtol(argv[0], &ptr, 10);
height = strtol(argv[2], &ptr, 10);
if (width < -1) {
sway_log(L_DEBUG, "floating_maximum_size invalid width value: '%s'", argv[0]);
} else {
config->floating_maximum_width = width;
}
if (height < -1) {
sway_log(L_DEBUG, "floating_maximum_size invalid height value: '%s'", argv[2]);
}
else {
config->floating_maximum_height = height;
}
sway_log(L_DEBUG, "New floating_maximum_size: '%d' x '%d'", config->floating_maximum_width,
config->floating_maximum_height);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

38
sway/old/commands/floating_minimum_size.c
View file

@ -1,38 +0,0 @@
#include <stdlib.h>
#include <string.h>
#include "sway/commands.h"
#include "log.h"
struct cmd_results *cmd_floating_minimum_size(int argc, char **argv) {
struct cmd_results *error = NULL;
int32_t width;
int32_t height;
char *ptr;
if ((error = checkarg(argc, "floating_minimum_size", EXPECTED_EQUAL_TO, 3))) {
return error;
}
width = strtol(argv[0], &ptr, 10);
height = strtol(argv[2], &ptr, 10);
if (width <= 0) {
sway_log(L_DEBUG, "floating_minimum_size invalid width value: '%s'", argv[0]);
} else {
config->floating_minimum_width = width;
}
if (height <= 0) {
sway_log(L_DEBUG, "floating_minimum_size invalid height value: '%s'", argv[2]);
}
else {
config->floating_minimum_height = height;
}
sway_log(L_DEBUG, "New floating_minimum_size: '%d' x '%d'", config->floating_minimum_width,
config->floating_minimum_height);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

42
sway/old/commands/floating_mod.c
View file

@ -1,42 +0,0 @@
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
#include "sway/input_state.h"
#include "list.h"
#include "log.h"
#include "stringop.h"
#include "util.h"
struct cmd_results *cmd_floating_mod(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "floating_modifier", EXPECTED_AT_LEAST, 1))) {
return error;
}
int i;
list_t *split = split_string(argv[0], "+");
config->floating_mod = 0;
// set modifier keys
for (i = 0; i < split->length; ++i) {
config->floating_mod |= get_modifier_mask_by_name(split->items[i]);
}
free_flat_list(split);
if (!config->floating_mod) {
error = cmd_results_new(CMD_INVALID, "floating_modifier", "Unknown keys %s", argv[0]);
return error;
}
if (argc >= 2) {
if (strcasecmp("inverse", argv[1]) == 0) {
config->dragging_key = M_RIGHT_CLICK;
config->resizing_key = M_LEFT_CLICK;
} else if (strcasecmp("normal", argv[1]) == 0) {
config->dragging_key = M_LEFT_CLICK;
config->resizing_key = M_RIGHT_CLICK;
} else {
error = cmd_results_new(CMD_INVALID, "floating_modifier", "Invalid definition %s", argv[1]);
return error;
}
}
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

46
sway/old/commands/floating_scroll.c
View file

@ -1,46 +0,0 @@
#define _XOPEN_SOURCE 500
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
#include "log.h"
#include "stringop.h"
struct cmd_results *cmd_floating_scroll(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "floating_scroll", EXPECTED_AT_LEAST, 1))) {
return error;
}
if (!strcasecmp("up", argv[0])) {
free(config->floating_scroll_up_cmd);
if (argc < 2) {
config->floating_scroll_up_cmd = strdup("");
} else {
config->floating_scroll_up_cmd = join_args(argv + 1, argc - 1);
}
} else if (!strcasecmp("down", argv[0])) {
free(config->floating_scroll_down_cmd);
if (argc < 2) {
config->floating_scroll_down_cmd = strdup("");
} else {
config->floating_scroll_down_cmd = join_args(argv + 1, argc - 1);
}
} else if (!strcasecmp("left", argv[0])) {
free(config->floating_scroll_left_cmd);
if (argc < 2) {
config->floating_scroll_left_cmd = strdup("");
} else {
config->floating_scroll_left_cmd = join_args(argv + 1, argc - 1);
}
} else if (!strcasecmp("right", argv[0])) {
free(config->floating_scroll_right_cmd);
if (argc < 2) {
config->floating_scroll_right_cmd = strdup("");
} else {
config->floating_scroll_right_cmd = join_args(argv + 1, argc - 1);
}
} else {
error = cmd_results_new(CMD_INVALID, "floating_scroll", "Unknown command: '%s'", argv[0]);
return error;
}
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

100
sway/old/commands/focus.c
View file

@ -1,100 +0,0 @@
#define _POSIX_C_SOURCE 200809L
#include <string.h>
#include <strings.h>
#include <wlc/wlc.h>
#include "sway/commands.h"
#include "sway/container.h"
#include "sway/focus.h"
#include "sway/input_state.h"
#include "sway/output.h"
#include "sway/workspace.h"
struct cmd_results *cmd_focus(int argc, char **argv) {
if (config->reading) return cmd_results_new(CMD_FAILURE, "focus", "Can't be used in config file.");
struct cmd_results *error = NULL;
if (argc > 0 && strcasecmp(argv[0], "output") == 0) {
swayc_t *output = NULL;
struct wlc_point abs_pos;
get_absolute_center_position(get_focused_container(&root_container), &abs_pos);
if ((error = checkarg(argc, "focus", EXPECTED_EQUAL_TO, 2))) {
return error;
} else if (!(output = output_by_name(argv[1], &abs_pos))) {
return cmd_results_new(CMD_FAILURE, "focus output",
"Can't find output with name/at direction '%s' @ (%i,%i)", argv[1], abs_pos.x, abs_pos.y);
} else if (!workspace_switch(swayc_active_workspace_for(output))) {
return cmd_results_new(CMD_FAILURE, "focus output",
"Switching to workspace on output '%s' was blocked", argv[1]);
} else if (config->mouse_warping) {
swayc_t *focused = get_focused_view(output);
if (focused && focused->type == C_VIEW) {
center_pointer_on(focused);
}
}
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
} else if (argc == 0) {
set_focused_container(current_container);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
} else if ((error = checkarg(argc, "focus", EXPECTED_EQUAL_TO, 1))) {
return error;
}
static int floating_toggled_index = 0;
static int tiled_toggled_index = 0;
if (strcasecmp(argv[0], "left") == 0) {
move_focus(MOVE_LEFT);
} else if (strcasecmp(argv[0], "right") == 0) {
move_focus(MOVE_RIGHT);
} else if (strcasecmp(argv[0], "up") == 0) {
move_focus(MOVE_UP);
} else if (strcasecmp(argv[0], "down") == 0) {
move_focus(MOVE_DOWN);
} else if (strcasecmp(argv[0], "parent") == 0) {
move_focus(MOVE_PARENT);
} else if (strcasecmp(argv[0], "child") == 0) {
move_focus(MOVE_CHILD);
} else if (strcasecmp(argv[0], "next") == 0) {
move_focus(MOVE_NEXT);
} else if (strcasecmp(argv[0], "prev") == 0) {
move_focus(MOVE_PREV);
} else if (strcasecmp(argv[0], "mode_toggle") == 0) {
int i;
swayc_t *workspace = swayc_active_workspace();
swayc_t *focused = get_focused_view(workspace);
if (focused->is_floating) {
if (workspace->children->length > 0) {
for (i = 0;i < workspace->floating->length; i++) {
if (workspace->floating->items[i] == focused) {
floating_toggled_index = i;
break;
}
}
if (workspace->children->length > tiled_toggled_index) {
set_focused_container(get_focused_view(workspace->children->items[tiled_toggled_index]));
} else {
set_focused_container(get_focused_view(workspace->children->items[0]));
tiled_toggled_index = 0;
}
}
} else {
if (workspace->floating->length > 0) {
for (i = 0;i < workspace->children->length; i++) {
if (workspace->children->items[i] == focused) {
tiled_toggled_index = i;
break;
}
}
if (workspace->floating->length > floating_toggled_index) {
swayc_t *floating = workspace->floating->items[floating_toggled_index];
set_focused_container(get_focused_view(floating));
} else {
swayc_t *floating = workspace->floating->items[workspace->floating->length - 1];
set_focused_container(get_focused_view(floating));
tiled_toggled_index = workspace->floating->length - 1;
}
}
}
} else {
return cmd_results_new(CMD_INVALID, "focus",
"Expected 'focus <direction|parent|child|mode_toggle>' or 'focus output <direction|name>'");
}
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

13
sway/old/commands/focus_follows_mouse.c
View file

@ -1,13 +0,0 @@
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
struct cmd_results *cmd_focus_follows_mouse(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "focus_follows_mouse", EXPECTED_EQUAL_TO, 1))) {
return error;
}
config->focus_follows_mouse = !strcasecmp(argv[0], "yes");
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

27
sway/old/commands/font.c
View file

@ -1,27 +0,0 @@
#define _XOPEN_SOURCE 500
#include <string.h>
#include "sway/border.h"
#include "sway/commands.h"
#include "log.h"
#include "stringop.h"
struct cmd_results *cmd_font(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "font", EXPECTED_AT_LEAST, 1))) {
return error;
}
char *font = join_args(argv, argc);
free(config->font);
if (strlen(font) > 6 && strncmp("pango:", font, 6) == 0) {
config->font = strdup(font + 6);
free(font);
} else {
config->font = font;
}
config->font_height = get_font_text_height(config->font);
sway_log(L_DEBUG, "Settings font %s", config->font);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

41
sway/old/commands/for_window.c
View file

@ -1,41 +0,0 @@
#define _XOPEN_SOURCE 500
#include <string.h>
#include "sway/commands.h"
#include "sway/criteria.h"
#include "list.h"
#include "log.h"
#include "stringop.h"
struct cmd_results *cmd_for_window(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "for_window", EXPECTED_AT_LEAST, 2))) {
return error;
}
// add command to a criteria/command pair that is run against views when they appear.
char *criteria = argv[0], *cmdlist = join_args(argv + 1, argc - 1);
struct criteria *crit = malloc(sizeof(struct criteria));
if (!crit) {
return cmd_results_new(CMD_FAILURE, "for_window", "Unable to allocate criteria");
}
crit->crit_raw = strdup(criteria);
crit->cmdlist = cmdlist;
crit->tokens = create_list();
char *err_str = extract_crit_tokens(crit->tokens, crit->crit_raw);
if (err_str) {
error = cmd_results_new(CMD_INVALID, "for_window", err_str);
free(err_str);
free_criteria(crit);
} else if (crit->tokens->length == 0) {
error = cmd_results_new(CMD_INVALID, "for_window", "Found no name/value pairs in criteria");
free_criteria(crit);
} else if (list_seq_find(config->criteria, criteria_cmp, crit) != -1) {
sway_log(L_DEBUG, "for_window: Duplicate, skipping.");
free_criteria(crit);
} else {
sway_log(L_DEBUG, "for_window: '%s' -> '%s' added", crit->crit_raw, crit->cmdlist);
list_add(config->criteria, crit);
}
return error ? error : cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

13
sway/old/commands/force_focus_wrapping.c
View file

@ -1,13 +0,0 @@
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
struct cmd_results *cmd_force_focus_wrapping(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "force_focus_wrapping", EXPECTED_EQUAL_TO, 1))) {
return error;
}
config->force_focus_wrapping = !strcasecmp(argv[0], "yes");
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

60
sway/old/commands/fullscreen.c
View file

@ -1,60 +0,0 @@
#include <stdbool.h>
#include <string.h>
#include <wlc/wlc.h>
#include "sway/commands.h"
#include "sway/container.h"
#include "sway/focus.h"
#include "sway/ipc-server.h"
#include "sway/layout.h"
struct cmd_results *cmd_fullscreen(int argc, char **argv) {
struct cmd_results *error = NULL;
if (config->reading) return cmd_results_new(CMD_FAILURE, "fullscreen", "Can't be used in config file.");
if (!config->active) return cmd_results_new(CMD_FAILURE, "fullscreen", "Can only be used when sway is running.");
if ((error = checkarg(argc, "fullscreen", EXPECTED_AT_LEAST, 0))) {
return error;
}
swayc_t *container = current_container;
if(container->type != C_VIEW){
return cmd_results_new(CMD_INVALID, "fullscreen", "Only views can fullscreen");
}
swayc_t *workspace = swayc_parent_by_type(container, C_WORKSPACE);
bool current = swayc_is_fullscreen(container);
wlc_view_set_state(container->handle, WLC_BIT_FULLSCREEN, !current);
if (container->is_floating) {
if (current) {
// set dimensions back to what they were before we fullscreened this
container->x = container->cached_geometry.origin.x;
container->y = container->cached_geometry.origin.y;
container->width = container->cached_geometry.size.w;
container->height = container->cached_geometry.size.h;
} else {
// cache dimensions so we can reset them after we "unfullscreen" this
struct wlc_geometry geo = {
.origin = {
.x = container->x,
.y = container->y
},
.size = {
.w = container->width,
.h = container->height
}
};
container->cached_geometry = geo;
}
}
// Resize workspace if going from fullscreen -> notfullscreen
// otherwise just resize container
if (!current) {
arrange_windows(workspace, -1, -1);
workspace->fullscreen = container;
} else {
arrange_windows(container, -1, -1);
workspace->fullscreen = NULL;
}
ipc_event_window(container, "fullscreen_mode");
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

166
sway/old/commands/gaps.c
View file

@ -1,166 +0,0 @@
#include <ctype.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
#include "sway/container.h"
#include "sway/focus.h"
#include "sway/layout.h"
struct cmd_results *cmd_gaps(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "gaps", EXPECTED_AT_LEAST, 1))) {
return error;
}
const char *expected_syntax =
"Expected 'gaps edge_gaps <on|off|toggle>' or "
"'gaps <inner|outer> <current|all|workspace> <set|plus|minus n>'";
const char *amount_str = argv[0];
// gaps amount
if (argc >= 1 && isdigit(*amount_str)) {
int amount = (int)strtol(amount_str, NULL, 10);
if (errno == ERANGE) {
errno = 0;
return cmd_results_new(CMD_INVALID, "gaps", "Number is out out of range.");
}
config->gaps_inner = config->gaps_outer = amount;
arrange_windows(&root_container, -1, -1);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}
// gaps inner|outer n
else if (argc >= 2 && isdigit((amount_str = argv[1])[0])) {
int amount = (int)strtol(amount_str, NULL, 10);
if (errno == ERANGE) {
errno = 0;
return cmd_results_new(CMD_INVALID, "gaps", "Number is out out of range.");
}
const char *target_str = argv[0];
if (strcasecmp(target_str, "inner") == 0) {
config->gaps_inner = amount;
} else if (strcasecmp(target_str, "outer") == 0) {
config->gaps_outer = amount;
}
arrange_windows(&root_container, -1, -1);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
} else if (argc == 2 && strcasecmp(argv[0], "edge_gaps") == 0) {
// gaps edge_gaps <on|off|toggle>
if (strcasecmp(argv[1], "toggle") == 0) {
if (config->reading) {
return cmd_results_new(CMD_FAILURE, "gaps edge_gaps toggle",
"Can't be used in config file.");
}
config->edge_gaps = !config->edge_gaps;
} else {
config->edge_gaps =
(strcasecmp(argv[1], "yes") == 0 || strcasecmp(argv[1], "on") == 0);
}
arrange_windows(&root_container, -1, -1);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}
// gaps inner|outer current|all set|plus|minus n
if (argc < 4 || config->reading) {
return cmd_results_new(CMD_INVALID, "gaps", expected_syntax);
}
// gaps inner|outer ...
const char *inout_str = argv[0];
enum {INNER, OUTER} inout;
if (strcasecmp(inout_str, "inner") == 0) {
inout = INNER;
} else if (strcasecmp(inout_str, "outer") == 0) {
inout = OUTER;
} else {
return cmd_results_new(CMD_INVALID, "gaps", expected_syntax);
}
// gaps ... current|all ...
const char *target_str = argv[1];
enum {CURRENT, WORKSPACE, ALL} target;
if (strcasecmp(target_str, "current") == 0) {
target = CURRENT;
} else if (strcasecmp(target_str, "all") == 0) {
target = ALL;
} else if (strcasecmp(target_str, "workspace") == 0) {
if (inout == OUTER) {
target = CURRENT;
} else {
// Set gap for views in workspace
target = WORKSPACE;
}
} else {
return cmd_results_new(CMD_INVALID, "gaps", expected_syntax);
}
// gaps ... n
amount_str = argv[3];
int amount = (int)strtol(amount_str, NULL, 10);
if (errno == ERANGE) {
errno = 0;
return cmd_results_new(CMD_INVALID, "gaps", "Number is out out of range.");
}
// gaps ... set|plus|minus ...
const char *method_str = argv[2];
enum {SET, ADD} method;
if (strcasecmp(method_str, "set") == 0) {
method = SET;
} else if (strcasecmp(method_str, "plus") == 0) {
method = ADD;
} else if (strcasecmp(method_str, "minus") == 0) {
method = ADD;
amount *= -1;
} else {
return cmd_results_new(CMD_INVALID, "gaps", expected_syntax);
}
if (target == CURRENT) {
swayc_t *cont;
if (inout == OUTER) {
if ((cont = swayc_active_workspace()) == NULL) {
return cmd_results_new(CMD_FAILURE, "gaps", "There's no active workspace.");
}
} else {
if ((cont = get_focused_view(&root_container))->type != C_VIEW) {
return cmd_results_new(CMD_FAILURE, "gaps", "Currently focused item is not a view.");
}
}
cont->gaps = swayc_gap(cont);
if (method == SET) {
cont->gaps = amount;
} else if ((cont->gaps += amount) < 0) {
cont->gaps = 0;
}
arrange_windows(cont->parent, -1, -1);
} else if (inout == OUTER) {
//resize all workspace.
int i,j;
for (i = 0; i < root_container.children->length; ++i) {
swayc_t *op = root_container.children->items[i];
for (j = 0; j < op->children->length; ++j) {
swayc_t *ws = op->children->items[j];
if (method == SET) {
ws->gaps = amount;
} else if ((ws->gaps += amount) < 0) {
ws->gaps = 0;
}
}
}
arrange_windows(&root_container, -1, -1);
} else {
// Resize gaps for all views in workspace
swayc_t *top;
if (target == WORKSPACE) {
if ((top = swayc_active_workspace()) == NULL) {
return cmd_results_new(CMD_FAILURE, "gaps", "There's currently no active workspace.");
}
} else {
top = &root_container;
}
int top_gap = top->gaps;
container_map(top, method == SET ? set_gaps : add_gaps, &amount);
top->gaps = top_gap;
arrange_windows(top, -1, -1);
}
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

27
sway/old/commands/hide_edge_borders.c
View file

@ -1,27 +0,0 @@
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
struct cmd_results *cmd_hide_edge_borders(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "hide_edge_borders", EXPECTED_EQUAL_TO, 1))) {
return error;
}
if (strcasecmp(argv[0], "none") == 0) {
config->hide_edge_borders = E_NONE;
} else if (strcasecmp(argv[0], "vertical") == 0) {
config->hide_edge_borders = E_VERTICAL;
} else if (strcasecmp(argv[0], "horizontal") == 0) {
config->hide_edge_borders = E_HORIZONTAL;
} else if (strcasecmp(argv[0], "both") == 0) {
config->hide_edge_borders = E_BOTH;
} else if (strcasecmp(argv[0], "smart") == 0) {
config->hide_edge_borders = E_SMART;
} else {
return cmd_results_new(CMD_INVALID, "hide_edge_borders",
"Expected 'hide_edge_borders <none|vertical|horizontal|both>'");
}
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

15
sway/old/commands/include.c
View file

@ -1,15 +0,0 @@
#include "sway/commands.h"
#include "sway/config.h"
struct cmd_results *cmd_include(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "include", EXPECTED_EQUAL_TO, 1))) {
return error;
}
if (!load_include_configs(argv[0], config)) {
return cmd_results_new(CMD_INVALID, "include", "Failed to include sub configuration file: %s", argv[0]);
}
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

55
sway/old/commands/input.c
View file

@ -1,55 +0,0 @@
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
#include "sway/input.h"
#include "log.h"
struct cmd_results *cmd_input(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "input", EXPECTED_AT_LEAST, 2))) {
return error;
}
if (config->reading && strcmp("{", argv[1]) == 0) {
current_input_config = new_input_config(argv[0]);
sway_log(L_DEBUG, "entering input block: %s", current_input_config->identifier);
return cmd_results_new(CMD_BLOCK_INPUT, NULL, NULL);
}
if (argc > 2) {
int argc_new = argc-2;
char **argv_new = argv+2;
struct cmd_results *res;
current_input_config = new_input_config(argv[0]);
if (strcasecmp("accel_profile", argv[1]) == 0) {
res = input_cmd_accel_profile(argc_new, argv_new);
} else if (strcasecmp("click_method", argv[1]) == 0) {
res = input_cmd_click_method(argc_new, argv_new);
} else if (strcasecmp("drag_lock", argv[1]) == 0) {
res = input_cmd_drag_lock(argc_new, argv_new);
} else if (strcasecmp("dwt", argv[1]) == 0) {
res = input_cmd_dwt(argc_new, argv_new);
} else if (strcasecmp("events", argv[1]) == 0) {
res = input_cmd_events(argc_new, argv_new);
} else if (strcasecmp("left_handed", argv[1]) == 0) {
res = input_cmd_left_handed(argc_new, argv_new);
} else if (strcasecmp("middle_emulation", argv[1]) == 0) {
res = input_cmd_middle_emulation(argc_new, argv_new);
} else if (strcasecmp("natural_scroll", argv[1]) == 0) {
res = input_cmd_natural_scroll(argc_new, argv_new);
} else if (strcasecmp("pointer_accel", argv[1]) == 0) {
res = input_cmd_pointer_accel(argc_new, argv_new);
} else if (strcasecmp("scroll_method", argv[1]) == 0) {
res = input_cmd_scroll_method(argc_new, argv_new);
} else if (strcasecmp("tap", argv[1]) == 0) {
res = input_cmd_tap(argc_new, argv_new);
} else {
res = cmd_results_new(CMD_INVALID, "input <device>", "Unknown command %s", argv[1]);
}
current_input_config = NULL;
return res;
}
return cmd_results_new(CMD_BLOCK_INPUT, NULL, NULL);
}

27
sway/old/commands/input/accel_profile.c
View file

@ -1,27 +0,0 @@
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
#include "sway/input.h"
struct cmd_results *input_cmd_accel_profile(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "accel_profile", EXPECTED_AT_LEAST, 1))) {
return error;
}
if (!current_input_config) {
return cmd_results_new(CMD_FAILURE, "accel_profile", "No input device defined.");
}
struct input_config *new_config = new_input_config(current_input_config->identifier);
if (strcasecmp(argv[0], "adaptive") == 0) {
new_config->accel_profile = LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE;
} else if (strcasecmp(argv[0], "flat") == 0) {
new_config->accel_profile = LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT;
} else {
return cmd_results_new(CMD_INVALID, "accel_profile",
"Expected 'accel_profile <adaptive|flat>'");
}
input_cmd_apply(new_config);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

30
sway/old/commands/input/click_method.c
View file

@ -1,30 +0,0 @@
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
#include "sway/input.h"
#include "log.h"
struct cmd_results *input_cmd_click_method(int argc, char **argv) {
sway_log(L_DEBUG, "click_method for device: %d %s", current_input_config==NULL, current_input_config->identifier);
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "click_method", EXPECTED_AT_LEAST, 1))) {
return error;
}
if (!current_input_config) {
return cmd_results_new(CMD_FAILURE, "click_method", "No input device defined.");
}
struct input_config *new_config = new_input_config(current_input_config->identifier);
if (strcasecmp(argv[0], "none") == 0) {
new_config->click_method = LIBINPUT_CONFIG_CLICK_METHOD_NONE;
} else if (strcasecmp(argv[0], "button_areas") == 0) {
new_config->click_method = LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS;
} else if (strcasecmp(argv[0], "clickfinger") == 0) {
new_config->click_method = LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER;
} else {
return cmd_results_new(CMD_INVALID, "click_method", "Expected 'click_method <none|button_areas|clickfinger'");
}
input_cmd_apply(new_config);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

26
sway/old/commands/input/drag_lock.c
View file

@ -1,26 +0,0 @@
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
#include "sway/input.h"
struct cmd_results *input_cmd_drag_lock(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "drag_lock", EXPECTED_AT_LEAST, 1))) {
return error;
}
if (!current_input_config) {
return cmd_results_new(CMD_FAILURE, "drag_lock", "No input device defined.");
}
struct input_config *new_config = new_input_config(current_input_config->identifier);
if (strcasecmp(argv[0], "enabled") == 0) {
new_config->drag_lock = LIBINPUT_CONFIG_DRAG_LOCK_ENABLED;
} else if (strcasecmp(argv[0], "disabled") == 0) {
new_config->drag_lock = LIBINPUT_CONFIG_DRAG_LOCK_DISABLED;
} else {
return cmd_results_new(CMD_INVALID, "drag_lock", "Expected 'drag_lock <enabled|disabled>'");
}
input_cmd_apply(new_config);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

26
sway/old/commands/input/dwt.c
View file

@ -1,26 +0,0 @@
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
#include "sway/input.h"
struct cmd_results *input_cmd_dwt(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "dwt", EXPECTED_AT_LEAST, 1))) {
return error;
}
if (!current_input_config) {
return cmd_results_new(CMD_FAILURE, "dwt", "No input device defined.");
}
struct input_config *new_config = new_input_config(current_input_config->identifier);
if (strcasecmp(argv[0], "enabled") == 0) {
new_config->dwt = LIBINPUT_CONFIG_DWT_ENABLED;
} else if (strcasecmp(argv[0], "disabled") == 0) {
new_config->dwt = LIBINPUT_CONFIG_DWT_DISABLED;
} else {
return cmd_results_new(CMD_INVALID, "dwt", "Expected 'dwt <enabled|disabled>'");
}
input_cmd_apply(new_config);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

30
sway/old/commands/input/events.c
View file

@ -1,30 +0,0 @@
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
#include "sway/input.h"
#include "log.h"
struct cmd_results *input_cmd_events(int argc, char **argv) {
sway_log(L_DEBUG, "events for device: %s", current_input_config->identifier);
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "events", EXPECTED_AT_LEAST, 1))) {
return error;
}
if (!current_input_config) {
return cmd_results_new(CMD_FAILURE, "events", "No input device defined.");
}
struct input_config *new_config = new_input_config(current_input_config->identifier);
if (strcasecmp(argv[0], "enabled") == 0) {
new_config->send_events = LIBINPUT_CONFIG_SEND_EVENTS_ENABLED;
} else if (strcasecmp(argv[0], "disabled") == 0) {
new_config->send_events = LIBINPUT_CONFIG_SEND_EVENTS_DISABLED;
} else if (strcasecmp(argv[0], "disabled_on_external_mouse") == 0) {
new_config->send_events = LIBINPUT_CONFIG_SEND_EVENTS_DISABLED_ON_EXTERNAL_MOUSE;
} else {
return cmd_results_new(CMD_INVALID, "events", "Expected 'events <enabled|disabled|disabled_on_external_mouse>'");
}
input_cmd_apply(new_config);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

26
sway/old/commands/input/left_handed.c
View file

@ -1,26 +0,0 @@
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
#include "sway/input.h"
struct cmd_results *input_cmd_left_handed(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "left_handed", EXPECTED_AT_LEAST, 1))) {
return error;
}
if (!current_input_config) {
return cmd_results_new(CMD_FAILURE, "left_handed", "No input device defined.");
}
struct input_config *new_config = new_input_config(current_input_config->identifier);
if (strcasecmp(argv[0], "enabled") == 0) {
new_config->left_handed = 1;
} else if (strcasecmp(argv[0], "disabled") == 0) {
new_config->left_handed = 0;
} else {
return cmd_results_new(CMD_INVALID, "left_handed", "Expected 'left_handed <enabled|disabled>'");
}
input_cmd_apply(new_config);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

26
sway/old/commands/input/middle_emulation.c
View file

@ -1,26 +0,0 @@
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
#include "sway/input.h"
struct cmd_results *input_cmd_middle_emulation(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "middle_emulation", EXPECTED_AT_LEAST, 1))) {
return error;
}
if (!current_input_config) {
return cmd_results_new(CMD_FAILURE, "middle_emulation", "No input device defined.");
}
struct input_config *new_config = new_input_config(current_input_config->identifier);
if (strcasecmp(argv[0], "enabled") == 0) {
new_config->middle_emulation = LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED;
} else if (strcasecmp(argv[0], "disabled") == 0) {
new_config->middle_emulation = LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED;
} else {
return cmd_results_new(CMD_INVALID, "middle_emulation", "Expected 'middle_emulation <enabled|disabled>'");
}
input_cmd_apply(new_config);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

26
sway/old/commands/input/natural_scroll.c
View file

@ -1,26 +0,0 @@
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
#include "sway/input.h"
struct cmd_results *input_cmd_natural_scroll(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "natural_scroll", EXPECTED_AT_LEAST, 1))) {
return error;
}
if (!current_input_config) {
return cmd_results_new(CMD_FAILURE, "natural_scoll", "No input device defined.");
}
struct input_config *new_config = new_input_config(current_input_config->identifier);
if (strcasecmp(argv[0], "enabled") == 0) {
new_config->natural_scroll = 1;
} else if (strcasecmp(argv[0], "disabled") == 0) {
new_config->natural_scroll = 0;
} else {
return cmd_results_new(CMD_INVALID, "natural_scroll", "Expected 'natural_scroll <enabled|disabled>'");
}
input_cmd_apply(new_config);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

24
sway/old/commands/input/pointer_accel.c
View file

@ -1,24 +0,0 @@
#include <stdlib.h>
#include <string.h>
#include "sway/commands.h"
#include "sway/input.h"
struct cmd_results *input_cmd_pointer_accel(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "pointer_accel", EXPECTED_AT_LEAST, 1))) {
return error;
}
if (!current_input_config) {
return cmd_results_new(CMD_FAILURE, "pointer_accel", "No input device defined.");
}
struct input_config *new_config = new_input_config(current_input_config->identifier);
float pointer_accel = atof(argv[0]);
if (pointer_accel < -1 || pointer_accel > 1) {
return cmd_results_new(CMD_INVALID, "pointer_accel", "Input out of range [-1, 1]");
}
new_config->pointer_accel = pointer_accel;
input_cmd_apply(new_config);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

30
sway/old/commands/input/scroll_method.c
View file

@ -1,30 +0,0 @@
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
#include "sway/input.h"
struct cmd_results *input_cmd_scroll_method(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "scroll_method", EXPECTED_AT_LEAST, 1))) {
return error;
}
if (!current_input_config) {
return cmd_results_new(CMD_FAILURE, "scroll_method", "No input device defined.");
}
struct input_config *new_config = new_input_config(current_input_config->identifier);
if (strcasecmp(argv[0], "none") == 0) {
new_config->scroll_method = LIBINPUT_CONFIG_SCROLL_NO_SCROLL;
} else if (strcasecmp(argv[0], "two_finger") == 0) {
new_config->scroll_method = LIBINPUT_CONFIG_SCROLL_2FG;
} else if (strcasecmp(argv[0], "edge") == 0) {
new_config->scroll_method = LIBINPUT_CONFIG_SCROLL_EDGE;
} else if (strcasecmp(argv[0], "on_button_down") == 0) {
new_config->scroll_method = LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN;
} else {
return cmd_results_new(CMD_INVALID, "scroll_method", "Expected 'scroll_method <none|two_finger|edge|on_button_down>'");
}
input_cmd_apply(new_config);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

29
sway/old/commands/input/tap.c
View file

@ -1,29 +0,0 @@
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
#include "sway/input.h"
#include "log.h"
struct cmd_results *input_cmd_tap(int argc, char **argv) {
sway_log(L_DEBUG, "tap for device: %s", current_input_config->identifier);
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "tap", EXPECTED_AT_LEAST, 1))) {
return error;
}
if (!current_input_config) {
return cmd_results_new(CMD_FAILURE, "tap", "No input device defined.");
}
struct input_config *new_config = new_input_config(current_input_config->identifier);
if (strcasecmp(argv[0], "enabled") == 0) {
new_config->tap = LIBINPUT_CONFIG_TAP_ENABLED;
} else if (strcasecmp(argv[0], "disabled") == 0) {
new_config->tap = LIBINPUT_CONFIG_TAP_DISABLED;
} else {
return cmd_results_new(CMD_INVALID, "tap", "Expected 'tap <enabled|disabled>'");
}
sway_log(L_DEBUG, "apply-tap for device: %s", current_input_config->identifier);
input_cmd_apply(new_config);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

162
sway/old/commands/ipc.c
View file

@ -1,162 +0,0 @@
#define _XOPEN_SOURCE 500
#include <stdio.h>
#include <string.h>
#include "sway/security.h"
#include "sway/commands.h"
#include "sway/config.h"
#include "ipc.h"
#include "log.h"
#include "util.h"
static struct ipc_policy *current_policy = NULL;
struct cmd_results *cmd_ipc(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "ipc", EXPECTED_EQUAL_TO, 2))) {
return error;
}
if ((error = check_security_config())) {
return error;
}
char *program = NULL;
if (!strcmp(argv[0], "*")) {
program = strdup(argv[0]);
} else if (!(program = resolve_path(argv[0]))) {
return cmd_results_new(
CMD_INVALID, "ipc", "Unable to resolve IPC Policy target.");
}
if (config->reading && strcmp("{", argv[1]) != 0) {
return cmd_results_new(CMD_INVALID, "ipc",
"Expected '{' at start of IPC config definition.");
}
if (!config->reading) {
return cmd_results_new(CMD_FAILURE, "ipc", "Can only be used in config file.");
}
current_policy = alloc_ipc_policy(program);
list_add(config->ipc_policies, current_policy);
free(program);
return cmd_results_new(CMD_BLOCK_IPC, NULL, NULL);
}
struct cmd_results *cmd_ipc_events(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "events", EXPECTED_EQUAL_TO, 1))) {
return error;
}
if (config->reading && strcmp("{", argv[0]) != 0) {
return cmd_results_new(CMD_INVALID, "events",
"Expected '{' at start of IPC event config definition.");
}
if (!config->reading) {
return cmd_results_new(CMD_FAILURE, "events", "Can only be used in config file.");
}
return cmd_results_new(CMD_BLOCK_IPC_EVENTS, NULL, NULL);
}
struct cmd_results *cmd_ipc_cmd(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "ipc", EXPECTED_EQUAL_TO, 1))) {
return error;
}
bool enabled;
if (strcmp(argv[0], "enabled") == 0) {
enabled = true;
} else if (strcmp(argv[0], "disabled") == 0) {
enabled = false;
} else {
return cmd_results_new(CMD_INVALID, argv[-1],
"Argument must be one of 'enabled' or 'disabled'");
}
struct {
char *name;
enum ipc_feature type;
} types[] = {
{ "*", IPC_FEATURE_ALL_COMMANDS },
{ "command", IPC_FEATURE_COMMAND },
{ "workspaces", IPC_FEATURE_GET_WORKSPACES },
{ "outputs", IPC_FEATURE_GET_OUTPUTS },
{ "tree", IPC_FEATURE_GET_TREE },
{ "marks", IPC_FEATURE_GET_MARKS },
{ "bar-config", IPC_FEATURE_GET_BAR_CONFIG },
{ "inputs", IPC_FEATURE_GET_INPUTS },
{ "clipboard", IPC_FEATURE_GET_CLIPBOARD },
};
uint32_t type = 0;
for (size_t i = 0; i < sizeof(types) / sizeof(types[0]); ++i) {
if (strcmp(types[i].name, argv[-1]) == 0) {
type = types[i].type;
break;
}
}
if (enabled) {
current_policy->features |= type;
sway_log(L_DEBUG, "Enabled IPC %s feature", argv[-1]);
} else {
current_policy->features &= ~type;
sway_log(L_DEBUG, "Disabled IPC %s feature", argv[-1]);
}
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}
struct cmd_results *cmd_ipc_event_cmd(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "ipc", EXPECTED_EQUAL_TO, 1))) {
return error;
}
bool enabled;
if (strcmp(argv[0], "enabled") == 0) {
enabled = true;
} else if (strcmp(argv[0], "disabled") == 0) {
enabled = false;
} else {
return cmd_results_new(CMD_INVALID, argv[-1],
"Argument must be one of 'enabled' or 'disabled'");
}
struct {
char *name;
enum ipc_feature type;
} types[] = {
{ "*", IPC_FEATURE_ALL_EVENTS },
{ "workspace", IPC_FEATURE_EVENT_WORKSPACE },
{ "output", IPC_FEATURE_EVENT_OUTPUT },
{ "mode", IPC_FEATURE_EVENT_MODE },
{ "window", IPC_FEATURE_EVENT_WINDOW },
{ "binding", IPC_FEATURE_EVENT_BINDING },
{ "input", IPC_FEATURE_EVENT_INPUT },
};
uint32_t type = 0;
for (size_t i = 0; i < sizeof(types) / sizeof(types[0]); ++i) {
if (strcmp(types[i].name, argv[-1]) == 0) {
type = types[i].type;
break;
}
}
if (enabled) {
current_policy->features |= type;
sway_log(L_DEBUG, "Enabled IPC %s event", argv[-1]);
} else {
current_policy->features &= ~type;
sway_log(L_DEBUG, "Disabled IPC %s event", argv[-1]);
}
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

12
sway/old/commands/kill.c
View file

@ -1,12 +0,0 @@
#include "sway/commands.h"
#include "sway/container.h"
#include "sway/focus.h"
struct cmd_results *cmd_kill(int argc, char **argv) {
if (config->reading) return cmd_results_new(CMD_FAILURE, "kill", "Can't be used in config file.");
if (!config->active) return cmd_results_new(CMD_FAILURE, "kill", "Can only be used when sway is running.");
swayc_t *container = current_container;
close_views(container);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

196
sway/old/commands/layout.c
View file

@ -1,196 +0,0 @@
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
#include "sway/container.h"
#include "sway/layout.h"
/**
* handle "layout auto" command group
*/
static struct cmd_results *cmd_layout_auto(swayc_t *container, int argc, char **argv);
struct cmd_results *cmd_layout(int argc, char **argv) {
struct cmd_results *error = NULL;
if (config->reading) return cmd_results_new(CMD_FAILURE, "layout", "Can't be used in config file.");
if (!config->active) return cmd_results_new(CMD_FAILURE, "layout", "Can only be used when sway is running.");
if ((error = checkarg(argc, "layout", EXPECTED_MORE_THAN, 0))) {
return error;
}
swayc_t *parent = current_container;
if (parent->is_floating) {
return cmd_results_new(CMD_FAILURE, "layout", "Unable to change layout of floating windows");
}
while (parent->type == C_VIEW) {
parent = parent->parent;
}
enum swayc_layouts old_layout = parent->layout;
if (strcasecmp(argv[0], "default") == 0) {
swayc_change_layout(parent, parent->prev_layout);
if (parent->layout == L_NONE) {
swayc_t *output = swayc_parent_by_type(parent, C_OUTPUT);
swayc_change_layout(parent, default_layout(output));
}
} else {
if (parent->layout != L_TABBED && parent->layout != L_STACKED) {
parent->prev_layout = parent->layout;
}
if (strcasecmp(argv[0], "tabbed") == 0) {
if (parent->type != C_CONTAINER && !swayc_is_empty_workspace(parent)){
parent = new_container(parent, L_TABBED);
}
swayc_change_layout(parent, L_TABBED);
} else if (strcasecmp(argv[0], "stacking") == 0) {
if (parent->type != C_CONTAINER && !swayc_is_empty_workspace(parent)) {
parent = new_container(parent, L_STACKED);
}
swayc_change_layout(parent, L_STACKED);
} else if (strcasecmp(argv[0], "splith") == 0) {
swayc_change_layout(parent, L_HORIZ);
} else if (strcasecmp(argv[0], "splitv") == 0) {
swayc_change_layout(parent, L_VERT);
} else if (strcasecmp(argv[0], "toggle") == 0 && argc == 2 && strcasecmp(argv[1], "split") == 0) {
if (parent->layout == L_HORIZ && (parent->workspace_layout == L_NONE
|| parent->workspace_layout == L_HORIZ)) {
swayc_change_layout(parent, L_VERT);
} else {
swayc_change_layout(parent, L_HORIZ);
}
} else if (strcasecmp(argv[0], "auto") == 0) {
return cmd_layout_auto(parent, argc, argv);
}
}
update_layout_geometry(parent, old_layout);
update_geometry(parent);
arrange_windows(parent, parent->width, parent->height);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}
static struct cmd_results *cmd_layout_auto(swayc_t *container, int argc, char **argv) {
// called after checking that argv[0] is auto, so just continue parsing from there
struct cmd_results *error = NULL;
const char *cmd_name = "layout auto";
const char *set_inc_cmd_name = "layout auto [master|ncol] [set|inc]";
const char *err_msg = "Allowed arguments are <right|left|top|bottom|next|prev|master|ncol>";
bool need_layout_update = false;
enum swayc_layouts old_layout = container->layout;
enum swayc_layouts layout = old_layout;
if ((error = checkarg(argc, "layout auto", EXPECTED_MORE_THAN, 1))) {
return error;
}
if (strcasecmp(argv[1], "left") == 0) {
layout = L_AUTO_LEFT;
} else if (strcasecmp(argv[1], "right") == 0) {
layout = L_AUTO_RIGHT;
} else if (strcasecmp(argv[1], "top") == 0) {
layout = L_AUTO_TOP;
} else if (strcasecmp(argv[1], "bottom") == 0) {
layout = L_AUTO_BOTTOM;
} else if (strcasecmp(argv[1], "next") == 0) {
if (is_auto_layout(container->layout) && container->layout < L_AUTO_LAST) {
layout = container->layout + 1;
} else {
layout = L_AUTO_FIRST;
}
} else if (strcasecmp(argv[1], "prev") == 0) {
if (is_auto_layout(container->layout) && container->layout > L_AUTO_FIRST) {
layout = container->layout - 1;
} else {
layout = L_AUTO_LAST;
}
} else {
bool is_nmaster;
bool is_set;
if (strcasecmp(argv[1], "master") == 0) {
is_nmaster = true;
} else if (strcasecmp(argv[1], "ncol") == 0) {
is_nmaster = false;
} else {
return cmd_results_new(CMD_INVALID, cmd_name, "Invalid %s command. %s",
cmd_name, err_msg);
}
if ((error = checkarg(argc, "auto <master|ncol>", EXPECTED_EQUAL_TO, 4))) {
return error;
}
if (strcasecmp(argv[2], "set") == 0) {
is_set = true;
} else if (strcasecmp(argv[2], "inc") == 0) {
is_set = false;
} else {
return cmd_results_new(CMD_INVALID, set_inc_cmd_name, "Invalid %s command. %s, "
"Argument must be on of <set|inc>",
set_inc_cmd_name);
}
char *end;
int n = (int)strtol(argv[3], &end, 10);
if (*end) {
return cmd_results_new(CMD_INVALID, set_inc_cmd_name, "Invalid %s command "
"(argument must be an integer)", set_inc_cmd_name);
}
if (is_auto_layout(container->layout)) {
int inc = 0; /* difference between current master/ncol and requested value */
if (is_nmaster) {
if (is_set) {
if (n < 0) {
return cmd_results_new(CMD_INVALID, set_inc_cmd_name, "Invalid %s command "
"(master must be >= 0)", set_inc_cmd_name);
}
inc = n - (int)container->nb_master;
} else { /* inc command */
if ((int)container->nb_master + n >= 0) {
inc = n;
}
}
if (inc) {
for (int i = container->nb_master;
i >= 0 && i < container->children->length
&& i != (int)container->nb_master + inc;) {
((swayc_t *)container->children->items[i])->height = -1;
((swayc_t *)container->children->items[i])->width = -1;
i += inc > 0 ? 1 : -1;
}
container->nb_master += inc;
need_layout_update = true;
}
} else { /* ncol modification */
if (is_set) {
if (n <= 0) {
return cmd_results_new(CMD_INVALID, set_inc_cmd_name, "Invalid %s command "
"(ncol must be > 0)", set_inc_cmd_name);
}
inc = n - (int)container->nb_slave_groups;
} else { /* inc command */
if ((int)container->nb_slave_groups + n > 0) {
inc = n;
}
}
if (inc) {
container->nb_slave_groups += inc;
need_layout_update = true;
}
}
}
}
if (layout != old_layout) {
swayc_change_layout(container, layout);
update_layout_geometry(container, old_layout);
need_layout_update = true;
}
if (need_layout_update) {
update_geometry(container);
arrange_windows(container, container->width, container->height);
}
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

22
sway/old/commands/log_colors.c
View file

@ -1,22 +0,0 @@
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
#include "log.h"
struct cmd_results *cmd_log_colors(int argc, char **argv) {
struct cmd_results *error = NULL;
if (!config->reading) return cmd_results_new(CMD_FAILURE, "log_colors", "Can only be used in config file.");
if ((error = checkarg(argc, "log_colors", EXPECTED_EQUAL_TO, 1))) {
return error;
}
if (strcasecmp(argv[0], "no") == 0) {
sway_log_colors(0);
} else if (strcasecmp(argv[0], "yes") == 0) {
sway_log_colors(1);
} else {
error = cmd_results_new(CMD_FAILURE, "log_colors",
"Invalid log_colors command (expected `yes` or `no`, got '%s')", argv[0]);
return error;
}
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

87
sway/old/commands/mark.c
View file

@ -1,87 +0,0 @@
#include <string.h>
#include <strings.h>
#include <stdbool.h>
#include "sway/commands.h"
#include "list.h"
#include "stringop.h"
static void find_marks_callback(swayc_t *container, void *_mark) {
char *mark = (char *)_mark;
int index;
if (container->marks && ((index = list_seq_find(container->marks, (int (*)(const void *, const void *))strcmp, mark)) != -1)) {
list_del(container->marks, index);
}
}
struct cmd_results *cmd_mark(int argc, char **argv) {
struct cmd_results *error = NULL;
if (config->reading) return cmd_results_new(CMD_FAILURE, "mark", "Can't be used in config file.");
if ((error = checkarg(argc, "mark", EXPECTED_AT_LEAST, 1))) {
return error;
}
swayc_t *view = current_container;
bool add = false;
bool toggle = false;
if (strcmp(argv[0], "--add") == 0) {
--argc; ++argv;
add = true;
} else if (strcmp(argv[0], "--replace") == 0) {
--argc; ++argv;
}
if (argc && strcmp(argv[0], "--toggle") == 0) {
--argc; ++argv;
toggle = true;
}
if (argc) {
char *mark = join_args(argv, argc);
// Remove all existing marks of this type
container_map(&root_container, find_marks_callback, mark);
if (view->marks) {
if (add) {
int index;
if ((index = list_seq_find(view->marks, (int (*)(const void *, const void *))strcmp, mark)) != -1) {
if (toggle) {
free(view->marks->items[index]);
list_del(view->marks, index);
if (0 == view->marks->length) {
list_free(view->marks);
view->marks = NULL;
}
}
free(mark);
} else {
list_add(view->marks, mark);
}
} else {
if (toggle && list_seq_find(view->marks, (int (*)(const void *, const void *))strcmp, mark) != -1) {
// Delete the list
list_foreach(view->marks, free);
list_free(view->marks);
view->marks = NULL;
} else {
// Delete and replace with a new list
list_foreach(view->marks, free);
list_free(view->marks);
view->marks = create_list();
list_add(view->marks, mark);
}
}
} else {
view->marks = create_list();
list_add(view->marks, mark);
}
} else {
return cmd_results_new(CMD_FAILURE, "mark",
"Expected 'mark [--add|--replace] [--toggle] <mark>'");
}
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

57
sway/old/commands/mode.c
View file

@ -1,57 +0,0 @@
#define _XOPEN_SOURCE 500
#include <stdbool.h>
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
#include "sway/config.h"
#include "sway/ipc-server.h"
#include "list.h"
#include "log.h"
struct cmd_results *cmd_mode(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "mode", EXPECTED_AT_LEAST, 1))) {
return error;
}
const char *mode_name = argv[0];
bool mode_make = (argc == 2 && strcmp(argv[1], "{") == 0);
if (mode_make) {
if (!config->reading)
return cmd_results_new(CMD_FAILURE, "mode", "Can only be used in config file.");
}
struct sway_mode *mode = NULL;
// Find mode
int i, len = config->modes->length;
for (i = 0; i < len; ++i) {
struct sway_mode *find = config->modes->items[i];
if (strcasecmp(find->name, mode_name) == 0) {
mode = find;
break;
}
}
// Create mode if it doesn't exist
if (!mode && mode_make) {
mode = malloc(sizeof(struct sway_mode));
if (!mode) {
return cmd_results_new(CMD_FAILURE, "mode", "Unable to allocate mode");
}
mode->name = strdup(mode_name);
mode->bindings = create_list();
list_add(config->modes, mode);
}
if (!mode) {
error = cmd_results_new(CMD_INVALID, "mode", "Unknown mode `%s'", mode_name);
return error;
}
if ((config->reading && mode_make) || (!config->reading && !mode_make)) {
sway_log(L_DEBUG, "Switching to mode `%s'",mode->name);
}
// Set current mode
config->current_mode = mode;
if (!mode_make) {
// trigger IPC mode event
ipc_event_mode(config->current_mode->name);
}
return cmd_results_new(mode_make ? CMD_BLOCK_MODE : CMD_SUCCESS, NULL, NULL);
}

17
sway/old/commands/mouse_warping.c
View file

@ -1,17 +0,0 @@
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
struct cmd_results *cmd_mouse_warping(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "mouse_warping", EXPECTED_EQUAL_TO, 1))) {
return error;
} else if (strcasecmp(argv[0], "output") == 0) {
config->mouse_warping = true;
} else if (strcasecmp(argv[0], "none") == 0) {
config->mouse_warping = false;
} else {
return cmd_results_new(CMD_FAILURE, "mouse_warping", "Expected 'mouse_warping output|none'");
}
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

189
sway/old/commands/move.c
View file

@ -1,189 +0,0 @@
#define _POSIX_C_SOURCE 200809L
#include <string.h>
#include <strings.h>
#include <wlc/wlc.h>
#include "sway/commands.h"
#include "sway/container.h"
#include "sway/layout.h"
#include "sway/output.h"
#include "sway/workspace.h"
#include "list.h"
#include "stringop.h"
struct cmd_results *cmd_move(int argc, char **argv) {
struct cmd_results *error = NULL;
int move_amt = 10;
if (config->reading) return cmd_results_new(CMD_FAILURE, "move", "Can't be used in config file.");
if ((error = checkarg(argc, "move", EXPECTED_AT_LEAST, 1))) {
return error;
}
const char* expected_syntax = "Expected 'move <left|right|up|down|next|prev|first> <[px] px>' or "
"'move <container|window> to workspace <name>' or "
"'move <container|window|workspace> to output <name|direction>' or "
"'move position mouse'";
swayc_t *view = current_container;
if (argc == 2 || (argc == 3 && strcasecmp(argv[2], "px") == 0 )) {
char *inv;
move_amt = (int)strtol(argv[1], &inv, 10);
if (*inv != '\0' && strcasecmp(inv, "px") != 0) {
move_amt = 10;
}
}
if (strcasecmp(argv[0], "left") == 0) {
move_container(view, MOVE_LEFT, move_amt);
} else if (strcasecmp(argv[0], "right") == 0) {
move_container(view, MOVE_RIGHT, move_amt);
} else if (strcasecmp(argv[0], "up") == 0) {
move_container(view, MOVE_UP, move_amt);
} else if (strcasecmp(argv[0], "down") == 0) {
move_container(view, MOVE_DOWN, move_amt);
} else if (strcasecmp(argv[0], "next") == 0) {
move_container(view, MOVE_NEXT, move_amt);
} else if (strcasecmp(argv[0], "prev") == 0) {
move_container(view, MOVE_PREV, move_amt);
} else if (strcasecmp(argv[0], "first") == 0) {
move_container(view, MOVE_FIRST, move_amt);
} else if (strcasecmp(argv[0], "container") == 0 || strcasecmp(argv[0], "window") == 0) {
// "move container ...
if ((error = checkarg(argc, "move container/window", EXPECTED_AT_LEAST, 4))) {
return error;
} else if (strcasecmp(argv[1], "to") == 0 && strcasecmp(argv[2], "workspace") == 0) {
// move container to workspace x
if (view->type == C_WORKSPACE) {
if (!view->children || view->children->length == 0) {
return cmd_results_new(CMD_FAILURE, "move", "Cannot move an empty workspace");
}
view = new_container(view, view->workspace_layout);
} if (view->type != C_CONTAINER && view->type != C_VIEW) {
return cmd_results_new(CMD_FAILURE, "move", "Can only move containers and views.");
}
swayc_t *ws;
const char *num_name = NULL;
char *ws_name = NULL;
if (argc == 5 && strcasecmp(argv[3], "number") == 0) {
// move "container to workspace number x"
num_name = argv[4];
ws = workspace_by_number(num_name);
} else {
ws_name = join_args(argv + 3, argc - 3);
ws = workspace_by_name(ws_name);
}
if (ws == NULL) {
ws = workspace_create(ws_name ? ws_name : num_name);
}
if (ws_name) {
free(ws_name);
}
move_container_to(view, get_focused_container(ws));
} else if (strcasecmp(argv[1], "to") == 0 && strcasecmp(argv[2], "output") == 0) {
// move container to output x
swayc_t *output = NULL;
struct wlc_point abs_pos;
get_absolute_center_position(view, &abs_pos);
if (view->type == C_WORKSPACE) {
if (!view->children || view->children->length == 0) {
return cmd_results_new(CMD_FAILURE, "move", "Cannot move an empty workspace");
}
view = new_container(view, view->workspace_layout);
} else if (view->type != C_CONTAINER && view->type != C_VIEW) {
return cmd_results_new(CMD_FAILURE, "move", "Can only move containers and views.");
} else if (!(output = output_by_name(argv[3], &abs_pos))) {
return cmd_results_new(CMD_FAILURE, "move",
"Can't find output with name/direction '%s' @ (%i,%i)", argv[3], abs_pos.x, abs_pos.y);
}
swayc_t *container = get_focused_container(output);
if (container->is_floating) {
move_container_to(view, container->parent);
} else {
move_container_to(view, container);
}
} else {
return cmd_results_new(CMD_INVALID, "move", expected_syntax);
}
} else if (strcasecmp(argv[0], "workspace") == 0) {
// move workspace (to output x)
swayc_t *output = NULL;
struct wlc_point abs_pos;
get_absolute_center_position(view, &abs_pos);
if ((error = checkarg(argc, "move workspace", EXPECTED_EQUAL_TO, 4))) {
return error;
} else if (strcasecmp(argv[1], "to") != 0 || strcasecmp(argv[2], "output") != 0) {
return cmd_results_new(CMD_INVALID, "move", expected_syntax);
} else if (!(output = output_by_name(argv[3], &abs_pos))) {
return cmd_results_new(CMD_FAILURE, "move workspace",
"Can't find output with name/direction '%s' @ (%i,%i)", argv[3], abs_pos.x, abs_pos.y);
}
if (view->type == C_WORKSPACE) {
// This probably means we're moving an empty workspace, but
// that's fine.
move_workspace_to(view, output);
} else {
swayc_t *workspace = swayc_parent_by_type(view, C_WORKSPACE);
move_workspace_to(workspace, output);
}
} else if (strcasecmp(argv[0], "scratchpad") == 0 || (strcasecmp(argv[0], "to") == 0 && strcasecmp(argv[1], "scratchpad") == 0)) {
// move scratchpad ...
if (view->type != C_CONTAINER && view->type != C_VIEW) {
return cmd_results_new(CMD_FAILURE, "move scratchpad", "Can only move containers and views.");
}
swayc_t *view = current_container;
int i;
for (i = 0; i < scratchpad->length; i++) {
if (scratchpad->items[i] == view) {
hide_view_in_scratchpad(view);
sp_view = NULL;
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}
}
list_add(scratchpad, view);
if (!view->is_floating) {
destroy_container(remove_child(view));
} else {
remove_child(view);
}
wlc_view_set_mask(view->handle, 0);
arrange_windows(swayc_active_workspace(), -1, -1);
swayc_t *focused = container_under_pointer();
if (focused == NULL) {
focused = swayc_active_workspace();
}
set_focused_container(focused);
} else if (strcasecmp(argv[0], "position") == 0) {
if ((error = checkarg(argc, "move workspace", EXPECTED_EQUAL_TO, 2))) {
return error;
}
if (strcasecmp(argv[1], "mouse")) {
return cmd_results_new(CMD_INVALID, "move", expected_syntax);
}
if (view->is_floating) {
swayc_t *output = swayc_parent_by_type(view, C_OUTPUT);
struct wlc_geometry g;
wlc_view_get_visible_geometry(view->handle, &g);
const struct wlc_size *size = wlc_output_get_resolution(output->handle);
double x_pos, y_pos;
wlc_pointer_get_position_v2(&x_pos, &y_pos);
int32_t x = x_pos - g.size.w / 2;
int32_t y = y_pos - g.size.h / 2;
uint32_t w = size->w - g.size.w;
uint32_t h = size->h - g.size.h;
view->x = g.origin.x = MIN((int32_t)w, MAX(x, 0));
view->y = g.origin.y = MIN((int32_t)h, MAX(y, 0));
wlc_view_set_geometry(view->handle, 0, &g);
}
} else {
return cmd_results_new(CMD_INVALID, "move", expected_syntax);
}
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

8
sway/old/commands/new_float.c
View file

@ -1,8 +0,0 @@
#include "log.h"
#include "sway/commands.h"
struct cmd_results *cmd_new_float(int argc, char **argv) {
sway_log(L_INFO, "`new_float` is deprecated and will be removed in the future. "
"Please use `default_floating_border` instead.");
return cmd_default_floating_border(argc, argv);
}

8
sway/old/commands/new_window.c
View file

@ -1,8 +0,0 @@
#include "log.h"
#include "sway/commands.h"
struct cmd_results *cmd_new_window(int argc, char **argv) {
sway_log(L_INFO, "`new_window` is deprecated and will be removed in the future. "
"Please use `default_border` instead.");
return cmd_default_border(argc, argv);
}

41
sway/old/commands/no_focus.c
View file

@ -1,41 +0,0 @@
#define _XOPEN_SOURCE 500
#include <string.h>
#include "sway/commands.h"
#include "sway/criteria.h"
#include "list.h"
#include "log.h"
#include "stringop.h"
struct cmd_results *cmd_no_focus(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "no_focus", EXPECTED_EQUAL_TO, 1))) {
return error;
}
// add command to a criteria/command pair that is run against views when they appear.
char *criteria = argv[0];
struct criteria *crit = malloc(sizeof(struct criteria));
if (!crit) {
return cmd_results_new(CMD_FAILURE, "no_focus", "Unable to allocate criteria");
}
crit->crit_raw = strdup(criteria);
crit->tokens = create_list();
crit->cmdlist = NULL;
char *err_str = extract_crit_tokens(crit->tokens, crit->crit_raw);
if (err_str) {
error = cmd_results_new(CMD_INVALID, "no_focus", err_str);
free(err_str);
free_criteria(crit);
} else if (crit->tokens->length == 0) {
error = cmd_results_new(CMD_INVALID, "no_focus", "Found no name/value pairs in criteria");
free_criteria(crit);
} else if (list_seq_find(config->no_focus, criteria_cmp, crit) != -1) {
sway_log(L_DEBUG, "no_focus: Duplicate, skipping.");
free_criteria(crit);
} else {
sway_log(L_DEBUG, "no_focus: '%s' added", crit->crit_raw);
list_add(config->no_focus, crit);
}
return error ? error : cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

21
sway/old/commands/orientation.c
View file

@ -1,21 +0,0 @@
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
struct cmd_results *cmd_orientation(int argc, char **argv) {
struct cmd_results *error = NULL;
if (!config->reading) return cmd_results_new(CMD_FAILURE, "orientation", "Can only be used in config file.");
if ((error = checkarg(argc, "orientation", EXPECTED_EQUAL_TO, 1))) {
return error;
}
if (strcasecmp(argv[0], "horizontal") == 0) {
config->default_orientation = L_HORIZ;
} else if (strcasecmp(argv[0], "vertical") == 0) {
config->default_orientation = L_VERT;
} else if (strcasecmp(argv[0], "auto") == 0) {
// Do nothing
} else {
return cmd_results_new(CMD_INVALID, "orientation", "Expected 'orientation <horizontal|vertical|auto>'");
}
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

219
sway/old/commands/output.c
View file

@ -1,219 +0,0 @@
#define _XOPEN_SOURCE 500
#include <ctype.h>
#include <libgen.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <unistd.h>
#include <wordexp.h>
#include "sway/commands.h"
#include "sway/config.h"
#include "list.h"
#include "log.h"
#include "stringop.h"
static char *bg_options[] = {
"stretch",
"center",
"fill",
"fit",
"tile"
};
struct cmd_results *cmd_output(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "output", EXPECTED_AT_LEAST, 1))) {
return error;
}
const char *name = argv[0];
struct output_config *output = calloc(1, sizeof(struct output_config));
if (!output) {
return cmd_results_new(CMD_FAILURE, "output", "Unable to allocate output config");
}
output->x = output->y = output->width = output->height = -1;
output->name = strdup(name);
output->enabled = -1;
output->scale = 1;
// TODO: atoi doesn't handle invalid numbers
int i;
for (i = 1; i < argc; ++i) {
const char *command = argv[i];
if (strcasecmp(command, "disable") == 0) {
output->enabled = 0;
} else if (strcasecmp(command, "resolution") == 0 || strcasecmp(command, "res") == 0) {
if (++i >= argc) {
error = cmd_results_new(CMD_INVALID, "output", "Missing resolution argument.");
goto fail;
}
char *res = argv[i];
char *x = strchr(res, 'x');
int width = -1, height = -1;
if (x != NULL) {
// Format is 1234x4321
*x = '\0';
width = atoi(res);
height = atoi(x + 1);
*x = 'x';
} else {
// Format is 1234 4321
width = atoi(res);
if (++i >= argc) {
error = cmd_results_new(CMD_INVALID, "output", "Missing resolution argument (height).");
goto fail;
}
res = argv[i];
height = atoi(res);
}
output->width = width;
output->height = height;
} else if (strcasecmp(command, "position") == 0 || strcasecmp(command, "pos") == 0) {
if (++i >= argc) {
error = cmd_results_new(CMD_INVALID, "output", "Missing position argument.");
goto fail;
}
char *res = argv[i];
char *c = strchr(res, ',');
int x = -1, y = -1;
if (c != NULL) {
// Format is 1234,4321
*c = '\0';
x = atoi(res);
y = atoi(c + 1);
*c = ',';
} else {
// Format is 1234 4321
x = atoi(res);
if (++i >= argc) {
error = cmd_results_new(CMD_INVALID, "output", "Missing position argument (y).");
goto fail;
}
res = argv[i];
y = atoi(res);
}
output->x = x;
output->y = y;
} else if (strcasecmp(command, "scale") == 0) {
if (++i >= argc) {
error = cmd_results_new(CMD_INVALID, "output", "Missing scale parameter.");
goto fail;
}
output->scale = atoi(argv[i]);
} else if (strcasecmp(command, "background") == 0 || strcasecmp(command, "bg") == 0) {
wordexp_t p;
if (++i >= argc) {
error = cmd_results_new(CMD_INVALID, "output", "Missing background file or color specification.");
goto fail;
}
if (i + 1 >= argc) {
error = cmd_results_new(CMD_INVALID, "output", "Missing background scaling mode or `solid_color`.");
goto fail;
}
if (strcasecmp(argv[i + 1], "solid_color") == 0) {
output->background = strdup(argv[argc - 2]);
output->background_option = strdup("solid_color");
} else {
// argv[i+j]=bg_option
bool valid = false;
char *mode;
size_t j;
for (j = 0; j < (size_t) (argc - i); ++j) {
mode = argv[i + j];
for (size_t k = 0; k < sizeof(bg_options) / sizeof(char *); ++k) {
if (strcasecmp(mode, bg_options[k]) == 0) {
valid = true;
break;
}
}
if (valid) {
break;
}
}
if (!valid) {
error = cmd_results_new(CMD_INVALID, "output", "Missing background scaling mode.");
goto fail;
}
char *src = join_args(argv + i, j);
if (wordexp(src, &p, 0) != 0 || p.we_wordv[0] == NULL) {
error = cmd_results_new(CMD_INVALID, "output", "Invalid syntax (%s)", src);
goto fail;
}
free(src);
src = p.we_wordv[0];
if (config->reading && *src != '/') {
char *conf = strdup(config->current_config);
if (conf) {
char *conf_path = dirname(conf);
src = malloc(strlen(conf_path) + strlen(src) + 2);
if (src) {
sprintf(src, "%s/%s", conf_path, p.we_wordv[0]);
} else {
sway_log(L_ERROR, "Unable to allocate background source");
}
free(conf);
} else {
sway_log(L_ERROR, "Unable to allocate background source");
}
}
if (!src || access(src, F_OK) == -1) {
error = cmd_results_new(CMD_INVALID, "output", "Background file unreadable (%s)", src);
wordfree(&p);
goto fail;
}
output->background = strdup(src);
output->background_option = strdup(mode);
if (src != p.we_wordv[0]) {
free(src);
}
wordfree(&p);
i += j;
}
}
}
i = list_seq_find(config->output_configs, output_name_cmp, name);
if (i >= 0) {
// merge existing config
struct output_config *oc = config->output_configs->items[i];
merge_output_config(oc, output);
free_output_config(output);
output = oc;
} else {
list_add(config->output_configs, output);
}
sway_log(L_DEBUG, "Config stored for output %s (enabled:%d) (%d x %d @ %d, %d scale %d) (bg %s %s)",
output->name, output->enabled, output->width,
output->height, output->x, output->y, output->scale,
output->background, output->background_option);
if (output->name) {
// Try to find the output container and apply configuration now. If
// this is during startup then there will be no container and config
// will be applied during normal "new output" event from wlc.
swayc_t *cont = NULL;
for (int i = 0; i < root_container.children->length; ++i) {
cont = root_container.children->items[i];
if (cont->name && ((strcmp(cont->name, output->name) == 0) || (strcmp(output->name, "*") == 0))) {
apply_output_config(output, cont);
if (strcmp(output->name, "*") != 0) {
// stop looking if the output config isn't applicable to all outputs
break;
}
}
}
}
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
fail:
free_output_config(output);
return error;
}

108
sway/old/commands/permit.c
View file

@ -1,108 +0,0 @@
#define _XOPEN_SOURCE 500
#include <string.h>
#include "sway/commands.h"
#include "sway/config.h"
#include "sway/security.h"
#include "util.h"
#include "log.h"
static enum secure_feature get_features(int argc, char **argv,
struct cmd_results **error) {
enum secure_feature features = 0;
struct {
char *name;
enum secure_feature feature;
} feature_names[] = {
{ "lock", FEATURE_LOCK },
{ "panel", FEATURE_PANEL },
{ "background", FEATURE_BACKGROUND },
{ "screenshot", FEATURE_SCREENSHOT },
{ "fullscreen", FEATURE_FULLSCREEN },
{ "keyboard", FEATURE_KEYBOARD },
{ "mouse", FEATURE_MOUSE },
};
for (int i = 1; i < argc; ++i) {
size_t j;
for (j = 0; j < sizeof(feature_names) / sizeof(feature_names[0]); ++j) {
if (strcmp(feature_names[j].name, argv[i]) == 0) {
break;
}
}
if (j == sizeof(feature_names) / sizeof(feature_names[0])) {
*error = cmd_results_new(CMD_INVALID,
"permit", "Invalid feature grant %s", argv[i]);
return 0;
}
features |= feature_names[j].feature;
}
return features;
}
struct cmd_results *cmd_permit(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "permit", EXPECTED_MORE_THAN, 1))) {
return error;
}
if ((error = check_security_config())) {
return error;
}
bool assign_perms = true;
char *program = NULL;
if (!strcmp(argv[0], "*")) {
program = strdup(argv[0]);
} else {
program = resolve_path(argv[0]);
}
if (!program) {
sway_assert(program, "Unable to resolve IPC permit target '%s'."
" will issue empty policy", argv[0]);
assign_perms = false;
program = strdup(argv[0]);
}
struct feature_policy *policy = get_feature_policy(program);
if (policy && assign_perms) {
policy->features |= get_features(argc, argv, &error);
sway_log(L_DEBUG, "Permissions granted to %s for features %d",
policy->program, policy->features);
}
free(program);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}
struct cmd_results *cmd_reject(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "reject", EXPECTED_MORE_THAN, 1))) {
return error;
}
if ((error = check_security_config())) {
return error;
}
char *program = NULL;
if (!strcmp(argv[0], "*")) {
program = strdup(argv[0]);
} else {
program = resolve_path(argv[0]);
}
if (!program) {
// Punt
sway_log(L_INFO, "Unable to resolve IPC reject target '%s'."
" Will use provided path", argv[0]);
program = strdup(argv[0]);
}
struct feature_policy *policy = get_feature_policy(program);
policy->features &= ~get_features(argc, argv, &error);
sway_log(L_DEBUG, "Permissions granted to %s for features %d",
policy->program, policy->features);
free(program);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

19
sway/old/commands/reload.c
View file

@ -1,19 +0,0 @@
#include "sway/commands.h"
#include "sway/config.h"
#include "sway/layout.h"
struct cmd_results *cmd_reload(int argc, char **argv) {
struct cmd_results *error = NULL;
if (config->reading) return cmd_results_new(CMD_FAILURE, "reload", "Can't be used in config file.");
if ((error = checkarg(argc, "reload", EXPECTED_EQUAL_TO, 0))) {
return error;
}
if (!load_main_config(config->current_config, true)) {
return cmd_results_new(CMD_FAILURE, "reload", "Error(s) reloading config.");
}
load_swaybars();
arrange_windows(&root_container, -1, -1);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

375
sway/old/commands/resize.c
View file

@ -1,375 +0,0 @@
#include <errno.h>
#include <math.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <wlc/wlc.h>
#include "sway/commands.h"
#include "sway/layout.h"
#include "sway/focus.h"
#include "sway/input_state.h"
#include "sway/handlers.h"
#include "log.h"
enum resize_dim_types {
RESIZE_DIM_PX,
RESIZE_DIM_PPT,
RESIZE_DIM_DEFAULT,
};
static bool set_size_floating(int new_dimension, bool use_width) {
swayc_t *view = current_container;
if (view) {
if (use_width) {
int current_width = view->width;
view->desired_width = new_dimension;
floating_view_sane_size(view);
int new_x = view->x + (int)(((view->desired_width - current_width) / 2) * -1);
view->width = view->desired_width;
view->x = new_x;
update_geometry(view);
} else {
int current_height = view->height;
view->desired_height = new_dimension;
floating_view_sane_size(view);
int new_y = view->y + (int)(((view->desired_height - current_height) / 2) * -1);
view->height = view->desired_height;
view->y = new_y;
update_geometry(view);
}
return true;
}
return false;
}
static bool resize_floating(int amount, bool use_width) {
swayc_t *view = current_container;
if (view) {
if (use_width) {
return set_size_floating(view->width + amount, true);
} else {
return set_size_floating(view->height + amount, false);
}
}
return false;
}
static bool resize_tiled(int amount, bool use_width) {
swayc_t *container = current_container;
swayc_t *parent = container->parent;
int idx_focused = 0;
bool use_major = false;
size_t nb_before = 0;
size_t nb_after = 0;
// 1. Identify a container ancestor that will allow the focused child to grow in the requested
// direction.
while (container->parent) {
parent = container->parent;
if ((parent->children && parent->children->length > 1)
&& (is_auto_layout(parent->layout)
|| (use_width ? parent->layout == L_HORIZ : parent->layout == L_VERT))) {
// check if container has siblings that can provide/absorb the space needed for
// the resize operation.
use_major = use_width
? parent->layout == L_AUTO_LEFT || parent->layout == L_AUTO_RIGHT
: parent->layout == L_AUTO_TOP || parent->layout == L_AUTO_BOTTOM;
// Note: use_major will be false for L_HORIZ and L_VERT
idx_focused = index_child(container);
if (idx_focused < 0) {
sway_log(L_ERROR, "Something weird is happening, child container not "
"present in its parent's children list.");
continue;
}
if (use_major) {
nb_before = auto_group_index(parent, idx_focused);
nb_after = auto_group_count(parent) - nb_before - 1;
} else {
nb_before = idx_focused - auto_group_start_index(parent, idx_focused);
nb_after = auto_group_end_index(parent, idx_focused) - idx_focused - 1;
sway_log(L_DEBUG, "+++ focused: %d, start: %d, end: %d, before: %d, after: %d",
idx_focused,
(int)auto_group_start_index(parent, idx_focused),
(int)auto_group_end_index(parent, idx_focused),
(int)nb_before, (int)nb_after);
}
if (nb_before || nb_after) {
break;
}
}
container = parent; /* continue up the tree to the next ancestor */
}
if (parent == &root_container) {
return true;
}
sway_log(L_DEBUG, "Found the proper parent: %p. It has %zu before conts, "
"and %zu after conts", parent, nb_before, nb_after);
// 2. Ensure that the resize operation will not make one of the resized containers drop
// below the "sane" size threshold.
bool valid = true;
swayc_t *focused = parent->children->items[idx_focused];
int start = use_major ? 0 : auto_group_start_index(parent, idx_focused);
int end = use_major ? parent->children->length : auto_group_end_index(parent, idx_focused);
sway_log(L_DEBUG, "Check children of container %p [%d,%d[", container, start, end);
for (int i = start; i < end; ) {
swayc_t *sibling = parent->children->items[i];
double pixels = amount;
bool is_before = use_width ? sibling->x < focused->x : sibling->y < focused->y;
bool is_after = use_width ? sibling->x > focused->x : sibling->y > focused->y;
if (is_before || is_after) {
pixels = -pixels;
pixels /= is_before ? nb_before : nb_after;
if (nb_after != 0 && nb_before != 0) {
pixels /= 2;
}
}
sway_log(L_DEBUG, "Check container %p: width %g vs %d, height %g vs %d", sibling, sibling->width + pixels, min_sane_w, sibling->height + pixels, min_sane_h);
if (use_width ?
sibling->width + pixels < min_sane_w :
sibling->height + pixels < min_sane_h) {
valid = false;
sway_log(L_DEBUG, "Container size no longer sane");
break;
}
i = use_major ? auto_group_end_index(parent, i) : (i + 1);
sway_log(L_DEBUG, "+++++ check %i", i);
}
// 3. Apply the size change
if (valid) {
for (int i = start; i < end; ) {
int next_i = use_major ? auto_group_end_index(parent, i) : (i + 1);
swayc_t *sibling = parent->children->items[i];
double pixels = amount;
bool is_before = use_width ? sibling->x < focused->x : sibling->y < focused->y;
bool is_after = use_width ? sibling->x > focused->x : sibling->y > focused->y;
if (is_before || is_after) {
pixels = -pixels;
pixels /= is_before ? nb_before : nb_after;
if (nb_after != 0 && nb_before != 0) {
pixels /= 2;
}
sway_log(L_DEBUG, "%p: %s", sibling, is_before ? "before" : "after");
if (use_major) {
for (int j = i; j < next_i; ++j) {
recursive_resize(parent->children->items[j], pixels,
use_width ?
(is_before ? WLC_RESIZE_EDGE_RIGHT : WLC_RESIZE_EDGE_LEFT) :
(is_before ? WLC_RESIZE_EDGE_BOTTOM : WLC_RESIZE_EDGE_TOP));
}
} else {
recursive_resize(sibling, pixels,
use_width ?
(is_before ? WLC_RESIZE_EDGE_RIGHT : WLC_RESIZE_EDGE_LEFT) :
(is_before ? WLC_RESIZE_EDGE_BOTTOM : WLC_RESIZE_EDGE_TOP));
}
} else {
if (use_major) {
for (int j = i; j < next_i; ++j) {
recursive_resize(parent->children->items[j], pixels / 2,
use_width ? WLC_RESIZE_EDGE_LEFT : WLC_RESIZE_EDGE_TOP);
recursive_resize(parent->children->items[j], pixels / 2,
use_width ? WLC_RESIZE_EDGE_RIGHT : WLC_RESIZE_EDGE_BOTTOM);
}
} else {
recursive_resize(sibling, pixels / 2,
use_width ? WLC_RESIZE_EDGE_LEFT : WLC_RESIZE_EDGE_TOP);
recursive_resize(sibling, pixels / 2,
use_width ? WLC_RESIZE_EDGE_RIGHT : WLC_RESIZE_EDGE_BOTTOM);
}
}
i = next_i;
}
// Recursive resize does not handle positions, let arrange_windows
// take care of that.
arrange_windows(swayc_active_workspace(), -1, -1);
}
return true;
}
static bool set_size_tiled(int amount, bool use_width) {
int desired;
swayc_t *focused = current_container;
if (use_width) {
desired = amount - focused->width;
} else {
desired = amount - focused->height;
}
return resize_tiled(desired, use_width);
}
static bool set_size(int dimension, bool use_width) {
swayc_t *focused = current_container;
if (focused) {
if (focused->is_floating) {
return set_size_floating(dimension, use_width);
} else {
return set_size_tiled(dimension, use_width);
}
}
return false;
}
static bool resize(int dimension, bool use_width, enum resize_dim_types dim_type) {
swayc_t *focused = current_container;
// translate "10 ppt" (10%) to appropriate # of pixels in case we need it
float ppt_dim = (float)dimension / 100;
if (use_width) {
ppt_dim = focused->width * ppt_dim;
} else {
ppt_dim = focused->height * ppt_dim;
}
if (focused) {
if (focused->is_floating) {
// floating view resize dimensions should default to px, so only
// use ppt if specified
if (dim_type == RESIZE_DIM_PPT) {
dimension = (int)ppt_dim;
}
return resize_floating(dimension, use_width);
} else {
// tiled view resize dimensions should default to ppt, so only use
// px if specified
if (dim_type != RESIZE_DIM_PX) {
dimension = (int)ppt_dim;
}
return resize_tiled(dimension, use_width);
}
}
return false;
}
static struct cmd_results *cmd_resize_set(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "resize set", EXPECTED_AT_LEAST, 2))) {
return error;
}
if (strcasecmp(argv[0], "width") == 0 || strcasecmp(argv[0], "height") == 0) {
// handle `reset set width 100 px height 100 px` syntax, also allows
// specifying only one dimension for a `resize set`
int cmd_num = 0;
int dim;
while ((cmd_num + 1) < argc) {
dim = (int)strtol(argv[cmd_num + 1], NULL, 10);
if (errno == ERANGE || dim == 0) {
errno = 0;
return cmd_results_new(CMD_INVALID, "resize set",
"Expected 'resize set <width|height> <amount> [px] [<width|height> <amount> [px]]'");
}
if (strcasecmp(argv[cmd_num], "width") == 0) {
set_size(dim, true);
} else if (strcasecmp(argv[cmd_num], "height") == 0) {
set_size(dim, false);
} else {
return cmd_results_new(CMD_INVALID, "resize set",
"Expected 'resize set <width|height> <amount> [px] [<width|height> <amount> [px]]'");
}
cmd_num += 2;
if (cmd_num < argc && strcasecmp(argv[cmd_num], "px") == 0) {
// if this was `resize set width 400 px height 300 px`, disregard the `px` arg
cmd_num++;
}
}
} else {
// handle `reset set 100 px 100 px` syntax
int width = (int)strtol(argv[0], NULL, 10);
if (errno == ERANGE || width == 0) {
errno = 0;
return cmd_results_new(CMD_INVALID, "resize set",
"Expected 'resize set <width> [px] <height> [px]'");
}
int height_arg = 1;
if (strcasecmp(argv[1], "px") == 0) {
height_arg = 2;
}
int height = (int)strtol(argv[height_arg], NULL, 10);
if (errno == ERANGE || height == 0) {
errno = 0;
return cmd_results_new(CMD_INVALID, "resize set",
"Expected 'resize set <width> [px] <height> [px]'");
}
set_size(width, true);
set_size(height, false);
}
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}
struct cmd_results *cmd_resize(int argc, char **argv) {
struct cmd_results *error = NULL;
if (config->reading) return cmd_results_new(CMD_FAILURE, "resize", "Can't be used in config file.");
if (!config->active) return cmd_results_new(CMD_FAILURE, "resize", "Can only be used when sway is running.");
if (strcasecmp(argv[0], "set") == 0) {
return cmd_resize_set(argc - 1, &argv[1]);
}
if ((error = checkarg(argc, "resize", EXPECTED_AT_LEAST, 2))) {
return error;
}
int dim_arg = argc - 1;
enum resize_dim_types dim_type = RESIZE_DIM_DEFAULT;
if (strcasecmp(argv[dim_arg], "ppt") == 0) {
dim_type = RESIZE_DIM_PPT;
dim_arg--;
} else if (strcasecmp(argv[dim_arg], "px") == 0) {
dim_type = RESIZE_DIM_PX;
dim_arg--;
}
int amount = (int)strtol(argv[dim_arg], NULL, 10);
if (errno == ERANGE || amount == 0) {
errno = 0;
amount = 10; // this is the default resize dimension used by i3 for both px and ppt
sway_log(L_DEBUG, "Tried to get resize dimension out of '%s' but failed; setting dimension to default %d",
argv[dim_arg], amount);
}
bool use_width = false;
if (strcasecmp(argv[1], "width") == 0) {
use_width = true;
} else if (strcasecmp(argv[1], "height") != 0) {
return cmd_results_new(CMD_INVALID, "resize",
"Expected 'resize <shrink|grow> <width|height> [<amount>] [px|ppt]'");
}
if (strcasecmp(argv[0], "shrink") == 0) {
amount *= -1;
} else if (strcasecmp(argv[0], "grow") != 0) {
return cmd_results_new(CMD_INVALID, "resize",
"Expected 'resize <shrink|grow> <width|height> [<amount>] [px|ppt]'");
}
resize(amount, use_width, dim_type);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

72
sway/old/commands/scratchpad.c
View file

@ -1,72 +0,0 @@
#include <string.h>
#include <strings.h>
#include <wlc/wlc.h>
#include "sway/commands.h"
#include "sway/container.h"
#include "sway/focus.h"
#include "sway/layout.h"
static swayc_t *fetch_view_from_scratchpad() {
sp_index = (sp_index + 1) % scratchpad->length;
swayc_t *view = scratchpad->items[sp_index];
if (wlc_view_get_output(view->handle) != swayc_active_output()->handle) {
wlc_view_set_output(view->handle, swayc_active_output()->handle);
}
if (!view->is_floating) {
view->width = swayc_active_workspace()->width * 0.5;
view->height = swayc_active_workspace()->height * 0.75;
view->x = (swayc_active_workspace()->width - view->width)/2;
view->y = (swayc_active_workspace()->height - view->height)/2;
}
if (swayc_active_workspace()->width < view->x + 20 || view->x + view->width < 20) {
view->x = (swayc_active_workspace()->width - view->width)/2;
}
if (swayc_active_workspace()->height < view->y + 20 || view->y + view->height < 20) {
view->y = (swayc_active_workspace()->height - view->height)/2;
}
add_floating(swayc_active_workspace(), view);
wlc_view_set_mask(view->handle, VISIBLE);
view->visible = true;
arrange_windows(swayc_active_workspace(), -1, -1);
set_focused_container(view);
return view;
}
struct cmd_results *cmd_scratchpad(int argc, char **argv) {
struct cmd_results *error = NULL;
if (config->reading) return cmd_results_new(CMD_FAILURE, "scratchpad", "Can't be used in config file.");
if (!config->active) return cmd_results_new(CMD_FAILURE, "scratchpad", "Can only be used when sway is running.");
if ((error = checkarg(argc, "scratchpad", EXPECTED_EQUAL_TO, 1))) {
return error;
}
if (strcasecmp(argv[0], "show") == 0 && scratchpad->length > 0) {
if (!sp_view) {
if (current_container) {
// Haxor the scratchpad index if criteria'd
for (int i = 0; i < scratchpad->length; ++i) {
if (scratchpad->items[i] == current_container) {
sp_index = (i - 1) % scratchpad->length;
}
}
}
sp_view = fetch_view_from_scratchpad();
} else {
if (swayc_active_workspace() != sp_view->parent) {
hide_view_in_scratchpad(sp_view);
if (sp_index == 0) {
sp_index = scratchpad->length;
}
sp_index--;
sp_view = fetch_view_from_scratchpad();
} else {
hide_view_in_scratchpad(sp_view);
sp_view = NULL;
}
}
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}
return cmd_results_new(CMD_FAILURE, "scratchpad", "Expected 'scratchpad show' when scratchpad is not empty.");
}

13
sway/old/commands/seamless_mouse.c
View file

@ -1,13 +0,0 @@
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
struct cmd_results *cmd_seamless_mouse(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "seamless_mouse", EXPECTED_EQUAL_TO, 1))) {
return error;
}
config->seamless_mouse = (strcasecmp(argv[0], "on") == 0 || strcasecmp(argv[0], "yes") == 0);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

61
sway/old/commands/set.c
View file

@ -1,61 +0,0 @@
#define _XOPEN_SOURCE 700
#include <stdio.h>
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
#include "sway/config.h"
#include "list.h"
#include "stringop.h"
// sort in order of longest->shortest
static int compare_set_qsort(const void *_l, const void *_r) {
struct sway_variable const *l = *(void **)_l;
struct sway_variable const *r = *(void **)_r;
return strlen(r->name) - strlen(l->name);
}
struct cmd_results *cmd_set(int argc, char **argv) {
char *tmp;
struct cmd_results *error = NULL;
if (!config->reading) return cmd_results_new(CMD_FAILURE, "set", "Can only be used in config file.");
if ((error = checkarg(argc, "set", EXPECTED_AT_LEAST, 2))) {
return error;
}
if (argv[0][0] != '$') {
sway_log(L_INFO, "Warning: variable '%s' doesn't start with $", argv[0]);
size_t size = snprintf(NULL, 0, "$%s", argv[0]);
tmp = malloc(size + 1);
if (!tmp) {
return cmd_results_new(CMD_FAILURE, "set", "Not possible to create variable $'%s'", argv[0]);
}
snprintf(tmp, size+1, "$%s", argv[0]);
argv[0] = tmp;
}
struct sway_variable *var = NULL;
// Find old variable if it exists
int i;
for (i = 0; i < config->symbols->length; ++i) {
var = config->symbols->items[i];
if (strcmp(var->name, argv[0]) == 0) {
break;
}
var = NULL;
}
if (var) {
free(var->value);
} else {
var = malloc(sizeof(struct sway_variable));
if (!var) {
return cmd_results_new(CMD_FAILURE, "set", "Unable to allocate variable");
}
var->name = strdup(argv[0]);
list_add(config->symbols, var);
list_qsort(config->symbols, compare_set_qsort);
}
var->value = join_args(argv + 1, argc - 1);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

13
sway/old/commands/show_marks.c
View file

@ -1,13 +0,0 @@
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
struct cmd_results *cmd_show_marks(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "show_marks", EXPECTED_EQUAL_TO, 1))) {
return error;
}
config->show_marks = !strcasecmp(argv[0], "on");
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

20
sway/old/commands/smart_gaps.c
View file

@ -1,20 +0,0 @@
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
struct cmd_results *cmd_smart_gaps(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "smart_gaps", EXPECTED_EQUAL_TO, 1))) {
return error;
}
if (strcasecmp(argv[0], "on") == 0) {
config->smart_gaps = true;
} else if (strcasecmp(argv[0], "off") == 0) {
config->smart_gaps = false;
} else {
return cmd_results_new(CMD_INVALID, "smart_gaps", "Expected 'smart_gaps <on|off>'");
}
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

98
sway/old/commands/split.c
View file

@ -1,98 +0,0 @@
#include <string.h>
#include <strings.h>
#include <wlc/wlc-render.h>
#include "sway/border.h"
#include "sway/commands.h"
#include "sway/container.h"
#include "sway/focus.h"
#include "sway/layout.h"
#include "log.h"
static struct cmd_results *_do_split(int argc, char **argv, int layout) {
char *name = layout == L_VERT ? "splitv" :
layout == L_HORIZ ? "splith" : "split";
struct cmd_results *error = NULL;
if (config->reading) return cmd_results_new(CMD_FAILURE, name, "Can't be used in config file.");
if (!config->active) return cmd_results_new(CMD_FAILURE, name, "Can only be used when sway is running.");
if ((error = checkarg(argc, name, EXPECTED_EQUAL_TO, 0))) {
return error;
}
swayc_t *focused = current_container;
// Case of floating window, don't split
if (focused->is_floating) {
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}
/* Case that focus is on an workspace with 0/1 children.change its layout */
if (focused->type == C_WORKSPACE && focused->children->length <= 1) {
sway_log(L_DEBUG, "changing workspace layout");
swayc_change_layout(focused, layout);
} else if (focused->type != C_WORKSPACE && focused->parent->children->length == 1) {
/* Case of no siblings. change parent layout */
sway_log(L_DEBUG, "changing container layout");
swayc_change_layout(focused->parent, layout);
} else {
/* regular case where new split container is build around focused container
* or in case of workspace, container inherits its children */
sway_log(L_DEBUG, "Adding new container around current focused container");
sway_log(L_INFO, "FOCUSED SIZE: %.f %.f", focused->width, focused->height);
swayc_t *parent = new_container(focused, layout);
set_focused_container(focused);
arrange_windows(parent, -1, -1);
}
// update container every time
// if it is tabbed/stacked then the title must change
// if the indicator color is different then the border must change
update_container_border(focused);
swayc_t *output = swayc_parent_by_type(focused, C_OUTPUT);
// schedule render to make changes take effect right away,
// otherwise we would have to wait for the view to render,
// which is unpredictable.
wlc_output_schedule_render(output->handle);
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}
struct cmd_results *cmd_split(int argc, char **argv) {
struct cmd_results *error = NULL;
if (config->reading) return cmd_results_new(CMD_FAILURE, "split", "Can't be used in config file.");
if (!config->active) return cmd_results_new(CMD_FAILURE, "split", "Can only be used when sway is running.");
if ((error = checkarg(argc, "split", EXPECTED_EQUAL_TO, 1))) {
return error;
}
if (strcasecmp(argv[0], "v") == 0 || strcasecmp(argv[0], "vertical") == 0) {
_do_split(argc - 1, argv + 1, L_VERT);
} else if (strcasecmp(argv[0], "h") == 0 || strcasecmp(argv[0], "horizontal") == 0) {
_do_split(argc - 1, argv + 1, L_HORIZ);
} else if (strcasecmp(argv[0], "t") == 0 || strcasecmp(argv[0], "toggle") == 0) {
swayc_t *focused = current_container;
if (focused->parent->layout == L_VERT) {
_do_split(argc - 1, argv + 1, L_HORIZ);
} else {
_do_split(argc - 1, argv + 1, L_VERT);
}
} else {
error = cmd_results_new(CMD_FAILURE, "split",
"Invalid split command (expected either horizontal or vertical).");
return error;
}
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}
struct cmd_results *cmd_splitv(int argc, char **argv) {
return _do_split(argc, argv, L_VERT);
}
struct cmd_results *cmd_splith(int argc, char **argv) {
return _do_split(argc, argv, L_HORIZ);
}
struct cmd_results *cmd_splitt(int argc, char **argv) {
swayc_t *focused = current_container;
if (focused->parent->layout == L_VERT) {
return _do_split(argc, argv, L_HORIZ);
} else {
return _do_split(argc, argv, L_VERT);
}
}

25
sway/old/commands/sticky.c
View file

@ -1,25 +0,0 @@
#include <string.h>
#include "sway/commands.h"
#include "sway/focus.h"
struct cmd_results *cmd_sticky(int argc, char **argv) {
struct cmd_results *error = NULL;
if (config->reading) return cmd_results_new(CMD_FAILURE, "sticky", "Can't be used in config file.");
if (!config->active) return cmd_results_new(CMD_FAILURE, "sticky", "Can only be used when sway is running.");
if ((error = checkarg(argc, "sticky", EXPECTED_EQUAL_TO, 1))) {
return error;
}
char *action = argv[0];
swayc_t *cont = get_focused_view(&root_container);
if (strcmp(action, "toggle") == 0) {
cont->sticky = !cont->sticky;
} else if (strcmp(action, "enable") == 0) {
cont->sticky = true;
} else if (strcmp(action, "disable") == 0) {
cont->sticky = false;
} else {
return cmd_results_new(CMD_FAILURE, "sticky",
"Expected 'sticky enable|disable|toggle'");
}
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

31
sway/old/commands/unmark.c
View file

@ -1,31 +0,0 @@
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
#include "list.h"
#include "stringop.h"
struct cmd_results *cmd_unmark(int argc, char **argv) {
swayc_t *view = current_container;
if (view->marks) {
if (argc) {
char *mark = join_args(argv, argc);
int index;
if ((index = list_seq_find(view->marks, (int (*)(const void *, const void *))strcmp, mark)) != -1) {
free(view->marks->items[index]);
list_del(view->marks, index);
if (view->marks->length == 0) {
list_free(view->marks);
view->marks = NULL;
}
}
free(mark);
} else {
list_foreach(view->marks, free);
list_free(view->marks);
view->marks = NULL;
}
}
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

92
sway/old/commands/workspace.c
View file

@ -1,92 +0,0 @@
#define _XOPEN_SOURCE 500
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
#include "sway/config.h"
#include "sway/input_state.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;
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);
}
sway_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();
} else if (strcasecmp(argv[0], "prev") == 0) {
ws = workspace_prev();
} else if (strcasecmp(argv[0], "next_on_output") == 0) {
ws = workspace_output_next();
} else if (strcasecmp(argv[0], "prev_on_output") == 0) {
ws = workspace_output_prev();
} 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 = swayc_active_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);
}
swayc_t *old_output = swayc_active_output();
workspace_switch(ws);
swayc_t *new_output = swayc_active_output();
if (config->mouse_warping && old_output != new_output) {
swayc_t *focused = get_focused_view(ws);
if (focused && focused->type == C_VIEW) {
center_pointer_on(focused);
}
}
}
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

18
sway/old/commands/workspace_auto_back_and_forth.c
View file

@ -1,18 +0,0 @@
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
struct cmd_results *cmd_ws_auto_back_and_forth(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "workspace_auto_back_and_forth", EXPECTED_EQUAL_TO, 1))) {
return error;
}
if (strcasecmp(argv[0], "yes") == 0) {
config->auto_back_and_forth = true;
} else if (strcasecmp(argv[0], "no") == 0) {
config->auto_back_and_forth = false;
} else {
return cmd_results_new(CMD_INVALID, "workspace_auto_back_and_forth", "Expected 'workspace_auto_back_and_forth <yes|no>'");
}
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

40
sway/old/commands/workspace_layout.c
View file

@ -1,40 +0,0 @@
#include <string.h>
#include <strings.h>
#include "sway/commands.h"
struct cmd_results *cmd_workspace_layout(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "workspace_layout", EXPECTED_AT_LEAST, 1))) {
return error;
}
if (strcasecmp(argv[0], "default") == 0) {
config->default_layout = L_NONE;
} else if (strcasecmp(argv[0], "stacking") == 0) {
config->default_layout = L_STACKED;
} else if (strcasecmp(argv[0], "tabbed") == 0) {
config->default_layout = L_TABBED;
} else if (strcasecmp(argv[0], "auto") == 0) {
if (argc == 1) {
config->default_layout = L_AUTO_FIRST;
} else {
if ((error = checkarg(argc, "workspace_layout auto", EXPECTED_EQUAL_TO, 2))) {
return error;
}
if (strcasecmp(argv[1], "left") == 0) {
config->default_layout = L_AUTO_LEFT;
} else if (strcasecmp(argv[1], "right") == 0) {
config->default_layout = L_AUTO_RIGHT;
} else if (strcasecmp(argv[1], "top") == 0) {
config->default_layout = L_AUTO_TOP;
} else if (strcasecmp(argv[1], "bottom") == 0) {
config->default_layout = L_AUTO_BOTTOM;
} else {
return cmd_results_new(CMD_INVALID, "workspace_layout auto", "Expected 'workspace_layout auto <left|right|top|bottom>'");
}
}
} else {
return cmd_results_new(CMD_INVALID, "workspace_layout", "Expected 'workspace_layout <default|stacking|tabbed|auto|auto left|auto right|auto top|auto bottom>'");
}
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

1313
sway/old/config.c
View file

File diff suppressed because it is too large Load diff

1024
sway/old/container.c
View file

File diff suppressed because it is too large Load diff

451
sway/old/criteria.c
View file

@ -1,451 +0,0 @@
#define _XOPEN_SOURCE 700
#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <pcre.h>
#include "sway/criteria.h"
#include "sway/container.h"
#include "sway/config.h"
#include "stringop.h"
#include "list.h"
#include "log.h"
enum criteria_type { // *must* keep in sync with criteria_strings[]
CRIT_CLASS,
CRIT_CON_ID,
CRIT_CON_MARK,
CRIT_FLOATING,
CRIT_ID,
CRIT_INSTANCE,
CRIT_TILING,
CRIT_TITLE,
CRIT_URGENT,
CRIT_WINDOW_ROLE,
CRIT_WINDOW_TYPE,
CRIT_WORKSPACE,
CRIT_LAST
};
static const char * const criteria_strings[CRIT_LAST] = {
[CRIT_CLASS] = "class",
[CRIT_CON_ID] = "con_id",
[CRIT_CON_MARK] = "con_mark",
[CRIT_FLOATING] = "floating",
[CRIT_ID] = "id",
[CRIT_INSTANCE] = "instance",
[CRIT_TILING] = "tiling",
[CRIT_TITLE] = "title",
[CRIT_URGENT] = "urgent", // either "latest" or "oldest" ...
[CRIT_WINDOW_ROLE] = "window_role",
[CRIT_WINDOW_TYPE] = "window_type",
[CRIT_WORKSPACE] = "workspace"
};
/**
* A single criteria token (ie. value/regex pair),
* e.g. 'class="some class regex"'.
*/
struct crit_token {
enum criteria_type type;
pcre *regex;
char *raw;
};
static void free_crit_token(struct crit_token *crit) {
pcre_free(crit->regex);
free(crit->raw);
free(crit);
}
static void free_crit_tokens(list_t *crit_tokens) {
for (int i = 0; i < crit_tokens->length; i++) {
free_crit_token(crit_tokens->items[i]);
}
list_free(crit_tokens);
}
// Extracts criteria string from its brackets. Returns new (duplicate)
// substring.
static char *criteria_from(const char *arg) {
char *criteria = NULL;
if (*arg == '[') {
criteria = strdup(arg + 1);
} else {
criteria = strdup(arg);
}
int last = strlen(criteria) - 1;
if (criteria[last] == ']') {
criteria[last] = '\0';
}
return criteria;
}
// Return instances of c found in str.
static int countchr(char *str, char c) {
int found = 0;
for (int i = 0; str[i]; i++) {
if (str[i] == c) {
++found;
}
}
return found;
}
// criteria_str is e.g. '[class="some class regex" instance="instance name"]'.
//
// Will create array of pointers in buf, where first is duplicate of given
// string (must be freed) and the rest are pointers to names and values in the
// base string (every other, naturally). argc will be populated with the length
// of buf.
//
// Returns error string or NULL if successful.
static char *crit_tokens(int *argc, char ***buf, const char * const criteria_str) {
sway_log(L_DEBUG, "Parsing criteria: '%s'", criteria_str);
char *base = criteria_from(criteria_str);
char *head = base;
char *namep = head; // start of criteria name
char *valp = NULL; // start of value
// We're going to place EOS markers where we need to and fill up an array
// of pointers to the start of each token (either name or value).
int pairs = countchr(base, '=');
int max_tokens = pairs * 2 + 1; // this gives us at least enough slots
char **argv = *buf = calloc(max_tokens, sizeof(char*));
argv[0] = base; // this needs to be freed by caller
bool quoted = true;
*argc = 1; // uneven = name, even = value
while (*head && *argc < max_tokens) {
if (namep != head && *(head - 1) == '\\') {
// escaped character: don't try to parse this
} else if (*head == '=' && namep != head) {
if (*argc % 2 != 1) {
// we're not expecting a name
return strdup("Unable to parse criteria: "
"Found out of place equal sign");
} else {
// name ends here
char *end = head; // don't want to rewind the head
while (*(end - 1) == ' ') {
--end;
}
*end = '\0';
if (*(namep) == ' ') {
namep = strrchr(namep, ' ') + 1;
}
argv[*argc] = namep;
*argc += 1;
}
} else if (*head == '"') {
if (*argc % 2 != 0) {
// we're not expecting a value
return strdup("Unable to parse criteria: "
"Found quoted value where it was not expected");
} else if (!valp) { // value starts here
valp = head + 1;
quoted = true;
} else {
// value ends here
argv[*argc] = valp;
*argc += 1;
*head = '\0';
valp = NULL;
namep = head + 1;
}
} else if (*argc % 2 == 0 && *head != ' ') {
// parse unquoted values
if (!valp) {
quoted = false;
valp = head; // value starts here
}
} else if (valp && !quoted && *head == ' ') {
// value ends here
argv[*argc] = valp;
*argc += 1;
*head = '\0';
valp = NULL;
namep = head + 1;
}
head++;
}
// catch last unquoted value if needed
if (valp && !quoted && !*head) {
argv[*argc] = valp;
*argc += 1;
}
return NULL;
}
// Returns error string on failure or NULL otherwise.
static char *parse_criteria_name(enum criteria_type *type, char *name) {
*type = CRIT_LAST;
for (int i = 0; i < CRIT_LAST; i++) {
if (strcmp(criteria_strings[i], name) == 0) {
*type = (enum criteria_type) i;
break;
}
}
if (*type == CRIT_LAST) {
const char *fmt = "Criteria type '%s' is invalid or unsupported.";
int len = strlen(name) + strlen(fmt) - 1;
char *error = malloc(len);
snprintf(error, len, fmt, name);
return error;
} else if (*type == CRIT_URGENT || *type == CRIT_WINDOW_ROLE ||
*type == CRIT_WINDOW_TYPE) {
// (we're just being helpful here)
const char *fmt = "\"%s\" criteria currently unsupported, "
"no window will match this";
int len = strlen(fmt) + strlen(name) - 1;
char *error = malloc(len);
snprintf(error, len, fmt, name);
return error;
}
return NULL;
}
// Returns error string on failure or NULL otherwise.
static char *generate_regex(pcre **regex, char *value) {
const char *reg_err;
int offset;
*regex = pcre_compile(value, PCRE_UTF8 | PCRE_UCP, &reg_err, &offset, NULL);
if (!*regex) {
const char *fmt = "Regex compilation (for '%s') failed: %s";
int len = strlen(fmt) + strlen(value) + strlen(reg_err) - 3;
char *error = malloc(len);
snprintf(error, len, fmt, value, reg_err);
return error;
}
return NULL;
}
// Test whether the criterion corresponds to the currently focused window
static bool crit_is_focused(const char *value) {
return !strcmp(value, "focused") || !strcmp(value, "__focused__");
}
// Populate list with crit_tokens extracted from criteria string, returns error
// string or NULL if successful.
char *extract_crit_tokens(list_t *tokens, const char * const criteria) {
int argc;
char **argv = NULL, *error = NULL;
if ((error = crit_tokens(&argc, &argv, criteria))) {
goto ect_cleanup;
}
for (int i = 1; i + 1 < argc; i += 2) {
char* name = argv[i], *value = argv[i + 1];
struct crit_token *token = calloc(1, sizeof(struct crit_token));
token->raw = strdup(value);
if ((error = parse_criteria_name(&token->type, name))) {
free_crit_token(token);
goto ect_cleanup;
} else if (token->type == CRIT_URGENT || crit_is_focused(value)) {
sway_log(L_DEBUG, "%s -> \"%s\"", name, value);
list_add(tokens, token);
} else if((error = generate_regex(&token->regex, value))) {
free_crit_token(token);
goto ect_cleanup;
} else {
sway_log(L_DEBUG, "%s -> /%s/", name, value);
list_add(tokens, token);
}
}
ect_cleanup:
free(argv[0]); // base string
free(argv);
return error;
}
static int regex_cmp(const char *item, const pcre *regex) {
return pcre_exec(regex, NULL, item, strlen(item), 0, 0, NULL, 0);
}
// test a single view if it matches list of criteria tokens (all of them).
static bool criteria_test(swayc_t *cont, list_t *tokens) {
if (cont->type != C_VIEW) {
return false;
}
int matches = 0;
for (int i = 0; i < tokens->length; i++) {
struct crit_token *crit = tokens->items[i];
switch (crit->type) {
case CRIT_CLASS:
if (!cont->class) {
// ignore
} else if (crit_is_focused(crit->raw)) {
swayc_t *focused = get_focused_view(&root_container);
if (focused->class && strcmp(cont->class, focused->class) == 0) {
matches++;
}
} else if (crit->regex && regex_cmp(cont->class, crit->regex) == 0) {
matches++;
}
break;
case CRIT_CON_ID: {
char *endptr;
size_t crit_id = strtoul(crit->raw, &endptr, 10);
if (*endptr == 0 && cont->id == crit_id) {
++matches;
}
break;
}
case CRIT_CON_MARK:
if (crit->regex && cont->marks && (list_seq_find(cont->marks, (int (*)(const void *, const void *))regex_cmp, crit->regex) != -1)) {
// Make sure it isn't matching the NUL string
if ((strcmp(crit->raw, "") == 0) == (list_seq_find(cont->marks, (int (*)(const void *, const void *))strcmp, "") != -1)) {
++matches;
}
}
break;
case CRIT_FLOATING:
if (cont->is_floating) {
matches++;
}
break;
case CRIT_ID:
if (!cont->app_id) {
// ignore
} else if (crit->regex && regex_cmp(cont->app_id, crit->regex) == 0) {
matches++;
}
break;
case CRIT_INSTANCE:
if (!cont->instance) {
// ignore
} else if (crit_is_focused(crit->raw)) {
swayc_t *focused = get_focused_view(&root_container);
if (focused->instance && strcmp(cont->instance, focused->instance) == 0) {
matches++;
}
} else if (crit->regex && regex_cmp(cont->instance, crit->regex) == 0) {
matches++;
}
break;
case CRIT_TILING:
if (!cont->is_floating) {
matches++;
}
break;
case CRIT_TITLE:
if (!cont->name) {
// ignore
} else if (crit_is_focused(crit->raw)) {
swayc_t *focused = get_focused_view(&root_container);
if (focused->name && strcmp(cont->name, focused->name) == 0) {
matches++;
}
} else if (crit->regex && regex_cmp(cont->name, crit->regex) == 0) {
matches++;
}
break;
case CRIT_URGENT: // "latest" or "oldest"
break;
case CRIT_WINDOW_ROLE:
break;
case CRIT_WINDOW_TYPE:
// TODO wlc indeed exposes this information
break;
case CRIT_WORKSPACE: ;
swayc_t *cont_ws = swayc_parent_by_type(cont, C_WORKSPACE);
if (!cont_ws || !cont_ws->name) {
// ignore
} else if (crit_is_focused(crit->raw)) {
swayc_t *focused_ws = swayc_active_workspace();
if (focused_ws->name && strcmp(cont_ws->name, focused_ws->name) == 0) {
matches++;
}
} else if (crit->regex && regex_cmp(cont_ws->name, crit->regex) == 0) {
matches++;
}
break;
default:
sway_abort("Invalid criteria type (%i)", crit->type);
break;
}
}
return matches == tokens->length;
}
int criteria_cmp(const void *a, const void *b) {
if (a == b) {
return 0;
} else if (!a) {
return -1;
} else if (!b) {
return 1;
}
const struct criteria *crit_a = a, *crit_b = b;
int cmp = lenient_strcmp(crit_a->cmdlist, crit_b->cmdlist);
if (cmp != 0) {
return cmp;
}
return lenient_strcmp(crit_a->crit_raw, crit_b->crit_raw);
}
void free_criteria(struct criteria *crit) {
if (crit->tokens) {
free_crit_tokens(crit->tokens);
}
if (crit->cmdlist) {
free(crit->cmdlist);
}
if (crit->crit_raw) {
free(crit->crit_raw);
}
free(crit);
}
bool criteria_any(swayc_t *cont, list_t *criteria) {
for (int i = 0; i < criteria->length; i++) {
struct criteria *bc = criteria->items[i];
if (criteria_test(cont, bc->tokens)) {
return true;
}
}
return false;
}
list_t *criteria_for(swayc_t *cont) {
list_t *criteria = config->criteria, *matches = create_list();
for (int i = 0; i < criteria->length; i++) {
struct criteria *bc = criteria->items[i];
if (criteria_test(cont, bc->tokens)) {
list_add(matches, bc);
}
}
return matches;
}
struct list_tokens {
list_t *list;
list_t *tokens;
};
static void container_match_add(swayc_t *container, struct list_tokens *list_tokens) {
if (criteria_test(container, list_tokens->tokens)) {
list_add(list_tokens->list, container);
}
}
list_t *container_for(list_t *tokens) {
struct list_tokens list_tokens = (struct list_tokens){create_list(), tokens};
container_map(&root_container, (void (*)(swayc_t *, void *))container_match_add, &list_tokens);
for (int i = 0; i < scratchpad->length; ++i) {
swayc_t *c = scratchpad->items[i];
if (criteria_test(c, tokens)) {
list_add(list_tokens.list, c);
}
}
return list_tokens.list;
}

278
sway/old/focus.c
View file

@ -1,278 +0,0 @@
#include "stdbool.h"
#include <wlc/wlc.h>
#include "sway/focus.h"
#include "sway/workspace.h"
#include "sway/layout.h"
#include "sway/config.h"
#include "sway/input_state.h"
#include "sway/ipc-server.h"
#include "sway/border.h"
#include "log.h"
bool locked_container_focus = false;
bool suspend_workspace_cleanup = false;
// switches parent focus to c. will switch it accordingly
static void update_focus(swayc_t *c) {
// Handle if focus switches
swayc_t *parent = c->parent;
if (!parent) return;
if (parent->focused != c) {
// Get previous focus
swayc_t *prev = parent->focused;
// Set new focus
parent->focused = c;
switch (c->type) {
// Shouldn't happen
case C_ROOT: return;
// Case where output changes
case C_OUTPUT:
wlc_output_focus(c->handle);
break;
// Case where workspace changes
case C_WORKSPACE:
if (prev) {
ipc_event_workspace(prev, c, "focus");
// if the old workspace has no children, destroy it
if(prev->children->length == 0 && prev->floating->length == 0 && !suspend_workspace_cleanup) {
destroy_workspace(prev);
} else {
// update visibility of old workspace
update_visibility(prev);
}
}
// Update visibility of newly focused workspace
update_visibility(c);
break;
default:
case C_VIEW:
case C_CONTAINER:
break;
}
}
}
bool move_focus(enum movement_direction direction) {
swayc_t *old_view = get_focused_container(&root_container);
swayc_t *new_view = get_swayc_in_direction(old_view, direction);
if (!new_view) {
return false;
} else if (new_view->type == C_ROOT) {
sway_log(L_DEBUG, "Not setting focus above the workspace level");
return false;
} else if (new_view->type == C_OUTPUT) {
return set_focused_container(swayc_active_workspace_for(new_view));
} else if (direction == MOVE_PARENT || direction == MOVE_CHILD) {
return set_focused_container(new_view);
} else if (config->mouse_warping) {
swayc_t *old_op = old_view->type == C_OUTPUT ?
old_view : swayc_parent_by_type(old_view, C_OUTPUT);
swayc_t *focused = get_focused_view(new_view);
if (set_focused_container(focused)) {
if (old_op != swayc_active_output() && focused && focused->type == C_VIEW) {
center_pointer_on(focused);
}
return true;
}
} else {
return set_focused_container(get_focused_view(new_view));
}
return false;
}
swayc_t *get_focused_container(swayc_t *parent) {
if (!parent) {
return swayc_active_workspace();
}
while (!parent->is_focused && parent->focused) {
parent = parent->focused;
}
return parent;
}
bool set_focused_container(swayc_t *c) {
if (locked_container_focus || !c || !c->parent) {
return false;
}
// current ("old") workspace for sending workspace change event later
swayc_t *old_ws = swayc_active_workspace();
// keep track of child count so we can determine if it gets destroyed
int old_ws_child_count = 0;
if (old_ws) {
old_ws_child_count = old_ws->children->length + old_ws->floating->length;
}
// current ("old") focused container
swayc_t *old_focus = get_focused_container(&root_container);
// if old_focus is a workspace, then it's the same workspace as
// old_ws, and we'll need to null its pointer too, since it will
// be destroyed in the update_focus() call
bool old_focus_was_ws = (old_focus->type == C_WORKSPACE);
// workspace of new focused container
swayc_t *workspace = swayc_active_workspace_for(c);
if (swayc_is_fullscreen(get_focused_container(workspace))) {
// if switching to a workspace with a fullscreen view,
// focus on the fullscreen view
c = get_focused_container(workspace);
}
swayc_log(L_DEBUG, c, "Setting focus to %p:%" PRIuPTR, c, c->handle);
if (c->type == C_VIEW) {
// dispatch a window event
ipc_event_window(c, "focus");
}
// update the global pointer
current_focus = c;
// update container focus from here to root, making necessary changes along
// the way
swayc_t *p = c;
if (p->type != C_OUTPUT && p->type != C_ROOT) {
p->is_focused = true;
}
while (p != &root_container) {
update_focus(p);
p = p->parent;
p->is_focused = false;
}
if (old_focus_was_ws && old_ws_child_count == 0) {
// this workspace was destroyed in update_focus(), so null the pointers
old_focus = NULL;
old_ws = NULL;
}
if (!(wlc_view_get_type(p->handle) & WLC_BIT_POPUP)) {
if (old_focus) {
if (old_focus->type == C_VIEW) {
wlc_view_set_state(old_focus->handle, WLC_BIT_ACTIVATED, false);
}
update_container_border(old_focus);
}
if (c->type == C_VIEW) {
wlc_view_set_state(c->handle, WLC_BIT_ACTIVATED, true);
}
/* TODO WLR
if (!desktop_shell.is_locked) {
// If the system is locked, we do everything _but_ actually setting
// focus. This includes making our internals think that this view is
// focused.
wlc_view_focus(c->handle);
}
*/
if (c->parent->layout != L_TABBED && c->parent->layout != L_STACKED) {
update_container_border(c);
}
swayc_t *parent = swayc_tabbed_stacked_ancestor(c);
if (parent != NULL) {
arrange_backgrounds();
arrange_windows(parent, -1, -1);
}
}
if (old_ws != workspace) {
// old_ws might be NULL here but that's ok
ipc_event_workspace(old_ws, workspace, "focus");
}
return true;
}
bool set_focused_container_for(swayc_t *a, swayc_t *c) {
if (locked_container_focus || !c) {
return false;
}
swayc_t *find = c;
while (find != a && (find = find->parent)) {
if (find == &root_container) {
return false;
}
}
// Get workspace for c, get that workspaces current focused container.
swayc_t *workspace = swayc_active_workspace_for(c);
swayc_t *focused = get_focused_view(workspace);
// if the workspace we are changing focus to has a fullscreen view return
if (swayc_is_fullscreen(focused) && c != focused) {
return false;
}
// Check if we are changing a parent container that will see change
bool effective = true;
while (find != &root_container) {
if (find->parent->focused != find) {
effective = false;
}
find = find->parent;
}
if (effective) {
// Go to set_focused_container
return set_focused_container(c);
}
sway_log(L_DEBUG, "Setting focus for %p:%" PRIuPTR " to %p:%" PRIuPTR,
a, a->handle, c, c->handle);
c->is_focused = true;
swayc_t *p = c;
while (p != a) {
update_focus(p);
p = p->parent;
p->is_focused = false;
}
return true;
}
swayc_t *get_focused_view(swayc_t *parent) {
swayc_t *c = parent;
while (c && c->type != C_VIEW) {
if (c->type == C_WORKSPACE && c->focused == NULL) {
return c;
}
c = c->focused;
}
if (c == NULL) {
c = swayc_active_workspace_for(parent);
}
return c;
}
swayc_t *get_focused_float(swayc_t *ws) {
if(!sway_assert(ws->type == C_WORKSPACE, "must be of workspace type")) {
ws = swayc_active_workspace();
}
if (ws->floating->length) {
return ws->floating->items[ws->floating->length - 1];
}
return NULL;
}
swayc_t *get_focused_view_include_floating(swayc_t *parent) {
swayc_t *c = parent;
swayc_t *f = NULL;
while (c && c->type != C_VIEW) {
if (c->type == C_WORKSPACE && c->focused == NULL) {
return ((f = get_focused_float(c))) ? f : c;
}
c = c->focused;
}
if (c == NULL) {
c = swayc_active_workspace_for(parent);
}
return c;
}

1143
sway/old/handlers.c
View file

File diff suppressed because it is too large Load diff

490
sway/old/input_state.c
View file

@ -1,490 +0,0 @@
#include <string.h>
#include <stdbool.h>
#include <ctype.h>
#include "sway/input_state.h"
#include "sway/config.h"
#include "log.h"
#define KEY_STATE_MAX_LENGTH 64
struct key_state {
/*
* Aims to store state regardless of modifiers.
* If you press a key, then hold shift, then release the key, we'll
* get two different key syms, but the same key code. This handles
* that scenario and makes sure we can use the right bindings.
*/
uint32_t key_sym;
uint32_t alt_sym;
uint32_t key_code;
};
static struct key_state key_state_array[KEY_STATE_MAX_LENGTH];
static struct key_state last_released;
static uint32_t modifiers_state;
void input_init(void) {
int i;
for (i = 0; i < KEY_STATE_MAX_LENGTH; ++i) {
struct key_state none = { 0, 0, 0 };
key_state_array[i] = none;
}
struct key_state none = { 0, 0, 0 };
last_released = none;
modifiers_state = 0;
}
uint32_t modifier_state_changed(uint32_t new_state, uint32_t mod) {
if ((new_state & mod) != 0) { // pressed
if ((modifiers_state & mod) != 0) { // already pressed
return MOD_STATE_UNCHANGED;
} else { // pressed
return MOD_STATE_PRESSED;
}
} else { // not pressed
if ((modifiers_state & mod) != 0) { // released
return MOD_STATE_RELEASED;
} else { // already released
return MOD_STATE_UNCHANGED;
}
}
}
void modifiers_state_update(uint32_t new_state) {
modifiers_state = new_state;
}
static uint8_t find_key(uint32_t key_sym, uint32_t key_code, bool update) {
int i;
for (i = 0; i < KEY_STATE_MAX_LENGTH; ++i) {
if (0 == key_sym && 0 == key_code && key_state_array[i].key_sym == 0) {
break;
}
if (key_sym != 0 && (key_state_array[i].key_sym == key_sym
|| key_state_array[i].alt_sym == key_sym)) {
break;
}
if (update && key_state_array[i].key_code == key_code) {
key_state_array[i].alt_sym = key_sym;
break;
}
if (key_sym == 0 && key_code != 0 && key_state_array[i].key_code == key_code) {
break;
}
}
return i;
}
bool check_key(uint32_t key_sym, uint32_t key_code) {
return find_key(key_sym, key_code, false) < KEY_STATE_MAX_LENGTH;
}
bool check_released_key(uint32_t key_sym) {
return (key_sym != 0
&& (last_released.key_sym == key_sym
|| last_released.alt_sym == key_sym));
}
void press_key(uint32_t key_sym, uint32_t key_code) {
if (key_code == 0) {
return;
}
// Check if key exists
if (!check_key(key_sym, key_code)) {
// Check that we don't exceed buffer length
int insert = find_key(0, 0, true);
if (insert < KEY_STATE_MAX_LENGTH) {
key_state_array[insert].key_sym = key_sym;
key_state_array[insert].key_code = key_code;
}
}
}
void release_key(uint32_t key_sym, uint32_t key_code) {
uint8_t index = find_key(key_sym, key_code, true);
if (index < KEY_STATE_MAX_LENGTH) {
last_released.key_sym = key_state_array[index].key_sym;
last_released.alt_sym = key_state_array[index].alt_sym;
last_released.key_code = key_state_array[index].key_code;
struct key_state none = { 0, 0, 0 };
key_state_array[index] = none;
}
}
// Pointer state and mode
struct pointer_state pointer_state;
static struct mode_state {
// initial view state
double x, y, w, h;
swayc_t *ptr;
// Containers used for resizing horizontally
struct {
double w;
swayc_t *ptr;
struct {
double w;
swayc_t *ptr;
} parent;
} horiz;
// Containers used for resizing vertically
struct {
double h;
swayc_t *ptr;
struct {
double h;
swayc_t *ptr;
} parent;
} vert;
} initial;
static struct {
bool left;
bool top;
} lock;
// initial set/unset
static void set_initial_view(swayc_t *view) {
initial.ptr = view;
initial.x = view->x;
initial.y = view->y;
initial.w = view->width;
initial.h = view->height;
}
static void set_initial_sibling(void) {
bool reset = true;
swayc_t *ws = swayc_active_workspace_for(initial.ptr);
if ((initial.horiz.ptr = get_swayc_in_direction_under(initial.ptr,
lock.left ? MOVE_RIGHT: MOVE_LEFT, ws))) {
initial.horiz.w = initial.horiz.ptr->width;
initial.horiz.parent.ptr = get_swayc_in_direction_under(initial.horiz.ptr,
lock.left ? MOVE_LEFT : MOVE_RIGHT, ws);
initial.horiz.parent.w = initial.horiz.parent.ptr->width;
reset = false;
}
if ((initial.vert.ptr = get_swayc_in_direction_under(initial.ptr,
lock.top ? MOVE_DOWN: MOVE_UP, ws))) {
initial.vert.h = initial.vert.ptr->height;
initial.vert.parent.ptr = get_swayc_in_direction_under(initial.vert.ptr,
lock.top ? MOVE_UP : MOVE_DOWN, ws);
initial.vert.parent.h = initial.vert.parent.ptr->height;
reset = false;
}
// If nothing will change just undo the mode
if (reset) {
pointer_state.mode = 0;
}
}
static void reset_initial_view(void) {
initial.ptr->x = initial.x;
initial.ptr->y = initial.y;
initial.ptr->width = initial.w;
initial.ptr->height = initial.h;
arrange_windows(initial.ptr, -1, -1);
pointer_state.mode = 0;
}
static void reset_initial_sibling(void) {
initial.horiz.ptr->width = initial.horiz.w;
initial.horiz.parent.ptr->width = initial.horiz.parent.w;
initial.vert.ptr->height = initial.vert.h;
initial.vert.parent.ptr->height = initial.vert.parent.h;
arrange_windows(initial.horiz.ptr->parent, -1, -1);
arrange_windows(initial.vert.ptr->parent, -1, -1);
pointer_state.mode = 0;
}
void pointer_position_set(double new_x, double new_y, bool force_focus) {
double x, y;
wlc_pointer_get_position_v2(&x, &y);
pointer_state.delta.x = new_x - x;
pointer_state.delta.y = new_y - y;
wlc_pointer_set_position_v2(new_x, new_y);
// Update view under pointer
swayc_t *prev_view = pointer_state.view;
pointer_state.view = container_under_pointer();
// If pointer is in a mode, update it
if (pointer_state.mode) {
pointer_mode_update();
// Otherwise change focus if config is set
} else if (force_focus || (prev_view != pointer_state.view && config->focus_follows_mouse)) {
if (pointer_state.view && pointer_state.view->type == C_VIEW) {
set_focused_container(pointer_state.view);
}
}
}
void center_pointer_on(swayc_t *view) {
pointer_position_set(view->x + view->width/2, view->y + view->height/2, true);
}
// Mode set left/right click
static void pointer_mode_set_dragging(void) {
switch (config->dragging_key) {
case M_LEFT_CLICK:
set_initial_view(pointer_state.left.view);
break;
case M_RIGHT_CLICK:
set_initial_view(pointer_state.right.view);
break;
}
if (initial.ptr->is_floating) {
pointer_state.mode = M_DRAGGING | M_FLOATING;
} else {
pointer_state.mode = M_DRAGGING | M_TILING;
// unset mode if we can't drag tile
if (initial.ptr->parent->type == C_WORKSPACE &&
initial.ptr->parent->children->length == 1) {
pointer_state.mode = 0;
}
}
}
static void pointer_mode_set_resizing(void) {
switch (config->resizing_key) {
case M_LEFT_CLICK:
set_initial_view(pointer_state.left.view);
break;
case M_RIGHT_CLICK:
set_initial_view(pointer_state.right.view);
break;
}
// Setup locking information
int midway_x = initial.ptr->x + initial.ptr->width/2;
int midway_y = initial.ptr->y + initial.ptr->height/2;
double x, y;
wlc_pointer_get_position_v2(&x, &y);
lock.left = x > midway_x;
lock.top = y > midway_y;
if (initial.ptr->is_floating) {
pointer_state.mode = M_RESIZING | M_FLOATING;
} else {
pointer_state.mode = M_RESIZING | M_TILING;
set_initial_sibling();
}
}
// Mode set/update/reset
void pointer_mode_set(uint32_t button, bool condition) {
// switch on drag/resize mode
switch (pointer_state.mode & (M_DRAGGING | M_RESIZING)) {
case M_DRAGGING:
// end drag mode when 'dragging' click is unpressed
if (config->dragging_key == M_LEFT_CLICK && !pointer_state.left.held) {
pointer_state.mode = 0;
} else if (config->dragging_key == M_RIGHT_CLICK && !pointer_state.right.held) {
pointer_state.mode = 0;
}
break;
case M_RESIZING:
// end resize mode when 'resizing' click is unpressed
if (config->resizing_key == M_LEFT_CLICK && !pointer_state.left.held) {
pointer_state.mode = 0;
} else if (config->resizing_key == M_RIGHT_CLICK && !pointer_state.right.held) {
pointer_state.mode = 0;
}
break;
// No mode case
default:
// return if failed condition, or no view
if (!condition || !pointer_state.view) {
break;
}
// Set mode depending on current button press
switch (button) {
// Start left-click mode
case M_LEFT_CLICK:
// if button release don't do anything
if (pointer_state.left.held) {
if (config->dragging_key == M_LEFT_CLICK) {
pointer_mode_set_dragging();
} else if (config->resizing_key == M_LEFT_CLICK) {
pointer_mode_set_resizing();
}
}
break;
// Start right-click mode
case M_RIGHT_CLICK:
// if button release don't do anyhting
if (pointer_state.right.held) {
if (config->dragging_key == M_RIGHT_CLICK) {
pointer_mode_set_dragging();
} else if (config->resizing_key == M_RIGHT_CLICK) {
pointer_mode_set_resizing();
}
}
break;
}
}
}
void pointer_mode_update(void) {
if (initial.ptr->type != C_VIEW) {
pointer_state.mode = 0;
return;
}
double x, y;
wlc_pointer_get_position_v2(&x, &y);
int dx = x;
int dy = y;
switch (pointer_state.mode) {
case M_FLOATING | M_DRAGGING:
// Update position
switch (config->dragging_key) {
case M_LEFT_CLICK:
dx -= pointer_state.left.x;
dy -= pointer_state.left.y;
break;
case M_RIGHT_CLICK:
dx -= pointer_state.right.x;
dy -= pointer_state.right.y;
break;
}
if (initial.x + dx != initial.ptr->x) {
initial.ptr->x = initial.x + dx;
}
if (initial.y + dy != initial.ptr->y) {
initial.ptr->y = initial.y + dy;
}
update_geometry(initial.ptr);
break;
case M_FLOATING | M_RESIZING:
switch (config->resizing_key) {
case M_LEFT_CLICK:
dx -= pointer_state.left.x;
dy -= pointer_state.left.y;
initial.ptr = pointer_state.left.view;
break;
case M_RIGHT_CLICK:
dx -= pointer_state.right.x;
dy -= pointer_state.right.y;
initial.ptr = pointer_state.right.view;
break;
}
if (lock.left) {
if (initial.w + dx > min_sane_w) {
initial.ptr->width = initial.w + dx;
}
} else { // lock.right
if (initial.w - dx > min_sane_w) {
initial.ptr->width = initial.w - dx;
initial.ptr->x = initial.x + dx;
}
}
if (lock.top) {
if (initial.h + dy > min_sane_h) {
initial.ptr->height = initial.h + dy;
}
} else { // lock.bottom
if (initial.h - dy > min_sane_h) {
initial.ptr->height = initial.h - dy;
initial.ptr->y = initial.y + dy;
}
}
update_geometry(initial.ptr);
break;
case M_TILING | M_DRAGGING:
// swap current view under pointer with dragged view
if (pointer_state.view && pointer_state.view->type == C_VIEW
&& pointer_state.view != initial.ptr
&& !pointer_state.view->is_floating) {
// Swap them around
swap_container(pointer_state.view, initial.ptr);
swap_geometry(pointer_state.view, initial.ptr);
update_geometry(pointer_state.view);
update_geometry(initial.ptr);
// Set focus back to initial view
set_focused_container(initial.ptr);
// Arrange the windows
arrange_windows(&root_container, -1, -1);
}
break;
case M_TILING | M_RESIZING:
switch (config->resizing_key) {
case M_LEFT_CLICK:
dx -= pointer_state.left.x;
dy -= pointer_state.left.y;
break;
case M_RIGHT_CLICK:
dx -= pointer_state.right.x;
dy -= pointer_state.right.y;
break;
}
// resize if we can
if (initial.horiz.ptr) {
if (lock.left) {
// Check whether its fine to resize
if (initial.w + dx > min_sane_w && initial.horiz.w - dx > min_sane_w) {
initial.horiz.ptr->width = initial.horiz.w - dx;
initial.horiz.parent.ptr->width = initial.horiz.parent.w + dx;
}
} else { // lock.right
if (initial.w - dx > min_sane_w && initial.horiz.w + dx > min_sane_w) {
initial.horiz.ptr->width = initial.horiz.w + dx;
initial.horiz.parent.ptr->width = initial.horiz.parent.w - dx;
}
}
arrange_windows(initial.horiz.ptr->parent, -1, -1);
}
if (initial.vert.ptr) {
if (lock.top) {
if (initial.h + dy > min_sane_h && initial.vert.h - dy > min_sane_h) {
initial.vert.ptr->height = initial.vert.h - dy;
initial.vert.parent.ptr->height = initial.vert.parent.h + dy;
}
} else { // lock.bottom
if (initial.h - dy > min_sane_h && initial.vert.h + dy > min_sane_h) {
initial.vert.ptr->height = initial.vert.h + dy;
initial.vert.parent.ptr->height = initial.vert.parent.h - dy;
}
}
arrange_windows(initial.vert.ptr->parent, -1, -1);
}
default:
return;
}
}
void pointer_mode_reset(void) {
switch (pointer_state.mode) {
case M_FLOATING | M_RESIZING:
case M_FLOATING | M_DRAGGING:
reset_initial_view();
break;
case M_TILING | M_RESIZING:
(void) reset_initial_sibling;
break;
case M_TILING | M_DRAGGING:
default:
break;
}
}

521
sway/old/ipc-json.c
View file

@ -1,521 +0,0 @@
#define _POSIX_C_SOURCE 200809L
#include <json-c/json.h>
#include <ctype.h>
#include <string.h>
#include <stdint.h>
#include <libinput.h>
#include <wlr/types/wlr_box.h>
#include <wlr/types/wlr_output.h>
#include "sway/output.h"
#include "sway/container.h"
#include "sway/input.h"
#include "sway/ipc-json.h"
#include "util.h"
static json_object *ipc_json_create_rect(swayc_t *c) {
json_object *rect = json_object_new_object();
json_object_object_add(rect, "x", json_object_new_int((int32_t)c->x));
json_object_object_add(rect, "y", json_object_new_int((int32_t)c->y));
struct wlr_box box;
if (c->type == C_OUTPUT) {
wlr_output_effective_resolution(c->_handle.output->wlr_output,
&box.width, &box.height);
} else {
box.width = c->width;
box.width = c->height;
}
json_object_object_add(rect, "width",
json_object_new_int((int32_t)box.width));
json_object_object_add(rect, "height",
json_object_new_int((int32_t)box.height));
return rect;
}
static json_object *ipc_json_create_rect_from_geometry(struct wlc_geometry g) {
json_object *rect = json_object_new_object();
json_object_object_add(rect, "x", json_object_new_int(g.origin.x));
json_object_object_add(rect, "y", json_object_new_int(g.origin.y));
json_object_object_add(rect, "width", json_object_new_int(g.size.w));
json_object_object_add(rect, "height", json_object_new_int(g.size.h));
return rect;
}
static const char *ipc_json_border_description(swayc_t *c) {
const char *border;
switch (c->border_type) {
case B_PIXEL:
border = "1pixel";
break;
case B_NORMAL:
border = "normal";
break;
case B_NONE: // fallthrough
default:
border = "none";
break;
}
return border;
}
static const char *ipc_json_layout_description(enum swayc_layouts l) {
const char *layout;
switch (l) {
case L_VERT:
layout = "splitv";
break;
case L_HORIZ:
layout = "splith";
break;
case L_TABBED:
layout = "tabbed";
break;
case L_STACKED:
layout = "stacked";
break;
case L_FLOATING:
layout = "floating";
break;
case L_NONE: // fallthrough
case L_LAYOUTS: // fallthrough; this should never happen, I'm just trying to silence compiler warnings
default:
layout = "null";
break;
}
return layout;
}
static float ipc_json_child_percentage(swayc_t *c) {
float percent = 0;
swayc_t *parent = c->parent;
if (parent) {
switch (parent->layout) {
case L_VERT:
percent = c->height / parent->height;
break;
case L_HORIZ:
percent = c->width / parent->width;
break;
case L_STACKED: // fallthrough
case L_TABBED: // fallthrough
percent = 1.0;
break;
default:
break;
}
}
return percent;
}
static void ipc_json_describe_output(swayc_t *output, json_object *object) {
uint32_t scale = wlc_output_get_scale(output->handle);
json_object_object_add(object, "active", json_object_new_boolean(true));
json_object_object_add(object, "primary", json_object_new_boolean(false));
json_object_object_add(object, "layout", json_object_new_string("output"));
json_object_object_add(object, "type", json_object_new_string("output"));
json_object_object_add(object, "current_workspace",
(output->focused) ? json_object_new_string(output->focused->name) : NULL);
json_object_object_add(object, "scale", json_object_new_int(scale));
}
static void ipc_json_describe_workspace(swayc_t *workspace, json_object *object) {
int num = (isdigit(workspace->name[0])) ? atoi(workspace->name) : -1;
const char *layout = ipc_json_layout_description(workspace->workspace_layout);
json_object_object_add(object, "num", json_object_new_int(num));
json_object_object_add(object, "output", (workspace->parent) ? json_object_new_string(workspace->parent->name) : NULL);
json_object_object_add(object, "type", json_object_new_string("workspace"));
json_object_object_add(object, "layout", (strcmp(layout, "null") == 0) ? NULL : json_object_new_string(layout));
}
// window is in the scratchpad ? changed : none
static const char *ipc_json_get_scratchpad_state(swayc_t *c) {
int i;
for (i = 0; i < scratchpad->length; i++) {
if (scratchpad->items[i] == c) {
return "changed";
}
}
return "none"; // we ignore the fresh value
}
static void ipc_json_describe_view(swayc_t *c, json_object *object) {
json_object *props = json_object_new_object();
json_object_object_add(object, "type", json_object_new_string((c->is_floating) ? "floating_con" : "con"));
wlc_handle parent = wlc_view_get_parent(c->handle);
json_object_object_add(object, "scratchpad_state",
json_object_new_string(ipc_json_get_scratchpad_state(c)));
json_object_object_add(object, "name", (c->name) ? json_object_new_string(c->name) : NULL);
json_object_object_add(props, "class", c->class ? json_object_new_string(c->class) :
c->app_id ? json_object_new_string(c->app_id) : NULL);
json_object_object_add(props, "instance", c->instance ? json_object_new_string(c->instance) :
c->app_id ? json_object_new_string(c->app_id) : NULL);
json_object_object_add(props, "title", (c->name) ? json_object_new_string(c->name) : NULL);
json_object_object_add(props, "transient_for", parent ? json_object_new_int(parent) : NULL);
json_object_object_add(object, "window_properties", props);
json_object_object_add(object, "fullscreen_mode",
json_object_new_int(swayc_is_fullscreen(c) ? 1 : 0));
json_object_object_add(object, "sticky", json_object_new_boolean(c->sticky));
json_object_object_add(object, "floating", json_object_new_string(
c->is_floating ? "auto_on" : "auto_off")); // we can't state the cause
json_object_object_add(object, "app_id", c->app_id ? json_object_new_string(c->app_id) : NULL);
if (c->parent) {
const char *layout = (c->parent->type == C_CONTAINER) ?
ipc_json_layout_description(c->parent->layout) : "none";
const char *last_layout = (c->parent->type == C_CONTAINER) ?
ipc_json_layout_description(c->parent->prev_layout) : "none";
json_object_object_add(object, "layout",
(strcmp(layout, "null") == 0) ? NULL : json_object_new_string(layout));
json_object_object_add(object, "last_split_layout",
(strcmp(last_layout, "null") == 0) ? NULL : json_object_new_string(last_layout));
json_object_object_add(object, "workspace_layout",
json_object_new_string(ipc_json_layout_description(swayc_parent_by_type(c, C_WORKSPACE)->workspace_layout)));
}
}
static void ipc_json_describe_root(swayc_t *c, json_object *object) {
json_object_object_add(object, "type", json_object_new_string("root"));
json_object_object_add(object, "layout", json_object_new_string("splith"));
}
json_object *ipc_json_describe_container(swayc_t *c) {
float percent = ipc_json_child_percentage(c);
if (!(sway_assert(c, "Container must not be null."))) {
return NULL;
}
json_object *object = json_object_new_object();
json_object_object_add(object, "id", json_object_new_int((int)c->id));
json_object_object_add(object, "name", (c->name) ? json_object_new_string(c->name) : NULL);
json_object_object_add(object, "rect", ipc_json_create_rect(c));
json_object_object_add(object, "visible", json_object_new_boolean(c->visible));
json_object_object_add(object, "focused", json_object_new_boolean(c == current_focus));
json_object_object_add(object, "border", json_object_new_string(ipc_json_border_description(c)));
json_object_object_add(object, "window_rect", ipc_json_create_rect_from_geometry(c->actual_geometry));
json_object_object_add(object, "deco_rect", ipc_json_create_rect_from_geometry(c->title_bar_geometry));
json_object_object_add(object, "geometry", ipc_json_create_rect_from_geometry(c->cached_geometry));
json_object_object_add(object, "percent", (percent > 0) ? json_object_new_double(percent) : NULL);
json_object_object_add(object, "window", json_object_new_int(c->handle)); // for the sake of i3 compat
// TODO: make urgency actually work once Sway supports it
json_object_object_add(object, "urgent", json_object_new_boolean(false));
json_object_object_add(object, "current_border_width", json_object_new_int(c->border_thickness));
switch (c->type) {
case C_ROOT:
ipc_json_describe_root(c, object);
break;
case C_OUTPUT:
ipc_json_describe_output(c, object);
break;
case C_CONTAINER: // fallthrough
case C_VIEW:
ipc_json_describe_view(c, object);
break;
case C_WORKSPACE:
ipc_json_describe_workspace(c, object);
break;
case C_TYPES: // fallthrough; this should never happen, I'm just trying to silence compiler warnings
default:
break;
}
return object;
}
json_object *ipc_json_describe_input(struct libinput_device *device) {
char* identifier = libinput_dev_unique_id(device);
int vendor = libinput_device_get_id_vendor(device);
int product = libinput_device_get_id_product(device);
const char *name = libinput_device_get_name(device);
double width = -1, height = -1;
int has_size = libinput_device_get_size(device, &width, &height);
json_object *device_object = json_object_new_object();
json_object_object_add(device_object,"identifier",
identifier ? json_object_new_string(identifier) : NULL);
json_object_object_add(device_object,
"vendor", json_object_new_int(vendor));
json_object_object_add(device_object,
"product", json_object_new_int(product));
json_object_object_add(device_object,
"name", json_object_new_string(name));
if (has_size == 0) {
json_object *size_object = json_object_new_object();
json_object_object_add(size_object,
"width", json_object_new_double(width));
json_object_object_add(size_object,
"height", json_object_new_double(height));
} else {
json_object_object_add(device_object, "size", NULL);
}
struct {
enum libinput_device_capability cap;
const char *name;
// If anyone feels like implementing device-specific IPC output,
// be my guest
json_object *(*describe)(struct libinput_device *);
} caps[] = {
{ LIBINPUT_DEVICE_CAP_KEYBOARD, "keyboard", NULL },
{ LIBINPUT_DEVICE_CAP_POINTER, "pointer", NULL },
{ LIBINPUT_DEVICE_CAP_TOUCH, "touch", NULL },
{ LIBINPUT_DEVICE_CAP_TABLET_TOOL, "tablet_tool", NULL },
{ LIBINPUT_DEVICE_CAP_TABLET_PAD, "tablet_pad", NULL },
{ LIBINPUT_DEVICE_CAP_GESTURE, "gesture", NULL },
#ifdef LIBINPUT_DEVICE_CAP_SWITCH // libinput 1.7.0+
{ LIBINPUT_DEVICE_CAP_SWITCH, "switch", NULL },
#endif
};
json_object *_caps = json_object_new_array();
for (size_t i = 0; i < sizeof(caps) / sizeof(caps[0]); ++i) {
if (libinput_device_has_capability(device, caps[i].cap)) {
json_object_array_add(_caps, json_object_new_string(caps[i].name));
if (caps[i].describe) {
json_object *desc = caps[i].describe(device);
json_object_object_add(device_object, caps[i].name, desc);
}
}
}
json_object_object_add(device_object, "capabilities", _caps);
free(identifier);
return device_object;
}
json_object *ipc_json_get_version() {
int major = 0, minor = 0, patch = 0;
json_object *version = json_object_new_object();
sscanf(SWAY_VERSION, "%u.%u.%u", &major, &minor, &patch);
json_object_object_add(version, "human_readable", json_object_new_string(SWAY_VERSION));
json_object_object_add(version, "variant", json_object_new_string("sway"));
json_object_object_add(version, "major", json_object_new_int(major));
json_object_object_add(version, "minor", json_object_new_int(minor));
json_object_object_add(version, "patch", json_object_new_int(patch));
return version;
}
json_object *ipc_json_describe_bar_config(struct bar_config *bar) {
if (!sway_assert(bar, "Bar must not be NULL")) {
return NULL;
}
json_object *json = json_object_new_object();
json_object_object_add(json, "id", json_object_new_string(bar->id));
#ifdef ENABLE_TRAY
if (bar->tray_output) {
json_object_object_add(json, "tray_output", json_object_new_string(bar->tray_output));
} else {
json_object_object_add(json, "tray_output", NULL);
}
if (bar->icon_theme) {
json_object_object_add(json, "icon_theme", json_object_new_string(bar->icon_theme));
} else {
json_object_object_add(json, "icon_theme", NULL);
}
json_object_object_add(json, "tray_padding", json_object_new_int(bar->tray_padding));
json_object_object_add(json, "activate_button", json_object_new_int(bar->activate_button));
json_object_object_add(json, "context_button", json_object_new_int(bar->context_button));
json_object_object_add(json, "secondary_button", json_object_new_int(bar->secondary_button));
#endif
json_object_object_add(json, "mode", json_object_new_string(bar->mode));
json_object_object_add(json, "hidden_state", json_object_new_string(bar->hidden_state));
json_object_object_add(json, "modifier", json_object_new_string(get_modifier_name_by_mask(bar->modifier)));
switch (bar->position) {
case DESKTOP_SHELL_PANEL_POSITION_TOP:
json_object_object_add(json, "position", json_object_new_string("top"));
break;
case DESKTOP_SHELL_PANEL_POSITION_BOTTOM:
json_object_object_add(json, "position", json_object_new_string("bottom"));
break;
case DESKTOP_SHELL_PANEL_POSITION_LEFT:
json_object_object_add(json, "position", json_object_new_string("left"));
break;
case DESKTOP_SHELL_PANEL_POSITION_RIGHT:
json_object_object_add(json, "position", json_object_new_string("right"));
break;
}
json_object_object_add(json, "status_command", json_object_new_string(bar->status_command));
json_object_object_add(json, "font", json_object_new_string((bar->font) ? bar->font : config->font));
if (bar->separator_symbol) {
json_object_object_add(json, "separator_symbol", json_object_new_string(bar->separator_symbol));
}
json_object_object_add(json, "bar_height", json_object_new_int(bar->height));
json_object_object_add(json, "wrap_scroll", json_object_new_boolean(bar->wrap_scroll));
json_object_object_add(json, "workspace_buttons", json_object_new_boolean(bar->workspace_buttons));
json_object_object_add(json, "strip_workspace_numbers", json_object_new_boolean(bar->strip_workspace_numbers));
json_object_object_add(json, "binding_mode_indicator", json_object_new_boolean(bar->binding_mode_indicator));
json_object_object_add(json, "verbose", json_object_new_boolean(bar->verbose));
json_object_object_add(json, "pango_markup", json_object_new_boolean(bar->pango_markup));
json_object *colors = json_object_new_object();
json_object_object_add(colors, "background", json_object_new_string(bar->colors.background));
json_object_object_add(colors, "statusline", json_object_new_string(bar->colors.statusline));
json_object_object_add(colors, "separator", json_object_new_string(bar->colors.separator));
if (bar->colors.focused_background) {
json_object_object_add(colors, "focused_background", json_object_new_string(bar->colors.focused_background));
} else {
json_object_object_add(colors, "focused_background", json_object_new_string(bar->colors.background));
}
if (bar->colors.focused_statusline) {
json_object_object_add(colors, "focused_statusline", json_object_new_string(bar->colors.focused_statusline));
} else {
json_object_object_add(colors, "focused_statusline", json_object_new_string(bar->colors.statusline));
}
if (bar->colors.focused_separator) {
json_object_object_add(colors, "focused_separator", json_object_new_string(bar->colors.focused_separator));
} else {
json_object_object_add(colors, "focused_separator", json_object_new_string(bar->colors.separator));
}
json_object_object_add(colors, "focused_workspace_border", json_object_new_string(bar->colors.focused_workspace_border));
json_object_object_add(colors, "focused_workspace_bg", json_object_new_string(bar->colors.focused_workspace_bg));
json_object_object_add(colors, "focused_workspace_text", json_object_new_string(bar->colors.focused_workspace_text));
json_object_object_add(colors, "inactive_workspace_border", json_object_new_string(bar->colors.inactive_workspace_border));
json_object_object_add(colors, "inactive_workspace_bg", json_object_new_string(bar->colors.inactive_workspace_bg));
json_object_object_add(colors, "inactive_workspace_text", json_object_new_string(bar->colors.inactive_workspace_text));
json_object_object_add(colors, "active_workspace_border", json_object_new_string(bar->colors.active_workspace_border));
json_object_object_add(colors, "active_workspace_bg", json_object_new_string(bar->colors.active_workspace_bg));
json_object_object_add(colors, "active_workspace_text", json_object_new_string(bar->colors.active_workspace_text));
json_object_object_add(colors, "urgent_workspace_border", json_object_new_string(bar->colors.urgent_workspace_border));
json_object_object_add(colors, "urgent_workspace_bg", json_object_new_string(bar->colors.urgent_workspace_bg));
json_object_object_add(colors, "urgent_workspace_text", json_object_new_string(bar->colors.urgent_workspace_text));
if (bar->colors.binding_mode_border) {
json_object_object_add(colors, "binding_mode_border", json_object_new_string(bar->colors.binding_mode_border));
} else {
json_object_object_add(colors, "binding_mode_border", json_object_new_string(bar->colors.urgent_workspace_border));
}
if (bar->colors.binding_mode_bg) {
json_object_object_add(colors, "binding_mode_bg", json_object_new_string(bar->colors.binding_mode_bg));
} else {
json_object_object_add(colors, "binding_mode_bg", json_object_new_string(bar->colors.urgent_workspace_bg));
}
if (bar->colors.binding_mode_text) {
json_object_object_add(colors, "binding_mode_text", json_object_new_string(bar->colors.binding_mode_text));
} else {
json_object_object_add(colors, "binding_mode_text", json_object_new_string(bar->colors.urgent_workspace_text));
}
json_object_object_add(json, "colors", colors);
// Add outputs if defined
if (bar->outputs && bar->outputs->length > 0) {
json_object *outputs = json_object_new_array();
int i;
for (i = 0; i < bar->outputs->length; ++i) {
const char *name = bar->outputs->items[i];
json_object_array_add(outputs, json_object_new_string(name));
}
json_object_object_add(json, "outputs", outputs);
}
return json;
}
json_object *ipc_json_describe_container_recursive(swayc_t *c) {
json_object *object = ipc_json_describe_container(c);
int i;
json_object *floating = json_object_new_array();
if (c->type != C_VIEW && c->floating) {
for (i = 0; i < c->floating->length; ++i) {
swayc_t *item = c->floating->items[i];
json_object_array_add(floating, ipc_json_describe_container_recursive(item));
}
}
json_object_object_add(object, "floating_nodes", floating);
json_object *children = json_object_new_array();
if (c->type != C_VIEW && c->children) {
for (i = 0; i < c->children->length; ++i) {
json_object_array_add(children, ipc_json_describe_container_recursive(c->children->items[i]));
}
}
json_object_object_add(object, "nodes", children);
json_object *focus = json_object_new_array();
if (c->type != C_VIEW) {
if (c->focused) {
json_object_array_add(focus, json_object_new_double(c->focused->id));
}
if (c->floating) {
for (i = 0; i < c->floating->length; ++i) {
swayc_t *item = c->floating->items[i];
if (item == c->focused) {
continue;
}
json_object_array_add(focus, json_object_new_double(item->id));
}
}
if (c->children) {
for (i = 0; i < c->children->length; ++i) {
swayc_t *item = c->children->items[i];
if (item == c->focused) {
continue;
}
json_object_array_add(focus, json_object_new_double(item->id));
}
}
}
json_object_object_add(object, "focus", focus);
if (c->type == C_ROOT) {
json_object *scratchpad_json = json_object_new_array();
if (scratchpad->length > 0) {
for (i = 0; i < scratchpad->length; ++i) {
json_object_array_add(scratchpad_json, ipc_json_describe_container_recursive(scratchpad->items[i]));
}
}
json_object_object_add(object, "scratchpad", scratchpad_json);
}
return object;
}

840
sway/old/ipc-server.c
View file

@ -1,840 +0,0 @@
// See https://i3wm.org/docs/ipc.html for protocol information
#ifndef __FreeBSD__
// Any value will hide SOCK_CLOEXEC on FreeBSD (__BSD_VISIBLE=0)
#define _XOPEN_SOURCE 700
#endif
#include <errno.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <stdbool.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <json-c/json.h>
#include <list.h>
#include <libinput.h>
#ifdef __linux__
struct ucred {
pid_t pid;
uid_t uid;
gid_t gid;
};
#endif
#include "sway/ipc-json.h"
#include "sway/ipc-server.h"
#include "sway/security.h"
#include "sway/config.h"
#include "sway/commands.h"
#include "sway/input.h"
#include "sway/server.h"
#include "stringop.h"
#include "log.h"
#include "list.h"
#include "util.h"
static int ipc_socket = -1;
static struct wl_event_source *ipc_event_source = NULL;
static struct sockaddr_un *ipc_sockaddr = NULL;
static list_t *ipc_client_list = NULL;
static const char ipc_magic[] = {'i', '3', '-', 'i', 'p', 'c'};
struct ipc_client {
struct wl_event_source *event_source;
struct wl_event_source *writable_event_source;
int fd;
uint32_t payload_length;
uint32_t security_policy;
enum ipc_command_type current_command;
enum ipc_command_type subscribed_events;
size_t write_buffer_len;
size_t write_buffer_size;
char *write_buffer;
};
struct sockaddr_un *ipc_user_sockaddr(void);
int ipc_handle_connection(int fd, uint32_t mask, void *data);
int ipc_client_handle_readable(int client_fd, uint32_t mask, void *data);
int ipc_client_handle_writable(int client_fd, uint32_t mask, void *data);
void ipc_client_disconnect(struct ipc_client *client);
void ipc_client_handle_command(struct ipc_client *client);
bool ipc_send_reply(struct ipc_client *client, const char *payload, uint32_t payload_length);
void ipc_get_workspaces_callback(swayc_t *workspace, void *data);
void ipc_get_outputs_callback(swayc_t *container, void *data);
static void ipc_get_marks_callback(swayc_t *container, void *data);
void ipc_init(void) {
ipc_socket = socket(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0);
if (ipc_socket == -1) {
sway_abort("Unable to create IPC socket");
}
ipc_sockaddr = ipc_user_sockaddr();
// We want to use socket name set by user, not existing socket from another sway instance.
if (getenv("SWAYSOCK") != NULL && access(getenv("SWAYSOCK"), F_OK) == -1) {
strncpy(ipc_sockaddr->sun_path, getenv("SWAYSOCK"), sizeof(ipc_sockaddr->sun_path));
ipc_sockaddr->sun_path[sizeof(ipc_sockaddr->sun_path) - 1] = 0;
}
unlink(ipc_sockaddr->sun_path);
if (bind(ipc_socket, (struct sockaddr *)ipc_sockaddr, sizeof(*ipc_sockaddr)) == -1) {
sway_abort("Unable to bind IPC socket");
}
if (listen(ipc_socket, 3) == -1) {
sway_abort("Unable to listen on IPC socket");
}
// Set i3 IPC socket path so that i3-msg works out of the box
setenv("I3SOCK", ipc_sockaddr->sun_path, 1);
setenv("SWAYSOCK", ipc_sockaddr->sun_path, 1);
ipc_client_list = create_list();
ipc_event_source = wl_event_loop_add_fd(server.wl_event_loop, ipc_socket,
WL_EVENT_READABLE, ipc_handle_connection, NULL);
}
void ipc_terminate(void) {
if (ipc_event_source) {
wl_event_source_remove(ipc_event_source);
}
close(ipc_socket);
unlink(ipc_sockaddr->sun_path);
list_free(ipc_client_list);
if (ipc_sockaddr) {
free(ipc_sockaddr);
}
}
struct sockaddr_un *ipc_user_sockaddr(void) {
struct sockaddr_un *ipc_sockaddr = malloc(sizeof(struct sockaddr_un));
if (ipc_sockaddr == NULL) {
sway_abort("Can't allocate ipc_sockaddr");
}
ipc_sockaddr->sun_family = AF_UNIX;
int path_size = sizeof(ipc_sockaddr->sun_path);
// Env var typically set by logind, e.g. "/run/user/<user-id>"
const char *dir = getenv("XDG_RUNTIME_DIR");
if (!dir) {
dir = "/tmp";
}
if (path_size <= snprintf(ipc_sockaddr->sun_path, path_size,
"%s/sway-ipc.%i.%i.sock", dir, getuid(), getpid())) {
sway_abort("Socket path won't fit into ipc_sockaddr->sun_path");
}
return ipc_sockaddr;
}
static pid_t get_client_pid(int client_fd) {
// FreeBSD supports getting uid/gid, but not pid
#ifdef __linux__
struct ucred ucred;
socklen_t len = sizeof(struct ucred);
if (getsockopt(client_fd, SOL_SOCKET, SO_PEERCRED, &ucred, &len) == -1) {
return -1;
}
return ucred.pid;
#else
return -1;
#endif
}
int ipc_handle_connection(int fd, uint32_t mask, void *data) {
(void) fd; (void) data;
sway_log(L_DEBUG, "Event on IPC listening socket");
assert(mask == WL_EVENT_READABLE);
int client_fd = accept(ipc_socket, NULL, NULL);
if (client_fd == -1) {
sway_log_errno(L_ERROR, "Unable to accept IPC client connection");
return 0;
}
int flags;
if ((flags = fcntl(client_fd, F_GETFD)) == -1
|| fcntl(client_fd, F_SETFD, flags|FD_CLOEXEC) == -1) {
sway_log_errno(L_ERROR, "Unable to set CLOEXEC on IPC client socket");
close(client_fd);
return 0;
}
if ((flags = fcntl(client_fd, F_GETFL)) == -1
|| fcntl(client_fd, F_SETFL, flags|O_NONBLOCK) == -1) {
sway_log_errno(L_ERROR, "Unable to set NONBLOCK on IPC client socket");
close(client_fd);
return 0;
}
struct ipc_client* client = malloc(sizeof(struct ipc_client));
if (!client) {
sway_log(L_ERROR, "Unable to allocate ipc client");
close(client_fd);
return 0;
}
client->payload_length = 0;
client->fd = client_fd;
client->subscribed_events = 0;
client->event_source = wl_event_loop_add_fd(server.wl_event_loop, client_fd,
WL_EVENT_READABLE, ipc_client_handle_readable, client);
client->writable_event_source = NULL;
client->write_buffer_size = 128;
client->write_buffer_len = 0;
client->write_buffer = malloc(client->write_buffer_size);
if (!client->write_buffer) {
sway_log(L_ERROR, "Unable to allocate ipc client write buffer");
close(client_fd);
return 0;
}
pid_t pid = get_client_pid(client->fd);
client->security_policy = get_ipc_policy_mask(pid);
sway_log(L_DEBUG, "New client: fd %d, pid %d", client_fd, pid);
list_add(ipc_client_list, client);
return 0;
}
static const int ipc_header_size = sizeof(ipc_magic)+8;
int ipc_client_handle_readable(int client_fd, uint32_t mask, void *data) {
struct ipc_client *client = data;
if (mask & WL_EVENT_ERROR) {
sway_log(L_ERROR, "IPC Client socket error, removing client");
ipc_client_disconnect(client);
return 0;
}
if (mask & WL_EVENT_HANGUP) {
sway_log(L_DEBUG, "Client %d hung up", client->fd);
ipc_client_disconnect(client);
return 0;
}
sway_log(L_DEBUG, "Client %d readable", client->fd);
int read_available;
if (ioctl(client_fd, FIONREAD, &read_available) == -1) {
sway_log_errno(L_INFO, "Unable to read IPC socket buffer size");
ipc_client_disconnect(client);
return 0;
}
// Wait for the rest of the command payload in case the header has already been read
if (client->payload_length > 0) {
if ((uint32_t)read_available >= client->payload_length) {
ipc_client_handle_command(client);
}
return 0;
}
if (read_available < ipc_header_size) {
return 0;
}
uint8_t buf[ipc_header_size];
uint32_t *buf32 = (uint32_t*)(buf + sizeof(ipc_magic));
// Should be fully available, because read_available >= ipc_header_size
ssize_t received = recv(client_fd, buf, ipc_header_size, 0);
if (received == -1) {
sway_log_errno(L_INFO, "Unable to receive header from IPC client");
ipc_client_disconnect(client);
return 0;
}
if (memcmp(buf, ipc_magic, sizeof(ipc_magic)) != 0) {
sway_log(L_DEBUG, "IPC header check failed");
ipc_client_disconnect(client);
return 0;
}
client->payload_length = buf32[0];
client->current_command = (enum ipc_command_type)buf32[1];
if (read_available - received >= (long)client->payload_length) {
ipc_client_handle_command(client);
}
return 0;
}
int ipc_client_handle_writable(int client_fd, uint32_t mask, void *data) {
struct ipc_client *client = data;
if (mask & WL_EVENT_ERROR) {
sway_log(L_ERROR, "IPC Client socket error, removing client");
ipc_client_disconnect(client);
return 0;
}
if (mask & WL_EVENT_HANGUP) {
sway_log(L_DEBUG, "Client %d hung up", client->fd);
ipc_client_disconnect(client);
return 0;
}
if (client->write_buffer_len <= 0) {
return 0;
}
sway_log(L_DEBUG, "Client %d writable", client->fd);
ssize_t written = write(client->fd, client->write_buffer, client->write_buffer_len);
if (written == -1 && errno == EAGAIN) {
return 0;
} else if (written == -1) {
sway_log_errno(L_INFO, "Unable to send data from queue to IPC client");
ipc_client_disconnect(client);
return 0;
}
memmove(client->write_buffer, client->write_buffer + written, client->write_buffer_len - written);
client->write_buffer_len -= written;
if (client->write_buffer_len == 0 && client->writable_event_source) {
wl_event_source_remove(client->writable_event_source);
client->writable_event_source = NULL;
}
return 0;
}
void ipc_client_disconnect(struct ipc_client *client) {
if (!sway_assert(client != NULL, "client != NULL")) {
return;
}
if (client->fd != -1) {
shutdown(client->fd, SHUT_RDWR);
}
sway_log(L_INFO, "IPC Client %d disconnected", client->fd);
wl_event_source_remove(client->event_source);
if (client->writable_event_source) {
wl_event_source_remove(client->writable_event_source);
}
int i = 0;
while (i < ipc_client_list->length && ipc_client_list->items[i] != client) i++;
list_del(ipc_client_list, i);
free(client->write_buffer);
close(client->fd);
free(client);
}
bool output_by_name_test(swayc_t *view, void *data) {
char *name = (char *)data;
if (view->type != C_OUTPUT) {
return false;
}
return !strcmp(name, view->name);
}
// greedy wildcard (only "*") matching
bool mime_type_matches(const char *mime_type, const char *pattern) {
const char *wildcard = NULL;
while (*mime_type && *pattern) {
if (*pattern == '*' && !wildcard) {
wildcard = pattern;
++pattern;
}
if (*mime_type != *pattern) {
if (!wildcard)
return false;
pattern = wildcard;
++mime_type;
continue;
}
++mime_type;
++pattern;
}
while (*pattern == '*') {
++pattern;
}
return (*mime_type == *pattern);
}
void ipc_client_handle_command(struct ipc_client *client) {
if (!sway_assert(client != NULL, "client != NULL")) {
return;
}
char *buf = malloc(client->payload_length + 1);
if (!buf) {
sway_log_errno(L_INFO, "Unable to allocate IPC payload");
ipc_client_disconnect(client);
return;
}
if (client->payload_length > 0) {
// Payload should be fully available
ssize_t received = recv(client->fd, buf, client->payload_length, 0);
if (received == -1)
{
sway_log_errno(L_INFO, "Unable to receive payload from IPC client");
ipc_client_disconnect(client);
free(buf);
return;
}
}
buf[client->payload_length] = '\0';
const char *error_denied = "{ \"success\": false, \"error\": \"Permission denied\" }";
switch (client->current_command) {
case IPC_COMMAND:
{
if (!(client->security_policy & IPC_FEATURE_COMMAND)) {
goto exit_denied;
}
struct cmd_results *results = handle_command(buf, CONTEXT_IPC);
const char *json = cmd_results_to_json(results);
char reply[256];
int length = snprintf(reply, sizeof(reply), "%s", json);
ipc_send_reply(client, reply, (uint32_t) length);
free_cmd_results(results);
goto exit_cleanup;
}
case IPC_SUBSCRIBE:
{
// TODO: Check if they're permitted to use these events
struct json_object *request = json_tokener_parse(buf);
if (request == NULL) {
ipc_send_reply(client, "{\"success\": false}", 18);
sway_log_errno(L_INFO, "Failed to read request");
goto exit_cleanup;
}
// parse requested event types
for (int i = 0; i < json_object_array_length(request); i++) {
const char *event_type = json_object_get_string(json_object_array_get_idx(request, i));
if (strcmp(event_type, "workspace") == 0) {
client->subscribed_events |= event_mask(IPC_EVENT_WORKSPACE);
} else if (strcmp(event_type, "barconfig_update") == 0) {
client->subscribed_events |= event_mask(IPC_EVENT_BARCONFIG_UPDATE);
} else if (strcmp(event_type, "mode") == 0) {
client->subscribed_events |= event_mask(IPC_EVENT_MODE);
} else if (strcmp(event_type, "window") == 0) {
client->subscribed_events |= event_mask(IPC_EVENT_WINDOW);
} else if (strcmp(event_type, "modifier") == 0) {
client->subscribed_events |= event_mask(IPC_EVENT_MODIFIER);
} else if (strcmp(event_type, "binding") == 0) {
client->subscribed_events |= event_mask(IPC_EVENT_BINDING);
} else {
ipc_send_reply(client, "{\"success\": false}", 18);
json_object_put(request);
sway_log_errno(L_INFO, "Failed to parse request");
goto exit_cleanup;
}
}
json_object_put(request);
ipc_send_reply(client, "{\"success\": true}", 17);
goto exit_cleanup;
}
case IPC_GET_WORKSPACES:
{
if (!(client->security_policy & IPC_FEATURE_GET_WORKSPACES)) {
goto exit_denied;
}
json_object *workspaces = json_object_new_array();
container_map(&root_container, ipc_get_workspaces_callback, workspaces);
const char *json_string = json_object_to_json_string(workspaces);
ipc_send_reply(client, json_string, (uint32_t) strlen(json_string));
json_object_put(workspaces); // free
goto exit_cleanup;
}
case IPC_GET_INPUTS:
{
if (!(client->security_policy & IPC_FEATURE_GET_INPUTS)) {
goto exit_denied;
}
json_object *inputs = json_object_new_array();
/* TODO WLR
if (input_devices) {
for(int i = 0; i<input_devices->length; i++) {
struct libinput_device *device = input_devices->items[i];
json_object_array_add(inputs, ipc_json_describe_input(device));
}
}
*/
const char *json_string = json_object_to_json_string(inputs);
ipc_send_reply(client, json_string, (uint32_t) strlen(json_string));
json_object_put(inputs);
goto exit_cleanup;
}
case IPC_GET_OUTPUTS:
{
if (!(client->security_policy & IPC_FEATURE_GET_OUTPUTS)) {
goto exit_denied;
}
json_object *outputs = json_object_new_array();
container_map(&root_container, ipc_get_outputs_callback, outputs);
const char *json_string = json_object_to_json_string(outputs);
ipc_send_reply(client, json_string, (uint32_t) strlen(json_string));
json_object_put(outputs); // free
goto exit_cleanup;
}
case IPC_GET_TREE:
{
if (!(client->security_policy & IPC_FEATURE_GET_TREE)) {
goto exit_denied;
}
json_object *tree = ipc_json_describe_container_recursive(&root_container);
const char *json_string = json_object_to_json_string(tree);
ipc_send_reply(client, json_string, (uint32_t) strlen(json_string));
json_object_put(tree);
goto exit_cleanup;
}
case IPC_GET_MARKS:
{
if (!(client->security_policy & IPC_FEATURE_GET_MARKS)) {
goto exit_denied;
}
json_object *marks = json_object_new_array();
container_map(&root_container, ipc_get_marks_callback, marks);
const char *json_string = json_object_to_json_string(marks);
ipc_send_reply(client, json_string, (uint32_t) strlen(json_string));
json_object_put(marks);
goto exit_cleanup;
}
case IPC_GET_VERSION:
{
json_object *version = ipc_json_get_version();
const char *json_string = json_object_to_json_string(version);
ipc_send_reply(client, json_string, (uint32_t)strlen(json_string));
json_object_put(version); // free
goto exit_cleanup;
}
case IPC_GET_BAR_CONFIG:
{
if (!(client->security_policy & IPC_FEATURE_GET_BAR_CONFIG)) {
goto exit_denied;
}
if (!buf[0]) {
// Send list of configured bar IDs
json_object *bars = json_object_new_array();
int i;
for (i = 0; i < config->bars->length; ++i) {
struct bar_config *bar = config->bars->items[i];
json_object_array_add(bars, json_object_new_string(bar->id));
}
const char *json_string = json_object_to_json_string(bars);
ipc_send_reply(client, json_string, (uint32_t)strlen(json_string));
json_object_put(bars); // free
} else {
// Send particular bar's details
struct bar_config *bar = NULL;
int i;
for (i = 0; i < config->bars->length; ++i) {
bar = config->bars->items[i];
if (strcmp(buf, bar->id) == 0) {
break;
}
bar = NULL;
}
if (!bar) {
const char *error = "{ \"success\": false, \"error\": \"No bar with that ID\" }";
ipc_send_reply(client, error, (uint32_t)strlen(error));
goto exit_cleanup;
}
json_object *json = ipc_json_describe_bar_config(bar);
const char *json_string = json_object_to_json_string(json);
ipc_send_reply(client, json_string, (uint32_t)strlen(json_string));
json_object_put(json); // free
}
goto exit_cleanup;
}
case IPC_GET_CLIPBOARD:
// TODO WLR
break;
default:
sway_log(L_INFO, "Unknown IPC command type %i", client->current_command);
goto exit_cleanup;
}
exit_denied:
ipc_send_reply(client, error_denied, (uint32_t)strlen(error_denied));
sway_log(L_DEBUG, "Denied IPC client access to %i", client->current_command);
exit_cleanup:
client->payload_length = 0;
free(buf);
return;
}
bool ipc_send_reply(struct ipc_client *client, const char *payload, uint32_t payload_length) {
assert(payload);
char data[ipc_header_size];
uint32_t *data32 = (uint32_t*)(data + sizeof(ipc_magic));
memcpy(data, ipc_magic, sizeof(ipc_magic));
data32[0] = payload_length;
data32[1] = client->current_command;
while (client->write_buffer_len + ipc_header_size + payload_length >=
client->write_buffer_size) {
client->write_buffer_size *= 2;
}
// TODO: reduce the limit back to 4 MB when screenshooter is implemented
if (client->write_buffer_size > (1 << 28)) { // 256 MB
sway_log(L_ERROR, "Client write buffer too big, disconnecting client");
ipc_client_disconnect(client);
return false;
}
char *new_buffer = realloc(client->write_buffer, client->write_buffer_size);
if (!new_buffer) {
sway_log(L_ERROR, "Unable to reallocate ipc client write buffer");
ipc_client_disconnect(client);
return false;
}
client->write_buffer = new_buffer;
memcpy(client->write_buffer + client->write_buffer_len, data, ipc_header_size);
client->write_buffer_len += ipc_header_size;
memcpy(client->write_buffer + client->write_buffer_len, payload, payload_length);
client->write_buffer_len += payload_length;
if (!client->writable_event_source) {
client->writable_event_source = wl_event_loop_add_fd(
server.wl_event_loop, client->fd, WL_EVENT_WRITABLE,
ipc_client_handle_writable, client);
}
sway_log(L_DEBUG, "Added IPC reply to client %d queue: %s", client->fd, payload);
return true;
}
void ipc_get_workspaces_callback(swayc_t *workspace, void *data) {
if (workspace->type == C_WORKSPACE) {
json_object *workspace_json = ipc_json_describe_container(workspace);
// override the default focused indicator because
// it's set differently for the get_workspaces reply
bool focused = root_container.focused == workspace->parent && workspace->parent->focused == workspace;
json_object_object_del(workspace_json, "focused");
json_object_object_add(workspace_json, "focused", json_object_new_boolean(focused));
json_object_array_add((json_object *)data, workspace_json);
}
}
void ipc_get_outputs_callback(swayc_t *container, void *data) {
if (container->type == C_OUTPUT) {
json_object_array_add((json_object *)data, ipc_json_describe_container(container));
}
}
static void ipc_get_marks_callback(swayc_t *container, void *data) {
json_object *object = (json_object *)data;
if (container->marks) {
for (int i = 0; i < container->marks->length; ++i) {
char *mark = (char *)container->marks->items[i];
json_object_array_add(object, json_object_new_string(mark));
}
}
}
void ipc_send_event(const char *json_string, enum ipc_command_type event) {
static struct {
enum ipc_command_type event;
enum ipc_feature feature;
} security_mappings[] = {
{ IPC_EVENT_WORKSPACE, IPC_FEATURE_EVENT_WORKSPACE },
{ IPC_EVENT_OUTPUT, IPC_FEATURE_EVENT_OUTPUT },
{ IPC_EVENT_MODE, IPC_FEATURE_EVENT_MODE },
{ IPC_EVENT_WINDOW, IPC_FEATURE_EVENT_WINDOW },
{ IPC_EVENT_BINDING, IPC_FEATURE_EVENT_BINDING },
{ IPC_EVENT_INPUT, IPC_FEATURE_EVENT_INPUT }
};
uint32_t security_mask = 0;
for (size_t i = 0; i < sizeof(security_mappings) / sizeof(security_mappings[0]); ++i) {
if (security_mappings[i].event == event) {
security_mask = security_mappings[i].feature;
break;
}
}
int i;
struct ipc_client *client;
for (i = 0; i < ipc_client_list->length; i++) {
client = ipc_client_list->items[i];
if (!(client->security_policy & security_mask)) {
continue;
}
if ((client->subscribed_events & event_mask(event)) == 0) {
continue;
}
client->current_command = event;
if (!ipc_send_reply(client, json_string, (uint32_t) strlen(json_string))) {
sway_log_errno(L_INFO, "Unable to send reply to IPC client");
ipc_client_disconnect(client);
}
}
}
void ipc_event_workspace(swayc_t *old, swayc_t *new, const char *change) {
sway_log(L_DEBUG, "Sending workspace::%s event", change);
json_object *obj = json_object_new_object();
json_object_object_add(obj, "change", json_object_new_string(change));
if (strcmp("focus", change) == 0) {
if (old) {
json_object_object_add(obj, "old", ipc_json_describe_container_recursive(old));
} else {
json_object_object_add(obj, "old", NULL);
}
}
if (new) {
json_object_object_add(obj, "current", ipc_json_describe_container_recursive(new));
} else {
json_object_object_add(obj, "current", NULL);
}
const char *json_string = json_object_to_json_string(obj);
ipc_send_event(json_string, IPC_EVENT_WORKSPACE);
json_object_put(obj); // free
}
void ipc_event_window(swayc_t *window, const char *change) {
sway_log(L_DEBUG, "Sending window::%s event", change);
json_object *obj = json_object_new_object();
json_object_object_add(obj, "change", json_object_new_string(change));
json_object_object_add(obj, "container", ipc_json_describe_container_recursive(window));
const char *json_string = json_object_to_json_string(obj);
ipc_send_event(json_string, IPC_EVENT_WINDOW);
json_object_put(obj); // free
}
void ipc_event_barconfig_update(struct bar_config *bar) {
sway_log(L_DEBUG, "Sending barconfig_update event");
json_object *json = ipc_json_describe_bar_config(bar);
const char *json_string = json_object_to_json_string(json);
ipc_send_event(json_string, IPC_EVENT_BARCONFIG_UPDATE);
json_object_put(json); // free
}
void ipc_event_mode(const char *mode) {
sway_log(L_DEBUG, "Sending mode::%s event", mode);
json_object *obj = json_object_new_object();
json_object_object_add(obj, "change", json_object_new_string(mode));
const char *json_string = json_object_to_json_string(obj);
ipc_send_event(json_string, IPC_EVENT_MODE);
json_object_put(obj); // free
}
void ipc_event_modifier(uint32_t modifier, const char *state) {
sway_log(L_DEBUG, "Sending modifier::%s event", state);
json_object *obj = json_object_new_object();
json_object_object_add(obj, "change", json_object_new_string(state));
const char *modifier_name = get_modifier_name_by_mask(modifier);
json_object_object_add(obj, "modifier", json_object_new_string(modifier_name));
const char *json_string = json_object_to_json_string(obj);
ipc_send_event(json_string, IPC_EVENT_MODIFIER);
json_object_put(obj); // free
}
static void ipc_event_binding(json_object *sb_obj) {
sway_log(L_DEBUG, "Sending binding::run event");
json_object *obj = json_object_new_object();
json_object_object_add(obj, "change", json_object_new_string("run"));
json_object_object_add(obj, "binding", sb_obj);
const char *json_string = json_object_to_json_string(obj);
ipc_send_event(json_string, IPC_EVENT_BINDING);
json_object_put(obj); // free
}
void ipc_event_binding_keyboard(struct sway_binding *sb) {
json_object *sb_obj = json_object_new_object();
json_object_object_add(sb_obj, "command", json_object_new_string(sb->command));
const char *names[10];
int len = get_modifier_names(names, sb->modifiers);
int i;
json_object *modifiers = json_object_new_array();
for (i = 0; i < len; ++i) {
json_object_array_add(modifiers, json_object_new_string(names[i]));
}
json_object_object_add(sb_obj, "event_state_mask", modifiers);
json_object *input_codes = json_object_new_array();
int input_code = 0;
json_object *symbols = json_object_new_array();
json_object *symbol = NULL;
if (sb->bindcode) { // bindcode: populate input_codes
uint32_t keycode;
for (i = 0; i < sb->keys->length; ++i) {
keycode = *(uint32_t *)sb->keys->items[i];
json_object_array_add(input_codes, json_object_new_int(keycode));
if (i == 0) {
input_code = keycode;
}
}
} else { // bindsym: populate symbols
uint32_t keysym;
char buffer[64];
for (i = 0; i < sb->keys->length; ++i) {
keysym = *(uint32_t *)sb->keys->items[i];
if (xkb_keysym_get_name(keysym, buffer, 64) > 0) {
json_object *str = json_object_new_string(buffer);
json_object_array_add(symbols, str);
if (i == 0) {
symbol = str;
}
}
}
}
json_object_object_add(sb_obj, "input_codes", input_codes);
json_object_object_add(sb_obj, "input_code", json_object_new_int(input_code));
json_object_object_add(sb_obj, "symbols", symbols);
json_object_object_add(sb_obj, "symbol", symbol);
json_object_object_add(sb_obj, "input_type", json_object_new_string("keyboard"));
ipc_event_binding(sb_obj);
}

Some files were not shown because too many files have changed in this diff Show more