Update function names, variable names and documentation for the RandR changes

diff --git a/include/randr.h b/include/randr.h
index 627afdbe9f8239f2db245ec61902567daf67e293..35e5f79bd49f1a930d9d12280316d76d49fc0055 100644 (file)
--- a/include/randr.h
+++ b/include/randr.h
@@ -28,7 +28,7 @@ void initialize_randr(xcb_connection_t *conn, int *event_base);
  * (Re-)queries the outputs via RandR and stores them in the list of outputs.
  *
  */
-void randr_query_screens(xcb_connection_t *conn);
+void randr_query_outputs(xcb_connection_t *conn);
 
 /**
  * Returns the first output which is active.
@@ -43,19 +43,20 @@ Output *get_first_output();
 Output *get_output_by_name(const char *name);
 
 /**
- * Looks in virtual_screens for the i3Screen which contains coordinates x, y
+ * Returns the active (!) output which contains the coordinates x, y or NULL
+ * if there is no output which contains these coordinates.
  *
  */
-Output *get_screen_containing(int x, int y);
+Output *get_output_containing(int x, int y);
 
 /**
- * Gets the screen which is the last one in the given direction, for example
- * the screen on the most bottom when direction == D_DOWN, the screen most
+ * Gets the output which is the last one in the given direction, for example
+ * the output on the most bottom when direction == D_DOWN, the output most
  * right when direction == D_RIGHT and so on.
  *
- * This function always returns a screen.
+ * This function always returns a output.
  *
  */
-Output *get_screen_most(direction_t direction, Output *current);
+Output *get_output_most(direction_t direction, Output *current);
 
 #endif

diff --git a/include/workspace.h b/include/workspace.h
index 1d2809831dd7801e4d170e2b9fe72d93d2369467..dae245ce036ec2060a69d3ed5e006b7e920bba37 100644 (file)
--- a/include/workspace.h
+++ b/include/workspace.h
@@ -69,7 +69,7 @@ void workspace_initialize(Workspace *ws, Output *screen, bool recheck);
  * the preferred_screen setting of every workspace (workspace assignments).
  *
  */
-Workspace *get_first_workspace_for_screen(Output *screen);
+Workspace *get_first_workspace_for_output(Output *screen);
 
 /**
  * Unmaps all clients (and stack windows) of the given workspace.

diff --git a/src/commands.c b/src/commands.c
index f4bc04be3dc83bb035cd3e8526ff39f1684ce86d..4317b36f6dd4a84aef40a7c9682cfee5b99edb5b 100644 (file)
--- a/src/commands.c
+++ b/src/commands.c
@@ -121,17 +121,17 @@ static void focus_thing(xcb_connection_t *conn, direction_t direction, thing_t t
                         bounds.y -= bounds.height;
                 else bounds.y += bounds.height;
 
-                Output *target = get_screen_containing(bounds.x, bounds.y);
+                Output *target = get_output_containing(bounds.x, bounds.y);
                 if (target == NULL) {
                         DLOG("Target output NULL\n");
                         /* Wrap around if the target screen is out of bounds */
                         if (direction == D_RIGHT)
-                                target = get_screen_most(D_LEFT, cs);
+                                target = get_output_most(D_LEFT, cs);
                         else if (direction == D_LEFT)
-                                target = get_screen_most(D_RIGHT, cs);
+                                target = get_output_most(D_RIGHT, cs);
                         else if (direction == D_UP)
-                                target = get_screen_most(D_DOWN, cs);
-                        else target = get_screen_most(D_UP, cs);
+                                target = get_output_most(D_DOWN, cs);
+                        else target = get_output_most(D_UP, cs);
                 }
 
                 DLOG("Switching to ws %d\n", target->current_workspace + 1);
@@ -165,10 +165,10 @@ static void focus_thing(xcb_connection_t *conn, direction_t direction, thing_t t
                         DLOG("container is at %d with height %d\n", container->y, container->height);
                         Output *output;
                         int destination_y = (direction == D_UP ? (container->y - 1) : (container->y + container->height + 1));
-                        if ((output = get_screen_containing(container->x, destination_y)) == NULL) {
+                        if ((output = get_output_containing(container->x, destination_y)) == NULL) {
                                 DLOG("Wrapping screen around vertically\n");
                                 /* No screen found? Then wrap */
-                                output = get_screen_most((direction == D_UP ? D_DOWN : D_UP), container->workspace->output);
+                                output = get_output_most((direction == D_UP ? D_DOWN : D_UP), container->workspace->output);
                         }
                         t_ws = output->current_workspace;
                         new_row = (direction == D_UP ? (t_ws->rows - 1) : 0);
@@ -208,9 +208,9 @@ static void focus_thing(xcb_connection_t *conn, direction_t direction, thing_t t
                         DLOG("container is at %d with width %d\n", container->x, container->width);
                         Output *output;
                         int destination_x = (direction == D_LEFT ? (container->x - 1) : (container->x + container->width + 1));
-                        if ((output = get_screen_containing(destination_x, container->y)) == NULL) {
+                        if ((output = get_output_containing(destination_x, container->y)) == NULL) {
                                 DLOG("Wrapping screen around horizontally\n");
-                                output = get_screen_most((direction == D_LEFT ? D_RIGHT : D_LEFT), container->workspace->output);
+                                output = get_output_most((direction == D_LEFT ? D_RIGHT : D_LEFT), container->workspace->output);
                         }
                         t_ws = output->current_workspace;
                         new_col = (direction == D_LEFT ? (t_ws->cols - 1) : 0);

diff --git a/src/handlers.c b/src/handlers.c
index da5697c1c314882338b7166d1d9298f2c6864a43..9c9f16f0836bb92b821603a9648c8eb50f35df03 100644 (file)
--- a/src/handlers.c
+++ b/src/handlers.c
@@ -166,7 +166,7 @@ int handle_key_press(void *ignored, xcb_connection_t *conn, xcb_key_press_event_
 static void check_crossing_screen_boundary(uint32_t x, uint32_t y) {
         Output *output;
 
-        if ((output = get_screen_containing(x, y)) == NULL) {
+        if ((output = get_output_containing(x, y)) == NULL) {
                 ELOG("ERROR: No such screen\n");
                 return;
         }
@@ -457,7 +457,7 @@ int handle_screen_change(void *prophs, xcb_connection_t *conn,
                          xcb_generic_event_t *e) {
         DLOG("RandR screen change\n");
 
-        randr_query_screens(conn);
+        randr_query_outputs(conn);
 
         return 1;
 }

diff --git a/src/layout.c b/src/layout.c
index 0e1eecb176f33a2ede6b4a7c35732661b47ec0d7..31ee404e3ffbccb34abd43a80b3b61b67d8dccc2 100644 (file)
--- a/src/layout.c
+++ b/src/layout.c
@@ -215,7 +215,7 @@ void reposition_client(xcb_connection_t *conn, Client *client) {
                 return;
 
         /* If the client is floating, we need to check if we moved it to a different workspace */
-        output = get_screen_containing(client->rect.x + (client->rect.width / 2),
+        output = get_output_containing(client->rect.x + (client->rect.width / 2),
                                        client->rect.y + (client->rect.height / 2));
         if (client->workspace->output == output)
                 return;

diff --git a/src/mainx.c b/src/mainx.c
index 00ecd43251ab724e6b595609530de351bcd82107..23fd757fd9de63238a2858e1394909a627a11506 100644 (file)
--- a/src/mainx.c
+++ b/src/mainx.c
@@ -478,7 +478,7 @@ int main(int argc, char *argv[], char *env[]) {
                 return 1;
         }
 
-        Output *screen = get_screen_containing(reply->root_x, reply->root_y);
+        Output *screen = get_output_containing(reply->root_x, reply->root_y);
         if (screen == NULL) {
                 ELOG("ERROR: No screen at %d x %d, starting on the first screen\n",
                     reply->root_x, reply->root_y);

diff --git a/src/randr.c b/src/randr.c
index 2d890efc14b6807b6ab5106ff790474266e5eb0d..1d440c2a9a5eb7ceac152b407eb6b28cb85b865d 100644 (file)
--- a/src/randr.c
+++ b/src/randr.c
@@ -44,8 +44,10 @@ typedef xcb_randr_get_screen_resources_current_reply_t resources_reply;
 /* Stores all outputs available in your current session. */
 struct outputs_head outputs = TAILQ_HEAD_INITIALIZER(outputs);
 
+static bool randr_disabled = false;
+
 /*
- * Get a specific output by its internal X11 id. Used by randr_query_screens
+ * Get a specific output by its internal X11 id. Used by randr_query_outputs
  * to check if the output is new (only in the first scan) or if we are
  * re-scanning.
  *
@@ -78,75 +80,75 @@ Output *get_output_by_name(const char *name) {
  *
  */
 Output *get_first_output() {
-        Output *screen;
+        Output *output;
 
-        TAILQ_FOREACH(screen, &outputs, outputs) {
-                if (screen->active)
-                        return screen;
-        }
+        TAILQ_FOREACH(output, &outputs, outputs)
+                if (output->active)
+                        return output;
 
         return NULL;
 }
 
 /*
- * Looks in virtual_screens for the Output which contains coordinates x, y
+ * Returns the active (!) output which contains the coordinates x, y or NULL
+ * if there is no output which contains these coordinates.
  *
  */
-Output *get_screen_containing(int x, int y) {
-        Output *screen;
-        TAILQ_FOREACH(screen, &outputs, outputs) {
-                if (!screen->active)
+Output *get_output_containing(int x, int y) {
+        Output *output;
+        TAILQ_FOREACH(output, &outputs, outputs) {
+                if (!output->active)
                         continue;
                 DLOG("comparing x=%d y=%d with x=%d and y=%d width %d height %d\n",
-                                x, y, screen->rect.x, screen->rect.y, screen->rect.width, screen->rect.height);
-                if (x >= screen->rect.x && x < (screen->rect.x + screen->rect.width) &&
-                    y >= screen->rect.y && y < (screen->rect.y + screen->rect.height))
-                        return screen;
+                                x, y, output->rect.x, output->rect.y, output->rect.width, output->rect.height);
+                if (x >= output->rect.x && x < (output->rect.x + output->rect.width) &&
+                    y >= output->rect.y && y < (output->rect.y + output->rect.height))
+                        return output;
         }
 
         return NULL;
 }
 
 /*
- * Gets the screen which is the last one in the given direction, for example the screen
- * on the most bottom when direction == D_DOWN, the screen most right when direction == D_RIGHT
- * and so on.
+ * Gets the output which is the last one in the given direction, for example
+ * the output on the most bottom when direction == D_DOWN, the output most
+ * right when direction == D_RIGHT and so on.
  *
- * This function always returns a screen.
+ * This function always returns a output.
  *
  */
-Output *get_screen_most(direction_t direction, Output *current) {
-        Output *screen, *candidate = NULL;
+Output *get_output_most(direction_t direction, Output *current) {
+        Output *output, *candidate = NULL;
         int position = 0;
-        TAILQ_FOREACH(screen, &outputs, outputs) {
-                if (!screen->active)
+        TAILQ_FOREACH(output, &outputs, outputs) {
+                if (!output->active)
                         continue;
 
                 /* Repeated calls of WIN determine the winner of the comparison */
                 #define WIN(variable, condition) \
                         if (variable condition) { \
-                                candidate = screen; \
+                                candidate = output; \
                                 position = variable; \
                         } \
                         break;
 
                 if (((direction == D_UP) || (direction == D_DOWN)) &&
-                    (current->rect.x != screen->rect.x))
+                    (current->rect.x != output->rect.x))
                         continue;
 
                 if (((direction == D_LEFT) || (direction == D_RIGHT)) &&
-                    (current->rect.y != screen->rect.y))
+                    (current->rect.y != output->rect.y))
                         continue;
 
                 switch (direction) {
                         case D_UP:
-                                WIN(screen->rect.y, <= position);
+                                WIN(output->rect.y, <= position);
                         case D_DOWN:
-                                WIN(screen->rect.y, >= position);
+                                WIN(output->rect.y, >= position);
                         case D_LEFT:
-                                WIN(screen->rect.x, <= position);
+                                WIN(output->rect.x, <= position);
                         case D_RIGHT:
-                                WIN(screen->rect.x, >= position);
+                                WIN(output->rect.x, >= position);
                 }
         }
 
@@ -186,14 +188,14 @@ static void initialize_output(xcb_connection_t *conn, Output *output,
 }
 
 /*
- * Fills virtual_screens with exactly one screen with width/height of the
- * whole X screen.
+ * Disables RandR support by creating exactly one output with the size of the
+ * X11 screen.
  *
  */
 static void disable_randr(xcb_connection_t *conn) {
         xcb_screen_t *root_screen = xcb_setup_roots_iterator(xcb_get_setup(conn)).data;
 
-        DLOG("RandR extension not found, disabling.\n");
+        DLOG("RandR extension unusable, disabling.\n");
 
         Output *s = scalloc(sizeof(Output));
 
@@ -204,6 +206,8 @@ static void disable_randr(xcb_connection_t *conn) {
         s->rect.height = root_screen->height_in_pixels;
 
         TAILQ_INSERT_TAIL(&outputs, s, outputs);
+
+        randr_disabled = true;
 }
 
 /*
@@ -274,7 +278,7 @@ static void output_change_mode(xcb_connection_t *conn, Output *output) {
 }
 
 /*
- * Gets called by randr_query_screens() for each output. The function adds new
+ * Gets called by randr_query_outputs() for each output. The function adds new
  * outputs to the list of outputs, checks if the mode of existing outputs has
  * been changed or if an existing output has been disabled. It will then change
  * either the "changed" or the "to_be_deleted" flag of the output, if
@@ -353,8 +357,9 @@ static void handle_output(xcb_connection_t *conn, xcb_randr_output_t id,
  * (Re-)queries the outputs via RandR and stores them in the list of outputs.
  *
  */
-void randr_query_screens(xcb_connection_t *conn) {
+void randr_query_outputs(xcb_connection_t *conn) {
         Workspace *ws;
+        Output *output, *other, *first;
         xcb_randr_get_screen_resources_current_cookie_t rcookie;
         resources_reply *res;
         /* timestamp of the configuration so that we get consistent replies to all
@@ -364,10 +369,15 @@ void randr_query_screens(xcb_connection_t *conn) {
         /* an output is VGA-1, LVDS-1, etc. (usually physical video outputs) */
         xcb_randr_output_t *randr_outputs;
 
+        if (randr_disabled)
+                return;
+
         /* Get screen resources (crtcs, outputs, modes) */
         rcookie = xcb_randr_get_screen_resources_current(conn, root);
-        if ((res = xcb_randr_get_screen_resources_current_reply(conn, rcookie, NULL)) == NULL)
-                die("Could not get RandR screen resources\n");
+        if ((res = xcb_randr_get_screen_resources_current_reply(conn, rcookie, NULL)) == NULL) {
+                disable_randr(conn);
+                return;
+        }
         cts = res->config_timestamp;
 
         int len = xcb_randr_get_screen_resources_current_outputs_length(res);
@@ -389,46 +399,47 @@ void randr_query_screens(xcb_connection_t *conn) {
         }
 
         free(res);
-        Output *screen, *oscreen;
-        /* Check for clones and reduce the mode to the lowest common mode */
-        TAILQ_FOREACH(screen, &outputs, outputs) {
-                if (!screen->active || screen->to_be_disabled)
+        /* Check for clones, disable the clones and reduce the mode to the
+         * lowest common mode */
+        TAILQ_FOREACH(output, &outputs, outputs) {
+                if (!output->active || output->to_be_disabled)
                         continue;
-                DLOG("screen %p, position (%d, %d), checking for clones\n",
-                        screen, screen->rect.x, screen->rect.y);
+                DLOG("output %p, position (%d, %d), checking for clones\n",
+                        output, output->rect.x, output->rect.y);
 
-                for (oscreen = screen;
-                     oscreen != TAILQ_END(&outputs);
-                     oscreen = TAILQ_NEXT(oscreen, outputs)) {
-                        if (oscreen == screen || !oscreen->active || oscreen->to_be_disabled)
+                for (other = output;
+                     other != TAILQ_END(&outputs);
+                     other = TAILQ_NEXT(other, outputs)) {
+                        if (other == output || !other->active || other->to_be_disabled)
                                 continue;
 
-                        if (oscreen->rect.x != screen->rect.x ||
-                            oscreen->rect.y != screen->rect.y)
+                        if (other->rect.x != output->rect.x ||
+                            other->rect.y != output->rect.y)
                                 continue;
 
-                        DLOG("screen %p has the same position, his mode = %d x %d\n",
-                                        oscreen, oscreen->rect.width, oscreen->rect.height);
-                        uint32_t width = min(oscreen->rect.width, screen->rect.width);
-                        uint32_t height = min(oscreen->rect.height, screen->rect.height);
+                        DLOG("output %p has the same position, his mode = %d x %d\n",
+                                        other, other->rect.width, other->rect.height);
+                        uint32_t width = min(other->rect.width, output->rect.width);
+                        uint32_t height = min(other->rect.height, output->rect.height);
 
-                        if (update_if_necessary(&(screen->rect.width), width) |
-                            update_if_necessary(&(screen->rect.height), height))
-                                screen->changed = true;
+                        if (update_if_necessary(&(output->rect.width), width) |
+                            update_if_necessary(&(output->rect.height), height))
+                                output->changed = true;
 
-                        update_if_necessary(&(oscreen->rect.width), width);
-                        update_if_necessary(&(oscreen->rect.height), height);
+                        update_if_necessary(&(other->rect.width), width);
+                        update_if_necessary(&(other->rect.height), height);
 
-                        DLOG("disabling screen %p (%s)\n", oscreen, oscreen->name);
-                        oscreen->to_be_disabled = true;
+                        DLOG("disabling output %p (%s)\n", other, other->name);
+                        other->to_be_disabled = true;
 
-                        DLOG("new screen mode %d x %d, oscreen mode %d x %d\n",
-                                        screen->rect.width, screen->rect.height,
-                                        oscreen->rect.width, oscreen->rect.height);
+                        DLOG("new output mode %d x %d, other mode %d x %d\n",
+                                        output->rect.width, output->rect.height,
+                                        other->rect.width, other->rect.height);
                 }
         }
 
-        Output *output, *first;
+        /* Handle outputs which have a new mode or are disabled now (either
+         * because the user disabled them or because they are clones) */
         TAILQ_FOREACH(output, &outputs, outputs) {
                 if (output->to_be_disabled) {
                         output->active = false;
@@ -467,11 +478,11 @@ void randr_query_screens(xcb_connection_t *conn) {
         ewmh_update_workarea();
 
         /* Just go through each active output and associate one workspace */
-        TAILQ_FOREACH(screen, &outputs, outputs) {
-                if (!screen->active || screen->current_workspace != NULL)
+        TAILQ_FOREACH(output, &outputs, outputs) {
+                if (!output->active || output->current_workspace != NULL)
                         continue;
-                ws = get_first_workspace_for_screen(screen);
-                initialize_output(conn, screen, ws);
+                ws = get_first_workspace_for_output(output);
+                initialize_output(conn, output, ws);
         }
 
         /* render_layout flushes */
@@ -489,7 +500,7 @@ void initialize_randr(xcb_connection_t *conn, int *event_base) {
         extreply = xcb_get_extension_data(conn, &xcb_randr_id);
         if (!extreply->present)
                 disable_randr(conn);
-        else randr_query_screens(conn);
+        else randr_query_outputs(conn);
 
         if (event_base != NULL)
                 *event_base = extreply->first_event;

diff --git a/src/resize.c b/src/resize.c
index 7b1f7bd825d5da5c316a11e8587841fc9c2734b7..4dd0352338bbdafba24381aba1cbd55fc9cc769c 100644 (file)
--- a/src/resize.c
+++ b/src/resize.c
@@ -3,7 +3,7 @@
  *
  * i3 - an improved dynamic tiling window manager
  *
- * © 2009 Michael Stapelberg and contributors
+ * © 2009-2010 Michael Stapelberg and contributors
  *
  * See file LICENSE for license information.
  *
@@ -38,7 +38,7 @@
 int resize_graphical_handler(xcb_connection_t *conn, Workspace *ws, int first, int second,
                              resize_orientation_t orientation, xcb_button_press_event_t *event) {
         int new_position;
-        struct xoutput *screen = get_screen_containing(event->root_x, event->root_y);
+        struct xoutput *screen = get_output_containing(event->root_x, event->root_y);
         if (screen == NULL) {
                 ELOG("BUG: No screen found at this position (%d, %d)\n", event->root_x, event->root_y);
                 return 1;
@@ -49,8 +49,8 @@ int resize_graphical_handler(xcb_connection_t *conn, Workspace *ws, int first, i
          * screens during runtime. Instead, we just use the most right and most
          * bottom Xinerama screen and use their position + width/height to get
          * the area of pixels currently in use */
-        struct xoutput *most_right = get_screen_most(D_RIGHT, screen),
-                 *most_bottom = get_screen_most(D_DOWN, screen);
+        struct xoutput *most_right = get_output_most(D_RIGHT, screen),
+                 *most_bottom = get_output_most(D_DOWN, screen);
 
         DLOG("event->event_x = %d, event->root_x = %d\n", event->event_x, event->root_x);
 

diff --git a/src/workspace.c b/src/workspace.c
index ef963a76f95cf2206ed7a62ffb8ceea7dee4853e..a17560ed6b2ad81a79b8b71b8c127f641ca0c355 100644 (file)
--- a/src/workspace.c
+++ b/src/workspace.c
@@ -277,7 +277,7 @@ void workspace_initialize(Workspace *ws, Output *output, bool recheck) {
  * the preferred_output setting of every workspace (workspace assignments).
  *
  */
-Workspace *get_first_workspace_for_screen(Output *output) {
+Workspace *get_first_workspace_for_output(Output *output) {
         Workspace *result = NULL;
 
         Workspace *ws;