clients/transformed.c

   1 /*
   2  * Copyright © 2008 Kristian Høgsberg
   3  * Copyright © 2012 Intel Corporation
   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 <string.h>
  28 #include <math.h>
  29 #include <cairo.h>
  30
  31 #include <linux/input.h>
  32 #include <wayland-client.h>
  33 #include "window.h"
  34
  35 struct transformed {
  36         struct display *display;
  37         struct window *window;
  38         struct widget *widget;
  39         int width, height;
  40         int fullscreen;
  41 };
  42
  43 static void
  44 draw_stuff(cairo_t *cr, int width, int height)
  45 {
  46         cairo_matrix_t m;
  47         cairo_get_matrix (cr, &m);
  48
  49         cairo_translate(cr, width / 2, height / 2);
  50         cairo_scale(cr, width / 2, height / 2);
  51
  52         cairo_set_source_rgba(cr, 0, 0, 0.3, 1.0);
  53         cairo_set_source_rgba(cr, 0, 0, 0, 1.0);
  54         cairo_rectangle(cr, -1, -1, 2, 2);
  55         cairo_fill(cr);
  56
  57         cairo_set_source_rgb(cr, 1, 0, 0);
  58         cairo_move_to(cr, 0,  0);
  59         cairo_line_to(cr, 0, -1);
  60
  61         cairo_save(cr);
  62         cairo_set_matrix(cr, &m);
  63         cairo_set_line_width(cr, 2.0);
  64         cairo_stroke(cr);
  65         cairo_restore(cr);
  66
  67         cairo_set_source_rgb(cr, 0, 1, 0);
  68         cairo_move_to(cr, 0, 0);
  69         cairo_line_to(cr, 1, 0);
  70
  71         cairo_save(cr);
  72         cairo_set_matrix(cr, &m);
  73         cairo_set_line_width(cr, 2.0);
  74         cairo_stroke(cr);
  75         cairo_restore(cr);
  76
  77         cairo_set_source_rgb(cr, 1, 1, 1);
  78         cairo_move_to(cr, 0, 0);
  79         cairo_line_to(cr, 0, 1);
  80         cairo_move_to(cr,  0, 0);
  81         cairo_line_to(cr, -1, 0);
  82
  83         cairo_save(cr);
  84         cairo_set_matrix(cr, &m);
  85         cairo_set_line_width(cr, 2.0);
  86         cairo_stroke(cr);
  87         cairo_restore(cr);
  88
  89         cairo_destroy(cr);
  90 }
  91
  92 static void
  93 fullscreen_handler(struct window *window, void *data)
  94 {
  95         struct transformed *transformed = data;
  96
  97         transformed->fullscreen ^= 1;
  98         window_set_fullscreen(window, transformed->fullscreen);
  99 }
 100
 101 static void
 102 redraw_handler(struct widget *widget, void *data)
 103 {
 104         struct transformed *transformed = data;
 105         struct rectangle allocation;
 106         cairo_surface_t *surface;
 107         cairo_t *cr;
 108
 109         surface = window_get_surface(transformed->window);
 110         if (surface == NULL ||
 111             cairo_surface_status(surface) != CAIRO_STATUS_SUCCESS) {
 112                 fprintf(stderr, "failed to create cairo egl surface\n");
 113                 return;
 114         }
 115
 116         widget_get_allocation(transformed->widget, &allocation);
 117
 118         cr = widget_cairo_create(widget);
 119         draw_stuff(cr, allocation.width, allocation.height);
 120
 121         cairo_surface_destroy(surface);
 122 }
 123
 124 static void
 125 output_handler(struct window *window, struct output *output, int enter,
 126                void *data)
 127 {
 128         if (!enter)
 129                 return;
 130
 131         window_set_buffer_transform(window, output_get_transform(output));
 132         window_set_buffer_scale(window, output_get_scale(output));
 133         window_schedule_redraw(window);
 134 }
 135
 136 static void
 137 key_handler(struct window *window, struct input *input, uint32_t time,
 138             uint32_t key, uint32_t sym, enum wl_keyboard_key_state state,
 139             void *data)
 140 {
 141         int transform, scale;
 142
 143         if (state == WL_KEYBOARD_KEY_STATE_RELEASED)
 144                 return;
 145
 146         transform = window_get_buffer_transform (window);
 147         scale = window_get_buffer_scale (window);
 148         switch (sym) {
 149         case XKB_KEY_Left:
 150                 if (transform == 0)
 151                         transform = 3;
 152                 else if (transform == 4)
 153                         transform = 7;
 154                 else
 155                         transform--;
 156                 break;
 157
 158         case XKB_KEY_Right:
 159                 if (transform == 3)
 160                         transform = 0;
 161                 else if (transform == 7)
 162                         transform = 4;
 163                 else
 164                         transform++;
 165                 break;
 166
 167         case XKB_KEY_space:
 168                 if (transform >= 4)
 169                         transform -= 4;
 170                 else
 171                         transform += 4;
 172                 break;
 173
 174         case XKB_KEY_z:
 175                 if (scale == 1)
 176                         scale = 2;
 177                 else
 178                         scale = 1;
 179                 break;
 180         }
 181
 182         printf ("setting buffer transform to %d\n", transform);
 183         printf ("setting buffer scale to %d\n", scale);
 184         window_set_buffer_transform(window, transform);
 185         window_set_buffer_scale(window, scale);
 186         window_schedule_redraw(window);
 187 }
 188
 189 static void
 190 button_handler(struct widget *widget,
 191                struct input *input, uint32_t time,
 192                uint32_t button, enum wl_pointer_button_state state, void *data)
 193 {
 194         struct transformed *transformed = data;
 195
 196         switch (button) {
 197         case BTN_LEFT:
 198                 if (state == WL_POINTER_BUTTON_STATE_PRESSED)
 199                         window_move(transformed->window, input,
 200                                     display_get_serial(transformed->display));
 201                 break;
 202         case BTN_MIDDLE:
 203                 if (state == WL_POINTER_BUTTON_STATE_PRESSED)
 204                         widget_schedule_redraw(widget);
 205                 break;
 206         case BTN_RIGHT:
 207                 if (state == WL_POINTER_BUTTON_STATE_PRESSED)
 208                         window_show_frame_menu(transformed->window, input, time);
 209                 break;
 210         }
 211 }
 212
 213 static void
 214 touch_handler(struct widget *widget, struct input *input,
 215                    uint32_t serial, uint32_t time, int32_t id,
 216                    float x, float y, void *data)
 217 {
 218         struct transformed *transformed = data;
 219         window_move(transformed->window, input, display_get_serial(transformed->display));
 220 }
 221
 222 static void
 223 usage(int error_code)
 224 {
 225         fprintf(stderr, "Usage: transformed [OPTIONS]\n\n"
 226                 "   -d\t\tUse \"driver\" fullscreen method\n"
 227                 "   -w <width>\tSet window width to <width>\n"
 228                 "   -h <height>\tSet window height to <height>\n"
 229                 "   --help\tShow this help text\n\n");
 230
 231         exit(error_code);
 232 }
 233
 234 int main(int argc, char *argv[])
 235 {
 236         struct transformed transformed;
 237         struct display *d;
 238         int i;
 239
 240         transformed.width = 500;
 241         transformed.height = 250;
 242         transformed.fullscreen = 0;
 243
 244         for (i = 1; i < argc; i++) {
 245                 if (strcmp(argv[i], "-w") == 0) {
 246                         if (++i >= argc)
 247                                 usage(EXIT_FAILURE);
 248
 249                         transformed.width = atol(argv[i]);
 250                 } else if (strcmp(argv[i], "-h") == 0) {
 251                         if (++i >= argc)
 252                                 usage(EXIT_FAILURE);
 253
 254                         transformed.height = atol(argv[i]);
 255                 } else if (strcmp(argv[i], "--help") == 0)
 256                         usage(EXIT_SUCCESS);
 257                 else
 258                         usage(EXIT_FAILURE);
 259         }
 260
 261         d = display_create(&argc, argv);
 262         if (d == NULL) {
 263                 fprintf(stderr, "failed to create display: %m\n");
 264                 return -1;
 265         }
 266
 267         transformed.display = d;
 268         transformed.window = window_create(d);
 269         transformed.widget =
 270                 window_add_widget(transformed.window, &transformed);
 271
 272         window_set_title(transformed.window, "Transformed");
 273
 274         widget_set_transparent(transformed.widget, 0);
 275         widget_set_default_cursor(transformed.widget, CURSOR_BLANK);
 276
 277         widget_set_redraw_handler(transformed.widget, redraw_handler);
 278         widget_set_button_handler(transformed.widget, button_handler);
 279
 280         widget_set_touch_down_handler(transformed.widget, touch_handler);
 281
 282         window_set_key_handler(transformed.window, key_handler);
 283         window_set_fullscreen_handler(transformed.window, fullscreen_handler);
 284         window_set_output_handler(transformed.window, output_handler);
 285
 286         window_set_user_data(transformed.window, &transformed);
 287         window_schedule_resize(transformed.window,
 288                                transformed.width, transformed.height);
 289
 290         display_run(d);
 291
 292         return 0;
 293 }