From: Kristian Høgsberg Date: Tue, 3 Jan 2012 16:29:15 +0000 (-0500) Subject: Merge remote-tracking branch 'pq/compositor-dtors-v1' X-Git-Tag: 0.85.0~124 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=3466bc8042591ad46082afeeb7a0cd1e5c08e130;p=platform%2Fupstream%2Fweston.git Merge remote-tracking branch 'pq/compositor-dtors-v1' This collided with the big weston rename, but git did a good job of fixing most cases. Conflicts: compositor/compositor.h src/compositor-x11.c src/compositor.c src/screenshooter.c src/util.c --- 3466bc8042591ad46082afeeb7a0cd1e5c08e130 diff --cc src/compositor-x11.c index ad5b587,fe3f9a0..11cdb59 --- a/src/compositor-x11.c +++ b/src/compositor-x11.c @@@ -100,6 -100,17 +100,17 @@@ x11_input_create(struct x11_compositor return 0; } + static void + x11_input_destroy(struct x11_compositor *compositor) + { + struct x11_input *input = container_of(compositor->base.input_device, + struct x11_input, + base.input_device); + - wlsc_input_device_fini(&input->base); ++ weston_input_device_release(&input->base); + free(input); + } + static int x11_compositor_init_egl(struct x11_compositor *c) { @@@ -163,11 -174,22 +174,22 @@@ return 0; } + static void + x11_compositor_fini_egl(struct x11_compositor *compositor) + { + eglMakeCurrent(compositor->base.display, + EGL_NO_SURFACE, EGL_NO_SURFACE, + EGL_NO_CONTEXT); + + eglTerminate(compositor->base.display); + eglReleaseThread(); + } + static int -x11_output_prepare_render(struct wlsc_output *output_base) +x11_output_prepare_render(struct weston_output *output_base) { struct x11_output *output = (struct x11_output *) output_base; - struct wlsc_compositor *ec = output->base.compositor; + struct weston_compositor *ec = output->base.compositor; if (!eglMakeCurrent(ec->display, output->egl_surface, output->egl_surface, ec->context)) { @@@ -223,9 -245,22 +245,22 @@@ x11_output_set_cursor(struct weston_out } static void -x11_output_destroy(struct wlsc_output *output_base) +x11_output_destroy(struct weston_output *output_base) { - return; + struct x11_output *output = (struct x11_output *)output_base; + struct x11_compositor *compositor = + (struct x11_compositor *)output->base.compositor; + + wl_list_remove(&output->base.link); + wl_event_source_remove(output->finish_frame_timer); + + eglDestroySurface(compositor->base.display, output->egl_surface); + + xcb_destroy_window(compositor->conn, output->window); + - wlsc_output_destroy(&output->base); ++ weston_output_destroy(&output->base); + + free(output); } static void @@@ -730,10 -765,18 +765,18 @@@ x11_compositor_get_resources(struct x11 } static void -x11_destroy(struct wlsc_compositor *ec) +x11_destroy(struct weston_compositor *ec) { - weston_compositor_shutdown(ec); + struct x11_compositor *compositor = (struct x11_compositor *)ec; + + wl_event_source_remove(compositor->xcb_source); + x11_input_destroy(compositor); + - wlsc_compositor_shutdown(ec); /* destroys outputs, too */ ++ weston_compositor_shutdown(ec); /* destroys outputs, too */ + + x11_compositor_fini_egl(compositor); + XCloseDisplay(compositor->dpy); free(ec); } diff --cc src/compositor.c index b1353f4,4800971..110e523 --- a/src/compositor.c +++ b/src/compositor.c @@@ -805,17 -805,20 +808,20 @@@ weston_output_repaint(struct weston_out pixman_region32_init(&repaint); pixman_region32_intersect(&repaint, &output->region, &es->damage); - wlsc_surface_draw(es, output, &repaint); + weston_surface_draw(es, output, &repaint); pixman_region32_subtract(&es->damage, &es->damage, &output->region); + pixman_region32_fini(&repaint); } } if (ec->fade.spring.current > 0.001) fade_output(output, ec->fade.spring.current, &total_damage); + + pixman_region32_fini(&total_damage); } -struct wlsc_frame_callback { +struct weston_frame_callback { struct wl_resource resource; struct wl_list link; }; @@@ -1677,6 -1680,18 +1683,18 @@@ weston_input_device_init(struct weston_ device->selection_data_source = NULL; } + WL_EXPORT void -wlsc_input_device_fini(struct wlsc_input_device *device) ++weston_input_device_release(struct weston_input_device *device) + { + wl_list_remove(&device->link); + /* The global object is destroyed at wl_display_destroy() time. */ + + if (device->sprite) + destroy_surface(&device->sprite->surface.resource); + - wl_input_device_fini(&device->input_device); ++ wl_input_device_release(&device->input_device); + } + static void bind_output(struct wl_client *client, void *data, uint32_t version, uint32_t id) @@@ -1991,9 -2006,9 +2009,9 @@@ weston_compositor_init(struct weston_co ec->fade.animation.frame = fade_frame; wl_list_init(&ec->fade.animation.link); - screenshooter_create(ec); + ec->screenshooter = screenshooter_create(ec); - wlsc_data_device_manager_init(ec); + weston_data_device_manager_init(ec); glActiveTexture(GL_TEXTURE0); @@@ -2015,13 -2030,25 +2033,25 @@@ } WL_EXPORT void -wlsc_compositor_shutdown(struct wlsc_compositor *ec) +weston_compositor_shutdown(struct weston_compositor *ec) { - struct wlsc_output *output, *next; + struct weston_output *output, *next; + wl_event_source_remove(ec->idle_source); + + if (ec->screenshooter) + screenshooter_destroy(ec->screenshooter); + /* Destroy all outputs associated with this compositor */ wl_list_for_each_safe(output, next, &ec->output_list, link) output->destroy(output); + - wlsc_binding_list_destroy_all(&ec->binding_list); ++ weston_binding_list_destroy_all(&ec->binding_list); + + wl_shm_finish(ec->shm); + + wl_array_release(&ec->vertices); + wl_array_release(&ec->indices); } static int on_term_signal(int signal_number, void *data) @@@ -2065,7 -2092,8 +2095,8 @@@ load_module(const char *name, const cha int main(int argc, char *argv[]) { struct wl_display *display; - struct wlsc_compositor *ec; + struct weston_compositor *ec; + struct wl_event_source *signals[4]; struct wl_event_loop *loop; int o, xserver = 0; void *shell_module, *backend_module; @@@ -2172,9 -2205,14 +2208,14 @@@ wl_display_run(display); + /* prevent further rendering while shutting down */ - ec->state = WLSC_COMPOSITOR_SLEEPING; ++ ec->state = WESTON_COMPOSITOR_SLEEPING; + if (xserver) - wlsc_xserver_destroy(ec); + weston_xserver_destroy(ec); + ec->shell->destroy(ec->shell); + if (ec->has_bind_display) ec->unbind_display(ec->display, display); diff --cc src/compositor.h index 209c21d,0000000..0f47393 mode 100644,000000..100644 --- a/src/compositor.h +++ b/src/compositor.h @@@ -1,471 -1,0 +1,484 @@@ +/* + * Copyright © 2008-2011 Kristian Høgsberg + * + * Permission to use, copy, modify, distribute, and sell this software and + * its documentation for any purpose is hereby granted without fee, provided + * that the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of the copyright holders not be used in + * advertising or publicity pertaining to distribution of the software + * without specific, written prior permission. The copyright holders make + * no representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS + * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY + * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER + * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF + * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef _WAYLAND_SYSTEM_COMPOSITOR_H_ +#define _WAYLAND_SYSTEM_COMPOSITOR_H_ + +#include +#include +#include + +#include +#include +#include +#include + +struct weston_matrix { + GLfloat d[16]; +}; + +struct weston_vector { + GLfloat f[4]; +}; + +void +weston_matrix_init(struct weston_matrix *matrix); +void +weston_matrix_scale(struct weston_matrix *matrix, GLfloat x, GLfloat y, GLfloat z); +void +weston_matrix_translate(struct weston_matrix *matrix, + GLfloat x, GLfloat y, GLfloat z); +void +weston_matrix_transform(struct weston_matrix *matrix, struct weston_vector *v); + +struct weston_transform { + struct weston_matrix matrix; + struct weston_matrix inverse; +}; + +struct weston_surface; +struct weston_input_device; + +struct weston_mode { + uint32_t flags; + int32_t width, height; + uint32_t refresh; + struct wl_list link; +}; + +struct weston_output { + struct wl_list link; + struct weston_compositor *compositor; + struct weston_matrix matrix; + struct wl_list frame_callback_list; + int32_t x, y, mm_width, mm_height; + pixman_region32_t region; + pixman_region32_t previous_damage; + uint32_t flags; + int repaint_needed; + int repaint_scheduled; + + char *make, *model; + uint32_t subpixel; + + struct weston_mode *current; + struct wl_list mode_list; + struct wl_buffer *scanout_buffer; + struct wl_listener scanout_buffer_destroy_listener; + struct wl_buffer *pending_scanout_buffer; + struct wl_listener pending_scanout_buffer_destroy_listener; + + int (*prepare_render)(struct weston_output *output); + int (*present)(struct weston_output *output); + int (*prepare_scanout_surface)(struct weston_output *output, + struct weston_surface *es); + int (*set_hardware_cursor)(struct weston_output *output, + struct weston_input_device *input); + void (*destroy)(struct weston_output *output); +}; + +struct weston_input_device { + struct wl_input_device input_device; + struct weston_compositor *compositor; + struct weston_surface *sprite; + int32_t hotspot_x, hotspot_y; + struct wl_list link; + uint32_t modifier_state; - struct wl_selection *selection; + + struct wl_list drag_resource_list; + struct weston_data_source *drag_data_source; + struct wl_surface *drag_focus; + struct wl_resource *drag_focus_resource; + struct wl_listener drag_focus_listener; + + struct weston_data_source *selection_data_source; + struct wl_listener selection_data_source_listener; + struct wl_grab grab; + + uint32_t num_tp; + struct wl_surface *touch_focus; + struct wl_listener touch_focus_listener; + struct wl_resource *touch_focus_resource; + struct wl_listener touch_focus_resource_listener; +}; + +enum weston_visual { + WESTON_NONE_VISUAL, + WESTON_ARGB_VISUAL, + WESTON_PREMUL_ARGB_VISUAL, + WESTON_RGB_VISUAL +}; + +struct weston_shader { + GLuint program; + GLuint vertex_shader, fragment_shader; + GLuint proj_uniform; + GLuint tex_uniform; + GLuint alpha_uniform; + GLuint color_uniform; +}; + +struct weston_animation { + void (*frame)(struct weston_animation *animation, + struct weston_output *output, uint32_t msecs); + struct wl_list link; +}; + +struct weston_spring { + double k; + double friction; + double current; + double target; + double previous; + uint32_t timestamp; +}; + +struct weston_shell { + void (*lock)(struct weston_shell *shell); + void (*unlock)(struct weston_shell *shell); + void (*map)(struct weston_shell *shell, struct weston_surface *surface, + int32_t width, int32_t height); + void (*configure)(struct weston_shell *shell, + struct weston_surface *surface, + int32_t x, int32_t y, int32_t width, int32_t height); ++ void (*destroy)(struct weston_shell *shell); +}; + +enum { + WESTON_COMPOSITOR_ACTIVE, + WESTON_COMPOSITOR_IDLE, /* shell->unlock called on activity */ + WESTON_COMPOSITOR_SLEEPING /* no rendering, no frame events */ +}; + ++struct screenshooter; ++ +struct weston_compositor { + struct wl_shm *shm; + struct weston_xserver *wxs; + + EGLDisplay display; + EGLContext context; + EGLConfig config; + GLuint fbo; + GLuint proj_uniform, tex_uniform, alpha_uniform; + uint32_t current_alpha; + struct weston_shader texture_shader; + struct weston_shader solid_shader; + struct wl_display *wl_display; + + struct weston_shell *shell; + + /* There can be more than one, but not right now... */ + struct wl_input_device *input_device; + + struct wl_list output_list; + struct wl_list input_device_list; + struct wl_list surface_list; + struct wl_list binding_list; + struct wl_list animation_list; + struct { + struct weston_spring spring; + struct weston_animation animation; + } fade; + + uint32_t state; + struct wl_event_source *idle_source; + uint32_t idle_inhibit; + int option_idle_time; /* default timeout, s */ + int idle_time; /* effective timeout, s */ + + /* Repaint state. */ + struct timespec previous_swap; + struct wl_array vertices, indices; + + struct weston_surface *overlay; + struct weston_switcher *switcher; + uint32_t focus; + + PFNGLEGLIMAGETARGETRENDERBUFFERSTORAGEOESPROC + image_target_renderbuffer_storage; + PFNGLEGLIMAGETARGETTEXTURE2DOESPROC image_target_texture_2d; + PFNEGLCREATEIMAGEKHRPROC create_image; + PFNEGLDESTROYIMAGEKHRPROC destroy_image; + PFNEGLBINDWAYLANDDISPLAYWL bind_display; + PFNEGLUNBINDWAYLANDDISPLAYWL unbind_display; + int has_bind_display; + + void (*destroy)(struct weston_compositor *ec); + int (*authenticate)(struct weston_compositor *c, uint32_t id); + EGLImageKHR (*create_cursor_image)(struct weston_compositor *c, + int32_t *width, int32_t *height); ++ ++ struct screenshooter *screenshooter; +}; + +#define MODIFIER_CTRL (1 << 8) +#define MODIFIER_ALT (1 << 9) +#define MODIFIER_SUPER (1 << 10) + +enum weston_output_flags { + WL_OUTPUT_FLIPPED = 0x01 +}; + +struct weston_surface { + struct wl_surface surface; + struct weston_compositor *compositor; + GLuint texture, saved_texture; + pixman_region32_t damage; + pixman_region32_t opaque; + int32_t x, y, width, height; + int32_t pitch; + struct wl_list link; + struct wl_list buffer_link; + struct weston_transform *transform; + uint32_t alpha; + uint32_t visual; + + /* + * Which output to vsync this surface to. + * Used to determine, whether to send or queue frame events. + * Must be NULL, if 'link' is not in weston_compositor::surface_list. + */ + struct weston_output *output; + + struct weston_output *fullscreen_output; + struct wl_list frame_callback_list; + + EGLImageKHR image; + + struct wl_buffer *buffer; + struct wl_listener buffer_destroy_listener; +}; + +struct weston_data_source { + struct wl_resource resource; + struct wl_array mime_types; + int refcount; + void *data; + + struct wl_resource *(*create_offer)(struct weston_data_source *source, + struct wl_resource *target); + + void (*cancel)(struct weston_data_source *source); +}; + +void +weston_data_source_unref(struct weston_data_source *source); + +void +weston_input_device_set_selection(struct weston_input_device *device, + struct weston_data_source *source, + uint32_t time); + +void +weston_spring_init(struct weston_spring *spring, + double k, double current, double target); +void +weston_spring_update(struct weston_spring *spring, uint32_t msec); +int +weston_spring_done(struct weston_spring *spring); + +void +weston_surface_activate(struct weston_surface *surface, + struct weston_input_device *device, uint32_t time); + +void +notify_motion(struct wl_input_device *device, + uint32_t time, int x, int y); +void +notify_button(struct wl_input_device *device, + uint32_t time, int32_t button, int32_t state); +void +notify_key(struct wl_input_device *device, + uint32_t time, uint32_t key, uint32_t state); + +void +notify_pointer_focus(struct wl_input_device *device, + uint32_t time, + struct weston_output *output, + int32_t x, int32_t y); + +void +notify_keyboard_focus(struct wl_input_device *device, + uint32_t time, struct weston_output *output, + struct wl_array *keys); + +void +notify_touch(struct wl_input_device *device, uint32_t time, int touch_id, + int x, int y, int touch_type); + +void +weston_output_finish_frame(struct weston_output *output, int msecs); +void +weston_output_damage(struct weston_output *output); +void +weston_compositor_repick(struct weston_compositor *compositor); +void +weston_compositor_schedule_repaint(struct weston_compositor *compositor); +void +weston_compositor_fade(struct weston_compositor *compositor, float tint); +void +weston_compositor_damage_all(struct weston_compositor *compositor); +void +weston_compositor_unlock(struct weston_compositor *compositor); +void +weston_compositor_wake(struct weston_compositor *compositor); +void +weston_compositor_activity(struct weston_compositor *compositor); + +struct weston_binding; +typedef void (*weston_binding_handler_t)(struct wl_input_device *device, + uint32_t time, uint32_t key, + uint32_t button, + uint32_t state, void *data); +struct weston_binding * +weston_compositor_add_binding(struct weston_compositor *compositor, + uint32_t key, uint32_t button, uint32_t modifier, + weston_binding_handler_t binding, void *data); +void +weston_binding_destroy(struct weston_binding *binding); + +void ++weston_binding_list_destroy_all(struct wl_list *list); ++ ++void +weston_compositor_run_binding(struct weston_compositor *compositor, + struct weston_input_device *device, + uint32_t time, + uint32_t key, uint32_t button, int32_t state); + +struct weston_surface * +weston_surface_create(struct weston_compositor *compositor, + int32_t x, int32_t y, int32_t width, int32_t height); + +void +weston_surface_configure(struct weston_surface *surface, + int x, int y, int width, int height); + +void +weston_surface_assign_output(struct weston_surface *surface); + +void +weston_surface_damage(struct weston_surface *surface); + +void +weston_surface_damage_below(struct weston_surface *surface); + +void +weston_surface_damage_rectangle(struct weston_surface *surface, + int32_t x, int32_t y, + int32_t width, int32_t height); + +struct weston_surface * +pick_surface(struct wl_input_device *device, int32_t *sx, int32_t *sy); + +uint32_t +weston_compositor_get_time(void); + +int +weston_compositor_init(struct weston_compositor *ec, struct wl_display *display); +void +weston_compositor_shutdown(struct weston_compositor *ec); +void +weston_output_move(struct weston_output *output, int x, int y); +void +weston_output_init(struct weston_output *output, struct weston_compositor *c, + int x, int y, int width, int height, uint32_t flags); +void +weston_output_destroy(struct weston_output *output); + +void +weston_input_device_init(struct weston_input_device *device, + struct weston_compositor *ec); + +void ++weston_input_device_release(struct weston_input_device *device); ++ ++void +weston_switcher_init(struct weston_compositor *compositor); + +enum { + TTY_ENTER_VT, + TTY_LEAVE_VT +}; + +typedef void (*tty_vt_func_t)(struct weston_compositor *compositor, int event); + +struct tty * +tty_create(struct weston_compositor *compositor, + tty_vt_func_t vt_func, int tty_nr); + +void +tty_destroy(struct tty *tty); + - void ++struct screenshooter * +screenshooter_create(struct weston_compositor *ec); + ++void ++screenshooter_destroy(struct screenshooter *s); ++ +uint32_t * +weston_load_image(const char *filename, + int32_t *width_arg, int32_t *height_arg, + uint32_t *stride_arg); + +struct weston_process; +typedef void (*weston_process_cleanup_func_t)(struct weston_process *process, + int status); + +struct weston_process { + pid_t pid; + weston_process_cleanup_func_t cleanup; + struct wl_list link; +}; + +struct wl_client * +weston_client_launch(struct weston_compositor *compositor, + struct weston_process *proc, + const char *path, + weston_process_cleanup_func_t cleanup); + +int +weston_data_device_manager_init(struct weston_compositor *compositor); +void +weston_data_device_set_keyboard_focus(struct weston_input_device *device); + +void +weston_watch_process(struct weston_process *process); + +int +weston_xserver_init(struct weston_compositor *compositor); +void +weston_xserver_destroy(struct weston_compositor *compositor); +void +weston_xserver_surface_activate(struct weston_surface *surface); +void +weston_xserver_set_selection(struct weston_input_device *device); + +struct weston_zoom; +typedef void (*weston_zoom_done_func_t)(struct weston_zoom *zoom, void *data); + +struct weston_zoom * +weston_zoom_run(struct weston_surface *surface, GLfloat start, GLfloat stop, + weston_zoom_done_func_t done, void *data); + +#endif diff --cc src/screenshooter.c index 191a77f,27967c4..d0c8308 --- a/src/screenshooter.c +++ b/src/screenshooter.c @@@ -27,7 -27,8 +27,8 @@@ struct screenshooter { struct wl_object base; - struct wlsc_compositor *ec; + struct weston_compositor *ec; + struct wl_global *global; }; static void @@@ -64,8 -65,8 +65,8 @@@ bind_shooter(struct wl_client *client &screenshooter_implementation, id, data); } - void + struct screenshooter * -screenshooter_create(struct wlsc_compositor *ec) +screenshooter_create(struct weston_compositor *ec) { struct screenshooter *shooter; diff --cc src/shell.c index 5274d52,4ff5306..0c214b0 --- a/src/shell.c +++ b/src/shell.c @@@ -1234,11 -1233,23 +1233,23 @@@ bind_screensaver(struct wl_client *clie wl_resource_destroy(resource, 0); } + static void -shell_destroy(struct wlsc_shell *base) ++shell_destroy(struct weston_shell *base) + { + struct wl_shell *shell = container_of(base, struct wl_shell, shell); + + if (shell->child.client) + wl_client_destroy(shell->child.client); + + free(shell->screensaver.path); + free(shell); + } + int -shell_init(struct wlsc_compositor *ec); +shell_init(struct weston_compositor *ec); WL_EXPORT int -shell_init(struct wlsc_compositor *ec) +shell_init(struct weston_compositor *ec) { struct wl_shell *shell; @@@ -1277,19 -1289,16 +1289,16 @@@ if (launch_desktop_shell_process(shell) != 0) return -1; - wlsc_compositor_add_binding(ec, 0, BTN_LEFT, MODIFIER_SUPER, + weston_compositor_add_binding(ec, 0, BTN_LEFT, MODIFIER_SUPER, move_binding, shell); - wlsc_compositor_add_binding(ec, 0, BTN_MIDDLE, MODIFIER_SUPER, + weston_compositor_add_binding(ec, 0, BTN_MIDDLE, MODIFIER_SUPER, resize_binding, shell); - wlsc_compositor_add_binding(ec, KEY_BACKSPACE, 0, + weston_compositor_add_binding(ec, KEY_BACKSPACE, 0, MODIFIER_CTRL | MODIFIER_ALT, terminate_binding, ec); - wlsc_compositor_add_binding(ec, 0, BTN_LEFT, 0, + weston_compositor_add_binding(ec, 0, BTN_LEFT, 0, click_to_activate_binding, ec); - - - ec->shell = &shell->shell; return 0; diff --cc src/tablet-shell.c index 46c57a1,5f91209..b673a84 --- a/src/tablet-shell.c +++ b/src/tablet-shell.c @@@ -511,11 -511,21 +511,21 @@@ bind_shell(struct wl_client *client, vo wl_client_add_resource(client, &shell->resource); } + static void -tablet_shell_destroy(struct wlsc_shell *base) ++tablet_shell_destroy(struct weston_shell *base) + { + struct tablet_shell *shell = + container_of(base, struct tablet_shell, shell); + + wl_event_source_remove(shell->long_press_source); + free(shell); + } + void -shell_init(struct wlsc_compositor *compositor); +shell_init(struct weston_compositor *compositor); WL_EXPORT void -shell_init(struct wlsc_compositor *compositor) +shell_init(struct weston_compositor *compositor) { struct tablet_shell *shell; struct wl_event_loop *loop; diff --cc src/util.c index 8914721,6d6c0c9..99dc09e --- a/src/util.c +++ b/src/util.c @@@ -179,18 -179,20 +179,20 @@@ handle_zoom_surface_destroy(struct wl_l } static void -wlsc_zoom_frame(struct wlsc_animation *animation, - struct wlsc_output *output, uint32_t msecs) +weston_zoom_frame(struct weston_animation *animation, + struct weston_output *output, uint32_t msecs) { - struct wlsc_zoom *zoom = - container_of(animation, struct wlsc_zoom, animation); - struct wlsc_surface *es = zoom->surface; + struct weston_zoom *zoom = + container_of(animation, struct weston_zoom, animation); + struct weston_surface *es = zoom->surface; GLfloat scale; - wlsc_spring_update(&zoom->spring, msecs); + weston_spring_update(&zoom->spring, msecs); - if (weston_spring_done(&zoom->spring)) - if (wlsc_spring_done(&zoom->spring)) { - wlsc_zoom_destroy(zoom); ++ if (weston_spring_done(&zoom->spring)) { + weston_zoom_destroy(zoom); + return; + } scale = zoom->start + (zoom->stop - zoom->start) * zoom->spring.current; @@@ -283,12 -285,21 +285,21 @@@ weston_binding_destroy(struct weston_bi } WL_EXPORT void -wlsc_binding_list_destroy_all(struct wl_list *list) ++weston_binding_list_destroy_all(struct wl_list *list) + { - struct wlsc_binding *binding, *tmp; ++ struct weston_binding *binding, *tmp; + + wl_list_for_each_safe(binding, tmp, list, link) - wlsc_binding_destroy(binding); ++ weston_binding_destroy(binding); + } + + WL_EXPORT void -wlsc_compositor_run_binding(struct wlsc_compositor *compositor, - struct wlsc_input_device *device, - uint32_t time, - uint32_t key, uint32_t button, int32_t state) +weston_compositor_run_binding(struct weston_compositor *compositor, - struct weston_input_device *device, - uint32_t time, - uint32_t key, uint32_t button, int32_t state) ++ struct weston_input_device *device, ++ uint32_t time, ++ uint32_t key, uint32_t button, int32_t state) { - struct wlsc_binding *b; + struct weston_binding *b; wl_list_for_each(b, &compositor->binding_list, link) { if (b->key == key && b->button == button &&