Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1 | /* |
| 2 | * Copyright © 2008-2011 Kristian Høgsberg |
Pekka Paalanen | d581a8f | 2012-01-27 16:25:16 +0200 | [diff] [blame] | 3 | * Copyright © 2012 Collabora, Ltd. |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 4 | * |
Bryce Harrington | a0bbfea | 2015-06-11 15:35:43 -0700 | [diff] [blame] | 5 | * Permission is hereby granted, free of charge, to any person obtaining |
| 6 | * a copy of this software and associated documentation files (the |
| 7 | * "Software"), to deal in the Software without restriction, including |
| 8 | * without limitation the rights to use, copy, modify, merge, publish, |
| 9 | * distribute, sublicense, and/or sell copies of the Software, and to |
| 10 | * permit persons to whom the Software is furnished to do so, subject to |
| 11 | * the following conditions: |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 12 | * |
Bryce Harrington | a0bbfea | 2015-06-11 15:35:43 -0700 | [diff] [blame] | 13 | * The above copyright notice and this permission notice (including the |
| 14 | * next paragraph) shall be included in all copies or substantial |
| 15 | * portions of the Software. |
| 16 | * |
| 17 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
| 18 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| 19 | * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
| 20 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
| 21 | * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
| 22 | * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
| 23 | * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
| 24 | * SOFTWARE. |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 25 | */ |
| 26 | |
| 27 | #ifndef _WAYLAND_SYSTEM_COMPOSITOR_H_ |
| 28 | #define _WAYLAND_SYSTEM_COMPOSITOR_H_ |
| 29 | |
Giulio Camuffo | 7fe01b1 | 2013-03-28 18:02:42 +0100 | [diff] [blame] | 30 | #ifdef __cplusplus |
| 31 | extern "C" { |
| 32 | #endif |
| 33 | |
Derek Foreman | 280e7dd | 2014-10-03 13:13:42 -0500 | [diff] [blame] | 34 | #include <stdbool.h> |
Pekka Paalanen | b5eedad | 2014-09-23 22:08:45 -0400 | [diff] [blame] | 35 | #include <time.h> |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 36 | #include <pixman.h> |
Daniel Stone | 855028f | 2012-05-01 20:37:10 +0100 | [diff] [blame] | 37 | #include <xkbcommon/xkbcommon.h> |
Kristian Høgsberg | 3c17933 | 2013-08-06 19:27:04 -0700 | [diff] [blame] | 38 | |
| 39 | #define WL_HIDE_DEPRECATED |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 40 | #include <wayland-server.h> |
| 41 | |
Kristian Høgsberg | af4f2aa | 2013-02-15 20:53:20 -0500 | [diff] [blame] | 42 | #include "version.h" |
| 43 | #include "matrix.h" |
| 44 | #include "config-parser.h" |
Peter Hutterer | b1bc4a6 | 2013-08-08 11:57:04 +1000 | [diff] [blame] | 45 | #include "zalloc.h" |
Pekka Paalanen | b502654 | 2014-11-12 15:09:24 +0200 | [diff] [blame] | 46 | #include "timeline-object.h" |
Pekka Paalanen | 2eaa11e | 2012-03-30 15:45:40 +0300 | [diff] [blame] | 47 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 48 | struct weston_transform { |
| 49 | struct weston_matrix matrix; |
Pekka Paalanen | c61eca6 | 2012-01-06 14:10:06 +0200 | [diff] [blame] | 50 | struct wl_list link; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 51 | }; |
| 52 | |
| 53 | struct weston_surface; |
Jason Ekstrand | 6bd6294 | 2013-06-20 20:38:23 -0500 | [diff] [blame] | 54 | struct weston_buffer; |
Tiago Vignatti | bc052c9 | 2012-04-19 16:18:18 +0300 | [diff] [blame] | 55 | struct shell_surface; |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 56 | struct weston_seat; |
Scott Moreau | 062be7e | 2012-04-20 13:37:33 -0600 | [diff] [blame] | 57 | struct weston_output; |
Jan Arne Petersen | e829adc | 2012-08-10 16:47:22 +0200 | [diff] [blame] | 58 | struct input_method; |
Derek Foreman | e4d6c83 | 2015-08-05 14:48:11 -0500 | [diff] [blame] | 59 | struct weston_pointer; |
Pekka Paalanen | 230f3b1 | 2014-09-29 14:18:40 -0400 | [diff] [blame] | 60 | struct linux_dmabuf_buffer; |
Giulio Camuffo | 26f62d4 | 2016-06-02 21:48:09 +0300 | [diff] [blame] | 61 | struct weston_recorder; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 62 | |
Daniel Stone | 496ca17 | 2012-05-30 16:31:42 +0100 | [diff] [blame] | 63 | enum weston_keyboard_modifier { |
| 64 | MODIFIER_CTRL = (1 << 0), |
| 65 | MODIFIER_ALT = (1 << 1), |
| 66 | MODIFIER_SUPER = (1 << 2), |
Kristian Høgsberg | 73694c8 | 2012-06-28 14:13:10 -0400 | [diff] [blame] | 67 | MODIFIER_SHIFT = (1 << 3), |
Daniel Stone | 496ca17 | 2012-05-30 16:31:42 +0100 | [diff] [blame] | 68 | }; |
| 69 | |
Giulio Camuffo | 6ef444d | 2014-08-28 19:44:09 +0300 | [diff] [blame] | 70 | enum weston_keyboard_locks { |
| 71 | WESTON_NUM_LOCK = (1 << 0), |
| 72 | WESTON_CAPS_LOCK = (1 << 1), |
| 73 | }; |
| 74 | |
Daniel Stone | 8c8164f | 2012-05-30 16:31:45 +0100 | [diff] [blame] | 75 | enum weston_led { |
| 76 | LED_NUM_LOCK = (1 << 0), |
| 77 | LED_CAPS_LOCK = (1 << 1), |
| 78 | LED_SCROLL_LOCK = (1 << 2), |
| 79 | }; |
| 80 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 81 | struct weston_mode { |
| 82 | uint32_t flags; |
| 83 | int32_t width, height; |
| 84 | uint32_t refresh; |
| 85 | struct wl_list link; |
| 86 | }; |
| 87 | |
Kristian Høgsberg | a61ca06 | 2012-05-22 16:05:52 -0400 | [diff] [blame] | 88 | struct weston_shell_client { |
Jasper St. Pierre | ac985be | 2014-04-28 11:19:28 -0400 | [diff] [blame] | 89 | void (*send_configure)(struct weston_surface *surface, int32_t width, int32_t height); |
Giulio Camuffo | f05d18f | 2015-12-11 20:57:05 +0200 | [diff] [blame] | 90 | void (*send_position)(struct weston_surface *surface, int32_t x, int32_t y); |
Kristian Høgsberg | a61ca06 | 2012-05-22 16:05:52 -0400 | [diff] [blame] | 91 | }; |
| 92 | |
Tiago Vignatti | bc052c9 | 2012-04-19 16:18:18 +0300 | [diff] [blame] | 93 | struct weston_shell_interface { |
| 94 | void *shell; /* either desktop or tablet */ |
| 95 | |
Kristian Høgsberg | 45ba869 | 2012-05-21 14:27:33 -0400 | [diff] [blame] | 96 | struct shell_surface *(*create_shell_surface)(void *shell, |
Kristian Høgsberg | a61ca06 | 2012-05-22 16:05:52 -0400 | [diff] [blame] | 97 | struct weston_surface *surface, |
| 98 | const struct weston_shell_client *client); |
Tiago Vignatti | bc052c9 | 2012-04-19 16:18:18 +0300 | [diff] [blame] | 99 | void (*set_toplevel)(struct shell_surface *shsurf); |
Kristian Høgsberg | 938b8fa | 2012-05-18 13:46:27 -0400 | [diff] [blame] | 100 | |
Tiago Vignatti | 491bac1 | 2012-05-18 16:37:43 -0400 | [diff] [blame] | 101 | void (*set_transient)(struct shell_surface *shsurf, |
Kristian Høgsberg | 8150b19 | 2012-06-27 10:22:58 -0400 | [diff] [blame] | 102 | struct weston_surface *parent, |
Tiago Vignatti | 491bac1 | 2012-05-18 16:37:43 -0400 | [diff] [blame] | 103 | int x, int y, uint32_t flags); |
Kristian Høgsberg | b810eb5 | 2013-02-12 20:07:05 -0500 | [diff] [blame] | 104 | void (*set_fullscreen)(struct shell_surface *shsurf, |
| 105 | uint32_t method, |
| 106 | uint32_t framerate, |
| 107 | struct weston_output *output); |
Tiago Vignatti | fb2adba | 2013-06-12 15:43:21 -0300 | [diff] [blame] | 108 | void (*set_xwayland)(struct shell_surface *shsurf, |
| 109 | int x, int y, uint32_t flags); |
Derek Foreman | e4d6c83 | 2015-08-05 14:48:11 -0500 | [diff] [blame] | 110 | int (*move)(struct shell_surface *shsurf, struct weston_pointer *pointer); |
Kristian Høgsberg | c1693f2 | 2012-05-22 16:56:23 -0400 | [diff] [blame] | 111 | int (*resize)(struct shell_surface *shsurf, |
Derek Foreman | e4d6c83 | 2015-08-05 14:48:11 -0500 | [diff] [blame] | 112 | struct weston_pointer *pointer, uint32_t edges); |
Giulio Camuffo | 62942ad | 2013-09-11 18:20:47 +0200 | [diff] [blame] | 113 | void (*set_title)(struct shell_surface *shsurf, |
| 114 | const char *title); |
Jasper St. Pierre | ccf48fb | 2014-05-02 10:21:38 -0400 | [diff] [blame] | 115 | void (*set_window_geometry)(struct shell_surface *shsurf, |
| 116 | int32_t x, int32_t y, |
| 117 | int32_t width, int32_t height); |
Giulio Camuffo | 6b4b241 | 2015-01-29 19:06:49 +0200 | [diff] [blame] | 118 | void (*set_maximized)(struct shell_surface *shsurf); |
Giulio Camuffo | a8e9b41 | 2015-01-27 19:10:37 +0200 | [diff] [blame] | 119 | void (*set_pid)(struct shell_surface *shsurf, pid_t pid); |
Quentin Glidic | 5c20195 | 2016-03-23 13:50:49 +0100 | [diff] [blame] | 120 | void (*get_output_work_area)(void *shell, struct weston_output *output, pixman_rectangle32_t *area); |
Tiago Vignatti | bc052c9 | 2012-04-19 16:18:18 +0300 | [diff] [blame] | 121 | }; |
| 122 | |
Scott Moreau | e660398 | 2012-06-11 13:07:51 -0600 | [diff] [blame] | 123 | struct weston_animation { |
| 124 | void (*frame)(struct weston_animation *animation, |
| 125 | struct weston_output *output, uint32_t msecs); |
| 126 | int frame_counter; |
| 127 | struct wl_list link; |
| 128 | }; |
| 129 | |
Kristian Høgsberg | 7eec9b3 | 2013-06-17 09:15:22 -0400 | [diff] [blame] | 130 | enum { |
| 131 | WESTON_SPRING_OVERSHOOT, |
| 132 | WESTON_SPRING_CLAMP, |
| 133 | WESTON_SPRING_BOUNCE |
| 134 | }; |
| 135 | |
Scott Moreau | e660398 | 2012-06-11 13:07:51 -0600 | [diff] [blame] | 136 | struct weston_spring { |
| 137 | double k; |
| 138 | double friction; |
| 139 | double current; |
| 140 | double target; |
| 141 | double previous; |
Kristian Høgsberg | 091b096 | 2013-06-17 09:23:14 -0400 | [diff] [blame] | 142 | double min, max; |
Scott Moreau | e660398 | 2012-06-11 13:07:51 -0600 | [diff] [blame] | 143 | uint32_t timestamp; |
Kristian Høgsberg | 7eec9b3 | 2013-06-17 09:15:22 -0400 | [diff] [blame] | 144 | uint32_t clip; |
Scott Moreau | e660398 | 2012-06-11 13:07:51 -0600 | [diff] [blame] | 145 | }; |
| 146 | |
Scott Moreau | ccbf29d | 2012-02-22 14:21:41 -0700 | [diff] [blame] | 147 | struct weston_output_zoom { |
Derek Foreman | a36eb50 | 2015-07-23 14:55:12 -0500 | [diff] [blame] | 148 | bool active; |
Scott Moreau | ccbf29d | 2012-02-22 14:21:41 -0700 | [diff] [blame] | 149 | float increment; |
| 150 | float level; |
Scott Moreau | e660398 | 2012-06-11 13:07:51 -0600 | [diff] [blame] | 151 | float max_level; |
Scott Moreau | ccbf29d | 2012-02-22 14:21:41 -0700 | [diff] [blame] | 152 | float trans_x, trans_y; |
Giulio Camuffo | 6850e7b | 2015-10-07 20:14:18 +0300 | [diff] [blame] | 153 | struct { |
| 154 | double x, y; |
| 155 | } current; |
Derek Foreman | 22276a5 | 2015-07-23 14:55:15 -0500 | [diff] [blame] | 156 | struct weston_seat *seat; |
Scott Moreau | e660398 | 2012-06-11 13:07:51 -0600 | [diff] [blame] | 157 | struct weston_animation animation_z; |
| 158 | struct weston_spring spring_z; |
Giulio Camuffo | 412b024 | 2013-11-14 23:42:51 +0100 | [diff] [blame] | 159 | struct wl_listener motion_listener; |
Scott Moreau | ccbf29d | 2012-02-22 14:21:41 -0700 | [diff] [blame] | 160 | }; |
| 161 | |
Tiago Vignatti | 8e53c7f | 2012-02-29 19:53:50 +0200 | [diff] [blame] | 162 | /* bit compatible with drm definitions. */ |
| 163 | enum dpms_enum { |
| 164 | WESTON_DPMS_ON, |
| 165 | WESTON_DPMS_STANDBY, |
| 166 | WESTON_DPMS_SUSPEND, |
| 167 | WESTON_DPMS_OFF |
| 168 | }; |
| 169 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 170 | struct weston_output { |
Casey Dahlin | 58ba137 | 2012-04-19 22:50:08 -0400 | [diff] [blame] | 171 | uint32_t id; |
Richard Hughes | afe690c | 2013-05-02 10:10:04 +0100 | [diff] [blame] | 172 | char *name; |
Casey Dahlin | 58ba137 | 2012-04-19 22:50:08 -0400 | [diff] [blame] | 173 | |
John Kåre Alsaker | 9465927 | 2012-11-13 19:10:18 +0100 | [diff] [blame] | 174 | void *renderer_state; |
| 175 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 176 | struct wl_list link; |
Casey Dahlin | 9074db5 | 2012-04-19 22:50:09 -0400 | [diff] [blame] | 177 | struct wl_list resource_list; |
Benjamin Franzke | b687940 | 2012-04-10 18:28:54 +0200 | [diff] [blame] | 178 | struct wl_global *global; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 179 | struct weston_compositor *compositor; |
Jason Ekstrand | fb23df7 | 2014-10-16 10:55:21 -0500 | [diff] [blame] | 180 | |
| 181 | /** From global to output buffer coordinates. */ |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 182 | struct weston_matrix matrix; |
Derek Foreman | c002321 | 2015-03-24 11:36:13 -0500 | [diff] [blame] | 183 | /** From output buffer to global coordinates. */ |
| 184 | struct weston_matrix inverse_matrix; |
Jason Ekstrand | fb23df7 | 2014-10-16 10:55:21 -0500 | [diff] [blame] | 185 | |
Scott Moreau | 9d1b112 | 2012-06-08 19:40:53 -0600 | [diff] [blame] | 186 | struct wl_list animation_list; |
Scott Moreau | 1bad5db | 2012-08-18 01:04:05 -0600 | [diff] [blame] | 187 | int32_t x, y, width, height; |
| 188 | int32_t mm_width, mm_height; |
Pekka Paalanen | efd08c7 | 2015-02-23 13:54:49 +0200 | [diff] [blame] | 189 | |
| 190 | /** Output area in global coordinates, simple rect */ |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 191 | pixman_region32_t region; |
Pekka Paalanen | efd08c7 | 2015-02-23 13:54:49 +0200 | [diff] [blame] | 192 | |
Ander Conselvan de Oliveira | b8fcca9 | 2012-11-16 17:23:52 +0200 | [diff] [blame] | 193 | pixman_region32_t previous_damage; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 194 | int repaint_needed; |
| 195 | int repaint_scheduled; |
Pekka Paalanen | 0513a95 | 2014-05-21 16:17:27 +0300 | [diff] [blame] | 196 | struct wl_event_source *repaint_timer; |
Scott Moreau | ccbf29d | 2012-02-22 14:21:41 -0700 | [diff] [blame] | 197 | struct weston_output_zoom zoom; |
| 198 | int dirty; |
Kristian Høgsberg | 5fb70bf | 2012-05-24 12:29:46 -0400 | [diff] [blame] | 199 | struct wl_signal frame_signal; |
Richard Hughes | 64ddde1 | 2013-05-01 21:52:10 +0100 | [diff] [blame] | 200 | struct wl_signal destroy_signal; |
Zhang, Xiong Y | f301241 | 2013-12-13 22:10:53 +0200 | [diff] [blame] | 201 | int move_x, move_y; |
Pekka Paalanen | b5eedad | 2014-09-23 22:08:45 -0400 | [diff] [blame] | 202 | uint32_t frame_time; /* presentation timestamp in milliseconds */ |
Pekka Paalanen | 641307c | 2014-09-23 22:08:47 -0400 | [diff] [blame] | 203 | uint64_t msc; /* media stream counter */ |
Kristian Høgsberg | 79af73e | 2012-08-03 15:45:23 -0400 | [diff] [blame] | 204 | int disable_planes; |
Ander Conselvan de Oliveira | e1e2352 | 2013-12-13 22:10:55 +0200 | [diff] [blame] | 205 | int destroying; |
Pekka Paalanen | 133e439 | 2014-09-23 22:08:46 -0400 | [diff] [blame] | 206 | struct wl_list feedback_list; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 207 | |
Richard Hughes | 2b2092a | 2013-04-24 14:58:02 +0100 | [diff] [blame] | 208 | char *make, *model, *serial_number; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 209 | uint32_t subpixel; |
Kristian Høgsberg | 05890dc | 2012-08-10 10:09:20 -0400 | [diff] [blame] | 210 | uint32_t transform; |
Hardening | 57388e4 | 2013-09-18 23:56:36 +0200 | [diff] [blame] | 211 | int32_t native_scale; |
Hardening | ff39efa | 2013-09-18 23:56:35 +0200 | [diff] [blame] | 212 | int32_t current_scale; |
Hardening | 57388e4 | 2013-09-18 23:56:36 +0200 | [diff] [blame] | 213 | int32_t original_scale; |
Alexander Larsson | 4ea9552 | 2013-05-22 14:41:37 +0200 | [diff] [blame] | 214 | |
Hardening | 57388e4 | 2013-09-18 23:56:36 +0200 | [diff] [blame] | 215 | struct weston_mode *native_mode; |
Hardening | ff39efa | 2013-09-18 23:56:35 +0200 | [diff] [blame] | 216 | struct weston_mode *current_mode; |
| 217 | struct weston_mode *original_mode; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 218 | struct wl_list mode_list; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 219 | |
Jonas Ådahl | e5a1225 | 2013-04-05 23:07:11 +0200 | [diff] [blame] | 220 | void (*start_repaint_loop)(struct weston_output *output); |
David Herrmann | 1edf44c | 2013-10-22 17:11:26 +0200 | [diff] [blame] | 221 | int (*repaint)(struct weston_output *output, |
Kristian Høgsberg | d7c1726 | 2012-09-05 21:54:15 -0400 | [diff] [blame] | 222 | pixman_region32_t *damage); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 223 | void (*destroy)(struct weston_output *output); |
Jesse Barnes | 5308a5e | 2012-02-09 13:12:57 -0800 | [diff] [blame] | 224 | void (*assign_planes)(struct weston_output *output); |
Alex Wu | 2dda604 | 2012-04-17 17:20:47 +0800 | [diff] [blame] | 225 | int (*switch_mode)(struct weston_output *output, struct weston_mode *mode); |
Tiago Vignatti | 8e53c7f | 2012-02-29 19:53:50 +0200 | [diff] [blame] | 226 | |
Tiago Vignatti | 5ab91ad | 2012-03-12 19:40:09 -0300 | [diff] [blame] | 227 | /* backlight values are on 0-255 range, where higher is brighter */ |
Kristian Høgsberg | 7c60912 | 2013-05-23 20:30:26 -0400 | [diff] [blame] | 228 | int32_t backlight_current; |
Tiago Vignatti | 8e53c7f | 2012-02-29 19:53:50 +0200 | [diff] [blame] | 229 | void (*set_backlight)(struct weston_output *output, uint32_t value); |
| 230 | void (*set_dpms)(struct weston_output *output, enum dpms_enum level); |
Richard Hughes | e729996 | 2013-05-01 21:52:12 +0100 | [diff] [blame] | 231 | |
Richard Hughes | b24e48e | 2013-05-09 20:31:09 +0100 | [diff] [blame] | 232 | int connection_internal; |
Richard Hughes | e729996 | 2013-05-01 21:52:12 +0100 | [diff] [blame] | 233 | uint16_t gamma_size; |
| 234 | void (*set_gamma)(struct weston_output *output, |
| 235 | uint16_t size, |
| 236 | uint16_t *r, |
| 237 | uint16_t *g, |
| 238 | uint16_t *b); |
Pekka Paalanen | b502654 | 2014-11-12 15:09:24 +0200 | [diff] [blame] | 239 | |
| 240 | struct weston_timeline_object timeline; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 241 | }; |
| 242 | |
Jonas Ådahl | d251010 | 2014-10-05 21:39:14 +0200 | [diff] [blame] | 243 | enum weston_pointer_motion_mask { |
| 244 | WESTON_POINTER_MOTION_ABS = 1 << 0, |
| 245 | WESTON_POINTER_MOTION_REL = 1 << 1, |
Jonas Ådahl | 3845b32 | 2014-10-21 23:51:29 +0200 | [diff] [blame] | 246 | WESTON_POINTER_MOTION_REL_UNACCEL = 1 << 2, |
Jonas Ådahl | d251010 | 2014-10-05 21:39:14 +0200 | [diff] [blame] | 247 | }; |
| 248 | |
| 249 | struct weston_pointer_motion_event { |
| 250 | uint32_t mask; |
Jonas Ådahl | de1ed2e | 2015-07-29 14:18:02 +0800 | [diff] [blame] | 251 | uint64_t time_usec; |
Jonas Ådahl | d251010 | 2014-10-05 21:39:14 +0200 | [diff] [blame] | 252 | double x; |
| 253 | double y; |
| 254 | double dx; |
| 255 | double dy; |
Jonas Ådahl | 3845b32 | 2014-10-21 23:51:29 +0200 | [diff] [blame] | 256 | double dx_unaccel; |
| 257 | double dy_unaccel; |
Jonas Ådahl | d251010 | 2014-10-05 21:39:14 +0200 | [diff] [blame] | 258 | }; |
| 259 | |
Peter Hutterer | 89b6a49 | 2016-01-18 15:58:17 +1000 | [diff] [blame] | 260 | struct weston_pointer_axis_event { |
| 261 | uint32_t axis; |
Giulio Camuffo | 90a6fc6 | 2016-03-22 17:44:54 +0200 | [diff] [blame] | 262 | double value; |
Peter Hutterer | 87743e9 | 2016-01-18 16:38:22 +1000 | [diff] [blame] | 263 | bool has_discrete; |
| 264 | int32_t discrete; |
Peter Hutterer | 89b6a49 | 2016-01-18 15:58:17 +1000 | [diff] [blame] | 265 | }; |
| 266 | |
Kristian Høgsberg | 02bbabb | 2013-05-06 22:15:05 -0400 | [diff] [blame] | 267 | struct weston_pointer_grab; |
| 268 | struct weston_pointer_grab_interface { |
Kristian Høgsberg | 6848c25 | 2013-05-08 22:02:59 -0400 | [diff] [blame] | 269 | void (*focus)(struct weston_pointer_grab *grab); |
Giulio Camuffo | 1959ab8 | 2013-11-14 23:42:52 +0100 | [diff] [blame] | 270 | void (*motion)(struct weston_pointer_grab *grab, uint32_t time, |
Jonas Ådahl | d251010 | 2014-10-05 21:39:14 +0200 | [diff] [blame] | 271 | struct weston_pointer_motion_event *event); |
Kristian Høgsberg | 02bbabb | 2013-05-06 22:15:05 -0400 | [diff] [blame] | 272 | void (*button)(struct weston_pointer_grab *grab, |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 273 | uint32_t time, uint32_t button, uint32_t state); |
Jonas Ådahl | 0336ca0 | 2014-10-04 16:28:29 +0200 | [diff] [blame] | 274 | void (*axis)(struct weston_pointer_grab *grab, |
Peter Hutterer | 89b6a49 | 2016-01-18 15:58:17 +1000 | [diff] [blame] | 275 | uint32_t time, |
| 276 | struct weston_pointer_axis_event *event); |
Peter Hutterer | 87743e9 | 2016-01-18 16:38:22 +1000 | [diff] [blame] | 277 | void (*axis_source)(struct weston_pointer_grab *grab, uint32_t source); |
| 278 | void (*frame)(struct weston_pointer_grab *grab); |
Jonas Ådahl | 1ea343e | 2013-10-25 23:18:05 +0200 | [diff] [blame] | 279 | void (*cancel)(struct weston_pointer_grab *grab); |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 280 | }; |
| 281 | |
Kristian Høgsberg | 02bbabb | 2013-05-06 22:15:05 -0400 | [diff] [blame] | 282 | struct weston_pointer_grab { |
| 283 | const struct weston_pointer_grab_interface *interface; |
| 284 | struct weston_pointer *pointer; |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 285 | }; |
| 286 | |
Kristian Høgsberg | 29139d4 | 2013-04-18 15:25:39 -0400 | [diff] [blame] | 287 | struct weston_keyboard_grab; |
| 288 | struct weston_keyboard_grab_interface { |
| 289 | void (*key)(struct weston_keyboard_grab *grab, uint32_t time, |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 290 | uint32_t key, uint32_t state); |
Kristian Høgsberg | 29139d4 | 2013-04-18 15:25:39 -0400 | [diff] [blame] | 291 | void (*modifiers)(struct weston_keyboard_grab *grab, uint32_t serial, |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 292 | uint32_t mods_depressed, uint32_t mods_latched, |
| 293 | uint32_t mods_locked, uint32_t group); |
Jonas Ådahl | 1ea343e | 2013-10-25 23:18:05 +0200 | [diff] [blame] | 294 | void (*cancel)(struct weston_keyboard_grab *grab); |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 295 | }; |
| 296 | |
Kristian Høgsberg | 29139d4 | 2013-04-18 15:25:39 -0400 | [diff] [blame] | 297 | struct weston_keyboard_grab { |
| 298 | const struct weston_keyboard_grab_interface *interface; |
| 299 | struct weston_keyboard *keyboard; |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 300 | }; |
| 301 | |
Kristian Høgsberg | e329f36 | 2013-05-06 22:19:57 -0400 | [diff] [blame] | 302 | struct weston_touch_grab; |
| 303 | struct weston_touch_grab_interface { |
| 304 | void (*down)(struct weston_touch_grab *grab, |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 305 | uint32_t time, |
| 306 | int touch_id, |
| 307 | wl_fixed_t sx, |
| 308 | wl_fixed_t sy); |
Kristian Høgsberg | e329f36 | 2013-05-06 22:19:57 -0400 | [diff] [blame] | 309 | void (*up)(struct weston_touch_grab *grab, |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 310 | uint32_t time, |
| 311 | int touch_id); |
Kristian Høgsberg | e329f36 | 2013-05-06 22:19:57 -0400 | [diff] [blame] | 312 | void (*motion)(struct weston_touch_grab *grab, |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 313 | uint32_t time, |
| 314 | int touch_id, |
| 315 | wl_fixed_t sx, |
| 316 | wl_fixed_t sy); |
Jonas Ådahl | 1679f23 | 2014-04-12 09:39:51 +0200 | [diff] [blame] | 317 | void (*frame)(struct weston_touch_grab *grab); |
Jonas Ådahl | 1ea343e | 2013-10-25 23:18:05 +0200 | [diff] [blame] | 318 | void (*cancel)(struct weston_touch_grab *grab); |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 319 | }; |
| 320 | |
Kristian Høgsberg | e329f36 | 2013-05-06 22:19:57 -0400 | [diff] [blame] | 321 | struct weston_touch_grab { |
| 322 | const struct weston_touch_grab_interface *interface; |
| 323 | struct weston_touch *touch; |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 324 | }; |
| 325 | |
Kristian Høgsberg | 5e76a49 | 2013-07-25 16:09:37 -0700 | [diff] [blame] | 326 | struct weston_data_offer { |
Jason Ekstrand | 8a4a9eb | 2013-06-14 10:07:55 -0500 | [diff] [blame] | 327 | struct wl_resource *resource; |
Kristian Høgsberg | 7ff3bdb | 2013-07-25 15:52:14 -0700 | [diff] [blame] | 328 | struct weston_data_source *source; |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 329 | struct wl_listener source_destroy_listener; |
Carlos Garnacho | 9c93179 | 2016-01-18 23:52:12 +0100 | [diff] [blame] | 330 | uint32_t dnd_actions; |
| 331 | enum wl_data_device_manager_dnd_action preferred_dnd_action; |
| 332 | bool in_ask; |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 333 | }; |
| 334 | |
Kristian Høgsberg | 7ff3bdb | 2013-07-25 15:52:14 -0700 | [diff] [blame] | 335 | struct weston_data_source { |
Jason Ekstrand | 8a4a9eb | 2013-06-14 10:07:55 -0500 | [diff] [blame] | 336 | struct wl_resource *resource; |
| 337 | struct wl_signal destroy_signal; |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 338 | struct wl_array mime_types; |
Carlos Garnacho | 78d4bf9 | 2016-01-15 21:14:23 +0100 | [diff] [blame] | 339 | struct weston_data_offer *offer; |
| 340 | struct weston_seat *seat; |
| 341 | bool accepted; |
Carlos Garnacho | 9c93179 | 2016-01-18 23:52:12 +0100 | [diff] [blame] | 342 | bool actions_set; |
| 343 | uint32_t dnd_actions; |
| 344 | enum wl_data_device_manager_dnd_action current_dnd_action; |
Carlos Garnacho | b288988 | 2016-01-15 21:14:26 +0100 | [diff] [blame] | 345 | enum wl_data_device_manager_dnd_action compositor_action; |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 346 | |
Kristian Høgsberg | 7ff3bdb | 2013-07-25 15:52:14 -0700 | [diff] [blame] | 347 | void (*accept)(struct weston_data_source *source, |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 348 | uint32_t serial, const char *mime_type); |
Kristian Høgsberg | 7ff3bdb | 2013-07-25 15:52:14 -0700 | [diff] [blame] | 349 | void (*send)(struct weston_data_source *source, |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 350 | const char *mime_type, int32_t fd); |
Kristian Høgsberg | 7ff3bdb | 2013-07-25 15:52:14 -0700 | [diff] [blame] | 351 | void (*cancel)(struct weston_data_source *source); |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 352 | }; |
| 353 | |
Jonas Ådahl | 2cbf293 | 2015-07-22 12:05:38 +0800 | [diff] [blame] | 354 | struct weston_pointer_client { |
| 355 | struct wl_list link; |
| 356 | struct wl_client *client; |
| 357 | struct wl_list pointer_resources; |
Jonas Ådahl | 30d61d8 | 2014-10-22 21:21:17 +0200 | [diff] [blame] | 358 | struct wl_list relative_pointer_resources; |
Jonas Ådahl | 2cbf293 | 2015-07-22 12:05:38 +0800 | [diff] [blame] | 359 | }; |
| 360 | |
Kristian Høgsberg | 02bbabb | 2013-05-06 22:15:05 -0400 | [diff] [blame] | 361 | struct weston_pointer { |
Kristian Høgsberg | e314875 | 2013-05-06 23:19:49 -0400 | [diff] [blame] | 362 | struct weston_seat *seat; |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 363 | |
Jonas Ådahl | 2cbf293 | 2015-07-22 12:05:38 +0800 | [diff] [blame] | 364 | struct wl_list pointer_clients; |
| 365 | |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 366 | struct weston_view *focus; |
Jonas Ådahl | 2cbf293 | 2015-07-22 12:05:38 +0800 | [diff] [blame] | 367 | struct weston_pointer_client *focus_client; |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 368 | uint32_t focus_serial; |
Giulio Camuffo | 576fe2a | 2013-11-20 18:00:24 +0100 | [diff] [blame] | 369 | struct wl_listener focus_view_listener; |
| 370 | struct wl_listener focus_resource_listener; |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 371 | struct wl_signal focus_signal; |
Giulio Camuffo | 6fcb378 | 2013-11-14 23:42:50 +0100 | [diff] [blame] | 372 | struct wl_signal motion_signal; |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 373 | |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 374 | struct weston_view *sprite; |
Kristian Høgsberg | 195b869 | 2013-05-08 15:02:05 -0400 | [diff] [blame] | 375 | struct wl_listener sprite_destroy_listener; |
| 376 | int32_t hotspot_x, hotspot_y; |
| 377 | |
Kristian Høgsberg | 02bbabb | 2013-05-06 22:15:05 -0400 | [diff] [blame] | 378 | struct weston_pointer_grab *grab; |
| 379 | struct weston_pointer_grab default_grab; |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 380 | wl_fixed_t grab_x, grab_y; |
| 381 | uint32_t grab_button; |
| 382 | uint32_t grab_serial; |
| 383 | uint32_t grab_time; |
| 384 | |
| 385 | wl_fixed_t x, y; |
Kristian Høgsberg | db1fccb | 2014-02-05 17:14:42 -0800 | [diff] [blame] | 386 | wl_fixed_t sx, sy; |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 387 | uint32_t button_count; |
Ander Conselvan de Oliveira | f84327a | 2014-01-29 18:47:51 +0200 | [diff] [blame] | 388 | |
| 389 | struct wl_listener output_destroy_listener; |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 390 | }; |
| 391 | |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 392 | |
Kristian Høgsberg | e329f36 | 2013-05-06 22:19:57 -0400 | [diff] [blame] | 393 | struct weston_touch { |
Kristian Høgsberg | e314875 | 2013-05-06 23:19:49 -0400 | [diff] [blame] | 394 | struct weston_seat *seat; |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 395 | |
| 396 | struct wl_list resource_list; |
Neil Roberts | 96d790e | 2013-09-19 17:32:00 +0100 | [diff] [blame] | 397 | struct wl_list focus_resource_list; |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 398 | struct weston_view *focus; |
Giulio Camuffo | 576fe2a | 2013-11-20 18:00:24 +0100 | [diff] [blame] | 399 | struct wl_listener focus_view_listener; |
| 400 | struct wl_listener focus_resource_listener; |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 401 | uint32_t focus_serial; |
| 402 | struct wl_signal focus_signal; |
| 403 | |
Jonas Ådahl | 9484b69 | 2013-12-02 22:05:03 +0100 | [diff] [blame] | 404 | uint32_t num_tp; |
| 405 | |
Kristian Høgsberg | e329f36 | 2013-05-06 22:19:57 -0400 | [diff] [blame] | 406 | struct weston_touch_grab *grab; |
| 407 | struct weston_touch_grab default_grab; |
Neil Roberts | 306fe08 | 2013-10-03 16:43:06 +0100 | [diff] [blame] | 408 | int grab_touch_id; |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 409 | wl_fixed_t grab_x, grab_y; |
| 410 | uint32_t grab_serial; |
| 411 | uint32_t grab_time; |
| 412 | }; |
| 413 | |
Jonas Ådahl | d251010 | 2014-10-05 21:39:14 +0200 | [diff] [blame] | 414 | void |
| 415 | weston_pointer_motion_to_abs(struct weston_pointer *pointer, |
| 416 | struct weston_pointer_motion_event *event, |
| 417 | wl_fixed_t *x, wl_fixed_t *y); |
| 418 | |
Kristian Høgsberg | a4036bb | 2013-05-07 23:52:07 -0400 | [diff] [blame] | 419 | struct weston_pointer * |
Giulio Camuffo | cdb4d29 | 2013-11-14 23:42:53 +0100 | [diff] [blame] | 420 | weston_pointer_create(struct weston_seat *seat); |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 421 | void |
Kristian Høgsberg | a4036bb | 2013-05-07 23:52:07 -0400 | [diff] [blame] | 422 | weston_pointer_destroy(struct weston_pointer *pointer); |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 423 | void |
Jonas Ådahl | 0336ca0 | 2014-10-04 16:28:29 +0200 | [diff] [blame] | 424 | weston_pointer_send_axis(struct weston_pointer *pointer, |
Peter Hutterer | 89b6a49 | 2016-01-18 15:58:17 +1000 | [diff] [blame] | 425 | uint32_t time, |
| 426 | struct weston_pointer_axis_event *event); |
Jonas Ådahl | 0336ca0 | 2014-10-04 16:28:29 +0200 | [diff] [blame] | 427 | void |
Peter Hutterer | 87743e9 | 2016-01-18 16:38:22 +1000 | [diff] [blame] | 428 | weston_pointer_send_axis_source(struct weston_pointer *pointer, |
| 429 | uint32_t source); |
| 430 | void |
| 431 | weston_pointer_send_frame(struct weston_pointer *pointer); |
| 432 | |
| 433 | void |
Kristian Høgsberg | 02bbabb | 2013-05-06 22:15:05 -0400 | [diff] [blame] | 434 | weston_pointer_set_focus(struct weston_pointer *pointer, |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 435 | struct weston_view *view, |
Kristian Høgsberg | 02bbabb | 2013-05-06 22:15:05 -0400 | [diff] [blame] | 436 | wl_fixed_t sx, wl_fixed_t sy); |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 437 | void |
Derek Foreman | f9318d1 | 2015-05-11 15:40:11 -0500 | [diff] [blame] | 438 | weston_pointer_clear_focus(struct weston_pointer *pointer); |
| 439 | void |
Kristian Høgsberg | 02bbabb | 2013-05-06 22:15:05 -0400 | [diff] [blame] | 440 | weston_pointer_start_grab(struct weston_pointer *pointer, |
| 441 | struct weston_pointer_grab *grab); |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 442 | void |
Kristian Høgsberg | 02bbabb | 2013-05-06 22:15:05 -0400 | [diff] [blame] | 443 | weston_pointer_end_grab(struct weston_pointer *pointer); |
Rob Bradford | 806d8c0 | 2013-06-25 18:56:41 +0100 | [diff] [blame] | 444 | void |
| 445 | weston_pointer_clamp(struct weston_pointer *pointer, |
| 446 | wl_fixed_t *fx, wl_fixed_t *fy); |
Giulio Camuffo | 1959ab8 | 2013-11-14 23:42:52 +0100 | [diff] [blame] | 447 | void |
| 448 | weston_pointer_move(struct weston_pointer *pointer, |
Jonas Ådahl | d251010 | 2014-10-05 21:39:14 +0200 | [diff] [blame] | 449 | struct weston_pointer_motion_event *event); |
Giulio Camuffo | cdb4d29 | 2013-11-14 23:42:53 +0100 | [diff] [blame] | 450 | void |
| 451 | weston_pointer_set_default_grab(struct weston_pointer *pointer, |
| 452 | const struct weston_pointer_grab_interface *interface); |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 453 | |
Kristian Høgsberg | a4036bb | 2013-05-07 23:52:07 -0400 | [diff] [blame] | 454 | struct weston_keyboard * |
| 455 | weston_keyboard_create(void); |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 456 | void |
Kristian Høgsberg | a4036bb | 2013-05-07 23:52:07 -0400 | [diff] [blame] | 457 | weston_keyboard_destroy(struct weston_keyboard *keyboard); |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 458 | void |
Kristian Høgsberg | 29139d4 | 2013-04-18 15:25:39 -0400 | [diff] [blame] | 459 | weston_keyboard_set_focus(struct weston_keyboard *keyboard, |
Kristian Høgsberg | fe7aa90 | 2013-05-08 09:54:37 -0400 | [diff] [blame] | 460 | struct weston_surface *surface); |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 461 | void |
Kristian Høgsberg | 29139d4 | 2013-04-18 15:25:39 -0400 | [diff] [blame] | 462 | weston_keyboard_start_grab(struct weston_keyboard *device, |
| 463 | struct weston_keyboard_grab *grab); |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 464 | void |
Kristian Høgsberg | 29139d4 | 2013-04-18 15:25:39 -0400 | [diff] [blame] | 465 | weston_keyboard_end_grab(struct weston_keyboard *keyboard); |
Giulio Camuffo | 6ef444d | 2014-08-28 19:44:09 +0300 | [diff] [blame] | 466 | int |
| 467 | /* |
| 468 | * 'mask' and 'value' should be a bitwise mask of one or more |
| 469 | * valued of the weston_keyboard_locks enum. |
| 470 | */ |
| 471 | weston_keyboard_set_locks(struct weston_keyboard *keyboard, |
| 472 | uint32_t mask, uint32_t value); |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 473 | |
Kristian Høgsberg | a4036bb | 2013-05-07 23:52:07 -0400 | [diff] [blame] | 474 | struct weston_touch * |
| 475 | weston_touch_create(void); |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 476 | void |
Kristian Høgsberg | a4036bb | 2013-05-07 23:52:07 -0400 | [diff] [blame] | 477 | weston_touch_destroy(struct weston_touch *touch); |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 478 | void |
Derek Foreman | 4c93c08 | 2015-04-30 16:45:41 -0500 | [diff] [blame] | 479 | weston_touch_set_focus(struct weston_touch *touch, |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 480 | struct weston_view *view); |
Michael Fu | a2bb791 | 2013-07-23 15:51:06 +0800 | [diff] [blame] | 481 | void |
Kristian Høgsberg | e329f36 | 2013-05-06 22:19:57 -0400 | [diff] [blame] | 482 | weston_touch_start_grab(struct weston_touch *device, |
| 483 | struct weston_touch_grab *grab); |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 484 | void |
Kristian Høgsberg | e329f36 | 2013-05-06 22:19:57 -0400 | [diff] [blame] | 485 | weston_touch_end_grab(struct weston_touch *touch); |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 486 | |
| 487 | void |
Kristian Høgsberg | e314875 | 2013-05-06 23:19:49 -0400 | [diff] [blame] | 488 | wl_data_device_set_keyboard_focus(struct weston_seat *seat); |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 489 | |
| 490 | int |
| 491 | wl_data_device_manager_init(struct wl_display *display); |
| 492 | |
| 493 | |
| 494 | void |
Kristian Høgsberg | e314875 | 2013-05-06 23:19:49 -0400 | [diff] [blame] | 495 | weston_seat_set_selection(struct weston_seat *seat, |
Kristian Høgsberg | 7ff3bdb | 2013-07-25 15:52:14 -0700 | [diff] [blame] | 496 | struct weston_data_source *source, uint32_t serial); |
Giulio Camuffo | dddf9e6 | 2015-05-01 12:59:35 +0300 | [diff] [blame] | 497 | void |
| 498 | weston_seat_send_selection(struct weston_seat *seat, struct wl_client *client); |
| 499 | |
Kristian Høgsberg | 85de9c2 | 2013-09-04 20:44:26 -0700 | [diff] [blame] | 500 | int |
Xiong Zhang | fd51e7b | 2013-11-25 18:42:49 +0800 | [diff] [blame] | 501 | weston_pointer_start_drag(struct weston_pointer *pointer, |
Kristian Høgsberg | 85de9c2 | 2013-09-04 20:44:26 -0700 | [diff] [blame] | 502 | struct weston_data_source *source, |
| 503 | struct weston_surface *icon, |
| 504 | struct wl_client *client); |
Xiong Zhang | fd51e7b | 2013-11-25 18:42:49 +0800 | [diff] [blame] | 505 | int |
| 506 | weston_touch_start_drag(struct weston_touch *touch, |
| 507 | struct weston_data_source *source, |
| 508 | struct weston_surface *icon, |
| 509 | struct wl_client *client); |
Kristian Høgsberg | 2158a88 | 2013-04-18 15:07:39 -0400 | [diff] [blame] | 510 | |
Daniel Stone | d65b909 | 2012-05-30 16:32:05 +0100 | [diff] [blame] | 511 | struct weston_xkb_info { |
| 512 | struct xkb_keymap *keymap; |
Daniel Stone | b7452fe | 2012-06-01 12:14:06 +0100 | [diff] [blame] | 513 | int keymap_fd; |
| 514 | size_t keymap_size; |
| 515 | char *keymap_area; |
Andrew Wedgbury | 9a6f02a | 2013-09-05 13:31:40 +0000 | [diff] [blame] | 516 | int32_t ref_count; |
Daniel Stone | abb9dcd | 2012-06-22 13:21:33 +0100 | [diff] [blame] | 517 | xkb_mod_index_t shift_mod; |
| 518 | xkb_mod_index_t caps_mod; |
Daniel Stone | d65b909 | 2012-05-30 16:32:05 +0100 | [diff] [blame] | 519 | xkb_mod_index_t ctrl_mod; |
| 520 | xkb_mod_index_t alt_mod; |
Daniel Stone | abb9dcd | 2012-06-22 13:21:33 +0100 | [diff] [blame] | 521 | xkb_mod_index_t mod2_mod; |
| 522 | xkb_mod_index_t mod3_mod; |
Daniel Stone | d65b909 | 2012-05-30 16:32:05 +0100 | [diff] [blame] | 523 | xkb_mod_index_t super_mod; |
Daniel Stone | abb9dcd | 2012-06-22 13:21:33 +0100 | [diff] [blame] | 524 | xkb_mod_index_t mod5_mod; |
Daniel Stone | d65b909 | 2012-05-30 16:32:05 +0100 | [diff] [blame] | 525 | xkb_led_index_t num_led; |
| 526 | xkb_led_index_t caps_led; |
| 527 | xkb_led_index_t scroll_led; |
| 528 | }; |
| 529 | |
Jan Arne Petersen | a75a789 | 2013-01-16 21:26:50 +0100 | [diff] [blame] | 530 | struct weston_keyboard { |
Kristian Høgsberg | e314875 | 2013-05-06 23:19:49 -0400 | [diff] [blame] | 531 | struct weston_seat *seat; |
Jan Arne Petersen | a75a789 | 2013-01-16 21:26:50 +0100 | [diff] [blame] | 532 | |
Kristian Høgsberg | 29139d4 | 2013-04-18 15:25:39 -0400 | [diff] [blame] | 533 | struct wl_list resource_list; |
Neil Roberts | 96d790e | 2013-09-19 17:32:00 +0100 | [diff] [blame] | 534 | struct wl_list focus_resource_list; |
Kristian Høgsberg | fe7aa90 | 2013-05-08 09:54:37 -0400 | [diff] [blame] | 535 | struct weston_surface *focus; |
Giulio Camuffo | 576fe2a | 2013-11-20 18:00:24 +0100 | [diff] [blame] | 536 | struct wl_listener focus_resource_listener; |
Kristian Høgsberg | 29139d4 | 2013-04-18 15:25:39 -0400 | [diff] [blame] | 537 | uint32_t focus_serial; |
| 538 | struct wl_signal focus_signal; |
| 539 | |
| 540 | struct weston_keyboard_grab *grab; |
| 541 | struct weston_keyboard_grab default_grab; |
| 542 | uint32_t grab_key; |
| 543 | uint32_t grab_serial; |
| 544 | uint32_t grab_time; |
| 545 | |
| 546 | struct wl_array keys; |
| 547 | |
| 548 | struct { |
| 549 | uint32_t mods_depressed; |
| 550 | uint32_t mods_latched; |
| 551 | uint32_t mods_locked; |
| 552 | uint32_t group; |
| 553 | } modifiers; |
| 554 | |
| 555 | struct weston_keyboard_grab input_method_grab; |
Jan Arne Petersen | a75a789 | 2013-01-16 21:26:50 +0100 | [diff] [blame] | 556 | struct wl_resource *input_method_resource; |
Jonas Ådahl | 7395ea0 | 2013-12-03 09:14:26 +0100 | [diff] [blame] | 557 | |
| 558 | struct weston_xkb_info *xkb_info; |
| 559 | struct { |
| 560 | struct xkb_state *state; |
| 561 | enum weston_led leds; |
| 562 | } xkb_state; |
| 563 | struct xkb_keymap *pending_keymap; |
Jan Arne Petersen | a75a789 | 2013-01-16 21:26:50 +0100 | [diff] [blame] | 564 | }; |
| 565 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 566 | struct weston_seat { |
Kristian Høgsberg | e314875 | 2013-05-06 23:19:49 -0400 | [diff] [blame] | 567 | struct wl_list base_resource_list; |
| 568 | |
Kristian Høgsberg | aaadc77 | 2013-07-08 16:20:31 -0400 | [diff] [blame] | 569 | struct wl_global *global; |
Derek Foreman | 1281a36 | 2015-07-31 16:55:32 -0500 | [diff] [blame] | 570 | struct weston_pointer *pointer_state; |
| 571 | struct weston_keyboard *keyboard_state; |
| 572 | struct weston_touch *touch_state; |
Jonas Ådahl | d6e1c34 | 2013-10-17 23:04:05 +0200 | [diff] [blame] | 573 | int pointer_device_count; |
| 574 | int keyboard_device_count; |
| 575 | int touch_device_count; |
Kristian Høgsberg | e314875 | 2013-05-06 23:19:49 -0400 | [diff] [blame] | 576 | |
Rob Bradford | 66bd9f5 | 2013-06-25 18:56:42 +0100 | [diff] [blame] | 577 | struct weston_output *output; /* constraint */ |
| 578 | |
Giulio Camuffo | 5085a75 | 2013-03-25 21:42:45 +0100 | [diff] [blame] | 579 | struct wl_signal destroy_signal; |
Jason Ekstrand | a4ab542 | 2014-04-02 19:53:45 -0500 | [diff] [blame] | 580 | struct wl_signal updated_caps_signal; |
Daniel Stone | 74419a2 | 2012-05-30 16:32:02 +0100 | [diff] [blame] | 581 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 582 | struct weston_compositor *compositor; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 583 | struct wl_list link; |
Daniel Stone | 496ca17 | 2012-05-30 16:31:42 +0100 | [diff] [blame] | 584 | enum weston_keyboard_modifier modifier_state; |
Kristian Høgsberg | fe7aa90 | 2013-05-08 09:54:37 -0400 | [diff] [blame] | 585 | struct weston_surface *saved_kbd_focus; |
Ander Conselvan de Oliveira | 71b1d0c | 2012-03-16 17:25:11 +0200 | [diff] [blame] | 586 | struct wl_listener saved_kbd_focus_listener; |
Kristian Høgsberg | 054c50a | 2013-05-08 15:27:47 -0400 | [diff] [blame] | 587 | struct wl_list drag_resource_list; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 588 | |
Kristian Høgsberg | e314875 | 2013-05-06 23:19:49 -0400 | [diff] [blame] | 589 | uint32_t selection_serial; |
Kristian Høgsberg | 7ff3bdb | 2013-07-25 15:52:14 -0700 | [diff] [blame] | 590 | struct weston_data_source *selection_data_source; |
Kristian Høgsberg | e314875 | 2013-05-06 23:19:49 -0400 | [diff] [blame] | 591 | struct wl_listener selection_data_source_listener; |
| 592 | struct wl_signal selection_signal; |
| 593 | |
Daniel Stone | 8c8164f | 2012-05-30 16:31:45 +0100 | [diff] [blame] | 594 | void (*led_update)(struct weston_seat *ws, enum weston_led leds); |
| 595 | |
Jan Arne Petersen | e829adc | 2012-08-10 16:47:22 +0200 | [diff] [blame] | 596 | struct input_method *input_method; |
Rob Bradford | 9af5f9e | 2013-05-31 18:09:50 +0100 | [diff] [blame] | 597 | char *seat_name; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 598 | }; |
| 599 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 600 | enum { |
Bryce Harrington | c2be857 | 2015-12-11 13:11:37 -0800 | [diff] [blame] | 601 | WESTON_COMPOSITOR_ACTIVE, /* normal rendering and events */ |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 602 | WESTON_COMPOSITOR_IDLE, /* shell->unlock called on activity */ |
Philipp Brüschweiler | 57edf7f | 2013-03-29 13:01:56 +0100 | [diff] [blame] | 603 | WESTON_COMPOSITOR_OFFSCREEN, /* no rendering, no frame events */ |
Bryce Harrington | c2be857 | 2015-12-11 13:11:37 -0800 | [diff] [blame] | 604 | WESTON_COMPOSITOR_SLEEPING /* same as offscreen, but also set dpms |
Philipp Brüschweiler | 57edf7f | 2013-03-29 13:01:56 +0100 | [diff] [blame] | 605 | * to off */ |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 606 | }; |
| 607 | |
Giulio Camuffo | 412e6a5 | 2014-07-09 22:12:56 +0300 | [diff] [blame] | 608 | struct weston_layer_entry { |
| 609 | struct wl_list link; |
| 610 | struct weston_layer *layer; |
| 611 | }; |
| 612 | |
Kristian Høgsberg | 3be2ce9 | 2012-02-29 12:42:35 -0500 | [diff] [blame] | 613 | struct weston_layer { |
Giulio Camuffo | 412e6a5 | 2014-07-09 22:12:56 +0300 | [diff] [blame] | 614 | struct weston_layer_entry view_list; |
Kristian Høgsberg | 3be2ce9 | 2012-02-29 12:42:35 -0500 | [diff] [blame] | 615 | struct wl_list link; |
Giulio Camuffo | 95ec0f9 | 2014-07-09 22:12:57 +0300 | [diff] [blame] | 616 | pixman_box32_t mask; |
Kristian Høgsberg | 3be2ce9 | 2012-02-29 12:42:35 -0500 | [diff] [blame] | 617 | }; |
| 618 | |
Kristian Høgsberg | 65a11e1 | 2012-08-03 11:30:18 -0400 | [diff] [blame] | 619 | struct weston_plane { |
Xiong Zhang | 9711653 | 2013-10-23 13:58:31 +0800 | [diff] [blame] | 620 | struct weston_compositor *compositor; |
Pekka Paalanen | 502f5e0 | 2015-02-23 14:08:25 +0200 | [diff] [blame] | 621 | pixman_region32_t damage; /**< in global coords */ |
Ander Conselvan de Oliveira | e1bd5a0 | 2013-03-05 17:30:29 +0200 | [diff] [blame] | 622 | pixman_region32_t clip; |
Kristian Høgsberg | 65a11e1 | 2012-08-03 11:30:18 -0400 | [diff] [blame] | 623 | int32_t x, y; |
Ander Conselvan de Oliveira | 8ad1982 | 2013-03-05 17:30:27 +0200 | [diff] [blame] | 624 | struct wl_list link; |
Kristian Høgsberg | 65a11e1 | 2012-08-03 11:30:18 -0400 | [diff] [blame] | 625 | }; |
| 626 | |
Kristian Høgsberg | fa1be02 | 2012-09-05 22:49:55 -0400 | [diff] [blame] | 627 | struct weston_renderer { |
John Kåre Alsaker | a95b2d6 | 2012-11-13 19:10:21 +0100 | [diff] [blame] | 628 | int (*read_pixels)(struct weston_output *output, |
| 629 | pixman_format_code_t format, void *pixels, |
| 630 | uint32_t x, uint32_t y, |
| 631 | uint32_t width, uint32_t height); |
Kristian Høgsberg | fa1be02 | 2012-09-05 22:49:55 -0400 | [diff] [blame] | 632 | void (*repaint_output)(struct weston_output *output, |
| 633 | pixman_region32_t *output_damage); |
| 634 | void (*flush_damage)(struct weston_surface *surface); |
Jason Ekstrand | 6bd6294 | 2013-06-20 20:38:23 -0500 | [diff] [blame] | 635 | void (*attach)(struct weston_surface *es, struct weston_buffer *buffer); |
John Kåre Alsaker | 878f449 | 2012-11-13 19:10:23 +0100 | [diff] [blame] | 636 | void (*surface_set_color)(struct weston_surface *surface, |
| 637 | float red, float green, |
| 638 | float blue, float alpha); |
Vasily Khoruzhick | 52cfd61 | 2013-01-08 19:09:01 +0300 | [diff] [blame] | 639 | void (*destroy)(struct weston_compositor *ec); |
Pekka Paalanen | c647ed7 | 2015-02-09 13:16:57 +0200 | [diff] [blame] | 640 | |
| 641 | |
| 642 | /** See weston_surface_get_content_size() */ |
| 643 | void (*surface_get_content_size)(struct weston_surface *surface, |
| 644 | int *width, int *height); |
| 645 | |
| 646 | /** See weston_surface_copy_content() */ |
| 647 | int (*surface_copy_content)(struct weston_surface *surface, |
| 648 | void *target, size_t size, |
| 649 | int src_x, int src_y, |
| 650 | int width, int height); |
Pekka Paalanen | 230f3b1 | 2014-09-29 14:18:40 -0400 | [diff] [blame] | 651 | |
| 652 | /** See weston_compositor_import_dmabuf() */ |
| 653 | bool (*import_dmabuf)(struct weston_compositor *ec, |
| 654 | struct linux_dmabuf_buffer *buffer); |
Kristian Høgsberg | fa1be02 | 2012-09-05 22:49:55 -0400 | [diff] [blame] | 655 | }; |
| 656 | |
Pekka Paalanen | 7bb6510 | 2013-05-22 18:03:04 +0300 | [diff] [blame] | 657 | enum weston_capability { |
| 658 | /* backend/renderer supports arbitrary rotation */ |
| 659 | WESTON_CAP_ROTATION_ANY = 0x0001, |
Pekka Paalanen | 4fc5dd0 | 2013-05-22 18:03:05 +0300 | [diff] [blame] | 660 | |
| 661 | /* screencaptures need to be y-flipped */ |
| 662 | WESTON_CAP_CAPTURE_YFLIP = 0x0002, |
Jason Ekstrand | 9fc7151 | 2014-04-02 19:53:46 -0500 | [diff] [blame] | 663 | |
Bryce Harrington | a86c3ee | 2015-03-18 18:42:00 -0700 | [diff] [blame] | 664 | /* backend/renderer has a separate cursor plane */ |
Jason Ekstrand | 9fc7151 | 2014-04-02 19:53:46 -0500 | [diff] [blame] | 665 | WESTON_CAP_CURSOR_PLANE = 0x0004, |
| 666 | |
| 667 | /* backend supports setting arbitrary resolutions */ |
| 668 | WESTON_CAP_ARBITRARY_MODES = 0x0008, |
Pekka Paalanen | 380adf5 | 2015-02-16 14:39:11 +0200 | [diff] [blame] | 669 | |
| 670 | /* renderer supports weston_view_set_mask() clipping */ |
| 671 | WESTON_CAP_VIEW_CLIP_MASK = 0x0010, |
Pekka Paalanen | 7bb6510 | 2013-05-22 18:03:04 +0300 | [diff] [blame] | 672 | }; |
| 673 | |
Giulio Camuffo | e3c0d8a | 2015-10-17 19:24:13 +0300 | [diff] [blame] | 674 | /* Configuration struct for an output. |
| 675 | * |
| 676 | * This struct is used to pass the configuration for an output |
| 677 | * to the compositor backend when creating a new output. |
| 678 | * The backend can subclass this struct to handle backend |
| 679 | * specific data. |
| 680 | */ |
| 681 | struct weston_backend_output_config { |
| 682 | uint32_t transform; |
Bryce Harrington | 32c3211 | 2015-10-23 15:29:23 -0700 | [diff] [blame] | 683 | uint32_t width; |
| 684 | uint32_t height; |
| 685 | uint32_t scale; |
Giulio Camuffo | e3c0d8a | 2015-10-17 19:24:13 +0300 | [diff] [blame] | 686 | }; |
| 687 | |
| 688 | /* Configuration struct for a backend. |
| 689 | * |
| 690 | * This struct carries the configuration for a backend, and it's |
| 691 | * passed to the backend's init entry point. The backend will |
| 692 | * likely want to subclass this in order to handle backend specific |
| 693 | * data. |
Bryce Harrington | 20b66c3 | 2016-04-15 20:28:29 -0700 | [diff] [blame] | 694 | * |
| 695 | * NOTE: Alternate designs were proposed (Feb 2016) for using opaque |
| 696 | * structures[1] and for section+key/value getter/setters[2]. The rationale |
| 697 | * for selecting the transparent structure design is based on several |
| 698 | * assumptions[3] which may require re-evaluating the design choice if they |
| 699 | * fail to hold. |
| 700 | * |
| 701 | * 1: https://lists.freedesktop.org/archives/wayland-devel/2016-February/026989.html |
| 702 | * 2: https://lists.freedesktop.org/archives/wayland-devel/2016-February/026929.html |
| 703 | * 3: https://lists.freedesktop.org/archives/wayland-devel/2016-February/027228.html |
Giulio Camuffo | e3c0d8a | 2015-10-17 19:24:13 +0300 | [diff] [blame] | 704 | */ |
| 705 | struct weston_backend_config { |
Bryce Harrington | 20b66c3 | 2016-04-15 20:28:29 -0700 | [diff] [blame] | 706 | /** Major version for the backend-specific config struct |
| 707 | * |
| 708 | * This version must match exactly what the backend expects, otherwise |
| 709 | * the struct is incompatible. |
| 710 | */ |
| 711 | uint32_t struct_version; |
| 712 | |
| 713 | /** Minor version of the backend-specific config struct |
| 714 | * |
| 715 | * This must be set to sizeof(struct backend-specific config). |
| 716 | * If the value here is smaller than what the backend expects, the |
| 717 | * extra config members will assume their default values. |
| 718 | * |
| 719 | * A value greater than what the backend expects is incompatible. |
| 720 | */ |
| 721 | size_t struct_size; |
Giulio Camuffo | e3c0d8a | 2015-10-17 19:24:13 +0300 | [diff] [blame] | 722 | }; |
| 723 | |
Giulio Camuffo | 954f183 | 2014-10-11 18:27:30 +0300 | [diff] [blame] | 724 | struct weston_backend { |
Giulio Camuffo | e3c0d8a | 2015-10-17 19:24:13 +0300 | [diff] [blame] | 725 | void (*destroy)(struct weston_compositor *compositor); |
| 726 | void (*restore)(struct weston_compositor *compositor); |
Giulio Camuffo | 954f183 | 2014-10-11 18:27:30 +0300 | [diff] [blame] | 727 | }; |
| 728 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 729 | struct weston_compositor { |
Kristian Høgsberg | 02e79dc | 2012-04-12 09:55:26 -0400 | [diff] [blame] | 730 | struct wl_signal destroy_signal; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 731 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 732 | struct wl_display *wl_display; |
Tiago Vignatti | bc052c9 | 2012-04-19 16:18:18 +0300 | [diff] [blame] | 733 | struct weston_shell_interface shell_interface; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 734 | |
Tiago Vignatti | fb2adba | 2013-06-12 15:43:21 -0300 | [diff] [blame] | 735 | /* surface signals */ |
Kristian Høgsberg | f03a04a | 2014-04-06 22:04:50 -0700 | [diff] [blame] | 736 | struct wl_signal create_surface_signal; |
Kristian Høgsberg | 02e79dc | 2012-04-12 09:55:26 -0400 | [diff] [blame] | 737 | struct wl_signal activate_signal; |
Tiago Vignatti | fb2adba | 2013-06-12 15:43:21 -0300 | [diff] [blame] | 738 | struct wl_signal transform_signal; |
| 739 | |
Tiago Vignatti | 1d01b01 | 2012-09-27 17:48:36 +0300 | [diff] [blame] | 740 | struct wl_signal kill_signal; |
Ander Conselvan de Oliveira | a457563 | 2013-02-21 18:35:23 +0200 | [diff] [blame] | 741 | struct wl_signal idle_signal; |
| 742 | struct wl_signal wake_signal; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 743 | |
Jan Arne Petersen | 42feced | 2012-06-21 21:52:17 +0200 | [diff] [blame] | 744 | struct wl_signal show_input_panel_signal; |
| 745 | struct wl_signal hide_input_panel_signal; |
Jan Arne Petersen | 14da96b | 2013-04-18 16:47:28 +0200 | [diff] [blame] | 746 | struct wl_signal update_input_panel_signal; |
Jan Arne Petersen | 42feced | 2012-06-21 21:52:17 +0200 | [diff] [blame] | 747 | |
Jan Arne Petersen | 674fd1d | 2012-11-18 19:06:42 +0100 | [diff] [blame] | 748 | struct wl_signal seat_created_signal; |
Richard Hughes | 59d5da7 | 2013-05-01 21:52:11 +0100 | [diff] [blame] | 749 | struct wl_signal output_created_signal; |
Ander Conselvan de Oliveira | f84327a | 2014-01-29 18:47:51 +0200 | [diff] [blame] | 750 | struct wl_signal output_destroyed_signal; |
Ander Conselvan de Oliveira | a8a9baf | 2014-01-29 18:47:52 +0200 | [diff] [blame] | 751 | struct wl_signal output_moved_signal; |
David Fort | 0de859e | 2016-05-27 23:22:57 +0200 | [diff] [blame] | 752 | struct wl_signal output_resized_signal; /* callback argument: resized output */ |
Jan Arne Petersen | 674fd1d | 2012-11-18 19:06:42 +0100 | [diff] [blame] | 753 | |
Kristian Høgsberg | 61741a2 | 2013-09-17 16:02:57 -0700 | [diff] [blame] | 754 | struct wl_signal session_signal; |
| 755 | int session_active; |
| 756 | |
Kristian Høgsberg | 3be2ce9 | 2012-02-29 12:42:35 -0500 | [diff] [blame] | 757 | struct weston_layer fade_layer; |
| 758 | struct weston_layer cursor_layer; |
| 759 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 760 | struct wl_list output_list; |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 761 | struct wl_list seat_list; |
Kristian Høgsberg | 3be2ce9 | 2012-02-29 12:42:35 -0500 | [diff] [blame] | 762 | struct wl_list layer_list; |
Pekka Paalanen | 20c7e55 | 2016-03-30 14:08:24 +0300 | [diff] [blame] | 763 | struct wl_list view_list; /* struct weston_view::link */ |
Ander Conselvan de Oliveira | 8ad1982 | 2013-03-05 17:30:27 +0200 | [diff] [blame] | 764 | struct wl_list plane_list; |
Daniel Stone | 325fc2d | 2012-05-30 16:31:58 +0100 | [diff] [blame] | 765 | struct wl_list key_binding_list; |
Daniel Stone | 96d47c0 | 2013-11-19 11:37:12 +0100 | [diff] [blame] | 766 | struct wl_list modifier_binding_list; |
Daniel Stone | 325fc2d | 2012-05-30 16:31:58 +0100 | [diff] [blame] | 767 | struct wl_list button_binding_list; |
Neil Roberts | a28c693 | 2013-10-03 16:43:04 +0100 | [diff] [blame] | 768 | struct wl_list touch_binding_list; |
Daniel Stone | 325fc2d | 2012-05-30 16:31:58 +0100 | [diff] [blame] | 769 | struct wl_list axis_binding_list; |
Ander Conselvan de Oliveira | c509d2b | 2012-11-08 17:20:45 +0200 | [diff] [blame] | 770 | struct wl_list debug_binding_list; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 771 | |
| 772 | uint32_t state; |
| 773 | struct wl_event_source *idle_source; |
| 774 | uint32_t idle_inhibit; |
Philipp Brüschweiler | 4b409c3 | 2013-03-10 14:37:04 +0100 | [diff] [blame] | 775 | int idle_time; /* timeout, s */ |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 776 | |
Giulio Camuffo | cdb4d29 | 2013-11-14 23:42:53 +0100 | [diff] [blame] | 777 | const struct weston_pointer_grab_interface *default_pointer_grab; |
| 778 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 779 | /* Repaint state. */ |
Kristian Høgsberg | 65a11e1 | 2012-08-03 11:30:18 -0400 | [diff] [blame] | 780 | struct weston_plane primary_plane; |
Pekka Paalanen | 7bb6510 | 2013-05-22 18:03:04 +0300 | [diff] [blame] | 781 | uint32_t capabilities; /* combination of enum weston_capability */ |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 782 | |
Kristian Høgsberg | fa1be02 | 2012-09-05 22:49:55 -0400 | [diff] [blame] | 783 | struct weston_renderer *renderer; |
| 784 | |
John Kåre Alsaker | f9e710b | 2012-11-13 19:10:22 +0100 | [diff] [blame] | 785 | pixman_format_code_t read_format; |
Pekka Paalanen | 52bfbaa | 2012-04-11 16:19:37 +0300 | [diff] [blame] | 786 | |
Giulio Camuffo | 954f183 | 2014-10-11 18:27:30 +0300 | [diff] [blame] | 787 | struct weston_backend *backend; |
Kristian Høgsberg | 3466bc8 | 2012-01-03 11:29:15 -0500 | [diff] [blame] | 788 | |
Kristian Høgsberg | 05ad1e4 | 2013-09-17 14:41:03 -0700 | [diff] [blame] | 789 | struct weston_launcher *launcher; |
Casey Dahlin | 58ba137 | 2012-04-19 22:50:08 -0400 | [diff] [blame] | 790 | |
Pekka Paalanen | 827b5d2 | 2016-06-29 11:54:26 +0200 | [diff] [blame] | 791 | struct wl_list plugin_api_list; /* struct weston_plugin_api::link */ |
| 792 | |
Casey Dahlin | 58ba137 | 2012-04-19 22:50:08 -0400 | [diff] [blame] | 793 | uint32_t output_id_pool; |
Daniel Stone | 855028f | 2012-05-01 20:37:10 +0100 | [diff] [blame] | 794 | |
Daniel Stone | e379da9 | 2012-05-30 16:32:04 +0100 | [diff] [blame] | 795 | struct xkb_rule_names xkb_names; |
| 796 | struct xkb_context *xkb_context; |
Andrew Wedgbury | 9a6f02a | 2013-09-05 13:31:40 +0000 | [diff] [blame] | 797 | struct weston_xkb_info *xkb_info; |
Matt Roper | 01a9273 | 2013-06-24 16:52:44 +0100 | [diff] [blame] | 798 | |
| 799 | /* Raw keyboard processing (no libxkbcommon initialization or handling) */ |
| 800 | int use_xkbcommon; |
Jonny Lamb | 66a41a0 | 2014-08-12 14:58:25 +0200 | [diff] [blame] | 801 | |
| 802 | int32_t kb_repeat_rate; |
| 803 | int32_t kb_repeat_delay; |
Pekka Paalanen | b5eedad | 2014-09-23 22:08:45 -0400 | [diff] [blame] | 804 | |
Bob Ham | 91880f1 | 2016-01-12 10:21:47 +0000 | [diff] [blame] | 805 | bool vt_switching; |
| 806 | |
Pekka Paalanen | b5eedad | 2014-09-23 22:08:45 -0400 | [diff] [blame] | 807 | clockid_t presentation_clock; |
Pekka Paalanen | 0513a95 | 2014-05-21 16:17:27 +0300 | [diff] [blame] | 808 | int32_t repaint_msec; |
Frederic Plourde | c336f06 | 2014-10-29 14:44:33 -0400 | [diff] [blame] | 809 | |
Jonas Ådahl | 94e2e2d | 2014-10-18 18:42:19 +0200 | [diff] [blame] | 810 | unsigned int activate_serial; |
| 811 | |
Frederic Plourde | c336f06 | 2014-10-29 14:44:33 -0400 | [diff] [blame] | 812 | int exit_code; |
Giulio Camuffo | 459137b | 2014-10-11 23:56:24 +0300 | [diff] [blame] | 813 | |
| 814 | void *user_data; |
| 815 | void (*exit)(struct weston_compositor *c); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 816 | }; |
| 817 | |
Jason Ekstrand | 6bd6294 | 2013-06-20 20:38:23 -0500 | [diff] [blame] | 818 | struct weston_buffer { |
| 819 | struct wl_resource *resource; |
| 820 | struct wl_signal destroy_signal; |
| 821 | struct wl_listener destroy_listener; |
| 822 | |
| 823 | union { |
| 824 | struct wl_shm_buffer *shm_buffer; |
Jason Ekstrand | a85118c | 2013-06-27 20:17:02 -0500 | [diff] [blame] | 825 | void *legacy_buffer; |
Jason Ekstrand | 6bd6294 | 2013-06-20 20:38:23 -0500 | [diff] [blame] | 826 | }; |
| 827 | int32_t width, height; |
| 828 | uint32_t busy_count; |
Stanislav Vorobiov | bfbb8e5 | 2013-08-29 11:36:44 +0400 | [diff] [blame] | 829 | int y_inverted; |
Jason Ekstrand | 6bd6294 | 2013-06-20 20:38:23 -0500 | [diff] [blame] | 830 | }; |
| 831 | |
Pekka Paalanen | de685b8 | 2012-12-04 15:58:12 +0200 | [diff] [blame] | 832 | struct weston_buffer_reference { |
Jason Ekstrand | 6bd6294 | 2013-06-20 20:38:23 -0500 | [diff] [blame] | 833 | struct weston_buffer *buffer; |
Pekka Paalanen | de685b8 | 2012-12-04 15:58:12 +0200 | [diff] [blame] | 834 | struct wl_listener destroy_listener; |
| 835 | }; |
| 836 | |
Pekka Paalanen | 1fd9c0f | 2013-11-26 18:19:41 +0100 | [diff] [blame] | 837 | struct weston_buffer_viewport { |
Pekka Paalanen | 952b6c8 | 2014-03-14 14:38:15 +0200 | [diff] [blame] | 838 | struct { |
| 839 | /* wl_surface.set_buffer_transform */ |
| 840 | uint32_t transform; |
Pekka Paalanen | 1fd9c0f | 2013-11-26 18:19:41 +0100 | [diff] [blame] | 841 | |
Pekka Paalanen | 952b6c8 | 2014-03-14 14:38:15 +0200 | [diff] [blame] | 842 | /* wl_surface.set_scaling_factor */ |
| 843 | int32_t scale; |
Jonny Lamb | 7413076 | 2013-11-26 18:19:46 +0100 | [diff] [blame] | 844 | |
Pekka Paalanen | f0cad48 | 2014-03-14 14:38:16 +0200 | [diff] [blame] | 845 | /* |
| 846 | * If src_width != wl_fixed_from_int(-1), |
| 847 | * then and only then src_* are used. |
| 848 | */ |
Pekka Paalanen | 952b6c8 | 2014-03-14 14:38:15 +0200 | [diff] [blame] | 849 | wl_fixed_t src_x, src_y; |
| 850 | wl_fixed_t src_width, src_height; |
| 851 | } buffer; |
| 852 | |
| 853 | struct { |
Pekka Paalanen | f0cad48 | 2014-03-14 14:38:16 +0200 | [diff] [blame] | 854 | /* |
| 855 | * If width == -1, the size is inferred from the buffer. |
| 856 | */ |
Pekka Paalanen | 952b6c8 | 2014-03-14 14:38:15 +0200 | [diff] [blame] | 857 | int32_t width, height; |
| 858 | } surface; |
George Kiagiadakis | 8f9e87f | 2014-06-13 18:14:20 +0200 | [diff] [blame] | 859 | |
| 860 | int changed; |
Pekka Paalanen | 1fd9c0f | 2013-11-26 18:19:41 +0100 | [diff] [blame] | 861 | }; |
| 862 | |
Kristian Høgsberg | 5e7e6f2 | 2012-02-23 16:11:59 -0500 | [diff] [blame] | 863 | struct weston_region { |
Jason Ekstrand | 8895efc | 2013-06-14 10:07:56 -0500 | [diff] [blame] | 864 | struct wl_resource *resource; |
Kristian Høgsberg | 5e7e6f2 | 2012-02-23 16:11:59 -0500 | [diff] [blame] | 865 | pixman_region32_t region; |
| 866 | }; |
| 867 | |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 868 | /* Using weston_view transformations |
Pekka Paalanen | 44ab69c | 2012-02-07 13:18:00 +0200 | [diff] [blame] | 869 | * |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 870 | * To add a transformation to a view, create a struct weston_transform, and |
| 871 | * add it to the list view->geometry.transformation_list. Whenever you |
| 872 | * change the list, anything under view->geometry, or anything in the |
Pekka Paalanen | c3ce738 | 2013-03-08 14:56:49 +0200 | [diff] [blame] | 873 | * weston_transforms linked into the list, you must call |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 874 | * weston_view_geometry_dirty(). |
Pekka Paalanen | 44ab69c | 2012-02-07 13:18:00 +0200 | [diff] [blame] | 875 | * |
| 876 | * The order in the list defines the order of transformations. Let the list |
| 877 | * contain the transformation matrices M1, ..., Mn as head to tail. The |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 878 | * transformation is applied to view-local coordinate vector p as |
Pekka Paalanen | 44ab69c | 2012-02-07 13:18:00 +0200 | [diff] [blame] | 879 | * P = Mn * ... * M2 * M1 * p |
| 880 | * to produce the global coordinate vector P. The total transform |
| 881 | * Mn * ... * M2 * M1 |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 882 | * is cached in view->transform.matrix, and the inverse of it in |
| 883 | * view->transform.inverse. |
Pekka Paalanen | 44ab69c | 2012-02-07 13:18:00 +0200 | [diff] [blame] | 884 | * |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 885 | * The list always contains view->transform.position transformation, which |
| 886 | * is the translation by view->geometry.x and y. |
Pekka Paalanen | 44ab69c | 2012-02-07 13:18:00 +0200 | [diff] [blame] | 887 | * |
| 888 | * If you want to apply a transformation in local coordinates, add your |
| 889 | * weston_transform to the head of the list. If you want to apply a |
| 890 | * transformation in global coordinates, add it to the tail of the list. |
Pekka Paalanen | 483243f | 2013-03-08 14:56:50 +0200 | [diff] [blame] | 891 | * |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 892 | * If view->geometry.parent is set, the total transformation of this |
| 893 | * view will be the parent's total transformation and this transformation |
Pekka Paalanen | 483243f | 2013-03-08 14:56:50 +0200 | [diff] [blame] | 894 | * combined: |
| 895 | * Mparent * Mn * ... * M2 * M1 |
Pekka Paalanen | 44ab69c | 2012-02-07 13:18:00 +0200 | [diff] [blame] | 896 | */ |
| 897 | |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 898 | struct weston_view { |
| 899 | struct weston_surface *surface; |
| 900 | struct wl_list surface_link; |
Jason Ekstrand | 26ed73c | 2013-06-06 22:34:41 -0500 | [diff] [blame] | 901 | struct wl_signal destroy_signal; |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 902 | |
Pekka Paalanen | 20c7e55 | 2016-03-30 14:08:24 +0300 | [diff] [blame] | 903 | struct wl_list link; /* weston_compositor::view_list */ |
Pekka Paalanen | 8844bf2 | 2015-02-18 16:30:47 +0200 | [diff] [blame] | 904 | struct weston_layer_entry layer_link; /* part of geometry */ |
Kristian Høgsberg | 65a11e1 | 2012-08-03 11:30:18 -0400 | [diff] [blame] | 905 | struct weston_plane *plane; |
Pekka Paalanen | 2d6e551 | 2015-02-18 16:06:46 +0200 | [diff] [blame] | 906 | |
| 907 | /* For weston_layer inheritance from another view */ |
Giulio Camuffo | 95ec0f9 | 2014-07-09 22:12:57 +0300 | [diff] [blame] | 908 | struct weston_view *parent_view; |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 909 | |
Jonas Ådahl | 94e2e2d | 2014-10-18 18:42:19 +0200 | [diff] [blame] | 910 | unsigned int click_to_activate_serial; |
| 911 | |
Pekka Paalanen | 51723d5 | 2015-02-17 13:10:01 +0200 | [diff] [blame] | 912 | pixman_region32_t clip; /* See weston_view_damage_below() */ |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 913 | float alpha; /* part of geometry, see below */ |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 914 | |
John Kåre Alsaker | 878f449 | 2012-11-13 19:10:23 +0100 | [diff] [blame] | 915 | void *renderer_state; |
| 916 | |
Pekka Paalanen | bc0b7e7 | 2012-01-24 09:53:37 +0200 | [diff] [blame] | 917 | /* Surface geometry state, mutable. |
Pekka Paalanen | c3ce738 | 2013-03-08 14:56:49 +0200 | [diff] [blame] | 918 | * If you change anything, call weston_surface_geometry_dirty(). |
Pekka Paalanen | bc0b7e7 | 2012-01-24 09:53:37 +0200 | [diff] [blame] | 919 | * That includes the transformations referenced from the list. |
| 920 | */ |
Pekka Paalanen | c61eca6 | 2012-01-06 14:10:06 +0200 | [diff] [blame] | 921 | struct { |
John Kåre Alsaker | 490d02a | 2012-09-30 02:57:21 +0200 | [diff] [blame] | 922 | float x, y; /* surface translation on display */ |
Pekka Paalanen | ba3cf95 | 2012-01-25 16:22:05 +0200 | [diff] [blame] | 923 | |
Pekka Paalanen | bc0b7e7 | 2012-01-24 09:53:37 +0200 | [diff] [blame] | 924 | /* struct weston_transform */ |
| 925 | struct wl_list transformation_list; |
Pekka Paalanen | 483243f | 2013-03-08 14:56:50 +0200 | [diff] [blame] | 926 | |
| 927 | /* managed by weston_surface_set_transform_parent() */ |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 928 | struct weston_view *parent; |
Pekka Paalanen | 483243f | 2013-03-08 14:56:50 +0200 | [diff] [blame] | 929 | struct wl_listener parent_destroy_listener; |
| 930 | struct wl_list child_list; /* geometry.parent_link */ |
| 931 | struct wl_list parent_link; |
Pekka Paalanen | 380adf5 | 2015-02-16 14:39:11 +0200 | [diff] [blame] | 932 | |
| 933 | /* managed by weston_view_set_mask() */ |
| 934 | bool scissor_enabled; |
| 935 | pixman_region32_t scissor; /* always a simple rect */ |
Pekka Paalanen | bc0b7e7 | 2012-01-24 09:53:37 +0200 | [diff] [blame] | 936 | } geometry; |
| 937 | |
| 938 | /* State derived from geometry state, read-only. |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 939 | * This is updated by weston_view_update_transform(). |
Pekka Paalanen | bc0b7e7 | 2012-01-24 09:53:37 +0200 | [diff] [blame] | 940 | */ |
| 941 | struct { |
Pekka Paalanen | c3ce738 | 2013-03-08 14:56:49 +0200 | [diff] [blame] | 942 | int dirty; |
| 943 | |
Pekka Paalanen | fbd00f1 | 2015-02-19 11:49:18 +0200 | [diff] [blame] | 944 | /* Approximations in global coordinates: |
| 945 | * - boundingbox is guaranteed to include the whole view in |
| 946 | * the smallest possible single rectangle. |
| 947 | * - opaque is guaranteed to be fully opaque, though not |
| 948 | * necessarily include all opaque areas. |
| 949 | */ |
Pekka Paalanen | 6720d8f | 2012-01-25 15:17:40 +0200 | [diff] [blame] | 950 | pixman_region32_t boundingbox; |
Pekka Paalanen | 730d87e | 2012-02-09 16:39:38 +0200 | [diff] [blame] | 951 | pixman_region32_t opaque; |
Pekka Paalanen | 6720d8f | 2012-01-25 15:17:40 +0200 | [diff] [blame] | 952 | |
Pekka Paalanen | bc0b7e7 | 2012-01-24 09:53:37 +0200 | [diff] [blame] | 953 | /* matrix and inverse are used only if enabled = 1. |
| 954 | * If enabled = 0, use x, y, width, height directly. |
| 955 | */ |
| 956 | int enabled; |
Pekka Paalanen | 061b747 | 2012-01-12 15:00:57 +0200 | [diff] [blame] | 957 | struct weston_matrix matrix; |
Pekka Paalanen | d1f0ab6 | 2012-01-20 10:47:57 +0200 | [diff] [blame] | 958 | struct weston_matrix inverse; |
Pekka Paalanen | cd40362 | 2012-01-25 13:37:39 +0200 | [diff] [blame] | 959 | |
| 960 | struct weston_transform position; /* matrix from x, y */ |
Pekka Paalanen | c61eca6 | 2012-01-06 14:10:06 +0200 | [diff] [blame] | 961 | } transform; |
| 962 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 963 | /* |
Pekka Paalanen | 130ae6e | 2016-03-30 14:33:33 +0300 | [diff] [blame] | 964 | * The primary output for this view. |
| 965 | * Used for picking the output for driving internal animations on the |
| 966 | * view, inheriting the primary output for related views in shells, etc. |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 967 | */ |
| 968 | struct weston_output *output; |
| 969 | |
Casey Dahlin | 9074db5 | 2012-04-19 22:50:09 -0400 | [diff] [blame] | 970 | /* |
| 971 | * A more complete representation of all outputs this surface is |
| 972 | * displayed on. |
| 973 | */ |
| 974 | uint32_t output_mask; |
Pekka Paalanen | bf0e031 | 2014-12-17 16:20:41 +0200 | [diff] [blame] | 975 | |
| 976 | /* Per-surface Presentation feedback flags, controlled by backend. */ |
| 977 | uint32_t psf_flags; |
Armin Krezović | f8486c3 | 2016-06-30 06:04:28 +0200 | [diff] [blame] | 978 | |
| 979 | bool is_mapped; |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 980 | }; |
| 981 | |
Jason Ekstrand | 7b98207 | 2014-05-20 14:33:03 -0500 | [diff] [blame] | 982 | struct weston_surface_state { |
| 983 | /* wl_surface.attach */ |
| 984 | int newly_attached; |
| 985 | struct weston_buffer *buffer; |
| 986 | struct wl_listener buffer_destroy_listener; |
| 987 | int32_t sx; |
| 988 | int32_t sy; |
| 989 | |
| 990 | /* wl_surface.damage */ |
Derek Foreman | 152254b | 2015-11-26 14:17:48 -0600 | [diff] [blame] | 991 | pixman_region32_t damage_surface; |
| 992 | /* wl_surface.damage_buffer */ |
| 993 | pixman_region32_t damage_buffer; |
Jason Ekstrand | 7b98207 | 2014-05-20 14:33:03 -0500 | [diff] [blame] | 994 | |
| 995 | /* wl_surface.set_opaque_region */ |
| 996 | pixman_region32_t opaque; |
| 997 | |
| 998 | /* wl_surface.set_input_region */ |
| 999 | pixman_region32_t input; |
| 1000 | |
| 1001 | /* wl_surface.frame */ |
| 1002 | struct wl_list frame_callback_list; |
| 1003 | |
Pekka Paalanen | 133e439 | 2014-09-23 22:08:46 -0400 | [diff] [blame] | 1004 | /* presentation.feedback */ |
| 1005 | struct wl_list feedback_list; |
| 1006 | |
Jason Ekstrand | 7b98207 | 2014-05-20 14:33:03 -0500 | [diff] [blame] | 1007 | /* wl_surface.set_buffer_transform */ |
| 1008 | /* wl_surface.set_scaling_factor */ |
Pekka Paalanen | e95ad5c | 2016-04-15 14:47:08 +0300 | [diff] [blame] | 1009 | /* wp_viewport.set_source */ |
| 1010 | /* wp_viewport.set_destination */ |
Jason Ekstrand | 7b98207 | 2014-05-20 14:33:03 -0500 | [diff] [blame] | 1011 | struct weston_buffer_viewport buffer_viewport; |
| 1012 | }; |
| 1013 | |
Jonas Ådahl | f7deb6a | 2016-07-22 17:50:26 +0800 | [diff] [blame^] | 1014 | struct weston_surface_activation_data { |
| 1015 | struct weston_surface *surface; |
| 1016 | struct weston_seat *seat; |
| 1017 | }; |
| 1018 | |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 1019 | struct weston_surface { |
| 1020 | struct wl_resource *resource; |
Pekka Paalanen | ca79076 | 2015-04-17 14:23:38 +0300 | [diff] [blame] | 1021 | struct wl_signal destroy_signal; /* callback argument: this surface */ |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 1022 | struct weston_compositor *compositor; |
Jonas Ådahl | 5d9ca27 | 2016-07-22 17:48:03 +0800 | [diff] [blame] | 1023 | struct wl_signal commit_signal; |
Pekka Paalanen | e508ce6 | 2015-02-19 13:59:55 +0200 | [diff] [blame] | 1024 | |
| 1025 | /** Damage in local coordinates from the client, for tex upload. */ |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 1026 | pixman_region32_t damage; |
Pekka Paalanen | e508ce6 | 2015-02-19 13:59:55 +0200 | [diff] [blame] | 1027 | |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 1028 | pixman_region32_t opaque; /* part of geometry, see below */ |
| 1029 | pixman_region32_t input; |
| 1030 | int32_t width, height; |
| 1031 | int32_t ref_count; |
| 1032 | |
| 1033 | /* Not for long-term storage. This exists for book-keeping while |
| 1034 | * iterating over surfaces and views |
| 1035 | */ |
Derek Foreman | 060cf11 | 2015-11-18 16:32:26 -0600 | [diff] [blame] | 1036 | bool touched; |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 1037 | |
| 1038 | void *renderer_state; |
| 1039 | |
| 1040 | struct wl_list views; |
| 1041 | |
| 1042 | /* |
| 1043 | * Which output to vsync this surface to. |
Pekka Paalanen | 130ae6e | 2016-03-30 14:33:33 +0300 | [diff] [blame] | 1044 | * Used to determine whether to send or queue frame events, and for |
| 1045 | * other client-visible syncing/throttling tied to the output |
| 1046 | * repaint cycle. |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 1047 | */ |
| 1048 | struct weston_output *output; |
| 1049 | |
| 1050 | /* |
| 1051 | * A more complete representation of all outputs this surface is |
| 1052 | * displayed on. |
| 1053 | */ |
| 1054 | uint32_t output_mask; |
Casey Dahlin | 9074db5 | 2012-04-19 22:50:09 -0400 | [diff] [blame] | 1055 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1056 | struct wl_list frame_callback_list; |
Pekka Paalanen | 133e439 | 2014-09-23 22:08:46 -0400 | [diff] [blame] | 1057 | struct wl_list feedback_list; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1058 | |
Pekka Paalanen | de685b8 | 2012-12-04 15:58:12 +0200 | [diff] [blame] | 1059 | struct weston_buffer_reference buffer_ref; |
Pekka Paalanen | 1fd9c0f | 2013-11-26 18:19:41 +0100 | [diff] [blame] | 1060 | struct weston_buffer_viewport buffer_viewport; |
Pekka Paalanen | 0b4c535 | 2014-03-14 14:38:17 +0200 | [diff] [blame] | 1061 | int32_t width_from_buffer; /* before applying viewport */ |
| 1062 | int32_t height_from_buffer; |
Derek Foreman | 0fd6d4e | 2014-10-10 09:36:45 -0500 | [diff] [blame] | 1063 | bool keep_buffer; /* for backends to prevent early release */ |
Alex Wu | 8811bf9 | 2012-02-28 18:07:54 +0800 | [diff] [blame] | 1064 | |
Pekka Paalanen | e95ad5c | 2016-04-15 14:47:08 +0300 | [diff] [blame] | 1065 | /* wp_viewport resource for this surface */ |
Pekka Paalanen | b0420ae | 2014-01-08 15:39:17 +0200 | [diff] [blame] | 1066 | struct wl_resource *viewport_resource; |
Jonny Lamb | 7413076 | 2013-11-26 18:19:46 +0100 | [diff] [blame] | 1067 | |
Pekka Paalanen | 5df44de | 2012-10-10 12:49:23 +0300 | [diff] [blame] | 1068 | /* All the pending state, that wl_surface.commit will apply. */ |
Jason Ekstrand | 7b98207 | 2014-05-20 14:33:03 -0500 | [diff] [blame] | 1069 | struct weston_surface_state pending; |
Pekka Paalanen | 5df44de | 2012-10-10 12:49:23 +0300 | [diff] [blame] | 1070 | |
Jason Ekstrand | 1e05904 | 2014-10-16 10:55:19 -0500 | [diff] [blame] | 1071 | /* Matrices representating of the full transformation between |
| 1072 | * buffer and surface coordinates. These matrices are updated |
| 1073 | * using the weston_surface_build_buffer_matrix function. */ |
| 1074 | struct weston_matrix buffer_to_surface_matrix; |
| 1075 | struct weston_matrix surface_to_buffer_matrix; |
| 1076 | |
Ander Conselvan de Oliveira | 093bfa3 | 2012-03-27 17:36:41 +0300 | [diff] [blame] | 1077 | /* |
Jasper St. Pierre | d67b52a | 2014-04-28 11:19:27 -0400 | [diff] [blame] | 1078 | * If non-NULL, this function will be called on |
| 1079 | * wl_surface::commit after a new buffer has been set up for |
| 1080 | * this surface. The integer params are the sx and sy |
| 1081 | * parameters supplied to wl_surface::attach. |
Ander Conselvan de Oliveira | 093bfa3 | 2012-03-27 17:36:41 +0300 | [diff] [blame] | 1082 | */ |
Jason Ekstrand | 918f2dd | 2013-12-02 21:01:53 -0600 | [diff] [blame] | 1083 | void (*configure)(struct weston_surface *es, int32_t sx, int32_t sy); |
Giulio Camuffo | 7fe01b1 | 2013-03-28 18:02:42 +0100 | [diff] [blame] | 1084 | void *configure_private; |
Pekka Paalanen | 8274d90 | 2014-08-06 19:36:51 +0300 | [diff] [blame] | 1085 | int (*get_label)(struct weston_surface *surface, char *buf, size_t len); |
Pekka Paalanen | e67858b | 2013-04-25 13:57:42 +0300 | [diff] [blame] | 1086 | |
| 1087 | /* Parent's list of its sub-surfaces, weston_subsurface:parent_link. |
| 1088 | * Contains also the parent itself as a dummy weston_subsurface, |
| 1089 | * if the list is not empty. |
| 1090 | */ |
| 1091 | struct wl_list subsurface_list; /* weston_subsurface::parent_link */ |
| 1092 | struct wl_list subsurface_list_pending; /* ...::parent_link_pending */ |
Pekka Paalanen | 50b6747 | 2014-10-01 15:02:41 +0300 | [diff] [blame] | 1093 | |
| 1094 | /* |
| 1095 | * For tracking protocol role assignments. Different roles may |
| 1096 | * have the same configure hook, e.g. in shell.c. Configure hook |
| 1097 | * may get reset, this will not. |
| 1098 | * XXX: map configure functions 1:1 to roles, and never reset it, |
| 1099 | * and replace role_name with configure. |
| 1100 | */ |
| 1101 | const char *role_name; |
Pekka Paalanen | b502654 | 2014-11-12 15:09:24 +0200 | [diff] [blame] | 1102 | |
| 1103 | struct weston_timeline_object timeline; |
Armin Krezović | f8486c3 | 2016-06-30 06:04:28 +0200 | [diff] [blame] | 1104 | |
| 1105 | bool is_mapped; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1106 | }; |
| 1107 | |
Jason Ekstrand | e9d40e3 | 2014-05-20 11:23:53 -0500 | [diff] [blame] | 1108 | struct weston_subsurface { |
| 1109 | struct wl_resource *resource; |
| 1110 | |
| 1111 | /* guaranteed to be valid and non-NULL */ |
| 1112 | struct weston_surface *surface; |
| 1113 | struct wl_listener surface_destroy_listener; |
| 1114 | |
| 1115 | /* can be NULL */ |
| 1116 | struct weston_surface *parent; |
| 1117 | struct wl_listener parent_destroy_listener; |
| 1118 | struct wl_list parent_link; |
| 1119 | struct wl_list parent_link_pending; |
| 1120 | |
| 1121 | struct { |
| 1122 | int32_t x; |
| 1123 | int32_t y; |
| 1124 | int set; |
| 1125 | } position; |
| 1126 | |
Jason Ekstrand | 7b98207 | 2014-05-20 14:33:03 -0500 | [diff] [blame] | 1127 | int has_cached_data; |
| 1128 | struct weston_surface_state cached; |
| 1129 | struct weston_buffer_reference cached_buffer_ref; |
Jason Ekstrand | e9d40e3 | 2014-05-20 11:23:53 -0500 | [diff] [blame] | 1130 | |
| 1131 | int synchronized; |
| 1132 | |
| 1133 | /* Used for constructing the view tree */ |
| 1134 | struct wl_list unused_views; |
| 1135 | }; |
| 1136 | |
Daniel Stone | d6da09e | 2012-06-22 13:21:29 +0100 | [diff] [blame] | 1137 | enum weston_key_state_update { |
| 1138 | STATE_UPDATE_AUTOMATIC, |
| 1139 | STATE_UPDATE_NONE, |
| 1140 | }; |
| 1141 | |
Jonas Ådahl | 4361b4e | 2014-10-18 18:20:16 +0200 | [diff] [blame] | 1142 | enum weston_activate_flag { |
| 1143 | WESTON_ACTIVATE_FLAG_NONE = 0, |
| 1144 | WESTON_ACTIVATE_FLAG_CONFIGURE = 1 << 0, |
Jonas Ådahl | 94e2e2d | 2014-10-18 18:42:19 +0200 | [diff] [blame] | 1145 | WESTON_ACTIVATE_FLAG_CLICKED = 1 << 1, |
Jonas Ådahl | 4361b4e | 2014-10-18 18:20:16 +0200 | [diff] [blame] | 1146 | }; |
| 1147 | |
Kristian Høgsberg | 9ddb826 | 2012-01-04 21:30:29 -0500 | [diff] [blame] | 1148 | void |
Kristian Høgsberg | af4f2aa | 2013-02-15 20:53:20 -0500 | [diff] [blame] | 1149 | weston_version(int *major, int *minor, int *micro); |
| 1150 | |
| 1151 | void |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 1152 | weston_view_update_transform(struct weston_view *view); |
Pekka Paalanen | 460099f | 2012-01-20 16:48:25 +0200 | [diff] [blame] | 1153 | |
| 1154 | void |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 1155 | weston_view_geometry_dirty(struct weston_view *view); |
Pekka Paalanen | c3ce738 | 2013-03-08 14:56:49 +0200 | [diff] [blame] | 1156 | |
| 1157 | void |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 1158 | weston_view_to_global_fixed(struct weston_view *view, |
| 1159 | wl_fixed_t sx, wl_fixed_t sy, |
| 1160 | wl_fixed_t *x, wl_fixed_t *y); |
Daniel Stone | bd3489b | 2012-05-08 17:17:53 +0100 | [diff] [blame] | 1161 | void |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 1162 | weston_view_to_global_float(struct weston_view *view, |
| 1163 | float sx, float sy, float *x, float *y); |
Pekka Paalanen | e0f3cb2 | 2012-01-24 09:59:29 +0200 | [diff] [blame] | 1164 | |
| 1165 | void |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 1166 | weston_view_from_global_float(struct weston_view *view, |
| 1167 | float x, float y, float *vx, float *vy); |
Kristian Høgsberg | ecf6ede | 2012-09-05 21:59:35 -0400 | [diff] [blame] | 1168 | void |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 1169 | weston_view_from_global(struct weston_view *view, |
| 1170 | int32_t x, int32_t y, int32_t *vx, int32_t *vy); |
Daniel Stone | bd3489b | 2012-05-08 17:17:53 +0100 | [diff] [blame] | 1171 | void |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 1172 | weston_view_from_global_fixed(struct weston_view *view, |
| 1173 | wl_fixed_t x, wl_fixed_t y, |
| 1174 | wl_fixed_t *vx, wl_fixed_t *vy); |
Pekka Paalanen | e0f3cb2 | 2012-01-24 09:59:29 +0200 | [diff] [blame] | 1175 | |
Derek Foreman | d1be312 | 2014-09-18 16:46:49 -0500 | [diff] [blame] | 1176 | void |
Ander Conselvan de Oliveira | 0396ba2 | 2012-11-28 17:10:26 +0200 | [diff] [blame] | 1177 | weston_surface_to_buffer_float(struct weston_surface *surface, |
| 1178 | float x, float y, float *bx, float *by); |
| 1179 | pixman_box32_t |
| 1180 | weston_surface_to_buffer_rect(struct weston_surface *surface, |
| 1181 | pixman_box32_t rect); |
| 1182 | |
Pekka Paalanen | e0f3cb2 | 2012-01-24 09:59:29 +0200 | [diff] [blame] | 1183 | void |
Pekka Paalanen | e54e31c | 2015-03-04 14:23:28 +0200 | [diff] [blame] | 1184 | weston_surface_to_buffer_region(struct weston_surface *surface, |
| 1185 | pixman_region32_t *surface_region, |
| 1186 | pixman_region32_t *buffer_region); |
| 1187 | |
| 1188 | void |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1189 | weston_spring_init(struct weston_spring *spring, |
| 1190 | double k, double current, double target); |
| 1191 | void |
| 1192 | weston_spring_update(struct weston_spring *spring, uint32_t msec); |
| 1193 | int |
| 1194 | weston_spring_done(struct weston_spring *spring); |
| 1195 | |
| 1196 | void |
Jonas Ådahl | 94e2e2d | 2014-10-18 18:42:19 +0200 | [diff] [blame] | 1197 | weston_view_activate(struct weston_view *view, |
| 1198 | struct weston_seat *seat, |
| 1199 | uint32_t flags); |
| 1200 | |
| 1201 | void |
Kristian Høgsberg | cb3eaae | 2012-08-10 09:50:11 -0400 | [diff] [blame] | 1202 | notify_motion(struct weston_seat *seat, uint32_t time, |
Jonas Ådahl | d251010 | 2014-10-05 21:39:14 +0200 | [diff] [blame] | 1203 | struct weston_pointer_motion_event *event); |
Rob Bradford | c088e2c | 2013-03-27 15:59:43 +0000 | [diff] [blame] | 1204 | void |
| 1205 | notify_motion_absolute(struct weston_seat *seat, uint32_t time, |
Giulio Camuffo | 90a6fc6 | 2016-03-22 17:44:54 +0200 | [diff] [blame] | 1206 | double x, double y); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1207 | void |
Kristian Høgsberg | cb3eaae | 2012-08-10 09:50:11 -0400 | [diff] [blame] | 1208 | notify_button(struct weston_seat *seat, uint32_t time, int32_t button, |
Daniel Stone | 4dbadb1 | 2012-05-30 16:31:51 +0100 | [diff] [blame] | 1209 | enum wl_pointer_button_state state); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1210 | void |
Peter Hutterer | 89b6a49 | 2016-01-18 15:58:17 +1000 | [diff] [blame] | 1211 | notify_axis(struct weston_seat *seat, uint32_t time, |
| 1212 | struct weston_pointer_axis_event *event); |
Scott Moreau | 210d079 | 2012-03-22 10:47:01 -0600 | [diff] [blame] | 1213 | void |
Peter Hutterer | 87743e9 | 2016-01-18 16:38:22 +1000 | [diff] [blame] | 1214 | notify_axis_source(struct weston_seat *seat, uint32_t source); |
| 1215 | |
| 1216 | void |
| 1217 | notify_pointer_frame(struct weston_seat *seat); |
| 1218 | |
| 1219 | void |
Kristian Høgsberg | cb3eaae | 2012-08-10 09:50:11 -0400 | [diff] [blame] | 1220 | notify_key(struct weston_seat *seat, uint32_t time, uint32_t key, |
Daniel Stone | 1b4e11f | 2012-06-22 13:21:37 +0100 | [diff] [blame] | 1221 | enum wl_keyboard_key_state state, |
| 1222 | enum weston_key_state_update update_state); |
Daniel Stone | 05d5868 | 2012-06-22 13:21:38 +0100 | [diff] [blame] | 1223 | void |
Kristian Høgsberg | cb3eaae | 2012-08-10 09:50:11 -0400 | [diff] [blame] | 1224 | notify_modifiers(struct weston_seat *seat, uint32_t serial); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1225 | |
| 1226 | void |
Kristian Høgsberg | cb3eaae | 2012-08-10 09:50:11 -0400 | [diff] [blame] | 1227 | notify_pointer_focus(struct weston_seat *seat, struct weston_output *output, |
Giulio Camuffo | 90a6fc6 | 2016-03-22 17:44:54 +0200 | [diff] [blame] | 1228 | double x, double y); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1229 | |
| 1230 | void |
Kristian Høgsberg | cb3eaae | 2012-08-10 09:50:11 -0400 | [diff] [blame] | 1231 | notify_keyboard_focus_in(struct weston_seat *seat, struct wl_array *keys, |
Daniel Stone | d6da09e | 2012-06-22 13:21:29 +0100 | [diff] [blame] | 1232 | enum weston_key_state_update update_state); |
| 1233 | void |
Kristian Høgsberg | cb3eaae | 2012-08-10 09:50:11 -0400 | [diff] [blame] | 1234 | notify_keyboard_focus_out(struct weston_seat *seat); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1235 | |
| 1236 | void |
Kristian Høgsberg | cb3eaae | 2012-08-10 09:50:11 -0400 | [diff] [blame] | 1237 | notify_touch(struct weston_seat *seat, uint32_t time, int touch_id, |
Giulio Camuffo | 90a6fc6 | 2016-03-22 17:44:54 +0200 | [diff] [blame] | 1238 | double x, double y, int touch_type); |
Jonas Ådahl | 1679f23 | 2014-04-12 09:39:51 +0200 | [diff] [blame] | 1239 | void |
| 1240 | notify_touch_frame(struct weston_seat *seat); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1241 | |
| 1242 | void |
Derek Foreman | 3cc004a | 2015-11-06 15:56:09 -0600 | [diff] [blame] | 1243 | notify_touch_cancel(struct weston_seat *seat); |
| 1244 | |
| 1245 | void |
Giulio Camuffo | 412e6a5 | 2014-07-09 22:12:56 +0300 | [diff] [blame] | 1246 | weston_layer_entry_insert(struct weston_layer_entry *list, |
| 1247 | struct weston_layer_entry *entry); |
| 1248 | void |
| 1249 | weston_layer_entry_remove(struct weston_layer_entry *entry); |
| 1250 | void |
Kristian Høgsberg | 3be2ce9 | 2012-02-29 12:42:35 -0500 | [diff] [blame] | 1251 | weston_layer_init(struct weston_layer *layer, struct wl_list *below); |
| 1252 | |
| 1253 | void |
Giulio Camuffo | 95ec0f9 | 2014-07-09 22:12:57 +0300 | [diff] [blame] | 1254 | weston_layer_set_mask(struct weston_layer *layer, int x, int y, int width, int height); |
| 1255 | |
| 1256 | void |
| 1257 | weston_layer_set_mask_infinite(struct weston_layer *layer); |
| 1258 | |
| 1259 | void |
Xiong Zhang | 9711653 | 2013-10-23 13:58:31 +0800 | [diff] [blame] | 1260 | weston_plane_init(struct weston_plane *plane, |
| 1261 | struct weston_compositor *ec, |
| 1262 | int32_t x, int32_t y); |
Kristian Høgsberg | 65a11e1 | 2012-08-03 11:30:18 -0400 | [diff] [blame] | 1263 | void |
| 1264 | weston_plane_release(struct weston_plane *plane); |
| 1265 | |
| 1266 | void |
Ander Conselvan de Oliveira | 8ad1982 | 2013-03-05 17:30:27 +0200 | [diff] [blame] | 1267 | weston_compositor_stack_plane(struct weston_compositor *ec, |
| 1268 | struct weston_plane *plane, |
| 1269 | struct weston_plane *above); |
| 1270 | |
Pekka Paalanen | 363aa7b | 2014-12-17 16:20:40 +0200 | [diff] [blame] | 1271 | /* An invalid flag in presented_flags to catch logic errors. */ |
Pekka Paalanen | b00c79b | 2016-02-18 16:53:27 +0200 | [diff] [blame] | 1272 | #define WP_PRESENTATION_FEEDBACK_INVALID (1U << 31) |
Pekka Paalanen | 363aa7b | 2014-12-17 16:20:40 +0200 | [diff] [blame] | 1273 | |
Ander Conselvan de Oliveira | 8ad1982 | 2013-03-05 17:30:27 +0200 | [diff] [blame] | 1274 | void |
Pekka Paalanen | b5eedad | 2014-09-23 22:08:45 -0400 | [diff] [blame] | 1275 | weston_output_finish_frame(struct weston_output *output, |
Pekka Paalanen | 363aa7b | 2014-12-17 16:20:40 +0200 | [diff] [blame] | 1276 | const struct timespec *stamp, |
| 1277 | uint32_t presented_flags); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1278 | void |
Kristian Høgsberg | 49952d1 | 2012-06-20 00:35:59 -0400 | [diff] [blame] | 1279 | weston_output_schedule_repaint(struct weston_output *output); |
| 1280 | void |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1281 | weston_output_damage(struct weston_output *output); |
| 1282 | void |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1283 | weston_compositor_schedule_repaint(struct weston_compositor *compositor); |
| 1284 | void |
| 1285 | weston_compositor_fade(struct weston_compositor *compositor, float tint); |
| 1286 | void |
| 1287 | weston_compositor_damage_all(struct weston_compositor *compositor); |
| 1288 | void |
| 1289 | weston_compositor_unlock(struct weston_compositor *compositor); |
| 1290 | void |
| 1291 | weston_compositor_wake(struct weston_compositor *compositor); |
| 1292 | void |
Philipp Brüschweiler | 57edf7f | 2013-03-29 13:01:56 +0100 | [diff] [blame] | 1293 | weston_compositor_offscreen(struct weston_compositor *compositor); |
| 1294 | void |
Ander Conselvan de Oliveira | 87524b6 | 2013-02-21 18:35:22 +0200 | [diff] [blame] | 1295 | weston_compositor_sleep(struct weston_compositor *compositor); |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 1296 | struct weston_view * |
| 1297 | weston_compositor_pick_view(struct weston_compositor *compositor, |
| 1298 | wl_fixed_t x, wl_fixed_t y, |
| 1299 | wl_fixed_t *sx, wl_fixed_t *sy); |
Ander Conselvan de Oliveira | 30eebc7 | 2012-02-15 17:02:57 +0200 | [diff] [blame] | 1300 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1301 | |
| 1302 | struct weston_binding; |
Derek Foreman | 8ae2db5 | 2015-07-15 13:00:36 -0500 | [diff] [blame] | 1303 | typedef void (*weston_key_binding_handler_t)(struct weston_keyboard *keyboard, |
Daniel Stone | 325fc2d | 2012-05-30 16:31:58 +0100 | [diff] [blame] | 1304 | uint32_t time, uint32_t key, |
| 1305 | void *data); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1306 | struct weston_binding * |
Daniel Stone | 325fc2d | 2012-05-30 16:31:58 +0100 | [diff] [blame] | 1307 | weston_compositor_add_key_binding(struct weston_compositor *compositor, |
| 1308 | uint32_t key, |
| 1309 | enum weston_keyboard_modifier modifier, |
| 1310 | weston_key_binding_handler_t binding, |
| 1311 | void *data); |
| 1312 | |
Derek Foreman | 8ae2db5 | 2015-07-15 13:00:36 -0500 | [diff] [blame] | 1313 | typedef void (*weston_modifier_binding_handler_t)(struct weston_keyboard *keyboard, |
Daniel Stone | 96d47c0 | 2013-11-19 11:37:12 +0100 | [diff] [blame] | 1314 | enum weston_keyboard_modifier modifier, |
| 1315 | void *data); |
| 1316 | struct weston_binding * |
| 1317 | weston_compositor_add_modifier_binding(struct weston_compositor *compositor, |
| 1318 | enum weston_keyboard_modifier modifier, |
| 1319 | weston_modifier_binding_handler_t binding, |
| 1320 | void *data); |
| 1321 | |
Derek Foreman | 8ae2db5 | 2015-07-15 13:00:36 -0500 | [diff] [blame] | 1322 | typedef void (*weston_button_binding_handler_t)(struct weston_pointer *pointer, |
Daniel Stone | 325fc2d | 2012-05-30 16:31:58 +0100 | [diff] [blame] | 1323 | uint32_t time, uint32_t button, |
| 1324 | void *data); |
| 1325 | struct weston_binding * |
| 1326 | weston_compositor_add_button_binding(struct weston_compositor *compositor, |
| 1327 | uint32_t button, |
| 1328 | enum weston_keyboard_modifier modifier, |
| 1329 | weston_button_binding_handler_t binding, |
| 1330 | void *data); |
| 1331 | |
Derek Foreman | 8ae2db5 | 2015-07-15 13:00:36 -0500 | [diff] [blame] | 1332 | typedef void (*weston_touch_binding_handler_t)(struct weston_touch *touch, |
Neil Roberts | a28c693 | 2013-10-03 16:43:04 +0100 | [diff] [blame] | 1333 | uint32_t time, |
| 1334 | void *data); |
| 1335 | struct weston_binding * |
| 1336 | weston_compositor_add_touch_binding(struct weston_compositor *compositor, |
| 1337 | enum weston_keyboard_modifier modifier, |
| 1338 | weston_touch_binding_handler_t binding, |
| 1339 | void *data); |
| 1340 | |
Derek Foreman | 8ae2db5 | 2015-07-15 13:00:36 -0500 | [diff] [blame] | 1341 | typedef void (*weston_axis_binding_handler_t)(struct weston_pointer *pointer, |
Peter Hutterer | 89b6a49 | 2016-01-18 15:58:17 +1000 | [diff] [blame] | 1342 | uint32_t time, |
| 1343 | struct weston_pointer_axis_event *event, |
| 1344 | void *data); |
Daniel Stone | 325fc2d | 2012-05-30 16:31:58 +0100 | [diff] [blame] | 1345 | struct weston_binding * |
| 1346 | weston_compositor_add_axis_binding(struct weston_compositor *compositor, |
| 1347 | uint32_t axis, |
| 1348 | enum weston_keyboard_modifier modifier, |
| 1349 | weston_axis_binding_handler_t binding, |
| 1350 | void *data); |
Ander Conselvan de Oliveira | c509d2b | 2012-11-08 17:20:45 +0200 | [diff] [blame] | 1351 | struct weston_binding * |
| 1352 | weston_compositor_add_debug_binding(struct weston_compositor *compositor, |
| 1353 | uint32_t key, |
| 1354 | weston_key_binding_handler_t binding, |
| 1355 | void *data); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1356 | void |
| 1357 | weston_binding_destroy(struct weston_binding *binding); |
| 1358 | |
| 1359 | void |
Pekka Paalanen | 2829f7c | 2015-02-19 17:02:13 +0200 | [diff] [blame] | 1360 | weston_install_debug_key_binding(struct weston_compositor *compositor, |
| 1361 | uint32_t mod); |
| 1362 | |
| 1363 | void |
Kristian Høgsberg | 3466bc8 | 2012-01-03 11:29:15 -0500 | [diff] [blame] | 1364 | weston_binding_list_destroy_all(struct wl_list *list); |
| 1365 | |
Pekka Paalanen | 86b5396 | 2014-11-19 13:43:32 +0200 | [diff] [blame] | 1366 | void |
Daniel Stone | 325fc2d | 2012-05-30 16:31:58 +0100 | [diff] [blame] | 1367 | weston_compositor_run_key_binding(struct weston_compositor *compositor, |
Derek Foreman | 99a6a2d | 2015-07-15 13:00:43 -0500 | [diff] [blame] | 1368 | struct weston_keyboard *keyboard, |
| 1369 | uint32_t time, |
Daniel Stone | 325fc2d | 2012-05-30 16:31:58 +0100 | [diff] [blame] | 1370 | uint32_t key, |
| 1371 | enum wl_keyboard_key_state state); |
Daniel Stone | 96d47c0 | 2013-11-19 11:37:12 +0100 | [diff] [blame] | 1372 | |
| 1373 | void |
| 1374 | weston_compositor_run_modifier_binding(struct weston_compositor *compositor, |
Derek Foreman | 99a6a2d | 2015-07-15 13:00:43 -0500 | [diff] [blame] | 1375 | struct weston_keyboard *keyboard, |
Daniel Stone | 96d47c0 | 2013-11-19 11:37:12 +0100 | [diff] [blame] | 1376 | enum weston_keyboard_modifier modifier, |
| 1377 | enum wl_keyboard_key_state state); |
Daniel Stone | 325fc2d | 2012-05-30 16:31:58 +0100 | [diff] [blame] | 1378 | void |
| 1379 | weston_compositor_run_button_binding(struct weston_compositor *compositor, |
Derek Foreman | 99a6a2d | 2015-07-15 13:00:43 -0500 | [diff] [blame] | 1380 | struct weston_pointer *pointer, uint32_t time, |
Daniel Stone | 325fc2d | 2012-05-30 16:31:58 +0100 | [diff] [blame] | 1381 | uint32_t button, |
| 1382 | enum wl_pointer_button_state value); |
Neil Roberts | a28c693 | 2013-10-03 16:43:04 +0100 | [diff] [blame] | 1383 | void |
| 1384 | weston_compositor_run_touch_binding(struct weston_compositor *compositor, |
Derek Foreman | 99a6a2d | 2015-07-15 13:00:43 -0500 | [diff] [blame] | 1385 | struct weston_touch *touch, uint32_t time, |
Neil Roberts | a28c693 | 2013-10-03 16:43:04 +0100 | [diff] [blame] | 1386 | int touch_type); |
Rune K. Svendsen | 14b2fe7 | 2013-03-07 21:50:00 +0100 | [diff] [blame] | 1387 | int |
Daniel Stone | 325fc2d | 2012-05-30 16:31:58 +0100 | [diff] [blame] | 1388 | weston_compositor_run_axis_binding(struct weston_compositor *compositor, |
Derek Foreman | 99a6a2d | 2015-07-15 13:00:43 -0500 | [diff] [blame] | 1389 | struct weston_pointer *pointer, uint32_t time, |
Peter Hutterer | 89b6a49 | 2016-01-18 15:58:17 +1000 | [diff] [blame] | 1390 | struct weston_pointer_axis_event *event); |
Ander Conselvan de Oliveira | c509d2b | 2012-11-08 17:20:45 +0200 | [diff] [blame] | 1391 | int |
| 1392 | weston_compositor_run_debug_binding(struct weston_compositor *compositor, |
Derek Foreman | 99a6a2d | 2015-07-15 13:00:43 -0500 | [diff] [blame] | 1393 | struct weston_keyboard *keyboard, uint32_t time, |
Ander Conselvan de Oliveira | c509d2b | 2012-11-08 17:20:45 +0200 | [diff] [blame] | 1394 | uint32_t key, |
| 1395 | enum wl_keyboard_key_state state); |
Daniel Stone | 325fc2d | 2012-05-30 16:31:58 +0100 | [diff] [blame] | 1396 | |
Giulio Camuffo | cdb4d29 | 2013-11-14 23:42:53 +0100 | [diff] [blame] | 1397 | void |
| 1398 | weston_compositor_set_default_pointer_grab(struct weston_compositor *compositor, |
| 1399 | const struct weston_pointer_grab_interface *interface); |
| 1400 | |
Benjamin Franzke | bfeda13 | 2012-01-30 14:04:04 +0100 | [diff] [blame] | 1401 | int |
| 1402 | weston_environment_get_fd(const char *env); |
| 1403 | |
Kristian Høgsberg | a82c486 | 2012-01-26 01:03:58 -0500 | [diff] [blame] | 1404 | struct wl_list * |
| 1405 | weston_compositor_top(struct weston_compositor *compositor); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1406 | |
| 1407 | struct weston_surface * |
Kristian Høgsberg | 18c9300 | 2012-01-27 11:58:31 -0500 | [diff] [blame] | 1408 | weston_surface_create(struct weston_compositor *compositor); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1409 | |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 1410 | struct weston_view * |
| 1411 | weston_view_create(struct weston_surface *surface); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1412 | |
| 1413 | void |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 1414 | weston_view_destroy(struct weston_view *view); |
Kristian Høgsberg | 3be2ce9 | 2012-02-29 12:42:35 -0500 | [diff] [blame] | 1415 | |
| 1416 | void |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 1417 | weston_view_set_position(struct weston_view *view, |
| 1418 | float x, float y); |
| 1419 | |
| 1420 | void |
| 1421 | weston_view_set_transform_parent(struct weston_view *view, |
| 1422 | struct weston_view *parent); |
| 1423 | |
Pekka Paalanen | 380adf5 | 2015-02-16 14:39:11 +0200 | [diff] [blame] | 1424 | void |
| 1425 | weston_view_set_mask(struct weston_view *view, |
| 1426 | int x, int y, int width, int height); |
| 1427 | |
| 1428 | void |
| 1429 | weston_view_set_mask_infinite(struct weston_view *view); |
| 1430 | |
Derek Foreman | 280e7dd | 2014-10-03 13:13:42 -0500 | [diff] [blame] | 1431 | bool |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 1432 | weston_view_is_mapped(struct weston_view *view); |
| 1433 | |
| 1434 | void |
| 1435 | weston_view_schedule_repaint(struct weston_view *view); |
Pekka Paalanen | 483243f | 2013-03-08 14:56:50 +0200 | [diff] [blame] | 1436 | |
Derek Foreman | 280e7dd | 2014-10-03 13:13:42 -0500 | [diff] [blame] | 1437 | bool |
Ander Conselvan de Oliveira | b8ab14f | 2012-03-27 17:36:36 +0300 | [diff] [blame] | 1438 | weston_surface_is_mapped(struct weston_surface *surface); |
| 1439 | |
Derek Foreman | d1be312 | 2014-09-18 16:46:49 -0500 | [diff] [blame] | 1440 | void |
Jason Ekstrand | 5c11a33 | 2013-12-04 20:32:03 -0600 | [diff] [blame] | 1441 | weston_surface_set_size(struct weston_surface *surface, |
| 1442 | int32_t width, int32_t height); |
| 1443 | |
Pekka Paalanen | 8fb8d3b | 2012-02-13 13:03:59 +0200 | [diff] [blame] | 1444 | void |
Kristian Høgsberg | 9823870 | 2012-08-03 16:29:12 -0400 | [diff] [blame] | 1445 | weston_surface_schedule_repaint(struct weston_surface *surface); |
| 1446 | |
| 1447 | void |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1448 | weston_surface_damage(struct weston_surface *surface); |
| 1449 | |
| 1450 | void |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 1451 | weston_view_damage_below(struct weston_view *view); |
Kristian Høgsberg | d8bf90c | 2012-02-23 23:03:14 -0500 | [diff] [blame] | 1452 | |
| 1453 | void |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 1454 | weston_view_move_to_plane(struct weston_view *view, |
| 1455 | struct weston_plane *plane); |
| 1456 | void |
| 1457 | weston_view_unmap(struct weston_view *view); |
| 1458 | |
Kristian Høgsberg | 65a11e1 | 2012-08-03 11:30:18 -0400 | [diff] [blame] | 1459 | void |
Kristian Høgsberg | af7b1ff | 2012-06-26 21:19:23 -0400 | [diff] [blame] | 1460 | weston_surface_unmap(struct weston_surface *surface); |
| 1461 | |
Pekka Paalanen | 01388e2 | 2013-04-25 13:57:44 +0300 | [diff] [blame] | 1462 | struct weston_surface * |
| 1463 | weston_surface_get_main_surface(struct weston_surface *surface); |
| 1464 | |
Pekka Paalanen | 50b6747 | 2014-10-01 15:02:41 +0300 | [diff] [blame] | 1465 | int |
| 1466 | weston_surface_set_role(struct weston_surface *surface, |
| 1467 | const char *role_name, |
| 1468 | struct wl_resource *error_resource, |
| 1469 | uint32_t error_code); |
| 1470 | |
Pekka Paalanen | 8274d90 | 2014-08-06 19:36:51 +0300 | [diff] [blame] | 1471 | void |
| 1472 | weston_surface_set_label_func(struct weston_surface *surface, |
| 1473 | int (*desc)(struct weston_surface *, |
| 1474 | char *, size_t)); |
| 1475 | |
Pekka Paalanen | c647ed7 | 2015-02-09 13:16:57 +0200 | [diff] [blame] | 1476 | void |
| 1477 | weston_surface_get_content_size(struct weston_surface *surface, |
| 1478 | int *width, int *height); |
| 1479 | |
| 1480 | int |
| 1481 | weston_surface_copy_content(struct weston_surface *surface, |
| 1482 | void *target, size_t size, |
| 1483 | int src_x, int src_y, |
| 1484 | int width, int height); |
| 1485 | |
Jason Ekstrand | 6bd6294 | 2013-06-20 20:38:23 -0500 | [diff] [blame] | 1486 | struct weston_buffer * |
| 1487 | weston_buffer_from_resource(struct wl_resource *resource); |
| 1488 | |
Kristian Høgsberg | af7b1ff | 2012-06-26 21:19:23 -0400 | [diff] [blame] | 1489 | void |
Pekka Paalanen | de685b8 | 2012-12-04 15:58:12 +0200 | [diff] [blame] | 1490 | weston_buffer_reference(struct weston_buffer_reference *ref, |
Jason Ekstrand | 6bd6294 | 2013-06-20 20:38:23 -0500 | [diff] [blame] | 1491 | struct weston_buffer *buffer); |
Pekka Paalanen | de685b8 | 2012-12-04 15:58:12 +0200 | [diff] [blame] | 1492 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1493 | uint32_t |
| 1494 | weston_compositor_get_time(void); |
| 1495 | |
Giulio Camuffo | 459137b | 2014-10-11 23:56:24 +0300 | [diff] [blame] | 1496 | void |
| 1497 | weston_compositor_destroy(struct weston_compositor *ec); |
| 1498 | struct weston_compositor * |
| 1499 | weston_compositor_create(struct wl_display *display, void *user_data); |
Pekka Paalanen | 50dbf38 | 2016-06-03 15:23:46 +0300 | [diff] [blame] | 1500 | |
| 1501 | enum weston_compositor_backend { |
| 1502 | WESTON_BACKEND_DRM, |
| 1503 | WESTON_BACKEND_FBDEV, |
| 1504 | WESTON_BACKEND_HEADLESS, |
| 1505 | WESTON_BACKEND_RDP, |
| 1506 | WESTON_BACKEND_WAYLAND, |
| 1507 | WESTON_BACKEND_X11, |
| 1508 | }; |
| 1509 | |
Pekka Paalanen | dd18673 | 2016-06-03 14:49:54 +0300 | [diff] [blame] | 1510 | int |
| 1511 | weston_compositor_load_backend(struct weston_compositor *compositor, |
Pekka Paalanen | 50dbf38 | 2016-06-03 15:23:46 +0300 | [diff] [blame] | 1512 | enum weston_compositor_backend backend, |
Pekka Paalanen | dd18673 | 2016-06-03 14:49:54 +0300 | [diff] [blame] | 1513 | struct weston_backend_config *config_base); |
Giulio Camuffo | 459137b | 2014-10-11 23:56:24 +0300 | [diff] [blame] | 1514 | void |
| 1515 | weston_compositor_exit(struct weston_compositor *ec); |
| 1516 | void * |
| 1517 | weston_compositor_get_user_data(struct weston_compositor *compositor); |
Pekka Paalanen | b5eedad | 2014-09-23 22:08:45 -0400 | [diff] [blame] | 1518 | int |
| 1519 | weston_compositor_set_presentation_clock(struct weston_compositor *compositor, |
| 1520 | clockid_t clk_id); |
| 1521 | int |
| 1522 | weston_compositor_set_presentation_clock_software( |
| 1523 | struct weston_compositor *compositor); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1524 | void |
Pekka Paalanen | 662f384 | 2015-03-18 12:17:26 +0200 | [diff] [blame] | 1525 | weston_compositor_read_presentation_clock( |
| 1526 | const struct weston_compositor *compositor, |
| 1527 | struct timespec *ts); |
| 1528 | |
Pekka Paalanen | 230f3b1 | 2014-09-29 14:18:40 -0400 | [diff] [blame] | 1529 | bool |
| 1530 | weston_compositor_import_dmabuf(struct weston_compositor *compositor, |
| 1531 | struct linux_dmabuf_buffer *buffer); |
| 1532 | |
Pekka Paalanen | 662f384 | 2015-03-18 12:17:26 +0200 | [diff] [blame] | 1533 | void |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1534 | weston_compositor_shutdown(struct weston_compositor *ec); |
| 1535 | void |
Frederic Plourde | c336f06 | 2014-10-29 14:44:33 -0400 | [diff] [blame] | 1536 | weston_compositor_exit_with_code(struct weston_compositor *compositor, |
| 1537 | int exit_code); |
| 1538 | void |
Scott Moreau | 429490d | 2012-06-17 18:10:59 -0600 | [diff] [blame] | 1539 | weston_output_init_zoom(struct weston_output *output); |
| 1540 | void |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 1541 | weston_output_update_zoom(struct weston_output *output); |
Scott Moreau | ccbf29d | 2012-02-22 14:21:41 -0700 | [diff] [blame] | 1542 | void |
Derek Foreman | 22276a5 | 2015-07-23 14:55:15 -0500 | [diff] [blame] | 1543 | weston_output_activate_zoom(struct weston_output *output, |
| 1544 | struct weston_seat *seat); |
Giulio Camuffo | 412b024 | 2013-11-14 23:42:51 +0100 | [diff] [blame] | 1545 | void |
Scott Moreau | ccbf29d | 2012-02-22 14:21:41 -0700 | [diff] [blame] | 1546 | weston_output_update_matrix(struct weston_output *output); |
| 1547 | void |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1548 | weston_output_move(struct weston_output *output, int x, int y); |
| 1549 | void |
| 1550 | weston_output_init(struct weston_output *output, struct weston_compositor *c, |
Alexander Larsson | edddbd1 | 2013-05-24 13:09:43 +0200 | [diff] [blame] | 1551 | int x, int y, int width, int height, uint32_t transform, int32_t scale); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1552 | void |
Giulio Camuffo | b114715 | 2015-05-06 21:41:57 +0300 | [diff] [blame] | 1553 | weston_compositor_add_output(struct weston_compositor *compositor, |
| 1554 | struct weston_output *output); |
| 1555 | void |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1556 | weston_output_destroy(struct weston_output *output); |
Kristian Høgsberg | 98c774f | 2013-07-22 14:33:42 -0700 | [diff] [blame] | 1557 | void |
Jason Ekstrand | b6a3cc7 | 2013-10-27 22:25:00 -0500 | [diff] [blame] | 1558 | weston_output_transform_coordinate(struct weston_output *output, |
Giulio Camuffo | 90a6fc6 | 2016-03-22 17:44:54 +0200 | [diff] [blame] | 1559 | double device_x, double device_y, |
| 1560 | double *x, double *y); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1561 | |
| 1562 | void |
Rob Bradford | 9af5f9e | 2013-05-31 18:09:50 +0100 | [diff] [blame] | 1563 | weston_seat_init(struct weston_seat *seat, struct weston_compositor *ec, |
| 1564 | const char *seat_name); |
Daniel Stone | 74419a2 | 2012-05-30 16:32:02 +0100 | [diff] [blame] | 1565 | void |
| 1566 | weston_seat_init_pointer(struct weston_seat *seat); |
Jonas Ådahl | d6e1c34 | 2013-10-17 23:04:05 +0200 | [diff] [blame] | 1567 | void |
| 1568 | weston_seat_release_pointer(struct weston_seat *seat); |
Kristian Høgsberg | 2f07ef6 | 2013-02-16 14:29:24 -0500 | [diff] [blame] | 1569 | int |
Daniel Stone | bb1df6a | 2012-05-30 16:32:06 +0100 | [diff] [blame] | 1570 | weston_seat_init_keyboard(struct weston_seat *seat, struct xkb_keymap *keymap); |
Daniel Stone | 74419a2 | 2012-05-30 16:32:02 +0100 | [diff] [blame] | 1571 | void |
Jonas Ådahl | d6e1c34 | 2013-10-17 23:04:05 +0200 | [diff] [blame] | 1572 | weston_seat_release_keyboard(struct weston_seat *seat); |
| 1573 | void |
Daniel Stone | 74419a2 | 2012-05-30 16:32:02 +0100 | [diff] [blame] | 1574 | weston_seat_init_touch(struct weston_seat *seat); |
Kristian Høgsberg | b5e2610 | 2013-04-18 15:40:10 -0400 | [diff] [blame] | 1575 | void |
Jonas Ådahl | d6e1c34 | 2013-10-17 23:04:05 +0200 | [diff] [blame] | 1576 | weston_seat_release_touch(struct weston_seat *seat); |
| 1577 | void |
Kristian Høgsberg | a71e8b2 | 2013-05-06 21:51:21 -0400 | [diff] [blame] | 1578 | weston_seat_repick(struct weston_seat *seat); |
Rui Matos | 65196bc | 2013-10-10 19:44:19 +0200 | [diff] [blame] | 1579 | void |
| 1580 | weston_seat_update_keymap(struct weston_seat *seat, struct xkb_keymap *keymap); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1581 | |
| 1582 | void |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 1583 | weston_seat_release(struct weston_seat *seat); |
Kristian Høgsberg | b5e2610 | 2013-04-18 15:40:10 -0400 | [diff] [blame] | 1584 | int |
Giulio Camuffo | 0358af4 | 2016-06-02 21:48:08 +0300 | [diff] [blame] | 1585 | weston_compositor_set_xkb_rule_names(struct weston_compositor *ec, |
| 1586 | struct xkb_rule_names *names); |
Kristian Høgsberg | b5e2610 | 2013-04-18 15:40:10 -0400 | [diff] [blame] | 1587 | void |
| 1588 | weston_compositor_xkb_destroy(struct weston_compositor *ec); |
Kristian Høgsberg | 3466bc8 | 2012-01-03 11:29:15 -0500 | [diff] [blame] | 1589 | |
Kristian Høgsberg | 64eca89 | 2012-08-01 00:00:57 -0400 | [diff] [blame] | 1590 | /* String literal of spaces, the same width as the timestamp. */ |
| 1591 | #define STAMP_SPACE " " |
| 1592 | |
Giulio Camuffo | be2b11a | 2016-06-02 21:48:13 +0300 | [diff] [blame] | 1593 | typedef int (*log_func_t)(const char *fmt, va_list ap); |
Kristian Høgsberg | 64eca89 | 2012-08-01 00:00:57 -0400 | [diff] [blame] | 1594 | void |
Giulio Camuffo | be2b11a | 2016-06-02 21:48:13 +0300 | [diff] [blame] | 1595 | weston_log_set_handler(log_func_t log, log_func_t cont); |
Kristian Høgsberg | 64eca89 | 2012-08-01 00:00:57 -0400 | [diff] [blame] | 1596 | int |
Kristian Høgsberg | 082d58c | 2013-06-18 01:00:27 -0400 | [diff] [blame] | 1597 | weston_vlog(const char *fmt, va_list ap); |
| 1598 | int |
| 1599 | weston_vlog_continue(const char *fmt, va_list ap); |
| 1600 | int |
Pekka Paalanen | d525b56 | 2012-08-06 14:57:04 +0300 | [diff] [blame] | 1601 | weston_log(const char *fmt, ...) |
| 1602 | __attribute__ ((format (printf, 1, 2))); |
Kristian Høgsberg | 64eca89 | 2012-08-01 00:00:57 -0400 | [diff] [blame] | 1603 | int |
Pekka Paalanen | d525b56 | 2012-08-06 14:57:04 +0300 | [diff] [blame] | 1604 | weston_log_continue(const char *fmt, ...) |
| 1605 | __attribute__ ((format (printf, 1, 2))); |
Kristian Høgsberg | 64eca89 | 2012-08-01 00:00:57 -0400 | [diff] [blame] | 1606 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1607 | enum { |
| 1608 | TTY_ENTER_VT, |
| 1609 | TTY_LEAVE_VT |
| 1610 | }; |
| 1611 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1612 | struct tty * |
Kristian Høgsberg | 61741a2 | 2013-09-17 16:02:57 -0700 | [diff] [blame] | 1613 | tty_create(struct weston_compositor *compositor, int tty_nr); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1614 | |
| 1615 | void |
| 1616 | tty_destroy(struct tty *tty); |
| 1617 | |
Kristian Høgsberg | 7b884bc | 2012-07-31 14:32:01 -0400 | [diff] [blame] | 1618 | void |
| 1619 | tty_reset(struct tty *tty); |
| 1620 | |
Kristian Høgsberg | 5d1c0c5 | 2012-04-10 00:11:50 -0400 | [diff] [blame] | 1621 | int |
| 1622 | tty_activate_vt(struct tty *tty, int vt); |
| 1623 | |
Giulio Camuffo | e9022e7 | 2013-12-11 23:45:11 +0100 | [diff] [blame] | 1624 | enum weston_screenshooter_outcome { |
| 1625 | WESTON_SCREENSHOOTER_SUCCESS, |
| 1626 | WESTON_SCREENSHOOTER_NO_MEMORY, |
| 1627 | WESTON_SCREENSHOOTER_BAD_BUFFER |
| 1628 | }; |
| 1629 | |
| 1630 | typedef void (*weston_screenshooter_done_func_t)(void *data, |
| 1631 | enum weston_screenshooter_outcome outcome); |
| 1632 | int |
| 1633 | weston_screenshooter_shoot(struct weston_output *output, struct weston_buffer *buffer, |
| 1634 | weston_screenshooter_done_func_t done, void *data); |
Giulio Camuffo | 26f62d4 | 2016-06-02 21:48:09 +0300 | [diff] [blame] | 1635 | struct weston_recorder * |
| 1636 | weston_recorder_start(struct weston_output *output, const char *filename); |
| 1637 | void |
| 1638 | weston_recorder_stop(struct weston_recorder *recorder); |
Giulio Camuffo | e9022e7 | 2013-12-11 23:45:11 +0100 | [diff] [blame] | 1639 | |
Kristian Høgsberg | a7ceaff | 2012-06-03 10:20:13 -0400 | [diff] [blame] | 1640 | struct clipboard * |
| 1641 | clipboard_create(struct weston_seat *seat); |
| 1642 | |
Pekka Paalanen | aa9536a | 2015-06-24 16:09:17 +0300 | [diff] [blame] | 1643 | struct text_backend; |
| 1644 | |
| 1645 | struct text_backend * |
Jan Arne Petersen | 674fd1d | 2012-11-18 19:06:42 +0100 | [diff] [blame] | 1646 | text_backend_init(struct weston_compositor *ec); |
Jan Arne Petersen | 1f17be4 | 2012-06-21 21:52:18 +0200 | [diff] [blame] | 1647 | |
Pekka Paalanen | aa9536a | 2015-06-24 16:09:17 +0300 | [diff] [blame] | 1648 | void |
| 1649 | text_backend_destroy(struct text_backend *text_backend); |
| 1650 | |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 1651 | struct weston_view_animation; |
| 1652 | typedef void (*weston_view_animation_done_func_t)(struct weston_view_animation *animation, void *data); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1653 | |
Louis-Francis Ratté-Boulianne | b482dbd | 2013-11-19 11:37:11 +0100 | [diff] [blame] | 1654 | void |
| 1655 | weston_view_animation_destroy(struct weston_view_animation *animation); |
| 1656 | |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 1657 | struct weston_view_animation * |
| 1658 | weston_zoom_run(struct weston_view *view, float start, float stop, |
| 1659 | weston_view_animation_done_func_t done, void *data); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1660 | |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 1661 | struct weston_view_animation * |
| 1662 | weston_fade_run(struct weston_view *view, |
Ander Conselvan de Oliveira | ee41605 | 2013-02-21 18:35:17 +0200 | [diff] [blame] | 1663 | float start, float end, float k, |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 1664 | weston_view_animation_done_func_t done, void *data); |
Daniel Stone | a67e6b9 | 2013-11-19 11:37:13 +0100 | [diff] [blame] | 1665 | |
| 1666 | struct weston_view_animation * |
| 1667 | weston_move_scale_run(struct weston_view *view, int dx, int dy, |
| 1668 | float start, float end, int reverse, |
| 1669 | weston_view_animation_done_func_t done, void *data); |
| 1670 | |
Ander Conselvan de Oliveira | ee41605 | 2013-02-21 18:35:17 +0200 | [diff] [blame] | 1671 | void |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 1672 | weston_fade_update(struct weston_view_animation *fade, float target); |
Ander Conselvan de Oliveira | ee41605 | 2013-02-21 18:35:17 +0200 | [diff] [blame] | 1673 | |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 1674 | struct weston_view_animation * |
Louis-Francis Ratté-Boulianne | b482dbd | 2013-11-19 11:37:11 +0100 | [diff] [blame] | 1675 | weston_stable_fade_run(struct weston_view *front_view, float start, |
| 1676 | struct weston_view *back_view, float end, |
| 1677 | weston_view_animation_done_func_t done, void *data); |
| 1678 | |
| 1679 | struct weston_view_animation * |
Jason Ekstrand | a7af704 | 2013-10-12 22:38:11 -0500 | [diff] [blame] | 1680 | weston_slide_run(struct weston_view *view, float start, float stop, |
| 1681 | weston_view_animation_done_func_t done, void *data); |
Juan Zhao | e10d279 | 2012-04-25 19:09:52 +0800 | [diff] [blame] | 1682 | |
Alex Wu | 8811bf9 | 2012-02-28 18:07:54 +0800 | [diff] [blame] | 1683 | void |
| 1684 | weston_surface_set_color(struct weston_surface *surface, |
John Kåre Alsaker | 490d02a | 2012-09-30 02:57:21 +0200 | [diff] [blame] | 1685 | float red, float green, float blue, float alpha); |
Alex Wu | 8811bf9 | 2012-02-28 18:07:54 +0800 | [diff] [blame] | 1686 | |
| 1687 | void |
| 1688 | weston_surface_destroy(struct weston_surface *surface); |
| 1689 | |
Alex Wu | 2dda604 | 2012-04-17 17:20:47 +0800 | [diff] [blame] | 1690 | int |
Derek Foreman | 6ae7bc9 | 2014-11-04 10:47:33 -0600 | [diff] [blame] | 1691 | weston_output_mode_set_native(struct weston_output *output, |
| 1692 | struct weston_mode *mode, |
| 1693 | int32_t scale); |
| 1694 | int |
| 1695 | weston_output_mode_switch_to_temporary(struct weston_output *output, |
| 1696 | struct weston_mode *mode, |
| 1697 | int32_t scale); |
| 1698 | int |
| 1699 | weston_output_mode_switch_to_native(struct weston_output *output); |
Alex Wu | 2dda604 | 2012-04-17 17:20:47 +0800 | [diff] [blame] | 1700 | |
Ander Conselvan de Oliveira | 11f8d40 | 2012-10-29 18:19:24 +0200 | [diff] [blame] | 1701 | int |
| 1702 | noop_renderer_init(struct weston_compositor *ec); |
Ander Conselvan de Oliveira | 11f8d40 | 2012-10-29 18:19:24 +0200 | [diff] [blame] | 1703 | |
Giulio Camuffo | 954f183 | 2014-10-11 18:27:30 +0300 | [diff] [blame] | 1704 | int |
Jonas Ådahl | 30d61d8 | 2014-10-22 21:21:17 +0200 | [diff] [blame] | 1705 | weston_input_init(struct weston_compositor *compositor); |
| 1706 | |
| 1707 | int |
Giulio Camuffo | 954f183 | 2014-10-11 18:27:30 +0300 | [diff] [blame] | 1708 | backend_init(struct weston_compositor *c, |
Giulio Camuffo | 93daabb | 2015-10-17 19:24:14 +0300 | [diff] [blame] | 1709 | struct weston_backend_config *config_base); |
Kristian Høgsberg | b00a9d3 | 2012-09-11 14:06:27 -0400 | [diff] [blame] | 1710 | int |
Kristian Høgsberg | cb4685b | 2013-02-20 15:37:49 -0500 | [diff] [blame] | 1711 | module_init(struct weston_compositor *compositor, |
Ossama Othman | a50e6e4 | 2013-05-14 09:48:26 -0700 | [diff] [blame] | 1712 | int *argc, char *argv[]); |
Kristian Høgsberg | b00a9d3 | 2012-09-11 14:06:27 -0400 | [diff] [blame] | 1713 | |
Ander Conselvan de Oliveira | 409eebf | 2012-12-05 15:14:04 +0200 | [diff] [blame] | 1714 | void |
| 1715 | weston_transformed_coord(int width, int height, |
| 1716 | enum wl_output_transform transform, |
Alexander Larsson | edddbd1 | 2013-05-24 13:09:43 +0200 | [diff] [blame] | 1717 | int32_t scale, |
Ander Conselvan de Oliveira | 409eebf | 2012-12-05 15:14:04 +0200 | [diff] [blame] | 1718 | float sx, float sy, float *bx, float *by); |
| 1719 | pixman_box32_t |
| 1720 | weston_transformed_rect(int width, int height, |
| 1721 | enum wl_output_transform transform, |
Alexander Larsson | edddbd1 | 2013-05-24 13:09:43 +0200 | [diff] [blame] | 1722 | int32_t scale, |
Ander Conselvan de Oliveira | 409eebf | 2012-12-05 15:14:04 +0200 | [diff] [blame] | 1723 | pixman_box32_t rect); |
Jason Ekstrand | 33ff636 | 2013-10-27 22:25:01 -0500 | [diff] [blame] | 1724 | void |
Derek Foreman | bc9a61c | 2015-11-18 16:32:30 -0600 | [diff] [blame] | 1725 | weston_matrix_transform_region(pixman_region32_t *dest, |
| 1726 | struct weston_matrix *matrix, |
| 1727 | pixman_region32_t *src); |
| 1728 | void |
Jason Ekstrand | 33ff636 | 2013-10-27 22:25:01 -0500 | [diff] [blame] | 1729 | weston_transformed_region(int width, int height, |
| 1730 | enum wl_output_transform transform, |
| 1731 | int32_t scale, |
| 1732 | pixman_region32_t *src, pixman_region32_t *dest); |
Ander Conselvan de Oliveira | 409eebf | 2012-12-05 15:14:04 +0200 | [diff] [blame] | 1733 | |
Ander Conselvan de Oliveira | 97f2952 | 2013-10-14 15:57:11 +0300 | [diff] [blame] | 1734 | void * |
| 1735 | weston_load_module(const char *name, const char *entrypoint); |
| 1736 | |
Derek Foreman | 64a3df0 | 2014-10-23 12:24:18 -0500 | [diff] [blame] | 1737 | int |
| 1738 | weston_parse_transform(const char *transform, uint32_t *out); |
| 1739 | |
| 1740 | const char * |
| 1741 | weston_transform_to_string(uint32_t output_transform); |
| 1742 | |
Derek Foreman | 1281a36 | 2015-07-31 16:55:32 -0500 | [diff] [blame] | 1743 | struct weston_keyboard * |
| 1744 | weston_seat_get_keyboard(struct weston_seat *seat); |
| 1745 | |
| 1746 | struct weston_pointer * |
| 1747 | weston_seat_get_pointer(struct weston_seat *seat); |
| 1748 | |
| 1749 | struct weston_touch * |
| 1750 | weston_seat_get_touch(struct weston_seat *seat); |
| 1751 | |
Bryce Harrington | 24f917e | 2016-06-29 19:04:07 -0700 | [diff] [blame] | 1752 | void |
| 1753 | weston_seat_set_keyboard_focus(struct weston_seat *seat, |
| 1754 | struct weston_surface *surface); |
| 1755 | |
Giulio Camuffo | 9c764df | 2016-06-29 11:54:27 +0200 | [diff] [blame] | 1756 | int |
| 1757 | weston_compositor_load_xwayland(struct weston_compositor *compositor); |
| 1758 | |
Giulio Camuffo | 7fe01b1 | 2013-03-28 18:02:42 +0100 | [diff] [blame] | 1759 | #ifdef __cplusplus |
| 1760 | } |
| 1761 | #endif |
| 1762 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 1763 | #endif |