Aire-One
/
awesome
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
awesome/tests/test-gravity.c

591 lines
19 KiB
C
Raw Blame History

/*
* A test for gravity handling.
*
* Copyright © 2017 Uli Schlachter <psychon@znc.in>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
*
* Loosely based on test-gravity.c from metacity, which does not have a
* copyright or license header, but Metacity itself is licensed under GPLv2.
*/
#include <xcb/xcb.h>
#include <xcb/xcb_aux.h>
#include <xcb/xcb_icccm.h>
#include <stdbool.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/*
* This program tests various gravity-related things. For each possible gravity,
* this does:
* - Create a window with this gravity.
* [Wait for expose event]
* - Check that the window is mapped in the correct place.
* - Resize the window.
* [Wait for real configure notify]
* - Check that the window moves as expected by the gravity.
* - Move and resize the window (go back to the original size).
* [Wait for real configure notify]
* - Check that the window moves as expected by the gravity.
* - Move the window.
* [Wait for synthetic configure notify]
* - Check that the window moves to the expected position.
*
* This needs a WM that supports _NET_FRAME_EXTENTS.
* Also, this assumes that the WM allows and applies window moves and resizes by
* the application.
*/
enum test_state {
TEST_STATE_CREATED,
TEST_STATE_RESIZED1,
TEST_STATE_RESIZED2,
TEST_STATE_MOVED,
TEST_STATE_DONE,
TEST_STATE_DONE_GOT_CONFIGURE,
};
#define WIN_POS_X1 50
#define WIN_POS_Y1 70
#define WIN_WIDTH1 30
#define WIN_HEIGHT1 40
#define WIN_POS_X2 42
#define WIN_POS_Y2 43
#define WIN_WIDTH2 12
#define WIN_HEIGHT2 16
static int32_t state_difference[][2] = {
[TEST_STATE_CREATED] = { 0, 0 },
[TEST_STATE_RESIZED1] = { WIN_WIDTH1 - WIN_WIDTH2, WIN_HEIGHT1 - WIN_HEIGHT2 },
[TEST_STATE_RESIZED2] = { 0, 0 },
[TEST_STATE_MOVED] = { 0, 0 },
[TEST_STATE_DONE] = { 0, 0 },
[TEST_STATE_DONE_GOT_CONFIGURE] = { 0, 0 },
};
struct window_state {
xcb_window_t window;
enum test_state state;
xcb_gravity_t gravity;
bool sent_delayed_proceed;
};
static xcb_connection_t *c = NULL;
static xcb_screen_t *screen;
static struct window_state window_state;
static xcb_atom_t net_frame_extents;
static bool done;
static bool had_error = false;
static void check(bool cond, const char *format, ...)
__attribute__ ((format(printf, 2, 3)));
static void do_log(const char *format, ...)
__attribute__ ((format(printf, 1, 2)));
static void check(bool cond, const char *format, ...)
{
va_list ap;
if (cond)
return;
va_start(ap, format);
fprintf(stderr, "ERROR: ");
vfprintf(stderr, format, ap);
fprintf(stderr, "\n");
va_end(ap);
if (c) {
xcb_no_operation(c);
free(xcb_get_input_focus_reply(c, xcb_get_input_focus(c), NULL));
}
had_error = true;
}
static void do_log(const char *format, ...)
{
va_list ap;
va_start(ap, format);
fprintf(stdout, "LOG: ");
vfprintf(stdout, format, ap);
fprintf(stdout, "\n");
va_end(ap);
}
static void query_frame_extents(xcb_window_t win, uint32_t *left,
uint32_t *right, uint32_t *top, uint32_t *bottom)
{
xcb_get_property_reply_t *reply = xcb_get_property_reply(c,
xcb_get_property(c, 0, win, net_frame_extents, XCB_ATOM_CARDINAL,
0, 4), NULL);
*left = 0;
*right = 0;
*top = 0;
*bottom = 0;
if (reply && reply->length == 4)
{
uint32_t *data = (uint32_t *) xcb_get_property_value(reply);
*left = data[0];
*right = data[1];
*top = data[2];
*bottom = data[3];
}
free(reply);
}
static void delayed_proceed_with_window(void)
{
xcb_client_message_event_t ev;
if (window_state.sent_delayed_proceed)
return;
memset(&ev, 0, sizeof(ev));
ev.response_type = XCB_CLIENT_MESSAGE;
ev.window = window_state.window;
ev.format = 32;
ev.type = XCB_ATOM_NOTICE;
ev.data.data32[0] = (int) window_state.state;
xcb_send_event(c, 0, window_state.window, XCB_EVENT_MASK_NO_EVENT, (char *) &ev);
window_state.sent_delayed_proceed = true;
}
static void get_geometry(xcb_window_t win, int32_t *x, int32_t *y,
uint32_t *width, uint32_t *height, uint32_t *left, uint32_t *right,
uint32_t *top, uint32_t *bottom)
{
xcb_get_geometry_cookie_t geo_c = xcb_get_geometry_unchecked(c, win);
xcb_translate_coordinates_cookie_t coord_c =
xcb_translate_coordinates(c, win, screen->root, 0, 0);
query_frame_extents(win, left, right, top, bottom);
xcb_get_geometry_reply_t *geo = xcb_get_geometry_reply(c, geo_c, NULL);
xcb_translate_coordinates_reply_t *coord =
xcb_translate_coordinates_reply(c, coord_c, NULL);
*x = coord->dst_x;
*y = coord->dst_y;
*width = geo->width;
*height = geo->height;
free(coord);
free(geo);
}
static const char *gravity_to_string(xcb_gravity_t gravity) {
switch (gravity)
{
case XCB_GRAVITY_NORTH_WEST:
return "NorthWest";
case XCB_GRAVITY_NORTH:
return "North";
case XCB_GRAVITY_NORTH_EAST:
return "NorthEast";
case XCB_GRAVITY_WEST:
return "West";
case XCB_GRAVITY_CENTER:
return "Center";
case XCB_GRAVITY_EAST:
return "East";
case XCB_GRAVITY_SOUTH_WEST:
return "SouthWest";
case XCB_GRAVITY_SOUTH:
return "South";
case XCB_GRAVITY_SOUTH_EAST:
return "SouthEast";
case XCB_GRAVITY_STATIC:
return "Static";
default:
fprintf(stderr, "Unknown gravity value %d", (int) gravity);
exit(1);
}
}
static const char *state_to_string(enum test_state state)
{
switch (state)
{
case TEST_STATE_CREATED:
return "CREATED";
case TEST_STATE_RESIZED1:
return "RESIZED1";
case TEST_STATE_RESIZED2:
return "RESIZED2";
case TEST_STATE_MOVED:
return "MOVED";
case TEST_STATE_DONE:
return "DONE";
case TEST_STATE_DONE_GOT_CONFIGURE:
return "DONE+c";
default:
return "UNKNOWN";
}
}
static int32_t div2(int32_t value, int32_t *rounding)
{
/* If value is odd, we could round up or down */
if (value & 1)
*rounding = 1;
return value / 2;
}
static void check_geometry(int32_t expected_x, int32_t expected_y, uint32_t expected_width, uint32_t expected_height)
{
int32_t actual_x, actual_y;
uint32_t actual_width, actual_height, left, right, top, bottom;
get_geometry(window_state.window, &actual_x, &actual_y, &actual_width, &actual_height,
&left, &right, &top, &bottom);
int32_t offset_x, offset_y;
int32_t extra_x = 0, extra_y = 0;
int32_t diff_x = state_difference[window_state.state][0], diff_y = state_difference[window_state.state][1];
switch (window_state.gravity)
{
case XCB_GRAVITY_NORTH_WEST:
offset_x = left;
offset_y = top;
break;
case XCB_GRAVITY_NORTH:
offset_x = div2(left - right + diff_x, &extra_x);;
offset_y = top;
break;
case XCB_GRAVITY_NORTH_EAST:
offset_x = -right + diff_x;
offset_y = top;
break;
case XCB_GRAVITY_WEST:
offset_x = left;
offset_y = div2(top - bottom + diff_y, &extra_y);
break;
case XCB_GRAVITY_CENTER:
offset_x = div2(left - right + diff_x, &extra_x);
offset_y = div2(top - bottom + diff_y, &extra_y);
break;
case XCB_GRAVITY_EAST:
offset_x = -right + diff_x;
offset_y = div2(top - bottom + diff_y, &extra_y);
break;
case XCB_GRAVITY_SOUTH_WEST:
offset_x = left;
offset_y = -bottom + diff_y;
break;
case XCB_GRAVITY_SOUTH:
offset_x = div2(left - right + diff_x, &extra_x);
offset_y = -bottom + diff_y;
break;
case XCB_GRAVITY_SOUTH_EAST:
offset_x = -right + diff_x;
offset_y = -bottom + diff_y;
break;
case XCB_GRAVITY_STATIC:
offset_x = 0;
offset_y = 0;
break;
default:
fprintf(stderr, "Unknown gravity!?\n");
return;
}
do_log("Checking if position of window with gravity %s is %dx%d and size "
"is %dx%d when frame has size left=%d, right=%d, top=%d, bottom=%d",
gravity_to_string(window_state.gravity),
expected_x, expected_y, expected_width, expected_height,
left, right, top, bottom);
check(expected_width == actual_width,
"For window with gravity %s in state %s, expected width = %d, but got %d",
gravity_to_string(window_state.gravity), state_to_string(window_state.state), (int) expected_width, (int) actual_width);
check(expected_height == actual_height,
"For window with gravity %s in state %s, expected height = %d, but got %d",
gravity_to_string(window_state.gravity), state_to_string(window_state.state), (int) expected_height, (int) actual_height);
check(expected_x + offset_x == actual_x || expected_x + offset_x + extra_x == actual_x,
"For window with gravity %s in state %s, expected x = %d+%d (+%d), but got %d",
gravity_to_string(window_state.gravity), state_to_string(window_state.state), (int) expected_x, (int) offset_x, (int) extra_x, (int) actual_x);
check(expected_y + offset_y == actual_y || expected_y + offset_y + extra_y == actual_y,
"For window with gravity %s in state %s, expected y = %d+%d (+%d), but got %d",
gravity_to_string(window_state.gravity), state_to_string(window_state.state), (int) expected_y, (int) offset_y, (int) extra_y, (int) actual_y);
}
static void init(xcb_gravity_t gravity)
{
const char *name = gravity_to_string(gravity);
xcb_size_hints_t size_hints;
memset(&size_hints, 0, sizeof(size_hints));
size_hints.win_gravity = gravity;
size_hints.flags = XCB_ICCCM_SIZE_HINT_US_POSITION
| XCB_ICCCM_SIZE_HINT_P_WIN_GRAVITY;
window_state.window = xcb_generate_id(c);
window_state.state = TEST_STATE_CREATED;
window_state.gravity = gravity;
do_log("creating window at %dx%d with size %dx%d", WIN_POS_X1, WIN_POS_Y1, WIN_WIDTH1, WIN_HEIGHT1);
xcb_create_window(c, screen->root_depth, window_state.window, screen->root,
WIN_POS_X1, WIN_POS_Y1, WIN_WIDTH1, WIN_HEIGHT1, 0,
XCB_WINDOW_CLASS_INPUT_OUTPUT, screen->root_visual,
XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK, (uint32_t[]) {
screen->white_pixel,
XCB_EVENT_MASK_STRUCTURE_NOTIFY | XCB_EVENT_MASK_EXPOSURE
});
xcb_change_property(c, XCB_PROP_MODE_REPLACE, window_state.window,
XCB_ATOM_WM_NAME, XCB_ATOM_STRING, 8, strlen(name), name);
xcb_icccm_set_wm_size_hints(c, window_state.window, XCB_ATOM_WM_NORMAL_HINTS, &size_hints);
xcb_map_window(c, window_state.window);
}
static void handle_expose(xcb_expose_event_t *ev)
{
if (window_state.window != ev->window || window_state.state != TEST_STATE_CREATED)
return;
do_log("Window in state CREATED was exposed, going to next state");
delayed_proceed_with_window();
}
static void handle_configure_notify(xcb_configure_notify_event_t *ev)
{
bool synthetic = ev->response_type & 0x80;
if (window_state.window != ev->window)
return;
switch (window_state.state)
{
case TEST_STATE_CREATED:
return;
case TEST_STATE_RESIZED1:
if (synthetic)
return;
do_log("Window in state RESIZED1 got ConfigureNotify, going to next state");
delayed_proceed_with_window();
return;
case TEST_STATE_RESIZED2:
if (synthetic)
return;
do_log("Window in state RESIZED2 got ConfigureNotify, going to next state");
delayed_proceed_with_window();
return;
case TEST_STATE_MOVED:
if (!synthetic)
return;
do_log("Window in state MOVED got ConfigureNotify, going to next state");
delayed_proceed_with_window();
return;
case TEST_STATE_DONE:
if (!synthetic)
return;
}
check(false, "Unexpected configure notify for window 0x%x with gravity %d, %dx%d+%d+%d%s",
(int) window_state.window, (int) window_state.gravity, ev->width, ev->height,
ev->x, ev->y, synthetic ? " (generated)" : "");
}
static void wait_for_wm(void)
{
/* Window managers can be awfully slow and ICCCM does not provide much
* possibilities to synchronise with them. We try to do this by creating a
* window and resizing it, but without mapping it.
*/
xcb_generic_event_t *event;
xcb_window_t window = xcb_generate_id(c);
do_log("waiting for WM");
xcb_create_window(c, screen->root_depth, window, screen->root,
0, 0, 1, 1, 0,
XCB_WINDOW_CLASS_INPUT_OUTPUT, screen->root_visual,
XCB_CW_EVENT_MASK, (uint32_t[]) { XCB_EVENT_MASK_STRUCTURE_NOTIFY });
xcb_configure_window(c, window,
XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y | XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT,
(uint32_t[]) { 1, 2, 3, 4 });
xcb_flush(c);
while (event = xcb_wait_for_event(c)) {
if ((event->response_type & 0x7f) == XCB_CONFIGURE_NOTIFY) {
free(event);
break;
}
free(event);
}
xcb_destroy_window(c, window);
}
static void handle_client_message(xcb_client_message_event_t *event)
{
/* We want a full roundtrip between "we decide to proceed" and "we actually
* proceed" so that any in-flight events are handled. To do this, we send
* ourselves two client messages. (So that any events that are still in
* flight when the first message is sent are handled)
*/
if (event->type == XCB_ATOM_NOTICE)
{
wait_for_wm();
event->response_type = XCB_CLIENT_MESSAGE;
event->type = XCB_ATOM_WM_COMMAND;
xcb_send_event(c, 0, event->window, XCB_EVENT_MASK_NO_EVENT, (char *) event);
return;
}
if (event->type != XCB_ATOM_WM_COMMAND)
return;
check(window_state.window == event->window, "Got weird client message?!?");
if (event->data.data32[0] != (int) window_state.state)
return;
window_state.sent_delayed_proceed = false;
switch (window_state.state)
{
case TEST_STATE_CREATED:
/* Verify the position and size set in init() */
check_geometry(WIN_POS_X1, WIN_POS_Y1, WIN_WIDTH1, WIN_HEIGHT1);
do_log("Resizing window to size %dx%d", WIN_WIDTH2, WIN_HEIGHT2);
xcb_configure_window(c, window_state.window,
XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT,
(uint32_t[]) { WIN_WIDTH2, WIN_HEIGHT2 });
window_state.state = TEST_STATE_RESIZED1;
return;
case TEST_STATE_RESIZED1:
check_geometry(WIN_POS_X1, WIN_POS_Y1, WIN_WIDTH2, WIN_HEIGHT2);
do_log("Moving+resizing window to position %dx%d and size %dx%d",
WIN_POS_X1, WIN_POS_Y1, WIN_WIDTH1, WIN_HEIGHT1);
xcb_configure_window(c, window_state.window,
XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y | XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT,
(uint32_t[]) { WIN_POS_X1, WIN_POS_Y1, WIN_WIDTH1, WIN_HEIGHT1 });
window_state.state = TEST_STATE_RESIZED2;
return;
case TEST_STATE_RESIZED2:
check_geometry(WIN_POS_X1, WIN_POS_Y1, WIN_WIDTH1, WIN_HEIGHT1);
do_log("Moving window to position %dx%d", WIN_POS_X2, WIN_POS_Y2);
xcb_configure_window(c, window_state.window,
XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y,
(uint32_t[]) { WIN_POS_X2, WIN_POS_Y2 });
window_state.state = TEST_STATE_MOVED;
return;
case TEST_STATE_MOVED:
check_geometry(WIN_POS_X2, WIN_POS_Y2, WIN_WIDTH1, WIN_HEIGHT1);
xcb_destroy_window(c, window_state.window);
window_state.window = XCB_NONE;
window_state.state = TEST_STATE_DONE;
done = true;
return;
}
}
static void event_loop(void)
{
xcb_generic_event_t *ev;
done = false;
xcb_flush(c);
while (!done && (ev = xcb_wait_for_event(c)))
{
uint8_t type = ev->response_type & 0x7f;
switch (type)
{
case XCB_EXPOSE:
handle_expose((xcb_expose_event_t *) ev);
break;
case XCB_CONFIGURE_NOTIFY:
handle_configure_notify((xcb_configure_notify_event_t *) ev);
break;
case XCB_CLIENT_MESSAGE:
handle_client_message((xcb_client_message_event_t *) ev);
case XCB_REPARENT_NOTIFY:
case XCB_MAP_NOTIFY:
case XCB_UNMAP_NOTIFY:
case XCB_DESTROY_NOTIFY:
break;
default:
printf("Got unexpected event of type 0x%x\n", (int) ev->response_type);
}
free(ev);
xcb_flush(c);
}
}
static xcb_atom_t intern_atom(const char *str)
{
xcb_atom_t result;
xcb_intern_atom_reply_t *reply = xcb_intern_atom_reply(c,
xcb_intern_atom(c, 0, strlen(str), str), NULL);
if (!reply)
return XCB_NONE;
result = reply->atom;
free(reply);
return result;
}
static void run_test(xcb_gravity_t gravity)
{
do_log("Doing run for gravity %s", gravity_to_string(gravity));
init(gravity);
event_loop();
do_log("Finished run for gravity %s", gravity_to_string(gravity));
}
int main()
{
int default_screen;
c = xcb_connect(NULL, &default_screen);
if (xcb_connection_has_error(c))
{
fprintf(stderr, "Could not connect to X11 server: %d",
xcb_connection_has_error(c));
return 1;
}
screen = xcb_aux_get_screen(c, default_screen);
net_frame_extents = intern_atom("_NET_FRAME_EXTENTS");
run_test(XCB_GRAVITY_NORTH_WEST);
run_test(XCB_GRAVITY_NORTH);
run_test(XCB_GRAVITY_NORTH_EAST);
run_test(XCB_GRAVITY_WEST);
run_test(XCB_GRAVITY_CENTER);
run_test(XCB_GRAVITY_EAST);
run_test(XCB_GRAVITY_SOUTH_WEST);
run_test(XCB_GRAVITY_SOUTH);
run_test(XCB_GRAVITY_SOUTH_EAST);
run_test(XCB_GRAVITY_STATIC);
check(!xcb_connection_has_error(c),
"X11 connection has error: %d", xcb_connection_has_error(c));
xcb_disconnect(c);
if (had_error)
return 1;
puts("SUCCESS");
return 0;
}
// vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:textwidth=80
Reference in New Issue View Git Blame Copy Permalink