Implement text cursor position protocol.
[profile/ivi/weston.git] / src / compositor.h
1 /*
2  * Copyright © 2008-2011 Kristian Høgsberg
3  * Copyright © 2012 Collabora, Ltd.
4  *
5  * Permission to use, copy, modify, distribute, and sell this software and
6  * its documentation for any purpose is hereby granted without fee, provided
7  * that the above copyright notice appear in all copies and that both that
8  * copyright notice and this permission notice appear in supporting
9  * documentation, and that the name of the copyright holders not be used in
10  * advertising or publicity pertaining to distribution of the software
11  * without specific, written prior permission.  The copyright holders make
12  * no representations about the suitability of this software for any
13  * purpose.  It is provided "as is" without express or implied warranty.
14  *
15  * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
16  * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
17  * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
18  * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
19  * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
20  * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
21  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
22  */
23
24 #ifndef _WAYLAND_SYSTEM_COMPOSITOR_H_
25 #define _WAYLAND_SYSTEM_COMPOSITOR_H_
26
27 #include <pixman.h>
28 #include <xkbcommon/xkbcommon.h>
29 #include <wayland-server.h>
30
31 #include <GLES2/gl2.h>
32 #include <GLES2/gl2ext.h>
33 #include <EGL/egl.h>
34 #include <EGL/eglext.h>
35
36 #include "matrix.h"
37 #include "../shared/config-parser.h"
38 #include "weston-egl-ext.h"
39
40
41 struct weston_transform {
42         struct weston_matrix matrix;
43         struct wl_list link;
44 };
45
46 struct weston_surface;
47 struct shell_surface;
48 struct weston_seat;
49 struct weston_output;
50
51 struct weston_mode {
52         uint32_t flags;
53         int32_t width, height;
54         uint32_t refresh;
55         struct wl_list link;
56 };
57
58 struct weston_shell_client {
59         void (*send_configure)(struct weston_surface *surface,
60                                uint32_t edges, int32_t width, int32_t height);
61 };
62
63 struct weston_shell_interface {
64         void *shell;                    /* either desktop or tablet */
65
66         struct shell_surface *(*create_shell_surface)(void *shell,
67                                                       struct weston_surface *surface,
68                                                       const struct weston_shell_client *client);
69
70         void (*set_toplevel)(struct shell_surface *shsurf);
71
72         void (*set_transient)(struct shell_surface *shsurf,
73                               struct shell_surface *pshsurf,
74                               int x, int y, uint32_t flags);
75         int (*move)(struct shell_surface *shsurf, struct weston_seat *ws);
76         int (*resize)(struct shell_surface *shsurf,
77                       struct weston_seat *ws, uint32_t edges);
78
79 };
80
81 struct weston_border {
82         int32_t left, right, top, bottom;
83 };
84
85 enum {
86         ZOOM_POINTER,
87         ZOOM_TEXT_CURSOR
88 };
89
90 struct weston_output_zoom {
91         int active;
92         float increment;
93         float level;
94         float trans_x, trans_y;
95 };
96
97 /* bit compatible with drm definitions. */
98 enum dpms_enum {
99         WESTON_DPMS_ON,
100         WESTON_DPMS_STANDBY,
101         WESTON_DPMS_SUSPEND,
102         WESTON_DPMS_OFF
103 };
104
105 struct weston_read_pixels {
106         void *data;
107         int x, y, width, height;
108         void (*done)(struct weston_read_pixels *read_pixels,
109                      struct weston_output *output);
110         struct wl_list link;
111 };
112
113 struct weston_output {
114         uint32_t id;
115
116         struct wl_list link;
117         struct wl_list resource_list;
118         struct wl_global *global;
119         struct weston_compositor *compositor;
120         struct weston_matrix matrix;
121         struct wl_list frame_callback_list;
122         int32_t x, y, mm_width, mm_height;
123         struct weston_border border;
124         pixman_region32_t region;
125         pixman_region32_t previous_damage;
126         uint32_t flags;
127         int repaint_needed;
128         int repaint_scheduled;
129         struct weston_output_zoom zoom;
130         int dirty;
131         struct wl_list read_pixels_list;
132         struct wl_signal frame_signal;
133
134         char *make, *model;
135         uint32_t subpixel;
136         
137         struct weston_mode *current;
138         struct weston_mode *origin;
139         struct wl_list mode_list;
140
141         void (*repaint)(struct weston_output *output,
142                         pixman_region32_t *damage);
143         void (*destroy)(struct weston_output *output);
144         void (*assign_planes)(struct weston_output *output);
145         int (*switch_mode)(struct weston_output *output, struct weston_mode *mode);
146
147         /* backlight values are on 0-255 range, where higher is brighter */
148         uint32_t backlight_current;
149         void (*set_backlight)(struct weston_output *output, uint32_t value);
150         void (*set_dpms)(struct weston_output *output, enum dpms_enum level);
151 };
152
153 struct weston_seat {
154         struct wl_seat seat;
155         struct wl_pointer pointer;
156         struct wl_keyboard keyboard;
157         struct wl_touch touch;
158         struct weston_compositor *compositor;
159         struct weston_surface *sprite;
160         struct weston_surface *drag_surface;
161         struct wl_listener drag_surface_destroy_listener;
162         int32_t hotspot_x, hotspot_y;
163         struct wl_list link;
164         uint32_t modifier_state;
165         int hw_cursor;
166         struct wl_surface *saved_kbd_focus;
167         struct wl_listener saved_kbd_focus_listener;
168
169         uint32_t num_tp;
170         struct wl_surface *touch_focus;
171         struct wl_listener touch_focus_listener;
172         struct wl_resource *touch_focus_resource;
173         struct wl_listener touch_focus_resource_listener;
174
175         struct wl_listener new_drag_icon_listener;
176 };
177
178 struct weston_shader {
179         GLuint program;
180         GLuint vertex_shader, fragment_shader;
181         GLint proj_uniform;
182         GLint tex_uniform;
183         GLint alpha_uniform;
184         GLint brightness_uniform;
185         GLint saturation_uniform;
186         GLint color_uniform;
187         GLint texwidth_uniform;
188         GLint opaque_uniform;
189 };
190
191 struct weston_animation {
192         void (*frame)(struct weston_animation *animation,
193                       struct weston_output *output, uint32_t msecs);
194         struct wl_list link;
195 };
196
197 struct weston_spring {
198         double k;
199         double friction;
200         double current;
201         double target;
202         double previous;
203         uint32_t timestamp;
204 };
205
206 enum {
207         WESTON_COMPOSITOR_ACTIVE,
208         WESTON_COMPOSITOR_IDLE,         /* shell->unlock called on activity */
209         WESTON_COMPOSITOR_SLEEPING      /* no rendering, no frame events */
210 };
211
212 struct weston_layer {
213         struct wl_list surface_list;
214         struct wl_list link;
215 };
216
217 struct weston_compositor {
218         struct wl_shm *shm;
219         struct wl_signal destroy_signal;
220
221         EGLDisplay display;
222         EGLContext context;
223         EGLConfig config;
224         GLuint fbo;
225         struct weston_shader texture_shader;
226         struct weston_shader solid_shader;
227         struct weston_shader *current_shader;
228         struct wl_display *wl_display;
229         struct weston_shell_interface shell_interface;
230
231         struct wl_signal activate_signal;
232         struct wl_signal lock_signal;
233         struct wl_signal unlock_signal;
234
235         struct wl_event_loop *input_loop;
236         struct wl_event_source *input_loop_source;
237
238         /* There can be more than one, but not right now... */
239         struct weston_seat *seat;
240
241         struct weston_layer fade_layer;
242         struct weston_layer cursor_layer;
243
244         struct wl_list output_list;
245         struct wl_list seat_list;
246         struct wl_list layer_list;
247         struct wl_list surface_list;
248         struct wl_list binding_list;
249         struct wl_list animation_list;
250         struct {
251                 struct weston_spring spring;
252                 struct weston_animation animation;
253                 struct weston_surface *surface;
254         } fade;
255
256         uint32_t state;
257         struct wl_event_source *idle_source;
258         uint32_t idle_inhibit;
259         int option_idle_time;           /* default timeout, s */
260         int idle_time;                  /* effective timeout, s */
261
262         /* Repaint state. */
263         struct wl_array vertices, indices;
264         pixman_region32_t damage;
265
266         uint32_t focus;
267
268         PFNGLEGLIMAGETARGETRENDERBUFFERSTORAGEOESPROC
269                 image_target_renderbuffer_storage;
270         PFNGLEGLIMAGETARGETTEXTURE2DOESPROC image_target_texture_2d;
271         PFNEGLCREATEIMAGEKHRPROC create_image;
272         PFNEGLDESTROYIMAGEKHRPROC destroy_image;
273
274         int has_unpack_subimage;
275         GLenum read_format;
276
277         PFNEGLBINDWAYLANDDISPLAYWL bind_display;
278         PFNEGLUNBINDWAYLANDDISPLAYWL unbind_display;
279         int has_bind_display;
280
281         void (*destroy)(struct weston_compositor *ec);
282         int (*authenticate)(struct weston_compositor *c, uint32_t id);
283
284         void (*ping_handler)(struct weston_surface *surface, uint32_t serial);
285
286         int launcher_sock;
287
288         uint32_t output_id_pool;
289
290         struct {
291                 struct xkb_rule_names names;
292                 struct xkb_context *context;
293                 struct xkb_keymap *keymap;
294                 struct xkb_state *state;
295         } xkb_info;
296 };
297
298 #define MODIFIER_CTRL   (1 << 8)
299 #define MODIFIER_ALT    (1 << 9)
300 #define MODIFIER_SUPER  (1 << 10)
301
302 enum weston_output_flags {
303         WL_OUTPUT_FLIPPED = 0x01
304 };
305
306 struct weston_region {
307         struct wl_resource resource;
308         pixman_region32_t region;
309 };
310
311 /* Using weston_surface transformations
312  *
313  * To add a transformation to a surface, create a struct weston_transform, and
314  * add it to the list surface->geometry.transformation_list. Whenever you
315  * change the list, anything under surface->geometry, or anything in the
316  * weston_transforms linked into the list, you must set
317  * surface->geometry.dirty = 1.
318  *
319  * The order in the list defines the order of transformations. Let the list
320  * contain the transformation matrices M1, ..., Mn as head to tail. The
321  * transformation is applied to surface-local coordinate vector p as
322  *    P = Mn * ... * M2 * M1 * p
323  * to produce the global coordinate vector P. The total transform
324  *    Mn * ... * M2 * M1
325  * is cached in surface->transform.matrix, and the inverse of it in
326  * surface->transform.inverse.
327  *
328  * The list always contains surface->transform.position transformation, which
329  * is the translation by surface->geometry.x and y.
330  *
331  * If you want to apply a transformation in local coordinates, add your
332  * weston_transform to the head of the list. If you want to apply a
333  * transformation in global coordinates, add it to the tail of the list.
334  */
335
336 struct weston_surface {
337         struct wl_surface surface;
338         struct weston_compositor *compositor;
339         GLuint texture;
340         pixman_region32_t clip;
341         pixman_region32_t damage;
342         pixman_region32_t opaque;
343         pixman_region32_t input;
344         int32_t pitch;
345         struct wl_list link;
346         struct wl_list layer_link;
347         struct weston_shader *shader;
348         GLfloat color[4];
349         GLfloat opaque_rect[4];
350         GLfloat alpha;
351         GLfloat brightness;
352         GLfloat saturation;
353         int blend;
354
355         /* Surface geometry state, mutable.
356          * If you change anything, set dirty = 1.
357          * That includes the transformations referenced from the list.
358          */
359         struct {
360                 GLfloat x, y; /* surface translation on display */
361                 int32_t width, height;
362
363                 /* struct weston_transform */
364                 struct wl_list transformation_list;
365
366                 int dirty;
367         } geometry;
368
369         /* State derived from geometry state, read-only.
370          * This is updated by weston_surface_update_transform().
371          */
372         struct {
373                 pixman_region32_t boundingbox;
374                 pixman_region32_t opaque;
375
376                 /* matrix and inverse are used only if enabled = 1.
377                  * If enabled = 0, use x, y, width, height directly.
378                  */
379                 int enabled;
380                 struct weston_matrix matrix;
381                 struct weston_matrix inverse;
382
383                 struct weston_transform position; /* matrix from x, y */
384         } transform;
385
386         /*
387          * Which output to vsync this surface to.
388          * Used to determine, whether to send or queue frame events.
389          * Must be NULL, if 'link' is not in weston_compositor::surface_list.
390          */
391         struct weston_output *output;
392
393         /*
394          * A more complete representation of all outputs this surface is
395          * displayed on.
396          */
397         uint32_t output_mask;
398
399         struct wl_list frame_callback_list;
400
401         EGLImageKHR image;
402
403         struct wl_buffer *buffer;
404         struct wl_listener buffer_destroy_listener;
405
406         /*
407          * If non-NULL, this function will be called on surface::attach after
408          * a new buffer has been set up for this surface. The integer params
409          * are the sx and sy paramerters supplied to surface::attach .
410          */
411         void (*configure)(struct weston_surface *es, int32_t sx, int32_t sy);
412         void *private;
413 };
414
415 void
416 weston_surface_update_transform(struct weston_surface *surface);
417
418 void
419 weston_surface_to_global(struct weston_surface *surface,
420                          int32_t sx, int32_t sy, int32_t *x, int32_t *y);
421 void
422 weston_surface_to_global_fixed(struct weston_surface *surface,
423                                wl_fixed_t sx, wl_fixed_t sy,
424                                wl_fixed_t *x, wl_fixed_t *y);
425 void
426 weston_surface_to_global_float(struct weston_surface *surface,
427                                GLfloat sx, GLfloat sy, GLfloat *x, GLfloat *y);
428
429 void
430 weston_surface_from_global(struct weston_surface *surface,
431                            int32_t x, int32_t y, int32_t *sx, int32_t *sy);
432 void
433 weston_surface_from_global_fixed(struct weston_surface *surface,
434                                  wl_fixed_t x, wl_fixed_t y,
435                                  wl_fixed_t *sx, wl_fixed_t *sy);
436
437 void
438 weston_spring_init(struct weston_spring *spring,
439                    double k, double current, double target);
440 void
441 weston_spring_update(struct weston_spring *spring, uint32_t msec);
442 int
443 weston_spring_done(struct weston_spring *spring);
444
445 void
446 weston_surface_activate(struct weston_surface *surface,
447                         struct weston_seat *seat);
448 void
449 weston_surface_draw(struct weston_surface *es,
450                     struct weston_output *output, pixman_region32_t *damage);
451
452 void
453 notify_motion(struct wl_seat *seat, uint32_t time,
454               wl_fixed_t x, wl_fixed_t y);
455 void
456 notify_button(struct wl_seat *seat, uint32_t time, int32_t button,
457               uint32_t state);
458 void
459 notify_axis(struct wl_seat *seat, uint32_t time, uint32_t axis,
460             int32_t value);
461 void
462 notify_key(struct wl_seat *seat, uint32_t time, uint32_t key,
463            uint32_t state);
464
465 void
466 notify_pointer_focus(struct wl_seat *seat, struct weston_output *output,
467                      wl_fixed_t x, wl_fixed_t y);
468
469 void
470 notify_keyboard_focus(struct wl_seat *seat, struct wl_array *keys);
471
472 void
473 notify_touch(struct wl_seat *seat, uint32_t time, int touch_id,
474              wl_fixed_t x, wl_fixed_t y, int touch_type);
475
476 void
477 weston_layer_init(struct weston_layer *layer, struct wl_list *below);
478
479 void
480 weston_output_finish_frame(struct weston_output *output, int msecs);
481 void
482 weston_output_damage(struct weston_output *output);
483 void
484 weston_output_do_read_pixels(struct weston_output *output);
485 void
486 weston_compositor_repick(struct weston_compositor *compositor);
487 void
488 weston_compositor_schedule_repaint(struct weston_compositor *compositor);
489 void
490 weston_compositor_fade(struct weston_compositor *compositor, float tint);
491 void
492 weston_compositor_damage_all(struct weston_compositor *compositor);
493 void
494 weston_compositor_unlock(struct weston_compositor *compositor);
495 void
496 weston_compositor_wake(struct weston_compositor *compositor);
497 void
498 weston_compositor_activity(struct weston_compositor *compositor);
499 void
500 weston_compositor_update_drag_surfaces(struct weston_compositor *compositor);
501
502
503 struct weston_binding;
504 typedef void (*weston_binding_handler_t)(struct wl_seat *seat,
505                                          uint32_t time, uint32_t key,
506                                          uint32_t button,
507                                          uint32_t axis,
508                                          int32_t value, void *data);
509 struct weston_binding *
510 weston_compositor_add_binding(struct weston_compositor *compositor,
511                               uint32_t key, uint32_t button, uint32_t axis,
512                               uint32_t modifier,
513                               weston_binding_handler_t binding, void *data);
514 void
515 weston_binding_destroy(struct weston_binding *binding);
516
517 void
518 weston_binding_list_destroy_all(struct wl_list *list);
519
520 void
521 weston_compositor_run_binding(struct weston_compositor *compositor,
522                               struct weston_seat *seat,
523                               uint32_t time,
524                               uint32_t key, uint32_t button, uint32_t axis,
525                               int32_t value);
526 int
527 weston_environment_get_fd(const char *env);
528
529 struct wl_list *
530 weston_compositor_top(struct weston_compositor *compositor);
531
532 struct weston_surface *
533 weston_surface_create(struct weston_compositor *compositor);
534
535 void
536 weston_surface_configure(struct weston_surface *surface,
537                          GLfloat x, GLfloat y, int width, int height);
538
539 void
540 weston_surface_restack(struct weston_surface *surface, struct wl_list *below);
541
542 void
543 weston_surface_set_position(struct weston_surface *surface,
544                             GLfloat x, GLfloat y);
545
546 int
547 weston_surface_is_mapped(struct weston_surface *surface);
548
549 void
550 weston_surface_assign_output(struct weston_surface *surface);
551
552 void
553 weston_surface_damage(struct weston_surface *surface);
554
555 void
556 weston_surface_damage_below(struct weston_surface *surface);
557
558 void
559 weston_buffer_post_release(struct wl_buffer *buffer);
560
561 uint32_t
562 weston_compositor_get_time(void);
563
564 int
565 weston_compositor_init(struct weston_compositor *ec, struct wl_display *display);
566 void
567 weston_compositor_shutdown(struct weston_compositor *ec);
568 void
569 weston_output_update_zoom(struct weston_output *output,
570                                                 int x, int y, uint32_t type);
571 void
572 weston_text_cursor_position_notify(struct weston_surface *surface, int x, int y);
573 void
574 weston_output_update_matrix(struct weston_output *output);
575 void
576 weston_output_move(struct weston_output *output, int x, int y);
577 void
578 weston_output_init(struct weston_output *output, struct weston_compositor *c,
579                    int x, int y, int width, int height, uint32_t flags);
580 void
581 weston_output_destroy(struct weston_output *output);
582
583 void
584 weston_seat_init(struct weston_seat *seat, struct weston_compositor *ec);
585
586 void
587 weston_seat_release(struct weston_seat *seat);
588
589 enum {
590         TTY_ENTER_VT,
591         TTY_LEAVE_VT
592 };
593
594 typedef void (*tty_vt_func_t)(struct weston_compositor *compositor, int event);
595
596 struct tty *
597 tty_create(struct weston_compositor *compositor,
598            tty_vt_func_t vt_func, int tty_nr);
599
600 void
601 tty_destroy(struct tty *tty);
602
603 int
604 tty_activate_vt(struct tty *tty, int vt);
605
606 void
607 screenshooter_create(struct weston_compositor *ec);
608
609 void
610 text_cursor_position_notifier_create(struct weston_compositor *ec);
611
612 struct weston_process;
613 typedef void (*weston_process_cleanup_func_t)(struct weston_process *process,
614                                             int status);
615
616 struct weston_process {
617         pid_t pid;
618         weston_process_cleanup_func_t cleanup;
619         struct wl_list link;
620 };
621
622 struct wl_client *
623 weston_client_launch(struct weston_compositor *compositor,
624                      struct weston_process *proc,
625                      const char *path,
626                      weston_process_cleanup_func_t cleanup);
627
628 void
629 weston_watch_process(struct weston_process *process);
630
631 int
632 weston_xserver_init(struct weston_compositor *compositor);
633
634 struct weston_zoom;
635 typedef void (*weston_zoom_done_func_t)(struct weston_zoom *zoom, void *data);
636
637 struct weston_zoom *
638 weston_zoom_run(struct weston_surface *surface, GLfloat start, GLfloat stop,
639                 weston_zoom_done_func_t done, void *data);
640
641 struct weston_fade;
642 typedef void (*weston_fade_done_func_t)(struct weston_fade *fade, void *data);
643
644 struct weston_fade *
645 weston_fade_run(struct weston_surface *surface,
646                 weston_fade_done_func_t done, void *data);
647
648
649 void
650 weston_surface_set_color(struct weston_surface *surface,
651                          GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
652
653 void
654 weston_surface_destroy(struct weston_surface *surface);
655
656 struct weston_compositor *
657 backend_init(struct wl_display *display, int argc, char *argv[]);
658
659 int
660 weston_output_switch_mode(struct weston_output *output, struct weston_mode *mode);
661
662 #endif