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