git.sur5r.net Git - i3/i3/blob - src/util.c

   1 /*
   2  * vim:ts=8:expandtab
   3  *
   4  * i3 - an improved dynamic tiling window manager
   5  *
   6  * © 2009 Michael Stapelberg and contributors
   7  *
   8  * See file LICENSE for license information.
   9  *
  10  * util.c: Utility functions, which can be useful everywhere.
  11  *
  12  */
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <unistd.h>
  16 #include <string.h>
  17 #include <sys/wait.h>
  18 #include <stdarg.h>
  19 #include <assert.h>
  20 #include <iconv.h>
  21 #if defined(__OpenBSD__)
  22 #include <sys/cdefs.h>
  23 #endif
  24
  25 #include <xcb/xcb_icccm.h>
  26
  27 #include "i3.h"
  28 #include "data.h"
  29 #include "table.h"
  30 #include "layout.h"
  31 #include "util.h"
  32 #include "xcb.h"
  33 #include "client.h"
  34 #include "log.h"
  35 #include "ewmh.h"
  36
  37 static iconv_t conversion_descriptor = 0;
  38 struct keyvalue_table_head by_parent = TAILQ_HEAD_INITIALIZER(by_parent);
  39 struct keyvalue_table_head by_child = TAILQ_HEAD_INITIALIZER(by_child);
  40
  41 int min(int a, int b) {
  42         return (a < b ? a : b);
  43 }
  44
  45 int max(int a, int b) {
  46         return (a > b ? a : b);
  47 }
  48
  49 /*
  50  * The s* functions (safe) are wrappers around malloc, strdup, …, which exits if one of
  51  * the called functions returns NULL, meaning that there is no more memory available
  52  *
  53  */
  54 void *smalloc(size_t size) {
  55         void *result = malloc(size);
  56         exit_if_null(result, "Error: out of memory (malloc(%zd))\n", size);
  57         return result;
  58 }
  59
  60 void *scalloc(size_t size) {
  61         void *result = calloc(size, 1);
  62         exit_if_null(result, "Error: out of memory (calloc(%zd))\n", size);
  63         return result;
  64 }
  65
  66 char *sstrdup(const char *str) {
  67         char *result = strdup(str);
  68         exit_if_null(result, "Error: out of memory (strdup())\n");
  69         return result;
  70 }
  71
  72 /*
  73  * The table_* functions emulate the behaviour of libxcb-wm, which in libxcb 0.3.4 suddenly
  74  * vanished. Great.
  75  *
  76  */
  77 bool table_put(struct keyvalue_table_head *head, uint32_t key, void *value) {
  78         struct keyvalue_element *element = scalloc(sizeof(struct keyvalue_element));
  79         element->key = key;
  80         element->value = value;
  81
  82         TAILQ_INSERT_TAIL(head, element, elements);
  83         return true;
  84 }
  85
  86 void *table_remove(struct keyvalue_table_head *head, uint32_t key) {
  87         struct keyvalue_element *element;
  88
  89         TAILQ_FOREACH(element, head, elements)
  90                 if (element->key == key) {
  91                         void *value = element->value;
  92                         TAILQ_REMOVE(head, element, elements);
  93                         free(element);
  94                         return value;
  95                 }
  96
  97         return NULL;
  98 }
  99
 100 void *table_get(struct keyvalue_table_head *head, uint32_t key) {
 101         struct keyvalue_element *element;
 102
 103         TAILQ_FOREACH(element, head, elements)
 104                 if (element->key == key)
 105                         return element->value;
 106
 107         return NULL;
 108 }
 109
 110 /*
 111  * Starts the given application by passing it through a shell. We use double fork
 112  * to avoid zombie processes. As the started application’s parent exits (immediately),
 113  * the application is reparented to init (process-id 1), which correctly handles
 114  * childs, so we don’t have to do it :-).
 115  *
 116  * The shell is determined by looking for the SHELL environment variable. If it
 117  * does not exist, /bin/sh is used.
 118  *
 119  */
 120 void start_application(const char *command) {
 121         if (fork() == 0) {
 122                 /* Child process */
 123                 if (fork() == 0) {
 124                         /* Stores the path of the shell */
 125                         static const char *shell = NULL;
 126
 127                         if (shell == NULL)
 128                                 if ((shell = getenv("SHELL")) == NULL)
 129                                         shell = "/bin/sh";
 130
 131                         /* This is the child */
 132                         execl(shell, shell, "-c", command, (void*)NULL);
 133                         /* not reached */
 134                 }
 135                 exit(0);
 136         }
 137         wait(0);
 138 }
 139
 140 /*
 141  * Checks a generic cookie for errors and quits with the given message if there
 142  * was an error.
 143  *
 144  */
 145 void check_error(xcb_connection_t *conn, xcb_void_cookie_t cookie, char *err_message) {
 146         xcb_generic_error_t *error = xcb_request_check(conn, cookie);
 147         if (error != NULL) {
 148                 fprintf(stderr, "ERROR: %s (X error %d)\n", err_message , error->error_code);
 149                 xcb_disconnect(conn);
 150                 exit(-1);
 151         }
 152 }
 153
 154 /*
 155  * Converts the given string to UCS-2 big endian for use with
 156  * xcb_image_text_16(). The amount of real glyphs is stored in real_strlen,
 157  * a buffer containing the UCS-2 encoded string (16 bit per glyph) is
 158  * returned. It has to be freed when done.
 159  *
 160  */
 161 char *convert_utf8_to_ucs2(char *input, int *real_strlen) {
 162         size_t input_size = strlen(input) + 1;
 163         /* UCS-2 consumes exactly two bytes for each glyph */
 164         int buffer_size = input_size * 2;
 165
 166         char *buffer = smalloc(buffer_size);
 167         size_t output_size = buffer_size;
 168         /* We need to use an additional pointer, because iconv() modifies it */
 169         char *output = buffer;
 170
 171         /* We convert the input into UCS-2 big endian */
 172         if (conversion_descriptor == 0) {
 173                 conversion_descriptor = iconv_open("UCS-2BE", "UTF-8");
 174                 if (conversion_descriptor == 0) {
 175                         fprintf(stderr, "error opening the conversion context\n");
 176                         exit(1);
 177                 }
 178         }
 179
 180         /* Get the conversion descriptor back to original state */
 181         iconv(conversion_descriptor, NULL, NULL, NULL, NULL);
 182
 183         /* Convert our text */
 184         int rc = iconv(conversion_descriptor, (void*)&input, &input_size, &output, &output_size);
 185         if (rc == (size_t)-1) {
 186                 perror("Converting to UCS-2 failed");
 187                 if (real_strlen != NULL)
 188                         *real_strlen = 0;
 189                 return NULL;
 190         }
 191
 192         if (real_strlen != NULL)
 193                 *real_strlen = ((buffer_size - output_size) / 2) - 1;
 194
 195         return buffer;
 196 }
 197
 198 /*
 199  * Returns the client which comes next in focus stack (= was selected before) for
 200  * the given container, optionally excluding the given client.
 201  *
 202  */
 203 Client *get_last_focused_client(xcb_connection_t *conn, Container *container, Client *exclude) {
 204         Client *current;
 205         SLIST_FOREACH(current, &(container->workspace->focus_stack), focus_clients)
 206                 if ((current->container == container) && ((exclude == NULL) || (current != exclude)))
 207                         return current;
 208         return NULL;
 209 }
 210
 211
 212 /*
 213  * Sets the given client as focused by updating the data structures correctly,
 214  * updating the X input focus and finally re-decorating both windows (to signalize
 215  * the user the new focus situation)
 216  *
 217  */
 218 void set_focus(xcb_connection_t *conn, Client *client, bool set_anyways) {
 219         /* The dock window cannot be focused, but enter notifies are still handled correctly */
 220         if (client->dock)
 221                 return;
 222
 223         /* Store the old client */
 224         Client *old_client = SLIST_FIRST(&(c_ws->focus_stack));
 225
 226         /* Check if the focus needs to be changed at all */
 227         if (!set_anyways && (old_client == client))
 228                 return;
 229
 230         /* Store current_row/current_col */
 231         c_ws->current_row = current_row;
 232         c_ws->current_col = current_col;
 233         c_ws = client->workspace;
 234         ewmh_update_current_desktop();
 235         /* Load current_col/current_row if we switch to a client without a container */
 236         current_col = c_ws->current_col;
 237         current_row = c_ws->current_row;
 238
 239         /* Update container */
 240         if (client->container != NULL) {
 241                 client->container->currently_focused = client;
 242
 243                 current_col = client->container->col;
 244                 current_row = client->container->row;
 245         }
 246
 247         CLIENT_LOG(client);
 248         /* Set focus to the entered window, and flush xcb buffer immediately */
 249         xcb_set_input_focus(conn, XCB_INPUT_FOCUS_POINTER_ROOT, client->child, XCB_CURRENT_TIME);
 250         ewmh_update_active_window(client->child);
 251         //xcb_warp_pointer(conn, XCB_NONE, client->child, 0, 0, 0, 0, 10, 10);
 252
 253         if (client->container != NULL) {
 254                 /* Get the client which was last focused in this particular container, it may be a different
 255                    one than old_client */
 256                 Client *last_focused = get_last_focused_client(conn, client->container, NULL);
 257
 258                 /* In stacking containers, raise the client in respect to the one which was focused before */
 259                 if ((client->container->mode == MODE_STACK || client->container->mode == MODE_TABBED) &&
 260                     client->container->workspace->fullscreen_client == NULL) {
 261                         /* We need to get the client again, this time excluding the current client, because
 262                          * we might have just gone into stacking mode and need to raise */
 263                         Client *last_focused = get_last_focused_client(conn, client->container, client);
 264
 265                         if (last_focused != NULL) {
 266                                 DLOG("raising above frame %p / child %p\n", last_focused->frame, last_focused->child);
 267                                 uint32_t values[] = { last_focused->frame, XCB_STACK_MODE_ABOVE };
 268                                 xcb_configure_window(conn, client->frame, XCB_CONFIG_WINDOW_SIBLING | XCB_CONFIG_WINDOW_STACK_MODE, values);
 269                         }
 270                 }
 271
 272                 /* If it is the same one as old_client, we save us the unnecessary redecorate */
 273                 if ((last_focused != NULL) && (last_focused != old_client))
 274                         redecorate_window(conn, last_focused);
 275         }
 276
 277         /* If the last client was a floating client, we need to go to the next
 278          * tiling client in stack and re-decorate it. */
 279         if (old_client != NULL && client_is_floating(old_client)) {
 280                 DLOG("Coming from floating client, searching next tiling...\n");
 281                 Client *current;
 282                 SLIST_FOREACH(current, &(client->workspace->focus_stack), focus_clients) {
 283                         if (client_is_floating(current))
 284                                 continue;
 285
 286                         DLOG("Found window: %p / child %p\n", current->frame, current->child);
 287                         redecorate_window(conn, current);
 288                         break;
 289                 }
 290
 291         }
 292
 293         SLIST_REMOVE(&(client->workspace->focus_stack), client, Client, focus_clients);
 294         SLIST_INSERT_HEAD(&(client->workspace->focus_stack), client, focus_clients);
 295
 296         /* If we’re in stacking mode, this renders the container to update changes in the title
 297            bars and to raise the focused client */
 298         if ((old_client != NULL) && (old_client != client) && !old_client->dock)
 299                 redecorate_window(conn, old_client);
 300
 301         /* redecorate_window flushes, so we don’t need to */
 302         redecorate_window(conn, client);
 303 }
 304
 305 /*
 306  * Called when the user switches to another mode or when the container is
 307  * destroyed and thus needs to be cleaned up.
 308  *
 309  */
 310 void leave_stack_mode(xcb_connection_t *conn, Container *container) {
 311         /* When going out of stacking mode, we need to close the window */
 312         struct Stack_Window *stack_win = &(container->stack_win);
 313
 314         SLIST_REMOVE(&stack_wins, stack_win, Stack_Window, stack_windows);
 315
 316         xcb_free_gc(conn, stack_win->pixmap.gc);
 317         xcb_free_pixmap(conn, stack_win->pixmap.id);
 318         xcb_destroy_window(conn, stack_win->window);
 319
 320         stack_win->rect.width = -1;
 321         stack_win->rect.height = -1;
 322 }
 323
 324 /*
 325  * Switches the layout of the given container taking care of the necessary house-keeping
 326  *
 327  */
 328 void switch_layout_mode(xcb_connection_t *conn, Container *container, int mode) {
 329         if (mode == MODE_STACK || mode == MODE_TABBED) {
 330                 /* When we’re already in stacking mode, nothing has to be done */
 331                 if ((mode == MODE_STACK && container->mode == MODE_STACK) ||
 332                     (mode == MODE_TABBED && container->mode == MODE_TABBED))
 333                         return;
 334
 335                 if (container->mode == MODE_STACK || container->mode == MODE_TABBED)
 336                         goto after_stackwin;
 337
 338                 /* When entering stacking mode, we need to open a window on
 339                  * which we can draw the title bars of the clients, it has
 340                  * height 1 because we don’t bother here with calculating the
 341                  * correct height - it will be adjusted when rendering anyways.
 342                  * Also, we need to use max(width, 1) because windows cannot
 343                  * be created with either width == 0 or height == 0. */
 344                 Rect rect = {container->x, container->y, max(container->width, 1), 1};
 345
 346                 uint32_t mask = 0;
 347                 uint32_t values[2];
 348
 349                 /* Don’t generate events for our new window, it should *not* be managed */
 350                 mask |= XCB_CW_OVERRIDE_REDIRECT;
 351                 values[0] = 1;
 352
 353                 /* We want to know when… */
 354                 mask |= XCB_CW_EVENT_MASK;
 355                 values[1] =     XCB_EVENT_MASK_ENTER_WINDOW |   /* …mouse is moved into our window */
 356                                 XCB_EVENT_MASK_BUTTON_PRESS |   /* …mouse is pressed */
 357                                 XCB_EVENT_MASK_EXPOSURE;        /* …our window needs to be redrawn */
 358
 359                 struct Stack_Window *stack_win = &(container->stack_win);
 360                 stack_win->window = create_window(conn, rect, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_CURSOR_LEFT_PTR, false, mask, values);
 361
 362                 stack_win->rect.height = 0;
 363
 364                 /* Initialize the entry for our cached pixmap. It will be
 365                  * created as soon as it’s needed (see cached_pixmap_prepare). */
 366                 memset(&(stack_win->pixmap), 0, sizeof(struct Cached_Pixmap));
 367                 stack_win->pixmap.referred_rect = &stack_win->rect;
 368                 stack_win->pixmap.referred_drawable = stack_win->window;
 369
 370                 stack_win->container = container;
 371
 372                 SLIST_INSERT_HEAD(&stack_wins, stack_win, stack_windows);
 373         } else {
 374                 if (container->mode == MODE_STACK || container->mode == MODE_TABBED)
 375                         leave_stack_mode(conn, container);
 376         }
 377 after_stackwin:
 378         container->mode = mode;
 379
 380         /* Force reconfiguration of each client */
 381         Client *client;
 382
 383         CIRCLEQ_FOREACH(client, &(container->clients), clients)
 384                 client->force_reconfigure = true;
 385
 386         render_layout(conn);
 387
 388         if (container->currently_focused != NULL) {
 389                 /* We need to make sure that this client is above *each* of the
 390                  * other clients in this container */
 391                 Client *last_focused = get_last_focused_client(conn, container, container->currently_focused);
 392
 393                 CIRCLEQ_FOREACH(client, &(container->clients), clients) {
 394                         if (client == container->currently_focused || client == last_focused)
 395                                 continue;
 396
 397                         DLOG("setting %08x below %08x / %08x\n", client->frame, container->currently_focused->frame);
 398                         uint32_t values[] = { container->currently_focused->frame, XCB_STACK_MODE_BELOW };
 399                         xcb_configure_window(conn, client->frame,
 400                                              XCB_CONFIG_WINDOW_SIBLING | XCB_CONFIG_WINDOW_STACK_MODE, values);
 401                 }
 402
 403                 if (last_focused != NULL) {
 404                         DLOG("Putting last_focused directly underneath the currently focused\n");
 405                         uint32_t values[] = { container->currently_focused->frame, XCB_STACK_MODE_BELOW };
 406                         xcb_configure_window(conn, last_focused->frame,
 407                                              XCB_CONFIG_WINDOW_SIBLING | XCB_CONFIG_WINDOW_STACK_MODE, values);
 408                 }
 409
 410
 411                 set_focus(conn, container->currently_focused, true);
 412         }
 413 }
 414
 415 /*
 416  * Gets the first matching client for the given window class/window title.
 417  * If the paramater specific is set to a specific client, only this one
 418  * will be checked.
 419  *
 420  */
 421 Client *get_matching_client(xcb_connection_t *conn, const char *window_classtitle,
 422                             Client *specific) {
 423         char *to_class, *to_title, *to_title_ucs = NULL;
 424         int to_title_ucs_len = 0;
 425         Client *matching = NULL;
 426
 427         to_class = sstrdup(window_classtitle);
 428
 429         /* If a title was specified, split both strings at the slash */
 430         if ((to_title = strstr(to_class, "/")) != NULL) {
 431                 *(to_title++) = '\0';
 432                 /* Convert to UCS-2 */
 433                 to_title_ucs = convert_utf8_to_ucs2(to_title, &to_title_ucs_len);
 434         }
 435
 436         /* If we were given a specific client we only check if that one matches */
 437         if (specific != NULL) {
 438                 if (client_matches_class_name(specific, to_class, to_title, to_title_ucs, to_title_ucs_len))
 439                         matching = specific;
 440                 goto done;
 441         }
 442
 443         DLOG("Getting clients for class \"%s\" / title \"%s\"\n", to_class, to_title);
 444         Workspace *ws;
 445         TAILQ_FOREACH(ws, workspaces, workspaces) {
 446                 if (ws->screen == NULL)
 447                         continue;
 448
 449                 Client *client;
 450                 SLIST_FOREACH(client, &(ws->focus_stack), focus_clients) {
 451                         DLOG("Checking client with class=%s, name=%s\n", client->window_class, client->name);
 452                         if (!client_matches_class_name(client, to_class, to_title, to_title_ucs, to_title_ucs_len))
 453                                 continue;
 454
 455                         matching = client;
 456                         goto done;
 457                 }
 458         }
 459
 460 done:
 461         free(to_class);
 462         FREE(to_title_ucs);
 463         return matching;
 464 }
 465
 466 #if defined(__OpenBSD__)
 467
 468 /*
 469  * Taken from FreeBSD
 470  * Find the first occurrence of the byte string s in byte string l.
 471  *
 472  */
 473 void *memmem(const void *l, size_t l_len, const void *s, size_t s_len) {
 474         register char *cur, *last;
 475         const char *cl = (const char *)l;
 476         const char *cs = (const char *)s;
 477
 478         /* we need something to compare */
 479         if (l_len == 0 || s_len == 0)
 480                 return NULL;
 481
 482         /* "s" must be smaller or equal to "l" */
 483         if (l_len < s_len)
 484                 return NULL;
 485
 486         /* special case where s_len == 1 */
 487         if (s_len == 1)
 488                 return memchr(l, (int)*cs, l_len);
 489
 490         /* the last position where its possible to find "s" in "l" */
 491         last = (char *)cl + l_len - s_len;
 492
 493         for (cur = (char *)cl; cur <= last; cur++)
 494                 if (cur[0] == cs[0] && memcmp(cur, cs, s_len) == 0)
 495                         return cur;
 496
 497         return NULL;
 498 }
 499
 500 #endif
 501