evas: move efl_input_device into evas/Efl_Canvas.h

Summary:
The internal and the API we would like is mostly a canvas API. A lot of the code
in evas is working around the fact that efl_input_device is not defined inside Evas.
This patch is the first step to try to clean this up.

Depends on D10487

Reviewers: zmike, raster, bu5hm4n, Hermet

Reviewed By: zmike

Subscribers: #reviewers, #committers

Tags: #efl

Maniphest Tasks: T8321

Differential Revision: https://phab.enlightenment.org/D10488

24 files changed, 1006 insertions, 53 deletions

diff --git a/src/lib/evas/Efl_Canvas.h b/src/lib/evas/Efl_Canvas.h
index cd8bf52693..dcb3836218 100644
--- a/src/lib/evas/Efl_Canvas.h
+++ b/src/lib/evas/Efl_Canvas.h
@@ -45,6 +45,19 @@ extern "C" {
 #include <canvas/efl_canvas_animation_types.eot.h>
 #include <gesture/efl_canvas_gesture_types.eot.h>
 
+/* Input events */
+#include "canvas/efl_input_device.eo.h"
+#include "canvas/efl_canvas_pointer.eo.h"
+#include "canvas/efl_canvas_scene.eo.h"
+#include "canvas/efl_input_state.eo.h"
+#include "canvas/efl_input_event.eo.h"
+#include "canvas/efl_input_pointer.eo.h"
+#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"
+#include "canvas/efl_input_clickable.eo.h"
+
 #include <gesture/efl_canvas_gesture.eo.h>
 #include <gesture/efl_canvas_gesture_touch.eo.h>
 #include <gesture/efl_canvas_gesture_recognizer.eo.h>
diff --git a/src/lib/evas/Evas_Common.h b/src/lib/evas/Evas_Common.h
index 1ae09bf259..f68f544dd3 100644
--- a/src/lib/evas/Evas_Common.h
+++ b/src/lib/evas/Evas_Common.h
@@ -3488,13 +3488,29 @@ typedef Eo Efl_Animation_Group_Sequential;
 #define EFL_ANIMATION_REPEAT_INFINITE -1
 #define EFL_ANIMATION_PLAYER_REPEAT_INFINITE -1
 
-#ifndef _EFL_INPUT_DEVICE_EO_H_
-#define _EFL_INPUT_DEVICE_EO_H_
+// The below type are necessary for legacy API and need to be manually kept in sync with .eo file.
+#ifndef _EFL_INPUT_DEVICE_EO_CLASS_TYPE
+#define _EFL_INPUT_DEVICE_EO_CLASS_TYPE
 typedef Eo Efl_Input_Device;
-typedef unsigned int Efl_Input_Device_Type;
+#endif
+
+#ifndef _EFL_INPUT_DEVICE_EO_TYPES
+#define _EFL_INPUT_DEVICE_EO_TYPES
+typedef enum
+{
+  EFL_INPUT_DEVICE_TYPE_NONE = 0,
+  EFL_INPUT_DEVICE_TYPE_SEAT,
+  EFL_INPUT_DEVICE_TYPE_KEYBOARD,
+  EFL_INPUT_DEVICE_TYPE_MOUSE,
+  EFL_INPUT_DEVICE_TYPE_TOUCH,
+  EFL_INPUT_DEVICE_TYPE_PEN,
+  EFL_INPUT_DEVICE_TYPE_WAND,
+  EFL_INPUT_DEVICE_TYPE_GAMEPAD
+} Efl_Input_Device_Type;
 
 #endif
 
+
 #ifndef _EFL_TEXT_CURSOR_EO_H_
 #define _EFL_TEXT_CURSOR_EO_H_
 
diff --git a/src/lib/evas/Evas_Eo.h b/src/lib/evas/Evas_Eo.h
index 5f46511e84..ddf3b2d2b0 100644
--- a/src/lib/evas/Evas_Eo.h
+++ b/src/lib/evas/Evas_Eo.h
@@ -185,6 +185,20 @@ struct _Efl_Canvas_Object_Animation_Event
  * @}
  */
 
+/* Input events */
+#include "interfaces/efl_input_types.eot.h"
+#include "canvas/efl_input_device.eo.h"
+#include "canvas/efl_canvas_pointer.eo.h"
+#include "canvas/efl_canvas_scene.eo.h"
+#include "canvas/efl_input_state.eo.h"
+#include "canvas/efl_input_event.eo.h"
+#include "canvas/efl_input_pointer.eo.h"
+#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"
+#include "canvas/efl_input_clickable.eo.h"
+
 #include "canvas/efl_canvas_animation_types.eot.h"
 
 #include "gesture/efl_canvas_gesture_types.eot.h"
@@ -457,12 +471,3 @@ typedef void (Evas_Canvas3D_Surface_Func)(Evas_Real *out_x,
 #include "canvas/efl_canvas_vg_gradient.eo.h"
 #include "canvas/efl_canvas_vg_gradient_linear.eo.h"
 #include "canvas/efl_canvas_vg_gradient_radial.eo.h"
-
-#include "canvas/efl_input_state.eo.h"
-#include "canvas/efl_input_event.eo.h"
-#include "canvas/efl_input_pointer.eo.h"
-#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"
-#include "canvas/efl_input_clickable.eo.h"
diff --git a/src/lib/evas/Evas_Internal.h b/src/lib/evas/Evas_Internal.h
index 15e4ed1e80..baf7cd5b16 100644
--- a/src/lib/evas/Evas_Internal.h
+++ b/src/lib/evas/Evas_Internal.h
@@ -32,6 +32,166 @@
 extern "C" {
 #endif
 
+
+#ifndef EFL_INTERNAL_UNSTABLE
+# error This file can not be included outside EFL
+#endif
+
+#include <Efl.h>
+
+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;
+typedef struct _Evas_Lock Evas_Lock;
+#endif
+
+struct _Efl_Input_Pointer_Data
+{
+   Eo             *eo;
+   unsigned int    timestamp; /* FIXME: store as double? */
+   int             button;
+   unsigned int    pressed_buttons;
+   int             touch_id; /* finger or tool ID */
+   double          radius, radius_x, radius_y;
+   double          pressure, distance, azimuth, tilt, twist;
+   double          angle;
+   /* current, previous positions in window coordinates.
+    * raw can be either un-smoothed, un-predicted x,y or a tablet's raw input.
+    * norm is the normalized value in [0..1] for tablet input.
+    */
+   Eina_Vector2    cur, prev, raw, norm;
+   struct {
+      int          z;
+      Eina_Bool    horizontal;
+   } wheel;
+   Efl_Gfx_Entity                    *source; /* could it be ecore? */
+   Efl_Input_Device           *device;
+   Efl_Pointer_Action          action;
+   Efl_Pointer_Flags           button_flags;
+   Efl_Input_Flags             event_flags;
+   void                       *data; /* evas data - whatever that is */
+   Eina_Bool                   window_pos; /* true if positions are window-relative
+                                              (see input vs. feed: this is "input") */
+   Evas_Modifier              *modifiers;
+   Evas_Lock                  *locks;
+   void                       *legacy; /* DO NOT TOUCH THIS */
+   uint32_t                    value_flags;
+   Eina_Bool                   has_norm : 1; /* not in value_flags */
+   Eina_Bool                   has_raw : 1; /* not in value_flags */
+   Eina_Bool                   evas_done : 1; /* set by evas */
+   Eina_Bool                   fake : 1;
+   Eina_Bool                   win_fed : 1;
+};
+
+struct _Efl_Input_Key_Data
+{
+   Eo                *eo;
+   unsigned int       timestamp; /* FIXME: store as double? */
+
+   Eina_Bool          pressed; /* 1 = pressed/down, 0 = released/up */
+   Eina_Stringshare  *keyname;
+   Eina_Stringshare  *key;
+   Eina_Stringshare  *string;
+   Eina_Stringshare  *compose;
+   unsigned int       keycode;
+
+   void              *data;
+   Evas_Modifier     *modifiers;
+   Evas_Lock         *locks;
+   Efl_Input_Flags    event_flags;
+   Efl_Input_Device  *device;
+   void              *legacy; /* DO NOT TOUCH THIS */
+   Eina_Bool          evas_done : 1; /* set by evas */
+   Eina_Bool          fake : 1;
+   Eina_Bool          win_fed : 1;
+   Eina_Bool          no_stringshare : 1;
+};
+
+struct _Efl_Input_Device_Data
+{
+   Eo               *eo;
+   Eo               *evas; /* Evas */
+   Efl_Input_Device *source;  /* ref */
+   Eina_List        *children; /* ref'ed by efl_parent, not by this list */
+   unsigned int      id;
+   Efl_Input_Device_Type klass;
+   unsigned int      subclass; // Evas_Device_Subclass (unused)
+   unsigned int      pointer_count;
+};
+
+struct _Efl_Input_Hold_Data
+{
+   Eo               *eo;
+   double            timestamp;
+   Efl_Input_Flags   event_flags;
+   Efl_Input_Device *device;
+   void             *data;
+   void             *legacy; /* DO NOT TOUCH THIS */
+   Eina_Bool         hold : 1;
+   Eina_Bool         evas_done : 1; /* set by evas */
+};
+
+struct _Efl_Input_Focus_Data
+{
+   Eo *eo;
+   Efl_Input_Device *device; //The seat
+   Eo *object_wref; // wref on the focused object - Efl.Canvas.Object or Efl.Canvas.
+   double timestamp;
+   Efl_Input_Flags   event_flags;
+};
+
+/* Internal helpers */
+
+static inline const char *
+_efl_input_modifier_to_string(Efl_Input_Modifier mod)
+{
+   switch (mod)
+     {
+      default:
+      case EFL_INPUT_MODIFIER_NONE:    return NULL;
+      case EFL_INPUT_MODIFIER_ALT:     return "Alt";
+      case EFL_INPUT_MODIFIER_CONTROL: return "Control";
+      case EFL_INPUT_MODIFIER_SHIFT:   return "Shift";
+      case EFL_INPUT_MODIFIER_META:    return "Meta";
+      case EFL_INPUT_MODIFIER_ALTGR:   return "AltGr";
+      case EFL_INPUT_MODIFIER_HYPER:   return "Hyper";
+      case EFL_INPUT_MODIFIER_SUPER:   return "Super";
+     }
+}
+
+static inline const char *
+_efl_input_lock_to_string(Efl_Input_Lock lock)
+{
+   switch (lock)
+     {
+      default:
+      case EFL_INPUT_LOCK_NONE:    return NULL;
+      case EFL_INPUT_LOCK_NUM:     return "Num";
+      case EFL_INPUT_LOCK_CAPS:    return "Caps";
+      case EFL_INPUT_LOCK_SCROLL:  return "Scroll";
+      case EFL_INPUT_LOCK_SHIFT:   return "Shift";
+     }
+}
+
+static inline Eina_Bool
+_efl_input_value_has(const Efl_Input_Pointer_Data *pd, Efl_Input_Value key)
+{
+   return (pd->value_flags & (1u << (int) key)) != 0;
+}
+
+static inline void
+_efl_input_value_mark(Efl_Input_Pointer_Data *pd, Efl_Input_Value key)
+{
+   pd->value_flags |= (1u << (int) key);
+}
+
+#define _efl_input_value_mask(key) (1u << (int) key)
+
 typedef struct _Efl_Canvas_Output Efl_Canvas_Output;
 
 EAPI Efl_Canvas_Output *efl_canvas_output_add(Evas *canvas);
diff --git a/src/lib/evas/canvas/efl_canvas_pointer.eo b/src/lib/evas/canvas/efl_canvas_pointer.eo
new file mode 100644
index 0000000000..f0c363a953
--- /dev/null
+++ b/src/lib/evas/canvas/efl_canvas_pointer.eo
@@ -0,0 +1,35 @@
+import efl_input_device;
+
+interface Efl.Canvas.Pointer
+{
+   [[Efl Canvas Pointer interface
+
+     @since 1.22
+   ]]
+   methods {
+      /* FIXME Efl.Input.Device is not stable yet*/
+      @property pointer_inside @beta {
+         [[Whether the mouse pointer is logically inside the canvas.
+
+           This value is $false or $true, depending on whether a pointer,in or pointer,out
+           event has been previously received.
+
+           A return value of $true indicates the mouse is logically
+           inside the canvas, and $false implies it is logically
+           outside the canvas.
+
+           A canvas begins with the mouse being assumed outside ($false).
+         ]]
+         get {
+         }
+         keys {
+            seat: Efl.Input.Device @optional; [[The seat to consider, if $null
+                     then the default seat will be used.]]
+         }
+         values {
+            inside: bool; [[$true if the mouse pointer is inside the canvas,
+                            $false otherwise]]
+         }
+      }
+   }
+}
diff --git a/src/lib/evas/canvas/efl_canvas_scene.eo b/src/lib/evas/canvas/efl_canvas_scene.eo
new file mode 100644
index 0000000000..b31f0ba3b4
--- /dev/null
+++ b/src/lib/evas/canvas/efl_canvas_scene.eo
@@ -0,0 +1,244 @@
+import efl_input_device;
+import efl_gfx_types;
+
+interface Efl.Canvas.Scene
+{
+   [[Interface containing basic canvas-related methods and events.
+
+     @since 1.22
+   ]]
+   methods {
+      @property image_max_size {
+         [[The maximum image size the canvas can possibly handle.
+
+           This function returns the largest image or surface size that
+           the canvas can handle in pixels, and if there is one, returns $true.
+           It returns $false if no extra constraint on maximum image
+           size exists.
+
+           The default limit is 65535x65535.
+
+         ]]
+         get {
+            return: bool; [[$true on success, $false otherwise]]
+         }
+         values {
+            max: Eina.Size2D; [[The maximum image size (in pixels).]]
+         }
+      }
+      group_objects_calculate {
+         [[Call user-provided $calculate group functions and unset the
+           flag signalling that the object needs to get recalculated to
+           all group objects in the canvas.
+         ]]
+      }
+      @property group_objects_calculating {
+         [[Get if the canvas is currently calculating group objects.]]
+         get {
+         }
+         values {
+            calculating: bool; [[$true if currently calculating group objects.]]
+         }
+      }
+      objects_at_xy_get {
+         [[Retrieve a list of objects at a given position in a canvas.
+
+           This function will traverse all the layers of the given canvas,
+           from top to bottom, querying for objects with areas covering the
+           given position. The user can exclude from the query objects which are
+           hidden and/or which are set to pass events.
+
+           Warning: This function will only evaluate top-level objects; child
+           or "sub" objects will be skipped.
+         ]]
+         return: iterator<Efl.Gfx.Entity> @move @no_unused; [[
+            The list of objects that are over the given position in $e.
+         ]]
+         params {
+            @in pos: Eina.Position2D; [[The pixel position.]]
+            @in include_pass_events_objects: bool; [[
+               Boolean flag to include or not objects which pass events
+               in this calculation.
+            ]]
+            @in include_hidden_objects: bool; [[
+               Boolean flag to include or not hidden objects in this
+               calculation.
+            ]]
+         }
+      }
+      object_top_at_xy_get @const {
+         [[Retrieve the object stacked at the top of a given position
+           in a canvas.
+
+           This function will traverse all the layers of the given canvas,
+           from top to bottom, querying for objects with areas covering the
+           given position. The user can exclude from the query objects which are
+           hidden and/or which are set to pass events.
+
+           Warning: This function will only evaluate top-level objects; child
+           or "sub" objects will be skipped.
+         ]]
+         return: Efl.Gfx.Entity @no_unused; [[The canvas object that is over all other objects at the given position.]]
+         params {
+            @in pos: Eina.Position2D; [[The pixel position.]]
+            @in include_pass_events_objects: bool; [[
+               Boolean flag to include or not objects which pass events
+               in this calculation.
+            ]]
+            @in include_hidden_objects: bool; [[
+               Boolean flag to include or not hidden objects in this
+               calculation.
+            ]]
+         }
+      }
+      objects_in_rectangle_get {
+         [[Retrieve a list of objects overlapping a given rectangular region in a canvas.
+
+           This function will traverse all the layers of the given canvas,
+           from top to bottom, querying for objects with areas overlapping
+           with the given rectangular region. The user can exclude
+           from the query objects which are hidden and/or which are set to
+           pass events.
+
+           Warning: This function will only evaluate top-level objects; child
+           or "sub" objects will be skipped.
+         ]]
+         return: iterator<Efl.Gfx.Entity> @move @no_unused; [[Iterator to objects]]
+         params {
+            @in rect: Eina.Rect; [[The rectangular region.]]
+            @in include_pass_events_objects: bool; [[
+               Boolean flag to include or not objects which pass events
+               in this calculation.
+            ]]
+            @in include_hidden_objects: bool; [[
+               Boolean flag to include or not hidden objects in this
+               calculation.
+            ]]
+         }
+      }
+      object_top_in_rectangle_get @const {
+         [[Retrieve the canvas object stacked at the top of a given
+           rectangular region in a canvas
+
+           This function will traverse all the layers of the given canvas,
+           from top to bottom, querying for objects with areas overlapping
+           with the given rectangular region. The user can exclude
+           from the query objects which are hidden and/or which are set to
+           pass events.
+
+           Warning: This function will only evaluate top-level objects; child
+           or "sub" objects will be skipped.
+         ]]
+         return: Efl.Gfx.Entity @no_unused; [[
+            The object that is over all other objects at the given
+            rectangular region.
+         ]]
+         params {
+            @in rect: Eina.Rect; [[The rectangular region.]]
+            @in include_pass_events_objects: bool; [[
+               Boolean flag to include or not objects which pass events
+               in this calculation.
+            ]]
+            @in include_hidden_objects: bool; [[
+               Boolean flag to include or not hidden objects in this
+               calculation.
+            ]]
+         }
+      }
+      /* FIXME Efl.Input.Device is not stable yet*/
+      seats @beta {
+         [[Iterate over the available input device seats for the canvas.
+
+           A "seat" is the term used for a group of input devices, typically including
+           a pointer and a keyboard. A seat object is the parent of the individual input
+           devices.
+         ]]
+         return: iterator<Efl.Input.Device> @move;
+            [[An iterator over the attached seats.]]
+      }
+      /* FIXME Efl.Input.Device is not stable yet*/
+      @property device @beta{
+         [[An input device attached to this canvas, found by name.
+
+           Note: This function is meant to find seats and not individual
+           input devices.
+
+           See also @.seat to find a seat by id instead of by name.
+         ]]
+         get {
+            [[Get a device by name.]]
+         }
+         keys {
+            name: string; [[The name of the seat to find.]]
+         }
+         values {
+            seat: Efl.Input.Device; [[The device or seat, $null if not found.]]
+         }
+      }
+      /* FIXME Efl.Input.Device is not stable yet*/
+      @property seat @beta {
+         [[Get a seat attached to this canvas using the seat's id property.
+
+           Seats are associated with an arbitrary integer id. The id is not a
+           persistent value and should never be hardcoded, as it may change between
+           runs of an application depending on the environment.
+
+           See also @.device to find a seat by name instead of by id.
+         ]]
+         get {
+            [[Get a seat by id.]]
+         }
+         keys {
+            id: int; [[The id of the seat to find.]]
+         }
+         values {
+            seat: Efl.Input.Device; [[The seat or $null if not found.]]
+         }
+      }
+      /* FIXME Efl.Input.Device is not stable yet*/
+      @property seat_default @beta {
+         [[Get the default seat attached to this canvas.
+
+           A canvas may have exactly one default seat.
+
+           See also @.device to find a seat by name.
+           See also @.seat to find a seat by id.
+         ]]
+         get {
+            [[Get the default seat.]]
+         }
+         values {
+            seat: Efl.Input.Device; [[The default seat or $null if one does not exist.]]
+         }
+      }
+      /* FIXME Efl.Input.Device is not stable yet*/
+      @property pointer_position @beta {
+         [[The current known pointer coordinates.
+
+           This function returns the current position of the main input
+           pointer (mouse, pen, etc...).
+         ]]
+         get {
+            return: bool; [[$true if a pointer exists for the given seat, otherwise $false.]]
+         }
+         keys {
+            seat: Efl.Input.Device; [[The seat, or $null to use the default.]]
+         }
+         values {
+            pos: Eina.Position2D; [[The pointer position in pixels.]]
+         }
+      }
+   }
+   events {
+      scene,focus,in: void; [[Called when scene got focus]]
+      scene,focus,out: void; [[Called when scene 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: void; [[Called when pre render happens]]
+      /* tag nullable once supported by eolian */
+      render,post @beta: Efl.Gfx.Event.Render_Post; [[Called when post render happens]]
+      device,changed @beta : Efl.Input.Device; [[Called when input device changed]]
+      device,added @beta: Efl.Input.Device; [[Called when input device was added]]
+      device,removed @beta : Efl.Input.Device; [[Called when input device was removed]]
+   }
+}
diff --git a/src/lib/evas/canvas/efl_input_device.c b/src/lib/evas/canvas/efl_input_device.c
new file mode 100644
index 0000000000..690db7698d
--- /dev/null
+++ b/src/lib/evas/canvas/efl_input_device.c
@@ -0,0 +1,230 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include "Evas.h"
+#define EFL_INTERNAL_UNSTABLE
+#include "Evas_Internal.h"
+
+#define MY_CLASS EFL_INPUT_DEVICE_CLASS
+
+/* Efl Input Device = Evas Device */
+
+typedef struct _Child_Device_Iterator Child_Device_Iterator;
+
+struct _Child_Device_Iterator
+{
+   Eina_Iterator  iterator;
+   Eina_List     *list;
+   Eina_Iterator *real_iterator;
+   Eo            *object;
+};
+
+static Eina_Bool
+_is_pointer(Efl_Input_Device_Data *pd)
+{
+   return (pd->klass == EFL_INPUT_DEVICE_TYPE_MOUSE ||
+           pd->klass == EFL_INPUT_DEVICE_TYPE_TOUCH ||
+           pd->klass == EFL_INPUT_DEVICE_TYPE_PEN ||
+           pd->klass == EFL_INPUT_DEVICE_TYPE_WAND);
+}
+
+static void
+_seat_pointers_update(Efl_Input_Device_Data *seat, Efl_Input_Device_Data *dev)
+{
+   if (seat && _is_pointer(dev))
+     seat->pointer_count++;
+}
+
+EOLIAN static Efl_Object *
+_efl_input_device_efl_object_constructor(Eo *obj, Efl_Input_Device_Data *pd)
+{
+   obj = efl_constructor(efl_super(obj, MY_CLASS));
+   pd->eo = obj;
+   return obj;
+}
+
+EOLIAN static void
+_efl_input_device_efl_object_destructor(Eo *obj, Efl_Input_Device_Data *pd)
+{
+   pd->children = eina_list_free(pd->children);
+   if (pd->klass != EFL_INPUT_DEVICE_TYPE_SEAT)
+     {
+        Efl_Input_Device_Data *p;
+        Eo *seat;
+
+        seat = efl_input_device_seat_get(obj);
+        p = efl_data_scope_get(seat, MY_CLASS);
+        if (p) p->children = eina_list_remove(p->children, obj);
+     }
+   efl_unref(pd->source);
+
+   return efl_destructor(efl_super(obj, MY_CLASS));
+}
+
+EOLIAN static void
+_efl_input_device_efl_object_parent_set(Eo *obj, Efl_Input_Device_Data *pd EINA_UNUSED, Eo *parent)
+{
+   Efl_Input_Device_Data *p;
+
+   if (parent)
+     {
+        if (efl_isa(parent, MY_CLASS))
+          {
+             p = efl_data_scope_get(parent, MY_CLASS);
+             EINA_SAFETY_ON_FALSE_RETURN(p->klass == EFL_INPUT_DEVICE_TYPE_SEAT);
+             if (!eina_list_data_find(p->children, obj))
+               {
+                  p->children = eina_list_append(p->children, obj);
+                  _seat_pointers_update(p, pd);
+               }
+          }
+        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;
+          }
+     }
+   else
+     {
+        Eo *old_parent = efl_parent_get(obj);
+        if (old_parent && efl_isa(old_parent, MY_CLASS))
+          {
+             p = efl_data_scope_get(old_parent, MY_CLASS);
+             p->children = eina_list_remove(p->children, obj);
+             if (_is_pointer(pd))
+               p->pointer_count--;
+          }
+     }
+
+   efl_parent_set(efl_super(obj, MY_CLASS), parent);
+}
+
+EOLIAN static void
+_efl_input_device_device_type_set(Eo *obj, Efl_Input_Device_Data *pd, Efl_Input_Device_Type klass)
+{
+   EINA_SAFETY_ON_TRUE_RETURN(pd->klass);
+   pd->klass = klass;
+   if (klass != EFL_INPUT_DEVICE_TYPE_SEAT)
+     {
+        Efl_Input_Device_Data *seat = efl_data_scope_get(efl_input_device_seat_get(obj), MY_CLASS);
+        _seat_pointers_update(seat, pd);
+     }
+}
+
+EOLIAN static Efl_Input_Device_Type
+_efl_input_device_device_type_get(const Eo *obj EINA_UNUSED, Efl_Input_Device_Data *pd)
+{
+   return pd->klass;
+}
+
+EOLIAN static void
+_efl_input_device_source_set(Eo *obj EINA_UNUSED, Efl_Input_Device_Data *pd, Efl_Input_Device *src)
+{
+   if (pd->source == src) return;
+   efl_unref(pd->source);
+   pd->source = efl_ref(src);
+}
+
+EOLIAN static Efl_Input_Device *
+_efl_input_device_source_get(const Eo *obj EINA_UNUSED, Efl_Input_Device_Data *pd)
+{
+   return pd->source;
+}
+
+EOLIAN static void
+_efl_input_device_seat_id_set(Eo *obj EINA_UNUSED, Efl_Input_Device_Data *pd, unsigned int id)
+{
+   EINA_SAFETY_ON_TRUE_RETURN(pd->klass != EFL_INPUT_DEVICE_TYPE_SEAT);
+   pd->id = id;
+}
+
+EOLIAN static unsigned int
+_efl_input_device_seat_id_get(const Eo *obj, Efl_Input_Device_Data *pd)
+{
+   if (pd->klass == EFL_INPUT_DEVICE_TYPE_SEAT)
+     return pd->id;
+   return efl_input_device_seat_id_get(efl_input_device_seat_get(obj));
+}
+
+EOLIAN static Efl_Input_Device *
+_efl_input_device_seat_get(const Eo *obj, Efl_Input_Device_Data *pd)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
+
+   if (pd->klass == EFL_INPUT_DEVICE_TYPE_SEAT)
+     return pd->eo;
+
+   while ((obj = efl_parent_get(obj)))
+     {
+        if (!efl_isa(obj, MY_CLASS)) break;
+        pd = efl_data_scope_get(obj, MY_CLASS);
+        if (pd->klass == EFL_INPUT_DEVICE_TYPE_SEAT)
+          return pd->eo;
+     }
+
+   return NULL;
+}
+
+static Eina_Bool
+_child_device_iterator_next(Child_Device_Iterator *it, void **data)
+{
+   Eo *sub;
+
+   if (!eina_iterator_next(it->real_iterator, (void **) &sub))
+     return EINA_FALSE;
+
+   if (data) *data = sub;
+   return EINA_TRUE;
+}
+
+static Eo *
+_child_device_iterator_get_container(Child_Device_Iterator *it)
+{
+   return it->object;
+}
+
+static void
+_child_device_iterator_free(Child_Device_Iterator *it)
+{
+   eina_iterator_free(it->real_iterator);
+   free(it);
+}
+
+EOLIAN static Eina_Iterator *
+_efl_input_device_children_iterate(Eo *obj, Efl_Input_Device_Data *pd)
+{
+   Child_Device_Iterator *it;
+
+   it = calloc(1, sizeof(*it));
+   if (!it) return NULL;
+
+   EINA_MAGIC_SET(&it->iterator, EINA_MAGIC_ITERATOR);
+
+   it->list = pd->children;
+   it->real_iterator = eina_list_iterator_new(it->list);
+   it->iterator.version = EINA_ITERATOR_VERSION;
+   it->iterator.next = FUNC_ITERATOR_NEXT(_child_device_iterator_next);
+   it->iterator.get_container = FUNC_ITERATOR_GET_CONTAINER(_child_device_iterator_get_container);
+   it->iterator.free = FUNC_ITERATOR_FREE(_child_device_iterator_free);
+   it->object = obj;
+
+   return &it->iterator;
+}
+
+EOLIAN static int
+_efl_input_device_pointer_device_count_get(const Eo *obj EINA_UNUSED, Efl_Input_Device_Data *pd)
+{
+   if (pd->klass == EFL_INPUT_DEVICE_TYPE_SEAT)
+     return pd->pointer_count;
+   return -1;
+}
+
+EOLIAN static Eina_Bool
+_efl_input_device_is_pointer_type_get(const Eo *obj EINA_UNUSED, Efl_Input_Device_Data *pd)
+{
+   return _is_pointer(pd);
+}
+
+
+#include "efl_input_device.eo.c"
diff --git a/src/lib/evas/canvas/efl_input_device.eo b/src/lib/evas/canvas/efl_input_device.eo
new file mode 100644
index 0000000000..dda39b1877
--- /dev/null
+++ b/src/lib/evas/canvas/efl_input_device.eo
@@ -0,0 +1,102 @@
+enum Efl.Input.Device_Type
+{
+   [[General type of input device.
+
+     Legacy support since 1.8 as $Evas_Device_Class.
+
+     @since 1.23
+   ]]
+   none,     [[Not a device.]]
+   seat,     [[The user/seat (the user themselves).]]
+   keyboard, [[A regular keyboard, numberpad or attached buttons.]]
+   mouse,    [[A mouse, trackball or touchpad relative motion device.]]
+   touch,    [[A touchscreen with fingers or stylus.]]
+   pen,      [[A special pen device.]]
+   wand,     [[A laser pointer, wii-style or "Minority Report" pointing device.]]
+   gamepad,  [[A gamepad controller or joystick.]]
+}
+
+/* TODO: Add canvas property. Current problem is we need to return
+         Efl.Ui.Win and not Evas:
+  @property canvas { values { canvas: Efl.Canvas; } }
+*/
+
+class Efl.Input.Device extends Efl.Object
+{
+   [[Represents a pointing device such as a touch finger, pen or mouse.
+
+     @since 1.23
+   ]]
+   methods {
+      @property device_type {
+          [[Device type property]]
+         values {
+            klass: Efl.Input.Device_Type; [[Input device class]]
+         }
+      }
+      @property source {
+          [[Device source property]]
+         values {
+            src: Efl.Input.Device; [[Input device]]
+         }
+      }
+      @property seat {
+         [[Get the @Efl.Input.Device that represents a seat.
+
+           This method will find the seat the device belongs to.
+
+           For this, it walk through device's parents looking for a device
+           with @Efl.Input.Device_Type.seat. It may be
+           the device itself.
+
+           In case no seat is found, $null is returned.
+         ]]
+         get {}
+         values {
+            seat: Efl.Input.Device; [[The seat this device belongs to.]]
+         }
+      }
+      @property seat_id {
+         [[Seat id number
+         ]]
+          values {
+             id: uint; [[The id of the seat]]
+          }
+      }
+      children_iterate {
+         [[Lists the children attached to this device.
+
+           This is only meaningful with seat devices, as they are groups of
+           real input devices.
+         ]]
+         return: iterator<const(Efl.Input.Device)> @move; [[List of device children]]
+      }
+      @property pointer_device_count {
+         [[The number of pointer devices in this seat.
+
+           Pointer devices are the ones whose @.device_type is $mouse, $pen, $touch or $wand.
+           In case this device is not of the type $seat, -1 is returned.
+         ]]
+         get {
+
+         }
+         values {
+            devices : int; [[The number of pointer devices.]]
+         }
+      }
+      @property is_pointer_type {
+         [[$true if @.device_type is $mouse, $pen, $touch or $wand.]]
+         get {
+
+         }
+         values {
+            pointer_type : bool; [[$true if the device has pointing capabilities.]]
+         }
+      }
+   }
+   implements {
+      Efl.Object.constructor;
+      Efl.Object.destructor;
+      Efl.Object.parent { set; }
+   }
+}
diff --git a/src/lib/evas/canvas/efl_input_event.c b/src/lib/evas/canvas/efl_input_event.c
index 3274b31a8e..90bddde143 100644
--- a/src/lib/evas/canvas/efl_input_event.c
+++ b/src/lib/evas/canvas/efl_input_event.c
@@ -5,12 +5,10 @@
 #define EFL_INPUT_EVENT_PROTECTED
 
 #include <Evas.h>
+#define EFL_INTERNAL_UNSTABLE
 #include <Evas_Internal.h>
 #include "canvas/evas_canvas_eo.h"
 
-#define EFL_INTERNAL_UNSTABLE
-#include "interfaces/efl_common_internal.h"
-
 #define MY_CLASS EFL_INPUT_EVENT_MIXIN
 
 EOLIAN static void
diff --git a/src/lib/evas/canvas/efl_input_focus.c b/src/lib/evas/canvas/efl_input_focus.c
index d7b18dec53..cb154a0017 100644
--- a/src/lib/evas/canvas/efl_input_focus.c
+++ b/src/lib/evas/canvas/efl_input_focus.c
@@ -9,11 +9,6 @@
 
 #include <Evas.h>
 
-#include <Evas_Internal.h>
-
-#define EFL_INTERNAL_UNSTABLE
-#include "interfaces/efl_common_internal.h"
-
 #define MY_CLASS EFL_INPUT_FOCUS_CLASS
 
 static void
diff --git a/src/lib/evas/canvas/efl_input_hold.c b/src/lib/evas/canvas/efl_input_hold.c
index c23f043ad1..b5ad65b644 100644
--- a/src/lib/evas/canvas/efl_input_hold.c
+++ b/src/lib/evas/canvas/efl_input_hold.c
@@ -7,9 +7,6 @@
 #include "evas_common_private.h"
 #include "evas_private.h"
 
-#define EFL_INTERNAL_UNSTABLE
-#include "interfaces/efl_common_internal.h"
-
 #define MY_CLASS EFL_INPUT_HOLD_CLASS
 
 EOLIAN static void
diff --git a/src/lib/evas/canvas/efl_input_key.c b/src/lib/evas/canvas/efl_input_key.c
index 07d5a63776..79c833ccda 100644
--- a/src/lib/evas/canvas/efl_input_key.c
+++ b/src/lib/evas/canvas/efl_input_key.c
@@ -7,9 +7,6 @@
 #include "evas_common_private.h"
 #include "evas_private.h"
 
-#define EFL_INTERNAL_UNSTABLE
-#include "interfaces/efl_common_internal.h"
-
 #define MY_CLASS EFL_INPUT_KEY_CLASS
 
 EOAPI Eo*
diff --git a/src/lib/evas/canvas/efl_input_pointer.c b/src/lib/evas/canvas/efl_input_pointer.c
index 8b16c5767a..33cb80ce68 100644
--- a/src/lib/evas/canvas/efl_input_pointer.c
+++ b/src/lib/evas/canvas/efl_input_pointer.c
@@ -7,9 +7,6 @@
 #include "evas_common_private.h"
 #include "evas_private.h"
 
-#define EFL_INTERNAL_UNSTABLE
-#include "interfaces/efl_common_internal.h"
-
 #define MY_CLASS EFL_INPUT_POINTER_CLASS
 
 
diff --git a/src/lib/evas/canvas/efl_input_types.eot b/src/lib/evas/canvas/efl_input_types.eot
new file mode 100644
index 0000000000..a716686528
--- /dev/null
+++ b/src/lib/evas/canvas/efl_input_types.eot
@@ -0,0 +1,178 @@
+enum Efl.Pointer.Action
+{
+   [[Pointer event type. Represents which kind of event this is.
+
+     @since 1.19
+   ]]
+   none,   [[Not a valid event, or nothing new happened (eg. when querying
+             current state of touch points).]]
+   move,   [[Mouse or equivalent pointer moved.]]
+   down,   [[Mouse button or equivalent pointer pressed down.
+             Always followed by up or cancel.]]
+   up,     [[Mouse button or equivalent pointer released. See also cancel.]]
+   cancel, [[Special event happening after a down if the up counterpart
+             can not happen (eg. another window forcibly stole the focus).]]
+   in,     [[Mouse or pointer entered the object.]]
+   out,    [[Mouse or pointer exited the object.]]
+   wheel,  [[Mouse wheel scroll, horizontally or vertically.]]
+   axis,   [[Axis event (pen, stick, ...).]]
+}
+
+enum Efl.Pointer.Flags
+{
+   [[Pointer flags indicating whether a double or triple click is under way.
+
+     @since 1.19
+   ]]
+   none = 0,                [[No extra mouse button data]]
+   double_click = (1 << 0), [[This mouse button press was the 2nd press of a double click]]
+   triple_click = (1 << 1), [[This mouse button press was the 3rd press of a triple click]]
+}
+
+enum Efl.Input.Flags
+{
+   [[Special flags set during an input event propagation.
+
+     @since 1.19
+   ]]
+   none = 0,             [[No fancy flags set]]
+   processed = (1 << 0), [[This event is being delivered and has been processed,
+                           so it should be put "on hold" until the flag is unset.
+                           The event should be used for informational purposes
+                           and maybe some indications visually, but not
+                           actually perform anything.]]
+   scrolling = (1 << 1), [[This event flag indicates the event occurs while
+                           scrolling; for example, DOWN event occurs during
+                           scrolling. The event should be used for informational
+                           purposes and maybe some indications visually, but not
+                           actually perform anything.]]
+}
+
+enum @beta Efl.Input.Object_Pointer_Mode {
+   [[How the mouse pointer should be handled by EFL.
+
+     In the mode $autograb, when a mouse button is pressed down over an
+     object and held down, with the mouse pointer being moved outside of it,
+     the pointer still behaves as being bound to that object, albeit out
+     of its drawing region. When the button is released, the event will
+     be fed to the object, that may check if the final position is over it
+     or not and do something about it.
+
+     In the mode $nograb, the pointer will always be bound to the object
+     right below it.
+
+     @since 1.19
+   ]]
+   auto_grab, [[Default, X11-like.]]
+   no_grab,   [[Pointer always bound to the object right below it.]]
+   no_grab_no_repeat_updown [[Useful on object with "repeat events" enabled,
+                              where mouse/touch up and down events WON'T be
+                              repeated to objects and these objects wont be
+                              auto-grabbed.
+
+                              @since 1.2
+                            ]]
+}
+
+enum @beta Efl.Input.Value  {
+   [[Keys for the generic values of all events.
+
+     @since 1.19
+   ]]
+   none,       [[Not a valid value type.]]
+   timestamp,  [[Timestamp of this event in seconds.]]
+   button,     [[ID of the button that triggered this event (unsigned int).
+                 Prefer the method $button to read this value. Default: 0.]]
+   buttons_pressed, [[32-bit bit mask (unsigned int). Prefer the
+                      method $buttons_pressed to read this value. Default: 0.]]
+   touch_id,       [[ID of the finger or tool (eg. pen) that triggered this event.
+                     Prefer the property $touch_id to read this value. Default: 0.]]
+   x,          [[Absolute X position where this event occurred, in pixels.
+                 Relative to the window. Default: last known position.
+                 This value may be smoothed out or even extrapolated by EFL.]]
+   y,          [[Absolute Y position where this event occurred, in pixels.
+                 Relative to the window. Default: last known position.
+                 This value may be smoothed out or even extrapolated by EFL.]]
+   dx,         [[Relative X movement, in pixels. Range: unbounded. Default: 0.]]
+   dy,         [[Relative Y movement, in pixels. Range: unbounded. Default: 0.]]
+   previous_x, [[Previous X position of the pointer, in pixels.
+                 Default: last known position, may be equal to x.]]
+   previous_y, [[Previous Y position of the pointer, in pixels.
+                 Default: last known position, may be equal to y.]]
+   raw_x,      [[Absolute X position where this event occurred. Default: 0.
+                 This value will be set from the hardware input without any
+                 smoothing or extrapolation. For an axis input event, this is
+                 the raw value set by the driver (undefined range and unit).]]
+   raw_y,      [[Absolute X position where this event occurred. Default: 0.
+                 This value will be set from the hardware input without any
+                 smoothing or extrapolation. For an axis input event, this is
+                 the raw value set by the driver (undefined range and unit).]]
+   radius,     [[Average radius of the pressed area under a finger or tool,
+                 in pixels. Default is 1.]]
+   radius_x,   [[Spread over X of the pressed area under a finger or tool,
+                 in pixels. Default is 1.]]
+   radius_y,   [[Spread over Y of the pressed area under a finger or tool,
+                 in pixels. Default is 1.]]
+   pressure,   [[Pressure applied to the button, touch or pen tip.
+                 Range: [0, 1]. Default is 1.]]
+   distance,   [[Relative distance along physical Z axis. Range: [0, 1].
+                 Default is 0.]]
+   azimuth,    [[Angle of tool about the Z axis from positive X axis.
+                 Range: [-PI, PI]. Unit: Radians.]]
+   tilt,       [[Angle of tool about plane of sensor from positive Z axis.
+                 Range: [0.0, PI]. Unit: Radians.]]
+   tilt_x,     [[Current tilt along the X axis of the tablet's current logical
+                 orientation, in radians off the tablet's Z axis.
+                 Range: [-PI, PI]. Unit: Radians.]]
+   tilt_y,     [[Current tilt along the Y axis of the tablet's current logical
+                 orientation, in radians off the tablet's Z axis.
+                 Range: [-PI, PI]. Unit: Radians.]]
+   twist,      [[Rotation of tool about its major axis from its "natural"
+                 position. Range: [-PI, PI] Unit: Radians.]]
+   wheel_delta, [[Delta movement of the wheel in discrete steps (int).
+                  Default: 0.]]
+   wheel_angle, [[Delta movement of the wheel in radians. Default: 0.]]
+   wheel_horizontal, [[Direction of the wheel (horizontal = 1 or vertical = 0).
+                       Default: 0. Prefer the property $wheel_horizontal to read.]]
+   slider,     [[Current position of the slider on the tool. Range: [-1, 1].
+                 Default: 0.]]
+}
+
+enum Efl.Input.Modifier {
+   [[Key modifiers such as Control, Alt, etc...
+
+     This enum may be used as a bitmask with OR operations, depending on the
+     API.
+
+     The available keys may vary depending on the physical keyboard layout, or
+     language and keyboard settings, or depending on the platform.
+
+     @since 1.20
+   ]]
+   none    = 0,      [[No key modifier]]
+   alt     = 1 << 0, [[Alt key modifier]]
+   control = 1 << 1, [[Control key modifier ("Ctrl" key)]]
+   shift   = 1 << 2, [[Shift key modifier]]
+   meta    = 1 << 3, [[Meta key modifier (often the "Windows" key)]]
+   altgr   = 1 << 4, [[AltGr key modifier (not present on all keyboards)]]
+   hyper   = 1 << 5, [[Hyper key modifier (may be "Windows" key)]]
+   super   = 1 << 6, [[Super key modifier (may be "Windows" key)]]
+}
+
+enum Efl.Input.Lock {
+   [[Key locks such as Num Lock, Scroll Lock and Caps Lock.
+
+     This enum may be used as a bitmask with OR operations, depending on the
+     API.
+
+     The available keys may vary depending on the physical keyboard layout, or
+     language and keyboard settings, or depending on the platform.
+
+     @since 1.20
+   ]]
+   none    = 0,      [[No key modifier]]
+   num     = 1 << 0, [[Num Lock for numeric key pad use]]
+   caps    = 1 << 1, [[Caps Lock for writing in all caps]]
+   scroll  = 1 << 2, [[Scroll Lock]]
+   shift   = 1 << 3, [[Shift Lock]]
+}
diff --git a/src/lib/evas/canvas/evas_callbacks.c b/src/lib/evas/canvas/evas_callbacks.c
index 65b78f2bcd..d19ce686da 100644
--- a/src/lib/evas/canvas/evas_callbacks.c
+++ b/src/lib/evas/canvas/evas_callbacks.c
@@ -2,9 +2,6 @@
 #include "evas_common_private.h"
 #include "evas_private.h"
 
-#define EFL_INTERNAL_UNSTABLE
-#include "interfaces/efl_common_internal.h"
-
 EVAS_MEMPOOL(_mp_pc);
 
 extern Eina_Hash* signals_hash_table;
diff --git a/src/lib/evas/canvas/evas_device.c b/src/lib/evas/canvas/evas_device.c
index 660f657158..5f5e1aaba8 100644
--- a/src/lib/evas/canvas/evas_device.c
+++ b/src/lib/evas/canvas/evas_device.c
@@ -1,9 +1,6 @@
 #include "evas_common_private.h"
 #include "evas_private.h"
 
-#define EFL_INTERNAL_UNSTABLE
-#include "interfaces/efl_common_internal.h"
-
 /* WARNING: This API is not used across EFL, hard to test! */
 
 #ifdef DEBUG_UNTESTED_
diff --git a/src/lib/evas/canvas/evas_events.c b/src/lib/evas/canvas/evas_events.c
index 46a765e32c..bb8c9346fb 100644
--- a/src/lib/evas/canvas/evas_events.c
+++ b/src/lib/evas/canvas/evas_events.c
@@ -3,9 +3,6 @@
 #include "evas_common_private.h"
 #include "evas_private.h"
 
-#define EFL_INTERNAL_UNSTABLE
-#include "interfaces/efl_common_internal.h"
-
 int _evas_event_counter = 0;
 
 static Eina_List *
diff --git a/src/lib/evas/canvas/evas_events_legacy.c b/src/lib/evas/canvas/evas_events_legacy.c
index 4675735727..1204800631 100644
--- a/src/lib/evas/canvas/evas_events_legacy.c
+++ b/src/lib/evas/canvas/evas_events_legacy.c
@@ -1,9 +1,6 @@
 #include "evas_common_private.h"
 #include "evas_private.h"
 
-#define EFL_INTERNAL_UNSTABLE
-#include "interfaces/efl_common_internal.h"
-
 typedef union {
    Evas_Event_Mouse_Down down;
    Evas_Event_Mouse_Up up;
diff --git a/src/lib/evas/canvas/evas_focus.c b/src/lib/evas/canvas/evas_focus.c
index d76c1042dc..e11df7887d 100644
--- a/src/lib/evas/canvas/evas_focus.c
+++ b/src/lib/evas/canvas/evas_focus.c
@@ -3,8 +3,6 @@
 
 #include "evas_common_private.h"
 #include "evas_private.h"
-#include "interfaces/efl_common_internal.h"
-
 
 static int evas_focus_log_domain = -1;
 
diff --git a/src/lib/evas/canvas/evas_key_grab.c b/src/lib/evas/canvas/evas_key_grab.c
index aaf6e6a2d0..5c8969ccb4 100644
--- a/src/lib/evas/canvas/evas_key_grab.c
+++ b/src/lib/evas/canvas/evas_key_grab.c
@@ -1,9 +1,6 @@
 #include "evas_common_private.h"
 #include "evas_private.h"
 
-#define EFL_INTERNAL_UNSTABLE
-#include "interfaces/efl_common_internal.h"
-
 /* private calls */
 
 /* FIXME: this is not optimal, but works. i should have a hash of keys per */
diff --git a/src/lib/evas/canvas/evas_main.c b/src/lib/evas/canvas/evas_main.c
index 92c9ed2334..6d4c07c95e 100644
--- a/src/lib/evas/canvas/evas_main.c
+++ b/src/lib/evas/canvas/evas_main.c
@@ -16,9 +16,6 @@
 
 #include <Ecore.h>
 
-#define EFL_INTERNAL_UNSTABLE
-#include "interfaces/efl_common_internal.h"
-
 #define MY_CLASS EVAS_CANVAS_CLASS
 
 #ifdef LKDEBUG
@@ -2052,3 +2049,5 @@ _evas_canvas_efl_object_event_callback_array_priority_add(Eo *obj, Evas_Public_D
 
 #include "evas_stack.x"
 #include "canvas/evas_canvas_eo.c"
+#include "efl_canvas_pointer.eo.c"
+#include "efl_canvas_scene.eo.c"
diff --git a/src/lib/evas/canvas/meson.build b/src/lib/evas/canvas/meson.build
index 758a8db064..1edaeca69e 100644
--- a/src/lib/evas/canvas/meson.build
+++ b/src/lib/evas/canvas/meson.build
@@ -28,6 +28,9 @@ pub_eo_files = [
   'efl_input_hold.eo',
   'efl_input_focus.eo',
   'efl_input_clickable.eo',
+  'efl_input_device.eo',
+  'efl_canvas_pointer.eo',
+  'efl_canvas_scene.eo',
   'efl_canvas_animation.eo',
   'efl_canvas_animation_alpha.eo',
   'efl_canvas_animation_rotate.eo',
@@ -52,7 +55,7 @@ pub_eo_files = [
   'efl_canvas_group.eo',
   'efl_gfx_mapping.eo',
   'efl_canvas_event_grabber.eo',
-  'efl_canvas_text.eo'
+  'efl_canvas_text.eo',
 ]
 
 evas_canvas_eo_files = pub_eo_files
@@ -76,7 +79,8 @@ endforeach
 
 pub_eo_types_files = [
     'evas_canvas3d_types.eot',
-    'efl_canvas_animation_types.eot'
+    'efl_canvas_animation_types.eot',
+    'efl_input_types.eot',
 ]
 
 evas_canvas_eot_files = pub_eo_types_files
@@ -171,6 +175,7 @@ evas_src += files([
   'efl_input_hold.c',
   'efl_input_focus.c',
   'efl_input_clickable.c',
+  'efl_input_device.c',
   'efl_canvas_animation.c',
   'efl_canvas_animation_alpha.c',
   'efl_canvas_animation_rotate.c',
diff --git a/src/lib/evas/gesture/efl_canvas_gesture_private.h b/src/lib/evas/gesture/efl_canvas_gesture_private.h
index ceb7ca7d42..a835c3093d 100644
--- a/src/lib/evas/gesture/efl_canvas_gesture_private.h
+++ b/src/lib/evas/gesture/efl_canvas_gesture_private.h
@@ -3,8 +3,6 @@
 
 #include "evas_common_private.h"
 #include "evas_private.h"
-#define EFL_INTERNAL_UNSTABLE
-#include "interfaces/efl_common_internal.h"
 
 #include "efl_gesture_events.eo.h"
 
diff --git a/src/lib/evas/include/evas_common_private.h b/src/lib/evas/include/evas_common_private.h
index 59eb800724..5fecf3f157 100644
--- a/src/lib/evas/include/evas_common_private.h
+++ b/src/lib/evas/include/evas_common_private.h
@@ -54,6 +54,7 @@
 
 #include "Evas.h"
 
+#define EFL_INTERNAL_UNSTABLE
 #include "Evas_Internal.h"
 
 #include "../common/evas_font.h"