clients/eventdemo.c

   1 /*
   2  * Copyright © 2011 Tim Wiederhake
   3  *
   4  * Permission to use, copy, modify, distribute, and sell this software and its
   5  * documentation for any purpose is hereby granted without fee, provided that
   6  * the above copyright notice appear in all copies and that both that copyright
   7  * notice and this permission notice appear in supporting documentation, and
   8  * that the name of the copyright holders not be used in advertising or
   9  * publicity pertaining to distribution of the software without specific,
  10  * written prior permission.  The copyright holders make no representations
  11  * about the suitability of this software for any purpose.  It is provided "as
  12  * is" without express or implied warranty.
  13  *
  14  * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  15  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  16  * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  17  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  18  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  19  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  20  * OF THIS SOFTWARE.
  21  */
  22
  23 /**
  24  * \file eventdemo.c
  25  * \brief Demonstrate the use of Wayland's toytoolkit.
  26  *
  27  * Heavily commented demo program that can report all events that are
  28  * dispatched to the window. For other functionality, eg. opengl/egl,
  29  * drag and drop, etc. have a look at the other demos.
  30  * \author Tim Wiederhake
  31  */
  32
  33 #include "config.h"
  34
  35 #include <stdio.h>
  36 #include <stdlib.h>
  37
  38 #include <cairo.h>
  39
  40 #include "window.h"
  41
  42 /** window title */
  43 static char *title = "EventDemo";
  44
  45 /** window width */
  46 static int width = 500;
  47
  48 /** window height */
  49 static int height = 400;
  50
  51 /** set if window has no borders */
  52 static int noborder = 0;
  53
  54 /** if non-zero, maximum window width */
  55 static int width_max = 0;
  56
  57 /** if non-zero, maximum window height */
  58 static int height_max = 0;
  59
  60 /** set to log redrawing */
  61 static int log_redraw = 0;
  62
  63 /** set to log resizing */
  64 static int log_resize = 0;
  65
  66 /** set to log keyboard focus */
  67 static int log_focus = 0;
  68
  69 /** set to log key events */
  70 static int log_key = 0;
  71
  72 /** set to log button events */
  73 static int log_button = 0;
  74
  75 /** set to log axis events */
  76 static int log_axis = 0;
  77
  78 /** set to log motion events */
  79 static int log_motion = 0;
  80
  81 /**
  82  * \struct eventdemo
  83  * \brief Holds all data the program needs per window
  84  *
  85  * In this demo the struct holds the position of a
  86  * red rectangle that is drawn in the window's area.
  87  */
  88 struct eventdemo {
  89         struct window *window;
  90         struct widget *widget;
  91         struct display *display;
  92
  93         int x, y, w, h;
  94 };
  95
  96 /**
  97  * \brief CALLBACK function, Wayland requests the window to redraw.
  98  * \param widget widget to be redrawn
  99  * \param data user data associated to the window
 100  *
 101  * Draws a red rectangle as demonstration of per-window data.
 102  */
 103 static void
 104 redraw_handler(struct widget *widget, void *data)
 105 {
 106         struct eventdemo *e = data;
 107         cairo_surface_t *surface;
 108         cairo_t *cr;
 109         struct rectangle rect;
 110
 111         if (log_redraw)
 112                 printf("redraw\n");
 113
 114         widget_get_allocation(e->widget, &rect);
 115         surface = window_get_surface(e->window);
 116
 117         cr = cairo_create(surface);
 118         cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
 119
 120         cairo_rectangle(cr, rect.x, rect.y, rect.width, rect.height);
 121         cairo_set_source_rgba(cr, 0, 0, 0, 0.8);
 122         cairo_fill(cr);
 123
 124         cairo_rectangle(cr, e->x, e->y, e->w, e->h);
 125         cairo_set_source_rgba(cr, 1.0, 0, 0, 1);
 126         cairo_fill(cr);
 127
 128         cairo_destroy(cr);
 129         cairo_surface_destroy(surface);
 130 }
 131
 132 /**
 133  * \brief CALLBACK function, Wayland requests the window to resize.
 134  * \param widget widget to be resized
 135  * \param width desired width
 136  * \param height desired height
 137  * \param data user data associated to the window
 138  */
 139
 140 static void
 141 resize_handler(struct widget *widget,
 142                int32_t width, int32_t height, void *data)
 143 {
 144         struct eventdemo *e = data;
 145         if (log_resize)
 146                 printf("resize width: %d, height: %d\n", width, height);
 147
 148         /* if a maximum width is set, constrain to it */
 149         if (width_max && width_max < width)
 150                 width = width_max;
 151
 152         /* if a maximum height is set, constrain to it */
 153         if (height_max && height_max < height)
 154                 height = height_max;
 155
 156         /* set the new window dimensions */
 157         widget_set_size(e->widget, width, height);
 158 }
 159
 160 /**
 161  * \brief CALLBACK function, Wayland informs about keyboard focus change
 162  * \param window window
 163  * \param device device that caused the focus change
 164  * \param data user data associated to the window
 165  */
 166 static void
 167 keyboard_focus_handler(struct window *window,
 168                        struct input *device, void *data)
 169 {
 170         int32_t x, y;
 171         struct eventdemo *e = data;
 172
 173         if(log_focus) {
 174                 if(device) {
 175                         input_get_position(device, &x, &y);
 176                         printf("focus x: %d, y: %d\n", x, y);
 177                 } else {
 178                         printf("focus lost\n");
 179                 }
 180         }
 181
 182         window_schedule_redraw(e->window);
 183 }
 184
 185 /**
 186  * \brief CALLBACK function, Wayland informs about key event
 187  * \param window window
 188  * \param key keycode
 189  * \param unicode associated character
 190  * \param state pressed or released
 191  * \param modifiers modifiers: ctrl, alt, meta etc.
 192  * \param data user data associated to the window
 193  */
 194 static void
 195 key_handler(struct window *window, struct input *input, uint32_t time,
 196             uint32_t key, uint32_t unicode, enum wl_keyboard_key_state state,
 197             void *data)
 198 {
 199         uint32_t modifiers = input_get_modifiers(input);
 200
 201         if(!log_key)
 202                 return;
 203
 204         printf("key key: %d, unicode: %d, state: %s, modifiers: 0x%x\n",
 205                key, unicode,
 206                (state == WL_KEYBOARD_KEY_STATE_PRESSED) ? "pressed" :
 207                                                           "released",
 208                modifiers);
 209 }
 210
 211 /**
 212  * \brief CALLBACK function, Wayland informs about button event
 213  * \param widget widget
 214  * \param input input device that caused the button event
 215  * \param time time the event happened
 216  * \param button button
 217  * \param state pressed or released
 218  * \param data user data associated to the window
 219  */
 220 static void
 221 button_handler(struct widget *widget, struct input *input, uint32_t time,
 222                uint32_t button, enum wl_pointer_button_state state, void *data)
 223 {
 224         int32_t x, y;
 225
 226         if (!log_button)
 227                 return;
 228
 229         input_get_position(input, &x, &y);
 230         printf("button time: %d, button: %d, state: %s, x: %d, y: %d\n",
 231                time, button,
 232                (state == WL_POINTER_BUTTON_STATE_PRESSED) ? "pressed" :
 233                                                             "released",
 234                x, y);
 235 }
 236
 237 /**
 238  * \brief CALLBACK function, Wayland informs about axis event
 239  * \param widget widget
 240  * \param input input device that caused the axis event
 241  * \param time time the event happened
 242  * \param axis vertical or horizontal
 243  * \param value amount of scrolling
 244  * \param data user data associated to the widget
 245  */
 246 static void
 247 axis_handler(struct widget *widget, struct input *input, uint32_t time,
 248              uint32_t axis, wl_fixed_t value, void *data)
 249 {
 250         if (!log_axis)
 251                 return;
 252
 253         printf("axis time: %d, axis: %s, value: %f\n",
 254                time,
 255                axis == WL_POINTER_AXIS_VERTICAL_SCROLL ? "vertical" :
 256                                                          "horizontal",
 257                wl_fixed_to_double(value));
 258 }
 259
 260 /**
 261  * \brief CALLBACK function, Waylands informs about pointer motion
 262  * \param widget widget
 263  * \param input input device that caused the motion event
 264  * \param time time the event happened
 265  * \param x absolute x position
 266  * \param y absolute y position
 267  * \param sx x position relative to the window
 268  * \param sy y position relative to the window
 269  * \param data user data associated to the window
 270  *
 271  * Demonstrates the use of different cursors
 272  */
 273 static int
 274 motion_handler(struct widget *widget, struct input *input, uint32_t time,
 275                float x, float y, void *data)
 276 {
 277         struct eventdemo *e = data;
 278
 279         if (log_motion) {
 280                 printf("motion time: %d, x: %f, y: %f\n", time, x, y);
 281         }
 282
 283         if (x > e->x && x < e->x + e->w)
 284                 if (y > e->y && y < e->y + e->h)
 285                         return CURSOR_HAND1;
 286
 287         return CURSOR_LEFT_PTR;
 288 }
 289
 290 /**
 291  * \brief Create and initialise a new eventdemo window.
 292  * The returned eventdemo instance should be destroyed using \c eventdemo_destroy().
 293  * \param d associated display
 294  */
 295 static struct eventdemo *
 296 eventdemo_create(struct display *d)
 297 {
 298         struct eventdemo *e;
 299
 300         e = malloc(sizeof (struct eventdemo));
 301         if(e == NULL)
 302                 return NULL;
 303
 304         e->window = window_create(d);
 305
 306         if (noborder) {
 307                 /* Demonstrate how to create a borderless window.
 308                  * Move windows with META + left mouse button.
 309                  */
 310                 e->widget = window_add_widget(e->window, e);
 311         } else {
 312                 e->widget = window_frame_create(e->window, e);
 313                 window_set_title(e->window, title);
 314         }
 315         e->display = d;
 316
 317         /* The eventdemo window draws a red rectangle as a demonstration
 318          * of per-window data. The dimensions of that rectangle are set
 319          * here.
 320          */
 321         e->x = width * 1.0 / 4.0;
 322         e->w = width * 2.0 / 4.0;
 323         e->y = height * 1.0 / 4.0;
 324         e->h = height * 2.0 / 4.0;
 325
 326         /* Connect the user data to the window */
 327         window_set_user_data(e->window, e);
 328
 329         /* Set the callback redraw handler for the window */
 330         widget_set_redraw_handler(e->widget, redraw_handler);
 331
 332         /* Set the callback resize handler for the window */
 333         widget_set_resize_handler(e->widget, resize_handler);
 334
 335         /* Set the callback focus handler for the window */
 336         window_set_keyboard_focus_handler(e->window,
 337                                           keyboard_focus_handler);
 338
 339         /* Set the callback key handler for the window */
 340         window_set_key_handler(e->window, key_handler);
 341
 342         /* Set the callback button handler for the window */
 343         widget_set_button_handler(e->widget, button_handler);
 344
 345         /* Set the callback motion handler for the window */
 346         widget_set_motion_handler(e->widget, motion_handler);
 347
 348         /* Set the callback axis handler for the window */
 349         widget_set_axis_handler(e->widget, axis_handler);
 350
 351         /* Initial drawing of the window */
 352         window_schedule_resize(e->window, width, height);
 353
 354         return e;
 355 }
 356 /**
 357  * \brief Destroy eventdemo instance previously created by \c eventdemo_create().
 358  * \param eventdemo eventdemo instance to destroy
 359  */
 360 static void eventdemo_destroy(struct eventdemo * eventdemo)
 361 {
 362         widget_destroy(eventdemo->widget);
 363         window_destroy(eventdemo->window);
 364         free(eventdemo);
 365 }
 366 /**
 367  * \brief command line options for eventdemo
 368  */
 369 static const struct weston_option eventdemo_options[] = {
 370         { WESTON_OPTION_STRING, "title", 0, &title },
 371         { WESTON_OPTION_INTEGER, "width", 'w', &width },
 372         { WESTON_OPTION_INTEGER, "height", 'h', &height },
 373         { WESTON_OPTION_INTEGER, "max-width", 0, &width_max },
 374         { WESTON_OPTION_INTEGER, "max-height", 0, &height_max },
 375         { WESTON_OPTION_BOOLEAN, "no-border", 'b', &noborder },
 376         { WESTON_OPTION_BOOLEAN, "log-redraw", 0, &log_redraw },
 377         { WESTON_OPTION_BOOLEAN, "log-resize", 0, &log_resize },
 378         { WESTON_OPTION_BOOLEAN, "log-focus", 0, &log_focus },
 379         { WESTON_OPTION_BOOLEAN, "log-key", 0, &log_key },
 380         { WESTON_OPTION_BOOLEAN, "log-button", 0, &log_button },
 381         { WESTON_OPTION_BOOLEAN, "log-axis", 0, &log_axis },
 382         { WESTON_OPTION_BOOLEAN, "log-motion", 0, &log_motion },
 383 };
 384
 385 /**
 386  * \brief Connects to the display, creates the window and hands over
 387  * to the main loop.
 388  */
 389 int
 390 main(int argc, char *argv[])
 391 {
 392         struct display *d;
 393         struct eventdemo *e;
 394
 395         if (parse_options(eventdemo_options,
 396                           ARRAY_LENGTH(eventdemo_options), &argc, argv) > 1) {
 397                 unsigned k;
 398                 printf("Usage: %s [OPTIONS]\n\n", argv[0]);
 399                 for (k = 0; k < ARRAY_LENGTH(eventdemo_options); k++) {
 400                         const struct weston_option* p = &eventdemo_options[k];
 401                         if (p->name) {
 402                                 printf("  --%s", p->name);
 403                                 if (p->type != WESTON_OPTION_BOOLEAN)
 404                                         printf("=VALUE");
 405                                 putchar('\n');
 406                         }
 407                         if (p->short_name) {
 408                                 printf("  -%c", p->short_name);
 409                                 if (p->type != WESTON_OPTION_BOOLEAN)
 410                                         printf("VALUE");
 411                                 putchar('\n');
 412                         }
 413                 }
 414                 return 1;
 415         }
 416
 417         if (!log_redraw && !log_resize && !log_focus && !log_key &&
 418             !log_button && !log_axis && !log_motion)
 419           log_redraw = log_resize = log_focus = log_key =
 420             log_button = log_axis = log_motion = 1;
 421
 422         /* Connect to the display and have the arguments parsed */
 423         d = display_create(&argc, argv);
 424         if (d == NULL) {
 425                 fprintf(stderr, "failed to create display: %m\n");
 426                 return -1;
 427         }
 428
 429         /* Create new eventdemo window */
 430         e = eventdemo_create(d);
 431         if (e == NULL) {
 432                 fprintf(stderr, "failed to create eventdemo: %m\n");
 433                 return -1;
 434         }
 435
 436         display_run(d);
 437
 438         /* Release resources */
 439         eventdemo_destroy(e);
 440         display_destroy(d);
 441
 442         return 0;
 443 }