Debian Codegraph @

i3bar/src/outputs.c

raw
1 /*
2 * vim:ts=4:sw=4:expandtab
3 *
4 * i3bar - an xcb-based status- and ws-bar for i3
5 * © 2010 Axel Wagner and contributors (see also: LICENSE)
6 *
7 * outputs.c: Maintaining the outputs list
8 *
9 */
10 #include "common.h"
11
12 #include <errno.h>
13 #include <stdio.h>
14 #include <stdlib.h>
15 #include <string.h>
16
17 #include <yajl/yajl_parse.h>
18
19 /* A datatype to pass through the callbacks to save the state */
20 struct outputs_json_params {
21 i3_output *outputs_walk;
22 char *cur_key;
23 bool in_rect;
24 };
25
26 /*
27 * Parse a null value (current_workspace)
28 *
29 */
30 static int outputs_null_cb(void *params_) {
31 struct outputs_json_params *params = (struct outputs_json_params *)params_;
32
33 FREE(params->cur_key);
34
35 return 1;
36 }
37
38 /*
39 * Parse a boolean value (active)
40 *
41 */
42 static int outputs_boolean_cb(void *params_, int val) {
43 struct outputs_json_params *params = (struct outputs_json_params *)params_;
44
45 if (!strcmp(params->cur_key, "active")) {
46 params->outputs_walk->active = val;
47 FREE(params->cur_key);
48 return 1;
49 }
50
51 if (!strcmp(params->cur_key, "primary")) {
52 params->outputs_walk->primary = val;
53 FREE(params->cur_key);
54 return 1;
55 }
56
57 return 0;
58 }
59
60 /*
61 * Parse an integer (current_workspace or the rect)
62 *
63 */
64 static int outputs_integer_cb(void *params_, long long val) {
65 struct outputs_json_params *params = (struct outputs_json_params *)params_;
66
67 if (!strcmp(params->cur_key, "current_workspace")) {
68 params->outputs_walk->ws = (int)val;
69 FREE(params->cur_key);
70 return 1;
71 }
72
73 if (!strcmp(params->cur_key, "x")) {
74 params->outputs_walk->rect.x = (int)val;
75 FREE(params->cur_key);
76 return 1;
77 }
78
79 if (!strcmp(params->cur_key, "y")) {
80 params->outputs_walk->rect.y = (int)val;
81 FREE(params->cur_key);
82 return 1;
83 }
84
85 if (!strcmp(params->cur_key, "width")) {
86 params->outputs_walk->rect.w = (int)val;
87 FREE(params->cur_key);
88 return 1;
89 }
90
91 if (!strcmp(params->cur_key, "height")) {
92 params->outputs_walk->rect.h = (int)val;
93 FREE(params->cur_key);
94 return 1;
95 }
96
97 return 0;
98 }
99
100 /*
101 * Parse a string (name)
102 *
103 */
104 static int outputs_string_cb(void *params_, const unsigned char *val, size_t len) {
105 struct outputs_json_params *params = (struct outputs_json_params *)params_;
106
107 if (!strcmp(params->cur_key, "current_workspace")) {
108 char *copy = NULL;
109 sasprintf(&copy, "%.*s", (int)len, val);
110
111 char *end;
112 errno = 0;
113 long parsed_num = strtol(copy, &end, 10);
114 if (errno == 0 &&
115 (end && *end == '\0')) {
116 params->outputs_walk->ws = parsed_num;
117 }
118
119 FREE(copy);
120 FREE(params->cur_key);
121 return 1;
122 }
123
124 if (strcmp(params->cur_key, "name")) {
125 return 0;
126 }
127
128 sasprintf(&(params->outputs_walk->name), "%.*s", (int)len, val);
129
130 FREE(params->cur_key);
131 return 1;
132 }
133
134 /*
135 * We hit the start of a JSON map (rect or a new output)
136 *
137 */
138 static int outputs_start_map_cb(void *params_) {
139 struct outputs_json_params *params = (struct outputs_json_params *)params_;
140 i3_output *new_output = NULL;
141
142 if (params->cur_key == NULL) {
143 new_output = smalloc(sizeof(i3_output));
144 new_output->name = NULL;
145 new_output->active = false;
146 new_output->primary = false;
147 new_output->visible = false;
148 new_output->ws = 0,
149 new_output->statusline_width = 0;
150 memset(&new_output->rect, 0, sizeof(rect));
151 memset(&new_output->bar, 0, sizeof(surface_t));
152 memset(&new_output->buffer, 0, sizeof(surface_t));
153 memset(&new_output->statusline_buffer, 0, sizeof(surface_t));
154
155 new_output->workspaces = smalloc(sizeof(struct ws_head));
156 TAILQ_INIT(new_output->workspaces);
157
158 new_output->trayclients = smalloc(sizeof(struct tc_head));
159 TAILQ_INIT(new_output->trayclients);
160
161 params->outputs_walk = new_output;
162
163 return 1;
164 }
165
166 if (!strcmp(params->cur_key, "rect")) {
167 params->in_rect = true;
168 }
169
170 return 1;
171 }
172
173 static void clear_output(i3_output *output) {
174 FREE(output->name);
175 FREE(output->workspaces);
176 FREE(output->trayclients);
177 }
178
179 /*
180 * We hit the end of a map (rect or a new output)
181 *
182 */
183 static int outputs_end_map_cb(void *params_) {
184 struct outputs_json_params *params = (struct outputs_json_params *)params_;
185 if (params->in_rect) {
186 params->in_rect = false;
187 /* Ignore the end of a rect */
188 return 1;
189 }
190
191 /* See if we actually handle that output */
192 if (config.num_outputs > 0) {
193 const bool is_primary = params->outputs_walk->primary;
194 bool handle_output = false;
195 for (int c = 0; c < config.num_outputs; c++) {
196 if ((strcasecmp(params->outputs_walk->name, config.outputs[c]) == 0) ||
197 (strcasecmp(config.outputs[c], "primary") == 0 && is_primary) ||
198 (strcasecmp(config.outputs[c], "nonprimary") == 0 && !is_primary)) {
199 handle_output = true;
200 break;
201 }
202 }
203 if (!handle_output) {
204 DLOG("Ignoring output \"%s\", not configured to handle it.\n",
205 params->outputs_walk->name);
206 clear_output(params->outputs_walk);
207 FREE(params->outputs_walk);
208 FREE(params->cur_key);
209 return 1;
210 }
211 }
212
213 i3_output *target = get_output_by_name(params->outputs_walk->name);
214
215 if (target == NULL) {
216 SLIST_INSERT_HEAD(outputs, params->outputs_walk, slist);
217 } else {
218 target->active = params->outputs_walk->active;
219 target->primary = params->outputs_walk->primary;
220 target->ws = params->outputs_walk->ws;
221 target->rect = params->outputs_walk->rect;
222
223 clear_output(params->outputs_walk);
224 FREE(params->outputs_walk);
225 }
226 return 1;
227 }
228
229 /*
230 * Parse a key.
231 *
232 * Essentially we just save it in the parsing state
233 *
234 */
235 static int outputs_map_key_cb(void *params_, const unsigned char *keyVal, size_t keyLen) {
236 struct outputs_json_params *params = (struct outputs_json_params *)params_;
237 FREE(params->cur_key);
238 sasprintf(&(params->cur_key), "%.*s", (int)keyLen, keyVal);
239 return 1;
240 }
241
242 /* A datastructure to pass all these callbacks to yajl */
243 static yajl_callbacks outputs_callbacks = {
244 .yajl_null = outputs_null_cb,
245 .yajl_boolean = outputs_boolean_cb,
246 .yajl_integer = outputs_integer_cb,
247 .yajl_string = outputs_string_cb,
248 .yajl_start_map = outputs_start_map_cb,
249 .yajl_map_key = outputs_map_key_cb,
250 .yajl_end_map = outputs_end_map_cb,
251 };
252
253 struct outputs_head *outputs;
254 /*
255 * Initiate the outputs list
256 *
257 */
258 void init_outputs(void) {
259 outputs = smalloc(sizeof(struct outputs_head));
260 SLIST_INIT(outputs);
261 }
262
263 /*
264 * Parse the received JSON string
265 *
266 */
267 void parse_outputs_json(const unsigned char *json, size_t size) {
268 struct outputs_json_params params;
269 params.outputs_walk = NULL;
270 params.cur_key = NULL;
271 params.in_rect = false;
272
273 yajl_handle handle = yajl_alloc(&outputs_callbacks, NULL, (void *)&params);
274 yajl_status state = yajl_parse(handle, json, size);
275
276 /* FIXME: Proper errorhandling for JSON-parsing */
277 switch (state) {
278 case yajl_status_ok:
279 break;
280 case yajl_status_client_canceled:
281 case yajl_status_error:
282 ELOG("Could not parse outputs reply!\n");
283 exit(EXIT_FAILURE);
284 break;
285 }
286
287 yajl_free(handle);
288 free(params.cur_key);
289 }
290
291 /*
292 * free() all outputs data structures.
293 *
294 */
295 void free_outputs(void) {
296 free_workspaces();
297
298 i3_output *outputs_walk;
299 if (outputs == NULL) {
300 return;
301 }
302 SLIST_FOREACH (outputs_walk, outputs, slist) {
303 destroy_window(outputs_walk);
304 if (outputs_walk->trayclients != NULL && !TAILQ_EMPTY(outputs_walk->trayclients)) {
305 FREE_TAILQ(outputs_walk->trayclients, trayclient);
306 }
307 clear_output(outputs_walk);
308 }
309 FREE_SLIST(outputs, i3_output);
310 }
311
312 /*
313 * Returns the output with the given name
314 *
315 */
316 i3_output *get_output_by_name(char *name) {
317 if (name == NULL) {
318 return NULL;
319 }
320 const bool is_primary = !strcasecmp(name, "primary");
321
322 i3_output *walk;
323 SLIST_FOREACH (walk, outputs, slist) {
324 if ((is_primary && walk->primary) || !strcmp(walk->name, name)) {
325 break;
326 }
327 }
328
329 return walk;
330 }
331
332 /*
333 * Returns true if the output has the currently focused workspace
334 *
335 */
336 bool output_has_focus(i3_output *output) {
337 i3_ws *ws_walk;
338 TAILQ_FOREACH (ws_walk, output->workspaces, tailq) {
339 if (ws_walk->focused) {
340 return true;
341 }
342 }
343 return false;
344 }