e_input: Add a new API for getting client geometry

Change-Id: I5dc83150641ae1b84fb8f584a1690d14581e7fb2

diff --git a/src/bin/compmgr/e_comp_object.c b/src/bin/compmgr/e_comp_object.c
index 59ad60d46735804ee9dc4f9973dbb6da6e552acc..d041d9430750a0ebb77f381880961adb4dd431f5 100644 (file)
--- a/src/bin/compmgr/e_comp_object.c
+++ b/src/bin/compmgr/e_comp_object.c
@@ -16,6 +16,8 @@
 #include "e_theme_intern.h"
 #include "e_config_intern.h"
 #include "e_compositor_intern.h"
+#include "e_input_thread_client_intern.h"
+#include "e_input_backend_intern.h"
 
 /* data keys:
 
@@ -2679,6 +2681,16 @@ _e_comp_smart_show(Evas_Object *obj)
    TRACE_DS_END();
 }
 
+static void
+_e_comp_object_input_thread_frame_set(void *data)
+{
+   E_Input_Thread_Request_EClient_Data *ec_data = data;
+   EINA_SAFETY_ON_NULL_RETURN(ec_data);
+
+   INF("[input thread|%s] ec(%p), frame(%p)\n", __func__, ec_data->ec, ec_data->frame);
+   e_input_thread_client_frame_set(e_input_thread_client_get(ec_data->ec), ec_data->frame);
+}
+
 static void
 _e_comp_smart_del(Evas_Object *obj)
 {
@@ -2745,6 +2757,17 @@ _e_comp_smart_del(Evas_Object *obj)
         e_object_unref(E_OBJECT(cw->ec));
      }
    cw->ec->frame = NULL;
+   if (e_input_thread_check_client_cloning_needed())
+     {
+        E_Input_Thread_Request_EClient_Data ec_data;
+        memset(&ec_data, 0, sizeof(E_Input_Thread_Request_EClient_Data));
+        ec_data.ec = cw->ec;
+        ec_data.frame = NULL;
+
+        INF("[%s] ec(%p), frame(NULL)\n", __func__, cw->ec);
+        e_input_backend_thread_safe_call(_e_comp_object_input_thread_frame_set, &ec_data, sizeof(E_Input_Thread_Request_EClient_Data));
+     }
+
    free(cw);
 }
 
@@ -3146,6 +3169,17 @@ e_comp_object_client_add(E_Client *ec)
 
    _e_comp_object_event_add(o);
 
+   if (e_input_thread_check_client_cloning_needed())
+     {
+        E_Input_Thread_Request_EClient_Data ec_data;
+        memset(&ec_data, 0, sizeof(E_Input_Thread_Request_EClient_Data));
+        ec_data.ec = ec;
+        ec_data.frame = ec->frame;
+
+        INF("[%s] ec(%p), frame(%p)\n", __func__, ec, ec->frame);
+        e_input_backend_thread_safe_call(_e_comp_object_input_thread_frame_set, &ec_data, sizeof(E_Input_Thread_Request_EClient_Data));
+     }
+
    return o;
 }
 

diff --git a/src/bin/core/e_client.c b/src/bin/core/e_client.c
index ee9054cec87b557dfac3542d5375c7b94163f6e1..1844efbc4864040ee9858feae60254b72a6ef994 100644 (file)
--- a/src/bin/core/e_client.c
+++ b/src/bin/core/e_client.c
@@ -1140,6 +1140,7 @@ _e_input_thread_client_del(void *data)
    EINA_SAFETY_ON_NULL_RETURN(ec_data);
 
    INF("[input thread|%s] ec: %p\n", __func__, ec_data->ec);
+   e_input_thread_client_transform_core_enable_set(e_input_thread_client_get(ec_data->ec), ec_data->transform_core.result.enable);
    e_input_thread_client_del(e_input_thread_client_get(ec_data->ec));
 }
 
@@ -1229,6 +1230,7 @@ _e_client_del(E_Client *ec)
    if (e_input_thread_check_client_cloning_needed())
      {
         ec_data.ec = ec;
+        ec_data.transform_core.result.enable = EINA_FALSE;
         INF("[%s] ec: %p\n", __func__, ec);
         e_input_backend_thread_safe_call(_e_input_thread_client_del, &ec_data, sizeof(E_Input_Thread_Request_EClient_Data));
      }
@@ -2024,6 +2026,26 @@ _e_client_cb_evas_move(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UN
    e_comp_visibility_calculation_set(EINA_TRUE);
 }
 
+static void
+_e_client_input_thread_eo_geometry_set(void *data)
+{
+   E_Input_Thread_Request_EClient_Data *ec_data = data;
+   EINA_SAFETY_ON_NULL_RETURN(ec_data);
+
+   INF("[input thread|%s] ec(%p), eo.x(%d), eo.y(%d), eo.w(%d), eo.h(%d)\n",
+       __func__,
+       ec_data->ec,
+       ec_data->eo_geometry.x,
+       ec_data->eo_geometry.y,
+       ec_data->eo_geometry.w,
+       ec_data->eo_geometry.h);
+   e_input_thread_client_eo_geometry_set(e_input_thread_client_get(ec_data->ec),
+                                         ec_data->eo_geometry.x,
+                                         ec_data->eo_geometry.y,
+                                         ec_data->eo_geometry.w,
+                                         ec_data->eo_geometry.h);
+}
+
 static void
 _e_client_cb_evas_resize(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
 {
@@ -2068,6 +2090,20 @@ _e_client_cb_evas_resize(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_
 
    e_client_transform_core_update(ec);
    e_comp_visibility_calculation_set(EINA_TRUE);
+
+   if (e_input_thread_check_client_cloning_needed())
+     {
+        E_Input_Thread_Request_EClient_Data ec_data;
+        memset(&ec_data, 0, sizeof(E_Input_Thread_Request_EClient_Data));
+        ec_data.ec = ec;
+        ec_data.eo_geometry.x = x;
+        ec_data.eo_geometry.y = y;
+        ec_data.eo_geometry.w = w;
+        ec_data.eo_geometry.h = h;
+
+        INF("[%s] ec(%p), eo.x(%d), eo.y(%d), eo.w(%d), eo.h(%d)\n", __func__, ec, x, y, w, h);
+        e_input_backend_thread_safe_call(_e_client_input_thread_eo_geometry_set, &ec_data, sizeof(E_Input_Thread_Request_EClient_Data));
+     }
 }
 
 static void
@@ -2732,6 +2768,26 @@ _e_client_transform_core_check_change(E_Client *ec)
    return check;
 }
 
+static void
+_e_client_input_thread_boundary_set(void *data)
+{
+   E_Input_Thread_Request_EClient_Data *ec_data = data;
+   EINA_SAFETY_ON_NULL_RETURN(ec_data);
+
+   INF("[input thread|%s] ec(%p), boundary.x(%d), boundary.y(%d), boundary.w(%d), boundary.h(%d)\n",
+       __func__,
+       ec_data->ec,
+       ec_data->transform_core.result.boundary.x,
+       ec_data->transform_core.result.boundary.y,
+       ec_data->transform_core.result.boundary.w,
+       ec_data->transform_core.result.boundary.h);
+   e_input_thread_client_transform_core_boundary_set(e_input_thread_client_get(ec_data->ec),
+                                                     ec_data->transform_core.result.boundary.x,
+                                                     ec_data->transform_core.result.boundary.y,
+                                                     ec_data->transform_core.result.boundary.w,
+                                                     ec_data->transform_core.result.boundary.h);
+}
+
 static void
 _e_client_transform_core_boundary_update(E_Client *ec, E_Util_Transform_Rect_Vertex *vertices)
 {
@@ -2769,6 +2825,26 @@ _e_client_transform_core_boundary_update(E_Client *ec, E_Util_Transform_Rect_Ver
          ec->transform_core.result.boundary.y,
          ec->transform_core.result.boundary.w,
          ec->transform_core.result.boundary.h);
+
+   if (e_input_thread_check_client_cloning_needed())
+     {
+        E_Input_Thread_Request_EClient_Data ec_data;
+        memset(&ec_data, 0, sizeof(E_Input_Thread_Request_EClient_Data));
+        ec_data.ec = ec;
+        ec_data.transform_core.result.boundary.x = ec->transform_core.result.boundary.x;
+        ec_data.transform_core.result.boundary.y = ec->transform_core.result.boundary.y;
+        ec_data.transform_core.result.boundary.w = ec->transform_core.result.boundary.w;
+        ec_data.transform_core.result.boundary.h = ec->transform_core.result.boundary.h;
+
+        INF("[%s] ec(%p), boundary.x(%d), boundary.y(%d), boundary.w(%d), boundary.h(%d)\n",
+             __func__,
+            ec,
+            ec->transform_core.result.boundary.x,
+            ec->transform_core.result.boundary.y,
+            ec->transform_core.result.boundary.w,
+            ec->transform_core.result.boundary.h);
+        e_input_backend_thread_safe_call(_e_client_input_thread_boundary_set, &ec_data, sizeof(E_Input_Thread_Request_EClient_Data));
+     }
 }
 
 static E_Map *
@@ -3232,6 +3308,7 @@ _e_input_thread_client_new(void *data)
 
    INF("[input thread|%s] ec(%p), surface(%p)\n", __func__, ec_data->ec, ec_data->wl_surface);
    e_input_thread_client_new(ec_data->ec, ec_data->wl_surface);
+   e_input_thread_client_size_set(e_input_thread_client_get(ec_data->ec), ec_data->w, ec_data->h);
 }
 
 static void
@@ -3244,6 +3321,8 @@ _e_client_input_thread_clone_new(E_Client *ec)
 
    ec_new_data.ec = ec;
    ec_new_data.wl_surface = ec->comp_data ? ec->comp_data->wl_surface : NULL;
+   ec_new_data.w = 1;
+   ec_new_data.h = 1;
 
    INF("[%s] ec(%p), surface(%p)\n", __func__, ec, ec_new_data.wl_surface);
    e_input_backend_thread_safe_call(_e_input_thread_client_new, &ec_new_data, sizeof(E_Input_Thread_Request_EClient_Data));
@@ -3387,6 +3466,22 @@ e_client_new(E_Pixmap *cp, int first_map, int internal)
         evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_MOVE, _e_client_cb_evas_move, ec);
         evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_RESIZE, _e_client_cb_evas_resize, ec);
         evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_RESTACK, _e_client_cb_evas_restack, ec);
+
+        if (e_input_thread_check_client_cloning_needed())
+          {
+             Evas_Coord x, y, w, h;
+             E_Input_Thread_Request_EClient_Data ec_data;
+             memset(&ec_data, 0, sizeof(E_Input_Thread_Request_EClient_Data));
+             e_view_client_geometry_get(PRI(ec)->view_client, &x, &y, &w, &h);
+             ec_data.ec = ec;
+             ec_data.eo_geometry.x = x;
+             ec_data.eo_geometry.y = y;
+             ec_data.eo_geometry.w = w;
+             ec_data.eo_geometry.h = h;
+
+             INF("[%s] ec(%p), eo.x(%d), eo.y(%d), eo.w(%d), eo.h(%d)\n", __func__, ec, x, y, w, h);
+             e_input_backend_thread_safe_call(_e_client_input_thread_eo_geometry_set, &ec_data, sizeof(E_Input_Thread_Request_EClient_Data));
+          }
      }
 
    _e_client_hook_call(E_CLIENT_HOOK_NEW_CLIENT_POST, ec);
@@ -3673,12 +3768,34 @@ e_client_res_change_geometry_restore(E_Client *ec)
    memcpy(&ec->pre_res_change, &pre_res_change, sizeof(pre_res_change));
 }
 
+static void
+_e_client_input_thread_pos_set(void *data)
+{
+   E_Input_Thread_Request_EClient_Data *ec_data = data;
+   EINA_SAFETY_ON_NULL_RETURN(ec_data);
+
+   INF("[input thread|%s] ec(%p), x(%d), y(%d)\n", __func__, ec_data->ec, ec_data->x, ec_data->y);
+   e_input_thread_client_position_set(e_input_thread_client_get(ec_data->ec), ec_data->x, ec_data->y);
+}
+
 E_API void
 e_client_pos_set(E_Client *ec, int x, int y)
 {
    if (!ec) return;
    ec->x = x;
    ec->y = y;
+
+   if (e_input_thread_check_client_cloning_needed())
+     {
+        E_Input_Thread_Request_EClient_Data ec_data;
+        memset(&ec_data, 0, sizeof(E_Input_Thread_Request_EClient_Data));
+        ec_data.ec = ec;
+        ec_data.x = x;
+        ec_data.y = y;
+
+        INF("[%s] ec(%p), x(%d), y(%d)\n", __func__, ec, x, y);
+        e_input_backend_thread_safe_call(_e_client_input_thread_pos_set, &ec_data, sizeof(E_Input_Thread_Request_EClient_Data));
+     }
 }
 
 E_API void
@@ -3697,12 +3814,34 @@ e_client_pos_get(E_Client *ec, int *x, int *y)
    if (y) *y = ey;
 }
 
+static void
+_e_client_input_thread_size_set(void *data)
+{
+   E_Input_Thread_Request_EClient_Data *ec_data = data;
+   EINA_SAFETY_ON_NULL_RETURN(ec_data);
+
+   INF("[input thread|%s] ec(%p), w(%d), h(%d)\n", __func__, ec_data->ec, ec_data->w, ec_data->h);
+   e_input_thread_client_size_set(e_input_thread_client_get(ec_data->ec), ec_data->w, ec_data->h);
+}
+
 E_API void
 e_client_size_set(E_Client *ec, int w, int h)
 {
    if (!ec) return;
    ec->w = w;
    ec->h = h;
+
+   if (e_input_thread_check_client_cloning_needed())
+     {
+        E_Input_Thread_Request_EClient_Data ec_data;
+        memset(&ec_data, 0, sizeof(E_Input_Thread_Request_EClient_Data));
+        ec_data.ec = ec;
+        ec_data.w = w;
+        ec_data.h = h;
+
+        INF("[%s] ec(%p), w(%d), h(%d)\n", __func__, ec, w, h);
+        e_input_backend_thread_safe_call(_e_client_input_thread_size_set, &ec_data, sizeof(E_Input_Thread_Request_EClient_Data));
+     }
 }
 
 E_API void
@@ -5128,6 +5267,28 @@ e_client_transform_core_remove(E_Client *ec, E_Util_Transform *transform)
    e_client_transform_core_update(ec);
 }
 
+static void
+_e_input_thread_client_transform_core_enable_set(void *data)
+{
+   E_Input_Thread_Request_EClient_Data *ec_data = data;
+   EINA_SAFETY_ON_NULL_RETURN(ec_data);
+
+   INF("[input thread|%s] ec(%p), transform_core.result.enable(%d)\n", __func__, ec_data->ec, ec_data->transform_core.result.enable);
+   e_input_thread_client_transform_core_enable_set(e_input_thread_client_get(ec_data->ec), ec_data->transform_core.result.enable);
+}
+
+static void
+_e_input_thread_client_transform_core_state_set(E_Client *ec, Eina_Bool enable)
+{
+   E_Input_Thread_Request_EClient_Data ec_data;
+   memset(&ec_data, 0, sizeof(E_Input_Thread_Request_EClient_Data));
+   ec_data.ec = ec;
+   ec_data.transform_core.result.enable = enable;
+
+   INF("[%s] ec(%p), transform_core.result.enable(%d)\n", __func__, ec, enable);
+   e_input_backend_thread_safe_call(_e_input_thread_client_transform_core_enable_set, &ec_data, sizeof(E_Input_Thread_Request_EClient_Data));
+}
+
 E_API void
 e_client_transform_core_update(E_Client *ec)
 {
@@ -5146,6 +5307,10 @@ e_client_transform_core_update(E_Client *ec)
 
         // 1. init state
         ec->transform_core.result.enable = EINA_TRUE;
+
+        if (e_input_thread_check_client_cloning_needed())
+          _e_input_thread_client_transform_core_state_set(ec, EINA_TRUE);
+
         e_util_transform_rect_client_rect_get(&source_rect, ec);
         e_util_transform_init(&ec->transform_core.result.transform);
 
@@ -5268,6 +5433,9 @@ e_client_transform_core_update(E_Client *ec)
         if (ec->transform_core.result.enable)
           {
              ec->transform_core.result.enable = EINA_FALSE;
+             if (e_input_thread_check_client_cloning_needed())
+               _e_input_thread_client_transform_core_state_set(ec, EINA_FALSE);
+
              _e_client_transform_core_vertices_apply(ec, ec->frame, NULL, NULL);
              e_comp_object_transform_bg_set(ec->frame, EINA_FALSE);
              ec->transform_core.background = EINA_FALSE;

diff --git a/src/bin/inputmgr/e_input_thread_client.c b/src/bin/inputmgr/e_input_thread_client.c
index 12bd932a234ae6b632514e6edea5af19062dc180..1ca4e55748c0df9db8d4e6586a32e1ed9e6f8133 100644 (file)
--- a/src/bin/inputmgr/e_input_thread_client.c
+++ b/src/bin/inputmgr/e_input_thread_client.c
@@ -18,6 +18,26 @@ struct _E_Input_Thread_Client
    Eina_Stringshare *icccm_name;
    Eina_Stringshare *netwm_name;
    Eina_Stringshare *icccm_title;
+
+   Evas_Object *frame;
+   int x, y, w, h;
+
+   struct
+   {
+      struct
+      {
+         Eina_Bool enable;
+         struct
+         {
+            int x, y, w, h;
+         } boundary;
+      } result;
+   } transform_core;
+
+   struct
+   {
+      int x, y, w, h;
+   } eo_geometry;
 };
 
 static Eina_List *_itc_list = NULL;
@@ -223,6 +243,76 @@ EINTERN void e_input_thread_client_is_cursor_set(E_Input_Thread_Client *iec, Ein
    INF("[%s] iec(%p), ec(%p), is_cursor(%d)\n", __func__, iec, iec->ec, iec->is_cursor);
 }
 
+EINTERN void e_input_thread_client_position_set(E_Input_Thread_Client *iec, int x, int y)
+{
+   EINA_SAFETY_ON_NULL_RETURN(iec);
+
+   iec->x = x;
+   iec->y = y;
+   INF("[%s] iec(%p), ec(%p), x(%d), y(%d)\n", __func__, iec, iec->ec, iec->x, iec->y);
+}
+
+EINTERN void e_input_thread_client_size_set(E_Input_Thread_Client *iec, int w, int h)
+{
+   EINA_SAFETY_ON_NULL_RETURN(iec);
+
+   iec->w = w;
+   iec->h = h;
+   INF("[%s] iec(%p), ec(%p), w(%d), h(%d)\n", __func__, iec, iec->ec, iec->w, iec->h);
+}
+
+EINTERN void e_input_thread_client_transform_core_boundary_set(E_Input_Thread_Client *iec, int x, int y, int w, int h)
+{
+   EINA_SAFETY_ON_NULL_RETURN(iec);
+
+   iec->transform_core.result.boundary.x = x;
+   iec->transform_core.result.boundary.y = y;
+   iec->transform_core.result.boundary.w = w;
+   iec->transform_core.result.boundary.h = h;
+   INF("[%s] iec(%p), ec(%p), x(%d), y(%d), w(%d), h(%d)\n",
+       __func__,
+       iec,
+       iec->ec,
+       iec->transform_core.result.boundary.x,
+       iec->transform_core.result.boundary.y,
+       iec->transform_core.result.boundary.w,
+       iec->transform_core.result.boundary.h);
+}
+
+EINTERN void e_input_thread_client_transform_core_enable_set(E_Input_Thread_Client *iec, Eina_Bool enable)
+{
+   EINA_SAFETY_ON_NULL_RETURN(iec);
+
+   iec->transform_core.result.enable = enable;
+   INF("[%s] iec(%p), ec(%p), enable(%d)\n", __func__, iec, iec->ec, iec->transform_core.result.enable);
+}
+
+EINTERN void e_input_thread_client_frame_set(E_Input_Thread_Client *iec, Evas_Object *frame)
+{
+   EINA_SAFETY_ON_NULL_RETURN(iec);
+
+   iec->frame = frame;
+   INF("[%s] iec(%p), ec(%p), frame(%p)\n", __func__, iec, iec->ec, iec->frame);
+}
+
+EINTERN void e_input_thread_client_eo_geometry_set(E_Input_Thread_Client *iec, int x, int y, int w, int h)
+{
+   EINA_SAFETY_ON_NULL_RETURN(iec);
+
+   iec->eo_geometry.x = x;
+   iec->eo_geometry.y = y;
+   iec->eo_geometry.w = w;
+   iec->eo_geometry.h = h;
+   INF("[%s] iec(%p), ec(%p), x(%d), y(%d), w(%d), h(%d)\n",
+       __func__,
+       iec,
+       iec->ec,
+       iec->eo_geometry.x,
+       iec->eo_geometry.y,
+       iec->eo_geometry.w,
+       iec->eo_geometry.h);
+}
+
 EINTERN E_Input_Thread_Client * e_input_thread_client_get(E_Client *ec)
 {
    Eina_List *l;
@@ -399,6 +489,56 @@ E_API E_Input_Thread_Client *e_input_thread_client_focused_get()
    return e_input_thread_client_get(e_comp_input->focused_ec);
 }
 
+E_API void e_input_thread_client_geometry_get(E_Input_Thread_Client *iec, int *x, int *y, int *w, int *h)
+{
+   int gx = 0;
+   int gy = 0;
+   int gw = 0;
+   int gh = 0;
+
+   EINA_SAFETY_ON_NULL_RETURN(iec);
+
+   if (iec->transform_core.result.enable)
+     {
+        gx = iec->transform_core.result.boundary.x;
+        gy = iec->transform_core.result.boundary.y;
+        gw = iec->transform_core.result.boundary.w;
+        gh = iec->transform_core.result.boundary.h;
+     }
+   else
+     {
+        if (iec->frame)
+          {
+             if (iec->eo_geometry.w == 0 && iec->eo_geometry.h == 0)
+               {
+                  gx = iec->x;
+                  gy = iec->y;
+                  gw = iec->w;
+                  gh = iec->h;
+               }
+             else
+               {
+                  gx = iec->eo_geometry.x;
+                  gy = iec->eo_geometry.y;
+                  gw = iec->eo_geometry.w;
+                  gh = iec->eo_geometry.h;
+               }
+          }
+        else
+          {
+             gx = iec->x;
+             gy = iec->y;
+             gw = iec->w;
+             gh = iec->h;
+          }
+     }
+
+   if (x) *x = gx;
+   if (y) *y = gy;
+   if (w) *w = gw;
+   if (h) *h = gh;
+}
+
 E_API E_Input_Thread_Client *e_input_thread_client_from_surface_resource(struct wl_resource *surface_resource)
 {
    Eina_List *l;

diff --git a/src/bin/inputmgr/e_input_thread_client_intern.h b/src/bin/inputmgr/e_input_thread_client_intern.h
index f51ada089d79800d8fde18890dad5539e91ddf3c..8cc711d89f13b399966ba239c5ac40f0c86ef8d0 100644 (file)
--- a/src/bin/inputmgr/e_input_thread_client_intern.h
+++ b/src/bin/inputmgr/e_input_thread_client_intern.h
@@ -11,13 +11,35 @@ typedef struct
 {
   void *ec;
   struct wl_resource *wl_surface;
+
   E_Layer layer;
   E_Visibility visibility;
+
   Eina_Bool layer_block;
   Eina_Bool layer_pending;
   bool is_video;
   Eina_Bool deleted;
   Eina_Bool is_cursor;
+
+  Evas_Object *frame;
+  int x, y, w, h;
+
+  struct
+  {
+     struct
+     {
+        Eina_Bool enable;
+        struct
+        {
+           int x, y, w, h;
+        } boundary;
+     } result;
+  } transform_core;
+
+  struct
+  {
+     int x, y, w, h;
+  } eo_geometry;
 } E_Input_Thread_Request_EClient_Data;
 
 typedef struct
@@ -55,6 +77,12 @@ EINTERN void e_input_thread_client_layer_set(E_Input_Thread_Client *ec, E_Layer
 EINTERN void e_input_thread_client_layer_block_set(E_Input_Thread_Client *ec, Eina_Bool block);
 EINTERN void e_input_thread_client_layer_pending_set(E_Input_Thread_Client *ec, Eina_Bool pending);
 EINTERN void e_input_thread_client_is_cursor_set(E_Input_Thread_Client *ec, Eina_Bool is_cursor);
+EINTERN void e_input_thread_client_position_set(E_Input_Thread_Client *ec, int x, int y);
+EINTERN void e_input_thread_client_size_set(E_Input_Thread_Client *ec, int w, int h);
+EINTERN void e_input_thread_client_transform_core_boundary_set(E_Input_Thread_Client *ec, int x, int y, int w, int h);
+EINTERN void e_input_thread_client_transform_core_enable_set(E_Input_Thread_Client *ec, Eina_Bool enable);
+EINTERN void e_input_thread_client_frame_set(E_Input_Thread_Client *ec, Evas_Object *frame);
+EINTERN void e_input_thread_client_eo_geometry_set(E_Input_Thread_Client *ec, int x, int y, int w, int h);
 
 EINTERN E_Input_Thread_Client * e_input_thread_client_get(E_Client *ec);
 EINTERN Eina_Inlist * e_input_thread_client_Inlist_get(E_Client *ec);

diff --git a/src/include/e_input_thread_client.h b/src/include/e_input_thread_client.h
index a242caef13baafeb3bb999cbfd95bb1b66cb095b..d444b96c9f1c4aaa740b796c91ef0120292c20cf 100644 (file)
--- a/src/include/e_input_thread_client.h
+++ b/src/include/e_input_thread_client.h
@@ -21,6 +21,8 @@ E_API E_Input_Thread_Client *e_input_thread_client_bottom_get();
 E_API E_Input_Thread_Client *e_input_thread_client_top_get();
 E_API E_Input_Thread_Client *e_input_thread_client_focused_get();
 
+E_API void e_input_thread_client_geometry_get(E_Input_Thread_Client *ec, int *x, int *y, int *w, int *h);
+
 E_API E_Input_Thread_Client *e_input_thread_client_from_surface_resource(struct wl_resource *surface_resource);
 E_API struct wl_resource *e_input_thread_client_wl_resource_get(E_Input_Thread_Client *ec);