downstream: terminal: destroy display at the end.
[profile/ivi/weston-ivi-shell.git] / clients / cliptest.c
1 /*
2  * Copyright © 2012 Collabora, Ltd.
3  * Copyright © 2012 Rob Clark
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 /* cliptest: for debugging calculate_edges() function.
25  * controls:
26  *      clip box position: mouse left drag, keys: w a s d
27  *      clip box size: mouse right drag, keys: i j k l
28  *      surface orientation: mouse wheel, keys: n m
29  *      surface transform disable key: r
30  */
31
32 #include "config.h"
33
34 #include <stdint.h>
35 #include <stdio.h>
36 #include <stdlib.h>
37 #include <string.h>
38 #include <fcntl.h>
39 #include <libgen.h>
40 #include <unistd.h>
41 #include <math.h>
42 #include <time.h>
43 #include <pixman.h>
44 #include <cairo.h>
45 #include <float.h>
46 #include <assert.h>
47
48 #include <linux/input.h>
49 #include <wayland-client.h>
50
51 #include "src/vertex-clipping.h"
52 #include "window.h"
53
54 typedef float GLfloat;
55
56 struct geometry {
57         pixman_box32_t clip;
58
59         pixman_box32_t surf;
60         float s; /* sin phi */
61         float c; /* cos phi */
62         float phi;
63 };
64
65 struct weston_view {
66         struct {
67                 int enabled;
68         } transform;
69
70         struct geometry *geometry;
71 };
72
73 static void
74 weston_view_to_global_float(struct weston_view *view,
75                             float sx, float sy, float *x, float *y)
76 {
77         struct geometry *g = view->geometry;
78
79         /* pure rotation around origin by sine and cosine */
80         *x = g->c * sx + g->s * sy;
81         *y = -g->s * sx + g->c * sy;
82 }
83
84 /* ---------------------- copied begins -----------------------*/
85 /* Keep this in sync with what is in gl-renderer.c! */
86
87 #define max(a, b) (((a) > (b)) ? (a) : (b))
88 #define min(a, b) (((a) > (b)) ? (b) : (a))
89
90 /*
91  * Compute the boundary vertices of the intersection of the global coordinate
92  * aligned rectangle 'rect', and an arbitrary quadrilateral produced from
93  * 'surf_rect' when transformed from surface coordinates into global coordinates.
94  * The vertices are written to 'ex' and 'ey', and the return value is the
95  * number of vertices. Vertices are produced in clockwise winding order.
96  * Guarantees to produce either zero vertices, or 3-8 vertices with non-zero
97  * polygon area.
98  */
99 static int
100 calculate_edges(struct weston_view *ev, pixman_box32_t *rect,
101                 pixman_box32_t *surf_rect, GLfloat *ex, GLfloat *ey)
102 {
103
104         struct clip_context ctx;
105         int i, n;
106         GLfloat min_x, max_x, min_y, max_y;
107         struct polygon8 surf = {
108                 { surf_rect->x1, surf_rect->x2, surf_rect->x2, surf_rect->x1 },
109                 { surf_rect->y1, surf_rect->y1, surf_rect->y2, surf_rect->y2 },
110                 4
111         };
112
113         ctx.clip.x1 = rect->x1;
114         ctx.clip.y1 = rect->y1;
115         ctx.clip.x2 = rect->x2;
116         ctx.clip.y2 = rect->y2;
117
118         /* transform surface to screen space: */
119         for (i = 0; i < surf.n; i++)
120                 weston_view_to_global_float(ev, surf.x[i], surf.y[i],
121                                             &surf.x[i], &surf.y[i]);
122
123         /* find bounding box: */
124         min_x = max_x = surf.x[0];
125         min_y = max_y = surf.y[0];
126
127         for (i = 1; i < surf.n; i++) {
128                 min_x = min(min_x, surf.x[i]);
129                 max_x = max(max_x, surf.x[i]);
130                 min_y = min(min_y, surf.y[i]);
131                 max_y = max(max_y, surf.y[i]);
132         }
133
134         /* First, simple bounding box check to discard early transformed
135          * surface rects that do not intersect with the clip region:
136          */
137         if ((min_x >= ctx.clip.x2) || (max_x <= ctx.clip.x1) ||
138             (min_y >= ctx.clip.y2) || (max_y <= ctx.clip.y1))
139                 return 0;
140
141         /* Simple case, bounding box edges are parallel to surface edges,
142          * there will be only four edges.  We just need to clip the surface
143          * vertices to the clip rect bounds:
144          */
145         if (!ev->transform.enabled)
146                 return clip_simple(&ctx, &surf, ex, ey);
147
148         /* Transformed case: use a general polygon clipping algorithm to
149          * clip the surface rectangle with each side of 'rect'.
150          * The algorithm is Sutherland-Hodgman, as explained in
151          * http://www.codeguru.com/cpp/misc/misc/graphics/article.php/c8965/Polygon-Clipping.htm
152          * but without looking at any of that code.
153          */
154         n = clip_transformed(&ctx, &surf, ex, ey);
155
156         if (n < 3)
157                 return 0;
158
159         return n;
160 }
161
162
163 /* ---------------------- copied ends -----------------------*/
164
165 static void
166 geometry_set_phi(struct geometry *g, float phi)
167 {
168         g->phi = phi;
169         g->s = sin(phi);
170         g->c = cos(phi);
171 }
172
173 static void
174 geometry_init(struct geometry *g)
175 {
176         g->clip.x1 = -50;
177         g->clip.y1 = -50;
178         g->clip.x2 = -10;
179         g->clip.y2 = -10;
180
181         g->surf.x1 = -20;
182         g->surf.y1 = -20;
183         g->surf.x2 = 20;
184         g->surf.y2 = 20;
185
186         geometry_set_phi(g, 0.0);
187 }
188
189 struct ui_state {
190         uint32_t button;
191         int down;
192
193         int down_pos[2];
194         struct geometry geometry;
195 };
196
197 struct cliptest {
198         struct window *window;
199         struct widget *widget;
200         struct display *display;
201         int fullscreen;
202
203         struct ui_state ui;
204
205         struct geometry geometry;
206         struct weston_view view;
207 };
208
209 static void
210 draw_polygon_closed(cairo_t *cr, GLfloat *x, GLfloat *y, int n)
211 {
212         int i;
213
214         cairo_move_to(cr, x[0], y[0]);
215         for (i = 1; i < n; i++)
216                 cairo_line_to(cr, x[i], y[i]);
217         cairo_line_to(cr, x[0], y[0]);
218 }
219
220 static void
221 draw_polygon_labels(cairo_t *cr, GLfloat *x, GLfloat *y, int n)
222 {
223         char str[16];
224         int i;
225
226         for (i = 0; i < n; i++) {
227                 snprintf(str, 16, "%d", i);
228                 cairo_move_to(cr, x[i], y[i]);
229                 cairo_show_text(cr, str);
230         }
231 }
232
233 static void
234 draw_coordinates(cairo_t *cr, double ox, double oy, GLfloat *x, GLfloat *y, int n)
235 {
236         char str[64];
237         int i;
238         cairo_font_extents_t ext;
239
240         cairo_font_extents(cr, &ext);
241         for (i = 0; i < n; i++) {
242                 snprintf(str, 64, "%d: %14.9f, %14.9f", i, x[i], y[i]);
243                 cairo_move_to(cr, ox, oy + ext.height * (i + 1));
244                 cairo_show_text(cr, str);
245         }
246 }
247
248 static void
249 draw_box(cairo_t *cr, pixman_box32_t *box, struct weston_view *view)
250 {
251         GLfloat x[4], y[4];
252
253         if (view) {
254                 weston_view_to_global_float(view, box->x1, box->y1, &x[0], &y[0]);
255                 weston_view_to_global_float(view, box->x2, box->y1, &x[1], &y[1]);
256                 weston_view_to_global_float(view, box->x2, box->y2, &x[2], &y[2]);
257                 weston_view_to_global_float(view, box->x1, box->y2, &x[3], &y[3]);
258         } else {
259                 x[0] = box->x1; y[0] = box->y1;
260                 x[1] = box->x2; y[1] = box->y1;
261                 x[2] = box->x2; y[2] = box->y2;
262                 x[3] = box->x1; y[3] = box->y2;
263         }
264
265         draw_polygon_closed(cr, x, y, 4);
266 }
267
268 static void
269 draw_geometry(cairo_t *cr, struct weston_view *view,
270               GLfloat *ex, GLfloat *ey, int n)
271 {
272         struct geometry *g = view->geometry;
273         float cx, cy;
274
275         draw_box(cr, &g->surf, view);
276         cairo_set_source_rgba(cr, 1.0, 0.0, 0.0, 0.4);
277         cairo_fill(cr);
278         weston_view_to_global_float(view, g->surf.x1 - 4, g->surf.y1 - 4, &cx, &cy);
279         cairo_arc(cr, cx, cy, 1.5, 0.0, 2.0 * M_PI);
280         if (view->transform.enabled == 0)
281                 cairo_set_source_rgba(cr, 1.0, 0.0, 0.0, 0.8);
282         cairo_fill(cr);
283
284         draw_box(cr, &g->clip, NULL);
285         cairo_set_source_rgba(cr, 0.0, 0.0, 1.0, 0.4);
286         cairo_fill(cr);
287
288         if (n) {
289                 draw_polygon_closed(cr, ex, ey, n);
290                 cairo_set_source_rgb(cr, 0.0, 1.0, 0.0);
291                 cairo_stroke(cr);
292
293                 cairo_set_source_rgba(cr, 0.0, 1.0, 0.0, 0.5);
294                 draw_polygon_labels(cr, ex, ey, n);
295         }
296 }
297
298 static void
299 redraw_handler(struct widget *widget, void *data)
300 {
301         struct cliptest *cliptest = data;
302         struct geometry *g = cliptest->view.geometry;
303         struct rectangle allocation;
304         cairo_t *cr;
305         cairo_surface_t *surface;
306         GLfloat ex[8];
307         GLfloat ey[8];
308         int n;
309
310         n = calculate_edges(&cliptest->view, &g->clip, &g->surf, ex, ey);
311
312         widget_get_allocation(cliptest->widget, &allocation);
313
314         surface = window_get_surface(cliptest->window);
315         cr = cairo_create(surface);
316         widget_get_allocation(cliptest->widget, &allocation);
317         cairo_rectangle(cr, allocation.x, allocation.y,
318                         allocation.width, allocation.height);
319         cairo_clip(cr);
320
321         cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
322         cairo_set_source_rgba(cr, 0, 0, 0, 1);
323         cairo_paint(cr);
324
325         cairo_translate(cr, allocation.x, allocation.y);
326         cairo_set_line_width(cr, 1.0);
327         cairo_move_to(cr, allocation.width / 2.0, 0.0);
328         cairo_line_to(cr, allocation.width / 2.0, allocation.height);
329         cairo_move_to(cr, 0.0, allocation.height / 2.0);
330         cairo_line_to(cr, allocation.width, allocation.height / 2.0);
331         cairo_set_source_rgba(cr, 0.5, 0.5, 0.5, 1.0);
332         cairo_stroke(cr);
333
334         cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
335         cairo_push_group(cr);
336                 cairo_translate(cr, allocation.width / 2.0,
337                                 allocation.height / 2.0);
338                 cairo_scale(cr, 4.0, 4.0);
339                 cairo_set_line_width(cr, 0.5);
340                 cairo_set_line_join(cr, CAIRO_LINE_JOIN_BEVEL);
341                 cairo_select_font_face(cr, "Sans", CAIRO_FONT_SLANT_NORMAL,
342                                        CAIRO_FONT_WEIGHT_BOLD);
343                 cairo_set_font_size(cr, 5.0);
344                 draw_geometry(cr, &cliptest->view, ex, ey, n);
345         cairo_pop_group_to_source(cr);
346         cairo_paint(cr);
347
348         cairo_set_source_rgba(cr, 0.0, 1.0, 0.0, 1.0);
349         cairo_select_font_face(cr, "monospace", CAIRO_FONT_SLANT_NORMAL,
350                                CAIRO_FONT_WEIGHT_NORMAL);
351         cairo_set_font_size(cr, 12.0);
352         draw_coordinates(cr, 10.0, 10.0, ex, ey, n);
353
354         cairo_destroy(cr);
355
356         cairo_surface_destroy(surface);
357 }
358
359 static int
360 motion_handler(struct widget *widget, struct input *input,
361                uint32_t time, float x, float y, void *data)
362 {
363         struct cliptest *cliptest = data;
364         struct ui_state *ui = &cliptest->ui;
365         struct geometry *ref = &ui->geometry;
366         struct geometry *geom = &cliptest->geometry;
367         float dx, dy;
368
369         if (!ui->down)
370                 return CURSOR_LEFT_PTR;
371
372         dx = (x - ui->down_pos[0]) * 0.25;
373         dy = (y - ui->down_pos[1]) * 0.25;
374
375         switch (ui->button) {
376         case BTN_LEFT:
377                 geom->clip.x1 = ref->clip.x1 + dx;
378                 geom->clip.y1 = ref->clip.y1 + dy;
379                 /* fall through */
380         case BTN_RIGHT:
381                 geom->clip.x2 = ref->clip.x2 + dx;
382                 geom->clip.y2 = ref->clip.y2 + dy;
383                 break;
384         default:
385                 return CURSOR_LEFT_PTR;
386         }
387
388         widget_schedule_redraw(cliptest->widget);
389         return CURSOR_BLANK;
390 }
391
392 static void
393 button_handler(struct widget *widget, struct input *input,
394                uint32_t time, uint32_t button,
395                enum wl_pointer_button_state state, void *data)
396 {
397         struct cliptest *cliptest = data;
398         struct ui_state *ui = &cliptest->ui;
399
400         ui->button = button;
401
402         if (state == WL_POINTER_BUTTON_STATE_PRESSED) {
403                 ui->down = 1;
404                 input_get_position(input, &ui->down_pos[0], &ui->down_pos[1]);
405         } else {
406                 ui->down = 0;
407                 ui->geometry = cliptest->geometry;
408         }
409 }
410
411 static void
412 axis_handler(struct widget *widget, struct input *input, uint32_t time,
413              uint32_t axis, wl_fixed_t value, void *data)
414 {
415         struct cliptest *cliptest = data;
416         struct geometry *geom = &cliptest->geometry;
417
418         if (axis != WL_POINTER_AXIS_VERTICAL_SCROLL)
419                 return;
420
421         geometry_set_phi(geom, geom->phi +
422                                 (M_PI / 12.0) * wl_fixed_to_double(value));
423         cliptest->view.transform.enabled = 1;
424
425         widget_schedule_redraw(cliptest->widget);
426 }
427
428 static void
429 key_handler(struct window *window, struct input *input, uint32_t time,
430             uint32_t key, uint32_t sym,
431             enum wl_keyboard_key_state state, void *data)
432 {
433         struct cliptest *cliptest = data;
434         struct geometry *g = &cliptest->geometry;
435
436         if (state == WL_KEYBOARD_KEY_STATE_RELEASED)
437                 return;
438
439         switch (sym) {
440         case XKB_KEY_Escape:
441                 display_exit(cliptest->display);
442                 return;
443         case XKB_KEY_w:
444                 g->clip.y1 -= 1;
445                 g->clip.y2 -= 1;
446                 break;
447         case XKB_KEY_a:
448                 g->clip.x1 -= 1;
449                 g->clip.x2 -= 1;
450                 break;
451         case XKB_KEY_s:
452                 g->clip.y1 += 1;
453                 g->clip.y2 += 1;
454                 break;
455         case XKB_KEY_d:
456                 g->clip.x1 += 1;
457                 g->clip.x2 += 1;
458                 break;
459         case XKB_KEY_i:
460                 g->clip.y2 -= 1;
461                 break;
462         case XKB_KEY_j:
463                 g->clip.x2 -= 1;
464                 break;
465         case XKB_KEY_k:
466                 g->clip.y2 += 1;
467                 break;
468         case XKB_KEY_l:
469                 g->clip.x2 += 1;
470                 break;
471         case XKB_KEY_n:
472                 geometry_set_phi(g, g->phi + (M_PI / 24.0));
473                 cliptest->view.transform.enabled = 1;
474                 break;
475         case XKB_KEY_m:
476                 geometry_set_phi(g, g->phi - (M_PI / 24.0));
477                 cliptest->view.transform.enabled = 1;
478                 break;
479         case XKB_KEY_r:
480                 geometry_set_phi(g, 0.0);
481                 cliptest->view.transform.enabled = 0;
482                 break;
483         default:
484                 return;
485         }
486
487         widget_schedule_redraw(cliptest->widget);
488 }
489
490 static void
491 keyboard_focus_handler(struct window *window,
492                        struct input *device, void *data)
493 {
494         struct cliptest *cliptest = data;
495
496         window_schedule_redraw(cliptest->window);
497 }
498
499 static void
500 fullscreen_handler(struct window *window, void *data)
501 {
502         struct cliptest *cliptest = data;
503
504         cliptest->fullscreen ^= 1;
505         window_set_fullscreen(window, cliptest->fullscreen);
506 }
507
508 static struct cliptest *
509 cliptest_create(struct display *display)
510 {
511         struct cliptest *cliptest;
512
513         cliptest = xzalloc(sizeof *cliptest);
514         cliptest->view.geometry = &cliptest->geometry;
515         cliptest->view.transform.enabled = 0;
516         geometry_init(&cliptest->geometry);
517         geometry_init(&cliptest->ui.geometry);
518
519         cliptest->window = window_create(display);
520         cliptest->widget = window_frame_create(cliptest->window, cliptest);
521         window_set_title(cliptest->window, "cliptest");
522         cliptest->display = display;
523
524         window_set_user_data(cliptest->window, cliptest);
525         widget_set_redraw_handler(cliptest->widget, redraw_handler);
526         widget_set_button_handler(cliptest->widget, button_handler);
527         widget_set_motion_handler(cliptest->widget, motion_handler);
528         widget_set_axis_handler(cliptest->widget, axis_handler);
529
530         window_set_keyboard_focus_handler(cliptest->window,
531                                           keyboard_focus_handler);
532         window_set_key_handler(cliptest->window, key_handler);
533         window_set_fullscreen_handler(cliptest->window, fullscreen_handler);
534
535         /* set minimum size */
536         widget_schedule_resize(cliptest->widget, 200, 100);
537
538         /* set current size */
539         widget_schedule_resize(cliptest->widget, 500, 400);
540
541         return cliptest;
542 }
543
544 static struct timespec begin_time;
545
546 static void
547 reset_timer(void)
548 {
549         clock_gettime(CLOCK_MONOTONIC, &begin_time);
550 }
551
552 static double
553 read_timer(void)
554 {
555         struct timespec t;
556
557         clock_gettime(CLOCK_MONOTONIC, &t);
558         return (double)(t.tv_sec - begin_time.tv_sec) +
559                1e-9 * (t.tv_nsec - begin_time.tv_nsec);
560 }
561
562 static int
563 benchmark(void)
564 {
565         struct weston_view view;
566         struct geometry geom;
567         GLfloat ex[8], ey[8];
568         int i;
569         double t;
570         const int N = 1000000;
571
572         geom.clip.x1 = -19;
573         geom.clip.y1 = -19;
574         geom.clip.x2 = 19;
575         geom.clip.y2 = 19;
576
577         geom.surf.x1 = -20;
578         geom.surf.y1 = -20;
579         geom.surf.x2 = 20;
580         geom.surf.y2 = 20;
581
582         geometry_set_phi(&geom, 0.0);
583
584         view.transform.enabled = 1;
585         view.geometry = &geom;
586
587         reset_timer();
588         for (i = 0; i < N; i++) {
589                 geometry_set_phi(&geom, (float)i / 360.0f);
590                 calculate_edges(&view, &geom.clip, &geom.surf, ex, ey);
591         }
592         t = read_timer();
593
594         printf("%d calls took %g s, average %g us/call\n", N, t, t / N * 1e6);
595
596         return 0;
597 }
598
599 static void
600 cliptest_destroy(struct cliptest *cliptest)
601 {
602         widget_destroy(cliptest->widget);
603         window_destroy(cliptest->window);
604         free(cliptest);
605 }
606
607 int
608 main(int argc, char *argv[])
609 {
610         struct display *d;
611         struct cliptest *cliptest;
612
613         if (argc > 1) {
614                 if (argc == 2 && !strcmp(argv[1], "-b"))
615                         return benchmark();
616                 printf("Usage: %s [OPTIONS]\n  -b  run benchmark\n", argv[0]);
617                 return 1;
618         }
619
620         d = display_create(&argc, argv);
621         if (d == NULL) {
622                 fprintf(stderr, "failed to create display: %m\n");
623                 return -1;
624         }
625
626         cliptest = cliptest_create(d);
627         display_run(d);
628
629         cliptest_destroy(cliptest);
630         display_destroy(d);
631
632         return 0;
633 }