dimmus
/
efl
forked from enlightenment/efl
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Efl.Canvas.Scene (from Efl.Canvas) 

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

Reviewed-by: Cedric Bail <cedric@osg.samsung.com>
This commit is contained in:
Xavi Artigas 2018-03-26 15:21:21 +02:00 committed by Cedric Bail
parent f6fc78119b
commit 65ee277a66
29 changed files with 141 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/Makefile_Efl.am
View File

@ -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 \

4
src/bin/elementary/test_evas_snapshot.c
View File

@ -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.

2
src/examples/ecore/ecore_evas_cursor_example.c
View File

@ -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);

6
src/examples/ecore/ecore_evas_vnc_example.c
View File

@ -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();

14
src/examples/ecore/ecore_evas_wayland_multiseat_example.c
View File

@ -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();

4
src/examples/edje/edje-multiseat-custom-names.c
View File

@ -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",

2
src/examples/edje/edje-multiseat-filter.c
View File

@ -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);

2
src/examples/edje/edje-multiseat.c
View File

@ -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);

6
src/examples/evas/evas-event-filter.c
View File

@ -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 },

8
src/examples/evas/evas-multiseat-events.c
View File

@ -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,

6
src/lib/ecore_evas/ecore_evas.c
View File

@ -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)
{

8
src/lib/edje/edje_entry.c
View File

@ -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);
}

18
src/lib/edje/edje_load.c
View File

@ -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);
}

2
src/lib/efl/Efl.h
View File

@ -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"

2
src/lib/efl/interfaces/efl_canvas.eo → src/lib/efl/interfaces/efl_canvas_scene.eo
View File

@ -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 {

2
src/lib/efl/interfaces/efl_input_device.c
View File

@ -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;

4
src/lib/efl/interfaces/efl_interfaces_main.c
View File

@ -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"

2
src/lib/efl/interfaces/efl_ui_base.eo
View File

@ -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 {

4
src/lib/efl_wl/efl_wl.c
View File

@ -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)

72
src/lib/elementary/efl_ui_win.c
View File

@ -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

22
src/lib/elementary/efl_ui_win.eo
View File

@ -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;

4
src/lib/evas/canvas/efl_canvas_vg.c
View File

@ -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;
}

2
src/lib/evas/canvas/efl_gfx_map.c
View File

@ -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);

18
src/lib/evas/canvas/evas_callbacks.c
View File

@ -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;

20
src/lib/evas/canvas/evas_canvas.eo
View File

@ -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; }
}
}

14
src/lib/evas/canvas/evas_device.c
View File

@ -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);
}
}

2
src/lib/evas/canvas/evas_image_legacy.c
View File

@ -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;

22
src/lib/evas/canvas/evas_main.c
View File

@ -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

8
src/tests/elementary/elm_test_win.c
View File

@ -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);