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