mirror of
https://gitlab.freedesktop.org/wayland/weston
synced 2024-09-06 18:05:39 +00:00
![Guillaume Champagne](/assets/img/avatar_default.png)
Fixes missing prototypes compilation warnings emitted when a function is defined before its prototype is declared. These warnings were introduced over time since the switch to meson because the -Wmissing-protoypes was not included in the compilation arguments. Signed-off-by: Guillaume Champagne <champagne.guillaume.c@gmail.com>
534 lines
14 KiB
C
534 lines
14 KiB
C
/*
|
|
* Copyright © 2011 Intel Corporation
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining
|
|
* a copy of this software and associated documentation files (the
|
|
* "Software"), to deal in the Software without restriction, including
|
|
* without limitation the rights to use, copy, modify, merge, publish,
|
|
* distribute, sublicense, and/or sell copies of the Software, and to
|
|
* permit persons to whom the Software is furnished to do so, subject to
|
|
* the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice (including the
|
|
* next paragraph) shall be included in all copies or substantial
|
|
* portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <math.h>
|
|
#include <inttypes.h>
|
|
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
|
|
#include <libweston/libweston.h>
|
|
#include "libweston-internal.h"
|
|
#include "shared/helpers.h"
|
|
#include "shared/timespec-util.h"
|
|
|
|
WL_EXPORT void
|
|
weston_spring_init(struct weston_spring *spring,
|
|
double k, double current, double target)
|
|
{
|
|
spring->k = k;
|
|
spring->friction = 400.0;
|
|
spring->current = current;
|
|
spring->previous = current;
|
|
spring->target = target;
|
|
spring->clip = WESTON_SPRING_OVERSHOOT;
|
|
spring->min = 0.0;
|
|
spring->max = 1.0;
|
|
}
|
|
|
|
WL_EXPORT void
|
|
weston_spring_update(struct weston_spring *spring, const struct timespec *time)
|
|
{
|
|
double force, v, current, step;
|
|
|
|
/* Limit the number of executions of the loop below by ensuring that
|
|
* the timestamp for last update of the spring is no more than 1s ago.
|
|
* This handles the case where time moves backwards or forwards in
|
|
* large jumps.
|
|
*/
|
|
if (timespec_sub_to_msec(time, &spring->timestamp) > 1000) {
|
|
weston_log("unexpectedly large timestamp jump "
|
|
"(from %" PRId64 " to %" PRId64 ")\n",
|
|
timespec_to_msec(&spring->timestamp),
|
|
timespec_to_msec(time));
|
|
timespec_add_msec(&spring->timestamp, time, -1000);
|
|
}
|
|
|
|
step = 0.01;
|
|
while (4 < timespec_sub_to_msec(time, &spring->timestamp)) {
|
|
current = spring->current;
|
|
v = current - spring->previous;
|
|
force = spring->k * (spring->target - current) / 10.0 +
|
|
(spring->previous - current) - v * spring->friction;
|
|
|
|
spring->current =
|
|
current + (current - spring->previous) +
|
|
force * step * step;
|
|
spring->previous = current;
|
|
|
|
switch (spring->clip) {
|
|
case WESTON_SPRING_OVERSHOOT:
|
|
break;
|
|
|
|
case WESTON_SPRING_CLAMP:
|
|
if (spring->current > spring->max) {
|
|
spring->current = spring->max;
|
|
spring->previous = spring->max;
|
|
} else if (spring->current < 0.0) {
|
|
spring->current = spring->min;
|
|
spring->previous = spring->min;
|
|
}
|
|
break;
|
|
|
|
case WESTON_SPRING_BOUNCE:
|
|
if (spring->current > spring->max) {
|
|
spring->current =
|
|
2 * spring->max - spring->current;
|
|
spring->previous =
|
|
2 * spring->max - spring->previous;
|
|
} else if (spring->current < spring->min) {
|
|
spring->current =
|
|
2 * spring->min - spring->current;
|
|
spring->previous =
|
|
2 * spring->min - spring->previous;
|
|
}
|
|
break;
|
|
}
|
|
|
|
timespec_add_msec(&spring->timestamp, &spring->timestamp, 4);
|
|
}
|
|
}
|
|
|
|
WL_EXPORT int
|
|
weston_spring_done(struct weston_spring *spring)
|
|
{
|
|
return fabs(spring->previous - spring->target) < 0.002 &&
|
|
fabs(spring->current - spring->target) < 0.002;
|
|
}
|
|
|
|
typedef void (*weston_view_animation_frame_func_t)(struct weston_view_animation *animation);
|
|
|
|
struct weston_view_animation {
|
|
struct weston_view *view;
|
|
struct weston_animation animation;
|
|
struct weston_spring spring;
|
|
struct weston_transform transform;
|
|
struct wl_listener listener;
|
|
float start, stop;
|
|
weston_view_animation_frame_func_t frame;
|
|
weston_view_animation_frame_func_t reset;
|
|
weston_view_animation_done_func_t done;
|
|
void *data;
|
|
void *private;
|
|
};
|
|
|
|
WL_EXPORT void
|
|
weston_view_animation_destroy(struct weston_view_animation *animation)
|
|
{
|
|
wl_list_remove(&animation->animation.link);
|
|
wl_list_remove(&animation->listener.link);
|
|
wl_list_remove(&animation->transform.link);
|
|
if (animation->reset)
|
|
animation->reset(animation);
|
|
weston_view_geometry_dirty(animation->view);
|
|
if (animation->done)
|
|
animation->done(animation, animation->data);
|
|
free(animation);
|
|
}
|
|
|
|
static void
|
|
handle_animation_view_destroy(struct wl_listener *listener, void *data)
|
|
{
|
|
struct weston_view_animation *animation =
|
|
container_of(listener,
|
|
struct weston_view_animation, listener);
|
|
|
|
weston_view_animation_destroy(animation);
|
|
}
|
|
|
|
static void
|
|
weston_view_animation_frame(struct weston_animation *base,
|
|
struct weston_output *output,
|
|
const struct timespec *time)
|
|
{
|
|
struct weston_view_animation *animation =
|
|
container_of(base,
|
|
struct weston_view_animation, animation);
|
|
struct weston_compositor *compositor =
|
|
animation->view->surface->compositor;
|
|
|
|
if (base->frame_counter <= 1)
|
|
animation->spring.timestamp = *time;
|
|
|
|
weston_spring_update(&animation->spring, time);
|
|
|
|
if (weston_spring_done(&animation->spring)) {
|
|
weston_view_schedule_repaint(animation->view);
|
|
weston_view_animation_destroy(animation);
|
|
return;
|
|
}
|
|
|
|
if (animation->frame)
|
|
animation->frame(animation);
|
|
|
|
weston_view_geometry_dirty(animation->view);
|
|
weston_view_schedule_repaint(animation->view);
|
|
|
|
/* The view's output_mask will be zero if its position is
|
|
* offscreen. Animations should always run but as they are also
|
|
* run off the repaint cycle, if there's nothing to repaint
|
|
* the animation stops running. Therefore if we catch this situation
|
|
* and schedule a repaint on all outputs it will be avoided.
|
|
*/
|
|
if (animation->view->output_mask == 0)
|
|
weston_compositor_schedule_repaint(compositor);
|
|
}
|
|
|
|
static void
|
|
idle_animation_destroy(void *data)
|
|
{
|
|
struct weston_view_animation *animation = data;
|
|
|
|
weston_view_animation_destroy(animation);
|
|
}
|
|
|
|
static struct weston_view_animation *
|
|
weston_view_animation_create(struct weston_view *view,
|
|
float start, float stop,
|
|
weston_view_animation_frame_func_t frame,
|
|
weston_view_animation_frame_func_t reset,
|
|
weston_view_animation_done_func_t done,
|
|
void *data,
|
|
void *private)
|
|
{
|
|
struct weston_view_animation *animation;
|
|
struct weston_compositor *ec = view->surface->compositor;
|
|
struct wl_event_loop *loop;
|
|
|
|
animation = malloc(sizeof *animation);
|
|
if (!animation)
|
|
return NULL;
|
|
|
|
animation->view = view;
|
|
animation->frame = frame;
|
|
animation->reset = reset;
|
|
animation->done = done;
|
|
animation->data = data;
|
|
animation->start = start;
|
|
animation->stop = stop;
|
|
animation->private = private;
|
|
|
|
weston_matrix_init(&animation->transform.matrix);
|
|
wl_list_insert(&view->geometry.transformation_list,
|
|
&animation->transform.link);
|
|
|
|
animation->animation.frame = weston_view_animation_frame;
|
|
|
|
animation->listener.notify = handle_animation_view_destroy;
|
|
wl_signal_add(&view->destroy_signal, &animation->listener);
|
|
|
|
if (view->output) {
|
|
wl_list_insert(&view->output->animation_list,
|
|
&animation->animation.link);
|
|
} else {
|
|
wl_list_init(&animation->animation.link);
|
|
loop = wl_display_get_event_loop(ec->wl_display);
|
|
wl_event_loop_add_idle(loop, idle_animation_destroy, animation);
|
|
}
|
|
|
|
return animation;
|
|
}
|
|
|
|
static void
|
|
weston_view_animation_run(struct weston_view_animation *animation)
|
|
{
|
|
struct timespec zero_time = { 0 };
|
|
|
|
animation->animation.frame_counter = 0;
|
|
weston_view_animation_frame(&animation->animation, NULL, &zero_time);
|
|
}
|
|
|
|
static void
|
|
reset_alpha(struct weston_view_animation *animation)
|
|
{
|
|
struct weston_view *view = animation->view;
|
|
|
|
view->alpha = animation->stop;
|
|
}
|
|
|
|
static void
|
|
zoom_frame(struct weston_view_animation *animation)
|
|
{
|
|
struct weston_view *es = animation->view;
|
|
float scale;
|
|
|
|
scale = animation->start +
|
|
(animation->stop - animation->start) *
|
|
animation->spring.current;
|
|
weston_matrix_init(&animation->transform.matrix);
|
|
weston_matrix_translate(&animation->transform.matrix,
|
|
-0.5f * es->surface->width,
|
|
-0.5f * es->surface->height, 0);
|
|
weston_matrix_scale(&animation->transform.matrix, scale, scale, scale);
|
|
weston_matrix_translate(&animation->transform.matrix,
|
|
0.5f * es->surface->width,
|
|
0.5f * es->surface->height, 0);
|
|
|
|
es->alpha = animation->spring.current;
|
|
if (es->alpha > 1.0)
|
|
es->alpha = 1.0;
|
|
}
|
|
|
|
WL_EXPORT struct weston_view_animation *
|
|
weston_zoom_run(struct weston_view *view, float start, float stop,
|
|
weston_view_animation_done_func_t done, void *data)
|
|
{
|
|
struct weston_view_animation *zoom;
|
|
|
|
zoom = weston_view_animation_create(view, start, stop,
|
|
zoom_frame, reset_alpha,
|
|
done, data, NULL);
|
|
|
|
if (zoom == NULL)
|
|
return NULL;
|
|
|
|
weston_spring_init(&zoom->spring, 300.0, start, stop);
|
|
zoom->spring.friction = 1400;
|
|
zoom->spring.previous = start - (stop - start) * 0.03;
|
|
|
|
weston_view_animation_run(zoom);
|
|
|
|
return zoom;
|
|
}
|
|
|
|
static void
|
|
fade_frame(struct weston_view_animation *animation)
|
|
{
|
|
if (animation->spring.current > 0.999)
|
|
animation->view->alpha = 1;
|
|
else if (animation->spring.current < 0.001 )
|
|
animation->view->alpha = 0;
|
|
else
|
|
animation->view->alpha = animation->spring.current;
|
|
}
|
|
|
|
WL_EXPORT struct weston_view_animation *
|
|
weston_fade_run(struct weston_view *view,
|
|
float start, float end, float k,
|
|
weston_view_animation_done_func_t done, void *data)
|
|
{
|
|
struct weston_view_animation *fade;
|
|
|
|
fade = weston_view_animation_create(view, start, end,
|
|
fade_frame, reset_alpha,
|
|
done, data, NULL);
|
|
|
|
if (fade == NULL)
|
|
return NULL;
|
|
|
|
weston_spring_init(&fade->spring, 1000.0, start, end);
|
|
fade->spring.friction = 4000;
|
|
fade->spring.previous = start - (end - start) * 0.1;
|
|
|
|
view->alpha = start;
|
|
|
|
weston_view_animation_run(fade);
|
|
|
|
return fade;
|
|
}
|
|
|
|
WL_EXPORT void
|
|
weston_fade_update(struct weston_view_animation *fade, float target)
|
|
{
|
|
fade->spring.target = target;
|
|
fade->stop = target;
|
|
}
|
|
|
|
static void
|
|
stable_fade_frame(struct weston_view_animation *animation)
|
|
{
|
|
struct weston_view *back_view;
|
|
|
|
if (animation->spring.current > 0.999)
|
|
animation->view->alpha = 1;
|
|
else if (animation->spring.current < 0.001 )
|
|
animation->view->alpha = 0;
|
|
else
|
|
animation->view->alpha = animation->spring.current;
|
|
|
|
back_view = (struct weston_view *) animation->private;
|
|
back_view->alpha =
|
|
(animation->spring.target - animation->view->alpha) /
|
|
(1.0 - animation->view->alpha);
|
|
weston_view_geometry_dirty(back_view);
|
|
}
|
|
|
|
WL_EXPORT struct weston_view_animation *
|
|
weston_stable_fade_run(struct weston_view *front_view, float start,
|
|
struct weston_view *back_view, float end,
|
|
weston_view_animation_done_func_t done, void *data)
|
|
{
|
|
struct weston_view_animation *fade;
|
|
|
|
fade = weston_view_animation_create(front_view, 0, 0,
|
|
stable_fade_frame, NULL,
|
|
done, data, back_view);
|
|
|
|
if (fade == NULL)
|
|
return NULL;
|
|
|
|
weston_spring_init(&fade->spring, 400, start, end);
|
|
fade->spring.friction = 1150;
|
|
|
|
front_view->alpha = start;
|
|
back_view->alpha = end;
|
|
|
|
weston_view_animation_run(fade);
|
|
|
|
return fade;
|
|
}
|
|
|
|
static void
|
|
slide_frame(struct weston_view_animation *animation)
|
|
{
|
|
float scale;
|
|
|
|
scale = animation->start +
|
|
(animation->stop - animation->start) *
|
|
animation->spring.current;
|
|
weston_matrix_init(&animation->transform.matrix);
|
|
weston_matrix_translate(&animation->transform.matrix, 0, scale, 0);
|
|
}
|
|
|
|
WL_EXPORT struct weston_view_animation *
|
|
weston_slide_run(struct weston_view *view, float start, float stop,
|
|
weston_view_animation_done_func_t done, void *data)
|
|
{
|
|
struct weston_view_animation *animation;
|
|
|
|
animation = weston_view_animation_create(view, start, stop,
|
|
slide_frame, NULL, done,
|
|
data, NULL);
|
|
if (!animation)
|
|
return NULL;
|
|
|
|
weston_spring_init(&animation->spring, 400.0, 0.0, 1.0);
|
|
animation->spring.friction = 600;
|
|
animation->spring.clip = WESTON_SPRING_BOUNCE;
|
|
|
|
weston_view_animation_run(animation);
|
|
|
|
return animation;
|
|
}
|
|
|
|
struct weston_move_animation {
|
|
int dx;
|
|
int dy;
|
|
bool reverse;
|
|
bool scale;
|
|
weston_view_animation_done_func_t done;
|
|
};
|
|
|
|
static void
|
|
move_frame(struct weston_view_animation *animation)
|
|
{
|
|
struct weston_move_animation *move = animation->private;
|
|
float scale;
|
|
float progress = animation->spring.current;
|
|
|
|
if (move->reverse)
|
|
progress = 1.0 - progress;
|
|
|
|
scale = animation->start +
|
|
(animation->stop - animation->start) *
|
|
progress;
|
|
weston_matrix_init(&animation->transform.matrix);
|
|
if (move->scale)
|
|
weston_matrix_scale(&animation->transform.matrix, scale, scale,
|
|
1.0f);
|
|
weston_matrix_translate(&animation->transform.matrix,
|
|
move->dx * progress, move->dy * progress,
|
|
0);
|
|
}
|
|
|
|
static void
|
|
move_done(struct weston_view_animation *animation, void *data)
|
|
{
|
|
struct weston_move_animation *move = animation->private;
|
|
|
|
if (move->done)
|
|
move->done(animation, data);
|
|
|
|
free(move);
|
|
}
|
|
|
|
static struct weston_view_animation *
|
|
weston_move_scale_run_internal(struct weston_view *view, int dx, int dy,
|
|
float start, float end, bool reverse, bool scale,
|
|
weston_view_animation_done_func_t done,
|
|
void *data)
|
|
{
|
|
struct weston_move_animation *move;
|
|
struct weston_view_animation *animation;
|
|
|
|
move = malloc(sizeof(*move));
|
|
if (!move)
|
|
return NULL;
|
|
move->dx = dx;
|
|
move->dy = dy;
|
|
move->reverse = reverse;
|
|
move->scale = scale;
|
|
move->done = done;
|
|
|
|
animation = weston_view_animation_create(view, start, end, move_frame,
|
|
NULL, move_done, data, move);
|
|
|
|
if (animation == NULL){
|
|
free(move);
|
|
return NULL;
|
|
}
|
|
|
|
weston_spring_init(&animation->spring, 400.0, 0.0, 1.0);
|
|
animation->spring.friction = 1150;
|
|
|
|
weston_view_animation_run(animation);
|
|
|
|
return animation;
|
|
}
|
|
|
|
WL_EXPORT struct weston_view_animation *
|
|
weston_move_scale_run(struct weston_view *view, int dx, int dy,
|
|
float start, float end, bool reverse,
|
|
weston_view_animation_done_func_t done, void *data)
|
|
{
|
|
return weston_move_scale_run_internal(view, dx, dy, start, end, reverse,
|
|
true, done, data);
|
|
}
|
|
|
|
WL_EXPORT struct weston_view_animation *
|
|
weston_move_run(struct weston_view *view, int dx, int dy,
|
|
float start, float end, bool reverse,
|
|
weston_view_animation_done_func_t done, void *data)
|
|
{
|
|
return weston_move_scale_run_internal(view, dx, dy, start, end, reverse,
|
|
false, done, data);
|
|
}
|