/* * 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 #include #include #include #include #include #include #include #include #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; struct wl_event_source *idle_destroy_source; 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); weston_view_remove_transform(animation->view, &animation->transform); if (animation->reset) animation->reset(animation); 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); if (animation->idle_destroy_source) wl_event_source_remove(animation->idle_destroy_source); 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)) { if (animation->idle_destroy_source) wl_event_source_remove(animation->idle_destroy_source); weston_view_animation_destroy(animation); return; } if (animation->frame) animation->frame(animation); weston_view_add_transform(animation->view, &animation->view->geometry.transformation_list, &animation->transform); weston_view_update_transform(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 = zalloc(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_init(&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); animation->idle_destroy_source = 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; weston_view_set_alpha(view, animation->stop); weston_view_update_transform(view); } 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); weston_view_set_alpha(es, MIN(animation->spring.current, 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) { float alpha; if (animation->spring.current > 0.999) alpha = 1.0; else if (animation->spring.current < 0.001) alpha = 0.0; else alpha = animation->spring.current; weston_view_set_alpha(animation->view, alpha); } WL_EXPORT struct weston_view_animation * weston_fade_run(struct weston_view *view, float start, float end, 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; weston_view_set_alpha(view, start); weston_view_update_transform(view); 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; float alpha; if (animation->spring.current > 0.999) alpha = 1.0; else if (animation->spring.current < 0.001) alpha = 0.0; else alpha = animation->spring.current; weston_view_set_alpha(animation->view, alpha); back_view = (struct weston_view *) animation->private; alpha = (animation->spring.target - animation->view->alpha) / (1.0 - animation->view->alpha); weston_view_set_alpha(back_view, alpha); } 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; weston_view_set_alpha(front_view, start); weston_view_set_alpha(back_view, 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); }