diff options
Diffstat (limited to 'ivi-shell/hmi-controller.c')
| -rw-r--r-- | ivi-shell/hmi-controller.c | 1718 |
1 files changed, 1718 insertions, 0 deletions
diff --git a/ivi-shell/hmi-controller.c b/ivi-shell/hmi-controller.c new file mode 100644 index 00000000..3a07a70d --- /dev/null +++ b/ivi-shell/hmi-controller.c @@ -0,0 +1,1718 @@ +/* + * Copyright (C) 2014 DENSO 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. + */ + +/** + * A reference implementation how to use ivi-layout APIs in order to manage + * layout of ivi_surfaces/ivi_layers. Layout change is triggered by + * ivi-hmi-controller protocol, ivi-hmi-controller.xml. A reference how to + * use the protocol, see hmi-controller-homescreen. + * + * In-Vehicle Infotainment system usually manage properties of + * ivi_surfaces/ivi_layers by only a central component which decide where + * ivi_surfaces/ivi_layers shall be. This reference show examples to + * implement the central component as a module of weston. + * + * Default Scene graph of UI is defined in hmi_controller_create. It + * consists of + * - In the bottom, a base ivi_layer to group ivi_surfaces of background, + * panel, and buttons + * - Next, a application ivi_layer to show application ivi_surfaces. + * - Workspace background ivi_layer to show a ivi_surface of background image. + * - Workspace ivi_layer to show launcher to launch application with icons. + * Paths to binary and icon are defined in weston.ini. The width of this + * ivi_layer is longer than the size of ivi_screen because a workspace has + * several pages and is controlled by motion of input. + * + * TODO: animation method shall be refined + * TODO: support fade-in when UI is ready + */ + +#include <sys/wait.h> +#include <unistd.h> +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#include <linux/input.h> +#include <assert.h> +#include <time.h> + +#include "ivi-layout-export.h" +#include "ivi-hmi-controller-server-protocol.h" + +/***************************************************************************** + * structure, globals + ****************************************************************************/ +struct hmi_controller_layer { + struct ivi_layout_layer *ivilayer; + uint32_t id_layer; + int32_t x; + int32_t y; + int32_t width; + int32_t height; +}; + +struct link_layer { + struct ivi_layout_layer *layout_layer; + struct wl_list link; +}; + +struct hmi_controller_fade { + uint32_t is_fade_in; + struct wl_list layer_list; +}; + +struct hmi_server_setting { + uint32_t base_layer_id; + uint32_t application_layer_id; + uint32_t workspace_background_layer_id; + uint32_t workspace_layer_id; + int32_t panel_height; + uint32_t transition_duration; + char *ivi_homescreen; +}; + +struct ui_setting { + uint32_t background_id; + uint32_t panel_id; + uint32_t tiling_id; + uint32_t sidebyside_id; + uint32_t fullscreen_id; + uint32_t random_id; + uint32_t home_id; + uint32_t workspace_background_id; +}; + +struct hmi_controller { + struct hmi_server_setting *hmi_setting; + struct hmi_controller_layer base_layer; + struct hmi_controller_layer application_layer; + struct hmi_controller_layer workspace_background_layer; + struct hmi_controller_layer workspace_layer; + enum ivi_hmi_controller_layout_mode layout_mode; + + struct hmi_controller_fade workspace_fade; + + int32_t workspace_count; + struct wl_array ui_widgets; + int32_t is_initialized; + + struct weston_compositor *compositor; + struct wl_listener destroy_listener; + + struct wl_client *user_interface; + struct ui_setting ui_setting; +}; + +struct launcher_info { + uint32_t surface_id; + uint32_t workspace_id; + int32_t index; +}; + +/***************************************************************************** + * local functions + ****************************************************************************/ +static void * +fail_on_null(void *p, size_t size, char *file, int32_t line) +{ + if (size && !p) { + weston_log("%s(%d) %zd: out of memory\n", file, line, size); + exit(EXIT_FAILURE); + } + + return p; +} + +static void * +mem_alloc(size_t size, char *file, int32_t line) +{ + return fail_on_null(calloc(1, size), size, file, line); +} + +#define MEM_ALLOC(s) mem_alloc((s),__FILE__,__LINE__) + +static int32_t +is_surf_in_ui_widget(struct hmi_controller *hmi_ctrl, + struct ivi_layout_surface *ivisurf) +{ + uint32_t id = ivi_layout_get_id_of_surface(ivisurf); + + uint32_t *ui_widget_id = NULL; + wl_array_for_each(ui_widget_id, &hmi_ctrl->ui_widgets) { + if (*ui_widget_id == id) + return 1; + } + + return 0; +} + +static int +compare_launcher_info(const void *lhs, const void *rhs) +{ + const struct launcher_info *left = lhs; + const struct launcher_info *right = rhs; + + if (left->workspace_id < right->workspace_id) + return -1; + + if (left->workspace_id > right->workspace_id) + return 1; + + if (left->index < right->index) + return -1; + + if (left->index > right->index) + return 1; + + return 0; +} + +/** + * Internal methods called by mainly ivi_hmi_controller_switch_mode + * This reference shows 4 examples how to use ivi_layout APIs. + */ +static void +mode_divided_into_tiling(struct hmi_controller *hmi_ctrl, + struct ivi_layout_surface **pp_surface, + int32_t surface_length, + struct hmi_controller_layer *layer) +{ + const float surface_width = (float)layer->width * 0.25; + const float surface_height = (float)layer->height * 0.5; + int32_t surface_x = 0; + int32_t surface_y = 0; + struct ivi_layout_surface *ivisurf = NULL; + struct ivi_layout_surface **surfaces; + struct ivi_layout_surface **new_order; + const uint32_t duration = hmi_ctrl->hmi_setting->transition_duration; + + int32_t i = 0; + int32_t surf_num = 0; + uint32_t num = 1; + + surfaces = MEM_ALLOC(sizeof(*surfaces) * surface_length); + new_order = MEM_ALLOC(sizeof(*surfaces) * surface_length); + + for (i = 0; i < surface_length; i++) { + ivisurf = pp_surface[i]; + + /* skip ui widgets */ + if (is_surf_in_ui_widget(hmi_ctrl, ivisurf)) + continue; + + surfaces[surf_num++] = ivisurf; + } + + for (i = 0; i < surf_num; i++) { + ivisurf = surfaces[i]; + new_order[i] = ivisurf; + + if (num <= 8) { + if (num < 5) { + surface_x = (int32_t)((num - 1) * (surface_width)); + surface_y = 0; + } else { + surface_x = (int32_t)((num - 5) * (surface_width)); + surface_y = (int32_t)surface_height; + } + + ivi_layout_surface_set_transition(ivisurf, + IVI_LAYOUT_TRANSITION_VIEW_DEFAULT, + duration); + ivi_layout_surface_set_visibility(ivisurf, true); + ivi_layout_surface_set_destination_rectangle(ivisurf, + surface_x, surface_y, + (int32_t)surface_width, + (int32_t)surface_height); + + num++; + continue; + } + ivi_layout_surface_set_visibility(ivisurf, false); + } + + if (surf_num > 0) { + ivi_layout_layer_set_transition(layer->ivilayer, + IVI_LAYOUT_TRANSITION_LAYER_VIEW_ORDER, + duration); + //TODO: implement IVI_LAYOUT_TRANSITION_LAYER_VIEW_ORDER later. + ivi_layout_transition_layer_render_order(layer->ivilayer, + new_order, + surf_num, + duration); + } + + free(surfaces); + free(new_order); +} + +static void +mode_divided_into_sidebyside(struct hmi_controller *hmi_ctrl, + struct ivi_layout_surface **pp_surface, + int32_t surface_length, + struct hmi_controller_layer *layer) +{ + int32_t surface_width = layer->width / 2; + int32_t surface_height = layer->height; + struct ivi_layout_surface *ivisurf = NULL; + + const uint32_t duration = hmi_ctrl->hmi_setting->transition_duration; + int32_t i = 0; + int32_t num = 1; + + for (i = 0; i < surface_length; i++) { + ivisurf = pp_surface[i]; + + /* skip ui widgets */ + if (is_surf_in_ui_widget(hmi_ctrl, ivisurf)) + continue; + + if (num == 1) { + ivi_layout_surface_set_transition(ivisurf, + IVI_LAYOUT_TRANSITION_VIEW_DEFAULT, + duration); + ivi_layout_surface_set_visibility(ivisurf, true); + ivi_layout_surface_set_destination_rectangle(ivisurf, + 0, 0, + surface_width, + surface_height); + + num++; + continue; + } else if (num == 2) { + ivi_layout_surface_set_transition(ivisurf, + IVI_LAYOUT_TRANSITION_VIEW_DEFAULT, + duration); + ivi_layout_surface_set_visibility(ivisurf, true); + ivi_layout_surface_set_destination_rectangle(ivisurf, + surface_width, 0, + surface_width, + surface_height); + + num++; + continue; + } + ivi_layout_surface_set_transition(ivisurf, + IVI_LAYOUT_TRANSITION_VIEW_FADE_ONLY, + duration); + ivi_layout_surface_set_visibility(ivisurf, false); + } +} + +static void +mode_fullscreen_someone(struct hmi_controller *hmi_ctrl, + struct ivi_layout_surface **pp_surface, + int32_t surface_length, + struct hmi_controller_layer *layer) +{ + const int32_t surface_width = layer->width; + const int32_t surface_height = layer->height; + struct ivi_layout_surface *ivisurf = NULL; + int32_t i = 0; + const uint32_t duration = hmi_ctrl->hmi_setting->transition_duration; + + for (i = 0; i < surface_length; i++) { + ivisurf = pp_surface[i]; + + /* skip ui widgets */ + if (is_surf_in_ui_widget(hmi_ctrl, ivisurf)) + continue; + + ivi_layout_surface_set_transition(ivisurf, + IVI_LAYOUT_TRANSITION_VIEW_DEFAULT, + duration); + ivi_layout_surface_set_visibility(ivisurf, true); + ivi_layout_surface_set_destination_rectangle(ivisurf, 0, 0, + surface_width, + surface_height); + } +} + +static void +mode_random_replace(struct hmi_controller *hmi_ctrl, + struct ivi_layout_surface **pp_surface, + int32_t surface_length, + struct hmi_controller_layer *layer) +{ + const int32_t surface_width = (int32_t)(layer->width * 0.25f); + const int32_t surface_height = (int32_t)(layer->height * 0.25f); + int32_t surface_x = 0; + int32_t surface_y = 0; + struct ivi_layout_surface *ivisurf = NULL; + const uint32_t duration = hmi_ctrl->hmi_setting->transition_duration; + int32_t i = 0; + + for (i = 0; i < surface_length; i++) { + ivisurf = pp_surface[i]; + + /* skip ui widgets */ + if (is_surf_in_ui_widget(hmi_ctrl, ivisurf)) + continue; + + ivi_layout_surface_set_transition(ivisurf, + IVI_LAYOUT_TRANSITION_VIEW_DEFAULT, + duration); + ivi_layout_surface_set_visibility(ivisurf, true); + surface_x = rand() % (layer->width - surface_width); + surface_y = rand() % (layer->height - surface_height); + + ivi_layout_surface_set_destination_rectangle(ivisurf, + surface_x, + surface_y, + surface_width, + surface_height); + } +} + +static int32_t +has_application_surface(struct hmi_controller *hmi_ctrl, + struct ivi_layout_surface **pp_surface, + int32_t surface_length) +{ + struct ivi_layout_surface *ivisurf = NULL; + int32_t i = 0; + + for (i = 0; i < surface_length; i++) { + ivisurf = pp_surface[i]; + + /* skip ui widgets */ + if (is_surf_in_ui_widget(hmi_ctrl, ivisurf)) + continue; + + return 1; + } + + return 0; +} + +/** + * Supports 4 example to layout of application ivi_surfaces; + * tiling, side by side, fullscreen, and random. + */ +static void +switch_mode(struct hmi_controller *hmi_ctrl, + enum ivi_hmi_controller_layout_mode layout_mode) +{ + struct hmi_controller_layer *layer = &hmi_ctrl->application_layer; + struct ivi_layout_surface **pp_surface = NULL; + int32_t surface_length = 0; + int32_t ret = 0; + + if (!hmi_ctrl->is_initialized) + return; + + hmi_ctrl->layout_mode = layout_mode; + + ret = ivi_layout_get_surfaces(&surface_length, &pp_surface); + assert(!ret); + + if (!has_application_surface(hmi_ctrl, pp_surface, surface_length)) { + free(pp_surface); + pp_surface = NULL; + return; + } + + switch (layout_mode) { + case IVI_HMI_CONTROLLER_LAYOUT_MODE_TILING: + mode_divided_into_tiling(hmi_ctrl, pp_surface, surface_length, + layer); + break; + case IVI_HMI_CONTROLLER_LAYOUT_MODE_SIDE_BY_SIDE: + mode_divided_into_sidebyside(hmi_ctrl, pp_surface, + surface_length, layer); + break; + case IVI_HMI_CONTROLLER_LAYOUT_MODE_FULL_SCREEN: + mode_fullscreen_someone(hmi_ctrl, pp_surface, surface_length, + layer); + break; + case IVI_HMI_CONTROLLER_LAYOUT_MODE_RANDOM: + mode_random_replace(hmi_ctrl, pp_surface, surface_length, + layer); + break; + } + + ivi_layout_commit_changes(); + free(pp_surface); +} + +/** + * Internal method for transition + */ +static void +hmi_controller_fade_run(struct hmi_controller *hmi_ctrl, uint32_t is_fade_in, + struct hmi_controller_fade *fade) +{ + double tint = is_fade_in ? 1.0 : 0.0; + struct link_layer *linklayer = NULL; + const uint32_t duration = hmi_ctrl->hmi_setting->transition_duration; + + fade->is_fade_in = is_fade_in; + + wl_list_for_each(linklayer, &fade->layer_list, link) { + ivi_layout_layer_set_transition(linklayer->layout_layer, + IVI_LAYOUT_TRANSITION_LAYER_FADE, + duration); + ivi_layout_layer_set_fade_info(linklayer->layout_layer, + is_fade_in, 1.0 - tint, tint); + } +} + +/** + * Internal method to create ivi_layer with hmi_controller_layer and + * add to a ivi_screen + */ +static void +create_layer(struct ivi_layout_screen *iviscrn, + struct hmi_controller_layer *layer) +{ + int32_t ret = 0; + + layer->ivilayer = + ivi_layout_layer_create_with_dimension(layer->id_layer, + layer->width, + layer->height); + assert(layer->ivilayer != NULL); + + ret = ivi_layout_screen_add_layer(iviscrn, layer->ivilayer); + assert(!ret); + + ret = ivi_layout_layer_set_destination_rectangle(layer->ivilayer, + layer->x, layer->y, + layer->width, + layer->height); + assert(!ret); + + ret = ivi_layout_layer_set_visibility(layer->ivilayer, true); + assert(!ret); +} + +/** + * Internal set notification + */ +static void +set_notification_create_surface(struct ivi_layout_surface *ivisurf, + void *userdata) +{ + struct hmi_controller *hmi_ctrl = userdata; + struct ivi_layout_layer *application_layer = + hmi_ctrl->application_layer.ivilayer; + int32_t ret = 0; + + /* skip ui widgets */ + if (is_surf_in_ui_widget(hmi_ctrl, ivisurf)) + return; + + ret = ivi_layout_layer_add_surface(application_layer, ivisurf); + assert(!ret); +} + +static void +set_notification_remove_surface(struct ivi_layout_surface *ivisurf, + void *userdata) +{ + struct hmi_controller *hmi_ctrl = userdata; + + switch_mode(hmi_ctrl, hmi_ctrl->layout_mode); +} + +static void +set_notification_configure_surface(struct ivi_layout_surface *ivisurf, + void *userdata) +{ + struct hmi_controller *hmi_ctrl = userdata; + + switch_mode(hmi_ctrl, hmi_ctrl->layout_mode); +} + +/** + * A hmi_controller used 4 ivi_layers to manage ivi_surfaces. The IDs of + * corresponding ivi_layer are defined in weston.ini. Default scene graph + * of ivi_layers are initialized in hmi_controller_create + */ +static struct hmi_server_setting * +hmi_server_setting_create(struct weston_compositor *ec) +{ + struct hmi_server_setting *setting = MEM_ALLOC(sizeof(*setting)); + struct weston_config *config = ec->config; + struct weston_config_section *shell_section = NULL; + + shell_section = weston_config_get_section(config, "ivi-shell", + NULL, NULL); + + weston_config_section_get_uint(shell_section, "base-layer-id", + &setting->base_layer_id, 1000); + + weston_config_section_get_uint(shell_section, + "workspace-background-layer-id", + &setting->workspace_background_layer_id, + 2000); + + weston_config_section_get_uint(shell_section, "workspace-layer-id", + &setting->workspace_layer_id, 3000); + + weston_config_section_get_uint(shell_section, "application-layer-id", + &setting->application_layer_id, 4000); + + weston_config_section_get_uint(shell_section, "transition-duration", + &setting->transition_duration, 300); + + setting->panel_height = 70; + + weston_config_section_get_string(shell_section, + "ivi-shell-user-interface", + &setting->ivi_homescreen, NULL); + + return setting; +} + +static void +hmi_controller_destroy(struct wl_listener *listener, void *data) +{ + struct link_layer *link = NULL; + struct link_layer *next = NULL; + struct hmi_controller *hmi_ctrl = + container_of(listener, struct hmi_controller, destroy_listener); + + wl_list_for_each_safe(link, next, + &hmi_ctrl->workspace_fade.layer_list, link) { + wl_list_remove(&link->link); + free(link); + } + + wl_array_release(&hmi_ctrl->ui_widgets); + free(hmi_ctrl->hmi_setting); + free(hmi_ctrl); +} + +/** + * This is a starting method called from module_init. + * This sets up scene graph of ivi_layers; base, application, workspace + * background, and workspace. These ivi_layers are created/added to + * ivi_screen in create_layer + * + * base: to group ivi_surfaces of panel and background + * application: to group ivi_surfaces of ivi_applications + * workspace background: to group a ivi_surface of background in workspace + * workspace: to group ivi_surfaces for launching ivi_applications + * + * ivi_layers of workspace background and workspace is set to invisible at + * first. The properties of it is updated with animation when + * ivi_hmi_controller_home is requested. + */ +static struct hmi_controller * +hmi_controller_create(struct weston_compositor *ec) +{ + struct ivi_layout_screen **pp_screen = NULL; + struct ivi_layout_screen *iviscrn = NULL; + int32_t screen_length = 0; + int32_t screen_width = 0; + int32_t screen_height = 0; + struct link_layer *tmp_link_layer = NULL; + int32_t panel_height = 0; + struct hmi_controller *hmi_ctrl = MEM_ALLOC(sizeof(*hmi_ctrl)); + + wl_array_init(&hmi_ctrl->ui_widgets); + hmi_ctrl->layout_mode = IVI_HMI_CONTROLLER_LAYOUT_MODE_TILING; + hmi_ctrl->hmi_setting = hmi_server_setting_create(ec); + hmi_ctrl->compositor = ec; + + ivi_layout_get_screens(&screen_length, &pp_screen); + + iviscrn = pp_screen[0]; + + ivi_layout_get_screen_resolution(iviscrn, &screen_width, + &screen_height); + + /* init base ivi_layer*/ + hmi_ctrl->base_layer.x = 0; + hmi_ctrl->base_layer.y = 0; + hmi_ctrl->base_layer.width = screen_width; + hmi_ctrl->base_layer.height = screen_height; + hmi_ctrl->base_layer.id_layer = hmi_ctrl->hmi_setting->base_layer_id; + + create_layer(iviscrn, &hmi_ctrl->base_layer); + + panel_height = hmi_ctrl->hmi_setting->panel_height; + + /* init application ivi_layer */ + hmi_ctrl->application_layer.x = 0; + hmi_ctrl->application_layer.y = 0; + hmi_ctrl->application_layer.width = screen_width; + hmi_ctrl->application_layer.height = screen_height - panel_height; + hmi_ctrl->application_layer.id_layer = + hmi_ctrl->hmi_setting->application_layer_id; + + create_layer(iviscrn, &hmi_ctrl->application_layer); + + /* init workspace background ivi_layer */ + hmi_ctrl->workspace_background_layer.x = 0; + hmi_ctrl->workspace_background_layer.y = 0; + hmi_ctrl->workspace_background_layer.width = screen_width; + hmi_ctrl->workspace_background_layer.height = + screen_height - panel_height; + + hmi_ctrl->workspace_background_layer.id_layer = + hmi_ctrl->hmi_setting->workspace_background_layer_id; + + create_layer(iviscrn, &hmi_ctrl->workspace_background_layer); + ivi_layout_layer_set_opacity( + hmi_ctrl->workspace_background_layer.ivilayer, 0); + ivi_layout_layer_set_visibility( + hmi_ctrl->workspace_background_layer.ivilayer, false); + + /* init workspace ivi_layer */ + hmi_ctrl->workspace_layer.x = hmi_ctrl->workspace_background_layer.x; + hmi_ctrl->workspace_layer.y = hmi_ctrl->workspace_background_layer.y; + hmi_ctrl->workspace_layer.width = + hmi_ctrl->workspace_background_layer.width; + hmi_ctrl->workspace_layer.height = + hmi_ctrl->workspace_background_layer.height; + hmi_ctrl->workspace_layer.id_layer = + hmi_ctrl->hmi_setting->workspace_layer_id; + + create_layer(iviscrn, &hmi_ctrl->workspace_layer); + ivi_layout_layer_set_opacity(hmi_ctrl->workspace_layer.ivilayer, 0); + ivi_layout_layer_set_visibility(hmi_ctrl->workspace_layer.ivilayer, + false); + + wl_list_init(&hmi_ctrl->workspace_fade.layer_list); + tmp_link_layer = MEM_ALLOC(sizeof(*tmp_link_layer)); + tmp_link_layer->layout_layer = hmi_ctrl->workspace_layer.ivilayer; + wl_list_insert(&hmi_ctrl->workspace_fade.layer_list, + &tmp_link_layer->link); + tmp_link_layer = MEM_ALLOC(sizeof(*tmp_link_layer)); + tmp_link_layer->layout_layer = + hmi_ctrl->workspace_background_layer.ivilayer; + wl_list_insert(&hmi_ctrl->workspace_fade.layer_list, + &tmp_link_layer->link); + + ivi_layout_add_notification_create_surface( + set_notification_create_surface, hmi_ctrl); + ivi_layout_add_notification_remove_surface( + set_notification_remove_surface, hmi_ctrl); + ivi_layout_add_notification_configure_surface( + set_notification_configure_surface, hmi_ctrl); + + hmi_ctrl->destroy_listener.notify = hmi_controller_destroy; + wl_signal_add(&hmi_ctrl->compositor->destroy_signal, + &hmi_ctrl->destroy_listener); + + free(pp_screen); + pp_screen = NULL; + + return hmi_ctrl; +} + +/** + * Implementations of ivi-hmi-controller.xml + */ + +/** + * A ivi_surface drawing background is identified by id_surface. + * Properties of the ivi_surface is set by using ivi_layout APIs according to + * the scene graph of UI defined in hmi_controller_create. + * + * UI ivi_layer is used to add this ivi_surface. + */ +static void +ivi_hmi_controller_set_background(struct hmi_controller *hmi_ctrl, + uint32_t id_surface) +{ + struct ivi_layout_surface *ivisurf = NULL; + struct ivi_layout_layer *ivilayer = hmi_ctrl->base_layer.ivilayer; + const int32_t dstx = hmi_ctrl->application_layer.x; + const int32_t dsty = hmi_ctrl->application_layer.y; + const int32_t width = hmi_ctrl->application_layer.width; + const int32_t height = hmi_ctrl->application_layer.height; + int32_t ret = 0; + + uint32_t *add_surface_id = wl_array_add(&hmi_ctrl->ui_widgets, + sizeof(*add_surface_id)); + *add_surface_id = id_surface; + + ivisurf = ivi_layout_get_surface_from_id(id_surface); + assert(ivisurf != NULL); + + ret = ivi_layout_layer_add_surface(ivilayer, ivisurf); + assert(!ret); + + ret = ivi_layout_surface_set_destination_rectangle(ivisurf, + dstx, dsty, width, height); + assert(!ret); + + ret = ivi_layout_surface_set_visibility(ivisurf, true); + assert(!ret); +} + +/** + * A ivi_surface drawing panel is identified by id_surface. + * Properties of the ivi_surface is set by using ivi_layout APIs according to + * the scene graph of UI defined in hmi_controller_create. + * + * UI ivi_layer is used to add this ivi_surface. + */ +static void +ivi_hmi_controller_set_panel(struct hmi_controller *hmi_ctrl, + uint32_t id_surface) +{ + struct ivi_layout_surface *ivisurf = NULL; + struct ivi_layout_layer *ivilayer = hmi_ctrl->base_layer.ivilayer; + const int32_t width = hmi_ctrl->base_layer.width; + int32_t ret = 0; + int32_t panel_height = 0; + const int32_t dstx = 0; + int32_t dsty = 0; + + uint32_t *add_surface_id = wl_array_add(&hmi_ctrl->ui_widgets, + sizeof(*add_surface_id)); + *add_surface_id = id_surface; + + ivisurf = ivi_layout_get_surface_from_id(id_surface); + assert(ivisurf != NULL); + + ret = ivi_layout_layer_add_surface(ivilayer, ivisurf); + assert(!ret); + + panel_height = hmi_ctrl->hmi_setting->panel_height; + + dsty = hmi_ctrl->base_layer.height - panel_height; + + ret = ivi_layout_surface_set_destination_rectangle( + ivisurf, dstx, dsty, width, panel_height); + assert(!ret); + + ret = ivi_layout_surface_set_visibility(ivisurf, true); + assert(!ret); +} + +/** + * A ivi_surface drawing buttons in panel is identified by id_surface. + * It can set several buttons. Properties of the ivi_surface is set by + * using ivi_layout APIs according to the scene graph of UI defined in + * hmi_controller_create. Additionally, the position of it is shifted to + * right when new one is requested. + * + * UI ivi_layer is used to add these ivi_surfaces. + */ +static void +ivi_hmi_controller_set_button(struct hmi_controller *hmi_ctrl, + uint32_t id_surface, int32_t number) +{ + struct ivi_layout_surface *ivisurf = NULL; + struct ivi_layout_layer *ivilayer = hmi_ctrl->base_layer.ivilayer; + const int32_t width = 48; + const int32_t height = 48; + int32_t ret = 0; + int32_t panel_height = 0; + int32_t dstx = 0; + int32_t dsty = 0; + uint32_t *add_surface_id = wl_array_add(&hmi_ctrl->ui_widgets, + sizeof(*add_surface_id)); + *add_surface_id = id_surface; + + ivisurf = ivi_layout_get_surface_from_id(id_surface); + assert(ivisurf != NULL); + + ret = ivi_layout_layer_add_surface(ivilayer, ivisurf); + assert(!ret); + + panel_height = hmi_ctrl->hmi_setting->panel_height; + + dstx = (60 * number) + 15; + dsty = (hmi_ctrl->base_layer.height - panel_height) + 5; + + ret = ivi_layout_surface_set_destination_rectangle( + ivisurf,dstx, dsty, width, height); + assert(!ret); + + ret = ivi_layout_surface_set_visibility(ivisurf, true); + assert(!ret); +} + +/** + * A ivi_surface drawing home button in panel is identified by id_surface. + * Properties of the ivi_surface is set by using ivi_layout APIs according to + * the scene graph of UI defined in hmi_controller_create. + * + * UI ivi_layer is used to add these ivi_surfaces. + */ +static void +ivi_hmi_controller_set_home_button(struct hmi_controller *hmi_ctrl, + uint32_t id_surface) +{ + struct ivi_layout_surface *ivisurf = NULL; + struct ivi_layout_layer *ivilayer = hmi_ctrl->base_layer.ivilayer; + int32_t ret = 0; + int32_t size = 48; + int32_t panel_height = hmi_ctrl->hmi_setting->panel_height; + const int32_t dstx = (hmi_ctrl->base_layer.width - size) / 2; + const int32_t dsty = (hmi_ctrl->base_layer.height - panel_height) + 5; + + uint32_t *add_surface_id = wl_array_add(&hmi_ctrl->ui_widgets, + sizeof(*add_surface_id)); + *add_surface_id = id_surface; + + ivisurf = ivi_layout_get_surface_from_id(id_surface); + assert(ivisurf != NULL); + + ret = ivi_layout_layer_add_surface(ivilayer, ivisurf); + assert(!ret); + + ret = ivi_layout_surface_set_destination_rectangle( + ivisurf, dstx, dsty, size, size); + assert(!ret); + + ret = ivi_layout_surface_set_visibility(ivisurf, true); + assert(!ret); +} + +/** + * A ivi_surface drawing background of workspace is identified by id_surface. + * Properties of the ivi_surface is set by using ivi_layout APIs according to + * the scene graph of UI defined in hmi_controller_create. + * + * A ivi_layer of workspace_background is used to add this ivi_surface. + */ +static void +ivi_hmi_controller_set_workspacebackground(struct hmi_controller *hmi_ctrl, + uint32_t id_surface) +{ + struct ivi_layout_surface *ivisurf = NULL; + struct ivi_layout_layer *ivilayer = NULL; + const int32_t width = hmi_ctrl->workspace_background_layer.width; + const int32_t height = hmi_ctrl->workspace_background_layer.height; + int32_t ret = 0; + + uint32_t *add_surface_id = wl_array_add(&hmi_ctrl->ui_widgets, + sizeof(*add_surface_id)); + *add_surface_id = id_surface; + ivilayer = hmi_ctrl->workspace_background_layer.ivilayer; + + ivisurf = ivi_layout_get_surface_from_id(id_surface); + assert(ivisurf != NULL); + + ret = ivi_layout_layer_add_surface(ivilayer, ivisurf); + assert(!ret); + + ret = ivi_layout_surface_set_destination_rectangle(ivisurf, + 0, 0, width, height); + assert(!ret); + + ret = ivi_layout_surface_set_visibility(ivisurf, true); + assert(!ret); +} + +/** + * A list of ivi_surfaces drawing launchers in workspace is identified by + * id_surfaces. Properties of the ivi_surface is set by using ivi_layout + * APIs according to the scene graph of UI defined in hmi_controller_create. + * + * The workspace can have several pages to group ivi_surfaces of launcher. + * Each call of this interface increments a number of page to add a group + * of ivi_surfaces + */ +static void +ivi_hmi_controller_add_launchers(struct hmi_controller *hmi_ctrl, + int32_t icon_size) +{ + struct ivi_layout_layer *layer = hmi_ctrl->workspace_layer.ivilayer; + int32_t minspace_x = 10; + int32_t minspace_y = minspace_x; + + int32_t width = hmi_ctrl->workspace_layer.width; + int32_t height = hmi_ctrl->workspace_layer.height; + + int32_t x_count = (width - minspace_x) / (minspace_x + icon_size); + int32_t space_x = (int32_t)((width - x_count * icon_size) / (1.0 + x_count)); + float fcell_size_x = icon_size + space_x; + + int32_t y_count = (height - minspace_y) / (minspace_y + icon_size); + int32_t space_y = (int32_t)((height - y_count * icon_size) / (1.0 + y_count)); + float fcell_size_y = icon_size + space_y; + + struct weston_config *config = NULL; + struct weston_config_section *section = NULL; + const char *name = NULL; + int launcher_count = 0; + struct wl_array launchers; + int32_t nx = 0; + int32_t ny = 0; + int32_t prev = -1; + struct launcher_info *data = NULL; + + uint32_t surfaceid = 0; + uint32_t workspaceid = 0; + struct launcher_info *info = NULL; + + int32_t x = 0; + int32_t y = 0; + int32_t ret = 0; + struct ivi_layout_surface* layout_surface = NULL; + uint32_t *add_surface_id = NULL; + + if (0 == x_count) + x_count = 1; + + if (0 == y_count) + y_count = 1; + + config = hmi_ctrl->compositor->config; + if (!config) + return; + + section = weston_config_get_section(config, "ivi-shell", NULL, NULL); + if (!section) + return; + + wl_array_init(&launchers); + + while (weston_config_next_section(config, §ion, &name)) { + surfaceid = 0; + workspaceid = 0; + info = NULL; + if (0 != strcmp(name, "ivi-launcher")) + continue; + + if (0 != weston_config_section_get_uint(section, "icon-id", + &surfaceid, 0)) + continue; + + if (0 != weston_config_section_get_uint(section, + "workspace-id", + &workspaceid, 0)) + continue; + + info = wl_array_add(&launchers, sizeof(*info)); + + if (info) { + info->surface_id = surfaceid; + info->workspace_id = workspaceid; + info->index = launcher_count; + ++launcher_count; + } + } + + qsort(launchers.data, launcher_count, sizeof(struct launcher_info), + compare_launcher_info); + + wl_array_for_each(data, &launchers) { + x = 0; + y = 0; + ret = 0; + layout_surface = NULL; + add_surface_id = wl_array_add(&hmi_ctrl->ui_widgets, + sizeof(*add_surface_id)); + + *add_surface_id = data->surface_id; + + if (0 > prev || (uint32_t)prev != data->workspace_id) { + nx = 0; + ny = 0; + prev = data->workspace_id; + + if (0 <= prev) + hmi_ctrl->workspace_count++; + } + + if (y_count == ny) { + ny = 0; + hmi_ctrl->workspace_count++; + } + + x = nx * fcell_size_x + (hmi_ctrl->workspace_count - 1) * width + space_x; + y = ny * fcell_size_y + space_y; + + layout_surface = + ivi_layout_get_surface_from_id(data->surface_id); + assert(layout_surface); + + ret = ivi_layout_layer_add_surface(layer, layout_surface); + assert(!ret); + + ret = ivi_layout_surface_set_destination_rectangle( + layout_surface, x, y, icon_size, icon_size); + assert(!ret); + + ret = ivi_layout_surface_set_visibility(layout_surface, true); + assert(!ret); + + nx++; + + if (x_count == nx) { + ny++; + nx = 0; + } + } + + wl_array_release(&launchers); + ivi_layout_commit_changes(); +} + +static void +ivi_hmi_controller_UI_ready(struct wl_client *client, + struct wl_resource *resource) +{ + struct hmi_controller *hmi_ctrl = wl_resource_get_user_data(resource); + + ivi_hmi_controller_set_background(hmi_ctrl, hmi_ctrl->ui_setting.background_id); + ivi_hmi_controller_set_panel(hmi_ctrl, hmi_ctrl->ui_setting.panel_id); + ivi_hmi_controller_set_button(hmi_ctrl, hmi_ctrl->ui_setting.tiling_id, 0); + ivi_hmi_controller_set_button(hmi_ctrl, hmi_ctrl->ui_setting.sidebyside_id, 1); + ivi_hmi_controller_set_button(hmi_ctrl, hmi_ctrl->ui_setting.fullscreen_id, 2); + ivi_hmi_controller_set_button(hmi_ctrl, hmi_ctrl->ui_setting.random_id, 3); + ivi_hmi_controller_set_home_button(hmi_ctrl, hmi_ctrl->ui_setting.home_id); + ivi_hmi_controller_set_workspacebackground(hmi_ctrl, hmi_ctrl->ui_setting.workspace_background_id); + ivi_layout_commit_changes(); + + ivi_hmi_controller_add_launchers(hmi_ctrl, 256); + hmi_ctrl->is_initialized = 1; +} + +/** + * Implementation of request and event of ivi_hmi_controller_workspace_control + * and controlling workspace. + * + * When motion of input is detected in a ivi_surface of workspace background, + * ivi_hmi_controller_workspace_control shall be invoked and to start + * controlling of workspace. The workspace has several pages to show several + * groups of applications. + * The workspace is slid by using ivi-layout to select a a page in layer_set_pos + * according to motion. When motion finished, e.g. touch up detected, control is + * terminated and event:ivi_hmi_controller_workspace_control is notified. + */ +struct pointer_grab { + struct weston_pointer_grab grab; + struct ivi_layout_layer *layer; + struct wl_resource *resource; +}; + +struct touch_grab { + struct weston_touch_grab grab; + struct ivi_layout_layer *layer; + struct wl_resource *resource; +}; + +struct move_grab { + wl_fixed_t dst[2]; + wl_fixed_t rgn[2][2]; + double v[2]; + struct timespec start_time; + struct timespec pre_time; + wl_fixed_t start_pos[2]; + wl_fixed_t pos[2]; + int32_t is_moved; +}; + +struct pointer_move_grab { + struct pointer_grab base; + struct move_grab move; +}; + +struct touch_move_grab { + struct touch_grab base; + struct move_grab move; + int32_t is_active; +}; + +static void +pointer_grab_start(struct pointer_grab *grab, + struct ivi_layout_layer *layer, + const struct weston_pointer_grab_interface *interface, + struct weston_pointer *pointer) +{ + grab->grab.interface = interface; + grab->layer = layer; + weston_pointer_start_grab(pointer, &grab->grab); +} + +static void +touch_grab_start(struct touch_grab *grab, + struct ivi_layout_layer *layer, + const struct weston_touch_grab_interface *interface, + struct weston_touch* touch) +{ + grab->grab.interface = interface; + grab->layer = layer; + weston_touch_start_grab(touch, &grab->grab); +} + +static int32_t +clamp(int32_t val, int32_t min, int32_t max) +{ + if (val < min) + return min; + + if (max < val) + return max; + + return val; +} + +static void +move_workspace_grab_end(struct move_grab *move, struct wl_resource* resource, + wl_fixed_t grab_x, struct ivi_layout_layer *layer) +{ + struct hmi_controller *hmi_ctrl = wl_resource_get_user_data(resource); + int32_t width = hmi_ctrl->workspace_background_layer.width; + + struct timespec time = {0}; + double grab_time = 0.0; + double from_motion_time = 0.0; + double pointer_v = 0.0; + int32_t is_flick = 0; + int32_t pos_x = 0; + int32_t pos_y = 0; + int page_no = 0; + double end_pos = 0.0; + uint32_t duration = 0; + + clock_gettime(CLOCK_MONOTONIC, &time); + + grab_time = 1e+3 * (time.tv_sec - move->start_time.tv_sec) + + 1e-6 * (time.tv_nsec - move->start_time.tv_nsec); + + from_motion_time = 1e+3 * (time.tv_sec - move->pre_time.tv_sec) + + 1e-6 * (time.tv_nsec - move->pre_time.tv_nsec); + + pointer_v = move->v[0]; + + is_flick = grab_time < 400 && 0.4 < fabs(pointer_v); + if (200 < from_motion_time) + pointer_v = 0.0; + + ivi_layout_layer_get_position(layer, &pos_x, &pos_y); + + + if (is_flick) { + int orgx = wl_fixed_to_int(move->dst[0] + grab_x); + page_no = (-orgx + width / 2) / width; + + if (pointer_v < 0.0) + page_no++; + else + page_no--; + } else { + page_no = (-pos_x + width / 2) / width; + } + + page_no = clamp(page_no, 0, hmi_ctrl->workspace_count - 1); + end_pos = -page_no * width; + + duration = hmi_ctrl->hmi_setting->transition_duration; + ivi_hmi_controller_send_workspace_end_control(resource, move->is_moved); + ivi_layout_layer_set_transition(layer, + IVI_LAYOUT_TRANSITION_LAYER_MOVE, + duration); + ivi_layout_layer_set_destination_rectangle(layer, + end_pos, pos_y, + hmi_ctrl->workspace_background_layer.width, + hmi_ctrl->workspace_background_layer.height); + ivi_layout_commit_changes(); +} + +static void +pointer_move_workspace_grab_end(struct pointer_grab *grab) +{ + struct pointer_move_grab *pnt_move_grab = + (struct pointer_move_grab *)grab; + struct ivi_layout_layer *layer = pnt_move_grab->base.layer; + + move_workspace_grab_end(&pnt_move_grab->move, grab->resource, + grab->grab.pointer->grab_x, layer); + + weston_pointer_end_grab(grab->grab.pointer); +} + +static void +touch_move_workspace_grab_end(struct touch_grab *grab) +{ + struct touch_move_grab *tch_move_grab = (struct touch_move_grab *)grab; + struct ivi_layout_layer *layer = tch_move_grab->base.layer; + + move_workspace_grab_end(&tch_move_grab->move, grab->resource, + grab->grab.touch->grab_x, layer); + + weston_touch_end_grab(grab->grab.touch); +} + +static void +pointer_noop_grab_focus(struct weston_pointer_grab *grab) +{ +} + +static void +move_grab_update(struct move_grab *move, wl_fixed_t pointer[2]) +{ + struct timespec timestamp = {0}; + int32_t ii = 0; + double dt = 0.0; + + clock_gettime(CLOCK_MONOTONIC, ×tamp); //FIXME + dt = (1e+3 * (timestamp.tv_sec - move->pre_time.tv_sec) + + 1e-6 * (timestamp.tv_nsec - move->pre_time.tv_nsec)); + + if (dt < 1e-6) + dt = 1e-6; + + move->pre_time = timestamp; + + for (ii = 0; ii < 2; ii++) { + wl_fixed_t prepos = move->pos[ii]; + move->pos[ii] = pointer[ii] + move->dst[ii]; + + if (move->pos[ii] < move->rgn[0][ii]) { + move->pos[ii] = move->rgn[0][ii]; + move->dst[ii] = move->pos[ii] - pointer[ii]; + } else if (move->rgn[1][ii] < move->pos[ii]) { + move->pos[ii] = move->rgn[1][ii]; + move->dst[ii] = move->pos[ii] - pointer[ii]; + } + + move->v[ii] = wl_fixed_to_double(move->pos[ii] - prepos) / dt; + + if (!move->is_moved && + 0 < wl_fixed_to_int(move->pos[ii] - move->start_pos[ii])) + move->is_moved = 1; + } +} + +static void +layer_set_pos(struct ivi_layout_layer *layer, wl_fixed_t pos_x, + wl_fixed_t pos_y) +{ + int32_t layout_pos_x = 0; + int32_t layout_pos_y = 0; + + layout_pos_x = wl_fixed_to_int(pos_x); + layout_pos_y = wl_fixed_to_int(pos_y); + ivi_layout_layer_set_position(layer, layout_pos_x, layout_pos_y); + ivi_layout_commit_changes(); +} + +static void +pointer_move_grab_motion(struct weston_pointer_grab *grab, uint32_t time, + wl_fixed_t x, wl_fixed_t y) +{ + struct pointer_move_grab *pnt_move_grab = + (struct pointer_move_grab *)grab; + wl_fixed_t pointer_pos[2] = {x, y}; + + move_grab_update(&pnt_move_grab->move, pointer_pos); + layer_set_pos(pnt_move_grab->base.layer, + pnt_move_grab->move.pos[0], pnt_move_grab->move.pos[1]); + weston_pointer_move(pnt_move_grab->base.grab.pointer, x, y); +} + +static void +touch_move_grab_motion(struct weston_touch_grab *grab, uint32_t time, + int touch_id, wl_fixed_t x, wl_fixed_t y) +{ + struct touch_move_grab *tch_move_grab = (struct touch_move_grab *)grab; + + if (!tch_move_grab->is_active) + return; + + wl_fixed_t pointer_pos[2] = { + grab->touch->grab_x, + grab->touch->grab_y + }; + + move_grab_update(&tch_move_grab->move, pointer_pos); + layer_set_pos(tch_move_grab->base.layer, + tch_move_grab->move.pos[0], tch_move_grab->move.pos[1]); +} + +static void +pointer_move_workspace_grab_button(struct weston_pointer_grab *grab, + uint32_t time, uint32_t button, + uint32_t state_w) +{ + if (BTN_LEFT == button && + WL_POINTER_BUTTON_STATE_RELEASED == state_w) { + struct pointer_grab *pg = (struct pointer_grab *)grab; + + pointer_move_workspace_grab_end(pg); + free(grab); + } +} + +static void +touch_nope_grab_down(struct weston_touch_grab *grab, uint32_t time, + int touch_id, wl_fixed_t sx, wl_fixed_t sy) +{ +} + +static void +touch_move_workspace_grab_up(struct weston_touch_grab *grab, uint32_t time, + int touch_id) +{ + struct touch_move_grab *tch_move_grab = (struct touch_move_grab *)grab; + + if (0 == touch_id) + tch_move_grab->is_active = 0; + + if (0 == grab->touch->num_tp) { + touch_move_workspace_grab_end(&tch_move_grab->base); + free(grab); + } +} + +static void +pointer_move_workspace_grab_cancel(struct weston_pointer_grab *grab) +{ + struct pointer_grab *pg = (struct pointer_grab *)grab; + + pointer_move_workspace_grab_end(pg); + free(grab); +} + +static void +touch_move_workspace_grab_cancel(struct weston_touch_grab *grab) +{ + struct touch_grab *tg = (struct touch_grab *)grab; + + touch_move_workspace_grab_end(tg); + free(grab); +} + +static const struct weston_pointer_grab_interface pointer_move_grab_workspace_interface = { + pointer_noop_grab_focus, + pointer_move_grab_motion, + pointer_move_workspace_grab_button, + pointer_move_workspace_grab_cancel +}; + +static const struct weston_touch_grab_interface touch_move_grab_workspace_interface = { + touch_nope_grab_down, + touch_move_workspace_grab_up, + touch_move_grab_motion, + touch_move_workspace_grab_cancel +}; + +enum HMI_GRAB_DEVICE { + HMI_GRAB_DEVICE_NONE, + HMI_GRAB_DEVICE_POINTER, + HMI_GRAB_DEVICE_TOUCH +}; + +static enum HMI_GRAB_DEVICE +get_hmi_grab_device(struct weston_seat *seat, uint32_t serial) +{ + if (seat->pointer && + seat->pointer->focus && + seat->pointer->button_count && + seat->pointer->grab_serial == serial) + return HMI_GRAB_DEVICE_POINTER; + + if (seat->touch && + seat->touch->focus && + seat->touch->grab_serial == serial) + return HMI_GRAB_DEVICE_TOUCH; + + return HMI_GRAB_DEVICE_NONE; +} + +static void +move_grab_init(struct move_grab* move, wl_fixed_t start_pos[2], + wl_fixed_t grab_pos[2], wl_fixed_t rgn[2][2], + struct wl_resource* resource) +{ + clock_gettime(CLOCK_MONOTONIC, &move->start_time); //FIXME + move->pre_time = move->start_time; + move->pos[0] = start_pos[0]; + move->pos[1] = start_pos[1]; + move->start_pos[0] = start_pos[0]; + move->start_pos[1] = start_pos[1]; + move->dst[0] = start_pos[0] - grab_pos[0]; + move->dst[1] = start_pos[1] - grab_pos[1]; + memcpy(move->rgn, rgn, sizeof(move->rgn)); +} + +static void +move_grab_init_workspace(struct move_grab* move, + wl_fixed_t grab_x, wl_fixed_t grab_y, + struct wl_resource *resource) +{ + struct hmi_controller *hmi_ctrl = wl_resource_get_user_data(resource); + struct ivi_layout_layer *layer = hmi_ctrl->workspace_layer.ivilayer; + int32_t workspace_count = hmi_ctrl->workspace_count; + int32_t workspace_width = hmi_ctrl->workspace_background_layer.width; + int32_t layer_pos_x = 0; + int32_t layer_pos_y = 0; + wl_fixed_t start_pos[2] = {0}; + wl_fixed_t rgn[2][2] = {{0}}; + wl_fixed_t grab_pos[2] = { grab_x, grab_y }; + + ivi_layout_layer_get_position(layer, &layer_pos_x, &layer_pos_y); + + start_pos[0] = wl_fixed_from_int(layer_pos_x); + start_pos[1] = wl_fixed_from_int(layer_pos_y); + + rgn[0][0] = wl_fixed_from_int(-workspace_width * (workspace_count - 1)); + + rgn[0][1] = wl_fixed_from_int(0); + rgn[1][0] = wl_fixed_from_int(0); + rgn[1][1] = wl_fixed_from_int(0); + + move_grab_init(move, start_pos, grab_pos, rgn, resource); +} + +static struct pointer_move_grab * +create_workspace_pointer_move(struct weston_pointer *pointer, + struct wl_resource* resource) +{ + struct pointer_move_grab *pnt_move_grab = + MEM_ALLOC(sizeof(*pnt_move_grab)); + + pnt_move_grab->base.resource = resource; + move_grab_init_workspace(&pnt_move_grab->move, pointer->grab_x, + pointer->grab_y, resource); + + return pnt_move_grab; +} + +static struct touch_move_grab * +create_workspace_touch_move(struct weston_touch *touch, + struct wl_resource* resource) +{ + struct touch_move_grab *tch_move_grab = + MEM_ALLOC(sizeof(*tch_move_grab)); + + tch_move_grab->base.resource = resource; + tch_move_grab->is_active = 1; + move_grab_init_workspace(&tch_move_grab->move, touch->grab_x, + touch->grab_y, resource); + + return tch_move_grab; +} + +static void +ivi_hmi_controller_workspace_control(struct wl_client *client, + struct wl_resource *resource, + struct wl_resource *seat_resource, + uint32_t serial) +{ + struct hmi_controller *hmi_ctrl = wl_resource_get_user_data(resource); + struct ivi_layout_layer *layer = NULL; + struct pointer_move_grab *pnt_move_grab = NULL; + struct touch_move_grab *tch_move_grab = NULL; + struct weston_seat *seat = NULL; + enum HMI_GRAB_DEVICE device; + + if (hmi_ctrl->workspace_count < 2) + return; + + seat = wl_resource_get_user_data(seat_resource); + device = get_hmi_grab_device(seat, serial); + + if (HMI_GRAB_DEVICE_POINTER != device && + HMI_GRAB_DEVICE_TOUCH != device) + return; + + layer = hmi_ctrl->workspace_layer.ivilayer; + + ivi_layout_transition_move_layer_cancel(layer); + + switch (device) { + case HMI_GRAB_DEVICE_POINTER: + pnt_move_grab = create_workspace_pointer_move(seat->pointer, + resource); + + pointer_grab_start(&pnt_move_grab->base, layer, + &pointer_move_grab_workspace_interface, + seat->pointer); + break; + + case HMI_GRAB_DEVICE_TOUCH: + tch_move_grab = create_workspace_touch_move(seat->touch, + resource); + + touch_grab_start(&tch_move_grab->base, layer, + &touch_move_grab_workspace_interface, + seat->touch); + break; + + default: + break; + } +} + +/** + * Implementation of switch_mode + */ +static void +ivi_hmi_controller_switch_mode(struct wl_client *client, + struct wl_resource *resource, + uint32_t layout_mode) +{ + struct hmi_controller *hmi_ctrl = wl_resource_get_user_data(resource); + + switch_mode(hmi_ctrl, layout_mode); +} + +/** + * Implementation of on/off displaying workspace and workspace background + * ivi_layers. + */ +static void +ivi_hmi_controller_home(struct wl_client *client, + struct wl_resource *resource, + uint32_t home) +{ + struct hmi_controller *hmi_ctrl = wl_resource_get_user_data(resource); + uint32_t is_fade_in; + + if ((IVI_HMI_CONTROLLER_HOME_ON == home && + !hmi_ctrl->workspace_fade.is_fade_in) || + (IVI_HMI_CONTROLLER_HOME_OFF == home && + hmi_ctrl->workspace_fade.is_fade_in)) { + is_fade_in = !hmi_ctrl->workspace_fade.is_fade_in; + hmi_controller_fade_run(hmi_ctrl, is_fade_in, + &hmi_ctrl->workspace_fade); + } + + ivi_layout_commit_changes(); +} + +/** + * binding ivi-hmi-controller implementation + */ +static const struct ivi_hmi_controller_interface ivi_hmi_controller_implementation = { + ivi_hmi_controller_UI_ready, + ivi_hmi_controller_workspace_control, + ivi_hmi_controller_switch_mode, + ivi_hmi_controller_home +}; + +static void +unbind_hmi_controller(struct wl_resource *resource) +{ +} + +static void +bind_hmi_controller(struct wl_client *client, + void *data, uint32_t version, uint32_t id) +{ + struct wl_resource *resource = NULL; + struct hmi_controller *hmi_ctrl = data; + + if (hmi_ctrl->user_interface != client) { + struct wl_resource *res = wl_client_get_object(client, 1); + wl_resource_post_error(res, + WL_DISPLAY_ERROR_INVALID_OBJECT, + "hmi-controller failed: permission denied"); + return; + } + + resource = wl_resource_create( + client, &ivi_hmi_controller_interface, 1, id); + + wl_resource_set_implementation( + resource, &ivi_hmi_controller_implementation, + hmi_ctrl, unbind_hmi_controller); +} + +static int32_t +initialize(struct hmi_controller *hmi_ctrl) +{ + struct config_command { + char *key; + uint32_t *dest; + }; + + struct weston_config *config = hmi_ctrl->compositor->config; + struct weston_config_section *section = NULL; + int result = 0; + int i = 0; + + const struct config_command uint_commands[] = { + { "background-id", &hmi_ctrl->ui_setting.background_id }, + { "panel-id", &hmi_ctrl->ui_setting.panel_id }, + { "tiling-id", &hmi_ctrl->ui_setting.tiling_id }, + { "sidebyside-id", &hmi_ctrl->ui_setting.sidebyside_id }, + { "fullscreen-id", &hmi_ctrl->ui_setting.fullscreen_id }, + { "random-id", &hmi_ctrl->ui_setting.random_id }, + { "home-id", &hmi_ctrl->ui_setting.home_id }, + { "workspace-background-id", &hmi_ctrl->ui_setting.workspace_background_id }, + { NULL, NULL } + }; + + section = weston_config_get_section(config, "ivi-shell", NULL, NULL); + + for (i = 0; -1 != result; ++i) { + const struct config_command *command = &uint_commands[i]; + + if (!command->key) + break; + + if (weston_config_section_get_uint( + section, command->key, command->dest, 0) != 0) + result = -1; + } + + if (-1 == result) { + weston_log("Failed to initialize hmi-controller\n"); + return 0; + } + + return 1; +} + +static void +launch_hmi_client_process(void *data) +{ + struct hmi_controller *hmi_ctrl = + (struct hmi_controller *)data; + + hmi_ctrl->user_interface = + weston_client_start(hmi_ctrl->compositor, + hmi_ctrl->hmi_setting->ivi_homescreen); + + free(hmi_ctrl->hmi_setting->ivi_homescreen); +} + +/***************************************************************************** + * exported functions + ****************************************************************************/ + +WL_EXPORT int +module_init(struct weston_compositor *ec, + int *argc, char *argv[]) +{ + struct hmi_controller *hmi_ctrl = hmi_controller_create(ec); + struct wl_event_loop *loop = NULL; + + if (!initialize(hmi_ctrl)) { + return -1; + } + + if (wl_global_create(ec->wl_display, + &ivi_hmi_controller_interface, 1, + hmi_ctrl, bind_hmi_controller) == NULL) { + return -1; + } + + loop = wl_display_get_event_loop(ec->wl_display); + wl_event_loop_add_idle(loop, launch_hmi_client_process, hmi_ctrl); + + return 0; +} |