diff options
author | D.B <thejan.2009@gmail.com> | 2016-11-02 21:07:04 +0100 |
---|---|---|
committer | D.B <thejan.2009@gmail.com> | 2016-11-02 21:07:04 +0100 |
commit | 58eb7ac19fe436737babcbd1effd41ef96af6632 (patch) | |
tree | a3db9567c63b2b2bae27c17d3a103c8f2786a9f7 /sway/commands/bar | |
parent | add bar colours for focused_(workspace|statusline|separator) (diff) | |
download | sway-58eb7ac19fe436737babcbd1effd41ef96af6632.tar.gz sway-58eb7ac19fe436737babcbd1effd41ef96af6632.tar.zst sway-58eb7ac19fe436737babcbd1effd41ef96af6632.zip |
change bar colors from char[10] to *char
This commit removes has_* booleans from bar color struct. It also
generalizes of functions in commands/bar/colors.c.
Diffstat (limited to 'sway/commands/bar')
-rw-r--r-- | sway/commands/bar/colors.c | 222 |
1 files changed, 67 insertions, 155 deletions
diff --git a/sway/commands/bar/colors.c b/sway/commands/bar/colors.c index 8fb7fe27..f6fb520a 100644 --- a/sway/commands/bar/colors.c +++ b/sway/commands/bar/colors.c | |||
@@ -1,211 +1,123 @@ | |||
1 | #include <string.h> | 1 | #include <string.h> |
2 | #include "sway/commands.h" | 2 | #include "sway/commands.h" |
3 | 3 | ||
4 | struct cmd_results *bar_cmd_colors(int argc, char **argv) { | 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, "colors", EXPECTED_EQUAL_TO, 1))) { | ||
7 | return error; | ||
8 | } | ||
9 | |||
10 | if (strcmp("{", argv[0]) != 0) { | ||
11 | return cmd_results_new(CMD_INVALID, "colors", | ||
12 | "Expected '{' at the start of colors config definition."); | ||
13 | } | ||
14 | |||
15 | return cmd_results_new(CMD_BLOCK_BAR_COLORS, NULL, NULL); | ||
16 | } | ||
17 | |||
18 | struct cmd_results *bar_colors_cmd_active_workspace(int argc, char **argv) { | ||
19 | struct cmd_results *error = NULL; | 5 | struct cmd_results *error = NULL; |
20 | if ((error = checkarg(argc, "active_workspace", EXPECTED_EQUAL_TO, 3))) { | 6 | if ((error = checkarg(argc, cmd_name, EXPECTED_EQUAL_TO, 1))) { |
21 | return error; | 7 | return error; |
22 | } | 8 | } |
23 | 9 | ||
24 | if ((error = add_color("active_workspace_border", config->current_bar->colors.active_workspace_border, argv[0]))) { | 10 | if (!*color) { |
25 | return error; | 11 | *color = malloc(10); |
26 | } | 12 | } |
27 | 13 | ||
28 | if ((error = add_color("active_workspace_bg", config->current_bar->colors.active_workspace_bg, argv[1]))) { | 14 | error = add_color(cmd_name, *color, argv[0]); |
29 | return error; | 15 | if (error) { |
30 | } | ||
31 | |||
32 | if ((error = add_color("active_workspace_text", config->current_bar->colors.active_workspace_text, argv[2]))) { | ||
33 | return error; | 16 | return error; |
34 | } | 17 | } |
35 | 18 | ||
36 | return cmd_results_new(CMD_SUCCESS, NULL, NULL); | 19 | return cmd_results_new(CMD_SUCCESS, NULL, NULL); |
37 | } | 20 | } |
38 | 21 | ||
39 | struct cmd_results *bar_colors_cmd_background(int argc, char **argv) { | 22 | static struct cmd_results *parse_three_colors(char ***colors, const char *cmd_name, int argc, char **argv) { |
40 | struct cmd_results *error = NULL; | 23 | struct cmd_results *error = NULL; |
41 | if ((error = checkarg(argc, "background", EXPECTED_EQUAL_TO, 1))) { | 24 | if (argc != 3) { |
42 | return error; | 25 | return cmd_results_new(CMD_INVALID, cmd_name, "Requires exactly three color values"); |
43 | } | 26 | } |
44 | 27 | ||
45 | if ((error = add_color("background", config->current_bar->colors.background, argv[0]))) { | 28 | int i; |
46 | return error; | 29 | for (i = 0; i < 3; i++) { |
30 | if (!*colors[i]) { | ||
31 | *(colors[i]) = malloc(10); | ||
32 | } | ||
33 | error = add_color(cmd_name, *(colors[i]), argv[i]); | ||
34 | if (error) { | ||
35 | return error; | ||
36 | } | ||
47 | } | 37 | } |
48 | 38 | ||
49 | return cmd_results_new(CMD_SUCCESS, NULL, NULL); | 39 | return cmd_results_new(CMD_SUCCESS, NULL, NULL); |
50 | } | 40 | } |
51 | 41 | ||
52 | struct cmd_results *bar_colors_cmd_focused_background(int argc, char **argv) { | 42 | struct cmd_results *bar_cmd_colors(int argc, char **argv) { |
53 | struct cmd_results *error = NULL; | 43 | struct cmd_results *error = NULL; |
54 | if ((error = checkarg(argc, "focused_background", EXPECTED_EQUAL_TO, 1))) { | 44 | if ((error = checkarg(argc, "colors", EXPECTED_EQUAL_TO, 1))) { |
55 | return error; | 45 | return error; |
56 | } | 46 | } |
57 | 47 | ||
58 | if ((error = add_color("focused_background", config->current_bar->colors.focused_background, argv[0]))) { | 48 | if (strcmp("{", argv[0]) != 0) { |
59 | return error; | 49 | return cmd_results_new(CMD_INVALID, "colors", |
60 | }else { | 50 | "Expected '{' at the start of colors config definition."); |
61 | config->current_bar->colors.has_focused_background = true; | ||
62 | } | 51 | } |
63 | 52 | ||
64 | return cmd_results_new(CMD_SUCCESS, NULL, NULL); | 53 | return cmd_results_new(CMD_BLOCK_BAR_COLORS, NULL, NULL); |
65 | } | 54 | } |
66 | 55 | ||
67 | struct cmd_results *bar_colors_cmd_binding_mode(int argc, char **argv) { | 56 | struct cmd_results *bar_colors_cmd_active_workspace(int argc, char **argv) { |
68 | struct cmd_results *error = NULL; | 57 | char **colors[3] = { |
69 | if ((error = checkarg(argc, "binding_mode", EXPECTED_EQUAL_TO, 3))) { | 58 | &(config->current_bar->colors.active_workspace_border), |
70 | return error; | 59 | &(config->current_bar->colors.active_workspace_bg), |
71 | } | 60 | &(config->current_bar->colors.active_workspace_text) |
72 | 61 | }; | |
73 | if ((error = add_color("binding_mode_border", config->current_bar->colors.binding_mode_border, argv[0]))) { | 62 | return parse_three_colors(colors, "active_workspace", argc, argv); |
74 | return error; | 63 | } |
75 | } else { | ||
76 | config->current_bar->colors.has_binding_mode_border = true; | ||
77 | } | ||
78 | 64 | ||
79 | if ((error = add_color("binding_mode_bg", config->current_bar->colors.binding_mode_bg, argv[1]))) { | 65 | struct cmd_results *bar_colors_cmd_background(int argc, char **argv) { |
80 | return error; | 66 | return parse_single_color(&(config->current_bar->colors.background), "background", argc, argv); |
81 | } else { | 67 | } |
82 | config->current_bar->colors.has_binding_mode_bg = true; | ||
83 | } | ||
84 | 68 | ||
85 | if ((error = add_color("binding_mode_text", config->current_bar->colors.binding_mode_text, argv[2]))) { | 69 | struct cmd_results *bar_colors_cmd_focused_background(int argc, char **argv) { |
86 | return error; | 70 | return parse_single_color(&(config->current_bar->colors.focused_background), "focused_background", argc, argv); |
87 | } else { | 71 | } |
88 | config->current_bar->colors.has_binding_mode_text = true; | ||
89 | } | ||
90 | 72 | ||
91 | return cmd_results_new(CMD_SUCCESS, NULL, NULL); | 73 | struct cmd_results *bar_colors_cmd_binding_mode(int argc, char **argv) { |
74 | char **colors[3] = { | ||
75 | &(config->current_bar->colors.binding_mode_border), | ||
76 | &(config->current_bar->colors.binding_mode_bg), | ||
77 | &(config->current_bar->colors.binding_mode_text) | ||
78 | }; | ||
79 | return parse_three_colors(colors, "binding_mode", argc, argv); | ||
92 | } | 80 | } |
93 | 81 | ||
94 | struct cmd_results *bar_colors_cmd_focused_workspace(int argc, char **argv) { | 82 | struct cmd_results *bar_colors_cmd_focused_workspace(int argc, char **argv) { |
95 | struct cmd_results *error = NULL; | 83 | char **colors[3] = { |
96 | if ((error = checkarg(argc, "focused_workspace", EXPECTED_EQUAL_TO, 3))) { | 84 | &(config->current_bar->colors.focused_workspace_border), |
97 | return error; | 85 | &(config->current_bar->colors.focused_workspace_bg), |
98 | } | 86 | &(config->current_bar->colors.focused_workspace_text) |
99 | 87 | }; | |
100 | if ((error = add_color("focused_workspace_border", config->current_bar->colors.focused_workspace_border, argv[0]))) { | 88 | return parse_three_colors(colors, "focused_workspace", argc, argv); |
101 | return error; | ||
102 | } | ||
103 | |||
104 | if ((error = add_color("focused_workspace_bg", config->current_bar->colors.focused_workspace_bg, argv[1]))) { | ||
105 | return error; | ||
106 | } | ||
107 | |||
108 | if ((error = add_color("focused_workspace_text", config->current_bar->colors.focused_workspace_text, argv[2]))) { | ||
109 | return error; | ||
110 | } | ||
111 | |||
112 | return cmd_results_new(CMD_SUCCESS, NULL, NULL); | ||
113 | } | 89 | } |
114 | 90 | ||
115 | struct cmd_results *bar_colors_cmd_inactive_workspace(int argc, char **argv) { | 91 | struct cmd_results *bar_colors_cmd_inactive_workspace(int argc, char **argv) { |
116 | struct cmd_results *error = NULL; | 92 | char **colors[3] = { |
117 | if ((error = checkarg(argc, "inactive_workspace", EXPECTED_EQUAL_TO, 3))) { | 93 | &(config->current_bar->colors.inactive_workspace_border), |
118 | return error; | 94 | &(config->current_bar->colors.inactive_workspace_bg), |
119 | } | 95 | &(config->current_bar->colors.inactive_workspace_text) |
120 | 96 | }; | |
121 | if ((error = add_color("inactive_workspace_border", config->current_bar->colors.inactive_workspace_border, argv[0]))) { | 97 | return parse_three_colors(colors, "inactive_workspace", argc, argv); |
122 | return error; | ||
123 | } | ||
124 | |||
125 | if ((error = add_color("inactive_workspace_bg", config->current_bar->colors.inactive_workspace_bg, argv[1]))) { | ||
126 | return error; | ||
127 | } | ||
128 | |||
129 | if ((error = add_color("inactive_workspace_text", config->current_bar->colors.inactive_workspace_text, argv[2]))) { | ||
130 | return error; | ||
131 | } | ||
132 | |||
133 | return cmd_results_new(CMD_SUCCESS, NULL, NULL); | ||
134 | } | 98 | } |
135 | 99 | ||
136 | struct cmd_results *bar_colors_cmd_separator(int argc, char **argv) { | 100 | struct cmd_results *bar_colors_cmd_separator(int argc, char **argv) { |
137 | struct cmd_results *error = NULL; | 101 | return parse_single_color(&(config->current_bar->colors.separator), "separator", argc, argv); |
138 | if ((error = checkarg(argc, "separator", EXPECTED_EQUAL_TO, 1))) { | ||
139 | return error; | ||
140 | } | ||
141 | |||
142 | if ((error = add_color("separator", config->current_bar->colors.separator, argv[0]))) { | ||
143 | return error; | ||
144 | } | ||
145 | |||
146 | return cmd_results_new(CMD_SUCCESS, NULL, NULL); | ||
147 | } | 102 | } |
148 | 103 | ||
149 | struct cmd_results *bar_colors_cmd_focused_separator(int argc, char **argv) { | 104 | struct cmd_results *bar_colors_cmd_focused_separator(int argc, char **argv) { |
150 | struct cmd_results *error = NULL; | 105 | return parse_single_color(&(config->current_bar->colors.focused_separator), "focused_separator", argc, argv); |
151 | if ((error = checkarg(argc, "focused_separator", EXPECTED_EQUAL_TO, 1))) { | ||
152 | return error; | ||
153 | } | ||
154 | |||
155 | if ((error = add_color("focused_separator", config->current_bar->colors.focused_separator, argv[0]))) { | ||
156 | return error; | ||
157 | } else { | ||
158 | config->current_bar->colors.has_focused_separator = true; | ||
159 | } | ||
160 | |||
161 | return cmd_results_new(CMD_SUCCESS, NULL, NULL); | ||
162 | } | 106 | } |
163 | 107 | ||
164 | struct cmd_results *bar_colors_cmd_statusline(int argc, char **argv) { | 108 | struct cmd_results *bar_colors_cmd_statusline(int argc, char **argv) { |
165 | struct cmd_results *error = NULL; | 109 | return parse_single_color(&(config->current_bar->colors.statusline), "statusline", argc, argv); |
166 | if ((error = checkarg(argc, "statusline", EXPECTED_EQUAL_TO, 1))) { | ||
167 | return error; | ||
168 | } | ||
169 | |||
170 | if ((error = add_color("statusline", config->current_bar->colors.statusline, argv[0]))) { | ||
171 | return error; | ||
172 | } | ||
173 | |||
174 | return cmd_results_new(CMD_SUCCESS, NULL, NULL); | ||
175 | } | 110 | } |
176 | 111 | ||
177 | struct cmd_results *bar_colors_cmd_focused_statusline(int argc, char **argv) { | 112 | struct cmd_results *bar_colors_cmd_focused_statusline(int argc, char **argv) { |
178 | struct cmd_results *error = NULL; | 113 | return parse_single_color(&(config->current_bar->colors.focused_separator), "focused_separator", argc, argv); |
179 | if ((error = checkarg(argc, "focused_statusline", EXPECTED_EQUAL_TO, 1))) { | ||
180 | return error; | ||
181 | } | ||
182 | |||
183 | if ((error = add_color("focused_statusline", config->current_bar->colors.focused_statusline, argv[0]))) { | ||
184 | return error; | ||
185 | } else { | ||
186 | config->current_bar->colors.has_focused_statusline = true; | ||
187 | } | ||
188 | |||
189 | return cmd_results_new(CMD_SUCCESS, NULL, NULL); | ||
190 | } | 114 | } |
191 | 115 | ||
192 | struct cmd_results *bar_colors_cmd_urgent_workspace(int argc, char **argv) { | 116 | struct cmd_results *bar_colors_cmd_urgent_workspace(int argc, char **argv) { |
193 | struct cmd_results *error = NULL; | 117 | char **colors[3] = { |
194 | if ((error = checkarg(argc, "urgent_workspace", EXPECTED_EQUAL_TO, 3))) { | 118 | &(config->current_bar->colors.urgent_workspace_border), |
195 | return error; | 119 | &(config->current_bar->colors.urgent_workspace_bg), |
196 | } | 120 | &(config->current_bar->colors.urgent_workspace_text) |
197 | 121 | }; | |
198 | if ((error = add_color("urgent_workspace_border", config->current_bar->colors.urgent_workspace_border, argv[0]))) { | 122 | return parse_three_colors(colors, "urgent_workspace", argc, argv); |
199 | return error; | ||
200 | } | ||
201 | |||
202 | if ((error = add_color("urgent_workspace_bg", config->current_bar->colors.urgent_workspace_bg, argv[1]))) { | ||
203 | return error; | ||
204 | } | ||
205 | |||
206 | if ((error = add_color("urgent_workspace_text", config->current_bar->colors.urgent_workspace_text, argv[2]))) { | ||
207 | return error; | ||
208 | } | ||
209 | |||
210 | return cmd_results_new(CMD_SUCCESS, NULL, NULL); | ||
211 | } | 123 | } |