2 * Copyright (c) 2011-2017 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the License);
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an AS IS BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
19 #define LOG_TAG "TIZEN_N_EFL_UTIL"
26 #include <sys/types.h>
30 #include <tbm_bufmgr.h>
31 #include <tbm_surface.h>
32 #include <tbm_surface_internal.h>
33 #include <Elementary.h>
34 #include <Ecore_Evas.h>
37 #include <Ecore_Wl2.h>
38 #include <wayland-client.h>
39 #include <wayland-tbm-client.h>
40 #include <tizen-extension-client-protocol.h>
42 #include <efl_util_screenshot_extension.h>
49 #define LOG_TAG "TIZEN_N_EFL_UTIL"
50 #define EFL_UTIL_INPUT_GENERATOR_TOUCH_MAX_FINGER 10
52 typedef struct _Efl_Util_Wl_Surface_Lv_Info
54 void *surface; /* wl_surface */
56 Eina_Bool wait_for_done;
58 } Efl_Util_Wl_Surface_Lv_Info;
60 typedef struct _Efl_Util_Wl_Surface_Scr_Mode_Info
62 void *surface; /* wl_surface */
64 Eina_Bool wait_for_done;
66 } Efl_Util_Wl_Surface_Scr_Mode_Info;
68 typedef struct _Efl_Util_Wl_Surface_Brightness_Info
70 void *surface; /* wl_surface */
72 Eina_Bool wait_for_done;
74 } Efl_Util_Wl_Surface_Brightness_Info;
76 typedef struct _Efl_Util_Wl_Output_Info
78 struct wl_output *output;
79 int offset_x, offset_y, width, height;
80 } Efl_Util_Wl_Output_Info;
82 typedef struct _Efl_Util_Gesture_Common_Grab_Data
85 } Efl_Util_Gesture_Common_Grab_Data;
87 typedef struct _Efl_Util_Gesture_Edge_Swipe_Grab_Data
89 Efl_Util_Gesture_Common_Grab_Data base;
92 efl_util_gesture_edge_e edge;
93 efl_util_gesture_edge_size_e edge_size;
94 unsigned int start_point;
95 unsigned int end_point;
96 } Efl_Util_Gesture_Edge_Swipe_Grab_Data;
98 typedef struct _Efl_Util_Gesture_Edge_Drag_Grab_Data
100 Efl_Util_Gesture_Common_Grab_Data base;
102 unsigned int fingers;
103 efl_util_gesture_edge_e edge;
104 efl_util_gesture_edge_size_e edge_size;
105 unsigned int start_point;
106 unsigned int end_point;
107 } Efl_Util_Gesture_Edge_Drag_Grab_Data;
109 typedef struct _Efl_Util_Gesture_Tap_Grab_Data
111 Efl_Util_Gesture_Common_Grab_Data base;
113 unsigned int fingers;
114 unsigned int repeats;
115 } Efl_Util_Gesture_Tap_Grab_Data;
117 typedef struct _Efl_Util_Gesture_Palm_Cover_Grab_Data
119 Efl_Util_Gesture_Common_Grab_Data base;
120 } Efl_Util_Gesture_Palm_Cover_Grab_Data;
122 typedef struct _E_Devicemgr_Inputgen_Touch_Axis
129 } E_Devicemgr_Inputgen_Touch_Axis;
131 typedef struct _Efl_Util_Data
133 /* wayland related stuffs */
137 Ecore_Wl2_Display *wl2_display;
138 struct wl_display *dpy;
139 struct wl_event_queue *queue;
144 struct tizen_policy *proto;
145 Eina_Hash *hash_noti_lv;
146 Eina_Hash *hash_scr_mode;
150 struct wl_event_queue *queue;
151 struct tizen_screenshooter *tz_screenshooter;
152 struct wayland_tbm_client *tbm_client;
153 Eina_List *output_list;
158 struct tizen_input_device_manager *devicemgr;
159 int request_notified;
161 Eina_List *wait_devices;
162 struct wl_event_source *wait_timer;
164 int request_touch_count;
169 struct tizen_display_policy *proto;
170 Eina_Hash *hash_brightness;
175 typedef struct _Efl_Util_Data_Default_Queue
177 /* wayland related stuffs */
181 Ecore_Wl2_Display *wl2_display;
182 struct wl_display *dpy;
187 struct tizen_gesture *proto;
188 int request_notified;
192 } Efl_Util_Data_Default_Queue;
195 static Efl_Util_Data _eflutil =
200 { 0, NULL, NULL, NULL }, /* tizen_policy protocol */
201 { NULL, NULL, NULL, NULL, 0 }, /* screenshooter protocol */
202 { NULL, -1, NULL, NULL, NULL, 0, 0 }, /* tizen_input_device_manager protocol */
203 { 0, NULL, NULL } /* display_policy protocol */
207 static Efl_Util_Data_Default_Queue _eflutil_defaultqueue =
212 { 0, NULL, -1, 0 } /* gesture protocol */
217 static Eina_Bool _wl_init(void);
218 static Eina_Bool _wl_init_default_queue(void);
219 static void _cb_wl_reg_global(void *data, struct wl_registry *reg, unsigned int name, const char *interface, unsigned int version);
220 static void _cb_wl_reg_global_remove(void *data, struct wl_registry *reg, unsigned int name);
221 static void _cb_wl_default_queue_reg_global(void *data, struct wl_registry *reg, unsigned int name, const char *interface, unsigned int version);
222 static void _cb_wl_default_queue_reg_global_remove(void *data, struct wl_registry *reg, unsigned int name);
223 static void _cb_wl_reg_screenshooter_global(void *data, struct wl_registry *reg, unsigned int name, const char *interface, unsigned int version);
224 static void _cb_wl_reg_screenshooter_global_remove(void *data, struct wl_registry *reg, unsigned int name);
225 static void _cb_wl_tz_policy_conformant(void *data, struct tizen_policy *tizen_policy, struct wl_surface *surface, uint32_t is_conformant);
226 static void _cb_wl_tz_policy_conformant_area(void *data, struct tizen_policy *tizen_policy, struct wl_surface *surface, uint32_t conformant_part, uint32_t state, int32_t x, int32_t y, int32_t w, int32_t h);
227 static void _cb_wl_tz_policy_notification_done(void *data, struct tizen_policy *tizen_policy, struct wl_surface *surface, int32_t level, uint32_t state);
228 static void _cb_wl_tz_policy_transient_for_done(void *data, struct tizen_policy *tizen_policy, uint32_t child_id);
229 static void _cb_wl_tz_policy_scr_mode_done(void *data, struct tizen_policy *tizen_policy, struct wl_surface *surface, uint32_t mode, uint32_t state);
230 static void _cb_wl_tz_policy_iconify_state_changed(void *data, struct tizen_policy *tizen_policy, struct wl_surface *surface_resource, uint32_t iconified, uint32_t force);
231 static void _cb_wl_tz_policy_supported_aux_hints(void *data, struct tizen_policy *tizen_policy, struct wl_surface *surface_resource, struct wl_array *hints, uint32_t num_hints);
232 static void _cb_wl_tz_policy_allowed_aux_hint(void *data, struct tizen_policy *tizen_policy, struct wl_surface *surface_resource, int id);
233 static void _cb_wl_tz_policy_aux_message(void *data, struct tizen_policy *tizen_policy, struct wl_surface *surface_resource, const char *key, const char *val, struct wl_array *options);
234 static void _cb_wl_conformant_region(void *data, struct tizen_policy *tizen_policy, struct wl_surface *surface, uint32_t conformant_part, uint32_t state, int32_t x, int32_t y, int32_t w, int32_t h, uint32_t serial);
236 static void _cb_wl_tz_display_policy_brightness_done(void *data, struct tizen_display_policy *tizen_display_policy, struct wl_surface *surface_resource, int32_t brightness, uint32_t state);
238 static void _cb_device_add(void *data EINA_UNUSED, struct tizen_input_device_manager *tizen_input_device_manager EINA_UNUSED, uint32_t serial EINA_UNUSED, const char *identifier EINA_UNUSED, struct tizen_input_device *device EINA_UNUSED, struct wl_seat *seat EINA_UNUSED);
239 static void _cb_device_remove(void *data EINA_UNUSED, struct tizen_input_device_manager *tizen_input_device_manager EINA_UNUSED, uint32_t serial EINA_UNUSED, const char *identifier EINA_UNUSED, struct tizen_input_device *device EINA_UNUSED, struct wl_seat *seat EINA_UNUSED);
240 static void _cb_error(void *data EINA_UNUSED, struct tizen_input_device_manager *tizen_input_device_manager EINA_UNUSED, uint32_t errorcode);
241 static void _cb_block_expired(void *data EINA_UNUSED, struct tizen_input_device_manager *tizen_input_device_manager EINA_UNUSED);
242 static void _cb_max_touch_count(void *data EINA_UNUSED, struct tizen_input_device_manager *tizen_input_device_manager EINA_UNUSED, uint32_t serial EINA_UNUSED, int32_t max_count EINA_UNUSED, struct wl_seat *seat EINA_UNUSED);
244 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);
245 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);
246 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);
247 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);
248 static void _cb_gesture_tap_notify(void *data EINA_UNUSED, struct tizen_gesture *tizen_gesture EINA_UNUSED, uint32_t fingers EINA_UNUSED, uint32_t repeats EINA_UNUSED, uint32_t error);
249 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);
250 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);
251 static void _cb_gesture_palm_cover(void *data EINA_UNUSED, struct tizen_gesture *tizen_gesture EINA_UNUSED, struct wl_surface *surface EINA_UNUSED, uint32_t mode, uint32_t duration, int cx, int cy, uint32_t size, wl_fixed_t pressure);
252 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);
255 static const struct wl_registry_listener _wl_reg_listener =
258 _cb_wl_reg_global_remove
261 static const struct wl_registry_listener _wl_reg_screenshooter_listener =
263 _cb_wl_reg_screenshooter_global,
264 _cb_wl_reg_screenshooter_global_remove
267 struct tizen_policy_listener _wl_tz_policy_listener =
269 _cb_wl_tz_policy_conformant,
270 _cb_wl_tz_policy_conformant_area,
271 _cb_wl_tz_policy_notification_done,
272 _cb_wl_tz_policy_transient_for_done,
273 _cb_wl_tz_policy_scr_mode_done,
274 _cb_wl_tz_policy_iconify_state_changed,
275 _cb_wl_tz_policy_supported_aux_hints,
276 _cb_wl_tz_policy_allowed_aux_hint,
277 _cb_wl_tz_policy_aux_message,
278 _cb_wl_conformant_region,
281 struct tizen_input_device_manager_listener _wl_tz_devmgr_listener =
290 struct tizen_display_policy_listener _wl_tz_display_policy_listener =
292 _cb_wl_tz_display_policy_brightness_done,
295 static const struct wl_registry_listener _wl_default_queue_reg_listener =
297 _cb_wl_default_queue_reg_global,
298 _cb_wl_default_queue_reg_global_remove
301 struct tizen_gesture_listener _wl_tz_gesture_listener =
303 _cb_gesture_edge_swipe_notify,
304 _cb_gesture_edge_swipe,
305 _cb_gesture_edge_drag_notify,
306 _cb_gesture_edge_drag,
307 _cb_gesture_tap_notify,
309 _cb_gesture_palm_cover_notify,
310 _cb_gesture_palm_cover,
311 _cb_gesture_activate_notify
317 struct wl_display *display_wrapper = NULL;
318 struct wl_registry *reg = NULL;
320 if (_eflutil.wl.init) return EINA_TRUE;
324 _eflutil.wl.wl2_display = ecore_wl2_display_connect(NULL);
325 EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.wl2_display, fail);
326 _eflutil.wl.dpy = ecore_wl2_display_get(_eflutil.wl.wl2_display);
327 EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.dpy, fail);
329 display_wrapper = wl_proxy_create_wrapper(_eflutil.wl.dpy);
330 EINA_SAFETY_ON_NULL_GOTO(display_wrapper, fail);
332 _eflutil.wl.queue = wl_display_create_queue(_eflutil.wl.dpy);
333 EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.queue, fail);
335 wl_proxy_set_queue((struct wl_proxy *)display_wrapper, _eflutil.wl.queue);
337 reg = wl_display_get_registry(display_wrapper);
338 wl_proxy_wrapper_destroy(display_wrapper);
339 display_wrapper = NULL;
340 EINA_SAFETY_ON_NULL_GOTO(reg, fail);
342 wl_registry_add_listener(reg, &_wl_reg_listener, NULL);
344 _eflutil.wl.init = EINA_TRUE;
349 wl_proxy_wrapper_destroy(display_wrapper);
351 if (_eflutil.wl.queue)
353 wl_event_queue_destroy(_eflutil.wl.queue);
354 _eflutil.wl.queue = NULL;
357 ecore_wl2_shutdown();
362 _wl_init_default_queue(void)
364 struct wl_display *display_wrapper = NULL;
365 struct wl_registry *reg = NULL;
367 if (_eflutil_defaultqueue.wl.init) return EINA_TRUE;
369 if (ecore_wl2_init() <= 0) return EINA_FALSE;
371 _eflutil_defaultqueue.wl.wl2_display = ecore_wl2_connected_display_get(NULL);
372 EINA_SAFETY_ON_NULL_GOTO(_eflutil_defaultqueue.wl.wl2_display, fail);
373 _eflutil_defaultqueue.wl.dpy = ecore_wl2_display_get(_eflutil_defaultqueue.wl.wl2_display);
374 EINA_SAFETY_ON_NULL_GOTO(_eflutil_defaultqueue.wl.dpy, fail);
376 display_wrapper = wl_proxy_create_wrapper(_eflutil_defaultqueue.wl.dpy);
377 EINA_SAFETY_ON_NULL_GOTO(display_wrapper, fail);
379 reg = wl_display_get_registry(display_wrapper);
380 wl_proxy_wrapper_destroy(display_wrapper);
381 display_wrapper = NULL;
382 EINA_SAFETY_ON_NULL_GOTO(reg, fail);
384 wl_registry_add_listener(reg, &_wl_default_queue_reg_listener, NULL);
386 _eflutil_defaultqueue.wl.init = EINA_TRUE;
391 ecore_wl2_shutdown();
396 _cb_wl_output_geometry(void *data, struct wl_output *wl_output, int x, int y,
397 int physical_width, int physical_height, int subpixel,
398 const char *make, const char *model, int transform)
400 Efl_Util_Wl_Output_Info *output = wl_output_get_user_data(wl_output);
401 if (wl_output == output->output)
403 output->offset_x = x;
404 output->offset_y = y;
409 _cb_wl_output_mode(void *data, struct wl_output *wl_output, uint32_t flags,
410 int width, int height, int refresh)
412 Efl_Util_Wl_Output_Info *output = wl_output_get_user_data(wl_output);
413 if (wl_output == output->output && (flags & WL_OUTPUT_MODE_CURRENT))
415 output->width = width;
416 output->height = height;
421 _cb_wl_output_done(void *data, struct wl_output *wl_output)
426 _cb_wl_output_scale(void *data, struct wl_output *wl_output, int32_t factor)
430 static const struct wl_output_listener output_listener =
432 _cb_wl_output_geometry,
439 _cb_tz_screenshot_format(void *data, struct tizen_screenshooter *tz_screenshooter, uint32_t format)
444 _cb_tz_screenshot_noti(void *data, struct tizen_screenshooter *tz_screenshooter, uint32_t noti)
446 _eflutil.wl.shot.noti = noti;
450 _cb_tz_screenshot_done(void *data, struct tizen_screenshooter *tz_screenshooter)
452 Eina_Bool *shot_done = (Eina_Bool*)data;
454 *shot_done = EINA_TRUE;
457 static const struct tizen_screenshooter_listener tz_screenshooter_listener =
459 _cb_tz_screenshot_format,
460 _cb_tz_screenshot_noti,
461 _cb_tz_screenshot_done,
465 _cb_wl_reg_global(void *data,
466 struct wl_registry *reg,
468 const char *interface,
469 unsigned int version)
471 if (!strcmp(interface, "tizen_policy"))
473 struct tizen_policy *proto;
474 proto = wl_registry_bind(reg,
476 &tizen_policy_interface,
480 tizen_policy_add_listener(proto,
481 &_wl_tz_policy_listener,
484 _eflutil.wl.policy.hash_noti_lv = eina_hash_pointer_new(free);
485 _eflutil.wl.policy.hash_scr_mode = eina_hash_pointer_new(free);
486 _eflutil.wl.policy.proto = proto;
487 _eflutil.wl.policy.id = id;
489 else if (strcmp(interface, "wl_output") == 0)
491 Efl_Util_Wl_Output_Info *output = calloc(1, sizeof(Efl_Util_Wl_Output_Info));
492 EINA_SAFETY_ON_NULL_RETURN(output);
494 _eflutil.wl.shot.output_list = eina_list_append(_eflutil.wl.shot.output_list, output);
496 output->output = wl_registry_bind(reg, id, &wl_output_interface, version);
497 wl_output_add_listener(output->output, &output_listener, output);
499 else if (strcmp(interface, "tizen_input_device_manager") == 0)
501 _eflutil.wl.devmgr.devicemgr = wl_registry_bind(reg, id, &tizen_input_device_manager_interface, version);
502 tizen_input_device_manager_add_listener(_eflutil.wl.devmgr.devicemgr, &_wl_tz_devmgr_listener, NULL);
504 else if (!strcmp(interface, "tizen_display_policy"))
506 _eflutil.wl.display_policy.proto = wl_registry_bind(reg, id, &tizen_display_policy_interface, version);
507 if (!_eflutil.wl.display_policy.proto) return;
509 tizen_display_policy_add_listener(_eflutil.wl.display_policy.proto,
510 &_wl_tz_display_policy_listener,
513 _eflutil.wl.display_policy.hash_brightness = eina_hash_pointer_new(free);
514 _eflutil.wl.display_policy.id = id;
517 /* LCOV_EXCL_START */
519 _cb_wl_reg_global_remove(void *data,
520 struct wl_registry *reg,
523 /* unset each global id number to 0 since global id is started
524 * from number 1 on server side display structure
526 if (id == _eflutil.wl.policy.id)
528 _eflutil.wl.policy.id = 0;
529 _eflutil.wl.policy.proto = NULL;
530 eina_hash_free(_eflutil.wl.policy.hash_noti_lv);
531 eina_hash_free(_eflutil.wl.policy.hash_scr_mode);
533 else if (id == _eflutil.wl.display_policy.id)
535 _eflutil.wl.display_policy.id = 0;
536 _eflutil.wl.display_policy.proto = NULL;
537 eina_hash_free(_eflutil.wl.display_policy.hash_brightness);
543 _cb_wl_default_queue_reg_global(void *data,
544 struct wl_registry *reg,
546 const char *interface,
547 unsigned int version)
549 if (strcmp(interface, "tizen_gesture") == 0)
551 _eflutil_defaultqueue.wl.gesture.id = id;
552 _eflutil_defaultqueue.wl.gesture.proto = wl_registry_bind(reg, id, &tizen_gesture_interface, version);
553 tizen_gesture_add_listener(_eflutil_defaultqueue.wl.gesture.proto, &_wl_tz_gesture_listener, NULL);
556 /* LCOV_EXCL_START */
558 _cb_wl_default_queue_reg_global_remove(void *data,
559 struct wl_registry *reg,
562 if (id == _eflutil_defaultqueue.wl.gesture.id)
564 _eflutil_defaultqueue.wl.gesture.id = 0;
565 _eflutil_defaultqueue.wl.gesture.proto = NULL;
572 _cb_wl_reg_screenshooter_global(void *data,
573 struct wl_registry *reg,
575 const char *interface,
576 unsigned int version)
578 if (strcmp(interface, "tizen_screenshooter") == 0)
580 _eflutil.wl.shot.tz_screenshooter = wl_registry_bind(reg, name, &tizen_screenshooter_interface, version);
581 tizen_screenshooter_add_listener(_eflutil.wl.shot.tz_screenshooter, &tz_screenshooter_listener, NULL);
583 wl_display_roundtrip_queue(_eflutil.wl.dpy, _eflutil.wl.shot.queue);
587 /* LCOV_EXCL_START */
589 _cb_wl_reg_screenshooter_global_remove(void *data,
590 struct wl_registry *reg,
596 _cb_wl_tz_policy_conformant(void *data, struct tizen_policy *tizen_policy,
597 struct wl_surface *surface, uint32_t is_conformant)
602 _cb_wl_tz_policy_conformant_area(void *data, struct tizen_policy *tizen_policy,
603 struct wl_surface *surface, uint32_t conformant_part,
604 uint32_t state, int32_t x, int32_t y, int32_t w, int32_t h)
610 _cb_wl_tz_policy_notification_done(void *data,
611 struct tizen_policy *tizen_policy,
612 struct wl_surface *surface,
616 Efl_Util_Wl_Surface_Lv_Info *lv_info;
618 lv_info = eina_hash_find(_eflutil.wl.policy.hash_noti_lv, &surface);
621 lv_info->level = level;
622 lv_info->wait_for_done = EINA_FALSE;
623 lv_info->state = state;
627 /* LCOV_EXCL_START */
629 _cb_wl_tz_policy_transient_for_done(void *data, struct tizen_policy *tizen_policy, uint32_t child_id)
635 _cb_wl_tz_policy_scr_mode_done(void *data,
636 struct tizen_policy *tizen_policy,
637 struct wl_surface *surface,
641 Efl_Util_Wl_Surface_Scr_Mode_Info *scr_mode_info;
643 scr_mode_info = eina_hash_find(_eflutil.wl.policy.hash_scr_mode, &surface);
646 scr_mode_info->mode = mode;
647 scr_mode_info->wait_for_done = EINA_FALSE;
648 scr_mode_info->state = state;
652 /* LCOV_EXCL_START */
653 static void _cb_wl_tz_policy_iconify_state_changed(void *data, struct tizen_policy *tizen_policy, struct wl_surface *surface_resource, uint32_t iconified, uint32_t force)
657 static void _cb_wl_tz_policy_supported_aux_hints(void *data, struct tizen_policy *tizen_policy, struct wl_surface *surface_resource, struct wl_array *hints, uint32_t num_hints)
661 static void _cb_wl_tz_policy_allowed_aux_hint(void *data, struct tizen_policy *tizen_policy, struct wl_surface *surface_resource, int id)
665 static void _cb_wl_tz_policy_aux_message(void *data, struct tizen_policy *tizen_policy, struct wl_surface *surface_resource, const char *key, const char *val, struct wl_array *options)
668 static void _cb_wl_conformant_region(void *data, struct tizen_policy *tizen_policy, struct wl_surface *surface, uint32_t conformant_part, uint32_t state, int32_t x, int32_t y, int32_t w, int32_t h, uint32_t serial)
674 _cb_wl_tz_display_policy_brightness_done(void *data,
675 struct tizen_display_policy *tizen_display_policy,
676 struct wl_surface *surface,
680 Efl_Util_Wl_Surface_Brightness_Info *brightness_info;
682 brightness_info = eina_hash_find(_eflutil.wl.display_policy.hash_brightness, &surface);
685 brightness_info->brightness = brightness;
686 brightness_info->wait_for_done = EINA_FALSE;
687 brightness_info->state = state;
692 _cb_window_del(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
694 Efl_Util_Wl_Surface_Lv_Info *lv_info;
697 if (EINA_UNLIKELY(!lv_info))
700 eina_hash_del(_eflutil.wl.policy.hash_noti_lv, &lv_info->surface, lv_info);
704 efl_util_set_notification_window_level(Evas_Object *window,
705 efl_util_notification_level_e level)
709 EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER);
710 EINA_SAFETY_ON_FALSE_RETURN_VAL((level >= EFL_UTIL_NOTIFICATION_LEVEL_NONE) &&
711 (level <= EFL_UTIL_NOTIFICATION_LEVEL_TOP),
712 EFL_UTIL_ERROR_INVALID_PARAMETER);
715 Ecore_Wl2_Window *wlwin;
716 struct wl_surface *surface;
717 Efl_Util_Wl_Surface_Lv_Info *lv_info;
718 Ecore_Wl2_Window_Type wl_type;
721 EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EFL_UTIL_ERROR_INVALID_PARAMETER);
723 wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window);
724 EINA_SAFETY_ON_NULL_RETURN_VAL(wlwin, EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE);
726 type = elm_win_type_get(window);
727 if (type != ELM_WIN_NOTIFICATION)
729 wl_type = ecore_wl2_window_type_get(wlwin);
730 EINA_SAFETY_ON_FALSE_RETURN_VAL((wl_type == ECORE_WL2_WINDOW_TYPE_NOTIFICATION),
731 EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE);
734 while (!_eflutil.wl.policy.proto)
735 wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
737 surface = ecore_wl2_window_surface_get(wlwin);
738 EINA_SAFETY_ON_NULL_RETURN_VAL(surface,
739 EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE);
741 lv_info = eina_hash_find(_eflutil.wl.policy.hash_noti_lv, &surface);
744 lv_info = calloc(1, sizeof(Efl_Util_Wl_Surface_Lv_Info));
745 EINA_SAFETY_ON_NULL_RETURN_VAL(lv_info, EFL_UTIL_ERROR_OUT_OF_MEMORY);
747 lv_info->surface = surface;
748 lv_info->level = (int)level;
749 lv_info->wait_for_done = EINA_TRUE;
750 lv_info->state = TIZEN_POLICY_ERROR_STATE_NONE;
751 eina_hash_add(_eflutil.wl.policy.hash_noti_lv,
755 evas_object_event_callback_add(window, EVAS_CALLBACK_DEL,
756 _cb_window_del, lv_info);
760 lv_info->level = (int)level;
761 lv_info->wait_for_done = EINA_TRUE;
762 lv_info->state = TIZEN_POLICY_ERROR_STATE_NONE;
766 tizen_policy_set_notification_level(_eflutil.wl.policy.proto,
767 surface, (int)level);
769 if (lv_info->wait_for_done)
772 while (lv_info->wait_for_done && (count < 3))
774 ecore_wl2_display_flush(_eflutil.wl.wl2_display);
775 wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
779 if (lv_info->wait_for_done)
781 return EFL_UTIL_ERROR_INVALID_PARAMETER;
785 if (lv_info->state == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED)
787 return EFL_UTIL_ERROR_PERMISSION_DENIED;
792 return EFL_UTIL_ERROR_NONE;
796 efl_util_get_notification_window_level(Evas_Object *window,
797 efl_util_notification_level_e *level)
801 EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER);
802 EINA_SAFETY_ON_NULL_RETURN_VAL(level, EFL_UTIL_ERROR_INVALID_PARAMETER);
805 Ecore_Wl2_Window *wlwin;
806 struct wl_surface *surface;
807 Efl_Util_Wl_Surface_Lv_Info *lv_info;
808 Ecore_Wl2_Window_Type wl_type;
811 EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EFL_UTIL_ERROR_INVALID_PARAMETER);
813 wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window);
814 EINA_SAFETY_ON_NULL_RETURN_VAL(wlwin, EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE);
816 type = elm_win_type_get(window);
817 if (type != ELM_WIN_NOTIFICATION)
819 wl_type = ecore_wl2_window_type_get(wlwin);
820 EINA_SAFETY_ON_FALSE_RETURN_VAL((wl_type == ECORE_WL2_WINDOW_TYPE_NOTIFICATION),
821 EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE);
824 while (!_eflutil.wl.policy.proto)
825 wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
827 surface = ecore_wl2_window_surface_get(wlwin);
828 EINA_SAFETY_ON_NULL_RETURN_VAL(surface,
829 EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE);
831 lv_info = eina_hash_find(_eflutil.wl.policy.hash_noti_lv, &surface);
834 if (lv_info->wait_for_done)
837 while ((lv_info->wait_for_done) && (count < 3))
839 ecore_wl2_display_flush(_eflutil.wl.wl2_display);
840 wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
844 if (lv_info->wait_for_done)
846 *level = EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT;
847 return EFL_UTIL_ERROR_INVALID_PARAMETER;
851 switch (lv_info->level)
853 case TIZEN_POLICY_LEVEL_NONE: *level = EFL_UTIL_NOTIFICATION_LEVEL_NONE; break;
854 case TIZEN_POLICY_LEVEL_DEFAULT: *level = EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT; break;
855 case TIZEN_POLICY_LEVEL_MEDIUM: *level = EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM; break;
856 case TIZEN_POLICY_LEVEL_HIGH: *level = EFL_UTIL_NOTIFICATION_LEVEL_HIGH; break;
857 case TIZEN_POLICY_LEVEL_TOP: *level = EFL_UTIL_NOTIFICATION_LEVEL_TOP; break;
858 default: *level = EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT;
859 return EFL_UTIL_ERROR_INVALID_PARAMETER;
861 return EFL_UTIL_ERROR_NONE;
864 *level = EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT;
866 return EFL_UTIL_ERROR_NONE;
870 efl_util_set_window_opaque_state(Evas_Object *window,
875 EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER);
876 EINA_SAFETY_ON_FALSE_RETURN_VAL(((opaque >= 0) && (opaque <= 1)),
877 EFL_UTIL_ERROR_INVALID_PARAMETER);
879 Ecore_Wl2_Window *wlwin;
880 struct wl_surface *surface;
882 if (!_eflutil.wl.policy.proto)
887 EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EFL_UTIL_ERROR_INVALID_PARAMETER);
889 while (!_eflutil.wl.policy.proto && ret != -1)
890 ret = wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
892 EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.policy.proto, EFL_UTIL_ERROR_INVALID_PARAMETER);
895 wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window);
897 return EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE;
899 surface = ecore_wl2_window_surface_get(wlwin);
901 return EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE;
903 tizen_policy_set_opaque_state(_eflutil.wl.policy.proto, surface, opaque);
905 return EFL_UTIL_ERROR_NONE;
909 efl_util_set_window_screen_mode(Evas_Object *window,
910 efl_util_screen_mode_e mode)
912 EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER);
913 EINA_SAFETY_ON_FALSE_RETURN_VAL(((mode >= EFL_UTIL_SCREEN_MODE_DEFAULT) &&
914 (mode <= EFL_UTIL_SCREEN_MODE_ALWAYS_ON)),
915 EFL_UTIL_ERROR_INVALID_PARAMETER);
917 Ecore_Wl2_Window *wlwin;
918 struct wl_surface *surface;
919 Efl_Util_Wl_Surface_Scr_Mode_Info *scr_mode_info;
923 EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EFL_UTIL_ERROR_INVALID_PARAMETER);
925 wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window);
928 while (!_eflutil.wl.policy.proto)
929 wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
931 surface = ecore_wl2_window_surface_get(wlwin);
932 EINA_SAFETY_ON_NULL_RETURN_VAL(surface,
933 EFL_UTIL_ERROR_INVALID_PARAMETER);
935 scr_mode_info = eina_hash_find(_eflutil.wl.policy.hash_scr_mode, &surface);
938 scr_mode_info = calloc(1, sizeof(Efl_Util_Wl_Surface_Scr_Mode_Info));
939 EINA_SAFETY_ON_NULL_RETURN_VAL(scr_mode_info, EFL_UTIL_ERROR_OUT_OF_MEMORY);
941 scr_mode_info->surface = surface;
942 scr_mode_info->mode = (unsigned int)mode;
943 scr_mode_info->wait_for_done = EINA_TRUE;
944 scr_mode_info->state = TIZEN_POLICY_ERROR_STATE_NONE;
946 eina_hash_add(_eflutil.wl.policy.hash_scr_mode,
952 scr_mode_info->mode = (unsigned int)mode;
953 scr_mode_info->wait_for_done = EINA_TRUE;
954 scr_mode_info->state = TIZEN_POLICY_ERROR_STATE_NONE;
957 tizen_policy_set_window_screen_mode(_eflutil.wl.policy.proto,
958 surface, (unsigned int)mode);
959 if (scr_mode_info->wait_for_done)
962 while (scr_mode_info->wait_for_done && (count < 3))
964 ecore_wl2_display_flush(_eflutil.wl.wl2_display);
965 wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
969 if (scr_mode_info->wait_for_done)
971 return EFL_UTIL_ERROR_INVALID_PARAMETER;
975 if (scr_mode_info->state == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED)
977 return EFL_UTIL_ERROR_PERMISSION_DENIED;
982 return EFL_UTIL_ERROR_NONE;
985 return EFL_UTIL_ERROR_INVALID_PARAMETER;
989 efl_util_get_window_screen_mode(Evas_Object *window,
990 efl_util_screen_mode_e *mode)
992 EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER);
993 EINA_SAFETY_ON_NULL_RETURN_VAL(mode, EFL_UTIL_ERROR_INVALID_PARAMETER);
995 Ecore_Wl2_Window *wlwin;
996 struct wl_surface *surface;
997 Efl_Util_Wl_Surface_Scr_Mode_Info *scr_mode_info;
1001 EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EFL_UTIL_ERROR_INVALID_PARAMETER);
1003 wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window);
1006 while (!_eflutil.wl.policy.proto)
1007 wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1009 surface = ecore_wl2_window_surface_get(wlwin);
1010 EINA_SAFETY_ON_NULL_RETURN_VAL(surface,
1011 EFL_UTIL_ERROR_INVALID_PARAMETER);
1013 scr_mode_info = eina_hash_find(_eflutil.wl.policy.hash_scr_mode, &surface);
1016 if (scr_mode_info->wait_for_done)
1018 while (scr_mode_info->wait_for_done)
1020 ecore_wl2_display_flush(_eflutil.wl.wl2_display);
1021 wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1025 switch (scr_mode_info->mode)
1027 case TIZEN_POLICY_MODE_DEFAULT: *mode = EFL_UTIL_SCREEN_MODE_DEFAULT; break;
1028 case TIZEN_POLICY_MODE_ALWAYS_ON: *mode = EFL_UTIL_SCREEN_MODE_ALWAYS_ON; break;
1029 default: *mode = EFL_UTIL_SCREEN_MODE_DEFAULT;
1030 return EFL_UTIL_ERROR_INVALID_PARAMETER;
1032 return EFL_UTIL_ERROR_NONE;
1036 *mode = EFL_UTIL_SCREEN_MODE_DEFAULT;
1037 return EFL_UTIL_ERROR_INVALID_PARAMETER;
1041 return EFL_UTIL_ERROR_INVALID_PARAMETER;
1045 efl_util_set_window_brightness(Evas_Object *window, int brightness)
1047 Ecore_Wl2_Window *wlwin;
1048 struct wl_surface *surface;
1049 Efl_Util_Wl_Surface_Brightness_Info *brightness_info;
1052 EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER);
1053 EINA_SAFETY_ON_FALSE_RETURN_VAL(brightness <= 100, EFL_UTIL_ERROR_INVALID_PARAMETER);
1056 EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EFL_UTIL_ERROR_INVALID_PARAMETER);
1058 wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window);
1061 while (!_eflutil.wl.display_policy.proto)
1062 wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1064 surface = ecore_wl2_window_surface_get(wlwin);
1065 EINA_SAFETY_ON_NULL_RETURN_VAL(surface,
1066 EFL_UTIL_ERROR_INVALID_PARAMETER);
1068 brightness_info = eina_hash_find(_eflutil.wl.display_policy.hash_brightness, &surface);
1069 if (!brightness_info)
1071 brightness_info = calloc(1, sizeof(Efl_Util_Wl_Surface_Brightness_Info));
1072 EINA_SAFETY_ON_NULL_RETURN_VAL(brightness_info, EFL_UTIL_ERROR_OUT_OF_MEMORY);
1074 brightness_info->surface = surface;
1075 brightness_info->brightness = brightness;
1076 brightness_info->wait_for_done = EINA_TRUE;
1077 brightness_info->state = TIZEN_DISPLAY_POLICY_ERROR_STATE_NONE;
1079 eina_hash_add(_eflutil.wl.display_policy.hash_brightness,
1085 brightness_info->brightness = brightness;
1086 brightness_info->wait_for_done = EINA_TRUE;
1087 brightness_info->state = TIZEN_DISPLAY_POLICY_ERROR_STATE_NONE;
1090 tizen_display_policy_set_window_brightness(_eflutil.wl.display_policy.proto,
1091 surface, brightness);
1092 if (brightness_info->wait_for_done)
1095 while (brightness_info->wait_for_done && (count < 3))
1097 ecore_wl2_display_flush(_eflutil.wl.wl2_display);
1098 wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1102 if (brightness_info->wait_for_done)
1104 return EFL_UTIL_ERROR_INVALID_PARAMETER;
1108 if (brightness_info->state == TIZEN_DISPLAY_POLICY_ERROR_STATE_PERMISSION_DENIED)
1110 return EFL_UTIL_ERROR_PERMISSION_DENIED;
1114 return EFL_UTIL_ERROR_NONE;
1117 return EFL_UTIL_ERROR_INVALID_PARAMETER;
1121 efl_util_get_window_brightness(Evas_Object *window, int *brightness)
1123 Ecore_Wl2_Window *wlwin;
1124 struct wl_surface *surface;
1125 Efl_Util_Wl_Surface_Brightness_Info *brightness_info;
1128 EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER);
1129 EINA_SAFETY_ON_NULL_RETURN_VAL(brightness, EFL_UTIL_ERROR_INVALID_PARAMETER);
1132 EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EFL_UTIL_ERROR_INVALID_PARAMETER);
1134 wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window);
1135 if (!wlwin) return EFL_UTIL_ERROR_INVALID_PARAMETER;
1137 while (!_eflutil.wl.display_policy.proto)
1138 wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1140 surface = ecore_wl2_window_surface_get(wlwin);
1141 EINA_SAFETY_ON_NULL_RETURN_VAL(surface,
1142 EFL_UTIL_ERROR_INVALID_PARAMETER);
1144 brightness_info = eina_hash_find(_eflutil.wl.display_policy.hash_brightness, &surface);
1145 if (brightness_info)
1147 if (brightness_info->wait_for_done)
1149 while (brightness_info->wait_for_done)
1151 ecore_wl2_display_flush(_eflutil.wl.wl2_display);
1152 wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1155 *brightness = brightness_info->brightness;
1160 return EFL_UTIL_ERROR_NONE;
1164 struct _efl_util_inputgen_h
1166 unsigned int init_type;
1168 E_Devicemgr_Inputgen_Touch_Axis *axis_info;
1171 /* LCOV_EXCL_STOP */
1174 _cb_device_add(void *data EINA_UNUSED,
1175 struct tizen_input_device_manager *tizen_input_device_manager EINA_UNUSED,
1176 uint32_t serial EINA_UNUSED,
1177 const char *identifier EINA_UNUSED,
1178 struct tizen_input_device *device,
1179 struct wl_seat *seat EINA_UNUSED)
1185 _cb_device_remove(void *data EINA_UNUSED,
1186 struct tizen_input_device_manager *tizen_input_device_manager EINA_UNUSED,
1187 uint32_t serial EINA_UNUSED,
1188 const char *identifier EINA_UNUSED,
1189 struct tizen_input_device *device,
1190 struct wl_seat *seat EINA_UNUSED)
1196 _cb_error(void *data EINA_UNUSED,
1197 struct tizen_input_device_manager *tizen_input_device_manager EINA_UNUSED,
1200 _eflutil.wl.devmgr.request_notified = errorcode;
1203 /* LCOV_EXCL_START */
1205 _cb_block_expired(void *data EINA_UNUSED,
1206 struct tizen_input_device_manager *tizen_input_device_manager EINA_UNUSED)
1210 /* LCOV_EXCL_STOP */
1213 _cb_max_touch_count(void *data EINA_UNUSED,
1214 struct tizen_input_device_manager *tizen_input_device_manager EINA_UNUSED,
1215 uint32_t serial EINA_UNUSED,
1217 struct wl_seat *seat EINA_UNUSED)
1219 _eflutil.wl.devmgr.max_touch_count = max_count;
1222 static efl_util_error_e
1223 _efl_util_input_convert_input_generator_error(int ret)
1227 case TIZEN_INPUT_DEVICE_MANAGER_ERROR_NONE:
1228 return EFL_UTIL_ERROR_NONE;
1229 case TIZEN_INPUT_DEVICE_MANAGER_ERROR_NO_PERMISSION:
1230 return EFL_UTIL_ERROR_PERMISSION_DENIED;
1231 case TIZEN_INPUT_DEVICE_MANAGER_ERROR_NO_SYSTEM_RESOURCES:
1232 return EFL_UTIL_ERROR_OUT_OF_MEMORY;
1233 case TIZEN_INPUT_DEVICE_MANAGER_ERROR_INVALID_PARAMETER:
1234 return EFL_UTIL_ERROR_INVALID_PARAMETER;
1235 case TIZEN_INPUT_DEVICE_MANAGER_ERROR_NOT_ALLOWED:
1236 return EFL_UTIL_ERROR_NO_RESOURCE_AVAILABLE;
1238 return EFL_UTIL_ERROR_NONE;
1242 static efl_util_inputgen_h
1243 _efl_util_input_create_inputgen(unsigned int dev_type, const char *name, int *ret, int with_name)
1245 efl_util_inputgen_h inputgen_h = NULL;
1246 unsigned int clas = 0x0;
1249 dev_type & ~(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN
1250 | EFL_UTIL_INPUT_DEVTYPE_KEYBOARD
1251 | EFL_UTIL_INPUT_DEVTYPE_POINTER))
1253 set_last_result(EFL_UTIL_ERROR_NO_SUCH_DEVICE);
1257 inputgen_h = (efl_util_inputgen_h)calloc(1, sizeof(struct _efl_util_inputgen_h));
1260 set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY);
1264 inputgen_h->init_type |= dev_type;
1267 if (name) strncpy(inputgen_h->name, name, 31);
1268 else strncpy(inputgen_h->name, "Input Generator", 31);
1272 if (*ret == (int)EINA_FALSE)
1274 set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
1278 if (dev_type & EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN)
1279 clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_TOUCHSCREEN;
1280 if (dev_type & EFL_UTIL_INPUT_DEVTYPE_KEYBOARD)
1281 clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_KEYBOARD;
1282 if (dev_type & EFL_UTIL_INPUT_DEVTYPE_POINTER)
1283 clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_MOUSE;
1285 while (!_eflutil.wl.devmgr.devicemgr)
1286 wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1289 tizen_input_device_manager_init_generator_with_sync(_eflutil.wl.devmgr.devicemgr, clas, inputgen_h->name);
1290 else if (with_name == 1)
1291 tizen_input_device_manager_init_generator_with_name(_eflutil.wl.devmgr.devicemgr, clas, inputgen_h->name);
1293 tizen_input_device_manager_init_generator(_eflutil.wl.devmgr.devicemgr, clas);
1296 while (_eflutil.wl.devmgr.request_notified == -1)
1297 wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1299 *ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
1300 _eflutil.wl.devmgr.request_notified = -1;
1302 set_last_result(*ret);
1303 if (*ret != TIZEN_INPUT_DEVICE_MANAGER_ERROR_NONE)
1317 API efl_util_inputgen_h
1318 efl_util_input_initialize_generator(unsigned int dev_type)
1320 int ret = EFL_UTIL_ERROR_NONE;
1321 efl_util_inputgen_h inputgen_h = NULL;
1323 inputgen_h = _efl_util_input_create_inputgen(dev_type, NULL, &ret, 0);
1330 API efl_util_inputgen_h
1331 efl_util_input_initialize_generator_with_name(unsigned int dev_type, const char *name)
1333 int ret = EFL_UTIL_ERROR_NONE;
1334 efl_util_inputgen_h inputgen_h = NULL;
1336 inputgen_h = _efl_util_input_create_inputgen(dev_type, name, &ret, 1);
1343 API efl_util_inputgen_h
1344 efl_util_input_initialize_generator_with_sync(unsigned int dev_type, const char *name)
1346 int ret = EFL_UTIL_ERROR_NONE;
1347 efl_util_inputgen_h inputgen_h = NULL;
1349 inputgen_h = _efl_util_input_create_inputgen(dev_type, name, &ret, 2);
1357 efl_util_input_set_touch_count(int max_count)
1359 int ret = EFL_UTIL_ERROR_NONE;
1362 if (ret == (int)EINA_FALSE)
1364 return EFL_UTIL_ERROR_INVALID_PARAMETER;
1367 while (!_eflutil.wl.devmgr.devicemgr)
1368 wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1370 if (_eflutil.wl.devmgr.max_touch_count >= max_count)
1371 return EFL_UTIL_ERROR_NONE;
1373 tizen_input_device_manager_set_touch_count(_eflutil.wl.devmgr.devicemgr, max_count);
1375 while (_eflutil.wl.devmgr.request_notified == -1)
1376 wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1378 ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
1379 _eflutil.wl.devmgr.request_notified = -1;
1381 if (ret == EFL_UTIL_ERROR_NONE)
1383 _eflutil.wl.devmgr.request_touch_count = max_count;
1390 efl_util_input_deinitialize_generator(efl_util_inputgen_h inputgen_h)
1392 int ret = EFL_UTIL_ERROR_NONE;
1393 unsigned int clas = 0x0;
1394 EINA_SAFETY_ON_NULL_RETURN_VAL(inputgen_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
1396 if (inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN)
1397 clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_TOUCHSCREEN;
1398 if (inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_KEYBOARD)
1399 clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_KEYBOARD;
1400 if (inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_POINTER)
1401 clas |= TIZEN_INPUT_DEVICE_MANAGER_CLAS_MOUSE;
1403 if (inputgen_h->axis_info)
1404 free(inputgen_h->axis_info);
1409 EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.devmgr.devicemgr, EFL_UTIL_ERROR_INVALID_PARAMETER);
1411 tizen_input_device_manager_deinit_generator(_eflutil.wl.devmgr.devicemgr, clas);
1413 while (_eflutil.wl.devmgr.request_notified == -1)
1414 wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1416 ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
1417 _eflutil.wl.devmgr.request_notified = -1;
1423 efl_util_input_generate_key(efl_util_inputgen_h inputgen_h, const char *key_name, int pressed)
1425 int ret = EFL_UTIL_ERROR_NONE;
1427 EINA_SAFETY_ON_NULL_RETURN_VAL(inputgen_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
1428 EINA_SAFETY_ON_NULL_RETURN_VAL(key_name, EFL_UTIL_ERROR_INVALID_PARAMETER);
1429 EINA_SAFETY_ON_FALSE_RETURN_VAL(pressed == 0 || pressed == 1, EFL_UTIL_ERROR_INVALID_PARAMETER);
1430 EINA_SAFETY_ON_FALSE_RETURN_VAL(inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_KEYBOARD, EFL_UTIL_ERROR_NO_SUCH_DEVICE);
1432 EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.devmgr.devicemgr, EFL_UTIL_ERROR_INVALID_PARAMETER);
1434 tizen_input_device_manager_generate_key(_eflutil.wl.devmgr.devicemgr, key_name, pressed);
1436 while (_eflutil.wl.devmgr.request_notified == -1)
1437 wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1439 ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
1440 _eflutil.wl.devmgr.request_notified = -1;
1446 efl_util_input_generate_touch(efl_util_inputgen_h inputgen_h, int idx,
1447 efl_util_input_touch_type_e touch_type, int x, int y)
1450 enum tizen_input_device_manager_pointer_event_type type;
1452 EINA_SAFETY_ON_NULL_RETURN_VAL(inputgen_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
1453 EINA_SAFETY_ON_FALSE_RETURN_VAL(idx >= 0, EFL_UTIL_ERROR_INVALID_PARAMETER);
1454 EINA_SAFETY_ON_FALSE_RETURN_VAL((x > 0 && y > 0), EFL_UTIL_ERROR_INVALID_PARAMETER);
1455 EINA_SAFETY_ON_FALSE_RETURN_VAL(inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN, EFL_UTIL_ERROR_NO_SUCH_DEVICE);
1457 if (idx >= _eflutil.wl.devmgr.max_touch_count)
1458 return EFL_UTIL_ERROR_INVALID_PARAMETER;
1460 EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.devmgr.devicemgr, EFL_UTIL_ERROR_INVALID_PARAMETER);
1464 case EFL_UTIL_INPUT_TOUCH_BEGIN:
1465 type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_BEGIN;
1467 case EFL_UTIL_INPUT_TOUCH_UPDATE:
1468 type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_UPDATE;
1470 case EFL_UTIL_INPUT_TOUCH_END:
1471 type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_END;
1474 return EFL_UTIL_ERROR_INVALID_PARAMETER;
1477 tizen_input_device_manager_generate_touch(_eflutil.wl.devmgr.devicemgr, type, x, y, idx);
1479 while (_eflutil.wl.devmgr.request_notified == -1)
1480 wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1482 ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
1483 _eflutil.wl.devmgr.request_notified = -1;
1489 _efl_util_input_generate_touch_axis_send(unsigned int type, double value)
1493 tizen_input_device_manager_generate_axis(_eflutil.wl.devmgr.devicemgr, type, wl_fixed_from_double(value));
1495 while (_eflutil.wl.devmgr.request_notified == -1)
1496 wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1498 ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
1499 _eflutil.wl.devmgr.request_notified = -1;
1505 _efl_util_input_generate_touch_axis_cleanup(efl_util_inputgen_h inputgen_h, int idx)
1510 inputgen_h->axis_info[idx].radius_x = 1.0;
1511 inputgen_h->axis_info[idx].radius_y = 1.0;
1512 inputgen_h->axis_info[idx].pressure = 1.0;
1513 inputgen_h->axis_info[idx].angle = 0.0;
1514 inputgen_h->axis_info[idx].palm = 0.0;
1518 for (i = 0; i < EFL_UTIL_INPUT_GENERATOR_TOUCH_MAX_FINGER; i++)
1520 inputgen_h->axis_info[i].radius_x = 1.0;
1521 inputgen_h->axis_info[i].radius_y = 1.0;
1522 inputgen_h->axis_info[i].pressure = 1.0;
1523 inputgen_h->axis_info[i].angle = 0.0;
1524 inputgen_h->axis_info[i].palm = 0.0;
1530 _efl_util_input_generate_touch_axis_process(efl_util_inputgen_h inputgen_h, int idx, double radius_x,
1531 double radius_y, double pressure, double angle, double palm)
1533 int ret = EFL_UTIL_ERROR_NONE;
1535 if (!inputgen_h->axis_info)
1537 inputgen_h->axis_info = calloc(EFL_UTIL_INPUT_GENERATOR_TOUCH_MAX_FINGER,
1538 sizeof(E_Devicemgr_Inputgen_Touch_Axis));
1539 _efl_util_input_generate_touch_axis_cleanup(inputgen_h, -1);
1542 if (inputgen_h->axis_info[idx].radius_x != radius_x)
1544 ret = _efl_util_input_generate_touch_axis_send(TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_RADIUS_X, radius_x);
1545 if (ret != EFL_UTIL_ERROR_NONE) return ret;
1546 inputgen_h->axis_info[idx].radius_x = radius_x;
1548 if (inputgen_h->axis_info[idx].radius_y != radius_y)
1550 ret = _efl_util_input_generate_touch_axis_send(TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_RADIUS_Y, radius_y);
1551 if (ret != EFL_UTIL_ERROR_NONE) return ret;
1552 inputgen_h->axis_info[idx].radius_y = radius_y;
1554 if (inputgen_h->axis_info[idx].pressure != pressure)
1556 ret = _efl_util_input_generate_touch_axis_send(TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_PRESSURE, pressure);
1557 if (ret != EFL_UTIL_ERROR_NONE) return ret;
1558 inputgen_h->axis_info[idx].pressure = pressure;
1560 if (inputgen_h->axis_info[idx].angle != angle)
1562 ret = _efl_util_input_generate_touch_axis_send(TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_ANGLE, angle);
1563 if (ret != EFL_UTIL_ERROR_NONE) return ret;
1564 inputgen_h->axis_info[idx].angle = angle;
1566 if (inputgen_h->axis_info[idx].palm != palm)
1568 ret = _efl_util_input_generate_touch_axis_send(TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_PALM, palm);
1569 if (ret != EFL_UTIL_ERROR_NONE) return ret;
1570 inputgen_h->axis_info[idx].palm = palm;
1577 efl_util_input_generate_touch_axis(efl_util_inputgen_h inputgen_h, int idx,
1578 efl_util_input_touch_type_e touch_type, int x, int y,
1579 double radius_x, double radius_y,
1580 double pressure, double angle, double palm)
1583 enum tizen_input_device_manager_pointer_event_type type;
1585 EINA_SAFETY_ON_NULL_RETURN_VAL(inputgen_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
1586 EINA_SAFETY_ON_FALSE_RETURN_VAL(idx >= 0, EFL_UTIL_ERROR_INVALID_PARAMETER);
1587 EINA_SAFETY_ON_FALSE_RETURN_VAL((x >= 0 && y >= 0), EFL_UTIL_ERROR_INVALID_PARAMETER);
1588 EINA_SAFETY_ON_FALSE_RETURN_VAL(inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN, EFL_UTIL_ERROR_NO_SUCH_DEVICE);
1589 EINA_SAFETY_ON_FALSE_RETURN_VAL((radius_x >= 0.0 && radius_y >= 0.0), EFL_UTIL_ERROR_INVALID_PARAMETER);
1590 EINA_SAFETY_ON_FALSE_RETURN_VAL((pressure >= 0.0 && palm >= 0.0), EFL_UTIL_ERROR_INVALID_PARAMETER);
1592 EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.devmgr.devicemgr, EFL_UTIL_ERROR_INVALID_PARAMETER);
1593 version = tizen_input_device_manager_get_version(_eflutil.wl.devmgr.devicemgr);
1594 EINA_SAFETY_ON_FALSE_RETURN_VAL((version >= 3), EFL_UTIL_ERROR_NOT_SUPPORTED);
1598 case EFL_UTIL_INPUT_TOUCH_BEGIN:
1599 type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_BEGIN;
1601 case EFL_UTIL_INPUT_TOUCH_UPDATE:
1602 type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_UPDATE;
1604 case EFL_UTIL_INPUT_TOUCH_END:
1605 type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_END;
1608 return EFL_UTIL_ERROR_INVALID_PARAMETER;
1611 if (touch_type != EFL_UTIL_INPUT_TOUCH_END)
1612 _efl_util_input_generate_touch_axis_process(inputgen_h, idx, radius_x, radius_y, pressure, angle, palm);
1614 _efl_util_input_generate_touch_axis_cleanup(inputgen_h, idx);
1616 tizen_input_device_manager_generate_touch(_eflutil.wl.devmgr.devicemgr, type, x, y, idx);
1618 while (_eflutil.wl.devmgr.request_notified == -1)
1619 wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1621 ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
1622 _eflutil.wl.devmgr.request_notified = -1;
1629 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)
1632 enum tizen_input_device_manager_pointer_event_type type;
1634 EINA_SAFETY_ON_NULL_RETURN_VAL(inputgen_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
1635 EINA_SAFETY_ON_FALSE_RETURN_VAL(buttons > 0, EFL_UTIL_ERROR_INVALID_PARAMETER);
1636 EINA_SAFETY_ON_FALSE_RETURN_VAL((x >= 0 && y >= 0), EFL_UTIL_ERROR_INVALID_PARAMETER);
1637 EINA_SAFETY_ON_FALSE_RETURN_VAL(inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_POINTER, EFL_UTIL_ERROR_NO_SUCH_DEVICE);
1639 EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.devmgr.devicemgr, EFL_UTIL_ERROR_INVALID_PARAMETER);
1641 switch(pointer_type)
1643 case EFL_UTIL_INPUT_POINTER_BUTTON_DOWN:
1644 type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_BEGIN;
1646 case EFL_UTIL_INPUT_POINTER_MOVE:
1647 type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_UPDATE;
1649 case EFL_UTIL_INPUT_POINTER_BUTTON_UP:
1650 type = TIZEN_INPUT_DEVICE_MANAGER_POINTER_EVENT_TYPE_END;
1653 return EFL_UTIL_ERROR_INVALID_PARAMETER;
1656 tizen_input_device_manager_generate_pointer(_eflutil.wl.devmgr.devicemgr, type, x, y, buttons);
1658 while (_eflutil.wl.devmgr.request_notified == -1)
1659 wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1661 ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
1662 _eflutil.wl.devmgr.request_notified = -1;
1668 efl_util_input_generate_wheel(efl_util_inputgen_h inputgen_h, efl_util_input_pointer_wheel_type_e wheel_type, int value)
1671 enum tizen_input_device_manager_pointer_event_type type;
1673 EINA_SAFETY_ON_NULL_RETURN_VAL(inputgen_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
1674 EINA_SAFETY_ON_FALSE_RETURN_VAL(inputgen_h->init_type & EFL_UTIL_INPUT_DEVTYPE_POINTER, EFL_UTIL_ERROR_NO_SUCH_DEVICE);
1676 EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil.wl.devmgr.devicemgr, EFL_UTIL_ERROR_INVALID_PARAMETER);
1677 version = tizen_input_device_manager_get_version(_eflutil.wl.devmgr.devicemgr);
1678 EINA_SAFETY_ON_FALSE_RETURN_VAL((version >= 3), EFL_UTIL_ERROR_NOT_SUPPORTED);
1682 case EFL_UTIL_INPUT_POINTER_WHEEL_VERT:
1683 type = TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_WHEEL;
1685 case EFL_UTIL_INPUT_POINTER_WHEEL_HORZ:
1686 type = TIZEN_INPUT_DEVICE_MANAGER_AXIS_TYPE_HWHEEL;
1689 return EFL_UTIL_ERROR_INVALID_PARAMETER;
1692 tizen_input_device_manager_generate_axis(_eflutil.wl.devmgr.devicemgr, type, wl_fixed_from_int(value));
1694 while (_eflutil.wl.devmgr.request_notified == -1)
1695 wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1697 ret = _efl_util_input_convert_input_generator_error(_eflutil.wl.devmgr.request_notified);
1698 _eflutil.wl.devmgr.request_notified = -1;
1705 struct _efl_util_screenshot_h
1710 Eina_Bool shot_done;
1715 Eina_Bool auto_rotation;
1718 /* scrrenshot handle */
1719 static efl_util_screenshot_h g_screenshot;
1720 static Eina_Bool shot_mutex_init;
1721 static pthread_mutex_t shot_lock;
1724 _screenshot_mutex_init(void)
1726 if (shot_mutex_init)
1729 if (pthread_mutex_init(&shot_lock, NULL))
1731 fprintf(stderr, "[screenshot] fail: mutex init"); /*LCOV_EXCL_LINE*/
1732 return EINA_FALSE; /*LCOV_EXCL_LINE*/
1735 shot_mutex_init = EINA_TRUE;
1741 _screenshot_mutex_destory(void)
1743 if (!shot_mutex_init)
1746 if (pthread_mutex_destroy(&shot_lock))
1748 fprintf(stderr, "[screenshot] fail: mutex destory"); /*LCOV_EXCL_LINE*/
1749 return EINA_FALSE; /*LCOV_EXCL_LINE*/
1752 shot_mutex_init = EINA_FALSE;
1758 _screenshot_mutex_lock(void)
1760 if (!_screenshot_mutex_init())
1763 pthread_mutex_lock(&shot_lock);
1767 _screenshot_mutex_unlock(void)
1769 pthread_mutex_unlock(&shot_lock);
1773 _efl_util_wl_screenshooter_init()
1775 struct wl_display *display_wrapper = NULL;
1776 struct wl_registry *registry = NULL;
1779 if (_wl_init() == EINA_FALSE)
1782 wl_display_roundtrip_queue(_eflutil.wl.dpy, _eflutil.wl.queue);
1784 display_wrapper = wl_proxy_create_wrapper(_eflutil.wl.dpy);
1785 EINA_SAFETY_ON_NULL_RETURN_VAL(display_wrapper, EINA_FALSE);
1787 _eflutil.wl.shot.queue = wl_display_create_queue(_eflutil.wl.dpy);
1788 EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.shot.queue, fail_create_queue);
1790 wl_proxy_set_queue((struct wl_proxy *)display_wrapper, _eflutil.wl.shot.queue);
1792 registry = wl_display_get_registry(display_wrapper);
1793 EINA_SAFETY_ON_NULL_GOTO(registry, fail_get_registry);
1795 wl_registry_add_listener(registry, &_wl_reg_screenshooter_listener, NULL);
1797 ret = wl_display_roundtrip_queue(_eflutil.wl.dpy, _eflutil.wl.shot.queue);
1798 EINA_SAFETY_ON_TRUE_GOTO(ret == -1, fail_roundtrip);
1799 EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.shot.tz_screenshooter, fail_roundtrip);
1801 _eflutil.wl.shot.tbm_client = wayland_tbm_client_init(_eflutil.wl.dpy);
1802 EINA_SAFETY_ON_NULL_GOTO(_eflutil.wl.shot.tbm_client, fail_tbm_client_init);
1804 wl_registry_destroy(registry);
1805 wl_proxy_wrapper_destroy(display_wrapper);
1807 if (_eflutil.wl.shot.noti == 0)
1809 fprintf(stderr, "[screenshot] fail: privilege error\n"); /* LCOV_EXCL_LINE */
1815 fail_tbm_client_init:
1816 tizen_screenshooter_destroy(_eflutil.wl.shot.tz_screenshooter);
1817 _eflutil.wl.shot.tz_screenshooter = NULL;
1819 wl_registry_destroy(registry);
1821 wl_event_queue_destroy(_eflutil.wl.shot.queue);
1822 _eflutil.wl.shot.queue = NULL;
1824 wl_proxy_wrapper_destroy(display_wrapper);
1830 _efl_util_wl_screenshooter_deinit()
1832 if (_eflutil.wl.shot.tbm_client)
1834 wayland_tbm_client_deinit(_eflutil.wl.shot.tbm_client);
1835 _eflutil.wl.shot.tbm_client = NULL;
1838 if (_eflutil.wl.shot.tz_screenshooter)
1840 tizen_screenshooter_destroy(_eflutil.wl.shot.tz_screenshooter);
1841 _eflutil.wl.shot.tz_screenshooter = NULL;
1844 if (_eflutil.wl.shot.queue)
1846 wl_event_queue_destroy(_eflutil.wl.shot.queue);
1847 _eflutil.wl.shot.queue = NULL;
1851 API efl_util_screenshot_h
1852 efl_util_screenshot_initialize(int width, int height)
1854 efl_util_screenshot_h screenshot = NULL;
1856 if (width <= 0 || height <= 0)
1858 set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
1862 _screenshot_mutex_lock();
1866 if (g_screenshot->width != width || g_screenshot->height != height)
1868 g_screenshot->width = width;
1869 g_screenshot->height = height;
1871 set_last_result(EFL_UTIL_ERROR_NONE);
1873 _screenshot_mutex_unlock();
1875 return g_screenshot;
1878 screenshot = calloc(1, sizeof(struct _efl_util_screenshot_h));
1879 if (screenshot == NULL)
1881 set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY);
1883 _screenshot_mutex_unlock();
1888 if (!_eflutil.wl.shot.tz_screenshooter)
1890 if (_efl_util_wl_screenshooter_init() == EINA_FALSE)
1892 if (_eflutil.wl.shot.noti == 0)
1893 set_last_result(EFL_UTIL_ERROR_PERMISSION_DENIED);
1895 set_last_result(EFL_UTIL_ERROR_SCREENSHOT_INIT_FAIL);
1899 _screenshot_mutex_unlock();
1905 screenshot->width = width;
1906 screenshot->height = height;
1907 screenshot->auto_rotation = EINA_TRUE;
1909 screenshot->bufmgr = wayland_tbm_client_get_bufmgr(_eflutil.wl.shot.tbm_client);
1910 EINA_SAFETY_ON_NULL_GOTO(screenshot->bufmgr, fail_get_bufmgr);
1912 g_screenshot = screenshot;
1913 set_last_result(EFL_UTIL_ERROR_NONE);
1915 tizen_screenshooter_set_user_data(_eflutil.wl.shot.tz_screenshooter, &screenshot->shot_done);
1917 _screenshot_mutex_unlock();
1919 return g_screenshot;
1921 /* LCOV_EXCL_START */
1923 set_last_result(EFL_UTIL_ERROR_SCREENSHOT_INIT_FAIL);
1924 _screenshot_mutex_unlock();
1925 efl_util_screenshot_deinitialize(screenshot);
1928 /* LCOV_EXCL_STOP */
1932 efl_util_screenshot_deinitialize(efl_util_screenshot_h screenshot)
1934 _screenshot_mutex_lock();
1938 _screenshot_mutex_unlock();
1939 _screenshot_mutex_destory();
1940 return EFL_UTIL_ERROR_INVALID_PARAMETER;
1944 g_screenshot = NULL;
1946 _efl_util_wl_screenshooter_deinit();
1948 _screenshot_mutex_unlock();
1949 _screenshot_mutex_destory();
1951 return EFL_UTIL_ERROR_NONE;
1956 efl_util_screenshot_take_tbm_surface(efl_util_screenshot_h screenshot)
1958 tbm_surface_h t_surface = NULL;
1959 struct wl_buffer *buffer = NULL;
1960 Efl_Util_Wl_Output_Info *output;
1963 _screenshot_mutex_lock();
1965 if (!screenshot || (screenshot != g_screenshot))
1967 set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
1968 _screenshot_mutex_unlock();
1972 output = eina_list_nth(_eflutil.wl.shot.output_list, 0);
1975 fprintf(stderr, "[screenshot] fail: no output for screenshot\n"); /* LCOV_EXCL_LINE */
1979 t_surface = tbm_surface_create(screenshot->width, screenshot->height, TBM_FORMAT_XRGB8888);
1982 fprintf(stderr, "[screenshot] fail: tbm_surface_create\n"); /* LCOV_EXCL_LINE */
1986 buffer = wayland_tbm_client_create_buffer(_eflutil.wl.shot.tbm_client, t_surface);
1989 fprintf(stderr, "[screenshot] fail: create wl_buffer for screenshot\n"); /* LCOV_EXCL_LINE */
1993 tizen_screenshooter_shoot(_eflutil.wl.shot.tz_screenshooter, output->output, buffer);
1995 screenshot->shot_done = EINA_FALSE;
1997 while (!screenshot->shot_done && ret != -1)
1998 ret = wl_display_roundtrip_queue(_eflutil.wl.dpy, _eflutil.wl.shot.queue);
2002 fprintf(stderr, "[screenshot] fail: tizen_screenshooter_shoot\n"); /* LCOV_EXCL_LINE */
2006 wayland_tbm_client_destroy_buffer(_eflutil.wl.shot.tbm_client, buffer);
2008 /* reset shot_done for next screenshot */
2009 screenshot->shot_done = EINA_FALSE;
2011 set_last_result(EFL_UTIL_ERROR_NONE);
2013 _screenshot_mutex_unlock();
2019 tbm_surface_destroy(t_surface);
2021 wayland_tbm_client_destroy_buffer(_eflutil.wl.shot.tbm_client, buffer);
2023 set_last_result(EFL_UTIL_ERROR_SCREENSHOT_EXECUTION_FAIL);
2025 _screenshot_mutex_unlock();
2031 efl_util_screenshot_set_auto_rotation(efl_util_screenshot_h screenshot, int set)
2033 if (!screenshot || (screenshot != g_screenshot))
2034 return EFL_UTIL_ERROR_INVALID_PARAMETER;
2036 if (!(set == 0 || set == 1))
2037 return EFL_UTIL_ERROR_INVALID_PARAMETER;
2040 g_screenshot->auto_rotation = EINA_TRUE;
2042 g_screenshot->auto_rotation = EINA_FALSE;
2044 tizen_screenshooter_set_oneshot_auto_rotation(_eflutil.wl.shot.tz_screenshooter, g_screenshot->auto_rotation);
2046 return EFL_UTIL_ERROR_NONE;
2050 efl_util_screenshot_get_auto_rotation(efl_util_screenshot_h screenshot, int *set)
2052 if (!screenshot || (screenshot != g_screenshot) || !set)
2053 return EFL_UTIL_ERROR_INVALID_PARAMETER;
2055 *set = g_screenshot->auto_rotation;
2057 return EFL_UTIL_ERROR_NONE;
2060 /* LCOV_EXCL_START */
2061 struct _efl_util_screenmirror_h
2063 struct tizen_screenmirror *tz_screenmirror;
2069 Eina_List *buffer_list;
2071 Eina_Bool mirror_working;
2074 Eina_Bool cb_content;
2075 efl_util_screenmirror_handler user_func;
2079 typedef struct _efl_util_mirror_buffer efl_util_mirror_buffer;
2080 struct _efl_util_mirror_buffer
2082 struct wl_buffer *buffer;
2084 tbm_surface_h t_surface;
2087 static efl_util_screenmirror_h g_screenmirror;
2090 _efl_util_screenmirror_loop(void *data)
2092 efl_util_screenmirror_h screenmirror;
2095 screenmirror = (efl_util_screenmirror_h)data;
2099 if (!screenmirror->mirror_working)
2102 ret = wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.shot.queue);
2105 fprintf(stderr, "[screenmirror] fail: dispatch_queue\n");
2113 static efl_util_mirror_buffer *
2114 _efl_util_create_mirror_buffer(efl_util_screenmirror_h screenmirror)
2116 efl_util_mirror_buffer *mbuffer;
2118 mbuffer = calloc(1, sizeof(struct _efl_util_mirror_buffer));
2119 EINA_SAFETY_ON_NULL_RETURN_VAL(mbuffer, NULL);
2121 mbuffer->w = screenmirror->width;
2122 mbuffer->h = screenmirror->height;
2124 mbuffer->t_surface = tbm_surface_internal_create_with_flags(mbuffer->w,
2125 mbuffer->h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
2126 EINA_SAFETY_ON_NULL_GOTO(mbuffer->t_surface, fail_create_surface);
2128 mbuffer->buffer = wayland_tbm_client_create_buffer(_eflutil.wl.shot.tbm_client, mbuffer->t_surface);
2129 EINA_SAFETY_ON_NULL_GOTO(mbuffer->buffer, fail_create_buffer);
2134 tbm_surface_destroy(mbuffer->t_surface);
2135 fail_create_surface:
2142 _efl_util_destroy_mirror_buffer(efl_util_mirror_buffer *mbuffer)
2144 EINA_SAFETY_ON_NULL_RETURN(mbuffer);
2146 if (mbuffer->buffer)
2147 wl_buffer_destroy(mbuffer->buffer);
2153 _efl_util_screenmirror_handle_dequeued(void *data,
2154 struct tizen_screenmirror *tz_screenmirror, struct wl_buffer *buffer)
2156 efl_util_screenmirror_h screenmirror;
2157 efl_util_mirror_buffer *mbuffer;
2160 screenmirror = (efl_util_screenmirror_h)data;
2161 screenmirror->cb_start = EINA_TRUE;
2163 EINA_LIST_FOREACH_SAFE(screenmirror->buffer_list, l, ll, mbuffer)
2165 if (mbuffer->buffer == buffer)
2167 if (mbuffer->w != screenmirror->width || mbuffer->h != screenmirror->height ||
2168 !screenmirror->mirror_working)
2169 tbm_surface_destroy(mbuffer->t_surface);
2171 screenmirror->user_func(screenmirror, mbuffer->t_surface, screenmirror->user_data);
2173 screenmirror->buffer_list = eina_list_remove_list(screenmirror->buffer_list, l);
2174 _efl_util_destroy_mirror_buffer(mbuffer);
2180 mbuffer = _efl_util_create_mirror_buffer(screenmirror);
2181 if (mbuffer == NULL)
2183 fprintf(stderr, "[screenmirror] fail: buffer create\n");
2186 screenmirror->buffer_list = eina_list_append(screenmirror->buffer_list, mbuffer);
2187 tizen_screenmirror_queue(screenmirror->tz_screenmirror, mbuffer->buffer);
2191 _efl_util_screenmirror_handle_content(void *data,
2192 struct tizen_screenmirror *tz_screenmirror, uint32_t content)
2194 efl_util_screenmirror_h screenmirror = NULL;
2196 screenmirror = (efl_util_screenmirror_h)data;
2197 screenmirror->cb_content = EINA_TRUE;
2201 _efl_util_screenmirror_handle_stop(void *data, struct tizen_screenmirror *tz_screenmirror)
2203 efl_util_screenmirror_h screenmirror = NULL;
2205 screenmirror = (efl_util_screenmirror_h)data;
2206 screenmirror->cb_stop = EINA_TRUE;
2209 static const struct tizen_screenmirror_listener efl_util_screenmirror_listener = {
2210 _efl_util_screenmirror_handle_dequeued,
2211 _efl_util_screenmirror_handle_content,
2212 _efl_util_screenmirror_handle_stop
2215 API efl_util_screenmirror_h
2216 efl_util_screenmirror_initialize(int width, int height)
2218 efl_util_screenmirror_h screenmirror = NULL;
2219 efl_util_mirror_buffer *mbuffer;
2220 Efl_Util_Wl_Output_Info *output;
2223 if (width <= 0 || height <= 0)
2225 set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
2229 _screenshot_mutex_lock();
2233 if (g_screenmirror->mirror_working)
2235 set_last_result(EFL_UTIL_ERROR_INVALID_OPERATION);
2236 _screenshot_mutex_unlock();
2241 g_screenmirror->width = width;
2242 g_screenmirror->height = height;
2243 set_last_result(EFL_UTIL_ERROR_NONE);
2244 _screenshot_mutex_unlock();
2245 return g_screenmirror;
2249 screenmirror = calloc(1, sizeof(struct _efl_util_screenmirror_h));
2250 if (screenmirror == NULL)
2252 set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY);
2253 _screenshot_mutex_unlock();
2257 if (!_eflutil.wl.shot.tz_screenshooter)
2259 if (_efl_util_wl_screenshooter_init() == EINA_FALSE)
2261 if (_eflutil.wl.shot.noti == 0)
2262 set_last_result(EFL_UTIL_ERROR_PERMISSION_DENIED);
2264 set_last_result(EFL_UTIL_ERROR_SCREENSHOT_INIT_FAIL);
2270 output = eina_list_nth(_eflutil.wl.shot.output_list, 0);
2273 set_last_result(EFL_UTIL_ERROR_NO_RESOURCE_AVAILABLE);
2274 fprintf(stderr, "[screenmirror] fail: no output for screenmirror\n");
2275 goto fail_get_output;
2278 screenmirror->tz_screenmirror = tizen_screenshooter_get_screenmirror(_eflutil.wl.shot.tz_screenshooter, output->output);
2279 wl_proxy_set_queue((struct wl_proxy *)screenmirror->tz_screenmirror, _eflutil.wl.shot.queue);
2280 tizen_screenmirror_add_listener(screenmirror->tz_screenmirror, &efl_util_screenmirror_listener, screenmirror);
2281 tizen_screenmirror_set_stretch(screenmirror->tz_screenmirror, TIZEN_SCREENMIRROR_STRETCH_KEEP_RATIO);
2282 screenmirror->width = width;
2283 screenmirror->height = height;
2285 g_screenmirror = screenmirror;
2287 for (i = 0; i < 1; i++)
2289 mbuffer = _efl_util_create_mirror_buffer(screenmirror);
2292 screenmirror->buffer_list = eina_list_append(screenmirror->buffer_list, mbuffer);
2293 tizen_screenmirror_queue(screenmirror->tz_screenmirror, mbuffer->buffer);
2296 fprintf(stderr, "[screenmirror] fail: buffer create %d\n", i);
2298 while (!screenmirror->cb_content && ret != -1)
2299 ret = wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.shot.queue);
2301 _screenshot_mutex_unlock();
2303 return screenmirror;
2308 _screenshot_mutex_unlock();
2313 efl_util_screenmirror_deinitialize(efl_util_screenmirror_h screenmirror)
2315 efl_util_mirror_buffer *mbuffer;
2318 _screenshot_mutex_lock();
2320 if (!screenmirror || (screenmirror != g_screenmirror))
2322 _screenshot_mutex_unlock();
2323 _screenshot_mutex_destory();
2324 return EFL_UTIL_ERROR_INVALID_PARAMETER;
2327 if (screenmirror->mirror_working)
2329 fprintf(stderr, "[screenmirror] fail: execute stop before deinit\n");
2330 _screenshot_mutex_unlock();
2331 _screenshot_mutex_destory();
2332 return EFL_UTIL_ERROR_INVALID_OPERATION;
2335 EINA_LIST_FOREACH(screenmirror->buffer_list, l, mbuffer)
2337 tbm_surface_destroy(mbuffer->t_surface);
2338 _efl_util_destroy_mirror_buffer(mbuffer);
2340 eina_list_free(screenmirror->buffer_list);
2342 tizen_screenmirror_destroy(screenmirror->tz_screenmirror);
2344 g_screenmirror = NULL;
2346 _efl_util_wl_screenshooter_deinit();
2348 _screenshot_mutex_unlock();
2349 _screenshot_mutex_destory();
2351 return EFL_UTIL_ERROR_NONE;
2355 efl_util_screenmirror_set_handler(efl_util_screenmirror_h screenmirror,
2356 efl_util_screenmirror_handler func, void *data)
2358 _screenshot_mutex_lock();
2360 if (!screenmirror || (screenmirror != g_screenmirror) || !func)
2362 _screenshot_mutex_unlock();
2363 return EFL_UTIL_ERROR_INVALID_PARAMETER;
2365 screenmirror->user_func = func;
2366 screenmirror->user_data = data;
2368 _screenshot_mutex_unlock();
2370 return EFL_UTIL_ERROR_NONE;
2374 efl_util_screenmirror_start(efl_util_screenmirror_h screenmirror)
2378 _screenshot_mutex_lock();
2380 if (!screenmirror || (screenmirror != g_screenmirror))
2382 _screenshot_mutex_unlock();
2383 return EFL_UTIL_ERROR_INVALID_PARAMETER;
2385 else if (!screenmirror->user_func)
2387 _screenshot_mutex_unlock();
2388 return EFL_UTIL_ERROR_SCREENSHOT_EXECUTION_FAIL;
2390 else if (screenmirror->mirror_working)
2392 _screenshot_mutex_unlock();
2393 return EFL_UTIL_ERROR_NONE;
2396 screenmirror->cb_start = EINA_FALSE;
2397 screenmirror->mirror_working = EINA_TRUE;
2398 tizen_screenmirror_start(screenmirror->tz_screenmirror);
2399 while (!screenmirror->cb_start && ret != -1)
2400 ret = wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.shot.queue);
2403 fprintf(stderr, "[screenmirror] fail: tizen_screenmirror_start\n");
2404 _screenshot_mutex_unlock();
2405 return EFL_UTIL_ERROR_SCREENSHOT_EXECUTION_FAIL;
2408 ret = pthread_create(&screenmirror->thread, NULL, _efl_util_screenmirror_loop, screenmirror);
2411 fprintf(stderr, "[screenmirror] fail: thread create fail\n");
2412 _screenshot_mutex_unlock();
2413 return EFL_UTIL_ERROR_SCREENSHOT_EXECUTION_FAIL;
2416 pthread_setname_np(screenmirror->thread, "e_util_mirror");
2418 _screenshot_mutex_unlock();
2420 return EFL_UTIL_ERROR_NONE;
2424 efl_util_screenmirror_stop(efl_util_screenmirror_h screenmirror)
2428 _screenshot_mutex_lock();
2430 if (!screenmirror || (screenmirror != g_screenmirror))
2432 _screenshot_mutex_unlock();
2433 return EFL_UTIL_ERROR_INVALID_PARAMETER;
2435 else if (!screenmirror->mirror_working)
2437 _screenshot_mutex_unlock();
2438 return EFL_UTIL_ERROR_NONE;
2440 screenmirror->mirror_working = EINA_FALSE;
2441 pthread_join(screenmirror->thread, NULL);
2442 tizen_screenmirror_stop(screenmirror->tz_screenmirror);
2443 screenmirror->cb_stop = EINA_FALSE;
2445 while (!screenmirror->cb_stop && ret != -1)
2446 ret = wl_display_dispatch_queue(_eflutil.wl.dpy, _eflutil.wl.shot.queue);
2449 fprintf(stderr, "[screenmirror] fail: tizen_screenmirror_stop\n");
2450 _screenshot_mutex_unlock();
2451 return EFL_UTIL_ERROR_SCREENSHOT_EXECUTION_FAIL;
2454 _screenshot_mutex_unlock();
2456 return EFL_UTIL_ERROR_NONE;
2458 /* LCOV_EXCL_STOP */
2460 struct _efl_util_gesture_h
2465 API int EFL_UTIL_EVENT_GESTURE_EDGE_SWIPE = 0;
2466 API int EFL_UTIL_EVENT_GESTURE_EDGE_DRAG = 0;
2467 API int EFL_UTIL_EVENT_GESTURE_TAP = 0;
2468 API int EFL_UTIL_EVENT_GESTURE_PALM_COVER = 0;
2470 /* LCOV_EXCL_START */
2472 _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)
2474 _eflutil_defaultqueue.wl.gesture.request_notified = error;
2478 _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)
2480 efl_util_event_gesture_edge_swipe_s *ev = NULL;
2482 ev = (efl_util_event_gesture_edge_swipe_s *)calloc(1, sizeof(*ev));
2487 ev->fingers = fingers;
2492 ecore_event_add(EFL_UTIL_EVENT_GESTURE_EDGE_SWIPE, ev, NULL, NULL);
2496 _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)
2498 _eflutil_defaultqueue.wl.gesture.request_notified = error;
2502 _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)
2504 efl_util_event_gesture_edge_drag_s *ev = NULL;
2506 ev = (efl_util_event_gesture_edge_drag_s *)calloc(1, sizeof(*ev));
2511 ev->fingers = fingers;
2516 ecore_event_add(EFL_UTIL_EVENT_GESTURE_EDGE_DRAG, ev, NULL, NULL);
2520 _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)
2522 _eflutil_defaultqueue.wl.gesture.request_notified = error;
2526 _cb_gesture_tap(void *data EINA_UNUSED, struct tizen_gesture *tizen_gesture EINA_UNUSED, uint32_t mode, uint32_t fingers, uint32_t repeats)
2528 efl_util_event_gesture_tap_s *ev = NULL;
2530 ev = (efl_util_event_gesture_tap_s *)calloc(1, sizeof(*ev));
2535 ev->fingers = fingers;
2536 ev->repeats = repeats;
2538 ecore_event_add(EFL_UTIL_EVENT_GESTURE_TAP, ev, NULL, NULL);
2540 /* LCOV_EXCL_STOP */
2543 _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)
2545 _eflutil_defaultqueue.wl.gesture.request_notified = error;
2548 /* LCOV_EXCL_START */
2550 _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)
2552 efl_util_event_gesture_palm_cover_s *ev = NULL;
2554 ev = (efl_util_event_gesture_palm_cover_s *)calloc(1, sizeof(*ev));
2559 ev->duration = duration;
2563 ev->pressure = wl_fixed_to_int(pressure);
2565 ecore_event_add(EFL_UTIL_EVENT_GESTURE_PALM_COVER, ev, NULL, NULL);
2567 /* LCOV_EXCL_STOP */
2570 _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)
2572 _eflutil_defaultqueue.wl.gesture.request_notified = error;
2575 static efl_util_error_e
2576 _efl_util_gesture_convert_error(int ret)
2580 case TIZEN_GESTURE_ERROR_NONE:
2581 return EFL_UTIL_ERROR_NONE;
2582 case TIZEN_GESTURE_ERROR_INVALID_DATA:
2583 return EFL_UTIL_ERROR_INVALID_PARAMETER;
2584 case TIZEN_GESTURE_ERROR_NO_PERMISSION:
2585 return EFL_UTIL_ERROR_PERMISSION_DENIED;
2586 case TIZEN_GESTURE_ERROR_NO_SYSTEM_RESOURCES:
2587 return EFL_UTIL_ERROR_OUT_OF_MEMORY;
2588 case TIZEN_GESTURE_ERROR_GRABBED_ALREADY:
2589 return EFL_UTIL_ERROR_NO_RESOURCE_AVAILABLE;
2590 case TIZEN_GESTURE_ERROR_NOT_SUPPORTED:
2591 return EFL_UTIL_ERROR_NOT_SUPPORTED;
2593 return EFL_UTIL_ERROR_NONE;
2597 /* LCOV_EXCL_START */
2598 static efl_util_error_e
2599 _efl_util_gesture_verify_request_notified()
2601 int ret = EFL_UTIL_ERROR_NONE;
2603 while (_eflutil_defaultqueue.wl.gesture.request_notified == -1)
2604 wl_display_dispatch(_eflutil_defaultqueue.wl.dpy);
2606 ret = _efl_util_gesture_convert_error(_eflutil_defaultqueue.wl.gesture.request_notified);
2607 _eflutil_defaultqueue.wl.gesture.request_notified = -1;
2613 _efl_util_gesture_grab_edge_swipe(efl_util_gesture_data data, Eina_Bool grabbed)
2615 int ret = EFL_UTIL_ERROR_NONE;
2616 Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
2617 Efl_Util_Gesture_Edge_Swipe_Grab_Data *edge_swipe_data = NULL;
2618 unsigned int fingers = 0;
2619 unsigned int edge = 0;
2620 unsigned int edge_size = 0;
2621 unsigned int start_point = 0;
2622 unsigned int end_point = 0;
2624 base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
2626 EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil_defaultqueue.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER);
2627 EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
2628 EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_EDGE_SWIPE,
2629 EFL_UTIL_ERROR_INVALID_PARAMETER);
2631 edge_swipe_data = (Efl_Util_Gesture_Edge_Swipe_Grab_Data *)data;
2633 fingers = edge_swipe_data->fingers;
2634 edge = edge_swipe_data->edge;
2635 edge_size = edge_swipe_data->edge_size;
2636 start_point = edge_swipe_data->start_point;
2637 end_point = edge_swipe_data->end_point;
2640 tizen_gesture_grab_edge_swipe(_eflutil_defaultqueue.wl.gesture.proto, fingers, edge, edge_size, start_point, end_point);
2642 tizen_gesture_ungrab_edge_swipe(_eflutil_defaultqueue.wl.gesture.proto, fingers, edge, edge_size, start_point, end_point);
2644 ret = _efl_util_gesture_verify_request_notified();
2650 _efl_util_gesture_grab_edge_drag(efl_util_gesture_data data, Eina_Bool grabbed)
2652 int ret = EFL_UTIL_ERROR_NONE;
2653 Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
2654 Efl_Util_Gesture_Edge_Drag_Grab_Data *edge_drag_data = NULL;
2655 unsigned int fingers = 0;
2656 unsigned int edge = 0;
2657 unsigned int edge_size = 0;
2658 unsigned int start_point = 0;
2659 unsigned int end_point = 0;
2661 base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
2663 EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil_defaultqueue.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER);
2664 EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
2665 EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_EDGE_DRAG,
2666 EFL_UTIL_ERROR_INVALID_PARAMETER);
2668 edge_drag_data = (Efl_Util_Gesture_Edge_Drag_Grab_Data *)data;
2670 fingers = edge_drag_data->fingers;
2671 edge = edge_drag_data->edge;
2672 edge_size = edge_drag_data->edge_size;
2673 start_point = edge_drag_data->start_point;
2674 end_point = edge_drag_data->end_point;
2677 tizen_gesture_grab_edge_drag(_eflutil_defaultqueue.wl.gesture.proto, fingers, edge, edge_size, start_point, end_point);
2679 tizen_gesture_ungrab_edge_drag(_eflutil_defaultqueue.wl.gesture.proto, fingers, edge, edge_size, start_point, end_point);
2681 ret = _efl_util_gesture_verify_request_notified();
2687 _efl_util_gesture_grab_tap(efl_util_gesture_data data, Eina_Bool grabbed)
2689 int ret = EFL_UTIL_ERROR_NONE;
2690 Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
2691 Efl_Util_Gesture_Tap_Grab_Data *tap_data = NULL;
2692 unsigned int fingers = 0;
2693 unsigned int repeats = 0;
2695 base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
2697 EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil_defaultqueue.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER);
2698 EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
2699 EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_TAP,
2700 EFL_UTIL_ERROR_INVALID_PARAMETER);
2702 tap_data = (Efl_Util_Gesture_Tap_Grab_Data *)data;
2704 fingers = tap_data->fingers;
2705 repeats = tap_data->repeats;
2708 tizen_gesture_grab_tap(_eflutil_defaultqueue.wl.gesture.proto, fingers, repeats);
2710 tizen_gesture_ungrab_tap(_eflutil_defaultqueue.wl.gesture.proto, fingers, repeats);
2712 ret = _efl_util_gesture_verify_request_notified();
2718 _efl_util_gesture_grab_palm_cover(efl_util_gesture_data data, Eina_Bool grabbed)
2720 int ret = EFL_UTIL_ERROR_NONE;
2721 Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
2723 base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
2725 EINA_SAFETY_ON_NULL_RETURN_VAL(_eflutil_defaultqueue.wl.gesture.proto, EFL_UTIL_ERROR_INVALID_PARAMETER);
2726 EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
2727 EINA_SAFETY_ON_FALSE_RETURN_VAL(base_data->type == TIZEN_GESTURE_TYPE_PALM_COVER,
2728 EFL_UTIL_ERROR_INVALID_PARAMETER);
2731 tizen_gesture_grab_palm_cover(_eflutil_defaultqueue.wl.gesture.proto);
2733 tizen_gesture_ungrab_palm_cover(_eflutil_defaultqueue.wl.gesture.proto);
2735 ret = _efl_util_gesture_verify_request_notified();
2739 /* LCOV_EXCL_STOP */
2741 API efl_util_gesture_h
2742 efl_util_gesture_initialize(void)
2744 efl_util_gesture_h gesture_h = NULL;
2746 gesture_h = (efl_util_gesture_h)calloc(1, sizeof(struct _efl_util_gesture_h));
2749 set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); /* LCOV_EXCL_LINE */
2750 goto out; /* LCOV_EXCL_LINE */
2753 if (_wl_init_default_queue() == (int)EINA_FALSE)
2755 set_last_result(EFL_UTIL_ERROR_NOT_SUPPORTED); /* LCOV_EXCL_LINE */
2756 goto out; /* LCOV_EXCL_LINE */
2759 while (!_eflutil_defaultqueue.wl.gesture.proto)
2760 wl_display_dispatch(_eflutil_defaultqueue.wl.dpy); /* LCOV_EXCL_LINE */
2762 if (_eflutil_defaultqueue.wl.gesture.event_init <= 0)
2764 if (ecore_event_init() <= 0)
2766 set_last_result(EFL_UTIL_ERROR_NOT_SUPPORTED); /* LCOV_EXCL_LINE */
2767 goto out; /* LCOV_EXCL_LINE */
2769 EFL_UTIL_EVENT_GESTURE_EDGE_SWIPE = ecore_event_type_new();
2770 EFL_UTIL_EVENT_GESTURE_EDGE_DRAG = ecore_event_type_new();
2771 EFL_UTIL_EVENT_GESTURE_TAP = ecore_event_type_new();
2772 EFL_UTIL_EVENT_GESTURE_PALM_COVER = ecore_event_type_new();
2774 _eflutil_defaultqueue.wl.gesture.event_init++;
2775 gesture_h->init = EINA_TRUE;
2777 set_last_result(EFL_UTIL_ERROR_NONE);
2781 /* LCOV_EXCL_START */
2788 /* LCOV_EXCL_STOP */
2792 efl_util_gesture_deinitialize(efl_util_gesture_h gesture_h)
2794 EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
2795 EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER);
2800 _eflutil_defaultqueue.wl.gesture.event_init--;
2802 if (_eflutil_defaultqueue.wl.gesture.event_init <= 0)
2804 _eflutil_defaultqueue.wl.gesture.event_init = 0;
2805 ecore_event_shutdown();
2806 EFL_UTIL_EVENT_GESTURE_EDGE_SWIPE = 0;
2807 EFL_UTIL_EVENT_GESTURE_EDGE_DRAG = 0;
2808 EFL_UTIL_EVENT_GESTURE_TAP = 0;
2809 EFL_UTIL_EVENT_GESTURE_PALM_COVER = 0;
2812 return EFL_UTIL_ERROR_NONE;
2815 API efl_util_gesture_data
2816 efl_util_gesture_edge_swipe_new(efl_util_gesture_h gesture_h, unsigned int fingers, efl_util_gesture_edge_e edge)
2818 Efl_Util_Gesture_Edge_Swipe_Grab_Data *data;
2820 if (!gesture_h || gesture_h->init == EINA_FALSE)
2822 set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
2826 if (edge <= EFL_UTIL_GESTURE_EDGE_NONE || edge > EFL_UTIL_GESTURE_EDGE_LEFT)
2828 set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
2832 data = (Efl_Util_Gesture_Edge_Swipe_Grab_Data *)calloc(1, sizeof(Efl_Util_Gesture_Edge_Swipe_Grab_Data));
2835 set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); /* LCOV_EXCL_LINE */
2836 return NULL; /* LCOV_EXCL_LINE */
2839 data->base.type = TIZEN_GESTURE_TYPE_EDGE_SWIPE;
2840 data->fingers = fingers;
2842 data->edge_size = EFL_UTIL_GESTURE_EDGE_SIZE_FULL;
2844 set_last_result(EFL_UTIL_ERROR_NONE);
2846 return (void *)data;
2850 efl_util_gesture_edge_swipe_free(efl_util_gesture_h gesture_h, efl_util_gesture_data data)
2852 if (!gesture_h || gesture_h->init == EINA_FALSE)
2854 return EFL_UTIL_ERROR_INVALID_PARAMETER;
2859 return EFL_UTIL_ERROR_INVALID_PARAMETER;
2865 return EFL_UTIL_ERROR_NONE;
2869 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)
2871 Efl_Util_Gesture_Edge_Swipe_Grab_Data *edge_swipe_data = data;
2873 EINA_SAFETY_ON_NULL_RETURN_VAL(edge_swipe_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
2874 EINA_SAFETY_ON_FALSE_RETURN_VAL(edge_swipe_data->base.type == TIZEN_GESTURE_TYPE_EDGE_SWIPE,
2875 EFL_UTIL_ERROR_INVALID_PARAMETER);
2876 EINA_SAFETY_ON_FALSE_RETURN_VAL(edge_size == EFL_UTIL_GESTURE_EDGE_SIZE_PARTIAL,
2877 EFL_UTIL_ERROR_INVALID_PARAMETER);
2878 EINA_SAFETY_ON_FALSE_RETURN_VAL(end_point > start_point, EFL_UTIL_ERROR_INVALID_PARAMETER);
2880 edge_swipe_data->edge_size = edge_size;
2881 edge_swipe_data->start_point = start_point;
2882 edge_swipe_data->end_point = end_point;
2884 return EFL_UTIL_ERROR_NONE;
2887 API efl_util_gesture_data
2888 efl_util_gesture_edge_drag_new(efl_util_gesture_h gesture_h, unsigned int fingers, efl_util_gesture_edge_e edge)
2890 Efl_Util_Gesture_Edge_Drag_Grab_Data *data;
2892 if (!gesture_h || gesture_h->init == EINA_FALSE)
2894 set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
2898 if (edge <= EFL_UTIL_GESTURE_EDGE_NONE || edge > EFL_UTIL_GESTURE_EDGE_LEFT)
2900 set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
2904 data = (Efl_Util_Gesture_Edge_Drag_Grab_Data *)calloc(1, sizeof(Efl_Util_Gesture_Edge_Drag_Grab_Data));
2907 set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); /* LCOV_EXCL_LINE */
2908 return NULL; /* LCOV_EXCL_LINE */
2911 data->base.type = TIZEN_GESTURE_TYPE_EDGE_DRAG;
2912 data->fingers = fingers;
2914 data->edge_size = EFL_UTIL_GESTURE_EDGE_SIZE_FULL;
2916 set_last_result(EFL_UTIL_ERROR_NONE);
2918 return (void *)data;
2922 efl_util_gesture_edge_drag_free(efl_util_gesture_h gesture_h, efl_util_gesture_data data)
2924 if (!gesture_h || gesture_h->init == EINA_FALSE)
2926 return EFL_UTIL_ERROR_INVALID_PARAMETER;
2931 return EFL_UTIL_ERROR_INVALID_PARAMETER;
2937 return EFL_UTIL_ERROR_NONE;
2941 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)
2943 Efl_Util_Gesture_Edge_Drag_Grab_Data *edge_drag_data = data;
2945 EINA_SAFETY_ON_NULL_RETURN_VAL(edge_drag_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
2946 EINA_SAFETY_ON_FALSE_RETURN_VAL(edge_drag_data->base.type == TIZEN_GESTURE_TYPE_EDGE_DRAG,
2947 EFL_UTIL_ERROR_INVALID_PARAMETER);
2948 EINA_SAFETY_ON_FALSE_RETURN_VAL(edge_size == EFL_UTIL_GESTURE_EDGE_SIZE_PARTIAL,
2949 EFL_UTIL_ERROR_INVALID_PARAMETER);
2950 EINA_SAFETY_ON_FALSE_RETURN_VAL(end_point > start_point, EFL_UTIL_ERROR_INVALID_PARAMETER);
2952 edge_drag_data->edge_size = edge_size;
2953 edge_drag_data->start_point = start_point;
2954 edge_drag_data->end_point = end_point;
2956 return EFL_UTIL_ERROR_NONE;
2959 API efl_util_gesture_data
2960 efl_util_gesture_tap_new(efl_util_gesture_h gesture_h, unsigned int fingers, unsigned int repeats)
2962 Efl_Util_Gesture_Tap_Grab_Data *data;
2964 if (!gesture_h || gesture_h->init == EINA_FALSE)
2966 set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
2970 if (fingers <= 1 || repeats <= 1)
2972 set_last_result(EFL_UTIL_ERROR_NOT_SUPPORTED);
2976 data = (Efl_Util_Gesture_Tap_Grab_Data *)calloc(1, sizeof(Efl_Util_Gesture_Tap_Grab_Data));
2979 set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); /* LCOV_EXCL_LINE */
2980 return NULL; /* LCOV_EXCL_LINE */
2983 data->base.type = TIZEN_GESTURE_TYPE_TAP;
2984 data->fingers = fingers;
2985 data->repeats = repeats;
2987 set_last_result(EFL_UTIL_ERROR_NONE);
2989 return (void *)data;
2993 efl_util_gesture_tap_free(efl_util_gesture_h gesture_h, efl_util_gesture_data data)
2995 if (!gesture_h || gesture_h->init == EINA_FALSE)
2997 return EFL_UTIL_ERROR_INVALID_PARAMETER;
3002 return EFL_UTIL_ERROR_INVALID_PARAMETER;
3008 return EFL_UTIL_ERROR_NONE;
3011 API efl_util_gesture_data
3012 efl_util_gesture_palm_cover_new(efl_util_gesture_h gesture_h)
3014 Efl_Util_Gesture_Palm_Cover_Grab_Data *data;
3016 if (!gesture_h || gesture_h->init == EINA_FALSE)
3018 set_last_result(EFL_UTIL_ERROR_INVALID_PARAMETER);
3022 data = (Efl_Util_Gesture_Palm_Cover_Grab_Data *)calloc(1, sizeof(Efl_Util_Gesture_Palm_Cover_Grab_Data));
3025 set_last_result(EFL_UTIL_ERROR_OUT_OF_MEMORY); /* LCOV_EXCL_LINE */
3026 return NULL; /* LCOV_EXCL_LINE */
3029 data->base.type = TIZEN_GESTURE_TYPE_PALM_COVER;
3031 set_last_result(EFL_UTIL_ERROR_NONE);
3033 return (void *)data;
3037 efl_util_gesture_palm_cover_free(efl_util_gesture_h gesture_h, efl_util_gesture_data data)
3039 if (!gesture_h || gesture_h->init == EINA_FALSE)
3041 return EFL_UTIL_ERROR_INVALID_PARAMETER;
3046 return EFL_UTIL_ERROR_INVALID_PARAMETER;
3052 return EFL_UTIL_ERROR_NONE;
3055 /* LCOV_EXCL_START */
3057 efl_util_gesture_grab(efl_util_gesture_h gesture_h, efl_util_gesture_data data)
3059 int ret = EFL_UTIL_ERROR_NONE;
3060 Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
3062 base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
3064 EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
3065 EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER);
3066 EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
3068 switch (base_data->type)
3070 case TIZEN_GESTURE_TYPE_EDGE_SWIPE:
3071 ret = _efl_util_gesture_grab_edge_swipe(data, EINA_TRUE);
3073 case TIZEN_GESTURE_TYPE_EDGE_DRAG:
3074 ret = _efl_util_gesture_grab_edge_drag(data, EINA_TRUE);
3076 case TIZEN_GESTURE_TYPE_TAP:
3077 ret = _efl_util_gesture_grab_tap(data, EINA_TRUE);
3079 case TIZEN_GESTURE_TYPE_PALM_COVER:
3080 ret = _efl_util_gesture_grab_palm_cover(data, EINA_TRUE);
3083 return EFL_UTIL_ERROR_INVALID_PARAMETER;
3090 efl_util_gesture_ungrab(efl_util_gesture_h gesture_h, efl_util_gesture_data data)
3092 int ret = EFL_UTIL_ERROR_NONE;
3093 Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
3095 base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
3097 EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
3098 EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER);
3099 EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
3101 switch (base_data->type)
3103 case TIZEN_GESTURE_TYPE_EDGE_SWIPE:
3104 ret = _efl_util_gesture_grab_edge_swipe(data, EINA_FALSE);
3106 case TIZEN_GESTURE_TYPE_EDGE_DRAG:
3107 ret = _efl_util_gesture_grab_edge_drag(data, EINA_FALSE);
3109 case TIZEN_GESTURE_TYPE_TAP:
3110 ret = _efl_util_gesture_grab_tap(data, EINA_FALSE);
3112 case TIZEN_GESTURE_TYPE_PALM_COVER:
3113 ret = _efl_util_gesture_grab_palm_cover(data, EINA_FALSE);
3116 return EFL_UTIL_ERROR_INVALID_PARAMETER;
3121 /* LCOV_EXCL_STOP */
3124 efl_util_gesture_select(efl_util_gesture_h gesture_h, Evas_Object *window, efl_util_gesture_data data)
3126 Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
3127 Ecore_Wl2_Window *wlwin;
3128 struct wl_surface *surface;
3131 base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
3133 EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
3134 EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER);
3135 EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER);
3136 EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
3138 if (base_data->type != TIZEN_GESTURE_TYPE_PALM_COVER)
3139 return EFL_UTIL_ERROR_NOT_SUPPORTED;
3141 wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window);
3142 if (!wlwin) return EFL_UTIL_ERROR_INVALID_PARAMETER;
3144 surface = ecore_wl2_window_surface_get(wlwin);
3145 EINA_SAFETY_ON_NULL_RETURN_VAL(surface,
3146 EFL_UTIL_ERROR_INVALID_PARAMETER);
3148 tizen_gesture_select_palm_cover(_eflutil_defaultqueue.wl.gesture.proto, surface);
3150 ret = _efl_util_gesture_verify_request_notified();
3156 efl_util_gesture_deselect(efl_util_gesture_h gesture_h, Evas_Object *window, efl_util_gesture_data data)
3158 Efl_Util_Gesture_Common_Grab_Data *base_data = NULL;
3159 Ecore_Wl2_Window *wlwin;
3160 struct wl_surface *surface;
3163 base_data = (Efl_Util_Gesture_Common_Grab_Data *)data;
3165 EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
3166 EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER);
3167 EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER);
3168 EINA_SAFETY_ON_NULL_RETURN_VAL(base_data, EFL_UTIL_ERROR_INVALID_PARAMETER);
3170 if (base_data->type != TIZEN_GESTURE_TYPE_PALM_COVER)
3171 return EFL_UTIL_ERROR_NOT_SUPPORTED;
3173 wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window);
3174 if (!wlwin) return EFL_UTIL_ERROR_INVALID_PARAMETER;
3176 surface = ecore_wl2_window_surface_get(wlwin);
3177 EINA_SAFETY_ON_NULL_RETURN_VAL(surface,
3178 EFL_UTIL_ERROR_INVALID_PARAMETER);
3180 tizen_gesture_deselect_palm_cover(_eflutil_defaultqueue.wl.gesture.proto, surface);
3182 ret = _efl_util_gesture_verify_request_notified();
3187 /* LCOV_EXCL_START */
3189 efl_util_gesture_activate_set(efl_util_gesture_h gesture_h, unsigned int type, Eina_Bool active)
3193 EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
3194 EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER);
3195 EINA_SAFETY_ON_TRUE_RETURN_VAL(type == EFL_UTIL_GESTURE_TYPE_NONE, EFL_UTIL_ERROR_INVALID_PARAMETER);
3197 tizen_gesture_activate_set(_eflutil_defaultqueue.wl.gesture.proto, NULL, type, active);
3199 ret = _efl_util_gesture_verify_request_notified();
3203 /* LCOV_EXCL_STOP */
3206 efl_util_gesture_activate_set_on_window(efl_util_gesture_h gesture_h, Evas_Object *window, unsigned int type, Eina_Bool active)
3208 Ecore_Wl2_Window *wlwin;
3209 struct wl_surface *surface;
3212 EINA_SAFETY_ON_NULL_RETURN_VAL(gesture_h, EFL_UTIL_ERROR_INVALID_PARAMETER);
3213 EINA_SAFETY_ON_FALSE_RETURN_VAL(gesture_h->init, EFL_UTIL_ERROR_INVALID_PARAMETER);
3214 EINA_SAFETY_ON_NULL_RETURN_VAL(window, EFL_UTIL_ERROR_INVALID_PARAMETER);
3215 EINA_SAFETY_ON_TRUE_RETURN_VAL(type == EFL_UTIL_GESTURE_TYPE_NONE, EFL_UTIL_ERROR_INVALID_PARAMETER);
3217 wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(window);
3218 if (!wlwin) return EFL_UTIL_ERROR_INVALID_PARAMETER;
3220 surface = ecore_wl2_window_surface_get(wlwin);
3221 EINA_SAFETY_ON_NULL_RETURN_VAL(surface,
3222 EFL_UTIL_ERROR_INVALID_PARAMETER);
3224 tizen_gesture_activate_set(_eflutil_defaultqueue.wl.gesture.proto, surface, type, active);
3226 ret = _efl_util_gesture_verify_request_notified();