Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 1 | /* |
| 2 | * Copyright © 2008 Kristian Høgsberg |
| 3 | * |
| 4 | * Permission to use, copy, modify, distribute, and sell this software and its |
| 5 | * documentation for any purpose is hereby granted without fee, provided that |
| 6 | * the above copyright notice appear in all copies and that both that copyright |
| 7 | * notice and this permission notice appear in supporting documentation, and |
| 8 | * that the name of the copyright holders not be used in advertising or |
| 9 | * publicity pertaining to distribution of the software without specific, |
| 10 | * written prior permission. The copyright holders make no representations |
| 11 | * about the suitability of this software for any purpose. It is provided "as |
| 12 | * is" without express or implied warranty. |
| 13 | * |
| 14 | * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, |
| 15 | * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO |
| 16 | * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR |
| 17 | * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, |
| 18 | * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER |
| 19 | * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE |
| 20 | * OF THIS SOFTWARE. |
| 21 | */ |
| 22 | |
| 23 | #ifndef _WINDOW_H_ |
| 24 | #define _WINDOW_H_ |
| 25 | |
Daniel Stone | 9d4f030 | 2012-02-15 16:33:21 +0000 | [diff] [blame] | 26 | #include <xkbcommon/xkbcommon.h> |
Fred Morcos | c4b8c45 | 2010-11-28 19:31:55 +0100 | [diff] [blame] | 27 | #include <wayland-client.h> |
Benjamin Franzke | cff904e | 2011-02-18 23:00:55 +0100 | [diff] [blame] | 28 | #include <cairo.h> |
Kristian Høgsberg | bcacef1 | 2012-03-11 21:05:57 -0400 | [diff] [blame] | 29 | #include "../shared/config-parser.h" |
Fred Morcos | c4b8c45 | 2010-11-28 19:31:55 +0100 | [diff] [blame] | 30 | |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 31 | struct window; |
Kristian Høgsberg | c51f799 | 2012-01-08 15:09:53 -0500 | [diff] [blame] | 32 | struct widget; |
Kristian Høgsberg | e28d05b | 2011-09-20 21:43:54 -0400 | [diff] [blame] | 33 | struct display; |
| 34 | struct input; |
Kristian Høgsberg | 53ff2f6 | 2011-11-26 17:27:37 -0500 | [diff] [blame] | 35 | struct output; |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 36 | |
Kristian Høgsberg | 3a69627 | 2011-09-14 17:33:48 -0400 | [diff] [blame] | 37 | struct task { |
| 38 | void (*run)(struct task *task, uint32_t events); |
| 39 | struct wl_list link; |
| 40 | }; |
| 41 | |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 42 | struct rectangle { |
| 43 | int32_t x; |
| 44 | int32_t y; |
| 45 | int32_t width; |
| 46 | int32_t height; |
| 47 | }; |
| 48 | |
Kristian Høgsberg | 43c28ee | 2009-01-26 23:42:46 -0500 | [diff] [blame] | 49 | struct display * |
Kristian Høgsberg | bcacef1 | 2012-03-11 21:05:57 -0400 | [diff] [blame] | 50 | display_create(int argc, char *argv[]); |
Kristian Høgsberg | 7824d81 | 2010-06-08 14:59:44 -0400 | [diff] [blame] | 51 | |
Pekka Paalanen | 999c5b5 | 2011-11-30 10:52:38 +0200 | [diff] [blame] | 52 | void |
Pekka Paalanen | fe6079a | 2011-12-15 15:20:04 +0200 | [diff] [blame] | 53 | display_destroy(struct display *display); |
| 54 | |
| 55 | void |
Pekka Paalanen | 999c5b5 | 2011-11-30 10:52:38 +0200 | [diff] [blame] | 56 | display_set_user_data(struct display *display, void *data); |
| 57 | |
| 58 | void * |
| 59 | display_get_user_data(struct display *display); |
| 60 | |
Kristian Høgsberg | 9d69f8e | 2010-09-03 14:46:38 -0400 | [diff] [blame] | 61 | struct wl_display * |
| 62 | display_get_display(struct display *display); |
| 63 | |
Kristian Høgsberg | 43c28ee | 2009-01-26 23:42:46 -0500 | [diff] [blame] | 64 | struct wl_compositor * |
| 65 | display_get_compositor(struct display *display); |
| 66 | |
Kristian Høgsberg | 58eec36 | 2011-01-19 14:27:42 -0500 | [diff] [blame] | 67 | struct wl_shell * |
| 68 | display_get_shell(struct display *display); |
| 69 | |
Kristian Høgsberg | 53ff2f6 | 2011-11-26 17:27:37 -0500 | [diff] [blame] | 70 | struct output * |
| 71 | display_get_output(struct display *display); |
| 72 | |
Kristian Høgsberg | eae5de7 | 2012-04-11 22:42:15 -0400 | [diff] [blame] | 73 | uint32_t |
| 74 | display_get_serial(struct display *display); |
| 75 | |
Pekka Paalanen | 999c5b5 | 2011-11-30 10:52:38 +0200 | [diff] [blame] | 76 | typedef void (*display_output_handler_t)(struct output *output, void *data); |
| 77 | |
| 78 | /* |
| 79 | * The output configure handler is called, when a new output is connected |
| 80 | * and we know its current mode, or when the current mode changes. |
| 81 | * Test and set the output user data in your handler to know, if the |
| 82 | * output is new. Note: 'data' in the configure handler is the display |
| 83 | * user data. |
| 84 | */ |
| 85 | void |
| 86 | display_set_output_configure_handler(struct display *display, |
| 87 | display_output_handler_t handler); |
| 88 | |
Kristian Høgsberg | 47fe08a | 2011-10-28 12:26:06 -0400 | [diff] [blame] | 89 | struct wl_data_source * |
| 90 | display_create_data_source(struct display *display); |
| 91 | |
Kristian Høgsberg | 7824d81 | 2010-06-08 14:59:44 -0400 | [diff] [blame] | 92 | #ifdef EGL_NO_DISPLAY |
| 93 | EGLDisplay |
| 94 | display_get_egl_display(struct display *d); |
Kristian Høgsberg | 2b43bd7 | 2010-11-08 15:45:55 -0500 | [diff] [blame] | 95 | |
Benjamin Franzke | cff904e | 2011-02-18 23:00:55 +0100 | [diff] [blame] | 96 | EGLConfig |
Benjamin Franzke | 0c99163 | 2011-09-27 21:57:31 +0200 | [diff] [blame] | 97 | display_get_argb_egl_config(struct display *d); |
Benjamin Franzke | cff904e | 2011-02-18 23:00:55 +0100 | [diff] [blame] | 98 | |
Benjamin Franzke | 1a89f28 | 2011-10-07 09:33:06 +0200 | [diff] [blame] | 99 | int |
Benjamin Franzke | cff904e | 2011-02-18 23:00:55 +0100 | [diff] [blame] | 100 | display_acquire_window_surface(struct display *display, |
| 101 | struct window *window, |
| 102 | EGLContext ctx); |
| 103 | void |
Benjamin Franzke | 0c99163 | 2011-09-27 21:57:31 +0200 | [diff] [blame] | 104 | display_release_window_surface(struct display *display, |
| 105 | struct window *window); |
Benjamin Franzke | cff904e | 2011-02-18 23:00:55 +0100 | [diff] [blame] | 106 | |
Kristian Høgsberg | 8def264 | 2011-01-14 17:41:33 -0500 | [diff] [blame] | 107 | #ifdef HAVE_CAIRO_EGL |
Kristian Høgsberg | 2b43bd7 | 2010-11-08 15:45:55 -0500 | [diff] [blame] | 108 | EGLImageKHR |
Kristian Høgsberg | 297c631 | 2011-02-04 14:11:33 -0500 | [diff] [blame] | 109 | display_get_image_for_egl_image_surface(struct display *display, |
| 110 | cairo_surface_t *surface); |
Kristian Høgsberg | 7824d81 | 2010-06-08 14:59:44 -0400 | [diff] [blame] | 111 | #endif |
nobled | 9835417 | 2011-01-05 17:48:15 +0000 | [diff] [blame] | 112 | #endif |
Kristian Høgsberg | 7824d81 | 2010-06-08 14:59:44 -0400 | [diff] [blame] | 113 | |
Kristian Høgsberg | 3be87d1 | 2011-05-13 13:45:17 -0400 | [diff] [blame] | 114 | #define SURFACE_OPAQUE 0x01 |
Ander Conselvan de Oliveira | 210eb9d | 2012-05-25 16:03:06 +0300 | [diff] [blame] | 115 | #define SURFACE_SHM 0x02 |
Kristian Høgsberg | 3be87d1 | 2011-05-13 13:45:17 -0400 | [diff] [blame] | 116 | |
Kristian Høgsberg | dcb71b6 | 2010-06-15 17:16:35 -0400 | [diff] [blame] | 117 | cairo_surface_t * |
| 118 | display_create_surface(struct display *display, |
Benjamin Franzke | 6693ac2 | 2011-02-10 12:04:30 +0100 | [diff] [blame] | 119 | struct wl_surface *surface, |
Kristian Høgsberg | 3be87d1 | 2011-05-13 13:45:17 -0400 | [diff] [blame] | 120 | struct rectangle *rectangle, |
| 121 | uint32_t flags); |
Kristian Høgsberg | dcb71b6 | 2010-06-15 17:16:35 -0400 | [diff] [blame] | 122 | |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame] | 123 | struct wl_buffer * |
| 124 | display_get_buffer_for_surface(struct display *display, |
| 125 | cairo_surface_t *surface); |
| 126 | |
Ander Conselvan de Oliveira | 1042dc1 | 2012-05-22 15:39:42 +0300 | [diff] [blame] | 127 | struct wl_cursor_image * |
| 128 | display_get_pointer_image(struct display *display, int pointer); |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame] | 129 | |
Kristian Høgsberg | 7824d81 | 2010-06-08 14:59:44 -0400 | [diff] [blame] | 130 | void |
Kristian Høgsberg | 3a69627 | 2011-09-14 17:33:48 -0400 | [diff] [blame] | 131 | display_defer(struct display *display, struct task *task); |
| 132 | |
| 133 | void |
| 134 | display_watch_fd(struct display *display, |
| 135 | int fd, uint32_t events, struct task *task); |
| 136 | |
| 137 | void |
Kristian Høgsberg | 7824d81 | 2010-06-08 14:59:44 -0400 | [diff] [blame] | 138 | display_run(struct display *d); |
| 139 | |
Pekka Paalanen | 826d795 | 2011-12-15 10:14:07 +0200 | [diff] [blame] | 140 | void |
| 141 | display_exit(struct display *d); |
| 142 | |
Ander Conselvan de Oliveira | dc8c8fc | 2012-05-25 16:01:41 +0300 | [diff] [blame] | 143 | enum cursor_type { |
| 144 | CURSOR_BOTTOM_LEFT, |
| 145 | CURSOR_BOTTOM_RIGHT, |
| 146 | CURSOR_BOTTOM, |
| 147 | CURSOR_DRAGGING, |
| 148 | CURSOR_LEFT_PTR, |
| 149 | CURSOR_LEFT, |
| 150 | CURSOR_RIGHT, |
| 151 | CURSOR_TOP_LEFT, |
| 152 | CURSOR_TOP_RIGHT, |
| 153 | CURSOR_TOP, |
| 154 | CURSOR_IBEAM, |
| 155 | CURSOR_HAND1, |
Kristian Høgsberg | f337052 | 2012-06-20 23:04:41 -0400 | [diff] [blame] | 156 | CURSOR_WATCH, |
| 157 | |
| 158 | CURSOR_BLANK |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame] | 159 | }; |
| 160 | |
Kristian Høgsberg | 67cac8a | 2011-01-19 14:20:33 -0500 | [diff] [blame] | 161 | typedef void (*window_key_handler_t)(struct window *window, struct input *input, |
| 162 | uint32_t time, uint32_t key, uint32_t unicode, |
Daniel Stone | c9785ea | 2012-05-30 16:31:52 +0100 | [diff] [blame] | 163 | enum wl_keyboard_key_state state, void *data); |
Tim Wiederhake | dc3f817 | 2011-01-17 17:25:34 +0100 | [diff] [blame] | 164 | |
Kristian Høgsberg | 3c248cc | 2009-02-22 23:01:35 -0500 | [diff] [blame] | 165 | typedef void (*window_keyboard_focus_handler_t)(struct window *window, |
Kristian Høgsberg | 808fd41 | 2010-07-20 17:06:19 -0400 | [diff] [blame] | 166 | struct input *device, void *data); |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 167 | |
Kristian Høgsberg | 47fe08a | 2011-10-28 12:26:06 -0400 | [diff] [blame] | 168 | typedef void (*window_data_handler_t)(struct window *window, |
Kristian Høgsberg | eae5de7 | 2012-04-11 22:42:15 -0400 | [diff] [blame] | 169 | struct input *input, |
Kristian Høgsberg | 80680c7 | 2012-05-10 12:21:37 -0400 | [diff] [blame] | 170 | float x, float y, |
Kristian Høgsberg | 47fe08a | 2011-10-28 12:26:06 -0400 | [diff] [blame] | 171 | const char **types, |
| 172 | void *data); |
| 173 | |
| 174 | typedef void (*window_drop_handler_t)(struct window *window, |
| 175 | struct input *input, |
| 176 | int32_t x, int32_t y, void *data); |
| 177 | |
Kristian Høgsberg | 4f7dcd6 | 2012-01-06 21:59:05 -0500 | [diff] [blame] | 178 | typedef void (*window_close_handler_t)(struct window *window, void *data); |
| 179 | |
Kristian Høgsberg | b67e94b | 2012-01-10 12:23:19 -0500 | [diff] [blame] | 180 | typedef void (*widget_resize_handler_t)(struct widget *widget, |
| 181 | int32_t width, int32_t height, |
| 182 | void *data); |
| 183 | typedef void (*widget_redraw_handler_t)(struct widget *widget, void *data); |
| 184 | |
Kristian Høgsberg | bb901fa | 2012-01-09 11:22:32 -0500 | [diff] [blame] | 185 | typedef int (*widget_enter_handler_t)(struct widget *widget, |
Kristian Høgsberg | eae5de7 | 2012-04-11 22:42:15 -0400 | [diff] [blame] | 186 | struct input *input, |
Kristian Høgsberg | 80680c7 | 2012-05-10 12:21:37 -0400 | [diff] [blame] | 187 | float x, float y, void *data); |
Kristian Høgsberg | ee14323 | 2012-01-09 08:42:24 -0500 | [diff] [blame] | 188 | typedef void (*widget_leave_handler_t)(struct widget *widget, |
| 189 | struct input *input, void *data); |
Kristian Høgsberg | 04e9834 | 2012-01-09 09:36:16 -0500 | [diff] [blame] | 190 | typedef int (*widget_motion_handler_t)(struct widget *widget, |
| 191 | struct input *input, uint32_t time, |
Kristian Høgsberg | 80680c7 | 2012-05-10 12:21:37 -0400 | [diff] [blame] | 192 | float x, float y, void *data); |
Kristian Høgsberg | a8a0db3 | 2012-01-09 11:12:05 -0500 | [diff] [blame] | 193 | typedef void (*widget_button_handler_t)(struct widget *widget, |
| 194 | struct input *input, uint32_t time, |
Daniel Stone | 4dbadb1 | 2012-05-30 16:31:51 +0100 | [diff] [blame] | 195 | uint32_t button, |
| 196 | enum wl_pointer_button_state state, |
Daniel Stone | da5b93c | 2012-05-04 11:21:54 +0100 | [diff] [blame] | 197 | void *data); |
Kristian Høgsberg | ee14323 | 2012-01-09 08:42:24 -0500 | [diff] [blame] | 198 | |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 199 | struct window * |
Kristian Høgsberg | 009ac0a | 2012-01-31 15:24:48 -0500 | [diff] [blame] | 200 | window_create(struct display *display); |
Kristian Høgsberg | 248c1b6 | 2011-01-21 18:03:15 -0500 | [diff] [blame] | 201 | struct window * |
| 202 | window_create_transient(struct display *display, struct window *parent, |
Tiago Vignatti | dec7658 | 2012-05-21 16:47:46 +0300 | [diff] [blame] | 203 | int32_t x, int32_t y, uint32_t flags); |
Kristian Høgsberg | 962342c | 2012-06-26 16:29:50 -0400 | [diff] [blame^] | 204 | struct window * |
| 205 | window_create_custom(struct display *display); |
Kristian Høgsberg | 4f7dcd6 | 2012-01-06 21:59:05 -0500 | [diff] [blame] | 206 | |
| 207 | typedef void (*menu_func_t)(struct window *window, int index, void *data); |
| 208 | |
Pekka Paalanen | 6d174cf | 2012-01-19 15:17:59 +0200 | [diff] [blame] | 209 | void |
| 210 | window_show_menu(struct display *display, |
| 211 | struct input *input, uint32_t time, struct window *parent, |
| 212 | int32_t x, int32_t y, |
| 213 | menu_func_t func, const char **entries, int count); |
Kristian Høgsberg | 248c1b6 | 2011-01-21 18:03:15 -0500 | [diff] [blame] | 214 | |
| 215 | void |
Kristian Høgsberg | d31fcab | 2012-01-31 09:53:44 -0500 | [diff] [blame] | 216 | window_show_frame_menu(struct window *window, |
| 217 | struct input *input, uint32_t time); |
| 218 | |
| 219 | void |
Kristian Høgsberg | 248c1b6 | 2011-01-21 18:03:15 -0500 | [diff] [blame] | 220 | window_destroy(struct window *window); |
| 221 | |
Kristian Høgsberg | c51f799 | 2012-01-08 15:09:53 -0500 | [diff] [blame] | 222 | struct widget * |
| 223 | window_add_widget(struct window *window, void *data); |
Kristian Høgsberg | e28d05b | 2011-09-20 21:43:54 -0400 | [diff] [blame] | 224 | |
Kristian Høgsberg | 47fe08a | 2011-10-28 12:26:06 -0400 | [diff] [blame] | 225 | typedef void (*data_func_t)(void *data, size_t len, |
| 226 | int32_t x, int32_t y, void *user_data); |
| 227 | |
Kristian Høgsberg | bcee9a4 | 2011-10-12 00:36:16 -0400 | [diff] [blame] | 228 | struct display * |
| 229 | window_get_display(struct window *window); |
Kristian Høgsberg | 248c1b6 | 2011-01-21 18:03:15 -0500 | [diff] [blame] | 230 | void |
Kristian Høgsberg | 82da52b | 2010-12-17 09:53:12 -0500 | [diff] [blame] | 231 | window_move(struct window *window, struct input *input, uint32_t time); |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 232 | void |
Kristian Høgsberg | bb97700 | 2012-01-10 19:11:42 -0500 | [diff] [blame] | 233 | window_get_allocation(struct window *window, struct rectangle *allocation); |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 234 | void |
Kristian Høgsberg | 3be87d1 | 2011-05-13 13:45:17 -0400 | [diff] [blame] | 235 | window_set_transparent(struct window *window, int transparent); |
| 236 | void |
Kristian Høgsberg | 80d746f | 2010-06-14 23:52:50 -0400 | [diff] [blame] | 237 | window_schedule_redraw(struct window *window); |
Kristian Høgsberg | b67e94b | 2012-01-10 12:23:19 -0500 | [diff] [blame] | 238 | void |
| 239 | window_schedule_resize(struct window *window, int width, int height); |
Kristian Høgsberg | a85fe3c | 2010-06-08 14:08:30 -0400 | [diff] [blame] | 240 | |
| 241 | void |
Kristian Høgsberg | d0c3b9d | 2010-10-25 11:40:03 -0400 | [diff] [blame] | 242 | window_damage(struct window *window, int32_t x, int32_t y, |
| 243 | int32_t width, int32_t height); |
| 244 | |
Kristian Høgsberg | 0ac16f0 | 2009-01-15 11:37:43 -0500 | [diff] [blame] | 245 | cairo_surface_t * |
Kristian Høgsberg | a85fe3c | 2010-06-08 14:08:30 -0400 | [diff] [blame] | 246 | window_get_surface(struct window *window); |
| 247 | |
Benjamin Franzke | ec4d342 | 2011-03-14 12:07:26 +0100 | [diff] [blame] | 248 | struct wl_surface * |
| 249 | window_get_wl_surface(struct window *window); |
| 250 | |
Pekka Paalanen | 9d1613e | 2011-11-25 12:09:16 +0200 | [diff] [blame] | 251 | struct wl_shell_surface * |
| 252 | window_get_wl_shell_surface(struct window *window); |
| 253 | |
Kristian Høgsberg | 0ac16f0 | 2009-01-15 11:37:43 -0500 | [diff] [blame] | 254 | void |
Kristian Høgsberg | 9d69f8e | 2010-09-03 14:46:38 -0400 | [diff] [blame] | 255 | window_flush(struct window *window); |
| 256 | |
Kristian Høgsberg | 012a007 | 2010-10-26 00:02:20 -0400 | [diff] [blame] | 257 | void |
Bryce Harrington | f57303f | 2010-11-19 12:15:15 -0800 | [diff] [blame] | 258 | window_set_surface(struct window *window, cairo_surface_t *surface); |
| 259 | |
| 260 | void |
Kristian Høgsberg | 012a007 | 2010-10-26 00:02:20 -0400 | [diff] [blame] | 261 | window_create_surface(struct window *window); |
| 262 | |
Kristian Høgsberg | d0c3b9d | 2010-10-25 11:40:03 -0400 | [diff] [blame] | 263 | enum window_buffer_type { |
Benjamin Franzke | 6693ac2 | 2011-02-10 12:04:30 +0100 | [diff] [blame] | 264 | WINDOW_BUFFER_TYPE_EGL_WINDOW, |
Kristian Høgsberg | d0c3b9d | 2010-10-25 11:40:03 -0400 | [diff] [blame] | 265 | WINDOW_BUFFER_TYPE_SHM, |
| 266 | }; |
| 267 | |
| 268 | void |
Benjamin Franzke | bde55ec | 2011-03-07 15:08:09 +0100 | [diff] [blame] | 269 | display_surface_damage(struct display *display, cairo_surface_t *cairo_surface, |
| 270 | int32_t x, int32_t y, int32_t width, int32_t height); |
| 271 | |
| 272 | void |
Kristian Høgsberg | d0c3b9d | 2010-10-25 11:40:03 -0400 | [diff] [blame] | 273 | window_set_buffer_type(struct window *window, enum window_buffer_type type); |
| 274 | |
Kristian Høgsberg | 9d69f8e | 2010-09-03 14:46:38 -0400 | [diff] [blame] | 275 | void |
Kristian Høgsberg | 0395f30 | 2008-12-22 12:14:50 -0500 | [diff] [blame] | 276 | window_set_fullscreen(struct window *window, int fullscreen); |
| 277 | |
| 278 | void |
Kristian Høgsberg | d6bcd7d | 2012-02-16 15:53:46 -0500 | [diff] [blame] | 279 | window_set_maximized(struct window *window, int maximized); |
| 280 | |
| 281 | void |
Kristian Høgsberg | 0c29eb2 | 2011-09-06 18:02:34 -0400 | [diff] [blame] | 282 | window_set_custom(struct window *window); |
| 283 | |
| 284 | void |
Kristian Høgsberg | c8c3734 | 2010-06-25 11:19:22 -0400 | [diff] [blame] | 285 | window_set_user_data(struct window *window, void *data); |
| 286 | |
Kristian Høgsberg | e9d37bd | 2010-09-02 20:22:42 -0400 | [diff] [blame] | 287 | void * |
| 288 | window_get_user_data(struct window *window); |
| 289 | |
Kristian Høgsberg | c8c3734 | 2010-06-25 11:19:22 -0400 | [diff] [blame] | 290 | void |
Kristian Høgsberg | 6e83d58 | 2008-12-08 00:01:36 -0500 | [diff] [blame] | 291 | window_set_key_handler(struct window *window, |
Kristian Høgsberg | c8c3734 | 2010-06-25 11:19:22 -0400 | [diff] [blame] | 292 | window_key_handler_t handler); |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 293 | |
Kristian Høgsberg | 3c248cc | 2009-02-22 23:01:35 -0500 | [diff] [blame] | 294 | void |
| 295 | window_set_keyboard_focus_handler(struct window *window, |
Kristian Høgsberg | c8c3734 | 2010-06-25 11:19:22 -0400 | [diff] [blame] | 296 | window_keyboard_focus_handler_t handler); |
Kristian Høgsberg | a85fe3c | 2010-06-08 14:08:30 -0400 | [diff] [blame] | 297 | |
| 298 | void |
Kristian Høgsberg | 47fe08a | 2011-10-28 12:26:06 -0400 | [diff] [blame] | 299 | window_set_data_handler(struct window *window, |
| 300 | window_data_handler_t handler); |
| 301 | |
| 302 | void |
| 303 | window_set_drop_handler(struct window *window, |
| 304 | window_drop_handler_t handler); |
| 305 | |
| 306 | void |
Kristian Høgsberg | 4f7dcd6 | 2012-01-06 21:59:05 -0500 | [diff] [blame] | 307 | window_set_close_handler(struct window *window, |
| 308 | window_close_handler_t handler); |
| 309 | |
| 310 | void |
Callum Lowcay | ef57a9b | 2011-01-14 20:46:23 +1300 | [diff] [blame] | 311 | window_set_title(struct window *window, const char *title); |
| 312 | |
| 313 | const char * |
| 314 | window_get_title(struct window *window); |
| 315 | |
Scott Moreau | 7a1b32a | 2012-05-27 14:25:02 -0600 | [diff] [blame] | 316 | void |
| 317 | window_set_text_cursor_position(struct window *window, int32_t x, int32_t y); |
| 318 | |
Tiago Vignatti | 82db9d8 | 2012-05-23 22:06:27 +0300 | [diff] [blame] | 319 | int |
| 320 | widget_set_tooltip(struct widget *parent, char *entry, float x, float y); |
| 321 | |
| 322 | void |
| 323 | widget_destroy_tooltip(struct widget *parent); |
| 324 | |
Kristian Høgsberg | 441338c | 2012-01-10 13:52:34 -0500 | [diff] [blame] | 325 | struct widget * |
| 326 | widget_add_widget(struct widget *parent, void *data); |
Tiago Vignatti | 82db9d8 | 2012-05-23 22:06:27 +0300 | [diff] [blame] | 327 | |
Kristian Høgsberg | 441338c | 2012-01-10 13:52:34 -0500 | [diff] [blame] | 328 | void |
| 329 | widget_destroy(struct widget *widget); |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame] | 330 | void |
Kristian Høgsberg | c51f799 | 2012-01-08 15:09:53 -0500 | [diff] [blame] | 331 | widget_get_allocation(struct widget *widget, struct rectangle *allocation); |
Kristian Høgsberg | e28d05b | 2011-09-20 21:43:54 -0400 | [diff] [blame] | 332 | |
| 333 | void |
Kristian Høgsberg | c51f799 | 2012-01-08 15:09:53 -0500 | [diff] [blame] | 334 | widget_set_allocation(struct widget *widget, |
| 335 | int32_t x, int32_t y, int32_t width, int32_t height); |
Kristian Høgsberg | bb97700 | 2012-01-10 19:11:42 -0500 | [diff] [blame] | 336 | void |
| 337 | widget_set_size(struct widget *widget, int32_t width, int32_t height); |
| 338 | void |
Kristian Høgsberg | 010f98b | 2012-02-23 17:30:45 -0500 | [diff] [blame] | 339 | widget_set_transparent(struct widget *widget, int transparent); |
| 340 | void |
Kristian Høgsberg | bb97700 | 2012-01-10 19:11:42 -0500 | [diff] [blame] | 341 | widget_schedule_resize(struct widget *widget, int32_t width, int32_t height); |
Kristian Høgsberg | e28d05b | 2011-09-20 21:43:54 -0400 | [diff] [blame] | 342 | |
| 343 | void * |
Kristian Høgsberg | c51f799 | 2012-01-08 15:09:53 -0500 | [diff] [blame] | 344 | widget_get_user_data(struct widget *widget); |
Kristian Høgsberg | e28d05b | 2011-09-20 21:43:54 -0400 | [diff] [blame] | 345 | |
| 346 | void |
Kristian Høgsberg | b67e94b | 2012-01-10 12:23:19 -0500 | [diff] [blame] | 347 | widget_set_redraw_handler(struct widget *widget, |
| 348 | widget_redraw_handler_t handler); |
| 349 | void |
| 350 | widget_set_resize_handler(struct widget *widget, |
| 351 | widget_resize_handler_t handler); |
| 352 | void |
Kristian Høgsberg | ee14323 | 2012-01-09 08:42:24 -0500 | [diff] [blame] | 353 | widget_set_enter_handler(struct widget *widget, |
| 354 | widget_enter_handler_t handler); |
| 355 | void |
| 356 | widget_set_leave_handler(struct widget *widget, |
| 357 | widget_leave_handler_t handler); |
Kristian Høgsberg | 04e9834 | 2012-01-09 09:36:16 -0500 | [diff] [blame] | 358 | void |
| 359 | widget_set_motion_handler(struct widget *widget, |
| 360 | widget_motion_handler_t handler); |
Kristian Høgsberg | 9a13dab | 2012-01-08 15:18:19 -0500 | [diff] [blame] | 361 | void |
Kristian Høgsberg | a8a0db3 | 2012-01-09 11:12:05 -0500 | [diff] [blame] | 362 | widget_set_button_handler(struct widget *widget, |
| 363 | widget_button_handler_t handler); |
| 364 | |
| 365 | void |
Kristian Høgsberg | 9a13dab | 2012-01-08 15:18:19 -0500 | [diff] [blame] | 366 | widget_schedule_redraw(struct widget *widget); |
| 367 | |
Kristian Høgsberg | 29af3eb | 2012-01-10 22:41:05 -0500 | [diff] [blame] | 368 | struct widget * |
| 369 | frame_create(struct window *window, void *data); |
Kristian Høgsberg | a162792 | 2012-06-20 17:30:03 -0400 | [diff] [blame] | 370 | void |
| 371 | frame_set_child_size(struct widget *widget, int child_width, int child_height); |
Kristian Høgsberg | 29af3eb | 2012-01-10 22:41:05 -0500 | [diff] [blame] | 372 | |
Kristian Høgsberg | 9a13dab | 2012-01-08 15:18:19 -0500 | [diff] [blame] | 373 | void |
Kristian Høgsberg | 5a4e9ff | 2012-06-04 16:04:07 -0400 | [diff] [blame] | 374 | input_set_pointer_image(struct input *input, int pointer); |
Kristian Høgsberg | 47fe08a | 2011-10-28 12:26:06 -0400 | [diff] [blame] | 375 | |
| 376 | void |
Kristian Høgsberg | 9a68624 | 2010-08-18 15:28:04 -0400 | [diff] [blame] | 377 | input_get_position(struct input *input, int32_t *x, int32_t *y); |
| 378 | |
Kristian Høgsberg | 7016313 | 2012-05-08 15:55:39 -0400 | [diff] [blame] | 379 | #define MOD_SHIFT_MASK 0x01 |
| 380 | #define MOD_ALT_MASK 0x02 |
| 381 | #define MOD_CONTROL_MASK 0x04 |
| 382 | |
Kristian Høgsberg | 67cac8a | 2011-01-19 14:20:33 -0500 | [diff] [blame] | 383 | uint32_t |
| 384 | input_get_modifiers(struct input *input); |
| 385 | |
Kristian Høgsberg | 831dd52 | 2012-01-10 23:46:33 -0500 | [diff] [blame] | 386 | void |
| 387 | input_grab(struct input *input, struct widget *widget, uint32_t button); |
| 388 | |
| 389 | void |
Kristian Høgsberg | eae5de7 | 2012-04-11 22:42:15 -0400 | [diff] [blame] | 390 | input_ungrab(struct input *input); |
Kristian Høgsberg | 831dd52 | 2012-01-10 23:46:33 -0500 | [diff] [blame] | 391 | |
Kristian Høgsberg | b632351 | 2012-01-11 00:04:42 -0500 | [diff] [blame] | 392 | struct widget * |
| 393 | input_get_focus_widget(struct input *input); |
| 394 | |
Kristian Høgsberg | d56bd90 | 2012-06-05 09:58:51 -0400 | [diff] [blame] | 395 | struct display * |
| 396 | input_get_display(struct input *input); |
| 397 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 398 | struct wl_seat * |
| 399 | input_get_seat(struct input *input); |
Kristian Høgsberg | 1d7ffd3 | 2010-08-25 16:34:05 -0400 | [diff] [blame] | 400 | |
Kristian Høgsberg | 47fe08a | 2011-10-28 12:26:06 -0400 | [diff] [blame] | 401 | struct wl_data_device * |
| 402 | input_get_data_device(struct input *input); |
| 403 | |
Kristian Høgsberg | 6bccebe | 2011-01-21 16:23:09 -0500 | [diff] [blame] | 404 | void |
Kristian Høgsberg | 47fe08a | 2011-10-28 12:26:06 -0400 | [diff] [blame] | 405 | input_set_selection(struct input *input, |
| 406 | struct wl_data_source *source, uint32_t time); |
| 407 | |
| 408 | void |
Kristian Høgsberg | eae5de7 | 2012-04-11 22:42:15 -0400 | [diff] [blame] | 409 | input_accept(struct input *input, const char *type); |
Kristian Høgsberg | 47fe08a | 2011-10-28 12:26:06 -0400 | [diff] [blame] | 410 | |
| 411 | |
| 412 | void |
| 413 | input_receive_drag_data(struct input *input, const char *mime_type, |
| 414 | data_func_t func, void *user_data); |
| 415 | |
| 416 | int |
| 417 | input_receive_selection_data(struct input *input, const char *mime_type, |
| 418 | data_func_t func, void *data); |
Kristian Høgsberg | e7aaec3 | 2011-12-27 13:50:04 -0500 | [diff] [blame] | 419 | int |
| 420 | input_receive_selection_data_to_fd(struct input *input, |
| 421 | const char *mime_type, int fd); |
Kristian Høgsberg | 58eec36 | 2011-01-19 14:27:42 -0500 | [diff] [blame] | 422 | |
Kristian Høgsberg | 53ff2f6 | 2011-11-26 17:27:37 -0500 | [diff] [blame] | 423 | void |
Pekka Paalanen | 999c5b5 | 2011-11-30 10:52:38 +0200 | [diff] [blame] | 424 | output_set_user_data(struct output *output, void *data); |
| 425 | |
| 426 | void * |
| 427 | output_get_user_data(struct output *output); |
| 428 | |
| 429 | void |
| 430 | output_set_destroy_handler(struct output *output, |
| 431 | display_output_handler_t handler); |
| 432 | |
| 433 | void |
Kristian Høgsberg | 53ff2f6 | 2011-11-26 17:27:37 -0500 | [diff] [blame] | 434 | output_get_allocation(struct output *output, struct rectangle *allocation); |
| 435 | |
Pekka Paalanen | 999c5b5 | 2011-11-30 10:52:38 +0200 | [diff] [blame] | 436 | struct wl_output * |
| 437 | output_get_wl_output(struct output *output); |
Kristian Høgsberg | 53ff2f6 | 2011-11-26 17:27:37 -0500 | [diff] [blame] | 438 | |
Kristian Høgsberg | 0c4457f | 2008-12-07 19:59:11 -0500 | [diff] [blame] | 439 | #endif |