From 8d648b4e371cd7959a332d80aa288a3fa390cc7e Mon Sep 17 00:00:00 2001 From: Michael Stapelberg Date: Fri, 5 Mar 2010 16:18:41 +0100 Subject: [PATCH] Update function names, variable names and documentation for the RandR changes --- include/randr.h | 15 ++--- include/workspace.h | 2 +- src/commands.c | 18 +++--- src/handlers.c | 4 +- src/layout.c | 2 +- src/mainx.c | 2 +- src/randr.c | 149 ++++++++++++++++++++++++-------------------- src/resize.c | 8 +-- src/workspace.c | 2 +- 9 files changed, 107 insertions(+), 95 deletions(-) diff --git a/include/randr.h b/include/randr.h index 627afdbe..35e5f79b 100644 --- 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 1d280983..dae245ce 100644 --- 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 f4bc04be..4317b36f 100644 --- 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 da5697c1..9c9f16f0 100644 --- 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 0e1eecb1..31ee404e 100644 --- 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 00ecd432..23fd757f 100644 --- 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 2d890efc..1d440c2a 100644 --- 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 7b1f7bd8..4dd03523 100644 --- 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 ef963a76..a17560ed 100644 --- 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; -- 2.39.5