E_FREE(e_comp_input_key);
}
-}
\ No newline at end of file
+}
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;
#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>
}
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);
_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--;
struct wl_resource *res;
E_Comp_Wl_Key_Data *k;
- if (!e_comp_wl->kbd.focused)
+ if (!e_comp_input_key->kbd.focused)
{
return;
}
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,
}
}
- 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();
}
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;
}
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);
}
}
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);
+
}
}
}
e_comp_wl->kbd.focus = ec->comp_data->surface;
+ e_comp_input_key->kbd.focus = ec->comp_data->surface;
}
static void
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
}
#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)
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;
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;
}
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)
{
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);
}
}
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())
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);
#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>
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)
{
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))
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;
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)))
{
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;
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
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;
}
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,
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);
/* 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 */
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));
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)))
/* 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);
/* 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,
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();
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);
}
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;
}
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
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();
}
}
e_comp_wl->kbd.enabled = !!enabled;
+ e_comp_input_key->kbd.enabled = !!enabled;
_e_comp_wl_input_update_seat_caps(NULL);
}
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;
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);
}
}
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))
{
}
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;
}
#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>
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))
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,
if (th == input->input_thread)
input->input_thread = NULL;
+
+ e_input_thread_shutdown();
}
static void
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)
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;
#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>
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;
}
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);
}
}
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 */