git.sur5r.net Git - i3/i3/blob - i3bar/src/outputs.c

   1 /*
   2  * i3bar - an xcb-based status- and ws-bar for i3
   3  *
   4  * © 2010-2011 Axel Wagner and contributors
   5  *
   6  * See file LICNSE for license information
   7  *
   8  * src/outputs.c: Maintaining the output-list
   9  *
  10  */
  11 #include <string.h>
  12 #include <stdlib.h>
  13 #include <stdio.h>
  14 #include <errno.h>
  15 #include <i3/ipc.h>
  16 #include <yajl/yajl_parse.h>
  17 #include <yajl/yajl_version.h>
  18
  19 #include "common.h"
  20
  21 /* A datatype to pass through the callbacks to save the state */
  22 struct outputs_json_params {
  23     struct outputs_head *outputs;
  24     i3_output           *outputs_walk;
  25     char                *cur_key;
  26     char                *json;
  27     bool                init;
  28 };
  29
  30 /*
  31  * Parse a null-value (current_workspace)
  32  *
  33  */
  34 static int outputs_null_cb(void *params_) {
  35     struct outputs_json_params *params = (struct outputs_json_params*) params_;
  36
  37     FREE(params->cur_key);
  38
  39     return 1;
  40 }
  41
  42 /*
  43  * Parse a boolean value (active)
  44  *
  45  */
  46 static int outputs_boolean_cb(void *params_, int val) {
  47     struct outputs_json_params *params = (struct outputs_json_params*) params_;
  48
  49     if (strcmp(params->cur_key, "active")) {
  50         return 0;
  51     }
  52
  53     params->outputs_walk->active = val;
  54
  55     FREE(params->cur_key);
  56
  57     return 1;
  58 }
  59
  60 /*
  61  * Parse an integer (current_workspace or the rect)
  62  *
  63  */
  64 #if YAJL_MAJOR >= 2
  65 static int outputs_integer_cb(void *params_, long long val) {
  66 #else
  67 static int outputs_integer_cb(void *params_, long val) {
  68 #endif
  69     struct outputs_json_params *params = (struct outputs_json_params*) params_;
  70
  71     if (!strcmp(params->cur_key, "current_workspace")) {
  72         params->outputs_walk->ws = (int) val;
  73         FREE(params->cur_key);
  74         return 1;
  75     }
  76
  77     if (!strcmp(params->cur_key, "x")) {
  78         params->outputs_walk->rect.x = (int) val;
  79         FREE(params->cur_key);
  80         return 1;
  81     }
  82
  83     if (!strcmp(params->cur_key, "y")) {
  84         params->outputs_walk->rect.y = (int) val;
  85         FREE(params->cur_key);
  86         return 1;
  87     }
  88
  89     if (!strcmp(params->cur_key, "width")) {
  90         params->outputs_walk->rect.w = (int) val;
  91         FREE(params->cur_key);
  92         return 1;
  93     }
  94
  95     if (!strcmp(params->cur_key, "height")) {
  96         params->outputs_walk->rect.h = (int) val;
  97         FREE(params->cur_key);
  98         return 1;
  99     }
 100
 101     return 0;
 102 }
 103
 104 /*
 105  * Parse a string (name)
 106  *
 107  */
 108 #if YAJL_MAJOR >= 2
 109 static int outputs_string_cb(void *params_, const unsigned char *val, size_t len) {
 110 #else
 111 static int outputs_string_cb(void *params_, const unsigned char *val, unsigned int len) {
 112 #endif
 113     struct outputs_json_params *params = (struct outputs_json_params*) params_;
 114
 115     if (!strcmp(params->cur_key, "current_workspace")) {
 116         char *copy = malloc(sizeof(const unsigned char) * (len + 1));
 117         strncpy(copy, (const char*) val, len);
 118         copy[len] = '\0';
 119
 120         char *end;
 121         errno = 0;
 122         long parsed_num = strtol(copy, &end, 10);
 123         if (errno == 0 &&
 124             (end && *end == '\0'))
 125             params->outputs_walk->ws = parsed_num;
 126         free(copy);
 127         FREE(params->cur_key);
 128         return 1;
 129     }
 130
 131     if (strcmp(params->cur_key, "name")) {
 132         return 0;
 133     }
 134
 135     char *name = malloc(sizeof(const unsigned char) * (len + 1));
 136     strncpy(name, (const char*) val, len);
 137     name[len] = '\0';
 138
 139     params->outputs_walk->name = name;
 140
 141     FREE(params->cur_key);
 142
 143     return 1;
 144 }
 145
 146 /*
 147  * We hit the start of a json-map (rect or a new output)
 148  *
 149  */
 150 static int outputs_start_map_cb(void *params_) {
 151     struct outputs_json_params *params = (struct outputs_json_params*) params_;
 152     i3_output *new_output = NULL;
 153
 154     if (params->cur_key == NULL) {
 155         new_output = malloc(sizeof(i3_output));
 156         new_output->name = NULL;
 157         new_output->ws = 0,
 158         memset(&new_output->rect, 0, sizeof(rect));
 159         new_output->bar = XCB_NONE;
 160
 161         new_output->workspaces = malloc(sizeof(struct ws_head));
 162         TAILQ_INIT(new_output->workspaces);
 163
 164         new_output->trayclients = malloc(sizeof(struct tc_head));
 165         TAILQ_INIT(new_output->trayclients);
 166
 167         params->outputs_walk = new_output;
 168
 169         return 1;
 170     }
 171
 172     return 1;
 173 }
 174
 175 /*
 176  * We hit the end of a map (rect or a new output)
 177  *
 178  */
 179 static int outputs_end_map_cb(void *params_) {
 180     struct outputs_json_params *params = (struct outputs_json_params*) params_;
 181     /* FIXME: What is at the end of a rect? */
 182
 183     i3_output *target = get_output_by_name(params->outputs_walk->name);
 184
 185     if (target == NULL) {
 186         SLIST_INSERT_HEAD(outputs, params->outputs_walk, slist);
 187     } else {
 188         target->active = params->outputs_walk->active;
 189         target->ws = params->outputs_walk->ws;
 190         target->rect = params->outputs_walk->rect;
 191     }
 192     return 1;
 193 }
 194
 195 /*
 196  * Parse a key.
 197  *
 198  * Essentially we just save it in the parsing-state
 199  *
 200  */
 201 #if YAJL_MAJOR >= 2
 202 static int outputs_map_key_cb(void *params_, const unsigned char *keyVal, size_t keyLen) {
 203 #else
 204 static int outputs_map_key_cb(void *params_, const unsigned char *keyVal, unsigned keyLen) {
 205 #endif
 206     struct outputs_json_params *params = (struct outputs_json_params*) params_;
 207     FREE(params->cur_key);
 208
 209     params->cur_key = malloc(sizeof(unsigned char) * (keyLen + 1));
 210     strncpy(params->cur_key, (const char*) keyVal, keyLen);
 211     params->cur_key[keyLen] = '\0';
 212
 213     return 1;
 214 }
 215
 216 /* A datastructure to pass all these callbacks to yajl */
 217 yajl_callbacks outputs_callbacks = {
 218     &outputs_null_cb,
 219     &outputs_boolean_cb,
 220     &outputs_integer_cb,
 221     NULL,
 222     NULL,
 223     &outputs_string_cb,
 224     &outputs_start_map_cb,
 225     &outputs_map_key_cb,
 226     &outputs_end_map_cb,
 227     NULL,
 228     NULL
 229 };
 230
 231 /*
 232  * Initiate the output-list
 233  *
 234  */
 235 void init_outputs() {
 236     outputs = malloc(sizeof(struct outputs_head));
 237     SLIST_INIT(outputs);
 238 }
 239
 240 /*
 241  * Start parsing the received json-string
 242  *
 243  */
 244 void parse_outputs_json(char *json) {
 245     struct outputs_json_params params;
 246
 247     params.outputs_walk = NULL;
 248     params.cur_key = NULL;
 249     params.json = json;
 250
 251     yajl_handle handle;
 252     yajl_status state;
 253 #if YAJL_MAJOR < 2
 254     yajl_parser_config parse_conf = { 0, 0 };
 255
 256     handle = yajl_alloc(&outputs_callbacks, &parse_conf, NULL, (void*) &params);
 257 #else
 258     handle = yajl_alloc(&outputs_callbacks, NULL, (void*) &params);
 259 #endif
 260
 261     state = yajl_parse(handle, (const unsigned char*) json, strlen(json));
 262
 263     /* FIXME: Propper errorhandling for JSON-parsing */
 264     switch (state) {
 265         case yajl_status_ok:
 266             break;
 267         case yajl_status_client_canceled:
 268 #if YAJL_MAJOR < 2
 269         case yajl_status_insufficient_data:
 270 #endif
 271         case yajl_status_error:
 272             ELOG("Could not parse outputs-reply!\n");
 273             exit(EXIT_FAILURE);
 274             break;
 275     }
 276
 277     yajl_free(handle);
 278 }
 279
 280 /*
 281  * Returns the output with the given name
 282  *
 283  */
 284 i3_output *get_output_by_name(char *name) {
 285     i3_output *walk;
 286     if (name == NULL) {
 287         return NULL;
 288     }
 289     SLIST_FOREACH(walk, outputs, slist) {
 290         if (!strcmp(walk->name, name)) {
 291             break;
 292         }
 293     }
 294
 295     return walk;
 296 }