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

   1 /*
   2  * vim:ts=8:expandtab
   3  *
   4  * i3 - an improved dynamic tiling window manager
   5  *
   6  * © 2009-2010 Michael Stapelberg and contributors
   7  *
   8  * See file LICENSE for license information.
   9  *
  10  * For more information on RandR, please see the X.org RandR specification at
  11  * http://cgit.freedesktop.org/xorg/proto/randrproto/tree/randrproto.txt
  12  * (take your time to read it completely, it answers all questions).
  13  *
  14  */
  15 #include <stdio.h>
  16 #include <stdlib.h>
  17 #include <string.h>
  18 #include <stdbool.h>
  19 #include <assert.h>
  20 #include <time.h>
  21 #include <unistd.h>
  22
  23 #include <xcb/xcb.h>
  24 #include <xcb/randr.h>
  25
  26 #include "queue.h"
  27 #include "i3.h"
  28 #include "data.h"
  29 #include "table.h"
  30 #include "util.h"
  31 #include "layout.h"
  32 #include "xcb.h"
  33 #include "config.h"
  34 #include "workspace.h"
  35 #include "log.h"
  36 #include "ewmh.h"
  37
  38 /* While a clean namespace is usually a pretty good thing, we really need
  39  * to use shorter names than the whole xcb_randr_* default names. */
  40 typedef xcb_randr_get_crtc_info_reply_t crtc_info;
  41 typedef xcb_randr_mode_info_t mode_info;
  42 typedef xcb_randr_get_screen_resources_current_reply_t resources_reply;
  43
  44 /* Stores all outputs available in your current session. */
  45 struct outputs_head outputs = TAILQ_HEAD_INITIALIZER(outputs);
  46
  47 /*
  48  * Returns true if both screen objects describe the same screen (checks their
  49  * size and position).
  50  *
  51  */
  52 bool screens_are_equal(Output *screen1, Output *screen2) {
  53         /* If one of both objects (or both) are NULL, we cannot compare them */
  54         if (screen1 == NULL || screen2 == NULL)
  55                 return false;
  56
  57         /* If the pointers are equal, take the short-circuit */
  58         if (screen1 == screen2)
  59                 return true;
  60
  61         /* Compare their size and position - other properties are not relevant
  62          * to determine if a screen is equal to another one */
  63         return (memcmp(&(screen1->rect), &(screen2->rect), sizeof(Rect)) == 0);
  64 }
  65
  66 /*
  67  * Get a specific output by its internal X11 id. Used by randr_query_screens
  68  * to check if the output is new (only in the first scan) or if we are
  69  * re-scanning.
  70  *
  71  */
  72 static Output *get_output_by_id(xcb_randr_output_t id) {
  73         Output *screen;
  74         TAILQ_FOREACH(screen, &outputs, outputs)
  75                 if (screen->id == id)
  76                         return screen;
  77
  78         return NULL;
  79 }
  80
  81 /*
  82  * Returns the first output which is active.
  83  *
  84  */
  85 Output *get_first_output() {
  86         Output *screen;
  87
  88         TAILQ_FOREACH(screen, &outputs, outputs) {
  89                 if (screen->active)
  90                         return screen;
  91         }
  92
  93         return NULL;
  94 }
  95
  96 /*
  97  * Looks in virtual_screens for the Output which contains coordinates x, y
  98  *
  99  */
 100 Output *get_screen_containing(int x, int y) {
 101         Output *screen;
 102         TAILQ_FOREACH(screen, &outputs, outputs) {
 103                 if (!screen->active)
 104                         continue;
 105                 DLOG("comparing x=%d y=%d with x=%d and y=%d width %d height %d\n",
 106                                 x, y, screen->rect.x, screen->rect.y, screen->rect.width, screen->rect.height);
 107                 if (x >= screen->rect.x && x < (screen->rect.x + screen->rect.width) &&
 108                     y >= screen->rect.y && y < (screen->rect.y + screen->rect.height))
 109                         return screen;
 110         }
 111
 112         return NULL;
 113 }
 114
 115 /*
 116  * Gets the screen which is the last one in the given direction, for example the screen
 117  * on the most bottom when direction == D_DOWN, the screen most right when direction == D_RIGHT
 118  * and so on.
 119  *
 120  * This function always returns a screen.
 121  *
 122  */
 123 Output *get_screen_most(direction_t direction, Output *current) {
 124         Output *screen, *candidate = NULL;
 125         int position = 0;
 126         TAILQ_FOREACH(screen, &outputs, outputs) {
 127                 /* Repeated calls of WIN determine the winner of the comparison */
 128                 #define WIN(variable, condition) \
 129                         if (variable condition) { \
 130                                 candidate = screen; \
 131                                 position = variable; \
 132                         } \
 133                         break;
 134
 135                 if (((direction == D_UP) || (direction == D_DOWN)) &&
 136                     (current->rect.x != screen->rect.x))
 137                         continue;
 138
 139                 if (((direction == D_LEFT) || (direction == D_RIGHT)) &&
 140                     (current->rect.y != screen->rect.y))
 141                         continue;
 142
 143                 switch (direction) {
 144                         case D_UP:
 145                                 WIN(screen->rect.y, <= position);
 146                         case D_DOWN:
 147                                 WIN(screen->rect.y, >= position);
 148                         case D_LEFT:
 149                                 WIN(screen->rect.x, <= position);
 150                         case D_RIGHT:
 151                                 WIN(screen->rect.x, >= position);
 152                 }
 153         }
 154
 155         assert(candidate != NULL);
 156
 157         return candidate;
 158 }
 159
 160 static void initialize_output(xcb_connection_t *conn, Output *output,
 161                               Workspace *workspace) {
 162         i3Font *font = load_font(conn, config.font);
 163
 164         workspace->output = output;
 165         output->current_workspace = workspace;
 166
 167         /* Create a xoutput for each output */
 168         Rect bar_rect = {output->rect.x,
 169                          output->rect.y + output->rect.height - (font->height + 6),
 170                          output->rect.x + output->rect.width,
 171                          font->height + 6};
 172         uint32_t mask = XCB_CW_OVERRIDE_REDIRECT | XCB_CW_EVENT_MASK;
 173         uint32_t values[] = {1, XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_BUTTON_PRESS};
 174         output->bar = create_window(conn, bar_rect, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_CURSOR_LEFT_PTR, true, mask, values);
 175         output->bargc = xcb_generate_id(conn);
 176         xcb_create_gc(conn, output->bargc, output->bar, 0, 0);
 177
 178         SLIST_INIT(&(output->dock_clients));
 179
 180         DLOG("initialized output at (%d, %d) with %d x %d\n",
 181                         output->rect.x, output->rect.y, output->rect.width, output->rect.height);
 182 }
 183
 184 /*
 185  * Fills virtual_screens with exactly one screen with width/height of the
 186  * whole X screen.
 187  *
 188  */
 189 static void disable_randr(xcb_connection_t *conn) {
 190         xcb_screen_t *root_screen = xcb_setup_roots_iterator(xcb_get_setup(conn)).data;
 191
 192         DLOG("RandR extension not found, disabling.\n");
 193
 194         Output *s = scalloc(sizeof(Output));
 195
 196         s->active = true;
 197         s->rect.x = 0;
 198         s->rect.y = 0;
 199         s->rect.width = root_screen->width_in_pixels;
 200         s->rect.height = root_screen->height_in_pixels;
 201
 202         TAILQ_INSERT_TAIL(&outputs, s, outputs);
 203 }
 204
 205 /*
 206  * Searches for a mode in the current RandR configuration by the mode id.
 207  * Returns NULL if no such mode could be found (should never happen).
 208  *
 209  */
 210 static mode_info *get_mode_by_id(resources_reply *reply, xcb_randr_mode_t mode) {
 211         xcb_randr_mode_info_iterator_t it;
 212
 213         for (it = xcb_randr_get_screen_resources_current_modes_iterator(reply);
 214                 it.rem > 0;
 215                 xcb_randr_mode_info_next(&it)) {
 216                 if (it.data->id == mode)
 217                         return it.data;
 218         }
 219
 220         return NULL;
 221 }
 222
 223 /*
 224  * This function needs to be called when changing the mode of an output when
 225  * it already has some workspaces (or a bar window) assigned.
 226  *
 227  * It reconfigures the bar window for the new mode, copies the new rect into
 228  * each workspace on this output and forces all windows on the affected
 229  * workspaces to be reconfigured.
 230  *
 231  * It is necessary to call render_layout() afterwards.
 232  *
 233  */
 234 static void output_change_mode(xcb_connection_t *conn, Output *output) {
 235         i3Font *font = load_font(conn, config.font);
 236         Workspace *ws;
 237         Client *client;
 238
 239         DLOG("Output mode changed, reconfiguring bar, updating workspaces\n");
 240         Rect bar_rect = {output->rect.x,
 241                          output->rect.y + output->rect.height - (font->height + 6),
 242                          output->rect.x + output->rect.width,
 243                          font->height + 6};
 244
 245         xcb_set_window_rect(conn, output->bar, bar_rect);
 246
 247         /* go through all workspaces and set force_reconfigure */
 248         TAILQ_FOREACH(ws, workspaces, workspaces) {
 249                 if (ws->output != output)
 250                         continue;
 251
 252                 /* Update dimensions from output */
 253                 memcpy(&(ws->rect), &(ws->output->rect), sizeof(Rect));
 254
 255                 SLIST_FOREACH(client, &(ws->focus_stack), focus_clients)
 256                         client->force_reconfigure = true;
 257         }
 258 }
 259
 260 /*
 261  * Gets called by randr_query_screens() for each output. The function adds new
 262  * outputs to the list of outputs, checks if the mode of existing outputs has
 263  * been changed or if an existing output has been disabled.
 264  *
 265  */
 266 static void handle_output(xcb_connection_t *conn, xcb_randr_output_t id,
 267                           xcb_randr_get_output_info_reply_t *output,
 268                           xcb_timestamp_t cts, resources_reply *res) {
 269         Workspace *ws;
 270
 271         /* each CRT controller has a position in which we are interested in */
 272         crtc_info *crtc;
 273
 274         /* the CRTC runs in a specific mode, while the position is stored in
 275          * the output itself */
 276         mode_info *mode;
 277
 278         Output *new = get_output_by_id(id);
 279         bool existing = (new != NULL);
 280         if (!existing)
 281                 new = scalloc(sizeof(Output));
 282         new->id = id;
 283         asprintf(&new->name, "%.*s",
 284                         xcb_randr_get_output_info_name_length(output),
 285                         xcb_randr_get_output_info_name(output));
 286
 287         DLOG("found output with name %s\n", new->name);
 288
 289         /* Even if no CRTC is used at the moment, we store the output so that
 290          * we do not need to change the list ever again (we only update the
 291          * position/size) */
 292         if (output->crtc == XCB_NONE) {
 293                 if (!existing)
 294                         TAILQ_INSERT_TAIL(&outputs, new, outputs);
 295                 else if (new->active) {
 296                         new->active = false;
 297                         new->current_workspace = NULL;
 298                         DLOG("Output %s disabled (no CRTC)\n", new->name);
 299                         TAILQ_FOREACH(ws, workspaces, workspaces) {
 300                                 if (ws->output != new)
 301                                         continue;
 302
 303                                 workspace_assign_to(ws, get_first_output());
 304                         }
 305
 306                 }
 307                 free(output);
 308                 return;
 309         }
 310
 311         xcb_randr_get_crtc_info_cookie_t icookie;
 312         icookie = xcb_randr_get_crtc_info(conn, output->crtc, cts);
 313         if ((crtc = xcb_randr_get_crtc_info_reply(conn, icookie, NULL)) == NULL ||
 314             (mode = get_mode_by_id(res, crtc->mode)) == NULL) {
 315                 DLOG("Skipping output %s: could not get CRTC/mode (%p/%p)\n",
 316                      new->name, crtc, mode);
 317                 free(new);
 318                 free(output);
 319                 return;
 320         }
 321
 322         new->active = true;
 323         bool updated = update_if_necessary(&(new->rect.x), crtc->x) |
 324                        update_if_necessary(&(new->rect.y), crtc->y) |
 325                        update_if_necessary(&(new->rect.width), mode->width) |
 326                        update_if_necessary(&(new->rect.height), mode->height);
 327
 328         DLOG("mode: %dx%d+%d+%d\n", new->rect.width, new->rect.height,
 329                                     new->rect.x, new->rect.y);
 330
 331         /* If we don’t need to change an existing output or if the output
 332          * does not exist in the first place, the case is simple: we either
 333          * need to insert the new output or we are done. */
 334         if (!updated || !existing) {
 335                 if (!existing)
 336                         TAILQ_INSERT_TAIL(&outputs, new, outputs);
 337                 free(output);
 338                 return;
 339         }
 340
 341         output_change_mode(conn, new);
 342 }
 343
 344 /*
 345  * (Re-)queries the outputs via RandR and stores them in the list of outputs.
 346  *
 347  */
 348 void randr_query_screens(xcb_connection_t *conn) {
 349         xcb_randr_get_screen_resources_current_cookie_t rcookie;
 350         resources_reply *res;
 351         /* timestamp of the configuration so that we get consistent replies to all
 352          * requests (if the configuration changes between our different calls) */
 353         xcb_timestamp_t cts;
 354
 355         /* an output is VGA-1, LVDS-1, etc. (usually physical video outputs) */
 356         xcb_randr_output_t *randr_outputs;
 357
 358         /* Get screen resources (crtcs, outputs, modes) */
 359         rcookie = xcb_randr_get_screen_resources_current(conn, root);
 360         if ((res = xcb_randr_get_screen_resources_current_reply(conn, rcookie, NULL)) == NULL)
 361                 die("Could not get RandR screen resources\n");
 362         cts = res->config_timestamp;
 363
 364         int len = xcb_randr_get_screen_resources_current_outputs_length(res);
 365         randr_outputs = xcb_randr_get_screen_resources_current_outputs(res);
 366
 367         /* Request information for each output */
 368         xcb_randr_get_output_info_cookie_t ocookie[len];
 369         for (int i = 0; i < len; i++)
 370                 ocookie[i] = xcb_randr_get_output_info(conn, randr_outputs[i], cts);
 371
 372         /* Loop through all outputs available for this X11 screen */
 373         xcb_randr_get_output_info_reply_t *output;
 374         for (int i = 0; i < len; i++) {
 375                 if ((output = xcb_randr_get_output_info_reply(conn, ocookie[i], NULL)) == NULL)
 376                         continue;
 377
 378                 handle_output(conn, randr_outputs[i], output, cts, res);
 379         }
 380
 381         free(res);
 382         Output *screen, *oscreen;
 383         /* Check for clones and reduce the mode  to the lowest common mode */
 384         TAILQ_FOREACH(screen, &outputs, outputs) {
 385                 if (!screen->active)
 386                         continue;
 387                 DLOG("screen %p, position (%d, %d), checking for clones\n",
 388                         screen, screen->rect.x, screen->rect.y);
 389
 390                 TAILQ_FOREACH(oscreen, &outputs, outputs) {
 391                         if (oscreen == screen || !oscreen->active)
 392                                 continue;
 393
 394                         if (oscreen->rect.x != screen->rect.x ||
 395                             oscreen->rect.y != screen->rect.y)
 396                                 continue;
 397
 398                         DLOG("screen %p has the same position, his mode = %d x %d\n",
 399                                         oscreen, oscreen->rect.width, oscreen->rect.height);
 400                         uint32_t width = min(oscreen->rect.width, screen->rect.width);
 401                         uint32_t height = min(oscreen->rect.height, screen->rect.height);
 402
 403                         if (update_if_necessary(&(screen->rect.width), width) |
 404                             update_if_necessary(&(screen->rect.height), height))
 405                                 output_change_mode(conn, screen);
 406
 407                         if (update_if_necessary(&(oscreen->rect.width), width) |
 408                             update_if_necessary(&(oscreen->rect.height), height))
 409                                 output_change_mode(conn, oscreen);
 410
 411
 412                         DLOG("new screen mode %d x %d, oscreen mode %d x %d\n",
 413                                         screen->rect.width, screen->rect.height,
 414                                         oscreen->rect.width, oscreen->rect.height);
 415                 }
 416         }
 417
 418         ewmh_update_workarea();
 419
 420         /* Just go through each workspace and associate as many screens as we can. */
 421         TAILQ_FOREACH(screen, &outputs, outputs) {
 422                 if (!screen->active || screen->current_workspace != NULL)
 423                         continue;
 424                 Workspace *ws = get_first_workspace_for_screen(screen);
 425                 initialize_output(conn, screen, ws);
 426         }
 427
 428         /* render_layout flushes */
 429         render_layout(conn);
 430 }
 431
 432 /*
 433  * We have just established a connection to the X server and need the initial
 434  * XRandR information to setup workspaces for each screen.
 435  *
 436  */
 437 void initialize_randr(xcb_connection_t *conn, int *event_base) {
 438         const xcb_query_extension_reply_t *extreply;
 439
 440         extreply = xcb_get_extension_data(conn, &xcb_randr_id);
 441         if (!extreply->present)
 442                 disable_randr(conn);
 443         else randr_query_screens(conn);
 444
 445         if (event_base != NULL)
 446                 *event_base = extreply->first_event;
 447
 448         xcb_randr_select_input(conn, root,
 449                 XCB_RANDR_NOTIFY_MASK_SCREEN_CHANGE |
 450                 XCB_RANDR_NOTIFY_MASK_OUTPUT_CHANGE |
 451                 XCB_RANDR_NOTIFY_MASK_CRTC_CHANGE |
 452                 XCB_RANDR_NOTIFY_MASK_OUTPUT_PROPERTY);
 453
 454         xcb_flush(conn);
 455 }