+ Eina_List *l, *l_next;
+ Efl_Util_Device_Info *dev;
+
+ EINA_LIST_FOREACH_SAFE(_eflutil.wl.devmgr.devices, l, l_next, dev)
+ {
+ if (dev->device == device)
+ {
+ if (dev->name) eina_stringshare_del(dev->name);
+ tizen_input_device_release(dev->device);
+
+ _eflutil.wl.devmgr.devices = eina_list_remove_list(_eflutil.wl.devmgr.devices, l);
+ free(dev);
+
+ break;
+ }
+ }
+}
+
+static void
+_cb_error(void *data EINA_UNUSED,
+ struct tizen_input_device_manager *tizen_input_device_manager EINA_UNUSED,
+ uint32_t errorcode)
+{
+ _eflutil.wl.devmgr.request_notified = errorcode;
+}
+
+/* LCOV_EXCL_START */
+static void
+_cb_block_expired(void *data EINA_UNUSED,
+ struct tizen_input_device_manager *tizen_input_device_manager EINA_UNUSED)
+{
+ ;
+}
+/* LCOV_EXCL_STOP */
+
+static efl_util_error_e
+_efl_util_input_convert_input_generator_error(int ret)
+{
+ switch (ret)
+ {
+ case TIZEN_INPUT_DEVICE_MANAGER_ERROR_NONE:
+ return EFL_UTIL_ERROR_NONE;
+ case TIZEN_INPUT_DEVICE_MANAGER_ERROR_NO_PERMISSION:
+ return EFL_UTIL_ERROR_PERMISSION_DENIED;
+ case TIZEN_INPUT_DEVICE_MANAGER_ERROR_NO_SYSTEM_RESOURCES:
+ return EFL_UTIL_ERROR_OUT_OF_MEMORY;
+ case TIZEN_INPUT_DEVICE_MANAGER_ERROR_INVALID_PARAMETER:
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
+ default :
+ return EFL_UTIL_ERROR_NONE;
+ }
+}
+
+/* LCOV_EXCL_START */
+static int
+_timer_wait(void *data)
+{
+ Efl_Util_Device_Info *dev;
+
+ _eflutil.wl.devmgr.request_notified = TIZEN_INPUT_DEVICE_MANAGER_ERROR_NO_SYSTEM_RESOURCES;
+
+ if (eina_list_count(_eflutil.wl.devmgr.wait_devices) > 0)
+ {
+ EINA_LIST_FREE(_eflutil.wl.devmgr.wait_devices, dev)
+ {
+ eina_stringshare_del(dev->name);
+ dev->name = NULL;
+ }
+ }
+
+ wl_event_source_remove(_eflutil.wl.devmgr.wait_timer);
+ _eflutil.wl.devmgr.wait_timer = NULL;
+
+ return 1;
+}
+/* LCOV_EXCL_STOP */
+
+static void
+_efl_util_input_initialize_wait_device(void)
+{
+ struct wl_event_loop *loop;
+ int ret = -1;
+
+ if (_efl_util_input_check_wait_device_full()) return;
+
+ loop = wl_event_loop_create();
+ _eflutil.wl.devmgr.wait_timer = wl_event_loop_add_timer(loop, _timer_wait, NULL);
+ if (_eflutil.wl.devmgr.wait_timer)
+ {
+ ret = wl_event_source_timer_update(_eflutil.wl.devmgr.wait_timer,
+ EFL_UTIL_INPUT_GENERATOR_DEFAULT_TIME_OUT);
+ if (ret != 0) _timer_wait(NULL);
+ return;
+ }
+
+ while (_eflutil.wl.devmgr.wait_timer)
+ {
+ wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
+ ret = wl_event_loop_dispatch(loop, EFL_UTIL_INPUT_GENERATOR_DEFAULT_DISPATCH_TIME_OUT);
+ if (ret != 0) _timer_wait(NULL);
+ }
+}
+
+static void
+_efl_util_input_initialize_append_device(const char *name, Ecore_Device_Class clas)
+{
+ Efl_Util_Device_Info *dev;
+
+ dev = (Efl_Util_Device_Info *)calloc(1, sizeof(Efl_Util_Device_Info));
+ EINA_SAFETY_ON_NULL_RETURN(dev);
+
+ dev->name = eina_stringshare_add(name);
+ dev->clas = clas;
+
+ _eflutil.wl.devmgr.wait_devices = eina_list_append(_eflutil.wl.devmgr.wait_devices, dev);
+}
+
+static void
+_efl_util_input_initialize_add_wait_device(const char *name, unsigned int dev_type)
+{
+ EINA_SAFETY_ON_NULL_RETURN(name);
+
+ if (dev_type & EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN)
+ _efl_util_input_initialize_append_device(name, ECORE_DEVICE_CLASS_TOUCH);
+
+ if (dev_type & EFL_UTIL_INPUT_DEVTYPE_KEYBOARD)
+ _efl_util_input_initialize_append_device(name, ECORE_DEVICE_CLASS_KEYBOARD);
+
+ if (dev_type & EFL_UTIL_INPUT_DEVTYPE_POINTER)
+ _efl_util_input_initialize_append_device(name, ECORE_DEVICE_CLASS_MOUSE);
+}
+
+API efl_util_inputgen_h
+efl_util_input_initialize_generator(unsigned int dev_type)
+{
+ int ret = EFL_UTIL_ERROR_NONE;
+ efl_util_inputgen_h inputgen_h = NULL;
+ unsigned int clas = 0x0;
+
+ if (!dev_type ||
+ dev_type & ~(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN
+ | EFL_UTIL_INPUT_DEVTYPE_KEYBOARD
+ | EFL_UTIL_INPUT_DEVTYPE_POINTER))
+ {
+ set_last_result(EFL_UTIL_ERROR_NO_SUCH_DEVICE);
+ goto out;
+ }
+
+ inputgen_h = (efl_util_inputgen_h)calloc(1, sizeof(struct _efl_util_inputgen_h));
+ if (!inputgen_h)
+ {
+ set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY);
+ goto out;
+ }
+
+ inputgen_h->init_type |= dev_type;
+
+ ret = _wl_init();
+ if (ret == (int)EINA_FALSE)
+ {
+ set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
+ goto out;
+ }
+
+ if (dev_type & EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN)
+ clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_TOUCHSCREEN;
+ if (dev_type & EFL_UTIL_INPUT_DEVTYPE_KEYBOARD)
+ clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_KEYBOARD;
+ if (dev_type & EFL_UTIL_INPUT_DEVTYPE_POINTER)
+ clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_MOUSE;
+
+ while (!_eflutil.wl.devmgr.devicemgr)
+ wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
+
+ tizen_input_device_manager_init_generator(_eflutil.wl.devmgr.devicemgr, clas);
+
+ while (_eflutil.wl.devmgr.request_notified == -1)
+ wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
+
+ ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
+ _eflutil.wl.devmgr.request_notified = -1;
+
+ set_last_result(ret);
+ if (ret != TIZEN_INPUT_DEVICE_MANAGER_ERROR_NONE)
+ goto out;
+
+ return inputgen_h;
+
+out:
+ if (inputgen_h)
+ {
+ free(inputgen_h);
+ inputgen_h = NULL;
+ }
+ return NULL;
+}
+
+API efl_util_inputgen_h
+efl_util_input_initialize_generator_with_name(unsigned int dev_type, const char *name)
+{
+ int ret = EFL_UTIL_ERROR_NONE;
+ efl_util_inputgen_h inputgen_h = NULL;
+ unsigned int clas = 0x0;
+
+ if (!dev_type ||
+ dev_type & ~(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN
+ | EFL_UTIL_INPUT_DEVTYPE_KEYBOARD
+ | EFL_UTIL_INPUT_DEVTYPE_POINTER))
+ {
+ set_last_result(EFL_UTIL_ERROR_NO_SUCH_DEVICE);
+ goto out;
+ }
+
+ inputgen_h = (efl_util_inputgen_h)calloc(1, sizeof(struct _efl_util_inputgen_h));
+ if (!inputgen_h)
+ {
+ set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY);
+ goto out;
+ }
+
+ inputgen_h->init_type |= dev_type;
+ strncpy(inputgen_h->name, name, 31);
+
+ ret = _wl_init();
+ if (ret == (int)EINA_FALSE)
+ {
+ set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
+ goto out;
+ }
+
+ if (dev_type & EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN)
+ clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_TOUCHSCREEN;
+ if (dev_type & EFL_UTIL_INPUT_DEVTYPE_KEYBOARD)
+ clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_KEYBOARD;
+ if (dev_type & EFL_UTIL_INPUT_DEVTYPE_POINTER)
+ clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_MOUSE;
+
+ while (!_eflutil.wl.devmgr.devicemgr)
+ wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
+
+ tizen_input_device_manager_init_generator_with_name(_eflutil.wl.devmgr.devicemgr, clas, inputgen_h->name);
+
+ while (_eflutil.wl.devmgr.request_notified == -1)
+ wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
+
+ ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
+ _eflutil.wl.devmgr.request_notified = -1;
+
+ set_last_result(ret);
+ if (ret != TIZEN_INPUT_DEVICE_MANAGER_ERROR_NONE)
+ goto out;
+
+ return inputgen_h;
+
+out:
+ if (inputgen_h)
+ {
+ free(inputgen_h);
+ inputgen_h = NULL;
+ }
+ return NULL;
+}
+
+API efl_util_inputgen_h
+efl_util_input_initialize_generator_with_sync(unsigned int dev_type, const char *name)
+{
+ int ret = EFL_UTIL_ERROR_NONE;
+ efl_util_inputgen_h inputgen_h = NULL;
+ unsigned int clas = 0x0;
+
+ if (!dev_type ||
+ dev_type & ~(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN
+ | EFL_UTIL_INPUT_DEVTYPE_KEYBOARD
+ | EFL_UTIL_INPUT_DEVTYPE_POINTER))
+ {
+ set_last_result(EFL_UTIL_ERROR_NO_SUCH_DEVICE);
+ goto out;
+ }
+
+ inputgen_h = (efl_util_inputgen_h)calloc(1, sizeof(struct _efl_util_inputgen_h));
+ if (!inputgen_h)
+ {
+ set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY);
+ goto out;
+ }
+
+ inputgen_h->init_type |= dev_type;
+ if (name) strncpy(inputgen_h->name, name, 31);
+ else strncpy(inputgen_h->name, "Input Generator", 31);
+
+ ret = _wl_init();
+ if (ret == (int)EINA_FALSE)
+ {
+ set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
+ goto out;
+ }
+
+ if (dev_type & EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN)
+ clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_TOUCHSCREEN;
+ if (dev_type & EFL_UTIL_INPUT_DEVTYPE_KEYBOARD)
+ clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_KEYBOARD;
+ if (dev_type & EFL_UTIL_INPUT_DEVTYPE_POINTER)
+ clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_MOUSE;
+
+ while (!_eflutil.wl.devmgr.devicemgr)
+ wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
+
+ tizen_input_device_manager_init_generator_with_name(_eflutil.wl.devmgr.devicemgr, clas, inputgen_h->name);
+
+ while (_eflutil.wl.devmgr.request_notified == -1)
+ wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
+
+ ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
+ _eflutil.wl.devmgr.request_notified = -1;
+
+ if (ret == EFL_UTIL_ERROR_NONE)
+ {
+ _efl_util_input_initialize_add_wait_device(inputgen_h->name, dev_type);
+ _efl_util_input_initialize_wait_device();
+ if (_eflutil.wl.devmgr.request_notified != -1)
+ {
+ ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
+ _eflutil.wl.devmgr.request_notified = -1;
+ }
+ }
+
+ set_last_result(ret);
+ if (ret != TIZEN_INPUT_DEVICE_MANAGER_ERROR_NONE)
+ goto out;
+
+ return inputgen_h;
+
+out:
+ if (inputgen_h)
+ {
+ free(inputgen_h);
+ inputgen_h = NULL;
+ }
+ return NULL;
+}
+
+API int
+efl_util_input_deinitialize_generator(efl_util_inputgen_h inputgen_h)
+{
+ int ret = EFL_UTIL_ERROR_NONE;
+ unsigned int clas = 0x0;
+ EINA_SAFETY_ON_NULL_RETURN_VAL(inputgen_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+ if (inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN)
+ clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_TOUCHSCREEN;
+ if (inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_KEYBOARD)
+ clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_KEYBOARD;
+ if (inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_POINTER)
+ clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_MOUSE;
+
+ if (inputgen_h->axis_info)
+ free(inputgen_h->axis_info);
+
+ free(inputgen_h);
+ inputgen_h = NULL;
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.devmgr.devicemgr, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+ tizen_input_device_manager_deinit_generator(_eflutil.wl.devmgr.devicemgr, clas);
+
+ while (_eflutil.wl.devmgr.request_notified == -1)
+ wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
+
+ ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
+ _eflutil.wl.devmgr.request_notified = -1;
+
+ return ret;
+}
+
+API int
+efl_util_input_generate_key(efl_util_inputgen_h inputgen_h, const char *key_name, int pressed)
+{
+ int ret = EFL_UTIL_ERROR_NONE;
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(inputgen_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(key_name, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(pressed == 0 || pressed == 1, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_KEYBOARD, EFL_UTIL_ERROR_NO_SUCH_DEVICE);
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.devmgr.devicemgr, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+ tizen_input_device_manager_generate_key(_eflutil.wl.devmgr.devicemgr, key_name, pressed);
+
+ while (_eflutil.wl.devmgr.request_notified == -1)
+ wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
+
+ ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
+ _eflutil.wl.devmgr.request_notified = -1;
+
+ return ret;
+}
+
+API int
+efl_util_input_generate_touch(efl_util_inputgen_h inputgen_h, int idx,
+ efl_util_input_touch_type_e touch_type, int x, int y)
+{
+ int ret;
+ enum tizen_input_device_manager_pointer_event_type type;
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(inputgen_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(idx >= 0, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL((x > 0 && y > 0), EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN, EFL_UTIL_ERROR_NO_SUCH_DEVICE);
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.devmgr.devicemgr, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+ switch(touch_type)
+ {
+ case EFL_UTIL_INPUT_TOUCH_BEGIN:
+ type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_BEGIN;
+ break;
+ case EFL_UTIL_INPUT_TOUCH_UPDATE:
+ type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_UPDATE;
+ break;
+ case EFL_UTIL_INPUT_TOUCH_END:
+ type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_END;
+ break;
+ default:
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
+ }
+
+ tizen_input_device_manager_generate_touch(_eflutil.wl.devmgr.devicemgr, type, x, y, idx);
+
+ while (_eflutil.wl.devmgr.request_notified == -1)
+ wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
+
+ ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
+ _eflutil.wl.devmgr.request_notified = -1;
+
+ return ret;
+}
+
+static int
+_efl_util_input_generate_touch_axis_send(unsigned int type, double value)
+{
+ int ret;
+
+ tizen_input_device_manager_generate_axis(_eflutil.wl.devmgr.devicemgr, type, wl_fixed_from_double(value));
+
+ while (_eflutil.wl.devmgr.request_notified == -1)
+ wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
+
+ ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
+ _eflutil.wl.devmgr.request_notified = -1;
+
+ return ret;
+}
+
+static void
+_efl_util_input_generate_touch_axis_cleanup(efl_util_inputgen_h inputgen_h, int idx)
+{
+ int i;
+ if (idx >= 0)
+ {
+ inputgen_h->axis_info[idx].radius_x = 1.0;
+ inputgen_h->axis_info[idx].radius_y = 1.0;
+ inputgen_h->axis_info[idx].pressure = 1.0;
+ inputgen_h->axis_info[idx].angle = 0.0;
+ inputgen_h->axis_info[idx].palm = 0.0;
+ }
+ else
+ {
+ for (i = 0; i < EFL_UTIL_INPUT_GENERATOR_TOUCH_MAX_FINGER; i++)
+ {
+ inputgen_h->axis_info[i].radius_x = 1.0;
+ inputgen_h->axis_info[i].radius_y = 1.0;
+ inputgen_h->axis_info[i].pressure = 1.0;
+ inputgen_h->axis_info[i].angle = 0.0;
+ inputgen_h->axis_info[i].palm = 0.0;
+ }
+ }
+}
+
+static int
+_efl_util_input_generate_touch_axis_process(efl_util_inputgen_h inputgen_h, int idx, double radius_x,
+ double radius_y, double pressure, double angle, double palm)
+{
+ int ret = EFL_UTIL_ERROR_NONE;
+
+ if (!inputgen_h->axis_info)
+ {
+ inputgen_h->axis_info = calloc(EFL_UTIL_INPUT_GENERATOR_TOUCH_MAX_FINGER,
+ sizeof(E_Devicemgr_Inputgen_Touch_Axis));
+ _efl_util_input_generate_touch_axis_cleanup(inputgen_h, -1);
+ }
+
+ if (inputgen_h->axis_info[idx].radius_x != radius_x)
+ {
+ ret = _efl_util_input_generate_touch_axis_send(TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_RADIUS_X, radius_x);
+ if (ret != EFL_UTIL_ERROR_NONE) return ret;
+ inputgen_h->axis_info[idx].radius_x = radius_x;
+ }
+ if (inputgen_h->axis_info[idx].radius_y != radius_y)
+ {
+ ret = _efl_util_input_generate_touch_axis_send(TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_RADIUS_Y, radius_y);
+ if (ret != EFL_UTIL_ERROR_NONE) return ret;
+ inputgen_h->axis_info[idx].radius_y = radius_y;
+ }
+ if (inputgen_h->axis_info[idx].pressure != pressure)
+ {
+ ret = _efl_util_input_generate_touch_axis_send(TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_PRESSURE, pressure);
+ if (ret != EFL_UTIL_ERROR_NONE) return ret;
+ inputgen_h->axis_info[idx].pressure = pressure;
+ }
+ if (inputgen_h->axis_info[idx].angle != angle)
+ {
+ ret = _efl_util_input_generate_touch_axis_send(TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_ANGLE, angle);
+ if (ret != EFL_UTIL_ERROR_NONE) return ret;
+ inputgen_h->axis_info[idx].angle = angle;
+ }
+ if (inputgen_h->axis_info[idx].palm != palm)
+ {
+ ret = _efl_util_input_generate_touch_axis_send(TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_PALM, palm);
+ if (ret != EFL_UTIL_ERROR_NONE) return ret;
+ inputgen_h->axis_info[idx].palm = palm;
+ }
+
+ return ret;
+}
+
+API int
+efl_util_input_generate_touch_axis(efl_util_inputgen_h inputgen_h, int idx,
+ efl_util_input_touch_type_e touch_type, int x, int y,
+ double radius_x, double radius_y,
+ double pressure, double angle, double palm)
+{
+ int ret, version;
+ enum tizen_input_device_manager_pointer_event_type type;
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(inputgen_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(idx >= 0, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL((x >= 0 && y >= 0), EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN, EFL_UTIL_ERROR_NO_SUCH_DEVICE);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL((radius_x >= 0.0 && radius_y >= 0.0), EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL((pressure >= 0.0 && palm >= 0.0), EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.devmgr.devicemgr, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ version = tizen_input_device_manager_get_version(_eflutil.wl.devmgr.devicemgr);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL((version >= 3), EFL_UTIL_ERROR_NOT_SUPPORTED);
+
+ switch(touch_type)
+ {
+ case EFL_UTIL_INPUT_TOUCH_BEGIN:
+ type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_BEGIN;
+ break;
+ case EFL_UTIL_INPUT_TOUCH_UPDATE:
+ type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_UPDATE;
+ break;
+ case EFL_UTIL_INPUT_TOUCH_END:
+ type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_END;
+ break;
+ default:
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
+ }
+
+ if (touch_type != EFL_UTIL_INPUT_TOUCH_END)
+ _efl_util_input_generate_touch_axis_process(inputgen_h, idx, radius_x, radius_y, pressure, angle, palm);
+ else
+ _efl_util_input_generate_touch_axis_cleanup(inputgen_h, idx);
+
+ tizen_input_device_manager_generate_touch(_eflutil.wl.devmgr.devicemgr, type, x, y, idx);
+
+ while (_eflutil.wl.devmgr.request_notified == -1)
+ wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
+
+ ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
+ _eflutil.wl.devmgr.request_notified = -1;
+
+ return ret;
+}
+
+
+API int
+efl_util_input_generate_pointer(efl_util_inputgen_h inputgen_h, int buttons, efl_util_input_pointer_type_e pointer_type, int x, int y)
+{
+ int ret;
+ enum tizen_input_device_manager_pointer_event_type type;
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(inputgen_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(buttons > 0, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL((x >= 0 && y >= 0), EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_POINTER, EFL_UTIL_ERROR_NO_SUCH_DEVICE);
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.devmgr.devicemgr, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+ switch(pointer_type)
+ {
+ case EFL_UTIL_INPUT_POINTER_BUTTON_DOWN:
+ type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_BEGIN;
+ break;
+ case EFL_UTIL_INPUT_POINTER_MOVE:
+ type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_UPDATE;
+ break;
+ case EFL_UTIL_INPUT_POINTER_BUTTON_UP:
+ type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_END;
+ break;
+ default:
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
+ }
+
+ tizen_input_device_manager_generate_pointer(_eflutil.wl.devmgr.devicemgr, type, x, y, buttons);
+
+ while (_eflutil.wl.devmgr.request_notified == -1)
+ wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
+
+ ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
+ _eflutil.wl.devmgr.request_notified = -1;
+
+ return ret;
+}
+
+API int
+efl_util_input_generate_wheel(efl_util_inputgen_h inputgen_h, efl_util_input_pointer_wheel_type_e wheel_type, int value)
+{
+ int ret, version;
+ enum tizen_input_device_manager_pointer_event_type type;
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(inputgen_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_POINTER, EFL_UTIL_ERROR_NO_SUCH_DEVICE);
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.devmgr.devicemgr, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ version = tizen_input_device_manager_get_version(_eflutil.wl.devmgr.devicemgr);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL((version >= 3), EFL_UTIL_ERROR_NOT_SUPPORTED);
+
+ switch(wheel_type)
+ {
+ case EFL_UTIL_INPUT_POINTER_WHEEL_VERT:
+ type = TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_WHEEL;
+ break;
+ case EFL_UTIL_INPUT_POINTER_WHEEL_HORZ:
+ type = TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_HWHEEL;
+ break;
+ default:
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
+ }
+
+ tizen_input_device_manager_generate_axis(_eflutil.wl.devmgr.devicemgr, type, wl_fixed_from_int(value));
+
+ while (_eflutil.wl.devmgr.request_notified == -1)
+ wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
+
+ ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
+ _eflutil.wl.devmgr.request_notified = -1;
+
+ return ret;
+}
+
+
+
+struct _efl_util_screenshot_h
+{
+ int width;
+ int height;
+
+ Eina_Bool shot_done;
+
+ /* tbm bufmgr */
+ tbm_bufmgr bufmgr;
+
+ Eina_Bool auto_rotation;
+};
+
+/* scrrenshot handle */
+static efl_util_screenshot_h g_screenshot;
+static Eina_Bool shot_mutex_init;
+static pthread_mutex_t shot_lock;
+
+static Eina_Bool
+_screenshot_mutex_init(void)
+{
+ if (shot_mutex_init)
+ return EINA_TRUE;
+
+ if (pthread_mutex_init(&shot_lock, NULL))
+ {
+ fprintf(stderr, "[screenshot] fail: mutex init"); /*LCOV_EXCL_LINE*/
+ return EINA_FALSE; /*LCOV_EXCL_LINE*/
+ }
+
+ shot_mutex_init = EINA_TRUE;
+
+ return EINA_TRUE;
+}
+
+static Eina_Bool
+_screenshot_mutex_destory(void)
+{
+ if (!shot_mutex_init)
+ return EINA_TRUE;
+
+ if (pthread_mutex_destroy(&shot_lock))
+ {
+ fprintf(stderr, "[screenshot] fail: mutex destory"); /*LCOV_EXCL_LINE*/
+ return EINA_FALSE; /*LCOV_EXCL_LINE*/
+ }
+
+ shot_mutex_init = EINA_FALSE;
+
+ return EINA_TRUE;
+}
+
+void
+_screenshot_mutex_lock(void)
+{
+ if (!_screenshot_mutex_init())
+ return;
+
+ pthread_mutex_lock(&shot_lock);
+}
+
+void
+_screenshot_mutex_unlock(void)
+{
+ pthread_mutex_unlock(&shot_lock);
+}
+
+API efl_util_screenshot_h
+efl_util_screenshot_initialize(int width, int height)
+{
+ efl_util_screenshot_h screenshot = NULL;
+ struct wl_display *display_wrapper = NULL;
+ struct wl_registry *reg = NULL;
+ int ret = 0;
+
+ if (width <= 0 || height <= 0)
+ {
+ set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
+ return NULL;
+ }
+
+ _screenshot_mutex_lock();
+
+ if (!g_screenshot)
+ {
+ screenshot = calloc(1, sizeof(struct _efl_util_screenshot_h));
+ EINA_SAFETY_ON_NULL_GOTO(screenshot, fail_memory);
+ }
+
+ if (!_eflutil.wl.shot.screenshooter)
+ {
+ ret = _wl_init();
+ if (ret == (int)EINA_FALSE)
+ {
+ set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
+ _screenshot_mutex_unlock();
+ return NULL;
+ }
+ wl_display_roundtrip_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
+
+ display_wrapper = wl_proxy_create_wrapper(_eflutil.wl.dpy);
+ EINA_SAFETY_ON_NULL_GOTO(display_wrapper, fail_memory);
+
+ _eflutil.wl.shot.queue = wl_display_create_queue(_eflutil.wl.dpy);
+ EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.shot.queue, fail_memory);
+
+ wl_proxy_set_queue((struct wl_proxy *)display_wrapper, _eflutil.wl.shot.queue);
+
+ reg = wl_display_get_registry(display_wrapper);
+ wl_proxy_wrapper_destroy(display_wrapper);
+ display_wrapper = NULL;
+ EINA_SAFETY_ON_NULL_GOTO(reg, fail_init);
+
+ wl_registry_add_listener(reg, &_wl_reg_screenshooter_listener, NULL);
+
+ ret = wl_display_roundtrip_queue(_eflutil.wl.dpy, _eflutil.wl.shot.queue);
+ EINA_SAFETY_ON_TRUE_GOTO(ret == -1, fail_init);
+ EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.shot.screenshooter, fail_init);
+ EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.shot.tz_screenshooter, fail_init);
+
+ _eflutil.wl.shot.tbm_client = wayland_tbm_client_init(_eflutil.wl.dpy);
+ EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.shot.tbm_client, fail_init);
+
+ wl_registry_destroy(reg);
+ reg = NULL;
+ }
+
+ if (_eflutil.wl.shot.noti == 0)
+ {
+ fprintf(stderr, "[screenshot] fail: privilege error\n"); /* LCOV_EXCL_LINE */
+ goto fail_init;
+ }
+
+ if (g_screenshot)
+ {
+ if (g_screenshot->width != width || g_screenshot->height != height)
+ {
+ g_screenshot->width = width;
+ g_screenshot->height = height;
+ }
+ set_last_result(EFL_UTIL_ERROR_NONE);
+
+ _screenshot_mutex_unlock();
+
+ return g_screenshot;
+ }
+
+ screenshot->width = width;
+ screenshot->height = height;
+ screenshot->auto_rotation = EINA_TRUE;
+
+ screenshot->bufmgr = wayland_tbm_client_get_bufmgr(_eflutil.wl.shot.tbm_client);
+ EINA_SAFETY_ON_NULL_GOTO(screenshot->bufmgr, fail_init);
+
+ g_screenshot = screenshot;
+ set_last_result(EFL_UTIL_ERROR_NONE);
+
+ screenshooter_set_user_data(_eflutil.wl.shot.screenshooter, &screenshot->shot_done);
+
+ _screenshot_mutex_unlock();
+
+ return g_screenshot;
+
+/* LCOV_EXCL_START */
+fail_memory:
+ if (display_wrapper)
+ wl_proxy_wrapper_destroy(display_wrapper);
+ set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY);
+ _screenshot_mutex_unlock();
+ return NULL;
+
+fail_init:
+ if (reg)
+ wl_registry_destroy(reg);
+ if (screenshot)
+ {
+ _screenshot_mutex_unlock();
+ efl_util_screenshot_deinitialize(screenshot);
+ }
+ if (_eflutil.wl.shot.noti == 0)
+ set_last_result(EFL_UTIL_ERROR_PERMISSION_DENIED);
+ else
+ set_last_result(EFL_UTIL_ERROR_SCREENSHOT_INIT_FAIL);
+ return NULL;
+/* LCOV_EXCL_STOP */
+}
+
+API int
+efl_util_screenshot_deinitialize(efl_util_screenshot_h screenshot)
+{
+ _screenshot_mutex_lock();
+
+ if (!screenshot)
+ {
+ _screenshot_mutex_unlock();
+ _screenshot_mutex_destory();
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
+ }
+
+ free(screenshot);
+ g_screenshot = NULL;
+
+ if (_eflutil.wl.shot.tbm_client)
+ {
+ wayland_tbm_client_deinit(_eflutil.wl.shot.tbm_client);
+ _eflutil.wl.shot.tbm_client = NULL;
+ }
+
+ if (_eflutil.wl.shot.screenshooter)
+ {
+ screenshooter_destroy(_eflutil.wl.shot.screenshooter);
+ _eflutil.wl.shot.screenshooter = NULL;
+ }
+ if (_eflutil.wl.shot.tz_screenshooter)
+ {
+ tizen_screenshooter_destroy(_eflutil.wl.shot.tz_screenshooter);
+ _eflutil.wl.shot.tz_screenshooter = NULL;
+ }
+
+ if (_eflutil.wl.shot.queue)
+ {
+ wl_event_queue_destroy(_eflutil.wl.shot.queue);
+ _eflutil.wl.shot.queue = NULL;
+ }
+
+ _screenshot_mutex_unlock();
+ _screenshot_mutex_destory();
+
+ return EFL_UTIL_ERROR_NONE;
+}
+
+
+API tbm_surface_h
+efl_util_screenshot_take_tbm_surface(efl_util_screenshot_h screenshot)
+{
+ tbm_surface_h t_surface = NULL;
+ struct wl_buffer *buffer = NULL;
+ Efl_Util_Wl_Output_Info *output;
+ int ret = 0;
+
+ _screenshot_mutex_lock();
+
+ if (!screenshot || (screenshot != g_screenshot))
+ {
+ set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
+ _screenshot_mutex_unlock();
+ return NULL;
+ }
+
+ output = eina_list_nth(_eflutil.wl.shot.output_list, 0);
+ if (!output)
+ {
+ fprintf(stderr, "[screenshot] fail: no output for screenshot\n"); /* LCOV_EXCL_LINE */
+ goto fail;
+ }
+
+ t_surface = tbm_surface_create(screenshot->width, screenshot->height, TBM_FORMAT_XRGB8888);
+ if (!t_surface)
+ {
+ fprintf(stderr, "[screenshot] fail: tbm_surface_create\n"); /* LCOV_EXCL_LINE */
+ goto fail;
+ }
+
+ buffer = wayland_tbm_client_create_buffer(_eflutil.wl.shot.tbm_client, t_surface);
+ if (!buffer)
+ {
+ fprintf(stderr, "[screenshot] fail: create wl_buffer for screenshot\n"); /* LCOV_EXCL_LINE */
+ goto fail;
+ }
+
+ screenshooter_shoot(_eflutil.wl.shot.screenshooter, output->output, buffer);
+
+ screenshot->shot_done = EINA_FALSE;
+ while (!screenshot->shot_done && ret != -1)
+ ret = wl_display_roundtrip_queue(_eflutil.wl.dpy, _eflutil.wl.shot.queue);
+
+ if (ret == -1)
+ {
+ fprintf(stderr, "[screenshot] fail: screenshooter_shoot\n"); /* LCOV_EXCL_LINE */
+ goto fail;
+ }
+
+ wayland_tbm_client_destroy_buffer(_eflutil.wl.shot.tbm_client, buffer);
+
+ /* reset shot_done for next screenshot */
+ screenshot->shot_done = EINA_FALSE;
+
+ set_last_result(EFL_UTIL_ERROR_NONE);
+
+ _screenshot_mutex_unlock();
+
+ return t_surface;
+
+fail:
+ if (t_surface)
+ tbm_surface_destroy(t_surface);
+ if (buffer)
+ wayland_tbm_client_destroy_buffer(_eflutil.wl.shot.tbm_client, buffer);
+
+ set_last_result(EFL_UTIL_ERROR_SCREENSHOT_EXECUTION_FAIL);
+
+ _screenshot_mutex_unlock();
+
+ return NULL;
+}
+
+API int
+efl_util_screenshot_set_auto_rotation(efl_util_screenshot_h screenshot, int set)
+{
+ if (!screenshot || (screenshot != g_screenshot))
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
+
+ if (!(set == 0 || set == 1))
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
+
+ if (set)
+ g_screenshot->auto_rotation = EINA_TRUE;
+ else
+ g_screenshot->auto_rotation = EINA_FALSE;
+
+ tizen_screenshooter_set_oneshot_auto_rotation(_eflutil.wl.shot.tz_screenshooter, g_screenshot->auto_rotation);
+
+ return EFL_UTIL_ERROR_NONE;
+}
+
+API int
+efl_util_screenshot_get_auto_rotation(efl_util_screenshot_h screenshot, int *set)
+{
+ if (!screenshot || (screenshot != g_screenshot) || !set)
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
+
+ *set = g_screenshot->auto_rotation;
+
+ return EFL_UTIL_ERROR_NONE;
+}
+
+struct _efl_util_gesture_h
+{
+ Eina_Bool init;
+};
+
+API int EFL_UTIL_EVENT_GESTURE_EDGE_SWIPE = 0;
+API int EFL_UTIL_EVENT_GESTURE_EDGE_DRAG = 0;
+API int EFL_UTIL_EVENT_GESTURE_TAP = 0;
+API int EFL_UTIL_EVENT_GESTURE_PALM_COVER = 0;
+
+/* LCOV_EXCL_START */
+static void
+_cb_gesture_edge_swipe_notify(void *data EINA_UNUSED, struct tizen_gesture *tizen_gesture EINA_UNUSED, uint32_t fingers EINA_UNUSED, uint32_t edge EINA_UNUSED, uint32_t edge_size EINA_UNUSED, uint32_t start_point EINA_UNUSED, uint32_t end_point EINA_UNUSED, uint32_t error)
+{
+ _eflutil_defaultqueue.wl.gesture.request_notified = error;
+}
+
+static void
+_cb_gesture_edge_swipe(void *data EINA_UNUSED, struct tizen_gesture *tizen_gesture EINA_UNUSED, uint32_t mode, uint32_t fingers, int sx, int sy, uint32_t edge)
+{
+ efl_util_event_gesture_edge_swipe_s *ev = NULL;
+
+ ev = (efl_util_event_gesture_edge_swipe_s *)calloc(1, sizeof(*ev));
+ if (!ev) return;
+
+ ev->mode = mode;
+
+ ev->fingers = fingers;
+ ev->sx = sx;
+ ev->sy = sy;
+ ev->edge = edge;
+
+ ecore_event_add(EFL_UTIL_EVENT_GESTURE_EDGE_SWIPE, ev, NULL, NULL);
+}
+
+static void
+_cb_gesture_edge_drag_notify(void *data EINA_UNUSED, struct tizen_gesture *tizen_gesture EINA_UNUSED, uint32_t fingers EINA_UNUSED, uint32_t edge EINA_UNUSED, uint32_t edge_size EINA_UNUSED, uint32_t start_point EINA_UNUSED, uint32_t end_point EINA_UNUSED, uint32_t error)
+{
+ _eflutil_defaultqueue.wl.gesture.request_notified = error;
+}
+
+static void
+_cb_gesture_edge_drag(void *data EINA_UNUSED, struct tizen_gesture *tizen_gesture EINA_UNUSED, uint32_t mode, uint32_t fingers, int cx, int cy, uint32_t edge)
+{
+ efl_util_event_gesture_edge_drag_s *ev = NULL;
+
+ ev = (efl_util_event_gesture_edge_drag_s *)calloc(1, sizeof(*ev));
+ if (!ev) return;
+
+ ev->mode = mode;
+
+ ev->fingers = fingers;
+ ev->cx = cx;
+ ev->cy = cy;
+ ev->edge = edge;
+
+ ecore_event_add(EFL_UTIL_EVENT_GESTURE_EDGE_DRAG, ev, NULL, NULL);
+}
+
+static void
+_cb_gesture_tap_notify(void *data EINA_UNUSED, struct tizen_gesture *tizen_gesture EINA_UNUSED, uint32_t fingers EINA_UNUSED, uint32_t repeat EINA_UNUSED, uint32_t error)
+{
+ _eflutil_defaultqueue.wl.gesture.request_notified = error;
+}
+
+static void
+_cb_gesture_tap(void *data EINA_UNUSED, struct tizen_gesture *tizen_gesture EINA_UNUSED, uint32_t mode, uint32_t fingers, uint32_t repeats)
+{
+ efl_util_event_gesture_tap_s *ev = NULL;
+
+ ev = (efl_util_event_gesture_tap_s *)calloc(1, sizeof(*ev));
+ if (!ev) return;
+
+ ev->mode = mode;
+
+ ev->fingers = fingers;
+ ev->repeats = repeats;
+
+ ecore_event_add(EFL_UTIL_EVENT_GESTURE_TAP, ev, NULL, NULL);
+}
+/* LCOV_EXCL_STOP */
+
+static void
+_cb_gesture_palm_cover_notify(void *data EINA_UNUSED, struct tizen_gesture *tizen_gesture EINA_UNUSED, struct wl_surface *surface EINA_UNUSED, uint32_t error)
+{
+ _eflutil_defaultqueue.wl.gesture.request_notified = error;
+}
+
+/* LCOV_EXCL_START */
+static void
+_cb_gesture_palm_cover(void *data EINA_UNUSED, struct tizen_gesture *tizen_gesture EINA_UNUSED, struct wl_surface *surface, uint32_t mode, uint32_t duration, int cx, int cy, uint32_t size, wl_fixed_t pressure)
+{
+ efl_util_event_gesture_palm_cover_s *ev = NULL;
+
+ ev = (efl_util_event_gesture_palm_cover_s *)calloc(1, sizeof(*ev));
+ if (!ev) return;
+
+ ev->mode = mode;
+
+ ev->duration = duration;
+ ev->cx = cx;
+ ev->cy = cy;
+ ev->size = size;
+ ev->pressure = wl_fixed_to_int(pressure);
+
+ ecore_event_add(EFL_UTIL_EVENT_GESTURE_PALM_COVER, ev, NULL, NULL);
+}
+/* LCOV_EXCL_STOP */
+
+static void
+_cb_gesture_activate_notify(void *data EINA_UNUSED, struct tizen_gesture *tizen_gesture EINA_UNUSED, struct wl_surface *surface EINA_UNUSED, uint32_t type EINA_UNUSED, uint32_t active EINA_UNUSED, uint32_t error)
+{
+ _eflutil_defaultqueue.wl.gesture.request_notified = error;
+}
+
+static efl_util_error_e
+_efl_util_gesture_convert_error(int ret)
+{
+ switch (ret)
+ {
+ case TIZEN_GESTURE_ERROR_NONE:
+ return EFL_UTIL_ERROR_NONE;
+ case TIZEN_GESTURE_ERROR_INVALID_DATA:
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
+ case TIZEN_GESTURE_ERROR_NO_PERMISSION:
+ return EFL_UTIL_ERROR_PERMISSION_DENIED;
+ case TIZEN_GESTURE_ERROR_NO_SYSTEM_RESOURCES:
+ return EFL_UTIL_ERROR_OUT_OF_MEMORY;
+ case TIZEN_GESTURE_ERROR_GRABBED_ALREADY:
+ return EFL_UTIL_ERROR_NO_RESOURCE_AVAILABLE;
+ case TIZEN_GESTURE_ERROR_NOT_SUPPORTED:
+ return EFL_UTIL_ERROR_NOT_SUPPORTED;
+ default :
+ return EFL_UTIL_ERROR_NONE;
+ }
+}
+
+/* LCOV_EXCL_START */
+static int
+_efl_util_gesture_grab_edge_swipe(efl_util_gesture_data data)
+{
+ int ret = EFL_UTIL_ERROR_NONE;
+ Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
+ Efl_Util_Gesture_Edge_Swipe_Grab_Data *edge_swipe_data = NULL;
+ unsigned int fingers = 0;
+ unsigned int edge = 0;
+ unsigned int edge_size = 0;
+ unsigned int start_point = 0;
+ unsigned int end_point = 0;
+
+ base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil_defaultqueue.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_EDGE_SWIPE,
+ EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+ edge_swipe_data = (Efl_Util_Gesture_Edge_Swipe_Grab_Data *)data;
+
+ fingers = edge_swipe_data->fingers;
+ edge = edge_swipe_data->edge;
+ edge_size = edge_swipe_data->edge_size;
+ start_point = edge_swipe_data->start_point;
+ end_point = edge_swipe_data->end_point;
+
+ tizen_gesture_grab_edge_swipe(_eflutil_defaultqueue.wl.gesture.proto, fingers, edge, edge_size, start_point, end_point);
+
+ while (_eflutil_defaultqueue.wl.gesture.request_notified == -1)
+ wl_display_dispatch(_eflutil_defaultqueue.wl.dpy);
+
+ ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified);
+ _eflutil_defaultqueue.wl.gesture.request_notified = -1;
+
+ return ret;
+}
+
+static int
+_efl_util_gesture_ungrab_edge_swipe(efl_util_gesture_data data)
+{
+ int ret = EFL_UTIL_ERROR_NONE;
+ Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
+ Efl_Util_Gesture_Edge_Swipe_Grab_Data *edge_swipe_data = NULL;
+ unsigned int fingers = 0;
+ unsigned int edge = 0;
+ unsigned int edge_size = 0;
+ unsigned int start_point = 0;
+ unsigned int end_point = 0;
+
+ base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil_defaultqueue.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_EDGE_SWIPE,
+ EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+ edge_swipe_data = (Efl_Util_Gesture_Edge_Swipe_Grab_Data *)data;
+
+ fingers = edge_swipe_data->fingers;
+ edge = edge_swipe_data->edge;
+ edge_size = edge_swipe_data->edge_size;
+ start_point = edge_swipe_data->start_point;
+ end_point = edge_swipe_data->end_point;
+
+ tizen_gesture_ungrab_edge_swipe(_eflutil_defaultqueue.wl.gesture.proto, fingers, edge, edge_size, start_point, end_point);
+
+ while (_eflutil_defaultqueue.wl.gesture.request_notified == -1)
+ wl_display_dispatch(_eflutil_defaultqueue.wl.dpy);
+
+ ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified);
+ _eflutil_defaultqueue.wl.gesture.request_notified = -1;
+
+ return ret;
+}
+
+static int
+_efl_util_gesture_grab_edge_drag(efl_util_gesture_data data)
+{
+ int ret = EFL_UTIL_ERROR_NONE;
+ Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
+ Efl_Util_Gesture_Edge_Drag_Grab_Data *edge_drag_data = NULL;
+ unsigned int fingers = 0;
+ unsigned int edge = 0;
+ unsigned int edge_size = 0;
+ unsigned int start_point = 0;
+ unsigned int end_point = 0;
+
+ base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil_defaultqueue.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_EDGE_DRAG,
+ EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+ edge_drag_data = (Efl_Util_Gesture_Edge_Drag_Grab_Data *)data;
+
+ fingers = edge_drag_data->fingers;
+ edge = edge_drag_data->edge;
+ edge_size = edge_drag_data->edge_size;
+ start_point = edge_drag_data->start_point;
+ end_point = edge_drag_data->end_point;
+
+ tizen_gesture_grab_edge_drag(_eflutil_defaultqueue.wl.gesture.proto, fingers, edge, edge_size, start_point, end_point);
+
+ while (_eflutil_defaultqueue.wl.gesture.request_notified == -1)
+ wl_display_dispatch(_eflutil_defaultqueue.wl.dpy);
+
+ ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified);
+ _eflutil_defaultqueue.wl.gesture.request_notified = -1;
+
+ return ret;
+}
+
+static int
+_efl_util_gesture_ungrab_edge_drag(efl_util_gesture_data data)
+{
+ int ret = EFL_UTIL_ERROR_NONE;
+ Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
+ Efl_Util_Gesture_Edge_Drag_Grab_Data *edge_drag_data = NULL;
+ unsigned int fingers = 0;
+ unsigned int edge = 0;
+ unsigned int edge_size = 0;
+ unsigned int start_point = 0;
+ unsigned int end_point = 0;
+
+ base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil_defaultqueue.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_EDGE_DRAG,
+ EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+ edge_drag_data = (Efl_Util_Gesture_Edge_Drag_Grab_Data *)data;
+
+ fingers = edge_drag_data->fingers;
+ edge = edge_drag_data->edge;
+ edge_size = edge_drag_data->edge_size;
+ start_point = edge_drag_data->start_point;
+ end_point = edge_drag_data->end_point;
+
+ tizen_gesture_ungrab_edge_drag(_eflutil_defaultqueue.wl.gesture.proto, fingers, edge, edge_size, start_point, end_point);
+
+ while (_eflutil_defaultqueue.wl.gesture.request_notified == -1)
+ wl_display_dispatch(_eflutil_defaultqueue.wl.dpy);
+
+ ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified);
+ _eflutil_defaultqueue.wl.gesture.request_notified = -1;
+
+ return ret;
+}
+
+
+static int
+_efl_util_gesture_grab_tap(efl_util_gesture_data data)
+{
+ int ret = EFL_UTIL_ERROR_NONE;
+ Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
+ Efl_Util_Gesture_Tap_Grab_Data *tap_data = NULL;
+ unsigned int fingers = 0;
+ unsigned int repeats = 0;
+
+ base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil_defaultqueue.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_TAP,
+ EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+ tap_data = (Efl_Util_Gesture_Tap_Grab_Data *)data;
+
+ fingers = tap_data->fingers;
+ repeats = tap_data->repeats;
+
+ tizen_gesture_grab_tap(_eflutil_defaultqueue.wl.gesture.proto, fingers, repeats);
+
+ while (_eflutil_defaultqueue.wl.gesture.request_notified == -1)
+ wl_display_dispatch(_eflutil_defaultqueue.wl.dpy);
+
+ ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified);
+ _eflutil_defaultqueue.wl.gesture.request_notified = -1;
+
+ return ret;
+}
+
+static int
+_efl_util_gesture_ungrab_tap(efl_util_gesture_data data)
+{
+ int ret = EFL_UTIL_ERROR_NONE;
+ Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
+ Efl_Util_Gesture_Tap_Grab_Data *tap_data = NULL;
+ unsigned int fingers = 0;
+ unsigned int repeats = 0;
+
+ base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil_defaultqueue.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_TAP,
+ EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+ tap_data = (Efl_Util_Gesture_Tap_Grab_Data *)data;
+
+ fingers = tap_data->fingers;
+ repeats = tap_data->repeats;
+
+ tizen_gesture_ungrab_tap(_eflutil_defaultqueue.wl.gesture.proto, fingers, repeats);
+
+ while (_eflutil_defaultqueue.wl.gesture.request_notified == -1)
+ wl_display_dispatch(_eflutil_defaultqueue.wl.dpy);
+
+ ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified);
+ _eflutil_defaultqueue.wl.gesture.request_notified = -1;
+
+ return ret;
+}
+
+static int
+_efl_util_gesture_grab_palm_cover(efl_util_gesture_data data)
+{
+ int ret = EFL_UTIL_ERROR_NONE;
+ Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
+
+ base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil_defaultqueue.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_PALM_COVER,
+ EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+ tizen_gesture_grab_palm_cover(_eflutil_defaultqueue.wl.gesture.proto);
+
+ while (_eflutil_defaultqueue.wl.gesture.request_notified == -1)
+ wl_display_dispatch(_eflutil_defaultqueue.wl.dpy);
+
+ ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified);
+ _eflutil_defaultqueue.wl.gesture.request_notified = -1;
+
+ return ret;
+}
+
+static int
+_efl_util_gesture_ungrab_palm_cover(efl_util_gesture_data data)
+{
+ int ret = EFL_UTIL_ERROR_NONE;
+ Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
+
+ base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil_defaultqueue.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_PALM_COVER,
+ EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+ tizen_gesture_ungrab_palm_cover(_eflutil_defaultqueue.wl.gesture.proto);
+
+ while (_eflutil_defaultqueue.wl.gesture.request_notified == -1)
+ wl_display_dispatch(_eflutil_defaultqueue.wl.dpy);
+
+ ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified);
+ _eflutil_defaultqueue.wl.gesture.request_notified = -1;
+
+ return ret;
+}
+/* LCOV_EXCL_STOP */
+
+API efl_util_gesture_h
+efl_util_gesture_initialize(void)
+{
+ efl_util_gesture_h gesture_h = NULL;
+
+ gesture_h = (efl_util_gesture_h)calloc(1, sizeof(struct _efl_util_gesture_h));
+ if (!gesture_h)
+ {
+ set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); /* LCOV_EXCL_LINE */
+ goto out; /* LCOV_EXCL_LINE */
+ }
+
+ if (_wl_init_default_queue() == (int)EINA_FALSE)
+ {
+ set_last_result(EFL_UTIL_ERROR_NOT_SUPPORTED); /* LCOV_EXCL_LINE */
+ goto out; /* LCOV_EXCL_LINE */
+ }
+
+ while (!_eflutil_defaultqueue.wl.gesture.proto)
+ wl_display_dispatch(_eflutil_defaultqueue.wl.dpy); /* LCOV_EXCL_LINE */
+
+ if (_eflutil_defaultqueue.wl.gesture.event_init <= 0)
+ {
+ if (ecore_event_init() <= 0)
+ {
+ set_last_result(EFL_UTIL_ERROR_NOT_SUPPORTED); /* LCOV_EXCL_LINE */
+ goto out; /* LCOV_EXCL_LINE */
+ }
+ EFL_UTIL_EVENT_GESTURE_EDGE_SWIPE = ecore_event_type_new();
+ EFL_UTIL_EVENT_GESTURE_EDGE_DRAG = ecore_event_type_new();
+ EFL_UTIL_EVENT_GESTURE_TAP = ecore_event_type_new();
+ EFL_UTIL_EVENT_GESTURE_PALM_COVER = ecore_event_type_new();
+ }
+ _eflutil_defaultqueue.wl.gesture.event_init++;
+ gesture_h->init = EINA_TRUE;
+
+ set_last_result(EFL_UTIL_ERROR_NONE);
+ return gesture_h;
+
+out:
+/* LCOV_EXCL_START */
+ if (gesture_h)
+ {
+ free(gesture_h);
+ gesture_h = NULL;
+ }
+ return gesture_h;
+/* LCOV_EXCL_STOP */
+}
+
+API int
+efl_util_gesture_deinitialize(efl_util_gesture_h gesture_h)
+{
+ EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+ free(gesture_h);
+ gesture_h = NULL;
+
+ _eflutil_defaultqueue.wl.gesture.event_init--;
+
+ if (_eflutil_defaultqueue.wl.gesture.event_init <= 0)
+ {
+ _eflutil_defaultqueue.wl.gesture.event_init = 0;
+ ecore_event_shutdown();
+ EFL_UTIL_EVENT_GESTURE_EDGE_SWIPE = 0;
+ EFL_UTIL_EVENT_GESTURE_EDGE_DRAG = 0;
+ EFL_UTIL_EVENT_GESTURE_TAP = 0;
+ EFL_UTIL_EVENT_GESTURE_PALM_COVER = 0;
+ }
+
+ return EFL_UTIL_ERROR_NONE;
+}
+
+API efl_util_gesture_data
+efl_util_gesture_edge_swipe_new(efl_util_gesture_h gesture_h, unsigned int fingers, efl_util_gesture_edge_e edge)
+{
+ Efl_Util_Gesture_Edge_Swipe_Grab_Data *data;
+
+ if (!gesture_h || gesture_h->init == EINA_FALSE)
+ {
+ set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
+ return NULL;
+ }
+
+ if (edge <= EFL_UTIL_GESTURE_EDGE_NONE || edge > EFL_UTIL_GESTURE_EDGE_LEFT)
+ {
+ set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
+ return NULL;
+ }
+
+ data = (Efl_Util_Gesture_Edge_Swipe_Grab_Data *)calloc(1, sizeof(Efl_Util_Gesture_Edge_Swipe_Grab_Data));
+ if (!data)
+ {
+ set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); /* LCOV_EXCL_LINE */
+ return NULL; /* LCOV_EXCL_LINE */
+ }
+
+ data->base.type = TIZEN_GESTURE_TYPE_EDGE_SWIPE;
+ data->fingers = fingers;
+ data->edge = edge;
+ data->edge_size = EFL_UTIL_GESTURE_EDGE_SIZE_FULL;
+
+ set_last_result(EFL_UTIL_ERROR_NONE);
+
+ return (void *)data;
+}
+
+API int
+efl_util_gesture_edge_swipe_free(efl_util_gesture_h gesture_h, efl_util_gesture_data data)
+{
+ if (!gesture_h || gesture_h->init == EINA_FALSE)
+ {
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
+ }
+
+ if (!data)
+ {
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
+ }
+
+ free(data);
+ data = NULL;
+
+ return EFL_UTIL_ERROR_NONE;
+}
+
+API int
+efl_util_gesture_edge_swipe_size_set(efl_util_gesture_data data, efl_util_gesture_edge_size_e edge_size, unsigned int start_point, unsigned int end_point)
+{
+ Efl_Util_Gesture_Edge_Swipe_Grab_Data *edge_swipe_data = data;
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(edge_swipe_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(edge_swipe_data->base.type == TIZEN_GESTURE_TYPE_EDGE_SWIPE,
+ EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(edge_size == EFL_UTIL_GESTURE_EDGE_SIZE_PARTIAL,
+ EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(end_point > start_point, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+ edge_swipe_data->edge_size = edge_size;
+ edge_swipe_data->start_point = start_point;
+ edge_swipe_data->end_point = end_point;
+
+ return EFL_UTIL_ERROR_NONE;
+}
+
+API efl_util_gesture_data
+efl_util_gesture_edge_drag_new(efl_util_gesture_h gesture_h, unsigned int fingers, efl_util_gesture_edge_e edge)
+{
+ Efl_Util_Gesture_Edge_Drag_Grab_Data *data;
+
+ if (!gesture_h || gesture_h->init == EINA_FALSE)
+ {
+ set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
+ return NULL;
+ }
+
+ if (edge <= EFL_UTIL_GESTURE_EDGE_NONE || edge > EFL_UTIL_GESTURE_EDGE_LEFT)
+ {
+ set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
+ return NULL;
+ }
+
+ data = (Efl_Util_Gesture_Edge_Drag_Grab_Data *)calloc(1, sizeof(Efl_Util_Gesture_Edge_Drag_Grab_Data));
+ if (!data)
+ {
+ set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); /* LCOV_EXCL_LINE */
+ return NULL; /* LCOV_EXCL_LINE */
+ }
+
+ data->base.type = TIZEN_GESTURE_TYPE_EDGE_DRAG;
+ data->fingers = fingers;
+ data->edge = edge;
+ data->edge_size = EFL_UTIL_GESTURE_EDGE_SIZE_FULL;
+
+ set_last_result(EFL_UTIL_ERROR_NONE);
+
+ return (void *)data;
+}
+
+API int
+efl_util_gesture_edge_drag_free(efl_util_gesture_h gesture_h, efl_util_gesture_data data)
+{
+ if (!gesture_h || gesture_h->init == EINA_FALSE)
+ {
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
+ }
+
+ if (!data)
+ {
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
+ }
+
+ free(data);
+ data = NULL;
+
+ return EFL_UTIL_ERROR_NONE;
+}
+
+API int
+efl_util_gesture_edge_drag_size_set(efl_util_gesture_data data, efl_util_gesture_edge_size_e edge_size, unsigned int start_point, unsigned int end_point)
+{
+ Efl_Util_Gesture_Edge_Drag_Grab_Data *edge_drag_data = data;
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(edge_drag_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(edge_drag_data->base.type == TIZEN_GESTURE_TYPE_EDGE_DRAG,
+ EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(edge_size == EFL_UTIL_GESTURE_EDGE_SIZE_PARTIAL,
+ EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(end_point > start_point, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+ edge_drag_data->edge_size = edge_size;
+ edge_drag_data->start_point = start_point;
+ edge_drag_data->end_point = end_point;
+
+ return EFL_UTIL_ERROR_NONE;
+}
+
+API efl_util_gesture_data
+efl_util_gesture_tap_new(efl_util_gesture_h gesture_h, unsigned int fingers, unsigned int repeats)
+{
+ Efl_Util_Gesture_Tap_Grab_Data *data;
+
+ if (!gesture_h || gesture_h->init == EINA_FALSE)
+ {
+ set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
+ return NULL;
+ }
+
+ if (fingers <= 1 || repeats <= 1)
+ {
+ set_last_result(EFL_UTIL_ERROR_NOT_SUPPORTED);
+ return NULL;
+ }
+
+ data = (Efl_Util_Gesture_Tap_Grab_Data *)calloc(1, sizeof(Efl_Util_Gesture_Tap_Grab_Data));
+ if (!data)
+ {
+ set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); /* LCOV_EXCL_LINE */
+ return NULL; /* LCOV_EXCL_LINE */
+ }
+
+ data->base.type = TIZEN_GESTURE_TYPE_TAP;
+ data->fingers = fingers;
+ data->repeats = repeats;
+
+ set_last_result(EFL_UTIL_ERROR_NONE);
+
+ return (void *)data;
+}
+
+API int
+efl_util_gesture_tap_free(efl_util_gesture_h gesture_h, efl_util_gesture_data data)
+{
+ if (!gesture_h || gesture_h->init == EINA_FALSE)
+ {
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
+ }
+
+ if (!data)
+ {
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
+ }
+
+ free(data);
+ data = NULL;
+
+ return EFL_UTIL_ERROR_NONE;
+}
+
+API efl_util_gesture_data
+efl_util_gesture_palm_cover_new(efl_util_gesture_h gesture_h)
+{
+ Efl_Util_Gesture_Palm_Cover_Grab_Data *data;
+
+ if (!gesture_h || gesture_h->init == EINA_FALSE)
+ {
+ set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
+ return NULL;
+ }
+
+ data = (Efl_Util_Gesture_Palm_Cover_Grab_Data *)calloc(1, sizeof(Efl_Util_Gesture_Palm_Cover_Grab_Data));
+ if (!data)
+ {
+ set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); /* LCOV_EXCL_LINE */
+ return NULL; /* LCOV_EXCL_LINE */
+ }
+
+ data->base.type = TIZEN_GESTURE_TYPE_PALM_COVER;
+
+ set_last_result(EFL_UTIL_ERROR_NONE);
+
+ return (void *)data;
+}
+
+API int
+efl_util_gesture_palm_cover_free(efl_util_gesture_h gesture_h, efl_util_gesture_data data)
+{
+ if (!gesture_h || gesture_h->init == EINA_FALSE)
+ {
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
+ }
+
+ if (!data)
+ {
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
+ }
+
+ free(data);
+ data = NULL;
+
+ return EFL_UTIL_ERROR_NONE;
+}
+
+/* LCOV_EXCL_START */
+API int
+efl_util_gesture_grab(efl_util_gesture_h gesture_h, efl_util_gesture_data data)
+{
+ int ret = EFL_UTIL_ERROR_NONE;
+ Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
+
+ base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+ switch (base_data->type)
+ {
+ case TIZEN_GESTURE_TYPE_EDGE_SWIPE:
+ ret = _efl_util_gesture_grab_edge_swipe(data);
+ break;
+ case TIZEN_GESTURE_TYPE_EDGE_DRAG:
+ ret = _efl_util_gesture_grab_edge_drag(data);
+ break;
+ case TIZEN_GESTURE_TYPE_TAP:
+ ret = _efl_util_gesture_grab_tap(data);
+ break;
+ case TIZEN_GESTURE_TYPE_PALM_COVER:
+ ret = _efl_util_gesture_grab_palm_cover(data);
+ break;
+ default:
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
+ }
+
+ return ret;
+}
+
+API int
+efl_util_gesture_ungrab(efl_util_gesture_h gesture_h, efl_util_gesture_data data)
+{
+ int ret = EFL_UTIL_ERROR_NONE;
+ Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
+
+ base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+ switch (base_data->type)
+ {
+ case TIZEN_GESTURE_TYPE_EDGE_SWIPE:
+ ret = _efl_util_gesture_ungrab_edge_swipe(data);
+ break;
+ case TIZEN_GESTURE_TYPE_EDGE_DRAG:
+ ret = _efl_util_gesture_ungrab_edge_drag(data);
+ break;
+ case TIZEN_GESTURE_TYPE_TAP:
+ ret = _efl_util_gesture_ungrab_tap(data);
+ break;
+ case TIZEN_GESTURE_TYPE_PALM_COVER:
+ ret = _efl_util_gesture_ungrab_palm_cover(data);
+ break;
+ default:
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
+ }
+
+ return ret;
+}
+/* LCOV_EXCL_STOP */
+
+API int
+efl_util_gesture_select(efl_util_gesture_h gesture_h, Evas_Object *window, efl_util_gesture_data data)
+{
+ Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
+ Ecore_Wl2_Window *wlwin;
+ struct wl_surface *surface;
+ int ret;
+
+ base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+ if (base_data->type != TIZEN_GESTURE_TYPE_PALM_COVER)
+ return EFL_UTIL_ERROR_NOT_SUPPORTED;
+
+ wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window);
+ if (!wlwin) return EFL_UTIL_ERROR_INVALID_PARAMETER;
+
+ surface = ecore_wl2_window_surface_get(wlwin);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(surface,
+ EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+ tizen_gesture_select_palm_cover(_eflutil_defaultqueue.wl.gesture.proto, surface);
+
+ while (_eflutil_defaultqueue.wl.gesture.request_notified == -1)
+ wl_display_dispatch(_eflutil_defaultqueue.wl.dpy);
+
+ ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified);
+ _eflutil_defaultqueue.wl.gesture.request_notified = -1;
+
+ return ret;
+}
+
+API int
+efl_util_gesture_deselect(efl_util_gesture_h gesture_h, Evas_Object *window, efl_util_gesture_data data)
+{
+ Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
+ Ecore_Wl2_Window *wlwin;
+ struct wl_surface *surface;
+ int ret;
+
+ base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+ if (base_data->type != TIZEN_GESTURE_TYPE_PALM_COVER)
+ return EFL_UTIL_ERROR_NOT_SUPPORTED;
+
+ wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window);
+ if (!wlwin) return EFL_UTIL_ERROR_INVALID_PARAMETER;
+
+ surface = ecore_wl2_window_surface_get(wlwin);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(surface,
+ EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+ tizen_gesture_deselect_palm_cover(_eflutil_defaultqueue.wl.gesture.proto, surface);
+
+ while (_eflutil_defaultqueue.wl.gesture.request_notified == -1)
+ wl_display_dispatch(_eflutil_defaultqueue.wl.dpy);
+
+ ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified);
+ _eflutil_defaultqueue.wl.gesture.request_notified = -1;
+
+ return ret;
+}
+
+/* LCOV_EXCL_START */
+API int
+efl_util_gesture_activate_set(efl_util_gesture_h gesture_h, unsigned int type, Eina_Bool active)
+{
+ int ret;
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_TRUE_RETURN_VAL(type == EFL_UTIL_GESTURE_TYPE_NONE, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+ tizen_gesture_activate_set(_eflutil_defaultqueue.wl.gesture.proto, NULL, type, active);
+
+ while (_eflutil_defaultqueue.wl.gesture.request_notified == -1)
+ wl_display_dispatch(_eflutil_defaultqueue.wl.dpy);
+
+ ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified);
+ _eflutil_defaultqueue.wl.gesture.request_notified = -1;
+
+ return ret;
+}
+/* LCOV_EXCL_STOP */
+
+API int
+efl_util_gesture_activate_set_on_window(efl_util_gesture_h gesture_h, Evas_Object *window, unsigned int type, Eina_Bool active)
+{
+ Ecore_Wl2_Window *wlwin;
+ struct wl_surface *surface;
+ int ret;
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER);
+ EINA_SAFETY_ON_TRUE_RETURN_VAL(type == EFL_UTIL_GESTURE_TYPE_NONE, EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+ wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window);
+ if (!wlwin) return EFL_UTIL_ERROR_INVALID_PARAMETER;
+
+ surface = ecore_wl2_window_surface_get(wlwin);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(surface,
+ EFL_UTIL_ERROR_INVALID_PARAMETER);
+
+ tizen_gesture_activate_set(_eflutil_defaultqueue.wl.gesture.proto, surface, type, active);
+
+ while (_eflutil_defaultqueue.wl.gesture.request_notified == -1)
+ wl_display_dispatch(_eflutil_defaultqueue.wl.dpy);
+
+ ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified);
+ _eflutil_defaultqueue.wl.gesture.request_notified = -1;
+
+ return ret;