clients/image.c

   1 /*
   2  * Copyright © 2008 Kristian Høgsberg
   3  * Copyright © 2009 Chris Wilson
   4  *
   5  * Permission to use, copy, modify, distribute, and sell this software and its
   6  * documentation for any purpose is hereby granted without fee, provided that
   7  * the above copyright notice appear in all copies and that both that copyright
   8  * notice and this permission notice appear in supporting documentation, and
   9  * that the name of the copyright holders not be used in advertising or
  10  * publicity pertaining to distribution of the software without specific,
  11  * written prior permission.  The copyright holders make no representations
  12  * about the suitability of this software for any purpose.  It is provided "as
  13  * is" without express or implied warranty.
  14  *
  15  * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  16  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  17  * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  18  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  19  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  20  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  21  * OF THIS SOFTWARE.
  22  */
  23
  24 #include <stdint.h>
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <stdbool.h>
  28 #include <string.h>
  29 #include <fcntl.h>
  30 #include <libgen.h>
  31 #include <unistd.h>
  32 #include <math.h>
  33 #include <time.h>
  34 #include <cairo.h>
  35 #include <assert.h>
  36 #include <linux/input.h>
  37
  38 #include <wayland-client.h>
  39
  40 #include "window.h"
  41 #include "../shared/cairo-util.h"
  42
  43 struct image {
  44         struct window *window;
  45         struct widget *widget;
  46         struct display *display;
  47         char *filename;
  48         cairo_surface_t *image;
  49         int fullscreen;
  50         int *image_counter;
  51         int32_t width, height;
  52
  53         struct {
  54                 double x;
  55                 double y;
  56         } pointer;
  57         bool button_pressed;
  58
  59         bool initialized;
  60         cairo_matrix_t matrix;
  61 };
  62
  63 static double
  64 get_scale(struct image *image)
  65 {
  66         assert(image->matrix.xy == 0.0 &&
  67                image->matrix.yx == 0.0 &&
  68                image->matrix.xx == image->matrix.yy);
  69         return image->matrix.xx;
  70 }
  71
  72 static void
  73 clamp_view(struct image *image)
  74 {
  75         struct rectangle allocation;
  76         double scale = get_scale(image);
  77         double sw, sh;
  78
  79         sw = image->width * scale;
  80         sh = image->height * scale;
  81         widget_get_allocation(image->widget, &allocation);
  82
  83         if (sw < allocation.width) {
  84                 image->matrix.x0 =
  85                         (allocation.width - image->width * scale) / 2;
  86         } else {
  87                 if (image->matrix.x0 > 0.0)
  88                         image->matrix.x0 = 0.0;
  89                 if (sw + image->matrix.x0 < allocation.width)
  90                         image->matrix.x0 = allocation.width - sw;
  91         }
  92
  93         if (sh < allocation.width) {
  94                 image->matrix.y0 =
  95                         (allocation.height - image->height * scale) / 2;
  96         } else {
  97                 if (image->matrix.y0 > 0.0)
  98                         image->matrix.y0 = 0.0;
  99                 if (sh + image->matrix.y0 < allocation.height)
 100                         image->matrix.y0 = allocation.height - sh;
 101         }
 102 }
 103
 104 static void
 105 redraw_handler(struct widget *widget, void *data)
 106 {
 107         struct image *image = data;
 108         struct rectangle allocation;
 109         cairo_t *cr;
 110         cairo_surface_t *surface;
 111         double width, height, doc_aspect, window_aspect, scale;
 112         cairo_matrix_t matrix;
 113         cairo_matrix_t translate;
 114
 115         surface = window_get_surface(image->window);
 116         cr = cairo_create(surface);
 117         widget_get_allocation(image->widget, &allocation);
 118         cairo_rectangle(cr, allocation.x, allocation.y,
 119                         allocation.width, allocation.height);
 120         cairo_clip(cr);
 121         cairo_push_group(cr);
 122         cairo_translate(cr, allocation.x, allocation.y);
 123
 124         cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
 125         cairo_set_source_rgba(cr, 0, 0, 0, 1);
 126         cairo_paint(cr);
 127
 128         if (!image->initialized) {
 129                 image->initialized = true;
 130                 width = cairo_image_surface_get_width(image->image);
 131                 height = cairo_image_surface_get_height(image->image);
 132
 133                 doc_aspect = width / height;
 134                 window_aspect = (double) allocation.width / allocation.height;
 135                 if (doc_aspect < window_aspect)
 136                         scale = allocation.height / height;
 137                 else
 138                         scale = allocation.width / width;
 139
 140                 image->width = width;
 141                 image->height = height;
 142                 cairo_matrix_init_scale(&image->matrix, scale, scale);
 143
 144                 clamp_view(image);
 145         }
 146
 147         matrix = image->matrix;
 148         cairo_matrix_init_translate(&translate, allocation.x, allocation.y);
 149         cairo_matrix_multiply(&matrix, &matrix, &translate);
 150         cairo_set_matrix(cr, &matrix);
 151
 152         cairo_set_source_surface(cr, image->image, 0, 0);
 153         cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
 154         cairo_paint(cr);
 155
 156         cairo_pop_group_to_source(cr);
 157         cairo_paint(cr);
 158         cairo_destroy(cr);
 159
 160         cairo_surface_destroy(surface);
 161 }
 162
 163 static void
 164 resize_handler(struct widget *widget,
 165                int32_t width, int32_t height, void *data)
 166 {
 167         struct image *image = data;
 168
 169         clamp_view(image);
 170 }
 171
 172 static void
 173 keyboard_focus_handler(struct window *window,
 174                        struct input *device, void *data)
 175 {
 176         struct image *image = data;
 177
 178         window_schedule_redraw(image->window);
 179 }
 180
 181 static int
 182 enter_handler(struct widget *widget,
 183               struct input *input,
 184               float x, float y, void *data)
 185 {
 186         struct image *image = data;
 187         struct rectangle allocation;
 188
 189         widget_get_allocation(image->widget, &allocation);
 190         x -= allocation.x;
 191         y -= allocation.y;
 192
 193         image->pointer.x = x;
 194         image->pointer.y = y;
 195
 196         return 1;
 197 }
 198
 199 static void
 200 move_viewport(struct image *image, double dx, double dy)
 201 {
 202         double scale = get_scale(image);
 203
 204         if (!image->initialized)
 205                 return;
 206
 207         cairo_matrix_translate(&image->matrix, -dx/scale, -dy/scale);
 208         clamp_view(image);
 209
 210         window_schedule_redraw(image->window);
 211 }
 212
 213 static int
 214 motion_handler(struct widget *widget,
 215                struct input *input, uint32_t time,
 216                float x, float y, void *data)
 217 {
 218         struct image *image = data;
 219         struct rectangle allocation;
 220
 221         widget_get_allocation(image->widget, &allocation);
 222         x -= allocation.x;
 223         y -= allocation.y;
 224
 225         if (image->button_pressed)
 226                 move_viewport(image, image->pointer.x - x,
 227                               image->pointer.y - y);
 228
 229         image->pointer.x = x;
 230         image->pointer.y = y;
 231
 232         return image->button_pressed ? CURSOR_DRAGGING : CURSOR_LEFT_PTR;
 233 }
 234
 235 static void
 236 button_handler(struct widget *widget,
 237                struct input *input, uint32_t time,
 238                uint32_t button,
 239                enum wl_pointer_button_state state,
 240                void *data)
 241 {
 242         struct image *image = data;
 243
 244         if (button == BTN_LEFT) {
 245                 image->button_pressed =
 246                         state == WL_POINTER_BUTTON_STATE_PRESSED;
 247
 248                 if (state == WL_POINTER_BUTTON_STATE_PRESSED)
 249                         input_set_pointer_image(input, CURSOR_DRAGGING);
 250                 else
 251                         input_set_pointer_image(input, CURSOR_LEFT_PTR);
 252         }
 253 }
 254
 255 static void
 256 zoom(struct image *image, double scale)
 257 {
 258         double x = image->pointer.x;
 259         double y = image->pointer.y;
 260         cairo_matrix_t scale_matrix;
 261
 262         if (!image->initialized)
 263                 return;
 264
 265         if (get_scale(image) * scale > 20.0 ||
 266             get_scale(image) * scale < 0.02)
 267                 return;
 268
 269         cairo_matrix_init_identity(&scale_matrix);
 270         cairo_matrix_translate(&scale_matrix, x, y);
 271         cairo_matrix_scale(&scale_matrix, scale, scale);
 272         cairo_matrix_translate(&scale_matrix, -x, -y);
 273
 274         cairo_matrix_multiply(&image->matrix, &image->matrix, &scale_matrix);
 275         clamp_view(image);
 276 }
 277
 278 static void
 279 key_handler(struct window *window, struct input *input, uint32_t time,
 280             uint32_t key, uint32_t sym, enum wl_keyboard_key_state state,
 281             void *data)
 282 {
 283         struct image *image = data;
 284
 285         if (state == WL_KEYBOARD_KEY_STATE_RELEASED)
 286                 return;
 287
 288         switch (sym) {
 289         case XKB_KEY_minus:
 290                 zoom(image, 0.8);
 291                 window_schedule_redraw(image->window);
 292                 break;
 293         case XKB_KEY_equal:
 294         case XKB_KEY_plus:
 295                 zoom(image, 1.2);
 296                 window_schedule_redraw(image->window);
 297                 break;
 298         case XKB_KEY_1:
 299                 image->matrix.xx = 1.0;
 300                 image->matrix.xy = 0.0;
 301                 image->matrix.yx = 0.0;
 302                 image->matrix.yy = 1.0;
 303                 clamp_view(image);
 304                 window_schedule_redraw(image->window);
 305                 break;
 306         }
 307 }
 308
 309 static void
 310 axis_handler(struct widget *widget, struct input *input, uint32_t time,
 311              uint32_t axis, wl_fixed_t value, void *data)
 312 {
 313         struct image *image = data;
 314
 315         if (axis == WL_POINTER_AXIS_VERTICAL_SCROLL &&
 316             input_get_modifiers(input) == MOD_CONTROL_MASK) {
 317                 /* set zoom level to 2% per 10 axis units */
 318                 zoom(image, (1.0 - wl_fixed_to_double(value) / 500.0));
 319
 320                 window_schedule_redraw(image->window);
 321         } else if (input_get_modifiers(input) == 0) {
 322                 if (axis == WL_POINTER_AXIS_VERTICAL_SCROLL)
 323                         move_viewport(image, 0, wl_fixed_to_double(value));
 324                 else if (axis == WL_POINTER_AXIS_HORIZONTAL_SCROLL)
 325                         move_viewport(image, wl_fixed_to_double(value), 0);
 326         }
 327 }
 328
 329 static void
 330 fullscreen_handler(struct window *window, void *data)
 331 {
 332         struct image *image = data;
 333
 334         image->fullscreen ^= 1;
 335         window_set_fullscreen(window, image->fullscreen);
 336 }
 337
 338 static void
 339 close_handler(struct window *window, void *data)
 340 {
 341         struct image *image = data;
 342
 343         *image->image_counter -= 1;
 344
 345         if (*image->image_counter == 0)
 346                 display_exit(image->display);
 347
 348         widget_destroy(image->widget);
 349         window_destroy(image->window);
 350
 351         free(image);
 352 }
 353
 354 static struct image *
 355 image_create(struct display *display, const char *filename,
 356              int *image_counter)
 357 {
 358         struct image *image;
 359         char *b, *copy, title[512];;
 360
 361         image = malloc(sizeof *image);
 362         if (image == NULL)
 363                 return image;
 364         memset(image, 0, sizeof *image);
 365
 366         copy = strdup(filename);
 367         b = basename(copy);
 368         snprintf(title, sizeof title, "Wayland Image - %s", b);
 369         free(copy);
 370
 371         image->filename = strdup(filename);
 372         image->image = load_cairo_surface(filename);
 373
 374         if (!image->image) {
 375                 fprintf(stderr, "could not find the image %s!\n", b);
 376                 return NULL;
 377         }
 378
 379         image->window = window_create(display);
 380         image->widget = frame_create(image->window, image);
 381         window_set_title(image->window, title);
 382         image->display = display;
 383         image->image_counter = image_counter;
 384         *image_counter += 1;
 385         image->initialized = false;
 386
 387         window_set_user_data(image->window, image);
 388         widget_set_redraw_handler(image->widget, redraw_handler);
 389         widget_set_resize_handler(image->widget, resize_handler);
 390         window_set_keyboard_focus_handler(image->window,
 391                                           keyboard_focus_handler);
 392         window_set_fullscreen_handler(image->window, fullscreen_handler);
 393         window_set_close_handler(image->window, close_handler);
 394
 395         widget_set_enter_handler(image->widget, enter_handler);
 396         widget_set_motion_handler(image->widget, motion_handler);
 397         widget_set_button_handler(image->widget, button_handler);
 398         widget_set_axis_handler(image->widget, axis_handler);
 399         window_set_key_handler(image->window, key_handler);
 400         widget_schedule_resize(image->widget, 500, 400);
 401
 402         return image;
 403 }
 404
 405 int
 406 main(int argc, char *argv[])
 407 {
 408         struct display *d;
 409         int i;
 410         int image_counter = 0;
 411
 412         d = display_create(argc, argv);
 413         if (d == NULL) {
 414                 fprintf(stderr, "failed to create display: %m\n");
 415                 return -1;
 416         }
 417
 418         for (i = 1; i < argc; i++)
 419                 image_create(d, argv[i], &image_counter);
 420
 421         if (image_counter > 0)
 422                 display_run(d);
 423
 424         return 0;
 425 }