/* * Copyright (C) 2014 DENSO CORPORATION * * Permission is hereby granted, free of charge, to any person obtaining * a copy of this software and associated documentation files (the * "Software"), to deal in the Software without restriction, including * without limitation the rights to use, copy, modify, merge, publish, * distribute, sublicense, and/or sell copies of the Software, and to * permit persons to whom the Software is furnished to do so, subject to * the following conditions: * * The above copyright notice and this permission notice (including the * next paragraph) shall be included in all copies or substantial * portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * 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, an 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 "config.h" #include #include #include #include #include #include #include #include #include #include "ivi-layout-export.h" #include "ivi-hmi-controller-server-protocol.h" #include "shared/helpers.h" #include "shared/xalloc.h" #include "compositor/weston.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 wl_list link; }; 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; uint32_t base_layer_id_offset; 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; uint32_t surface_id_offset; }; struct hmi_controller { struct hmi_server_setting *hmi_setting; /* List of struct hmi_controller_layer */ struct wl_list base_layer_list; struct wl_list application_layer_list; 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_listener surface_removed; struct wl_listener surface_configured; struct wl_listener desktop_surface_configured; struct wl_client *user_interface; struct ui_setting ui_setting; struct weston_output * workspace_background_output; int32_t screen_num; const struct ivi_layout_interface *interface; }; struct launcher_info { uint32_t surface_id; uint32_t workspace_id; int32_t index; }; /***************************************************************************** * local functions ****************************************************************************/ static int32_t is_surf_in_ui_widget(struct hmi_controller *hmi_ctrl, struct ivi_layout_surface *ivisurf) { uint32_t id = hmi_ctrl->interface->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 wl_list *layer_list) { struct hmi_controller_layer *layer = wl_container_of(layer_list->prev, layer, link); 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; struct ivi_layout_layer *ivilayer = NULL; int32_t i = 0; int32_t surf_num = 0; int32_t idx = 0; surfaces = xcalloc(surface_length, sizeof(*surfaces)); new_order = xcalloc(surface_length, sizeof(*surfaces)); 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; } wl_list_for_each_reverse(layer, layer_list, link) { if (idx >= surf_num) break; ivilayer = layer->ivilayer; for (i = 0; i < 8; i++, idx++) { if (idx >= surf_num) break; ivisurf = surfaces[idx]; new_order[i] = ivisurf; if (i < 4) { surface_x = (int32_t)(i * (surface_width)); surface_y = 0; } else { surface_x = (int32_t)((i - 4) * (surface_width)); surface_y = (int32_t)surface_height; } hmi_ctrl->interface->surface_set_transition(ivisurf, IVI_LAYOUT_TRANSITION_VIEW_DEFAULT, duration); hmi_ctrl->interface->surface_set_visibility(ivisurf, true); hmi_ctrl->interface->surface_set_destination_rectangle(ivisurf, surface_x, surface_y, (int32_t)surface_width, (int32_t)surface_height); } hmi_ctrl->interface->layer_set_render_order(ivilayer, new_order, i); hmi_ctrl->interface->layer_set_transition(ivilayer, IVI_LAYOUT_TRANSITION_LAYER_VIEW_ORDER, duration); } for (i = idx; i < surf_num; i++) hmi_ctrl->interface->surface_set_visibility(surfaces[i], false); 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 wl_list *layer_list) { struct hmi_controller_layer *layer = wl_container_of(layer_list->prev, layer, link); 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; struct ivi_layout_surface **surfaces; struct ivi_layout_surface **new_order; struct ivi_layout_layer *ivilayer = NULL; int32_t surf_num = 0; int32_t idx = 0; surfaces = xcalloc(surface_length, sizeof(*surfaces)); new_order = xcalloc(surface_length, sizeof(*surfaces)); 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; } wl_list_for_each_reverse(layer, layer_list, link) { if (idx >= surf_num) break; ivilayer = layer->ivilayer; for (i = 0; i < 2; i++, idx++) { if (idx >= surf_num) break; ivisurf = surfaces[idx]; new_order[i] = ivisurf; hmi_ctrl->interface->surface_set_transition(ivisurf, IVI_LAYOUT_TRANSITION_VIEW_DEFAULT, duration); hmi_ctrl->interface->surface_set_visibility(ivisurf, true); hmi_ctrl->interface->surface_set_destination_rectangle(ivisurf, i * surface_width, 0, surface_width, surface_height); } hmi_ctrl->interface->layer_set_render_order(ivilayer, new_order, i); } for (i = idx; i < surf_num; i++) { hmi_ctrl->interface->surface_set_transition(surfaces[i], IVI_LAYOUT_TRANSITION_VIEW_FADE_ONLY, duration); hmi_ctrl->interface->surface_set_visibility(surfaces[i], false); } free(surfaces); free(new_order); } static void mode_fullscreen_someone(struct hmi_controller *hmi_ctrl, struct ivi_layout_surface **pp_surface, int32_t surface_length, struct wl_list *layer_list) { struct hmi_controller_layer *layer = wl_container_of(layer_list->prev, layer, link); 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; int32_t surf_num = 0; struct ivi_layout_surface **surfaces; surfaces = xcalloc(surface_length, sizeof(*surfaces)); 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; } hmi_ctrl->interface->layer_set_render_order(layer->ivilayer, surfaces, surf_num); for (i = 0; i < surf_num; i++) { ivisurf = surfaces[i]; if ((i > 0) && (i < hmi_ctrl->screen_num)) { layer = wl_container_of(layer->link.prev, layer, link); hmi_ctrl->interface->layer_set_render_order(layer->ivilayer, &ivisurf, 1); } hmi_ctrl->interface->surface_set_transition(ivisurf, IVI_LAYOUT_TRANSITION_VIEW_DEFAULT, duration); hmi_ctrl->interface->surface_set_visibility(ivisurf, true); hmi_ctrl->interface->surface_set_destination_rectangle(ivisurf, 0, 0, surface_width, surface_height); } free(surfaces); } static void mode_random_replace(struct hmi_controller *hmi_ctrl, struct ivi_layout_surface **pp_surface, int32_t surface_length, struct wl_list *layer_list) { struct hmi_controller_layer *application_layer = NULL; struct hmi_controller_layer **layers = NULL; int32_t surface_width = 0; int32_t surface_height = 0; 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; int32_t layer_idx = 0; layers = xcalloc(hmi_ctrl->screen_num, sizeof(*layers)); wl_list_for_each(application_layer, layer_list, link) { layers[layer_idx] = application_layer; layer_idx++; } for (i = 0; i < surface_length; i++) { ivisurf = pp_surface[i]; /* skip ui widgets */ if (is_surf_in_ui_widget(hmi_ctrl, ivisurf)) continue; /* surface determined at random a layer that belongs */ layer_idx = rand() % hmi_ctrl->screen_num; hmi_ctrl->interface->surface_set_transition(ivisurf, IVI_LAYOUT_TRANSITION_VIEW_DEFAULT, duration); hmi_ctrl->interface->surface_set_visibility(ivisurf, true); surface_width = (int32_t)(layers[layer_idx]->width * 0.25f); surface_height = (int32_t)(layers[layer_idx]->height * 0.25f); surface_x = rand() % (layers[layer_idx]->width - surface_width); surface_y = rand() % (layers[layer_idx]->height - surface_height); hmi_ctrl->interface->surface_set_destination_rectangle(ivisurf, surface_x, surface_y, surface_width, surface_height); } free(layers); } 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 wl_list *layer = &hmi_ctrl->application_layer_list; 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 = hmi_ctrl->interface->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; } hmi_ctrl->interface->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) { hmi_ctrl->interface->layer_set_transition(linklayer->layout_layer, IVI_LAYOUT_TRANSITION_LAYER_FADE, duration); hmi_ctrl->interface->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 weston_output */ static void create_layer(struct weston_output *output, struct hmi_controller_layer *layer, struct hmi_controller *hmi_ctrl) { int32_t ret = 0; layer->ivilayer = hmi_ctrl->interface->layer_create_with_dimension(layer->id_layer, layer->width, layer->height); assert(layer->ivilayer != NULL); ret = hmi_ctrl->interface->screen_add_layer(output, layer->ivilayer); assert(!ret); ret = hmi_ctrl->interface->layer_set_destination_rectangle(layer->ivilayer, layer->x, layer->y, layer->width, layer->height); assert(!ret); ret = hmi_ctrl->interface->layer_set_visibility(layer->ivilayer, true); assert(!ret); } /** * Internal set notification */ static void set_notification_remove_surface(struct wl_listener *listener, void *data) { struct hmi_controller *hmi_ctrl = wl_container_of(listener, hmi_ctrl, surface_removed); (void)data; switch_mode(hmi_ctrl, hmi_ctrl->layout_mode); } static void set_notification_configure_surface(struct wl_listener *listener, void *data) { struct hmi_controller *hmi_ctrl = wl_container_of(listener, hmi_ctrl, surface_configured); struct ivi_layout_surface *ivisurf = data; struct hmi_controller_layer *layer_link = NULL; struct ivi_layout_layer *application_layer = NULL; struct weston_surface *surface; struct ivi_layout_surface **ivisurfs = NULL; int32_t length = 0; int32_t i; /* return if the surface is not application content */ if (is_surf_in_ui_widget(hmi_ctrl, ivisurf)) { return; } /* * if application changes size of wl_buffer. The source rectangle shall be * fit to the size. */ surface = hmi_ctrl->interface->surface_get_weston_surface(ivisurf); if (surface) { hmi_ctrl->interface->surface_set_source_rectangle( ivisurf, 0, 0, surface->width, surface->height); } /* * search if the surface is already added to layer. * If not yet, it is newly invoded application to go to switch_mode. */ wl_list_for_each_reverse(layer_link, &hmi_ctrl->application_layer_list, link) { application_layer = layer_link->ivilayer; hmi_ctrl->interface->get_surfaces_on_layer(application_layer, &length, &ivisurfs); for (i = 0; i < length; i++) { if (ivisurf == ivisurfs[i]) { /* * if it is non new invoked application, just call * commit_changes to apply source_rectangle. */ hmi_ctrl->interface->commit_changes(); free(ivisurfs); return; } } free(ivisurfs); ivisurfs = NULL; } switch_mode(hmi_ctrl, hmi_ctrl->layout_mode); } static void set_notification_configure_desktop_surface(struct wl_listener *listener, void *data) { struct hmi_controller *hmi_ctrl = wl_container_of(listener, hmi_ctrl, desktop_surface_configured); struct ivi_layout_surface *ivisurf = data; struct hmi_controller_layer *layer_link = wl_container_of(hmi_ctrl->application_layer_list.prev, layer_link, link); struct ivi_layout_layer *application_layer = layer_link->ivilayer; struct weston_surface *surface; int32_t ret = 0; /* skip ui widgets */ if (is_surf_in_ui_widget(hmi_ctrl, ivisurf)) return; ret = hmi_ctrl->interface->layer_add_surface(application_layer, ivisurf); assert(!ret); /* * if application changes size of wl_buffer. The source rectangle shall be * fit to the size. */ surface = hmi_ctrl->interface->surface_get_weston_surface(ivisurf); if (surface) { hmi_ctrl->interface->surface_set_source_rectangle(ivisurf, 0, 0, surface->width, surface->height); } hmi_ctrl->interface->commit_changes(); 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 = xzalloc(sizeof(*setting)); struct weston_config *config = wet_get_config(ec); struct weston_config_section *shell_section = NULL; char *ivi_ui_config; 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, "base-layer-id-offset", &setting->base_layer_id_offset, 10000); 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", &ivi_ui_config, NULL); if (ivi_ui_config && ivi_ui_config[0] != '/') { setting->ivi_homescreen = wet_get_libexec_path(ivi_ui_config); if (setting->ivi_homescreen) free(ivi_ui_config); else setting->ivi_homescreen = ivi_ui_config; } else { setting->ivi_homescreen = ivi_ui_config; } 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_layer *ctrl_layer_link = NULL; struct hmi_controller_layer *ctrl_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); } /* clear base_layer_list */ wl_list_for_each_safe(ctrl_layer_link, ctrl_layer_next, &hmi_ctrl->base_layer_list, link) { wl_list_remove(&ctrl_layer_link->link); free(ctrl_layer_link); } /* clear application_layer_list */ wl_list_for_each_safe(ctrl_layer_link, ctrl_layer_next, &hmi_ctrl->application_layer_list, link) { wl_list_remove(&ctrl_layer_link->link); free(ctrl_layer_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 link_layer *tmp_link_layer = NULL; int32_t panel_height = 0; struct hmi_controller *hmi_ctrl; const struct ivi_layout_interface *interface; struct hmi_controller_layer *base_layer = NULL; struct hmi_controller_layer *application_layer = NULL; struct weston_output *output; int32_t i; interface = ivi_layout_get_api(ec); if (!interface) { weston_log("Cannot use ivi_layout_interface.\n"); return NULL; } hmi_ctrl = xzalloc(sizeof(*hmi_ctrl)); i = 0; 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; hmi_ctrl->screen_num = wl_list_length(&ec->output_list); hmi_ctrl->interface = interface; /* init base ivi_layer*/ wl_list_init(&hmi_ctrl->base_layer_list); wl_list_for_each(output, &ec->output_list, link) { base_layer = xzalloc(sizeof(struct hmi_controller_layer)); base_layer->x = 0; base_layer->y = 0; base_layer->width = output->current_mode->width; base_layer->height = output->current_mode->height; base_layer->id_layer = hmi_ctrl->hmi_setting->base_layer_id + (i * hmi_ctrl->hmi_setting->base_layer_id_offset); wl_list_insert(&hmi_ctrl->base_layer_list, &base_layer->link); create_layer(output, base_layer, hmi_ctrl); i++; } i = 0; panel_height = hmi_ctrl->hmi_setting->panel_height; /* init application ivi_layer */ wl_list_init(&hmi_ctrl->application_layer_list); wl_list_for_each(output, &ec->output_list, link) { application_layer = xzalloc(sizeof(struct hmi_controller_layer)); application_layer->x = 0; application_layer->y = 0; application_layer->width = output->current_mode->width; application_layer->height = output->current_mode->height - panel_height; application_layer->id_layer = hmi_ctrl->hmi_setting->application_layer_id + (i * hmi_ctrl->hmi_setting->base_layer_id_offset); wl_list_insert(&hmi_ctrl->application_layer_list, &application_layer->link); create_layer(output, application_layer, hmi_ctrl); i++; } /* init workspace background ivi_layer */ output = wl_container_of(ec->output_list.next, output, link); hmi_ctrl->workspace_background_output = output; hmi_ctrl->workspace_background_layer.x = 0; hmi_ctrl->workspace_background_layer.y = 0; hmi_ctrl->workspace_background_layer.width = output->current_mode->width; hmi_ctrl->workspace_background_layer.height = output->current_mode->height - panel_height; hmi_ctrl->workspace_background_layer.id_layer = hmi_ctrl->hmi_setting->workspace_background_layer_id; create_layer(output, &hmi_ctrl->workspace_background_layer, hmi_ctrl); hmi_ctrl->interface->layer_set_opacity( hmi_ctrl->workspace_background_layer.ivilayer, 0); hmi_ctrl->interface->layer_set_visibility( hmi_ctrl->workspace_background_layer.ivilayer, false); wl_list_init(&hmi_ctrl->workspace_fade.layer_list); tmp_link_layer = xzalloc(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); hmi_ctrl->surface_removed.notify = set_notification_remove_surface; hmi_ctrl->interface->add_listener_remove_surface(&hmi_ctrl->surface_removed); hmi_ctrl->surface_configured.notify = set_notification_configure_surface; hmi_ctrl->interface->add_listener_configure_surface(&hmi_ctrl->surface_configured); hmi_ctrl->desktop_surface_configured.notify = set_notification_configure_desktop_surface; hmi_ctrl->interface->add_listener_configure_desktop_surface(&hmi_ctrl->desktop_surface_configured); hmi_ctrl->destroy_listener.notify = hmi_controller_destroy; wl_signal_add(&hmi_ctrl->compositor->destroy_signal, &hmi_ctrl->destroy_listener); 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 hmi_controller_layer *base_layer = NULL; struct ivi_layout_layer *ivilayer = NULL; int32_t dstx; int32_t dsty; int32_t width; int32_t height; int32_t ret = 0; int32_t i = 0; wl_list_for_each_reverse(base_layer, &hmi_ctrl->base_layer_list, link) { uint32_t *add_surface_id = wl_array_add(&hmi_ctrl->ui_widgets, sizeof(*add_surface_id)); *add_surface_id = id_surface + (i * hmi_ctrl->ui_setting.surface_id_offset); dstx = base_layer->x; dsty = base_layer->y; width = base_layer->width; height = base_layer->height; ivilayer = base_layer->ivilayer; ivisurf = hmi_ctrl->interface->get_surface_from_id(*add_surface_id); assert(ivisurf != NULL); ret = hmi_ctrl->interface->layer_add_surface(ivilayer, ivisurf); assert(!ret); ret = hmi_ctrl->interface->surface_set_destination_rectangle(ivisurf, dstx, dsty, width, height); assert(!ret); ret = hmi_ctrl->interface->surface_set_visibility(ivisurf, true); assert(!ret); i++; } } /** * 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 hmi_controller_layer *base_layer; struct ivi_layout_layer *ivilayer = NULL; int32_t width; int32_t ret = 0; int32_t panel_height = hmi_ctrl->hmi_setting->panel_height; const int32_t dstx = 0; int32_t dsty = 0; int32_t i = 0; wl_list_for_each_reverse(base_layer, &hmi_ctrl->base_layer_list, link) { uint32_t *add_surface_id = wl_array_add(&hmi_ctrl->ui_widgets, sizeof(*add_surface_id)); *add_surface_id = id_surface + (i * hmi_ctrl->ui_setting.surface_id_offset); ivilayer = base_layer->ivilayer; ivisurf = hmi_ctrl->interface->get_surface_from_id(*add_surface_id); assert(ivisurf != NULL); ret = hmi_ctrl->interface->layer_add_surface(ivilayer, ivisurf); assert(!ret); dsty = base_layer->height - panel_height; width = base_layer->width; ret = hmi_ctrl->interface->surface_set_destination_rectangle( ivisurf, dstx, dsty, width, panel_height); assert(!ret); ret = hmi_ctrl->interface->surface_set_visibility(ivisurf, true); assert(!ret); i++; } } /** * 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 hmi_controller_layer *base_layer = wl_container_of(hmi_ctrl->base_layer_list.prev, base_layer, link); struct ivi_layout_layer *ivilayer = 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 = hmi_ctrl->interface->get_surface_from_id(id_surface); assert(ivisurf != NULL); ret = hmi_ctrl->interface->layer_add_surface(ivilayer, ivisurf); assert(!ret); panel_height = hmi_ctrl->hmi_setting->panel_height; dstx = (60 * number) + 15; dsty = (base_layer->height - panel_height) + 5; ret = hmi_ctrl->interface->surface_set_destination_rectangle( ivisurf,dstx, dsty, width, height); assert(!ret); ret = hmi_ctrl->interface->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 hmi_controller_layer *base_layer = wl_container_of(hmi_ctrl->base_layer_list.prev, base_layer, link); struct ivi_layout_layer *ivilayer = 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 = (base_layer->width - size) / 2; const int32_t dsty = (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 = hmi_ctrl->interface->get_surface_from_id(id_surface); assert(ivisurf != NULL); ret = hmi_ctrl->interface->layer_add_surface(ivilayer, ivisurf); assert(!ret); ret = hmi_ctrl->interface->surface_set_destination_rectangle( ivisurf, dstx, dsty, size, size); assert(!ret); ret = hmi_ctrl->interface->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 = hmi_ctrl->interface->get_surface_from_id(id_surface); assert(ivisurf != NULL); ret = hmi_ctrl->interface->layer_add_surface(ivilayer, ivisurf); assert(!ret); ret = hmi_ctrl->interface->surface_set_destination_rectangle(ivisurf, 0, 0, width, height); assert(!ret); ret = hmi_ctrl->interface->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) { int32_t minspace_x = 10; int32_t minspace_y = minspace_x; int32_t width = hmi_ctrl->workspace_background_layer.width; int32_t height = hmi_ctrl->workspace_background_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; struct link_layer *tmp_link_layer = NULL; if (0 == x_count) x_count = 1; if (0 == y_count) y_count = 1; config = wet_get_config(hmi_ctrl->compositor); 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) { 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 = hmi_ctrl->interface->get_surface_from_id(data->surface_id); assert(layout_surface); ret = hmi_ctrl->interface->surface_set_destination_rectangle( layout_surface, x, y, icon_size, icon_size); assert(!ret); nx++; if (x_count == nx) { ny++; nx = 0; } } /* 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_count; 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(hmi_ctrl->workspace_background_output, &hmi_ctrl->workspace_layer, hmi_ctrl); hmi_ctrl->interface->layer_set_opacity(hmi_ctrl->workspace_layer.ivilayer, 0); hmi_ctrl->interface->layer_set_visibility(hmi_ctrl->workspace_layer.ivilayer, false); tmp_link_layer = xzalloc(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); /* Add surface to layer */ wl_array_for_each(data, &launchers) { layout_surface = hmi_ctrl->interface->get_surface_from_id(data->surface_id); assert(layout_surface); ret = hmi_ctrl->interface->layer_add_surface(hmi_ctrl->workspace_layer.ivilayer, layout_surface); assert(!ret); ret = hmi_ctrl->interface->surface_set_visibility(layout_surface, true); assert(!ret); } wl_array_release(&launchers); hmi_ctrl->interface->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); hmi_ctrl->interface->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 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; const struct ivi_layout_layer_properties *prop; 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; prop = hmi_ctrl->interface->get_properties_of_layer(layer); pos_x = prop->dest_x; pos_y = prop->dest_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); hmi_ctrl->interface->layer_set_transition(layer, IVI_LAYOUT_TRANSITION_LAYER_MOVE, duration); hmi_ctrl->interface->layer_set_destination_rectangle(layer, end_pos, pos_y, hmi_ctrl->workspace_layer.width, hmi_ctrl->workspace_layer.height); hmi_ctrl->interface->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 pointer_default_grab_axis(struct weston_pointer_grab *grab, const struct timespec *time, struct weston_pointer_axis_event *event) { weston_pointer_send_axis(grab->pointer, time, event); } static void pointer_default_grab_axis_source(struct weston_pointer_grab *grab, uint32_t source) { weston_pointer_send_axis_source(grab->pointer, source); } static void pointer_default_grab_frame(struct weston_pointer_grab *grab) { weston_pointer_send_frame(grab->pointer); } 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 hmi_controller *hmi_ctrl, struct ivi_layout_layer *layer, wl_fixed_t pos_x, wl_fixed_t pos_y) { const struct ivi_layout_layer_properties *prop; int32_t layout_pos_x = 0; int32_t layout_pos_y = 0; prop = hmi_ctrl->interface->get_properties_of_layer(layer); layout_pos_x = wl_fixed_to_int(pos_x); layout_pos_y = wl_fixed_to_int(pos_y); hmi_ctrl->interface->layer_set_destination_rectangle(layer, layout_pos_x, layout_pos_y, prop->dest_width, prop->dest_height); hmi_ctrl->interface->commit_changes(); } static void pointer_move_grab_motion(struct weston_pointer_grab *grab, const struct timespec *time, struct weston_pointer_motion_event *event) { struct pointer_move_grab *pnt_move_grab = (struct pointer_move_grab *)grab; struct hmi_controller *hmi_ctrl = wl_resource_get_user_data(pnt_move_grab->base.resource); wl_fixed_t pointer_pos[2]; weston_pointer_motion_to_abs(grab->pointer, event, &pointer_pos[0], &pointer_pos[1]); move_grab_update(&pnt_move_grab->move, pointer_pos); layer_set_pos(hmi_ctrl, 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, event); } static void touch_move_grab_motion(struct weston_touch_grab *grab, const struct timespec *time, int touch_id, wl_fixed_t x, wl_fixed_t y) { struct touch_move_grab *tch_move_grab = (struct touch_move_grab *)grab; struct hmi_controller *hmi_ctrl = wl_resource_get_user_data(tch_move_grab->base.resource); 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(hmi_ctrl, 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, const struct timespec *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, const struct timespec *time, int touch_id, wl_fixed_t sx, wl_fixed_t sy) { } static void touch_move_workspace_grab_up(struct weston_touch_grab *grab, const struct timespec *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_frame(struct weston_touch_grab *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_default_grab_axis, pointer_default_grab_axis_source, pointer_default_grab_frame, 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_frame, 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) { struct weston_pointer *pointer = weston_seat_get_pointer(seat); struct weston_touch *touch = weston_seat_get_touch(seat); if (pointer && pointer->focus && pointer->button_count && pointer->grab_serial == serial) return HMI_GRAB_DEVICE_POINTER; if (touch && touch->focus && 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; const struct ivi_layout_layer_properties *prop; 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 }; prop = hmi_ctrl->interface->get_properties_of_layer(layer); layer_pos_x = prop->dest_x; layer_pos_y = prop->dest_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 = xzalloc(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 = xzalloc(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; struct weston_pointer *pointer; struct weston_touch *touch; 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; hmi_ctrl->interface->transition_move_layer_cancel(layer); switch (device) { case HMI_GRAB_DEVICE_POINTER: pointer = weston_seat_get_pointer(seat); pnt_move_grab = create_workspace_pointer_move(pointer, resource); pointer_grab_start(&pnt_move_grab->base, layer, &pointer_move_grab_workspace_interface, pointer); break; case HMI_GRAB_DEVICE_TOUCH: touch = weston_seat_get_touch(seat); tch_move_grab = create_workspace_touch_move(touch, resource); touch_grab_start(&tch_move_grab->base, layer, &touch_move_grab_workspace_interface, 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); } hmi_ctrl->interface->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 = wet_get_config(hmi_ctrl->compositor); 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 }, { "surface-id-offset", &hmi_ctrl->ui_setting.surface_id_offset }, { 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 wet_module_init(struct weston_compositor *ec, int *argc, char *argv[]) { struct hmi_controller *hmi_ctrl = NULL; struct wl_event_loop *loop = NULL; /* ad hoc weston_compositor_add_destroy_listener_once() */ if (wl_signal_get(&ec->destroy_signal, hmi_controller_destroy)) return 0; hmi_ctrl = hmi_controller_create(ec); if (hmi_ctrl == NULL) return -1; 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; }