tablet-shell: come back to life

A couple of fixes were made: Weston tablet-shell needed to use weston_layer,
so the compositor could rebuild the surface list correctly when repainting;
homescreen and locking are using the widget + window abstration of toytoolkit;
and widget_set_redraw_handler are being set for widgets redraw.

Also, it was given some basic meaning for lockscreen_button_handler, which
was completely disabled before. As a clean up, I updated the global listener
mechanism on tablet-shell client, using the regular way of registering a
handler instead wl_display_roundtrip -> wl_display_get_global.

Switcher still without code to proper work and the same for tablet-shell
clients, which are not launched.

krh: Edited to not scale down homescreen icons, use new load_cairo_surface()
for image loading.

Signed-off-by: Tiago Vignatti <tiago.vignatti@intel.com>

diff --git a/clients/tablet-shell.c b/clients/tablet-shell.c
index 3a532c4..e486782 100644 (file)
--- a/clients/tablet-shell.c
+++ b/clients/tablet-shell.c
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2011 Intel Corporation
+ * Copyright © 2011, 2012 Intel Corporation
  *
  * Permission to use, copy, modify, distribute, and sell this software and its
  * documentation for any purpose is hereby granted without fee, provided that
@@ -24,6 +24,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <sys/wait.h>
 
 #include "window.h"
 #include "cairo-util.h"
@@ -31,16 +32,27 @@
 
 #include "tablet-shell-client-protocol.h"
 
-struct tablet_shell {
+struct tablet {
        struct display *display;
        struct tablet_shell *tablet_shell;
        struct rectangle allocation;
-       struct window *lockscreen;
        struct window *switcher;
-       struct window *homescreen;
+
+       struct homescreen *homescreen;
+       struct lockscreen *lockscreen;
+};
+
+struct homescreen {
+       struct window *window;
+       struct widget *widget;
        struct wl_list launcher_list;
 };
 
+struct lockscreen {
+       struct window *window;
+       struct widget *widget;
+};
+
 struct launcher {
        cairo_surface_t *icon;
        char *path;
@@ -74,6 +86,16 @@ static const struct config_section config_sections[] = {
 };
 
 static void
+sigchild_handler(int s)
+{
+       int status;
+       pid_t pid;
+
+       while (pid = waitpid(-1, &status, WNOHANG), pid > 0)
+               fprintf(stderr, "child %d exited\n", pid);
+}
+
+static void
 paint_background(cairo_t *cr, const char *path, struct rectangle *allocation)
 {
        cairo_surface_t *image = NULL;
@@ -97,16 +119,16 @@ paint_background(cairo_t *cr, const char *path, struct rectangle *allocation)
                cairo_surface_destroy(image);
                cairo_paint(cr);
        } else {
-               fprintf(stderr, "couldn't load backgrond image: %s\n",
-                       key_lockscreen_background);
+               fprintf(stderr, "couldn't load background image: %s\n", path);
                cairo_set_source_rgb(cr, 0.2, 0, 0);
                cairo_paint(cr);
        }
 }
 
 static void
-homescreen_draw(struct tablet_shell *shell)
+homescreen_draw(struct widget *widget, void *data)
 {
+       struct homescreen *homescreen = data;
        cairo_surface_t *surface;
        struct rectangle allocation;
        cairo_pattern_t *pattern;
@@ -116,11 +138,10 @@ homescreen_draw(struct tablet_shell *shell)
        const int rows = 4, columns = 5, icon_width = 128, icon_height = 128;
        int x, y, i, width, height, vmargin, hmargin, vpadding, hpadding;
 
-       window_create_surface(shell->homescreen);
-       window_get_allocation(shell->homescreen, &allocation);
-       surface = window_get_surface(shell->homescreen);
+       surface = window_get_surface(homescreen->window);
        cr = cairo_create(surface);
 
+       widget_get_allocation(widget, &allocation);
        paint_background(cr, key_homescreen_background, &allocation);
 
        cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
@@ -137,10 +158,9 @@ homescreen_draw(struct tablet_shell *shell)
        y = vmargin;
        i = 0;
 
-       wl_list_for_each(launcher, &shell->launcher_list, link) {
+       wl_list_for_each(launcher, &homescreen->launcher_list, link) {
                pattern = cairo_pattern_create_for_surface(launcher->icon);
-               cairo_matrix_init_scale(&matrix, 2.0, 2.0);
-               cairo_matrix_translate(&matrix, -x, -y);
+               cairo_matrix_init_translate(&matrix, -x, -y);
                cairo_pattern_set_matrix(pattern, &matrix);
                cairo_pattern_set_extend(pattern, CAIRO_EXTEND_NONE);
                cairo_set_source(cr, pattern);
@@ -155,67 +175,116 @@ homescreen_draw(struct tablet_shell *shell)
                }
        }
 
-       cairo_surface_flush(surface);
+       cairo_destroy(cr);
        cairo_surface_destroy(surface);
-       window_flush(shell->homescreen);
 }
 
-
 static void
-lockscreen_draw(struct tablet_shell *shell)
+lockscreen_draw(struct widget *widget, void *data)
 {
+       struct lockscreen *lockscreen = data;
        cairo_surface_t *surface;
        cairo_surface_t *icon;
        struct rectangle allocation;
        cairo_t *cr;
        int width, height;
 
-       window_create_surface(shell->lockscreen);
-       window_get_allocation(shell->lockscreen, &allocation);
-       surface = window_get_surface(shell->lockscreen);
+       surface = window_get_surface(lockscreen->window);
        cr = cairo_create(surface);
 
+       widget_get_allocation(widget, &allocation);
        paint_background(cr, key_lockscreen_background, &allocation);
 
        cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
-       icon = cairo_image_surface_create_from_png(key_lockscreen_icon);
+       icon = load_cairo_surface(key_lockscreen_icon);
        width = cairo_image_surface_get_width(icon);
        height = cairo_image_surface_get_height(icon);
        cairo_set_source_surface(cr, icon,
                                 allocation.x + (allocation.width - width) / 2,
                                 allocation.y + (allocation.height - height) / 2);
        cairo_paint(cr);
+       cairo_destroy(cr);
        cairo_surface_destroy(icon);
-
-       cairo_surface_flush(surface);
        cairo_surface_destroy(surface);
-       window_flush(shell->lockscreen);
+}
+
+static void
+lockscreen_button_handler(struct widget *widget,
+                         struct input *input, uint32_t time,
+                         int button, int state, void *data)
+{
+       struct lockscreen *lockscreen = data;
+
+       if (state && lockscreen->window) {
+               window_destroy(lockscreen->window);
+               lockscreen->window = NULL;
+       }
+}
+
+static struct homescreen *
+homescreen_create(struct tablet *tablet)
+{
+       struct homescreen *homescreen;
+
+       homescreen = malloc (sizeof *homescreen);
+       memset(homescreen, 0, sizeof *homescreen);
+
+       homescreen->window = window_create(tablet->display);
+       homescreen->widget =
+               window_add_widget(homescreen->window, homescreen);
+       window_set_custom(homescreen->window);
+       window_set_user_data(homescreen->window, homescreen);
+       window_set_title(homescreen->window, "homescreen");
+       widget_set_redraw_handler(homescreen->widget, homescreen_draw);
+
+       return homescreen;
+}
+
+static struct lockscreen *
+lockscreen_create(struct tablet *tablet)
+{
+       struct lockscreen *lockscreen;
+
+       lockscreen = malloc (sizeof *lockscreen);
+       memset(lockscreen, 0, sizeof *lockscreen);
+
+       lockscreen->window = window_create(tablet->display);
+       lockscreen->widget =
+               window_add_widget(lockscreen->window, lockscreen);
+       window_set_user_data(lockscreen->window, lockscreen);
+       window_set_title(lockscreen->window, "lockscreen");
+       window_set_custom(lockscreen->window);
+       widget_set_redraw_handler(lockscreen->widget, lockscreen_draw);
+       widget_set_button_handler(lockscreen->widget,
+                                 lockscreen_button_handler);
+
+       return lockscreen;
 }
 
 static void
 show_lockscreen(void *data, struct tablet_shell *tablet_shell)
 {
-       struct tablet_shell *shell = data;
+       struct tablet *tablet = data;
 
-       shell->lockscreen = window_create(shell->display);
-       window_set_user_data(shell->lockscreen, shell);
-       window_set_custom(shell->lockscreen);
+       tablet->lockscreen = lockscreen_create(tablet);
+       tablet_shell_set_lockscreen(tablet->tablet_shell,
+                       window_get_wl_surface(tablet->lockscreen->window));
 
-       tablet_shell_set_lockscreen(shell->tablet_shell,
-                                   window_get_wl_surface(shell->lockscreen));
-       lockscreen_draw(shell);
+       widget_schedule_resize(tablet->lockscreen->widget,
+                              tablet->allocation.width,
+                              tablet->allocation.height);
 }
 
 static void
 show_switcher(void *data, struct tablet_shell *tablet_shell)
 {
-       struct tablet_shell *shell = data;
+       struct tablet *tablet = data;
 
-       shell->switcher = window_create(shell->display);
-       window_set_user_data(shell->switcher, shell);
-       window_set_custom(shell->switcher);
-       tablet_shell_set_switcher(shell->tablet_shell,
-                                 window_get_wl_surface(shell->switcher));
+       tablet->switcher = window_create(tablet->display);
+       window_set_user_data(tablet->switcher, tablet);
+       window_set_custom(tablet->switcher);
+       tablet_shell_set_switcher(tablet->tablet_shell,
+                                 window_get_wl_surface(tablet->switcher));
 }
 
 static void
@@ -229,63 +298,36 @@ static const struct tablet_shell_listener tablet_shell_listener = {
        hide_switcher
 };
 
-static struct tablet_shell *
-tablet_shell_create(struct display *display, uint32_t id)
-{
-       struct tablet_shell *shell;
-       struct output *output;
-
-       shell = malloc(sizeof *shell);
-
-       shell->display = display;
-       shell->tablet_shell =
-               wl_display_bind(display_get_display(display),
-                               id, &tablet_shell_interface);
-       tablet_shell_add_listener(shell->tablet_shell,
-                                 &tablet_shell_listener, shell);
-       output = display_get_output(display);
-       output_get_allocation(output, &shell->allocation);
-
-       shell->homescreen = window_create(display);
-       window_set_user_data(shell->homescreen, shell);
-       window_set_custom(shell->homescreen);
-
-       tablet_shell_set_homescreen(shell->tablet_shell,
-                                   window_get_wl_surface(shell->homescreen));
-       wl_list_init(&shell->launcher_list);
-
-       return shell;
-}
-
 static void
-tablet_shell_add_launcher(struct tablet_shell *shell,
+tablet_shell_add_launcher(struct tablet *tablet,
                          const char *icon, const char *path)
 {
        struct launcher *launcher;
+       struct homescreen *homescreen = tablet->homescreen;
 
        launcher = malloc(sizeof *launcher);
        launcher->path = strdup(path);
-       launcher->icon = cairo_image_surface_create_from_png(icon);
+       launcher->icon = load_cairo_surface(icon);
        if (cairo_surface_status (launcher->icon) != CAIRO_STATUS_SUCCESS) {
                fprintf(stderr, "couldn't load %s\n", icon);
                free(launcher);
                return;
        }
 
-       wl_list_insert(&shell->launcher_list, &launcher->link);
+       wl_list_insert(&homescreen->launcher_list, &launcher->link);
 }
 
 static void
 launcher_section_done(void *data)
 {
-       struct tablet_shell *shell = data;
+       struct tablet *tablet = data;
 
        if (key_launcher_icon == NULL || key_launcher_path == NULL) {
                fprintf(stderr, "invalid launcher section\n");
                return;
        }
 
-       tablet_shell_add_launcher(shell, key_launcher_icon, key_launcher_path);
+       tablet_shell_add_launcher(tablet, key_launcher_icon, key_launcher_path);
 
        free(key_launcher_icon);
        key_launcher_icon = NULL;
@@ -293,12 +335,26 @@ launcher_section_done(void *data)
        key_launcher_path = NULL;
 }
 
+static void
+global_handler(struct wl_display *display, uint32_t id,
+               const char *interface, uint32_t version, void *data)
+{
+       struct tablet *tablet = data;
+
+       if (!strcmp(interface, "tablet_shell")) {
+               tablet->tablet_shell =
+                       wl_display_bind(display, id, &tablet_shell_interface);
+               tablet_shell_add_listener(tablet->tablet_shell,
+                               &tablet_shell_listener, tablet);
+       }
+}
+
 int main(int argc, char *argv[])
 {
+       struct tablet tablet = { 0 };
        struct display *display;
        char *config_file;
-       uint32_t id;
-       struct tablet_shell *shell;
+       struct output *output;
 
        display = display_create(argc, argv);
        if (display == NULL) {
@@ -306,19 +362,29 @@ int main(int argc, char *argv[])
                return -1;
        }
 
-       wl_display_roundtrip(display_get_display(display));
-       id = wl_display_get_global(display_get_display(display),
-                                  "tablet_shell", 1);
-       shell = tablet_shell_create(display, id);
+       tablet.display = display;
+
+       wl_display_add_global_listener(display_get_display(tablet.display),
+                       global_handler, &tablet);
+
+       tablet.homescreen = homescreen_create(&tablet);
+       tablet_shell_set_homescreen(tablet.tablet_shell,
+                       window_get_wl_surface(tablet.homescreen->window));
+       wl_list_init(&tablet.homescreen->launcher_list);
 
        config_file = config_file_path("weston.ini");
        parse_config_file(config_file,
                          config_sections, ARRAY_LENGTH(config_sections),
-                         shell);
+                         &tablet);
        free(config_file);
 
-       homescreen_draw(shell);
+       signal(SIGCHLD, sigchild_handler);
 
+       output = display_get_output(tablet.display);
+       output_get_allocation(output, &tablet.allocation);
+       widget_schedule_resize(tablet.homescreen->widget,
+                       tablet.allocation.width,
+                       tablet.allocation.height);
        display_run(display);
 
        return 0;

diff --git a/src/tablet-shell.c b/src/tablet-shell.c
index fe215ab..cb7211c 100644 (file)
--- a/src/tablet-shell.c
+++ b/src/tablet-shell.c
@@ -57,8 +57,10 @@ struct tablet_shell {
 
        struct weston_surface *lockscreen_surface;
        struct wl_listener lockscreen_listener;
+       struct weston_layer lockscreen_layer;
 
        struct weston_surface *home_surface;
+       struct weston_layer homescreen_layer;
 
        struct weston_surface *switcher_surface;
        struct wl_listener switcher_listener;
@@ -113,11 +115,16 @@ tablet_shell_map(struct weston_shell *base, struct weston_surface *surface,
        weston_surface_configure(surface, 0, 0, width, height);
 
        if (surface == shell->lockscreen_surface) {
-               /* */
+                       wl_list_insert(&shell->lockscreen_layer.surface_list,
+                                       &surface->layer_link);
        } else if (surface == shell->switcher_surface) {
                /* */
        } else if (surface == shell->home_surface) {
                if (shell->state == STATE_STARTING) {
+                       /* homescreen always visible, at the bottom */
+                       wl_list_insert(&shell->homescreen_layer.surface_list,
+                                       &surface->layer_link);
+
                        tablet_shell_set_state(shell, STATE_LOCKED);
                        shell->previous_state = STATE_HOME;
                        tablet_shell_send_show_lockscreen(&shell->resource);
@@ -144,6 +151,17 @@ tablet_shell_configure(struct weston_shell *base,
 }
 
 static void
+tablet_shell_surface_configure(struct weston_surface *es, int32_t sx,
+                              int32_t sy)
+{
+       struct weston_shell *shell = es->compositor->shell;
+
+       if (!weston_surface_is_mapped(es))
+               tablet_shell_map(shell, es, es->buffer->width,
+                                es->buffer->height, sx, sy);
+}
+
+static void
 handle_lockscreen_surface_destroy(struct wl_listener *listener,
                                  struct wl_resource *resource, uint32_t time)
 {
@@ -165,6 +183,7 @@ tablet_shell_set_lockscreen(struct wl_client *client,
 
        weston_surface_set_position(es, 0, 0);
        shell->lockscreen_surface = es;
+       shell->lockscreen_surface->configure = tablet_shell_surface_configure;
        shell->lockscreen_listener.func = handle_lockscreen_surface_destroy;
        wl_list_insert(es->surface.resource.destroy_listener_list.prev,
                       &shell->lockscreen_listener.link);
@@ -211,6 +230,8 @@ tablet_shell_set_homescreen(struct wl_client *client,
        struct tablet_shell *shell = resource->data;
 
        shell->home_surface = surface_resource->data;
+       shell->home_surface->configure = tablet_shell_surface_configure;
+
        weston_surface_set_position(shell->home_surface, 0, 0);
 }
 
@@ -506,6 +527,12 @@ tablet_shell_destroy(struct weston_shell *base)
        struct tablet_shell *shell =
                container_of(base, struct tablet_shell, shell);
 
+       if (shell->home_surface)
+               shell->home_surface->configure = NULL;
+
+       if (shell->lockscreen_surface)
+               shell->lockscreen_surface->configure = NULL;
+
        wl_event_source_remove(shell->long_press_source);
        free(shell);
 }
@@ -553,6 +580,10 @@ shell_init(struct weston_compositor *compositor)
        shell->shell.configure = tablet_shell_configure;
        shell->shell.destroy = tablet_shell_destroy;
 
+       weston_layer_init(&shell->homescreen_layer,
+                         &compositor->cursor_layer.link);
+       weston_layer_init(&shell->lockscreen_layer,
+                         &compositor->cursor_layer.link);
        launch_ux_daemon(shell);
 
        tablet_shell_set_state(shell, STATE_STARTING);