Efl.Canvas.Scene (from Efl.Canvas)

Ref https://phab.enlightenment.org/T6847

Reviewed-by: Cedric Bail <cedric@osg.samsung.com>

29 files changed, 141 insertions, 141 deletions

diff --git a/src/Makefile_Efl.am b/src/Makefile_Efl.am
index 469b76a336..8994e25186 100644
--- a/src/Makefile_Efl.am
+++ b/src/Makefile_Efl.am
@@ -16,7 +16,7 @@ efl_eolian_legacy_files = \
         $(NULL)
 
 efl_eolian_files = \
-      lib/efl/interfaces/efl_canvas.eo \
+      lib/efl/interfaces/efl_canvas_scene.eo \
       lib/efl/interfaces/efl_canvas_pointer.eo \
       lib/efl/interfaces/efl_config.eo \
       lib/efl/interfaces/efl_control.eo \
diff --git a/src/bin/elementary/test_evas_snapshot.c b/src/bin/elementary/test_evas_snapshot.c
index 9eb5dca932..dd9e15388f 100644
--- a/src/bin/elementary/test_evas_snapshot.c
+++ b/src/bin/elementary/test_evas_snapshot.c
@@ -55,7 +55,7 @@ _render_post(void *data, const Efl_Event *ev)
 {
    Eo *snap = data;
 
-   efl_event_callback_del(ev->object, EFL_CANVAS_EVENT_RENDER_POST, _render_post, data);
+   efl_event_callback_del(ev->object, EFL_CANVAS_SCENE_EVENT_RENDER_POST, _render_post, data);
    efl_file_save(snap, eina_slstr_printf("%s/snap-efl.png", eina_environment_tmp_get()), NULL, NULL);
 }
 
@@ -67,7 +67,7 @@ _save_image(void *data, const Efl_Event *ev EINA_UNUSED)
 
    // Save is available only during render_post
    snap = efl_key_wref_get(win, "snap");
-   efl_event_callback_add(win, EFL_CANVAS_EVENT_RENDER_POST, _render_post, snap);
+   efl_event_callback_add(win, EFL_CANVAS_SCENE_EVENT_RENDER_POST, _render_post, snap);
 
    // Force a render in order to ensure post_render is called. EO API provides
    // no way to do manual render, so we add a damage to the snapshot object.
diff --git a/src/examples/ecore/ecore_evas_cursor_example.c b/src/examples/ecore/ecore_evas_cursor_example.c
index a40ad3c0bc..cbf7dfc32d 100644
--- a/src/examples/ecore/ecore_evas_cursor_example.c
+++ b/src/examples/ecore/ecore_evas_cursor_example.c
@@ -202,7 +202,7 @@ main(int argc EINA_UNUSED, char *argv[] EINA_UNUSED)
      }
 
    t = ecore_timer_add(TIMEOUT, _mouse_pos_print, ee);
-   efl_event_callback_add(e, EFL_CANVAS_EVENT_DEVICE_ADDED,
+   efl_event_callback_add(e, EFL_CANVAS_SCENE_EVENT_DEVICE_ADDED,
                           _device_added, ee);
    ecore_evas_callback_resize_set(ee, _resize_cb);
    ecore_evas_callback_delete_request_set(ee, _delete_request_cb);
diff --git a/src/examples/ecore/ecore_evas_vnc_example.c b/src/examples/ecore/ecore_evas_vnc_example.c
index 0f06c62d3e..c3d1ac7cfd 100644
--- a/src/examples/ecore/ecore_evas_vnc_example.c
+++ b/src/examples/ecore/ecore_evas_vnc_example.c
@@ -188,7 +188,7 @@ _dev_added_or_removed(void *data EINA_UNUSED, const Efl_Event *event)
           efl_name_get(dev),
           _device_type_to_string(efl_input_device_type_get(dev)),
           efl_comment_get(dev),
-          event->desc == EFL_CANVAS_EVENT_DEVICE_ADDED ? "added" : "removed");
+          event->desc == EFL_CANVAS_SCENE_EVENT_DEVICE_ADDED ? "added" : "removed");
 
    if (efl_input_device_type_get(dev) == EFL_INPUT_DEVICE_TYPE_SEAT)
      _seat_children_print(dev);
@@ -301,9 +301,9 @@ main(int argc, char *argv[])
                                         _mouse_wheel, NULL);
 
    _seat_children_print(evas_default_device_get(evas, EFL_INPUT_DEVICE_TYPE_SEAT));
-   efl_event_callback_add(evas, EFL_CANVAS_EVENT_DEVICE_ADDED,
+   efl_event_callback_add(evas, EFL_CANVAS_SCENE_EVENT_DEVICE_ADDED,
                           _dev_added_or_removed, NULL);
-   efl_event_callback_add(evas, EFL_CANVAS_EVENT_DEVICE_REMOVED,
+   efl_event_callback_add(evas, EFL_CANVAS_SCENE_EVENT_DEVICE_REMOVED,
                           _dev_added_or_removed, NULL);
    ecore_main_loop_begin();
 
diff --git a/src/examples/ecore/ecore_evas_wayland_multiseat_example.c b/src/examples/ecore/ecore_evas_wayland_multiseat_example.c
index 5b21a88e39..3aec0fa524 100644
--- a/src/examples/ecore/ecore_evas_wayland_multiseat_example.c
+++ b/src/examples/ecore/ecore_evas_wayland_multiseat_example.c
@@ -106,7 +106,7 @@ _dev_added_or_removed(void *data, const Efl_Event *event)
           dev, efl_name_get(dev),
           _device_type_to_string(efl_input_device_type_get(dev)),
           efl_comment_get(dev),
-          event->desc == EFL_CANVAS_EVENT_DEVICE_ADDED ? "added" : "removed",
+          event->desc == EFL_CANVAS_SCENE_EVENT_DEVICE_ADDED ? "added" : "removed",
           data);
 }
 
@@ -197,18 +197,18 @@ main(int argc EINA_UNUSED, char *argv[] EINA_UNUSED)
    mouse_wheel = ecore_event_handler_add(ECORE_EVENT_MOUSE_WHEEL,
                                         _mouse_wheel, NULL);
 
-   efl_event_callback_add(evas1, EFL_CANVAS_EVENT_DEVICE_ADDED,
+   efl_event_callback_add(evas1, EFL_CANVAS_SCENE_EVENT_DEVICE_ADDED,
                           _dev_added_or_removed, ee1);
-   efl_event_callback_add(evas1, EFL_CANVAS_EVENT_DEVICE_REMOVED,
+   efl_event_callback_add(evas1, EFL_CANVAS_SCENE_EVENT_DEVICE_REMOVED,
                           _dev_added_or_removed, ee1);
-   efl_event_callback_add(evas1, EFL_CANVAS_EVENT_DEVICE_CHANGED,
+   efl_event_callback_add(evas1, EFL_CANVAS_SCENE_EVENT_DEVICE_CHANGED,
                           _dev_changed, ee1);
 
-   efl_event_callback_add(evas2, EFL_CANVAS_EVENT_DEVICE_ADDED,
+   efl_event_callback_add(evas2, EFL_CANVAS_SCENE_EVENT_DEVICE_ADDED,
                           _dev_added_or_removed, ee2);
-   efl_event_callback_add(evas2, EFL_CANVAS_EVENT_DEVICE_REMOVED,
+   efl_event_callback_add(evas2, EFL_CANVAS_SCENE_EVENT_DEVICE_REMOVED,
                           _dev_added_or_removed, ee2);
-   efl_event_callback_add(evas2, EFL_CANVAS_EVENT_DEVICE_CHANGED,
+   efl_event_callback_add(evas2, EFL_CANVAS_SCENE_EVENT_DEVICE_CHANGED,
                           _dev_changed, ee2);
 
    ecore_main_loop_begin();
diff --git a/src/examples/edje/edje-multiseat-custom-names.c b/src/examples/edje/edje-multiseat-custom-names.c
index ce1342bbb2..9da96b8371 100644
--- a/src/examples/edje/edje-multiseat-custom-names.c
+++ b/src/examples/edje/edje-multiseat-custom-names.c
@@ -123,9 +123,9 @@ main(int argc EINA_UNUSED, char *argv[] EINA_UNUSED)
         if (efl_input_device_type_get(dev) == EFL_INPUT_DEVICE_TYPE_SEAT)
           _device_rename(dev);
      }
-   efl_event_callback_add(evas, EFL_CANVAS_EVENT_DEVICE_ADDED,
+   efl_event_callback_add(evas, EFL_CANVAS_SCENE_EVENT_DEVICE_ADDED,
                           _device_added, NULL);
-   efl_event_callback_add(evas, EFL_CANVAS_EVENT_DEVICE_CHANGED,
+   efl_event_callback_add(evas, EFL_CANVAS_SCENE_EVENT_DEVICE_CHANGED,
                           _device_changed, NULL);
 
    printf("Running example on evas engine %s\n",
diff --git a/src/examples/edje/edje-multiseat-filter.c b/src/examples/edje/edje-multiseat-filter.c
index 5cf59d69b2..92a7e7c7b6 100644
--- a/src/examples/edje/edje-multiseat-filter.c
+++ b/src/examples/edje/edje-multiseat-filter.c
@@ -108,7 +108,7 @@ main(int argc EINA_UNUSED, char *argv[] EINA_UNUSED)
           efl_canvas_object_seat_focus_add(edje_obj, dev);
 
      }
-   efl_event_callback_add(evas, EFL_CANVAS_EVENT_DEVICE_ADDED,
+   efl_event_callback_add(evas, EFL_CANVAS_SCENE_EVENT_DEVICE_ADDED,
                           _device_added, edje_obj);
 
    ecore_evas_show(ee);
diff --git a/src/examples/edje/edje-multiseat.c b/src/examples/edje/edje-multiseat.c
index a6cd6c0e72..18abfec743 100644
--- a/src/examples/edje/edje-multiseat.c
+++ b/src/examples/edje/edje-multiseat.c
@@ -255,7 +255,7 @@ main(int argc EINA_UNUSED, char *argv[] EINA_UNUSED)
           efl_canvas_object_seat_focus_add(edje_obj, dev);
 
      }
-   efl_event_callback_add(evas, EFL_CANVAS_EVENT_DEVICE_ADDED,
+   efl_event_callback_add(evas, EFL_CANVAS_SCENE_EVENT_DEVICE_ADDED,
                           _device_added, edje_obj);
    evas_object_event_callback_add(edje_obj, EVAS_CALLBACK_KEY_DOWN,
                                   _on_key_down, evas);
diff --git a/src/examples/evas/evas-event-filter.c b/src/examples/evas/evas-event-filter.c
index 530aba9b5a..dc25750871 100644
--- a/src/examples/evas/evas-event-filter.c
+++ b/src/examples/evas/evas-event-filter.c
@@ -165,7 +165,7 @@ _device_added_removed_cb(void *data, const Efl_Event *event)
    if (efl_input_device_type_get(dev) != EFL_INPUT_DEVICE_TYPE_SEAT)
      return;
 
-   if (event->desc == EFL_CANVAS_EVENT_DEVICE_ADDED)
+   if (event->desc == EFL_CANVAS_SCENE_EVENT_DEVICE_ADDED)
      {
         if (ctx->allowed_seat)
           efl_input_seat_event_filter_set(ctx->filtered_obj,
@@ -180,8 +180,8 @@ _device_added_removed_cb(void *data, const Efl_Event *event)
 }
 
 EFL_CALLBACKS_ARRAY_DEFINE(_device_callbacks,
-                           { EFL_CANVAS_EVENT_DEVICE_ADDED, _device_added_removed_cb },
-                           { EFL_CANVAS_EVENT_DEVICE_REMOVED, _device_added_removed_cb });
+                           { EFL_CANVAS_SCENE_EVENT_DEVICE_ADDED, _device_added_removed_cb },
+                           { EFL_CANVAS_SCENE_EVENT_DEVICE_REMOVED, _device_added_removed_cb });
 
 EFL_CALLBACKS_ARRAY_DEFINE(_obj_callbacks,
                            { EFL_EVENT_FOCUS_IN, _obj_events_cb },
diff --git a/src/examples/evas/evas-multiseat-events.c b/src/examples/evas/evas-multiseat-events.c
index c0659f06ff..bc99bd3246 100644
--- a/src/examples/evas/evas-multiseat-events.c
+++ b/src/examples/evas/evas-multiseat-events.c
@@ -212,15 +212,15 @@ _dev_added_or_removed(void *data EINA_UNUSED, const Efl_Event *event)
    printf("The seat '%s' - description: '%s' was '%s'\n",
           efl_name_get(dev),
           efl_comment_get(dev),
-          event->desc == EFL_CANVAS_EVENT_DEVICE_ADDED ? "added" : "removed");
+          event->desc == EFL_CANVAS_SCENE_EVENT_DEVICE_ADDED ? "added" : "removed");
 }
 
 EFL_CALLBACKS_ARRAY_DEFINE(canvas_callbacks,
-                           { EFL_CANVAS_EVENT_OBJECT_FOCUS_IN,
+                           { EFL_CANVAS_SCENE_EVENT_OBJECT_FOCUS_IN,
                            _canvas_focus_in_cb },
-                           { EFL_CANVAS_EVENT_DEVICE_ADDED,
+                           { EFL_CANVAS_SCENE_EVENT_DEVICE_ADDED,
                            _dev_added_or_removed },
-                           { EFL_CANVAS_EVENT_DEVICE_REMOVED,
+                           { EFL_CANVAS_SCENE_EVENT_DEVICE_REMOVED,
                            _dev_added_or_removed });
 
 EFL_CALLBACKS_ARRAY_DEFINE(callbacks,
diff --git a/src/lib/ecore_evas/ecore_evas.c b/src/lib/ecore_evas/ecore_evas.c
index 915945c7e4..1866d48676 100644
--- a/src/lib/ecore_evas/ecore_evas.c
+++ b/src/lib/ecore_evas/ecore_evas.c
@@ -372,7 +372,7 @@ _ecore_evas_dev_added_or_removed(void *data, const Efl_Event *event)
 {
    Ecore_Evas *ee = data;
 
-   if (event->desc == EFL_CANVAS_EVENT_DEVICE_ADDED)
+   if (event->desc == EFL_CANVAS_SCENE_EVENT_DEVICE_ADDED)
      {
         if (_is_pointer(event->info))
           _ecore_evas_cursor_add(ee, event->info);
@@ -402,8 +402,8 @@ _ecore_evas_dev_added_or_removed(void *data, const Efl_Event *event)
 }
 
 EFL_CALLBACKS_ARRAY_DEFINE(_ecore_evas_device_cbs,
-                           { EFL_CANVAS_EVENT_DEVICE_ADDED, _ecore_evas_dev_added_or_removed },
-                           { EFL_CANVAS_EVENT_DEVICE_REMOVED, _ecore_evas_dev_added_or_removed });
+                           { EFL_CANVAS_SCENE_EVENT_DEVICE_ADDED, _ecore_evas_dev_added_or_removed },
+                           { EFL_CANVAS_SCENE_EVENT_DEVICE_REMOVED, _ecore_evas_dev_added_or_removed });
 Eina_Bool
 _ecore_evas_cursors_init(Ecore_Evas *ee)
 {
diff --git a/src/lib/edje/edje_entry.c b/src/lib/edje/edje_entry.c
index 26c599020b..a4c35ceaa5 100644
--- a/src/lib/edje/edje_entry.c
+++ b/src/lib/edje/edje_entry.c
@@ -2875,9 +2875,9 @@ _edje_entry_init(Edje *ed)
                                   _edje_key_down_cb, ed);
    evas_object_event_callback_add(ed->obj, EVAS_CALLBACK_KEY_UP,
                                   _edje_key_up_cb, ed);
-   efl_event_callback_add(ed->base.evas, EFL_CANVAS_EVENT_FOCUS_IN,
+   efl_event_callback_add(ed->base.evas, EFL_CANVAS_SCENE_EVENT_FOCUS_IN,
                           _evas_focus_in_cb, ed);
-   efl_event_callback_add(ed->base.evas, EFL_CANVAS_EVENT_FOCUS_OUT,
+   efl_event_callback_add(ed->base.evas, EFL_CANVAS_SCENE_EVENT_FOCUS_OUT,
                           _evas_focus_out_cb, ed);
 }
 
@@ -2896,9 +2896,9 @@ _edje_entry_shutdown(Edje *ed)
                                   _edje_key_down_cb);
    evas_object_event_callback_del(ed->obj, EVAS_CALLBACK_KEY_UP,
                                   _edje_key_up_cb);
-   efl_event_callback_del(ed->base.evas, EFL_CANVAS_EVENT_FOCUS_IN,
+   efl_event_callback_del(ed->base.evas, EFL_CANVAS_SCENE_EVENT_FOCUS_IN,
                           _evas_focus_in_cb, ed);
-   efl_event_callback_del(ed->base.evas, EFL_CANVAS_EVENT_FOCUS_OUT,
+   efl_event_callback_del(ed->base.evas, EFL_CANVAS_SCENE_EVENT_FOCUS_OUT,
                           _evas_focus_out_cb, ed);
 }
 
diff --git a/src/lib/edje/edje_load.c b/src/lib/edje/edje_load.c
index 88f1664be2..230c556af2 100644
--- a/src/lib/edje/edje_load.c
+++ b/src/lib/edje/edje_load.c
@@ -727,13 +727,13 @@ static void
 _edje_device_canvas_del(void *data, const Efl_Event *event)
 {
    Edje *ed = data;
-   efl_event_callback_del(event->object, EFL_CANVAS_EVENT_DEVICE_ADDED,
+   efl_event_callback_del(event->object, EFL_CANVAS_SCENE_EVENT_DEVICE_ADDED,
                           _edje_device_added_cb, ed);
-   efl_event_callback_del(event->object, EFL_CANVAS_EVENT_DEVICE_REMOVED,
+   efl_event_callback_del(event->object, EFL_CANVAS_SCENE_EVENT_DEVICE_REMOVED,
                           _edje_device_removed_cb, ed);
 
    if (ed->collection && ed->collection->use_custom_seat_names)
-     efl_event_callback_del(event->object, EFL_CANVAS_EVENT_DEVICE_CHANGED,
+     efl_event_callback_del(event->object, EFL_CANVAS_SCENE_EVENT_DEVICE_CHANGED,
                             _edje_device_changed_cb, ed);
 }
 
@@ -751,13 +751,13 @@ _edje_devices_add(Edje *ed, Evas *tev)
      }
    efl_event_callback_add(tev, EFL_EVENT_DEL, _edje_device_canvas_del, ed);
 
-   efl_event_callback_add(tev, EFL_CANVAS_EVENT_DEVICE_ADDED,
+   efl_event_callback_add(tev, EFL_CANVAS_SCENE_EVENT_DEVICE_ADDED,
                           _edje_device_added_cb, ed);
-   efl_event_callback_add(tev, EFL_CANVAS_EVENT_DEVICE_REMOVED,
+   efl_event_callback_add(tev, EFL_CANVAS_SCENE_EVENT_DEVICE_REMOVED,
                           _edje_device_removed_cb, ed);
 
    if (ed->collection && ed->collection->use_custom_seat_names)
-     efl_event_callback_add(tev, EFL_CANVAS_EVENT_DEVICE_CHANGED,
+     efl_event_callback_add(tev, EFL_CANVAS_SCENE_EVENT_DEVICE_CHANGED,
                             _edje_device_changed_cb, ed);
 }
 
@@ -1857,12 +1857,12 @@ _edje_file_callbacks_del(Edje *ed, Evas *e)
 
    if (!tev) tev = evas_object_evas_get(ed->obj);
    efl_event_callback_del(tev, EFL_EVENT_DEL, _edje_device_canvas_del, ed);
-   efl_event_callback_del(tev, EFL_CANVAS_EVENT_DEVICE_ADDED,
+   efl_event_callback_del(tev, EFL_CANVAS_SCENE_EVENT_DEVICE_ADDED,
                           _edje_device_added_cb, ed);
-   efl_event_callback_del(tev, EFL_CANVAS_EVENT_DEVICE_REMOVED,
+   efl_event_callback_del(tev, EFL_CANVAS_SCENE_EVENT_DEVICE_REMOVED,
                           _edje_device_removed_cb, ed);
    if (ed->collection && ed->collection->use_custom_seat_names)
-     efl_event_callback_del(tev, EFL_CANVAS_EVENT_DEVICE_CHANGED,
+     efl_event_callback_del(tev, EFL_CANVAS_SCENE_EVENT_DEVICE_CHANGED,
                             _edje_device_changed_cb, ed);
 }
 
diff --git a/src/lib/efl/Efl.h b/src/lib/efl/Efl.h
index b428d459fd..8b0c18b7fc 100644
--- a/src/lib/efl/Efl.h
+++ b/src/lib/efl/Efl.h
@@ -128,7 +128,7 @@ typedef Efl_Gfx_Path_Command_Type Efl_Gfx_Path_Command;
 #include "interfaces/efl_input_device.eo.h"
 
 /* Canvas & UI */
-#include "interfaces/efl_canvas.eo.h"
+#include "interfaces/efl_canvas_scene.eo.h"
 #include "interfaces/efl_canvas_pointer.eo.h"
 #include "interfaces/efl_ui_view.eo.h"
 #include "interfaces/efl_ui_model_connect.eo.h"
diff --git a/src/lib/efl/interfaces/efl_canvas.eo b/src/lib/efl/interfaces/efl_canvas_scene.eo
index c7657e9db2..ccba22c030 100644
--- a/src/lib/efl/interfaces/efl_canvas.eo
+++ b/src/lib/efl/interfaces/efl_canvas_scene.eo
@@ -1,6 +1,6 @@
 import efl_input_device;
 
-interface Efl.Canvas ()
+interface Efl.Canvas.Scene ()
 {
    [[Common interface for window and some internal classes in EFL.]]
    methods {
diff --git a/src/lib/efl/interfaces/efl_input_device.c b/src/lib/efl/interfaces/efl_input_device.c
index a347e09db9..aed03c9980 100644
--- a/src/lib/efl/interfaces/efl_input_device.c
+++ b/src/lib/efl/interfaces/efl_input_device.c
@@ -80,7 +80,7 @@ _efl_input_device_efl_object_parent_set(Eo *obj, Efl_Input_Device_Data *pd EINA_
                   _seat_pointers_update(p, pd);
                }
           }
-        else if(!efl_isa(parent, EFL_CANVAS_INTERFACE))
+        else if(!efl_isa(parent, EFL_CANVAS_SCENE_INTERFACE))
           {
              EINA_SAFETY_ERROR("The parent of a device must be a seat or the canvas");
              return;
diff --git a/src/lib/efl/interfaces/efl_interfaces_main.c b/src/lib/efl/interfaces/efl_interfaces_main.c
index a9a663e60b..e3a26f8c49 100644
--- a/src/lib/efl/interfaces/efl_interfaces_main.c
+++ b/src/lib/efl/interfaces/efl_interfaces_main.c
@@ -2,7 +2,7 @@
 # include <config.h>
 #endif
 
-#define EFL_CANVAS_BETA
+#define EFL_CANVAS_SCENE_BETA
 #define EFL_UI_SCROLLBAR_PROTECTED
 #define EFL_UI_SCROLLBAR_BETA
 
@@ -43,7 +43,7 @@
 #include "interfaces/efl_gfx_blur.eo.c"
 
 #include "interfaces/efl_gfx_size_hint.eo.c"
-#include "interfaces/efl_canvas.eo.c"
+#include "interfaces/efl_canvas_scene.eo.c"
 #include "interfaces/efl_canvas_pointer.eo.c"
 
 #include "interfaces/efl_screen.eo.c"
diff --git a/src/lib/efl/interfaces/efl_ui_base.eo b/src/lib/efl/interfaces/efl_ui_base.eo
index 7ce917d660..646b31be99 100644
--- a/src/lib/efl/interfaces/efl_ui_base.eo
+++ b/src/lib/efl/interfaces/efl_ui_base.eo
@@ -21,7 +21,7 @@ interface Efl.Ui.Base
            to set the value of @.mirrored.
 
            This property may be implemented by high-level widgets (in Efl.Ui)
-           but not by low-level widgets (in @Efl.Canvas) as the configuration
+           but not by low-level widgets (in @Efl.Canvas.Scene) as the configuration
            should affect only high-level widgets.
          ]]
          values {
diff --git a/src/lib/efl_wl/efl_wl.c b/src/lib/efl_wl/efl_wl.c
index a6c51b07b9..0da7d8c374 100644
--- a/src/lib/efl_wl/efl_wl.c
+++ b/src/lib/efl_wl/efl_wl.c
@@ -5285,8 +5285,8 @@ comp_mouse_out(void *data, Evas *e EINA_UNUSED, Evas_Object *obj, void *event_in
 }
 
 EFL_CALLBACKS_ARRAY_DEFINE(comp_device_cbs,
-  { EFL_CANVAS_EVENT_DEVICE_ADDED, comp_device_add },
-  { EFL_CANVAS_EVENT_DEVICE_REMOVED, comp_device_del });
+  { EFL_CANVAS_SCENE_EVENT_DEVICE_ADDED, comp_device_add },
+  { EFL_CANVAS_SCENE_EVENT_DEVICE_REMOVED, comp_device_del });
 
 static void
 hints_set_aspect(struct wl_client *client, struct wl_resource *resource, struct wl_resource *surface, uint32_t width, uint32_t height, uint32_t aspect)
diff --git a/src/lib/elementary/efl_ui_win.c b/src/lib/elementary/efl_ui_win.c
index d5f3518dbf..d8504a8563 100644
--- a/src/lib/elementary/efl_ui_win.c
+++ b/src/lib/elementary/efl_ui_win.c
@@ -13,7 +13,7 @@
 #define EFL_UI_WIN_INLINED_PROTECTED
 #define EFL_UI_FOCUS_OBJECT_PROTECTED
 #define EFL_UI_WIN_BETA
-#define EFL_CANVAS_BETA
+#define EFL_CANVAS_SCENE_BETA
 
 #include <Elementary.h>
 #include <Elementary_Cursor.h>
@@ -1792,7 +1792,7 @@ _elm_win_evas_render_post(void *data,
    Efl_Gfx_Event_Render_Post *ev = event_info;
    Eo *win = data;
 
-   efl_event_callback_legacy_call(win, EFL_CANVAS_EVENT_RENDER_POST, ev);
+   efl_event_callback_legacy_call(win, EFL_CANVAS_SCENE_EVENT_RENDER_POST, ev);
 }
 
 static void
@@ -1803,7 +1803,7 @@ _elm_win_evas_render_pre(void *data,
    Eo *win = data;
 
    _elm_win_throttle_ok = EINA_TRUE;
-   efl_event_callback_legacy_call(win, EFL_CANVAS_EVENT_RENDER_PRE, NULL);
+   efl_event_callback_legacy_call(win, EFL_CANVAS_SCENE_EVENT_RENDER_PRE, NULL);
 }
 
 static void
@@ -1814,7 +1814,7 @@ _elm_win_evas_focus_in(void *data,
    Eo *win = data;
 
    _elm_win_throttle_ok = EINA_TRUE;
-   efl_event_callback_legacy_call(win, EFL_CANVAS_EVENT_FOCUS_IN, NULL);
+   efl_event_callback_legacy_call(win, EFL_CANVAS_SCENE_EVENT_FOCUS_IN, NULL);
 }
 
 static void
@@ -1824,7 +1824,7 @@ _elm_win_evas_focus_out(void *data,
 {
    Eo *win = data;
 
-   efl_event_callback_legacy_call(win, EFL_CANVAS_EVENT_FOCUS_OUT, NULL);
+   efl_event_callback_legacy_call(win, EFL_CANVAS_SCENE_EVENT_FOCUS_OUT, NULL);
 }
 
 static void
@@ -1836,7 +1836,7 @@ _elm_win_evas_object_focus_in(void *data,
    Eo *win = data;
 
    _elm_win_throttle_ok = EINA_TRUE;
-   efl_event_callback_legacy_call(win, EFL_CANVAS_EVENT_OBJECT_FOCUS_IN, object);
+   efl_event_callback_legacy_call(win, EFL_CANVAS_SCENE_EVENT_OBJECT_FOCUS_IN, object);
 }
 
 static void
@@ -1847,7 +1847,7 @@ _elm_win_evas_object_focus_out(void *data,
    Eo *object = event_info;
    Eo *win = data;
 
-   efl_event_callback_legacy_call(win, EFL_CANVAS_EVENT_OBJECT_FOCUS_OUT, object);
+   efl_event_callback_legacy_call(win, EFL_CANVAS_SCENE_EVENT_OBJECT_FOCUS_OUT, object);
 }
 
 static void
@@ -1858,7 +1858,7 @@ _elm_win_evas_device_changed(void *data,
    Eo *device = event_info;
    Eo *win = data;
 
-   efl_event_callback_legacy_call(win, EFL_CANVAS_EVENT_DEVICE_CHANGED, device);
+   efl_event_callback_legacy_call(win, EFL_CANVAS_SCENE_EVENT_DEVICE_CHANGED, device);
 }
 
 static void
@@ -1947,43 +1947,43 @@ _win_event_add_cb(void *data, const Efl_Event *ev)
                efl_event_callback_add(sd->evas, array[i].desc,
                                      _evas_event_key_cb, win);
           }
-        else if (array[i].desc == EFL_CANVAS_EVENT_RENDER_POST)
+        else if (array[i].desc == EFL_CANVAS_SCENE_EVENT_RENDER_POST)
           {
              if (!(sd->event_forward.render_post++))
                evas_event_callback_add(sd->evas, EVAS_CALLBACK_RENDER_POST,
                                        _elm_win_evas_render_post, win);
           }
-        else if (array[i].desc == EFL_CANVAS_EVENT_RENDER_PRE)
+        else if (array[i].desc == EFL_CANVAS_SCENE_EVENT_RENDER_PRE)
           {
              if (!(sd->event_forward.render_pre++))
                evas_event_callback_add(sd->evas, EVAS_CALLBACK_RENDER_PRE,
                                        _elm_win_evas_render_pre, win);
           }
-        else if (array[i].desc == EFL_CANVAS_EVENT_FOCUS_IN)
+        else if (array[i].desc == EFL_CANVAS_SCENE_EVENT_FOCUS_IN)
           {
              if (!(sd->event_forward.focus_in++))
                evas_event_callback_add(sd->evas, EVAS_CALLBACK_FOCUS_IN,
                                        _elm_win_evas_focus_in, win);
           }
-        else if (array[i].desc == EFL_CANVAS_EVENT_FOCUS_OUT)
+        else if (array[i].desc == EFL_CANVAS_SCENE_EVENT_FOCUS_OUT)
           {
              if (!(sd->event_forward.focus_out++))
                evas_event_callback_add(sd->evas, EVAS_CALLBACK_FOCUS_OUT,
                                        _elm_win_evas_focus_out, win);
           }
-        else if (array[i].desc == EFL_CANVAS_EVENT_OBJECT_FOCUS_IN)
+        else if (array[i].desc == EFL_CANVAS_SCENE_EVENT_OBJECT_FOCUS_IN)
           {
              if (!(sd->event_forward.object_focus_in++))
                evas_event_callback_add(sd->evas, EVAS_CALLBACK_CANVAS_OBJECT_FOCUS_IN,
                                        _elm_win_evas_object_focus_in, win);
           }
-        else if (array[i].desc == EFL_CANVAS_EVENT_OBJECT_FOCUS_OUT)
+        else if (array[i].desc == EFL_CANVAS_SCENE_EVENT_OBJECT_FOCUS_OUT)
           {
              if (!(sd->event_forward.object_focus_out++))
                evas_event_callback_add(sd->evas, EVAS_CALLBACK_CANVAS_OBJECT_FOCUS_OUT,
                                        _elm_win_evas_object_focus_out, win);
           }
-        else if (array[i].desc == EFL_CANVAS_EVENT_DEVICE_CHANGED)
+        else if (array[i].desc == EFL_CANVAS_SCENE_EVENT_DEVICE_CHANGED)
           {
              if (!(sd->event_forward.device_changed++))
                evas_event_callback_add(sd->evas, EVAS_CALLBACK_DEVICE_CHANGED,
@@ -2078,43 +2078,43 @@ _win_event_del_cb(void *data, const Efl_Event *ev)
                efl_event_callback_del(sd->evas, array[i].desc,
                                      _evas_event_key_cb, win);
           }
-        else if (array[i].desc == EFL_CANVAS_EVENT_RENDER_POST)
+        else if (array[i].desc == EFL_CANVAS_SCENE_EVENT_RENDER_POST)
           {
              if (!(--sd->event_forward.render_post))
                evas_event_callback_del_full(sd->evas, EVAS_CALLBACK_RENDER_POST,
                                             _elm_win_evas_render_post, win);
           }
-        else if (array[i].desc == EFL_CANVAS_EVENT_RENDER_PRE)
+        else if (array[i].desc == EFL_CANVAS_SCENE_EVENT_RENDER_PRE)
           {
              if (!(--sd->event_forward.render_pre))
                evas_event_callback_del_full(sd->evas, EVAS_CALLBACK_RENDER_PRE,
                                             _elm_win_evas_render_pre, win);
           }
-        else if (array[i].desc == EFL_CANVAS_EVENT_FOCUS_IN)
+        else if (array[i].desc == EFL_CANVAS_SCENE_EVENT_FOCUS_IN)
           {
              if (!(--sd->event_forward.focus_in))
                evas_event_callback_del_full(sd->evas, EVAS_CALLBACK_FOCUS_IN,
                                             _elm_win_evas_focus_in, win);
           }
-        else if (array[i].desc == EFL_CANVAS_EVENT_FOCUS_OUT)
+        else if (array[i].desc == EFL_CANVAS_SCENE_EVENT_FOCUS_OUT)
           {
              if (!(--sd->event_forward.focus_out))
                evas_event_callback_del_full(sd->evas, EVAS_CALLBACK_FOCUS_OUT,
                                             _elm_win_evas_focus_out, win);
           }
-        else if (array[i].desc == EFL_CANVAS_EVENT_OBJECT_FOCUS_IN)
+        else if (array[i].desc == EFL_CANVAS_SCENE_EVENT_OBJECT_FOCUS_IN)
           {
              if (!(--sd->event_forward.object_focus_in))
                evas_event_callback_del_full(sd->evas, EVAS_CALLBACK_CANVAS_OBJECT_FOCUS_IN,
                                             _elm_win_evas_object_focus_in, win);
           }
-        else if (array[i].desc == EFL_CANVAS_EVENT_OBJECT_FOCUS_OUT)
+        else if (array[i].desc == EFL_CANVAS_SCENE_EVENT_OBJECT_FOCUS_OUT)
           {
              if (!(--sd->event_forward.object_focus_out))
                evas_event_callback_del_full(sd->evas, EVAS_CALLBACK_CANVAS_OBJECT_FOCUS_OUT,
                                             _elm_win_evas_object_focus_out, win);
           }
-        else if (array[i].desc == EFL_CANVAS_EVENT_DEVICE_CHANGED)
+        else if (array[i].desc == EFL_CANVAS_SCENE_EVENT_DEVICE_CHANGED)
           {
              if (!(--sd->event_forward.device_changed))
                evas_event_callback_del_full(sd->evas, EVAS_CALLBACK_DEVICE_CHANGED,
@@ -2172,7 +2172,7 @@ _elm_win_resume(void *data, const Efl_Event *ev)
 
 EFL_CALLBACKS_ARRAY_DEFINE(_elm_evas_tracking,
                            { EFL_EVENT_POINTER_UP, _elm_win_cb_mouse_up },
-                           { EFL_CANVAS_EVENT_RENDER_PRE, _elm_win_resume })
+                           { EFL_CANVAS_SCENE_EVENT_RENDER_PRE, _elm_win_resume })
 
 static void
 _deferred_ecore_evas_free(void *data)
@@ -2346,7 +2346,7 @@ _efl_ui_win_efl_gfx_visible_set(Eo *obj, Efl_Ui_Win_Data *sd, Eina_Bool vis)
 }
 
 EOLIAN static Eina_Position2D
-_efl_ui_win_efl_canvas_pointer_position_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd)
+_efl_ui_win_efl_canvas_scene_pointer_position_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd)
 {
    Eina_Position2D pos;
    evas_pointer_canvas_xy_get(sd->evas, &pos.x, &pos.y);
@@ -2390,7 +2390,7 @@ _input_pointer_iterator_free(Input_Pointer_Iterator *it)
 }
 
 EOLIAN static Eina_Iterator *
-_efl_ui_win_efl_canvas_pointer_iterate(const Eo *obj, Efl_Ui_Win_Data *sd,
+_efl_ui_win_efl_canvas_scene_pointer_iterate(const Eo *obj, Efl_Ui_Win_Data *sd,
                                        Eina_Bool hover EINA_UNUSED)
 {
    Input_Pointer_Iterator *it;
@@ -2458,19 +2458,19 @@ _efl_ui_win_efl_canvas_pointer_iterate(const Eo *obj, Efl_Ui_Win_Data *sd,
 }
 
 EOLIAN static Eina_Bool
-_efl_ui_win_efl_canvas_image_max_size_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, Eina_Size2D *max)
+_efl_ui_win_efl_canvas_scene_image_max_size_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, Eina_Size2D *max)
 {
-   return efl_canvas_image_max_size_get(sd->evas, max);
+   return efl_canvas_scene_image_max_size_get(sd->evas, max);
 }
 
 EOLIAN static void
-_efl_ui_win_efl_canvas_smart_objects_calculate(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd)
+_efl_ui_win_efl_canvas_scene_smart_objects_calculate(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd)
 {
    evas_smart_objects_calculate(sd->evas);
 }
 
 EOLIAN static Eina_Iterator *
-_efl_ui_win_efl_canvas_objects_at_xy_get(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, Eina_Position2D pos, Eina_Bool include_pass_events_objects, Eina_Bool include_hidden_objects)
+_efl_ui_win_efl_canvas_scene_objects_at_xy_get(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, Eina_Position2D pos, Eina_Bool include_pass_events_objects, Eina_Bool include_hidden_objects)
 {
    Eina_List *objs = NULL;
    objs = evas_objects_at_xy_get(sd->evas, pos.x, pos.y, include_pass_events_objects, include_hidden_objects);
@@ -2478,13 +2478,13 @@ _efl_ui_win_efl_canvas_objects_at_xy_get(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *s
 }
 
 EOLIAN static Efl_Gfx *
-_efl_ui_win_efl_canvas_object_top_at_xy_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, Eina_Position2D pos, Eina_Bool include_pass_events_objects, Eina_Bool include_hidden_objects)
+_efl_ui_win_efl_canvas_scene_object_top_at_xy_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, Eina_Position2D pos, Eina_Bool include_pass_events_objects, Eina_Bool include_hidden_objects)
 {
    return evas_object_top_at_xy_get(sd->evas, pos.x, pos.y, include_pass_events_objects, include_hidden_objects);
 }
 
 EOLIAN static Eina_Iterator *
-_efl_ui_win_efl_canvas_objects_in_rectangle_get(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, Eina_Rect r, Eina_Bool include_pass_events_objects, Eina_Bool include_hidden_objects)
+_efl_ui_win_efl_canvas_scene_objects_in_rectangle_get(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, Eina_Rect r, Eina_Bool include_pass_events_objects, Eina_Bool include_hidden_objects)
 {
    Eina_List *objs = NULL;
    objs = evas_objects_in_rectangle_get(sd->evas, r.x, r.y, r.w, r.h, include_pass_events_objects, include_hidden_objects);
@@ -2492,21 +2492,21 @@ _efl_ui_win_efl_canvas_objects_in_rectangle_get(Eo *obj EINA_UNUSED, Efl_Ui_Win_
 }
 
 EOLIAN static Efl_Gfx *
-_efl_ui_win_efl_canvas_object_top_in_rectangle_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, Eina_Rect r, Eina_Bool include_pass_events_objects, Eina_Bool include_hidden_objects)
+_efl_ui_win_efl_canvas_scene_object_top_in_rectangle_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, Eina_Rect r, Eina_Bool include_pass_events_objects, Eina_Bool include_hidden_objects)
 {
    return evas_object_top_in_rectangle_get(sd->evas, r.x, r.y, r.w, r.h, include_pass_events_objects, include_hidden_objects);
 }
 
 EOLIAN static Efl_Input_Device *
-_efl_ui_win_efl_canvas_device_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, const char *name)
+_efl_ui_win_efl_canvas_scene_device_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, const char *name)
 {
-   return efl_canvas_device_get(sd->evas, name);
+   return efl_canvas_scene_device_get(sd->evas, name);
 }
 
 EOLIAN static Efl_Input_Device *
-_efl_ui_win_efl_canvas_seat_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, int id)
+_efl_ui_win_efl_canvas_scene_seat_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, int id)
 {
-   return efl_canvas_seat_get(sd->evas, id);
+   return efl_canvas_scene_seat_get(sd->evas, id);
 }
 
 static void
diff --git a/src/lib/elementary/efl_ui_win.eo b/src/lib/elementary/efl_ui_win.eo
index 0101b54b82..53601f1b9e 100644
--- a/src/lib/elementary/efl_ui_win.eo
+++ b/src/lib/elementary/efl_ui_win.eo
@@ -154,7 +154,7 @@ enum Efl.Ui.Win.Move_Resize_Mode
    right = (1 << 4)    [[Start resizing window to the right]]
 }
 
-class Efl.Ui.Win (Efl.Ui.Widget, Efl.Canvas, Efl.Canvas.Pointer, Efl.Access.Window,
+class Efl.Ui.Win (Efl.Ui.Widget, Efl.Canvas.Scene, Efl.Canvas.Pointer, Efl.Access.Window,
                   Efl.Access.Component, Efl.Access.Widget.Action,
                   Efl.Content, Efl.Input.State, Efl.Input.Interface, Efl.Screen,
                   Efl.Gfx.Size.Hint, Efl.Text, Efl.Config.Global, Efl.Part,
@@ -803,18 +803,18 @@ class Efl.Ui.Win (Efl.Ui.Widget, Efl.Canvas, Efl.Canvas.Pointer, Efl.Access.Wind
       Efl.Gfx.Size.Hint.hint_weight { set; }
       Efl.Gfx.Size.Hint.hint_max { set; }
       Efl.Text.text { get; set; }
-      Efl.Canvas.pointer_position { get; }
+      Efl.Canvas.Scene.pointer_position { get; }
       Efl.Canvas.Pointer.pointer_inside { get; }
-      Efl.Canvas.pointer_iterate;
-      Efl.Canvas.image_max_size { get; }
-      Efl.Canvas.smart_objects_calculate;
-      Efl.Canvas.objects_at_xy_get;
-      Efl.Canvas.object_top_at_xy_get;
-      Efl.Canvas.objects_in_rectangle_get;
-      Efl.Canvas.object_top_in_rectangle_get;
+      Efl.Canvas.Scene.pointer_iterate;
+      Efl.Canvas.Scene.image_max_size { get; }
+      Efl.Canvas.Scene.smart_objects_calculate;
+      Efl.Canvas.Scene.objects_at_xy_get;
+      Efl.Canvas.Scene.object_top_at_xy_get;
+      Efl.Canvas.Scene.objects_in_rectangle_get;
+      Efl.Canvas.Scene.object_top_in_rectangle_get;
       //Efl.Canvas.seats;
-      Efl.Canvas.device { get; }
-      Efl.Canvas.seat { get; }
+      Efl.Canvas.Scene.device { get; }
+      Efl.Canvas.Scene.seat { get; }
       Efl.Content.content { get; set; }
       Efl.Content.content_unset;
       Efl.Part.part;
diff --git a/src/lib/evas/canvas/efl_canvas_vg.c b/src/lib/evas/canvas/efl_canvas_vg.c
index 92bf7c04fd..6662c53528 100644
--- a/src/lib/evas/canvas/efl_canvas_vg.c
+++ b/src/lib/evas/canvas/efl_canvas_vg.c
@@ -319,7 +319,7 @@ _efl_canvas_vg_efl_object_destructor(Eo *eo_obj, Efl_Canvas_Vg_Data *pd)
 {
    Evas *e = evas_object_evas_get(eo_obj);
 
-   efl_event_callback_del(e, EFL_CANVAS_EVENT_RENDER_POST, _cleanup_reference, pd);
+   efl_event_callback_del(e, EFL_CANVAS_SCENE_EVENT_RENDER_POST, _cleanup_reference, pd);
 
    efl_unref(pd->root);
    pd->root = NULL;
@@ -355,7 +355,7 @@ _efl_canvas_vg_efl_object_finalize(Eo *obj, Efl_Canvas_Vg_Data *pd)
 
    // TODO: If we start to have to many Evas_Object_VG per canvas, it may be nice
    // to actually have one event per canvas and one array per canvas to.
-   efl_event_callback_add(e, EFL_CANVAS_EVENT_RENDER_POST, _cleanup_reference, pd);
+   efl_event_callback_add(e, EFL_CANVAS_SCENE_EVENT_RENDER_POST, _cleanup_reference, pd);
 
    return obj;
 }
diff --git a/src/lib/evas/canvas/efl_gfx_map.c b/src/lib/evas/canvas/efl_gfx_map.c
index 1d070921d0..58ddb9953f 100644
--- a/src/lib/evas/canvas/efl_gfx_map.c
+++ b/src/lib/evas/canvas/efl_gfx_map.c
@@ -742,7 +742,7 @@ _gfx_map_op_add(Eo *eo_obj, Efl_Gfx_Map_Data *pd, Gfx_Map_Op_Type type,
                        pivot->is_evas = EINA_TRUE;
                        pivot->is_canvas = EINA_TRUE;
                     }
-                  else if (efl_isa(eo_pivot, EFL_CANVAS_INTERFACE))
+                  else if (efl_isa(eo_pivot, EFL_CANVAS_SCENE_INTERFACE))
                     pivot->is_canvas = EINA_TRUE;
                   pivot->map_obj = obj;
                   EINA_INLIST_APPEND(mcow->pivots, pivot);
diff --git a/src/lib/evas/canvas/evas_callbacks.c b/src/lib/evas/canvas/evas_callbacks.c
index 10f4597ad6..a94fba30d4 100644
--- a/src/lib/evas/canvas/evas_callbacks.c
+++ b/src/lib/evas/canvas/evas_callbacks.c
@@ -59,17 +59,17 @@ DEFINE_EVAS_CALLBACKS(_legacy_evas_callback_table, EVAS_CALLBACK_LAST,
                       EFL_EVENT_HOLD,
                       EFL_GFX_EVENT_CHANGE_SIZE_HINTS,
                       EFL_IMAGE_EVENT_PRELOAD,
-                      EFL_CANVAS_EVENT_FOCUS_IN,
-                      EFL_CANVAS_EVENT_FOCUS_OUT,
+                      EFL_CANVAS_SCENE_EVENT_FOCUS_IN,
+                      EFL_CANVAS_SCENE_EVENT_FOCUS_OUT,
                       EVAS_CANVAS_EVENT_RENDER_FLUSH_PRE,
                       EVAS_CANVAS_EVENT_RENDER_FLUSH_POST,
-                      EFL_CANVAS_EVENT_OBJECT_FOCUS_IN,
-                      EFL_CANVAS_EVENT_OBJECT_FOCUS_OUT,
+                      EFL_CANVAS_SCENE_EVENT_OBJECT_FOCUS_IN,
+                      EFL_CANVAS_SCENE_EVENT_OBJECT_FOCUS_OUT,
                       EFL_IMAGE_EVENT_UNLOAD,
-                      EFL_CANVAS_EVENT_RENDER_PRE,
-                      EFL_CANVAS_EVENT_RENDER_POST,
+                      EFL_CANVAS_SCENE_EVENT_RENDER_PRE,
+                      EFL_CANVAS_SCENE_EVENT_RENDER_POST,
                       EFL_IMAGE_EVENT_RESIZE,
-                      EFL_CANVAS_EVENT_DEVICE_CHANGED,
+                      EFL_CANVAS_SCENE_EVENT_DEVICE_CHANGED,
                       EFL_EVENT_POINTER_AXIS,
                       EVAS_CANVAS_EVENT_VIEWPORT_RESIZE );
 
@@ -209,8 +209,8 @@ _eo_evas_cb(void *data, const Efl_Event *event)
 
    if (!info->func.evas_cb) return;
 
-   if (event->desc == EFL_CANVAS_EVENT_OBJECT_FOCUS_IN ||
-       event->desc == EFL_CANVAS_EVENT_OBJECT_FOCUS_OUT)
+   if (event->desc == EFL_CANVAS_SCENE_EVENT_OBJECT_FOCUS_IN ||
+       event->desc == EFL_CANVAS_SCENE_EVENT_OBJECT_FOCUS_OUT)
      {
         event_info = efl_input_focus_object_get(efl_event_info);
         goto emit;
diff --git a/src/lib/evas/canvas/evas_canvas.eo b/src/lib/evas/canvas/evas_canvas.eo
index 4afdade8d8..d11285a611 100644
--- a/src/lib/evas/canvas/evas_canvas.eo
+++ b/src/lib/evas/canvas/evas_canvas.eo
@@ -1,6 +1,6 @@
 import efl_input_types;
 
-class Evas.Canvas (Efl.Object, Efl.Canvas, Efl.Animator, Efl.Input.Interface,
+class Evas.Canvas (Efl.Object, Efl.Canvas.Scene, Efl.Animator, Efl.Input.Interface,
                    Efl.Loop.Consumer, Efl.Canvas.Pointer)
 {
    [[Evas canvas class]]
@@ -990,14 +990,14 @@ class Evas.Canvas (Efl.Object, Efl.Canvas, Efl.Animator, Efl.Input.Interface,
       Efl.Loop.Consumer.loop { get; }
       //Efl.Canvas.seats;
       Efl.Canvas.Pointer.pointer_inside { get; }
-      Efl.Canvas.device { get; }
-      Efl.Canvas.seat { get; }
-      Efl.Canvas.image_max_size { get; }
-      Efl.Canvas.objects_at_xy_get;
-      Efl.Canvas.object_top_at_xy_get;
-      Efl.Canvas.objects_in_rectangle_get;
-      Efl.Canvas.object_top_in_rectangle_get;
-      Efl.Canvas.smart_objects_calculate;
-      Efl.Canvas.smart_objects_calculating { get; }
+      Efl.Canvas.Scene.device { get; }
+      Efl.Canvas.Scene.seat { get; }
+      Efl.Canvas.Scene.image_max_size { get; }
+      Efl.Canvas.Scene.objects_at_xy_get;
+      Efl.Canvas.Scene.object_top_at_xy_get;
+      Efl.Canvas.Scene.objects_in_rectangle_get;
+      Efl.Canvas.Scene.object_top_in_rectangle_get;
+      Efl.Canvas.Scene.smart_objects_calculate;
+      Efl.Canvas.Scene.smart_objects_calculating { get; }
    }
 }
diff --git a/src/lib/evas/canvas/evas_device.c b/src/lib/evas/canvas/evas_device.c
index 23eb01d08c..e67350deeb 100644
--- a/src/lib/evas/canvas/evas_device.c
+++ b/src/lib/evas/canvas/evas_device.c
@@ -111,12 +111,12 @@ _del_cb(void *data, const Efl_Event *ev)
    _evas_pointer_data_remove(e, ev->object);
    eina_hash_del_by_key(e->locks.masks, &ev->object);
    eina_hash_del_by_key(e->modifiers.masks, &ev->object);
-   efl_event_callback_call(e->evas, EFL_CANVAS_EVENT_DEVICE_REMOVED,
+   efl_event_callback_call(e->evas, EFL_CANVAS_SCENE_EVENT_DEVICE_REMOVED,
                            ev->object);
 }
 
 EOLIAN Efl_Input_Device *
-_evas_canvas_efl_canvas_device_get(Evas *eo_e EINA_UNUSED, Evas_Public_Data *e, const char *name)
+_evas_canvas_efl_canvas_scene_device_get(Evas *eo_e EINA_UNUSED, Evas_Public_Data *e, const char *name)
 {
    const char *dev_name;
    Evas_Device *dev;
@@ -138,11 +138,11 @@ _evas_canvas_efl_canvas_device_get(Evas *eo_e EINA_UNUSED, Evas_Public_Data *e,
 EAPI Evas_Device *
 evas_device_get(Evas *eo_e, const char *name)
 {
-   return efl_canvas_device_get(eo_e, name);
+   return efl_canvas_scene_device_get(eo_e, name);
 }
 
 EOLIAN Efl_Input_Device *
-_evas_canvas_efl_canvas_seat_get(Evas *eo_e EINA_UNUSED, Evas_Public_Data *e, unsigned int id)
+_evas_canvas_efl_canvas_scene_seat_get(Evas *eo_e EINA_UNUSED, Evas_Public_Data *e, unsigned int id)
 {
    Evas_Device *dev;
    Eina_List *l;
@@ -162,7 +162,7 @@ _evas_canvas_efl_canvas_seat_get(Evas *eo_e EINA_UNUSED, Evas_Public_Data *e, un
 EAPI Evas_Device *
 evas_device_get_by_seat_id(Evas *eo_e, unsigned int id)
 {
-   return efl_canvas_seat_get(eo_e, id);
+   return efl_canvas_scene_seat_get(eo_e, id);
 }
 
 EAPI Evas_Device *
@@ -247,7 +247,7 @@ evas_device_add_full(Evas *eo_e, const char *name, const char *desc,
    e->devices = eina_list_append(e->devices, dev);
    efl_event_callback_add(dev, EFL_EVENT_DEL, _del_cb, e);
 
-   efl_event_callback_call(eo_e, EFL_CANVAS_EVENT_DEVICE_ADDED, dev);
+   efl_event_callback_call(eo_e, EFL_CANVAS_SCENE_EVENT_DEVICE_ADDED, dev);
    // Keeping this event to do not break things...
    evas_event_callback_call(eo_e, EVAS_CALLBACK_DEVICE_CHANGED, dev);
    if (e->pending_default_focus_obj && (e->default_seat == dev))
@@ -500,7 +500,7 @@ again:
    */
    EINA_LIST_FREE(e->devices, dev)
      {
-        efl_event_callback_call(e->evas, EFL_CANVAS_EVENT_DEVICE_REMOVED, dev);
+        efl_event_callback_call(e->evas, EFL_CANVAS_SCENE_EVENT_DEVICE_REMOVED, dev);
         efl_event_callback_del(dev, EFL_EVENT_DEL, _del_cb, e);
      }
 }
diff --git a/src/lib/evas/canvas/evas_image_legacy.c b/src/lib/evas/canvas/evas_image_legacy.c
index ace876cb0b..be5b2ad1cb 100644
--- a/src/lib/evas/canvas/evas_image_legacy.c
+++ b/src/lib/evas/canvas/evas_image_legacy.c
@@ -1220,7 +1220,7 @@ evas_image_max_size_get(Eo *eo_e, int *w, int *h)
    Eina_Size2D size;
    Eina_Bool ret;
 
-   ret = efl_canvas_image_max_size_get(eo_e, &size);
+   ret = efl_canvas_scene_image_max_size_get(eo_e, &size);
    if (ret)
      {
         if (w) *w = size.w;
diff --git a/src/lib/evas/canvas/evas_main.c b/src/lib/evas/canvas/evas_main.c
index 42e2c6c8e3..7b658aac90 100644
--- a/src/lib/evas/canvas/evas_main.c
+++ b/src/lib/evas/canvas/evas_main.c
@@ -1055,7 +1055,7 @@ _evas_canvas_image_cache_get(const Eo *eo_e EINA_UNUSED, Evas_Public_Data *e)
 }
 
 EOLIAN static Eina_Bool
-_evas_canvas_efl_canvas_image_max_size_get(const Eo *eo_e EINA_UNUSED, Evas_Public_Data *e, Eina_Size2D *max)
+_evas_canvas_efl_canvas_scene_image_max_size_get(const Eo *eo_e EINA_UNUSED, Evas_Public_Data *e, Eina_Size2D *max)
 {
    int w = 0, h = 0;
 
@@ -1452,7 +1452,7 @@ efl_canvas_iterator_create(Eo *obj, Eina_Iterator *real_iterator, Eina_List *lis
 }
 
 EOLIAN static Evas_Object*
-_evas_canvas_efl_canvas_object_top_at_xy_get(const Eo *eo_e EINA_UNUSED, Evas_Public_Data *e, Eina_Position2D pos, Eina_Bool include_pass_events_objects, Eina_Bool include_hidden_objects)
+_evas_canvas_efl_canvas_scene_object_top_at_xy_get(const Eo *eo_e EINA_UNUSED, Evas_Public_Data *e, Eina_Position2D pos, Eina_Bool include_pass_events_objects, Eina_Bool include_hidden_objects)
 {
    Evas_Layer *lay;
    int xx, yy;
@@ -1490,7 +1490,7 @@ EAPI Evas_Object*
 evas_object_top_at_xy_get(Eo *eo_e, Evas_Coord x, Evas_Coord y, Eina_Bool include_pass_events_objects, Eina_Bool include_hidden_objects)
 {
    Eina_Position2D pos = {x, y};
-   return efl_canvas_object_top_at_xy_get(eo_e, pos, include_pass_events_objects, include_hidden_objects);
+   return efl_canvas_scene_object_top_at_xy_get(eo_e, pos, include_pass_events_objects, include_hidden_objects);
 }
 
 EAPI Evas_Object *
@@ -1502,11 +1502,11 @@ evas_object_top_at_pointer_get(const Evas *eo_e)
 
    Evas_Pointer_Data *pdata = _evas_pointer_data_by_device_get(e, NULL);
    EINA_SAFETY_ON_NULL_RETURN_VAL(pdata, NULL);
-   return efl_canvas_object_top_at_xy_get((Eo *)eo_e, EINA_POSITION2D(pdata->seat->x, pdata->seat->y), EINA_TRUE, EINA_TRUE);
+   return efl_canvas_scene_object_top_at_xy_get((Eo *)eo_e, EINA_POSITION2D(pdata->seat->x, pdata->seat->y), EINA_TRUE, EINA_TRUE);
 }
 
 EOLIAN Evas_Object*
-_evas_canvas_efl_canvas_object_top_in_rectangle_get(const Eo *eo_e EINA_UNUSED, Evas_Public_Data *e, Eina_Rect rect, Eina_Bool include_pass_events_objects, Eina_Bool include_hidden_objects)
+_evas_canvas_efl_canvas_scene_object_top_in_rectangle_get(const Eo *eo_e EINA_UNUSED, Evas_Public_Data *e, Eina_Rect rect, Eina_Bool include_pass_events_objects, Eina_Bool include_hidden_objects)
 {
    Evas_Layer *lay;
    int xx, yy, ww, hh;
@@ -1548,7 +1548,7 @@ _evas_canvas_efl_canvas_object_top_in_rectangle_get(const Eo *eo_e EINA_UNUSED,
 EAPI Evas_Object *
 evas_object_top_in_rectangle_get(const Eo *obj, int x, int y, int w, int h, Eina_Bool include_pass_events_objects, Eina_Bool include_hidden_objects)
 {
-   return efl_canvas_object_top_in_rectangle_get(obj, EINA_RECT(x, y, w, h), include_pass_events_objects, include_hidden_objects);
+   return efl_canvas_scene_object_top_in_rectangle_get(obj, EINA_RECT(x, y, w, h), include_pass_events_objects, include_hidden_objects);
 }
 
 static Eina_List *
@@ -1596,7 +1596,7 @@ _efl_canvas_evas_canvas_objects_at_xy_get_helper(Eo *eo_e EINA_UNUSED, Evas_Publ
 }
 
 EOLIAN static Eina_Iterator *
-_evas_canvas_efl_canvas_objects_at_xy_get(Eo *eo_e, Evas_Public_Data *e, Eina_Position2D pos, Eina_Bool include_pass_events_objects, Eina_Bool include_hidden_objects)
+_evas_canvas_efl_canvas_scene_objects_at_xy_get(Eo *eo_e, Evas_Public_Data *e, Eina_Position2D pos, Eina_Bool include_pass_events_objects, Eina_Bool include_hidden_objects)
 {
    Eina_List *l = _efl_canvas_evas_canvas_objects_at_xy_get_helper(eo_e, e, pos.x, pos.y, include_pass_events_objects, include_hidden_objects);
    if (l) return efl_canvas_iterator_create(eo_e, eina_list_iterator_new(l), l);
@@ -1665,7 +1665,7 @@ _efl_canvas_objects_in_rectangle_get_helper(const Eo *eo_e EINA_UNUSED, Evas_Pub
 
 
 EOLIAN static Eina_Iterator*
-_evas_canvas_efl_canvas_objects_in_rectangle_get(Eo *eo_e EINA_UNUSED, Evas_Public_Data *e, Eina_Rect rect, Eina_Bool include_pass_events_objects, Eina_Bool include_hidden_objects)
+_evas_canvas_efl_canvas_scene_objects_in_rectangle_get(Eo *eo_e EINA_UNUSED, Evas_Public_Data *e, Eina_Rect rect, Eina_Bool include_pass_events_objects, Eina_Bool include_hidden_objects)
 {
    Eina_List *l = _efl_canvas_objects_in_rectangle_get_helper(eo_e, e, rect.x, rect.y, rect.w, rect.h, include_pass_events_objects, include_hidden_objects);
    if (!l) return NULL;
@@ -1812,7 +1812,7 @@ evas_font_available_list_free(Evas *eo_e, Eina_List *available)
 
 
 EOLIAN static void
-_evas_canvas_efl_canvas_smart_objects_calculate(Eo *eo_e, Evas_Public_Data *o EINA_UNUSED)
+_evas_canvas_efl_canvas_scene_smart_objects_calculate(Eo *eo_e, Evas_Public_Data *o EINA_UNUSED)
 {
    evas_call_smarts_calculate(eo_e);
 }
@@ -1824,7 +1824,7 @@ evas_smart_objects_calculate(Eo *eo_e)
 }
 
 EOLIAN Eina_Bool
-_evas_canvas_efl_canvas_smart_objects_calculating_get(const Eo *eo_e EINA_UNUSED, Evas_Public_Data *e)
+_evas_canvas_efl_canvas_scene_smart_objects_calculating_get(const Eo *eo_e EINA_UNUSED, Evas_Public_Data *e)
 {
    return !!e->in_smart_calc;
 }
@@ -1832,7 +1832,7 @@ _evas_canvas_efl_canvas_smart_objects_calculating_get(const Eo *eo_e EINA_UNUSED
 EAPI Eina_Bool
 evas_smart_objects_calculating_get(const Eo *obj)
 {
-   return efl_canvas_smart_objects_calculating_get(obj);
+   return efl_canvas_scene_smart_objects_calculating_get(obj);
 }
 
 EOLIAN int
diff --git a/src/tests/elementary/elm_test_win.c b/src/tests/elementary/elm_test_win.c
index 942927ab66..c7ef94a74e 100644
--- a/src/tests/elementary/elm_test_win.c
+++ b/src/tests/elementary/elm_test_win.c
@@ -5,7 +5,7 @@
 #define EFL_ACCESS_BETA
 #define EFL_ACCESS_COMPONENT_BETA
 #define EFL_ACCESS_COMPONENT_PROTECTED
-#define EFL_CANVAS_BETA
+#define EFL_CANVAS_SCENE_BETA
 
 #include <Elementary.h>
 #ifdef HAVE_ELEMENTARY_X
@@ -246,7 +246,7 @@ _inputs_timer2_cb(void *data)
    size_t cnt = 0;
    int i = 0;
 
-   it = efl_canvas_pointer_iterate(win, 0);
+   it = efl_canvas_scene_pointer_iterate(win, 0);
    EINA_ITERATOR_FOREACH(it, ptr)
      {
         double x, y;
@@ -309,7 +309,7 @@ _inputs_timer3_cb(void *data)
    size_t cnt = 0;
    int i = 0;
 
-   it = efl_canvas_pointer_iterate(win, 0);
+   it = efl_canvas_scene_pointer_iterate(win, 0);
    EINA_ITERATOR_FOREACH(it, ptr)
      {
         int tool, ok = 0;
@@ -340,7 +340,7 @@ _inputs_timer3_cb(void *data)
    fail_if(cnt != 2); // 2 moves (in the list), 2 ups (gone)
 
    fail_if(!efl_canvas_pointer_inside_get(win, NULL));
-   pos = efl_canvas_pointer_position_get(win);
+   pos = efl_canvas_scene_pointer_position_get(win);
    ck_assert_int_eq(pos.x, points[1][0].x);
    ck_assert_int_eq(pos.y, points[1][0].y);