You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
weston/clients/tablet-shell.c

362 lines
10 KiB

/*
* Copyright © 2011 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
* 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.
*/
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "window.h"
#include "cairo-util.h"
#include "../shared/configparser.h"
#include "tablet-shell-client-protocol.h"
struct tablet_shell {
struct display *display;
struct tablet_shell *tablet_shell;
struct rectangle allocation;
struct window *lockscreen;
struct window *switcher;
struct window *homescreen;
struct wl_list launcher_list;
};
struct launcher {
cairo_surface_t *icon;
char *path;
struct wl_list link;
};
static char *key_lockscreen_icon;
static char *key_lockscreen_background;
static char *key_homescreen_background;
static char *key_launcher_icon;
static char *key_launcher_path;
static void launcher_section_done(void *data);
static const struct config_key lockscreen_config_keys[] = {
{ "icon", CONFIG_KEY_STRING, &key_lockscreen_icon },
{ "background", CONFIG_KEY_STRING, &key_lockscreen_background },
};
static const struct config_key homescreen_config_keys[] = {
{ "background", CONFIG_KEY_STRING, &key_homescreen_background },
};
static const struct config_key launcher_config_keys[] = {
{ "icon", CONFIG_KEY_STRING, &key_launcher_icon },
{ "path", CONFIG_KEY_STRING, &key_launcher_path },
};
static const struct config_section config_sections[] = {
{ "lockscreen",
lockscreen_config_keys, ARRAY_LENGTH(lockscreen_config_keys) },
{ "homescreen",
homescreen_config_keys, ARRAY_LENGTH(homescreen_config_keys) },
{ "launcher",
launcher_config_keys, ARRAY_LENGTH(launcher_config_keys),
launcher_section_done }
};
static void
paint_background(cairo_t *cr, const char *path, struct rectangle *allocation)
{
cairo_surface_t *image = NULL;
cairo_pattern_t *pattern;
cairo_matrix_t matrix;
double sx, sy;
cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
if (path)
image = load_jpeg(path);
if (image) {
pattern = cairo_pattern_create_for_surface(image);
sx = (double) cairo_image_surface_get_width(image) /
allocation->width;
sy = (double) cairo_image_surface_get_height(image) /
allocation->height;
cairo_matrix_init_scale(&matrix, sx, sy);
cairo_pattern_set_matrix(pattern, &matrix);
cairo_set_source(cr, pattern);
cairo_pattern_destroy (pattern);
cairo_surface_destroy(image);
cairo_paint(cr);
} else {
fprintf(stderr, "couldn't load backgrond image: %s\n",
key_lockscreen_background);
cairo_set_source_rgb(cr, 0.2, 0, 0);
cairo_paint(cr);
}
}
static void
homescreen_draw(struct tablet_shell *shell)
{
cairo_surface_t *surface;
struct rectangle allocation;
cairo_pattern_t *pattern;
cairo_matrix_t matrix;
cairo_t *cr;
struct launcher *launcher;
const int rows = 4, columns = 5, icon_width = 128, icon_height = 128;
int x, y, i, width, height, vmargin, hmargin, vpadding, hpadding;
window_draw(shell->homescreen);
window_get_child_allocation(shell->homescreen, &allocation);
surface = window_get_surface(shell->homescreen);
cr = cairo_create(surface);
paint_background(cr, key_homescreen_background, &allocation);
cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
width = allocation.width - columns * icon_width;
hpadding = width / (columns + 1);
hmargin = (width - hpadding * (columns - 1)) / 2;
height = allocation.height - rows * icon_height;
vpadding = height / (rows + 1);
vmargin = (height - vpadding * (rows - 1)) / 2;
x = hmargin;
y = vmargin;
i = 0;
wl_list_for_each(launcher, &shell->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_pattern_set_matrix(pattern, &matrix);
cairo_pattern_set_extend(pattern, CAIRO_EXTEND_NONE);
cairo_set_source(cr, pattern);
cairo_pattern_destroy(pattern);
cairo_paint(cr);
x += icon_width + hpadding;
i++;
if (i == columns) {
x = hmargin;
y += icon_height + vpadding;
i = 0;
}
}
cairo_surface_flush(surface);
cairo_surface_destroy(surface);
window_flush(shell->homescreen);
}
static void
lockscreen_draw(struct tablet_shell *shell)
{
cairo_surface_t *surface;
cairo_surface_t *icon;
struct rectangle allocation;
cairo_t *cr;
int width, height;
window_draw(shell->lockscreen);
window_get_child_allocation(shell->lockscreen, &allocation);
surface = window_get_surface(shell->lockscreen);
cr = cairo_create(surface);
paint_background(cr, key_lockscreen_background, &allocation);
cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
icon = cairo_image_surface_create_from_png(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_surface_destroy(icon);
cairo_surface_flush(surface);
cairo_surface_destroy(surface);
window_flush(shell->lockscreen);
}
static int
lockscreen_motion_handler(struct window *window,
struct input *input, uint32_t time,
int32_t x, int32_t y,
int32_t sx, int32_t sy, void *data)
{
return POINTER_LEFT_PTR;
}
static void
lockscreen_button_handler(struct window *window,
struct input *input, uint32_t time,
int button, int state, void *data)
{
struct tablet_shell *shell = data;
window_destroy(shell->lockscreen);
shell->lockscreen = NULL;
}
static void
show_lockscreen(void *data, struct tablet_shell *tablet_shell)
{
struct tablet_shell *shell = data;
shell->lockscreen = window_create(shell->display,
shell->allocation.width,
shell->allocation.height);
window_set_user_data(shell->lockscreen, shell);
window_set_decoration(shell->lockscreen, 0);
window_set_custom(shell->lockscreen);
window_set_button_handler(shell->lockscreen,
lockscreen_button_handler);
window_set_motion_handler(shell->lockscreen,
lockscreen_motion_handler);
tablet_shell_set_lockscreen(shell->tablet_shell,
window_get_wl_surface(shell->lockscreen));
lockscreen_draw(shell);
}
static void
show_switcher(void *data, struct tablet_shell *tablet_shell)
{
struct tablet_shell *shell = data;
shell->switcher = window_create(shell->display, 0, 0);
window_set_user_data(shell->switcher, shell);
window_set_decoration(shell->switcher, 0);
window_set_custom(shell->switcher);
tablet_shell_set_switcher(shell->tablet_shell,
window_get_wl_surface(shell->switcher));
}
static void
hide_switcher(void *data, struct tablet_shell *tablet_shell)
{
}
static const struct tablet_shell_listener tablet_shell_listener = {
show_lockscreen,
show_switcher,
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,
shell->allocation.width,
shell->allocation.height);
window_set_user_data(shell->homescreen, shell);
window_set_decoration(shell->homescreen, 0);
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,
const char *icon, const char *path)
{
struct launcher *launcher;
launcher = malloc(sizeof *launcher);
launcher->path = strdup(path);
launcher->icon = cairo_image_surface_create_from_png(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);
}
static void
launcher_section_done(void *data)
{
struct tablet_shell *shell = 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);
free(key_launcher_icon);
key_launcher_icon = NULL;
free(key_launcher_path);
key_launcher_path = NULL;
}
int main(int argc, char *argv[])
{
struct display *display;
char *config_file;
uint32_t id;
struct tablet_shell *shell;
display = display_create(&argc, &argv, NULL);
if (display == NULL) {
fprintf(stderr, "failed to create display: %m\n");
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);
config_file = config_file_path("wayland-tablet-shell.ini");
parse_config_file(config_file,
config_sections, ARRAY_LENGTH(config_sections),
shell);
free(config_file);
homescreen_draw(shell);
display_run(display);
return 0;
}