src/util.c

   1 /*
   2  * Copyright © 2011 Intel Corporation
   3  *
   4  * Permission to use, copy, modify, distribute, and sell this software and
   5  * its documentation for any purpose is hereby granted without fee, provided
   6  * that the above copyright notice appear in all copies and that both that
   7  * copyright notice and this permission notice appear in supporting
   8  * documentation, and that the name of the copyright holders not be used in
   9  * advertising or publicity pertaining to distribution of the software
  10  * without specific, written prior permission.  The copyright holders make
  11  * no representations about the suitability of this software for any
  12  * purpose.  It is provided "as is" without express or implied warranty.
  13  *
  14  * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
  15  * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  16  * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
  17  * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
  18  * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
  19  * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  20  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  21  */
  22
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <stdio.h>
  26 #include <math.h>
  27
  28 #include "compositor.h"
  29
  30 WL_EXPORT void
  31 weston_matrix_init(struct weston_matrix *matrix)
  32 {
  33         static const struct weston_matrix identity = {
  34                 { 1, 0, 0, 0,  0, 1, 0, 0,  0, 0, 1, 0,  0, 0, 0, 1 }
  35         };
  36
  37         memcpy(matrix, &identity, sizeof identity);
  38 }
  39
  40 static void
  41 weston_matrix_multiply(struct weston_matrix *m, const struct weston_matrix *n)
  42 {
  43         struct weston_matrix tmp;
  44         const GLfloat *row, *column;
  45         div_t d;
  46         int i, j;
  47
  48         for (i = 0; i < 16; i++) {
  49                 tmp.d[i] = 0;
  50                 d = div(i, 4);
  51                 row = m->d + d.quot * 4;
  52                 column = n->d + d.rem;
  53                 for (j = 0; j < 4; j++)
  54                         tmp.d[i] += row[j] * column[j * 4];
  55         }
  56         memcpy(m, &tmp, sizeof tmp);
  57 }
  58
  59 WL_EXPORT void
  60 weston_matrix_translate(struct weston_matrix *matrix, GLfloat x, GLfloat y, GLfloat z)
  61 {
  62         struct weston_matrix translate = {
  63                 { 1, 0, 0, 0,  0, 1, 0, 0,  0, 0, 1, 0,  x, y, z, 1 }
  64         };
  65
  66         weston_matrix_multiply(matrix, &translate);
  67 }
  68
  69 WL_EXPORT void
  70 weston_matrix_scale(struct weston_matrix *matrix, GLfloat x, GLfloat y, GLfloat z)
  71 {
  72         struct weston_matrix scale = {
  73                 { x, 0, 0, 0,  0, y, 0, 0,  0, 0, z, 0,  0, 0, 0, 1 }
  74         };
  75
  76         weston_matrix_multiply(matrix, &scale);
  77 }
  78
  79 WL_EXPORT void
  80 weston_matrix_transform(struct weston_matrix *matrix, struct weston_vector *v)
  81 {
  82         int i, j;
  83         struct weston_vector t;
  84
  85         for (i = 0; i < 4; i++) {
  86                 t.f[i] = 0;
  87                 for (j = 0; j < 4; j++)
  88                         t.f[i] += v->f[j] * matrix->d[i + j * 4];
  89         }
  90
  91         *v = t;
  92 }
  93
  94 WL_EXPORT void
  95 weston_spring_init(struct weston_spring *spring,
  96                  double k, double current, double target)
  97 {
  98         spring->k = k;
  99         spring->friction = 400.0;
 100         spring->current = current;
 101         spring->previous = current;
 102         spring->target = target;
 103 }
 104
 105 WL_EXPORT void
 106 weston_spring_update(struct weston_spring *spring, uint32_t msec)
 107 {
 108         double force, v, current, step;
 109
 110         step = 0.01;
 111         while (4 < msec - spring->timestamp) {
 112                 current = spring->current;
 113                 v = current - spring->previous;
 114                 force = spring->k * (spring->target - current) / 10.0 +
 115                         (spring->previous - current) - v * spring->friction;
 116
 117                 spring->current =
 118                         current + (current - spring->previous) +
 119                         force * step * step;
 120                 spring->previous = current;
 121
 122 #if 0
 123                 if (spring->current >= 1.0) {
 124 #ifdef TWEENER_BOUNCE
 125                         spring->current = 2.0 - spring->current;
 126                         spring->previous = 2.0 - spring->previous;
 127 #else
 128                         spring->current = 1.0;
 129                         spring->previous = 1.0;
 130 #endif
 131                 }
 132
 133                 if (spring->current <= 0.0) {
 134                         spring->current = 0.0;
 135                         spring->previous = 0.0;
 136                 }
 137 #endif
 138                 spring->timestamp += 4;
 139         }
 140 }
 141
 142 WL_EXPORT int
 143 weston_spring_done(struct weston_spring *spring)
 144 {
 145         return fabs(spring->previous - spring->target) < 0.0002 &&
 146                 fabs(spring->current - spring->target) < 0.0002;
 147 }
 148
 149 struct weston_zoom {
 150         struct weston_surface *surface;
 151         struct weston_animation animation;
 152         struct weston_spring spring;
 153         struct weston_transform transform;
 154         struct wl_listener listener;
 155         GLfloat start, stop;
 156         void (*done)(struct weston_zoom *zoom, void *data);
 157         void *data;
 158 };
 159
 160 static void
 161 weston_zoom_destroy(struct weston_zoom *zoom)
 162 {
 163         wl_list_remove(&zoom->animation.link);
 164         wl_list_remove(&zoom->listener.link);
 165         zoom->surface->transform = NULL;
 166         if (zoom->done)
 167                 zoom->done(zoom, zoom->data);
 168         free(zoom);
 169 }
 170
 171 static void
 172 handle_zoom_surface_destroy(struct wl_listener *listener,
 173                             struct wl_resource *resource, uint32_t time)
 174 {
 175         struct weston_zoom *zoom =
 176                 container_of(listener, struct weston_zoom, listener);
 177
 178         weston_zoom_destroy(zoom);
 179 }
 180
 181 static void
 182 weston_zoom_frame(struct weston_animation *animation,
 183                 struct weston_output *output, uint32_t msecs)
 184 {
 185         struct weston_zoom *zoom =
 186                 container_of(animation, struct weston_zoom, animation);
 187         struct weston_surface *es = zoom->surface;
 188         GLfloat scale;
 189
 190         weston_spring_update(&zoom->spring, msecs);
 191
 192         if (weston_spring_done(&zoom->spring))
 193                 weston_zoom_destroy(zoom);
 194
 195         scale = zoom->start +
 196                 (zoom->stop - zoom->start) * zoom->spring.current;
 197         weston_matrix_init(&zoom->transform.matrix);
 198         weston_matrix_translate(&zoom->transform.matrix,
 199                               -(es->x + es->width / 2.0),
 200                               -(es->y + es->height / 2.0), 0);
 201         weston_matrix_scale(&zoom->transform.matrix, scale, scale, scale);
 202         weston_matrix_translate(&zoom->transform.matrix,
 203                               es->x + es->width / 2.0,
 204                               es->y + es->height / 2.0, 0);
 205
 206         es->alpha = zoom->spring.current * 255;
 207         if (es->alpha > 255)
 208                 es->alpha = 255;
 209         scale = 1.0 / zoom->spring.current;
 210         weston_matrix_init(&zoom->transform.inverse);
 211         weston_matrix_scale(&zoom->transform.inverse, scale, scale, scale);
 212
 213         weston_compositor_damage_all(es->compositor);
 214 }
 215
 216 WL_EXPORT struct weston_zoom *
 217 weston_zoom_run(struct weston_surface *surface, GLfloat start, GLfloat stop,
 218               weston_zoom_done_func_t done, void *data)
 219 {
 220         struct weston_zoom *zoom;
 221
 222         zoom = malloc(sizeof *zoom);
 223         if (!zoom)
 224                 return NULL;
 225
 226         zoom->surface = surface;
 227         zoom->done = done;
 228         zoom->data = data;
 229         zoom->start = start;
 230         zoom->stop = stop;
 231         surface->transform = &zoom->transform;
 232         weston_spring_init(&zoom->spring, 200.0, 0.0, 1.0);
 233         zoom->spring.friction = 700;
 234         zoom->spring.timestamp = weston_compositor_get_time();
 235         zoom->animation.frame = weston_zoom_frame;
 236         weston_zoom_frame(&zoom->animation, NULL, zoom->spring.timestamp);
 237
 238         zoom->listener.func = handle_zoom_surface_destroy;
 239         wl_list_insert(surface->surface.resource.destroy_listener_list.prev,
 240                        &zoom->listener.link);
 241
 242         wl_list_insert(surface->compositor->animation_list.prev,
 243                        &zoom->animation.link);
 244
 245         return zoom;
 246 }
 247
 248 struct weston_binding {
 249         uint32_t key;
 250         uint32_t button;
 251         uint32_t modifier;
 252         weston_binding_handler_t handler;
 253         void *data;
 254         struct wl_list link;
 255 };
 256
 257 WL_EXPORT struct weston_binding *
 258 weston_compositor_add_binding(struct weston_compositor *compositor,
 259                             uint32_t key, uint32_t button, uint32_t modifier,
 260                             weston_binding_handler_t handler, void *data)
 261 {
 262         struct weston_binding *binding;
 263
 264         binding = malloc(sizeof *binding);
 265         if (binding == NULL)
 266                 return NULL;
 267
 268         binding->key = key;
 269         binding->button = button;
 270         binding->modifier = modifier;
 271         binding->handler = handler;
 272         binding->data = data;
 273         wl_list_insert(compositor->binding_list.prev, &binding->link);
 274
 275         return binding;
 276 }
 277
 278 WL_EXPORT void
 279 weston_binding_destroy(struct weston_binding *binding)
 280 {
 281         wl_list_remove(&binding->link);
 282         free(binding);
 283 }
 284
 285 WL_EXPORT void
 286 weston_compositor_run_binding(struct weston_compositor *compositor,
 287                             struct weston_input_device *device,
 288                             uint32_t time,
 289                             uint32_t key, uint32_t button, int32_t state)
 290 {
 291         struct weston_binding *b;
 292
 293         wl_list_for_each(b, &compositor->binding_list, link) {
 294                 if (b->key == key && b->button == button &&
 295                     b->modifier == device->modifier_state && state) {
 296                         b->handler(&device->input_device,
 297                                    time, key, button, state, b->data);
 298                         break;
 299                 }
 300         }
 301 }