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
  21 #include "i3.h"
  22 #include "data.h"
  23 #include "table.h"
  24 #include "layout.h"
  25 #include "util.h"
  26 #include "xcb.h"
  27
  28 int min(int a, int b) {
  29         return (a < b ? a : b);
  30 }
  31
  32 int max(int a, int b) {
  33         return (a > b ? a : b);
  34 }
  35
  36 /*
  37  * Prints the message (see printf()) to stderr, then exits the program.
  38  *
  39  */
  40 void die(char *fmt, ...) {
  41         va_list args;
  42
  43         va_start(args, fmt);
  44         vfprintf(stderr, fmt, args);
  45         va_end(args);
  46
  47         exit(EXIT_FAILURE);
  48 }
  49
  50 /*
  51  * The s* functions (safe) are wrappers around malloc, strdup, …, which exits if one of
  52  * the called functions returns NULL, meaning that there is no more memory available
  53  *
  54  */
  55 void *smalloc(size_t size) {
  56         void *result = malloc(size);
  57         exit_if_null(result, "Too less memory for malloc(%d)\n", size);
  58         return result;
  59 }
  60
  61 void *scalloc(size_t size) {
  62         void *result = calloc(size, 1);
  63         exit_if_null(result, "Too less memory for calloc(%d)\n", size);
  64         return result;
  65 }
  66
  67 char *sstrdup(const char *str) {
  68         char *result = strdup(str);
  69         exit_if_null(result, "Too less memory for strdup()\n");
  70         return result;
  71 }
  72
  73 /*
  74  * Starts the given application by passing it through a shell. We use double fork
  75  * to avoid zombie processes. As the started application’s parent exits (immediately),
  76  * the application is reparented to init (process-id 1), which correctly handles
  77  * childs, so we don’t have to do it :-).
  78  *
  79  * The shell is determined by looking for the SHELL environment variable. If it
  80  * does not exist, /bin/sh is used.
  81  *
  82  */
  83 void start_application(const char *command) {
  84         if (fork() == 0) {
  85                 /* Child process */
  86                 if (fork() == 0) {
  87                         /* Stores the path of the shell */
  88                         static const char *shell = NULL;
  89
  90                         if (shell == NULL)
  91                                 if ((shell = getenv("SHELL")) == NULL)
  92                                         shell = "/bin/sh";
  93
  94                         /* This is the child */
  95                         execl(shell, shell, "-c", command, NULL);
  96                         /* not reached */
  97                 }
  98                 exit(0);
  99         }
 100         wait(0);
 101 }
 102
 103 /*
 104  * Checks a generic cookie for errors and quits with the given message if there
 105  * was an error.
 106  *
 107  */
 108 void check_error(xcb_connection_t *connection, xcb_void_cookie_t cookie, char *err_message) {
 109         xcb_generic_error_t *error = xcb_request_check(connection, cookie);
 110         if (error != NULL) {
 111                 fprintf(stderr, "ERROR: %s : %d\n", err_message , error->error_code);
 112                 xcb_disconnect(connection);
 113                 exit(-1);
 114         }
 115 }
 116
 117 /*
 118  * Sets the given client as focused by updating the data structures correctly,
 119  * updating the X input focus and finally re-decorating both windows (to signalize
 120  * the user the new focus situation)
 121  *
 122  */
 123 void set_focus(xcb_connection_t *conn, Client *client) {
 124         /* The dock window cannot be focused */
 125         /* TODO: does this play well with dzen2’s popup menus? or do we just need to set the input
 126            focus but not update our internal structures? */
 127         if (client->dock)
 128                 return;
 129
 130         /* TODO: check if the focus needs to be changed at all */
 131         /* Store current_row/current_col */
 132         c_ws->current_row = current_row;
 133         c_ws->current_col = current_col;
 134         c_ws = client->container->workspace;
 135
 136         /* Update container */
 137         Client *old_client = client->container->currently_focused;
 138         client->container->currently_focused = client;
 139
 140         current_col = client->container->col;
 141         current_row = client->container->row;
 142
 143         printf("set_focus(frame %08x, child %08x)\n", client->frame, client->child);
 144         /* Set focus to the entered window, and flush xcb buffer immediately */
 145         xcb_set_input_focus(conn, XCB_INPUT_FOCUS_POINTER_ROOT, client->child, XCB_CURRENT_TIME);
 146         //xcb_warp_pointer(conn, XCB_NONE, client->child, 0, 0, 0, 0, 10, 10);
 147
 148         /* If we’re in stacking mode, we render the container to update changes in the title
 149            bars and to raise the focused client */
 150         if (client->container->mode == MODE_STACK)
 151                 render_container(conn, client->container);
 152         else {
 153                 /* Update last/current client’s titlebar */
 154                 if (old_client != NULL)
 155                         decorate_window(conn, old_client, old_client->frame, old_client->titlegc, 0);
 156                 decorate_window(conn, client, client->frame, client->titlegc, 0);
 157         }
 158
 159         xcb_flush(conn);
 160 }
 161
 162 /*
 163  * Switches the layout of the given container taking care of the necessary house-keeping
 164  *
 165  */
 166 void switch_layout_mode(xcb_connection_t *conn, Container *container, int mode) {
 167         if (mode == MODE_STACK) {
 168                 /* When we’re already in stacking mode, nothing has to be done */
 169                 if (container->mode == MODE_STACK)
 170                         return;
 171
 172                 /* When entering stacking mode, we need to open a window on which we can draw the
 173                    title bars of the clients, it has height 1 because we don’t bother here with
 174                    calculating the correct height - it will be adjusted when rendering anyways. */
 175                 Rect rect = {container->x, container->y, container->width, 1 };
 176
 177                 uint32_t mask = 0;
 178                 uint32_t values[2];
 179
 180                 /* Don’t generate events for our new window, it should *not* be managed */
 181                 mask |= XCB_CW_OVERRIDE_REDIRECT;
 182                 values[0] = 1;
 183
 184                 /* We want to know when… */
 185                 mask |= XCB_CW_EVENT_MASK;
 186                 values[1] =     XCB_EVENT_MASK_BUTTON_PRESS |   /* …mouse is pressed */
 187                                 XCB_EVENT_MASK_EXPOSURE;        /* …our window needs to be redrawn */
 188
 189                 struct Stack_Window *stack_win = &(container->stack_win);
 190                 stack_win->window = create_window(conn, rect, XCB_WINDOW_CLASS_INPUT_OUTPUT, mask, values);
 191
 192                 /* Generate a graphics context for the titlebar */
 193                 stack_win->gc = xcb_generate_id(conn);
 194                 xcb_create_gc(conn, stack_win->gc, stack_win->window, 0, 0);
 195
 196                 stack_win->container = container;
 197
 198                 SLIST_INSERT_HEAD(&stack_wins, stack_win, stack_windows);
 199         } else {
 200                 if (container->mode == MODE_STACK) {
 201                         /* When going out of stacking mode, we need to close the window */
 202                         struct Stack_Window *stack_win = &(container->stack_win);
 203
 204                         SLIST_REMOVE(&stack_wins, stack_win, Stack_Window, stack_windows);
 205
 206                         xcb_free_gc(conn, stack_win->gc);
 207                         xcb_destroy_window(conn, stack_win->window);
 208
 209                         stack_win->width = -1;
 210                         stack_win->height = -1;
 211                 }
 212         }
 213         container->mode = mode;
 214
 215         /* Force reconfiguration of each client */
 216         Client *client;
 217
 218         CIRCLEQ_FOREACH(client, &(container->clients), clients)
 219                 client->force_reconfigure = true;
 220
 221         render_layout(conn);
 222 }
 223
 224 /*
 225  * Warps the pointer into the given client (in the middle of it, to be specific), therefore
 226  * selecting it
 227  *
 228  */
 229 void warp_pointer_into(xcb_connection_t *connection, Client *client) {
 230         int mid_x = client->rect.width / 2,
 231             mid_y = client->rect.height / 2;
 232         xcb_warp_pointer(connection, XCB_NONE, client->child, 0, 0, 0, 0, mid_x, mid_y);
 233 }
 234
 235 /*
 236  * Toggles fullscreen mode for the given client. It updates the data structures and
 237  * reconfigures (= resizes/moves) the client and its frame to the full size of the
 238  * screen. When leaving fullscreen, re-rendering the layout is forced.
 239  *
 240  */
 241 void toggle_fullscreen(xcb_connection_t *conn, Client *client) {
 242         /* clients without a container (docks) cannot be focused */
 243         assert(client->container != NULL);
 244
 245         Workspace *workspace = client->container->workspace;
 246
 247         workspace->fullscreen_client = (client->fullscreen ? NULL : client);
 248
 249         client->fullscreen = !client->fullscreen;
 250
 251         if (client->fullscreen) {
 252                 printf("Entering fullscreen mode...\n");
 253                 /* We just entered fullscreen mode, let’s configure the window */
 254                  uint32_t mask = XCB_CONFIG_WINDOW_X |
 255                                  XCB_CONFIG_WINDOW_Y |
 256                                  XCB_CONFIG_WINDOW_WIDTH |
 257                                  XCB_CONFIG_WINDOW_HEIGHT;
 258                 uint32_t values[4] = {workspace->rect.x,
 259                                       workspace->rect.y,
 260                                       workspace->rect.width,
 261                                       workspace->rect.height};
 262
 263                 printf("child itself will be at %dx%d with size %dx%d\n",
 264                                 values[0], values[1], values[2], values[3]);
 265
 266                 xcb_configure_window(conn, client->frame, mask, values);
 267
 268                 /* Child’s coordinates are relative to the parent (=frame) */
 269                 values[0] = 0;
 270                 values[1] = 0;
 271                 xcb_configure_window(conn, client->child, mask, values);
 272
 273                 /* Raise the window */
 274                 values[0] = XCB_STACK_MODE_ABOVE;
 275                 xcb_configure_window(conn, client->frame, XCB_CONFIG_WINDOW_STACK_MODE, values);
 276
 277                 xcb_flush(conn);
 278         } else {
 279                 printf("leaving fullscreen mode\n");
 280                 /* Because the coordinates of the window haven’t changed, it would not be
 281                    re-configured if we don’t set the following flag */
 282                 client->force_reconfigure = true;
 283                 /* We left fullscreen mode, redraw the layout */
 284                 render_layout(conn);
 285         }
 286 }