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 | * |
| 5 | * Permission to use, copy, modify, distribute, and sell this software and |
| 6 | * its documentation for any purpose is hereby granted without fee, provided |
| 7 | * that the above copyright notice appear in all copies and that both that |
| 8 | * copyright notice and this permission notice appear in supporting |
| 9 | * documentation, and that the name of the copyright holders not be used in |
| 10 | * advertising or publicity pertaining to distribution of the software |
| 11 | * without specific, written prior permission. The copyright holders make |
| 12 | * no representations about the suitability of this software for any |
| 13 | * purpose. It is provided "as is" without express or implied warranty. |
| 14 | * |
| 15 | * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS |
| 16 | * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND |
| 17 | * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY |
| 18 | * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER |
| 19 | * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF |
| 20 | * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN |
| 21 | * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
| 22 | */ |
| 23 | |
| 24 | #ifndef _WAYLAND_SYSTEM_COMPOSITOR_H_ |
| 25 | #define _WAYLAND_SYSTEM_COMPOSITOR_H_ |
| 26 | |
Giulio Camuffo | 7fe01b1 | 2013-03-28 18:02:42 +0100 | [diff] [blame] | 27 | #ifdef __cplusplus |
| 28 | extern "C" { |
| 29 | #endif |
| 30 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 31 | #include <pixman.h> |
Daniel Stone | 855028f | 2012-05-01 20:37:10 +0100 | [diff] [blame] | 32 | #include <xkbcommon/xkbcommon.h> |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 33 | #include <wayland-server.h> |
| 34 | |
Kristian Høgsberg | af4f2aa | 2013-02-15 20:53:20 -0500 | [diff] [blame] | 35 | #include "version.h" |
| 36 | #include "matrix.h" |
| 37 | #include "config-parser.h" |
Pekka Paalanen | 2eaa11e | 2012-03-30 15:45:40 +0300 | [diff] [blame] | 38 | |
Kristian Høgsberg | 5717b6d | 2012-10-19 17:12:38 -0400 | [diff] [blame] | 39 | #define ARRAY_LENGTH(a) (sizeof (a) / sizeof (a)[0]) |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 40 | |
Kristian Høgsberg | 8c31a4c | 2012-10-19 23:05:37 -0400 | [diff] [blame] | 41 | #define container_of(ptr, type, member) ({ \ |
| 42 | const __typeof__( ((type *)0)->member ) *__mptr = (ptr); \ |
| 43 | (type *)( (char *)__mptr - offsetof(type,member) );}) |
| 44 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 45 | struct weston_transform { |
| 46 | struct weston_matrix matrix; |
Pekka Paalanen | c61eca6 | 2012-01-06 14:10:06 +0200 | [diff] [blame] | 47 | struct wl_list link; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 48 | }; |
| 49 | |
| 50 | struct weston_surface; |
Tiago Vignatti | bc052c9 | 2012-04-19 16:18:18 +0300 | [diff] [blame] | 51 | struct shell_surface; |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 52 | struct weston_seat; |
Scott Moreau | 062be7e | 2012-04-20 13:37:33 -0600 | [diff] [blame] | 53 | struct weston_output; |
Jan Arne Petersen | e829adc | 2012-08-10 16:47:22 +0200 | [diff] [blame] | 54 | struct input_method; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 55 | |
Daniel Stone | 496ca17 | 2012-05-30 16:31:42 +0100 | [diff] [blame] | 56 | enum weston_keyboard_modifier { |
| 57 | MODIFIER_CTRL = (1 << 0), |
| 58 | MODIFIER_ALT = (1 << 1), |
| 59 | MODIFIER_SUPER = (1 << 2), |
Kristian Høgsberg | 73694c8 | 2012-06-28 14:13:10 -0400 | [diff] [blame] | 60 | MODIFIER_SHIFT = (1 << 3), |
Daniel Stone | 496ca17 | 2012-05-30 16:31:42 +0100 | [diff] [blame] | 61 | }; |
| 62 | |
Daniel Stone | 8c8164f | 2012-05-30 16:31:45 +0100 | [diff] [blame] | 63 | enum weston_led { |
| 64 | LED_NUM_LOCK = (1 << 0), |
| 65 | LED_CAPS_LOCK = (1 << 1), |
| 66 | LED_SCROLL_LOCK = (1 << 2), |
| 67 | }; |
| 68 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 69 | struct weston_mode { |
| 70 | uint32_t flags; |
| 71 | int32_t width, height; |
| 72 | uint32_t refresh; |
| 73 | struct wl_list link; |
| 74 | }; |
| 75 | |
Kristian Høgsberg | a61ca06 | 2012-05-22 16:05:52 -0400 | [diff] [blame] | 76 | struct weston_shell_client { |
| 77 | void (*send_configure)(struct weston_surface *surface, |
| 78 | uint32_t edges, int32_t width, int32_t height); |
| 79 | }; |
| 80 | |
Tiago Vignatti | bc052c9 | 2012-04-19 16:18:18 +0300 | [diff] [blame] | 81 | struct weston_shell_interface { |
| 82 | void *shell; /* either desktop or tablet */ |
| 83 | |
Kristian Høgsberg | 45ba869 | 2012-05-21 14:27:33 -0400 | [diff] [blame] | 84 | struct shell_surface *(*create_shell_surface)(void *shell, |
Kristian Høgsberg | a61ca06 | 2012-05-22 16:05:52 -0400 | [diff] [blame] | 85 | struct weston_surface *surface, |
| 86 | const struct weston_shell_client *client); |
Kristian Høgsberg | 45ba869 | 2012-05-21 14:27:33 -0400 | [diff] [blame] | 87 | |
Tiago Vignatti | bc052c9 | 2012-04-19 16:18:18 +0300 | [diff] [blame] | 88 | void (*set_toplevel)(struct shell_surface *shsurf); |
Kristian Høgsberg | 938b8fa | 2012-05-18 13:46:27 -0400 | [diff] [blame] | 89 | |
Tiago Vignatti | 491bac1 | 2012-05-18 16:37:43 -0400 | [diff] [blame] | 90 | void (*set_transient)(struct shell_surface *shsurf, |
Kristian Høgsberg | 8150b19 | 2012-06-27 10:22:58 -0400 | [diff] [blame] | 91 | struct weston_surface *parent, |
Tiago Vignatti | 491bac1 | 2012-05-18 16:37:43 -0400 | [diff] [blame] | 92 | int x, int y, uint32_t flags); |
Kristian Høgsberg | b810eb5 | 2013-02-12 20:07:05 -0500 | [diff] [blame] | 93 | void (*set_fullscreen)(struct shell_surface *shsurf, |
| 94 | uint32_t method, |
| 95 | uint32_t framerate, |
| 96 | struct weston_output *output); |
Kristian Høgsberg | 938b8fa | 2012-05-18 13:46:27 -0400 | [diff] [blame] | 97 | int (*move)(struct shell_surface *shsurf, struct weston_seat *ws); |
Kristian Høgsberg | c1693f2 | 2012-05-22 16:56:23 -0400 | [diff] [blame] | 98 | int (*resize)(struct shell_surface *shsurf, |
| 99 | struct weston_seat *ws, uint32_t edges); |
| 100 | |
Tiago Vignatti | bc052c9 | 2012-04-19 16:18:18 +0300 | [diff] [blame] | 101 | }; |
| 102 | |
Kristian Høgsberg | 546a812 | 2012-02-01 07:45:51 -0500 | [diff] [blame] | 103 | struct weston_border { |
| 104 | int32_t left, right, top, bottom; |
| 105 | }; |
| 106 | |
Scott Moreau | e660398 | 2012-06-11 13:07:51 -0600 | [diff] [blame] | 107 | struct weston_animation { |
| 108 | void (*frame)(struct weston_animation *animation, |
| 109 | struct weston_output *output, uint32_t msecs); |
| 110 | int frame_counter; |
| 111 | struct wl_list link; |
| 112 | }; |
| 113 | |
| 114 | struct weston_spring { |
| 115 | double k; |
| 116 | double friction; |
| 117 | double current; |
| 118 | double target; |
| 119 | double previous; |
| 120 | uint32_t timestamp; |
| 121 | }; |
| 122 | |
Scott Moreau | 7a1b32a | 2012-05-27 14:25:02 -0600 | [diff] [blame] | 123 | enum { |
Scott Moreau | e660398 | 2012-06-11 13:07:51 -0600 | [diff] [blame] | 124 | ZOOM_FOCUS_POINTER, |
| 125 | ZOOM_FOCUS_TEXT |
Scott Moreau | 7a1b32a | 2012-05-27 14:25:02 -0600 | [diff] [blame] | 126 | }; |
| 127 | |
Scott Moreau | 8dacaab | 2012-06-17 18:10:58 -0600 | [diff] [blame] | 128 | struct weston_fixed_point { |
| 129 | wl_fixed_t x, y; |
| 130 | }; |
| 131 | |
Scott Moreau | ccbf29d | 2012-02-22 14:21:41 -0700 | [diff] [blame] | 132 | struct weston_output_zoom { |
| 133 | int active; |
Scott Moreau | e660398 | 2012-06-11 13:07:51 -0600 | [diff] [blame] | 134 | uint32_t type; |
Scott Moreau | ccbf29d | 2012-02-22 14:21:41 -0700 | [diff] [blame] | 135 | float increment; |
| 136 | float level; |
Scott Moreau | e660398 | 2012-06-11 13:07:51 -0600 | [diff] [blame] | 137 | float max_level; |
Scott Moreau | ccbf29d | 2012-02-22 14:21:41 -0700 | [diff] [blame] | 138 | float trans_x, trans_y; |
Scott Moreau | e660398 | 2012-06-11 13:07:51 -0600 | [diff] [blame] | 139 | struct weston_animation animation_z; |
| 140 | struct weston_spring spring_z; |
Scott Moreau | 8dacaab | 2012-06-17 18:10:58 -0600 | [diff] [blame] | 141 | struct weston_animation animation_xy; |
| 142 | struct weston_spring spring_xy; |
| 143 | struct weston_fixed_point from; |
| 144 | struct weston_fixed_point to; |
| 145 | struct weston_fixed_point current; |
| 146 | struct weston_fixed_point text_cursor; |
Scott Moreau | ccbf29d | 2012-02-22 14:21:41 -0700 | [diff] [blame] | 147 | }; |
| 148 | |
Tiago Vignatti | 8e53c7f | 2012-02-29 19:53:50 +0200 | [diff] [blame] | 149 | /* bit compatible with drm definitions. */ |
| 150 | enum dpms_enum { |
| 151 | WESTON_DPMS_ON, |
| 152 | WESTON_DPMS_STANDBY, |
| 153 | WESTON_DPMS_SUSPEND, |
| 154 | WESTON_DPMS_OFF |
| 155 | }; |
| 156 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 157 | struct weston_output { |
Casey Dahlin | 58ba137 | 2012-04-19 22:50:08 -0400 | [diff] [blame] | 158 | uint32_t id; |
| 159 | |
John Kåre Alsaker | 9465927 | 2012-11-13 19:10:18 +0100 | [diff] [blame] | 160 | void *renderer_state; |
| 161 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 162 | struct wl_list link; |
Casey Dahlin | 9074db5 | 2012-04-19 22:50:09 -0400 | [diff] [blame] | 163 | struct wl_list resource_list; |
Benjamin Franzke | b687940 | 2012-04-10 18:28:54 +0200 | [diff] [blame] | 164 | struct wl_global *global; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 165 | struct weston_compositor *compositor; |
| 166 | struct weston_matrix matrix; |
Scott Moreau | 9d1b112 | 2012-06-08 19:40:53 -0600 | [diff] [blame] | 167 | struct wl_list animation_list; |
Scott Moreau | 1bad5db | 2012-08-18 01:04:05 -0600 | [diff] [blame] | 168 | int32_t x, y, width, height; |
| 169 | int32_t mm_width, mm_height; |
Kristian Høgsberg | 546a812 | 2012-02-01 07:45:51 -0500 | [diff] [blame] | 170 | struct weston_border border; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 171 | pixman_region32_t region; |
Ander Conselvan de Oliveira | b8fcca9 | 2012-11-16 17:23:52 +0200 | [diff] [blame] | 172 | pixman_region32_t previous_damage; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 173 | int repaint_needed; |
| 174 | int repaint_scheduled; |
Scott Moreau | ccbf29d | 2012-02-22 14:21:41 -0700 | [diff] [blame] | 175 | struct weston_output_zoom zoom; |
| 176 | int dirty; |
Kristian Høgsberg | 5fb70bf | 2012-05-24 12:29:46 -0400 | [diff] [blame] | 177 | struct wl_signal frame_signal; |
Richard Hughes | 64ddde1 | 2013-05-01 21:52:10 +0100 | [diff] [blame] | 178 | struct wl_signal destroy_signal; |
Kristian Høgsberg | e9d0492 | 2012-06-19 23:54:26 -0400 | [diff] [blame] | 179 | uint32_t frame_time; |
Kristian Høgsberg | 79af73e | 2012-08-03 15:45:23 -0400 | [diff] [blame] | 180 | int disable_planes; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 181 | |
Richard Hughes | 2b2092a | 2013-04-24 14:58:02 +0100 | [diff] [blame] | 182 | char *make, *model, *serial_number; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 183 | uint32_t subpixel; |
Kristian Høgsberg | 05890dc | 2012-08-10 10:09:20 -0400 | [diff] [blame] | 184 | uint32_t transform; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 185 | |
| 186 | struct weston_mode *current; |
Alex Wu | bd3354b | 2012-04-17 17:20:49 +0800 | [diff] [blame] | 187 | struct weston_mode *origin; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 188 | struct wl_list mode_list; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 189 | |
Jonas Ådahl | e5a1225 | 2013-04-05 23:07:11 +0200 | [diff] [blame] | 190 | void (*start_repaint_loop)(struct weston_output *output); |
Kristian Høgsberg | 6ddcdae | 2012-02-28 22:31:58 -0500 | [diff] [blame] | 191 | void (*repaint)(struct weston_output *output, |
Kristian Høgsberg | d7c1726 | 2012-09-05 21:54:15 -0400 | [diff] [blame] | 192 | pixman_region32_t *damage); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 193 | void (*destroy)(struct weston_output *output); |
Jesse Barnes | 5308a5e | 2012-02-09 13:12:57 -0800 | [diff] [blame] | 194 | void (*assign_planes)(struct weston_output *output); |
Alex Wu | 2dda604 | 2012-04-17 17:20:47 +0800 | [diff] [blame] | 195 | int (*switch_mode)(struct weston_output *output, struct weston_mode *mode); |
Tiago Vignatti | 8e53c7f | 2012-02-29 19:53:50 +0200 | [diff] [blame] | 196 | |
Tiago Vignatti | 5ab91ad | 2012-03-12 19:40:09 -0300 | [diff] [blame] | 197 | /* backlight values are on 0-255 range, where higher is brighter */ |
Tiago Vignatti | 8e53c7f | 2012-02-29 19:53:50 +0200 | [diff] [blame] | 198 | uint32_t backlight_current; |
| 199 | void (*set_backlight)(struct weston_output *output, uint32_t value); |
| 200 | void (*set_dpms)(struct weston_output *output, enum dpms_enum level); |
Richard Hughes | e729996 | 2013-05-01 21:52:12 +0100 | [diff] [blame^] | 201 | |
| 202 | uint16_t gamma_size; |
| 203 | void (*set_gamma)(struct weston_output *output, |
| 204 | uint16_t size, |
| 205 | uint16_t *r, |
| 206 | uint16_t *g, |
| 207 | uint16_t *b); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 208 | }; |
| 209 | |
Daniel Stone | d65b909 | 2012-05-30 16:32:05 +0100 | [diff] [blame] | 210 | struct weston_xkb_info { |
| 211 | struct xkb_keymap *keymap; |
Daniel Stone | b7452fe | 2012-06-01 12:14:06 +0100 | [diff] [blame] | 212 | int keymap_fd; |
| 213 | size_t keymap_size; |
| 214 | char *keymap_area; |
Daniel Stone | abb9dcd | 2012-06-22 13:21:33 +0100 | [diff] [blame] | 215 | xkb_mod_index_t shift_mod; |
| 216 | xkb_mod_index_t caps_mod; |
Daniel Stone | d65b909 | 2012-05-30 16:32:05 +0100 | [diff] [blame] | 217 | xkb_mod_index_t ctrl_mod; |
| 218 | xkb_mod_index_t alt_mod; |
Daniel Stone | abb9dcd | 2012-06-22 13:21:33 +0100 | [diff] [blame] | 219 | xkb_mod_index_t mod2_mod; |
| 220 | xkb_mod_index_t mod3_mod; |
Daniel Stone | d65b909 | 2012-05-30 16:32:05 +0100 | [diff] [blame] | 221 | xkb_mod_index_t super_mod; |
Daniel Stone | abb9dcd | 2012-06-22 13:21:33 +0100 | [diff] [blame] | 222 | xkb_mod_index_t mod5_mod; |
Daniel Stone | d65b909 | 2012-05-30 16:32:05 +0100 | [diff] [blame] | 223 | xkb_led_index_t num_led; |
| 224 | xkb_led_index_t caps_led; |
| 225 | xkb_led_index_t scroll_led; |
| 226 | }; |
| 227 | |
Jan Arne Petersen | a75a789 | 2013-01-16 21:26:50 +0100 | [diff] [blame] | 228 | struct weston_keyboard { |
| 229 | struct wl_keyboard keyboard; |
| 230 | |
| 231 | struct wl_keyboard_grab input_method_grab; |
| 232 | struct wl_resource *input_method_resource; |
| 233 | }; |
| 234 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 235 | struct weston_seat { |
| 236 | struct wl_seat seat; |
| 237 | struct wl_pointer pointer; |
Daniel Stone | 74419a2 | 2012-05-30 16:32:02 +0100 | [diff] [blame] | 238 | int has_pointer; |
Jan Arne Petersen | a75a789 | 2013-01-16 21:26:50 +0100 | [diff] [blame] | 239 | struct weston_keyboard keyboard; |
Daniel Stone | 74419a2 | 2012-05-30 16:32:02 +0100 | [diff] [blame] | 240 | int has_keyboard; |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 241 | struct wl_touch touch; |
Daniel Stone | 74419a2 | 2012-05-30 16:32:02 +0100 | [diff] [blame] | 242 | int has_touch; |
Giulio Camuffo | 5085a75 | 2013-03-25 21:42:45 +0100 | [diff] [blame] | 243 | struct wl_signal destroy_signal; |
Daniel Stone | 74419a2 | 2012-05-30 16:32:02 +0100 | [diff] [blame] | 244 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 245 | struct weston_compositor *compositor; |
| 246 | struct weston_surface *sprite; |
Ander Conselvan de Oliveira | 37ffc3c | 2012-06-15 17:27:35 +0300 | [diff] [blame] | 247 | struct wl_listener sprite_destroy_listener; |
Ander Conselvan de Oliveira | 30eebc7 | 2012-02-15 17:02:57 +0200 | [diff] [blame] | 248 | struct weston_surface *drag_surface; |
Ander Conselvan de Oliveira | c5fb9a7 | 2012-03-01 14:09:44 +0200 | [diff] [blame] | 249 | struct wl_listener drag_surface_destroy_listener; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 250 | int32_t hotspot_x, hotspot_y; |
| 251 | struct wl_list link; |
Daniel Stone | 496ca17 | 2012-05-30 16:31:42 +0100 | [diff] [blame] | 252 | enum weston_keyboard_modifier modifier_state; |
Ander Conselvan de Oliveira | 71b1d0c | 2012-03-16 17:25:11 +0200 | [diff] [blame] | 253 | struct wl_surface *saved_kbd_focus; |
| 254 | struct wl_listener saved_kbd_focus_listener; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 255 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 256 | uint32_t num_tp; |
Ander Conselvan de Oliveira | d6ea33d | 2012-03-27 17:36:39 +0300 | [diff] [blame] | 257 | |
| 258 | struct wl_listener new_drag_icon_listener; |
Daniel Stone | 994679a | 2012-05-30 16:31:43 +0100 | [diff] [blame] | 259 | |
Daniel Stone | 8c8164f | 2012-05-30 16:31:45 +0100 | [diff] [blame] | 260 | void (*led_update)(struct weston_seat *ws, enum weston_led leds); |
| 261 | |
Daniel Stone | d65b909 | 2012-05-30 16:32:05 +0100 | [diff] [blame] | 262 | struct weston_xkb_info xkb_info; |
Daniel Stone | 994679a | 2012-05-30 16:31:43 +0100 | [diff] [blame] | 263 | struct { |
| 264 | struct xkb_state *state; |
Daniel Stone | 8c8164f | 2012-05-30 16:31:45 +0100 | [diff] [blame] | 265 | enum weston_led leds; |
Daniel Stone | 994679a | 2012-05-30 16:31:43 +0100 | [diff] [blame] | 266 | } xkb_state; |
Jan Arne Petersen | e829adc | 2012-08-10 16:47:22 +0200 | [diff] [blame] | 267 | |
| 268 | struct input_method *input_method; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 269 | }; |
| 270 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 271 | enum { |
| 272 | WESTON_COMPOSITOR_ACTIVE, |
| 273 | WESTON_COMPOSITOR_IDLE, /* shell->unlock called on activity */ |
Philipp Brüschweiler | 57edf7f | 2013-03-29 13:01:56 +0100 | [diff] [blame] | 274 | WESTON_COMPOSITOR_OFFSCREEN, /* no rendering, no frame events */ |
| 275 | WESTON_COMPOSITOR_SLEEPING /* same as offscreen, but also set dmps |
| 276 | * to off */ |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 277 | }; |
| 278 | |
Kristian Høgsberg | 3be2ce9 | 2012-02-29 12:42:35 -0500 | [diff] [blame] | 279 | struct weston_layer { |
| 280 | struct wl_list surface_list; |
| 281 | struct wl_list link; |
| 282 | }; |
| 283 | |
Kristian Høgsberg | 65a11e1 | 2012-08-03 11:30:18 -0400 | [diff] [blame] | 284 | struct weston_plane { |
| 285 | pixman_region32_t damage; |
Ander Conselvan de Oliveira | e1bd5a0 | 2013-03-05 17:30:29 +0200 | [diff] [blame] | 286 | pixman_region32_t clip; |
Kristian Høgsberg | 65a11e1 | 2012-08-03 11:30:18 -0400 | [diff] [blame] | 287 | int32_t x, y; |
Ander Conselvan de Oliveira | 8ad1982 | 2013-03-05 17:30:27 +0200 | [diff] [blame] | 288 | struct wl_list link; |
Kristian Høgsberg | 65a11e1 | 2012-08-03 11:30:18 -0400 | [diff] [blame] | 289 | }; |
| 290 | |
Kristian Høgsberg | fa1be02 | 2012-09-05 22:49:55 -0400 | [diff] [blame] | 291 | struct weston_renderer { |
John Kåre Alsaker | a95b2d6 | 2012-11-13 19:10:21 +0100 | [diff] [blame] | 292 | int (*read_pixels)(struct weston_output *output, |
| 293 | pixman_format_code_t format, void *pixels, |
| 294 | uint32_t x, uint32_t y, |
| 295 | uint32_t width, uint32_t height); |
Kristian Høgsberg | fa1be02 | 2012-09-05 22:49:55 -0400 | [diff] [blame] | 296 | void (*repaint_output)(struct weston_output *output, |
| 297 | pixman_region32_t *output_damage); |
| 298 | void (*flush_damage)(struct weston_surface *surface); |
| 299 | void (*attach)(struct weston_surface *es, struct wl_buffer *buffer); |
John Kåre Alsaker | 878f449 | 2012-11-13 19:10:23 +0100 | [diff] [blame] | 300 | int (*create_surface)(struct weston_surface *surface); |
| 301 | void (*surface_set_color)(struct weston_surface *surface, |
| 302 | float red, float green, |
| 303 | float blue, float alpha); |
Kristian Høgsberg | 4226385 | 2012-09-06 21:59:29 -0400 | [diff] [blame] | 304 | void (*destroy_surface)(struct weston_surface *surface); |
Vasily Khoruzhick | 52cfd61 | 2013-01-08 19:09:01 +0300 | [diff] [blame] | 305 | void (*destroy)(struct weston_compositor *ec); |
Kristian Høgsberg | fa1be02 | 2012-09-05 22:49:55 -0400 | [diff] [blame] | 306 | }; |
| 307 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 308 | struct weston_compositor { |
Kristian Høgsberg | 02e79dc | 2012-04-12 09:55:26 -0400 | [diff] [blame] | 309 | struct wl_signal destroy_signal; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 310 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 311 | struct wl_display *wl_display; |
Tiago Vignatti | bc052c9 | 2012-04-19 16:18:18 +0300 | [diff] [blame] | 312 | struct weston_shell_interface shell_interface; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 313 | |
Kristian Høgsberg | 02e79dc | 2012-04-12 09:55:26 -0400 | [diff] [blame] | 314 | struct wl_signal activate_signal; |
Tiago Vignatti | 1d01b01 | 2012-09-27 17:48:36 +0300 | [diff] [blame] | 315 | struct wl_signal kill_signal; |
Ander Conselvan de Oliveira | a457563 | 2013-02-21 18:35:23 +0200 | [diff] [blame] | 316 | struct wl_signal idle_signal; |
| 317 | struct wl_signal wake_signal; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 318 | |
Jan Arne Petersen | 42feced | 2012-06-21 21:52:17 +0200 | [diff] [blame] | 319 | struct wl_signal show_input_panel_signal; |
| 320 | struct wl_signal hide_input_panel_signal; |
| 321 | |
Jan Arne Petersen | 674fd1d | 2012-11-18 19:06:42 +0100 | [diff] [blame] | 322 | struct wl_signal seat_created_signal; |
Richard Hughes | 59d5da7 | 2013-05-01 21:52:11 +0100 | [diff] [blame] | 323 | struct wl_signal output_created_signal; |
Jan Arne Petersen | 674fd1d | 2012-11-18 19:06:42 +0100 | [diff] [blame] | 324 | |
Kristian Høgsberg | 7ea1086 | 2012-03-05 17:49:30 -0500 | [diff] [blame] | 325 | struct wl_event_loop *input_loop; |
| 326 | struct wl_event_source *input_loop_source; |
| 327 | |
Kristian Høgsberg | 3be2ce9 | 2012-02-29 12:42:35 -0500 | [diff] [blame] | 328 | struct weston_layer fade_layer; |
| 329 | struct weston_layer cursor_layer; |
| 330 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 331 | struct wl_list output_list; |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 332 | struct wl_list seat_list; |
Kristian Høgsberg | 3be2ce9 | 2012-02-29 12:42:35 -0500 | [diff] [blame] | 333 | struct wl_list layer_list; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 334 | struct wl_list surface_list; |
Ander Conselvan de Oliveira | 8ad1982 | 2013-03-05 17:30:27 +0200 | [diff] [blame] | 335 | struct wl_list plane_list; |
Daniel Stone | 325fc2d | 2012-05-30 16:31:58 +0100 | [diff] [blame] | 336 | struct wl_list key_binding_list; |
| 337 | struct wl_list button_binding_list; |
| 338 | struct wl_list axis_binding_list; |
Ander Conselvan de Oliveira | c509d2b | 2012-11-08 17:20:45 +0200 | [diff] [blame] | 339 | struct wl_list debug_binding_list; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 340 | |
| 341 | uint32_t state; |
| 342 | struct wl_event_source *idle_source; |
| 343 | uint32_t idle_inhibit; |
Philipp Brüschweiler | 4b409c3 | 2013-03-10 14:37:04 +0100 | [diff] [blame] | 344 | int idle_time; /* timeout, s */ |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 345 | |
| 346 | /* Repaint state. */ |
Rob Clark | 0e5a2d0 | 2012-08-30 16:47:18 -0500 | [diff] [blame] | 347 | struct wl_array vertices; |
| 348 | struct wl_array indices; /* only used in compositor-wayland */ |
| 349 | struct wl_array vtxcnt; |
Kristian Høgsberg | 65a11e1 | 2012-08-03 11:30:18 -0400 | [diff] [blame] | 350 | struct weston_plane primary_plane; |
Pekka Paalanen | 07c91f8 | 2012-08-30 16:47:21 -0500 | [diff] [blame] | 351 | int fan_debug; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 352 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 353 | uint32_t focus; |
| 354 | |
Kristian Høgsberg | fa1be02 | 2012-09-05 22:49:55 -0400 | [diff] [blame] | 355 | struct weston_renderer *renderer; |
| 356 | |
John Kåre Alsaker | f9e710b | 2012-11-13 19:10:22 +0100 | [diff] [blame] | 357 | pixman_format_code_t read_format; |
Pekka Paalanen | 52bfbaa | 2012-04-11 16:19:37 +0300 | [diff] [blame] | 358 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 359 | void (*destroy)(struct weston_compositor *ec); |
Kristian Høgsberg | 7b884bc | 2012-07-31 14:32:01 -0400 | [diff] [blame] | 360 | void (*restore)(struct weston_compositor *ec); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 361 | int (*authenticate)(struct weston_compositor *c, uint32_t id); |
Kristian Høgsberg | 3466bc8 | 2012-01-03 11:29:15 -0500 | [diff] [blame] | 362 | |
Scott Moreau | ff1db4a | 2012-04-17 19:06:18 -0600 | [diff] [blame] | 363 | void (*ping_handler)(struct weston_surface *surface, uint32_t serial); |
| 364 | |
Benjamin Franzke | bfeda13 | 2012-01-30 14:04:04 +0100 | [diff] [blame] | 365 | int launcher_sock; |
Casey Dahlin | 58ba137 | 2012-04-19 22:50:08 -0400 | [diff] [blame] | 366 | |
| 367 | uint32_t output_id_pool; |
Daniel Stone | 855028f | 2012-05-01 20:37:10 +0100 | [diff] [blame] | 368 | |
Daniel Stone | e379da9 | 2012-05-30 16:32:04 +0100 | [diff] [blame] | 369 | struct xkb_rule_names xkb_names; |
| 370 | struct xkb_context *xkb_context; |
| 371 | struct weston_xkb_info xkb_info; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 372 | }; |
| 373 | |
Pekka Paalanen | de685b8 | 2012-12-04 15:58:12 +0200 | [diff] [blame] | 374 | struct weston_buffer_reference { |
| 375 | struct wl_buffer *buffer; |
| 376 | struct wl_listener destroy_listener; |
| 377 | }; |
| 378 | |
Kristian Høgsberg | 5e7e6f2 | 2012-02-23 16:11:59 -0500 | [diff] [blame] | 379 | struct weston_region { |
| 380 | struct wl_resource resource; |
| 381 | pixman_region32_t region; |
| 382 | }; |
| 383 | |
Pekka Paalanen | 44ab69c | 2012-02-07 13:18:00 +0200 | [diff] [blame] | 384 | /* Using weston_surface transformations |
| 385 | * |
| 386 | * To add a transformation to a surface, create a struct weston_transform, and |
| 387 | * add it to the list surface->geometry.transformation_list. Whenever you |
| 388 | * change the list, anything under surface->geometry, or anything in the |
Pekka Paalanen | c3ce738 | 2013-03-08 14:56:49 +0200 | [diff] [blame] | 389 | * weston_transforms linked into the list, you must call |
| 390 | * weston_surface_geometry_dirty(). |
Pekka Paalanen | 44ab69c | 2012-02-07 13:18:00 +0200 | [diff] [blame] | 391 | * |
| 392 | * The order in the list defines the order of transformations. Let the list |
| 393 | * contain the transformation matrices M1, ..., Mn as head to tail. The |
| 394 | * transformation is applied to surface-local coordinate vector p as |
| 395 | * P = Mn * ... * M2 * M1 * p |
| 396 | * to produce the global coordinate vector P. The total transform |
| 397 | * Mn * ... * M2 * M1 |
| 398 | * is cached in surface->transform.matrix, and the inverse of it in |
| 399 | * surface->transform.inverse. |
| 400 | * |
| 401 | * The list always contains surface->transform.position transformation, which |
| 402 | * is the translation by surface->geometry.x and y. |
| 403 | * |
| 404 | * If you want to apply a transformation in local coordinates, add your |
| 405 | * weston_transform to the head of the list. If you want to apply a |
| 406 | * transformation in global coordinates, add it to the tail of the list. |
Pekka Paalanen | 483243f | 2013-03-08 14:56:50 +0200 | [diff] [blame] | 407 | * |
| 408 | * If surface->geometry.parent is set, the total transformation of this |
| 409 | * surface will be the parent's total transformation and this transformation |
| 410 | * combined: |
| 411 | * Mparent * Mn * ... * M2 * M1 |
Pekka Paalanen | 44ab69c | 2012-02-07 13:18:00 +0200 | [diff] [blame] | 412 | */ |
| 413 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 414 | struct weston_surface { |
| 415 | struct wl_surface surface; |
| 416 | struct weston_compositor *compositor; |
Kristian Høgsberg | 6ddcdae | 2012-02-28 22:31:58 -0500 | [diff] [blame] | 417 | pixman_region32_t clip; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 418 | pixman_region32_t damage; |
Pekka Paalanen | c3ce738 | 2013-03-08 14:56:49 +0200 | [diff] [blame] | 419 | pixman_region32_t opaque; /* part of geometry, see below */ |
Kristian Høgsberg | 5e7e6f2 | 2012-02-23 16:11:59 -0500 | [diff] [blame] | 420 | pixman_region32_t input; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 421 | struct wl_list link; |
Kristian Høgsberg | 3be2ce9 | 2012-02-29 12:42:35 -0500 | [diff] [blame] | 422 | struct wl_list layer_link; |
Pekka Paalanen | c3ce738 | 2013-03-08 14:56:49 +0200 | [diff] [blame] | 423 | float alpha; /* part of geometry, see below */ |
Kristian Høgsberg | 65a11e1 | 2012-08-03 11:30:18 -0400 | [diff] [blame] | 424 | struct weston_plane *plane; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 425 | |
John Kåre Alsaker | 878f449 | 2012-11-13 19:10:23 +0100 | [diff] [blame] | 426 | void *renderer_state; |
| 427 | |
Pekka Paalanen | bc0b7e7 | 2012-01-24 09:53:37 +0200 | [diff] [blame] | 428 | /* Surface geometry state, mutable. |
Pekka Paalanen | c3ce738 | 2013-03-08 14:56:49 +0200 | [diff] [blame] | 429 | * If you change anything, call weston_surface_geometry_dirty(). |
Pekka Paalanen | bc0b7e7 | 2012-01-24 09:53:37 +0200 | [diff] [blame] | 430 | * That includes the transformations referenced from the list. |
| 431 | */ |
Pekka Paalanen | c61eca6 | 2012-01-06 14:10:06 +0200 | [diff] [blame] | 432 | struct { |
John Kåre Alsaker | 490d02a | 2012-09-30 02:57:21 +0200 | [diff] [blame] | 433 | float x, y; /* surface translation on display */ |
Pekka Paalanen | 60921e5 | 2012-01-25 15:55:43 +0200 | [diff] [blame] | 434 | int32_t width, height; |
Pekka Paalanen | ba3cf95 | 2012-01-25 16:22:05 +0200 | [diff] [blame] | 435 | |
Pekka Paalanen | bc0b7e7 | 2012-01-24 09:53:37 +0200 | [diff] [blame] | 436 | /* struct weston_transform */ |
| 437 | struct wl_list transformation_list; |
Pekka Paalanen | 483243f | 2013-03-08 14:56:50 +0200 | [diff] [blame] | 438 | |
| 439 | /* managed by weston_surface_set_transform_parent() */ |
| 440 | struct weston_surface *parent; |
| 441 | struct wl_listener parent_destroy_listener; |
| 442 | struct wl_list child_list; /* geometry.parent_link */ |
| 443 | struct wl_list parent_link; |
Pekka Paalanen | bc0b7e7 | 2012-01-24 09:53:37 +0200 | [diff] [blame] | 444 | } geometry; |
| 445 | |
| 446 | /* State derived from geometry state, read-only. |
| 447 | * This is updated by weston_surface_update_transform(). |
| 448 | */ |
| 449 | struct { |
Pekka Paalanen | c3ce738 | 2013-03-08 14:56:49 +0200 | [diff] [blame] | 450 | int dirty; |
| 451 | |
Pekka Paalanen | 6720d8f | 2012-01-25 15:17:40 +0200 | [diff] [blame] | 452 | pixman_region32_t boundingbox; |
Pekka Paalanen | 730d87e | 2012-02-09 16:39:38 +0200 | [diff] [blame] | 453 | pixman_region32_t opaque; |
Pekka Paalanen | 6720d8f | 2012-01-25 15:17:40 +0200 | [diff] [blame] | 454 | |
Pekka Paalanen | bc0b7e7 | 2012-01-24 09:53:37 +0200 | [diff] [blame] | 455 | /* matrix and inverse are used only if enabled = 1. |
| 456 | * If enabled = 0, use x, y, width, height directly. |
| 457 | */ |
| 458 | int enabled; |
Pekka Paalanen | 061b747 | 2012-01-12 15:00:57 +0200 | [diff] [blame] | 459 | struct weston_matrix matrix; |
Pekka Paalanen | d1f0ab6 | 2012-01-20 10:47:57 +0200 | [diff] [blame] | 460 | struct weston_matrix inverse; |
Pekka Paalanen | cd40362 | 2012-01-25 13:37:39 +0200 | [diff] [blame] | 461 | |
| 462 | struct weston_transform position; /* matrix from x, y */ |
Pekka Paalanen | c61eca6 | 2012-01-06 14:10:06 +0200 | [diff] [blame] | 463 | } transform; |
| 464 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 465 | /* |
| 466 | * Which output to vsync this surface to. |
| 467 | * Used to determine, whether to send or queue frame events. |
| 468 | * Must be NULL, if 'link' is not in weston_compositor::surface_list. |
| 469 | */ |
| 470 | struct weston_output *output; |
| 471 | |
Casey Dahlin | 9074db5 | 2012-04-19 22:50:09 -0400 | [diff] [blame] | 472 | /* |
| 473 | * A more complete representation of all outputs this surface is |
| 474 | * displayed on. |
| 475 | */ |
| 476 | uint32_t output_mask; |
| 477 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 478 | struct wl_list frame_callback_list; |
| 479 | |
Pekka Paalanen | de685b8 | 2012-12-04 15:58:12 +0200 | [diff] [blame] | 480 | struct weston_buffer_reference buffer_ref; |
Ander Conselvan de Oliveira | 012b4c7 | 2012-11-27 17:03:42 +0200 | [diff] [blame] | 481 | uint32_t buffer_transform; |
Pekka Paalanen | ccfeae2 | 2012-12-04 15:58:14 +0200 | [diff] [blame] | 482 | int keep_buffer; /* bool for backends to prevent early release */ |
Alex Wu | 8811bf9 | 2012-02-28 18:07:54 +0800 | [diff] [blame] | 483 | |
Pekka Paalanen | 5df44de | 2012-10-10 12:49:23 +0300 | [diff] [blame] | 484 | /* All the pending state, that wl_surface.commit will apply. */ |
| 485 | struct { |
| 486 | /* wl_surface.attach */ |
Giulio Camuffo | 184df50 | 2013-02-21 11:29:21 +0100 | [diff] [blame] | 487 | int newly_attached; |
Pekka Paalanen | 5df44de | 2012-10-10 12:49:23 +0300 | [diff] [blame] | 488 | struct wl_buffer *buffer; |
| 489 | struct wl_listener buffer_destroy_listener; |
| 490 | int32_t sx; |
| 491 | int32_t sy; |
Pekka Paalanen | 8e15918 | 2012-10-10 12:49:25 +0300 | [diff] [blame] | 492 | |
| 493 | /* wl_surface.damage */ |
| 494 | pixman_region32_t damage; |
Pekka Paalanen | 512dde8 | 2012-10-10 12:49:27 +0300 | [diff] [blame] | 495 | |
| 496 | /* wl_surface.set_opaque_region */ |
| 497 | pixman_region32_t opaque; |
Pekka Paalanen | 0cbd3b5 | 2012-10-10 12:49:28 +0300 | [diff] [blame] | 498 | |
| 499 | /* wl_surface.set_input_region */ |
| 500 | pixman_region32_t input; |
Pekka Paalanen | bc10638 | 2012-10-10 12:49:31 +0300 | [diff] [blame] | 501 | |
| 502 | /* wl_surface.frame */ |
| 503 | struct wl_list frame_callback_list; |
Ander Conselvan de Oliveira | 012b4c7 | 2012-11-27 17:03:42 +0200 | [diff] [blame] | 504 | |
| 505 | /* wl_surface.set_buffer_transform */ |
| 506 | uint32_t buffer_transform; |
Pekka Paalanen | 5df44de | 2012-10-10 12:49:23 +0300 | [diff] [blame] | 507 | } pending; |
| 508 | |
Ander Conselvan de Oliveira | 093bfa3 | 2012-03-27 17:36:41 +0300 | [diff] [blame] | 509 | /* |
| 510 | * If non-NULL, this function will be called on surface::attach after |
| 511 | * a new buffer has been set up for this surface. The integer params |
| 512 | * are the sx and sy paramerters supplied to surface::attach . |
| 513 | */ |
Giulio Camuffo | 184df50 | 2013-02-21 11:29:21 +0100 | [diff] [blame] | 514 | void (*configure)(struct weston_surface *es, int32_t sx, int32_t sy, int32_t width, int32_t height); |
Giulio Camuffo | 7fe01b1 | 2013-03-28 18:02:42 +0100 | [diff] [blame] | 515 | void *configure_private; |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 516 | }; |
| 517 | |
Daniel Stone | d6da09e | 2012-06-22 13:21:29 +0100 | [diff] [blame] | 518 | enum weston_key_state_update { |
| 519 | STATE_UPDATE_AUTOMATIC, |
| 520 | STATE_UPDATE_NONE, |
| 521 | }; |
| 522 | |
Kristian Høgsberg | 9ddb826 | 2012-01-04 21:30:29 -0500 | [diff] [blame] | 523 | void |
Kristian Høgsberg | af4f2aa | 2013-02-15 20:53:20 -0500 | [diff] [blame] | 524 | weston_version(int *major, int *minor, int *micro); |
| 525 | |
| 526 | void |
Pekka Paalanen | 460099f | 2012-01-20 16:48:25 +0200 | [diff] [blame] | 527 | weston_surface_update_transform(struct weston_surface *surface); |
| 528 | |
| 529 | void |
Pekka Paalanen | c3ce738 | 2013-03-08 14:56:49 +0200 | [diff] [blame] | 530 | weston_surface_geometry_dirty(struct weston_surface *surface); |
| 531 | |
| 532 | void |
Daniel Stone | bd3489b | 2012-05-08 17:17:53 +0100 | [diff] [blame] | 533 | weston_surface_to_global_fixed(struct weston_surface *surface, |
| 534 | wl_fixed_t sx, wl_fixed_t sy, |
| 535 | wl_fixed_t *x, wl_fixed_t *y); |
| 536 | void |
Ander Conselvan de Oliveira | fbf2894 | 2012-03-27 17:36:37 +0300 | [diff] [blame] | 537 | weston_surface_to_global_float(struct weston_surface *surface, |
John Kåre Alsaker | 490d02a | 2012-09-30 02:57:21 +0200 | [diff] [blame] | 538 | float sx, float sy, float *x, float *y); |
Pekka Paalanen | e0f3cb2 | 2012-01-24 09:59:29 +0200 | [diff] [blame] | 539 | |
| 540 | void |
Kristian Høgsberg | ecf6ede | 2012-09-05 21:59:35 -0400 | [diff] [blame] | 541 | weston_surface_from_global_float(struct weston_surface *surface, |
John Kåre Alsaker | 490d02a | 2012-09-30 02:57:21 +0200 | [diff] [blame] | 542 | float x, float y, float *sx, float *sy); |
Kristian Høgsberg | ecf6ede | 2012-09-05 21:59:35 -0400 | [diff] [blame] | 543 | void |
Pekka Paalanen | e0f3cb2 | 2012-01-24 09:59:29 +0200 | [diff] [blame] | 544 | weston_surface_from_global(struct weston_surface *surface, |
| 545 | int32_t x, int32_t y, int32_t *sx, int32_t *sy); |
Daniel Stone | bd3489b | 2012-05-08 17:17:53 +0100 | [diff] [blame] | 546 | void |
| 547 | weston_surface_from_global_fixed(struct weston_surface *surface, |
| 548 | wl_fixed_t x, wl_fixed_t y, |
| 549 | wl_fixed_t *sx, wl_fixed_t *sy); |
Ander Conselvan de Oliveira | 012b4c7 | 2012-11-27 17:03:42 +0200 | [diff] [blame] | 550 | int32_t |
| 551 | weston_surface_buffer_width(struct weston_surface *surface); |
| 552 | int32_t |
| 553 | weston_surface_buffer_height(struct weston_surface *surface); |
Pekka Paalanen | e0f3cb2 | 2012-01-24 09:59:29 +0200 | [diff] [blame] | 554 | |
Ander Conselvan de Oliveira | 0396ba2 | 2012-11-28 17:10:26 +0200 | [diff] [blame] | 555 | WL_EXPORT void |
| 556 | weston_surface_to_buffer_float(struct weston_surface *surface, |
| 557 | float x, float y, float *bx, float *by); |
| 558 | pixman_box32_t |
| 559 | weston_surface_to_buffer_rect(struct weston_surface *surface, |
| 560 | pixman_box32_t rect); |
| 561 | |
Pekka Paalanen | e0f3cb2 | 2012-01-24 09:59:29 +0200 | [diff] [blame] | 562 | void |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 563 | weston_spring_init(struct weston_spring *spring, |
| 564 | double k, double current, double target); |
| 565 | void |
| 566 | weston_spring_update(struct weston_spring *spring, uint32_t msec); |
| 567 | int |
| 568 | weston_spring_done(struct weston_spring *spring); |
| 569 | |
| 570 | void |
| 571 | weston_surface_activate(struct weston_surface *surface, |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 572 | struct weston_seat *seat); |
Kristian Høgsberg | 68c479a | 2012-01-25 23:32:28 -0500 | [diff] [blame] | 573 | void |
Kristian Høgsberg | cb3eaae | 2012-08-10 09:50:11 -0400 | [diff] [blame] | 574 | notify_motion(struct weston_seat *seat, uint32_t time, |
Rob Bradford | c088e2c | 2013-03-27 15:59:43 +0000 | [diff] [blame] | 575 | wl_fixed_t dx, wl_fixed_t dy); |
| 576 | void |
| 577 | notify_motion_absolute(struct weston_seat *seat, uint32_t time, |
| 578 | wl_fixed_t x, wl_fixed_t y); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 579 | void |
Kristian Høgsberg | cb3eaae | 2012-08-10 09:50:11 -0400 | [diff] [blame] | 580 | notify_button(struct weston_seat *seat, uint32_t time, int32_t button, |
Daniel Stone | 4dbadb1 | 2012-05-30 16:31:51 +0100 | [diff] [blame] | 581 | enum wl_pointer_button_state state); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 582 | void |
Kristian Høgsberg | cb3eaae | 2012-08-10 09:50:11 -0400 | [diff] [blame] | 583 | notify_axis(struct weston_seat *seat, uint32_t time, uint32_t axis, |
Daniel Stone | 878f0b7 | 2012-05-30 16:31:57 +0100 | [diff] [blame] | 584 | wl_fixed_t value); |
Scott Moreau | 210d079 | 2012-03-22 10:47:01 -0600 | [diff] [blame] | 585 | void |
Kristian Høgsberg | cb3eaae | 2012-08-10 09:50:11 -0400 | [diff] [blame] | 586 | notify_key(struct weston_seat *seat, uint32_t time, uint32_t key, |
Daniel Stone | 1b4e11f | 2012-06-22 13:21:37 +0100 | [diff] [blame] | 587 | enum wl_keyboard_key_state state, |
| 588 | enum weston_key_state_update update_state); |
Daniel Stone | 05d5868 | 2012-06-22 13:21:38 +0100 | [diff] [blame] | 589 | void |
Kristian Høgsberg | cb3eaae | 2012-08-10 09:50:11 -0400 | [diff] [blame] | 590 | notify_modifiers(struct weston_seat *seat, uint32_t serial); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 591 | |
| 592 | void |
Kristian Høgsberg | cb3eaae | 2012-08-10 09:50:11 -0400 | [diff] [blame] | 593 | notify_pointer_focus(struct weston_seat *seat, struct weston_output *output, |
Kristian Høgsberg | e11bbe4 | 2012-05-09 12:19:04 -0400 | [diff] [blame] | 594 | wl_fixed_t x, wl_fixed_t y); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 595 | |
| 596 | void |
Kristian Høgsberg | cb3eaae | 2012-08-10 09:50:11 -0400 | [diff] [blame] | 597 | notify_keyboard_focus_in(struct weston_seat *seat, struct wl_array *keys, |
Daniel Stone | d6da09e | 2012-06-22 13:21:29 +0100 | [diff] [blame] | 598 | enum weston_key_state_update update_state); |
| 599 | void |
Kristian Høgsberg | cb3eaae | 2012-08-10 09:50:11 -0400 | [diff] [blame] | 600 | notify_keyboard_focus_out(struct weston_seat *seat); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 601 | |
| 602 | void |
Kristian Høgsberg | cb3eaae | 2012-08-10 09:50:11 -0400 | [diff] [blame] | 603 | notify_touch(struct weston_seat *seat, uint32_t time, int touch_id, |
Kristian Høgsberg | e11bbe4 | 2012-05-09 12:19:04 -0400 | [diff] [blame] | 604 | wl_fixed_t x, wl_fixed_t y, int touch_type); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 605 | |
| 606 | void |
Kristian Høgsberg | 3be2ce9 | 2012-02-29 12:42:35 -0500 | [diff] [blame] | 607 | weston_layer_init(struct weston_layer *layer, struct wl_list *below); |
| 608 | |
| 609 | void |
Kristian Høgsberg | 65a11e1 | 2012-08-03 11:30:18 -0400 | [diff] [blame] | 610 | weston_plane_init(struct weston_plane *plane, int32_t x, int32_t y); |
| 611 | void |
| 612 | weston_plane_release(struct weston_plane *plane); |
| 613 | |
| 614 | void |
Ander Conselvan de Oliveira | 8ad1982 | 2013-03-05 17:30:27 +0200 | [diff] [blame] | 615 | weston_compositor_stack_plane(struct weston_compositor *ec, |
| 616 | struct weston_plane *plane, |
| 617 | struct weston_plane *above); |
| 618 | |
| 619 | void |
Rob Bradford | 0fb7975 | 2012-08-02 15:36:57 +0100 | [diff] [blame] | 620 | weston_output_finish_frame(struct weston_output *output, uint32_t msecs); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 621 | void |
Kristian Høgsberg | 49952d1 | 2012-06-20 00:35:59 -0400 | [diff] [blame] | 622 | weston_output_schedule_repaint(struct weston_output *output); |
| 623 | void |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 624 | weston_output_damage(struct weston_output *output); |
| 625 | void |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 626 | weston_compositor_schedule_repaint(struct weston_compositor *compositor); |
| 627 | void |
| 628 | weston_compositor_fade(struct weston_compositor *compositor, float tint); |
| 629 | void |
| 630 | weston_compositor_damage_all(struct weston_compositor *compositor); |
| 631 | void |
| 632 | weston_compositor_unlock(struct weston_compositor *compositor); |
| 633 | void |
| 634 | weston_compositor_wake(struct weston_compositor *compositor); |
| 635 | void |
Philipp Brüschweiler | 57edf7f | 2013-03-29 13:01:56 +0100 | [diff] [blame] | 636 | weston_compositor_offscreen(struct weston_compositor *compositor); |
| 637 | void |
Ander Conselvan de Oliveira | 87524b6 | 2013-02-21 18:35:22 +0200 | [diff] [blame] | 638 | weston_compositor_sleep(struct weston_compositor *compositor); |
Ander Conselvan de Oliveira | 30eebc7 | 2012-02-15 17:02:57 +0200 | [diff] [blame] | 639 | void |
| 640 | weston_compositor_update_drag_surfaces(struct weston_compositor *compositor); |
| 641 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 642 | |
| 643 | struct weston_binding; |
Daniel Stone | 325fc2d | 2012-05-30 16:31:58 +0100 | [diff] [blame] | 644 | typedef void (*weston_key_binding_handler_t)(struct wl_seat *seat, |
| 645 | uint32_t time, uint32_t key, |
| 646 | void *data); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 647 | struct weston_binding * |
Daniel Stone | 325fc2d | 2012-05-30 16:31:58 +0100 | [diff] [blame] | 648 | weston_compositor_add_key_binding(struct weston_compositor *compositor, |
| 649 | uint32_t key, |
| 650 | enum weston_keyboard_modifier modifier, |
| 651 | weston_key_binding_handler_t binding, |
| 652 | void *data); |
| 653 | |
| 654 | typedef void (*weston_button_binding_handler_t)(struct wl_seat *seat, |
| 655 | uint32_t time, uint32_t button, |
| 656 | void *data); |
| 657 | struct weston_binding * |
| 658 | weston_compositor_add_button_binding(struct weston_compositor *compositor, |
| 659 | uint32_t button, |
| 660 | enum weston_keyboard_modifier modifier, |
| 661 | weston_button_binding_handler_t binding, |
| 662 | void *data); |
| 663 | |
| 664 | typedef void (*weston_axis_binding_handler_t)(struct wl_seat *seat, |
| 665 | uint32_t time, uint32_t axis, |
Daniel Stone | 0c1e46e | 2012-05-30 16:31:59 +0100 | [diff] [blame] | 666 | wl_fixed_t value, void *data); |
Daniel Stone | 325fc2d | 2012-05-30 16:31:58 +0100 | [diff] [blame] | 667 | struct weston_binding * |
| 668 | weston_compositor_add_axis_binding(struct weston_compositor *compositor, |
| 669 | uint32_t axis, |
| 670 | enum weston_keyboard_modifier modifier, |
| 671 | weston_axis_binding_handler_t binding, |
| 672 | void *data); |
Ander Conselvan de Oliveira | c509d2b | 2012-11-08 17:20:45 +0200 | [diff] [blame] | 673 | struct weston_binding * |
| 674 | weston_compositor_add_debug_binding(struct weston_compositor *compositor, |
| 675 | uint32_t key, |
| 676 | weston_key_binding_handler_t binding, |
| 677 | void *data); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 678 | void |
| 679 | weston_binding_destroy(struct weston_binding *binding); |
| 680 | |
| 681 | void |
Kristian Høgsberg | 3466bc8 | 2012-01-03 11:29:15 -0500 | [diff] [blame] | 682 | weston_binding_list_destroy_all(struct wl_list *list); |
| 683 | |
| 684 | void |
Daniel Stone | 325fc2d | 2012-05-30 16:31:58 +0100 | [diff] [blame] | 685 | weston_compositor_run_key_binding(struct weston_compositor *compositor, |
| 686 | struct weston_seat *seat, uint32_t time, |
| 687 | uint32_t key, |
| 688 | enum wl_keyboard_key_state state); |
| 689 | void |
| 690 | weston_compositor_run_button_binding(struct weston_compositor *compositor, |
| 691 | struct weston_seat *seat, uint32_t time, |
| 692 | uint32_t button, |
| 693 | enum wl_pointer_button_state value); |
Rune K. Svendsen | 14b2fe7 | 2013-03-07 21:50:00 +0100 | [diff] [blame] | 694 | int |
Daniel Stone | 325fc2d | 2012-05-30 16:31:58 +0100 | [diff] [blame] | 695 | weston_compositor_run_axis_binding(struct weston_compositor *compositor, |
| 696 | struct weston_seat *seat, uint32_t time, |
| 697 | uint32_t axis, int32_t value); |
Ander Conselvan de Oliveira | c509d2b | 2012-11-08 17:20:45 +0200 | [diff] [blame] | 698 | int |
| 699 | weston_compositor_run_debug_binding(struct weston_compositor *compositor, |
| 700 | struct weston_seat *seat, uint32_t time, |
| 701 | uint32_t key, |
| 702 | enum wl_keyboard_key_state state); |
Daniel Stone | 325fc2d | 2012-05-30 16:31:58 +0100 | [diff] [blame] | 703 | |
Benjamin Franzke | bfeda13 | 2012-01-30 14:04:04 +0100 | [diff] [blame] | 704 | int |
| 705 | weston_environment_get_fd(const char *env); |
| 706 | |
Kristian Høgsberg | a82c486 | 2012-01-26 01:03:58 -0500 | [diff] [blame] | 707 | struct wl_list * |
| 708 | weston_compositor_top(struct weston_compositor *compositor); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 709 | |
| 710 | struct weston_surface * |
Kristian Høgsberg | 18c9300 | 2012-01-27 11:58:31 -0500 | [diff] [blame] | 711 | weston_surface_create(struct weston_compositor *compositor); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 712 | |
| 713 | void |
| 714 | weston_surface_configure(struct weston_surface *surface, |
John Kåre Alsaker | 490d02a | 2012-09-30 02:57:21 +0200 | [diff] [blame] | 715 | float x, float y, int width, int height); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 716 | |
| 717 | void |
Kristian Høgsberg | 3be2ce9 | 2012-02-29 12:42:35 -0500 | [diff] [blame] | 718 | weston_surface_restack(struct weston_surface *surface, struct wl_list *below); |
| 719 | |
| 720 | void |
Pekka Paalanen | 8fb8d3b | 2012-02-13 13:03:59 +0200 | [diff] [blame] | 721 | weston_surface_set_position(struct weston_surface *surface, |
John Kåre Alsaker | 490d02a | 2012-09-30 02:57:21 +0200 | [diff] [blame] | 722 | float x, float y); |
Pekka Paalanen | 8fb8d3b | 2012-02-13 13:03:59 +0200 | [diff] [blame] | 723 | |
Pekka Paalanen | 483243f | 2013-03-08 14:56:50 +0200 | [diff] [blame] | 724 | void |
| 725 | weston_surface_set_transform_parent(struct weston_surface *surface, |
| 726 | struct weston_surface *parent); |
| 727 | |
Ander Conselvan de Oliveira | b8ab14f | 2012-03-27 17:36:36 +0300 | [diff] [blame] | 728 | int |
| 729 | weston_surface_is_mapped(struct weston_surface *surface); |
| 730 | |
Pekka Paalanen | 8fb8d3b | 2012-02-13 13:03:59 +0200 | [diff] [blame] | 731 | void |
Kristian Høgsberg | 9823870 | 2012-08-03 16:29:12 -0400 | [diff] [blame] | 732 | weston_surface_schedule_repaint(struct weston_surface *surface); |
| 733 | |
| 734 | void |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 735 | weston_surface_damage(struct weston_surface *surface); |
| 736 | |
| 737 | void |
Kristian Høgsberg | d8bf90c | 2012-02-23 23:03:14 -0500 | [diff] [blame] | 738 | weston_surface_damage_below(struct weston_surface *surface); |
| 739 | |
| 740 | void |
Kristian Høgsberg | 65a11e1 | 2012-08-03 11:30:18 -0400 | [diff] [blame] | 741 | weston_surface_move_to_plane(struct weston_surface *surface, |
| 742 | struct weston_plane *plane); |
| 743 | void |
Kristian Høgsberg | af7b1ff | 2012-06-26 21:19:23 -0400 | [diff] [blame] | 744 | weston_surface_unmap(struct weston_surface *surface); |
| 745 | |
| 746 | void |
Pekka Paalanen | de685b8 | 2012-12-04 15:58:12 +0200 | [diff] [blame] | 747 | weston_buffer_reference(struct weston_buffer_reference *ref, |
| 748 | struct wl_buffer *buffer); |
| 749 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 750 | uint32_t |
| 751 | weston_compositor_get_time(void); |
| 752 | |
| 753 | int |
Daniel Stone | baf4359 | 2012-06-01 11:11:10 -0400 | [diff] [blame] | 754 | weston_compositor_init(struct weston_compositor *ec, struct wl_display *display, |
Kristian Høgsberg | 4172f66 | 2013-02-20 15:27:49 -0500 | [diff] [blame] | 755 | int *argc, char *argv[], const char *config_file); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 756 | void |
| 757 | weston_compositor_shutdown(struct weston_compositor *ec); |
| 758 | void |
Scott Moreau | ae71220 | 2012-06-01 12:46:09 -0600 | [diff] [blame] | 759 | weston_text_cursor_position_notify(struct weston_surface *surface, |
| 760 | wl_fixed_t x, wl_fixed_t y); |
Scott Moreau | 7a1b32a | 2012-05-27 14:25:02 -0600 | [diff] [blame] | 761 | void |
Scott Moreau | 429490d | 2012-06-17 18:10:59 -0600 | [diff] [blame] | 762 | weston_output_init_zoom(struct weston_output *output); |
| 763 | void |
Scott Moreau | 8dacaab | 2012-06-17 18:10:58 -0600 | [diff] [blame] | 764 | weston_output_update_zoom(struct weston_output *output, uint32_t type); |
Scott Moreau | ccbf29d | 2012-02-22 14:21:41 -0700 | [diff] [blame] | 765 | void |
| 766 | weston_output_update_matrix(struct weston_output *output); |
| 767 | void |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 768 | weston_output_move(struct weston_output *output, int x, int y); |
| 769 | void |
| 770 | weston_output_init(struct weston_output *output, struct weston_compositor *c, |
Scott Moreau | 1bad5db | 2012-08-18 01:04:05 -0600 | [diff] [blame] | 771 | int x, int y, int width, int height, uint32_t transform); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 772 | void |
| 773 | weston_output_destroy(struct weston_output *output); |
| 774 | |
| 775 | void |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 776 | weston_seat_init(struct weston_seat *seat, struct weston_compositor *ec); |
Daniel Stone | 74419a2 | 2012-05-30 16:32:02 +0100 | [diff] [blame] | 777 | void |
| 778 | weston_seat_init_pointer(struct weston_seat *seat); |
Kristian Høgsberg | 2f07ef6 | 2013-02-16 14:29:24 -0500 | [diff] [blame] | 779 | int |
Daniel Stone | bb1df6a | 2012-05-30 16:32:06 +0100 | [diff] [blame] | 780 | weston_seat_init_keyboard(struct weston_seat *seat, struct xkb_keymap *keymap); |
Daniel Stone | 74419a2 | 2012-05-30 16:32:02 +0100 | [diff] [blame] | 781 | void |
| 782 | weston_seat_init_touch(struct weston_seat *seat); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 783 | |
| 784 | void |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 785 | weston_seat_release(struct weston_seat *seat); |
Kristian Høgsberg | 3466bc8 | 2012-01-03 11:29:15 -0500 | [diff] [blame] | 786 | |
Kristian Høgsberg | 64eca89 | 2012-08-01 00:00:57 -0400 | [diff] [blame] | 787 | /* String literal of spaces, the same width as the timestamp. */ |
| 788 | #define STAMP_SPACE " " |
| 789 | |
| 790 | void |
| 791 | weston_log_file_open(const char *filename); |
| 792 | void |
| 793 | weston_log_file_close(void); |
| 794 | int |
Pekka Paalanen | d525b56 | 2012-08-06 14:57:04 +0300 | [diff] [blame] | 795 | weston_log(const char *fmt, ...) |
| 796 | __attribute__ ((format (printf, 1, 2))); |
Kristian Høgsberg | 64eca89 | 2012-08-01 00:00:57 -0400 | [diff] [blame] | 797 | int |
Pekka Paalanen | d525b56 | 2012-08-06 14:57:04 +0300 | [diff] [blame] | 798 | weston_log_continue(const char *fmt, ...) |
| 799 | __attribute__ ((format (printf, 1, 2))); |
Kristian Høgsberg | 64eca89 | 2012-08-01 00:00:57 -0400 | [diff] [blame] | 800 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 801 | enum { |
| 802 | TTY_ENTER_VT, |
| 803 | TTY_LEAVE_VT |
| 804 | }; |
| 805 | |
| 806 | typedef void (*tty_vt_func_t)(struct weston_compositor *compositor, int event); |
| 807 | |
| 808 | struct tty * |
| 809 | tty_create(struct weston_compositor *compositor, |
| 810 | tty_vt_func_t vt_func, int tty_nr); |
| 811 | |
| 812 | void |
| 813 | tty_destroy(struct tty *tty); |
| 814 | |
Kristian Høgsberg | 7b884bc | 2012-07-31 14:32:01 -0400 | [diff] [blame] | 815 | void |
| 816 | tty_reset(struct tty *tty); |
| 817 | |
Kristian Høgsberg | 5d1c0c5 | 2012-04-10 00:11:50 -0400 | [diff] [blame] | 818 | int |
| 819 | tty_activate_vt(struct tty *tty, int vt); |
| 820 | |
Kristian Høgsberg | 3466bc8 | 2012-01-03 11:29:15 -0500 | [diff] [blame] | 821 | void |
Kristian Høgsberg | 02e79dc | 2012-04-12 09:55:26 -0400 | [diff] [blame] | 822 | screenshooter_create(struct weston_compositor *ec); |
Kristian Høgsberg | 3466bc8 | 2012-01-03 11:29:15 -0500 | [diff] [blame] | 823 | |
Kristian Høgsberg | a7ceaff | 2012-06-03 10:20:13 -0400 | [diff] [blame] | 824 | struct clipboard * |
| 825 | clipboard_create(struct weston_seat *seat); |
| 826 | |
Scott Moreau | 7a1b32a | 2012-05-27 14:25:02 -0600 | [diff] [blame] | 827 | void |
| 828 | text_cursor_position_notifier_create(struct weston_compositor *ec); |
| 829 | |
Jan Arne Petersen | 674fd1d | 2012-11-18 19:06:42 +0100 | [diff] [blame] | 830 | int |
| 831 | text_backend_init(struct weston_compositor *ec); |
Jan Arne Petersen | 1f17be4 | 2012-06-21 21:52:18 +0200 | [diff] [blame] | 832 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 833 | struct weston_process; |
| 834 | typedef void (*weston_process_cleanup_func_t)(struct weston_process *process, |
| 835 | int status); |
| 836 | |
| 837 | struct weston_process { |
| 838 | pid_t pid; |
| 839 | weston_process_cleanup_func_t cleanup; |
| 840 | struct wl_list link; |
| 841 | }; |
| 842 | |
| 843 | struct wl_client * |
| 844 | weston_client_launch(struct weston_compositor *compositor, |
| 845 | struct weston_process *proc, |
| 846 | const char *path, |
| 847 | weston_process_cleanup_func_t cleanup); |
| 848 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 849 | void |
| 850 | weston_watch_process(struct weston_process *process); |
| 851 | |
Kristian Høgsberg | 414bd42 | 2012-06-21 22:07:30 -0400 | [diff] [blame] | 852 | struct weston_surface_animation; |
| 853 | typedef void (*weston_surface_animation_done_func_t)(struct weston_surface_animation *animation, void *data); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 854 | |
Kristian Høgsberg | 414bd42 | 2012-06-21 22:07:30 -0400 | [diff] [blame] | 855 | struct weston_surface_animation * |
John Kåre Alsaker | 490d02a | 2012-09-30 02:57:21 +0200 | [diff] [blame] | 856 | weston_zoom_run(struct weston_surface *surface, float start, float stop, |
Kristian Høgsberg | 414bd42 | 2012-06-21 22:07:30 -0400 | [diff] [blame] | 857 | weston_surface_animation_done_func_t done, void *data); |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 858 | |
Kristian Høgsberg | 414bd42 | 2012-06-21 22:07:30 -0400 | [diff] [blame] | 859 | struct weston_surface_animation * |
Juan Zhao | e10d279 | 2012-04-25 19:09:52 +0800 | [diff] [blame] | 860 | weston_fade_run(struct weston_surface *surface, |
Ander Conselvan de Oliveira | ee41605 | 2013-02-21 18:35:17 +0200 | [diff] [blame] | 861 | float start, float end, float k, |
Kristian Høgsberg | 414bd42 | 2012-06-21 22:07:30 -0400 | [diff] [blame] | 862 | weston_surface_animation_done_func_t done, void *data); |
Ander Conselvan de Oliveira | ee41605 | 2013-02-21 18:35:17 +0200 | [diff] [blame] | 863 | void |
| 864 | weston_fade_update(struct weston_surface_animation *fade, |
| 865 | float start, float end, float k); |
| 866 | |
Kristian Høgsberg | 1ce6a2a | 2012-06-21 22:34:39 -0400 | [diff] [blame] | 867 | struct weston_surface_animation * |
John Kåre Alsaker | 490d02a | 2012-09-30 02:57:21 +0200 | [diff] [blame] | 868 | weston_slide_run(struct weston_surface *surface, float start, float stop, |
Kristian Høgsberg | 1ce6a2a | 2012-06-21 22:34:39 -0400 | [diff] [blame] | 869 | weston_surface_animation_done_func_t done, void *data); |
Juan Zhao | e10d279 | 2012-04-25 19:09:52 +0800 | [diff] [blame] | 870 | |
Alex Wu | 8811bf9 | 2012-02-28 18:07:54 +0800 | [diff] [blame] | 871 | void |
| 872 | weston_surface_set_color(struct weston_surface *surface, |
John Kåre Alsaker | 490d02a | 2012-09-30 02:57:21 +0200 | [diff] [blame] | 873 | float red, float green, float blue, float alpha); |
Alex Wu | 8811bf9 | 2012-02-28 18:07:54 +0800 | [diff] [blame] | 874 | |
| 875 | void |
| 876 | weston_surface_destroy(struct weston_surface *surface); |
| 877 | |
Alex Wu | 2dda604 | 2012-04-17 17:20:47 +0800 | [diff] [blame] | 878 | int |
| 879 | weston_output_switch_mode(struct weston_output *output, struct weston_mode *mode); |
| 880 | |
Ander Conselvan de Oliveira | 11f8d40 | 2012-10-29 18:19:24 +0200 | [diff] [blame] | 881 | int |
| 882 | noop_renderer_init(struct weston_compositor *ec); |
Ander Conselvan de Oliveira | 11f8d40 | 2012-10-29 18:19:24 +0200 | [diff] [blame] | 883 | |
Kristian Høgsberg | b00a9d3 | 2012-09-11 14:06:27 -0400 | [diff] [blame] | 884 | struct weston_compositor * |
Kristian Høgsberg | 4172f66 | 2013-02-20 15:27:49 -0500 | [diff] [blame] | 885 | backend_init(struct wl_display *display, int *argc, char *argv[], |
| 886 | const char *config_file); |
Kristian Høgsberg | b00a9d3 | 2012-09-11 14:06:27 -0400 | [diff] [blame] | 887 | |
| 888 | int |
Kristian Høgsberg | cb4685b | 2013-02-20 15:37:49 -0500 | [diff] [blame] | 889 | module_init(struct weston_compositor *compositor, |
| 890 | int *argc, char *argv[], const char *config_file); |
Kristian Høgsberg | b00a9d3 | 2012-09-11 14:06:27 -0400 | [diff] [blame] | 891 | |
Ander Conselvan de Oliveira | 409eebf | 2012-12-05 15:14:04 +0200 | [diff] [blame] | 892 | void |
| 893 | weston_transformed_coord(int width, int height, |
| 894 | enum wl_output_transform transform, |
| 895 | float sx, float sy, float *bx, float *by); |
| 896 | pixman_box32_t |
| 897 | weston_transformed_rect(int width, int height, |
| 898 | enum wl_output_transform transform, |
| 899 | pixman_box32_t rect); |
| 900 | |
Giulio Camuffo | 7fe01b1 | 2013-03-28 18:02:42 +0100 | [diff] [blame] | 901 | #ifdef __cplusplus |
| 902 | } |
| 903 | #endif |
| 904 | |
Kristian Høgsberg | 8334bc1 | 2012-01-03 10:29:47 -0500 | [diff] [blame] | 905 | #endif |