diff options
31 files changed, 1051 insertions, 50 deletions
diff --git a/include/sway/commands.h b/include/sway/commands.h index 9ff18823..dda286a2 100644 --- a/include/sway/commands.h +++ b/include/sway/commands.h | |||
@@ -74,6 +74,9 @@ void free_cmd_results(struct cmd_results *results); | |||
74 | */ | 74 | */ |
75 | const char *cmd_results_to_json(struct cmd_results *results); | 75 | const char *cmd_results_to_json(struct cmd_results *results); |
76 | 76 | ||
77 | struct cmd_results *add_color(const char *name, | ||
78 | char *buffer, const char *color); | ||
79 | |||
77 | typedef struct cmd_results *sway_cmd(int argc, char **argv); | 80 | typedef struct cmd_results *sway_cmd(int argc, char **argv); |
78 | 81 | ||
79 | sway_cmd cmd_assign; | 82 | sway_cmd cmd_assign; |
diff --git a/include/sway/ipc-server.h b/include/sway/ipc-server.h index 6b7404e5..1f6fffff 100644 --- a/include/sway/ipc-server.h +++ b/include/sway/ipc-server.h | |||
@@ -12,5 +12,6 @@ struct sockaddr_un *ipc_user_sockaddr(void); | |||
12 | 12 | ||
13 | void ipc_event_workspace(swayc_t *old, swayc_t *new, const char *change); | 13 | void ipc_event_workspace(swayc_t *old, swayc_t *new, const char *change); |
14 | void ipc_event_window(swayc_t *window, const char *change); | 14 | void ipc_event_window(swayc_t *window, const char *change); |
15 | void ipc_event_barconfig_update(struct bar_config *bar); | ||
15 | 16 | ||
16 | #endif | 17 | #endif |
diff --git a/sway/commands.c b/sway/commands.c index b52eb200..8d8b643b 100644 --- a/sway/commands.c +++ b/sway/commands.c | |||
@@ -91,45 +91,9 @@ void apply_seat_config(struct seat_config *seat) { | |||
91 | sway_input_manager_apply_seat_config(input_manager, seat); | 91 | sway_input_manager_apply_seat_config(input_manager, seat); |
92 | } | 92 | } |
93 | 93 | ||
94 | /** | 94 | /* Keep alphabetized */ |
95 | * Check and add color to buffer. | ||
96 | * | ||
97 | * return error object, or NULL if color is valid. | ||
98 | */ | ||
99 | struct cmd_results *add_color(const char *name, char *buffer, const char *color) { | ||
100 | int len = strlen(color); | ||
101 | if (len != 7 && len != 9) { | ||
102 | return cmd_results_new(CMD_INVALID, name, "Invalid color definition %s", color); | ||
103 | } | ||
104 | |||
105 | if (color[0] != '#') { | ||
106 | return cmd_results_new(CMD_INVALID, name, "Invalid color definition %s", color); | ||
107 | } | ||
108 | |||
109 | int i; | ||
110 | for (i = 1; i < len; ++i) { | ||
111 | if (!isxdigit(color[i])) { | ||
112 | return cmd_results_new(CMD_INVALID, name, "Invalid color definition %s", color); | ||
113 | } | ||
114 | } | ||
115 | |||
116 | // copy color to buffer | ||
117 | strncpy(buffer, color, len); | ||
118 | // add default alpha channel if color was defined without it | ||
119 | if (len == 7) { | ||
120 | buffer[7] = 'f'; | ||
121 | buffer[8] = 'f'; | ||
122 | } | ||
123 | buffer[9] = '\0'; | ||
124 | |||
125 | return NULL; | ||
126 | } | ||
127 | |||
128 | /** | ||
129 | * handlers that can run in either config or command context | ||
130 | * Keep alphabetized | ||
131 | */ | ||
132 | static struct cmd_handler handlers[] = { | 95 | static struct cmd_handler handlers[] = { |
96 | { "bar", cmd_bar }, | ||
133 | { "bindcode", cmd_bindcode }, | 97 | { "bindcode", cmd_bindcode }, |
134 | { "bindsym", cmd_bindsym }, | 98 | { "bindsym", cmd_bindsym }, |
135 | { "exec", cmd_exec }, | 99 | { "exec", cmd_exec }, |
@@ -141,18 +105,53 @@ static struct cmd_handler handlers[] = { | |||
141 | { "workspace", cmd_workspace }, | 105 | { "workspace", cmd_workspace }, |
142 | }; | 106 | }; |
143 | 107 | ||
144 | /** | 108 | static struct cmd_handler bar_handlers[] = { |
145 | * Commands that can *only* run in the config loading context | 109 | { "activate_button", bar_cmd_activate_button }, |
146 | * Keep alphabetized | 110 | { "binding_mode_indicator", bar_cmd_binding_mode_indicator }, |
147 | */ | 111 | { "bindsym", bar_cmd_bindsym }, |
112 | { "colors", bar_cmd_colors }, | ||
113 | { "context_button", bar_cmd_context_button }, | ||
114 | { "font", bar_cmd_font }, | ||
115 | { "height", bar_cmd_height }, | ||
116 | { "hidden_state", bar_cmd_hidden_state }, | ||
117 | { "icon_theme", bar_cmd_icon_theme }, | ||
118 | { "id", bar_cmd_id }, | ||
119 | { "mode", bar_cmd_mode }, | ||
120 | { "modifier", bar_cmd_modifier }, | ||
121 | { "output", bar_cmd_output }, | ||
122 | { "pango_markup", bar_cmd_pango_markup }, | ||
123 | { "position", bar_cmd_position }, | ||
124 | { "secondary_button", bar_cmd_secondary_button }, | ||
125 | { "separator_symbol", bar_cmd_separator_symbol }, | ||
126 | { "status_command", bar_cmd_status_command }, | ||
127 | { "strip_workspace_numbers", bar_cmd_strip_workspace_numbers }, | ||
128 | { "swaybar_command", bar_cmd_swaybar_command }, | ||
129 | { "tray_output", bar_cmd_tray_output }, | ||
130 | { "tray_padding", bar_cmd_tray_padding }, | ||
131 | { "workspace_buttons", bar_cmd_workspace_buttons }, | ||
132 | { "wrap_scroll", bar_cmd_wrap_scroll }, | ||
133 | }; | ||
134 | |||
135 | static struct cmd_handler bar_colors_handlers[] = { | ||
136 | { "active_workspace", bar_colors_cmd_active_workspace }, | ||
137 | { "background", bar_colors_cmd_background }, | ||
138 | { "binding_mode", bar_colors_cmd_binding_mode }, | ||
139 | { "focused_background", bar_colors_cmd_focused_background }, | ||
140 | { "focused_separator", bar_colors_cmd_focused_separator }, | ||
141 | { "focused_statusline", bar_colors_cmd_focused_statusline }, | ||
142 | { "focused_workspace", bar_colors_cmd_focused_workspace }, | ||
143 | { "inactive_workspace", bar_colors_cmd_inactive_workspace }, | ||
144 | { "separator", bar_colors_cmd_separator }, | ||
145 | { "statusline", bar_colors_cmd_statusline }, | ||
146 | { "urgent_workspace", bar_colors_cmd_urgent_workspace }, | ||
147 | }; | ||
148 | |||
149 | /* Config-time only commands. Keep alphabetized */ | ||
148 | static struct cmd_handler config_handlers[] = { | 150 | static struct cmd_handler config_handlers[] = { |
149 | { "set", cmd_set }, | 151 | { "set", cmd_set }, |
150 | }; | 152 | }; |
151 | 153 | ||
152 | /** | 154 | /* Runtime-only commands. Keep alphabetized */ |
153 | * Commands that can *not* run in the config loading context | ||
154 | * Keep alphabetized | ||
155 | */ | ||
156 | static struct cmd_handler command_handlers[] = { | 155 | static struct cmd_handler command_handlers[] = { |
157 | { "exit", cmd_exit }, | 156 | { "exit", cmd_exit }, |
158 | { "focus", cmd_focus }, | 157 | { "focus", cmd_focus }, |
@@ -200,13 +199,19 @@ static struct cmd_handler *find_handler(char *line, enum cmd_status block) { | |||
200 | 199 | ||
201 | bool config_loading = config->reading || !config->active; | 200 | bool config_loading = config->reading || !config->active; |
202 | 201 | ||
203 | if (block == CMD_BLOCK_INPUT) { | 202 | if (block == CMD_BLOCK_BAR) { |
204 | // input commands can run in either context | 203 | return bsearch(&d, bar_handlers, |
204 | sizeof(bar_handlers) / sizeof(struct cmd_handler), | ||
205 | sizeof(struct cmd_handler), handler_compare); | ||
206 | } else if (block == CMD_BLOCK_BAR_COLORS) { | ||
207 | return bsearch(&d, bar_colors_handlers, | ||
208 | sizeof(bar_colors_handlers) / sizeof(struct cmd_handler), | ||
209 | sizeof(struct cmd_handler), handler_compare); | ||
210 | } else if (block == CMD_BLOCK_INPUT) { | ||
205 | return bsearch(&d, input_handlers, | 211 | return bsearch(&d, input_handlers, |
206 | sizeof(input_handlers) / sizeof(struct cmd_handler), | 212 | sizeof(input_handlers) / sizeof(struct cmd_handler), |
207 | sizeof(struct cmd_handler), handler_compare); | 213 | sizeof(struct cmd_handler), handler_compare); |
208 | } else if (block == CMD_BLOCK_SEAT) { | 214 | } else if (block == CMD_BLOCK_SEAT) { |
209 | // seat commands can run in either context | ||
210 | return bsearch(&d, seat_handlers, | 215 | return bsearch(&d, seat_handlers, |
211 | sizeof(seat_handlers) / sizeof(struct cmd_handler), | 216 | sizeof(seat_handlers) / sizeof(struct cmd_handler), |
212 | sizeof(struct cmd_handler), handler_compare); | 217 | sizeof(struct cmd_handler), handler_compare); |
@@ -558,3 +563,35 @@ const char *cmd_results_to_json(struct cmd_results *results) { | |||
558 | free(root); | 563 | free(root); |
559 | return json; | 564 | return json; |
560 | } | 565 | } |
566 | |||
567 | /** | ||
568 | * Check and add color to buffer. | ||
569 | * | ||
570 | * return error object, or NULL if color is valid. | ||
571 | */ | ||
572 | struct cmd_results *add_color(const char *name, | ||
573 | char *buffer, const char *color) { | ||
574 | int len = strlen(color); | ||
575 | if (len != 7 && len != 9) { | ||
576 | return cmd_results_new(CMD_INVALID, name, | ||
577 | "Invalid color definition %s", color); | ||
578 | } | ||
579 | if (color[0] != '#') { | ||
580 | return cmd_results_new(CMD_INVALID, name, | ||
581 | "Invalid color definition %s", color); | ||
582 | } | ||
583 | for (int i = 1; i < len; ++i) { | ||
584 | if (!isxdigit(color[i])) { | ||
585 | return cmd_results_new(CMD_INVALID, name, | ||
586 | "Invalid color definition %s", color); | ||
587 | } | ||
588 | } | ||
589 | strncpy(buffer, color, len); | ||
590 | // add default alpha channel if color was defined without it | ||
591 | if (len == 7) { | ||
592 | buffer[7] = 'f'; | ||
593 | buffer[8] = 'f'; | ||
594 | } | ||
595 | buffer[9] = '\0'; | ||
596 | return NULL; | ||
597 | } | ||
diff --git a/sway/commands/bar.c b/sway/commands/bar.c new file mode 100644 index 00000000..548106b3 --- /dev/null +++ b/sway/commands/bar.c | |||
@@ -0,0 +1,57 @@ | |||
1 | #include <string.h> | ||
2 | #include <strings.h> | ||
3 | #include <wlr/util/log.h> | ||
4 | #include "sway/commands.h" | ||
5 | #include "sway/config.h" | ||
6 | #include "util.h" | ||
7 | |||
8 | struct cmd_results *cmd_bar(int argc, char **argv) { | ||
9 | struct cmd_results *error = NULL; | ||
10 | if ((error = checkarg(argc, "bar", EXPECTED_AT_LEAST, 1))) { | ||
11 | return error; | ||
12 | } | ||
13 | |||
14 | if (config->reading && strcmp("{", argv[0]) != 0) { | ||
15 | return cmd_results_new(CMD_INVALID, "bar", | ||
16 | "Expected '{' at start of bar config definition."); | ||
17 | } | ||
18 | |||
19 | if (!config->reading) { | ||
20 | if (argc > 1) { | ||
21 | if (strcasecmp("mode", argv[0]) == 0) { | ||
22 | return bar_cmd_mode(argc-1, argv + 1); | ||
23 | } | ||
24 | |||
25 | if (strcasecmp("hidden_state", argv[0]) == 0) { | ||
26 | return bar_cmd_hidden_state(argc-1, argv + 1); | ||
27 | } | ||
28 | } | ||
29 | return cmd_results_new(CMD_FAILURE, "bar", "Can only be used in config file."); | ||
30 | } | ||
31 | |||
32 | // Create new bar with default values | ||
33 | struct bar_config *bar = default_bar_config(); | ||
34 | if (!bar) { | ||
35 | return cmd_results_new(CMD_FAILURE, "bar", "Unable to allocate bar state"); | ||
36 | } | ||
37 | |||
38 | // set bar id | ||
39 | int i; | ||
40 | for (i = 0; i < config->bars->length; ++i) { | ||
41 | if (bar == config->bars->items[i]) { | ||
42 | const int len = 5 + numlen(i); // "bar-" + i + \0 | ||
43 | bar->id = malloc(len * sizeof(char)); | ||
44 | if (bar->id) { | ||
45 | snprintf(bar->id, len, "bar-%d", i); | ||
46 | } else { | ||
47 | return cmd_results_new(CMD_FAILURE, "bar", "Unable to allocate bar ID"); | ||
48 | } | ||
49 | break; | ||
50 | } | ||
51 | } | ||
52 | |||
53 | // Set current bar | ||
54 | config->current_bar = bar; | ||
55 | wlr_log(L_DEBUG, "Configuring bar %s", bar->id); | ||
56 | return cmd_results_new(CMD_BLOCK_BAR, NULL, NULL); | ||
57 | } | ||
diff --git a/sway/commands/bar/activate_button.c b/sway/commands/bar/activate_button.c new file mode 100644 index 00000000..0665d2a6 --- /dev/null +++ b/sway/commands/bar/activate_button.c | |||
@@ -0,0 +1,9 @@ | |||
1 | #include <stdlib.h> | ||
2 | #include "sway/commands.h" | ||
3 | #include "log.h" | ||
4 | |||
5 | struct cmd_results *bar_cmd_activate_button(int argc, char **argv) { | ||
6 | const char *cmd_name = "activate_button"; | ||
7 | // TODO TRAY | ||
8 | return cmd_results_new(CMD_INVALID, cmd_name, "TODO TRAY"); | ||
9 | } | ||
diff --git a/sway/commands/bar/binding_mode_indicator.c b/sway/commands/bar/binding_mode_indicator.c new file mode 100644 index 00000000..e11e1033 --- /dev/null +++ b/sway/commands/bar/binding_mode_indicator.c | |||
@@ -0,0 +1,27 @@ | |||
1 | #include <string.h> | ||
2 | #include <strings.h> | ||
3 | #include "sway/commands.h" | ||
4 | #include "log.h" | ||
5 | |||
6 | struct cmd_results *bar_cmd_binding_mode_indicator(int argc, char **argv) { | ||
7 | struct cmd_results *error = NULL; | ||
8 | if ((error = checkarg(argc, "binding_mode_indicator", EXPECTED_EQUAL_TO, 1))) { | ||
9 | return error; | ||
10 | } | ||
11 | |||
12 | if (!config->current_bar) { | ||
13 | return cmd_results_new(CMD_FAILURE, "binding_mode_indicator", "No bar defined."); | ||
14 | } | ||
15 | |||
16 | if (strcasecmp("yes", argv[0]) == 0) { | ||
17 | config->current_bar->binding_mode_indicator = true; | ||
18 | wlr_log(L_DEBUG, "Enabling binding mode indicator on bar: %s", config->current_bar->id); | ||
19 | } else if (strcasecmp("no", argv[0]) == 0) { | ||
20 | config->current_bar->binding_mode_indicator = false; | ||
21 | wlr_log(L_DEBUG, "Disabling binding mode indicator on bar: %s", config->current_bar->id); | ||
22 | } else { | ||
23 | error = cmd_results_new(CMD_INVALID, "binding_mode_indicator", "Invalid value %s", argv[0]); | ||
24 | return error; | ||
25 | } | ||
26 | return cmd_results_new(CMD_SUCCESS, NULL, NULL); | ||
27 | } | ||
diff --git a/sway/commands/bar/bindsym.c b/sway/commands/bar/bindsym.c new file mode 100644 index 00000000..ac09a03f --- /dev/null +++ b/sway/commands/bar/bindsym.c | |||
@@ -0,0 +1,11 @@ | |||
1 | #include <stdlib.h> | ||
2 | #include <string.h> | ||
3 | #include "sway/commands.h" | ||
4 | #include "sway/config.h" | ||
5 | #include "list.h" | ||
6 | #include "log.h" | ||
7 | #include "stringop.h" | ||
8 | |||
9 | struct cmd_results *bar_cmd_bindsym(int argc, char **argv) { | ||
10 | return cmd_results_new(CMD_FAILURE, "bindsym", "TODO"); // TODO | ||
11 | } | ||
diff --git a/sway/commands/bar/colors.c b/sway/commands/bar/colors.c new file mode 100644 index 00000000..8b3b0aac --- /dev/null +++ b/sway/commands/bar/colors.c | |||
@@ -0,0 +1,129 @@ | |||
1 | #include <string.h> | ||
2 | #include "sway/commands.h" | ||
3 | |||
4 | static struct cmd_results *parse_single_color(char **color, const char *cmd_name, int argc, char **argv) { | ||
5 | struct cmd_results *error = NULL; | ||
6 | if ((error = checkarg(argc, cmd_name, EXPECTED_EQUAL_TO, 1))) { | ||
7 | return error; | ||
8 | } | ||
9 | |||
10 | if (!*color) { | ||
11 | *color = malloc(10); | ||
12 | if (!*color) { | ||
13 | return cmd_results_new(CMD_FAILURE, cmd_name, "Unable to allocate color"); | ||
14 | } | ||
15 | } | ||
16 | |||
17 | error = add_color(cmd_name, *color, argv[0]); | ||
18 | if (error) { | ||
19 | return error; | ||
20 | } | ||
21 | |||
22 | return cmd_results_new(CMD_SUCCESS, NULL, NULL); | ||
23 | } | ||
24 | |||
25 | static struct cmd_results *parse_three_colors(char ***colors, const char *cmd_name, int argc, char **argv) { | ||
26 | struct cmd_results *error = NULL; | ||
27 | if (argc != 3) { | ||
28 | return cmd_results_new(CMD_INVALID, cmd_name, "Requires exactly three color values"); | ||
29 | } | ||
30 | |||
31 | int i; | ||
32 | for (i = 0; i < 3; i++) { | ||
33 | if (!*colors[i]) { | ||
34 | *(colors[i]) = malloc(10); | ||
35 | if (!*(colors[i])) { | ||
36 | return cmd_results_new(CMD_FAILURE, cmd_name, "Unable to allocate color"); | ||
37 | } | ||
38 | } | ||
39 | error = add_color(cmd_name, *(colors[i]), argv[i]); | ||
40 | if (error) { | ||
41 | return error; | ||
42 | } | ||
43 | } | ||
44 | |||
45 | return cmd_results_new(CMD_SUCCESS, NULL, NULL); | ||
46 | } | ||
47 | |||
48 | struct cmd_results *bar_cmd_colors(int argc, char **argv) { | ||
49 | struct cmd_results *error = NULL; | ||
50 | if ((error = checkarg(argc, "colors", EXPECTED_EQUAL_TO, 1))) { | ||
51 | return error; | ||
52 | } | ||
53 | |||
54 | if (strcmp("{", argv[0]) != 0) { | ||
55 | return cmd_results_new(CMD_INVALID, "colors", | ||
56 | "Expected '{' at the start of colors config definition."); | ||
57 | } | ||
58 | |||
59 | return cmd_results_new(CMD_BLOCK_BAR_COLORS, NULL, NULL); | ||
60 | } | ||
61 | |||
62 | struct cmd_results *bar_colors_cmd_active_workspace(int argc, char **argv) { | ||
63 | char **colors[3] = { | ||
64 | &(config->current_bar->colors.active_workspace_border), | ||
65 | &(config->current_bar->colors.active_workspace_bg), | ||
66 | &(config->current_bar->colors.active_workspace_text) | ||
67 | }; | ||
68 | return parse_three_colors(colors, "active_workspace", argc, argv); | ||
69 | } | ||
70 | |||
71 | struct cmd_results *bar_colors_cmd_background(int argc, char **argv) { | ||
72 | return parse_single_color(&(config->current_bar->colors.background), "background", argc, argv); | ||
73 | } | ||
74 | |||
75 | struct cmd_results *bar_colors_cmd_focused_background(int argc, char **argv) { | ||
76 | return parse_single_color(&(config->current_bar->colors.focused_background), "focused_background", argc, argv); | ||
77 | } | ||
78 | |||
79 | struct cmd_results *bar_colors_cmd_binding_mode(int argc, char **argv) { | ||
80 | char **colors[3] = { | ||
81 | &(config->current_bar->colors.binding_mode_border), | ||
82 | &(config->current_bar->colors.binding_mode_bg), | ||
83 | &(config->current_bar->colors.binding_mode_text) | ||
84 | }; | ||
85 | return parse_three_colors(colors, "binding_mode", argc, argv); | ||
86 | } | ||
87 | |||
88 | struct cmd_results *bar_colors_cmd_focused_workspace(int argc, char **argv) { | ||
89 | char **colors[3] = { | ||
90 | &(config->current_bar->colors.focused_workspace_border), | ||
91 | &(config->current_bar->colors.focused_workspace_bg), | ||
92 | &(config->current_bar->colors.focused_workspace_text) | ||
93 | }; | ||
94 | return parse_three_colors(colors, "focused_workspace", argc, argv); | ||
95 | } | ||
96 | |||
97 | struct cmd_results *bar_colors_cmd_inactive_workspace(int argc, char **argv) { | ||
98 | char **colors[3] = { | ||
99 | &(config->current_bar->colors.inactive_workspace_border), | ||
100 | &(config->current_bar->colors.inactive_workspace_bg), | ||
101 | &(config->current_bar->colors.inactive_workspace_text) | ||
102 | }; | ||
103 | return parse_three_colors(colors, "inactive_workspace", argc, argv); | ||
104 | } | ||
105 | |||
106 | struct cmd_results *bar_colors_cmd_separator(int argc, char **argv) { | ||
107 | return parse_single_color(&(config->current_bar->colors.separator), "separator", argc, argv); | ||
108 | } | ||
109 | |||
110 | struct cmd_results *bar_colors_cmd_focused_separator(int argc, char **argv) { | ||
111 | return parse_single_color(&(config->current_bar->colors.focused_separator), "focused_separator", argc, argv); | ||
112 | } | ||
113 | |||
114 | struct cmd_results *bar_colors_cmd_statusline(int argc, char **argv) { | ||
115 | return parse_single_color(&(config->current_bar->colors.statusline), "statusline", argc, argv); | ||
116 | } | ||
117 | |||
118 | struct cmd_results *bar_colors_cmd_focused_statusline(int argc, char **argv) { | ||
119 | return parse_single_color(&(config->current_bar->colors.focused_separator), "focused_separator", argc, argv); | ||
120 | } | ||
121 | |||
122 | struct cmd_results *bar_colors_cmd_urgent_workspace(int argc, char **argv) { | ||
123 | char **colors[3] = { | ||
124 | &(config->current_bar->colors.urgent_workspace_border), | ||
125 | &(config->current_bar->colors.urgent_workspace_bg), | ||
126 | &(config->current_bar->colors.urgent_workspace_text) | ||
127 | }; | ||
128 | return parse_three_colors(colors, "urgent_workspace", argc, argv); | ||
129 | } | ||
diff --git a/sway/commands/bar/context_button.c b/sway/commands/bar/context_button.c new file mode 100644 index 00000000..e6d17f10 --- /dev/null +++ b/sway/commands/bar/context_button.c | |||
@@ -0,0 +1,9 @@ | |||
1 | #include <stdlib.h> | ||
2 | #include "sway/commands.h" | ||
3 | #include "log.h" | ||
4 | |||
5 | struct cmd_results *bar_cmd_context_button(int argc, char **argv) { | ||
6 | const char *cmd_name = "context_button"; | ||
7 | // TODO TRAY | ||
8 | return cmd_results_new(CMD_INVALID, cmd_name, "TODO TRAY"); | ||
9 | } | ||
diff --git a/sway/commands/bar/font.c b/sway/commands/bar/font.c new file mode 100644 index 00000000..6d7c533a --- /dev/null +++ b/sway/commands/bar/font.c | |||
@@ -0,0 +1,26 @@ | |||
1 | #include <string.h> | ||
2 | #include "sway/commands.h" | ||
3 | #include "log.h" | ||
4 | #include "stringop.h" | ||
5 | |||
6 | struct cmd_results *bar_cmd_font(int argc, char **argv) { | ||
7 | struct cmd_results *error = NULL; | ||
8 | if ((error = checkarg(argc, "font", EXPECTED_AT_LEAST, 1))) { | ||
9 | return error; | ||
10 | } | ||
11 | |||
12 | if (!config->current_bar) { | ||
13 | return cmd_results_new(CMD_FAILURE, "font", "No bar defined."); | ||
14 | } | ||
15 | |||
16 | char *font = join_args(argv, argc); | ||
17 | free(config->current_bar->font); | ||
18 | if (strlen(font) > 6 && strncmp("pango:", font, 6) == 0) { | ||
19 | config->current_bar->font = font; | ||
20 | } else { | ||
21 | config->current_bar->font = font; | ||
22 | } | ||
23 | |||
24 | wlr_log(L_DEBUG, "Settings font '%s' for bar: %s", config->current_bar->font, config->current_bar->id); | ||
25 | return cmd_results_new(CMD_SUCCESS, NULL, NULL); | ||
26 | } | ||
diff --git a/sway/commands/bar/height.c b/sway/commands/bar/height.c new file mode 100644 index 00000000..ae0c7834 --- /dev/null +++ b/sway/commands/bar/height.c | |||
@@ -0,0 +1,21 @@ | |||
1 | #include <stdlib.h> | ||
2 | #include <string.h> | ||
3 | #include "sway/commands.h" | ||
4 | #include "log.h" | ||
5 | |||
6 | struct cmd_results *bar_cmd_height(int argc, char **argv) { | ||
7 | struct cmd_results *error = NULL; | ||
8 | if ((error = checkarg(argc, "height", EXPECTED_EQUAL_TO, 1))) { | ||
9 | return error; | ||
10 | } | ||
11 | |||
12 | int height = atoi(argv[0]); | ||
13 | if (height < 0) { | ||
14 | return cmd_results_new(CMD_INVALID, "height", | ||
15 | "Invalid height value: %s", argv[0]); | ||
16 | } | ||
17 | |||
18 | config->current_bar->height = height; | ||
19 | wlr_log(L_DEBUG, "Setting bar height to %d on bar: %s", height, config->current_bar->id); | ||
20 | return cmd_results_new(CMD_SUCCESS, NULL, NULL); | ||
21 | } | ||
diff --git a/sway/commands/bar/hidden_state.c b/sway/commands/bar/hidden_state.c new file mode 100644 index 00000000..245d0858 --- /dev/null +++ b/sway/commands/bar/hidden_state.c | |||
@@ -0,0 +1,78 @@ | |||
1 | #define _XOPEN_SOURCE 500 | ||
2 | #include <string.h> | ||
3 | #include <strings.h> | ||
4 | #include "sway/commands.h" | ||
5 | #include "sway/config.h" | ||
6 | #include "sway/ipc-server.h" | ||
7 | #include "log.h" | ||
8 | |||
9 | static struct cmd_results *bar_set_hidden_state(struct bar_config *bar, | ||
10 | const char *hidden_state) { | ||
11 | char *old_state = bar->hidden_state; | ||
12 | if (strcasecmp("toggle", hidden_state) == 0 && !config->reading) { | ||
13 | if (strcasecmp("hide", bar->hidden_state) == 0) { | ||
14 | bar->hidden_state = strdup("show"); | ||
15 | } else if (strcasecmp("show", bar->hidden_state) == 0) { | ||
16 | bar->hidden_state = strdup("hide"); | ||
17 | } | ||
18 | } else if (strcasecmp("hide", hidden_state) == 0) { | ||
19 | bar->hidden_state = strdup("hide"); | ||
20 | } else if (strcasecmp("show", hidden_state) == 0) { | ||
21 | bar->hidden_state = strdup("show"); | ||
22 | } else { | ||
23 | return cmd_results_new(CMD_INVALID, "hidden_state", | ||
24 | "Invalid value %s", hidden_state); | ||
25 | } | ||
26 | |||
27 | if (strcmp(old_state, bar->hidden_state) != 0) { | ||
28 | if (!config->reading) { | ||
29 | ipc_event_barconfig_update(bar); | ||
30 | } | ||
31 | wlr_log(L_DEBUG, "Setting hidden_state: '%s' for bar: %s", | ||
32 | bar->hidden_state, bar->id); | ||
33 | } | ||
34 | |||
35 | // free old mode | ||
36 | free(old_state); | ||
37 | return cmd_results_new(CMD_SUCCESS, NULL, NULL); | ||
38 | } | ||
39 | |||
40 | struct cmd_results *bar_cmd_hidden_state(int argc, char **argv) { | ||
41 | struct cmd_results *error = NULL; | ||
42 | if ((error = checkarg(argc, "hidden_state", EXPECTED_AT_LEAST, 1))) { | ||
43 | return error; | ||
44 | } | ||
45 | if ((error = checkarg(argc, "hidden_state", EXPECTED_LESS_THAN, 3))) { | ||
46 | return error; | ||
47 | } | ||
48 | |||
49 | if (config->reading && argc > 1) { | ||
50 | return cmd_results_new(CMD_INVALID, "hidden_state", | ||
51 | "Unexpected value %s in config mode", argv[1]); | ||
52 | } | ||
53 | |||
54 | const char *state = argv[0]; | ||
55 | |||
56 | if (config->reading) { | ||
57 | return bar_set_hidden_state(config->current_bar, state); | ||
58 | } | ||
59 | |||
60 | const char *id = NULL; | ||
61 | if (argc == 2) { | ||
62 | id = argv[1]; | ||
63 | } | ||
64 | |||
65 | struct bar_config *bar; | ||
66 | for (int i = 0; i < config->bars->length; ++i) { | ||
67 | bar = config->bars->items[i]; | ||
68 | if (id && strcmp(id, bar->id) == 0) { | ||
69 | return bar_set_hidden_state(bar, state); | ||
70 | } | ||
71 | |||
72 | error = bar_set_hidden_state(bar, state); | ||
73 | if (error) { | ||
74 | return error; | ||
75 | } | ||
76 | } | ||
77 | return cmd_results_new(CMD_SUCCESS, NULL, NULL); | ||
78 | } | ||
diff --git a/sway/commands/bar/icon_theme.c b/sway/commands/bar/icon_theme.c new file mode 100644 index 00000000..c6090b81 --- /dev/null +++ b/sway/commands/bar/icon_theme.c | |||
@@ -0,0 +1,9 @@ | |||
1 | #define _XOPEN_SOURCE 500 | ||
2 | #include <string.h> | ||
3 | #include "sway/commands.h" | ||
4 | |||
5 | struct cmd_results *bar_cmd_icon_theme(int argc, char **argv) { | ||
6 | const char *cmd_name = "tray_output"; | ||
7 | // TODO TRAY | ||
8 | return cmd_results_new(CMD_INVALID, cmd_name, "TODO TRAY"); | ||
9 | } | ||
diff --git a/sway/commands/bar/id.c b/sway/commands/bar/id.c new file mode 100644 index 00000000..d9e7f8df --- /dev/null +++ b/sway/commands/bar/id.c | |||
@@ -0,0 +1,33 @@ | |||
1 | #define _XOPEN_SOURCE 500 | ||
2 | #include <string.h> | ||
3 | #include "sway/commands.h" | ||
4 | #include "log.h" | ||
5 | |||
6 | struct cmd_results *bar_cmd_id(int argc, char **argv) { | ||
7 | struct cmd_results *error = NULL; | ||
8 | if ((error = checkarg(argc, "id", EXPECTED_EQUAL_TO, 1))) { | ||
9 | return error; | ||
10 | } | ||
11 | |||
12 | const char *name = argv[0]; | ||
13 | const char *oldname = config->current_bar->id; | ||
14 | |||
15 | // check if id is used by a previously defined bar | ||
16 | int i; | ||
17 | for (i = 0; i < config->bars->length; ++i) { | ||
18 | struct bar_config *find = config->bars->items[i]; | ||
19 | if (strcmp(name, find->id) == 0 && config->current_bar != find) { | ||
20 | return cmd_results_new(CMD_FAILURE, "id", | ||
21 | "Id '%s' already defined for another bar. Id unchanged (%s).", | ||
22 | name, oldname); | ||
23 | } | ||
24 | } | ||
25 | |||
26 | wlr_log(L_DEBUG, "Renaming bar: '%s' to '%s'", oldname, name); | ||
27 | |||
28 | // free old bar id | ||
29 | free(config->current_bar->id); | ||
30 | |||
31 | config->current_bar->id = strdup(name); | ||
32 | return cmd_results_new(CMD_SUCCESS, NULL, NULL); | ||
33 | } | ||
diff --git a/sway/commands/bar/mode.c b/sway/commands/bar/mode.c new file mode 100644 index 00000000..7d346956 --- /dev/null +++ b/sway/commands/bar/mode.c | |||
@@ -0,0 +1,78 @@ | |||
1 | #define _XOPEN_SOURCE 500 | ||
2 | #include <string.h> | ||
3 | #include <strings.h> | ||
4 | #include "sway/commands.h" | ||
5 | #include "sway/config.h" | ||
6 | #include "sway/ipc-server.h" | ||
7 | #include "log.h" | ||
8 | |||
9 | static struct cmd_results *bar_set_mode(struct bar_config *bar, const char *mode) { | ||
10 | char *old_mode = bar->mode; | ||
11 | if (strcasecmp("toggle", mode) == 0 && !config->reading) { | ||
12 | if (strcasecmp("dock", bar->mode) == 0) { | ||
13 | bar->mode = strdup("hide"); | ||
14 | } else if (strcasecmp("hide", bar->mode) == 0) { | ||
15 | bar->mode = strdup("dock"); | ||
16 | } | ||
17 | } else if (strcasecmp("dock", mode) == 0) { | ||
18 | bar->mode = strdup("dock"); | ||
19 | } else if (strcasecmp("hide", mode) == 0) { | ||
20 | bar->mode = strdup("hide"); | ||
21 | } else if (strcasecmp("invisible", mode) == 0) { | ||
22 | bar->mode = strdup("invisible"); | ||
23 | } else { | ||
24 | return cmd_results_new(CMD_INVALID, "mode", "Invalid value %s", mode); | ||
25 | } | ||
26 | |||
27 | if (strcmp(old_mode, bar->mode) != 0) { | ||
28 | if (!config->reading) { | ||
29 | ipc_event_barconfig_update(bar); | ||
30 | } | ||
31 | wlr_log(L_DEBUG, "Setting mode: '%s' for bar: %s", bar->mode, bar->id); | ||
32 | } | ||
33 | |||
34 | // free old mode | ||
35 | free(old_mode); | ||
36 | return cmd_results_new(CMD_SUCCESS, NULL, NULL); | ||
37 | } | ||
38 | |||
39 | struct cmd_results *bar_cmd_mode(int argc, char **argv) { | ||
40 | struct cmd_results *error = NULL; | ||
41 | if ((error = checkarg(argc, "mode", EXPECTED_AT_LEAST, 1))) { | ||
42 | return error; | ||
43 | } | ||
44 | if ((error = checkarg(argc, "mode", EXPECTED_LESS_THAN, 3))) { | ||
45 | return error; | ||
46 | } | ||
47 | |||
48 | if (config->reading && argc > 1) { | ||
49 | return cmd_results_new(CMD_INVALID, "mode", "Unexpected value %s in config mode", argv[1]); | ||
50 | } | ||
51 | |||
52 | const char *mode = argv[0]; | ||
53 | |||
54 | if (config->reading) { | ||
55 | return bar_set_mode(config->current_bar, mode); | ||
56 | } | ||
57 | |||
58 | const char *id = NULL; | ||
59 | if (argc == 2) { | ||
60 | id = argv[1]; | ||
61 | } | ||
62 | |||
63 | int i; | ||
64 | struct bar_config *bar; | ||
65 | for (i = 0; i < config->bars->length; ++i) { | ||
66 | bar = config->bars->items[i]; | ||
67 | if (id && strcmp(id, bar->id) == 0) { | ||
68 | return bar_set_mode(bar, mode); | ||
69 | } | ||
70 | |||
71 | error = bar_set_mode(bar, mode); | ||
72 | if (error) { | ||
73 | return error; | ||
74 | } | ||
75 | } | ||
76 | |||
77 | return cmd_results_new(CMD_SUCCESS, NULL, NULL); | ||
78 | } | ||
diff --git a/sway/commands/bar/modifier.c b/sway/commands/bar/modifier.c new file mode 100644 index 00000000..9a1f8b01 --- /dev/null +++ b/sway/commands/bar/modifier.c | |||
@@ -0,0 +1,35 @@ | |||
1 | #include <string.h> | ||
2 | #include "sway/commands.h" | ||
3 | #include "log.h" | ||
4 | #include "stringop.h" | ||
5 | #include "util.h" | ||
6 | |||
7 | struct cmd_results *bar_cmd_modifier(int argc, char **argv) { | ||
8 | struct cmd_results *error = NULL; | ||
9 | if ((error = checkarg(argc, "modifier", EXPECTED_EQUAL_TO, 1))) { | ||
10 | return error; | ||
11 | } | ||
12 | |||
13 | if (!config->current_bar) { | ||
14 | return cmd_results_new(CMD_FAILURE, "modifier", "No bar defined."); | ||
15 | } | ||
16 | |||
17 | uint32_t mod = 0; | ||
18 | |||
19 | list_t *split = split_string(argv[0], "+"); | ||
20 | for (int i = 0; i < split->length; ++i) { | ||
21 | uint32_t tmp_mod; | ||
22 | if ((tmp_mod = get_modifier_mask_by_name(split->items[i])) > 0) { | ||
23 | mod |= tmp_mod; | ||
24 | continue; | ||
25 | } else { | ||
26 | free_flat_list(split); | ||
27 | return cmd_results_new(CMD_INVALID, "modifier", "Unknown modifier '%s'", split->items[i]); | ||
28 | } | ||
29 | } | ||
30 | free_flat_list(split); | ||
31 | |||
32 | config->current_bar->modifier = mod; | ||
33 | wlr_log(L_DEBUG, "Show/Hide the bar when pressing '%s' in hide mode.", argv[0]); | ||
34 | return cmd_results_new(CMD_SUCCESS, NULL, NULL); | ||
35 | } | ||
diff --git a/sway/commands/bar/output.c b/sway/commands/bar/output.c new file mode 100644 index 00000000..034d9ca4 --- /dev/null +++ b/sway/commands/bar/output.c | |||
@@ -0,0 +1,50 @@ | |||
1 | #define _XOPEN_SOURCE 500 | ||
2 | #include <string.h> | ||
3 | #include "sway/commands.h" | ||
4 | #include "list.h" | ||
5 | #include "log.h" | ||
6 | |||
7 | struct cmd_results *bar_cmd_output(int argc, char **argv) { | ||
8 | struct cmd_results *error = NULL; | ||
9 | if ((error = checkarg(argc, "output", EXPECTED_EQUAL_TO, 1))) { | ||
10 | return error; | ||
11 | } | ||
12 | |||
13 | if (!config->current_bar) { | ||
14 | return cmd_results_new(CMD_FAILURE, "output", "No bar defined."); | ||
15 | } | ||
16 | |||
17 | const char *output = argv[0]; | ||
18 | list_t *outputs = config->current_bar->outputs; | ||
19 | if (!outputs) { | ||
20 | outputs = create_list(); | ||
21 | config->current_bar->outputs = outputs; | ||
22 | } | ||
23 | |||
24 | int i; | ||
25 | int add_output = 1; | ||
26 | if (strcmp("*", output) == 0) { | ||
27 | // remove all previous defined outputs and replace with '*' | ||
28 | for (i = 0; i < outputs->length; ++i) { | ||
29 | free(outputs->items[i]); | ||
30 | list_del(outputs, i); | ||
31 | } | ||
32 | } else { | ||
33 | // only add output if not already defined with either the same | ||
34 | // name or as '*' | ||
35 | for (i = 0; i < outputs->length; ++i) { | ||
36 | const char *find = outputs->items[i]; | ||
37 | if (strcmp("*", find) == 0 || strcmp(output, find) == 0) { | ||
38 | add_output = 0; | ||
39 | break; | ||
40 | } | ||
41 | } | ||
42 | } | ||
43 | |||
44 | if (add_output) { | ||
45 | list_add(outputs, strdup(output)); | ||
46 | wlr_log(L_DEBUG, "Adding bar: '%s' to output '%s'", config->current_bar->id, output); | ||
47 | } | ||
48 | |||
49 | return cmd_results_new(CMD_SUCCESS, NULL, NULL); | ||
50 | } | ||
diff --git a/sway/commands/bar/pango_markup.c b/sway/commands/bar/pango_markup.c new file mode 100644 index 00000000..34b85e98 --- /dev/null +++ b/sway/commands/bar/pango_markup.c | |||
@@ -0,0 +1,27 @@ | |||
1 | #include <string.h> | ||
2 | #include <strings.h> | ||
3 | #include "sway/commands.h" | ||
4 | #include "log.h" | ||
5 | |||
6 | struct cmd_results *bar_cmd_pango_markup(int argc, char **argv) { | ||
7 | struct cmd_results *error = NULL; | ||
8 | if ((error = checkarg(argc, "pango_markup", EXPECTED_EQUAL_TO, 1))) { | ||
9 | return error; | ||
10 | } | ||
11 | |||
12 | if (!config->current_bar) { | ||
13 | return cmd_results_new(CMD_FAILURE, "pango_markup", "No bar defined."); | ||
14 | } | ||
15 | |||
16 | if (strcasecmp("enabled", argv[0]) == 0) { | ||
17 | config->current_bar->pango_markup = true; | ||
18 | wlr_log(L_DEBUG, "Enabling pango markup for bar: %s", config->current_bar->id); | ||
19 | } else if (strcasecmp("disabled", argv[0]) == 0) { | ||
20 | config->current_bar->pango_markup = false; | ||
21 | wlr_log(L_DEBUG, "Disabling pango markup for bar: %s", config->current_bar->id); | ||
22 | } else { | ||
23 | error = cmd_results_new(CMD_INVALID, "pango_markup", "Invalid value %s", argv[0]); | ||
24 | return error; | ||
25 | } | ||
26 | return cmd_results_new(CMD_SUCCESS, NULL, NULL); | ||
27 | } | ||
diff --git a/sway/commands/bar/position.c b/sway/commands/bar/position.c new file mode 100644 index 00000000..efa8c0bc --- /dev/null +++ b/sway/commands/bar/position.c | |||
@@ -0,0 +1,29 @@ | |||
1 | #define _POSIX_C_SOURCE 200809L | ||
2 | #include <string.h> | ||
3 | #include <strings.h> | ||
4 | #include "sway/commands.h" | ||
5 | #include "log.h" | ||
6 | |||
7 | struct cmd_results *bar_cmd_position(int argc, char **argv) { | ||
8 | struct cmd_results *error = NULL; | ||
9 | if ((error = checkarg(argc, "position", EXPECTED_EQUAL_TO, 1))) { | ||
10 | return error; | ||
11 | } | ||
12 | |||
13 | if (!config->current_bar) { | ||
14 | return cmd_results_new(CMD_FAILURE, "position", "No bar defined."); | ||
15 | } | ||
16 | |||
17 | char *valid[] = { "top", "bottom", "left", "right" }; | ||
18 | for (size_t i = 0; i < sizeof(valid) / sizeof(valid[0]); ++i) { | ||
19 | if (strcasecmp(valid[i], argv[0]) == 0) { | ||
20 | wlr_log(L_DEBUG, "Setting bar position '%s' for bar: %s", | ||
21 | argv[0], config->current_bar->id); | ||
22 | config->current_bar->position = strdup(argv[0]); | ||
23 | return cmd_results_new(CMD_SUCCESS, NULL, NULL); | ||
24 | } | ||
25 | } | ||
26 | |||
27 | error = cmd_results_new(CMD_INVALID, "position", "Invalid value %s", argv[0]); | ||
28 | return error; | ||
29 | } | ||
diff --git a/sway/commands/bar/secondary_button.c b/sway/commands/bar/secondary_button.c new file mode 100644 index 00000000..46d53e3f --- /dev/null +++ b/sway/commands/bar/secondary_button.c | |||
@@ -0,0 +1,9 @@ | |||
1 | #include <stdlib.h> | ||
2 | #include "sway/commands.h" | ||
3 | #include "log.h" | ||
4 | |||
5 | struct cmd_results *bar_cmd_secondary_button(int argc, char **argv) { | ||
6 | const char *cmd_name = "secondary_button"; | ||
7 | // TODO TRAY | ||
8 | return cmd_results_new(CMD_INVALID, cmd_name, "TODO TRAY"); | ||
9 | } | ||
diff --git a/sway/commands/bar/separator_symbol.c b/sway/commands/bar/separator_symbol.c new file mode 100644 index 00000000..7dc0956b --- /dev/null +++ b/sway/commands/bar/separator_symbol.c | |||
@@ -0,0 +1,21 @@ | |||
1 | #define _XOPEN_SOURCE 500 | ||
2 | #include <string.h> | ||
3 | #include "sway/commands.h" | ||
4 | #include "log.h" | ||
5 | |||
6 | struct cmd_results *bar_cmd_separator_symbol(int argc, char **argv) { | ||
7 | struct cmd_results *error = NULL; | ||
8 | if ((error = checkarg(argc, "separator_symbol", EXPECTED_EQUAL_TO, 1))) { | ||
9 | return error; | ||
10 | } | ||
11 | |||
12 | if (!config->current_bar) { | ||
13 | return cmd_results_new(CMD_FAILURE, "separator_symbol", "No bar defined."); | ||
14 | } | ||
15 | |||
16 | free(config->current_bar->separator_symbol); | ||
17 | config->current_bar->separator_symbol = strdup(argv[0]); | ||
18 | wlr_log(L_DEBUG, "Settings separator_symbol '%s' for bar: %s", config->current_bar->separator_symbol, config->current_bar->id); | ||
19 | |||
20 | return cmd_results_new(CMD_SUCCESS, NULL, NULL); | ||
21 | } | ||
diff --git a/sway/commands/bar/status_command.c b/sway/commands/bar/status_command.c new file mode 100644 index 00000000..05377fcc --- /dev/null +++ b/sway/commands/bar/status_command.c | |||
@@ -0,0 +1,21 @@ | |||
1 | #include <string.h> | ||
2 | #include "sway/commands.h" | ||
3 | #include "log.h" | ||
4 | #include "stringop.h" | ||
5 | |||
6 | struct cmd_results *bar_cmd_status_command(int argc, char **argv) { | ||
7 | struct cmd_results *error = NULL; | ||
8 | if ((error = checkarg(argc, "status_command", EXPECTED_AT_LEAST, 1))) { | ||
9 | return error; | ||
10 | } | ||
11 | |||
12 | if (!config->current_bar) { | ||
13 | return cmd_results_new(CMD_FAILURE, "status_command", "No bar defined."); | ||
14 | } | ||
15 | |||
16 | free(config->current_bar->status_command); | ||
17 | config->current_bar->status_command = join_args(argv, argc); | ||
18 | wlr_log(L_DEBUG, "Feeding bar with status command: %s", config->current_bar->status_command); | ||
19 | |||
20 | return cmd_results_new(CMD_SUCCESS, NULL, NULL); | ||
21 | } | ||
diff --git a/sway/commands/bar/strip_workspace_numbers.c b/sway/commands/bar/strip_workspace_numbers.c new file mode 100644 index 00000000..0558db8f --- /dev/null +++ b/sway/commands/bar/strip_workspace_numbers.c | |||
@@ -0,0 +1,27 @@ | |||
1 | #include <string.h> | ||
2 | #include <strings.h> | ||
3 | #include "sway/commands.h" | ||
4 | #include "log.h" | ||
5 | |||
6 | struct cmd_results *bar_cmd_strip_workspace_numbers(int argc, char **argv) { | ||
7 | struct cmd_results *error = NULL; | ||
8 | if ((error = checkarg(argc, "strip_workspace_numbers", EXPECTED_EQUAL_TO, 1))) { | ||
9 | return error; | ||
10 | } | ||
11 | |||
12 | if (!config->current_bar) { | ||
13 | return cmd_results_new(CMD_FAILURE, "strip_workspace_numbers", "No bar defined."); | ||
14 | } | ||
15 | |||
16 | if (strcasecmp("yes", argv[0]) == 0) { | ||
17 | config->current_bar->strip_workspace_numbers = true; | ||
18 | wlr_log(L_DEBUG, "Stripping workspace numbers on bar: %s", config->current_bar->id); | ||
19 | } else if (strcasecmp("no", argv[0]) == 0) { | ||
20 | config->current_bar->strip_workspace_numbers = false; | ||
21 | wlr_log(L_DEBUG, "Enabling workspace numbers on bar: %s", config->current_bar->id); | ||
22 | } else { | ||
23 | error = cmd_results_new(CMD_INVALID, "strip_workspace_numbers", "Invalid value %s", argv[0]); | ||
24 | return error; | ||
25 | } | ||
26 | return cmd_results_new(CMD_SUCCESS, NULL, NULL); | ||
27 | } | ||
diff --git a/sway/commands/bar/swaybar_command.c b/sway/commands/bar/swaybar_command.c new file mode 100644 index 00000000..63d4f29a --- /dev/null +++ b/sway/commands/bar/swaybar_command.c | |||
@@ -0,0 +1,21 @@ | |||
1 | #include <string.h> | ||
2 | #include "sway/commands.h" | ||
3 | #include "log.h" | ||
4 | #include "stringop.h" | ||
5 | |||
6 | struct cmd_results *bar_cmd_swaybar_command(int argc, char **argv) { | ||
7 | struct cmd_results *error = NULL; | ||
8 | if ((error = checkarg(argc, "swaybar_command", EXPECTED_AT_LEAST, 1))) { | ||
9 | return error; | ||
10 | } | ||
11 | |||
12 | if (!config->current_bar) { | ||
13 | return cmd_results_new(CMD_FAILURE, "swaybar_command", "No bar defined."); | ||
14 | } | ||
15 | |||
16 | free(config->current_bar->swaybar_command); | ||
17 | config->current_bar->swaybar_command = join_args(argv, argc); | ||
18 | wlr_log(L_DEBUG, "Using custom swaybar command: %s", config->current_bar->swaybar_command); | ||
19 | |||
20 | return cmd_results_new(CMD_SUCCESS, NULL, NULL); | ||
21 | } | ||
diff --git a/sway/commands/bar/tray_output.c b/sway/commands/bar/tray_output.c new file mode 100644 index 00000000..2d822146 --- /dev/null +++ b/sway/commands/bar/tray_output.c | |||
@@ -0,0 +1,9 @@ | |||
1 | #define _XOPEN_SOURCE 500 | ||
2 | #include <string.h> | ||
3 | #include "sway/commands.h" | ||
4 | |||
5 | struct cmd_results *bar_cmd_tray_output(int argc, char **argv) { | ||
6 | const char *cmd_name = "tray_output"; | ||
7 | // TODO TRAY | ||
8 | return cmd_results_new(CMD_INVALID, cmd_name, "TODO TRAY"); | ||
9 | } | ||
diff --git a/sway/commands/bar/tray_padding.c b/sway/commands/bar/tray_padding.c new file mode 100644 index 00000000..95b8ad3b --- /dev/null +++ b/sway/commands/bar/tray_padding.c | |||
@@ -0,0 +1,10 @@ | |||
1 | #include <stdlib.h> | ||
2 | #include <strings.h> | ||
3 | #include "sway/commands.h" | ||
4 | #include "log.h" | ||
5 | |||
6 | struct cmd_results *bar_cmd_tray_padding(int argc, char **argv) { | ||
7 | const char *cmd_name = "tray_padding"; | ||
8 | // TODO TRAY | ||
9 | return cmd_results_new(CMD_INVALID, cmd_name, "TODO TRAY"); | ||
10 | } | ||
diff --git a/sway/commands/bar/workspace_buttons.c b/sway/commands/bar/workspace_buttons.c new file mode 100644 index 00000000..1a617eb8 --- /dev/null +++ b/sway/commands/bar/workspace_buttons.c | |||
@@ -0,0 +1,27 @@ | |||
1 | #include <string.h> | ||
2 | #include <strings.h> | ||
3 | #include "sway/commands.h" | ||
4 | #include "log.h" | ||
5 | |||
6 | struct cmd_results *bar_cmd_workspace_buttons(int argc, char **argv) { | ||
7 | struct cmd_results *error = NULL; | ||
8 | if ((error = checkarg(argc, "workspace_buttons", EXPECTED_EQUAL_TO, 1))) { | ||
9 | return error; | ||
10 | } | ||
11 | |||
12 | if (!config->current_bar) { | ||
13 | return cmd_results_new(CMD_FAILURE, "workspace_buttons", "No bar defined."); | ||
14 | } | ||
15 | |||
16 | if (strcasecmp("yes", argv[0]) == 0) { | ||
17 | config->current_bar->workspace_buttons = true; | ||
18 | wlr_log(L_DEBUG, "Enabling workspace buttons on bar: %s", config->current_bar->id); | ||
19 | } else if (strcasecmp("no", argv[0]) == 0) { | ||
20 | config->current_bar->workspace_buttons = false; | ||
21 | wlr_log(L_DEBUG, "Disabling workspace buttons on bar: %s", config->current_bar->id); | ||
22 | } else { | ||
23 | error = cmd_results_new(CMD_INVALID, "workspace_buttons", "Invalid value %s", argv[0]); | ||
24 | return error; | ||
25 | } | ||
26 | return cmd_results_new(CMD_SUCCESS, NULL, NULL); | ||
27 | } | ||
diff --git a/sway/commands/bar/wrap_scroll.c b/sway/commands/bar/wrap_scroll.c new file mode 100644 index 00000000..c89dff5f --- /dev/null +++ b/sway/commands/bar/wrap_scroll.c | |||
@@ -0,0 +1,27 @@ | |||
1 | #include <string.h> | ||
2 | #include <strings.h> | ||
3 | #include "sway/commands.h" | ||
4 | #include "log.h" | ||
5 | |||
6 | struct cmd_results *bar_cmd_wrap_scroll(int argc, char **argv) { | ||
7 | struct cmd_results *error = NULL; | ||
8 | if ((error = checkarg(argc, "wrap_scroll", EXPECTED_EQUAL_TO, 1))) { | ||
9 | return error; | ||
10 | } | ||
11 | |||
12 | if (!config->current_bar) { | ||
13 | return cmd_results_new(CMD_FAILURE, "wrap_scroll", "No bar defined."); | ||
14 | } | ||
15 | |||
16 | if (strcasecmp("yes", argv[0]) == 0) { | ||
17 | config->current_bar->wrap_scroll = true; | ||
18 | wlr_log(L_DEBUG, "Enabling wrap scroll on bar: %s", config->current_bar->id); | ||
19 | } else if (strcasecmp("no", argv[0]) == 0) { | ||
20 | config->current_bar->wrap_scroll = false; | ||
21 | wlr_log(L_DEBUG, "Disabling wrap scroll on bar: %s", config->current_bar->id); | ||
22 | } else { | ||
23 | error = cmd_results_new(CMD_INVALID, "wrap_scroll", "Invalid value %s", argv[0]); | ||
24 | return error; | ||
25 | } | ||
26 | return cmd_results_new(CMD_SUCCESS, NULL, NULL); | ||
27 | } | ||
diff --git a/sway/config.c b/sway/config.c index 0422fdd9..a0e408de 100644 --- a/sway/config.c +++ b/sway/config.c | |||
@@ -110,6 +110,48 @@ void free_config(struct sway_config *config) { | |||
110 | free(config); | 110 | free(config); |
111 | } | 111 | } |
112 | 112 | ||
113 | static void free_bar(struct bar_config *bar) { | ||
114 | if (!bar) { | ||
115 | return; | ||
116 | } | ||
117 | free(bar->mode); | ||
118 | free(bar->position); | ||
119 | free(bar->hidden_state); | ||
120 | free(bar->status_command); | ||
121 | free(bar->font); | ||
122 | free(bar->separator_symbol); | ||
123 | // TODO: Free mouse bindings | ||
124 | list_free(bar->bindings); | ||
125 | if (bar->outputs) { | ||
126 | free_flat_list(bar->outputs); | ||
127 | } | ||
128 | if (bar->pid != 0) { | ||
129 | // TODO terminate_swaybar(bar->pid); | ||
130 | } | ||
131 | free(bar->colors.background); | ||
132 | free(bar->colors.statusline); | ||
133 | free(bar->colors.separator); | ||
134 | free(bar->colors.focused_background); | ||
135 | free(bar->colors.focused_statusline); | ||
136 | free(bar->colors.focused_separator); | ||
137 | free(bar->colors.focused_workspace_border); | ||
138 | free(bar->colors.focused_workspace_bg); | ||
139 | free(bar->colors.focused_workspace_text); | ||
140 | free(bar->colors.active_workspace_border); | ||
141 | free(bar->colors.active_workspace_bg); | ||
142 | free(bar->colors.active_workspace_text); | ||
143 | free(bar->colors.inactive_workspace_border); | ||
144 | free(bar->colors.inactive_workspace_bg); | ||
145 | free(bar->colors.inactive_workspace_text); | ||
146 | free(bar->colors.urgent_workspace_border); | ||
147 | free(bar->colors.urgent_workspace_bg); | ||
148 | free(bar->colors.urgent_workspace_text); | ||
149 | free(bar->colors.binding_mode_border); | ||
150 | free(bar->colors.binding_mode_bg); | ||
151 | free(bar->colors.binding_mode_text); | ||
152 | free(bar); | ||
153 | } | ||
154 | |||
113 | static void destroy_removed_seats(struct sway_config *old_config, | 155 | static void destroy_removed_seats(struct sway_config *old_config, |
114 | struct sway_config *new_config) { | 156 | struct sway_config *new_config) { |
115 | struct seat_config *seat_config; | 157 | struct seat_config *seat_config; |
@@ -239,6 +281,91 @@ cleanup: | |||
239 | sway_abort("Unable to allocate config structures"); | 281 | sway_abort("Unable to allocate config structures"); |
240 | } | 282 | } |
241 | 283 | ||
284 | struct bar_config *default_bar_config(void) { | ||
285 | struct bar_config *bar = NULL; | ||
286 | bar = malloc(sizeof(struct bar_config)); | ||
287 | if (!bar) { | ||
288 | return NULL; | ||
289 | } | ||
290 | if (!(bar->mode = strdup("dock"))) goto cleanup; | ||
291 | if (!(bar->hidden_state = strdup("hide"))) goto cleanup; | ||
292 | bar->outputs = NULL; | ||
293 | bar->position = strdup("bottom"); | ||
294 | if (!(bar->bindings = create_list())) goto cleanup; | ||
295 | if (!(bar->status_command = strdup("while :; do date +'%Y-%m-%d %l:%M:%S %p'; sleep 1; done"))) goto cleanup; | ||
296 | bar->pango_markup = false; | ||
297 | bar->swaybar_command = NULL; | ||
298 | bar->font = NULL; | ||
299 | bar->height = -1; | ||
300 | bar->workspace_buttons = true; | ||
301 | bar->wrap_scroll = false; | ||
302 | bar->separator_symbol = NULL; | ||
303 | bar->strip_workspace_numbers = false; | ||
304 | bar->binding_mode_indicator = true; | ||
305 | bar->verbose = false; | ||
306 | bar->pid = 0; | ||
307 | // set default colors | ||
308 | if (!(bar->colors.background = strndup("#000000ff", 9))) { | ||
309 | goto cleanup; | ||
310 | } | ||
311 | if (!(bar->colors.statusline = strndup("#ffffffff", 9))) { | ||
312 | goto cleanup; | ||
313 | } | ||
314 | if (!(bar->colors.separator = strndup("#666666ff", 9))) { | ||
315 | goto cleanup; | ||
316 | } | ||
317 | if (!(bar->colors.focused_workspace_border = strndup("#4c7899ff", 9))) { | ||
318 | goto cleanup; | ||
319 | } | ||
320 | if (!(bar->colors.focused_workspace_bg = strndup("#285577ff", 9))) { | ||
321 | goto cleanup; | ||
322 | } | ||
323 | if (!(bar->colors.focused_workspace_text = strndup("#ffffffff", 9))) { | ||
324 | goto cleanup; | ||
325 | } | ||
326 | if (!(bar->colors.active_workspace_border = strndup("#333333ff", 9))) { | ||
327 | goto cleanup; | ||
328 | } | ||
329 | if (!(bar->colors.active_workspace_bg = strndup("#5f676aff", 9))) { | ||
330 | goto cleanup; | ||
331 | } | ||
332 | if (!(bar->colors.active_workspace_text = strndup("#ffffffff", 9))) { | ||
333 | goto cleanup; | ||
334 | } | ||
335 | if (!(bar->colors.inactive_workspace_border = strndup("#333333ff", 9))) { | ||
336 | goto cleanup; | ||
337 | } | ||
338 | if (!(bar->colors.inactive_workspace_bg = strndup("#222222ff", 9))) { | ||
339 | goto cleanup; | ||
340 | } | ||
341 | if (!(bar->colors.inactive_workspace_text = strndup("#888888ff", 9))) { | ||
342 | goto cleanup; | ||
343 | } | ||
344 | if (!(bar->colors.urgent_workspace_border = strndup("#2f343aff", 9))) { | ||
345 | goto cleanup; | ||
346 | } | ||
347 | if (!(bar->colors.urgent_workspace_bg = strndup("#900000ff", 9))) { | ||
348 | goto cleanup; | ||
349 | } | ||
350 | if (!(bar->colors.urgent_workspace_text = strndup("#ffffffff", 9))) { | ||
351 | goto cleanup; | ||
352 | } | ||
353 | // if the following colors stay undefined, they fall back to background, | ||
354 | // statusline, separator and urgent_workspace_*. | ||
355 | bar->colors.focused_background = NULL; | ||
356 | bar->colors.focused_statusline = NULL; | ||
357 | bar->colors.focused_separator = NULL; | ||
358 | bar->colors.binding_mode_border = NULL; | ||
359 | bar->colors.binding_mode_bg = NULL; | ||
360 | bar->colors.binding_mode_text = NULL; | ||
361 | |||
362 | list_add(config->bars, bar); | ||
363 | return bar; | ||
364 | cleanup: | ||
365 | free_bar(bar); | ||
366 | return NULL; | ||
367 | } | ||
368 | |||
242 | static bool file_exists(const char *path) { | 369 | static bool file_exists(const char *path) { |
243 | return path && access(path, R_OK) != -1; | 370 | return path && access(path, R_OK) != -1; |
244 | } | 371 | } |
diff --git a/sway/ipc-server.c b/sway/ipc-server.c index 408ed432..59fc05f9 100644 --- a/sway/ipc-server.c +++ b/sway/ipc-server.c | |||
@@ -313,10 +313,18 @@ void ipc_event_window(swayc_t *window, const char *change) { | |||
313 | 313 | ||
314 | const char *json_string = json_object_to_json_string(obj); | 314 | const char *json_string = json_object_to_json_string(obj); |
315 | ipc_send_event(json_string, IPC_EVENT_WINDOW); | 315 | ipc_send_event(json_string, IPC_EVENT_WINDOW); |
316 | |||
317 | json_object_put(obj); // free | 316 | json_object_put(obj); // free |
318 | } | 317 | } |
319 | 318 | ||
319 | void ipc_event_barconfig_update(struct bar_config *bar) { | ||
320 | wlr_log(L_DEBUG, "Sending barconfig_update event"); | ||
321 | json_object *json = ipc_json_describe_bar_config(bar); | ||
322 | |||
323 | const char *json_string = json_object_to_json_string(json); | ||
324 | ipc_send_event(json_string, IPC_EVENT_BARCONFIG_UPDATE); | ||
325 | json_object_put(json); // free | ||
326 | } | ||
327 | |||
320 | int ipc_client_handle_writable(int client_fd, uint32_t mask, void *data) { | 328 | int ipc_client_handle_writable(int client_fd, uint32_t mask, void *data) { |
321 | struct ipc_client *client = data; | 329 | struct ipc_client *client = data; |
322 | 330 | ||
diff --git a/sway/meson.build b/sway/meson.build index 8bddb11b..8fcb0dbf 100644 --- a/sway/meson.build +++ b/sway/meson.build | |||
@@ -6,6 +6,7 @@ sway_sources = files( | |||
6 | 'input/seat.c', | 6 | 'input/seat.c', |
7 | 'input/cursor.c', | 7 | 'input/cursor.c', |
8 | 'input/keyboard.c', | 8 | 'input/keyboard.c', |
9 | 'commands/bar.c', | ||
9 | 'commands/bind.c', | 10 | 'commands/bind.c', |
10 | 'commands/exit.c', | 11 | 'commands/exit.c', |
11 | 'commands/exec.c', | 12 | 'commands/exec.c', |
@@ -19,6 +20,30 @@ sway_sources = files( | |||
19 | 'commands/seat/attach.c', | 20 | 'commands/seat/attach.c', |
20 | 'commands/seat/fallback.c', | 21 | 'commands/seat/fallback.c', |
21 | 'commands/set.c', | 22 | 'commands/set.c', |
23 | 'commands/bar/activate_button.c', | ||
24 | 'commands/bar/binding_mode_indicator.c', | ||
25 | 'commands/bar/bindsym.c', | ||
26 | 'commands/bar/colors.c', | ||
27 | 'commands/bar/context_button.c', | ||
28 | 'commands/bar/font.c', | ||
29 | 'commands/bar/height.c', | ||
30 | 'commands/bar/hidden_state.c', | ||
31 | 'commands/bar/icon_theme.c', | ||
32 | 'commands/bar/id.c', | ||
33 | 'commands/bar/mode.c', | ||
34 | 'commands/bar/modifier.c', | ||
35 | 'commands/bar/output.c', | ||
36 | 'commands/bar/pango_markup.c', | ||
37 | 'commands/bar/position.c', | ||
38 | 'commands/bar/secondary_button.c', | ||
39 | 'commands/bar/separator_symbol.c', | ||
40 | 'commands/bar/status_command.c', | ||
41 | 'commands/bar/strip_workspace_numbers.c', | ||
42 | 'commands/bar/swaybar_command.c', | ||
43 | 'commands/bar/tray_output.c', | ||
44 | 'commands/bar/tray_padding.c', | ||
45 | 'commands/bar/workspace_buttons.c', | ||
46 | 'commands/bar/wrap_scroll.c', | ||
22 | 'commands/input/accel_profile.c', | 47 | 'commands/input/accel_profile.c', |
23 | 'commands/input/click_method.c', | 48 | 'commands/input/click_method.c', |
24 | 'commands/input/drag_lock.c', | 49 | 'commands/input/drag_lock.c', |