input: Add e_input_thread_client

Change-Id: I9acd95f68a4ff4a64807b15cf43d809d8a7b457b
Signed-off-by: Jihoon Kim <jihoon48.kim@samsung.com>

diff --git a/src/bin/Makefile.mk b/src/bin/Makefile.mk
index f8a7806..41b34b5 100644 (file)
--- a/src/bin/Makefile.mk
+++ b/src/bin/Makefile.mk
@@ -103,7 +103,8 @@ src/include/e_devicemgr.h \
 src/include/e_map.h \
 src/include/e_input_event.h \
 src/include/e_device.h \
-src/include/e_types.h
+src/include/e_types.h \
+src/include/e_input_thread_client.h
 
 enlightenment_src = \
 src/bin/e_actions.c \
@@ -245,7 +246,8 @@ src/bin/e_devicemgr_keyboard_grab.c \
 src/bin/e_subsurface_watcher.c \
 src/bin/e_tbm_gbm_server.c \
 src/bin/e_comp_input.c \
-src/bin/e_linux_dmabuf.c
+src/bin/e_linux_dmabuf.c \
+src/bin/e_input_thread_client.c
 
 src_bin_enlightenment_CPPFLAGS = $(E_CPPFLAGS) -DEFL_BETA_API_SUPPORT -DEFL_EO_API_SUPPORT -DE_LOGGING=2 @WAYLAND_CFLAGS@ $(TTRACE_CFLAGS) $(DLOG_CFLAGS) $(PIXMAN_CFLAGS) $(POLICY_CFLAGS) $(EGL_CFLAGS)
 if HAVE_LIBGOMP

diff --git a/src/bin/e_client.c b/src/bin/e_client.c
index e2daf59..b7f3024 100644 (file)
--- a/src/bin/e_client.c
+++ b/src/bin/e_client.c
@@ -17,6 +17,7 @@
 #include "e_desk_intern.h"
 #include "e_zone_intern.h"
 #include "e_config_intern.h"
+#include "e_input_thread_client_intern.h"
 
 #define PRI(ec) ((E_Client_Private *)e_object_data_get(E_OBJECT(ec)))
 
@@ -2654,14 +2655,33 @@ e_client_visibility_get(E_Client *ec)
    return ec->visibility.obscured;
 }
 
+static void
+_e_input_thread_client_visible_set(void *data)
+{
+   E_Input_Thread_Request_EClient_Data ec_data;
+   memcpy(&ec_data, data, sizeof(E_Input_Thread_Request_EClient_Data));
+
+   INF("[input thread|%s] ec(%p), visible(%d)\n", __func__, ec_data.ec, ec_data.visible);
+   e_input_thread_client_visible_set(e_input_thread_client_get(ec_data.ec), ec_data.visible);
+}
+
 EINTERN void
 e_client_visibility_set(E_Client *ec, E_Visibility visibility)
 {
+   E_Input_Thread_Request_EClient_Data ec_data;
+   memset(&ec_data, 0, sizeof(E_Input_Thread_Request_EClient_Data));
+
    EINA_SAFETY_ON_NULL_RETURN(ec);
 
    if (e_client_visibility_get(ec) == visibility) return;
 
    ec->visibility.obscured = visibility;
+
+   ec_data.ec = ec;
+   ec_data.visible = ec->visibility.obscured;
+
+   INF("[%s] ec(%p), visible(%d)\n", __func__, ec, ec->visibility.obscured);
+   e_input_thread_safe_call(_e_input_thread_client_visible_set, &ec_data, sizeof(E_Input_Thread_Request_EClient_Data));
 }
 
 static Eina_Bool
@@ -3214,6 +3234,16 @@ _e_client_convert_fullscreen_layer(int layer)
      return E_LAYER_CLIENT_FULLSCREEN;
 }
 
+static void
+_e_input_thread_client_new(void *data)
+{
+   E_Input_Thread_Request_EClient_Data ec_new_data;
+   memcpy(&ec_new_data, data, sizeof(E_Input_Thread_Request_EClient_Data));
+
+   INF("[input thread|%s] ec(%p), surface(%p)\n", __func__, ec_new_data.ec, ec_new_data.wl_surface);
+   e_input_thread_client_new(ec_new_data.ec, ec_new_data.wl_surface);
+}
+
 E_API E_Client *
 e_client_new(E_Pixmap *cp, int first_map, int internal)
 {
@@ -3353,6 +3383,14 @@ e_client_new(E_Pixmap *cp, int first_map, int internal)
 
    ec->visibility.ignore_geometry = e_config->calc_vis_ignore_geometry;
 
+   E_Input_Thread_Request_EClient_Data ec_new_data;
+   memset(&ec_new_data, 0, sizeof(E_Input_Thread_Request_EClient_Data));
+
+   ec_new_data.ec = ec;
+   ec_new_data.wl_surface = ec->comp_data ? ec->comp_data->wl_surface : NULL;
+   INF("[%s] ec(%p), surface(%p)\n", __func__, ec, ec_new_data.wl_surface);
+   e_input_thread_safe_call(_e_input_thread_client_new, &ec_new_data, sizeof(E_Input_Thread_Request_EClient_Data));
+
    return ec;
 }
 
@@ -7356,13 +7394,39 @@ e_client_shell_ping(E_Client *ec)
    ec->comp_data->shell.ping(ec->comp_data->shell.surface);
 }
 
+static void
+_e_input_thread_client_icccm_name_set(void *data)
+{
+   E_Input_Thread_Request_EClient_Data ec_data;
+   memcpy(&ec_data, data, sizeof(E_Input_Thread_Request_EClient_Data));
+
+   INF("[input thread|%s] ec(%p), name(%s)\n", __func__, ec_data.ec, ec_data.icccm_name);
+   e_input_thread_client_icccm_name_set(e_input_thread_client_get(ec_data.ec), ec_data.icccm_name);
+}
+
 EINTERN void
 e_client_icccm_name_set(E_Client *ec, const char *name)
 {
+   E_Input_Thread_Request_EClient_Data ec_data;
+   memset(&ec_data, 0, sizeof(E_Input_Thread_Request_EClient_Data));
+
    EINA_SAFETY_ON_NULL_RETURN(ec);
 
    if (eina_stringshare_replace(&ec->icccm.name, name))
-     ec->changes.title = EINA_TRUE;
+     {
+        ec->changes.title = EINA_TRUE;
+
+        ec_data.ec = ec;
+        ec_data.wl_surface = ec->comp_data ? ec->comp_data->wl_surface : NULL;
+        ec_data.visible = ec->visible;
+        ec_data.is_video = EINA_FALSE;
+
+        if (name)
+          strncpy(ec_data.icccm_name, name, sizeof(ec_data.icccm_name)-1);
+
+        INF("[%s] ec(%p), surface(%p), name(%s)\n", __func__, ec, ec_data.wl_surface, name);
+        e_input_thread_safe_call(_e_input_thread_client_icccm_name_set, &ec_data, sizeof(E_Input_Thread_Request_EClient_Data));
+     }
 }
 
 E_API Eina_Stringshare *
@@ -7373,12 +7437,35 @@ e_client_icccm_name_get(E_Client *ec)
    return ec->icccm.name;
 }
 
+static void
+_e_input_thread_client_netwm_name_set(void *data)
+{
+   E_Input_Thread_Request_EClient_Data ec_data;
+   memcpy(&ec_data, data, sizeof(E_Input_Thread_Request_EClient_Data));
+
+   INF("[input thread|%s] ec(%p), name(%p)\n", __func__, ec_data.ec, ec_data.netwm_name);
+   e_input_thread_client_netwm_name_set(e_input_thread_client_get(ec_data.ec), ec_data.netwm_name);
+}
+
 EINTERN void
 e_client_netwm_name_set(E_Client *ec, const char *name)
 {
+   E_Input_Thread_Request_EClient_Data ec_data = { NULL, NULL, EINA_FALSE, EINA_FALSE };
+   memset(&ec_data, 0, sizeof(E_Input_Thread_Request_EClient_Data));
+
    EINA_SAFETY_ON_NULL_RETURN(ec);
 
    eina_stringshare_replace(&ec->netwm.name, name);
+
+   ec_data.ec = ec;
+   ec_data.wl_surface = ec->comp_data ? ec->comp_data->wl_surface : NULL;
+   ec_data.visible = EINA_FALSE;
+
+   if (name)
+     strncpy(ec_data.netwm_name, name, sizeof(ec_data.netwm_name)-1);
+
+   INF("[%s] ec(%p), surface(%p), name(%s)\n", __func__, ec, ec_data.wl_surface, ec_data.netwm_name);
+   e_input_thread_safe_call(_e_input_thread_client_netwm_name_set, &ec_data, sizeof(E_Input_Thread_Request_EClient_Data));
 }
 
 E_API Eina_Stringshare *
@@ -7389,13 +7476,36 @@ e_client_netwm_name_get(E_Client *ec)
    return ec->netwm.name;
 }
 
+static void
+_e_input_thread_client_icccm_title_set(void *data)
+{
+   E_Input_Thread_Request_EClient_Data ec_data;
+   memcpy(&ec_data, data, sizeof(E_Input_Thread_Request_EClient_Data));
+
+   INF("[input thread|%s] ec(%p), title(%s)\n", __func__, ec_data.ec, ec_data.icccm_title);
+   e_input_thread_client_icccm_title_set(e_input_thread_client_get(ec_data.ec), ec_data.icccm_title);
+}
+
 EINTERN void
 e_client_icccm_title_set(E_Client *ec, const char *title)
 {
+   E_Input_Thread_Request_EClient_Data ec_data;
+   memset(&ec_data, 0, sizeof(E_Input_Thread_Request_EClient_Data));
+
    EINA_SAFETY_ON_NULL_RETURN(ec);
 
    if (eina_stringshare_replace(&ec->icccm.title, title))
-     ec->changes.title = EINA_TRUE;
+     {
+        ec->changes.title = EINA_TRUE;
+
+        ec_data.ec = ec;
+        ec_data.wl_surface = ec->comp_data ? ec->comp_data->wl_surface : NULL;
+        if (title)
+          strncpy(ec_data.icccm_title, title, sizeof(ec_data.icccm_title)-1);
+
+        INF("[%s] ec(%p), surface(%p)\n", __func__, ec, ec_data.wl_surface);
+        e_input_thread_safe_call(_e_input_thread_client_icccm_title_set, &ec_data, sizeof(E_Input_Thread_Request_EClient_Data));
+     }
 }
 
 E_API Eina_Stringshare *
@@ -7501,3 +7611,31 @@ e_client_hide(E_Client *ec)
         ec->comp_data->mapped = 0;
      }
 }
+
+static void
+_e_input_thread_client_video_mode_set(void *data)
+{
+   E_Input_Thread_Request_EClient_Data ec_data;
+   memcpy(&ec_data, data, sizeof(E_Input_Thread_Request_EClient_Data));
+
+   INF("[input thread|%s] ec(%p), is_video(%d)\n", __func__, ec_data.ec, ec_data.is_video);
+   e_input_thread_client_video_set(e_input_thread_client_get(ec_data.ec), ec_data.is_video);
+}
+
+EINTERN void
+e_client_video_mode_set(E_Client *ec, Eina_Bool is_video)
+{
+   E_Input_Thread_Request_EClient_Data ec_data;
+   memset(&ec_data, 0, sizeof(E_Input_Thread_Request_EClient_Data));
+
+   EINA_SAFETY_ON_NULL_RETURN(ec);
+   EINA_SAFETY_ON_NULL_RETURN(ec->hwc_window);
+
+   ec->hwc_window->is_video = is_video;
+
+   ec_data.ec = ec;
+   ec_data.is_video = is_video;
+
+   INF("[%s] ec(%p), is_video(%d)\n", __func__, ec, is_video);
+   e_input_thread_safe_call(_e_input_thread_client_video_mode_set, &ec_data, sizeof(E_Input_Thread_Request_EClient_Data));
+}

diff --git a/src/bin/e_client_intern.h b/src/bin/e_client_intern.h
index 86df3a4..40de000 100644 (file)
--- a/src/bin/e_client_intern.h
+++ b/src/bin/e_client_intern.h
@@ -196,6 +196,8 @@ EINTERN void         e_client_visibility_end_notify(void);
 EINTERN E_Visibility e_client_visibility_get(E_Client *ec);
 EINTERN void         e_client_visibility_set(E_Client *ec, E_Visibility visibility);
 
+EINTERN void         e_client_video_mode_set(E_Client *ec, Eina_Bool is_video);
+
 EINTERN Eina_Bool e_client_intercept_hook_focus_revert_call(E_Client *ec);
 EINTERN Eina_Bool e_client_intercept_hook_auto_placement_call(E_Client *ec);
 

diff --git a/src/bin/e_comp_wl.c b/src/bin/e_comp_wl.c
index 37d8b7b..eaf5c97 100644 (file)
--- a/src/bin/e_comp_wl.c
+++ b/src/bin/e_comp_wl.c
@@ -39,6 +39,7 @@
 #include "e_hints_intern.h"
 #include "e_comp_input_intern.h"
 #include "e_blur_intern.h"
+#include "e_input_thread_client_intern.h"
 
 #include <tizen-extension-server-protocol.h>
 #include <relative-pointer-unstable-v1-server-protocol.h>
@@ -3252,6 +3253,15 @@ _e_comp_wl_surface_render_stop(E_Client *ec)
    evas_object_hide(ec->frame);
 }
 
+static void
+_e_input_thread_client_free(void *data)
+{
+   E_Input_Thread_Request_EClient_Data ec_free_data;
+   memcpy(&ec_free_data, data, sizeof(E_Input_Thread_Request_EClient_Data));
+
+   INF("[input thread|e_client_free] ec: %p, surface: %p\n", ec_free_data.ec, ec_free_data.wl_surface);
+}
+
 EINTERN void
 e_comp_wl_client_surface_finish(E_Client *ec)
 {
@@ -3277,6 +3287,14 @@ e_comp_wl_client_surface_finish(E_Client *ec)
           }
      }
 
+   E_Input_Thread_Request_EClient_Data ec_free_data;
+   memset(&ec_free_data, 0, sizeof(E_Input_Thread_Request_EClient_Data));
+   ec_free_data.ec = ec;
+   ec_free_data.wl_surface = ec->comp_data->wl_surface;
+
+   INF("[e_comp_wl_client_surface_finish] surface: %p\n", ec_free_data.wl_surface);
+   e_input_thread_safe_call(_e_input_thread_client_free, &ec_free_data, sizeof(E_Input_Thread_Request_EClient_Data));
+
    e_comp_wl_client_surface_set(ec, NULL);
 
    ec->comp_data->wl_surface = NULL;

diff --git a/src/bin/e_comp_wl_input.c b/src/bin/e_comp_wl_input.c
index f0d270d..baecd15 100644 (file)
--- a/src/bin/e_comp_wl_input.c
+++ b/src/bin/e_comp_wl_input.c
@@ -7,6 +7,7 @@
 #include "e_comp_input_intern.h"
 #include "e_policy_intern.h"
 #include "e_keyrouter_intern.h"
+#include "e_input_thread_client_intern.h"
 
 #include <sys/mman.h>
 #include <fcntl.h>
@@ -382,6 +383,8 @@ _e_comp_wl_input_thread_cb_keyboard_get(void *data)
    E_Input_Thread_Request_Keyboard_Get_Data keyboard_get_data;
    memcpy(&keyboard_get_data, data, sizeof(E_Input_Thread_Request_Keyboard_Get_Data));
 
+   INF("[input thread|keyboard_get] resource: %p, client : %p\n", keyboard_get_data.resource, keyboard_get_data.client);
+
    res = keyboard_get_data.resource;
 
    e_comp_input_key->kbd.resources =

diff --git a/src/bin/e_hwc_window.c b/src/bin/e_hwc_window.c
index 9cb50e4..9bf0d62 100644 (file)
--- a/src/bin/e_hwc_window.c
+++ b/src/bin/e_hwc_window.c
@@ -1102,7 +1102,7 @@ _e_hwc_window_new(E_Hwc *hwc, E_Client *ec, E_Hwc_Window_State state)
 end:
    /* video window */
    if (state == E_HWC_WINDOW_STATE_VIDEO)
-     ec->hwc_window->is_video = EINA_TRUE;
+     e_client_video_mode_set(ec, EINA_TRUE);
 
    e_hwc_window_state_set(ec->hwc_window, state, EINA_TRUE);
 

diff --git a/src/bin/e_input_intern.h b/src/bin/e_input_intern.h
index d2e42ac..5aa3e3e 100644 (file)
--- a/src/bin/e_input_intern.h
+++ b/src/bin/e_input_intern.h
@@ -31,21 +31,6 @@ typedef struct {
     unsigned int data_length;
 } E_Input_Thread_Request_Data;
 
-typedef struct
-{
-  struct wl_client *client;
-  struct wl_resource *resource;
-  struct wl_resource *surface;
-  uint32_t key;
-  uint32_t mode;
-} E_Input_Thread_Request_Keygrab_Data;
-
-typedef struct
-{
-   struct wl_client *client;
-   struct wl_resource *resource;
-} E_Input_Thread_Request_Keyboard_Get_Data;
-
 struct _E_Input_Seat
 {
    const char *name;

diff --git a/src/bin/e_input_thread_client.c b/src/bin/e_input_thread_client.c
new file mode 100644 (file)
index 0000000..0cf2e95
--- /dev/null
+++ b/src/bin/e_input_thread_client.c
@@ -0,0 +1,178 @@
+#include "e_input_thread_client_intern.h"
+
+struct _E_Input_Thread_Client
+{
+   void *ec;
+   struct wl_resource *surface;
+   Eina_Bool visible;
+   Eina_Bool is_video;
+   Eina_Stringshare *icccm_name;
+   Eina_Stringshare *netwm_name;
+   Eina_Stringshare *icccm_title;
+};
+
+static Eina_List *_itc_list = NULL;
+
+///////////////////////////////////////////
+EINTERN void
+e_input_thread_client_init()
+{
+
+}
+
+EINTERN void
+e_input_thread_client_shutdown()
+{
+   if (_itc_list)
+     eina_list_free(_itc_list);
+
+   _itc_list = NULL;
+}
+
+EINTERN E_Input_Thread_Client *
+e_input_thread_client_new(E_Client *ec, struct wl_resource *surface)
+{
+   E_Input_Thread_Client *itc = calloc(1, sizeof(E_Input_Thread_Client));
+   EINA_SAFETY_ON_NULL_RETURN_VAL(itc, NULL);
+
+   itc->ec = ec;
+   itc->surface = surface;
+
+   _itc_list = eina_list_append(_itc_list, itc);
+   INF("[%s] iec(%p), ec(%p), surface(%p)\n", __func__, itc, ec, surface);
+
+   return itc;
+}
+
+EINTERN void
+e_input_thread_client_free(E_Input_Thread_Client *iec)
+{
+   EINA_SAFETY_ON_NULL_RETURN(iec);
+
+   _itc_list = eina_list_remove(_itc_list, iec);
+
+   free(iec);
+}
+
+EINTERN void
+e_input_thread_visible_set(E_Input_Thread_Client *iec, Eina_Bool visible)
+{
+   EINA_SAFETY_ON_NULL_RETURN(iec);
+
+   INF("[%s] iec(%p), visible(%d)\n", __func__, iec, visible);
+
+   iec->visible = visible;
+}
+
+E_API Eina_Bool
+e_input_thread_visible_get(E_Input_Thread_Client *iec, Eina_Bool visible)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(iec, EINA_FALSE);
+
+   return iec->visible;
+}
+
+E_API Eina_Bool
+e_input_thread_client_video_mode_get(E_Input_Thread_Client *iec)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(iec, EINA_FALSE);
+
+   return iec->is_video;
+}
+
+EINTERN void
+e_input_thread_client_video_set(E_Input_Thread_Client *iec, Eina_Bool is_video)
+{
+   EINA_SAFETY_ON_NULL_RETURN(iec);
+
+   iec->is_video = is_video;
+   INF("[%s] iec(%p), video(%d)\n", __func__, iec, is_video);
+}
+
+EINTERN void
+e_input_thread_client_visible_set(E_Input_Thread_Client *iec, Eina_Bool visible)
+{
+   EINA_SAFETY_ON_NULL_RETURN(iec);
+
+   iec->visible = visible;
+   INF("[%s] iec(%p), ec(%p), visible(%d)\n", __func__, iec, iec->ec, visible);
+}
+
+E_API Eina_Bool
+e_input_thread_client_visible_get(E_Input_Thread_Client *iec)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(iec, EINA_FALSE);
+
+   return iec->visible;
+}
+
+EINTERN void
+e_input_thread_client_icccm_name_set(E_Input_Thread_Client *iec, char *name)
+{
+   EINA_SAFETY_ON_NULL_RETURN(iec);
+
+   eina_stringshare_replace(&iec->icccm_name, name);
+   INF("[%s] iec(%p), name(%s)\n", __func__, iec, name);
+}
+
+E_API Eina_Stringshare *
+e_input_thread_client_icccm_name_get(E_Input_Thread_Client *iec)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(iec, NULL);
+
+   return iec->icccm_name;
+}
+
+EINTERN void
+e_input_thread_client_icccm_title_set(E_Input_Thread_Client *iec, char *title)
+{
+   EINA_SAFETY_ON_NULL_RETURN(iec);
+
+   eina_stringshare_replace(&iec->icccm_title, title);
+
+   INF("[%s] iec(%p), title(%s)\n", __func__, iec, title);
+}
+
+E_API Eina_Stringshare *
+e_input_thread_client_icccm_title_get(E_Input_Thread_Client *iec)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(iec, NULL);
+
+   return iec->icccm_title;
+}
+
+EINTERN void
+e_input_thread_client_netwm_name_set(E_Input_Thread_Client *iec, char *name)
+{
+   EINA_SAFETY_ON_NULL_RETURN(iec);
+
+   eina_stringshare_replace(&iec->icccm_name, name);
+
+   INF("[%s] iec(%p), name(%s)\n", __func__, iec, name);
+}
+
+E_API Eina_Stringshare *
+e_input_thread_client_netwm_name_get(E_Input_Thread_Client *iec)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(iec, NULL);
+
+   return iec->icccm_name;
+}
+
+EINTERN E_Input_Thread_Client * e_input_thread_client_get(E_Client *ec)
+{
+   Eina_List *l;
+   void *list_data;
+   E_Input_Thread_Client *itc = NULL;
+
+   EINA_SAFETY_ON_NULL_RETURN_VAL(ec, NULL);
+
+   EINA_LIST_FOREACH(_itc_list, l, list_data)
+     {
+        itc = (E_Input_Thread_Client *)list_data;
+        if (itc && itc->ec == ec)
+          return itc;
+     }
+
+   return NULL;
+}

diff --git a/src/bin/e_input_thread_client_intern.h b/src/bin/e_input_thread_client_intern.h
new file mode 100644 (file)
index 0000000..102c8a5
--- /dev/null
+++ b/src/bin/e_input_thread_client_intern.h
@@ -0,0 +1,47 @@
+#ifndef E_INPUT_THREAD_CLIENT_INTERN_H
+#define E_INPUT_THREAD_CLIENT_INTERN_H
+
+#include "e_intern.h"
+
+#include <wayland-server.h>
+
+typedef struct _E_Input_Thread_Client E_Input_Thread_Client;
+
+typedef struct
+{
+  void *ec;
+  struct wl_resource *wl_surface;
+  bool visible;
+  bool is_video;
+  char icccm_name[1024];
+  char netwm_name[1024];
+  char icccm_title[1024];
+} E_Input_Thread_Request_EClient_Data;
+
+typedef struct
+{
+  struct wl_client *client;
+  struct wl_resource *resource;
+  struct wl_resource *surface;
+  uint32_t key;
+  uint32_t mode;
+} E_Input_Thread_Request_Keygrab_Data;
+
+typedef struct
+{
+   struct wl_client *client;
+   struct wl_resource *resource;
+} E_Input_Thread_Request_Keyboard_Get_Data;
+
+EINTERN E_Input_Thread_Client * e_input_thread_client_new(E_Client *ec, struct wl_resource *surface);
+EINTERN void e_input_thread_client_free(E_Input_Thread_Client *ec);
+EINTERN void e_input_thread_client_visible_set(E_Input_Thread_Client *ec, Eina_Bool visible);
+EINTERN void e_input_thread_client_video_set(E_Input_Thread_Client *ec, Eina_Bool is_video);
+
+EINTERN void e_input_thread_client_icccm_name_set(E_Input_Thread_Client *ec, char *name);
+EINTERN void e_input_thread_client_icccm_title_set(E_Input_Thread_Client *ec, char *title);
+EINTERN void e_input_thread_client_netwm_name_set(E_Input_Thread_Client *ec, char *name);
+
+EINTERN E_Input_Thread_Client * e_input_thread_client_get(E_Client *ec);
+
+#endif

diff --git a/src/bin/e_keyrouter_wl.c b/src/bin/e_keyrouter_wl.c
index c3f3e5c..e86c8d7 100644 (file)
--- a/src/bin/e_keyrouter_wl.c
+++ b/src/bin/e_keyrouter_wl.c
@@ -6,6 +6,7 @@
 #include "e_config_intern.h"
 #include "e_security.h"
 #include "e_comp_input_intern.h"
+#include "e_input_thread_client_intern.h"
 
 #include <tizen-extension-server-protocol.h>
 

diff --git a/src/include/e_input_thread_client.h b/src/include/e_input_thread_client.h
new file mode 100644 (file)
index 0000000..e37b21d
--- /dev/null
+++ b/src/include/e_input_thread_client.h
@@ -0,0 +1,14 @@
+#ifndef E_INPUT_THREAD_CLIENT_H
+#define E_INPUT_THREAD_CLIENT_H
+
+#include <e_types.h>
+
+typedef struct _E_Input_Thread_Client E_Input_Thread_Client;
+
+E_API Eina_Bool e_input_thread_client_video_mode_get(E_Input_Thread_Client *ec);
+E_API Eina_Bool e_input_thread_client_visible_get(E_Input_Thread_Client *ec);
+E_API Eina_Stringshare *e_input_thread_client_icccm_name_get(E_Input_Thread_Client *ec);
+E_API Eina_Stringshare *e_input_thread_client_netwm_name_get(E_Input_Thread_Client *ec);
+E_API Eina_Stringshare *e_input_thread_client_icccm_title_get(E_Input_Thread_Client *ec);
+
+#endif