diff options
Diffstat (limited to 'meta-ivi/recipes-graphics/wayland')
| -rw-r--r-- | meta-ivi/recipes-graphics/wayland/wayland-ivi-extension/apply_weston-1.6.x.patch | 2135 | ||||
| -rw-r--r-- | meta-ivi/recipes-graphics/wayland/wayland-ivi-extension_1.3.0.bb | 8 |
2 files changed, 2141 insertions, 2 deletions
diff --git a/meta-ivi/recipes-graphics/wayland/wayland-ivi-extension/apply_weston-1.6.x.patch b/meta-ivi/recipes-graphics/wayland/wayland-ivi-extension/apply_weston-1.6.x.patch new file mode 100644 index 0000000..7f8ef4e --- /dev/null +++ b/meta-ivi/recipes-graphics/wayland/wayland-ivi-extension/apply_weston-1.6.x.patch @@ -0,0 +1,2135 @@ +diff --git a/weston-ivi-shell/src/ivi-controller.c b/weston-ivi-shell/src/ivi-controller.c +index f341454..049859e 100755 +--- a/weston-ivi-shell/src/ivi-controller.c ++++ b/weston-ivi-shell/src/ivi-controller.c +@@ -202,7 +202,7 @@ destroy_ivicontroller_layer(struct wl_resource *resource) + struct ivicontroller_layer *next = NULL; + uint32_t id_layer = 0; + +- id_layer = ivi_layout_getIdOfLayer(ivilayer->layout_layer); ++ id_layer = ivi_layout_get_id_of_layer(ivilayer->layout_layer); + + wl_list_for_each_safe(ctrllayer, next, + &shell->list_controller_layer, link) { +@@ -222,7 +222,7 @@ destroy_ivicontroller_layer(struct wl_resource *resource) + if ((ivilayer->layout_layer != NULL) && + (ivilayer->controller_layer_count == 0) && + (ivilayer->layer_canbe_removed == 1)) { +- ivi_layout_layerRemove(ivilayer->layout_layer); ++ ivi_layout_layer_remove(ivilayer->layout_layer); + } + } + +@@ -271,7 +271,7 @@ get_surface(struct wl_list *list_surf, uint32_t id_surface) + uint32_t ivisurf_id = 0; + + wl_list_for_each(ivisurf, list_surf, link) { +- ivisurf_id = ivi_layout_getIdOfSurface(ivisurf->layout_surface); ++ ivisurf_id = ivi_layout_get_id_of_surface(ivisurf->layout_surface); + if (ivisurf_id == id_surface) { + return ivisurf; + } +@@ -287,7 +287,7 @@ get_layer(struct wl_list *list_layer, uint32_t id_layer) + uint32_t ivilayer_id = 0; + + wl_list_for_each(ivilayer, list_layer, link) { +- ivilayer_id = ivi_layout_getIdOfLayer(ivilayer->layout_layer); ++ ivilayer_id = ivi_layout_get_id_of_layer(ivilayer->layout_layer); + if (ivilayer_id == id_layer) { + return ivilayer; + } +@@ -361,7 +361,7 @@ send_surface_add_event(struct ivisurface *ivisurf, + struct wl_client *surface_client = wl_resource_get_client(resource); + int found = 0; + +- ans = ivi_layout_getLayersUnderSurface(ivisurf->layout_surface, ++ ans = ivi_layout_get_layers_under_surface(ivisurf->layout_surface, + &length, &pArray); + if (0 != ans) { + weston_log("failed to get layers at send_surface_add_event\n"); +@@ -389,7 +389,7 @@ send_surface_add_event(struct ivisurface *ivisurf, + } + + id_layout_layer = +- ivi_layout_getIdOfLayer(ivilayer->layout_layer); ++ ivi_layout_get_id_of_layer(ivilayer->layout_layer); + wl_list_for_each(ctrllayer, &shell->list_controller_layer, link) { + if (id_layout_layer != ctrllayer->id_layer) { + continue; +@@ -412,7 +412,7 @@ send_surface_add_event(struct ivisurface *ivisurf, + static void + send_surface_event(struct wl_resource *resource, + struct ivisurface *ivisurf, +- struct ivi_layout_SurfaceProperties *prop, ++ struct ivi_layout_surface_properties *prop, + uint32_t mask) + { + if (mask & IVI_NOTIFICATION_OPACITY) { +@@ -421,13 +421,13 @@ send_surface_event(struct wl_resource *resource, + } + if (mask & IVI_NOTIFICATION_SOURCE_RECT) { + ivi_controller_surface_send_source_rectangle(resource, +- prop->sourceX, prop->sourceY, +- prop->sourceWidth, prop->sourceHeight); ++ prop->source_x, prop->source_y, ++ prop->source_width, prop->source_height); + } + if (mask & IVI_NOTIFICATION_DEST_RECT) { + ivi_controller_surface_send_destination_rectangle(resource, +- prop->destX, prop->destY, +- prop->destWidth, prop->destHeight); ++ prop->dest_x, prop->dest_y, ++ prop->dest_width, prop->dest_height); + } + if (mask & IVI_NOTIFICATION_ORIENTATION) { + ivi_controller_surface_send_orientation(resource, +@@ -437,15 +437,6 @@ send_surface_event(struct wl_resource *resource, + ivi_controller_surface_send_visibility(resource, + prop->visibility); + } +- if (mask & IVI_NOTIFICATION_PIXELFORMAT) { +- ivi_controller_surface_send_pixelformat(resource, +- prop->pixelformat); +- } +- if (mask & IVI_NOTIFICATION_KEYBOARD_FOCUS) { +- ivi_controller_surface_send_input_focus(resource, +- IVI_CONTROLLER_SURFACE_INPUT_DEVICE_KEYBOARD, +- prop->hasKeyboardFocus); +- } + if (mask & IVI_NOTIFICATION_REMOVE) { + send_surface_add_event(ivisurf, resource, IVI_NOTIFICATION_REMOVE); + } +@@ -464,7 +455,7 @@ update_surface_prop(struct ivisurface *ivisurf, + int i = 0; + struct ivishell *shell = ivisurf->shell; + +- ans = ivi_layout_getLayersUnderSurface(ivisurf->layout_surface, ++ ans = ivi_layout_get_layers_under_surface(ivisurf->layout_surface, + &length, &pArray); + if (0 != ans) { + weston_log("failed to get layers at send_surface_add_event\n"); +@@ -511,7 +502,7 @@ update_surface_prop(struct ivisurface *ivisurf, + + static void + send_surface_prop(struct ivi_layout_surface *layout_surface, +- struct ivi_layout_SurfaceProperties *prop, ++ struct ivi_layout_surface_properties *prop, + enum ivi_layout_notification_mask mask, + void *userdata) + { +@@ -520,7 +511,7 @@ send_surface_prop(struct ivi_layout_surface *layout_surface, + struct ivicontroller_surface *ctrlsurf = NULL; + uint32_t id_surface = 0; + +- id_surface = ivi_layout_getIdOfSurface(layout_surface); ++ id_surface = ivi_layout_get_id_of_surface(layout_surface); + + wl_list_for_each(ctrlsurf, &shell->list_controller_surface, link) { + if (id_surface != ctrlsurf->id_surface) { +@@ -548,7 +539,7 @@ send_layer_add_event(struct ivilayer *ivilayer, + struct wl_client *client = wl_resource_get_client(resource); + struct wl_resource *resource_output = NULL; + +- ans = ivi_layout_getScreensUnderLayer(ivilayer->layout_layer, ++ ans = ivi_layout_get_screens_under_layer(ivilayer->layout_layer, + &length, &pArray); + if (0 != ans) { + weston_log("failed to get screens at send_layer_add_event\n"); +@@ -591,7 +582,7 @@ send_layer_add_event(struct ivilayer *ivilayer, + static void + send_layer_event(struct wl_resource *resource, + struct ivilayer *ivilayer, +- struct ivi_layout_LayerProperties *prop, ++ struct ivi_layout_layer_properties *prop, + uint32_t mask) + { + if (mask & IVI_NOTIFICATION_OPACITY) { +@@ -600,17 +591,17 @@ send_layer_event(struct wl_resource *resource, + } + if (mask & IVI_NOTIFICATION_SOURCE_RECT) { + ivi_controller_layer_send_source_rectangle(resource, +- prop->sourceX, +- prop->sourceY, +- prop->sourceWidth, +- prop->sourceHeight); ++ prop->source_x, ++ prop->source_y, ++ prop->source_width, ++ prop->source_height); + } + if (mask & IVI_NOTIFICATION_DEST_RECT) { + ivi_controller_layer_send_destination_rectangle(resource, +- prop->destX, +- prop->destY, +- prop->destWidth, +- prop->destHeight); ++ prop->dest_x, ++ prop->dest_y, ++ prop->dest_width, ++ prop->dest_height); + } + if (mask & IVI_NOTIFICATION_ORIENTATION) { + ivi_controller_layer_send_orientation(resource, +@@ -638,7 +629,7 @@ update_layer_prop(struct ivilayer *ivilayer, + struct link_screen *link_scrn = NULL; + struct link_screen *next = NULL; + +- ans = ivi_layout_getScreensUnderLayer(ivilayer->layout_layer, ++ ans = ivi_layout_get_screens_under_layer(ivilayer->layout_layer, + &length, &pArray); + if (0 != ans) { + weston_log("failed to get screens at send_layer_add_event\n"); +@@ -687,7 +678,7 @@ update_layer_prop(struct ivilayer *ivilayer, + + static void + send_layer_prop(struct ivi_layout_layer *layer, +- struct ivi_layout_LayerProperties *prop, ++ struct ivi_layout_layer_properties *prop, + enum ivi_layout_notification_mask mask, + void *userdata) + { +@@ -696,7 +687,7 @@ send_layer_prop(struct ivi_layout_layer *layer, + struct ivishell *shell = ivilayer->shell; + uint32_t id_layout_layer = 0; + +- id_layout_layer = ivi_layout_getIdOfLayer(layer); ++ id_layout_layer = ivi_layout_get_id_of_layer(layer); + wl_list_for_each(ctrllayer, &shell->list_controller_layer, link) { + if (id_layout_layer != ctrllayer->id_layer) { + continue; +@@ -714,7 +705,7 @@ controller_surface_set_opacity(struct wl_client *client, + { + struct ivisurface *ivisurf = wl_resource_get_user_data(resource); + (void)client; +- ivi_layout_surfaceSetOpacity(ivisurf->layout_surface, (float)opacity); ++ ivi_layout_surface_set_opacity(ivisurf->layout_surface, (float)opacity); + } + + static void +@@ -727,7 +718,7 @@ controller_surface_set_source_rectangle(struct wl_client *client, + { + struct ivisurface *ivisurf = wl_resource_get_user_data(resource); + (void)client; +- ivi_layout_surfaceSetSourceRectangle(ivisurf->layout_surface, ++ ivi_layout_surface_set_source_rectangle(ivisurf->layout_surface, + (uint32_t)x, (uint32_t)y, (uint32_t)width, (uint32_t)height); + } + +@@ -743,11 +734,11 @@ controller_surface_set_destination_rectangle(struct wl_client *client, + (void)client; + + // TODO: create set transition type protocol +- ivi_layout_surfaceSetTransition( ivisurf->layout_surface, ++ ivi_layout_surface_set_transition(ivisurf->layout_surface, + IVI_LAYOUT_TRANSITION_NONE, + 300); // ms + +- ivi_layout_surfaceSetDestinationRectangle(ivisurf->layout_surface, ++ ivi_layout_surface_set_destination_rectangle(ivisurf->layout_surface, + (uint32_t)x, (uint32_t)y, (uint32_t)width, (uint32_t)height); + } + +@@ -758,7 +749,7 @@ controller_surface_set_visibility(struct wl_client *client, + { + struct ivisurface *ivisurf = wl_resource_get_user_data(resource); + (void)client; +- ivi_layout_surfaceSetVisibility(ivisurf->layout_surface, visibility); ++ ivi_layout_surface_set_visibility(ivisurf->layout_surface, visibility); + } + + static void +@@ -780,7 +771,7 @@ controller_surface_set_orientation(struct wl_client *client, + { + struct ivisurface *ivisurf = wl_resource_get_user_data(resource); + (void)client; +- ivi_layout_surfaceSetOrientation(ivisurf->layout_surface, (uint32_t)orientation); ++ ivi_layout_surface_set_orientation(ivisurf->layout_surface, (uint32_t)orientation); + } + + static int +@@ -941,7 +932,7 @@ clear_viewlist_but_specified_surface(struct weston_compositor *compositor, + } + + static void +-get_gl_surface_rectangle(struct ivi_layout_SurfaceProperties *prop, ++get_gl_surface_rectangle(struct ivi_layout_surface_properties *prop, + int32_t *x, + int32_t *y, + int32_t *width, +@@ -951,10 +942,10 @@ get_gl_surface_rectangle(struct ivi_layout_SurfaceProperties *prop, + return; + } + +- *x = prop->sourceX; +- *y = prop->sourceY; +- *width = prop->sourceWidth; +- *height = prop->sourceHeight; ++ *x = prop->source_x; ++ *y = prop->source_y; ++ *width = prop->source_width; ++ *height = prop->source_height; + } + + static int +@@ -967,7 +958,7 @@ gl_surface_screenshot(struct ivisurface *ivisurf, + struct weston_view *view = NULL; + struct weston_output *output = NULL; + struct iviscreen *link_scrn = NULL; +- struct ivi_layout_SurfaceProperties prop = {}; ++ struct ivi_layout_surface_properties *prop; + int32_t x = 0; + int32_t y = 0; + int32_t width = 0; +@@ -984,7 +975,9 @@ gl_surface_screenshot(struct ivisurface *ivisurf, + return -1; + } + +- if (ivi_layout_getPropertiesOfSurface(ivisurf->layout_surface, &prop) != 0) { ++ prop = (struct ivi_layout_surface_properties *) ++ ivi_layout_get_properties_of_surface(ivisurf->layout_surface); ++ if (prop == NULL) { + fprintf(stderr, "Failed to get surface properties."); + return -1; + } +@@ -997,7 +990,7 @@ gl_surface_screenshot(struct ivisurface *ivisurf, + view->plane = &compositor->primary_plane; + } + +- get_gl_surface_rectangle(&prop, &x, &y, &width, &height); ++ get_gl_surface_rectangle(prop, &x, &y, &width, &height); + dump_surface(link_scrn->output, + compositor, + filename, +@@ -1026,13 +1019,13 @@ controller_surface_screenshot(struct wl_client *client, + int32_t height = 0; + int32_t stride = 0; + +- weston_surface = ivi_layout_surfaceGetWestonSurface(ivisurf->layout_surface); ++ weston_surface = ivi_layout_surface_get_weston_surface(ivisurf->layout_surface); + if (weston_surface == NULL) { + fprintf(stderr, "Failed to get weston surface.\n"); + return; + } + +- if (ivi_layout_surfaceGetSize(ivisurf->layout_surface, &width, &height, &stride) != 0) { ++ if (ivi_layout_surface_get_size(ivisurf->layout_surface, &width, &height, &stride) != 0) { + fprintf(stderr, "Failed to get surface size.\n"); + return; + } +@@ -1069,43 +1062,24 @@ controller_surface_destroy(struct wl_client *client, + wl_resource_destroy(resource); + } + +-static void send_all_keyboard_focus(struct ivishell *shell) +-{ +- struct ivi_layout_SurfaceProperties props; +- struct ivicontroller_surface *ctrlsurf; +- struct ivisurface *current_surf; +- uint32_t id_surface; +- +- wl_list_for_each(current_surf, &shell->list_surface, link) { +- ivi_layout_getPropertiesOfSurface(current_surf->layout_surface, +- &props); +- id_surface = ivi_layout_getIdOfSurface(current_surf->layout_surface); +- wl_list_for_each(ctrlsurf, &shell->list_controller_surface, link) { +- if (id_surface != ctrlsurf->id_surface) { +- continue; +- } +- ivi_controller_surface_send_input_focus(ctrlsurf->resource, +- IVI_CONTROLLER_SURFACE_INPUT_DEVICE_KEYBOARD, +- props.hasKeyboardFocus); +- } +- } +-} +- + static void + controller_surface_set_input_focus(struct wl_client *client, + struct wl_resource *resource, + uint32_t device, + int32_t enabled) + { ++ weston_log("%s: %p, %p, %x, %d\n", __FUNCTION__, client, resource, device, enabled); ++#if 0 + (void)client; + struct ivisurface *ivisurf = wl_resource_get_user_data(resource); + + if (device & IVI_CONTROLLER_SURFACE_INPUT_DEVICE_KEYBOARD) { + if (enabled) { +- ivi_layout_SetKeyboardFocusOn(ivisurf->layout_surface); ++ ivi_layout_SetKeyboardFocusOn(ivisurf->layout_surface); // tolkien + send_all_keyboard_focus(ivisurf->shell); + } + } ++#endif + } + + static const +@@ -1132,7 +1106,7 @@ controller_layer_set_source_rectangle(struct wl_client *client, + { + struct ivilayer *ivilayer = wl_resource_get_user_data(resource); + (void)client; +- ivi_layout_layerSetSourceRectangle(ivilayer->layout_layer, ++ ivi_layout_layer_set_source_rectangle(ivilayer->layout_layer, + (uint32_t)x, (uint32_t)y, (uint32_t)width, (uint32_t)height); + } + +@@ -1146,7 +1120,7 @@ controller_layer_set_destination_rectangle(struct wl_client *client, + { + struct ivilayer *ivilayer = wl_resource_get_user_data(resource); + (void)client; +- ivi_layout_layerSetDestinationRectangle(ivilayer->layout_layer, ++ ivi_layout_layer_set_destination_rectangle(ivilayer->layout_layer, + (uint32_t)x, (uint32_t)y, (uint32_t)width, (uint32_t)height); + } + +@@ -1157,7 +1131,7 @@ controller_layer_set_visibility(struct wl_client *client, + { + struct ivilayer *ivilayer = wl_resource_get_user_data(resource); + (void)client; +- ivi_layout_layerSetVisibility(ivilayer->layout_layer, visibility); ++ ivi_layout_layer_set_visibility(ivilayer->layout_layer, visibility); + } + + static void +@@ -1167,7 +1141,7 @@ controller_layer_set_opacity(struct wl_client *client, + { + struct ivilayer *ivilayer = wl_resource_get_user_data(resource); + (void)client; +- ivi_layout_layerSetOpacity(ivilayer->layout_layer, (float)opacity); ++ ivi_layout_layer_set_opacity(ivilayer->layout_layer, (float)opacity); + } + + static void +@@ -1190,7 +1164,7 @@ controller_layer_set_orientation(struct wl_client *client, + { + struct ivilayer *ivilayer = wl_resource_get_user_data(resource); + (void)client; +- ivi_layout_layerSetOrientation(ivilayer->layout_layer, (uint32_t)orientation); ++ ivi_layout_layer_set_orientation(ivilayer->layout_layer, (uint32_t)orientation); + } + + static void +@@ -1199,7 +1173,7 @@ controller_layer_clear_surfaces(struct wl_client *client, + { + struct ivilayer *ivilayer = wl_resource_get_user_data(resource); + (void)client; +- ivi_layout_layerSetRenderOrder(ivilayer->layout_layer, NULL, 0); ++ ivi_layout_layer_set_render_order(ivilayer->layout_layer, NULL, 0); + } + + static void +@@ -1210,7 +1184,7 @@ controller_layer_add_surface(struct wl_client *client, + struct ivilayer *ivilayer = wl_resource_get_user_data(resource); + struct ivisurface *ivisurf = wl_resource_get_user_data(surface); + (void)client; +- ivi_layout_layerAddSurface(ivilayer->layout_layer, ivisurf->layout_surface); ++ ivi_layout_layer_add_surface(ivilayer->layout_layer, ivisurf->layout_surface); + } + + static void +@@ -1221,7 +1195,7 @@ controller_layer_remove_surface(struct wl_client *client, + struct ivilayer *ivilayer = wl_resource_get_user_data(resource); + struct ivisurface *ivisurf = wl_resource_get_user_data(surface); + (void)client; +- ivi_layout_layerRemoveSurface(ivilayer->layout_layer, ivisurf->layout_surface); ++ ivi_layout_layer_remove_surface(ivilayer->layout_layer, ivisurf->layout_surface); + } + + static void +@@ -1252,7 +1226,7 @@ controller_layer_set_render_order(struct wl_client *client, + + wl_array_for_each(id_surface, id_surfaces) { + wl_list_for_each(ivisurf, &ivilayer->shell->list_surface, link) { +- id_layout_surface = ivi_layout_getIdOfSurface(ivisurf->layout_surface); ++ id_layout_surface = ivi_layout_get_id_of_surface(ivisurf->layout_surface); + if (*id_surface == id_layout_surface) { + layoutsurf_array[i] = ivisurf->layout_surface; + i++; +@@ -1261,7 +1235,7 @@ controller_layer_set_render_order(struct wl_client *client, + } + } + +- ivi_layout_layerSetRenderOrder(ivilayer->layout_layer, ++ ivi_layout_layer_set_render_order(ivilayer->layout_layer, + layoutsurf_array, i); + free(layoutsurf_array); + } +@@ -1275,7 +1249,7 @@ controller_layer_destroy(struct wl_client *client, + struct ivishell *shell = ivilayer->shell; + struct ivicontroller_layer *ctrllayer = NULL; + struct ivicontroller_layer *next = NULL; +- uint32_t id_layer = ivi_layout_getIdOfLayer(ivilayer->layout_layer); ++ uint32_t id_layer = ivi_layout_get_id_of_layer(ivilayer->layout_layer); + (void)client; + (void)destroy_scene_object; + +@@ -1335,7 +1309,7 @@ controller_screen_clear(struct wl_client *client, + { + struct iviscreen *iviscrn = wl_resource_get_user_data(resource); + (void)client; +- ivi_layout_screenSetRenderOrder(iviscrn->layout_screen, NULL, 0); ++ ivi_layout_screen_set_render_order(iviscrn->layout_screen, NULL, 0); + } + + static void +@@ -1346,7 +1320,7 @@ controller_screen_add_layer(struct wl_client *client, + struct iviscreen *iviscrn = wl_resource_get_user_data(resource); + struct ivilayer *ivilayer = wl_resource_get_user_data(layer); + (void)client; +- ivi_layout_screenAddLayer(iviscrn->layout_screen, ivilayer->layout_layer); ++ ivi_layout_screen_add_layer(iviscrn->layout_screen, ivilayer->layout_layer); + } + + static void +@@ -1365,7 +1339,7 @@ controller_screen_screenshot(struct wl_client *client, + int32_t stride = 0; + uint8_t *readpixs = NULL; + +- output = ivi_layout_screenGetOutput(iviscrn->layout_screen); ++ output = ivi_layout_screen_get_output(iviscrn->layout_screen); + --output->disable_planes; + + width = output->current_mode->width; +@@ -1409,7 +1383,7 @@ controller_screen_set_render_order(struct wl_client *client, + + wl_array_for_each(id_layer, id_layers) { + wl_list_for_each(ivilayer, &iviscrn->shell->list_layer, link) { +- id_layout_layer = ivi_layout_getIdOfLayer(ivilayer->layout_layer); ++ id_layout_layer = ivi_layout_get_id_of_layer(ivilayer->layout_layer); + if (*id_layer == id_layout_layer) { + layoutlayer_array[i] = ivilayer->layout_layer; + i++; +@@ -1418,7 +1392,7 @@ controller_screen_set_render_order(struct wl_client *client, + } + } + +- ivi_layout_screenSetRenderOrder(iviscrn->layout_screen, ++ ivi_layout_screen_set_render_order(iviscrn->layout_screen, + layoutlayer_array, i); + free(layoutlayer_array); + } +@@ -1440,7 +1414,7 @@ controller_commit_changes(struct wl_client *client, + (void)client; + (void)resource; + +- ans = ivi_layout_commitChanges(); ++ ans = ivi_layout_commit_changes(); + if (ans < 0) { + weston_log("Failed to commit changes at controller_commit_changes\n"); + } +@@ -1459,11 +1433,11 @@ controller_layer_create(struct wl_client *client, + struct ivi_layout_layer *layout_layer = NULL; + struct ivicontroller_layer *ctrllayer = NULL; + struct ivilayer *ivilayer = NULL; +- struct ivi_layout_LayerProperties prop; ++ struct ivi_layout_layer_properties *prop = NULL; + + ivilayer = get_layer(&shell->list_layer, id_layer); + if (ivilayer == NULL) { +- layout_layer = ivi_layout_layerCreateWithDimension(id_layer, ++ layout_layer = ivi_layout_layer_create_with_dimension(id_layer, + (uint32_t)width, (uint32_t)height); + if (layout_layer == NULL) { + weston_log("id_layer is already created\n"); +@@ -1505,11 +1479,9 @@ controller_layer_create(struct wl_client *client, + &controller_layer_implementation, + ivilayer, destroy_ivicontroller_layer); + +- memset(&prop, 0, sizeof prop); +- +- ivi_layout_getPropertiesOfLayer(ivilayer->layout_layer, &prop); ++ prop = ivi_layout_get_properties_of_surface(ivilayer->layout_layer); + send_layer_event(ctrllayer->resource, ivilayer, +- &prop, IVI_NOTIFICATION_ALL); ++ prop, IVI_NOTIFICATION_ALL); + } + + static void +@@ -1533,7 +1505,7 @@ controller_surface_create(struct wl_client *client, + struct ivicontroller *ctrl = wl_resource_get_user_data(resource); + struct ivishell *shell = ctrl->shell; + struct ivicontroller_surface *ctrlsurf = NULL; +- struct ivi_layout_SurfaceProperties prop; ++ struct ivi_layout_surface_properties *prop = NULL; + struct ivisurface *ivisurf = NULL; + struct ivicontroller_surface *ctrl_link = NULL; + +@@ -1583,13 +1555,11 @@ controller_surface_create(struct wl_client *client, + + ctrlsurf->implementation_set = 1; + +- memset(&prop, 0, sizeof prop); +- +- ivi_layout_getPropertiesOfSurface(ivisurf->layout_surface, &prop); +- ivi_layout_surfaceSetContentObserver(ivisurf->layout_surface, surface_event_content, shell); ++ prop = ivi_layout_get_properties_of_surface(ivisurf->layout_surface); ++ ivi_layout_surface_set_content_observer(ivisurf->layout_surface, surface_event_content, shell); + + send_surface_event(ctrlsurf->resource, ivisurf, +- &prop, IVI_NOTIFICATION_ALL); ++ prop, IVI_NOTIFICATION_ALL); + } + + static const struct ivi_controller_interface controller_implementation = { +@@ -1629,14 +1599,14 @@ add_client_to_resources(struct ivishell *shell, + } + wl_list_for_each_reverse(ivilayer, &shell->list_layer, link) { + id_layout_layer = +- ivi_layout_getIdOfLayer(ivilayer->layout_layer); ++ ivi_layout_get_id_of_layer(ivilayer->layout_layer); + + ivi_controller_send_layer(controller->resource, + id_layout_layer); + } + wl_list_for_each_reverse(ivisurf, &shell->list_surface, link) { + id_layout_surface = +- ivi_layout_getIdOfSurface(ivisurf->layout_surface); ++ ivi_layout_get_id_of_surface(ivisurf->layout_surface); + + ivi_controller_send_surface(controller->resource, + id_layout_surface); +@@ -1687,7 +1657,7 @@ create_screen(struct ivishell *shell, struct weston_output *output) + iviscrn->output = output; + + // TODO : Only Single display +- iviscrn->layout_screen = ivi_layout_getScreenFromId(0); ++ iviscrn->layout_screen = ivi_layout_get_screen_from_id(0); + + wl_list_init(&iviscrn->link); + +@@ -1720,7 +1690,7 @@ create_layer(struct ivishell *shell, + wl_list_insert(&shell->list_layer, &ivilayer->link); + ivilayer->layout_layer = layout_layer; + +- ivi_layout_layerAddNotification(layout_layer, send_layer_prop, ivilayer); ++ ivi_layout_layer_add_notification(layout_layer, send_layer_prop, ivilayer); + + wl_list_for_each(controller, &shell->list_controller, link) { + ivi_controller_send_layer(controller->resource, id_layer); +@@ -1760,7 +1730,7 @@ create_surface(struct ivishell *shell, + id_surface); + } + +- ivi_layout_surfaceAddNotification(layout_surface, ++ ivi_layout_layer_add_notification(layout_surface, + send_surface_prop, ivisurf); + + return ivisurf; +@@ -1774,7 +1744,7 @@ layer_event_create(struct ivi_layout_layer *layout_layer, + struct ivilayer *ivilayer = NULL; + uint32_t id_layer = 0; + +- id_layer = ivi_layout_getIdOfLayer(layout_layer); ++ id_layer = ivi_layout_get_id_of_layer(layout_layer); + + ivilayer = create_layer(shell, layout_layer, id_layer); + if (ivilayer == NULL) { +@@ -1808,7 +1778,7 @@ layer_event_remove(struct ivi_layout_layer *layout_layer, + } + + if (is_removed) { +- id_layer = ivi_layout_getIdOfLayer(layout_layer); ++ id_layer = ivi_layout_get_id_of_layer(layout_layer); + + wl_list_for_each(ctrllayer, &shell->list_controller_layer, link) { + if (id_layer != ctrllayer->id_layer) { +@@ -1829,7 +1799,7 @@ surface_event_create(struct ivi_layout_surface *layout_surface, + uint32_t id_surface = 0; + struct ivicontroller_surface *ctrlsurf = NULL; + +- id_surface = ivi_layout_getIdOfSurface(layout_surface); ++ id_surface = ivi_layout_get_id_of_surface(layout_surface); + + ivisurf = create_surface(shell, layout_surface, id_surface); + if (ivisurf == NULL) { +@@ -1875,7 +1845,7 @@ surface_event_remove(struct ivi_layout_surface *layout_surface, + } + + if (is_removed) { +- id_surface = ivi_layout_getIdOfSurface(layout_surface); ++ id_surface = ivi_layout_get_id_of_surface(layout_surface); + + wl_list_for_each(ctrlsurf, &shell->list_controller_surface, link) { + if (id_surface != ctrlsurf->id_surface) { +@@ -1894,10 +1864,10 @@ surface_event_configure(struct ivi_layout_surface *layout_surface, + struct ivishell *shell = userdata; + struct ivisurface *ivisurf = NULL; + struct ivicontroller_surface *ctrlsurf = NULL; +- struct ivi_layout_SurfaceProperties prop; ++ struct ivi_layout_surface_properties *prop = NULL; + uint32_t id_surface = 0; + +- id_surface = ivi_layout_getIdOfSurface(layout_surface); ++ id_surface = ivi_layout_get_id_of_surface(layout_surface); + + ivisurf = get_surface(&shell->list_surface, id_surface); + if (ivisurf == NULL) { +@@ -1905,8 +1875,7 @@ surface_event_configure(struct ivi_layout_surface *layout_surface, + return; + } + +- memset(&prop, 0, sizeof prop); +- ivi_layout_getPropertiesOfSurface(layout_surface, &prop); ++ prop = ivi_layout_get_properties_of_surface(layout_surface); + + wl_list_for_each(ctrlsurf, &shell->list_controller_surface, link) { + if (id_surface != ctrlsurf->id_surface) { +@@ -1927,7 +1896,7 @@ check_layout_layers(struct ivishell *shell) + uint32_t i = 0; + int32_t ret = 0; + +- ret = ivi_layout_getLayers(&length, &pArray); ++ ret = ivi_layout_get_layers(&length, &pArray); + if(ret != 0) { + weston_log("failed to get layers at check_layout_layers\n"); + return -1; +@@ -1939,7 +1908,7 @@ check_layout_layers(struct ivishell *shell) + } + + for (i = 0; i < length; i++) { +- id_layer = ivi_layout_getIdOfLayer(pArray[i]); ++ id_layer = ivi_layout_get_id_of_layer(pArray[i]); + ivilayer = create_layer(shell, pArray[i], id_layer); + if (ivilayer == NULL) { + weston_log("failed to create layer"); +@@ -1962,7 +1931,7 @@ check_layout_surfaces(struct ivishell *shell) + uint32_t i = 0; + int32_t ret = 0; + +- ret = ivi_layout_getSurfaces(&length, &pArray); ++ ret = ivi_layout_get_surfaces(&length, &pArray); + if(ret != 0) { + weston_log("failed to get surfaces at check_layout_surfaces\n"); + return -1; +@@ -1974,7 +1943,7 @@ check_layout_surfaces(struct ivishell *shell) + } + + for (i = 0; i < length; i++) { +- id_surface = ivi_layout_getIdOfSurface(pArray[i]); ++ id_surface = ivi_layout_get_id_of_surface(pArray[i]); + ivisurf = create_surface(shell, pArray[i], id_surface); + if (ivisurf == NULL) { + weston_log("failed to create surface"); +@@ -2023,12 +1992,12 @@ init_ivi_shell(struct weston_compositor *ec, struct ivishell *shell) + weston_log("failed to check_layout_surfaces"); + } + +- ivi_layout_addNotificationCreateLayer(layer_event_create, shell); +- ivi_layout_addNotificationRemoveLayer(layer_event_remove, shell); ++ ivi_layout_add_notification_create_layer(layer_event_create, shell); ++ ivi_layout_add_notification_remove_layer(layer_event_remove, shell); + +- ivi_layout_addNotificationCreateSurface(surface_event_create, shell); +- ivi_layout_addNotificationRemoveSurface(surface_event_remove, shell); +- ivi_layout_addNotificationConfigureSurface(surface_event_configure, shell); ++ ivi_layout_add_notification_create_surface(surface_event_create, shell); ++ ivi_layout_add_notification_remove_surface(surface_event_remove, shell); ++ ivi_layout_add_notification_configure_surface(surface_event_configure, shell); + } + + WL_EXPORT int +diff --git a/weston-ivi-shell/src/ivi-layout-export.h b/weston-ivi-shell/src/ivi-layout-export.h +index 3d1afc9..eb3752c 100644 +--- a/weston-ivi-shell/src/ivi-layout-export.h ++++ b/weston-ivi-shell/src/ivi-layout-export.h +@@ -36,10 +36,13 @@ + * - commit to apply property changes. + * - notifications of property change. + * +- * Management of surfaces and layers grouping these surfaces are common way in +- * In-Vehicle Infotainment system, which integrate several domains in one system. +- * A layer is allocated to a domain in order to control application surfaces +- * grouped to the layer all together. ++ * Management of surfaces and layers grouping these surfaces are common ++ * way in In-Vehicle Infotainment system, which integrate several domains ++ * in one system. A layer is allocated to a domain in order to control ++ * application surfaces grouped to the layer all together. ++ * ++ * This API and ABI follow following specifications. ++ * http://projects.genivi.org/wayland-ivi-extension/layer-manager-apis + */ + + #ifndef _IVI_LAYOUT_EXPORT_H_ +@@ -49,181 +52,205 @@ + extern "C" { + #endif /* __cplusplus */ + +-#include "compositor.h" +-#include "ivi-layout.h" ++#include "stdbool.h" ++#include <weston/compositor.h> ++ ++#define IVI_SUCCEEDED (0) ++#define IVI_FAILED (-1) + + struct ivi_layout_layer; + struct ivi_layout_screen; ++struct ivi_layout_surface; ++ ++struct ivi_layout_surface_properties ++{ ++ wl_fixed_t opacity; ++ int32_t source_x; ++ int32_t source_y; ++ int32_t source_width; ++ int32_t source_height; ++ int32_t start_x; ++ int32_t start_y; ++ int32_t start_width; ++ int32_t start_height; ++ int32_t dest_x; ++ int32_t dest_y; ++ int32_t dest_width; ++ int32_t dest_height; ++ enum wl_output_transform orientation; ++ bool visibility; ++ int32_t transition_type; ++ uint32_t transition_duration; ++}; ++ ++struct ivi_layout_layer_properties ++{ ++ wl_fixed_t opacity; ++ int32_t source_x; ++ int32_t source_y; ++ int32_t source_width; ++ int32_t source_height; ++ int32_t dest_x; ++ int32_t dest_y; ++ int32_t dest_width; ++ int32_t dest_height; ++ enum wl_output_transform orientation; ++ uint32_t visibility; ++ int32_t transition_type; ++ uint32_t transition_duration; ++ double start_alpha; ++ double end_alpha; ++ uint32_t is_fade_in; ++}; + + enum ivi_layout_notification_mask { +- IVI_NOTIFICATION_NONE = 0, +- IVI_NOTIFICATION_OPACITY = (1 << 1), +- IVI_NOTIFICATION_SOURCE_RECT = (1 << 2), +- IVI_NOTIFICATION_DEST_RECT = (1 << 3), +- IVI_NOTIFICATION_DIMENSION = (1 << 4), +- IVI_NOTIFICATION_POSITION = (1 << 5), +- IVI_NOTIFICATION_ORIENTATION = (1 << 6), +- IVI_NOTIFICATION_VISIBILITY = (1 << 7), +- IVI_NOTIFICATION_PIXELFORMAT = (1 << 8), +- IVI_NOTIFICATION_ADD = (1 << 9), +- IVI_NOTIFICATION_REMOVE = (1 << 10), +- IVI_NOTIFICATION_CONFIGURE = (1 << 11), +- IVI_NOTIFICATION_KEYBOARD_FOCUS = (1 << 12), +- IVI_NOTIFICATION_ALL = 0xFFFF ++ IVI_NOTIFICATION_NONE = 0, ++ IVI_NOTIFICATION_OPACITY = (1 << 1), ++ IVI_NOTIFICATION_SOURCE_RECT = (1 << 2), ++ IVI_NOTIFICATION_DEST_RECT = (1 << 3), ++ IVI_NOTIFICATION_DIMENSION = (1 << 4), ++ IVI_NOTIFICATION_POSITION = (1 << 5), ++ IVI_NOTIFICATION_ORIENTATION = (1 << 6), ++ IVI_NOTIFICATION_VISIBILITY = (1 << 7), ++ IVI_NOTIFICATION_PIXELFORMAT = (1 << 8), ++ IVI_NOTIFICATION_ADD = (1 << 9), ++ IVI_NOTIFICATION_REMOVE = (1 << 10), ++ IVI_NOTIFICATION_CONFIGURE = (1 << 11), ++ IVI_NOTIFICATION_ALL = 0xFFFF + }; + + enum ivi_layout_transition_type{ +- IVI_LAYOUT_TRANSITION_NONE, +- IVI_LAYOUT_TRANSITION_VIEW_DEFAULT, +- IVI_LAYOUT_TRANSITION_VIEW_DEST_RECT_ONLY, +- IVI_LAYOUT_TRANSITION_VIEW_FADE_ONLY, +- IVI_LAYOUT_TRANSITION_LAYER_FADE, +- IVI_LAYOUT_TRANSITION_LAYER_MOVE, +- IVI_LAYOUT_TRANSITION_LAYER_VIEW_ORDER, +- IVI_LAYOUT_TRANSITION_MAX, ++ IVI_LAYOUT_TRANSITION_NONE, ++ IVI_LAYOUT_TRANSITION_VIEW_DEFAULT, ++ IVI_LAYOUT_TRANSITION_VIEW_DEST_RECT_ONLY, ++ IVI_LAYOUT_TRANSITION_VIEW_FADE_ONLY, ++ IVI_LAYOUT_TRANSITION_LAYER_FADE, ++ IVI_LAYOUT_TRANSITION_LAYER_MOVE, ++ IVI_LAYOUT_TRANSITION_LAYER_VIEW_ORDER, ++ IVI_LAYOUT_TRANSITION_VIEW_MOVE_RESIZE, ++ IVI_LAYOUT_TRANSITION_VIEW_RESIZE, ++ IVI_LAYOUT_TRANSITION_VIEW_FADE, ++ IVI_LAYOUT_TRANSITION_MAX, + }; + +-typedef void(*shellWarningNotificationFunc)(uint32_t id_surface, +- enum ivi_layout_warning_flag warn, +- void *userdata); +- +-typedef void(*layerPropertyNotificationFunc)(struct ivi_layout_layer *ivilayer, +- struct ivi_layout_LayerProperties*, +- enum ivi_layout_notification_mask mask, +- void *userdata); +- +-typedef void(*surfacePropertyNotificationFunc)(struct ivi_layout_surface *ivisurf, +- struct ivi_layout_SurfaceProperties*, +- enum ivi_layout_notification_mask mask, +- void *userdata); ++typedef void (*layer_property_notification_func)( ++ struct ivi_layout_layer *ivilayer, ++ const struct ivi_layout_layer_properties *, ++ enum ivi_layout_notification_mask mask, ++ void *userdata); + +-typedef void(*layerCreateNotificationFunc)(struct ivi_layout_layer *ivilayer, +- void *userdata); ++typedef void (*surface_property_notification_func)( ++ struct ivi_layout_surface *ivisurf, ++ const struct ivi_layout_surface_properties *, ++ enum ivi_layout_notification_mask mask, ++ void *userdata); + +-typedef void(*layerRemoveNotificationFunc)(struct ivi_layout_layer *ivilayer, +- void *userdata); ++typedef void (*layer_create_notification_func)( ++ struct ivi_layout_layer *ivilayer, ++ void *userdata); + +-typedef void(*surfaceCreateNotificationFunc)(struct ivi_layout_surface *ivisurf, +- void *userdata); ++typedef void (*layer_remove_notification_func)( ++ struct ivi_layout_layer *ivilayer, ++ void *userdata); + +-typedef void(*surfaceRemoveNotificationFunc)(struct ivi_layout_surface *ivisurf, +- void *userdata); ++typedef void (*surface_create_notification_func)( ++ struct ivi_layout_surface *ivisurf, ++ void *userdata); + +-typedef void(*surfaceConfigureNotificationFunc)(struct ivi_layout_surface *ivisurf, +- void *userdata); ++typedef void (*surface_remove_notification_func)( ++ struct ivi_layout_surface *ivisurf, ++ void *userdata); + +-typedef void(*ivi_controller_surface_content_callback)(struct ivi_layout_surface *ivisurf, +- int32_t content, +- void *userdata); +- +-int32_t +-ivi_layout_addNotificationShellWarning(shellWarningNotificationFunc callback, +- void *userdata); +- +-void +-ivi_layout_removeNotificationShellWarning(shellWarningNotificationFunc callback, +- void *userdata); +- +-/** +- * \brief to be called by ivi-shell in order to set initail view of +- * weston_surface. +- */ +-/* +-struct weston_view * +-ivi_layout_get_weston_view(struct ivi_layout_surface *surface); +-*/ ++typedef void (*surface_configure_notification_func)( ++ struct ivi_layout_surface *ivisurf, ++ void *userdata); + +-/** +- * \brief initialize ivi-layout +- */ +-/* +-void +-ivi_layout_initWithCompositor(struct weston_compositor *ec); +-*/ ++typedef void (*ivi_controller_surface_content_callback)( ++ struct ivi_layout_surface *ivisurf, ++ int32_t content, ++ void *userdata); + + /** + * \brief register for notification when layer is created + */ + int32_t +-ivi_layout_addNotificationCreateLayer(layerCreateNotificationFunc callback, +- void *userdata); ++ivi_layout_add_notification_create_layer( ++ layer_create_notification_func callback, ++ void *userdata); + + void +-ivi_layout_removeNotificationCreateLayer(layerCreateNotificationFunc callback, +- void *userdata); ++ivi_layout_remove_notification_create_layer( ++ layer_create_notification_func callback, ++ void *userdata); + + /** + * \brief register for notification when layer is removed + */ + int32_t +-ivi_layout_addNotificationRemoveLayer(layerRemoveNotificationFunc callback, +- void *userdata); ++ivi_layout_add_notification_remove_layer( ++ layer_remove_notification_func callback, ++ void *userdata); + + void +-ivi_layout_removeNotificationRemoveLayer(layerRemoveNotificationFunc callback, +- void *userdata); ++ivi_layout_remove_notification_remove_layer( ++ layer_remove_notification_func callback, ++ void *userdata); + + /** + * \brief register for notification when surface is created + */ + int32_t +-ivi_layout_addNotificationCreateSurface(surfaceCreateNotificationFunc callback, +- void *userdata); ++ivi_layout_add_notification_create_surface( ++ surface_create_notification_func callback, ++ void *userdata); + + void +-ivi_layout_removeNotificationCreateSurface(surfaceCreateNotificationFunc callback, +- void *userdata); ++ivi_layout_remove_notification_create_surface( ++ surface_create_notification_func callback, ++ void *userdata); + + /** + * \brief register for notification when surface is removed + */ + int32_t +-ivi_layout_addNotificationRemoveSurface(surfaceRemoveNotificationFunc callback, +- void *userdata); ++ivi_layout_add_notification_remove_surface( ++ surface_remove_notification_func callback, ++ void *userdata); + + void +-ivi_layout_removeNotificationRemoveSurface(surfaceRemoveNotificationFunc callback, +- void *userdata); ++ivi_layout_remove_notification_remove_surface( ++ surface_remove_notification_func callback, ++ void *userdata); + + /** + * \brief register for notification when surface is configured + */ + int32_t +-ivi_layout_addNotificationConfigureSurface(surfaceConfigureNotificationFunc callback, +- void *userdata); ++ivi_layout_add_notification_configure_surface( ++ surface_configure_notification_func callback, ++ void *userdata); + + void +-ivi_layout_removeNotificationConfigureSurface(surfaceConfigureNotificationFunc callback, +- void *userdata); ++ivi_layout_remove_notification_configure_surface( ++ surface_configure_notification_func callback, ++ void *userdata); + + /** + * \brief get id of surface from ivi_layout_surface + * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed ++ * \return id of surface + */ + uint32_t +-ivi_layout_getIdOfSurface(struct ivi_layout_surface *ivisurf); ++ivi_layout_get_id_of_surface(struct ivi_layout_surface *ivisurf); + + /** + * \brief get id of layer from ivi_layout_layer + * + * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed ++ * \return id of layer + */ + uint32_t +-ivi_layout_getIdOfLayer(struct ivi_layout_layer *ivilayer); +- +-/** +- * \brief get ivi_layout_layer from id of layer +- * +- * \return (struct ivi_layout_layer *) +- * if the method call was successful +- * \return NULL if the method call was failed +- */ +-struct ivi_layout_layer * +-ivi_layout_getLayerFromId(uint32_t id_layer); ++ivi_layout_get_id_of_layer(struct ivi_layout_layer *ivilayer); + + /** + * \brief get ivi_layout_surface from id of surface +@@ -233,7 +260,7 @@ ivi_layout_getLayerFromId(uint32_t id_layer); + * \return NULL if the method call was failed + */ + struct ivi_layout_surface * +-ivi_layout_getSurfaceFromId(uint32_t id_surface); ++ivi_layout_get_surface_from_id(uint32_t id_surface); + + /** + * \brief get ivi_layout_screen from id of screen +@@ -243,708 +270,420 @@ ivi_layout_getSurfaceFromId(uint32_t id_surface); + * \return NULL if the method call was failed + */ + struct ivi_layout_screen * +-ivi_layout_getScreenFromId(uint32_t id_screen); ++ivi_layout_get_screen_from_id(uint32_t id_screen); + + /** + * \brief Get the screen resolution of a specific screen + * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed +- */ +-int32_t +-ivi_layout_getScreenResolution(struct ivi_layout_screen *iviscrn, +- int32_t *pWidth, +- int32_t *pHeight); +- +-/** +- * \brief register for notification on property changes of surface +- * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed +- */ +-int32_t +-ivi_layout_surfaceAddNotification(struct ivi_layout_surface *ivisurf, +- surfacePropertyNotificationFunc callback, +- void *userdata); +- +-/** +- * \brief remove notification on property changes of surface +- * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed ++ * \return IVI_SUCCEEDED if the method call was successful ++ * \return IVI_FAILED if the method call was failed + */ + int32_t +-ivi_layout_surfaceRemoveNotification(struct ivi_layout_surface *ivisurf); +- +-/** +- * \brief Create a surface +- * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed +- */ +-/* +-struct ivi_layout_surface * +-ivi_layout_surfaceCreate(struct weston_surface *wl_surface, +- uint32_t id_surface); +-*/ +- +-/** +- * \brief Set the native content of an application to be used as surface content. +- * If wl_surface is NULL, remove the native content of a surface +- * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed +- */ +-/* +-int32_t +-ivi_layout_surfaceSetNativeContent(struct weston_surface *wl_surface, +- uint32_t width, +- uint32_t height, +- uint32_t id_surface); +-*/ ++ivi_layout_get_screen_resolution(struct ivi_layout_screen *iviscrn, ++ int32_t *pWidth, ++ int32_t *pHeight); + + /** + * \brief Set an observer callback for surface content status change. + * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed +- */ +-int32_t +-ivi_layout_surfaceSetContentObserver(struct ivi_layout_surface *ivisurf, +- ivi_controller_surface_content_callback callback, +- void* userdata); +- +-/** +- * \brief initialize ivi_layout_surface dest/source width and height +- */ +-/* +-void +-ivi_layout_surfaceConfigure(struct ivi_layout_surface *ivisurf, +- uint32_t width, uint32_t height); +-*/ +- +-/** +- * \brief Remove a surface +- * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed +- */ +-int32_t +-ivi_layout_surfaceRemove(struct ivi_layout_surface *ivisurf); +- +-/** +- * \brief Set from which kind of devices the surface can accept input events. +- * By default, a surface accept input events from all kind of devices (keyboards, pointer, ...) +- * By calling this function, you can adjust surface preferences. Note that this function only +- * adjust the acceptance for the specified devices. Non specified are keept untouched. +- * +- * Typicall use case for this function is when dealing with pointer or touch events. +- * Those are normally dispatched to the first visible surface below the coordinate. +- * If you want a different behavior (i.e. forward events to an other surface below the coordinate, +- * you can set all above surfaces to refuse input events) +- * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed ++ * \return IVI_SUCCEEDED if the method call was successful ++ * \return IVI_FAILED if the method call was failed + */ + int32_t +-ivi_layout_UpdateInputEventAcceptanceOn(struct ivi_layout_surface *ivisurf, +- int32_t devices, +- int32_t acceptance); ++ivi_layout_surface_set_content_observer( ++ struct ivi_layout_surface *ivisurf, ++ ivi_controller_surface_content_callback callback, ++ void* userdata); + + /** + * \brief Get the layer properties + * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed +- */ +-int32_t +-ivi_layout_getPropertiesOfLayer(struct ivi_layout_layer *ivilayer, +- struct ivi_layout_LayerProperties *pLayerProperties); +- +-/** +- * \brief Get the number of hardware layers of a screen +- * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed ++ * \return (const struct ivi_layout_layer_properties *) ++ * if the method call was successful ++ * \return NULL if the method call was failed + */ +-int32_t +-ivi_layout_getNumberOfHardwareLayers(uint32_t id_screen, +- int32_t *pNumberOfHardwareLayers); ++const struct ivi_layout_layer_properties * ++ivi_layout_get_properties_of_layer(struct ivi_layout_layer *ivilayer); + + /** + * \brief Get the screens + * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed ++ * \return IVI_SUCCEEDED if the method call was successful ++ * \return IVI_FAILED if the method call was failed + */ + int32_t +-ivi_layout_getScreens(int32_t *pLength, struct ivi_layout_screen ***ppArray); ++ivi_layout_get_screens(int32_t *pLength, struct ivi_layout_screen ***ppArray); + + /** + * \brief Get the screens under the given layer + * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed +- */ +-int32_t +-ivi_layout_getScreensUnderLayer(struct ivi_layout_layer *ivilayer, +- int32_t *pLength, +- struct ivi_layout_screen ***ppArray); +- +-/** +- * \brief Get all Layers which are currently registered and managed by the services +- * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed ++ * \return IVI_SUCCEEDED if the method call was successful ++ * \return IVI_FAILED if the method call was failed + */ + int32_t +-ivi_layout_getLayers(int32_t *pLength, struct ivi_layout_layer ***ppArray); ++ivi_layout_get_screens_under_layer(struct ivi_layout_layer *ivilayer, ++ int32_t *pLength, ++ struct ivi_layout_screen ***ppArray); + + /** +- * \brief Get all Layers of the given screen ++ * \brief Get all Layers which are currently registered and managed ++ * by the services + * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed ++ * \return IVI_SUCCEEDED if the method call was successful ++ * \return IVI_FAILED if the method call was failed + */ + int32_t +-ivi_layout_getLayersOnScreen(struct ivi_layout_screen *iviscrn, +- int32_t *pLength, +- struct ivi_layout_layer ***ppArray); ++ivi_layout_get_layers(int32_t *pLength, struct ivi_layout_layer ***ppArray); + + /** + * \brief Get all Layers under the given surface + * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed +- */ +-int32_t +-ivi_layout_getLayersUnderSurface(struct ivi_layout_surface *ivisurf, +- int32_t *pLength, +- struct ivi_layout_layer ***ppArray); +- +-/** +- * \brief Get all Surfaces which are currently registered and managed by the services +- * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed ++ * \return IVI_SUCCEEDED if the method call was successful ++ * \return IVI_FAILED if the method call was failed + */ + int32_t +-ivi_layout_getSurfaces(int32_t *pLength, struct ivi_layout_surface ***ppArray); ++ivi_layout_get_layers_under_surface(struct ivi_layout_surface *ivisurf, ++ int32_t *pLength, ++ struct ivi_layout_layer ***ppArray); + + /** +- * \brief Get all Surfaces which are currently registered to a given layer and are managed by the services ++ * \brief Get all Surfaces which are currently registered and managed ++ * by the services + * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed ++ * \return IVI_SUCCEEDED if the method call was successful ++ * \return IVI_FAILED if the method call was failed + */ + int32_t +-ivi_layout_getSurfacesOnLayer(struct ivi_layout_layer *ivilayer, +- int32_t *pLength, +- struct ivi_layout_surface ***ppArray); ++ivi_layout_get_surfaces(int32_t *pLength, struct ivi_layout_surface ***ppArray); + + /** + * \brief Create a layer which should be managed by the service + * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed ++ * \return (struct ivi_layout_layer *) ++ * if the method call was successful ++ * \return NULL if the method call was failed + */ + struct ivi_layout_layer * +-ivi_layout_layerCreateWithDimension(uint32_t id_layer, +- int32_t width, int32_t height); ++ivi_layout_layer_create_with_dimension(uint32_t id_layer, ++ int32_t width, int32_t height); + + /** + * \brief Removes a layer which is currently managed by the service +- * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed +- */ +-int32_t +-ivi_layout_layerRemove(struct ivi_layout_layer *ivilayer); +- +-/** +- * \brief Get the current type of the layer. +- * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed + */ +-int32_t +-ivi_layout_layerGetType(struct ivi_layout_layer *ivilayer, +- int32_t *pLayerType); +- +-/** +- * \brief Set the visibility of a layer. If a layer is not visible, the layer and its +- * surfaces will not be rendered. +- * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed +- */ +-int32_t +-ivi_layout_layerSetVisibility(struct ivi_layout_layer *ivilayer, +- int32_t newVisibility); ++void ++ivi_layout_layer_remove(struct ivi_layout_layer *ivilayer); + + /** +- * \brief Get the visibility of a layer. If a layer is not visible, the layer and its +- * surfaces will not be rendered. ++ * \brief Set the visibility of a layer. If a layer is not visible, the ++ * layer and its surfaces will not be rendered. + * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed ++ * \return IVI_SUCCEEDED if the method call was successful ++ * \return IVI_FAILED if the method call was failed + */ + int32_t +-ivi_layout_layerGetVisibility(struct ivi_layout_layer *ivilayer, +- int32_t *pVisibility); ++ivi_layout_layer_set_visibility(struct ivi_layout_layer *ivilayer, ++ bool newVisibility); + + /** + * \brief Set the opacity of a layer. + * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed ++ * \return IVI_SUCCEEDED if the method call was successful ++ * \return IVI_FAILED if the method call was failed + */ + int32_t +-ivi_layout_layerSetOpacity(struct ivi_layout_layer *ivilayer, float opacity); ++ivi_layout_layer_set_opacity(struct ivi_layout_layer *ivilayer, ++ wl_fixed_t opacity); + + /** + * \brief Get the opacity of a layer. + * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed ++ * \return opacity if the method call was successful ++ * \return wl_fixed_from_double(0.0) if the method call was failed + */ +-int32_t +-ivi_layout_layerGetOpacity(struct ivi_layout_layer *ivilayer, float *pOpacity); ++wl_fixed_t ++ivi_layout_layer_get_opacity(struct ivi_layout_layer *ivilayer); + + /** + * \brief Set the area of a layer which should be used for the rendering. +- * Only this part will be visible. + * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed +- */ +-int32_t +-ivi_layout_layerSetSourceRectangle(struct ivi_layout_layer *ivilayer, +- int32_t x, int32_t y, +- int32_t width, int32_t height); +- +-/** +- * \brief Set the destination area on the display for a layer. +- * The layer will be scaled and positioned to this rectangle for rendering ++ * Only this part will be visible. + * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed ++ * \return IVI_SUCCEEDED if the method call was successful ++ * \return IVI_FAILED if the method call was failed + */ + int32_t +-ivi_layout_layerSetDestinationRectangle(struct ivi_layout_layer *ivilayer, +- int32_t x, int32_t y, +- int32_t width, int32_t height); ++ivi_layout_layer_set_source_rectangle(struct ivi_layout_layer *ivilayer, ++ int32_t x, int32_t y, ++ int32_t width, int32_t height); + + /** +- * \brief Get the horizontal and vertical dimension of the layer. ++ * \brief Set the destination area on the display for a layer. + * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed +- */ +-int32_t +-ivi_layout_layerGetDimension(struct ivi_layout_layer *ivilayer, +- int32_t *pDimension); +- +-/** +- * \brief Set the horizontal and vertical dimension of the layer. ++ * The layer will be scaled and positioned to this rectangle ++ * for rendering + * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed ++ * \return IVI_SUCCEEDED if the method call was successful ++ * \return IVI_FAILED if the method call was failed + */ + int32_t +-ivi_layout_layerSetDimension(struct ivi_layout_layer *ivilayer, +- int32_t *pDimension); ++ivi_layout_layer_set_destination_rectangle(struct ivi_layout_layer *ivilayer, ++ int32_t x, int32_t y, ++ int32_t width, int32_t height); + + /** + * \brief Get the horizontal and vertical position of the layer. + * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed ++ * \return IVI_SUCCEEDED if the method call was successful ++ * \return IVI_FAILED if the method call was failed + */ + int32_t +-ivi_layout_layerGetPosition(struct ivi_layout_layer *ivilayer, +- int32_t *pPosition); ++ivi_layout_layer_get_position(struct ivi_layout_layer *ivilayer, ++ int32_t *dest_x, int32_t *dest_y); + + /** + * \brief Sets the horizontal and vertical position of the layer. + * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed ++ * \return IVI_SUCCEEDED if the method call was successful ++ * \return IVI_FAILED if the method call was failed + */ + int32_t +-ivi_layout_layerSetPosition(struct ivi_layout_layer *ivilayer, +- int32_t *pPosition); ++ivi_layout_layer_set_position(struct ivi_layout_layer *ivilayer, ++ int32_t dest_x, int32_t dest_y); + + /** + * \brief Sets the orientation of a layer. + * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed +- */ +-int32_t +-ivi_layout_layerSetOrientation(struct ivi_layout_layer *ivilayer, +- int32_t orientation); +- +-/** +- * \brief Gets the orientation of a layer. +- * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed ++ * \return IVI_SUCCEEDED if the method call was successful ++ * \return IVI_FAILED if the method call was failed + */ + int32_t +-ivi_layout_layerGetOrientation(struct ivi_layout_layer *ivilayer, +- int32_t *pOrientation); +- +-/** +- * \brief Sets the color value which defines the transparency value. +- * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed +- */ +-int32_t +-ivi_layout_layerSetChromaKey(struct ivi_layout_layer *ivilayer, +- int32_t* pColor); ++ivi_layout_layer_set_orientation(struct ivi_layout_layer *ivilayer, ++ enum wl_output_transform orientation); + + /** + * \brief Sets render order of surfaces within one layer + * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed +- */ +-int32_t +-ivi_layout_layerSetRenderOrder(struct ivi_layout_layer *ivilayer, +- struct ivi_layout_surface **pSurface, +- int32_t number); +- +-/** +- * \brief Get the capabilities of a layer +- * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed +- */ +-int32_t +-ivi_layout_layerGetCapabilities(struct ivi_layout_layer *ivilayer, +- int32_t *pCapabilities); +- +-/** +- * \brief Get the possible capabilities of a layertype +- * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed +- */ +-int32_t +-ivi_layout_layerTypeGetCapabilities(int32_t layerType, +- int32_t *pCapabilities); +- +-/** +- * \brief Create the logical surface, which has no native buffer associated +- * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed ++ * \return IVI_SUCCEEDED if the method call was successful ++ * \return IVI_FAILED if the method call was failed + */ + int32_t +-ivi_layout_surfaceInitialize(struct ivi_layout_surface **pSurface); ++ivi_layout_layer_set_render_order(struct ivi_layout_layer *ivilayer, ++ struct ivi_layout_surface **pSurface, ++ int32_t number); + + /** + * \brief Set the visibility of a surface. +- * If a surface is not visible it will not be rendered. + * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed ++ * If a surface is not visible it will not be rendered. ++ * ++ * \return IVI_SUCCEEDED if the method call was successful ++ * \return IVI_FAILED if the method call was failed + */ + int32_t +-ivi_layout_surfaceSetVisibility(struct ivi_layout_surface *ivisurf, +- int32_t newVisibility); ++ivi_layout_surface_set_visibility(struct ivi_layout_surface *ivisurf, ++ bool newVisibility); + + /** + * \brief Get the visibility of a surface. +- * If a surface is not visible it will not be rendered. + * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed ++ * If a surface is not visible it will not be rendered. ++ * ++ * \return true if surface is visible ++ * \return false if surface is invisible or the method call was failed + */ +-int32_t +-ivi_layout_surfaceGetVisibility(struct ivi_layout_surface *ivisurf, +- int32_t *pVisibility); ++bool ++ivi_layout_surface_get_visibility(struct ivi_layout_surface *ivisurf); + + /** + * \brief Set the opacity of a surface. + * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed ++ * \return IVI_SUCCEEDED if the method call was successful ++ * \return IVI_FAILED if the method call was failed + */ + int32_t +-ivi_layout_surfaceSetOpacity(struct ivi_layout_surface *ivisurf, +- float opacity); ++ivi_layout_surface_set_opacity(struct ivi_layout_surface *ivisurf, ++ wl_fixed_t opacity); + + /** + * \brief Get the opacity of a surface. + * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed +- */ +-int32_t +-ivi_layout_surfaceGetOpacity(struct ivi_layout_surface *ivisurf, +- float *pOpacity); +- +-/** +- * \brief Set the keyboard focus on a certain surface +- * To receive keyboard events, 2 conditions must be fulfilled: +- * 1- The surface must accept events from keyboard. See ilm_UpdateInputEventAcceptanceOn +- * 2- The keyboard focus must be set on that surface +- * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed ++ * \return opacity if the method call was successful ++ * \return wl_fixed_from_double(0.0) if the method call was failed + */ +-int32_t +-ivi_layout_SetKeyboardFocusOn(struct ivi_layout_surface *ivisurf); +- +-/** +- * \brief Get the indentifier of the surface which hold the keyboard focus +- * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed +- */ +-int32_t +-ivi_layout_GetKeyboardFocusSurfaceId(struct ivi_layout_surface **pSurfaceId); ++wl_fixed_t ++ivi_layout_surface_get_opacity(struct ivi_layout_surface *ivisurf); + + /** + * \brief Set the destination area of a surface within a layer for rendering. +- * The surface will be scaled to this rectangle for rendering. + * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed +- */ +-int32_t +-ivi_layout_surfaceSetDestinationRectangle(struct ivi_layout_surface *ivisurf, +- int32_t x, int32_t y, +- int32_t width, int32_t height); +- +-/** +- * \brief Set the horizontal and vertical dimension of the surface. ++ * The surface will be scaled to this rectangle for rendering. + * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed ++ * \return IVI_SUCCEEDED if the method call was successful ++ * \return IVI_FAILED if the method call was failed + */ + int32_t +-ivi_layout_surfaceSetDimension(struct ivi_layout_surface *ivisurf, +- int32_t *pDimension); +- +-/** +- * \brief Get the horizontal and vertical dimension of the surface. +- * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed +- */ +-int32_t +-ivi_layout_surfaceGetDimension(struct ivi_layout_surface *ivisurf, +- int32_t *pDimension); +- +-/** +- * \brief Sets the horizontal and vertical position of the surface. +- * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed +- */ +-int32_t +-ivi_layout_surfaceSetPosition(struct ivi_layout_surface *ivisurf, +- int32_t *pPosition); +- +-/** +- * \brief Get the horizontal and vertical position of the surface. +- * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed +- */ +-int32_t +-ivi_layout_surfaceGetPosition(struct ivi_layout_surface *ivisurf, +- int32_t *pPosition); ++ivi_layout_surface_set_destination_rectangle(struct ivi_layout_surface *ivisurf, ++ int32_t x, int32_t y, ++ int32_t width, int32_t height); + + /** + * \brief Sets the orientation of a surface. + * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed ++ * \return IVI_SUCCEEDED if the method call was successful ++ * \return IVI_FAILED if the method call was failed + */ + int32_t +-ivi_layout_surfaceSetOrientation(struct ivi_layout_surface *ivisurf, +- int32_t orientation); +- +-/** +- * \brief Gets the orientation of a surface. +- * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed +- */ +-int32_t +-ivi_layout_surfaceGetOrientation(struct ivi_layout_surface *ivisurf, +- int32_t *pOrientation); +- +-/** +- * \brief Gets the pixelformat of a surface. +- * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed +- */ +-int32_t +-ivi_layout_surfaceGetPixelformat(struct ivi_layout_layer *ivisurf, +- int32_t *pPixelformat); +- +-/** +- * \brief Sets the color value which defines the transparency value of a surface. +- * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed +- */ +-int32_t +-ivi_layout_surfaceSetChromaKey(struct ivi_layout_surface *ivisurf, +- int32_t* pColor); ++ivi_layout_surface_set_orientation(struct ivi_layout_surface *ivisurf, ++ enum wl_output_transform orientation); + + /** + * \brief Add a layer to a screen which is currently managed by the service + * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed ++ * \return IVI_SUCCEEDED if the method call was successful ++ * \return IVI_FAILED if the method call was failed + */ + int32_t +-ivi_layout_screenAddLayer(struct ivi_layout_screen *iviscrn, +- struct ivi_layout_layer *addlayer); ++ivi_layout_screen_add_layer(struct ivi_layout_screen *iviscrn, ++ struct ivi_layout_layer *addlayer); + + /** + * \brief Sets render order of layers on a display + * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed ++ * \return IVI_SUCCEEDED if the method call was successful ++ * \return IVI_FAILED if the method call was failed + */ + int32_t +-ivi_layout_screenSetRenderOrder(struct ivi_layout_screen *iviscrn, +- struct ivi_layout_layer **pLayer, +- const int32_t number); ++ivi_layout_screen_set_render_order(struct ivi_layout_screen *iviscrn, ++ struct ivi_layout_layer **pLayer, ++ const int32_t number); + + /** +- * \brief Enable or disable a rendering optimization ++ * \brief register for notification on property changes of layer + * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed ++ * \return IVI_SUCCEEDED if the method call was successful ++ * \return IVI_FAILED if the method call was failed + */ + int32_t +-ivi_layout_SetOptimizationMode(uint32_t id, int32_t mode); ++ivi_layout_layer_add_notification(struct ivi_layout_layer *ivilayer, ++ layer_property_notification_func callback, ++ void *userdata); + + /** +- * \brief Get the current enablement for an optimization +- * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed ++ * \brief remove notification on property changes of layer + */ +-int32_t +-ivi_layout_GetOptimizationMode(uint32_t id, int32_t *pMode); ++void ++ivi_layout_layer_remove_notification(struct ivi_layout_layer *ivilayer); + + /** +- * \brief register for notification on property changes of layer ++ * \brief register for notification on property changes of surface + * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed ++ * \return IVI_SUCCEEDED if the method call was successful ++ * \return IVI_FAILED if the method call was failed + */ + int32_t +-ivi_layout_layerAddNotification(struct ivi_layout_layer *ivilayer, +- layerPropertyNotificationFunc callback, +- void *userdata); ++ivi_layout_surface_add_notification(struct ivi_layout_surface *ivisurf, ++ surface_property_notification_func callback, ++ void *userdata); + + /** +- * \brief remove notification on property changes of layer +- * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed ++ * \brief remove notification on property changes of surface + */ +-int32_t +-ivi_layout_layerRemoveNotification(struct ivi_layout_layer *ivilayer); ++void ++ivi_layout_surface_remove_notification(struct ivi_layout_surface *ivisurf); + + /** + * \brief Get the surface properties + * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed ++ * \return (const struct ivi_surface_layer_properties *) ++ * if the method call was successful ++ * \return NULL if the method call was failed + */ +-int32_t +-ivi_layout_getPropertiesOfSurface(struct ivi_layout_surface *ivisurf, +- struct ivi_layout_SurfaceProperties *pSurfaceProperties); ++const struct ivi_layout_surface_properties * ++ivi_layout_get_properties_of_surface(struct ivi_layout_surface *ivisurf); + + /** + * \brief Add a surface to a layer which is currently managed by the service + * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed ++ * \return IVI_SUCCEEDED if the method call was successful ++ * \return IVI_FAILED if the method call was failed + */ + int32_t +-ivi_layout_layerAddSurface(struct ivi_layout_layer *ivilayer, +- struct ivi_layout_surface *addsurf); ++ivi_layout_layer_add_surface(struct ivi_layout_layer *ivilayer, ++ struct ivi_layout_surface *addsurf); + + /** + * \brief Removes a surface from a layer which is currently managed by the service +- * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed + */ +-int32_t +-ivi_layout_layerRemoveSurface(struct ivi_layout_layer *ivilayer, +- struct ivi_layout_surface *remsurf); ++void ++ivi_layout_layer_remove_surface(struct ivi_layout_layer *ivilayer, ++ struct ivi_layout_surface *remsurf); + + /** + * \brief Set the area of a surface which should be used for the rendering. + * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed ++ * \return IVI_SUCCEEDED if the method call was successful ++ * \return IVI_FAILED if the method call was failed + */ + int32_t +-ivi_layout_surfaceSetSourceRectangle(struct ivi_layout_surface *ivisurf, +- int32_t x, int32_t y, +- int32_t width, int32_t height); ++ivi_layout_surface_set_source_rectangle(struct ivi_layout_surface *ivisurf, ++ int32_t x, int32_t y, ++ int32_t width, int32_t height); + + /** + * \brief get weston_output from ivi_layout_screen. + * +- * \return (struct weston_screen *) ++ * \return (struct weston_output *) + * if the method call was successful + * \return NULL if the method call was failed + */ + struct weston_output * +-ivi_layout_screenGetOutput(struct ivi_layout_screen *); ++ivi_layout_screen_get_output(struct ivi_layout_screen *); + + struct weston_surface * +-ivi_layout_surfaceGetWestonSurface(struct ivi_layout_surface *ivisurf); ++ivi_layout_surface_get_weston_surface(struct ivi_layout_surface *ivisurf); + + int32_t +-ivi_layout_surfaceGetSize(struct ivi_layout_surface *ivisurf, int32_t *width, int32_t *height, int32_t *stride); ++ivi_layout_surface_get_size(struct ivi_layout_surface *ivisurf, ++ int32_t *width, ++ int32_t *height, ++ int32_t *stride); + + int32_t +-ivi_layout_layerSetTransition(struct ivi_layout_layer *ivilayer, +- enum ivi_layout_transition_type type, +- uint32_t duration); ++ivi_layout_layer_set_transition(struct ivi_layout_layer *ivilayer, ++ enum ivi_layout_transition_type type, ++ uint32_t duration); + + int32_t +-ivi_layout_layerSetFadeInfo(struct ivi_layout_layer* layer, +- uint32_t is_fade_in, +- double start_alpha, double end_alpha); ++ivi_layout_layer_set_fade_info(struct ivi_layout_layer* layer, ++ uint32_t is_fade_in, ++ double start_alpha, double end_alpha); + + int32_t +-ivi_layout_surfaceSetTransition(struct ivi_layout_surface *ivisurf, +- enum ivi_layout_transition_type type, +- uint32_t duration); ++ivi_layout_surface_set_transition(struct ivi_layout_surface *ivisurf, ++ enum ivi_layout_transition_type type, ++ uint32_t duration); + +-int32_t +-ivi_layout_surfaceSetTransitionDuration(struct ivi_layout_surface *ivisurf,uint32_t duration); ++void ++ivi_layout_transition_layer_render_order(struct ivi_layout_layer* layer, ++ struct ivi_layout_surface** new_order, ++ uint32_t surface_num, ++ uint32_t duration); ++ ++void ++ivi_layout_transition_move_layer_cancel(struct ivi_layout_layer* layer); + + /** +- * \brief Commit all changes and execute all enqueued commands since last commit. ++ * \brief Commit all changes and execute all enqueued commands since ++ * last commit. + * +- * \return 0 if the method call was successful +- * \return -1 if the method call was failed ++ * \return IVI_SUCCEEDED if the method call was successful ++ * \return IVI_FAILED if the method call was failed + */ + int32_t +-ivi_layout_commitChanges(void); ++ivi_layout_commit_changes(void); + + #ifdef __cplusplus +-} /**/ ++} + #endif /* __cplusplus */ + + #endif /* _IVI_LAYOUT_EXPORT_H_ */ +diff --git a/weston-ivi-shell/src/ivi-layout.h b/weston-ivi-shell/src/ivi-layout.h +deleted file mode 100644 +index 7a53733..0000000 +--- a/weston-ivi-shell/src/ivi-layout.h ++++ /dev/null +@@ -1,147 +0,0 @@ +-/* +- * Copyright (C) 2013 DENSO CORPORATION +- * +- * Permission to use, copy, modify, distribute, and sell this software and +- * its documentation for any purpose is hereby granted without fee, provided +- * that the above copyright notice appear in all copies and that both that +- * copyright notice and this permission notice appear in supporting +- * documentation, and that the name of the copyright holders not be used in +- * advertising or publicity pertaining to distribution of the software +- * without specific, written prior permission. The copyright holders make +- * no representations about the suitability of this software for any +- * purpose. It is provided "as is" without express or implied warranty. +- * +- * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS +- * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND +- * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY +- * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER +- * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF +- * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN +- * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +- */ +- +-/** +- * The ivi-layout library supports API set of controlling properties of +- * surface and layer which groups surfaces. An unique ID whose type is integer +- * is required to create surface and layer. With the unique ID, surface and +- * layer are identified to control them. The API set consists of APIs to control +- * properties of surface and layers about followings, +- * - visibility. +- * - opacity. +- * - clipping (x,y,width,height). +- * - position and size of it to be displayed. +- * - orientation per 90 degree. +- * - add or remove surfaces to a layer. +- * - order of surfaces/layers in layer/screen to be displayed. +- * - commit to apply property changes. +- * - notifications of property change. +- * +- * Management of surfaces and layers grouping these surfaces are common way in +- * In-Vehicle Infotainment system, which integrate several domains in one system. +- * A layer is allocated to a domain in order to control application surfaces +- * grouped to the layer all together. +- */ +- +-#ifndef _IVI_LAYOUT_H_ +-#define _IVI_LAYOUT_H_ +- +-#ifdef __cplusplus +-extern "C" { +-#endif /* __cplusplus */ +- +-#include "compositor.h" +- +-struct ivi_layout_surface; +-struct ivi_layout_layer; +-struct ivi_layout_screen; +- +-struct ivi_layout_SurfaceProperties +-{ +- float opacity; +- uint32_t sourceX; +- uint32_t sourceY; +- uint32_t sourceWidth; +- uint32_t sourceHeight; +- uint32_t origSourceWidth; +- uint32_t origSourceHeight; +- int32_t startX; +- int32_t startY; +- uint32_t startWidth; +- uint32_t startHeight; +- int32_t destX; +- int32_t destY; +- uint32_t destWidth; +- uint32_t destHeight; +- uint32_t orientation; +- uint32_t visibility; +- uint32_t frameCounter; +- uint32_t drawCounter; +- uint32_t updateCounter; +- uint32_t pixelformat; +- uint32_t nativeSurface; +- uint32_t inputDevicesAcceptance; +- uint32_t chromaKeyEnabled; +- uint32_t chromaKeyRed; +- uint32_t chromaKeyGreen; +- uint32_t chromaKeyBlue; +- int32_t creatorPid; +- int32_t transitionType; +- uint32_t transitionDuration; +- uint32_t hasKeyboardFocus; +-}; +- +-struct ivi_layout_LayerProperties +-{ +- float opacity; +- uint32_t sourceX; +- uint32_t sourceY; +- uint32_t sourceWidth; +- uint32_t sourceHeight; +- uint32_t origSourceWidth; +- uint32_t origSourceHeight; +- int32_t destX; +- int32_t destY; +- uint32_t destWidth; +- uint32_t destHeight; +- uint32_t orientation; +- uint32_t visibility; +- uint32_t type; +- uint32_t chromaKeyEnabled; +- uint32_t chromaKeyRed; +- uint32_t chromaKeyGreen; +- uint32_t chromaKeyBlue; +- int32_t creatorPid; +- int32_t transitionType; +- uint32_t transitionDuration; +- double startAlpha; +- double endAlpha; +- uint32_t isFadeIn; +-}; +- +-enum ivi_layout_warning_flag { +- IVI_WARNING_INVALID_WL_SURFACE, +- IVI_WARNING_IVI_ID_IN_USE +-}; +- +-struct ivi_layout_interface { +- struct weston_view* (*get_weston_view)(struct ivi_layout_surface *surface); +- void (*surfaceConfigure)(struct ivi_layout_surface *ivisurf, +- int32_t width, int32_t height); +- int32_t (*surfaceSetNativeContent)(struct weston_surface *wl_surface, +- int32_t width, +- int32_t height, +- uint32_t id_surface); +- struct ivi_layout_surface* (*surfaceCreate)(struct weston_surface *wl_surface, +- uint32_t id_surface); +- void (*initWithCompositor)(struct weston_compositor *ec); +- void (*emitWarningSignal)(uint32_t id_surface, +- enum ivi_layout_warning_flag flag); +-}; +- +-WL_EXPORT struct ivi_layout_interface ivi_layout_interface; +- +-#ifdef __cplusplus +-} /**/ +-#endif /* __cplusplus */ +- +-#endif /* _IVI_LAYOUT_H_ */ diff --git a/meta-ivi/recipes-graphics/wayland/wayland-ivi-extension_1.3.0.bb b/meta-ivi/recipes-graphics/wayland/wayland-ivi-extension_1.3.0.bb index c8f9ca8..f7d8d0a 100644 --- a/meta-ivi/recipes-graphics/wayland/wayland-ivi-extension_1.3.0.bb +++ b/meta-ivi/recipes-graphics/wayland/wayland-ivi-extension_1.3.0.bb @@ -10,11 +10,15 @@ DEPENDS = "weston" # FIX ME # This should be TAG = "${PV}" but yocto doesn't support lightweight tags for now # https://bugzilla.yoctoproject.org/show_bug.cgi?id=6881 -TAG = "a4bde3e5a4c21ff7cf28cc027d45d7c63cac2f66" +#TAG = "a4bde3e5a4c21ff7cf28cc027d45d7c63cac2f66" +TAG = "1.3.91" SRC_URI = "git://git.projects.genivi.org/${PN}.git;tag=${TAG} \ file://use_sysroot_dir.patch \ - file://fix_compositor_include.patch \ + file://apply_weston-1.6.x.patch \ " +#" +# file://fix_compositor_include.patch \ +#" S = "${WORKDIR}/git" inherit cmake autotools |