Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 1 | /* |
| 2 | * Copyright © 2011 Intel Corporation |
| 3 | * |
| 4 | * Permission to use, copy, modify, distribute, and sell this software and |
| 5 | * its documentation for any purpose is hereby granted without fee, provided |
| 6 | * that the above copyright notice appear in all copies and that both that |
| 7 | * copyright notice and this permission notice appear in supporting |
| 8 | * documentation, and that the name of the copyright holders not be used in |
| 9 | * advertising or publicity pertaining to distribution of the software |
| 10 | * without specific, written prior permission. The copyright holders make |
| 11 | * no representations about the suitability of this software for any |
| 12 | * purpose. It is provided "as is" without express or implied warranty. |
| 13 | * |
| 14 | * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS |
| 15 | * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND |
| 16 | * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY |
| 17 | * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER |
| 18 | * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF |
| 19 | * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN |
| 20 | * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
| 21 | */ |
| 22 | |
| 23 | #include <sys/wait.h> |
| 24 | #include <unistd.h> |
| 25 | #include <stdlib.h> |
| 26 | #include <stdio.h> |
| 27 | #include <string.h> |
| 28 | #include <sys/types.h> |
| 29 | #include <sys/socket.h> |
| 30 | #include <fcntl.h> |
| 31 | #include <linux/input.h> |
| 32 | |
| 33 | #include "compositor.h" |
| 34 | #include "meego-tablet-server-protocol.h" |
| 35 | |
| 36 | /* |
| 37 | * TODO: Don't fade back from black until we've received a lockscreen |
| 38 | * attachment. |
| 39 | */ |
| 40 | |
Kristian Høgsberg | 1258a4a | 2011-05-04 11:35:02 -0400 | [diff] [blame] | 41 | enum { |
| 42 | STATE_STARTING, |
| 43 | STATE_LOCKED, |
| 44 | STATE_HOME, |
| 45 | STATE_SWITCHER, |
| 46 | STATE_TASK |
| 47 | }; |
| 48 | |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 49 | struct meego_tablet_shell { |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 50 | struct wl_resource resource; |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 51 | |
| 52 | struct wlsc_shell shell; |
| 53 | |
| 54 | struct wlsc_compositor *compositor; |
Kristian Høgsberg | d4af320 | 2011-06-21 17:43:31 -0400 | [diff] [blame] | 55 | struct wlsc_process process; |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 56 | struct wlsc_input_device *device; |
| 57 | struct wl_client *client; |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 58 | |
| 59 | struct wlsc_surface *surface; |
| 60 | |
| 61 | struct wlsc_surface *lockscreen_surface; |
| 62 | struct wl_listener lockscreen_listener; |
| 63 | |
| 64 | struct wlsc_surface *home_surface; |
| 65 | |
| 66 | struct wlsc_surface *switcher_surface; |
| 67 | struct wl_listener switcher_listener; |
| 68 | |
Kristian Høgsberg | 1258a4a | 2011-05-04 11:35:02 -0400 | [diff] [blame] | 69 | struct meego_tablet_client *current_client; |
| 70 | |
| 71 | int state, previous_state; |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 72 | int long_press_active; |
| 73 | struct wl_event_source *long_press_source; |
| 74 | }; |
| 75 | |
Kristian Høgsberg | 3a53efe | 2011-05-02 14:21:03 -0400 | [diff] [blame] | 76 | struct meego_tablet_client { |
| 77 | struct wl_resource resource; |
| 78 | struct meego_tablet_shell *shell; |
| 79 | struct wl_client *client; |
Kristian Høgsberg | 1258a4a | 2011-05-04 11:35:02 -0400 | [diff] [blame] | 80 | struct wlsc_surface *surface; |
Kristian Høgsberg | 3a53efe | 2011-05-02 14:21:03 -0400 | [diff] [blame] | 81 | char *name; |
| 82 | }; |
| 83 | |
| 84 | struct meego_tablet_zoom { |
| 85 | struct wlsc_surface *surface; |
| 86 | struct wlsc_animation animation; |
Kristian Høgsberg | 269c782 | 2011-05-02 14:38:18 -0400 | [diff] [blame] | 87 | struct wlsc_spring spring; |
Kristian Høgsberg | 0bc0e24 | 2011-05-02 14:35:40 -0400 | [diff] [blame] | 88 | struct wlsc_transform transform; |
Kristian Høgsberg | 132c653 | 2011-05-03 12:41:03 -0400 | [diff] [blame] | 89 | struct wl_listener listener; |
Kristian Høgsberg | 57eca74 | 2011-06-21 16:40:56 -0400 | [diff] [blame] | 90 | struct meego_tablet_shell *shell; |
| 91 | void (*done)(struct meego_tablet_zoom *zoom); |
Kristian Høgsberg | 3a53efe | 2011-05-02 14:21:03 -0400 | [diff] [blame] | 92 | }; |
| 93 | |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 94 | |
Kristian Høgsberg | d4af320 | 2011-06-21 17:43:31 -0400 | [diff] [blame] | 95 | static void |
| 96 | meego_tablet_shell_sigchld(struct wlsc_process *process, int status) |
| 97 | { |
| 98 | struct meego_tablet_shell *shell = |
| 99 | container_of(process, struct meego_tablet_shell, process); |
| 100 | |
| 101 | shell->process.pid = 0; |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 102 | |
| 103 | fprintf(stderr, "meego-ux-daemon crashed, exit code %d\n", status); |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 104 | } |
| 105 | |
| 106 | static void |
Kristian Høgsberg | 1258a4a | 2011-05-04 11:35:02 -0400 | [diff] [blame] | 107 | meego_tablet_shell_set_state(struct meego_tablet_shell *shell, int state) |
| 108 | { |
| 109 | static const char *states[] = { |
| 110 | "STARTING", "LOCKED", "HOME", "SWITCHER", "TASK" |
| 111 | }; |
| 112 | |
| 113 | fprintf(stderr, "switching to state %s (from %s)\n", |
| 114 | states[state], states[shell->state]); |
| 115 | shell->previous_state = shell->state; |
| 116 | shell->state = state; |
| 117 | } |
| 118 | |
| 119 | static void |
Kristian Høgsberg | 57eca74 | 2011-06-21 16:40:56 -0400 | [diff] [blame] | 120 | meego_tablet_zoom_destroy(struct meego_tablet_zoom *zoom) |
| 121 | { |
| 122 | wl_list_remove(&zoom->animation.link); |
| 123 | zoom->surface->transform = NULL; |
| 124 | if (zoom->done) |
| 125 | zoom->done(zoom); |
| 126 | free(zoom); |
| 127 | } |
| 128 | |
| 129 | static void |
Kristian Høgsberg | 132c653 | 2011-05-03 12:41:03 -0400 | [diff] [blame] | 130 | handle_zoom_surface_destroy(struct wl_listener *listener, |
Benjamin Franzke | 4721a3c | 2011-05-06 17:13:17 +0200 | [diff] [blame] | 131 | struct wl_resource *resource, uint32_t time) |
Kristian Høgsberg | 132c653 | 2011-05-03 12:41:03 -0400 | [diff] [blame] | 132 | { |
| 133 | struct meego_tablet_zoom *zoom = |
| 134 | container_of(listener, struct meego_tablet_zoom, listener); |
| 135 | |
Kristian Høgsberg | 132c653 | 2011-05-03 12:41:03 -0400 | [diff] [blame] | 136 | fprintf(stderr, "animation surface gone\n"); |
Kristian Høgsberg | 57eca74 | 2011-06-21 16:40:56 -0400 | [diff] [blame] | 137 | meego_tablet_zoom_destroy(zoom); |
Kristian Høgsberg | 132c653 | 2011-05-03 12:41:03 -0400 | [diff] [blame] | 138 | } |
| 139 | |
| 140 | static void |
Kristian Høgsberg | 3a53efe | 2011-05-02 14:21:03 -0400 | [diff] [blame] | 141 | meego_tablet_zoom_frame(struct wlsc_animation *animation, |
| 142 | struct wlsc_output *output, uint32_t msecs) |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 143 | { |
Kristian Høgsberg | 3a53efe | 2011-05-02 14:21:03 -0400 | [diff] [blame] | 144 | struct meego_tablet_zoom *zoom = |
| 145 | container_of(animation, struct meego_tablet_zoom, animation); |
| 146 | struct wlsc_surface *es = zoom->surface; |
| 147 | GLfloat scale; |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 148 | |
Kristian Høgsberg | 269c782 | 2011-05-02 14:38:18 -0400 | [diff] [blame] | 149 | wlsc_spring_update(&zoom->spring, msecs); |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 150 | |
Kristian Høgsberg | 269c782 | 2011-05-02 14:38:18 -0400 | [diff] [blame] | 151 | if (wlsc_spring_done(&zoom->spring)) { |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 152 | fprintf(stderr, "animation done\n"); |
Kristian Høgsberg | 57eca74 | 2011-06-21 16:40:56 -0400 | [diff] [blame] | 153 | meego_tablet_zoom_destroy(zoom); |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 154 | } |
| 155 | |
Kristian Høgsberg | 269c782 | 2011-05-02 14:38:18 -0400 | [diff] [blame] | 156 | scale = zoom->spring.current; |
Kristian Høgsberg | 0bc0e24 | 2011-05-02 14:35:40 -0400 | [diff] [blame] | 157 | wlsc_matrix_init(&zoom->transform.matrix); |
| 158 | wlsc_matrix_translate(&zoom->transform.matrix, |
Kristian Høgsberg | 3a53efe | 2011-05-02 14:21:03 -0400 | [diff] [blame] | 159 | -es->width / 2.0, -es->height / 2.0, 0); |
Kristian Høgsberg | 0bc0e24 | 2011-05-02 14:35:40 -0400 | [diff] [blame] | 160 | wlsc_matrix_scale(&zoom->transform.matrix, scale, scale, scale); |
| 161 | wlsc_matrix_translate(&zoom->transform.matrix, |
Kristian Høgsberg | 3a53efe | 2011-05-02 14:21:03 -0400 | [diff] [blame] | 162 | es->width / 2.0, es->height / 2.0, 0); |
| 163 | |
Kristian Høgsberg | 269c782 | 2011-05-02 14:38:18 -0400 | [diff] [blame] | 164 | scale = 1.0 / zoom->spring.current; |
Kristian Høgsberg | 0bc0e24 | 2011-05-02 14:35:40 -0400 | [diff] [blame] | 165 | wlsc_matrix_init(&zoom->transform.inverse); |
| 166 | wlsc_matrix_scale(&zoom->transform.inverse, scale, scale, scale); |
Kristian Høgsberg | 3a53efe | 2011-05-02 14:21:03 -0400 | [diff] [blame] | 167 | |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 168 | wlsc_surface_damage(es); |
| 169 | } |
| 170 | |
Kristian Høgsberg | 57eca74 | 2011-06-21 16:40:56 -0400 | [diff] [blame] | 171 | static struct meego_tablet_zoom * |
Kristian Høgsberg | 3a53efe | 2011-05-02 14:21:03 -0400 | [diff] [blame] | 172 | meego_tablet_zoom_run(struct meego_tablet_shell *shell, |
Kristian Høgsberg | 57eca74 | 2011-06-21 16:40:56 -0400 | [diff] [blame] | 173 | struct wlsc_surface *surface, |
| 174 | GLfloat start, GLfloat stop) |
Kristian Høgsberg | 3a53efe | 2011-05-02 14:21:03 -0400 | [diff] [blame] | 175 | { |
| 176 | struct meego_tablet_zoom *zoom; |
Kristian Høgsberg | 3a53efe | 2011-05-02 14:21:03 -0400 | [diff] [blame] | 177 | |
| 178 | fprintf(stderr, "starting animation for surface %p\n", surface); |
| 179 | |
| 180 | zoom = malloc(sizeof *zoom); |
| 181 | if (!zoom) |
Kristian Høgsberg | 57eca74 | 2011-06-21 16:40:56 -0400 | [diff] [blame] | 182 | return NULL; |
Kristian Høgsberg | 3a53efe | 2011-05-02 14:21:03 -0400 | [diff] [blame] | 183 | |
Kristian Høgsberg | 57eca74 | 2011-06-21 16:40:56 -0400 | [diff] [blame] | 184 | zoom->shell = shell; |
Kristian Høgsberg | 3a53efe | 2011-05-02 14:21:03 -0400 | [diff] [blame] | 185 | zoom->surface = surface; |
Kristian Høgsberg | 57eca74 | 2011-06-21 16:40:56 -0400 | [diff] [blame] | 186 | zoom->done = NULL; |
Kristian Høgsberg | 3a53efe | 2011-05-02 14:21:03 -0400 | [diff] [blame] | 187 | surface->transform = &zoom->transform; |
Kristian Høgsberg | 57eca74 | 2011-06-21 16:40:56 -0400 | [diff] [blame] | 188 | wlsc_spring_init(&zoom->spring, 200.0, start, stop); |
Kristian Høgsberg | 269c782 | 2011-05-02 14:38:18 -0400 | [diff] [blame] | 189 | zoom->spring.timestamp = wlsc_compositor_get_time(); |
Kristian Høgsberg | 3a53efe | 2011-05-02 14:21:03 -0400 | [diff] [blame] | 190 | zoom->animation.frame = meego_tablet_zoom_frame; |
Kristian Høgsberg | 0bc0e24 | 2011-05-02 14:35:40 -0400 | [diff] [blame] | 191 | meego_tablet_zoom_frame(&zoom->animation, NULL, |
Kristian Høgsberg | 269c782 | 2011-05-02 14:38:18 -0400 | [diff] [blame] | 192 | zoom->spring.timestamp); |
Kristian Høgsberg | 0bc0e24 | 2011-05-02 14:35:40 -0400 | [diff] [blame] | 193 | |
Kristian Høgsberg | 132c653 | 2011-05-03 12:41:03 -0400 | [diff] [blame] | 194 | zoom->listener.func = handle_zoom_surface_destroy; |
Benjamin Franzke | 4721a3c | 2011-05-06 17:13:17 +0200 | [diff] [blame] | 195 | wl_list_insert(surface->surface.resource.destroy_listener_list.prev, |
Kristian Høgsberg | 132c653 | 2011-05-03 12:41:03 -0400 | [diff] [blame] | 196 | &zoom->listener.link); |
| 197 | |
Kristian Høgsberg | 3a53efe | 2011-05-02 14:21:03 -0400 | [diff] [blame] | 198 | wl_list_insert(shell->compositor->animation_list.prev, |
| 199 | &zoom->animation.link); |
Kristian Høgsberg | 57eca74 | 2011-06-21 16:40:56 -0400 | [diff] [blame] | 200 | |
| 201 | return zoom; |
Kristian Høgsberg | 3a53efe | 2011-05-02 14:21:03 -0400 | [diff] [blame] | 202 | } |
| 203 | |
Kristian Høgsberg | 3a53efe | 2011-05-02 14:21:03 -0400 | [diff] [blame] | 204 | /* FIXME: We should be handling map, not attach... Map is when the |
| 205 | * surface becomes visible, which is what we want to catch. Attach |
| 206 | * will happen whenever the surface changes. */ |
| 207 | |
| 208 | static void |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 209 | meego_tablet_shell_attach(struct wlsc_shell *base, |
| 210 | struct wlsc_surface *surface) |
| 211 | { |
| 212 | struct meego_tablet_shell *shell = |
| 213 | container_of(base, struct meego_tablet_shell, shell); |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 214 | |
Kristian Høgsberg | bfcf07c | 2011-05-05 15:25:28 -0400 | [diff] [blame] | 215 | surface->x = 0; |
| 216 | surface->y = 0; |
| 217 | |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 218 | if (surface == shell->lockscreen_surface) { |
Kristian Høgsberg | b79216e | 2011-05-08 21:28:45 -0400 | [diff] [blame] | 219 | wlsc_compositor_fade(shell->compositor, 0.0); |
| 220 | wlsc_compositor_wake(shell->compositor); |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 221 | } else if (surface == shell->switcher_surface) { |
Kristian Høgsberg | 1258a4a | 2011-05-04 11:35:02 -0400 | [diff] [blame] | 222 | /* */ |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 223 | } else if (surface == shell->home_surface) { |
Kristian Høgsberg | b79216e | 2011-05-08 21:28:45 -0400 | [diff] [blame] | 224 | if (shell->state == STATE_STARTING) { |
| 225 | meego_tablet_shell_set_state(shell, STATE_LOCKED); |
| 226 | shell->previous_state = STATE_HOME; |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 227 | wl_resource_post_event(&shell->resource, |
| 228 | MEEGO_TABLET_SHELL_SHOW_LOCKSCREEN); |
Kristian Høgsberg | b79216e | 2011-05-08 21:28:45 -0400 | [diff] [blame] | 229 | } |
Kristian Høgsberg | bfcf07c | 2011-05-05 15:25:28 -0400 | [diff] [blame] | 230 | } else if (shell->current_client && |
| 231 | shell->current_client->surface != surface && |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 232 | shell->current_client->client == surface->surface.resource.client) { |
Kristian Høgsberg | 1258a4a | 2011-05-04 11:35:02 -0400 | [diff] [blame] | 233 | meego_tablet_shell_set_state(shell, STATE_TASK); |
| 234 | shell->current_client->surface = surface; |
Kristian Høgsberg | 57eca74 | 2011-06-21 16:40:56 -0400 | [diff] [blame] | 235 | meego_tablet_zoom_run(shell, surface, 0.3, 1.0); |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 236 | } |
| 237 | } |
| 238 | |
| 239 | static void |
| 240 | handle_lockscreen_surface_destroy(struct wl_listener *listener, |
Benjamin Franzke | 4721a3c | 2011-05-06 17:13:17 +0200 | [diff] [blame] | 241 | struct wl_resource *resource, uint32_t time) |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 242 | { |
| 243 | struct meego_tablet_shell *shell = |
| 244 | container_of(listener, |
| 245 | struct meego_tablet_shell, lockscreen_listener); |
| 246 | |
| 247 | shell->lockscreen_surface = NULL; |
Kristian Høgsberg | 1258a4a | 2011-05-04 11:35:02 -0400 | [diff] [blame] | 248 | meego_tablet_shell_set_state(shell, shell->previous_state); |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 249 | } |
| 250 | |
| 251 | static void |
| 252 | tablet_shell_set_lockscreen(struct wl_client *client, |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 253 | struct wl_resource *resource, |
Kristian Høgsberg | 97d44aa | 2011-08-26 17:21:20 -0400 | [diff] [blame] | 254 | struct wl_resource *surface_resource) |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 255 | { |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 256 | struct meego_tablet_shell *shell = resource->data; |
Kristian Høgsberg | 97d44aa | 2011-08-26 17:21:20 -0400 | [diff] [blame] | 257 | struct wlsc_surface *es = surface_resource->data; |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 258 | struct wlsc_input_device *device = |
| 259 | (struct wlsc_input_device *) shell->compositor->input_device; |
| 260 | |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 261 | es->x = 0; |
| 262 | es->y = 0; |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 263 | wlsc_surface_activate(es, device, wlsc_compositor_get_time()); |
| 264 | shell->lockscreen_surface = es; |
| 265 | |
| 266 | shell->lockscreen_listener.func = handle_lockscreen_surface_destroy; |
Benjamin Franzke | 4721a3c | 2011-05-06 17:13:17 +0200 | [diff] [blame] | 267 | wl_list_insert(es->surface.resource.destroy_listener_list.prev, |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 268 | &shell->lockscreen_listener.link); |
| 269 | } |
| 270 | |
| 271 | static void |
| 272 | handle_switcher_surface_destroy(struct wl_listener *listener, |
Benjamin Franzke | 4721a3c | 2011-05-06 17:13:17 +0200 | [diff] [blame] | 273 | struct wl_resource *resource, uint32_t time) |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 274 | { |
| 275 | struct meego_tablet_shell *shell = |
| 276 | container_of(listener, |
| 277 | struct meego_tablet_shell, switcher_listener); |
| 278 | |
| 279 | shell->switcher_surface = NULL; |
Kristian Høgsberg | 1258a4a | 2011-05-04 11:35:02 -0400 | [diff] [blame] | 280 | if (shell->state != STATE_LOCKED) |
| 281 | meego_tablet_shell_set_state(shell, shell->previous_state); |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 282 | } |
| 283 | |
| 284 | static void |
| 285 | tablet_shell_set_switcher(struct wl_client *client, |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 286 | struct wl_resource *resource, |
Kristian Høgsberg | 97d44aa | 2011-08-26 17:21:20 -0400 | [diff] [blame] | 287 | struct wl_resource *surface_resource) |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 288 | { |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 289 | struct meego_tablet_shell *shell = resource->data; |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 290 | struct wlsc_input_device *device = |
| 291 | (struct wlsc_input_device *) shell->compositor->input_device; |
Kristian Høgsberg | 97d44aa | 2011-08-26 17:21:20 -0400 | [diff] [blame] | 292 | struct wlsc_surface *es = surface_resource->data; |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 293 | |
| 294 | /* FIXME: Switcher should be centered and the compositor |
| 295 | * should do the tinting of the background. With the cache |
| 296 | * layer idea, we should be able to hit the framerate on the |
| 297 | * fade/zoom in. */ |
| 298 | shell->switcher_surface = es; |
| 299 | shell->switcher_surface->x = 0; |
| 300 | shell->switcher_surface->y = 0; |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 301 | |
| 302 | wlsc_surface_activate(es, device, wlsc_compositor_get_time()); |
| 303 | |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 304 | shell->switcher_listener.func = handle_switcher_surface_destroy; |
Benjamin Franzke | 4721a3c | 2011-05-06 17:13:17 +0200 | [diff] [blame] | 305 | wl_list_insert(es->surface.resource.destroy_listener_list.prev, |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 306 | &shell->switcher_listener.link); |
| 307 | } |
| 308 | |
| 309 | static void |
| 310 | tablet_shell_set_homescreen(struct wl_client *client, |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 311 | struct wl_resource *resource, |
Kristian Høgsberg | 97d44aa | 2011-08-26 17:21:20 -0400 | [diff] [blame] | 312 | struct wl_resource *surface_resource) |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 313 | { |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 314 | struct meego_tablet_shell *shell = resource->data; |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 315 | struct wlsc_input_device *device = |
| 316 | (struct wlsc_input_device *) shell->compositor->input_device; |
| 317 | |
Kristian Høgsberg | 97d44aa | 2011-08-26 17:21:20 -0400 | [diff] [blame] | 318 | shell->home_surface = surface_resource->data; |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 319 | shell->home_surface->x = 0; |
| 320 | shell->home_surface->y = 0; |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 321 | |
| 322 | wlsc_surface_activate(shell->home_surface, device, |
| 323 | wlsc_compositor_get_time()); |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 324 | } |
| 325 | |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 326 | static void |
Kristian Høgsberg | 57eca74 | 2011-06-21 16:40:56 -0400 | [diff] [blame] | 327 | minimize_zoom_done(struct meego_tablet_zoom *zoom) |
| 328 | { |
| 329 | struct meego_tablet_shell *shell = zoom->shell; |
| 330 | struct wlsc_compositor *compositor = shell->compositor; |
| 331 | struct wlsc_input_device *device = |
| 332 | (struct wlsc_input_device *) compositor->input_device; |
| 333 | |
| 334 | wlsc_surface_activate(shell->home_surface, |
| 335 | device, wlsc_compositor_get_time()); |
| 336 | } |
| 337 | |
| 338 | static void |
Kristian Høgsberg | bfcf07c | 2011-05-05 15:25:28 -0400 | [diff] [blame] | 339 | meego_tablet_shell_switch_to(struct meego_tablet_shell *shell, |
| 340 | struct wlsc_surface *surface) |
| 341 | { |
| 342 | struct wlsc_compositor *compositor = shell->compositor; |
| 343 | struct wlsc_input_device *device = |
| 344 | (struct wlsc_input_device *) compositor->input_device; |
Kristian Høgsberg | 57eca74 | 2011-06-21 16:40:56 -0400 | [diff] [blame] | 345 | struct wlsc_surface *current; |
| 346 | struct meego_tablet_zoom *zoom; |
Kristian Høgsberg | bfcf07c | 2011-05-05 15:25:28 -0400 | [diff] [blame] | 347 | |
| 348 | if (shell->state == STATE_SWITCHER) { |
| 349 | wl_list_remove(&shell->switcher_listener.link); |
| 350 | shell->switcher_surface = NULL; |
| 351 | }; |
| 352 | |
Kristian Høgsberg | 57eca74 | 2011-06-21 16:40:56 -0400 | [diff] [blame] | 353 | if (surface == shell->home_surface) { |
Kristian Høgsberg | bfcf07c | 2011-05-05 15:25:28 -0400 | [diff] [blame] | 354 | meego_tablet_shell_set_state(shell, STATE_HOME); |
Kristian Høgsberg | 57eca74 | 2011-06-21 16:40:56 -0400 | [diff] [blame] | 355 | |
| 356 | if (shell->current_client && shell->current_client->surface) { |
| 357 | current = shell->current_client->surface; |
| 358 | zoom = meego_tablet_zoom_run(shell, current, 1.0, 0.3); |
| 359 | zoom->done = minimize_zoom_done; |
| 360 | } |
| 361 | } else { |
| 362 | fprintf(stderr, "switch to %p\n", surface); |
| 363 | wlsc_surface_activate(surface, device, |
| 364 | wlsc_compositor_get_time()); |
Kristian Høgsberg | bfcf07c | 2011-05-05 15:25:28 -0400 | [diff] [blame] | 365 | meego_tablet_shell_set_state(shell, STATE_TASK); |
Kristian Høgsberg | 57eca74 | 2011-06-21 16:40:56 -0400 | [diff] [blame] | 366 | meego_tablet_zoom_run(shell, surface, 0.3, 1.0); |
| 367 | } |
Kristian Høgsberg | bfcf07c | 2011-05-05 15:25:28 -0400 | [diff] [blame] | 368 | } |
| 369 | |
| 370 | static void |
Kristian Høgsberg | 92fb0e9 | 2011-05-04 16:16:43 -0400 | [diff] [blame] | 371 | tablet_shell_show_grid(struct wl_client *client, |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 372 | struct wl_resource *resource, |
Kristian Høgsberg | 97d44aa | 2011-08-26 17:21:20 -0400 | [diff] [blame] | 373 | struct wl_resource *surface_resource) |
Kristian Høgsberg | 92fb0e9 | 2011-05-04 16:16:43 -0400 | [diff] [blame] | 374 | { |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 375 | struct meego_tablet_shell *shell = resource->data; |
Kristian Høgsberg | 97d44aa | 2011-08-26 17:21:20 -0400 | [diff] [blame] | 376 | struct wlsc_surface *es = surface_resource->data; |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 377 | |
Kristian Høgsberg | 97d44aa | 2011-08-26 17:21:20 -0400 | [diff] [blame] | 378 | meego_tablet_shell_switch_to(shell, es); |
Kristian Høgsberg | 92fb0e9 | 2011-05-04 16:16:43 -0400 | [diff] [blame] | 379 | } |
| 380 | |
| 381 | static void |
| 382 | tablet_shell_show_panels(struct wl_client *client, |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 383 | struct wl_resource *resource, |
Kristian Høgsberg | 97d44aa | 2011-08-26 17:21:20 -0400 | [diff] [blame] | 384 | struct wl_resource *surface_resource) |
Kristian Høgsberg | 92fb0e9 | 2011-05-04 16:16:43 -0400 | [diff] [blame] | 385 | { |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 386 | struct meego_tablet_shell *shell = resource->data; |
Kristian Høgsberg | 97d44aa | 2011-08-26 17:21:20 -0400 | [diff] [blame] | 387 | struct wlsc_surface *es = surface_resource->data; |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 388 | |
Kristian Høgsberg | 97d44aa | 2011-08-26 17:21:20 -0400 | [diff] [blame] | 389 | meego_tablet_shell_switch_to(shell, es); |
Kristian Høgsberg | 92fb0e9 | 2011-05-04 16:16:43 -0400 | [diff] [blame] | 390 | } |
| 391 | |
| 392 | static void |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 393 | destroy_tablet_client(struct wl_resource *resource) |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 394 | { |
| 395 | struct meego_tablet_client *tablet_client = |
| 396 | container_of(resource, struct meego_tablet_client, resource); |
| 397 | |
| 398 | free(tablet_client->name); |
| 399 | free(tablet_client); |
| 400 | } |
| 401 | |
| 402 | static void |
Kristian Høgsberg | 97d44aa | 2011-08-26 17:21:20 -0400 | [diff] [blame] | 403 | tablet_client_destroy(struct wl_client *client, |
| 404 | struct wl_resource *resource) |
Kristian Høgsberg | 81e8c26 | 2011-05-04 16:17:20 -0400 | [diff] [blame] | 405 | { |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 406 | wl_resource_destroy(resource, wlsc_compositor_get_time()); |
Kristian Høgsberg | 81e8c26 | 2011-05-04 16:17:20 -0400 | [diff] [blame] | 407 | } |
| 408 | |
| 409 | static void |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 410 | tablet_client_activate(struct wl_client *client, struct wl_resource *resource) |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 411 | { |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 412 | struct meego_tablet_client *tablet_client = resource->data; |
Kristian Høgsberg | 1258a4a | 2011-05-04 11:35:02 -0400 | [diff] [blame] | 413 | struct meego_tablet_shell *shell = tablet_client->shell; |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 414 | |
Kristian Høgsberg | 1258a4a | 2011-05-04 11:35:02 -0400 | [diff] [blame] | 415 | shell->current_client = tablet_client; |
Kristian Høgsberg | 81e8c26 | 2011-05-04 16:17:20 -0400 | [diff] [blame] | 416 | if (!tablet_client->surface) |
| 417 | return; |
| 418 | |
Kristian Høgsberg | bfcf07c | 2011-05-05 15:25:28 -0400 | [diff] [blame] | 419 | meego_tablet_shell_switch_to(shell, tablet_client->surface); |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 420 | } |
| 421 | |
| 422 | static const struct meego_tablet_client_interface tablet_client_interface = { |
Kristian Høgsberg | 81e8c26 | 2011-05-04 16:17:20 -0400 | [diff] [blame] | 423 | tablet_client_destroy, |
| 424 | tablet_client_activate |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 425 | }; |
| 426 | |
| 427 | static void |
| 428 | tablet_shell_create_client(struct wl_client *client, |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 429 | struct wl_resource *resource, |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 430 | uint32_t id, const char *name, int fd) |
| 431 | { |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 432 | struct meego_tablet_shell *shell = resource->data; |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 433 | struct wlsc_compositor *compositor = shell->compositor; |
| 434 | struct meego_tablet_client *tablet_client; |
| 435 | |
| 436 | tablet_client = malloc(sizeof *tablet_client); |
| 437 | if (tablet_client == NULL) { |
Kristian Høgsberg | 9ebcf94 | 2011-09-01 09:54:57 -0400 | [diff] [blame^] | 438 | wl_resource_post_no_memory(resource); |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 439 | return; |
| 440 | } |
| 441 | |
| 442 | tablet_client->client = wl_client_create(compositor->wl_display, fd); |
| 443 | tablet_client->shell = shell; |
| 444 | tablet_client->name = strdup(name); |
| 445 | |
| 446 | tablet_client->resource.destroy = destroy_tablet_client; |
| 447 | tablet_client->resource.object.id = id; |
| 448 | tablet_client->resource.object.interface = |
| 449 | &meego_tablet_client_interface; |
| 450 | tablet_client->resource.object.implementation = |
| 451 | (void (**)(void)) &tablet_client_interface; |
| 452 | |
| 453 | wl_client_add_resource(client, &tablet_client->resource); |
Kristian Høgsberg | 1258a4a | 2011-05-04 11:35:02 -0400 | [diff] [blame] | 454 | tablet_client->surface = NULL; |
| 455 | shell->current_client = tablet_client; |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 456 | |
| 457 | fprintf(stderr, "created client %p, id %d, name %s, fd %d\n", |
| 458 | tablet_client->client, id, name, fd); |
| 459 | } |
| 460 | |
| 461 | static const struct meego_tablet_shell_interface tablet_shell_interface = { |
| 462 | tablet_shell_set_lockscreen, |
| 463 | tablet_shell_set_switcher, |
| 464 | tablet_shell_set_homescreen, |
Kristian Høgsberg | 92fb0e9 | 2011-05-04 16:16:43 -0400 | [diff] [blame] | 465 | tablet_shell_show_grid, |
| 466 | tablet_shell_show_panels, |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 467 | tablet_shell_create_client |
| 468 | }; |
| 469 | |
| 470 | static void |
Kristian Høgsberg | 1258a4a | 2011-05-04 11:35:02 -0400 | [diff] [blame] | 471 | launch_ux_daemon(struct meego_tablet_shell *shell) |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 472 | { |
| 473 | struct wlsc_compositor *compositor = shell->compositor; |
| 474 | char s[32]; |
| 475 | int sv[2], flags; |
| 476 | |
| 477 | if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, sv) < 0) { |
| 478 | fprintf(stderr, "socketpair failed\n"); |
| 479 | return; |
| 480 | } |
| 481 | |
Kristian Høgsberg | d4af320 | 2011-06-21 17:43:31 -0400 | [diff] [blame] | 482 | shell->process.pid = fork(); |
| 483 | shell->process.cleanup = meego_tablet_shell_sigchld; |
| 484 | |
| 485 | switch (shell->process.pid) { |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 486 | case 0: |
Kristian Høgsberg | 3d1cad8 | 2011-05-02 13:57:38 -0400 | [diff] [blame] | 487 | /* SOCK_CLOEXEC closes both ends, so we need to unset |
| 488 | * the flag on the client fd. */ |
| 489 | flags = fcntl(sv[1], F_GETFD); |
| 490 | if (flags != -1) |
| 491 | fcntl(sv[1], F_SETFD, flags & ~FD_CLOEXEC); |
| 492 | |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 493 | snprintf(s, sizeof s, "%d", sv[1]); |
| 494 | setenv("WAYLAND_SOCKET", s, 1); |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 495 | setenv("QT_QPA_PLATFORM", "waylandgl", 1); |
| 496 | if (execl("/usr/libexec/meego-ux-daemon", |
| 497 | "/usr/libexec/meego-ux-daemon", NULL) < 0) |
| 498 | fprintf(stderr, "exec failed: %m\n"); |
| 499 | exit(-1); |
| 500 | |
| 501 | default: |
| 502 | close(sv[1]); |
| 503 | shell->client = |
| 504 | wl_client_create(compositor->wl_display, sv[0]); |
Kristian Høgsberg | d4af320 | 2011-06-21 17:43:31 -0400 | [diff] [blame] | 505 | wlsc_watch_process(&shell->process); |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 506 | break; |
| 507 | |
| 508 | case -1: |
| 509 | fprintf(stderr, "failed to fork\n"); |
| 510 | break; |
| 511 | } |
| 512 | } |
| 513 | |
| 514 | static void |
| 515 | toggle_switcher(struct meego_tablet_shell *shell) |
| 516 | { |
Kristian Høgsberg | 1258a4a | 2011-05-04 11:35:02 -0400 | [diff] [blame] | 517 | switch (shell->state) { |
| 518 | case STATE_SWITCHER: |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 519 | wl_resource_post_event(&shell->resource, |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 520 | MEEGO_TABLET_SHELL_HIDE_SWITCHER); |
Kristian Høgsberg | 1258a4a | 2011-05-04 11:35:02 -0400 | [diff] [blame] | 521 | break; |
| 522 | default: |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 523 | wl_resource_post_event(&shell->resource, |
| 524 | MEEGO_TABLET_SHELL_SHOW_SWITCHER); |
Kristian Høgsberg | 1258a4a | 2011-05-04 11:35:02 -0400 | [diff] [blame] | 525 | meego_tablet_shell_set_state(shell, STATE_SWITCHER); |
| 526 | break; |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 527 | } |
| 528 | } |
| 529 | |
| 530 | static void |
| 531 | meego_tablet_shell_lock(struct wlsc_shell *base) |
| 532 | { |
| 533 | struct meego_tablet_shell *shell = |
| 534 | container_of(base, struct meego_tablet_shell, shell); |
| 535 | |
Kristian Høgsberg | 1258a4a | 2011-05-04 11:35:02 -0400 | [diff] [blame] | 536 | if (shell->state == STATE_LOCKED) |
| 537 | return; |
| 538 | if (shell->state == STATE_SWITCHER) |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 539 | wl_resource_post_event(&shell->resource, |
| 540 | MEEGO_TABLET_SHELL_HIDE_SWITCHER); |
Kristian Høgsberg | 1258a4a | 2011-05-04 11:35:02 -0400 | [diff] [blame] | 541 | |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 542 | wl_resource_post_event(&shell->resource, |
| 543 | MEEGO_TABLET_SHELL_SHOW_LOCKSCREEN); |
Kristian Høgsberg | 1258a4a | 2011-05-04 11:35:02 -0400 | [diff] [blame] | 544 | |
| 545 | meego_tablet_shell_set_state(shell, STATE_LOCKED); |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 546 | } |
| 547 | |
| 548 | static void |
| 549 | go_home(struct meego_tablet_shell *shell) |
| 550 | { |
| 551 | struct wlsc_input_device *device = |
| 552 | (struct wlsc_input_device *) shell->compositor->input_device; |
| 553 | |
Kristian Høgsberg | 1258a4a | 2011-05-04 11:35:02 -0400 | [diff] [blame] | 554 | if (shell->state == STATE_SWITCHER) |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 555 | wl_resource_post_event(&shell->resource, |
| 556 | MEEGO_TABLET_SHELL_HIDE_SWITCHER); |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 557 | |
| 558 | wlsc_surface_activate(shell->home_surface, device, |
| 559 | wlsc_compositor_get_time()); |
Kristian Høgsberg | 1258a4a | 2011-05-04 11:35:02 -0400 | [diff] [blame] | 560 | |
| 561 | meego_tablet_shell_set_state(shell, STATE_HOME); |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 562 | } |
| 563 | |
| 564 | static int |
| 565 | long_press_handler(void *data) |
| 566 | { |
| 567 | struct meego_tablet_shell *shell = data; |
| 568 | |
| 569 | shell->long_press_active = 0; |
| 570 | toggle_switcher(shell); |
| 571 | |
| 572 | return 1; |
| 573 | } |
| 574 | |
| 575 | static void |
| 576 | menu_key_binding(struct wl_input_device *device, uint32_t time, |
| 577 | uint32_t key, uint32_t button, uint32_t state, void *data) |
| 578 | { |
| 579 | struct meego_tablet_shell *shell = data; |
| 580 | |
Kristian Høgsberg | 1258a4a | 2011-05-04 11:35:02 -0400 | [diff] [blame] | 581 | if (shell->state == STATE_LOCKED) |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 582 | return; |
| 583 | |
| 584 | if (state) |
| 585 | toggle_switcher(shell); |
| 586 | } |
| 587 | |
| 588 | static void |
| 589 | home_key_binding(struct wl_input_device *device, uint32_t time, |
| 590 | uint32_t key, uint32_t button, uint32_t state, void *data) |
| 591 | { |
| 592 | struct meego_tablet_shell *shell = data; |
| 593 | |
Kristian Høgsberg | 1258a4a | 2011-05-04 11:35:02 -0400 | [diff] [blame] | 594 | if (shell->state == STATE_LOCKED) |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 595 | return; |
| 596 | |
| 597 | shell->device = (struct wlsc_input_device *) device; |
| 598 | |
| 599 | if (state) { |
| 600 | wl_event_source_timer_update(shell->long_press_source, 500); |
| 601 | shell->long_press_active = 1; |
| 602 | } else if (shell->long_press_active) { |
| 603 | wl_event_source_timer_update(shell->long_press_source, 0); |
| 604 | shell->long_press_active = 0; |
| 605 | |
Kristian Høgsberg | 1258a4a | 2011-05-04 11:35:02 -0400 | [diff] [blame] | 606 | switch (shell->state) { |
| 607 | case STATE_HOME: |
| 608 | case STATE_SWITCHER: |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 609 | toggle_switcher(shell); |
Kristian Høgsberg | 1258a4a | 2011-05-04 11:35:02 -0400 | [diff] [blame] | 610 | break; |
| 611 | default: |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 612 | go_home(shell); |
Kristian Høgsberg | 1258a4a | 2011-05-04 11:35:02 -0400 | [diff] [blame] | 613 | break; |
| 614 | } |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 615 | } |
| 616 | } |
| 617 | |
| 618 | static void |
Kristian Høgsberg | 1c56218 | 2011-05-02 22:09:20 -0400 | [diff] [blame] | 619 | meego_tablet_shell_set_selection_focus(struct wlsc_shell *shell, |
| 620 | struct wl_selection *selection, |
| 621 | struct wl_surface *surface, |
| 622 | uint32_t time) |
| 623 | { |
| 624 | } |
| 625 | |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 626 | static void |
Kristian Høgsberg | 97d44aa | 2011-08-26 17:21:20 -0400 | [diff] [blame] | 627 | bind_shell(struct wl_client *client, void *data, uint32_t version, uint32_t id) |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 628 | { |
Kristian Høgsberg | 97d44aa | 2011-08-26 17:21:20 -0400 | [diff] [blame] | 629 | struct meego_tablet_shell *shell = data; |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 630 | |
| 631 | if (shell->client != client) |
| 632 | /* Throw an error or just let the client fail when it |
| 633 | * tries to access the object?. */ |
| 634 | return; |
| 635 | |
| 636 | shell->resource.client = client; |
Kristian Høgsberg | f790c79 | 2011-08-19 14:41:57 -0400 | [diff] [blame] | 637 | shell->resource.object.id = id; |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 638 | } |
| 639 | |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 640 | void |
| 641 | shell_init(struct wlsc_compositor *compositor); |
| 642 | |
| 643 | WL_EXPORT void |
| 644 | shell_init(struct wlsc_compositor *compositor) |
| 645 | { |
| 646 | struct meego_tablet_shell *shell; |
| 647 | struct wl_event_loop *loop; |
| 648 | |
| 649 | shell = malloc(sizeof *shell); |
| 650 | if (shell == NULL) |
| 651 | return; |
| 652 | |
| 653 | memset(shell, 0, sizeof *shell); |
| 654 | shell->compositor = compositor; |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 655 | |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 656 | shell->resource.object.interface = &meego_tablet_shell_interface; |
| 657 | shell->resource.object.implementation = |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 658 | (void (**)(void)) &tablet_shell_interface; |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 659 | |
| 660 | /* FIXME: This will make the object available to all clients. */ |
Kristian Høgsberg | 904055a | 2011-08-18 17:55:30 -0400 | [diff] [blame] | 661 | wl_display_add_global(compositor->wl_display, |
Kristian Høgsberg | 97d44aa | 2011-08-26 17:21:20 -0400 | [diff] [blame] | 662 | &wl_shell_interface, shell, bind_shell); |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 663 | |
| 664 | loop = wl_display_get_event_loop(compositor->wl_display); |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 665 | shell->long_press_source = |
| 666 | wl_event_loop_add_timer(loop, long_press_handler, shell); |
| 667 | |
Kristian Høgsberg | d28b4d7 | 2011-05-02 14:11:15 -0400 | [diff] [blame] | 668 | wlsc_compositor_add_binding(compositor, KEY_LEFTMETA, 0, 0, |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 669 | home_key_binding, shell); |
Kristian Høgsberg | d28b4d7 | 2011-05-02 14:11:15 -0400 | [diff] [blame] | 670 | wlsc_compositor_add_binding(compositor, KEY_RIGHTMETA, 0, 0, |
| 671 | home_key_binding, shell); |
Kristian Høgsberg | f77ce46 | 2011-05-03 13:11:43 -0400 | [diff] [blame] | 672 | wlsc_compositor_add_binding(compositor, KEY_LEFTMETA, 0, |
| 673 | MODIFIER_SUPER, home_key_binding, shell); |
| 674 | wlsc_compositor_add_binding(compositor, KEY_RIGHTMETA, 0, |
| 675 | MODIFIER_SUPER, home_key_binding, shell); |
Kristian Høgsberg | 9d09777 | 2011-05-02 15:24:11 -0400 | [diff] [blame] | 676 | wlsc_compositor_add_binding(compositor, KEY_COMPOSE, 0, 0, |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 677 | menu_key_binding, shell); |
| 678 | |
| 679 | compositor->shell = &shell->shell; |
| 680 | |
| 681 | shell->shell.lock = meego_tablet_shell_lock; |
| 682 | shell->shell.attach = meego_tablet_shell_attach; |
Kristian Høgsberg | 1c56218 | 2011-05-02 22:09:20 -0400 | [diff] [blame] | 683 | shell->shell.set_selection_focus = |
| 684 | meego_tablet_shell_set_selection_focus; |
Kristian Høgsberg | 1258a4a | 2011-05-04 11:35:02 -0400 | [diff] [blame] | 685 | launch_ux_daemon(shell); |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 686 | |
Kristian Høgsberg | 269c782 | 2011-05-02 14:38:18 -0400 | [diff] [blame] | 687 | wlsc_spring_init(&compositor->fade.spring, 40.0, 1.0, 1.0); |
Kristian Høgsberg | 1258a4a | 2011-05-04 11:35:02 -0400 | [diff] [blame] | 688 | meego_tablet_shell_set_state(shell, STATE_STARTING); |
Kristian Høgsberg | eb7e12c | 2011-04-23 13:17:43 -0400 | [diff] [blame] | 689 | } |