e_input: move kbd structure to e_comp_input_intern.h

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

diff --git a/src/bin/e_comp_input.c b/src/bin/e_comp_input.c
index ba66fb5..ef7fee8 100644 (file)
--- a/src/bin/e_comp_input.c
+++ b/src/bin/e_comp_input.c
@@ -42,4 +42,4 @@ e_comp_input_shutdown(void)
 
         E_FREE(e_comp_input_key);
      }
-}
\ No newline at end of file
+}

diff --git a/src/bin/e_comp_input_intern.h b/src/bin/e_comp_input_intern.h
index da73b4a..cd3ed45 100644 (file)
--- a/src/bin/e_comp_input_intern.h
+++ b/src/bin/e_comp_input_intern.h
@@ -17,6 +17,25 @@ struct _E_Comp_Input_Key_Data
         size_t size;
         char *area;
      } xkb;
+
+   struct
+     {
+        Eina_List *resources;
+        Eina_List *focused;
+        Eina_Bool enabled : 1;
+        xkb_mod_index_t mod_shift, mod_caps;
+        xkb_mod_index_t mod_ctrl, mod_alt;
+        xkb_mod_index_t mod_super;
+        xkb_mod_mask_t mod_depressed, mod_latched, mod_locked;
+        xkb_layout_index_t mod_group;
+        struct wl_array keys;
+        struct wl_array routed_keys;
+        struct wl_resource *focus;
+        int mod_changed;
+        atomic_int repeat_delay;
+        atomic_int repeat_rate;
+        unsigned int num_devices;
+     } kbd;
 };
 
 extern EINTERN E_Comp_Input_Key_Data *e_comp_input_key;

diff --git a/src/bin/e_comp_screen.c b/src/bin/e_comp_screen.c
index c483ea2..a1b2842 100644 (file)
--- a/src/bin/e_comp_screen.c
+++ b/src/bin/e_comp_screen.c
@@ -20,6 +20,7 @@
 #include "e_dbus_conn_intern.h"
 #include "e_main_intern.h"
 #include "e_hwc_planes_intern.h"
+#include "e_comp_input_intern.h"
 
 #include "Eeze.h"
 #include <tizen-extension-server-protocol.h>
@@ -319,11 +320,6 @@ _e_comp_screen_cb_input_device_add(void *data, int type, void *event)
           }
         comp->wl_comp_data->ptr.num_devices++;
      }
-   else if (e->clas == ECORE_DEVICE_CLASS_KEYBOARD)
-     {
-        comp->wl_comp_data->kbd.num_devices++;
-        e_comp_wl_input_keyboard_enabled_set(EINA_TRUE);
-     }
    else if (e->clas == ECORE_DEVICE_CLASS_TOUCH)
      {
         e_comp_wl_input_touch_enabled_set(EINA_TRUE);
@@ -388,14 +384,6 @@ _e_comp_screen_cb_input_device_del(void *data, int type, void *event)
              _e_comp_screen_pointer_renew();
           }
      }
-   else if (e->clas == ECORE_DEVICE_CLASS_KEYBOARD)
-     {
-        comp->wl_comp_data->kbd.num_devices--;
-        if (comp->wl_comp_data->kbd.num_devices == 0)
-          {
-             e_comp_wl_input_keyboard_enabled_set(EINA_FALSE);
-          }
-     }
    else if (e->clas == ECORE_DEVICE_CLASS_TOUCH)
      {
         comp->wl_comp_data->touch.num_devices--;

diff --git a/src/bin/e_comp_wl.c b/src/bin/e_comp_wl.c
index 71f354e..742d3e1 100644 (file)
--- a/src/bin/e_comp_wl.c
+++ b/src/bin/e_comp_wl.c
@@ -2012,7 +2012,7 @@ _e_comp_wl_input_thread_send_keys()
    struct wl_resource *res;
    E_Comp_Wl_Key_Data *k;
 
-   if (!e_comp_wl->kbd.focused)
+   if (!e_comp_input_key->kbd.focused)
      {
         return;
      }
@@ -2020,9 +2020,9 @@ _e_comp_wl_input_thread_send_keys()
    serial = wl_display_next_serial(e_comp_wl->wl.disp);
    t = ecore_time_unix_get();
 
-   EINA_LIST_FOREACH(e_comp_wl->kbd.focused, l, res)
+   EINA_LIST_FOREACH(e_comp_input_key->kbd.focused, l, res)
      {
-        wl_array_for_each(k, &e_comp_wl->kbd.keys)
+        wl_array_for_each(k, &e_comp_input_key->kbd.keys)
           {
              _e_comp_wl_send_event_device(wl_resource_get_client(res), t, k->dev, serial);
              wl_keyboard_send_key(res, serial, t,
@@ -2065,12 +2065,22 @@ _e_comp_wl_input_thread_focus_in(void *data)
           }
      }
 
-   if (!e_comp_wl->kbd.focused)
+   EINA_LIST_FOREACH(e_comp_input_key->kbd.resources, l, res)
+     {
+        if (wl_resource_get_client(res) == wc)
+          {
+             if (!eina_list_data_find(e_comp_input_key->kbd.focused, res))
+               e_comp_input_key->kbd.focused = eina_list_append(e_comp_input_key->kbd.focused, res);
+          }
+     }
+
+   if (!e_comp_input_key->kbd.focused)
      {
         return;
      }
 
    e_comp_wl->kbd.focus = surface;
+   e_comp_input_key->kbd.focus = surface;
    e_comp_wl_input_keyboard_enter_send(surface);
    e_comp_wl_data_device_keyboard_focus_set();
 }
@@ -2129,12 +2139,12 @@ _e_comp_wl_input_thread_focus_out(void *data)
    memcpy(&surface, data, sizeof(struct wl_resource *));
 
    /* update keyboard modifier state */
-   wl_array_for_each(k, &e_comp_wl->kbd.keys)
+   wl_array_for_each(k, &e_comp_input_key->kbd.keys)
       e_comp_wl_input_keyboard_state_update(k->key, EINA_FALSE);
 
    if (!surface) return;
 
-   if (!eina_list_count(e_comp_wl->kbd.resources))
+   if (!eina_list_count(e_comp_input_key->kbd.resources))
      {
         return;
      }
@@ -2145,15 +2155,21 @@ _e_comp_wl_input_thread_focus_out(void *data)
 
    EINA_LIST_FOREACH_SAFE(e_comp_wl->kbd.focused, l, ll, res)
      {
-        wl_array_for_each(k, &e_comp_wl->kbd.keys)
+        e_comp_wl->kbd.focused =
+           eina_list_remove_list(e_comp_wl->kbd.focused, l);
+     }
+
+   EINA_LIST_FOREACH_SAFE(e_comp_input_key->kbd.focused, l, ll, res)
+     {
+        wl_array_for_each(k, &e_comp_input_key->kbd.keys)
           {
              _e_comp_wl_send_event_device(wl_resource_get_client(res), t, k->dev, serial);
               wl_keyboard_send_key(res, serial, t,
                                    k->key, WL_KEYBOARD_KEY_STATE_RELEASED);
           }
         wl_keyboard_send_leave(res, serial, surface);
-        e_comp_wl->kbd.focused =
-           eina_list_remove_list(e_comp_wl->kbd.focused, l);
+        e_comp_input_key->kbd.focused =
+           eina_list_remove_list(e_comp_input_key->kbd.focused, l);
      }
 }
 
@@ -3272,12 +3288,13 @@ e_comp_wl_client_surface_finish(E_Client *ec)
    if (surface_client &&
        (ec == e_client_focused_get()))
      {
-        EINA_LIST_FOREACH_SAFE(e_comp_wl->kbd.focused, l, ll, res)
+        EINA_LIST_FOREACH_SAFE(e_comp_input_key->kbd.focused, l, ll, res)
           {
              if (wl_resource_get_client(res) ==
                  surface_client)
-               e_comp_wl->kbd.focused =
-                  eina_list_remove_list(e_comp_wl->kbd.focused, l);
+               e_comp_input_key->kbd.focused =
+                  eina_list_remove_list(e_comp_input_key->kbd.focused, l);
+
           }
      }
 
@@ -3399,6 +3416,7 @@ _e_comp_wl_client_cb_focus_set(void *data EINA_UNUSED, E_Client *ec)
      }
 
    e_comp_wl->kbd.focus = ec->comp_data->surface;
+   e_comp_input_key->kbd.focus = ec->comp_data->surface;
 }
 
 static void
@@ -3417,6 +3435,9 @@ _e_comp_wl_client_cb_focus_unset(void *data EINA_UNUSED, E_Client *ec)
 
    if (e_comp_wl->kbd.focus == ec->comp_data->surface)
      e_comp_wl->kbd.focus = NULL;
+
+   if (e_comp_input_key->kbd.focus == ec->comp_data->surface)
+     e_comp_input_key->kbd.focus = NULL;
 }
 
 static void
@@ -4317,9 +4338,9 @@ e_comp_wl_key_down(Ecore_Event_Key *ev, E_Device *dev)
      }
 #endif
 
-   end = (E_Comp_Wl_Key_Data *)e_comp_wl->kbd.keys.data + (e_comp_wl->kbd.keys.size / sizeof(*k));
+   end = (E_Comp_Wl_Key_Data *)e_comp_input_key->kbd.keys.data + (e_comp_input_key->kbd.keys.size / sizeof(*k));
 
-   for (k = e_comp_wl->kbd.keys.data; k < end; k++)
+   for (k = e_comp_input_key->kbd.keys.data; k < end; k++)
      {
         /* ignore server-generated key repeats */
         if (k->key == keycode)
@@ -4334,9 +4355,9 @@ e_comp_wl_key_down(Ecore_Event_Key *ev, E_Device *dev)
         struct wl_resource *surface = e_comp_wl_client_surface_get(ec);
         if (ec && ec->comp_data && surface)
           {
-             if (e_comp_wl->kbd.focused)
+             if (e_comp_input_key->kbd.focused)
                {
-                  _e_comp_wl_key_send(ev, dev, WL_KEYBOARD_KEY_STATE_PRESSED, e_comp_wl->kbd.focused, ec);
+                  _e_comp_wl_key_send(ev, dev, WL_KEYBOARD_KEY_STATE_PRESSED, e_comp_input_key->kbd.focused, ec);
 
                   /* A key only sent to clients is added to the list */
                   e_comp_wl->kbd.keys.size = (const char *)end - (const char *)e_comp_wl->kbd.keys.data;
@@ -4346,6 +4367,14 @@ e_comp_wl_key_down(Ecore_Event_Key *ev, E_Device *dev)
                        DBG("wl_array_add: Out of memory\n");
                        return EINA_FALSE;
                     }
+
+                  e_comp_input_key->kbd.keys.size = (const char *)end - (const char *)e_comp_input_key->kbd.keys.data;
+
+                  if (!(k = wl_array_add(&e_comp_input_key->kbd.keys, sizeof(*k))))
+                    {
+                       DBG("wl_array_add: Out of memory\n");
+                       return EINA_FALSE;
+                    }
                   k->key = keycode;
                   k->dev = ev->dev;
                }
@@ -4377,8 +4406,8 @@ e_comp_wl_key_up(Ecore_Event_Key *ev, E_Device *dev)
         return EINA_FALSE;
      }
 
-   end = (E_Comp_Wl_Key_Data *)e_comp_wl->kbd.keys.data + (e_comp_wl->kbd.keys.size / sizeof(*k));
-   for (k = e_comp_wl->kbd.keys.data; k < end; k++)
+   end = (E_Comp_Wl_Key_Data *)e_comp_input_key->kbd.keys.data + (e_comp_input_key->kbd.keys.size / sizeof(*k));
+   for (k = e_comp_input_key->kbd.keys.data; k < end; k++)
      {
         if (k->key == keycode)
           {
@@ -4390,15 +4419,18 @@ e_comp_wl_key_up(Ecore_Event_Key *ev, E_Device *dev)
    e_comp_wl->kbd.keys.size =
      (const char *)end - (const char *)e_comp_wl->kbd.keys.data;
 
+   e_comp_input_key->kbd.keys.size =
+     (const char *)end - (const char *)e_comp_input_key->kbd.keys.data;
+
    /* If a key down event have been sent to clients, send a key up event to client for garantee key event sequence pair. (down/up) */
    if ((delivered_key) ||
        ((!e_client_action_get()) && (!e_comp->input_key_grabs)))
      {
         ec = e_client_focused_get();
 
-        if (e_comp_wl->kbd.focused)
+        if (e_comp_input_key->kbd.focused)
           {
-             _e_comp_wl_key_send(ev, dev, WL_KEYBOARD_KEY_STATE_RELEASED, e_comp_wl->kbd.focused, ec);
+             _e_comp_wl_key_send(ev, dev, WL_KEYBOARD_KEY_STATE_RELEASED, e_comp_input_key->kbd.focused, ec);
           }
      }
 
@@ -4660,7 +4692,7 @@ e_comp_wl_key_send(E_Client *ec, int keycode, Eina_Bool pressed, void *dev, uint
         ELOGF("INPUT", "wl_keyboard_send_key:%s:%d|B|", NULL, (state ? "PRESS" : "RELEASE"), keycode);
      }
 
-   EINA_LIST_FOREACH(e_comp_wl->kbd.resources, l, res)
+   EINA_LIST_FOREACH(e_comp_input_key->kbd.resources, l, res)
      {
         if (wl_resource_get_client(res) != wc) continue;
         if (!e_input_thread_mode_get())
@@ -4742,7 +4774,7 @@ e_comp_wl_key_cancel(E_Client *ec, int keycode, Ecore_Device *dev, uint32_t time
    comp_conf = e_comp_config_get();
    e_keyrouter_event_surface_send(ec, keycode);
 
-   EINA_LIST_FOREACH(e_comp_wl->kbd.resources, l, res)
+   EINA_LIST_FOREACH(e_comp_input_key->kbd.resources, l, res)
      {
         if (wl_resource_get_client(res) != wc) continue;
         if (dev) _e_comp_wl_send_event_device(wc, time, dev, serial);

diff --git a/src/bin/e_comp_wl_data.c b/src/bin/e_comp_wl_data.c
index 4f95263..ec38ac5 100644 (file)
--- a/src/bin/e_comp_wl_data.c
+++ b/src/bin/e_comp_wl_data.c
@@ -3,6 +3,7 @@
 #include "e_comp_canvas_intern.h"
 #include "e_comp_wl_intern.h"
 #include "e_dnd_intern.h"
+#include "e_comp_input_intern.h"
 
 #include <fcntl.h>
 #include <unistd.h>
@@ -602,8 +603,8 @@ _e_comp_wl_data_device_destroy_selection_data_source(struct wl_listener *listene
         return;
      }
 
-   if (e_comp_wl->kbd.enabled)
-     focus = e_comp_wl->kbd.focus;
+   if (e_comp_input_key->kbd.enabled)
+     focus = e_comp_input_key->kbd.focus;
 
    if (focus)
      {
@@ -778,8 +779,8 @@ _e_comp_wl_data_device_selection_set(void *data EINA_UNUSED, E_Comp_Wl_Data_Sour
    e_comp_wl->clipboard.xwl_owner = NULL;
    e_comp_wl->selection.serial = serial;
 
-   if (e_comp_wl->kbd.enabled)
-     focus = e_comp_wl->kbd.focus;
+   if (e_comp_input_key->kbd.enabled)
+     focus = e_comp_input_key->kbd.focus;
 
    //if source is from cbhm_client do not create data offer for cbhm
    if ((cbhm_client) && (source_client != cbhm_client))
@@ -1382,13 +1383,13 @@ e_comp_wl_data_device_keyboard_focus_set(void)
    struct wl_resource *data_device_res, *offer_res = NULL, *focus;
    E_Comp_Wl_Data_Source *source;
 
-   if (!e_comp_wl->kbd.enabled)
+   if (!e_comp_input_key->kbd.enabled)
      {
         ERR("Keyboard not enabled");
         return;
      }
 
-   if (!(focus = e_comp_wl->kbd.focus))
+   if (!(focus = e_comp_input_key->kbd.focus))
      {
         ERR("No focused resource");
         return;
@@ -1603,7 +1604,7 @@ e_comp_wl_data_device_only_set(struct wl_resource *data_device_res, Eina_Bool se
         e_comp_wl->selection.data_only_list =
            eina_list_remove(e_comp_wl->selection.data_only_list, data_device_res);
 
-        focus = e_comp_wl->kbd.focus;
+        focus = e_comp_input_key->kbd.focus;
         if ((!focus) ||
             (wl_resource_get_client(focus) != wl_resource_get_client(data_device_res)))
           {

diff --git a/src/bin/e_comp_wl_input.c b/src/bin/e_comp_wl_input.c
index 2e83ac8..84c651e 100644 (file)
--- a/src/bin/e_comp_wl_input.c
+++ b/src/bin/e_comp_wl_input.c
@@ -84,7 +84,7 @@ _e_comp_wl_input_update_seat_caps(struct wl_client *wc)
 
    if (e_comp_wl->ptr.enabled)
      caps |= WL_SEAT_CAPABILITY_POINTER;
-   if (e_comp_wl->kbd.enabled)
+   if (e_comp_input_key->kbd.enabled)
      caps |= WL_SEAT_CAPABILITY_KEYBOARD;
    if (e_comp_wl->touch.enabled)
      caps |= WL_SEAT_CAPABILITY_TOUCH;
@@ -325,6 +325,14 @@ _e_comp_wl_input_thread_cb_keyboard_unbind(void *data)
      if (res == resource)
        e_comp_wl->kbd.focused =
          eina_list_remove_list(e_comp_wl->kbd.focused, l);
+
+   e_comp_input_key->kbd.resources =
+     eina_list_remove(e_comp_input_key->kbd.resources, resource);
+
+   EINA_LIST_FOREACH_SAFE(e_comp_input_key->kbd.focused, l, ll, res)
+     if (res == resource)
+       e_comp_input_key->kbd.focused =
+         eina_list_remove_list(e_comp_input_key->kbd.focused, l);
 }
 
 static void
@@ -343,7 +351,7 @@ e_comp_wl_input_keyboard_enter_send(struct wl_resource *surface)
    xkb_mod_mask_t mod_depressed, mod_latched, mod_locked;
    xkb_layout_index_t mod_group;
 
-   if (!e_comp_wl->kbd.focused)
+   if (!e_comp_input_key->kbd.focused)
      {
         return;
      }
@@ -352,16 +360,16 @@ e_comp_wl_input_keyboard_enter_send(struct wl_resource *surface)
 
    serial = wl_display_next_serial(e_comp_wl->wl.disp);
 
-   mod_depressed = atomic_load(&e_comp_wl->kbd.mod_depressed);
-   mod_latched = atomic_load(&e_comp_wl->kbd.mod_latched);
-   mod_locked = atomic_load(&e_comp_wl->kbd.mod_locked);
+   mod_depressed = atomic_load(&e_comp_input_key->kbd.mod_depressed);
+   mod_latched = atomic_load(&e_comp_input_key->kbd.mod_latched);
+   mod_locked = atomic_load(&e_comp_input_key->kbd.mod_locked);
 
-   mod_group = atomic_load(&e_comp_wl->kbd.mod_group);
+   mod_group = atomic_load(&e_comp_input_key->kbd.mod_group);
 
-   EINA_LIST_FOREACH(e_comp_wl->kbd.focused, l, res)
+   EINA_LIST_FOREACH(e_comp_input_key->kbd.focused, l, res)
      {
         wl_keyboard_send_enter(res, serial, surface,
-                               &e_comp_wl->kbd.keys);
+                               &e_comp_input_key->kbd.keys);
 
         wl_keyboard_send_modifiers(res, serial,
                                    mod_depressed,
@@ -394,6 +402,9 @@ _e_comp_wl_input_thread_cb_keyboard_get(void *data)
    e_comp_wl->kbd.resources =
      eina_list_append(e_comp_wl->kbd.resources, res);
 
+   e_comp_input_key->kbd.resources =
+     eina_list_append(e_comp_input_key->kbd.resources, res);
+
    wl_resource_set_implementation(res, &_e_keyboard_interface,
                                   e_comp->wl_comp_data,
                                   _e_comp_wl_input_cb_keyboard_unbind);
@@ -401,7 +412,7 @@ _e_comp_wl_input_thread_cb_keyboard_get(void *data)
    /* send current repeat_info */
    if (wl_resource_get_version(res) >= WL_KEYBOARD_REPEAT_INFO_SINCE_VERSION)
      {
-        wl_keyboard_send_repeat_info(res, e_comp_wl->kbd.repeat_rate, e_comp_wl->kbd.repeat_delay);
+        wl_keyboard_send_repeat_info(res, e_comp_input_key->kbd.repeat_rate, e_comp_input_key->kbd.repeat_delay);
      }
 
    /* send current keymap */
@@ -420,6 +431,7 @@ _e_comp_wl_input_thread_cb_keyboard_get(void *data)
    if (!surface) return;
 
    if (keyboard_get_data.client != wl_resource_get_client(surface)) return;
+   e_comp_input_key->kbd.focused = eina_list_append(e_comp_input_key->kbd.focused, res);
    e_comp_wl->kbd.focused = eina_list_append(e_comp_wl->kbd.focused, res);
 
    e_comp_wl_input_keyboard_enter_send(e_comp_wl_client_surface_get(focused));
@@ -1432,15 +1444,15 @@ _e_comp_wl_input_keymap_update(struct xkb_keymap *keymap, const char *keymap_pat
    e_comp_input_key->xkb.keymap = keymap;
 
    /* fetch updated modifiers */
-   e_comp_wl->kbd.mod_shift =
+   e_comp_input_key->kbd.mod_shift =
      xkb_map_mod_get_index(keymap, XKB_MOD_NAME_SHIFT);
-   e_comp_wl->kbd.mod_caps =
+   e_comp_input_key->kbd.mod_caps =
      xkb_map_mod_get_index(keymap, XKB_MOD_NAME_CAPS);
-   e_comp_wl->kbd.mod_ctrl =
+   e_comp_input_key->kbd.mod_ctrl =
      xkb_map_mod_get_index(keymap, XKB_MOD_NAME_CTRL);
-   e_comp_wl->kbd.mod_alt =
+   e_comp_input_key->kbd.mod_alt =
      xkb_map_mod_get_index(keymap, XKB_MOD_NAME_ALT);
-   e_comp_wl->kbd.mod_super =
+   e_comp_input_key->kbd.mod_super =
      xkb_map_mod_get_index(keymap, XKB_MOD_NAME_LOGO);
 
    if (!(tmp = xkb_map_get_as_string(keymap)))
@@ -1478,7 +1490,7 @@ _e_comp_wl_input_keymap_update(struct xkb_keymap *keymap, const char *keymap_pat
 
    /* send updated keymap */
    TRACE_INPUT_BEGIN(wl_keyboard_send_keymap_update);
-   EINA_LIST_FOREACH(e_comp_wl->kbd.resources, l, res)
+   EINA_LIST_FOREACH(e_comp_input_key->kbd.resources, l, res)
      wl_keyboard_send_keymap(res, WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1,
                              e_comp_input_key->xkb.fd,
                              e_comp_input_key->xkb.size);
@@ -1510,18 +1522,26 @@ e_comp_wl_input_init(void)
 
    /* get default keyboard repeat delay from configuration */
    atomic_store(&e_comp_wl->kbd.repeat_delay, e_config->keyboard.repeat_delay);
+   atomic_store(&e_comp_input_key->kbd.repeat_delay, e_config->keyboard.repeat_delay);
    /* check for valid repeat_delay */
    /* if invalid, set the default value of repeat delay */
    if (e_comp_wl->kbd.repeat_delay < 0)
      atomic_store(&e_comp_wl->kbd.repeat_delay, 400);
 
+   if (e_comp_input_key->kbd.repeat_delay < 0)
+     atomic_store(&e_comp_input_key->kbd.repeat_delay, 400);
+
    /* get default keyboard repeat rate from configuration */
    atomic_store(&e_comp_wl->kbd.repeat_rate, e_config->keyboard.repeat_rate);
+   atomic_store(&e_comp_input_key->kbd.repeat_rate, e_config->keyboard.repeat_rate);
    /* check for valid repeat_rate value */
    /* if invalid, set the default value of repeat rate value */
    if (e_comp_wl->kbd.repeat_rate < 0)
      atomic_store(&e_comp_wl->kbd.repeat_rate, 25);
 
+   if (e_comp_input_key->kbd.repeat_rate < 0)
+     atomic_store(&e_comp_input_key->kbd.repeat_rate, 25);
+
    /* create the global resource for input seat */
    e_comp_wl->seat.global =
      wl_global_create(e_comp_wl->wl.disp, &wl_seat_interface, 4,
@@ -1569,6 +1589,8 @@ e_comp_wl_input_init(void)
 
    wl_array_init(&e_comp_wl->kbd.keys);
    wl_array_init(&e_comp_wl->kbd.routed_keys);
+   wl_array_init(&e_comp_input_key->kbd.keys);
+   wl_array_init(&e_comp_input_key->kbd.routed_keys);
 
    E_EVENT_TEXT_INPUT_PANEL_VISIBILITY_CHANGE = ecore_event_type_new();
 
@@ -1674,7 +1696,6 @@ e_comp_wl_input_shutdown(void)
    g_mutex_clear(&e_comp_wl->xkb.keymap_mutex);
    g_mutex_clear(&e_comp_wl->xkb.state_mutex);
 
-   g_mutex_clear(&e_comp_wl->kbd.keys_mutex);
    g_mutex_clear(&e_comp_wl->kbd.repeat_delay_mutex);
    g_mutex_clear(&e_comp_wl->kbd.repeat_rate_mutex);
 }
@@ -1712,28 +1733,28 @@ e_comp_wl_input_keyboard_modifiers_serialize(void)
 
    mod = xkb_state_serialize_mods(e_comp_input_key->xkb.state,
                               XKB_STATE_DEPRESSED);
-   mod_depressed = atomic_load(&e_comp_wl->kbd.mod_depressed);
+   mod_depressed = atomic_load(&e_comp_input_key->kbd.mod_depressed);
    changed |= mod != mod_depressed;
-   atomic_store(&e_comp_wl->kbd.mod_depressed, mod);
+   atomic_store(&e_comp_input_key->kbd.mod_depressed, mod);
 
    mod = xkb_state_serialize_mods(e_comp_input_key->xkb.state,
                               XKB_STATE_MODS_LATCHED);
 
-   mod_latched = atomic_load(&e_comp_wl->kbd.mod_latched);
+   mod_latched = atomic_load(&e_comp_input_key->kbd.mod_latched);
    changed |= mod != mod_latched;
-   atomic_store(&e_comp_wl->kbd.mod_latched, mod);
+   atomic_store(&e_comp_input_key->kbd.mod_latched, mod);
 
    mod = xkb_state_serialize_mods(e_comp_input_key->xkb.state,
                               XKB_STATE_MODS_LOCKED);
-   mod_locked = atomic_load(&e_comp_wl->kbd.mod_locked);
+   mod_locked = atomic_load(&e_comp_input_key->kbd.mod_locked);
    changed |= mod != mod_locked;
-   atomic_store(&e_comp_wl->kbd.mod_locked, mod);
+   atomic_store(&e_comp_input_key->kbd.mod_locked, mod);
 
    grp = xkb_state_serialize_layout(e_comp_input_key->xkb.state,
                                 XKB_STATE_LAYOUT_EFFECTIVE);
-   mod_group = atomic_load(&e_comp_wl->kbd.mod_group);
+   mod_group = atomic_load(&e_comp_input_key->kbd.mod_group);
    changed |= grp != mod_group;
-   atomic_store(&e_comp_wl->kbd.mod_group, grp);
+   atomic_store(&e_comp_input_key->kbd.mod_group, grp);
 
    return changed;
 }
@@ -1746,18 +1767,18 @@ e_comp_wl_input_keyboard_modifiers_update(void)
    Eina_List *l;
 
    if (!e_comp_wl_input_keyboard_modifiers_serialize()) return;
-   if (!e_comp_wl->kbd.focused)
+   if (!e_comp_input_key->kbd.focused)
      {
        return;
      }
 
    serial = wl_display_next_serial(e_comp_wl->wl.disp);
-   EINA_LIST_FOREACH(e_comp_wl->kbd.focused, l, res)
+   EINA_LIST_FOREACH(e_comp_input_key->kbd.focused, l, res)
      wl_keyboard_send_modifiers(res, serial,
-                                e_comp_wl->kbd.mod_depressed,
-                                e_comp_wl->kbd.mod_latched,
-                                e_comp_wl->kbd.mod_locked,
-                                e_comp_wl->kbd.mod_group);
+                                e_comp_input_key->kbd.mod_depressed,
+                                e_comp_input_key->kbd.mod_latched,
+                                e_comp_input_key->kbd.mod_locked,
+                                e_comp_input_key->kbd.mod_group);
 }
 
 EINTERN void
@@ -1774,6 +1795,7 @@ e_comp_wl_input_keyboard_state_update(uint32_t keycode, Eina_Bool pressed)
    else dir = XKB_KEY_UP;
 
    atomic_store(&e_comp_wl->kbd.mod_changed, xkb_state_update_key(e_comp_input_key->xkb.state, keycode + 8, dir));
+   atomic_store(&e_comp_input_key->kbd.mod_changed, xkb_state_update_key(e_comp_input_key->xkb.state, keycode + 8, dir));
 
    e_comp_wl_input_keyboard_modifiers_update();
 }
@@ -1803,6 +1825,7 @@ e_comp_wl_input_keyboard_enabled_set(Eina_Bool enabled)
      }
 
    e_comp_wl->kbd.enabled = !!enabled;
+   e_comp_input_key->kbd.enabled = !!enabled;
    _e_comp_wl_input_update_seat_caps(NULL);
 }
 
@@ -2063,8 +2086,13 @@ e_comp_wl_input_seat_caps_set(unsigned int caps)
 
    if (caps & E_INPUT_SEAT_POINTER)
      e_comp_wl->ptr.enabled = need_update = EINA_TRUE;
+
    if (caps & E_INPUT_SEAT_KEYBOARD)
-     e_comp_wl->kbd.enabled = need_update = EINA_TRUE;
+     {
+        e_comp_wl->kbd.enabled = need_update = EINA_TRUE;
+        e_comp_input_key->kbd.enabled = need_update = EINA_TRUE;
+     }
+
    if (caps & E_INPUT_SEAT_TOUCH)
      e_comp_wl->touch.enabled = need_update = EINA_TRUE;
 
@@ -2090,11 +2118,14 @@ e_comp_wl_input_keyboard_repeat_set(int delay, int rate)
    atomic_store(&e_comp_wl->kbd.repeat_delay, delay);
    atomic_store(&e_comp_wl->kbd.repeat_rate, rate);
 
-   EINA_LIST_FOREACH(e_comp_wl->kbd.resources, l, res)
+   atomic_store(&e_comp_input_key->kbd.repeat_delay, delay);
+   atomic_store(&e_comp_input_key->kbd.repeat_rate, rate);
+
+   EINA_LIST_FOREACH(e_comp_input_key->kbd.resources, l, res)
      {
         if (wl_resource_get_version(res) >= WL_KEYBOARD_REPEAT_INFO_SINCE_VERSION)
-          wl_keyboard_send_repeat_info(res, e_comp_wl->kbd.repeat_rate,
-                                       e_comp_wl->kbd.repeat_delay);
+          wl_keyboard_send_repeat_info(res, e_comp_input_key->kbd.repeat_rate,
+                                       e_comp_input_key->kbd.repeat_delay);
      }
 }
 

diff --git a/src/bin/e_info_server.c b/src/bin/e_info_server.c
index ec59ab7..2472440 100644 (file)
--- a/src/bin/e_info_server.c
+++ b/src/bin/e_info_server.c
@@ -6628,13 +6628,44 @@ finish:
    return reply;
 }
 
+static void
+_e_info_server_input_thread_key_repeat_set(void *data)
+{
+   FILE *log_fp;
+   int delay = 0;
+   int rate = 0;
+   E_Input_Thread_Request_Key_Repeat_Data key_repeat_data;
+
+   memcpy(&key_repeat_data, data, sizeof(E_Input_Thread_Request_Key_Repeat_Data));
+
+   delay = key_repeat_data.delay;
+   rate = key_repeat_data.rate;
+
+   if (strlen(key_repeat_data.path) > 0)
+     {
+        log_fp = fopen(key_repeat_data.path, "a");
+        EINA_SAFETY_ON_NULL_RETURN(log_fp);
+
+        fprintf(log_fp, "\tkeyboard repeat info\n");
+        fprintf(log_fp, "\t\trate: %d (ms), delay: %d (ms)\n", e_comp_input_key->kbd.repeat_rate, e_comp_input_key->kbd.repeat_delay);
+        fclose(log_fp);
+        log_fp = NULL;
+     }
+   else
+     {
+        if (delay <= 0) delay = e_comp_input_key->kbd.repeat_delay;
+        if (rate <= 0) rate = e_comp_input_key->kbd.repeat_rate;
+
+        e_comp_wl_input_keyboard_repeat_set(delay, rate);
+     }
+}
+
 static Eldbus_Message *
 _e_info_server_cb_key_repeat(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg)
 {
    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
    const char *path = NULL;
    int rate = 0, delay = 0;
-   FILE *log_fp;
 
    if (!eldbus_message_arguments_get(msg, "sii", &path, &delay, &rate))
      {
@@ -6643,23 +6674,14 @@ _e_info_server_cb_key_repeat(const Eldbus_Service_Interface *iface EINA_UNUSED,
      }
    if (!e_comp_wl) return reply;
 
+   E_Input_Thread_Request_Key_Repeat_Data key_repeat_data = { 0 };
    if (path && strlen(path) > 0)
-     {
-        log_fp = fopen(path, "a");
-        EINA_SAFETY_ON_NULL_RETURN_VAL(log_fp, reply);
+      strncpy(key_repeat_data.path, path, strlen(path));
 
-        fprintf(log_fp, "\tkeyboard repeat info\n");
-        fprintf(log_fp, "\t\trate: %d (ms), delay: %d (ms)\n", e_comp_wl->kbd.repeat_rate, e_comp_wl->kbd.repeat_delay);
-        fclose(log_fp);
-        log_fp = NULL;
-     }
-   else
-     {
-        if (delay <= 0) delay = e_comp_wl->kbd.repeat_delay;
-        if (rate <= 0) rate = e_comp_wl->kbd.repeat_rate;
+   key_repeat_data.delay = delay;
+   key_repeat_data.rate = rate;
 
-        e_comp_wl_input_keyboard_repeat_set(delay, rate);
-     }
+   e_input_thread_safe_call(_e_info_server_input_thread_key_repeat_set, &key_repeat_data, sizeof(E_Input_Thread_Request_Key_Repeat_Data));
 
    return reply;
 }

diff --git a/src/bin/e_input_inputs.c b/src/bin/e_input_inputs.c
index d1af561..e970807 100644 (file)
--- a/src/bin/e_input_inputs.c
+++ b/src/bin/e_input_inputs.c
@@ -8,6 +8,7 @@
 #include "e_device_intern.h"
 #include "e_comp_wl_input_intern.h"
 #include "e_main_intern.h"
+#include "e_comp_input_intern.h"
 #include <libudev.h>
 
 #include <glib.h>
@@ -314,6 +315,12 @@ _e_input_add_ecore_device(E_Input_Evdev *edev, Ecore_Device_Class clas, Ecore_De
    e_device_class_set(e_dev, clas);
    e_device_subclass_set(e_dev, subclas);
 
+   if (clas == ECORE_DEVICE_CLASS_KEYBOARD)
+     {
+        e_comp_input_key->kbd.num_devices++;
+        e_comp_wl_input_keyboard_enabled_set(EINA_TRUE);
+     }
+
    if (!edev->e_dev)
      {
         if (!edev->e_dev_list || (g_list_length(edev->e_dev_list) == 0))
@@ -405,6 +412,15 @@ _e_input_remove_ecore_device(E_Input_Evdev *edev, Ecore_Device_Class clas)
 
         if ((e_device_class_get(device) == clas) && (!strcmp(device_identifier, edev->path)))
           {
+             if (clas == ECORE_DEVICE_CLASS_KEYBOARD)
+               {
+                  e_comp_input_key->kbd.num_devices--;
+                  if (e_comp_input_key->kbd.num_devices == 0)
+                    {
+                       e_comp_wl_input_keyboard_enabled_set(EINA_FALSE);
+                    }
+               }
+
              device_remove_log = eina_stringshare_printf("[Remove Device] device name(%s), identifier(%s), class(%s)",
                                                          e_device_name_get(device),
                                                          device_identifier,
@@ -948,6 +964,8 @@ input_thread_end(void *data, Ecore_Thread *th)
 
    if (th == input->input_thread)
      input->input_thread = NULL;
+
+   e_input_thread_shutdown();
 }
 
 static void
@@ -1100,10 +1118,18 @@ EINTERN void e_input_thread_init()
 
 EINTERN void e_input_thread_shutdown()
 {
+   struct wl_resource *res;
+
    EINA_SAFETY_ON_NULL_RETURN(g_input_backend);
 
    close(g_input_backend->main_to_input_thread_pipe_fd[0]);
    close(g_input_backend->main_to_input_thread_pipe_fd[1]);
+
+   EINA_LIST_FREE(e_comp_input_key->kbd.resources, res)
+     wl_resource_destroy(res);
+   e_comp_input_key->kbd.resources = eina_list_free(e_comp_input_key->kbd.resources);
+
+   wl_array_release(&e_comp_input_key->kbd.routed_keys);
 }
 
 EINTERN void e_input_thread_input_backend_set(E_Input_Backend *input)

diff --git a/src/bin/e_input_intern.h b/src/bin/e_input_intern.h
index 51dca4b..c82d18a 100644 (file)
--- a/src/bin/e_input_intern.h
+++ b/src/bin/e_input_intern.h
@@ -42,6 +42,13 @@ typedef struct
 
 typedef struct
 {
+  char path[1024];
+  int delay;
+  int rate;
+} E_Input_Thread_Request_Key_Repeat_Data;
+
+typedef struct
+{
   int resource_version;
   struct wl_client *client;
   uint32_t id;

diff --git a/src/bin/e_keyrouter_wl.c b/src/bin/e_keyrouter_wl.c
index d99becc..25ade28 100644 (file)
--- a/src/bin/e_keyrouter_wl.c
+++ b/src/bin/e_keyrouter_wl.c
@@ -4,6 +4,7 @@
 #include "e_comp_wl_intern.h"
 #include "e_client_intern.h"
 #include "e_config_intern.h"
+#include "e_comp_input_intern.h"
 
 #include <tizen-extension-server-protocol.h>
 
@@ -133,7 +134,7 @@ e_keyrouter_wl_key_send(Ecore_Event_Key *ev, E_Device *dev, Eina_Bool pressed, s
 
    if (!focused)
      {
-        _e_keyrouter_wl_key_send(ev, dev, state, e_comp_wl->kbd.resources, EINA_FALSE, client, surface);
+        _e_keyrouter_wl_key_send(ev, dev, state, e_comp_input_key->kbd.resources, EINA_FALSE, client, surface);
         return EINA_FALSE;
      }
 
@@ -146,10 +147,10 @@ e_keyrouter_wl_key_send(Ecore_Event_Key *ev, E_Device *dev, Eina_Bool pressed, s
              struct wl_resource *surface = e_comp_wl_client_surface_get(ec);
              if (surface)
                {
-                  if (e_comp_wl->kbd.focused)
+                  if (e_comp_input_key->kbd.focused)
                     {
                        wc = wl_resource_get_client(surface);
-                       _e_keyrouter_wl_key_send(ev, dev, state, e_comp_wl->kbd.focused, EINA_TRUE, wc, surface);
+                       _e_keyrouter_wl_key_send(ev, dev, state, e_comp_input_key->kbd.focused, EINA_TRUE, wc, surface);
                     }
                }
 

diff --git a/src/include/e_comp_wl.h b/src/include/e_comp_wl.h
index 2ef548b..7bbacbc 100644 (file)
--- a/src/include/e_comp_wl.h
+++ b/src/include/e_comp_wl.h
@@ -234,7 +234,7 @@ struct _E_Comp_Wl_Data
         int mod_changed;
         atomic_int repeat_delay;
         atomic_int repeat_rate;
-        unsigned int num_devices;
+        EINA_DEPRECATED unsigned int num_devices;
         GMutex resource_mutex; /* for resources variable */
         GMutex focused_mutex; /* for focused variable */
         EINA_DEPRECATED GMutex keys_mutex; /* for keys variable */