nixo
/
gri3-wm
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

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

This commit is contained in:
Michael Stapelberg 2010-03-05 16:18:41 +01:00
parent 8b192ac7ed
commit 8d648b4e37
9 changed files with 107 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
include/randr.h
View File

@ -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. * (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. * Returns the first output which is active.
@ -43,19 +43,20 @@ Output *get_first_output();
Output *get_output_by_name(const char *name); 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 * Gets the output which is the last one in the given direction, for example
* the screen on the most bottom when direction == D_DOWN, the screen most * the output on the most bottom when direction == D_DOWN, the output most
* right when direction == D_RIGHT and so on. * 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 #endif

2
include/workspace.h
View File

@ -69,7 +69,7 @@ void workspace_initialize(Workspace *ws, Output *screen, bool recheck);
* the preferred_screen setting of every workspace (workspace assignments). * 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. * Unmaps all clients (and stack windows) of the given workspace.

18
src/commands.c
View File

@ -121,17 +121,17 @@ static void focus_thing(xcb_connection_t *conn, direction_t direction, thing_t t
bounds.y -= bounds.height; bounds.y -= bounds.height;
else 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) { if (target == NULL) {
DLOG("Target output NULL\n"); DLOG("Target output NULL\n");
/* Wrap around if the target screen is out of bounds */ /* Wrap around if the target screen is out of bounds */
if (direction == D_RIGHT) if (direction == D_RIGHT)
target = get_screen_most(D_LEFT, cs); target = get_output_most(D_LEFT, cs);
else if (direction == D_LEFT) else if (direction == D_LEFT)
target = get_screen_most(D_RIGHT, cs); target = get_output_most(D_RIGHT, cs);
else if (direction == D_UP) else if (direction == D_UP)
target = get_screen_most(D_DOWN, cs); target = get_output_most(D_DOWN, cs);
else target = get_screen_most(D_UP, cs); else target = get_output_most(D_UP, cs);
} }
DLOG("Switching to ws %d\n", target->current_workspace + 1); 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); DLOG("container is at %d with height %d\n", container->y, container->height);
Output *output; Output *output;
int destination_y = (direction == D_UP ? (container->y - 1) : (container->y + container->height + 1)); 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"); DLOG("Wrapping screen around vertically\n");
/* No screen found? Then wrap */ /* 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; t_ws = output->current_workspace;
new_row = (direction == D_UP ? (t_ws->rows - 1) : 0); 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); DLOG("container is at %d with width %d\n", container->x, container->width);
Output *output; Output *output;
int destination_x = (direction == D_LEFT ? (container->x - 1) : (container->x + container->width + 1)); 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"); 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; t_ws = output->current_workspace;
new_col = (direction == D_LEFT ? (t_ws->cols - 1) : 0); new_col = (direction == D_LEFT ? (t_ws->cols - 1) : 0);

4
src/handlers.c
View File

@ -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) { static void check_crossing_screen_boundary(uint32_t x, uint32_t y) {
Output *output; Output *output;
if ((output = get_screen_containing(x, y)) == NULL) { if ((output = get_output_containing(x, y)) == NULL) {
ELOG("ERROR: No such screen\n"); ELOG("ERROR: No such screen\n");
return; return;
} }
@ -457,7 +457,7 @@ int handle_screen_change(void *prophs, xcb_connection_t *conn,
xcb_generic_event_t *e) { xcb_generic_event_t *e) {
DLOG("RandR screen change\n"); DLOG("RandR screen change\n");
randr_query_screens(conn); randr_query_outputs(conn);
return 1; return 1;
} }

2
src/layout.c
View File

@ -215,7 +215,7 @@ void reposition_client(xcb_connection_t *conn, Client *client) {
return; return;
/* If the client is floating, we need to check if we moved it to a different workspace */ /* 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)); client->rect.y + (client->rect.height / 2));
if (client->workspace->output == output) if (client->workspace->output == output)
return; return;

2
src/mainx.c
View File

@ -478,7 +478,7 @@ int main(int argc, char *argv[], char *env[]) {
return 1; 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) { if (screen == NULL) {
ELOG("ERROR: No screen at %d x %d, starting on the first screen\n", ELOG("ERROR: No screen at %d x %d, starting on the first screen\n",
reply->root_x, reply->root_y); reply->root_x, reply->root_y);

149
src/randr.c
View File

@ -44,8 +44,10 @@ typedef xcb_randr_get_screen_resources_current_reply_t resources_reply;
/* Stores all outputs available in your current session. */ /* Stores all outputs available in your current session. */
struct outputs_head outputs = TAILQ_HEAD_INITIALIZER(outputs); 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 * to check if the output is new (only in the first scan) or if we are
* re-scanning. * re-scanning.
* *
@ -78,75 +80,75 @@ Output *get_output_by_name(const char *name) {
* *
*/ */
Output *get_first_output() { Output *get_first_output() {
Output *screen; Output *output;
TAILQ_FOREACH(screen, &outputs, outputs) { TAILQ_FOREACH(output, &outputs, outputs)
if (screen->active) if (output->active)
return screen; return output;
}
return NULL; 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 *get_output_containing(int x, int y) {
Output *screen; Output *output;
TAILQ_FOREACH(screen, &outputs, outputs) { TAILQ_FOREACH(output, &outputs, outputs) {
if (!screen->active) if (!output->active)
continue; continue;
DLOG("comparing x=%d y=%d with x=%d and y=%d width %d height %d\n", 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); x, y, output->rect.x, output->rect.y, output->rect.width, output->rect.height);
if (x >= screen->rect.x && x < (screen->rect.x + screen->rect.width) && if (x >= output->rect.x && x < (output->rect.x + output->rect.width) &&
y >= screen->rect.y && y < (screen->rect.y + screen->rect.height)) y >= output->rect.y && y < (output->rect.y + output->rect.height))
return screen; return output;
} }
return NULL; return NULL;
} }
/* /*
* Gets the screen which is the last one in the given direction, for example the screen * Gets the output which is the last one in the given direction, for example
* on the most bottom when direction == D_DOWN, the screen most right when direction == D_RIGHT * the output on the most bottom when direction == D_DOWN, the output most
* and so on. * 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) {
Output *screen, *candidate = NULL; Output *output, *candidate = NULL;
int position = 0; int position = 0;
TAILQ_FOREACH(screen, &outputs, outputs) { TAILQ_FOREACH(output, &outputs, outputs) {
if (!screen->active) if (!output->active)
continue; continue;
/* Repeated calls of WIN determine the winner of the comparison */ /* Repeated calls of WIN determine the winner of the comparison */
#define WIN(variable, condition) \ #define WIN(variable, condition) \
if (variable condition) { \ if (variable condition) { \
candidate = screen; \ candidate = output; \
position = variable; \ position = variable; \
} \ } \
break; break;
if (((direction == D_UP) || (direction == D_DOWN)) && if (((direction == D_UP) || (direction == D_DOWN)) &&
(current->rect.x != screen->rect.x)) (current->rect.x != output->rect.x))
continue; continue;
if (((direction == D_LEFT) || (direction == D_RIGHT)) && if (((direction == D_LEFT) || (direction == D_RIGHT)) &&
(current->rect.y != screen->rect.y)) (current->rect.y != output->rect.y))
continue; continue;
switch (direction) { switch (direction) {
case D_UP: case D_UP:
WIN(screen->rect.y, <= position); WIN(output->rect.y, <= position);
case D_DOWN: case D_DOWN:
WIN(screen->rect.y, >= position); WIN(output->rect.y, >= position);
case D_LEFT: case D_LEFT:
WIN(screen->rect.x, <= position); WIN(output->rect.x, <= position);
case D_RIGHT: 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 * Disables RandR support by creating exactly one output with the size of the
* whole X screen. * X11 screen.
* *
*/ */
static void disable_randr(xcb_connection_t *conn) { static void disable_randr(xcb_connection_t *conn) {
xcb_screen_t *root_screen = xcb_setup_roots_iterator(xcb_get_setup(conn)).data; 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)); 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; s->rect.height = root_screen->height_in_pixels;
TAILQ_INSERT_TAIL(&outputs, s, outputs); 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 * 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 * 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 * 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. * (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; Workspace *ws;
Output *output, *other, *first;
xcb_randr_get_screen_resources_current_cookie_t rcookie; xcb_randr_get_screen_resources_current_cookie_t rcookie;
resources_reply *res; resources_reply *res;
/* timestamp of the configuration so that we get consistent replies to all /* 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) */ /* an output is VGA-1, LVDS-1, etc. (usually physical video outputs) */
xcb_randr_output_t *randr_outputs; xcb_randr_output_t *randr_outputs;
if (randr_disabled)
return;
/* Get screen resources (crtcs, outputs, modes) */ /* Get screen resources (crtcs, outputs, modes) */
rcookie = xcb_randr_get_screen_resources_current(conn, root); rcookie = xcb_randr_get_screen_resources_current(conn, root);
if ((res = xcb_randr_get_screen_resources_current_reply(conn, rcookie, NULL)) == NULL) if ((res = xcb_randr_get_screen_resources_current_reply(conn, rcookie, NULL)) == NULL) {
die("Could not get RandR screen resources\n"); disable_randr(conn);
return;
}
cts = res->config_timestamp; cts = res->config_timestamp;
int len = xcb_randr_get_screen_resources_current_outputs_length(res); 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); free(res);
Output *screen, *oscreen; /* Check for clones, disable the clones and reduce the mode to the
/* Check for clones and reduce the mode to the lowest common mode */ * lowest common mode */
TAILQ_FOREACH(screen, &outputs, outputs) { TAILQ_FOREACH(output, &outputs, outputs) {
if (!screen->active || screen->to_be_disabled) if (!output->active || output->to_be_disabled)
continue; continue;
DLOG("screen %p, position (%d, %d), checking for clones\n", DLOG("output %p, position (%d, %d), checking for clones\n",
screen, screen->rect.x, screen->rect.y); output, output->rect.x, output->rect.y);
for (oscreen = screen; for (other = output;
oscreen != TAILQ_END(&outputs); other != TAILQ_END(&outputs);
oscreen = TAILQ_NEXT(oscreen, outputs)) { other = TAILQ_NEXT(other, outputs)) {
if (oscreen == screen || !oscreen->active || oscreen->to_be_disabled) if (other == output || !other->active || other->to_be_disabled)
continue; continue;
if (oscreen->rect.x != screen->rect.x || if (other->rect.x != output->rect.x ||
oscreen->rect.y != screen->rect.y) other->rect.y != output->rect.y)
continue; continue;
DLOG("screen %p has the same position, his mode = %d x %d\n", DLOG("output %p has the same position, his mode = %d x %d\n",
oscreen, oscreen->rect.width, oscreen->rect.height); other, other->rect.width, other->rect.height);
uint32_t width = min(oscreen->rect.width, screen->rect.width); uint32_t width = min(other->rect.width, output->rect.width);
uint32_t height = min(oscreen->rect.height, screen->rect.height); uint32_t height = min(other->rect.height, output->rect.height);
if (update_if_necessary(&(screen->rect.width), width) | if (update_if_necessary(&(output->rect.width), width) |
update_if_necessary(&(screen->rect.height), height)) update_if_necessary(&(output->rect.height), height))
screen->changed = true; output->changed = true;
update_if_necessary(&(oscreen->rect.width), width); update_if_necessary(&(other->rect.width), width);
update_if_necessary(&(oscreen->rect.height), height); update_if_necessary(&(other->rect.height), height);
DLOG("disabling screen %p (%s)\n", oscreen, oscreen->name); DLOG("disabling output %p (%s)\n", other, other->name);
oscreen->to_be_disabled = true; other->to_be_disabled = true;
DLOG("new screen mode %d x %d, oscreen mode %d x %d\n", DLOG("new output mode %d x %d, other mode %d x %d\n",
screen->rect.width, screen->rect.height, output->rect.width, output->rect.height,
oscreen->rect.width, oscreen->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) { TAILQ_FOREACH(output, &outputs, outputs) {
if (output->to_be_disabled) { if (output->to_be_disabled) {
output->active = false; output->active = false;
@ -467,11 +478,11 @@ void randr_query_screens(xcb_connection_t *conn) {
ewmh_update_workarea(); ewmh_update_workarea();
/* Just go through each active output and associate one workspace */ /* Just go through each active output and associate one workspace */
TAILQ_FOREACH(screen, &outputs, outputs) { TAILQ_FOREACH(output, &outputs, outputs) {
if (!screen->active || screen->current_workspace != NULL) if (!output->active || output->current_workspace != NULL)
continue; continue;
ws = get_first_workspace_for_screen(screen); ws = get_first_workspace_for_output(output);
initialize_output(conn, screen, ws); initialize_output(conn, output, ws);
} }
/* render_layout flushes */ /* 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); extreply = xcb_get_extension_data(conn, &xcb_randr_id);
if (!extreply->present) if (!extreply->present)
disable_randr(conn); disable_randr(conn);
else randr_query_screens(conn); else randr_query_outputs(conn);
if (event_base != NULL) if (event_base != NULL)
*event_base = extreply->first_event; *event_base = extreply->first_event;

8
src/resize.c
View File

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

2
src/workspace.c
View File

@ -277,7 +277,7 @@ void workspace_initialize(Workspace *ws, Output *output, bool recheck) {
* the preferred_output setting of every workspace (workspace assignments). * 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 *result = NULL;
Workspace *ws; Workspace *ws;