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

   1 #include <string.h>
   2 #include <stdlib.h>
   3 #include <stdio.h>
   4
   5 #include <yajl/yajl_parse.h>
   6
   7 #include "common.h"
   8 #include "workspaces.h"
   9 #include "xcb.h"
  10 #include "ipc.h"
  11
  12 struct workspaces_json_params {
  13         struct ws_head  *workspaces;
  14         i3_ws           *workspaces_walk;
  15         char            *cur_key;
  16         char            *json;
  17 };
  18
  19 static int workspaces_null_cb(void* params_) {
  20         struct workspaces_json_params* params = (struct workspaces_json_params*) params_;
  21
  22         if (strcmp(params->cur_key, "current_workspace")) {
  23                 return 0;
  24         }
  25
  26         FREE(params->cur_key);
  27
  28         return 1;
  29 }
  30
  31 static int workspaces_boolean_cb(void* params_, bool val) {
  32         struct workspaces_json_params* params = (struct workspaces_json_params*) params_;
  33
  34         if (!strcmp(params->cur_key, "visible")) {
  35                 params->workspaces_walk->visible = val;
  36                 FREE(params->cur_key);
  37                 return 1;
  38         }
  39
  40         if (!strcmp(params->cur_key, "focused")) {
  41                 params->workspaces_walk->focused = val;
  42                 FREE(params->cur_key);
  43                 return 1;
  44         }
  45
  46         if (!strcmp(params->cur_key, "urgent")) {
  47                 params->workspaces_walk->urgent = val;
  48                 FREE(params->cur_key);
  49                 return 1;
  50         }
  51
  52         FREE(params->cur_key);
  53
  54         return 0;
  55 }
  56
  57 static int workspaces_integer_cb(void* params_, long val) {
  58         struct workspaces_json_params* params = (struct workspaces_json_params*) params_;
  59
  60         if (!strcmp(params->cur_key, "num")) {
  61                 params->workspaces_walk->num = (int) val;
  62                 FREE(params->cur_key);
  63                 return 1;
  64         }
  65
  66         if (!strcmp(params->cur_key, "x")) {
  67                 params->workspaces_walk->rect.x = (int) val;
  68                 FREE(params->cur_key);
  69                 return 1;
  70         }
  71
  72         if (!strcmp(params->cur_key, "y")) {
  73                 params->workspaces_walk->rect.y = (int) val;
  74                 FREE(params->cur_key);
  75                 return 1;
  76         }
  77
  78         if (!strcmp(params->cur_key, "width")) {
  79                 params->workspaces_walk->rect.w = (int) val;
  80                 FREE(params->cur_key);
  81                 return 1;
  82         }
  83
  84         if (!strcmp(params->cur_key, "height")) {
  85                 params->workspaces_walk->rect.h = (int) val;
  86                 FREE(params->cur_key);
  87                 return 1;
  88         }
  89
  90         FREE(params->cur_key);
  91         return 0;
  92 }
  93
  94 static int workspaces_string_cb(void* params_, const unsigned char* val, unsigned int len) {
  95
  96         struct workspaces_json_params* params = (struct workspaces_json_params*) params_;
  97
  98         char* output_name;
  99
 100         if (!strcmp(params->cur_key, "name")) {
 101                 params->workspaces_walk->name = malloc(sizeof(const unsigned char) * (len + 1));
 102                 strncpy(params->workspaces_walk->name, (const char*) val, len);
 103                 params->workspaces_walk->name[len] = '\0';
 104
 105                 params->workspaces_walk->name_width = get_string_width(params->workspaces_walk->name);
 106
 107                 printf("Got Workspace %s, name_width: %d\n",
 108                        params->workspaces_walk->name,
 109                        params->workspaces_walk->name_width);
 110                 FREE(params->cur_key);
 111
 112                 return 1;
 113         }
 114
 115         if (!strcmp(params->cur_key, "output")) {
 116                 output_name = malloc(sizeof(const unsigned char) * (len + 1));
 117                 strncpy(output_name, (const char*) val, len);
 118                 output_name[len] = '\0';
 119                 params->workspaces_walk->output = get_output_by_name(output_name);
 120
 121                 TAILQ_INSERT_TAIL(params->workspaces_walk->output->workspaces,
 122                                   params->workspaces_walk,
 123                                   tailq);
 124
 125                 free(output_name);
 126                 return 1;
 127         }
 128
 129         return 0;
 130 }
 131
 132 static int workspaces_start_map_cb(void* params_) {
 133         struct workspaces_json_params* params = (struct workspaces_json_params*) params_;
 134
 135         i3_ws     *new_workspace = NULL;
 136
 137         if (params->cur_key == NULL) {
 138                 new_workspace = malloc(sizeof(i3_ws));
 139                 new_workspace->num = -1;
 140                 new_workspace->name = NULL;
 141                 new_workspace->visible = 0;
 142                 new_workspace->focused = 0;
 143                 new_workspace->urgent = 0;
 144                 memset(&new_workspace->rect, 0, sizeof(rect));
 145                 new_workspace->output = NULL;
 146
 147                 params->workspaces_walk = new_workspace;
 148                 return 1;
 149         }
 150
 151         return 1;
 152 }
 153
 154 static int workspaces_map_key_cb(void* params_, const unsigned char* keyVal, unsigned int keyLen) {
 155         struct workspaces_json_params* params = (struct workspaces_json_params*) params_;
 156         FREE(params->cur_key);
 157
 158         params->cur_key = malloc(sizeof(unsigned char) * (keyLen + 1));
 159         if (params->cur_key == NULL) {
 160                 printf("ERROR: Could not allocate memory!\n");
 161                 exit(EXIT_FAILURE);
 162         }
 163         strncpy(params->cur_key, (const char*) keyVal, keyLen);
 164         params->cur_key[keyLen] = '\0';
 165
 166         return 1;
 167 }
 168
 169 yajl_callbacks workspaces_callbacks = {
 170         &workspaces_null_cb,
 171         &workspaces_boolean_cb,
 172         &workspaces_integer_cb,
 173         NULL,
 174         NULL,
 175         &workspaces_string_cb,
 176         &workspaces_start_map_cb,
 177         &workspaces_map_key_cb,
 178         NULL,
 179         NULL,
 180         NULL
 181 };
 182
 183 void parse_workspaces_json(char* json) {
 184         /* FIXME: Fasciliate stream-processing, i.e. allow starting to interpret
 185          * JSON in chunks */
 186         struct workspaces_json_params params;
 187
 188         free_workspaces();
 189
 190         params.workspaces_walk = NULL;
 191         params.cur_key = NULL;
 192         params.json = json;
 193
 194         yajl_handle handle;
 195         yajl_parser_config parse_conf = { 0, 0 };
 196         yajl_status state;
 197
 198         handle = yajl_alloc(&workspaces_callbacks, &parse_conf, NULL, (void*) &params);
 199
 200         state = yajl_parse(handle, (const unsigned char*) json, strlen(json));
 201
 202         /* FIXME: Propper errorhandling for JSON-parsing */
 203         switch (state) {
 204                 case yajl_status_ok:
 205                         break;
 206                 case yajl_status_client_canceled:
 207                 case yajl_status_insufficient_data:
 208                 case yajl_status_error:
 209                         printf("ERROR: Could not parse workspaces-reply!\n");
 210                         exit(EXIT_FAILURE);
 211                         break;
 212         }
 213
 214         yajl_free(handle);
 215
 216         FREE(params.cur_key);
 217 }
 218
 219 void free_workspaces() {
 220         i3_output *outputs_walk;
 221         SLIST_FOREACH(outputs_walk, outputs, slist) {
 222                 if (outputs_walk->workspaces != NULL && !TAILQ_EMPTY(outputs_walk->workspaces)) {
 223                         FREE_TAILQ(outputs_walk->workspaces, i3_ws);
 224                 }
 225         }
 226 }