Merge branch 'devs/iscaro/focus-event'

This series changes evas focus events, always providing
Efl.Input.Focus, making their usage way more straightforward.

Patches by Guilherme Iscaro <iscaro@profusion.mobi>
Differential Revision: https://phab.enlightenment.org/D4412

15 files changed, 324 insertions, 61 deletions

diff --git a/src/Makefile_Evas.am b/src/Makefile_Evas.am
index f690335831..973ec6b848 100644
--- a/src/Makefile_Evas.am
+++ b/src/Makefile_Evas.am
@@ -48,6 +48,7 @@ evas_eolian_pub_files = \
 	lib/evas/canvas/efl_input_key.eo \
 	lib/evas/canvas/efl_input_pointer.eo \
 	lib/evas/canvas/efl_input_hold.eo \
+	lib/evas/canvas/efl_input_focus.eo \
 	lib/evas/canvas/efl_gfx_map.eo \
 	lib/evas/canvas/efl_canvas_output.eo \
 	$(NULL)
@@ -208,6 +209,7 @@ lib/evas/canvas/efl_input_event.c \
 lib/evas/canvas/efl_input_key.c \
 lib/evas/canvas/efl_input_pointer.c \
 lib/evas/canvas/efl_input_hold.c \
+lib/evas/canvas/efl_input_focus.c \
 $(NULL)
 
 EXTRA_DIST2 += \
diff --git a/src/lib/edje/edje_callbacks.c b/src/lib/edje/edje_callbacks.c
index 9ec3287cad..b27049fc83 100644
--- a/src/lib/edje/edje_callbacks.c
+++ b/src/lib/edje/edje_callbacks.c
@@ -439,8 +439,8 @@ EFL_CALLBACKS_ARRAY_DEFINE(edje_callbacks,
                           { EFL_EVENT_POINTER_WHEEL, _edje_mouse_wheel_signal_cb });
 
 EFL_CALLBACKS_ARRAY_DEFINE(edje_focus_callbacks,
-                          { EFL_CANVAS_OBJECT_EVENT_FOCUS_IN, _edje_focus_in_signal_cb },
-                          { EFL_CANVAS_OBJECT_EVENT_FOCUS_OUT, _edje_focus_out_signal_cb });
+                          { EFL_EVENT_FOCUS_IN, _edje_focus_in_signal_cb },
+                          { EFL_EVENT_FOCUS_OUT, _edje_focus_out_signal_cb });
 
 void
 _edje_callbacks_add(Evas_Object *obj, Edje *ed, Edje_Real_Part *rp)
diff --git a/src/lib/efl/interfaces/efl_canvas.eo b/src/lib/efl/interfaces/efl_canvas.eo
index bd053376a6..0e2179f37a 100644
--- a/src/lib/efl/interfaces/efl_canvas.eo
+++ b/src/lib/efl/interfaces/efl_canvas.eo
@@ -160,10 +160,10 @@ interface Efl.Canvas ()
       }
    }
    events {
-      focus,in; [[Called when canvas got focus]]
-      focus,out; [[Called when canvas lost focus]]
-      object,focus,in: Efl.Canvas.Object; [[Called when object got focus]]
-      object,focus,out: Efl.Canvas.Object; [[Called when object lost focus]]
+      focus,in: Efl.Input.Focus; [[Called when canvas got focus]]
+      focus,out: Efl.Input.Focus; [[Called when canvas lost focus]]
+      object,focus,in: Efl.Input.Focus; [[Called when object got focus]]
+      object,focus,out: Efl.Input.Focus; [[Called when object lost focus]]
       render,pre; [[Called when pre render happens]]
       render,post; [[Called when post render happens]]
       device,changed: Efl.Input.Device; [[Called when input device changed]]
diff --git a/src/lib/efl/interfaces/efl_common_internal.h b/src/lib/efl/interfaces/efl_common_internal.h
index dd1b29e719..c7ae160e09 100644
--- a/src/lib/efl/interfaces/efl_common_internal.h
+++ b/src/lib/efl/interfaces/efl_common_internal.h
@@ -17,6 +17,7 @@ typedef struct _Efl_Input_Pointer_Data  Efl_Input_Pointer_Data;
 typedef struct _Efl_Input_Key_Data      Efl_Input_Key_Data;
 typedef struct _Efl_Input_Device_Data   Efl_Input_Device_Data;
 typedef struct _Efl_Input_Hold_Data     Efl_Input_Hold_Data;
+typedef struct _Efl_Input_Focus_Data    Efl_Input_Focus_Data;
 
 #ifndef _EVAS_TYPES_EOT_H_
 typedef struct _Evas_Modifier Evas_Modifier;
@@ -110,6 +111,14 @@ struct _Efl_Input_Hold_Data
    Eina_Bool         evas_done : 1; /* set by evas */
 };
 
+struct _Efl_Input_Focus_Data
+{
+   Eo *eo;
+   Efl_Input_Device *device; //The seat
+   Eo *object; //The focused object - Efl.Canvas.Object or Efl.Canvas.
+   double timestamp;
+};
+
 static inline Eina_Bool
 _efl_input_value_has(const Efl_Input_Pointer_Data *pd, Efl_Input_Value key)
 {
diff --git a/src/lib/evas/Evas_Eo.h b/src/lib/evas/Evas_Eo.h
index cc7273e59e..de9b786f69 100644
--- a/src/lib/evas/Evas_Eo.h
+++ b/src/lib/evas/Evas_Eo.h
@@ -307,4 +307,5 @@ typedef void (Evas_Canvas3D_Surface_Func)(Evas_Real *out_x,
 #include "canvas/efl_input_key.eo.h"
 #include "canvas/efl_input_hold.eo.h"
 #include "canvas/efl_input_interface.eo.h"
+#include "canvas/efl_input_focus.eo.h"
 #endif /* EFL_EO_API_SUPPORT */
diff --git a/src/lib/evas/canvas/efl_canvas_object.eo b/src/lib/evas/canvas/efl_canvas_object.eo
index 793a0047fa..4b8a8d43fd 100644
--- a/src/lib/evas/canvas/efl_canvas_object.eo
+++ b/src/lib/evas/canvas/efl_canvas_object.eo
@@ -636,10 +636,4 @@ abstract Efl.Canvas.Object (Efl.Object, Efl.Gfx, Efl.Gfx.Stack, Efl.Animator,
       Efl.Gfx.Map.map_enable.set;
       Efl.Gfx.Map.map_enable.get;
    }
-   events {
-       focus,in; [[Focus In Event ]]
-       focus,out; [[Focus Out Event ]]
-       focus,device,in: Efl.Input.Device; [[Focus In event that contains the seat device that this object was focused. @since 1.19]]
-       focus,device,out: Efl.Input.Device; [[Focus Out event that contains the seat device that this object was unfocused.@since 1.19]]
-   }
 }
diff --git a/src/lib/evas/canvas/efl_input_focus.c b/src/lib/evas/canvas/efl_input_focus.c
new file mode 100644
index 0000000000..0bf4912364
--- /dev/null
+++ b/src/lib/evas/canvas/efl_input_focus.c
@@ -0,0 +1,161 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#define EFL_INPUT_EVENT_PROTECTED
+
+#include <Evas.h>
+
+#define EFL_INTERNAL_UNSTABLE
+#include "interfaces/efl_common_internal.h"
+
+#define MY_CLASS EFL_INPUT_FOCUS_CLASS
+
+static Efl_Input_Focus *s_cached_event = NULL;
+
+static void
+_del_hook(Eo *evt)
+{
+   if (!s_cached_event)
+     {
+        if (efl_parent_get(evt))
+          {
+             efl_ref(evt);
+             efl_parent_set(evt, NULL);
+          }
+        efl_reuse(evt);
+        s_cached_event = evt;
+     }
+   else
+     {
+        efl_del_intercept_set(evt, NULL);
+        efl_del(evt);
+     }
+}
+
+static void
+_efl_input_focus_free(Efl_Input_Focus_Data *pd)
+{
+   efl_unref(pd->device);
+}
+
+EOLIAN static Efl_Object *
+_efl_input_focus_efl_object_constructor(Eo *obj,
+                                        Efl_Input_Focus_Data *pd EINA_UNUSED)
+{
+   obj = efl_constructor(efl_super(obj, MY_CLASS));
+   return obj;
+}
+
+EOLIAN static void
+_efl_input_focus_efl_object_destructor(Eo *obj,
+                                       Efl_Input_Focus_Data *pd)
+{
+   _efl_input_focus_free(pd);
+   efl_destructor(efl_super(obj, MY_CLASS));
+}
+
+EOLIAN static void
+_efl_input_focus_class_destructor(Efl_Class *klass EINA_UNUSED)
+{
+   // this is a strange situation...
+   efl_del_intercept_set(s_cached_event, NULL);
+   efl_del(s_cached_event);
+   s_cached_event = NULL;
+}
+
+EOLIAN static void
+_efl_input_focus_object_set(Eo *obj EINA_UNUSED, Efl_Input_Focus_Data *pd,
+                            Efl_Object *object)
+{
+   pd->object = object;
+}
+
+EOLIAN static Efl_Object *
+_efl_input_focus_object_get(Eo *obj EINA_UNUSED, Efl_Input_Focus_Data *pd)
+{
+   return pd->object;
+}
+
+EOLIAN static void
+_efl_input_focus_efl_input_event_device_set(Eo *obj EINA_UNUSED,
+                                            Efl_Input_Focus_Data *pd,
+                                            Efl_Input_Device *device)
+{
+   pd->device = efl_ref(device);
+}
+
+EOLIAN static Efl_Input_Device *
+_efl_input_focus_efl_input_event_device_get(Eo *obj EINA_UNUSED,
+                                            Efl_Input_Focus_Data *pd)
+{
+   return pd->device;
+}
+
+EOLIAN static void
+_efl_input_focus_efl_input_event_timestamp_set(Eo *obj EINA_UNUSED,
+                                               Efl_Input_Focus_Data *pd,
+                                               double ms)
+{
+   pd->timestamp = ms;
+}
+
+EOLIAN static double
+_efl_input_focus_efl_input_event_timestamp_get(Eo *obj EINA_UNUSED,
+                                               Efl_Input_Focus_Data *pd)
+{
+   return pd->timestamp;
+}
+
+EOLIAN static Efl_Input_Focus *
+_efl_input_focus_efl_input_event_dup(Eo *obj EINA_UNUSED,
+                                     Efl_Input_Focus_Data *pd)
+{
+   Efl_Input_Focus_Data *ev;
+   Efl_Input_Focus *evt;
+
+   // no parent
+   evt = efl_input_instance_get(MY_CLASS, NULL, (void **) &ev);
+   if (!evt || !ev) return NULL;
+
+   ev->eo        = evt;
+   ev->object    = pd->object;
+   ev->device    = efl_ref(pd->device);
+   ev->timestamp = pd->timestamp;
+   return evt;
+}
+
+EOLIAN static Efl_Input_Focus *
+_efl_input_focus_efl_input_event_instance_get(Eo *klass EINA_UNUSED, void *_pd EINA_UNUSED,
+                                              Eo *owner, void **priv)
+{
+   Efl_Input_Focus_Data *ev;
+   Efl_Input_Focus *evt;
+
+   if (s_cached_event)
+     {
+        evt = s_cached_event;
+        s_cached_event = NULL;
+        efl_input_reset(evt);
+        efl_parent_set(evt, owner);
+     }
+   else
+     {
+        evt = efl_add(MY_CLASS, owner);
+        efl_del_intercept_set(evt, _del_hook);
+     }
+
+   ev = efl_data_scope_get(evt, MY_CLASS);
+   if (priv) *priv = ev;
+   return evt;
+}
+
+EOLIAN static void
+_efl_input_focus_efl_input_event_reset(Eo *obj, Efl_Input_Focus_Data *pd)
+{
+   _efl_input_focus_free(pd);
+   memset(pd, 0, sizeof(Efl_Input_Focus_Data));
+   pd->eo = obj;
+}
+
+#include "efl_input_focus.eo.c"
diff --git a/src/lib/evas/canvas/efl_input_focus.eo b/src/lib/evas/canvas/efl_input_focus.eo
new file mode 100644
index 0000000000..2d5a2d1bd5
--- /dev/null
+++ b/src/lib/evas/canvas/efl_input_focus.eo
@@ -0,0 +1,25 @@
+class Efl.Input.Focus(Efl.Object, Efl.Input.Event)
+{
+   [[Reprents a focus event. @since 1.19]]
+   methods {
+      @property object {
+         values {
+            object: Efl.Object; [[The focused object.
+                                  In case this represents a canvas
+                                  focus the object will be $null]]
+         }
+      }
+   }
+   implements {
+      class.destructor;
+      Efl.Object.constructor;
+      Efl.Object.destructor;
+      Efl.Input.Event.device.set;
+      Efl.Input.Event.device.get;
+      Efl.Input.Event.instance_get;
+      Efl.Input.Event.reset;
+      Efl.Input.Event.dup;
+      Efl.Input.Event.timestamp.set;
+      Efl.Input.Event.timestamp.get;
+   }
+}
\ No newline at end of file
diff --git a/src/lib/evas/canvas/efl_input_interface.eo b/src/lib/evas/canvas/efl_input_interface.eo
index 4f60188f2f..49a7f1ab00 100644
--- a/src/lib/evas/canvas/efl_input_interface.eo
+++ b/src/lib/evas/canvas/efl_input_interface.eo
@@ -99,5 +99,7 @@ interface Efl.Input.Interface ()
       key,down: Efl.Input.Key;           [[Keyboard key press.]]
       key,up: Efl.Input.Key;             [[Keyboard key release.]]
       hold: Efl.Input.Hold;              [[All input events are on hold or resumed.]]
+      focus,in: Efl.Input.Focus;         [[A focus in event.]]
+      focus,out: Efl.Input.Focus;        [[A focus out event.]]
    }
 }
diff --git a/src/lib/evas/canvas/evas_callbacks.c b/src/lib/evas/canvas/evas_callbacks.c
index d529399429..3487543617 100644
--- a/src/lib/evas/canvas/evas_callbacks.c
+++ b/src/lib/evas/canvas/evas_callbacks.c
@@ -48,8 +48,8 @@ DEFINE_EVAS_CALLBACKS(_legacy_evas_callback_table, EVAS_CALLBACK_LAST,
                       EVAS_OBJECT_EVENT_FREE,
                       EFL_EVENT_KEY_DOWN,
                       EFL_EVENT_KEY_UP,
-                      EFL_CANVAS_OBJECT_EVENT_FOCUS_IN,
-                      EFL_CANVAS_OBJECT_EVENT_FOCUS_OUT,
+                      EFL_EVENT_FOCUS_IN,
+                      EFL_EVENT_FOCUS_OUT,
                       EFL_GFX_EVENT_SHOW,
                       EFL_GFX_EVENT_HIDE,
                       EFL_GFX_EVENT_MOVE,
@@ -93,7 +93,8 @@ typedef enum {
    EFL_EVENT_TYPE_STRUCT,
    EFL_EVENT_TYPE_POINTER,
    EFL_EVENT_TYPE_KEY,
-   EFL_EVENT_TYPE_HOLD
+   EFL_EVENT_TYPE_HOLD,
+   EFL_EVENT_TYPE_FOCUS
 } Efl_Event_Info_Type;
 
 typedef struct
@@ -147,6 +148,10 @@ _evas_event_efl_event_info_type(Evas_Callback_Type type)
       case EVAS_CALLBACK_DEVICE_CHANGED: /* Efl.Input.Device */
         return EFL_EVENT_TYPE_OBJECT;
 
+      case EVAS_CALLBACK_FOCUS_IN:
+      case EVAS_CALLBACK_FOCUS_OUT:
+          return EFL_EVENT_TYPE_FOCUS;
+
       default:
         return EFL_EVENT_TYPE_NULL;
      }
@@ -164,6 +169,7 @@ _eo_evas_object_cb(void *data, const Efl_Event *event)
    if (!info->func) return;
    evas = evas_object_evas_get(event->object);
 
+   event_info = event->info;
    switch (info->efl_event_type)
      {
       case EFL_EVENT_TYPE_POINTER:
@@ -178,12 +184,13 @@ _eo_evas_object_cb(void *data, const Efl_Event *event)
         event_info = efl_input_hold_legacy_info_fill(efl_event_info, &event_flags);
         break;
 
+      case EFL_EVENT_TYPE_FOCUS:
+         event_info = NULL;
       case EFL_EVENT_TYPE_NULL:
       case EFL_EVENT_TYPE_STRUCT:
       case EFL_EVENT_TYPE_OBJECT:
-        info->func(info->data, evas, event->object, event->info);
+        info->func(info->data, evas, event->object, event_info);
         return;
-
       default: return;
      }
 
@@ -197,8 +204,20 @@ _eo_evas_object_cb(void *data, const Efl_Event *event)
 static void
 _eo_evas_cb(void *data, const Efl_Event *event)
 {
+   void *event_info;
    _eo_evas_cb_info *info = data;
-   if (info->func) info->func(info->data, event->object, event->info);
+
+   //Keep the legacy behaviour for focus events.
+   if (event->desc == EFL_CANVAS_EVENT_FOCUS_IN ||
+       event->desc == EFL_CANVAS_EVENT_FOCUS_OUT)
+     event_info = NULL;
+   else if (event->desc == EFL_CANVAS_EVENT_OBJECT_FOCUS_IN ||
+            event->desc == EFL_CANVAS_EVENT_OBJECT_FOCUS_OUT)
+     event_info = efl_input_focus_object_get(event->info);
+   else
+     event_info = event->info;
+
+   if (info->func) info->func(info->data, event->object, event_info);
 }
 
 void
diff --git a/src/lib/evas/canvas/evas_events.c b/src/lib/evas/canvas/evas_events.c
index 7d7492ed6c..5bccd61272 100644
--- a/src/lib/evas/canvas/evas_events.c
+++ b/src/lib/evas/canvas/evas_events.c
@@ -3528,6 +3528,27 @@ _evas_canvas_event_key_cb(void *data, const Efl_Event *event)
    ev->evas_done = EINA_TRUE;
 }
 
+static void
+_evas_canvas_event_focus_cb(void *data, const Efl_Event *event)
+{
+   Evas_Public_Data *e = data;
+
+   if (event->desc == EFL_EVENT_FOCUS_IN)
+     {
+        if (e->focus) return;
+        e->focus = 1;
+        evas_event_callback_call(e->evas, EVAS_CALLBACK_CANVAS_FOCUS_IN,
+                                 event->info);
+     }
+   else
+     {
+        if (!e->focus) return;
+        e->focus = 0;
+        evas_event_callback_call(e->evas, EVAS_CALLBACK_CANVAS_FOCUS_OUT,
+                                 event->info);
+     }
+}
+
 // note: "hold" event comes from above (elm), not below (ecore)
 EFL_CALLBACKS_ARRAY_DEFINE(_evas_canvas_event_pointer_callbacks,
 { EFL_EVENT_POINTER_MOVE, _evas_canvas_event_pointer_cb },
@@ -3542,7 +3563,9 @@ EFL_CALLBACKS_ARRAY_DEFINE(_evas_canvas_event_pointer_callbacks,
 { EFL_EVENT_FINGER_DOWN, _evas_canvas_event_pointer_cb },
 { EFL_EVENT_FINGER_UP, _evas_canvas_event_pointer_cb },
 { EFL_EVENT_KEY_DOWN, _evas_canvas_event_key_cb },
-{ EFL_EVENT_KEY_UP, _evas_canvas_event_key_cb })
+{ EFL_EVENT_KEY_UP, _evas_canvas_event_key_cb },
+{ EFL_EVENT_FOCUS_IN, _evas_canvas_event_focus_cb },
+{ EFL_EVENT_FOCUS_OUT, _evas_canvas_event_focus_cb })
 
 void
 _evas_canvas_event_init(Evas *eo_e, Evas_Public_Data *e)
diff --git a/src/lib/evas/canvas/evas_focus.c b/src/lib/evas/canvas/evas_focus.c
index 3245867fee..9269985073 100644
--- a/src/lib/evas/canvas/evas_focus.c
+++ b/src/lib/evas/canvas/evas_focus.c
@@ -1,5 +1,9 @@
+#define EFL_INTERNAL_UNSTABLE
+#define EFL_INPUT_EVENT_PROTECTED
+
 #include "evas_common_private.h"
 #include "evas_private.h"
+#include "interfaces/efl_common_internal.h"
 
 /* private calls */
 
@@ -59,26 +63,49 @@ _current_focus_get(Eo *evas_obj, Efl_Input_Device *key)
    return eina_hash_find(edata->focused_objects, &key);
 }
 
+void
+_evas_focus_dispatch_event(Evas_Object_Protected_Data *obj, Efl_Input_Device *seat, Eina_Bool in)
+{
+   Efl_Input_Focus_Data *ev_data;
+   Efl_Input_Focus *evt;
+   Evas_Callback_Type cb_evas, cb_obj_evas;
+   const Efl_Event_Description *efl_object_focus_event;
+
+   evt = efl_input_instance_get(EFL_INPUT_FOCUS_CLASS, NULL, (void **) &ev_data);
+   if (!evt) return;
+
+   ev_data->device = efl_ref(seat);
+   ev_data->object = obj->object;
+   ev_data->timestamp = time(NULL);
+
+   if (in)
+     {
+        cb_obj_evas = EVAS_CALLBACK_FOCUS_IN;
+        cb_evas = EVAS_CALLBACK_CANVAS_OBJECT_FOCUS_IN;
+        efl_object_focus_event = EFL_EVENT_FOCUS_IN;
+     }
+   else
+     {
+        cb_obj_evas = EVAS_CALLBACK_FOCUS_OUT;
+        cb_evas = EVAS_CALLBACK_CANVAS_OBJECT_FOCUS_OUT;
+        efl_object_focus_event = EFL_EVENT_FOCUS_OUT;
+     }
+
+   evas_object_event_callback_call(obj->object, obj,
+                                   cb_obj_evas,
+                                   evt, _evas_object_event_new(),
+                                   efl_object_focus_event);
+   evas_event_callback_call(obj->layer->evas->evas, cb_evas, evt);
+   efl_del(evt);
+}
+
 static void
 _evas_object_unfocus(Evas_Object_Protected_Data *obj, Efl_Input_Device *seat)
 {
    obj->focused_by_seats = eina_list_remove(obj->focused_by_seats, seat);
    _evas_focus_set(obj->object, seat, EINA_FALSE);
 
-   //Legacy events...
-   if (seat == obj->layer->evas->default_seat)
-     {
-        evas_object_event_callback_call(obj->object, obj,
-                                        EVAS_CALLBACK_FOCUS_OUT,
-                                        NULL, _evas_object_event_new(),
-                                        EFL_CANVAS_OBJECT_EVENT_FOCUS_OUT);
-        evas_event_callback_call(obj->layer->evas->evas,
-                                 EVAS_CALLBACK_CANVAS_OBJECT_FOCUS_OUT,
-                                 obj->object);
-     }
-   efl_event_callback_call(obj->object,
-                           EFL_CANVAS_OBJECT_EVENT_FOCUS_DEVICE_OUT,
-                           seat);
+   _evas_focus_dispatch_event(obj, seat, EINA_FALSE);
    _evas_post_event_callback_call(obj->layer->evas->evas,
                                   obj->layer->evas);
 }
@@ -161,18 +188,7 @@ _efl_canvas_object_seat_focus_add(Eo *eo_obj,
    obj->focused_by_seats = eina_list_append(obj->focused_by_seats, seat);
    _evas_focus_set(eo_obj, seat, EINA_TRUE);
 
-   //Legacy events...
-   if (seat == _default_seat_get(eo_obj))
-     {
-        evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_FOCUS_IN,
-                                        NULL, _evas_object_event_new(),
-                                        EFL_CANVAS_OBJECT_EVENT_FOCUS_IN);
-        evas_event_callback_call(obj->layer->evas->evas,
-                                 EVAS_CALLBACK_CANVAS_OBJECT_FOCUS_IN, eo_obj);
-     }
-
-   efl_event_callback_call(eo_obj,
-                           EFL_CANVAS_OBJECT_EVENT_FOCUS_DEVICE_IN, seat);
+   _evas_focus_dispatch_event(obj, seat, EINA_TRUE);
  end:
    _evas_post_event_callback_call(obj->layer->evas->evas, obj->layer->evas);
    return EINA_TRUE;
diff --git a/src/lib/evas/canvas/evas_main.c b/src/lib/evas/canvas/evas_main.c
index 48048cf047..4174602bb5 100644
--- a/src/lib/evas/canvas/evas_main.c
+++ b/src/lib/evas/canvas/evas_main.c
@@ -1,5 +1,5 @@
 #define EVAS_CANVAS_BETA
-
+#define EFL_INPUT_EVENT_PROTECTED
 #include "evas_common_private.h"
 #include "evas_private.h"
 //#include "evas_cs.h"
@@ -13,6 +13,9 @@
 
 #include <Ecore.h>
 
+#define EFL_INTERNAL_UNSTABLE
+#include "interfaces/efl_common_internal.h"
+
 #define MY_CLASS EVAS_CANVAS_CLASS
 
 #ifdef LKDEBUG
@@ -529,20 +532,33 @@ _evas_canvas_data_attach_get(Eo *eo_e EINA_UNUSED, Evas_Public_Data *e)
    return e->attach_data;
 }
 
+static void
+_evas_canvas_focus_inout_dispatch(Eo *eo_e, Evas_Public_Data *e, Eina_Bool in)
+{
+   Efl_Input_Focus_Data *ev_data;
+   Efl_Input_Focus *evt;
+
+   evt = efl_input_instance_get(EFL_INPUT_FOCUS_CLASS, eo_e, (void **) &ev_data);
+   if (!evt) return;
+
+   ev_data->device = efl_ref(e->default_seat);
+   ev_data->timestamp = time(NULL);
+   efl_event_callback_call(eo_e,
+                           in ? EFL_EVENT_FOCUS_IN : EFL_EVENT_FOCUS_OUT,
+                           evt);
+   efl_del(evt);
+}
+
 EOLIAN static void
 _evas_canvas_focus_in(Eo *eo_e, Evas_Public_Data *e)
 {
-   if (e->focus) return;
-   e->focus = 1;
-   evas_event_callback_call(eo_e, EVAS_CALLBACK_CANVAS_FOCUS_IN, NULL);
+   _evas_canvas_focus_inout_dispatch(eo_e, e, EINA_TRUE);
 }
 
 EOLIAN static void
 _evas_canvas_focus_out(Eo *eo_e, Evas_Public_Data *e)
 {
-   if (!e->focus) return;
-   e->focus = 0;
-   evas_event_callback_call(eo_e, EVAS_CALLBACK_CANVAS_FOCUS_OUT, NULL);
+   _evas_canvas_focus_inout_dispatch(eo_e, e, EINA_FALSE);
 }
 
 EOLIAN static Eina_Bool
diff --git a/src/lib/evas/canvas/evas_object_main.c b/src/lib/evas/canvas/evas_object_main.c
index 46e8266f7b..8466babb9a 100644
--- a/src/lib/evas/canvas/evas_object_main.c
+++ b/src/lib/evas/canvas/evas_object_main.c
@@ -706,15 +706,7 @@ _efl_canvas_object_efl_object_destructor(Eo *eo_obj, Evas_Object_Protected_Data
         efl_event_callback_del(dev, EFL_EVENT_DEL,
                                _evas_focus_device_del_cb, obj);
         eina_hash_del_by_key(edata->focused_objects, &dev);
-        //default seat - legacy support.
-        if (dev == edata->default_seat)
-          {
-             evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_FOCUS_OUT,
-                                             NULL, _evas_object_event_new(),
-                                             EFL_CANVAS_OBJECT_EVENT_FOCUS_OUT);
-          }
-        efl_event_callback_call(eo_obj,
-                                EFL_CANVAS_OBJECT_EVENT_FOCUS_DEVICE_OUT, dev);
+        _evas_focus_dispatch_event(obj, dev, EINA_FALSE);
         if ((obj->layer) && (obj->layer->evas))
           _evas_post_event_callback_call(obj->layer->evas->evas, obj->layer->evas);
      }
diff --git a/src/lib/evas/include/evas_private.h b/src/lib/evas/include/evas_private.h
index 476c31cbd7..f955e1d3b3 100644
--- a/src/lib/evas/include/evas_private.h
+++ b/src/lib/evas/include/evas_private.h
@@ -1945,6 +1945,9 @@ Eina_Bool evas_vg_loader_svg(Evas_Object *vg, const Eina_File *f, const char *ke
 void *_evas_object_image_surface_get(Evas_Object *eo, Evas_Object_Protected_Data *obj);
 Eina_Bool _evas_image_proxy_source_clip_get(const Eo *eo_obj);
 
+void _evas_focus_dispatch_event(Evas_Object_Protected_Data *obj,
+                                Efl_Input_Device *seat, Eina_Bool in);
+
 extern Eina_Cow *evas_object_proxy_cow;
 extern Eina_Cow *evas_object_map_cow;
 extern Eina_Cow *evas_object_state_cow;