mainnika
/
weston
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

ivi-shell: rename ivi_controller_interface

Browse Source 
The name of ivi_controller_interface is changed to ivi_layout_interface
with this patch.

This name is better suited to the interface, because it is implemented
in ivi-layout.c and its methods are linked to ivi_layout* functions.

Furthermore, the controller modules (e.g. hmi-controller) are the users
of this interface and they have their own interfaces,
which are called *_controller_interface,
e.g.: ivi_hmi_controller_interface.

This causes confusion about the software architecture.

Signed-off-by: Emre Ucan <eucan@de.adit-jv.com>
Tested-by: Nobuhiko Tanibata <NOBUHIKO_TANIBATA@xddp.denso.co.jp>
Reviewed-by: Nobuhiko Tanibata <NOBUHIKO_TANIBATA@xddp.denso.co.jp>
dev
Ucan, Emre \(ADITG/SW1\) 9 years ago committed by Bryce Harrington
parent 32c3211e38
commit 0c0e51e096
5 changed files with 552 additions and 552 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 168
      ivi-shell/hmi-controller.c
  2. 2
      ivi-shell/ivi-layout-export.h
  3. 8
      ivi-shell/ivi-layout.c
  4. 562
      tests/ivi_layout-internal-test.c
  5. 364
      tests/ivi_layout-test-plugin.c

168
ivi-shell/hmi-controller.c
Unescape View File

@ -132,12 +132,12 @@ struct launcher_info {
int32_t index; int32_t index;
}; };
const struct ivi_controller_interface *ivi_controller_interface; const struct ivi_layout_interface *ivi_layout_interface;
int int
controller_module_init(struct weston_compositor *ec, controller_module_init(struct weston_compositor *ec,
int *argc, char *argv[], int *argc, char *argv[],
const struct ivi_controller_interface *interface, const struct ivi_layout_interface *interface,
size_t interface_version); size_t interface_version);
/***************************************************************************** /*****************************************************************************
@ -166,7 +166,7 @@ static int32_t
is_surf_in_ui_widget(struct hmi_controller *hmi_ctrl, is_surf_in_ui_widget(struct hmi_controller *hmi_ctrl,
struct ivi_layout_surface *ivisurf) struct ivi_layout_surface *ivisurf)
{ {
uint32_t id = ivi_controller_interface->get_id_of_surface(ivisurf); uint32_t id = ivi_layout_interface->get_id_of_surface(ivisurf);
uint32_t *ui_widget_id = NULL; uint32_t *ui_widget_id = NULL;
wl_array_for_each(ui_widget_id, &hmi_ctrl->ui_widgets) { wl_array_for_each(ui_widget_id, &hmi_ctrl->ui_widgets) {
@ -247,11 +247,11 @@ mode_divided_into_tiling(struct hmi_controller *hmi_ctrl,
surface_y = (int32_t)surface_height; surface_y = (int32_t)surface_height;
} }
ivi_controller_interface->surface_set_transition(ivisurf, ivi_layout_interface->surface_set_transition(ivisurf,
IVI_LAYOUT_TRANSITION_VIEW_DEFAULT, IVI_LAYOUT_TRANSITION_VIEW_DEFAULT,
duration); duration);
ivi_controller_interface->surface_set_visibility(ivisurf, true); ivi_layout_interface->surface_set_visibility(ivisurf, true);
ivi_controller_interface->surface_set_destination_rectangle(ivisurf, ivi_layout_interface->surface_set_destination_rectangle(ivisurf,
surface_x, surface_y, surface_x, surface_y,
(int32_t)surface_width, (int32_t)surface_width,
(int32_t)surface_height); (int32_t)surface_height);
@ -259,11 +259,11 @@ mode_divided_into_tiling(struct hmi_controller *hmi_ctrl,
num++; num++;
continue; continue;
} }
ivi_controller_interface->surface_set_visibility(ivisurf, false); ivi_layout_interface->surface_set_visibility(ivisurf, false);
} }
if (surf_num > 0) { if (surf_num > 0) {
ivi_controller_interface->layer_set_transition(layer->ivilayer, ivi_layout_interface->layer_set_transition(layer->ivilayer,
IVI_LAYOUT_TRANSITION_LAYER_VIEW_ORDER, IVI_LAYOUT_TRANSITION_LAYER_VIEW_ORDER,
duration); duration);
} }
@ -294,11 +294,11 @@ mode_divided_into_sidebyside(struct hmi_controller *hmi_ctrl,
continue; continue;
if (num == 1) { if (num == 1) {
ivi_controller_interface->surface_set_transition(ivisurf, ivi_layout_interface->surface_set_transition(ivisurf,
IVI_LAYOUT_TRANSITION_VIEW_DEFAULT, IVI_LAYOUT_TRANSITION_VIEW_DEFAULT,
duration); duration);
ivi_controller_interface->surface_set_visibility(ivisurf, true); ivi_layout_interface->surface_set_visibility(ivisurf, true);
ivi_controller_interface->surface_set_destination_rectangle(ivisurf, ivi_layout_interface->surface_set_destination_rectangle(ivisurf,
0, 0, 0, 0,
surface_width, surface_width,
surface_height); surface_height);
@ -306,11 +306,11 @@ mode_divided_into_sidebyside(struct hmi_controller *hmi_ctrl,
num++; num++;
continue; continue;
} else if (num == 2) { } else if (num == 2) {
ivi_controller_interface->surface_set_transition(ivisurf, ivi_layout_interface->surface_set_transition(ivisurf,
IVI_LAYOUT_TRANSITION_VIEW_DEFAULT, IVI_LAYOUT_TRANSITION_VIEW_DEFAULT,
duration); duration);
ivi_controller_interface->surface_set_visibility(ivisurf, true); ivi_layout_interface->surface_set_visibility(ivisurf, true);
ivi_controller_interface->surface_set_destination_rectangle(ivisurf, ivi_layout_interface->surface_set_destination_rectangle(ivisurf,
surface_width, 0, surface_width, 0,
surface_width, surface_width,
surface_height); surface_height);
@ -318,10 +318,10 @@ mode_divided_into_sidebyside(struct hmi_controller *hmi_ctrl,
num++; num++;
continue; continue;
} }
ivi_controller_interface->surface_set_transition(ivisurf, ivi_layout_interface->surface_set_transition(ivisurf,
IVI_LAYOUT_TRANSITION_VIEW_FADE_ONLY, IVI_LAYOUT_TRANSITION_VIEW_FADE_ONLY,
duration); duration);
ivi_controller_interface->surface_set_visibility(ivisurf, false); ivi_layout_interface->surface_set_visibility(ivisurf, false);
} }
} }
@ -344,11 +344,11 @@ mode_fullscreen_someone(struct hmi_controller *hmi_ctrl,
if (is_surf_in_ui_widget(hmi_ctrl, ivisurf)) if (is_surf_in_ui_widget(hmi_ctrl, ivisurf))
continue; continue;
ivi_controller_interface->surface_set_transition(ivisurf, ivi_layout_interface->surface_set_transition(ivisurf,
IVI_LAYOUT_TRANSITION_VIEW_DEFAULT, IVI_LAYOUT_TRANSITION_VIEW_DEFAULT,
duration); duration);
ivi_controller_interface->surface_set_visibility(ivisurf, true); ivi_layout_interface->surface_set_visibility(ivisurf, true);
ivi_controller_interface->surface_set_destination_rectangle(ivisurf, 0, 0, ivi_layout_interface->surface_set_destination_rectangle(ivisurf, 0, 0,
surface_width, surface_width,
surface_height); surface_height);
} }
@ -375,14 +375,14 @@ mode_random_replace(struct hmi_controller *hmi_ctrl,
if (is_surf_in_ui_widget(hmi_ctrl, ivisurf)) if (is_surf_in_ui_widget(hmi_ctrl, ivisurf))
continue; continue;
ivi_controller_interface->surface_set_transition(ivisurf, ivi_layout_interface->surface_set_transition(ivisurf,
IVI_LAYOUT_TRANSITION_VIEW_DEFAULT, IVI_LAYOUT_TRANSITION_VIEW_DEFAULT,
duration); duration);
ivi_controller_interface->surface_set_visibility(ivisurf, true); ivi_layout_interface->surface_set_visibility(ivisurf, true);
surface_x = rand() % (layer->width - surface_width); surface_x = rand() % (layer->width - surface_width);
surface_y = rand() % (layer->height - surface_height); surface_y = rand() % (layer->height - surface_height);
ivi_controller_interface->surface_set_destination_rectangle(ivisurf, ivi_layout_interface->surface_set_destination_rectangle(ivisurf,
surface_x, surface_x,
surface_y, surface_y,
surface_width, surface_width,
@ -429,7 +429,7 @@ switch_mode(struct hmi_controller *hmi_ctrl,
hmi_ctrl->layout_mode = layout_mode; hmi_ctrl->layout_mode = layout_mode;
ret = ivi_controller_interface->get_surfaces(&surface_length, &pp_surface); ret = ivi_layout_interface->get_surfaces(&surface_length, &pp_surface);
assert(!ret); assert(!ret);
if (!has_application_surface(hmi_ctrl, pp_surface, surface_length)) { if (!has_application_surface(hmi_ctrl, pp_surface, surface_length)) {
@ -457,7 +457,7 @@ switch_mode(struct hmi_controller *hmi_ctrl,
break; break;
} }
ivi_controller_interface->commit_changes(); ivi_layout_interface->commit_changes();
free(pp_surface); free(pp_surface);
} }
@ -475,10 +475,10 @@ hmi_controller_fade_run(struct hmi_controller *hmi_ctrl, uint32_t is_fade_in,
fade->is_fade_in = is_fade_in; fade->is_fade_in = is_fade_in;
wl_list_for_each(linklayer, &fade->layer_list, link) { wl_list_for_each(linklayer, &fade->layer_list, link) {
ivi_controller_interface->layer_set_transition(linklayer->layout_layer, ivi_layout_interface->layer_set_transition(linklayer->layout_layer,
IVI_LAYOUT_TRANSITION_LAYER_FADE, IVI_LAYOUT_TRANSITION_LAYER_FADE,
duration); duration);
ivi_controller_interface->layer_set_fade_info(linklayer->layout_layer, ivi_layout_interface->layer_set_fade_info(linklayer->layout_layer,
is_fade_in, 1.0 - tint, tint); is_fade_in, 1.0 - tint, tint);
} }
} }
@ -494,21 +494,21 @@ create_layer(struct ivi_layout_screen *iviscrn,
int32_t ret = 0; int32_t ret = 0;
layer->ivilayer = layer->ivilayer =
ivi_controller_interface->layer_create_with_dimension(layer->id_layer, ivi_layout_interface->layer_create_with_dimension(layer->id_layer,
layer->width, layer->width,
layer->height); layer->height);
assert(layer->ivilayer != NULL); assert(layer->ivilayer != NULL);
ret = ivi_controller_interface->screen_add_layer(iviscrn, layer->ivilayer); ret = ivi_layout_interface->screen_add_layer(iviscrn, layer->ivilayer);
assert(!ret); assert(!ret);
ret = ivi_controller_interface->layer_set_destination_rectangle(layer->ivilayer, ret = ivi_layout_interface->layer_set_destination_rectangle(layer->ivilayer,
layer->x, layer->y, layer->x, layer->y,
layer->width, layer->width,
layer->height); layer->height);
assert(!ret); assert(!ret);
ret = ivi_controller_interface->layer_set_visibility(layer->ivilayer, true); ret = ivi_layout_interface->layer_set_visibility(layer->ivilayer, true);
assert(!ret); assert(!ret);
} }
@ -528,7 +528,7 @@ set_notification_create_surface(struct ivi_layout_surface *ivisurf,
if (is_surf_in_ui_widget(hmi_ctrl, ivisurf)) if (is_surf_in_ui_widget(hmi_ctrl, ivisurf))
return; return;
ret = ivi_controller_interface->layer_add_surface(application_layer, ivisurf); ret = ivi_layout_interface->layer_add_surface(application_layer, ivisurf);
assert(!ret); assert(!ret);
} }
@ -562,9 +562,9 @@ set_notification_configure_surface(struct ivi_layout_surface *ivisurf,
* if application changes size of wl_buffer. The source rectangle shall be * if application changes size of wl_buffer. The source rectangle shall be
* fit to the size. * fit to the size.
*/ */
surface = ivi_controller_interface->surface_get_weston_surface(ivisurf); surface = ivi_layout_interface->surface_get_weston_surface(ivisurf);
if (surface) { if (surface) {
ivi_controller_interface->surface_set_source_rectangle( ivi_layout_interface->surface_set_source_rectangle(
ivisurf, 0, 0, surface->width, ivisurf, 0, 0, surface->width,
surface->height); surface->height);
} }
@ -573,7 +573,7 @@ set_notification_configure_surface(struct ivi_layout_surface *ivisurf,
* search if the surface is already added to layer. * search if the surface is already added to layer.
* If not yet, it is newly invoded application to go to switch_mode. * If not yet, it is newly invoded application to go to switch_mode.
*/ */
ivi_controller_interface->get_surfaces_on_layer(application_layer, ivi_layout_interface->get_surfaces_on_layer(application_layer,
&length, &ivisurfs); &length, &ivisurfs);
for (i = 0; i < length; i++) { for (i = 0; i < length; i++) {
if (ivisurf == ivisurfs[i]) { if (ivisurf == ivisurfs[i]) {
@ -581,7 +581,7 @@ set_notification_configure_surface(struct ivi_layout_surface *ivisurf,
* if it is non new invoked application, just call * if it is non new invoked application, just call
* commit_changes to apply source_rectangle. * commit_changes to apply source_rectangle.
*/ */
ivi_controller_interface->commit_changes(); ivi_layout_interface->commit_changes();
return; return;
} }
} }
@ -681,11 +681,11 @@ hmi_controller_create(struct weston_compositor *ec)
hmi_ctrl->hmi_setting = hmi_server_setting_create(ec); hmi_ctrl->hmi_setting = hmi_server_setting_create(ec);
hmi_ctrl->compositor = ec; hmi_ctrl->compositor = ec;
ivi_controller_interface->get_screens(&screen_length, &pp_screen); ivi_layout_interface->get_screens(&screen_length, &pp_screen);
iviscrn = pp_screen[0]; iviscrn = pp_screen[0];
ivi_controller_interface->get_screen_resolution(iviscrn, &screen_width, ivi_layout_interface->get_screen_resolution(iviscrn, &screen_width,
&screen_height); &screen_height);
/* init base ivi_layer*/ /* init base ivi_layer*/
@ -720,9 +720,9 @@ hmi_controller_create(struct weston_compositor *ec)
hmi_ctrl->hmi_setting->workspace_background_layer_id; hmi_ctrl->hmi_setting->workspace_background_layer_id;
create_layer(iviscrn, &hmi_ctrl->workspace_background_layer); create_layer(iviscrn, &hmi_ctrl->workspace_background_layer);
ivi_controller_interface->layer_set_opacity( ivi_layout_interface->layer_set_opacity(
hmi_ctrl->workspace_background_layer.ivilayer, 0); hmi_ctrl->workspace_background_layer.ivilayer, 0);
ivi_controller_interface->layer_set_visibility( ivi_layout_interface->layer_set_visibility(
hmi_ctrl->workspace_background_layer.ivilayer, false); hmi_ctrl->workspace_background_layer.ivilayer, false);
@ -733,11 +733,11 @@ hmi_controller_create(struct weston_compositor *ec)
wl_list_insert(&hmi_ctrl->workspace_fade.layer_list, wl_list_insert(&hmi_ctrl->workspace_fade.layer_list,
&tmp_link_layer->link); &tmp_link_layer->link);
ivi_controller_interface->add_notification_create_surface( ivi_layout_interface->add_notification_create_surface(
set_notification_create_surface, hmi_ctrl); set_notification_create_surface, hmi_ctrl);
ivi_controller_interface->add_notification_remove_surface( ivi_layout_interface->add_notification_remove_surface(
set_notification_remove_surface, hmi_ctrl); set_notification_remove_surface, hmi_ctrl);
ivi_controller_interface->add_notification_configure_surface( ivi_layout_interface->add_notification_configure_surface(
set_notification_configure_surface, hmi_ctrl); set_notification_configure_surface, hmi_ctrl);
hmi_ctrl->destroy_listener.notify = hmi_controller_destroy; hmi_ctrl->destroy_listener.notify = hmi_controller_destroy;
@ -777,17 +777,17 @@ ivi_hmi_controller_set_background(struct hmi_controller *hmi_ctrl,
sizeof(*add_surface_id)); sizeof(*add_surface_id));
*add_surface_id = id_surface; *add_surface_id = id_surface;
ivisurf = ivi_controller_interface->get_surface_from_id(id_surface); ivisurf = ivi_layout_interface->get_surface_from_id(id_surface);
assert(ivisurf != NULL); assert(ivisurf != NULL);
ret = ivi_controller_interface->layer_add_surface(ivilayer, ivisurf); ret = ivi_layout_interface->layer_add_surface(ivilayer, ivisurf);
assert(!ret); assert(!ret);
ret = ivi_controller_interface->surface_set_destination_rectangle(ivisurf, ret = ivi_layout_interface->surface_set_destination_rectangle(ivisurf,
dstx, dsty, width, height); dstx, dsty, width, height);
assert(!ret); assert(!ret);
ret = ivi_controller_interface->surface_set_visibility(ivisurf, true); ret = ivi_layout_interface->surface_set_visibility(ivisurf, true);
assert(!ret); assert(!ret);
} }
@ -814,21 +814,21 @@ ivi_hmi_controller_set_panel(struct hmi_controller *hmi_ctrl,
sizeof(*add_surface_id)); sizeof(*add_surface_id));
*add_surface_id = id_surface; *add_surface_id = id_surface;
ivisurf = ivi_controller_interface->get_surface_from_id(id_surface); ivisurf = ivi_layout_interface->get_surface_from_id(id_surface);
assert(ivisurf != NULL); assert(ivisurf != NULL);
ret = ivi_controller_interface->layer_add_surface(ivilayer, ivisurf); ret = ivi_layout_interface->layer_add_surface(ivilayer, ivisurf);
assert(!ret); assert(!ret);
panel_height = hmi_ctrl->hmi_setting->panel_height; panel_height = hmi_ctrl->hmi_setting->panel_height;
dsty = hmi_ctrl->base_layer.height - panel_height; dsty = hmi_ctrl->base_layer.height - panel_height;
ret = ivi_controller_interface->surface_set_destination_rectangle( ret = ivi_layout_interface->surface_set_destination_rectangle(
ivisurf, dstx, dsty, width, panel_height); ivisurf, dstx, dsty, width, panel_height);
assert(!ret); assert(!ret);
ret = ivi_controller_interface->surface_set_visibility(ivisurf, true); ret = ivi_layout_interface->surface_set_visibility(ivisurf, true);
assert(!ret); assert(!ret);
} }
@ -857,10 +857,10 @@ ivi_hmi_controller_set_button(struct hmi_controller *hmi_ctrl,
sizeof(*add_surface_id)); sizeof(*add_surface_id));
*add_surface_id = id_surface; *add_surface_id = id_surface;
ivisurf = ivi_controller_interface->get_surface_from_id(id_surface); ivisurf = ivi_layout_interface->get_surface_from_id(id_surface);
assert(ivisurf != NULL); assert(ivisurf != NULL);
ret = ivi_controller_interface->layer_add_surface(ivilayer, ivisurf); ret = ivi_layout_interface->layer_add_surface(ivilayer, ivisurf);
assert(!ret); assert(!ret);
panel_height = hmi_ctrl->hmi_setting->panel_height; panel_height = hmi_ctrl->hmi_setting->panel_height;
@ -868,11 +868,11 @@ ivi_hmi_controller_set_button(struct hmi_controller *hmi_ctrl,
dstx = (60 * number) + 15; dstx = (60 * number) + 15;
dsty = (hmi_ctrl->base_layer.height - panel_height) + 5; dsty = (hmi_ctrl->base_layer.height - panel_height) + 5;
ret = ivi_controller_interface->surface_set_destination_rectangle( ret = ivi_layout_interface->surface_set_destination_rectangle(
ivisurf,dstx, dsty, width, height); ivisurf,dstx, dsty, width, height);
assert(!ret); assert(!ret);
ret = ivi_controller_interface->surface_set_visibility(ivisurf, true); ret = ivi_layout_interface->surface_set_visibility(ivisurf, true);
assert(!ret); assert(!ret);
} }
@ -899,17 +899,17 @@ ivi_hmi_controller_set_home_button(struct hmi_controller *hmi_ctrl,
sizeof(*add_surface_id)); sizeof(*add_surface_id));
*add_surface_id = id_surface; *add_surface_id = id_surface;
ivisurf = ivi_controller_interface->get_surface_from_id(id_surface); ivisurf = ivi_layout_interface->get_surface_from_id(id_surface);
assert(ivisurf != NULL); assert(ivisurf != NULL);
ret = ivi_controller_interface->layer_add_surface(ivilayer, ivisurf); ret = ivi_layout_interface->layer_add_surface(ivilayer, ivisurf);
assert(!ret); assert(!ret);
ret = ivi_controller_interface->surface_set_destination_rectangle( ret = ivi_layout_interface->surface_set_destination_rectangle(
ivisurf, dstx, dsty, size, size); ivisurf, dstx, dsty, size, size);
assert(!ret); assert(!ret);
ret = ivi_controller_interface->surface_set_visibility(ivisurf, true); ret = ivi_layout_interface->surface_set_visibility(ivisurf, true);
assert(!ret); assert(!ret);
} }
@ -935,17 +935,17 @@ ivi_hmi_controller_set_workspacebackground(struct hmi_controller *hmi_ctrl,
*add_surface_id = id_surface; *add_surface_id = id_surface;
ivilayer = hmi_ctrl->workspace_background_layer.ivilayer; ivilayer = hmi_ctrl->workspace_background_layer.ivilayer;
ivisurf = ivi_controller_interface->get_surface_from_id(id_surface); ivisurf = ivi_layout_interface->get_surface_from_id(id_surface);
assert(ivisurf != NULL); assert(ivisurf != NULL);
ret = ivi_controller_interface->layer_add_surface(ivilayer, ivisurf); ret = ivi_layout_interface->layer_add_surface(ivilayer, ivisurf);
assert(!ret); assert(!ret);
ret = ivi_controller_interface->surface_set_destination_rectangle(ivisurf, ret = ivi_layout_interface->surface_set_destination_rectangle(ivisurf,
0, 0, width, height); 0, 0, width, height);
assert(!ret); assert(!ret);
ret = ivi_controller_interface->surface_set_visibility(ivisurf, true); ret = ivi_layout_interface->surface_set_visibility(ivisurf, true);
assert(!ret); assert(!ret);
} }
@ -1074,10 +1074,10 @@ ivi_hmi_controller_add_launchers(struct hmi_controller *hmi_ctrl,
y = ny * fcell_size_y + space_y; y = ny * fcell_size_y + space_y;
layout_surface = layout_surface =
ivi_controller_interface->get_surface_from_id(data->surface_id); ivi_layout_interface->get_surface_from_id(data->surface_id);
assert(layout_surface); assert(layout_surface);
ret = ivi_controller_interface->surface_set_destination_rectangle( ret = ivi_layout_interface->surface_set_destination_rectangle(
layout_surface, x, y, icon_size, icon_size); layout_surface, x, y, icon_size, icon_size);
assert(!ret); assert(!ret);
@ -1099,12 +1099,12 @@ ivi_hmi_controller_add_launchers(struct hmi_controller *hmi_ctrl,
hmi_ctrl->workspace_layer.id_layer = hmi_ctrl->workspace_layer.id_layer =
hmi_ctrl->hmi_setting->workspace_layer_id; hmi_ctrl->hmi_setting->workspace_layer_id;
ivi_controller_interface->get_screens(&screen_length, &pp_screen); ivi_layout_interface->get_screens(&screen_length, &pp_screen);
iviscrn = pp_screen[0]; iviscrn = pp_screen[0];
free(pp_screen); free(pp_screen);
create_layer(iviscrn, &hmi_ctrl->workspace_layer); create_layer(iviscrn, &hmi_ctrl->workspace_layer);
ivi_controller_interface->layer_set_opacity(hmi_ctrl->workspace_layer.ivilayer, 0); ivi_layout_interface->layer_set_opacity(hmi_ctrl->workspace_layer.ivilayer, 0);
ivi_controller_interface->layer_set_visibility(hmi_ctrl->workspace_layer.ivilayer, ivi_layout_interface->layer_set_visibility(hmi_ctrl->workspace_layer.ivilayer,
false); false);
tmp_link_layer = MEM_ALLOC(sizeof(*tmp_link_layer)); tmp_link_layer = MEM_ALLOC(sizeof(*tmp_link_layer));
@ -1115,19 +1115,19 @@ ivi_hmi_controller_add_launchers(struct hmi_controller *hmi_ctrl,
/* Add surface to layer */ /* Add surface to layer */
wl_array_for_each(data, &launchers) { wl_array_for_each(data, &launchers) {
layout_surface = layout_surface =
ivi_controller_interface->get_surface_from_id(data->surface_id); ivi_layout_interface->get_surface_from_id(data->surface_id);
assert(layout_surface); assert(layout_surface);
ret = ivi_controller_interface->layer_add_surface(hmi_ctrl->workspace_layer.ivilayer, ret = ivi_layout_interface->layer_add_surface(hmi_ctrl->workspace_layer.ivilayer,
layout_surface); layout_surface);
assert(!ret); assert(!ret);
ret = ivi_controller_interface->surface_set_visibility(layout_surface, true); ret = ivi_layout_interface->surface_set_visibility(layout_surface, true);
assert(!ret); assert(!ret);
} }
wl_array_release(&launchers); wl_array_release(&launchers);
ivi_controller_interface->commit_changes(); ivi_layout_interface->commit_changes();
} }
static void static void
@ -1144,7 +1144,7 @@ ivi_hmi_controller_UI_ready(struct wl_client *client,
ivi_hmi_controller_set_button(hmi_ctrl, hmi_ctrl->ui_setting.random_id, 3); 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_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_hmi_controller_set_workspacebackground(hmi_ctrl, hmi_ctrl->ui_setting.workspace_background_id);
ivi_controller_interface->commit_changes(); ivi_layout_interface->commit_changes();
ivi_hmi_controller_add_launchers(hmi_ctrl, 256); ivi_hmi_controller_add_launchers(hmi_ctrl, 256);
hmi_ctrl->is_initialized = 1; hmi_ctrl->is_initialized = 1;
@ -1262,7 +1262,7 @@ move_workspace_grab_end(struct move_grab *move, struct wl_resource* resource,
if (200 < from_motion_time) if (200 < from_motion_time)
pointer_v = 0.0; pointer_v = 0.0;
ivi_controller_interface->layer_get_position(layer, &pos_x, &pos_y); ivi_layout_interface->layer_get_position(layer, &pos_x, &pos_y);
if (is_flick) { if (is_flick) {
@ -1282,14 +1282,14 @@ move_workspace_grab_end(struct move_grab *move, struct wl_resource* resource,
duration = hmi_ctrl->hmi_setting->transition_duration; duration = hmi_ctrl->hmi_setting->transition_duration;
ivi_hmi_controller_send_workspace_end_control(resource, move->is_moved); ivi_hmi_controller_send_workspace_end_control(resource, move->is_moved);
ivi_controller_interface->layer_set_transition(layer, ivi_layout_interface->layer_set_transition(layer,
IVI_LAYOUT_TRANSITION_LAYER_MOVE, IVI_LAYOUT_TRANSITION_LAYER_MOVE,
duration); duration);
ivi_controller_interface->layer_set_destination_rectangle(layer, ivi_layout_interface->layer_set_destination_rectangle(layer,
end_pos, pos_y, end_pos, pos_y,
hmi_ctrl->workspace_layer.width, hmi_ctrl->workspace_layer.width,
hmi_ctrl->workspace_layer.height); hmi_ctrl->workspace_layer.height);
ivi_controller_interface->commit_changes(); ivi_layout_interface->commit_changes();
} }
static void static void
@ -1367,8 +1367,8 @@ layer_set_pos(struct ivi_layout_layer *layer, wl_fixed_t pos_x,
layout_pos_x = wl_fixed_to_int(pos_x); layout_pos_x = wl_fixed_to_int(pos_x);
layout_pos_y = wl_fixed_to_int(pos_y); layout_pos_y = wl_fixed_to_int(pos_y);
ivi_controller_interface->layer_set_position(layer, layout_pos_x, layout_pos_y); ivi_layout_interface->layer_set_position(layer, layout_pos_x, layout_pos_y);
ivi_controller_interface->commit_changes(); ivi_layout_interface->commit_changes();
} }
static void static void
@ -1534,7 +1534,7 @@ move_grab_init_workspace(struct move_grab* move,
wl_fixed_t rgn[2][2] = {{0}}; wl_fixed_t rgn[2][2] = {{0}};
wl_fixed_t grab_pos[2] = { grab_x, grab_y }; wl_fixed_t grab_pos[2] = { grab_x, grab_y };
ivi_controller_interface->layer_get_position(layer, &layer_pos_x, &layer_pos_y); ivi_layout_interface->layer_get_position(layer, &layer_pos_x, &layer_pos_y);
start_pos[0] = wl_fixed_from_int(layer_pos_x); start_pos[0] = wl_fixed_from_int(layer_pos_x);
start_pos[1] = wl_fixed_from_int(layer_pos_y); start_pos[1] = wl_fixed_from_int(layer_pos_y);
@ -1605,7 +1605,7 @@ ivi_hmi_controller_workspace_control(struct wl_client *client,
layer = hmi_ctrl->workspace_layer.ivilayer; layer = hmi_ctrl->workspace_layer.ivilayer;
ivi_controller_interface->transition_move_layer_cancel(layer); ivi_layout_interface->transition_move_layer_cancel(layer);
switch (device) { switch (device) {
case HMI_GRAB_DEVICE_POINTER: case HMI_GRAB_DEVICE_POINTER:
@ -1667,7 +1667,7 @@ ivi_hmi_controller_home(struct wl_client *client,
&hmi_ctrl->workspace_fade); &hmi_ctrl->workspace_fade);
} }
ivi_controller_interface->commit_changes(); ivi_layout_interface->commit_changes();
} }
/** /**
@ -1773,18 +1773,18 @@ launch_hmi_client_process(void *data)
WL_EXPORT int WL_EXPORT int
controller_module_init(struct weston_compositor *ec, controller_module_init(struct weston_compositor *ec,
int *argc, char *argv[], int *argc, char *argv[],
const struct ivi_controller_interface *interface, const struct ivi_layout_interface *interface,
size_t interface_version) size_t interface_version)
{ {
struct hmi_controller *hmi_ctrl = NULL; struct hmi_controller *hmi_ctrl = NULL;
struct wl_event_loop *loop = NULL; struct wl_event_loop *loop = NULL;
if (interface_version < sizeof(struct ivi_controller_interface)) { if (interface_version < sizeof(struct ivi_layout_interface)) {
weston_log("ivi-shell: version mismatch of controller interface\n"); weston_log("ivi-shell: version mismatch of controller interface\n");
return -1; return -1;
} }
ivi_controller_interface = interface; ivi_layout_interface = interface;
hmi_ctrl = hmi_controller_create(ec); hmi_ctrl = hmi_controller_create(ec);

2
ivi-shell/ivi-layout-export.h
Unescape View File

@ -173,7 +173,7 @@ typedef void (*ivi_controller_surface_content_callback)(
int32_t content, int32_t content,
void *userdata); void *userdata);
struct ivi_controller_interface { struct ivi_layout_interface {
/** /**
* \brief Commit all changes and execute all enqueued commands since * \brief Commit all changes and execute all enqueued commands since

8
ivi-shell/ivi-layout.c
Unescape View File

@ -2682,7 +2682,7 @@ ivi_layout_surface_add_configured_listener(struct ivi_layout_surface* ivisurf,
wl_signal_add(&ivisurf->configured, listener); wl_signal_add(&ivisurf->configured, listener);
} }
static struct ivi_controller_interface ivi_controller_interface = { static struct ivi_layout_interface ivi_layout_interface = {
/** /**
* commit all changes * commit all changes
*/ */
@ -2798,7 +2798,7 @@ load_controller_modules(struct weston_compositor *compositor, const char *module
char buffer[256]; char buffer[256];
int (*controller_module_init)(struct weston_compositor *compositor, int (*controller_module_init)(struct weston_compositor *compositor,
int *argc, char *argv[], int *argc, char *argv[],
const struct ivi_controller_interface *interface, const struct ivi_layout_interface *interface,
size_t interface_version); size_t interface_version);
if (modules == NULL) if (modules == NULL)
@ -2814,8 +2814,8 @@ load_controller_modules(struct weston_compositor *compositor, const char *module
return -1; return -1;
if (controller_module_init(compositor, argc, argv, if (controller_module_init(compositor, argc, argv,
&ivi_controller_interface, &ivi_layout_interface,
sizeof(struct ivi_controller_interface)) != 0) { sizeof(struct ivi_layout_interface)) != 0) {
weston_log("ivi-shell: Initialization of controller module fails"); weston_log("ivi-shell: Initialization of controller module fails");
return -1; return -1;
} }

562
tests/ivi_layout-internal-test.c
View File

File diff suppressed because it is too large Load Diff

364
tests/ivi_layout-test-plugin.c
Unescape View File

@ -76,11 +76,11 @@ struct test_launcher {
struct weston_compositor *compositor; struct weston_compositor *compositor;
char exe[2048]; char exe[2048];
struct weston_process process; struct weston_process process;
const struct ivi_controller_interface *controller_interface; const struct ivi_layout_interface *layout_interface;
}; };
struct test_context { struct test_context {
const struct ivi_controller_interface *controller_interface; const struct ivi_layout_interface *layout_interface;
struct wl_resource *runner_resource; struct wl_resource *runner_resource;
uint32_t user_flags; uint32_t user_flags;
}; };
@ -93,7 +93,7 @@ destroy_runner(struct wl_resource *resource)
assert(static_context.runner_resource == NULL || assert(static_context.runner_resource == NULL ||
static_context.runner_resource == resource); static_context.runner_resource == resource);
static_context.controller_interface = NULL; static_context.layout_interface = NULL;
static_context.runner_resource = NULL; static_context.runner_resource = NULL;
} }
@ -114,7 +114,7 @@ runner_run_handler(struct wl_client *client, struct wl_resource *resource,
static_context.runner_resource == resource); static_context.runner_resource == resource);
launcher = wl_resource_get_user_data(resource); launcher = wl_resource_get_user_data(resource);
static_context.controller_interface = launcher->controller_interface; static_context.layout_interface = launcher->layout_interface;
static_context.runner_resource = resource; static_context.runner_resource = resource;
t = find_runner_test(test_name); t = find_runner_test(test_name);
@ -213,13 +213,13 @@ idle_launch_client(void *data)
int int
controller_module_init(struct weston_compositor *compositor, controller_module_init(struct weston_compositor *compositor,
int *argc, char *argv[], int *argc, char *argv[],
const struct ivi_controller_interface *iface, const struct ivi_layout_interface *iface,
size_t iface_version); size_t iface_version);
WL_EXPORT int WL_EXPORT int
controller_module_init(struct weston_compositor *compositor, controller_module_init(struct weston_compositor *compositor,
int *argc, char *argv[], int *argc, char *argv[],
const struct ivi_controller_interface *iface, const struct ivi_layout_interface *iface,
size_t iface_version) size_t iface_version)
{ {
struct wl_event_loop *loop; struct wl_event_loop *loop;
@ -243,7 +243,7 @@ controller_module_init(struct weston_compositor *compositor,
return -1; return -1;
launcher->compositor = compositor; launcher->compositor = compositor;
launcher->controller_interface = iface; launcher->layout_interface = iface;
snprintf(launcher->exe, sizeof launcher->exe, snprintf(launcher->exe, sizeof launcher->exe,
"%s/ivi-layout.ivi", path); "%s/ivi-layout.ivi", path);
@ -324,145 +324,145 @@ runner_assert_fail(const char *cond, const char *file, int line,
RUNNER_TEST(surface_create_p1) RUNNER_TEST(surface_create_p1)
{ {
const struct ivi_controller_interface *ctl = ctx->controller_interface; const struct ivi_layout_interface *lyt = ctx->layout_interface;
struct ivi_layout_surface *ivisurf[2]; struct ivi_layout_surface *ivisurf[2];
uint32_t ivi_id; uint32_t ivi_id;
ivisurf[0] = ctl->get_surface_from_id(IVI_TEST_SURFACE_ID(0)); ivisurf[0] = lyt->get_surface_from_id(IVI_TEST_SURFACE_ID(0));
runner_assert(ivisurf[0]); runner_assert(ivisurf[0]);
ivisurf[1] = ctl->get_surface_from_id(IVI_TEST_SURFACE_ID(1)); ivisurf[1] = lyt->get_surface_from_id(IVI_TEST_SURFACE_ID(1));
runner_assert(ivisurf[1]); runner_assert(ivisurf[1]);
ivi_id = ctl->get_id_of_surface(ivisurf[0]); ivi_id = lyt->get_id_of_surface(ivisurf[0]);
runner_assert(ivi_id == IVI_TEST_SURFACE_ID(0)); runner_assert(ivi_id == IVI_TEST_SURFACE_ID(0));
ivi_id = ctl->get_id_of_surface(ivisurf[1]); ivi_id = lyt->get_id_of_surface(ivisurf[1]);
runner_assert(ivi_id == IVI_TEST_SURFACE_ID(1)); runner_assert(ivi_id == IVI_TEST_SURFACE_ID(1));
} }
RUNNER_TEST(surface_create_p2) RUNNER_TEST(surface_create_p2)
{ {
const struct ivi_controller_interface *ctl = ctx->controller_interface; const struct ivi_layout_interface *lyt = ctx->layout_interface;
struct ivi_layout_surface *ivisurf; struct ivi_layout_surface *ivisurf;
/* the ivi_surface was destroyed by the client */ /* the ivi_surface was destroyed by the client */
ivisurf = ctl->get_surface_from_id(IVI_TEST_SURFACE_ID(0)); ivisurf = lyt->get_surface_from_id(IVI_TEST_SURFACE_ID(0));
runner_assert(ivisurf == NULL); runner_assert(ivisurf == NULL);
} }
RUNNER_TEST(surface_visibility) RUNNER_TEST(surface_visibility)
{ {
const struct ivi_controller_interface *ctl = ctx->controller_interface; const struct ivi_layout_interface *lyt = ctx->layout_interface;
struct ivi_layout_surface *ivisurf; struct ivi_layout_surface *ivisurf;
int32_t ret; int32_t ret;
bool visibility; bool visibility;
const struct ivi_layout_surface_properties *prop; const struct ivi_layout_surface_properties *prop;
ivisurf = ctl->get_surface_from_id(IVI_TEST_SURFACE_ID(0)); ivisurf = lyt->get_surface_from_id(IVI_TEST_SURFACE_ID(0));
runner_assert(ivisurf); runner_assert(ivisurf);
ret = ctl->surface_set_visibility(ivisurf, true); ret = lyt->surface_set_visibility(ivisurf, true);
runner_assert(ret == IVI_SUCCEEDED); runner_assert(ret == IVI_SUCCEEDED);
ctl->commit_changes(); lyt->commit_changes();
visibility = ctl->surface_get_visibility(ivisurf); visibility = lyt->surface_get_visibility(ivisurf);
runner_assert(visibility == true); runner_assert(visibility == true);
prop = ctl->get_properties_of_surface(ivisurf); prop = lyt->get_properties_of_surface(ivisurf);
runner_assert(prop->visibility == true); runner_assert(prop->visibility == true);
} }
RUNNER_TEST(surface_opacity) RUNNER_TEST(surface_opacity)
{ {
const struct ivi_controller_interface *ctl = ctx->controller_interface; const struct ivi_layout_interface *lyt = ctx->layout_interface;
struct ivi_layout_surface *ivisurf; struct ivi_layout_surface *ivisurf;
int32_t ret; int32_t ret;
wl_fixed_t opacity; wl_fixed_t opacity;
const struct ivi_layout_surface_properties *prop; const struct ivi_layout_surface_properties *prop;
ivisurf = ctl->get_surface_from_id(IVI_TEST_SURFACE_ID(0)); ivisurf = lyt->get_surface_from_id(IVI_TEST_SURFACE_ID(0));
runner_assert(ivisurf); runner_assert(ivisurf);
runner_assert(ctl->surface_get_opacity(ivisurf) == runner_assert(lyt->surface_get_opacity(ivisurf) ==
wl_fixed_from_double(1.0)); wl_fixed_from_double(1.0));
ret = ctl->surface_set_opacity(ivisurf, wl_fixed_from_double(0.5)); ret = lyt->surface_set_opacity(ivisurf, wl_fixed_from_double(0.5));
runner_assert(ret == IVI_SUCCEEDED); runner_assert(ret == IVI_SUCCEEDED);
runner_assert(ctl->surface_get_opacity(ivisurf) == runner_assert(lyt->surface_get_opacity(ivisurf) ==
wl_fixed_from_double(1.0)); wl_fixed_from_double(1.0));
ctl->commit_changes(); lyt->commit_changes();
opacity = ctl->surface_get_opacity(ivisurf); opacity = lyt->surface_get_opacity(ivisurf);
runner_assert(opacity == wl_fixed_from_double(0.5)); runner_assert(opacity == wl_fixed_from_double(0.5));
prop = ctl->get_properties_of_surface(ivisurf); prop = lyt->get_properties_of_surface(ivisurf);
runner_assert(prop->opacity == wl_fixed_from_double(0.5)); runner_assert(prop->opacity == wl_fixed_from_double(0.5));
} }
RUNNER_TEST(surface_orientation) RUNNER_TEST(surface_orientation)
{ {
const struct ivi_controller_interface *ctl = ctx->controller_interface; const struct ivi_layout_interface *lyt = ctx->layout_interface;
struct ivi_layout_surface *ivisurf; struct ivi_layout_surface *ivisurf;
const struct ivi_layout_surface_properties *prop; const struct ivi_layout_surface_properties *prop;
ivisurf = ctl->get_surface_from_id(IVI_TEST_SURFACE_ID(0)); ivisurf = lyt->get_surface_from_id(IVI_TEST_SURFACE_ID(0));
runner_assert(ivisurf != NULL); runner_assert(ivisurf != NULL);
runner_assert(ctl->surface_get_orientation(ivisurf) == runner_assert(lyt->surface_get_orientation(ivisurf) ==
WL_OUTPUT_TRANSFORM_NORMAL); WL_OUTPUT_TRANSFORM_NORMAL);
runner_assert(ctl->surface_set_orientation( runner_assert(lyt->surface_set_orientation(
ivisurf, WL_OUTPUT_TRANSFORM_90) == IVI_SUCCEEDED); ivisurf, WL_OUTPUT_TRANSFORM_90) == IVI_SUCCEEDED);
runner_assert(ctl->surface_get_orientation(ivisurf) == runner_assert(lyt->surface_get_orientation(ivisurf) ==
WL_OUTPUT_TRANSFORM_NORMAL); WL_OUTPUT_TRANSFORM_NORMAL);
ctl->commit_changes(); lyt->commit_changes();
runner_assert(ctl->surface_get_orientation( runner_assert(lyt->surface_get_orientation(
ivisurf) == WL_OUTPUT_TRANSFORM_90); ivisurf) == WL_OUTPUT_TRANSFORM_90);
prop = ctl->get_properties_of_surface(ivisurf); prop = lyt->get_properties_of_surface(ivisurf);
runner_assert_or_return(prop); runner_assert_or_return(prop);
runner_assert(prop->orientation == WL_OUTPUT_TRANSFORM_90); runner_assert(prop->orientation == WL_OUTPUT_TRANSFORM_90);
} }
RUNNER_TEST(surface_dimension) RUNNER_TEST(surface_dimension)
{ {
const struct ivi_controller_interface *ctl = ctx->controller_interface; const struct ivi_layout_interface *lyt = ctx->layout_interface;
struct ivi_layout_surface *ivisurf; struct ivi_layout_surface *ivisurf;
const struct ivi_layout_surface_properties *prop; const struct ivi_layout_surface_properties *prop;
int32_t dest_width; int32_t dest_width;
int32_t dest_height; int32_t dest_height;
ivisurf = ctl->get_surface_from_id(IVI_TEST_SURFACE_ID(0)); ivisurf = lyt->get_surface_from_id(IVI_TEST_SURFACE_ID(0));
runner_assert(ivisurf != NULL); runner_assert(ivisurf != NULL);
runner_assert(ctl->surface_get_dimension( runner_assert(lyt->surface_get_dimension(
ivisurf, &dest_width, &dest_height) == IVI_SUCCEEDED); ivisurf, &dest_width, &dest_height) == IVI_SUCCEEDED);
runner_assert(dest_width == 1); runner_assert(dest_width == 1);
runner_assert(dest_height == 1); runner_assert(dest_height == 1);
runner_assert(IVI_SUCCEEDED == runner_assert(IVI_SUCCEEDED ==
ctl->surface_set_dimension(ivisurf, 200, 300)); lyt->surface_set_dimension(ivisurf, 200, 300));
runner_assert(ctl->surface_get_dimension( runner_assert(lyt->surface_get_dimension(
ivisurf, &dest_width, &dest_height) == IVI_SUCCEEDED); ivisurf, &dest_width, &dest_height) == IVI_SUCCEEDED);
runner_assert(dest_width == 1); runner_assert(dest_width == 1);
runner_assert(dest_height == 1); runner_assert(dest_height == 1);
ctl->commit_changes(); lyt->commit_changes();
runner_assert(ctl->surface_get_dimension( runner_assert(lyt->surface_get_dimension(
ivisurf, &dest_width, &dest_height) == IVI_SUCCEEDED); ivisurf, &dest_width, &dest_height) == IVI_SUCCEEDED);
runner_assert(dest_width == 200); runner_assert(dest_width == 200);
runner_assert(dest_height == 300); runner_assert(dest_height == 300);
prop = ctl->get_properties_of_surface(ivisurf); prop = lyt->get_properties_of_surface(ivisurf);
runner_assert_or_return(prop); runner_assert_or_return(prop);
runner_assert(prop->dest_width == 200); runner_assert(prop->dest_width == 200);
runner_assert(prop->dest_height == 300); runner_assert(prop->dest_height == 300);
@ -470,36 +470,36 @@ RUNNER_TEST(surface_dimension)
RUNNER_TEST(surface_position) RUNNER_TEST(surface_position)
{ {
const struct ivi_controller_interface *ctl = ctx->controller_interface; const struct ivi_layout_interface *lyt = ctx->layout_interface;
struct ivi_layout_surface *ivisurf; struct ivi_layout_surface *ivisurf;
const struct ivi_layout_surface_properties *prop; const struct ivi_layout_surface_properties *prop;
int32_t dest_x; int32_t dest_x;
int32_t dest_y; int32_t dest_y;
ivisurf = ctl->get_surface_from_id(IVI_TEST_SURFACE_ID(0)); ivisurf = lyt->get_surface_from_id(IVI_TEST_SURFACE_ID(0));
runner_assert(ivisurf != NULL); runner_assert(ivisurf != NULL);
runner_assert(ctl->surface_get_position( runner_assert(lyt->surface_get_position(
ivisurf, &dest_x, &dest_y) == IVI_SUCCEEDED); ivisurf, &dest_x, &dest_y) == IVI_SUCCEEDED);
runner_assert(dest_x == 0); runner_assert(dest_x == 0);
runner_assert(dest_y == 0); runner_assert(dest_y == 0);
runner_assert(ctl->surface_set_position( runner_assert(lyt->surface_set_position(
ivisurf, 20, 30) == IVI_SUCCEEDED); ivisurf, 20, 30) == IVI_SUCCEEDED);
runner_assert(ctl->surface_get_position( runner_assert(lyt->surface_get_position(
ivisurf, &dest_x, &dest_y) == IVI_SUCCEEDED); ivisurf, &dest_x, &dest_y) == IVI_SUCCEEDED);
runner_assert(dest_x == 0); runner_assert(dest_x == 0);
runner_assert(dest_y == 0); runner_assert(dest_y == 0);
ctl->commit_changes(); lyt->commit_changes();
runner_assert(ctl->surface_get_position( runner_assert(lyt->surface_get_position(
ivisurf, &dest_x, &dest_y) == IVI_SUCCEEDED); ivisurf, &dest_x, &dest_y) == IVI_SUCCEEDED);
runner_assert(dest_x == 20); runner_assert(dest_x == 20);
runner_assert(dest_y == 30); runner_assert(dest_y == 30);
prop = ctl->get_properties_of_surface(ivisurf); prop = lyt->get_properties_of_surface(ivisurf);
runner_assert_or_return(prop); runner_assert_or_return(prop);
runner_assert(prop->dest_x == 20); runner_assert(prop->dest_x == 20);
runner_assert(prop->dest_y == 30); runner_assert(prop->dest_y == 30);
@ -507,7 +507,7 @@ RUNNER_TEST(surface_position)
RUNNER_TEST(surface_destination_rectangle) RUNNER_TEST(surface_destination_rectangle)
{ {
const struct ivi_controller_interface *ctl = ctx->controller_interface; const struct ivi_layout_interface *lyt = ctx->layout_interface;
struct ivi_layout_surface *ivisurf; struct ivi_layout_surface *ivisurf;
const struct ivi_layout_surface_properties *prop; const struct ivi_layout_surface_properties *prop;
int32_t dest_width; int32_t dest_width;
@ -515,38 +515,38 @@ RUNNER_TEST(surface_destination_rectangle)
int32_t dest_x; int32_t dest_x;
int32_t dest_y; int32_t dest_y;
ivisurf = ctl->get_surface_from_id(IVI_TEST_SURFACE_ID(0)); ivisurf = lyt->get_surface_from_id(IVI_TEST_SURFACE_ID(0));
runner_assert(ivisurf != NULL); runner_assert(ivisurf != NULL);
prop = ctl->get_properties_of_surface(ivisurf); prop = lyt->get_properties_of_surface(ivisurf);
runner_assert_or_return(prop); runner_assert_or_return(prop);
runner_assert(prop->dest_width == 1); runner_assert(prop->dest_width == 1);
runner_assert(prop->dest_height == 1); runner_assert(prop->dest_height == 1);
runner_assert(prop->dest_x == 0); runner_assert(prop->dest_x == 0);
runner_assert(prop->dest_y == 0); runner_assert(prop->dest_y == 0);
runner_assert(ctl->surface_set_destination_rectangle( runner_assert(lyt->surface_set_destination_rectangle(
ivisurf, 20, 30, 200, 300) == IVI_SUCCEEDED); ivisurf, 20, 30, 200, 300) == IVI_SUCCEEDED);
prop = ctl->get_properties_of_surface(ivisurf); prop = lyt->get_properties_of_surface(ivisurf);
runner_assert_or_return(prop); runner_assert_or_return(prop);
runner_assert(prop->dest_width == 1); runner_assert(prop->dest_width == 1);
runner_assert(prop->dest_height == 1); runner_assert(prop->dest_height == 1);
runner_assert(prop->dest_x == 0); runner_assert(prop->dest_x == 0);
runner_assert(prop->dest_y == 0); runner_assert(prop->dest_y == 0);
ctl->commit_changes(); lyt->commit_changes();
runner_assert(ctl->surface_get_dimension( runner_assert(lyt->surface_get_dimension(
ivisurf, &dest_width, &dest_height) == IVI_SUCCEEDED); ivisurf, &dest_width, &dest_height) == IVI_SUCCEEDED);
runner_assert(dest_width == 200); runner_assert(dest_width == 200);
runner_assert(dest_height == 300); runner_assert(dest_height == 300);
runner_assert(ctl->surface_get_position(ivisurf, &dest_x, &dest_y) == IVI_SUCCEEDED); runner_assert(lyt->surface_get_position(ivisurf, &dest_x, &dest_y) == IVI_SUCCEEDED);
runner_assert(dest_x == 20); runner_assert(dest_x == 20);
runner_assert(dest_y == 30); runner_assert(dest_y == 30);
prop = ctl->get_properties_of_surface(ivisurf); prop = lyt->get_properties_of_surface(ivisurf);
runner_assert_or_return(prop); runner_assert_or_return(prop);
runner_assert(prop->dest_width == 200); runner_assert(prop->dest_width == 200);
runner_assert(prop->dest_height == 300); runner_assert(prop->dest_height == 300);
@ -556,33 +556,33 @@ RUNNER_TEST(surface_destination_rectangle)
RUNNER_TEST(surface_source_rectangle) RUNNER_TEST(surface_source_rectangle)
{ {
const struct ivi_controller_interface *ctl = ctx->controller_interface; const struct ivi_layout_interface *lyt = ctx->layout_interface;
struct ivi_layout_surface *ivisurf; struct ivi_layout_surface *ivisurf;
const struct ivi_layout_surface_properties *prop; const struct ivi_layout_surface_properties *prop;
ivisurf = ctl->get_surface_from_id(IVI_TEST_SURFACE_ID(0)); ivisurf = lyt->get_surface_from_id(IVI_TEST_SURFACE_ID(0));
runner_assert(ivisurf != NULL); runner_assert(ivisurf != NULL);
prop = ctl->get_properties_of_surface(ivisurf); prop = lyt->get_properties_of_surface(ivisurf);
runner_assert_or_return(prop); runner_assert_or_return(prop);
runner_assert(prop->source_width == 0); runner_assert(prop->source_width == 0);
runner_assert(prop->source_height == 0); runner_assert(prop->source_height == 0);
runner_assert(prop->source_x == 0); runner_assert(prop->source_x == 0);
runner_assert(prop->source_y == 0); runner_assert(prop->source_y == 0);
runner_assert(ctl->surface_set_source_rectangle( runner_assert(lyt->surface_set_source_rectangle(
ivisurf, 20, 30, 200, 300) == IVI_SUCCEEDED); ivisurf, 20, 30, 200, 300) == IVI_SUCCEEDED);
prop = ctl->get_properties_of_surface(ivisurf); prop = lyt->get_properties_of_surface(ivisurf);
runner_assert_or_return(prop); runner_assert_or_return(prop);
runner_assert(prop->source_width == 0); runner_assert(prop->source_width == 0);
runner_assert(prop->source_height == 0); runner_assert(prop->source_height == 0);
runner_assert(prop->source_x == 0); runner_assert(prop->source_x == 0);
runner_assert(prop->source_y == 0); runner_assert(prop->source_y == 0);
ctl->commit_changes(); lyt->commit_changes();
prop = ctl->get_properties_of_surface(ivisurf); prop = lyt->get_properties_of_surface(ivisurf);
runner_assert_or_return(prop); runner_assert_or_return(prop);
runner_assert(prop->source_width == 200); runner_assert(prop->source_width == 200);
runner_assert(prop->source_height == 300); runner_assert(prop->source_height == 300);
@ -592,157 +592,157 @@ RUNNER_TEST(surface_source_rectangle)
RUNNER_TEST(surface_bad_opacity) RUNNER_TEST(surface_bad_opacity)
{ {
const struct ivi_controller_interface *ctl = ctx->controller_interface; const struct ivi_layout_interface *lyt = ctx->layout_interface;
struct ivi_layout_surface *ivisurf; struct ivi_layout_surface *ivisurf;
wl_fixed_t opacity; wl_fixed_t opacity;
ivisurf = ctl->get_surface_from_id(IVI_TEST_SURFACE_ID(0)); ivisurf = lyt->get_surface_from_id(IVI_TEST_SURFACE_ID(0));
runner_assert(ivisurf != NULL); runner_assert(ivisurf != NULL);
runner_assert(ctl->surface_set_opacity( runner_assert(lyt->surface_set_opacity(
NULL, wl_fixed_from_double(0.3)) == IVI_FAILED); NULL, wl_fixed_from_double(0.3)) == IVI_FAILED);
runner_assert(ctl->surface_set_opacity( runner_assert(lyt->surface_set_opacity(
ivisurf, wl_fixed_from_double(0.3)) == IVI_SUCCEEDED); ivisurf, wl_fixed_from_double(0.3)) == IVI_SUCCEEDED);
runner_assert(ctl->surface_set_opacity( runner_assert(lyt->surface_set_opacity(
ivisurf, wl_fixed_from_double(-1)) == IVI_FAILED); ivisurf, wl_fixed_from_double(-1)) == IVI_FAILED);
ctl->commit_changes(); lyt->commit_changes();
opacity = ctl->surface_get_opacity(ivisurf); opacity = lyt->surface_get_opacity(ivisurf);
runner_assert(opacity == wl_fixed_from_double(0.3)); runner_assert(opacity == wl_fixed_from_double(0.3));
runner_assert(ctl->surface_set_opacity( runner_assert(lyt->surface_set_opacity(
ivisurf, wl_fixed_from_double(1.1)) == IVI_FAILED); ivisurf, wl_fixed_from_double(1.1)) == IVI_FAILED);
ctl->commit_changes(); lyt->commit_changes();
opacity = ctl->surface_get_opacity(ivisurf); opacity = lyt->surface_get_opacity(ivisurf);
runner_assert(opacity == wl_fixed_from_double(0.3)); runner_assert(opacity == wl_fixed_from_double(0.3));
runner_assert(ctl->surface_set_opacity( runner_assert(lyt->surface_set_opacity(
NULL, wl_fixed_from_double(0.5)) == IVI_FAILED); NULL, wl_fixed_from_double(0.5)) == IVI_FAILED);
ctl->commit_changes(); lyt->commit_changes();
opacity = ctl->surface_get_opacity(NULL); opacity = lyt->surface_get_opacity(NULL);
runner_assert(opacity == wl_fixed_from_double(0.0)); runner_assert(opacity == wl_fixed_from_double(0.0));
} }
RUNNER_TEST(ivi_layout_commit_changes) RUNNER_TEST(ivi_layout_commit_changes)
{ {
const struct ivi_controller_interface *ctl = ctx->controller_interface; const struct ivi_layout_interface *lyt = ctx->layout_interface;
ctl->commit_changes(); lyt->commit_changes();
} }
RUNNER_TEST(commit_changes_after_visibility_set_surface_destroy) RUNNER_TEST(commit_changes_after_visibility_set_surface_destroy)
{ {
const struct ivi_controller_interface *ctl = ctx->controller_interface; const struct ivi_layout_interface *lyt = ctx->layout_interface;
struct ivi_layout_surface *ivisurf; struct ivi_layout_surface *ivisurf;
ivisurf = ctl->get_surface_from_id(IVI_TEST_SURFACE_ID(0)); ivisurf = lyt->get_surface_from_id(IVI_TEST_SURFACE_ID(0));
runner_assert(ivisurf != NULL); runner_assert(ivisurf != NULL);
runner_assert(ctl->surface_set_visibility( runner_assert(lyt->surface_set_visibility(
ivisurf, true) == IVI_SUCCEEDED); ivisurf, true) == IVI_SUCCEEDED);
} }
RUNNER_TEST(commit_changes_after_opacity_set_surface_destroy) RUNNER_TEST(commit_changes_after_opacity_set_surface_destroy)
{ {
const struct ivi_controller_interface *ctl = ctx->controller_interface; const struct ivi_layout_interface *lyt = ctx->layout_interface;
struct ivi_layout_surface *ivisurf; struct ivi_layout_surface *ivisurf;
ivisurf = ctl->get_surface_from_id(IVI_TEST_SURFACE_ID(0)); ivisurf = lyt->get_surface_from_id(IVI_TEST_SURFACE_ID(0));
runner_assert(ivisurf != NULL); runner_assert(ivisurf != NULL);
runner_assert(ctl->surface_set_opacity( runner_assert(lyt->surface_set_opacity(
ivisurf, wl_fixed_from_double(0.5)) == IVI_SUCCEEDED); ivisurf, wl_fixed_from_double(0.5)) == IVI_SUCCEEDED);
} }
RUNNER_TEST(commit_changes_after_orientation_set_surface_destroy) RUNNER_TEST(commit_changes_after_orientation_set_surface_destroy)
{ {
const struct ivi_controller_interface *ctl = ctx->controller_interface; const struct ivi_layout_interface *lyt = ctx->layout_interface;
struct ivi_layout_surface *ivisurf; struct ivi_layout_surface *ivisurf;
ivisurf = ctl->get_surface_from_id(IVI_TEST_SURFACE_ID(0)); ivisurf = lyt->get_surface_from_id(IVI_TEST_SURFACE_ID(0));
runner_assert(ivisurf != NULL); runner_assert(ivisurf != NULL);
runner_assert(ctl->surface_set_orientation( runner_assert(lyt->surface_set_orientation(
ivisurf, WL_OUTPUT_TRANSFORM_90) == IVI_SUCCEEDED); ivisurf, WL_OUTPUT_TRANSFORM_90) == IVI_SUCCEEDED);
} }
RUNNER_TEST(commit_changes_after_dimension_set_surface_destroy) RUNNER_TEST(commit_changes_after_dimension_set_surface_destroy)
{ {
const struct ivi_controller_interface *ctl = ctx->controller_interface; const struct ivi_layout_interface *lyt = ctx->layout_interface;
struct ivi_layout_surface *ivisurf; struct ivi_layout_surface *ivisurf;
ivisurf = ctl->get_surface_from_id(IVI_TEST_SURFACE_ID(0)); ivisurf = lyt->get_surface_from_id(IVI_TEST_SURFACE_ID(0));
runner_assert(ivisurf != NULL); runner_assert(ivisurf != NULL);
runner_assert(ctl->surface_set_dimension( runner_assert(lyt->surface_set_dimension(
ivisurf, 200, 300) == IVI_SUCCEEDED); ivisurf, 200, 300) == IVI_SUCCEEDED);
} }
RUNNER_TEST(commit_changes_after_position_set_surface_destroy) RUNNER_TEST(commit_changes_after_position_set_surface_destroy)
{ {
const struct ivi_controller_interface *ctl = ctx->controller_interface; const struct ivi_layout_interface *lyt = ctx->layout_interface;
struct ivi_layout_surface *ivisurf; struct ivi_layout_surface *ivisurf;
ivisurf = ctl->get_surface_from_id(IVI_TEST_SURFACE_ID(0)); ivisurf = lyt->get_surface_from_id(IVI_TEST_SURFACE_ID(0));
runner_assert(ivisurf != NULL); runner_assert(ivisurf != NULL);
runner_assert(ctl->surface_set_position( runner_assert(lyt->surface_set_position(
ivisurf, 20, 30) == IVI_SUCCEEDED); ivisurf, 20, 30) == IVI_SUCCEEDED);
} }
RUNNER_TEST(commit_changes_after_source_rectangle_set_surface_destroy) RUNNER_TEST(commit_changes_after_source_rectangle_set_surface_destroy)
{ {
const struct ivi_controller_interface *ctl = ctx->controller_interface; const struct ivi_layout_interface *lyt = ctx->layout_interface;
struct ivi_layout_surface *ivisurf; struct ivi_layout_surface *ivisurf;
ivisurf = ctl->get_surface_from_id(IVI_TEST_SURFACE_ID(0)); ivisurf = lyt->get_surface_from_id(IVI_TEST_SURFACE_ID(0));
runner_assert(ivisurf != NULL); runner_assert(ivisurf != NULL);
runner_assert(ctl->surface_set_source_rectangle( runner_assert(lyt->surface_set_source_rectangle(
ivisurf, 20, 30, 200, 300) == IVI_SUCCEEDED); ivisurf, 20, 30, 200, 300) == IVI_SUCCEEDED);
} }
RUNNER_TEST(commit_changes_after_destination_rectangle_set_surface_destroy) RUNNER_TEST(commit_changes_after_destination_rectangle_set_surface_destroy)
{ {
const struct ivi_controller_interface *ctl = ctx->controller_interface; const struct ivi_layout_interface *lyt = ctx->layout_interface;
struct ivi_layout_surface *ivisurf; struct ivi_layout_surface *ivisurf;
ivisurf = ctl->get_surface_from_id(IVI_TEST_SURFACE_ID(0)); ivisurf = lyt->get_surface_from_id(IVI_TEST_SURFACE_ID(0));
runner_assert(ivisurf != NULL); runner_assert(ivisurf != NULL);
runner_assert(ctl->surface_set_destination_rectangle( runner_assert(lyt->surface_set_destination_rectangle(
ivisurf, 20, 30, 200, 300) == IVI_SUCCEEDED); ivisurf, 20, 30, 200, 300) == IVI_SUCCEEDED);
} }
RUNNER_TEST(get_surface_after_destroy_surface) RUNNER_TEST(get_surface_after_destroy_surface)
{ {
const struct ivi_controller_interface *ctl = ctx->controller_interface; const struct ivi_layout_interface *lyt = ctx->layout_interface;
struct ivi_layout_surface *ivisurf; struct ivi_layout_surface *ivisurf;
ivisurf = ctl->get_surface_from_id(IVI_TEST_SURFACE_ID(0)); ivisurf = lyt->get_surface_from_id(IVI_TEST_SURFACE_ID(0));
runner_assert(ivisurf == NULL); runner_assert(ivisurf == NULL);
} }
RUNNER_TEST(layer_render_order) RUNNER_TEST(layer_render_order)
{ {
const struct ivi_controller_interface *ctl = ctx->controller_interface; const struct ivi_layout_interface *lyt = ctx->layout_interface;
struct ivi_layout_layer *ivilayer; struct ivi_layout_layer *ivilayer;
struct ivi_layout_surface *ivisurfs[IVI_TEST_SURFACE_COUNT] = {}; struct ivi_layout_surface *ivisurfs[IVI_TEST_SURFACE_COUNT] = {};
struct ivi_layout_surface **array; struct ivi_layout_surface **array;
int32_t length = 0; int32_t length = 0;
uint32_t i; uint32_t i;
ivilayer = ctl->layer_create_with_dimension(IVI_TEST_LAYER_ID(0), 200, 300); ivilayer = lyt->layer_create_with_dimension(IVI_TEST_LAYER_ID(0), 200, 300);
for (i = 0; i < IVI_TEST_SURFACE_COUNT; i++) for (i = 0; i < IVI_TEST_SURFACE_COUNT; i++)
ivisurfs[i] = ctl->get_surface_from_id(IVI_TEST_SURFACE_ID(i)); ivisurfs[i] = lyt->get_surface_from_id(IVI_TEST_SURFACE_ID(i));
runner_assert(ctl->layer_set_render_order( runner_assert(lyt->layer_set_render_order(
ivilayer, ivisurfs, IVI_TEST_SURFACE_COUNT) == IVI_SUCCEEDED); ivilayer, ivisurfs, IVI_TEST_SURFACE_COUNT) == IVI_SUCCEEDED);
ctl->commit_changes(); lyt->commit_changes();
runner_assert(ctl->get_surfaces_on_layer( runner_assert(lyt->get_surfaces_on_layer(
ivilayer, &length, &array) == IVI_SUCCEEDED); ivilayer, &length, &array) == IVI_SUCCEEDED);
runner_assert(IVI_TEST_SURFACE_COUNT == length); runner_assert(IVI_TEST_SURFACE_COUNT == length);
for (i = 0; i < IVI_TEST_SURFACE_COUNT; i++) for (i = 0; i < IVI_TEST_SURFACE_COUNT; i++)
@ -751,40 +751,40 @@ RUNNER_TEST(layer_render_order)
if (length > 0) if (length > 0)
free(array); free(array);
runner_assert(ctl->layer_set_render_order( runner_assert(lyt->layer_set_render_order(
ivilayer, NULL, 0) == IVI_SUCCEEDED); ivilayer, NULL, 0) == IVI_SUCCEEDED);
array = NULL; array = NULL;
ctl->commit_changes(); lyt->commit_changes();
runner_assert(ctl->get_surfaces_on_layer( runner_assert(lyt->get_surfaces_on_layer(
ivilayer, &length, &array) == IVI_SUCCEEDED); ivilayer, &length, &array) == IVI_SUCCEEDED);
runner_assert(length == 0 && array == NULL); runner_assert(length == 0 && array == NULL);
ctl->layer_destroy(ivilayer); lyt->layer_destroy(ivilayer);
} }
RUNNER_TEST(test_layer_render_order_destroy_one_surface_p1) RUNNER_TEST(test_layer_render_order_destroy_one_surface_p1)
{ {
const struct ivi_controller_interface *ctl = ctx->controller_interface; const struct ivi_layout_interface *lyt = ctx->layout_interface;
struct ivi_layout_layer *ivilayer; struct ivi_layout_layer *ivilayer;
struct ivi_layout_surface *ivisurfs[IVI_TEST_SURFACE_COUNT] = {}; struct ivi_layout_surface *ivisurfs[IVI_TEST_SURFACE_COUNT] = {};
struct ivi_layout_surface **array; struct ivi_layout_surface **array;
int32_t length = 0; int32_t length = 0;
int32_t i; int32_t i;
ivilayer = ctl->layer_create_with_dimension(IVI_TEST_LAYER_ID(0), 200, 300); ivilayer = lyt->layer_create_with_dimension(IVI_TEST_LAYER_ID(0), 200, 300);
for (i = 0; i < IVI_TEST_SURFACE_COUNT; i++) for (i = 0; i < IVI_TEST_SURFACE_COUNT; i++)
ivisurfs[i] = ctl->get_surface_from_id(IVI_TEST_SURFACE_ID(i)); ivisurfs[i] = lyt->get_surface_from_id(IVI_TEST_SURFACE_ID(i));
runner_assert(ctl->layer_set_render_order( runner_assert(lyt->layer_set_render_order(
ivilayer, ivisurfs, IVI_TEST_SURFACE_COUNT) == IVI_SUCCEEDED); ivilayer, ivisurfs, IVI_TEST_SURFACE_COUNT) == IVI_SUCCEEDED);
ctl->commit_changes(); lyt->commit_changes();
runner_assert(ctl->get_surfaces_on_layer( runner_assert(lyt->get_surfaces_on_layer(
ivilayer, &length, &array) == IVI_SUCCEEDED); ivilayer, &length, &array) == IVI_SUCCEEDED);
runner_assert(IVI_TEST_SURFACE_COUNT == length); runner_assert(IVI_TEST_SURFACE_COUNT == length);
for (i = 0; i < length; i++) for (i = 0; i < length; i++)
@ -796,18 +796,18 @@ RUNNER_TEST(test_layer_render_order_destroy_one_surface_p1)
RUNNER_TEST(test_layer_render_order_destroy_one_surface_p2) RUNNER_TEST(test_layer_render_order_destroy_one_surface_p2)
{ {
const struct ivi_controller_interface *ctl = ctx->controller_interface; const struct ivi_layout_interface *lyt = ctx->layout_interface;
struct ivi_layout_layer *ivilayer; struct ivi_layout_layer *ivilayer;
struct ivi_layout_surface *ivisurfs[2] = {}; struct ivi_layout_surface *ivisurfs[2] = {};
struct ivi_layout_surface **array; struct ivi_layout_surface **array;
int32_t length = 0; int32_t length = 0;
int32_t i; int32_t i;
ivilayer = ctl->get_layer_from_id(IVI_TEST_LAYER_ID(0)); ivilayer = lyt->get_layer_from_id(IVI_TEST_LAYER_ID(0));
ivisurfs[0] = ctl->get_surface_from_id(IVI_TEST_SURFACE_ID(0)); ivisurfs[0] = lyt->get_surface_from_id(IVI_TEST_SURFACE_ID(0));
ivisurfs[1] = ctl->get_surface_from_id(IVI_TEST_SURFACE_ID(2)); ivisurfs[1] = lyt->get_surface_from_id(IVI_TEST_SURFACE_ID(2));
runner_assert(ctl->get_surfaces_on_layer( runner_assert(lyt->get_surfaces_on_layer(
ivilayer, &length, &array) == IVI_SUCCEEDED); ivilayer, &length, &array) == IVI_SUCCEEDED);
runner_assert(2 == length); runner_assert(2 == length);
for (i = 0; i < length; i++) for (i = 0; i < length; i++)
@ -816,66 +816,66 @@ RUNNER_TEST(test_layer_render_order_destroy_one_surface_p2)
if (length > 0) if (length > 0)
free(array); free(array);
ctl->layer_destroy(ivilayer); lyt->layer_destroy(ivilayer);
} }
RUNNER_TEST(layer_bad_render_order) RUNNER_TEST(layer_bad_render_order)
{ {
const struct ivi_controller_interface *ctl = ctx->controller_interface; const struct ivi_layout_interface *lyt = ctx->layout_interface;
struct ivi_layout_layer *ivilayer; struct ivi_layout_layer *ivilayer;
struct ivi_layout_surface *ivisurfs[IVI_TEST_SURFACE_COUNT] = {}; struct ivi_layout_surface *ivisurfs[IVI_TEST_SURFACE_COUNT] = {};
struct ivi_layout_surface **array = NULL; struct ivi_layout_surface **array = NULL;
int32_t length = 0; int32_t length = 0;
uint32_t i; uint32_t i;
ivilayer = ctl->layer_create_with_dimension(IVI_TEST_LAYER_ID(0), 200, 300); ivilayer = lyt->layer_create_with_dimension(IVI_TEST_LAYER_ID(0), 200, 300);
for (i = 0; i < IVI_TEST_SURFACE_COUNT; i++) for (i = 0; i < IVI_TEST_SURFACE_COUNT; i++)
ivisurfs[i] = ctl->get_surface_from_id(IVI_TEST_SURFACE_ID(i)); ivisurfs[i] = lyt->get_surface_from_id(IVI_TEST_SURFACE_ID(i));
runner_assert(ctl->layer_set_render_order( runner_assert(lyt->layer_set_render_order(
NULL, ivisurfs, IVI_TEST_SURFACE_COUNT) == IVI_FAILED); NULL, ivisurfs, IVI_TEST_SURFACE_COUNT) == IVI_FAILED);
ctl->commit_changes(); lyt->commit_changes();
runner_assert(ctl->get_surfaces_on_layer( runner_assert(lyt->get_surfaces_on_layer(
NULL, &length, &array) == IVI_FAILED); NULL, &length, &array) == IVI_FAILED);
runner_assert(length == 0 && array == NULL); runner_assert(length == 0 && array == NULL);
runner_assert(ctl->get_surfaces_on_layer( runner_assert(lyt->get_surfaces_on_layer(
ivilayer, NULL, &array) == IVI_FAILED); ivilayer, NULL, &array) == IVI_FAILED);
runner_assert(array == NULL); runner_assert(array == NULL);
runner_assert(ctl->get_surfaces_on_layer( runner_assert(lyt->get_surfaces_on_layer(
ivilayer, &length, NULL) == IVI_FAILED); ivilayer, &length, NULL) == IVI_FAILED);
runner_assert(length == 0); runner_assert(length == 0);
ctl->layer_destroy(ivilayer); lyt->layer_destroy(ivilayer);
} }
RUNNER_TEST(commit_changes_after_render_order_set_surface_destroy) RUNNER_TEST(commit_changes_after_render_order_set_surface_destroy)
{ {
const struct ivi_controller_interface *ctl = ctx->controller_interface; const struct ivi_layout_interface *lyt = ctx->layout_interface;
struct ivi_layout_layer *ivilayer; struct ivi_layout_layer *ivilayer;
struct ivi_layout_surface *ivisurfs[IVI_TEST_SURFACE_COUNT] = {}; struct ivi_layout_surface *ivisurfs[IVI_TEST_SURFACE_COUNT] = {};
int i; int i;
ivilayer = ctl->layer_create_with_dimension(IVI_TEST_LAYER_ID(0), 200, 300); ivilayer = lyt->layer_create_with_dimension(IVI_TEST_LAYER_ID(0), 200, 300);
for (i = 0; i < IVI_TEST_SURFACE_COUNT; i++) for (i = 0; i < IVI_TEST_SURFACE_COUNT; i++)
ivisurfs[i] = ctl->get_surface_from_id(IVI_TEST_SURFACE_ID(i)); ivisurfs[i] = lyt->get_surface_from_id(IVI_TEST_SURFACE_ID(i));
runner_assert(ctl->layer_set_render_order( runner_assert(lyt->layer_set_render_order(
ivilayer, ivisurfs, IVI_TEST_SURFACE_COUNT) == IVI_SUCCEEDED); ivilayer, ivisurfs, IVI_TEST_SURFACE_COUNT) == IVI_SUCCEEDED);
} }
RUNNER_TEST(cleanup_layer) RUNNER_TEST(cleanup_layer)
{ {
const struct ivi_controller_interface *ctl = ctx->controller_interface; const struct ivi_layout_interface *lyt = ctx->layout_interface;
struct ivi_layout_layer *ivilayer; struct ivi_layout_layer *ivilayer;
ivilayer = ctl->get_layer_from_id(IVI_TEST_LAYER_ID(0)); ivilayer = lyt->get_layer_from_id(IVI_TEST_LAYER_ID(0));
ctl->layer_destroy(ivilayer); lyt->layer_destroy(ivilayer);
} }
static void static void
@ -885,52 +885,52 @@ test_surface_properties_changed_notification_callback(struct ivi_layout_surface
void *userdata) void *userdata)
{ {
struct test_context *ctx = userdata; struct test_context *ctx = userdata;
const struct ivi_controller_interface *ctl = ctx->controller_interface; const struct ivi_layout_interface *lyt = ctx->layout_interface;
runner_assert_or_return(ctl->get_id_of_surface(ivisurf) == IVI_TEST_SURFACE_ID(0)); runner_assert_or_return(lyt->get_id_of_surface(ivisurf) == IVI_TEST_SURFACE_ID(0));
ctx->user_flags = 1; ctx->user_flags = 1;
} }
RUNNER_TEST(surface_properties_changed_notification) RUNNER_TEST(surface_properties_changed_notification)
{ {
const struct ivi_controller_interface *ctl = ctx->controller_interface; const struct ivi_layout_interface *lyt = ctx->layout_interface;
const uint32_t id_surface = IVI_TEST_SURFACE_ID(0); const uint32_t id_surface = IVI_TEST_SURFACE_ID(0);
struct ivi_layout_surface *ivisurf; struct ivi_layout_surface *ivisurf;
ctx->user_flags = 0; ctx->user_flags = 0;
ivisurf = ctl->get_surface_from_id(id_surface); ivisurf = lyt->get_surface_from_id(id_surface);
runner_assert(ivisurf != NULL); runner_assert(ivisurf != NULL);
runner_assert(ctl->surface_add_notification( runner_assert(lyt->surface_add_notification(
ivisurf, test_surface_properties_changed_notification_callback, ctx) == IVI_SUCCEEDED); ivisurf, test_surface_properties_changed_notification_callback, ctx) == IVI_SUCCEEDED);
ctl->commit_changes(); lyt->commit_changes();
runner_assert(ctx->user_flags == 0); runner_assert(ctx->user_flags == 0);
runner_assert(ctl->surface_set_destination_rectangle( runner_assert(lyt->surface_set_destination_rectangle(
ivisurf, 20, 30, 200, 300) == IVI_SUCCEEDED); ivisurf, 20, 30, 200, 300) == IVI_SUCCEEDED);
ctl->commit_changes(); lyt->commit_changes();
runner_assert(ctx->user_flags == 1); runner_assert(ctx->user_flags == 1);
ctx->user_flags = 0; ctx->user_flags = 0;
runner_assert(ctl->surface_set_destination_rectangle( runner_assert(lyt->surface_set_destination_rectangle(
ivisurf, 20, 30, 200, 300) == IVI_SUCCEEDED); ivisurf, 20, 30, 200, 300) == IVI_SUCCEEDED);
ctl->commit_changes(); lyt->commit_changes();
runner_assert(ctx->user_flags == 0); runner_assert(ctx->user_flags == 0);
ctl->surface_remove_notification(ivisurf); lyt->surface_remove_notification(ivisurf);
ctx->user_flags = 0; ctx->user_flags = 0;
runner_assert(ctl->surface_set_destination_rectangle( runner_assert(lyt->surface_set_destination_rectangle(
ivisurf, 40, 50, 400, 500) == IVI_SUCCEEDED); ivisurf, 40, 50, 400, 500) == IVI_SUCCEEDED);
ctl->commit_changes(); lyt->commit_changes();
runner_assert(ctx->user_flags == 0); runner_assert(ctx->user_flags == 0);
} }
@ -940,38 +940,38 @@ test_surface_configure_notification_callback(struct ivi_layout_surface *ivisurf,
void *userdata) void *userdata)
{ {
struct test_context *ctx = userdata; struct test_context *ctx = userdata;
const struct ivi_controller_interface *ctl = ctx->controller_interface; const struct ivi_layout_interface *lyt = ctx->layout_interface;
runner_assert_or_return(ctl->get_id_of_surface(ivisurf) == IVI_TEST_SURFACE_ID(0)); runner_assert_or_return(lyt->get_id_of_surface(ivisurf) == IVI_TEST_SURFACE_ID(0));
ctx->user_flags = 1; ctx->user_flags = 1;
} }
RUNNER_TEST(surface_configure_notification_p1) RUNNER_TEST(surface_configure_notification_p1)
{ {
const struct ivi_controller_interface *ctl = ctx->controller_interface; const struct ivi_layout_interface *lyt = ctx->layout_interface;
runner_assert(IVI_SUCCEEDED == ctl->add_notification_configure_surface(test_surface_configure_notification_callback, ctx)); runner_assert(IVI_SUCCEEDED == lyt->add_notification_configure_surface(test_surface_configure_notification_callback, ctx));
ctl->commit_changes(); lyt->commit_changes();
ctx->user_flags = 0; ctx->user_flags = 0;
} }
RUNNER_TEST(surface_configure_notification_p2) RUNNER_TEST(surface_configure_notification_p2)
{ {
const struct ivi_controller_interface *ctl = ctx->controller_interface; const struct ivi_layout_interface *lyt = ctx->layout_interface;
runner_assert(ctx->user_flags == 1); runner_assert(ctx->user_flags == 1);
ctl->remove_notification_configure_surface(test_surface_configure_notification_callback, ctx); lyt->remove_notification_configure_surface(test_surface_configure_notification_callback, ctx);
ctx->user_flags = 0; ctx->user_flags = 0;
} }
RUNNER_TEST(surface_configure_notification_p3) RUNNER_TEST(surface_configure_notification_p3)
{ {
const struct ivi_controller_interface *ctl = ctx->controller_interface; const struct ivi_layout_interface *lyt = ctx->layout_interface;
ctl->commit_changes(); lyt->commit_changes();
runner_assert(ctx->user_flags == 0); runner_assert(ctx->user_flags == 0);
} }
@ -980,18 +980,18 @@ test_surface_create_notification_callback(struct ivi_layout_surface *ivisurf,
void *userdata) void *userdata)
{ {
struct test_context *ctx = userdata; struct test_context *ctx = userdata;
const struct ivi_controller_interface *ctl = ctx->controller_interface; const struct ivi_layout_interface *lyt = ctx->layout_interface;
runner_assert_or_return(ctl->get_id_of_surface(ivisurf) == IVI_TEST_SURFACE_ID(0)); runner_assert_or_return(lyt->get_id_of_surface(ivisurf) == IVI_TEST_SURFACE_ID(0));
ctx->user_flags = 1; ctx->user_flags = 1;
} }
RUNNER_TEST(surface_create_notification_p1) RUNNER_TEST(surface_create_notification_p1)
{ {
const struct ivi_controller_interface *ctl = ctx->controller_interface; const struct ivi_layout_interface *lyt = ctx->layout_interface;
runner_assert(ctl->add_notification_create_surface( runner_assert(lyt->add_notification_create_surface(
test_surface_create_notification_callback, ctx) == IVI_SUCCEEDED); test_surface_create_notification_callback, ctx) == IVI_SUCCEEDED);
ctx->user_flags = 0; ctx->user_flags = 0;
@ -999,11 +999,11 @@ RUNNER_TEST(surface_create_notification_p1)
RUNNER_TEST(surface_create_notification_p2) RUNNER_TEST(surface_create_notification_p2)
{ {
const struct ivi_controller_interface *ctl = ctx->controller_interface; const struct ivi_layout_interface *lyt = ctx->layout_interface;
runner_assert(ctx->user_flags == 1); runner_assert(ctx->user_flags == 1);
ctl->remove_notification_create_surface( lyt->remove_notification_create_surface(
test_surface_create_notification_callback, ctx); test_surface_create_notification_callback, ctx);
ctx->user_flags = 0; ctx->user_flags = 0;
} }
@ -1018,18 +1018,18 @@ test_surface_remove_notification_callback(struct ivi_layout_surface *ivisurf,
void *userdata) void *userdata)
{ {
struct test_context *ctx = userdata; struct test_context *ctx = userdata;
const struct ivi_controller_interface *ctl = ctx->controller_interface; const struct ivi_layout_interface *lyt = ctx->layout_interface;
runner_assert_or_return(ctl->get_id_of_surface(ivisurf) == IVI_TEST_SURFACE_ID(0)); runner_assert_or_return(lyt->get_id_of_surface(ivisurf) == IVI_TEST_SURFACE_ID(0));
ctx->user_flags = 1; ctx->user_flags = 1;
} }
RUNNER_TEST(surface_remove_notification_p1) RUNNER_TEST(surface_remove_notification_p1)
{ {
const struct ivi_controller_interface *ctl = ctx->controller_interface; const struct ivi_layout_interface *lyt = ctx->layout_interface;
runner_assert(ctl->add_notification_remove_surface( runner_assert(lyt->add_notification_remove_surface(
test_surface_remove_notification_callback, ctx) == IVI_SUCCEEDED); test_surface_remove_notification_callback, ctx) == IVI_SUCCEEDED);
ctx->user_flags = 0; ctx->user_flags = 0;
@ -1037,11 +1037,11 @@ RUNNER_TEST(surface_remove_notification_p1)
RUNNER_TEST(surface_remove_notification_p2) RUNNER_TEST(surface_remove_notification_p2)
{ {
const struct ivi_controller_interface *ctl = ctx->controller_interface; const struct ivi_layout_interface *lyt = ctx->layout_interface;
runner_assert(ctx->user_flags == 1); runner_assert(ctx->user_flags == 1);
ctl->remove_notification_remove_surface(test_surface_remove_notification_callback, ctx); lyt->remove_notification_remove_surface(test_surface_remove_notification_callback, ctx);
ctx->user_flags = 0; ctx->user_flags = 0;
} }
@ -1060,14 +1060,14 @@ test_surface_bad_properties_changed_notification_callback(struct ivi_layout_surf
RUNNER_TEST(surface_bad_properties_changed_notification) RUNNER_TEST(surface_bad_properties_changed_notification)
{ {
const struct ivi_controller_interface *ctl = ctx->controller_interface; const struct ivi_layout_interface *lyt = ctx->layout_interface;
struct ivi_layout_surface *ivisurf; struct ivi_layout_surface *ivisurf;
ivisurf = ctl->get_surface_from_id(IVI_TEST_SURFACE_ID(0)); ivisurf = lyt->get_surface_from_id(IVI_TEST_SURFACE_ID(0));
runner_assert(ivisurf != NULL); runner_assert(ivisurf != NULL);
runner_assert(ctl->surface_add_notification( runner_assert(lyt->surface_add_notification(
NULL, test_surface_bad_properties_changed_notification_callback, NULL) == IVI_FAILED); NULL, test_surface_bad_properties_changed_notification_callback, NULL) == IVI_FAILED);
runner_assert(ctl->surface_add_notification( runner_assert(lyt->surface_add_notification(
ivisurf, NULL, NULL) == IVI_FAILED); ivisurf, NULL, NULL) == IVI_FAILED);
} }

Write Preview
Loading…
Cancel
Save