You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
345 lines
10 KiB
345 lines
10 KiB
/*
|
|
* Copyright © 2012 Intel Corporation
|
|
*
|
|
* Permission to use, copy, modify, distribute, and sell this software and
|
|
* its documentation for any purpose is hereby granted without fee, provided
|
|
* that the above copyright notice appear in all copies and that both that
|
|
* copyright notice and this permission notice appear in supporting
|
|
* documentation, and that the name of the copyright holders not be used in
|
|
* advertising or publicity pertaining to distribution of the software
|
|
* without specific, written prior permission. The copyright holders make
|
|
* no representations about the suitability of this software for any
|
|
* purpose. It is provided "as is" without express or implied warranty.
|
|
*
|
|
* THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
|
|
* SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
|
* FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
|
* SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
|
|
* RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
|
|
* CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
|
|
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
*/
|
|
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <sys/socket.h>
|
|
#include <assert.h>
|
|
#include <unistd.h>
|
|
#include <string.h>
|
|
|
|
#include "test-runner.h"
|
|
|
|
struct state {
|
|
int px; /* pointer x */
|
|
int py; /* pointer y */
|
|
int sx; /* surface x */
|
|
int sy; /* surface y */
|
|
int sw; /* surface width */
|
|
int sh; /* surface height */
|
|
};
|
|
|
|
static size_t state_size = sizeof(struct state);
|
|
|
|
struct context {
|
|
struct weston_layer *layer;
|
|
struct weston_seat *seat;
|
|
struct weston_surface *surface;
|
|
int pointer_x; /* server pointer x */
|
|
int pointer_y; /* server pointer y */
|
|
size_t index;
|
|
struct wl_array states;
|
|
};
|
|
|
|
static void
|
|
resize(struct context *context, int w, int h)
|
|
{
|
|
/* resize the surface only if the width or height is different */
|
|
if (context->surface->geometry.width != w ||
|
|
context->surface->geometry.height != h) {
|
|
|
|
weston_surface_configure(context->surface,
|
|
context->surface->geometry.x,
|
|
context->surface->geometry.y,
|
|
w, h);
|
|
weston_surface_update_transform(context->surface);
|
|
weston_surface_damage(context->surface);
|
|
|
|
fprintf(stderr, "resize surface: %d %d\n",
|
|
context->surface->geometry.width,
|
|
context->surface->geometry.height);
|
|
}
|
|
}
|
|
|
|
static void
|
|
move(struct context *context, int x, int y)
|
|
{
|
|
/* move the surface only if x or y is different */
|
|
if (context->surface->geometry.x != x ||
|
|
context->surface->geometry.y != y) {
|
|
|
|
weston_surface_configure(context->surface,
|
|
x, y,
|
|
context->surface->geometry.width,
|
|
context->surface->geometry.height);
|
|
weston_surface_update_transform(context->surface);
|
|
weston_surface_damage(context->surface);
|
|
|
|
fprintf(stderr, "move surface: %f %f\n",
|
|
context->surface->geometry.x,
|
|
context->surface->geometry.y);
|
|
}
|
|
}
|
|
|
|
static int
|
|
contains(struct context *context, int x, int y)
|
|
{
|
|
/* test whether a global x,y point is contained in the surface */
|
|
int sx = context->surface->geometry.x;
|
|
int sy = context->surface->geometry.y;
|
|
int sw = context->surface->geometry.width;
|
|
int sh = context->surface->geometry.height;
|
|
return x >= sx && y >= sy && x < sx + sw && y < sy + sh;
|
|
}
|
|
|
|
static void
|
|
move_pointer(struct context *context, int x, int y)
|
|
{
|
|
if (contains(context, context->pointer_x, context->pointer_y)) {
|
|
/* pointer is currently on the surface */
|
|
notify_motion(context->seat, 100,
|
|
wl_fixed_from_int(x), wl_fixed_from_int(y));
|
|
} else {
|
|
/* pointer is not currently on the surface */
|
|
notify_pointer_focus(context->seat, context->surface->output,
|
|
wl_fixed_from_int(x),
|
|
wl_fixed_from_int(y));
|
|
}
|
|
|
|
/* update server expected pointer location */
|
|
context->pointer_x = x;
|
|
context->pointer_y = y;
|
|
|
|
fprintf(stderr, "move pointer: %d %d\n", x, y);
|
|
}
|
|
|
|
static void
|
|
check_pointer(struct context *context, int cx, int cy)
|
|
{
|
|
/*
|
|
* Check whether the client reported pointer position matches
|
|
* the server expected pointer position. The client
|
|
* reports -1,-1 when the pointer is not on its surface and
|
|
* a surface relative x,y otherwise.
|
|
*/
|
|
int gx = context->surface->geometry.x + cx;
|
|
int gy = context->surface->geometry.y + cy;
|
|
if (!contains(context, gx, gy)) {
|
|
assert(!contains(context, context->pointer_x,
|
|
context->pointer_y));
|
|
} else {
|
|
assert(gx == context->pointer_x);
|
|
assert(gy == context->pointer_y);
|
|
}
|
|
}
|
|
|
|
static void
|
|
check_visible(struct context *context, int visible)
|
|
{
|
|
/*
|
|
* Check whether the client reported surface visibility matches
|
|
* the servers expected surface visibility
|
|
*/
|
|
int ow = context->surface->output->width;
|
|
int oh = context->surface->output->height;
|
|
int sx = context->surface->geometry.x;
|
|
int sy = context->surface->geometry.y;
|
|
int sw = context->surface->geometry.width;
|
|
int sh = context->surface->geometry.height;
|
|
|
|
const int expect = sx < ow && sy < oh && sx + sw > 0 && sy + sh > 0;
|
|
|
|
assert(visible == expect);
|
|
}
|
|
|
|
static void
|
|
handle_state(struct test_client *);
|
|
|
|
static void
|
|
set_state(struct test_client *client)
|
|
{
|
|
struct state* state;
|
|
struct context *context = client->data;
|
|
|
|
if (context->index < context->states.size) {
|
|
state = context->states.data + context->index;
|
|
resize(context, state->sw, state->sh);
|
|
move(context, state->sx, state->sy);
|
|
move_pointer(context, state->px, state->py);
|
|
context->index += state_size;
|
|
|
|
test_client_send(client, "send-state\n");
|
|
client->handle = handle_state;
|
|
} else {
|
|
test_client_send(client, "bye\n");
|
|
client->handle = NULL;
|
|
}
|
|
}
|
|
|
|
static void
|
|
handle_state(struct test_client *client)
|
|
{
|
|
struct context *context = client->data;
|
|
wl_fixed_t x, y;
|
|
int visible;
|
|
|
|
assert(sscanf(client->buf, "%d %d %d", &x, &y, &visible) == 3);
|
|
|
|
check_pointer(context, wl_fixed_to_int(x), wl_fixed_to_int(y));
|
|
check_visible(context, visible);
|
|
|
|
set_state(client);
|
|
}
|
|
|
|
static void
|
|
add_state(struct context *context, int px, int py, int sx, int sy,
|
|
int sw, int sh)
|
|
{
|
|
struct state *state = wl_array_add(&context->states,
|
|
sizeof(struct state));
|
|
|
|
assert(state);
|
|
|
|
state->px = px;
|
|
state->py = py;
|
|
state->sx = sx;
|
|
state->sy = sy;
|
|
state->sw = sw;
|
|
state->sh = sh;
|
|
}
|
|
|
|
static void
|
|
initialize_states(struct test_client *client)
|
|
{
|
|
struct context *context = client->data;
|
|
struct weston_surface *surface = context->surface;
|
|
|
|
int x = surface->geometry.x;
|
|
int y = surface->geometry.y;
|
|
int w = surface->geometry.width;
|
|
int h = surface->geometry.height;
|
|
|
|
wl_array_init(&context->states);
|
|
|
|
/* move pointer outside top left */
|
|
add_state(context, x - 1, y - 1, x, y, w, h);
|
|
/* move pointer on top left */
|
|
add_state(context, x, y, x, y, w, h);
|
|
/* move pointer outside bottom left */
|
|
add_state(context, x - 1, y + h, x, y, w, h);
|
|
/* move pointer on bottom left */
|
|
add_state(context, x, y + h - 1, x, y, w, h);
|
|
/* move pointer outside top right */
|
|
add_state(context, x + w, y - 1, x, y, w, h);
|
|
/* move pointer on top right */
|
|
add_state(context, x + w - 1, y, x, y, w, h);
|
|
/* move pointer outside bottom right */
|
|
add_state(context, x + w, y + h, x, y, w, h);
|
|
/* move pointer on bottom right */
|
|
add_state(context, x + w - 1, y + h - 1, x, y, w, h);
|
|
|
|
/* move pointer outside top center */
|
|
add_state(context, x + w/2, y - 1, x, y, w, h);
|
|
/* move pointer on top center */
|
|
add_state(context, x + w/2, y, x, y, w, h);
|
|
/* move pointer outside bottom center */
|
|
add_state(context, x + w/2, y + h, x, y, w, h);
|
|
/* move pointer on bottom center */
|
|
add_state(context, x + w/2, y + h - 1, x, y, w, h);
|
|
/* move pointer outside left center */
|
|
add_state(context, x - 1, y + h/2, x, y, w, h);
|
|
/* move pointer on left center */
|
|
add_state(context, x, y + h/2, x, y, w, h);
|
|
/* move pointer outside right center */
|
|
add_state(context, x + w, y + h/2, x, y, w, h);
|
|
/* move pointer on right center */
|
|
add_state(context, x + w - 1, y + h/2, x, y, w, h);
|
|
|
|
/* move pointer outside of client */
|
|
add_state(context, 50, 50, x, y, w, h);
|
|
/* move client center to pointer */
|
|
add_state(context, 50, 50, 0, 0, w, h);
|
|
|
|
/* not visible */
|
|
add_state(context, 0, 0, 0, -h, w, h);
|
|
/* visible */
|
|
add_state(context, 0, 0, 0, -h+1, w, h);
|
|
/* not visible */
|
|
add_state(context, 0, 0, 0, context->surface->output->height, w, h);
|
|
/* visible */
|
|
add_state(context, 0, 0, 0, context->surface->output->height - 1, w, h);
|
|
/* not visible */
|
|
add_state(context, 0, 0, -w, 0, w, h);
|
|
/* visible */
|
|
add_state(context, 0, 0, -w+1, 0, w, h);
|
|
/* not visible */
|
|
add_state(context, 0, 0, context->surface->output->width, 0, w, h);
|
|
/* visible */
|
|
add_state(context, 0, 0, context->surface->output->width - 1, 0, w, h);
|
|
|
|
set_state(client);
|
|
}
|
|
|
|
static void
|
|
handle_surface(struct test_client *client)
|
|
{
|
|
uint32_t id;
|
|
struct context *context = client->data;
|
|
struct wl_resource *resource;
|
|
struct wl_list *seat_list;
|
|
|
|
assert(sscanf(client->buf, "surface %u", &id) == 1);
|
|
fprintf(stderr, "server: got surface id %u\n", id);
|
|
resource = wl_client_get_object(client->client, id);
|
|
assert(resource);
|
|
assert(strcmp(resource->object.interface->name, "wl_surface") == 0);
|
|
|
|
context->surface = (struct weston_surface *) resource;
|
|
weston_surface_set_color(context->surface, 0.0, 0.0, 0.0, 1.0);
|
|
|
|
context->layer = malloc(sizeof *context->layer);
|
|
assert(context->layer);
|
|
weston_layer_init(context->layer,
|
|
&client->compositor->cursor_layer.link);
|
|
wl_list_insert(&context->layer->surface_list,
|
|
&context->surface->layer_link);
|
|
|
|
seat_list = &client->compositor->seat_list;
|
|
assert(wl_list_length(seat_list) == 1);
|
|
context->seat = container_of(seat_list->next, struct weston_seat, link);
|
|
|
|
client->compositor->focus = 1; /* Make it work even if pointer is
|
|
* outside X window. */
|
|
|
|
resize(context, 100, 100);
|
|
move(context, 100, 100);
|
|
move_pointer(context, 150, 150);
|
|
|
|
test_client_send(client, "send-state\n");
|
|
client->handle = initialize_states;
|
|
}
|
|
|
|
TEST(event_test)
|
|
{
|
|
struct context *context;
|
|
struct test_client *client;
|
|
|
|
client = test_client_launch(compositor, "test-client");
|
|
client->terminate = 1;
|
|
|
|
test_client_send(client, "create-surface\n");
|
|
client->handle = handle_surface;
|
|
|
|
context = calloc(1, sizeof *context);
|
|
assert(context);
|
|
client->data = context;
|
|
}
|
|
|