pixman_region32_init(&surface->transform.opaque);
wl_list_init(&surface->frame_callback_list);
- surface->buffer_destroy_listener.notify = surface_handle_buffer_destroy;
+ surface->buffer_destroy_listener.notify =
+ surface_handle_buffer_destroy;
wl_list_init(&surface->geometry.transformation_list);
wl_list_insert(&surface->geometry.transformation_list,
compositor->fade.surface = NULL;
} else if (compositor->fade.spring.current > 0.999) {
compositor->state = WESTON_COMPOSITOR_SLEEPING;
- compositor->shell->lock(compositor->shell);
+ wl_signal_emit(&compositor->lock_signal, compositor);
}
}
}
weston_compositor_wake(compositor);
} else {
weston_compositor_dpms_on(compositor);
- compositor->shell->unlock(compositor->shell);
+ wl_signal_emit(&compositor->unlock_signal, compositor);
}
}
weston_surface_activate(struct weston_surface *surface,
struct weston_input_device *device)
{
+ struct weston_compositor *compositor = device->compositor;
+
wl_input_device_set_keyboard_focus(&device->input_device,
&surface->surface);
wl_data_device_set_keyboard_focus(&device->input_device);
+
+ wl_signal_emit(&compositor->activate_signal, surface);
}
WL_EXPORT void
const char *extensions;
ec->wl_display = display;
+ wl_signal_init(&ec->destroy_signal);
+ wl_signal_init(&ec->activate_signal);
+ wl_signal_init(&ec->lock_signal);
+ wl_signal_init(&ec->unlock_signal);
ec->launcher_sock = weston_environment_get_fd("WESTON_LAUNCHER_SOCK");
if (!wl_display_add_global(display, &wl_compositor_interface,
weston_layer_init(&ec->fade_layer, &ec->layer_list);
weston_layer_init(&ec->cursor_layer, &ec->fade_layer.link);
- ec->screenshooter = screenshooter_create(ec);
+ screenshooter_create(ec);
wl_data_device_manager_init(ec->wl_display);
if (ec->input_loop_source)
wl_event_source_remove(ec->input_loop_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);
/* prevent further rendering while shutting down */
ec->state = WESTON_COMPOSITOR_SLEEPING;
-#ifdef BUILD_XSERVER_LAUNCHER
- if (xserver)
- weston_xserver_destroy(ec);
-#endif
-
- ec->shell->destroy(ec->shell);
+ wl_signal_emit(&ec->destroy_signal, ec);
if (ec->has_bind_display)
ec->unbind_display(ec->display, display);
uint32_t timestamp;
};
-struct weston_shell {
- void (*lock)(struct weston_shell *shell);
- void (*unlock)(struct weston_shell *shell);
- void (*destroy)(struct weston_shell *shell);
-};
-
enum {
WESTON_COMPOSITOR_ACTIVE,
WESTON_COMPOSITOR_IDLE, /* shell->unlock called on activity */
struct weston_compositor {
struct wl_shm *shm;
- struct weston_xserver *wxs;
+ struct wl_signal destroy_signal;
EGLDisplay display;
EGLContext context;
struct weston_shader *current_shader;
struct wl_display *wl_display;
- struct weston_shell *shell;
+ struct wl_signal activate_signal;
+ struct wl_signal lock_signal;
+ struct wl_signal unlock_signal;
struct wl_event_loop *input_loop;
struct wl_event_source *input_loop_source;
int
tty_activate_vt(struct tty *tty, int vt);
-struct screenshooter *
-screenshooter_create(struct weston_compositor *ec);
-
void
-screenshooter_destroy(struct screenshooter *s);
+screenshooter_create(struct weston_compositor *ec);
struct weston_process;
typedef void (*weston_process_cleanup_func_t)(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 wl_global *global;
struct wl_client *client;
struct weston_process process;
+ struct wl_listener destroy_listener;
};
static void
screenshooter_exe, screenshooter_sigchld);
}
-struct screenshooter *
+static void
+screenshooter_destroy(struct wl_listener *listener, void *data)
+{
+ struct screenshooter *shooter =
+ container_of(listener, struct screenshooter, destroy_listener);
+
+ wl_display_remove_global(shooter->ec->wl_display, shooter->global);
+ free(shooter);
+}
+
+void
screenshooter_create(struct weston_compositor *ec)
{
struct screenshooter *shooter;
shooter = malloc(sizeof *shooter);
if (shooter == NULL)
- return NULL;
+ return;
shooter->base.interface = &screenshooter_interface;
shooter->base.implementation =
weston_compositor_add_binding(ec, KEY_S, 0, 0, MODIFIER_SUPER,
screenshooter_binding, shooter);
- return shooter;
-}
-
-void
-screenshooter_destroy(struct screenshooter *shooter)
-{
- wl_display_remove_global(shooter->ec->wl_display, shooter->global);
- free(shooter);
+ shooter->destroy_listener.notify = screenshooter_destroy;
+ wl_signal_add(&ec->destroy_signal, &shooter->destroy_listener);
}
struct wl_shell {
struct weston_compositor *compositor;
- struct weston_shell shell;
+
+ struct wl_listener lock_listener;
+ struct wl_listener unlock_listener;
+ struct wl_listener destroy_listener;
struct weston_layer fullscreen_layer;
struct weston_layer panel_layer;
struct weston_surface *surface;
struct wl_listener surface_destroy_listener;
struct shell_surface *parent;
+ struct wl_shell *shell;
enum shell_surface_type type;
int32_t saved_x, saved_y;
static struct wl_shell *
shell_surface_get_shell(struct shell_surface *shsurf)
{
- struct weston_surface *es = shsurf->surface;
- struct weston_shell *shell = es->compositor->shell;
-
- return (struct wl_shell *)container_of(shell, struct wl_shell, shell);
+ return shsurf->shell;
}
static int
(void (**)(void)) &shell_surface_implementation;
shsurf->resource.data = shsurf;
+ shsurf->shell = resource->data;
shsurf->saved_position_valid = false;
shsurf->surface = surface;
shsurf->fullscreen.type = WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT;
}
static void
-activate(struct weston_shell *base, struct weston_surface *es,
+activate(struct wl_shell *shell, struct weston_surface *es,
struct weston_input_device *device)
{
- struct wl_shell *shell = container_of(base, struct wl_shell, shell);
- struct weston_compositor *compositor = shell->compositor;
struct weston_surface *surf, *prev;
weston_surface_activate(es, device);
- if (compositor->wxs)
- weston_xserver_surface_activate(es);
-
switch (get_shell_surface_type(es)) {
case SHELL_SURFACE_BACKGROUND:
case SHELL_SURFACE_PANEL:
uint32_t button, uint32_t axis, int32_t state, void *data)
{
struct weston_input_device *wd = (struct weston_input_device *) device;
- struct weston_compositor *compositor = data;
+ struct wl_shell *shell = data;
struct weston_surface *focus;
struct weston_surface *upper;
focus = upper;
if (state && device->pointer_grab == &device->default_pointer_grab)
- activate(compositor->shell, focus, wd);
+ activate(shell, focus, wd);
}
static void
-lock(struct weston_shell *base)
+lock(struct wl_listener *listener, void *data)
{
- struct wl_shell *shell = container_of(base, struct wl_shell, shell);
+ struct wl_shell *shell =
+ container_of(listener, struct wl_shell, lock_listener);
struct weston_input_device *device;
struct shell_surface *shsurf;
struct weston_output *output;
}
static void
-unlock(struct weston_shell *base)
+unlock(struct wl_listener *listener, void *data)
{
- struct wl_shell *shell = container_of(base, struct wl_shell, shell);
+ struct wl_shell *shell =
+ container_of(listener, struct wl_shell, unlock_listener);
if (!shell->locked || shell->lock_surface) {
weston_compositor_wake(shell->compositor);
}
static void
-map(struct weston_shell *base, struct weston_surface *surface,
+map(struct wl_shell *shell, struct weston_surface *surface,
int32_t width, int32_t height, int32_t sx, int32_t sy)
{
- struct wl_shell *shell = container_of(base, struct wl_shell, shell);
struct weston_compositor *compositor = shell->compositor;
struct shell_surface *shsurf;
enum shell_surface_type surface_type = SHELL_SURFACE_NONE;
case SHELL_SURFACE_FULLSCREEN:
case SHELL_SURFACE_MAXIMIZED:
if (!shell->locked)
- activate(base, surface,
+ activate(shell, surface,
(struct weston_input_device *)
compositor->input_device);
break;
}
static void
-configure(struct weston_shell *base, struct weston_surface *surface,
+configure(struct wl_shell *shell, struct weston_surface *surface,
GLfloat x, GLfloat y, int32_t width, int32_t height)
{
- struct wl_shell *shell = container_of(base, struct wl_shell, shell);
enum shell_surface_type surface_type = SHELL_SURFACE_NONE;
enum shell_surface_type prev_surface_type = SHELL_SURFACE_NONE;
struct shell_surface *shsurf;
static void
shell_surface_configure(struct weston_surface *es, int32_t sx, int32_t sy)
{
- struct weston_shell *shell = es->compositor->shell;
struct shell_surface *shsurf = get_shell_surface(es);
+ struct wl_shell *shell = shsurf->shell;
if (!weston_surface_is_mapped(es)) {
map(shell, es, es->buffer->width, es->buffer->height, sx, sy);
}
struct switcher {
- struct weston_compositor *compositor;
+ struct wl_shell *shell;
struct weston_surface *current;
struct wl_listener listener;
struct wl_keyboard_grab grab;
static void
switcher_next(struct switcher *switcher)
{
- struct weston_compositor *compositor = switcher->compositor;
+ struct weston_compositor *compositor = switcher->shell->compositor;
struct weston_surface *surface;
struct weston_surface *first = NULL, *prev = NULL, *next = NULL;
struct shell_surface *shsurf;
static void
switcher_destroy(struct switcher *switcher, uint32_t time)
{
- struct weston_compositor *compositor = switcher->compositor;
+ struct weston_compositor *compositor = switcher->shell->compositor;
struct weston_surface *surface;
struct weston_input_device *device =
(struct weston_input_device *) switcher->grab.input_device;
}
if (switcher->current)
- activate(compositor->shell, switcher->current, device);
+ activate(switcher->shell, switcher->current, device);
wl_list_remove(&switcher->listener.link);
wl_input_device_end_keyboard_grab(&device->input_device);
free(switcher);
uint32_t key, uint32_t button, uint32_t axis,
int32_t state, void *data)
{
- struct weston_compositor *compositor = data;
+ struct wl_shell *shell = data;
struct switcher *switcher;
switcher = malloc(sizeof *switcher);
- switcher->compositor = compositor;
+ switcher->shell = shell;
switcher->current = NULL;
switcher->listener.notify = switcher_handle_surface_destroy;
wl_list_init(&switcher->listener.link);
debug_repaint_binding(struct wl_input_device *device, uint32_t time,
uint32_t key, uint32_t button, uint32_t axis, int32_t state, void *data)
{
- struct weston_compositor *compositor = data;
- struct wl_shell *shell =
- container_of(compositor->shell, struct wl_shell, shell);
+ struct wl_shell *shell = data;
+ struct weston_compositor *compositor = shell->compositor;
struct weston_surface *surface;
if (shell->debug_repaint_surface) {
}
static void
-shell_destroy(struct weston_shell *base)
+shell_destroy(struct wl_listener *listener, void *data)
{
- struct wl_shell *shell = container_of(base, struct wl_shell, shell);
+ struct wl_shell *shell =
+ container_of(listener, struct wl_shell, destroy_listener);
if (shell->child.client)
wl_client_destroy(shell->child.client);
memset(shell, 0, sizeof *shell);
shell->compositor = ec;
- shell->shell.lock = lock;
- shell->shell.unlock = unlock;
- shell->shell.destroy = shell_destroy;
+
+ shell->destroy_listener.notify = shell_destroy;
+ wl_signal_add(&ec->destroy_signal, &shell->destroy_listener);
+ shell->lock_listener.notify = lock;
+ wl_signal_add(&ec->lock_signal, &shell->lock_listener);
+ shell->unlock_listener.notify = unlock;
+ wl_signal_add(&ec->unlock_signal, &shell->unlock_listener);
wl_list_init(&shell->backgrounds);
wl_list_init(&shell->panels);
MODIFIER_CTRL | MODIFIER_ALT,
terminate_binding, ec);
weston_compositor_add_binding(ec, 0, BTN_LEFT, 0, 0,
- click_to_activate_binding, ec);
+ click_to_activate_binding, shell);
weston_compositor_add_binding(ec, 0, 0, WL_INPUT_DEVICE_AXIS_VERTICAL_SCROLL,
MODIFIER_SUPER | MODIFIER_ALT,
surface_opacity_binding, NULL);
MODIFIER_SUPER | MODIFIER_ALT,
rotate_binding, NULL);
weston_compositor_add_binding(ec, KEY_TAB, 0, 0, MODIFIER_SUPER,
- switcher_binding, ec);
+ switcher_binding, shell);
/* brightness */
weston_compositor_add_binding(ec, KEY_F9, 0, 0, MODIFIER_CTRL,
backlight_binding, ec);
weston_compositor_add_binding(ec, KEY_SPACE, 0, 0, MODIFIER_SUPER,
- debug_repaint_binding, ec);
-
- ec->shell = &shell->shell;
+ debug_repaint_binding, shell);
return 0;
}
struct tablet_shell {
struct wl_resource resource;
- struct weston_shell shell;
+ struct wl_listener lock_listener;
+ struct wl_listener unlock_listener;
+ struct wl_listener destroy_listener;
struct weston_compositor *compositor;
struct weston_process process;
};
static void
+tablet_shell_destroy(struct wl_listener *listener, void *data);
+
+static struct tablet_shell *
+get_shell(struct weston_compositor *compositor)
+{
+ struct wl_listener *l;
+
+ l = wl_signal_get(&compositor->destroy_signal, tablet_shell_destroy);
+ if (l)
+ return container_of(l, struct tablet_shell, destroy_listener);
+
+ return NULL;
+}
+
+static void
tablet_shell_sigchld(struct weston_process *process, int status)
{
struct tablet_shell *shell =
tablet_shell_surface_configure(struct weston_surface *surface,
int32_t sx, int32_t sy)
{
- struct tablet_shell *shell =
- container_of(surface->compositor->shell,
- struct tablet_shell, shell);
+ struct tablet_shell *shell = get_shell(surface->compositor);
int32_t width, height;
if (weston_surface_is_mapped(surface))
}
static void
-tablet_shell_lock(struct weston_shell *base)
+tablet_shell_lock(struct wl_listener *listener, void *data)
{
struct tablet_shell *shell =
- container_of(base, struct tablet_shell, shell);
+ container_of(listener, struct tablet_shell, lock_listener);
if (shell->state == STATE_LOCKED)
return;
}
static void
-tablet_shell_unlock(struct weston_shell *base)
+tablet_shell_unlock(struct wl_listener *listener, void *data)
{
struct tablet_shell *shell =
- container_of(base, struct tablet_shell, shell);
+ container_of(listener, struct tablet_shell, lock_listener);
weston_compositor_wake(shell->compositor);
}
}
static void
-tablet_shell_destroy(struct weston_shell *base)
+tablet_shell_destroy(struct wl_listener *listener, void *data)
{
struct tablet_shell *shell =
- container_of(base, struct tablet_shell, shell);
+ container_of(listener, struct tablet_shell, destroy_listener);
if (shell->home_surface)
shell->home_surface->configure = NULL;
memset(shell, 0, sizeof *shell);
shell->compositor = compositor;
+ shell->destroy_listener.notify = tablet_shell_destroy;
+ wl_signal_add(&compositor->destroy_signal, &shell->destroy_listener);
+ shell->lock_listener.notify = tablet_shell_lock;
+ wl_signal_add(&compositor->lock_signal, &shell->lock_listener);
+ shell->unlock_listener.notify = tablet_shell_unlock;
+ wl_signal_add(&compositor->unlock_signal, &shell->unlock_listener);
+
/* FIXME: This will make the object available to all clients. */
wl_display_add_global(compositor->wl_display,
&tablet_shell_interface, shell, bind_shell);
weston_compositor_add_binding(compositor, KEY_COMPOSE, 0, 0, 0,
menu_key_binding, shell);
- compositor->shell = &shell->shell;
-
- shell->shell.lock = tablet_shell_lock;
- shell->shell.unlock = tablet_shell_unlock;
- shell->shell.destroy = tablet_shell_destroy;
-
weston_layer_init(&shell->homescreen_layer,
&compositor->cursor_layer.link);
weston_layer_init(&shell->lockscreen_layer,
struct wl_client *client;
struct weston_compositor *compositor;
struct weston_wm *wm;
+ struct wl_listener activate_listener;
+ struct wl_listener destroy_listener;
};
struct weston_wm {
XCB_INPUT_FOCUS_POINTER_ROOT, window->id, time);
}
-WL_EXPORT void
-weston_xserver_surface_activate(struct weston_surface *surface)
+static void
+weston_xserver_surface_activate(struct wl_listener *listener, void *data)
{
+ struct weston_surface *surface = data;
struct weston_wm_window *window = get_wm_window(surface);
- struct weston_xserver *wxs = surface->compositor->wxs;
+ struct weston_xserver *wxs =
+ container_of(listener,
+ struct weston_xserver, activate_listener);
if (window)
weston_wm_activate(wxs->wm, window, XCB_TIME_CURRENT_TIME);
return 0;
}
+static void
+weston_xserver_destroy(struct wl_listener *l, void *data)
+{
+ struct weston_xserver *wxs =
+ container_of(l, struct weston_xserver, destroy_listener);
+
+ if (!wxs)
+ return;
+
+ if (wxs->loop)
+ weston_xserver_shutdown(wxs);
+
+ free(wxs);
+}
+
int
weston_xserver_init(struct weston_compositor *compositor)
{
wl_display_add_global(display, &xserver_interface, mxs, bind_xserver);
- compositor->wxs = mxs;
-
- return 0;
-}
-
-void
-weston_xserver_destroy(struct weston_compositor *compositor)
-{
- struct weston_xserver *wxs = compositor->wxs;
+ mxs->destroy_listener.notify = weston_xserver_destroy;
+ wl_signal_add(&compositor->destroy_signal, &mxs->destroy_listener);
- if (!wxs)
- return;
- if (wxs->loop)
- weston_xserver_shutdown(wxs);
+ mxs->activate_listener.notify = weston_xserver_surface_activate;
+ wl_signal_add(&compositor->activate_signal, &mxs->activate_listener);
- free(wxs);
+ return 0;
}