2 # include "elementary_config.h"
5 #define EFL_ACCESS_OBJECT_PROTECTED
6 #define EFL_ACCESS_COMPONENT_PROTECTED
7 #define EFL_ACCESS_WIDGET_ACTION_PROTECTED
8 #define EFL_INPUT_EVENT_PROTECTED
9 #define EFL_GFX_HINT_PROTECTED
10 #define EFL_CANVAS_OBJECT_PROTECTED
11 #define EFL_UI_L10N_PROTECTED
12 #define EFL_UI_WIN_INLINED_PROTECTED
13 #define EFL_UI_FOCUS_OBJECT_PROTECTED
14 #define EFL_UI_WIDGET_FOCUS_MANAGER_PROTECTED
15 #define EFL_PART_PROTECTED
16 #define IPA_YLNO_ESU_LANRETNI_MLE
18 #include <Elementary.h>
19 #include <Elementary_Cursor.h>
21 #include "efl_tracing.h"
24 #include "elm_widget_menu.h"
25 #ifdef HAVE_ELEMENTARY_WL2
26 # include "ecore_evas_wayland_private.h"
29 #include "../evas/canvas/evas_box_eo.h"
31 #include "elm_part_helper.h"
32 #include "efl_ui_win_part.eo.h"
33 #include "elm_plug_eo.h"
34 #include "efl_ui_win_legacy_eo.h"
35 #include "efl_ui_win_socket_legacy_eo.h"
36 #include "efl_ui_win_inlined_legacy_eo.h"
37 #include "efl_ui_widget_common.h"
39 #define MY_CLASS EFL_UI_WIN_CLASS
40 #define MY_CLASS_NAME "Efl.Ui.Win"
41 #define MY_CLASS_NAME_LEGACY "elm_win"
43 #define FRAME_OBJ_THEME_MIN_VERSION 119
45 extern void ecore_evas_dnd_mark_motion_used(Ecore_Evas *ee, unsigned int seat);
47 Ecore_Evas *_wayland_shm_new(const char *disp_name, Ecore_Window parent, int x, int y, int w, int h, Eina_Bool frame);
48 Ecore_Evas *_wayland_egl_new(const char *disp_name, Ecore_Window parent, int x, int y, int w, int h, Eina_Bool frame, const int *opt);
50 static const Elm_Win_Trap *trap = NULL;
52 static int _paused_windows = 0;
54 #define TRAP(sd, name, ...) \
57 if (sd->type != EFL_UI_WIN_TYPE_FAKE) \
58 if ((!trap) || (!trap->name) || \
60 (trap->name(sd->trap_data, sd->obj, ## __VA_ARGS__)))) \
61 ecore_evas_##name(sd->ee, ##__VA_ARGS__); \
65 #define ELM_WIN_DATA_GET(o, sd) \
66 Efl_Ui_Win_Data *sd = efl_data_scope_get(o, MY_CLASS)
68 #define ELM_WIN_DATA_GET_OR_RETURN(o, ptr, ...) \
69 ELM_WIN_DATA_GET(o, ptr); \
72 ERR("No widget data for object %p (%s)", \
73 o, efl_class_name_get(o)); \
77 // Ecore_Evas callbacks are unsafe unlike EO calls. As a consequence a user
78 // callback (eg evas cb, efl event cb, ...) could be triggered that deletes the
79 // object. This macro ensures the sd data is still valid after a foreign call.
80 #define ELM_WIN_DATA_ALIVE_CHECK(_obj, _sd, ...) do { \
81 _sd = efl_data_scope_safe_get(_obj, MY_CLASS); \
82 if (EINA_UNLIKELY(!(_sd))) { return __VA_ARGS__; } \
85 #define ENGINE_GET() (_elm_preferred_engine ? _elm_preferred_engine : _elm_config->engine)
87 typedef struct _Efl_Ui_Win_Data Efl_Ui_Win_Data;
88 typedef struct _Input_Pointer_Iterator Input_Pointer_Iterator;
90 struct _Efl_Ui_Win_Data
94 Evas_Object *parent; /* parent *window* object*/
95 Evas_Object *img_obj, *frame_obj;
96 Eo /* wref */ *bg, *content;
97 Evas_Object *obj; /* The object itself */
98 Evas_Object *indicator;
99 #ifdef HAVE_ELEMENTARY_X
103 Ecore_Event_Handler *client_message_handler;
104 Ecore_Event_Handler *property_handler;
105 Eina_Bool shaped : 1;
108 #ifdef HAVE_ELEMENTARY_WL2
111 Ecore_Wl2_Window *win;
112 Ecore_Event_Handler *configure_handler;
114 //TIZEN_ONLY(20171110): added signal for effect start and done
115 Ecore_Event_Handler *effect_start_handler;
116 Ecore_Event_Handler *effect_end_handler;
118 // TIZEN_ONLY(20160801): indicator implementation
119 Ecore_Event_Handler *indicator_flick_handler;
121 // TIZEN_ONLY(20150722): added signal for aux_hint(auxiliary hint)
122 Ecore_Event_Handler *aux_msg_handler;
126 #ifdef HAVE_ELEMENTARY_COCOA
128 Ecore_Cocoa_Window *win;
131 #ifdef HAVE_ELEMENTARY_WIN32
134 Ecore_Win32_Window *win;
135 Ecore_Event_Handler *key_down_handler;
139 unsigned /* Efl_Ui_Win_Type */ type;
140 Efl_Ui_Win_Keyboard_Mode kbdmode;
141 Efl_Ui_Win_Indicator_Mode indimode;
142 // TIZEN_ONLY(20150707): elm_conform for wayland, and signal if parts are changed
153 int *autodel_clear, rot;
160 #ifdef HAVE_ELEMENTARY_WL2
161 Ecore_Wl2_Window *win;
162 struct wl_surface *surf;
167 Eina_Bool visible : 1;
171 Evas_Object *fobj; /* focus highlight edje object */
176 Eina_Bool visible : 1;
177 Eina_Bool in_theme: 1; /**< focus highlight is handled by theme.
178 this is set true if edc data item "focus_highlight" is set to "on" during focus in callback. */
182 Ecore_Job *reconf_job;
184 Eina_Bool enabled : 1;
185 Eina_Bool theme_changed : 1; /* set true when the focus theme is changed */
186 Eina_Bool animate : 1; /* set true when the focus highlight animate is enabled */
187 Eina_Bool animate_supported : 1; /* set true when the focus highlight animate is supported by theme */
188 Eina_Bool geometry_changed : 1;
189 Eina_Bool auto_enabled : 1;
190 Eina_Bool auto_animate : 1;
193 // TIZEN_ONLY(20171114) Accessibility Highlight Frame added
196 // Evas_Object *fobj; /*accessibility highlight edje object */
197 // Evas_Object *target;
198 // Eina_Bool enabled;
199 Evas_Object *fobj; /* accessibility highlight edje object */
204 //TIZEN_ONLY(20160623): atspi: moved highlight when object is out of screen
209 Eina_Bool need_moved;
213 } accessibility_highlight;
215 //TIZEN_ONLY(20170919): Handle default label object
216 Eina_List *default_label_objs;
220 const char *icon_name;
222 const char *stack_id;
223 const char *stack_master_id;
224 Eina_Stringshare *name;
225 Eina_Stringshare *accel_pref;
227 //TIZEN_ONLY(20230302): Added frontbuffer API
228 Eina_Bool use_frontbuffer;
230 Eina_Future *finalize_future;
232 Evas_Object *main_menu;
234 Efl_Ui_Focus_Parent_Provider_Standard *provider;
238 Eina_Stringshare *name; /* Current profile in use */
239 Eina_Array *available; /* Never NULL, contains Eina_Stringshare */
243 int preferred_rot; /* indicates preferred rotation value, -1 means invalid. */
244 int *rots; /* indicates available rotations */
245 unsigned int count; /* number of elements in available rotations */
246 Eina_Bool wm_supported : 1; /* set true when the window manager support window rotation */
247 Eina_Bool use : 1; /* set true when application use window manager rotation. */
248 // TIZEN_ONLY(20170212): pend rotation until app set rotation
249 Eina_Bool rotation_pending : 1; /* set true when application will manage the rotation */
255 double aspect; /* defined as w/h or 0 */
256 int size_base_w, size_base_h;
257 int size_step_w, size_step_h;
258 int req_x, req_y, req_w, req_h;
263 Eina_Bool req_wh : 1;
264 Eina_Bool req_xy : 1;
265 Eina_Array *selection_changed;
266 Eina_Array *planned_changes;
267 Eina_Inarray *drop_target;
275 short pointer_cancel;
286 short object_focus_in;
287 short object_focus_out;
288 short device_changed;
292 /* frame_obj is always used except for FAKE */
293 Eina_Bool need : 1; /**< if true, application draws its own csd */
294 Eina_Bool need_shadow : 1; /**< if true, application draws its csd and shadow */
295 Eina_Bool need_borderless : 1;
296 Eina_Bool need_bg_solid : 1;
297 Eina_Bool need_bg_standard : 1;
298 Eina_Bool need_menu : 1;
299 Eina_Bool need_unresizable : 1;
300 Eina_Bool need_indicator : 1;
301 Eina_Bool cur_borderless : 1;
302 Eina_Bool cur_shadow : 1;
303 Eina_Bool cur_focus : 1;
304 Eina_Bool cur_maximized : 1;
305 Eina_Bool cur_bg_solid : 1;
306 Eina_Bool cur_bg_standard : 1;
307 Eina_Bool cur_menu : 1;
308 Eina_Bool cur_unresizable : 1;
309 Eina_Bool cur_indicator : 1;
310 Eina_Bool wayland : 1;
314 Evas_Object *box, *edje;
315 Elm_Win_Indicator_Mode indmode;
316 Elm_Win_Indicator_Opacity_Mode ind_o_mode;
317 Eina_Bool forbidden : 1; /**< Marks some legacy APIs as not allowed. */
318 Eina_Bool bg_must_swallow : 1; /**< Legacy theme compatibility (elm_bg for standard window) */
319 Eina_Bool bg_must_swallow_init : 1;
320 Eina_Bool ctor : 1; /**< legacy constructor: elm_win~add */
322 Efl_Ui_Shared_Win_Data spd;
324 Eina_Value exit_on_close;
326 Eina_Bool first_draw : 1;
327 Eina_Bool deferred_resize_job : 1;
328 Eina_Bool urgent : 1;
330 Eina_Bool demand_attention : 1;
331 Eina_Bool autodel : 1;
332 Eina_Bool autohide : 1;
333 Eina_Bool constrain : 1;
334 Eina_Bool resizing : 1;
335 Eina_Bool minimized : 1;
336 Eina_Bool withdrawn : 1;
337 Eina_Bool sticky : 1;
338 Eina_Bool fullscreen : 1;
339 Eina_Bool maximized : 1;
340 Eina_Bool skip_focus : 1;
341 Eina_Bool floating : 1;
342 Eina_Bool noblank : 1;
343 Eina_Bool theme_alpha : 1; /**< alpha value fetched by a theme. this has higher priority than application_alpha */
344 Eina_Bool application_alpha : 1; /**< alpha value set by an elm_win_alpha_set() api. this has lower priority than theme_alpha */
345 Eina_Bool tmp_updating_hints : 1;
346 Eina_Bool single_edje_content: 1; /* hack for E */
348 Eina_Bool stack_base : 1;
349 Eina_Bool paused : 1;
351 // TIZEN_ONLY(20160120): support visibility_change event
352 Eina_Bool obscured : 1;
356 struct _Input_Pointer_Iterator
358 Eina_Iterator iterator;
360 Eina_Iterator *real_iterator;
364 static const char SIG_DELETE_REQUEST[] = "delete,request";
365 static const char SIG_FOCUS_OUT[] = "focus,out"; // deprecated. use "unfocused" instead.
366 static const char SIG_FOCUS_IN[] = "focus,in"; // deprecated. use "focused" instead.
367 static const char SIG_MOVED[] = "moved";
368 static const char SIG_WITHDRAWN[] = "withdrawn";
369 static const char SIG_MINIMIZED[] = "minimized";
370 static const char SIG_NORMAL[] = "normal";
371 static const char SIG_STICK[] = "stick";
372 static const char SIG_UNSTICK[] = "unstick";
373 static const char SIG_FULLSCREEN[] = "fullscreen";
374 static const char SIG_UNFULLSCREEN[] = "unfullscreen";
375 static const char SIG_MAXIMIZED[] = "maximized";
376 static const char SIG_UNMAXIMIZED[] = "unmaximized";
377 static const char SIG_IOERR[] = "ioerr";
378 static const char SIG_INDICATOR_PROP_CHANGED[] = "indicator,prop,changed";
379 static const char SIG_ROTATION_CHANGED[] = "rotation,changed";
380 static const char SIG_PROFILE_CHANGED[] = "profile,changed";
381 static const char SIG_WM_ROTATION_CHANGED[] = "wm,rotation,changed";
383 // TIZEN_ONLY(20160801): indicator implementation
384 #ifdef HAVE_ELEMENTARY_WL2
385 static const char SIG_INDICATOR_FLICK_DONE[] = "indicator,flick,done";
388 static const char SIG_EFFECT_STARTED[] = "effect,started";
389 static const char SIG_EFFECT_DONE[] = "effect,done";
391 //TIZEN_ONLY(20161028): add smart signal 'atspi,screen,reader,changed'
392 static const char SIG_ATSPI_SCREEN_READER_CHANGED[] = "atspi,screen,reader,changed";
394 // TIZEN_ONLY(20160120): support visibility_change event
395 static const char SIG_VISIBILITY_CHANGED[] = "visibility,changed";
397 //TIZEN_ONLY(20160704): added signal for launch
398 static const char SIG_LAUNCH_DONE[] = "launch,done";
400 // TIZEN_ONLY(20150722): added signal for aux_hint(auxiliary hint)
401 static const char SIG_AUX_HINT_ALLOWED[] = "aux,hint,allowed";
402 static const char SIG_AUX_MESSAGE_RECEIVED[] = "aux,msg,received";
404 // TIZEN_ONLY(20150707): elm_conform for wayland, and signal if parts are changed
405 static const char SIG_CONFORMANT_CHANGED[] = "conformant,changed";
408 static const Evas_Smart_Cb_Description _smart_callbacks[] = {
409 {SIG_DELETE_REQUEST, ""},
418 {SIG_FULLSCREEN, ""},
419 {SIG_UNFULLSCREEN, ""},
421 {SIG_UNMAXIMIZED, ""},
423 {SIG_INDICATOR_PROP_CHANGED, ""},
424 {SIG_ROTATION_CHANGED, ""},
425 {SIG_PROFILE_CHANGED, ""},
426 {SIG_WM_ROTATION_CHANGED, ""},
427 {SIG_WIDGET_FOCUSED, ""}, /**< handled by elm_widget */
428 {SIG_WIDGET_UNFOCUSED, ""}, /**< handled by elm_widget */
429 // TIZEN_ONLY(20150707): elm_conform for wayland, and signal if parts are changed
430 {SIG_CONFORMANT_CHANGED, ""},
431 {SIG_AUX_HINT_ALLOWED, ""},
432 {SIG_AUX_MESSAGE_RECEIVED, ""},
433 {SIG_EFFECT_STARTED, ""},
434 {SIG_EFFECT_DONE, ""},
435 {SIG_LAUNCH_DONE, ""},
437 //TIZEN_ONLY(20161028): add smart signal 'atspi,screen,reader,changed'
438 {SIG_ATSPI_SCREEN_READER_CHANGED, ""},
440 // TIZEN_ONLY(20150707): elm_conform for wayland, and signal if parts are changed
441 {SIG_VISIBILITY_CHANGED, ""},
446 static Eina_Bool _key_action_return(Evas_Object *obj, const char *params);
447 static Eina_Bool _key_action_move(Evas_Object *obj, const char *params);
448 // TIZEN_ONLY(20171114) Accessibility Highlight Frame added
449 // //TIZEN_ONLY(20171108): bring HIGHLIGHT related changes
450 // static void _elm_win_accessibility_highlight_shutdown(Efl_Ui_Win_Data *sd);
451 // static void _elm_win_accessibility_highlight_update(Efl_Ui_Win_Data *sd);
455 static const Elm_Action key_actions[] = {
456 {"return", _key_action_return},
457 {"move", _key_action_move},
461 Eina_List *_elm_win_list = NULL;
462 int _elm_win_deferred_free = 0;
463 static Eina_Value exit_on_all_windows_closed;
465 static Eina_Bool _elm_win_throttle_ok = EINA_FALSE;
466 static int _elm_win_count = 0;
468 // TIZEN_ONLY(20160218): Improve launching performance.
469 static Evas_Object *_precreated_win_obj = NULL;
472 static Eina_Bool _elm_win_auto_throttled = EINA_FALSE;
474 /*TIZEN_ONLY(20171113):Use ecore_job instead of ecore_timer
475 static Ecore_Timer *_elm_win_state_eval_timer = NULL;
477 static Ecore_Job *_elm_win_state_eval_job = NULL;
480 static void _elm_win_legacy_init(Efl_Ui_Win_Data *sd);
482 _elm_win_on_resize_obj_changed_size_hints(void *data,
487 _elm_win_img_callbacks_del(Evas_Object *obj, Evas_Object *imgobj);
488 static Eina_Error _elm_win_theme_internal(Eo *obj, Efl_Ui_Win_Data *sd);
489 static void _elm_win_frame_add(Efl_Ui_Win_Data *sd, const char *element, const char *style);
490 static void _elm_win_frame_style_update(Efl_Ui_Win_Data *sd, Eina_Bool force_emit, Eina_Bool calc);
491 static inline void _elm_win_need_frame_adjust(Efl_Ui_Win_Data *sd, const char *engine);
492 static void _elm_win_resize_objects_eval(Evas_Object *obj, Eina_Bool force_resize);
493 static void _elm_win_frame_obj_update(Efl_Ui_Win_Data *sd, Eina_Bool force);
494 static void _ee_backbone_init(Efl_Ui_Win *obj, Efl_Ui_Win_Data *pd);
495 static void _ee_backbone_shutdown(Efl_Ui_Win *obj, Efl_Ui_Win_Data *pd);
497 static inline Efl_Ui_Win_Type
498 _elm_win_type_to_efl_ui_win_type(Elm_Win_Type type)
502 #define CONVERT_TYPE(TYPE) case ELM_WIN_##TYPE: return EFL_UI_WIN_TYPE_##TYPE
504 CONVERT_TYPE(DIALOG_BASIC);
505 CONVERT_TYPE(DESKTOP);
507 CONVERT_TYPE(TOOLBAR);
509 CONVERT_TYPE(UTILITY);
510 CONVERT_TYPE(SPLASH);
511 CONVERT_TYPE(DROPDOWN_MENU);
512 CONVERT_TYPE(POPUP_MENU);
513 CONVERT_TYPE(TOOLTIP);
514 CONVERT_TYPE(NOTIFICATION);
517 CONVERT_TYPE(INLINED_IMAGE);
518 CONVERT_TYPE(SOCKET_IMAGE);
520 CONVERT_TYPE(NAVIFRAME_BASIC);
523 return EFL_UI_WIN_TYPE_UNKNOWN;
527 static inline Elm_Win_Type
528 _efl_ui_win_type_to_elm_win_type(Efl_Ui_Win_Type type)
532 //#define CONVERT_TYPE(TYPE) case EFL_UI_WIN_TYPE_##TYPE: return ELM_WIN_##TYPE
533 /*CONVERT_TYPE(BASIC);
534 CONVERT_TYPE(DIALOG_BASIC);
535 CONVERT_TYPE(DESKTOP);
537 CONVERT_TYPE(TOOLBAR);
539 CONVERT_TYPE(UTILITY);
540 CONVERT_TYPE(SPLASH);
541 CONVERT_TYPE(DROPDOWN_MENU);
542 CONVERT_TYPE(POPUP_MENU);
543 CONVERT_TYPE(TOOLTIP);
544 CONVERT_TYPE(NOTIFICATION);
547 CONVERT_TYPE(INLINED_IMAGE);
548 CONVERT_TYPE(SOCKET_IMAGE);
550 CONVERT_TYPE(NAVIFRAME_BASIC);*/
551 case EFL_UI_WIN_TYPE_BASIC: return ELM_WIN_BASIC;
552 case EFL_UI_WIN_TYPE_DIALOG_BASIC: return ELM_WIN_DIALOG_BASIC;
553 case EFL_UI_WIN_TYPE_DESKTOP: return ELM_WIN_DESKTOP;
554 case EFL_UI_WIN_TYPE_DOCK: return ELM_WIN_DOCK;
555 case EFL_UI_WIN_TYPE_TOOLBAR: return ELM_WIN_TOOLBAR;
556 case EFL_UI_WIN_TYPE_MENU: return ELM_WIN_MENU;
557 case EFL_UI_WIN_TYPE_UTILITY: return ELM_WIN_UTILITY;
558 case EFL_UI_WIN_TYPE_SPLASH: return ELM_WIN_SPLASH;
559 case EFL_UI_WIN_TYPE_DROPDOWN_MENU: return ELM_WIN_DROPDOWN_MENU;
560 case EFL_UI_WIN_TYPE_POPUP_MENU: return ELM_WIN_POPUP_MENU;
561 case EFL_UI_WIN_TYPE_TOOLTIP: return ELM_WIN_TOOLTIP;
562 case EFL_UI_WIN_TYPE_NOTIFICATION: return ELM_WIN_NOTIFICATION;
563 case EFL_UI_WIN_TYPE_COMBO: return ELM_WIN_COMBO;
564 case EFL_UI_WIN_TYPE_DND: return ELM_WIN_DND;
565 case EFL_UI_WIN_TYPE_INLINED_IMAGE: return ELM_WIN_INLINED_IMAGE;
566 case EFL_UI_WIN_TYPE_SOCKET_IMAGE: return ELM_WIN_SOCKET_IMAGE;
567 case EFL_UI_WIN_TYPE_FAKE: return ELM_WIN_FAKE;
568 case EFL_UI_WIN_TYPE_NAVIFRAME_BASIC: return ELM_WIN_NAVIFRAME_BASIC;
571 return ELM_WIN_UNKNOWN;
572 //#undef CONVERT_TYPE
575 #ifdef HAVE_ELEMENTARY_X
576 static void _elm_win_xwin_update(Efl_Ui_Win_Data *sd);
578 // TIZEN_ONLY(20160404) skip_focus in case invoking elm_win_quickpanel_set
579 static void _elm_win_focus_skip_set(Efl_Ui_Win_Data *sd, Eina_Bool skip);
582 EAPI double _elm_startup_time = 0;
585 _elm_win_first_frame_do(void *data, Evas *e EINA_UNUSED, void *event_info EINA_UNUSED)
587 double end = ecore_time_unix_get();
595 case 'T': fprintf(stderr, "Startup time: '%f' - '%f' = '%f' sec\n", end, _elm_startup_time, end - _elm_startup_time);
599 evas_event_callback_del_full(e, EVAS_CALLBACK_RENDER_POST, _elm_win_first_frame_do, data);
603 _elm_ee_xwin_get(const Ecore_Evas *ee)
605 #ifdef HAVE_ELEMENTARY_X
606 const char *engine_name;
609 engine_name = ecore_evas_engine_name_get(ee);
610 if (EINA_UNLIKELY(!engine_name)) return 0;
612 if (!strcmp(engine_name, ELM_SOFTWARE_X11))
614 return ecore_evas_software_x11_window_get(ee);
616 else if (!strcmp(engine_name, ELM_OPENGL_X11))
618 return ecore_evas_gl_x11_window_get(ee);
626 #ifdef HAVE_ELEMENTARY_X
628 _internal_elm_win_xwindow_get(Efl_Ui_Win_Data *sd)
630 Ecore_X_Window pwin = sd->x.xwin;
631 sd->x.xwin = _elm_ee_xwin_get(sd->ee);
632 if (sd->x.xwin != pwin)
636 snprintf(buf, sizeof(buf), "%x", sd->x.xwin);
637 eina_stringshare_del(sd->stack_id);
638 sd->stack_id = eina_stringshare_add(buf);
644 _elm_ee_wlwin_get(const Ecore_Evas *ee)
646 #ifdef HAVE_ELEMENTARY_WL2
647 const char *engine_name;
649 if (!ee) return NULL;
651 engine_name = ecore_evas_engine_name_get(ee);
652 if (EINA_UNLIKELY(!engine_name)) return NULL;
654 if ((!strcmp(engine_name, ELM_WAYLAND_SHM)) ||
655 (!strcmp(engine_name, ELM_WAYLAND_EGL)))
657 return ecore_evas_wayland2_window_get(ee);
666 _win_noblank_eval(void)
668 #ifdef HAVE_ELEMENTARY_X
672 Eina_Bool change = EINA_FALSE;
674 EINA_LIST_FOREACH(_elm_win_list, l, obj)
676 ELM_WIN_DATA_GET(obj, sd);
680 _internal_elm_win_xwindow_get(sd);
681 if ((sd->noblank) && (!sd->minimized) && (!sd->withdrawn) &&
682 evas_object_visible_get(obj))
691 if (noblanks > 0) ecore_x_screensaver_suspend();
692 else ecore_x_screensaver_resume();
694 #ifdef HAVE_ELEMENTARY_WL2
695 // XXX: no wl implementation of this yet - maybe higher up at prop level
699 static Elm_Process_State _elm_process_state = ELM_PROCESS_STATE_FOREGROUND;
701 EAPI Elm_Process_State
702 elm_process_state_get(void)
704 return _elm_process_state;
708 _elm_win_apply_alpha(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd)
714 enabled = sd->theme_alpha | sd->application_alpha;
717 evas_object_image_alpha_set(sd->img_obj, enabled);
718 ecore_evas_alpha_set(sd->ee, enabled);
722 #ifdef HAVE_ELEMENTARY_X
725 _internal_elm_win_xwindow_get(sd);
726 enabled |= (sd->csd.need && !sd->fullscreen);
727 if (!ecore_x_screen_is_composited(0))
729 if (enabled || (!sd->x.shaped))
730 TRAP(sd, shaped_set, enabled);
733 TRAP(sd, alpha_set, enabled);
739 TRAP(sd, alpha_set, enabled);
743 /* auto norender withdrawn is really only for X11.
744 * On other backends like wayland, there's actually
745 * no way for a client to tell if the window is
746 * minimized or not. You can request minimized state
747 * but there's no explicit feedback for minimization
748 * or return to normal state.
750 * So, blocking drawing based on client side thinking
751 * it's minimized, and having the compositor think
752 * the client should be drawing will lead to
753 * predictably disappointing results.
755 * If you maintain a backend that is really capable
756 * of handling this properly, feel free to extend
760 _elm_win_auto_norender_withdrawn(const Evas_Object *obj)
763 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
766 return _elm_config->auto_norender_withdrawn;
768 engine = ecore_evas_engine_name_get(sd->ee);
769 //TIZEN_ONLY(20191119): Tizen Wayland has own policy listener for it.
770 //if (!strcmp(engine, ELM_SOFTWARE_X11) || !strcmp(engine, ELM_OPENGL_X11))
771 if (!strcmp(engine, ELM_WAYLAND_EGL) || !strcmp(engine, ELM_SOFTWARE_X11) || !strcmp(engine, ELM_OPENGL_X11))
773 return _elm_config->auto_norender_withdrawn;
779 _elm_win_state_eval(void *data EINA_UNUSED)
783 int _elm_win_count_shown = 0;
784 int _elm_win_count_minimized = 0;
785 int _elm_win_count_withdrawn = 0;
786 Eina_Bool throttle = EINA_FALSE;
788 /*TIZEN_ONLY(20171113):Use ecore_job instead of ecore_timer
789 _elm_win_state_eval_timer = NULL;
791 _elm_win_state_eval_job = NULL;
794 EINA_LIST_FOREACH(_elm_win_list, l, obj)
796 if (_elm_win_auto_norender_withdrawn(obj))
798 if ((elm_win_withdrawn_get(obj)) ||
799 ((elm_win_iconified_get(obj) &&
800 (_elm_config->auto_norender_iconified_same_as_withdrawn))))
802 if (!evas_object_data_get(obj, "__win_auto_norender"))
804 Evas *evas = evas_object_evas_get(obj);
806 elm_win_norender_push(obj);
807 evas_object_data_set(obj, "__win_auto_norender", obj);
809 if (_elm_config->auto_flush_withdrawn)
811 edje_file_cache_flush();
812 edje_collection_cache_flush();
813 evas_image_cache_flush(evas);
814 evas_font_cache_flush(evas);
816 if (_elm_config->auto_dump_withdrawn)
818 evas_render_dump(evas);
822 if (elm_win_iconified_get(obj))
823 efl_event_callback_call(obj, EFL_UI_WIN_EVENT_PAUSE, NULL);
827 if (evas_object_data_get(obj, "__win_auto_norender"))
829 elm_win_norender_pop(obj);
830 evas_object_data_del(obj, "__win_auto_norender");
833 if (((_elm_config->auto_throttle) &&
834 (elm_policy_get(ELM_POLICY_THROTTLE) != ELM_POLICY_THROTTLE_NEVER)) ||
835 (elm_policy_get(ELM_POLICY_THROTTLE) == ELM_POLICY_THROTTLE_HIDDEN_ALWAYS))
836 throttle = EINA_TRUE;
837 if (_elm_win_count == 0)
839 if ((_elm_win_throttle_ok) && (_elm_win_auto_throttled))
841 _elm_process_state = ELM_PROCESS_STATE_FOREGROUND;
842 ecore_event_add(ELM_EVENT_PROCESS_FOREGROUND, NULL, NULL, NULL);
844 ecore_throttle_adjust(-_elm_config->auto_throttle_amount);
845 _elm_win_auto_throttled = EINA_FALSE;
850 EINA_LIST_FOREACH(_elm_win_list, l, obj)
852 if (elm_win_withdrawn_get(obj)) _elm_win_count_withdrawn++;
853 else if (elm_win_iconified_get(obj)) _elm_win_count_minimized++;
854 else if (evas_object_visible_get(obj)) _elm_win_count_shown++;
856 if (_elm_win_count_shown <= 0)
858 if ((_elm_win_throttle_ok) && (!_elm_win_auto_throttled))
860 _elm_process_state = ELM_PROCESS_STATE_BACKGROUND;
861 ecore_event_add(ELM_EVENT_PROCESS_BACKGROUND, NULL, NULL, NULL);
863 ecore_throttle_adjust(_elm_config->auto_throttle_amount);
864 _elm_win_auto_throttled = EINA_TRUE;
869 if ((_elm_win_throttle_ok) && (_elm_win_auto_throttled))
871 _elm_process_state = ELM_PROCESS_STATE_FOREGROUND;
872 ecore_event_add(ELM_EVENT_PROCESS_FOREGROUND, NULL, NULL, NULL);
874 ecore_throttle_adjust(-_elm_config->auto_throttle_amount);
875 _elm_win_auto_throttled = EINA_FALSE;
883 _elm_win_policy_quit_triggered(Eo* triggering_obj)
885 if (elm_policy_get(ELM_POLICY_QUIT) == ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN)
890 EINA_LIST_FOREACH(_elm_win_list, l, win)
891 if (win != triggering_obj && evas_object_visible_get(win) == EINA_TRUE)
902 _elm_win_flush_cache_and_exit(Eo *obj)
904 edje_file_cache_flush();
905 edje_collection_cache_flush();
906 evas_image_cache_flush(evas_object_evas_get(obj));
907 evas_font_cache_flush(evas_object_evas_get(obj));
912 _elm_win_state_eval_queue(void)
914 /*TIZEN_ONLY(20171113):Use ecore_job instead of ecore_timer
915 if (_elm_win_state_eval_timer) ecore_timer_del(_elm_win_state_eval_timer);
916 _elm_win_state_eval_timer = ecore_timer_add(0.5, _elm_win_state_eval, NULL);
918 if (_elm_win_state_eval_job) ecore_job_del(_elm_win_state_eval_job);
919 _elm_win_state_eval_job = ecore_job_add(_elm_win_state_eval, NULL);
923 // example shot spec (wait 0.1 sec then save as my-window.png):
924 // ELM_ENGINE="shot:delay=0.1:file=my-window.png"
927 _shot_delay_get(Efl_Ui_Win_Data *sd)
930 char *d = strdup(sd->shot.info);
933 for (p = (char *)sd->shot.info; *p; p++)
935 if (!strncmp(p, "delay=", 6))
939 for (pd = d, p += 6; (*p) && (*p != ':'); p++, pd++)
955 _shot_file_get(Efl_Ui_Win_Data *sd)
958 char *tmp = strdup(sd->shot.info);
959 char *repname = NULL;
961 if (!tmp) return NULL;
963 for (p = (char *)sd->shot.info; *p; p++)
965 if (!strncmp(p, "file=", 5))
968 if (!sd->shot.repeat_count) return tmp;
971 char *dotptr = strrchr(tmp, '.');
974 size_t size = sizeof(char) * (strlen(tmp) + 16);
975 repname = malloc(size);
978 strncpy(repname, tmp, dotptr - tmp);
979 snprintf(repname + (dotptr - tmp), size -
980 (dotptr - tmp), "%03i",
981 sd->shot.shot_counter + 1);
982 strcat(repname, dotptr);
991 if (!sd->shot.repeat_count) return strdup("out.png");
993 repname = malloc(sizeof(char) * 24);
994 if (!repname) return NULL;
995 snprintf(repname, sizeof(char) * 24, "out%03i.png",
996 sd->shot.shot_counter + 1);
1002 _shot_repeat_count_get(Efl_Ui_Win_Data *sd)
1005 char *d = strdup(sd->shot.info);
1008 for (p = (char *)sd->shot.info; *p; p++)
1010 if (!strncmp(p, "repeat=", 7))
1014 for (pd = d, p += 7; (*p) && (*p != ':'); p++, pd++)
1021 if (v > 1000) v = 999;
1032 _shot_key_get(Efl_Ui_Win_Data *sd EINA_UNUSED)
1038 _shot_flags_get(Efl_Ui_Win_Data *sd EINA_UNUSED)
1044 _shot_do(Efl_Ui_Win_Data *sd)
1048 unsigned int *pixels;
1050 char *file, *key, *flags;
1052 ecore_evas_manual_render(sd->ee);
1053 pixels = (void *)ecore_evas_buffer_pixels_get(sd->ee);
1054 if (!pixels) return;
1056 ecore_evas_geometry_get(sd->ee, NULL, NULL, &w, &h);
1057 if ((w < 1) || (h < 1)) return;
1059 file = _shot_file_get(sd);
1062 key = _shot_key_get(sd);
1063 flags = _shot_flags_get(sd);
1064 ee = ecore_evas_buffer_new(1, 1);
1065 o = evas_object_image_add(ecore_evas_get(ee));
1066 evas_object_image_alpha_set(o,
1067 sd->theme_alpha | sd->application_alpha);
1068 evas_object_image_size_set(o, w, h);
1069 evas_object_image_data_set(o, pixels);
1070 if (!evas_object_image_save(o, file, key, flags))
1072 ERR("Cannot save window to '%s' (key '%s', flags '%s')",
1078 ecore_evas_free(ee);
1079 if (sd->shot.repeat_count) sd->shot.shot_counter++;
1083 _shot_delay(void *data)
1085 ELM_WIN_DATA_GET(data, sd);
1088 if (sd->shot.repeat_count)
1090 int remainshot = (sd->shot.repeat_count - sd->shot.shot_counter);
1091 if (remainshot > 0) return EINA_TRUE;
1093 sd->shot.timer = NULL;
1100 _shot_init(Efl_Ui_Win_Data *sd)
1102 if (!sd->shot.info) return;
1104 sd->shot.repeat_count = _shot_repeat_count_get(sd);
1105 sd->shot.shot_counter = 0;
1109 _shot_handle(Efl_Ui_Win_Data *sd)
1111 if (!sd->shot.info) return;
1113 if (!sd->shot.timer)
1114 sd->shot.timer = ecore_timer_add(_shot_delay_get(sd), _shot_delay,
1118 /* elm-win specific associate, does the trap while ecore_evas_object_associate()
1121 static Efl_Ui_Win_Data *
1122 _elm_win_associate_get(const Ecore_Evas *ee)
1124 Evas_Object *obj = ecore_evas_data_get(ee, "elm_win");
1125 return efl_data_scope_safe_get(obj, MY_CLASS);
1128 /* Interceptors Callbacks */
1130 _elm_win_obj_intercept_raise(void *data, Evas_Object *obj EINA_UNUSED)
1132 // Note: This is probably not necessary anymore (Win implements raise)
1133 ELM_WIN_DATA_GET(data, sd);
1138 _elm_win_obj_intercept_lower(void *data, Evas_Object *obj EINA_UNUSED)
1140 // Note: This is probably not necessary anymore (Win ignores lower)
1141 ELM_WIN_DATA_GET(data, sd);
1146 _elm_win_obj_intercept_stack_above(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, Evas_Object *above EINA_UNUSED)
1148 INF("TODO: %s", __func__);
1152 _elm_win_obj_intercept_stack_below(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, Evas_Object *below EINA_UNUSED)
1154 INF("TODO: %s", __func__);
1158 _elm_win_obj_intercept_layer_set(void *data, Evas_Object *obj EINA_UNUSED, int l)
1160 ELM_WIN_DATA_GET(data, sd);
1161 TRAP(sd, layer_set, l);
1164 /* Event Callbacks */
1167 _elm_win_size_hints_update(Efl_Ui_Win *win, Efl_Ui_Win_Data *sd)
1169 Eina_Size2D min, max;
1171 min = efl_gfx_hint_size_combined_min_get(win);
1172 max = efl_gfx_hint_size_combined_max_get(win);
1173 if (max.w < 1) max.w = -1;
1174 if (max.h < 1) max.h = -1;
1179 evas_output_framespace_get(sd->evas, NULL, NULL, &fw, &fh);
1183 /* TIZEN_ONLY(20230125): Disable automatic size_min/max_set.
1184 TRAP(sd, size_min_set, min.w, min.h);
1185 TRAP(sd, size_max_set, max.w, max.h);
1190 _elm_win_obj_callback_changed_size_hints(void *data EINA_UNUSED, Evas *e EINA_UNUSED,
1191 Evas_Object *obj, void *event_info EINA_UNUSED)
1193 ELM_WIN_DATA_GET(obj, sd);
1195 if (sd->tmp_updating_hints) return;
1196 _elm_win_size_hints_update(obj, sd);
1198 /* end of elm-win specific associate */
1201 _elm_win_move(Ecore_Evas *ee)
1203 Efl_Ui_Win_Data *sd = _elm_win_associate_get(ee);
1206 Eina_Position2D pos;
1211 ecore_evas_geometry_get(ee, &x, &y, NULL, NULL);
1212 pos.x = sd->screen.x = x;
1213 pos.y = sd->screen.y = y;
1214 efl_event_callback_call(sd->obj, EFL_GFX_ENTITY_EVENT_POSITION_CHANGED, &pos);
1215 evas_object_smart_callback_call(sd->obj, "move", NULL);
1216 ELM_WIN_DATA_ALIVE_CHECK(obj, sd);
1217 evas_nochange_push(evas_object_evas_get(sd->obj));
1219 sd->req_xy = EINA_FALSE;
1220 evas_object_move(sd->obj, x, y);
1221 ELM_WIN_DATA_ALIVE_CHECK(obj, sd);
1223 evas_nochange_pop(evas_object_evas_get(sd->obj));
1227 _elm_win_resize_job(void *data)
1229 ELM_WIN_DATA_GET(data, sd);
1232 sd->deferred_resize_job = EINA_FALSE;
1233 ecore_evas_geometry_get(sd->ee, NULL, NULL, &w, &h);
1237 ecore_evas_screen_geometry_get(sd->ee, NULL, NULL, &sw, &sh);
1246 evas_output_framespace_get(sd->evas, &fx, &fy, &fw, &fh);
1247 evas_object_geometry_set(sd->frame_obj, -fx, -fy, w + fw, h + fh);
1252 Eina_Position2D pos;
1254 pos = efl_gfx_entity_position_get(sd->main_menu);
1255 elm_menu_move(sd->main_menu, pos.x, pos.y);
1259 sd->req_wh = EINA_FALSE;
1260 evas_object_resize(sd->obj, w, h);
1261 evas_object_resize(sd->legacy.edje, w, h);
1266 _elm_win_pre_render(Ecore_Evas *ee)
1268 Efl_Ui_Win_Data *sd = _elm_win_associate_get(ee);
1274 _elm_win_throttle_ok = EINA_TRUE;
1275 if (!sd->first_draw)
1279 if (sd->type != EFL_UI_WIN_TYPE_FAKE)
1281 edje_object_thaw(sd->frame_obj);
1282 evas_object_show(sd->frame_obj);
1285 _elm_win_frame_style_update(sd, 1, 1);
1286 ELM_WIN_DATA_ALIVE_CHECK(obj, sd);
1290 /* force initial sizing on frame to enable sizing of content */
1291 edje_object_size_min_calc(sd->frame_obj, &mw, &mh);
1292 evas_object_resize(sd->frame_obj, mw, mh);
1297 evas_object_show(sd->img_obj);
1299 if (sd->pointer.obj) evas_object_show(sd->pointer.obj);
1301 if (sd->type == ELM_WIN_TOOLTIP)
1303 _internal_elm_win_xwindow_get(sd);
1304 ecore_x_window_shape_input_rectangle_set(sd->x.xwin, 0, 0, 0, 0);
1307 sd->first_draw = EINA_TRUE;
1308 /* set this to handle ecore-evas engine code which incorrectly
1309 * assumes that a client resize call is the same as a server resize
1310 * event, or which has no server event
1312 sd->deferred_resize_job = EINA_TRUE;
1314 if (sd->deferred_resize_job)
1316 _elm_win_resize_job(sd->obj);
1317 _elm_win_frame_obj_update(sd, 1);
1322 _elm_win_resize(Ecore_Evas *ee)
1324 Efl_Ui_Win_Data *sd = _elm_win_associate_get(ee);
1327 sd->deferred_resize_job = EINA_TRUE;
1331 _elm_win_mouse_in(Ecore_Evas *ee)
1333 Efl_Ui_Win_Data *sd = _elm_win_associate_get(ee);
1336 _elm_win_throttle_ok = EINA_TRUE;
1337 sd->resizing = EINA_FALSE;
1338 #ifdef HAVE_ELEMENTARY_WL2
1339 if ((sd->wl.win) && (sd->pointer.ee))
1341 sd->pointer.visible = EINA_TRUE;
1342 sd->pointer.surf = ecore_wl2_window_surface_get(sd->pointer.win);
1343 _elm_win_wl_cursor_set(sd->obj, NULL);
1344 //ELM_WIN_DATA_ALIVE_CHECK(obj, sd);
1350 _elm_win_mouse_out(Ecore_Evas *ee)
1352 Efl_Ui_Win_Data *sd = _elm_win_associate_get(ee);
1355 #ifdef HAVE_ELEMENTARY_WL2
1356 if ((sd->wl.win) && (sd->pointer.ee))
1357 sd->pointer.visible = EINA_FALSE;
1362 _elm_win_focus_highlight_reconfigure_job_stop(Efl_Ui_Win_Data *sd)
1364 ELM_SAFE_FREE(sd->focus_highlight.reconf_job, ecore_job_del);
1367 // TIZEN_ONLY(20171114) Accessibility Highlight Frame added
1369 _elm_win_accessibility_highlight_visible_set(Efl_Ui_Win_Data *sd,
1372 Evas_Object *fobj = sd->accessibility_highlight.fobj;
1379 evas_object_show(fobj);
1383 evas_object_smart_member_del(fobj);
1384 evas_object_hide(fobj);
1385 evas_object_del(fobj);
1391 _elm_win_focus_highlight_visible_set(Efl_Ui_Win_Data *sd,
1394 Evas_Object *fobj = sd->focus_highlight.fobj;
1399 evas_object_show(fobj);
1400 if (elm_widget_is_legacy(sd->obj))
1401 edje_object_signal_emit(fobj, "elm,action,focus,show", "elm");
1403 edje_object_signal_emit(fobj, "efl,focus,visible,on", "efl");
1407 if (elm_widget_is_legacy(sd->obj))
1408 edje_object_signal_emit(fobj, "elm,action,focus,hide", "elm");
1410 edje_object_signal_emit(fobj, "efl,focus,visible,off", "efl");
1415 _elm_win_focus_highlight_object_get(Evas_Object *obj)
1417 ELM_WIN_DATA_GET(obj, sd);
1419 return sd->focus_highlight.fobj;
1423 _elm_win_focus_highlight_anim_setup(Efl_Ui_Win_Data *sd,
1427 Edje_Message_Int_Set *m;
1428 Evas_Object *target = sd->focus_highlight.cur.target;
1430 rp = efl_gfx_entity_geometry_get(obj);
1431 rt = elm_widget_focus_highlight_geometry_get(target);
1432 efl_gfx_entity_geometry_set(obj, rt);
1434 if (eina_rectangle_equal(&rp.rect, &rt.rect)) return;
1436 if (!_elm_config->focus_highlight_clip_disable)
1437 evas_object_clip_unset(obj);
1439 m = alloca(sizeof(*m) + (sizeof(int) * 8));
1441 m->val[0] = rp.x - rt.x;
1442 m->val[1] = rp.y - rt.y;
1449 edje_object_message_send(obj, EDJE_MESSAGE_INT_SET, 1, m);
1451 // TIZEN_ONLY(20180326) : Atspi: enhance finding next and prev item on screen's edge
1453 _elm_win_accessibility_parent_is_item(Evas_Object *obj)
1455 Evas_Object *parent;
1456 parent = efl_provider_find(efl_parent_get(obj), EFL_ACCESS_OBJECT_MIXIN);
1459 if (efl_isa(parent, ELM_WIDGET_ITEM_CLASS)) return EINA_TRUE;
1460 parent = efl_provider_find(efl_parent_get(parent), EFL_ACCESS_OBJECT_MIXIN);
1465 // TIZEN_ONLY(20171114) Accessibility Highlight Frame added
1467 _elm_win_accessibility_highlight_simple_setup(Efl_Ui_Win_Data *sd,
1470 // TIZEN_ONLY(20171117) Accessibility frame follows parent item on scroll event
1471 // Evas_Object *target = sd->accessibility_highlight.cur.target;
1472 Evas_Object *target = sd->accessibility_highlight.cur.target;
1474 Evas_Coord x, y, w, h;
1475 //TIZEN_ONLY(20160623): atspi: moved highlight when object is out of screen
1477 Efl_Access_Role role;
1480 _elm_widget_showing_geometry_get(target, &x, &y, &w, &h);
1482 //TIZEN_ONLY(20160623): atspi: moved highlight when object is out of screen
1483 evas_object_geometry_get(target, &ox, &oy, NULL, NULL);
1484 //TIZEN_ONLY(20171011) : atspi : During the highlight grab, out signal is not sent.
1485 if (!_elm_widget_accessibility_highlight_grabbing_get(target))
1488 if (((w < 0 && ox > sd->accessibility_highlight.cur.x) || (h < 0 && oy < sd->accessibility_highlight.cur.y))
1489 && sd->accessibility_highlight.cur.need_moved
1490 && efl_isa(target, EFL_ACCESS_OBJECT_MIXIN))
1492 role = efl_access_object_role_get(target);
1493 if (role && role != EFL_ACCESS_ROLE_MENU_ITEM && role != EFL_ACCESS_ROLE_LIST_ITEM
1494 // TIZEN_ONLY(20180326) : Atspi: enhance finding next and prev item on screen's edge
1495 && ! _elm_win_accessibility_parent_is_item(target))
1498 efl_access_move_outed_signal_emit(target, EFL_ACCESS_MOVE_OUTED_TOP_LEFT);
1499 sd->accessibility_highlight.cur.need_moved = EINA_FALSE;
1503 else if (((w < 0 && ox < sd->accessibility_highlight.cur.x) || (h < 0 && oy > sd->accessibility_highlight.cur.y))
1504 && sd->accessibility_highlight.cur.need_moved
1505 && efl_isa(target, EFL_ACCESS_OBJECT_MIXIN))
1507 role = efl_access_object_role_get(target);
1508 if (role && role != EFL_ACCESS_ROLE_MENU_ITEM && role != EFL_ACCESS_ROLE_LIST_ITEM
1509 // TIZEN_ONLY(20180326) : Atspi: enhance finding next and prev item on screen's edge
1510 && ! _elm_win_accessibility_parent_is_item(target))
1513 efl_access_move_outed_signal_emit(target, EFL_ACCESS_MOVE_OUTED_BOTTOM_RIGHT);
1514 sd->accessibility_highlight.cur.need_moved = EINA_FALSE;
1521 evas_object_move(obj, x, y);
1522 evas_object_resize(obj, w, h);
1524 //TIZEN_ONLY(20160623): atspi: moved highlight when object is out of screen
1525 sd->accessibility_highlight.cur.x = ox;
1526 sd->accessibility_highlight.cur.y = oy;
1529 evas_object_smart_member_add(obj, target);
1534 _elm_win_focus_highlight_simple_setup(Efl_Ui_Win_Data *sd,
1537 Evas_Object *clip, *target = sd->focus_highlight.cur.target;
1539 efl_gfx_entity_geometry_set(obj, elm_widget_focus_highlight_geometry_get(target));
1541 if (!_elm_config->focus_highlight_clip_disable)
1543 clip = evas_object_clip_get(target);
1544 if (clip) evas_object_clip_set(obj, clip);
1547 if (elm_widget_is_legacy(sd->obj))
1548 edje_object_signal_emit(obj, "elm,state,anim,stop", "elm");
1550 edje_object_signal_emit(obj, "efl,state,animating,stopped", "efl");
1554 _elm_win_focus_prev_target_del(void *data,
1555 Evas *e EINA_UNUSED,
1556 Evas_Object *obj EINA_UNUSED,
1557 void *event_info EINA_UNUSED)
1559 ELM_WIN_DATA_GET(data, sd);
1560 sd->focus_highlight.prev.target = NULL;
1563 // TIZEN_ONLY(20171114) Accessibility Highlight Frame added
1565 _elm_win_accessibility_highlight_hide(void *data)
1567 ELM_WIN_DATA_GET(data, sd);
1568 _elm_win_accessibility_highlight_visible_set(sd, EINA_FALSE);
1572 _elm_win_accessibility_highlight_show(void *data)
1574 ELM_WIN_DATA_GET(data, sd);
1575 Evas_Object *fobj = sd->accessibility_highlight.fobj;
1576 elm_widget_theme_object_set (sd->obj, fobj, "accessibility_highlight", "top", "default");
1577 evas_object_raise(fobj);
1578 _elm_win_accessibility_highlight_simple_setup(sd, fobj);
1579 _elm_win_accessibility_highlight_visible_set(sd, EINA_TRUE);
1584 _elm_win_focus_highlight_reconfigure_job(void *data)
1586 ELM_WIN_DATA_GET(data, sd);
1587 Evas_Object *target = sd->focus_highlight.cur.target;
1588 Evas_Object *previous = sd->focus_highlight.prev.target;
1589 Evas_Object *fobj = sd->focus_highlight.fobj;
1590 Eina_Bool visible_changed;
1591 Eina_Bool common_visible;
1592 const char *sig = NULL;
1594 _elm_win_focus_highlight_reconfigure_job_stop(sd);
1596 visible_changed = (sd->focus_highlight.cur.visible !=
1597 sd->focus_highlight.prev.visible);
1599 if ((target == previous) && (!visible_changed) &&
1600 (!sd->focus_highlight.geometry_changed) &&
1601 (!sd->focus_highlight.theme_changed))
1606 evas_object_event_callback_del_full
1607 (previous, EVAS_CALLBACK_DEL, _elm_win_focus_prev_target_del, data);
1608 if (sd->focus_highlight.prev.in_theme)
1610 if (elm_widget_is_legacy(sd->obj))
1611 elm_widget_signal_emit
1612 (previous, "elm,action,focus_highlight,hide", "elm");
1614 elm_widget_signal_emit
1615 (previous, "efl,action,focus_highlight,hide", "efl");
1620 common_visible = EINA_FALSE;
1621 else if (sd->focus_highlight.cur.in_theme)
1623 common_visible = EINA_FALSE;
1625 if (elm_widget_is_legacy(sd->obj))
1627 if (sd->focus_highlight.cur.visible)
1628 sig = "elm,action,focus_highlight,show";
1630 sig = "elm,action,focus_highlight,hide";
1634 if (sd->focus_highlight.cur.visible)
1635 sig = "efl,action,focus_highlight,show";
1637 sig = "efl,action,focus_highlight,hide";
1641 common_visible = sd->focus_highlight.cur.visible;
1645 if (elm_widget_is_legacy(sd->obj))
1646 elm_widget_signal_emit(target, sig, "elm");
1648 elm_widget_signal_emit(target, sig, "efl");
1651 if ((!target) || (!common_visible) || (sd->focus_highlight.cur.in_theme))
1654 _elm_win_focus_highlight_simple_setup(sd, fobj);
1658 if (sd->focus_highlight.theme_changed)
1662 if (sd->focus_highlight.style)
1663 str = sd->focus_highlight.style;
1667 elm_widget_theme_object_set
1668 (sd->obj, fobj, "focus_highlight", "top", str);
1669 sd->focus_highlight.theme_changed = EINA_FALSE;
1671 if ((sd->focus_highlight.animate) || (sd->focus_highlight.auto_animate))
1673 str = edje_object_data_get(sd->focus_highlight.fobj, "animate");
1674 sd->focus_highlight.animate_supported = ((str) && (!strcmp(str, "on")));
1677 sd->focus_highlight.animate_supported = EINA_FALSE;
1680 if ((sd->focus_highlight.animate_supported) && (previous) &&
1681 (!sd->focus_highlight.prev.in_theme))
1682 _elm_win_focus_highlight_anim_setup(sd, fobj);
1684 _elm_win_focus_highlight_simple_setup(sd, fobj);
1685 evas_object_raise(fobj);
1688 _elm_win_focus_highlight_visible_set(sd, common_visible);
1689 sd->focus_highlight.geometry_changed = EINA_FALSE;
1690 sd->focus_highlight.prev = sd->focus_highlight.cur;
1691 if (sd->focus_highlight.prev.target)
1693 evas_object_event_callback_add
1694 (sd->focus_highlight.prev.target,
1695 EVAS_CALLBACK_DEL, _elm_win_focus_prev_target_del, data);
1700 _elm_win_focus_highlight_reconfigure_job_start(Efl_Ui_Win_Data *sd)
1702 ecore_job_del(sd->focus_highlight.reconf_job);
1704 sd->focus_highlight.reconf_job = ecore_job_add(
1705 _elm_win_focus_highlight_reconfigure_job, sd->obj);
1709 _elm_win_focus_in(Ecore_Evas *ee)
1711 Efl_Ui_Win_Data *sd = _elm_win_associate_get(ee);
1714 if ((!sd) || (sd->modal_count)) return;
1716 _elm_win_throttle_ok = EINA_TRUE;
1719 _elm_widget_top_win_focused_set(obj, EINA_TRUE);
1720 ELM_WIN_DATA_ALIVE_CHECK(obj, sd);
1721 if (sd->type != EFL_UI_WIN_TYPE_FAKE)
1723 /* TIZEN_ONLY(20180607): Restore legacy focus
1724 Efl_Ui_Focus_Manager *man = sd->obj;
1725 while(efl_ui_focus_manager_redirect_get(man))
1727 man = efl_ui_focus_manager_redirect_get(man);
1730 Evas_Object *focused = efl_ui_focus_manager_focus_get(man);
1732 efl_ui_focus_object_focus_set(focused, EINA_TRUE);
1734 if (!efl_ui_widget_focus_order_get(obj))
1736 efl_ui_widget_focus_steal(obj, NULL);
1740 Evas_Object *newest = NULL;
1741 unsigned int newest_focus_order = 0;
1743 newest = efl_ui_widget_newest_focus_order_get
1744 (obj, &newest_focus_order, EINA_TRUE);
1745 if (newest) efl_ui_widget_focus_restore(obj);
1747 evas_object_focus_set(obj, EINA_TRUE);
1752 evas_object_smart_callback_call(obj, SIG_FOCUS_IN, NULL);
1753 //TIZEN_ONLY(20180607): Restore legacy focus
1754 //evas_object_smart_callback_call(obj, SIG_WIDGET_FOCUSED, NULL);
1756 ELM_WIN_DATA_ALIVE_CHECK(obj, sd);
1757 sd->focus_highlight.cur.visible = EINA_TRUE;
1758 _elm_win_focus_highlight_reconfigure_job_start(sd);
1759 _elm_win_frame_style_update(sd, 0, 1);
1761 //TIZEN_ONLY(20210608): make plug and socket window work
1762 /* elm_plug: do not send activate signal if window is socket window.
1763 The socket window is embedded in another window. if AT-client works
1764 with activated embedded window directly, it will lost chance to work
1765 with embedding window. ex: "1 finger double tap and hold" makes the
1766 embedded window get focus when embedded window has highlight object,
1767 then "1 finger tap" will interact with the embedded window even though
1768 the "1 finger tap" occurs on embedding window */
1769 if (_elm_atspi_enabled() && sd->type != EFL_UI_WIN_TYPE_SOCKET_IMAGE)
1772 efl_access_window_activated_signal_emit(obj);
1773 efl_access_state_changed_signal_emit(obj, EFL_ACCESS_STATE_TYPE_ACTIVE, EINA_TRUE);
1777 /* else if (sd->img_obj) */
1780 /* TIZEN_ONLY(20180607): Restore legacy focus
1781 if ((!efl_ui_focus_manager_focus_get(sd->obj)) &&
1782 (!efl_ui_focus_manager_redirect_get(sd->obj)))
1784 Efl_Ui_Focus_Object *child;
1786 child = efl_ui_focus_manager_request_subchild(sd->obj, sd->obj);
1789 efl_ui_focus_manager_focus_set(sd->obj, sd->obj);
1790 else if (!evas_focus_get(evas_object_evas_get(sd->obj)))
1791 evas_object_focus_set(obj, EINA_TRUE);
1797 _elm_win_focus_out(Ecore_Evas *ee)
1799 Efl_Ui_Win_Data *sd = _elm_win_associate_get(ee);
1806 _elm_widget_top_win_focused_set(obj, EINA_FALSE);
1807 ELM_WIN_DATA_ALIVE_CHECK(obj, sd);
1808 evas_object_smart_callback_call(obj, SIG_FOCUS_OUT, NULL);
1809 //TIZEN_ONLY(20180607): Restore legacy focus
1810 //evas_object_smart_callback_call(obj, SIG_WIDGET_UNFOCUSED, NULL);
1812 ELM_WIN_DATA_ALIVE_CHECK(obj, sd);
1813 sd->focus_highlight.cur.visible = EINA_FALSE;
1814 _elm_win_focus_highlight_reconfigure_job_start(sd);
1816 _elm_win_frame_style_update(sd, 0, 1);
1819 _elm_access_object_highlight_disable(evas_object_evas_get(obj));
1821 //TIZEN_ONLY(20210608): make plug and socket window work
1822 /* elm_plug: do not send deactivate signal if window is socket window.
1823 The socket window is embedded in another window. if AT-client works
1824 with activated embedded window directly, it will lost chance to work
1825 with embedding window. ex: "1 finger double tap and hold" makes the
1826 embedded window get focus when embedded window has highlight object,
1827 then "1 finger tap" will interact with the embedded window even though
1828 the "1 finger tap" occurs on embedding window */
1829 if (_elm_atspi_enabled() && sd->type != EFL_UI_WIN_TYPE_SOCKET_IMAGE)
1832 efl_access_window_deactivated_signal_emit(obj);
1833 efl_access_state_changed_signal_emit(obj, EFL_ACCESS_STATE_TYPE_ACTIVE, EINA_FALSE);
1836 /*TIZEN_ONLY(20180607): Restore legacy focus
1837 if (sd->type != EFL_UI_WIN_TYPE_FAKE)
1839 Efl_Ui_Focus_Manager *man = sd->obj;
1840 while(efl_ui_focus_manager_redirect_get(man))
1842 man = efl_ui_focus_manager_redirect_get(man);
1845 Evas_Object *focused = efl_ui_focus_manager_focus_get(man);
1846 efl_ui_focus_object_focus_set(focused, EINA_FALSE);
1850 /* if (sd->img_obj) */
1856 _elm_win_available_profiles_del(Efl_Ui_Win_Data *sd)
1858 Eina_Stringshare *prof;
1861 it = eina_array_iterator_new(sd->profile.available);
1862 EINA_ITERATOR_FOREACH(it, prof)
1863 eina_stringshare_del(prof);
1864 eina_iterator_free(it);
1865 eina_array_flush(sd->profile.available);
1869 _elm_win_profile_del(Efl_Ui_Win_Data *sd)
1871 ELM_SAFE_FREE(sd->profile.name, eina_stringshare_del);
1875 _internal_elm_win_profile_set(Efl_Ui_Win_Data *sd, const char *profile)
1877 Eina_Bool changed = EINA_FALSE;
1879 if (profile == sd->profile.name) return EINA_FALSE;
1882 if (eina_stringshare_replace(&sd->profile.name, profile))
1883 changed = EINA_TRUE;
1886 _elm_win_profile_del(sd);
1891 static inline Eina_Bool
1892 _profile_exists(Efl_Ui_Win_Data *sd, const char *profile)
1894 Eina_Bool found = EINA_FALSE;
1895 Eina_Stringshare *prof;
1898 if (!profile) return EINA_FALSE;
1899 it = eina_array_iterator_new(sd->profile.available);
1900 EINA_ITERATOR_FOREACH(it, prof)
1901 if (!strcmp(profile, prof))
1906 eina_iterator_free(it);
1911 _elm_win_profile_update(Efl_Ui_Win_Data *sd)
1913 if (getenv("ELM_PROFILE")) return;
1915 if (eina_array_count(sd->profile.available))
1917 Eina_Bool found = _profile_exists(sd, sd->profile.name);
1919 /* If current profile is not present in an available profiles,
1920 * change current profile to the 1st element of an array.
1923 _internal_elm_win_profile_set(sd, eina_array_data_get(sd->profile.available, 0));
1926 _config_profile_lock = EINA_TRUE;
1927 _elm_config_profile_set(sd->profile.name);
1931 Eina_List *sub, *l = NULL;
1933 sub = ecore_evas_sub_ecore_evas_list_get(sd->ee);
1934 EINA_LIST_FOREACH(sub, l, ee2)
1935 ecore_evas_window_profile_set(ee2, sd->profile.name);
1937 efl_event_callback_legacy_call(sd->obj, EFL_UI_WIN_EVENT_PROFILE_CHANGED, NULL);
1941 _elm_win_frame_geometry_adjust(Efl_Ui_Win_Data *sd)
1943 int l = 0, t = 0, r = 0, b = 0;
1945 if (sd->frame_obj && sd->csd.need && !sd->fullscreen)
1947 int fw, fh, ox, oy, ow, oh;
1948 evas_object_geometry_get(sd->frame_obj, NULL, NULL, &fw, &fh);
1949 if (elm_widget_is_legacy(sd->obj))
1950 edje_object_part_geometry_get(sd->frame_obj, "elm.spacer.opaque",
1951 &ox, &oy, &ow, &oh);
1953 edje_object_part_geometry_get(sd->frame_obj, "efl.spacer.opaque",
1954 &ox, &oy, &ow, &oh);
1960 ecore_evas_shadow_geometry_set(sd->ee, l, r, t, b);
1963 static inline Eina_Bool
1964 _elm_win_framespace_set(Efl_Ui_Win_Data *sd, int x, int y, int w, int h)
1968 evas_output_framespace_get(sd->evas, &fx, &fy, &fw, &fh);
1969 evas_output_framespace_set(sd->evas, x, y, w, h);
1971 // return true if framespace geometry changed
1972 return ((fx != x) || (fy != y) || (fw != w) || (fh != h));
1976 _elm_win_frame_obj_update(Efl_Ui_Win_Data *sd, Eina_Bool force)
1982 if (!sd->frame_obj) return;
1983 if (!sd->csd.need) return;
1984 _elm_win_frame_geometry_adjust(sd);
1985 evas_object_geometry_get(sd->frame_obj, &ox, &oy, &ow, &oh);
1986 if (elm_widget_is_legacy(sd->obj))
1987 edje_object_part_geometry_get(sd->frame_obj, "elm.spacer.content", &cx, &cy, &cw, &ch);
1989 edje_object_part_geometry_get(sd->frame_obj, "efl.spacer.content", &cx, &cy, &cw, &ch);
1991 if (!_elm_win_framespace_set(sd, cx, cy, ow - cw, oh - ch) && (!force)) return;
1992 _elm_win_frame_geometry_adjust(sd);
1994 if (!sd->first_draw) return;
1996 _elm_win_resize_objects_eval(sd->obj, force);
2000 _win_rotation_degree_check(int rotation)
2002 if ((rotation > 360) || (rotation < 0))
2004 WRN("Rotation degree should be 0 ~ 360 (passed degree: %d)", rotation);
2006 if (rotation < 0) rotation += 360;
2012 * This API resizes the internal window(ex: X window) and evas_output.
2013 * But this does not resize the elm window object and its contents.
2016 _win_rotate(Evas_Object *obj, Efl_Ui_Win_Data *sd, int rotation, Eina_Bool resize)
2018 rotation = _win_rotation_degree_check(rotation);
2019 if (sd->rot == rotation) return;
2021 if (resize) TRAP(sd, rotation_with_resize_set, rotation);
2022 else TRAP(sd, rotation_set, rotation);
2023 efl_gfx_hint_size_restricted_min_set(obj, EINA_SIZE2D(-1, -1));
2024 efl_gfx_hint_size_restricted_max_set(obj, EINA_SIZE2D(-1, -1));
2025 _elm_win_resize_objects_eval(obj, EINA_FALSE);
2026 #ifdef HAVE_ELEMENTARY_X
2027 _elm_win_xwin_update(sd);
2029 _elm_win_frame_obj_update(sd, 0);
2030 efl_event_callback_call
2031 (obj, EFL_UI_WIN_EVENT_WIN_ROTATION_CHANGED, &rotation);
2032 evas_object_smart_callback_call(obj, "rotation,changed", NULL);
2033 if (_elm_config->atspi_mode)
2035 Evas_Coord x = 0, y = 0, width = 0, height = 0;
2036 elm_win_screen_size_get(obj, &x, &y, &width, &height);
2037 if ((sd->rot == 0) || (sd->rot == 180))
2039 efl_access_bounds_changed_signal_emit(obj, x, y, width, height);
2043 efl_access_bounds_changed_signal_emit(obj, x, y, height, width);
2049 _efl_ui_win_win_rotation_set(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *pd, int rotation)
2051 Efl_Ui_Widget *widget;
2053 int rot = rotation %360;
2055 if (pd->rot == rot) return;
2057 _win_rotate(obj, pd, rot, EINA_FALSE);
2059 it = efl_ui_widget_tree_widget_iterator(obj);
2060 EINA_ITERATOR_FOREACH(it, widget)
2062 if (!efl_isa(widget, EFL_UI_LAYOUT_BASE_CLASS)) continue;
2064 if (efl_ui_layout_automatic_theme_rotation_get(widget))
2065 efl_ui_layout_theme_rotation_apply(widget, rot);
2070 _efl_ui_win_win_rotation_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *pd)
2076 elm_win_rotation_set(Evas_Object *obj, int rotation)
2078 efl_ui_win_rotation_set(obj, rotation);
2082 elm_win_rotation_get(const Evas_Object *obj)
2084 EINA_SAFETY_ON_NULL_RETURN_VAL(obj, -1);
2085 return efl_ui_win_rotation_get(obj);
2089 _elm_win_state_change(Ecore_Evas *ee)
2091 Efl_Ui_Win_Data *sd = _elm_win_associate_get(ee);
2094 Eina_Bool ch_withdrawn = EINA_FALSE;
2095 Eina_Bool ch_sticky = EINA_FALSE;
2096 Eina_Bool ch_minimized = EINA_FALSE;
2097 Eina_Bool ch_fullscreen = EINA_FALSE;
2098 Eina_Bool ch_maximized = EINA_FALSE;
2099 Eina_Bool ch_profile = EINA_FALSE;
2100 Eina_Bool ch_wm_rotation = EINA_FALSE;
2101 // TIZEN_ONLY(20150707): elm_conform for wayland, and signal if parts are changed
2102 Eina_Bool ch_conformant = EINA_FALSE;
2103 Eina_Bool ch_visibility = EINA_FALSE;
2104 Eina_Bool ch_aux_hint = EINA_FALSE;
2105 Eina_List *aux_hints = NULL;
2108 #ifdef HAVE_ELEMENTARY_WL2
2109 Efl_Ui_Win_Conformant_Property property = EFL_UI_WIN_CONFORMANT_PROPERTY_DEFAULT; //TIZEN_ONLY(20160330): add processing properties of window
2112 const char *profile;
2118 if (sd->withdrawn != ecore_evas_withdrawn_get(sd->ee))
2120 sd->withdrawn = ecore_evas_withdrawn_get(sd->ee);
2121 ch_withdrawn = EINA_TRUE;
2123 if (sd->sticky != ecore_evas_sticky_get(sd->ee))
2125 sd->sticky = ecore_evas_sticky_get(sd->ee);
2126 ch_sticky = EINA_TRUE;
2128 if (sd->minimized != ecore_evas_iconified_get(sd->ee))
2130 sd->minimized = ecore_evas_iconified_get(sd->ee);
2131 ch_minimized = EINA_TRUE;
2133 if (sd->fullscreen != ecore_evas_fullscreen_get(sd->ee))
2135 sd->fullscreen = ecore_evas_fullscreen_get(sd->ee);
2136 ch_fullscreen = EINA_TRUE;
2138 if (sd->maximized != ecore_evas_maximized_get(sd->ee))
2140 sd->maximized = ecore_evas_maximized_get(sd->ee);
2141 ch_maximized = EINA_TRUE;
2144 if (ecore_evas_window_profile_supported_get(sd->ee))
2146 profile = ecore_evas_window_profile_get(sd->ee);
2147 ch_profile = _internal_elm_win_profile_set(sd, profile);
2150 ELM_WIN_DATA_ALIVE_CHECK(obj, sd);
2153 if (sd->rot != ecore_evas_rotation_get(sd->ee))
2155 ch_wm_rotation = EINA_TRUE;
2159 // TIZEN_ONLY(20160120): support visibility_change event
2160 if (sd->obscured != ecore_evas_obscured_get(sd->ee))
2162 sd->obscured = ecore_evas_obscured_get(sd->ee);
2163 ch_visibility = EINA_TRUE;
2166 // TIZEN_ONLY(20150722): added signal for aux_hint(auxiliary hint)
2167 aux_hints = ecore_evas_aux_hints_allowed_get(sd->ee);
2170 ch_aux_hint = EINA_TRUE;
2173 // TIZEN_ONLY(20150707): elm_conform for wayland, and signal if parts are changed
2174 #ifdef HAVE_ELEMENTARY_WL2
2176 if (sd->legacy.indmode != (Elm_Win_Indicator_Mode)ecore_wl2_window_indicator_state_get(sd->wl.win))
2178 sd->legacy.indmode = (Elm_Win_Indicator_Mode)ecore_wl2_window_indicator_state_get(sd->wl.win);
2179 ch_conformant = EINA_TRUE;
2180 property |= EFL_UI_WIN_CONFORMANT_PROPERTY_INDICATOR_STATE; //TIZEN_ONLY(20160330): add processing properties of window
2182 if (sd->kbdmode != (Efl_Ui_Win_Keyboard_Mode)ecore_wl2_window_keyboard_state_get(sd->wl.win))
2184 sd->kbdmode = (Efl_Ui_Win_Keyboard_Mode)ecore_wl2_window_keyboard_state_get(sd->wl.win);
2185 ch_conformant = EINA_TRUE;
2186 property |= EFL_UI_WIN_CONFORMANT_PROPERTY_KEYBOARD_STATE; //TIZEN_ONLY(20160330): add processing properties of window
2189 if (ecore_wl2_window_indicator_geometry_get(sd->wl.win, &x, &y, &w, &h))
2191 if ((sd->ind.x != x) || (sd->ind.y != y) || (sd->ind.w != w) || (sd->ind.h != h))
2197 ch_conformant = EINA_TRUE;
2198 property |= EFL_UI_WIN_CONFORMANT_PROPERTY_INDICATOR_GEOMETRY; //TIZEN_ONLY(20160330): add processing properties of window
2201 if (ecore_wl2_window_keyboard_geometry_get(sd->wl.win, &x, &y, &w, &h))
2203 if ((sd->kbd.x != x) || (sd->kbd.y != y) || (sd->kbd.w != w) || (sd->kbd.h != h))
2209 ch_conformant = EINA_TRUE;
2210 property |= EFL_UI_WIN_CONFORMANT_PROPERTY_KEYBOARD_GEOMETRY; //TIZEN_ONLY(20160330): add processing properties of window
2214 // END of TIZEN_ONLY(20150707)
2215 _elm_win_state_eval_queue();
2217 if ((ch_withdrawn) || (ch_minimized))
2219 ELM_WIN_DATA_ALIVE_CHECK(obj, sd);
2221 efl_event_callback_legacy_call(obj, EFL_UI_WIN_EVENT_WITHDRAWN, NULL);
2222 else if (sd->minimized)
2224 efl_event_callback_call(obj, EFL_UI_WIN_EVENT_MINIMIZED, NULL);
2225 evas_object_smart_callback_call(obj, "iconified", NULL);
2226 if (_elm_atspi_enabled())
2227 efl_access_window_minimized_signal_emit(obj);
2231 efl_event_callback_legacy_call(obj, EFL_UI_WIN_EVENT_NORMAL, NULL);
2232 if (_elm_atspi_enabled())
2233 efl_access_window_restored_signal_emit(obj);
2236 //TIZEN_ONLY(20200122): add minimized,changed event to avoid name conflict in bindings
2239 Eina_Bool minimized = sd->minimized;
2240 efl_event_callback_call(obj, EFL_UI_WIN_EVENT_MINIMIZED_CHANGED, &minimized);
2247 efl_event_callback_legacy_call(obj, EFL_UI_WIN_EVENT_STICK, NULL);
2249 efl_event_callback_legacy_call(obj, EFL_UI_WIN_EVENT_UNSTICK, NULL);
2251 #ifdef HAVE_ELEMENTARY_WL2
2254 if (sd->csd.cur_focus != ecore_wl2_window_activated_get(sd->wl.win))
2255 _elm_win_frame_style_update(sd, 0, 1);
2260 Eina_Bool fullscreen;
2261 ELM_WIN_DATA_ALIVE_CHECK(obj, sd);
2262 _elm_win_frame_style_update(sd, 0, 1);
2263 fullscreen = sd->fullscreen;
2266 evas_object_smart_callback_call(obj, "fullscreen", NULL);
2270 evas_object_smart_callback_call(obj, "unfullscreen", NULL);
2272 efl_event_callback_call(obj, EFL_UI_WIN_EVENT_FULLSCREEN_CHANGED, &fullscreen);
2276 Eina_Bool maximized;
2277 ELM_WIN_DATA_ALIVE_CHECK(obj, sd);
2278 _elm_win_frame_style_update(sd, 0, 1);
2279 maximized = sd->maximized;
2282 evas_object_smart_callback_call(obj, "maximized", NULL);
2283 if (_elm_atspi_enabled())
2284 efl_access_window_maximized_signal_emit(obj);
2288 evas_object_smart_callback_call(obj, "unmaximized", NULL);
2289 if (_elm_atspi_enabled())
2290 efl_access_window_restored_signal_emit(obj);
2292 efl_event_callback_call(obj, EFL_UI_WIN_EVENT_MAXIMIZED_CHANGED, &maximized);
2296 ELM_WIN_DATA_ALIVE_CHECK(obj, sd);
2297 _elm_win_profile_update(sd);
2301 //TIZEN_ONLY(20170912)
2302 /* if there are deferred resize job, do the job immediately
2303 before calling rotation change callback */
2304 if (sd->deferred_resize_job)
2305 _elm_win_resize_job(obj);
2307 efl_ui_win_rotation_set(obj, ecore_evas_rotation_get(sd->ee));
2309 efl_event_callback_legacy_call
2310 (obj, EFL_UI_WIN_EVENT_WM_ROTATION_CHANGED, NULL);
2313 // TIZEN_ONLY(20150707): elm_conform for wayland, and signal if parts are changed
2316 #ifdef HAVE_ELEMENTARY_WL2
2317 evas_object_smart_callback_call(obj, SIG_CONFORMANT_CHANGED, (void *)property); //TIZEN_ONLY(20160330): add processing properties of window
2319 evas_object_smart_callback_call(obj, SIG_CONFORMANT_CHANGED, NULL);
2323 // TIZEN_ONLY(20150722): added signal for aux_hint(auxiliary hint)
2328 EINA_LIST_FOREACH(aux_hints, l, id)
2330 evas_object_smart_callback_call(obj, SIG_AUX_HINT_ALLOWED, id);
2332 eina_list_free(aux_hints);
2335 // TIZEN_ONLY(20160120): support visibility_change event
2338 evas_object_smart_callback_call(obj, SIG_VISIBILITY_CHANGED, (void*)!sd->obscured);
2339 //TIZEN_ONLY(20160701): add atspi window state visible change signal
2340 if (_elm_atspi_enabled())
2341 efl_access_state_changed_signal_emit(obj, EFL_ACCESS_STATE_TYPE_VISIBLE, !sd->obscured);
2347 // TIZEN_ONLY(20160404) skip_focus in case invoking elm_win_quickpanel_set
2349 _elm_win_focus_skip_set(Efl_Ui_Win_Data *sd, Eina_Bool skip)
2352 sd->skip_focus = skip;
2353 TRAP(sd, focus_skip_set, skip);
2357 //TIZEN_ONLY(20180607): Restore legacy focus
2358 EOLIAN static Eina_Bool
2359 _efl_ui_win_efl_ui_widget_focus_next_manager_is(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *_pd EINA_UNUSED)
2364 EOLIAN static Eina_Bool
2365 _efl_ui_win_efl_ui_widget_focus_next(Eo *obj, Efl_Ui_Win_Data *_pd EINA_UNUSED, Efl_Ui_Focus_Direction dir, Evas_Object **next, Elm_Object_Item **next_item)
2367 ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd, EINA_FALSE);
2369 const Eina_List *items;
2370 void *(*list_data_get)(const Eina_List *list);
2375 if (!(items = efl_ui_widget_focus_custom_chain_get(obj)))
2377 for (unsigned int i = 0; i < eina_array_count(wd->children); ++i)
2378 items = eina_list_append((Eina_List *)items, eina_array_data_get(wd->children, i));
2382 list_data_get = eina_list_data_get;
2384 efl_ui_widget_focus_list_next_get(obj, items, list_data_get, dir, next, next_item);
2386 if (*next) return EINA_TRUE;
2388 *next = (Evas_Object *)obj;
2392 EOLIAN static Eina_Bool
2393 _efl_ui_win_efl_ui_widget_focus_direction_manager_is(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *_pd EINA_UNUSED)
2398 EOLIAN static Eina_Bool
2399 _efl_ui_win_efl_ui_widget_focus_direction(Eo *obj, Efl_Ui_Win_Data *_pd EINA_UNUSED, const Evas_Object *base, double degree, Evas_Object **direction, Elm_Object_Item **direction_item, double *weight)
2401 const Eina_List *items;
2402 void *(*list_data_get)(const Eina_List *list);
2404 ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd, EINA_FALSE);
2409 if (!(items = efl_ui_widget_focus_custom_chain_get(obj)))
2411 for (unsigned int i = 0; i < eina_array_count(wd->children); ++i)
2412 items = eina_list_append((Eina_List *)items, eina_array_data_get(wd->children, i));
2415 list_data_get = eina_list_data_get;
2417 return efl_ui_widget_focus_list_direction_get
2418 (obj, base, items, list_data_get, degree, direction, direction_item, weight);
2425 EOLIAN static Eina_Bool
2426 _efl_ui_win_efl_ui_focus_object_on_focus_update(Eo *obj, Efl_Ui_Win_Data *sd)
2428 if (!efl_ui_focus_object_on_focus_update(efl_super(obj, MY_CLASS)))
2432 evas_object_focus_set(sd->img_obj, efl_ui_focus_object_focus_get(obj));
2434 evas_object_focus_set(obj, efl_ui_focus_object_focus_get(obj));
2440 _key_action_return(Evas_Object *obj EINA_UNUSED, const char *params EINA_UNUSED)
2446 _key_action_move(Evas_Object *obj, const char *params)
2448 const char *dir = params;
2450 _elm_widget_focus_auto_show(obj);
2452 Efl_Ui_Focus_Direction focus_dir;
2454 if (!strcmp(dir, "previous"))
2455 focus_dir = EFL_UI_FOCUS_DIRECTION_PREVIOUS;
2456 else if (!strcmp(dir, "next"))
2457 focus_dir = EFL_UI_FOCUS_DIRECTION_NEXT;
2458 else if (!strcmp(dir, "left"))
2459 focus_dir = EFL_UI_FOCUS_DIRECTION_LEFT;
2460 else if (!strcmp(dir, "right"))
2461 focus_dir = EFL_UI_FOCUS_DIRECTION_RIGHT;
2462 else if (!strcmp(dir, "up"))
2463 focus_dir = EFL_UI_FOCUS_DIRECTION_UP;
2464 else if (!strcmp(dir, "down"))
2465 focus_dir = EFL_UI_FOCUS_DIRECTION_DOWN;
2466 else return EINA_FALSE;
2468 //TIZEN_ONLY(20180607): Restore legacy focus
2469 efl_ui_widget_focus_cycle(obj, focus_dir);
2471 // The handling for legacy is different due to elm_object_next set
2472 if (elm_widget_is_legacy(obj))
2473 elm_object_focus_next(obj, (Elm_Focus_Direction)focus_dir);
2478 o = efl_ui_focus_manager_move(obj, focus_dir);
2481 if (focus_dir == EFL_UI_FOCUS_DIRECTION_NEXT || focus_dir == EFL_UI_FOCUS_DIRECTION_PREVIOUS)
2483 Efl_Ui_Focus_Object *root;
2485 root = efl_ui_focus_manager_root_get(obj);
2486 efl_ui_focus_manager_setup_on_first_touch(obj, focus_dir, root);
2494 /* forward events sent to evas to the window */
2496 _evas_event_key_cb(void *data, const Efl_Event *ev)
2500 Efl_Input_Key_Data *evdata;
2502 evdata = efl_data_scope_get(evt, EFL_INPUT_KEY_CLASS);
2503 if (!evdata || evdata->win_fed)
2506 // evas_callbacks will send the event to the focused object (ie. this win)
2507 if (evas_focus_get(evas_object_evas_get(win)) == win)
2510 efl_event_callback_call(win, ev->desc, evt);
2514 _evas_event_pointer_cb(void *data, const Efl_Event *ev)
2518 Efl_Input_Pointer_Data *evdata;
2520 evdata = efl_data_scope_get(evt, EFL_INPUT_POINTER_CLASS);
2521 if (!evdata || evdata->win_fed)
2524 efl_event_callback_call(win, ev->desc, evt);
2527 /* feed events from the window to evas - for fake inputs */
2529 _evas_event_key_feed_fake_cb(void *data, const Efl_Event *ev)
2532 Efl_Input_Event *evt = ev->info;
2533 Efl_Input_Key_Data *evdata;
2535 if (!efl_input_fake_get(evt))
2538 evdata = efl_data_scope_get(evt, EFL_INPUT_KEY_CLASS);
2539 if (!evdata || evdata->win_fed)
2541 evdata->win_fed = EINA_TRUE;
2543 efl_event_callback_call(evas, ev->desc, evt);
2544 evdata->win_fed = EINA_FALSE;
2545 evdata->evas_done = EINA_FALSE;
2549 _evas_event_pointer_feed_fake_cb(void *data, const Efl_Event *ev)
2552 Efl_Input_Event *evt = ev->info;
2553 Efl_Input_Pointer_Data *evdata;
2555 if (!efl_input_fake_get(evt))
2558 evdata = efl_data_scope_get(evt, EFL_INPUT_POINTER_CLASS);
2559 if (!evdata || evdata->win_fed)
2561 evdata->win_fed = EINA_TRUE;
2563 efl_event_callback_call(evas, ev->desc, evt);
2564 evdata->win_fed = EINA_FALSE;
2565 evdata->evas_done = EINA_FALSE;
2568 EFL_CALLBACKS_ARRAY_DEFINE(_elm_win_evas_feed_fake_callbacks,
2569 { EFL_EVENT_POINTER_MOVE, _evas_event_pointer_feed_fake_cb },
2570 { EFL_EVENT_POINTER_DOWN, _evas_event_pointer_feed_fake_cb },
2571 { EFL_EVENT_POINTER_UP, _evas_event_pointer_feed_fake_cb },
2572 { EFL_EVENT_POINTER_IN, _evas_event_pointer_feed_fake_cb },
2573 { EFL_EVENT_POINTER_OUT, _evas_event_pointer_feed_fake_cb },
2574 { EFL_EVENT_POINTER_CANCEL, _evas_event_pointer_feed_fake_cb },
2575 { EFL_EVENT_POINTER_WHEEL, _evas_event_pointer_feed_fake_cb },
2576 { EFL_EVENT_FINGER_MOVE, _evas_event_pointer_feed_fake_cb },
2577 { EFL_EVENT_FINGER_DOWN, _evas_event_pointer_feed_fake_cb },
2578 { EFL_EVENT_FINGER_UP, _evas_event_pointer_feed_fake_cb },
2579 { EFL_EVENT_KEY_DOWN, _evas_event_key_feed_fake_cb },
2580 { EFL_EVENT_KEY_UP, _evas_event_key_feed_fake_cb })
2583 _elm_win_evas_render_post(void *data,
2584 Evas *e EINA_UNUSED,
2587 Efl_Gfx_Event_Render_Post *ev = event_info;
2590 efl_event_callback_call(win, EFL_CANVAS_SCENE_EVENT_RENDER_POST, ev);
2594 _elm_win_evas_render_pre(void *data,
2595 Evas *e EINA_UNUSED,
2596 void *event_info EINA_UNUSED)
2600 _elm_win_throttle_ok = EINA_TRUE;
2601 efl_event_callback_call(win, EFL_CANVAS_SCENE_EVENT_RENDER_PRE, NULL);
2605 _elm_win_evas_focus_in(void *data,
2606 Evas *e EINA_UNUSED,
2607 void *event_info EINA_UNUSED)
2611 _elm_win_throttle_ok = EINA_TRUE;
2612 efl_event_callback_call(win, EFL_CANVAS_SCENE_EVENT_SCENE_FOCUS_IN, NULL);
2616 _elm_win_evas_focus_out(void *data,
2617 Evas *e EINA_UNUSED,
2618 void *event_info EINA_UNUSED)
2622 efl_event_callback_call(win, EFL_CANVAS_SCENE_EVENT_SCENE_FOCUS_OUT, NULL);
2626 _evas_event_focus_object_cb(void *data, const Efl_Event *ev)
2630 if (ev->desc == EFL_CANVAS_SCENE_EVENT_OBJECT_FOCUS_IN)
2631 _elm_win_throttle_ok = EINA_TRUE;
2633 efl_event_callback_call(win, ev->desc, ev->info);
2637 _elm_win_evas_device_changed(void *data,
2638 Evas *e EINA_UNUSED,
2641 Eo *device = event_info;
2644 efl_event_callback_call(win, EFL_CANVAS_SCENE_EVENT_DEVICE_CHANGED, device);
2648 _win_event_add_cb(void *data, const Efl_Event *ev)
2650 const Efl_Callback_Array_Item_Full *array = ev->info;
2651 Efl_Ui_Win_Data *sd = data;
2652 Efl_Ui_Win *win = ev->object;
2655 for (i = 0; array[i].desc; i++)
2657 if (array[i].desc == EFL_EVENT_POINTER_MOVE)
2659 if (!(sd->event_forward.pointer_move++))
2660 efl_event_callback_add(sd->evas, array[i].desc,
2661 _evas_event_pointer_cb, win);
2663 else if (array[i].desc == EFL_EVENT_POINTER_DOWN)
2665 if (!(sd->event_forward.pointer_down++))
2666 efl_event_callback_add(sd->evas, array[i].desc,
2667 _evas_event_pointer_cb, win);
2669 else if (array[i].desc == EFL_EVENT_POINTER_UP)
2671 if (!(sd->event_forward.pointer_up++))
2672 efl_event_callback_add(sd->evas, array[i].desc,
2673 _evas_event_pointer_cb, win);
2675 else if (array[i].desc == EFL_EVENT_POINTER_IN)
2677 if (!(sd->event_forward.pointer_in++))
2678 efl_event_callback_add(sd->evas, array[i].desc,
2679 _evas_event_pointer_cb, win);
2681 else if (array[i].desc == EFL_EVENT_POINTER_OUT)
2683 if (!(sd->event_forward.pointer_out++))
2684 efl_event_callback_add(sd->evas, array[i].desc,
2685 _evas_event_pointer_cb, win);
2687 else if (array[i].desc == EFL_EVENT_POINTER_CANCEL)
2689 if (!(sd->event_forward.pointer_cancel++))
2690 efl_event_callback_add(sd->evas, array[i].desc,
2691 _evas_event_pointer_cb, win);
2693 else if (array[i].desc == EFL_EVENT_POINTER_WHEEL)
2695 if (!(sd->event_forward.pointer_wheel++))
2696 efl_event_callback_add(sd->evas, array[i].desc,
2697 _evas_event_pointer_cb, win);
2699 else if (array[i].desc == EFL_EVENT_FINGER_MOVE)
2701 if (!(sd->event_forward.finger_move++))
2702 efl_event_callback_add(sd->evas, array[i].desc,
2703 _evas_event_pointer_cb, win);
2705 else if (array[i].desc == EFL_EVENT_FINGER_DOWN)
2707 if (!(sd->event_forward.finger_down++))
2708 efl_event_callback_add(sd->evas, array[i].desc,
2709 _evas_event_pointer_cb, win);
2711 else if (array[i].desc == EFL_EVENT_FINGER_UP)
2713 if (!(sd->event_forward.finger_up++))
2714 efl_event_callback_add(sd->evas, array[i].desc,
2715 _evas_event_pointer_cb, win);
2717 else if (array[i].desc == EFL_EVENT_KEY_DOWN)
2719 // Legacy API: Must grab key
2720 if (elm_widget_is_legacy(win)) return;
2721 if (!(sd->event_forward.key_down++))
2722 efl_event_callback_add(sd->evas, array[i].desc,
2723 _evas_event_key_cb, win);
2725 else if (array[i].desc == EFL_EVENT_KEY_UP)
2727 // Legacy API: Must grab key
2728 if (elm_widget_is_legacy(win)) return;
2729 if (!(sd->event_forward.key_up++))
2730 efl_event_callback_add(sd->evas, array[i].desc,
2731 _evas_event_key_cb, win);
2733 else if (array[i].desc == EFL_CANVAS_SCENE_EVENT_RENDER_POST)
2735 if (!(sd->event_forward.render_post++))
2736 evas_event_callback_add(sd->evas, EVAS_CALLBACK_RENDER_POST,
2737 _elm_win_evas_render_post, win);
2739 else if (array[i].desc == EFL_CANVAS_SCENE_EVENT_RENDER_PRE)
2741 if (!(sd->event_forward.render_pre++))
2742 evas_event_callback_add(sd->evas, EVAS_CALLBACK_RENDER_PRE,
2743 _elm_win_evas_render_pre, win);
2745 else if (array[i].desc == EFL_CANVAS_SCENE_EVENT_SCENE_FOCUS_IN)
2747 if (!(sd->event_forward.focus_in++))
2748 evas_event_callback_add(sd->evas, EVAS_CALLBACK_CANVAS_FOCUS_IN,
2749 _elm_win_evas_focus_in, win);
2751 else if (array[i].desc == EFL_CANVAS_SCENE_EVENT_SCENE_FOCUS_OUT)
2753 if (!(sd->event_forward.focus_out++))
2754 evas_event_callback_add(sd->evas, EVAS_CALLBACK_CANVAS_FOCUS_OUT,
2755 _elm_win_evas_focus_out, win);
2757 else if (array[i].desc == EFL_CANVAS_SCENE_EVENT_OBJECT_FOCUS_IN)
2759 if (!(sd->event_forward.object_focus_in++))
2760 efl_event_callback_add(sd->evas, EFL_CANVAS_SCENE_EVENT_OBJECT_FOCUS_IN,
2761 _evas_event_focus_object_cb, win);
2763 else if (array[i].desc == EFL_CANVAS_SCENE_EVENT_OBJECT_FOCUS_OUT)
2765 if (!(sd->event_forward.object_focus_out++))
2766 efl_event_callback_add(sd->evas, EFL_CANVAS_SCENE_EVENT_OBJECT_FOCUS_OUT,
2767 _evas_event_focus_object_cb, win);
2769 else if (array[i].desc == EFL_CANVAS_SCENE_EVENT_DEVICE_CHANGED)
2771 if (!(sd->event_forward.device_changed++))
2772 evas_event_callback_add(sd->evas, EVAS_CALLBACK_DEVICE_CHANGED,
2773 _elm_win_evas_device_changed, win);
2779 _win_event_del_cb(void *data, const Efl_Event *ev)
2781 const Efl_Callback_Array_Item_Full *array = ev->info;
2782 Efl_Ui_Win_Data *sd = data;
2783 Efl_Ui_Win *win = ev->object;
2786 for (i = 0; array[i].desc; i++)
2788 if (array[i].desc == EFL_EVENT_POINTER_MOVE)
2790 if (!(--sd->event_forward.pointer_move))
2791 efl_event_callback_del(sd->evas, array[i].desc,
2792 _evas_event_pointer_cb, win);
2794 else if (array[i].desc == EFL_EVENT_POINTER_DOWN)
2796 if (!(--sd->event_forward.pointer_down))
2797 efl_event_callback_del(sd->evas, array[i].desc,
2798 _evas_event_pointer_cb, win);
2800 else if (array[i].desc == EFL_EVENT_POINTER_UP)
2802 if (!(--sd->event_forward.pointer_up))
2803 efl_event_callback_del(sd->evas, array[i].desc,
2804 _evas_event_pointer_cb, win);
2806 else if (array[i].desc == EFL_EVENT_POINTER_IN)
2808 if (!(--sd->event_forward.pointer_in))
2809 efl_event_callback_del(sd->evas, array[i].desc,
2810 _evas_event_pointer_cb, win);
2812 else if (array[i].desc == EFL_EVENT_POINTER_OUT)
2814 if (!(--sd->event_forward.pointer_out))
2815 efl_event_callback_del(sd->evas, array[i].desc,
2816 _evas_event_pointer_cb, win);
2818 else if (array[i].desc == EFL_EVENT_POINTER_CANCEL)
2820 if (!(--sd->event_forward.pointer_cancel))
2821 efl_event_callback_del(sd->evas, array[i].desc,
2822 _evas_event_pointer_cb, win);
2824 else if (array[i].desc == EFL_EVENT_POINTER_WHEEL)
2826 if (!(--sd->event_forward.pointer_wheel))
2827 efl_event_callback_del(sd->evas, array[i].desc,
2828 _evas_event_pointer_cb, win);
2830 else if (array[i].desc == EFL_EVENT_FINGER_MOVE)
2832 if (!(--sd->event_forward.finger_move))
2833 efl_event_callback_del(sd->evas, array[i].desc,
2834 _evas_event_pointer_cb, win);
2836 else if (array[i].desc == EFL_EVENT_FINGER_DOWN)
2838 if (!(--sd->event_forward.finger_down))
2839 efl_event_callback_del(sd->evas, array[i].desc,
2840 _evas_event_pointer_cb, win);
2842 else if (array[i].desc == EFL_EVENT_FINGER_UP)
2844 if (!(--sd->event_forward.finger_up))
2845 efl_event_callback_del(sd->evas, array[i].desc,
2846 _evas_event_pointer_cb, win);
2848 else if (array[i].desc == EFL_EVENT_KEY_DOWN)
2850 // Legacy API: Must grab key
2851 if (elm_widget_is_legacy(win)) return;
2852 if (!(--sd->event_forward.key_down))
2853 efl_event_callback_del(sd->evas, array[i].desc,
2854 _evas_event_key_cb, win);
2856 else if (array[i].desc == EFL_EVENT_KEY_UP)
2858 // Legacy API: Must grab key
2859 if (elm_widget_is_legacy(win)) return;
2860 if (!(--sd->event_forward.key_up))
2861 efl_event_callback_del(sd->evas, array[i].desc,
2862 _evas_event_key_cb, win);
2864 else if (array[i].desc == EFL_CANVAS_SCENE_EVENT_RENDER_POST)
2866 if (!(--sd->event_forward.render_post))
2867 evas_event_callback_del_full(sd->evas, EVAS_CALLBACK_RENDER_POST,
2868 _elm_win_evas_render_post, win);
2870 else if (array[i].desc == EFL_CANVAS_SCENE_EVENT_RENDER_PRE)
2872 if (!(--sd->event_forward.render_pre))
2873 evas_event_callback_del_full(sd->evas, EVAS_CALLBACK_RENDER_PRE,
2874 _elm_win_evas_render_pre, win);
2876 else if (array[i].desc == EFL_CANVAS_SCENE_EVENT_SCENE_FOCUS_IN)
2878 if (!(--sd->event_forward.focus_in))
2879 evas_event_callback_del_full(sd->evas, EVAS_CALLBACK_FOCUS_IN,
2880 _elm_win_evas_focus_in, win);
2882 else if (array[i].desc == EFL_CANVAS_SCENE_EVENT_SCENE_FOCUS_OUT)
2884 if (!(--sd->event_forward.focus_out))
2885 evas_event_callback_del_full(sd->evas, EVAS_CALLBACK_FOCUS_OUT,
2886 _elm_win_evas_focus_out, win);
2888 else if (array[i].desc == EFL_CANVAS_SCENE_EVENT_OBJECT_FOCUS_IN)
2890 if (!(--sd->event_forward.object_focus_in))
2891 efl_event_callback_del(sd->evas, EFL_CANVAS_SCENE_EVENT_OBJECT_FOCUS_IN,
2892 _evas_event_focus_object_cb, win);
2894 else if (array[i].desc == EFL_CANVAS_SCENE_EVENT_OBJECT_FOCUS_OUT)
2896 if (!(--sd->event_forward.object_focus_out))
2897 efl_event_callback_del(sd->evas, EFL_CANVAS_SCENE_EVENT_OBJECT_FOCUS_OUT,
2898 _evas_event_focus_object_cb, win);
2900 else if (array[i].desc == EFL_CANVAS_SCENE_EVENT_DEVICE_CHANGED)
2902 if (!(--sd->event_forward.device_changed))
2903 evas_event_callback_del_full(sd->evas, EVAS_CALLBACK_DEVICE_CHANGED,
2904 _elm_win_evas_device_changed, win);
2910 _win_paused(void *data, const Efl_Event *ev)
2912 Efl_Ui_Win_Data *sd = data;
2916 ERR("A window did receive a pause event while still paused. Dismissing.");
2919 sd->paused = EINA_TRUE;
2922 if (_elm_win_count == _paused_windows)
2923 efl_event_callback_call(efl_loop_get(ev->object), EFL_APP_EVENT_PAUSE, NULL);
2926 EFL_CALLBACKS_ARRAY_DEFINE(_elm_win_tracking,
2927 { EFL_EVENT_CALLBACK_ADD, _win_event_add_cb },
2928 { EFL_EVENT_CALLBACK_DEL, _win_event_del_cb },
2929 { EFL_UI_WIN_EVENT_PAUSE, _win_paused })
2932 _elm_win_cb_mouse_up(void *data, const Efl_Event *ev EINA_UNUSED)
2934 DBG("Evas mouse up event");
2935 /*Currently wayland server didn't send mouse up event after resize the window*/
2936 Efl_Ui_Win_Data *sd = data;
2937 if(sd->resizing) sd->resizing = EINA_FALSE;
2941 _elm_win_resume(void *data, const Efl_Event *ev)
2943 Efl_Ui_Win_Data *sd = data;
2945 if (!sd->paused) return ;
2947 efl_event_callback_call(sd->obj, EFL_UI_WIN_EVENT_RESUME, NULL);
2948 sd->paused = EINA_FALSE;
2950 if (_elm_win_count == _paused_windows)
2951 efl_event_callback_call(efl_loop_get(ev->object), EFL_APP_EVENT_RESUME, NULL);
2956 EFL_CALLBACKS_ARRAY_DEFINE(_elm_evas_tracking,
2957 { EFL_EVENT_POINTER_UP, _elm_win_cb_mouse_up },
2958 { EFL_CANVAS_SCENE_EVENT_RENDER_PRE, _elm_win_resume })
2961 _deferred_ecore_evas_free(void *data)
2963 ecore_evas_free(data);
2964 _elm_win_deferred_free--;
2967 static inline Edje_Object *
2968 _elm_win_modal_blocker_edje_get(Efl_Ui_Win_Data *sd)
2970 /* Legacy theme compatibility */
2971 const char *version = edje_object_data_get(sd->legacy.edje, "version");
2972 int v = version ? atoi(version) : 0;
2973 if (v < FRAME_OBJ_THEME_MIN_VERSION)
2975 DBG("Detected legacy theme (<1.19) for modal window blocker.");
2976 return sd->legacy.edje;
2978 return sd->frame_obj;
2982 _elm_win_modality_increment(Efl_Ui_Win_Data *modalsd)
2984 Efl_Ui_Win *current;
2986 Eina_Bool is_legacy = elm_widget_is_legacy(modalsd->obj);
2988 EINA_LIST_FOREACH(_elm_win_list, l, current)
2990 ELM_WIN_DATA_GET_OR_RETURN(current, cursd);
2991 if (modalsd != cursd)
2992 cursd->modal_count++;
2993 if (cursd->modal_count > 0)
2995 Edje_Object *ed = _elm_win_modal_blocker_edje_get(cursd);
2997 edje_object_signal_emit(ed, "elm,action,show_blocker", "elm");
2999 edje_object_signal_emit(ed, "efl,action,show_blocker", "efl");
3000 efl_event_callback_legacy_call
3001 (cursd->main_menu, EFL_UI_WIN_EVENT_ELM_ACTION_BLOCK_MENU, NULL);
3002 _elm_win_frame_style_update(cursd, 0, 1);
3008 _elm_win_modality_decrement(Efl_Ui_Win_Data *modalsd)
3010 Efl_Ui_Win *current;
3012 Eina_Bool is_legacy = elm_widget_is_legacy(modalsd->obj);
3014 EINA_LIST_FOREACH(_elm_win_list, l, current)
3016 ELM_WIN_DATA_GET_OR_RETURN(current, cursd);
3017 if ((modalsd != cursd) && (cursd->modal_count > 0))
3018 cursd->modal_count--;
3019 if (cursd->modal_count == 0)
3021 Edje_Object *ed = _elm_win_modal_blocker_edje_get(cursd);
3023 edje_object_signal_emit(ed, "elm,action,hide_blocker", "elm");
3025 edje_object_signal_emit(ed, "efl,action,hide_blocker", "efl");
3026 efl_event_callback_legacy_call
3027 (cursd->main_menu, ELM_MENU_EVENT_ELM_ACTION_UNBLOCK_MENU, NULL);
3028 _elm_win_frame_style_update(cursd, 0, 1);
3034 _efl_ui_win_show(Eo *obj, Efl_Ui_Win_Data *sd)
3036 Eina_Bool do_eval = EINA_FALSE;
3038 sd->shown = EINA_TRUE;
3039 if (sd->modal_count)
3041 /* FIXME FIXME FIXME
3042 * Ugly code flow: legacy code had an early return in smart_show, ie.
3043 * evas object show would be processed but smart object show would be
3044 * aborted. This super call tries to simulate that. */
3045 efl_gfx_entity_visible_set(efl_super(obj, EFL_CANVAS_GROUP_CLASS), EINA_TRUE);
3049 if ((sd->modal) && (!evas_object_visible_get(obj)))
3050 _elm_win_modality_increment(sd);
3052 if (!evas_object_visible_get(obj)) do_eval = EINA_TRUE;
3053 efl_gfx_entity_visible_set(efl_super(obj, MY_CLASS), EINA_TRUE);
3055 if (sd->deferred_resize_job)
3056 _elm_win_resize_job(sd->obj);
3057 evas_smart_objects_calculate(evas_object_evas_get(obj));
3061 if (_elm_atspi_enabled())
3064 root = efl_access_object_access_root_get();
3066 efl_access_children_changed_added_signal_emit(root, obj);
3068 //TIZEN_ONLY(20200508):Listen to socket when widget window is shown
3069 _access_socket_proxy_listen(obj);
3075 /*TIZEN_ONLY(20171113):Use ecore_job instead of ecore_timer
3076 if (_elm_win_state_eval_timer)
3078 ecore_timer_del(_elm_win_state_eval_timer);
3079 _elm_win_state_eval_timer = NULL;
3082 if (_elm_win_state_eval_job)
3084 ecore_job_del(_elm_win_state_eval_job);
3085 _elm_win_state_eval_job = NULL;
3088 _elm_win_state_eval(NULL);
3091 if (sd->shot.info) _shot_handle(sd);
3093 if (!sd->first_draw) return;
3096 evas_object_show(sd->frame_obj);
3100 evas_object_show(sd->img_obj);
3102 if (sd->pointer.obj)
3104 evas_object_show(sd->pointer.obj);
3109 _efl_ui_win_hide(Eo *obj, Efl_Ui_Win_Data *sd)
3111 if (sd->modal_count)
3113 /* FIXME FIXME FIXME
3114 * Ugly code flow: legacy code had an early return in smart_show, ie.
3115 * evas object show would be processed but smart object show would be
3116 * aborted. This super call tries to simulate that. */
3117 efl_gfx_entity_visible_set(efl_super(obj, EFL_CANVAS_GROUP_CLASS), EINA_FALSE);
3121 _elm_win_state_eval_queue();
3123 if ((sd->modal) && (evas_object_visible_get(obj)))
3124 _elm_win_modality_decrement(sd);
3126 efl_gfx_entity_visible_set(efl_super(obj, MY_CLASS), EINA_FALSE);
3131 evas_object_hide(sd->frame_obj);
3135 evas_object_hide(sd->img_obj);
3137 if (sd->pointer.obj)
3139 evas_object_hide(sd->pointer.obj);
3142 if (_elm_atspi_enabled())
3145 root = efl_access_object_access_root_get();
3147 efl_access_children_changed_del_signal_emit(root, obj);
3150 if (_elm_win_policy_quit_triggered(obj))
3151 _elm_win_flush_cache_and_exit(obj);
3155 _efl_ui_win_efl_gfx_entity_visible_set(Eo *obj, Efl_Ui_Win_Data *sd, Eina_Bool vis)
3157 if (_evas_object_intercept_call(obj, EVAS_OBJECT_INTERCEPT_CB_VISIBLE, 0, vis))
3160 if (vis) _efl_ui_win_show(obj, sd);
3161 else _efl_ui_win_hide(obj, sd);
3164 EOLIAN static Eina_Bool
3165 _efl_ui_win_efl_canvas_scene_pointer_position_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, Eo *dev, Eina_Position2D *pos)
3167 return efl_canvas_scene_pointer_position_get(sd->evas, dev, pos);
3170 EOLIAN static Eina_Bool
3171 _efl_ui_win_efl_canvas_pointer_pointer_inside_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, Eo *dev)
3173 return efl_canvas_pointer_inside_get(sd->evas, dev);
3176 /* multi touch support */
3178 _input_pointer_iterator_next(Input_Pointer_Iterator *it, void **data)
3182 if (!eina_iterator_next(it->real_iterator, (void **) &sub))
3185 if (data) *data = sub;
3190 _input_pointer_iterator_get_container(Input_Pointer_Iterator *it)
3192 return (Eo *) it->object;
3196 _input_pointer_iterator_free(Input_Pointer_Iterator *it)
3198 Efl_Input_Pointer *ptr;
3200 EINA_LIST_FREE(it->list, ptr)
3202 eina_iterator_free(it->real_iterator);
3206 EOLIAN static Eina_Iterator *
3207 _efl_ui_win_pointer_iterate(const Eo *obj, Efl_Ui_Win_Data *sd,
3208 Eina_Bool hover EINA_UNUSED)
3210 Input_Pointer_Iterator *it;
3211 Eina_List *list = NULL;
3214 // Note: "hover" is here as a possible extension to this API. At the moment
3215 // I don't have any device that could track the position of hovering fingers
3216 // and Evas also wouldn't track those.
3218 ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd, NULL);
3220 cnt = evas_touch_point_list_count(sd->evas);
3221 if (!cnt) return NULL;
3223 it = calloc(1, sizeof(*it));
3224 if (!it) return NULL;
3226 EINA_MAGIC_SET(&it->iterator, EINA_MAGIC_ITERATOR);
3228 for (i = 0; i < cnt; i++)
3230 Efl_Input_Pointer_Data *ptrdata;
3231 Evas_Touch_Point_State state;
3232 Efl_Input_Pointer *ptr;
3235 ptr = efl_input_pointer_instance_get( (Eo *) obj, (void **) &ptrdata);
3236 if (!ptrdata) break;
3238 ptrdata->touch_id = evas_touch_point_list_nth_id_get(sd->evas, i);
3239 _efl_input_value_mark(ptrdata, EFL_INPUT_VALUE_TOUCH_ID);
3241 // Note that "still" maps to "down" here.
3242 state = evas_touch_point_list_nth_state_get(sd->evas, i);
3245 case EVAS_TOUCH_POINT_DOWN: ptrdata->action = EFL_POINTER_ACTION_DOWN; break;
3246 case EVAS_TOUCH_POINT_UP: ptrdata->action = EFL_POINTER_ACTION_UP; break;
3247 case EVAS_TOUCH_POINT_MOVE: ptrdata->action = EFL_POINTER_ACTION_MOVE; break;
3248 case EVAS_TOUCH_POINT_STILL: ptrdata->action = EFL_POINTER_ACTION_DOWN; break;
3249 case EVAS_TOUCH_POINT_CANCEL: ptrdata->action = EFL_POINTER_ACTION_CANCEL; break;
3250 default: ptrdata->action = EFL_POINTER_ACTION_NONE; break;
3253 evas_canvas_touch_point_list_nth_xy_get(sd->evas, i, &x, &y);
3254 _efl_input_value_mark(ptrdata, EFL_INPUT_VALUE_X);
3255 _efl_input_value_mark(ptrdata, EFL_INPUT_VALUE_Y);
3258 ptrdata->prev = ptrdata->cur;
3260 list = eina_list_append(list, ptr);
3264 it->real_iterator = eina_list_iterator_new(it->list);
3265 it->iterator.version = EINA_ITERATOR_VERSION;
3266 it->iterator.next = FUNC_ITERATOR_NEXT(_input_pointer_iterator_next);
3267 it->iterator.get_container = FUNC_ITERATOR_GET_CONTAINER(_input_pointer_iterator_get_container);
3268 it->iterator.free = FUNC_ITERATOR_FREE(_input_pointer_iterator_free);
3271 return &it->iterator;
3274 EOLIAN static Eina_Bool
3275 _efl_ui_win_efl_canvas_scene_image_max_size_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, Eina_Size2D *max)
3277 return efl_canvas_scene_image_max_size_get(sd->evas, max);
3281 _efl_ui_win_efl_canvas_scene_group_objects_calculate(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd)
3283 evas_smart_objects_calculate(sd->evas);
3286 EOLIAN static Eina_Bool
3287 _efl_ui_win_efl_canvas_scene_group_objects_calculating_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd)
3289 return efl_canvas_scene_group_objects_calculating_get(sd->evas);
3292 EOLIAN static Eina_Iterator *
3293 _efl_ui_win_efl_canvas_scene_objects_at_xy_get(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, Eina_Position2D pos, Eina_Bool include_pass_events_objects, Eina_Bool include_hidden_objects)
3295 Eina_List *objs = NULL;
3296 objs = evas_objects_at_xy_get(sd->evas, pos.x, pos.y, include_pass_events_objects, include_hidden_objects);
3297 return eina_list_iterator_new(objs); // FIXME: This leaks the list!
3300 EOLIAN static Efl_Gfx_Entity *
3301 _efl_ui_win_efl_canvas_scene_object_top_at_xy_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, Eina_Position2D pos, Eina_Bool include_pass_events_objects, Eina_Bool include_hidden_objects)
3303 return evas_object_top_at_xy_get(sd->evas, pos.x, pos.y, include_pass_events_objects, include_hidden_objects);
3306 EOLIAN static Eina_Iterator *
3307 _efl_ui_win_efl_canvas_scene_objects_in_rectangle_get(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, Eina_Rect r, Eina_Bool include_pass_events_objects, Eina_Bool include_hidden_objects)
3309 Eina_List *objs = NULL;
3310 objs = evas_objects_in_rectangle_get(sd->evas, r.x, r.y, r.w, r.h, include_pass_events_objects, include_hidden_objects);
3311 return eina_list_iterator_new(objs); // FIXME: This leaks the list!
3314 EOLIAN static Efl_Gfx_Entity *
3315 _efl_ui_win_efl_canvas_scene_object_top_in_rectangle_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, Eina_Rect r, Eina_Bool include_pass_events_objects, Eina_Bool include_hidden_objects)
3317 return evas_object_top_in_rectangle_get(sd->evas, r.x, r.y, r.w, r.h, include_pass_events_objects, include_hidden_objects);
3320 EOLIAN static Efl_Input_Device *
3321 _efl_ui_win_efl_canvas_scene_device_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, const char *name)
3323 return efl_canvas_scene_device_get(sd->evas, name);
3326 EOLIAN static Efl_Input_Device *
3327 _efl_ui_win_efl_canvas_scene_seat_default_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd)
3329 return efl_canvas_scene_seat_default_get(sd->evas);
3332 EOLIAN static Efl_Input_Device *
3333 _efl_ui_win_efl_canvas_scene_seat_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, int id)
3335 return efl_canvas_scene_seat_get(sd->evas, id);
3338 // TIZEN_ONLY(20171114) Accessibility Highlight Frame added
3340 _elm_win_accessibility_highlight_obj_del(void *data,
3341 Evas *e EINA_UNUSED,
3343 void *event_info EINA_UNUSED)
3345 ELM_WIN_DATA_GET(data, sd);
3346 // TIZEN_ONLY(20160805): set _accessibility_currently_highlighted_obj to NULL in object delete callback
3347 /* set _accessibility_currently_highlighted_obj to NULL */
3348 elm_object_accessibility_highlight_set(obj, EINA_FALSE);
3350 _elm_win_accessibility_highlight_hide(sd->obj);
3354 _elm_win_accessibility_highlight_obj_move(void *data,
3355 Evas *e EINA_UNUSED,
3356 Evas_Object *obj EINA_UNUSED,
3357 void *event_info EINA_UNUSED)
3359 ELM_WIN_DATA_GET(data, sd);
3361 _elm_win_accessibility_highlight_show(sd->obj);
3365 _elm_win_accessibility_highlight_obj_resize(void *data,
3366 Evas *e EINA_UNUSED,
3367 Evas_Object *obj EINA_UNUSED,
3368 void *event_info EINA_UNUSED)
3370 ELM_WIN_DATA_GET(data, sd);
3371 _elm_win_accessibility_highlight_show(sd->obj);
3377 _elm_win_on_parent_del(void *data,
3378 Evas *e EINA_UNUSED,
3380 void *event_info EINA_UNUSED)
3382 ELM_WIN_DATA_GET(data, sd);
3384 if (obj == sd->parent)
3386 ecore_wl2_window_parent_set(sd->wl.win, NULL);
3392 _elm_win_focus_target_move(void *data,
3393 Evas *e EINA_UNUSED,
3394 Evas_Object *obj EINA_UNUSED,
3395 void *event_info EINA_UNUSED)
3397 ELM_WIN_DATA_GET(data, sd);
3399 sd->focus_highlight.geometry_changed = EINA_TRUE;
3400 _elm_win_focus_highlight_reconfigure_job_start(sd);
3404 _elm_win_focus_target_resize(void *data,
3405 Evas *e EINA_UNUSED,
3406 Evas_Object *obj EINA_UNUSED,
3407 void *event_info EINA_UNUSED)
3409 ELM_WIN_DATA_GET(data, sd);
3411 sd->focus_highlight.geometry_changed = EINA_TRUE;
3412 _elm_win_focus_highlight_reconfigure_job_start(sd);
3416 _elm_win_focus_target_del(void *data,
3417 Evas *e EINA_UNUSED,
3418 Evas_Object *obj EINA_UNUSED,
3419 void *event_info EINA_UNUSED)
3421 ELM_WIN_DATA_GET(data, sd);
3423 sd->focus_highlight.cur.target = NULL;
3425 _elm_win_focus_highlight_reconfigure_job_start(sd);
3428 static Evas_Object *
3429 _elm_win_focus_target_get(Evas_Object *obj)
3431 Evas_Object *o = obj;
3435 if (elm_widget_is(o))
3437 if (!elm_widget_highlight_ignore_get(o))
3440 o = elm_widget_parent_widget_get(o);
3447 _elm_win_focus_target_callbacks_add(Efl_Ui_Win_Data *sd)
3449 Evas_Object *obj = sd->focus_highlight.cur.target;
3452 evas_object_event_callback_add
3453 (obj, EVAS_CALLBACK_MOVE, _elm_win_focus_target_move, sd->obj);
3454 evas_object_event_callback_add
3455 (obj, EVAS_CALLBACK_RESIZE, _elm_win_focus_target_resize, sd->obj);
3459 _elm_win_focus_target_callbacks_del(Efl_Ui_Win_Data *sd)
3461 Evas_Object *obj = sd->focus_highlight.cur.target;
3463 evas_object_event_callback_del_full
3464 (obj, EVAS_CALLBACK_MOVE, _elm_win_focus_target_move, sd->obj);
3465 evas_object_event_callback_del_full
3466 (obj, EVAS_CALLBACK_RESIZE, _elm_win_focus_target_resize, sd->obj);
3469 // TIZEN_ONLY(20171114) Accessibility Highlight Frame added
3471 _elm_win_accessibility_highlight_callbacks_add(Efl_Ui_Win_Data *sd)
3473 Evas_Object *obj = sd->accessibility_highlight.cur.target;
3475 evas_object_event_callback_add
3476 (obj, EVAS_CALLBACK_DEL, _elm_win_accessibility_highlight_obj_del, sd->obj);
3477 evas_object_event_callback_add
3478 (obj, EVAS_CALLBACK_MOVE, _elm_win_accessibility_highlight_obj_move, sd->obj);
3479 evas_object_event_callback_add
3480 (obj, EVAS_CALLBACK_RESIZE, _elm_win_accessibility_highlight_obj_resize, sd->obj);
3485 _elm_win_object_focus_in(void *data,
3486 Evas *e EINA_UNUSED,
3489 Evas_Object *obj = event_info, *target;
3490 ELM_WIN_DATA_GET(data, sd);
3492 if (sd->focus_highlight.cur.target == obj)
3495 target = _elm_win_focus_target_get(obj);
3496 sd->focus_highlight.cur.target = target;
3500 if (elm_widget_highlight_in_theme_get(target))
3501 sd->focus_highlight.cur.in_theme = EINA_TRUE;
3503 _elm_win_focus_target_callbacks_add(sd);
3504 evas_object_event_callback_add
3505 (target, EVAS_CALLBACK_DEL, _elm_win_focus_target_del, sd->obj);
3508 _elm_win_focus_highlight_reconfigure_job_start(sd);
3512 _elm_win_object_focus_out(void *data,
3513 Evas *e EINA_UNUSED,
3514 void *event_info EINA_UNUSED)
3516 ELM_WIN_DATA_GET(data, sd);
3518 if (!sd->focus_highlight.cur.target)
3521 if (!sd->focus_highlight.cur.in_theme)
3522 _elm_win_focus_target_callbacks_del(sd);
3524 evas_object_event_callback_del_full
3525 (sd->focus_highlight.cur.target,
3526 EVAS_CALLBACK_DEL, _elm_win_focus_target_del, sd->obj);
3528 sd->focus_highlight.cur.target = NULL;
3529 sd->focus_highlight.cur.in_theme = EINA_FALSE;
3531 _elm_win_focus_highlight_reconfigure_job_start(sd);
3535 _elm_win_focus_highlight_shutdown(Efl_Ui_Win_Data *sd)
3537 _elm_win_focus_highlight_reconfigure_job_stop(sd);
3538 if (sd->focus_highlight.cur.target)
3540 if (elm_widget_is_legacy(sd->obj))
3541 elm_widget_signal_emit(sd->focus_highlight.cur.target,
3542 "elm,action,focus_highlight,hide", "elm");
3544 elm_widget_signal_emit(sd->focus_highlight.cur.target,
3545 "efl,action,focus_highlight,hide", "efl");
3546 _elm_win_focus_target_callbacks_del(sd);
3547 evas_object_event_callback_del_full
3548 (sd->focus_highlight.cur.target,
3549 EVAS_CALLBACK_DEL, _elm_win_focus_target_del, sd->obj);
3550 sd->focus_highlight.cur.target = NULL;
3552 ELM_SAFE_FREE(sd->focus_highlight.fobj, evas_object_del);
3554 evas_event_callback_del_full
3555 (sd->evas, EVAS_CALLBACK_CANVAS_OBJECT_FOCUS_IN,
3556 _elm_win_object_focus_in, sd->obj);
3557 evas_event_callback_del_full
3558 (sd->evas, EVAS_CALLBACK_CANVAS_OBJECT_FOCUS_OUT,
3559 _elm_win_object_focus_out, sd->obj);
3563 _win_img_hide(void *data,
3564 Evas *e EINA_UNUSED,
3565 Evas_Object *obj EINA_UNUSED,
3566 void *event_info EINA_UNUSED)
3568 /* TIZEN_ONLY(20180607): Restore legacy focus
3569 Efl_Ui_Win *real_win = elm_widget_top_get(data);
3570 efl_ui_focus_manager_redirect_set(real_win, NULL);
3572 efl_ui_widget_focus_hide_handle(data);
3577 _win_img_mouse_up(void *data,
3578 Evas *e EINA_UNUSED,
3579 Evas_Object *obj EINA_UNUSED,
3582 Evas_Event_Mouse_Up *ev = event_info;
3583 if (!(ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD))
3584 elm_widget_focus_mouse_up_handle(evas_object_widget_parent_find(data));
3588 _win_img_focus_in(void *data,
3589 Evas *e EINA_UNUSED,
3590 Evas_Object *obj EINA_UNUSED,
3591 void *event_info EINA_UNUSED)
3593 /* TIZEN_ONLY(20180607): Restore legacy focus
3594 Efl_Ui_Win *real_win = elm_widget_top_get(data);
3595 efl_ui_focus_manager_redirect_set(real_win, data);
3596 efl_ui_focus_manager_focus_set(data, efl_ui_focus_manager_root_get(data));
3598 efl_ui_widget_focus_steal(data, NULL);
3603 _win_img_focus_out(void *data,
3604 Evas *e EINA_UNUSED,
3605 Evas_Object *obj EINA_UNUSED,
3606 void *event_info EINA_UNUSED)
3608 /* TIZEN_ONLY(20180607): Restore legacy focus
3609 Efl_Ui_Win *real_win = elm_widget_top_get(data);
3610 efl_ui_focus_manager_redirect_set(real_win, NULL);
3612 efl_ui_widget_focused_object_clear(data);
3617 _elm_win_on_img_obj_del(void *data,
3618 Evas *e EINA_UNUSED,
3619 Evas_Object *obj EINA_UNUSED,
3620 void *event_info EINA_UNUSED)
3622 ELM_WIN_DATA_GET(data, sd);
3623 _elm_win_img_callbacks_del(sd->obj, sd->img_obj);
3628 _elm_win_img_callbacks_del(Evas_Object *obj, Evas_Object *imgobj)
3630 if (!imgobj) return;
3631 evas_object_event_callback_del_full
3632 (imgobj, EVAS_CALLBACK_DEL, _elm_win_on_img_obj_del, obj);
3633 evas_object_event_callback_del_full
3634 (imgobj, EVAS_CALLBACK_HIDE, _win_img_hide, obj);
3635 evas_object_event_callback_del_full
3636 (imgobj, EVAS_CALLBACK_MOUSE_UP, _win_img_mouse_up, obj);
3637 evas_object_event_callback_del_full
3638 (imgobj, EVAS_CALLBACK_FOCUS_IN, _win_img_focus_in, obj);
3639 evas_object_event_callback_del_full
3640 (imgobj, EVAS_CALLBACK_FOCUS_OUT, _win_img_focus_out, obj);
3644 _efl_ui_win_efl_canvas_group_group_del(Eo *obj, Efl_Ui_Win_Data *sd)
3646 efl_event_freeze(sd->evas);
3648 if ((sd->modal) && (evas_object_visible_get(obj)))
3649 _elm_win_modality_decrement(sd);
3651 if ((sd->modal) && (sd->modal_count > 0))
3652 ERR("Deleted modal win was blocked by another modal win which was created after creation of that win.");
3654 evas_object_event_callback_del_full(sd->legacy.edje,
3655 EVAS_CALLBACK_CHANGED_SIZE_HINTS,
3656 _elm_win_on_resize_obj_changed_size_hints,
3659 efl_event_callback_array_del(sd->evas, _elm_evas_tracking(), sd);
3660 efl_event_callback_array_del(obj, _elm_win_evas_feed_fake_callbacks(), sd->evas);
3661 efl_event_callback_array_del(obj, _elm_win_tracking(), sd);
3662 evas_object_del(sd->legacy.box);
3663 evas_object_del(sd->legacy.edje);
3665 /* NB: child deletion handled by parent's smart del */
3667 if ((sd->type != EFL_UI_WIN_TYPE_FAKE) && (trap) && (trap->del))
3668 trap->del(sd->trap_data, obj);
3672 evas_object_event_callback_del_full
3673 (sd->parent, EVAS_CALLBACK_DEL, _elm_win_on_parent_del, obj);
3677 if (sd->autodel_clear) *(sd->autodel_clear) = -1;
3679 if (_elm_atspi_enabled())
3680 efl_access_window_destroyed_signal_emit(obj);
3682 _elm_win_list = eina_list_remove(_elm_win_list, obj);
3684 _elm_win_state_eval_queue();
3686 if (_elm_win_count == _paused_windows)
3687 efl_event_callback_call(efl_loop_get(obj), EFL_APP_EVENT_PAUSE, NULL);
3691 ecore_evas_callback_delete_request_set(sd->ee, NULL);
3692 ecore_evas_callback_resize_set(sd->ee, NULL);
3695 eina_stringshare_del(sd->shot.info);
3696 ecore_timer_del(sd->shot.timer);
3698 #ifdef HAVE_ELEMENTARY_X
3699 ecore_event_handler_del(sd->x.client_message_handler);
3700 ecore_event_handler_del(sd->x.property_handler);
3702 #ifdef HAVE_ELEMENTARY_WL2
3703 ecore_event_handler_del(sd->wl.configure_handler);
3704 if (sd->pointer.obj) evas_object_del(sd->pointer.obj);
3705 if (sd->pointer.ee) ecore_evas_free(sd->pointer.ee);
3706 sd->pointer.surf = NULL;
3707 //TIZEN_ONLY(20171110): added signal for effect start and done
3708 ecore_event_handler_del(sd->wl.effect_start_handler);
3709 ecore_event_handler_del(sd->wl.effect_end_handler);
3711 // TIZEN_ONLY(20160801): indicator implementation
3712 ecore_event_handler_del(sd->wl.indicator_flick_handler);
3714 // TIZEN_ONLY(20150722): added signal for aux_hint(auxiliary hint)
3715 ecore_event_handler_del(sd->wl.aux_msg_handler);
3718 #ifdef HAVE_ELEMENTARY_WIN32
3719 ecore_event_handler_del(sd->win32.key_down_handler);
3722 if (sd->type == ELM_WIN_INLINED_IMAGE)
3724 _elm_win_img_callbacks_del(obj, sd->img_obj);
3728 //TIZEN_ONLY(20211108): delete ecore_evas when inlined image window is deleted
3729 if (sd->ee && (sd->type != EFL_UI_WIN_TYPE_FAKE))
3731 ecore_evas_manual_render_set(sd->ee, EINA_TRUE);
3732 edje_object_freeze(sd->frame_obj);
3733 ecore_job_add(_deferred_ecore_evas_free, sd->ee);
3734 _elm_win_deferred_free++;
3738 _elm_win_focus_highlight_shutdown(sd);
3739 // TIZEN_ONLY(20171114) Accessibility Highlight Frame added
3740 // //TIZEN_ONLY(20171108): bring HIGHLIGHT related changes
3741 // _elm_win_accessibility_highlight_shutdown(sd);
3744 eina_stringshare_del(sd->focus_highlight.style);
3746 eina_stringshare_del(sd->title);
3747 eina_stringshare_del(sd->icon_name);
3748 eina_stringshare_del(sd->role);
3749 eina_stringshare_del(sd->name);
3750 eina_stringshare_del(sd->accel_pref);
3751 eina_stringshare_del(sd->stack_id);
3752 eina_stringshare_del(sd->stack_master_id);
3753 evas_object_del(sd->icon);
3754 evas_object_del(sd->main_menu);
3755 evas_object_del(sd->indicator);
3757 sd->focus_highlight.style = NULL;
3759 sd->icon_name = NULL;
3763 sd->main_menu = NULL;
3765 _elm_win_profile_del(sd);
3766 _elm_win_available_profiles_del(sd);
3767 eina_array_free(sd->profile.available);
3768 sd->profile.available = NULL;
3770 eina_array_free(sd->planned_changes);
3771 sd->planned_changes = NULL;
3773 free(sd->wm_rot.rots);
3774 sd->wm_rot.rots = NULL;
3776 /* Don't let callback in the air that point to sd */
3779 ecore_evas_callback_mouse_in_set(sd->ee, NULL);
3780 ecore_evas_callback_focus_in_set(sd->ee, NULL);
3781 ecore_evas_callback_focus_out_set(sd->ee, NULL);
3782 ecore_evas_callback_move_set(sd->ee, NULL);
3783 ecore_evas_callback_state_change_set(sd->ee, NULL);
3784 ecore_evas_callback_pre_render_set(sd->ee, NULL);
3787 efl_canvas_group_del(efl_super(obj, MY_CLASS));
3789 if (eina_value_type_get(&sd->exit_on_close))
3790 efl_loop_quit(efl_loop_get(obj), sd->exit_on_close);
3791 else if (!_elm_win_list)
3793 if (elm_policy_get(ELM_POLICY_QUIT) == ELM_POLICY_QUIT_LAST_WINDOW_CLOSED)
3794 _elm_win_flush_cache_and_exit(obj);
3798 efl_event_callback_call(efl_app_main_get(), EFL_APP_EVENT_STANDBY, NULL);
3799 if (eina_value_type_get(&exit_on_all_windows_closed))
3800 efl_loop_quit(efl_loop_get(obj), exit_on_all_windows_closed);
3804 /* TIZEN_ONLY(20190520): Support Atomic geometry change */
3806 _efl_ui_win_efl_gfx_entity_geometry_set(Eo *obj, Efl_Ui_Win_Data *sd, Eina_Rect r)
3809 Eina_Rect r2 = efl_gfx_entity_geometry_get(obj);
3810 efl_gfx_entity_geometry_set(efl_super(obj, MY_CLASS), r);
3813 //Both position and size has been changed, Request atomic move/resize
3814 if (((r.x != r2.x) || (r.y != r2.y)) && ((r.w != r2.w) || (r.h != r2.h)))
3815 ecore_evas_move_resize(sd->ee, r.x, r.y, r.w, r.h);
3817 /* End of TIZEN_ONLY */
3820 _efl_ui_win_efl_gfx_entity_position_set(Eo *obj, Efl_Ui_Win_Data *sd, Eina_Position2D pos)
3822 if (_evas_object_intercept_call(obj, EVAS_OBJECT_INTERCEPT_CB_MOVE, 0, pos.x, pos.y))
3827 if ((pos.x != sd->screen.x) || (pos.y != sd->screen.y))
3829 sd->screen.x = pos.x;
3830 sd->screen.y = pos.y;
3831 efl_event_callback_call(obj, EFL_GFX_ENTITY_EVENT_POSITION_CHANGED, &pos);
3832 evas_object_smart_callback_call(obj, "move", NULL);
3840 sd->req_xy = EINA_TRUE;
3843 TRAP(sd, move, pos.x, pos.y);
3844 // TIZEN_ONLY(20180424): set window position
3845 #ifdef HAVE_ELEMENTARY_WL2
3846 ecore_wl2_window_position_set(sd->wl.win, pos.x, pos.y);
3850 if (!ecore_evas_override_get(sd->ee)) goto super_skip;
3853 efl_gfx_entity_position_set(efl_super(obj, MY_CLASS), pos);
3855 if (ecore_evas_override_get(sd->ee))
3857 sd->screen.x = pos.x;
3858 sd->screen.y = pos.y;
3859 efl_event_callback_call(obj, EFL_GFX_ENTITY_EVENT_POSITION_CHANGED, &pos);
3860 evas_object_smart_callback_call(obj, "move", NULL);
3864 #ifdef HAVE_ELEMENTARY_WL2
3865 // TIZEN_ONLY(20180424): set window position
3866 ecore_wl2_window_position_set(sd->wl.win, pos.x, pos.y);
3869 /* ecore_wl_window_update_location(sd->wl.win, x, y); */
3871 sd->screen.x = pos.x;
3872 sd->screen.y = pos.y;
3876 sd->screen.x = pos.x;
3877 sd->screen.y = pos.y;
3883 /* FIXME FIXME FIXME
3884 * Ugly code flow: legacy code had an early return in smart_move, ie.
3885 * evas object move would be processed but smart object move would be
3886 * aborted. This super call tries to simulate that. */
3887 efl_gfx_entity_position_set(efl_super(obj, EFL_CANVAS_GROUP_CLASS), pos);
3891 _efl_ui_win_efl_gfx_entity_size_set(Eo *obj, Efl_Ui_Win_Data *sd, Eina_Size2D sz)
3893 if (_evas_object_intercept_call(obj, EVAS_OBJECT_INTERCEPT_CB_RESIZE, 0, sz.w, sz.h))
3902 ecore_evas_screen_geometry_get(sd->ee, NULL, NULL, &sw, &sh);
3903 sz.w = MIN(sz.w, sw);
3904 sz.h = MIN(sz.h, sh);
3906 if (sz.w < 1) sz.w = 1;
3907 if (sz.h < 1) sz.h = 1;
3909 evas_object_image_size_set(sd->img_obj, sz.w, sz.h);
3912 _elm_win_frame_obj_update(sd, 1);
3915 sd->req_wh = EINA_TRUE;
3918 //TIZEN_ONLY(20221228): add resize request set for ignoring configure event
3919 if (sz.w > 1 && sz.h > 1 && !sd->frame_obj)
3921 if ((sd->rot == 0) || (sd->rot == 180))
3923 ERR("Call resize request set w: %d h: %d", sz.w, sz.h);
3924 ecore_wl2_window_resize_request_set(sd->wl.win, sz.w, sz.h);
3928 ERR("Call resize request set w: %d h: %d", sz.h, sz.w);
3929 ecore_wl2_window_resize_request_set(sd->wl.win, sz.h, sz.w);
3933 TRAP(sd, resize, sz.w, sz.h);
3936 efl_gfx_entity_size_set(efl_super(obj, MY_CLASS), sz);
3937 /* if window is hidden during a resize,
3938 * revert to initial state where pre-render triggers recalc and other resizes are deferred
3940 if (efl_gfx_entity_visible_get(obj)) return;
3941 if (!sd->first_draw) return;
3942 sd->first_draw = EINA_FALSE;
3943 edje_object_freeze(sd->frame_obj);
3947 _elm_win_delete_request(Ecore_Evas *ee)
3949 Efl_Ui_Win_Data *sd = _elm_win_associate_get(ee);
3956 int autodel = sd->autodel;
3957 sd->autodel_clear = &autodel;
3958 evas_object_ref(obj);
3959 efl_event_callback_legacy_call(obj, EFL_UI_WIN_EVENT_DELETE_REQUEST, NULL);
3960 ELM_WIN_DATA_ALIVE_CHECK(obj, sd);
3962 evas_object_hide(obj);
3963 ELM_WIN_DATA_ALIVE_CHECK(obj, sd);
3964 if (_elm_atspi_enabled())
3965 efl_access_window_destroyed_signal_emit(obj);
3966 ELM_WIN_DATA_ALIVE_CHECK(obj, sd);
3967 if (autodel) evas_object_del(obj);
3968 else sd->autodel_clear = NULL;
3969 evas_object_unref(obj);
3972 // TIZEN_ONLY(20150722): added signal for aux_hint(auxiliary hint)
3973 struct _Elm_Win_Aux_Message
3980 #ifdef HAVE_ELEMENTARY_WL2
3982 _elm_win_wlwindow_get(Efl_Ui_Win_Data *sd)
3984 Ecore_Wl2_Window *pwin = sd->wl.win;
3985 sd->wl.win = _elm_ee_wlwin_get(sd->ee);
3986 if (sd->wl.win != pwin)
3991 snprintf(buf, sizeof(buf), "%u||%p", getpid(), sd->wl.win);
3992 eina_stringshare_replace(&sd->stack_id, buf);
3993 id = ecore_evas_aux_hint_id_get(sd->ee, "stack_id");
3994 if (id >= 0) ecore_evas_aux_hint_val_set(sd->ee, id, sd->stack_id);
3995 else ecore_evas_aux_hint_add(sd->ee, "stack_id", sd->stack_id);
4000 _elm_win_wl_cursor_set(Evas_Object *obj, const char *cursor)
4002 ELM_WIN_DATA_GET(obj, sd);
4006 if (sd->pointer.obj)
4008 Evas_Coord mw = 1, mh = 1, hx = 0, hy = 0;
4012 if (elm_widget_theme_object_set(sd->obj, sd->pointer.obj,
4013 "cursor", cursor, "default"))
4015 elm_widget_theme_object_set(sd->obj, sd->pointer.obj,
4016 "pointer", "base", "default");
4020 elm_widget_theme_object_set(sd->obj, sd->pointer.obj,
4021 "pointer", "base", "default");
4023 edje_object_size_min_get(sd->pointer.obj, &mw, &mh);
4024 edje_object_size_min_restricted_calc(sd->pointer.obj, &mw, &mh, mw, mh);
4025 if ((mw < 32) || (mh < 32))
4030 evas_object_geometry_set(sd->pointer.obj, 0, 0, mw, mh);
4031 if (elm_widget_is_legacy(obj))
4032 edje_object_part_geometry_get(sd->pointer.obj,
4033 "elm.swallow.hotspot",
4034 &hx, &hy, NULL, NULL);
4036 edje_object_part_geometry_get(sd->pointer.obj,
4038 &hx, &hy, NULL, NULL);
4040 sd->pointer.hot_x = hx;
4041 sd->pointer.hot_y = hy;
4043 ecore_evas_resize(sd->pointer.ee, mw, mh);
4046 if ((sd->wl.win) && (sd->pointer.surf) && (sd->pointer.visible))
4048 /* FIXME: multiseat */
4049 Ecore_Wl2_Input *input;
4052 /* FIXME: Here be dragons...
4053 pointer_set_cursor is totally unsynchronized, and on a cursor
4054 change we get here before the new cursor is rendered. So
4055 the cursor frequently moves to its new hotspot with the old
4056 cursor image, causing an ugly jump.
4057 Forcing manual render causes us to render first then set the
4058 cursor, which is still racey but far more likely to win the
4060 The right way to do this is to create an entirely new surface
4061 on every cursor change.
4063 ecore_evas_manual_render(sd->pointer.ee);
4064 it = ecore_wl2_display_inputs_get(ecore_wl2_window_display_get(sd->wl.win));
4065 EINA_ITERATOR_FOREACH(it, input)
4066 ecore_wl2_input_pointer_set(input, sd->pointer.surf, sd->pointer.hot_x, sd->pointer.hot_y);
4067 eina_iterator_free(it);
4071 // TIZEN_ONLY(20171109):allow changing window type after initializing
4073 _elm_win_wlwin_type_update(Efl_Ui_Win_Data *sd)
4075 Ecore_Wl2_Window_Type wtype;
4078 if (!sd->wl.win) return;
4079 if (sd->type == ELM_WIN_FAKE) return;
4084 case ELM_WIN_TOOLBAR:
4085 wtype = ECORE_WL2_WINDOW_TYPE_TOPLEVEL;
4087 case ELM_WIN_DESKTOP:
4088 wtype = ECORE_WL2_WINDOW_TYPE_DESKTOP;
4090 case ELM_WIN_UTILITY:
4091 wtype = ECORE_WL2_WINDOW_TYPE_UTILITY;
4093 case ELM_WIN_DIALOG_BASIC:
4094 wtype = ECORE_WL2_WINDOW_TYPE_DIALOG;
4097 wtype = ECORE_WL2_WINDOW_TYPE_DOCK;
4099 case ELM_WIN_SPLASH:
4100 wtype = ECORE_WL2_WINDOW_TYPE_SPLASH;
4102 case ELM_WIN_TOOLTIP:
4105 case ELM_WIN_POPUP_MENU:
4106 wtype = ECORE_WL2_WINDOW_TYPE_MENU;
4109 wtype = ECORE_WL2_WINDOW_TYPE_DND;
4111 case ELM_WIN_NOTIFICATION:
4112 wtype = ECORE_WL2_WINDOW_TYPE_NOTIFICATION;
4115 wtype = ECORE_WL2_WINDOW_TYPE_NONE;
4117 ecore_wl2_window_type_set(sd->wl.win, wtype);
4122 _elm_win_wl_aux_message(void *data, int type EINA_UNUSED, void *event)
4124 ELM_WIN_DATA_GET(data, sd);
4125 Ecore_Wl2_Event_Aux_Message *ev = event;
4126 Elm_Win_Aux_Message *msg = NULL;
4127 const char *opt = NULL, *tmp = NULL;
4130 if (!sd->wl.win) return ECORE_CALLBACK_PASS_ON;
4132 if ((ecore_wl2_window_id_get(sd->wl.win) != (int)ev->win))
4133 return ECORE_CALLBACK_PASS_ON;
4135 msg = calloc(1, sizeof(*msg));
4136 if (!msg) return ECORE_CALLBACK_PASS_ON;
4138 msg->key = eina_stringshare_add(ev->key);
4139 msg->val = eina_stringshare_add(ev->val);
4141 EINA_LIST_FOREACH(ev->options, l, opt)
4144 tmp = eina_stringshare_add(opt);
4145 msg->options = eina_list_append(msg->options, tmp);
4148 evas_object_smart_callback_call(sd->obj, SIG_AUX_MESSAGE_RECEIVED, (void*)msg);
4150 eina_stringshare_del(msg->key);
4151 eina_stringshare_del(msg->val);
4152 EINA_LIST_FREE(msg->options, opt)
4153 eina_stringshare_del(opt);
4156 return ECORE_CALLBACK_PASS_ON;
4158 // END of TIZEN_ONLY(20150722)
4161 Ecore_Cocoa_Window *
4162 _elm_ee_cocoa_win_get(const Ecore_Evas *ee)
4164 #ifdef HAVE_ELEMENTARY_COCOA
4165 const char *engine_name;
4167 if (!ee) return NULL;
4169 engine_name = ecore_evas_engine_name_get(ee);
4170 if (EINA_UNLIKELY(!engine_name)) return NULL;
4172 if (!strcmp(engine_name, "opengl_cocoa") ||
4173 !strcmp(engine_name, "gl_cocoa"))
4174 return ecore_evas_cocoa_window_get(ee);
4181 Ecore_Win32_Window *
4182 _elm_ee_win32win_get(const Ecore_Evas *ee)
4184 #ifdef HAVE_ELEMENTARY_WIN32
4185 const char *engine_name;
4187 if (!ee) return NULL;
4189 engine_name = ecore_evas_engine_name_get(ee);
4190 if (EINA_UNLIKELY(!engine_name)) return NULL;
4192 if ((!strcmp(engine_name, ELM_SOFTWARE_WIN32)) ||
4193 (!strcmp(engine_name, ELM_SOFTWARE_DDRAW)))
4195 return ecore_evas_win32_window_get(ee);
4203 #ifdef HAVE_ELEMENTARY_COCOA
4205 _elm_win_cocoawindow_get(Efl_Ui_Win_Data *sd)
4207 sd->cocoa.win = _elm_ee_cocoa_win_get(sd->ee);
4211 #ifdef HAVE_ELEMENTARY_WIN32
4213 _internal_elm_win_win32window_get(Efl_Ui_Win_Data *sd)
4215 sd->win32.win = _elm_ee_win32win_get(sd->ee);
4219 #ifdef HAVE_ELEMENTARY_X
4221 _elm_win_xwin_update(Efl_Ui_Win_Data *sd)
4225 if (sd->type == EFL_UI_WIN_TYPE_FAKE) return;
4226 _internal_elm_win_xwindow_get(sd);
4228 if (!sd->x.xwin) return; /* nothing more to do */
4229 _internal_elm_win_xwindow_get(sd);
4231 if (sd->stack_master_id)
4233 Ecore_X_Window win = strtol(sd->stack_master_id, NULL, 16);
4236 ecore_x_icccm_transient_for_set(sd->x.xwin, win);
4238 ecore_x_e_stack_type_set(sd->x.xwin, ECORE_X_STACK_BASE);
4240 ecore_x_e_stack_type_set(sd->x.xwin, ECORE_X_STACK_STANDARD);
4247 ELM_WIN_DATA_GET(sd->parent, sdp);
4250 _internal_elm_win_xwindow_get(sdp);
4251 ecore_x_icccm_transient_for_set(sd->x.xwin, sdp->x.xwin);
4257 if (!s) s = _elm_appname;
4259 if (sd->icon_name) s = sd->icon_name;
4260 ecore_x_icccm_icon_name_set(sd->x.xwin, s);
4261 ecore_x_netwm_icon_name_set(sd->x.xwin, s);
4264 if (s) ecore_x_icccm_window_role_set(sd->x.xwin, s);
4271 if (efl_isa(sd->icon, EFL_CANVAS_IMAGE_INTERNAL_CLASS))
4273 else if (efl_isa(sd->icon, EFL_UI_IMAGE_CLASS))
4274 image = elm_image_object_get(sd->icon);
4278 int w = 0, h = 0, stride, x, y;
4279 Eina_Bool unmap = EINA_FALSE;
4280 Eina_Rw_Slice sl = {};
4282 if (efl_isa(image, EFL_CANVAS_IMAGE_CLASS))
4284 Eina_Rect rect = {};
4287 rect.size = efl_gfx_buffer_size_get(image);
4288 sl = efl_gfx_buffer_map(image, EFL_GFX_BUFFER_ACCESS_MODE_READ,
4289 &rect, EFL_GFX_COLORSPACE_ARGB8888, 0,
4296 evas_object_image_size_get(image, &w, &h);
4297 stride = evas_object_image_stride_get(image);
4298 sl.mem = evas_object_image_data_get(image, EINA_FALSE);
4307 if ((w > 0) && (h > 0) &&
4308 (stride >= (int)(w * sizeof(unsigned int))))
4310 if (stride == (int)(w * sizeof(unsigned int)))
4313 ecore_x_netwm_icons_set(sd->x.xwin, &ic, 1);
4317 ic.data = malloc(w * h * sizeof(unsigned int));
4320 unsigned char *p = sl.mem;
4321 unsigned int *p2 = ic.data;
4323 for (y = 0; y < h; y++)
4325 for (x = 0; x < w; x++)
4327 *p2 = *((unsigned int *)p);
4328 p += sizeof(unsigned int);
4331 p += (stride - (w * sizeof(unsigned int)));
4333 ecore_x_netwm_icons_set(sd->x.xwin, &ic, 1);
4338 if (unmap) efl_gfx_buffer_unmap(image, sl);
4339 else evas_object_image_data_set(image, sl.mem);
4347 ecore_x_netwm_window_type_set(sd->x.xwin, ECORE_X_WINDOW_TYPE_NORMAL);
4350 case ELM_WIN_DIALOG_BASIC:
4351 ecore_x_netwm_window_type_set(sd->x.xwin, ECORE_X_WINDOW_TYPE_DIALOG);
4354 case ELM_WIN_DESKTOP:
4355 ecore_x_netwm_window_type_set(sd->x.xwin, ECORE_X_WINDOW_TYPE_DESKTOP);
4359 ecore_x_netwm_window_type_set(sd->x.xwin, ECORE_X_WINDOW_TYPE_DOCK);
4362 case ELM_WIN_TOOLBAR:
4363 ecore_x_netwm_window_type_set(sd->x.xwin, ECORE_X_WINDOW_TYPE_TOOLBAR);
4367 ecore_x_netwm_window_type_set(sd->x.xwin, ECORE_X_WINDOW_TYPE_MENU);
4370 case ELM_WIN_UTILITY:
4371 ecore_x_netwm_window_type_set(sd->x.xwin, ECORE_X_WINDOW_TYPE_UTILITY);
4374 case ELM_WIN_SPLASH:
4375 ecore_x_netwm_window_type_set(sd->x.xwin, ECORE_X_WINDOW_TYPE_SPLASH);
4378 case ELM_WIN_DROPDOWN_MENU:
4379 ecore_x_netwm_window_type_set
4380 (sd->x.xwin, ECORE_X_WINDOW_TYPE_DROPDOWN_MENU);
4383 case ELM_WIN_POPUP_MENU:
4384 ecore_x_netwm_window_type_set
4385 (sd->x.xwin, ECORE_X_WINDOW_TYPE_POPUP_MENU);
4388 case ELM_WIN_TOOLTIP:
4389 ecore_x_netwm_window_type_set(sd->x.xwin, ECORE_X_WINDOW_TYPE_TOOLTIP);
4390 ecore_x_window_shape_input_rectangle_set(sd->x.xwin, 0, 0, 0, 0);
4393 case ELM_WIN_NOTIFICATION:
4394 ecore_x_netwm_window_type_set
4395 (sd->x.xwin, ECORE_X_WINDOW_TYPE_NOTIFICATION);
4399 ecore_x_netwm_window_type_set(sd->x.xwin, ECORE_X_WINDOW_TYPE_COMBO);
4403 ecore_x_netwm_window_type_set(sd->x.xwin, ECORE_X_WINDOW_TYPE_DND);
4409 ecore_x_e_virtual_keyboard_state_set
4410 (sd->x.xwin, (Ecore_X_Virtual_Keyboard_State)sd->kbdmode);
4411 if (sd->legacy.indmode == ELM_WIN_INDICATOR_SHOW)
4412 ecore_x_e_illume_indicator_state_set
4413 (sd->x.xwin, ECORE_X_ILLUME_INDICATOR_STATE_ON);
4414 else if (sd->legacy.indmode == ELM_WIN_INDICATOR_HIDE)
4415 ecore_x_e_illume_indicator_state_set
4416 (sd->x.xwin, ECORE_X_ILLUME_INDICATOR_STATE_OFF);
4418 if ((sd->wm_rot.count) && (sd->wm_rot.rots))
4419 ecore_evas_wm_rotation_available_rotations_set(sd->ee,
4422 if (sd->wm_rot.preferred_rot != -1)
4423 ecore_evas_wm_rotation_preferred_rotation_set(sd->ee,
4424 sd->wm_rot.preferred_rot);
4426 #ifdef HAVE_ELEMENTARY_X
4427 if (sd->csd.need && sd->x.xwin)
4428 TRAP(sd, borderless_set, EINA_TRUE);
4437 * Resize the window according to window layout's min and weight.
4438 * If the window layout's weight is 0.0, the window max is limited to layout's
4441 * This is called when the window layout's weight hint is changed or when the
4442 * window is rotated.
4444 * @param obj window object
4447 _elm_win_resize_objects_eval(Evas_Object *obj, Eina_Bool force_resize)
4449 Efl_Ui_Win_Data *sd = efl_data_scope_get(obj, MY_CLASS);
4450 Evas_Coord w, h, minw, minh, maxw, maxh, ow, oh;
4451 Eina_Bool unresizable;
4454 evas_object_size_hint_combined_min_get(sd->legacy.edje, &minw, &minh);
4455 if ((!minw) && (!minh) && (!sd->deferred_resize_job) && (!force_resize)) return;
4457 efl_gfx_hint_size_restricted_max_set(obj, EINA_SIZE2D(-1, -1));
4458 // If content has a weight, make resizable
4459 efl_gfx_hint_weight_get(sd->legacy.edje, &wx, &wy);
4461 // Content max hint is ignored
4465 // Compatibility hack (for E)
4466 if (sd->single_edje_content && EINA_DBL_EQ(wx, 0) && EINA_DBL_EQ(wy, 0))
4469 if (EINA_DBL_EQ(wx, 0)) maxw = minw;
4470 if (maxw < 1) maxw = 32767;
4471 if (EINA_DBL_EQ(wy, 0)) maxh = minh;
4472 if (maxh < 1) maxh = 32767;
4473 if (maxw < minw) maxw = minw;
4474 if (maxh < minh) maxh = minh;
4475 if (maxw > 32767) maxw = 32767;
4476 if (maxh > 32767) maxh = 32767;
4478 unresizable = ((minw == maxw) && (minh == maxh));
4480 if (sd->csd.need_unresizable != unresizable)
4482 sd->csd.need_unresizable = unresizable;
4483 _elm_win_frame_style_update(sd, 0, 1);
4486 sd->tmp_updating_hints = 1;
4487 efl_gfx_hint_size_restricted_min_set(obj, EINA_SIZE2D(minw, minh));
4488 efl_gfx_hint_size_restricted_max_set(obj, EINA_SIZE2D(maxw, maxh));
4489 sd->tmp_updating_hints = 0;
4490 _elm_win_size_hints_update(obj, sd);
4492 /* do not need to go below. if you go, ee could become 0. */
4493 if ((!minw) && (!minh) && (!force_resize)) return;
4495 evas_object_geometry_get(obj, NULL, NULL, &ow, &oh);
4498 if (w < minw) w = minw;
4499 if (h < minh) h = minh;
4500 if (w > maxw) w = maxw;
4501 if (h > maxh) h = maxh;
4502 if (!force_resize && (w == ow) && (h == oh))
4505 sd->req_wh = EINA_FALSE;
4506 if (sd->img_obj) evas_object_resize(obj, w, h);
4509 _elm_win_frame_geometry_adjust(sd);
4512 sd->req_wh = EINA_TRUE;
4515 TRAP(sd, resize, w, h);
4521 _elm_win_on_resize_obj_changed_size_hints(void *data,
4522 Evas *e EINA_UNUSED,
4523 Evas_Object *obj EINA_UNUSED,
4524 void *event_info EINA_UNUSED)
4526 _elm_win_resize_objects_eval(data, EINA_FALSE);
4530 _elm_win_shutdown(void)
4532 while (_elm_win_list)
4534 Eina_List *itr = _elm_win_list;
4535 evas_object_del(itr->data);
4536 if (_elm_win_list == itr)
4538 _elm_win_list = eina_list_remove_list(_elm_win_list, _elm_win_list);
4541 /*TIZEN_ONLY(20171113):Use ecore_job instead of ecore_timer
4542 ELM_SAFE_FREE(_elm_win_state_eval_timer, ecore_timer_del);
4544 ELM_SAFE_FREE(_elm_win_state_eval_job, ecore_job_del);
4549 _elm_win_rescale(Elm_Theme *th,
4550 Eina_Bool use_theme)
4557 EINA_LIST_FOREACH(_elm_win_list, l, obj)
4558 elm_widget_theme(obj);
4562 EINA_LIST_FOREACH(_elm_win_list, l, obj)
4563 elm_widget_theme_specific(obj, th, EINA_FALSE);
4568 _elm_win_access(Eina_Bool is_access)
4575 EINA_LIST_FOREACH(_elm_win_list, l, obj)
4577 elm_widget_access(obj, is_access);
4579 /* floating orphan object. if there are A, B, C objects and user does
4580 as below, then there would be floating orphan objects.
4582 1. elm_object_content_set(layout, A);
4583 2. elm_object_content_set(layout, B);
4584 3. elm_object_content_set(layout, C);
4586 now, the object A and B are floating orphan objects */
4591 fobj = evas_object_below_get(fobj);
4594 if (elm_widget_is(fobj) && !elm_widget_parent_get(fobj))
4596 elm_widget_access(fobj, is_access);
4602 evas = evas_object_evas_get(obj);
4603 if (evas) _elm_access_object_highlight_disable(evas);
4608 //TIZEN_ONLY(20160822): When atspi mode is dynamically switched on/off,
4609 //register/unregister access objects accordingly.
4611 _elm_win_screen_reader(Eina_Bool is_screen_reader)
4617 EINA_LIST_FOREACH(_elm_win_list, l, obj)
4619 elm_widget_screen_reader(obj, is_screen_reader);
4620 evas_object_smart_callback_call(obj, SIG_ATSPI_SCREEN_READER_CHANGED, NULL);
4622 /* floating orphan object. if there are A, B, C objects and user does
4623 as below, then there would be floating orphan objects.
4625 1. elm_object_content_set(layout, A);
4626 2. elm_object_content_set(layout, B);
4627 3. elm_object_content_set(layout, C);
4629 now, the object A and B are floating orphan objects */
4634 fobj = evas_object_below_get(fobj);
4637 if (elm_widget_is(fobj) && !elm_widget_parent_get(fobj))
4639 elm_widget_screen_reader(fobj, is_screen_reader);
4643 if (!is_screen_reader)
4645 Evas_Object *ptr = _elm_object_accessibility_currently_highlighted_get();
4647 efl_access_component_highlight_clear(ptr);
4655 //TIZEN_ONLY(20170621) handle atspi proxy connection at runtime
4657 _elm_win_atspi(Eina_Bool is_atspi)
4661 Efl_Access_State_Set ss;
4663 EINA_LIST_FOREACH(_elm_win_list, l, obj)
4667 _access_socket_proxy_del(obj);
4671 _access_socket_proxy_listen(obj);
4672 ss = efl_access_object_state_set_get(obj);
4673 if (STATE_TYPE_GET(ss, EFL_ACCESS_STATE_TYPE_ACTIVE))
4675 efl_access_window_activated_signal_emit(obj);
4676 efl_access_state_changed_signal_emit(obj, EFL_ACCESS_STATE_TYPE_ACTIVE, EINA_TRUE);
4680 Efl_Access_Role role;
4681 role = efl_access_object_role_get(obj);
4682 if (role == EFL_ACCESS_ROLE_INPUT_METHOD_WINDOW)
4684 efl_access_window_activated_signal_emit(obj);
4685 efl_access_state_changed_signal_emit(obj, EFL_ACCESS_STATE_TYPE_ACTIVE, EINA_TRUE);
4689 elm_widget_atspi(obj, is_atspi);
4697 _elm_win_translate(void)
4702 /* TIZEN_ONLY(20180117): Apply paragraph direction according to locale
4703 EINA_LIST_FOREACH(_elm_win_list, l, obj)
4704 efl_ui_l10n_translation_update(obj);
4706 EINA_LIST_FOREACH(_elm_win_list, l, obj)
4708 if (!strcmp(E_("default:LTR"), "default:RTL"))
4709 efl_canvas_object_paragraph_direction_set(obj, EVAS_BIDI_DIRECTION_ANY_RTL);
4711 efl_canvas_object_paragraph_direction_set(obj, EVAS_BIDI_DIRECTION_LTR);
4713 efl_ui_l10n_translation_update(obj);
4717 //TIZEN_ONLY(20161202): Temporary code - Apply mirroring in _elm_win_translate()
4718 if (_elm_config && _elm_config->language_auto_mirrored)
4720 if (!strcmp(E_("default:LTR"), "default:RTL"))
4721 elm_config_mirrored_set(EINA_TRUE);
4723 elm_config_mirrored_set(EINA_FALSE);
4728 #ifdef HAVE_ELEMENTARY_X
4730 _elm_win_client_message(void *data,
4731 int type EINA_UNUSED,
4734 ELM_WIN_DATA_GET(data, sd);
4735 Ecore_X_Event_Client_Message *e = event;
4737 if (e->format != 32) return ECORE_CALLBACK_PASS_ON;
4738 _internal_elm_win_xwindow_get(sd);
4739 if (e->message_type == ECORE_X_ATOM_E_COMP_FLUSH)
4741 if ((unsigned int)e->data.l[0] == sd->x.xwin)
4743 Evas *evas = evas_object_evas_get(sd->obj);
4746 edje_file_cache_flush();
4747 edje_collection_cache_flush();
4748 evas_image_cache_flush(evas);
4749 evas_font_cache_flush(evas);
4753 else if (e->message_type == ECORE_X_ATOM_E_COMP_DUMP)
4755 if ((unsigned int)e->data.l[0] == sd->x.xwin)
4757 Evas *evas = evas_object_evas_get(sd->obj);
4760 edje_file_cache_flush();
4761 edje_collection_cache_flush();
4762 evas_image_cache_flush(evas);
4763 evas_font_cache_flush(evas);
4764 evas_render_dump(evas);
4768 else if (e->message_type == ECORE_X_ATOM_E_ILLUME_ACCESS_CONTROL)
4770 if ((unsigned int)e->data.l[0] == sd->x.xwin)
4772 if ((unsigned int)e->data.l[1] ==
4773 ECORE_X_ATOM_E_ILLUME_ACCESS_ACTION_NEXT)
4775 // XXX: call right access func
4777 else if ((unsigned int)e->data.l[1] ==
4778 ECORE_X_ATOM_E_ILLUME_ACCESS_ACTION_PREV)
4780 // XXX: call right access func
4782 else if ((unsigned int)e->data.l[1] ==
4783 ECORE_X_ATOM_E_ILLUME_ACCESS_ACTION_ACTIVATE)
4785 _elm_access_highlight_object_activate
4786 (sd->obj, EFL_UI_ACTIVATE_DEFAULT);
4788 else if ((unsigned int)e->data.l[1] ==
4789 ECORE_X_ATOM_E_ILLUME_ACCESS_ACTION_READ)
4791 /* there would be better way to read highlight object */
4793 evas = evas_object_evas_get(sd->obj);
4794 if (!evas) return ECORE_CALLBACK_PASS_ON;
4796 _elm_access_mouse_event_enabled_set(EINA_TRUE);
4798 evas_event_feed_mouse_in(evas, 0, NULL);
4799 evas_event_feed_mouse_move
4800 (evas, e->data.l[2], e->data.l[3], 0, NULL);
4802 _elm_access_mouse_event_enabled_set(EINA_FALSE);
4804 else if ((unsigned int)e->data.l[1] ==
4805 ECORE_X_ATOM_E_ILLUME_ACCESS_ACTION_READ_NEXT)
4807 _elm_access_highlight_cycle(sd->obj, ELM_FOCUS_NEXT);
4809 else if ((unsigned int)e->data.l[1] ==
4810 ECORE_X_ATOM_E_ILLUME_ACCESS_ACTION_READ_PREV)
4812 _elm_access_highlight_cycle(sd->obj, ELM_FOCUS_PREVIOUS);
4814 else if ((unsigned int)e->data.l[1] ==
4815 ECORE_X_ATOM_E_ILLUME_ACCESS_ACTION_UP)
4817 _elm_access_highlight_object_activate
4818 (sd->obj, EFL_UI_ACTIVATE_UP);
4820 else if ((unsigned int)e->data.l[1] ==
4821 ECORE_X_ATOM_E_ILLUME_ACCESS_ACTION_DOWN)
4823 _elm_access_highlight_object_activate
4824 (sd->obj, EFL_UI_ACTIVATE_DOWN);
4828 return ECORE_CALLBACK_PASS_ON;
4832 _elm_win_property_change(void *data,
4833 int type EINA_UNUSED,
4836 ELM_WIN_DATA_GET(data, sd);
4837 Ecore_X_Event_Window_Property *e = event;
4839 if (e->atom == ECORE_X_ATOM_E_ILLUME_INDICATOR_STATE)
4841 _internal_elm_win_xwindow_get(sd);
4842 if (e->win == sd->x.xwin)
4844 sd->legacy.indmode = (Elm_Win_Indicator_Mode)ecore_x_e_illume_indicator_state_get(e->win);
4845 efl_event_callback_legacy_call
4846 (sd->obj, EFL_UI_WIN_EVENT_INDICATOR_PROP_CHANGED, NULL);
4849 return ECORE_CALLBACK_PASS_ON;
4853 #ifdef HAVE_ELEMENTARY_WIN32
4855 _elm_win_key_down(void *data,
4856 int type EINA_UNUSED,
4859 ELM_WIN_DATA_GET(data, sd);
4860 Ecore_Event_Key *e = event;
4861 if ((e->modifiers & ECORE_EVENT_MODIFIER_ALT) &&
4862 (strcmp(e->key, "F4") == 0))
4863 _elm_win_delete_request(sd->ee);
4865 return ECORE_CALLBACK_PASS_ON;
4871 _elm_win_focus_highlight_hide(void *data EINA_UNUSED,
4873 const char *emission EINA_UNUSED,
4874 const char *source EINA_UNUSED)
4876 evas_object_hide(obj);
4880 _elm_win_focus_highlight_anim_end(void *data,
4882 const char *emission EINA_UNUSED,
4883 const char *source EINA_UNUSED)
4885 ELM_WIN_DATA_GET(data, sd);
4887 _elm_win_focus_highlight_simple_setup(sd, obj);
4891 _elm_win_focus_highlight_init(Efl_Ui_Win_Data *sd)
4893 evas_event_callback_add(sd->evas, EVAS_CALLBACK_CANVAS_OBJECT_FOCUS_IN,
4894 _elm_win_object_focus_in, sd->obj);
4895 evas_event_callback_add(sd->evas,
4896 EVAS_CALLBACK_CANVAS_OBJECT_FOCUS_OUT,
4897 _elm_win_object_focus_out, sd->obj);
4899 sd->focus_highlight.cur.target = _elm_win_focus_target_get(evas_focus_get(sd->evas));
4900 if (sd->focus_highlight.cur.target)
4902 if (elm_widget_highlight_in_theme_get(sd->focus_highlight.cur.target))
4903 sd->focus_highlight.cur.in_theme = EINA_TRUE;
4905 _elm_win_focus_target_callbacks_add(sd);
4907 evas_object_event_callback_add
4908 (sd->focus_highlight.cur.target,
4909 EVAS_CALLBACK_DEL, _elm_win_focus_target_del, sd->obj);
4912 sd->focus_highlight.prev.target = NULL;
4913 sd->focus_highlight.theme_changed = EINA_TRUE;
4914 if (!sd->focus_highlight.fobj)
4916 sd->focus_highlight.fobj = edje_object_add(sd->evas);
4918 if (elm_widget_is_legacy(sd->obj))
4920 edje_object_signal_callback_add(sd->focus_highlight.fobj,
4921 "elm,action,focus,hide,end", "*",
4922 _elm_win_focus_highlight_hide, NULL);
4923 edje_object_signal_callback_add(sd->focus_highlight.fobj,
4924 "elm,action,focus,anim,end", "*",
4925 _elm_win_focus_highlight_anim_end, sd->obj);
4929 edje_object_signal_callback_add(sd->focus_highlight.fobj,
4930 "efl,focus,visible,off,done", "*",
4931 _elm_win_focus_highlight_hide, NULL);
4932 edje_object_signal_callback_add(sd->focus_highlight.fobj,
4933 "efl,action,focus,anim,end", "*",
4934 _elm_win_focus_highlight_anim_end, sd->obj);
4938 _elm_win_focus_highlight_reconfigure_job_start(sd);
4941 typedef struct _resize_info {
4944 Efl_Ui_Win_Move_Resize_Mode mode;
4946 #ifdef HAVE_ELEMENTARY_X
4947 #define XDIR(d) , ECORE_X_NETWM_DIRECTION_##d
4948 Ecore_X_Netwm_Direction x_dir;
4954 static const resize_info _resize_infos_legacy[8] = {
4955 { "elm.event.resize.t", ELM_CURSOR_TOP_SIDE, EFL_UI_WIN_MOVE_RESIZE_MODE_TOP, 1 XDIR(SIZE_T) },
4956 { "elm.event.resize.b", ELM_CURSOR_BOTTOM_SIDE, EFL_UI_WIN_MOVE_RESIZE_MODE_BOTTOM, 2 XDIR(SIZE_B) },
4957 { "elm.event.resize.l", ELM_CURSOR_LEFT_SIDE, EFL_UI_WIN_MOVE_RESIZE_MODE_LEFT, 4 XDIR(SIZE_L) },
4958 { "elm.event.resize.r", ELM_CURSOR_RIGHT_SIDE, EFL_UI_WIN_MOVE_RESIZE_MODE_RIGHT, 8 XDIR(SIZE_R) },
4959 { "elm.event.resize.tl", ELM_CURSOR_TOP_LEFT_CORNER, EFL_UI_WIN_MOVE_RESIZE_MODE_TOP | EFL_UI_WIN_MOVE_RESIZE_MODE_LEFT, 5 XDIR(SIZE_TL) },
4960 { "elm.event.resize.bl", ELM_CURSOR_BOTTOM_LEFT_CORNER, EFL_UI_WIN_MOVE_RESIZE_MODE_BOTTOM | EFL_UI_WIN_MOVE_RESIZE_MODE_LEFT, 6 XDIR(SIZE_BL) },
4961 { "elm.event.resize.br", ELM_CURSOR_BOTTOM_RIGHT_CORNER, EFL_UI_WIN_MOVE_RESIZE_MODE_BOTTOM | EFL_UI_WIN_MOVE_RESIZE_MODE_RIGHT, 10 XDIR(SIZE_BR) },
4962 { "elm.event.resize.tr", ELM_CURSOR_TOP_RIGHT_CORNER, EFL_UI_WIN_MOVE_RESIZE_MODE_TOP | EFL_UI_WIN_MOVE_RESIZE_MODE_RIGHT, 9 XDIR(SIZE_TR) },
4965 static const resize_info _resize_infos[8] = {
4966 { "efl.event.resize.t", ELM_CURSOR_TOP_SIDE, EFL_UI_WIN_MOVE_RESIZE_MODE_TOP, 1 XDIR(SIZE_T) },
4967 { "efl.event.resize.b", ELM_CURSOR_BOTTOM_SIDE, EFL_UI_WIN_MOVE_RESIZE_MODE_BOTTOM, 2 XDIR(SIZE_B) },
4968 { "efl.event.resize.l", ELM_CURSOR_LEFT_SIDE, EFL_UI_WIN_MOVE_RESIZE_MODE_LEFT, 4 XDIR(SIZE_L) },
4969 { "efl.event.resize.r", ELM_CURSOR_RIGHT_SIDE, EFL_UI_WIN_MOVE_RESIZE_MODE_RIGHT, 8 XDIR(SIZE_R) },
4970 { "efl.event.resize.tl", ELM_CURSOR_TOP_LEFT_CORNER, EFL_UI_WIN_MOVE_RESIZE_MODE_TOP | EFL_UI_WIN_MOVE_RESIZE_MODE_LEFT, 5 XDIR(SIZE_TL) },
4971 { "efl.event.resize.bl", ELM_CURSOR_BOTTOM_LEFT_CORNER, EFL_UI_WIN_MOVE_RESIZE_MODE_BOTTOM | EFL_UI_WIN_MOVE_RESIZE_MODE_LEFT, 6 XDIR(SIZE_BL) },
4972 { "efl.event.resize.br", ELM_CURSOR_BOTTOM_RIGHT_CORNER, EFL_UI_WIN_MOVE_RESIZE_MODE_BOTTOM | EFL_UI_WIN_MOVE_RESIZE_MODE_RIGHT, 10 XDIR(SIZE_BR) },
4973 { "efl.event.resize.tr", ELM_CURSOR_TOP_RIGHT_CORNER, EFL_UI_WIN_MOVE_RESIZE_MODE_TOP | EFL_UI_WIN_MOVE_RESIZE_MODE_RIGHT, 9 XDIR(SIZE_TR) },
4976 static inline Efl_Ui_Win_Move_Resize_Mode
4977 _move_resize_mode_rotate(int rotation, Efl_Ui_Win_Move_Resize_Mode mode)
4979 const Efl_Ui_Win_Move_Resize_Mode edges[4] = {
4980 EFL_UI_WIN_MOVE_RESIZE_MODE_TOP, EFL_UI_WIN_MOVE_RESIZE_MODE_LEFT,
4981 EFL_UI_WIN_MOVE_RESIZE_MODE_BOTTOM, EFL_UI_WIN_MOVE_RESIZE_MODE_RIGHT
4984 const Efl_Ui_Win_Move_Resize_Mode corners[4] = {
4985 EFL_UI_WIN_MOVE_RESIZE_MODE_TOP | EFL_UI_WIN_MOVE_RESIZE_MODE_LEFT,
4986 EFL_UI_WIN_MOVE_RESIZE_MODE_BOTTOM | EFL_UI_WIN_MOVE_RESIZE_MODE_LEFT,
4987 EFL_UI_WIN_MOVE_RESIZE_MODE_BOTTOM | EFL_UI_WIN_MOVE_RESIZE_MODE_RIGHT,
4988 EFL_UI_WIN_MOVE_RESIZE_MODE_TOP | EFL_UI_WIN_MOVE_RESIZE_MODE_RIGHT,
4991 const int i = rotation / 90;
4994 for (k = 0; k < 4; k++)
4995 if (mode == edges[k])
4996 return edges[(k + i) % 4];
4998 for (k = 0; k < 4; k++)
4999 if (mode == corners[k])
5000 return corners[(k + i) % 4];
5002 return EFL_UI_WIN_MOVE_RESIZE_MODE_MOVE;
5005 static const resize_info *
5006 _resize_info_get(Evas_Object *obj, int rotation, Efl_Ui_Win_Move_Resize_Mode mode)
5009 return _resize_info_get(obj, 0, _move_resize_mode_rotate(rotation, mode));
5011 if (elm_widget_is_legacy(obj))
5013 for (size_t k = 0; k < EINA_C_ARRAY_LENGTH(_resize_infos_legacy); k++)
5015 if (_resize_infos_legacy[k].mode == mode)
5016 return &_resize_infos_legacy[k];
5021 for (size_t k = 0; k < EINA_C_ARRAY_LENGTH(_resize_infos); k++)
5023 if (_resize_infos[k].mode == mode)
5024 return &_resize_infos[k];
5031 static Efl_Ui_Win_Move_Resize_Mode
5032 _move_resize_mode_get(Evas_Object *obj, const char *source)
5034 if (elm_widget_is_legacy(obj))
5036 for (size_t k = 0; k < EINA_C_ARRAY_LENGTH(_resize_infos_legacy); k++)
5037 if (!strcmp(source, _resize_infos_legacy[k].source))
5038 return _resize_infos_legacy[k].mode;
5042 for (size_t k = 0; k < EINA_C_ARRAY_LENGTH(_resize_infos); k++)
5043 if (!strcmp(source, _resize_infos[k].source))
5044 return _resize_infos[k].mode;
5047 return EFL_UI_WIN_MOVE_RESIZE_MODE_MOVE;
5051 _elm_win_frame_obj_move(void *data,
5052 Evas *e EINA_UNUSED,
5053 Evas_Object *obj EINA_UNUSED,
5054 void *event_info EINA_UNUSED)
5056 Efl_Ui_Win_Data *sd;
5058 if (!(sd = data)) return;
5059 if (!sd->legacy.edje) return;
5061 _elm_win_frame_obj_update(sd, 0);
5065 _elm_win_frame_obj_resize(void *data,
5066 Evas *e EINA_UNUSED,
5067 Evas_Object *obj EINA_UNUSED,
5068 void *event_info EINA_UNUSED)
5070 Efl_Ui_Win_Data *sd;
5072 if (!(sd = data)) return;
5073 if (!sd->legacy.edje) return;
5075 _elm_win_frame_obj_update(sd, 0);
5079 _elm_win_frame_cb_resize_show(void *data,
5080 Evas_Object *obj EINA_UNUSED,
5081 const char *sig EINA_UNUSED,
5084 ELM_WIN_DATA_GET(data, sd);
5087 if (sd->resizing) return;
5089 #ifdef HAVE_ELEMENTARY_WL2
5090 if (sd->pointer.obj)
5092 Efl_Ui_Win_Move_Resize_Mode mode = _move_resize_mode_get(sd->obj, source);
5093 const resize_info *ri = _resize_info_get(sd->obj, sd->rot, mode);
5094 if (ri) elm_widget_theme_object_set(sd->obj, sd->pointer.obj, "pointer", "base", ri->cursor);
5102 _elm_win_frame_cb_resize_hide(void *data,
5103 Evas_Object *obj EINA_UNUSED,
5104 const char *sig EINA_UNUSED,
5105 const char *source EINA_UNUSED)
5107 ELM_WIN_DATA_GET(data, sd);
5110 if (sd->resizing) return;
5112 #ifdef HAVE_ELEMENTARY_WL2
5113 if (sd->pointer.obj)
5114 elm_widget_theme_object_set(sd->obj, sd->pointer.obj,
5115 "pointer", "base", "default");
5119 #ifdef HAVE_ELEMENTARY_WL2
5120 /* This only works when called from an edje event
5121 * that propagates seat info...
5123 static Ecore_Wl2_Input *
5124 _elm_win_wayland_input_get(Efl_Ui_Win_Data *sd)
5126 Ecore_Wl2_Display *di;
5130 engine = ecore_evas_engine_name_get(sd->ee);
5131 if (strcmp(engine, ELM_WAYLAND_SHM) &&
5132 strcmp(engine, ELM_WAYLAND_EGL))
5135 di = ecore_wl2_window_display_get(sd->wl.win);
5137 sname = edje_object_signal_callback_seat_data_get();
5138 if (!sname) return NULL;
5139 return ecore_wl2_display_input_find_by_name(di, sname);
5143 static inline Eina_Bool
5144 _win_move_start(Efl_Ui_Win_Data *sd)
5146 #ifdef HAVE_ELEMENTARY_WL2
5149 Ecore_Wl2_Input *ei;
5151 ei = _elm_win_wayland_input_get(sd);
5152 ecore_wl2_window_move(sd->wl.win, ei);
5157 #ifdef HAVE_ELEMENTARY_X
5162 _internal_elm_win_xwindow_get(sd);
5163 sd->resizing = EINA_TRUE;
5164 ecore_x_pointer_ungrab();
5165 ecore_x_pointer_root_xy_get(&x, &y);
5166 ecore_x_netwm_moveresize_request_send(sd->x.xwin, x, y,
5167 ECORE_X_NETWM_DIRECTION_MOVE, 1);
5172 INF("Window move request not supported for this window!");
5177 _win_move_resize_start(Efl_Ui_Win_Data *sd, Efl_Ui_Win_Move_Resize_Mode mode)
5179 EINA_SAFETY_ON_NULL_RETURN_VAL(sd, EINA_FALSE);
5180 const resize_info *ri;
5182 // 2. check move_resize already started
5185 ERR("Window is already being resized.");
5189 if (mode == EFL_UI_WIN_MOVE_RESIZE_MODE_MOVE)
5190 return _win_move_start(sd);
5192 ri = _resize_info_get(sd->obj, sd->rot, mode);
5195 ERR("Unsupported move_resize mode %#x", (int) mode);
5199 sd->resizing = EINA_TRUE;
5201 #ifdef HAVE_ELEMENTARY_WL2
5204 Ecore_Wl2_Input *ei;
5206 ei = _elm_win_wayland_input_get(sd);
5207 ecore_wl2_window_resize(sd->wl.win, ei, ri->wl_location);
5212 #ifdef HAVE_ELEMENTARY_X
5216 _internal_elm_win_xwindow_get(sd);
5217 ecore_x_pointer_ungrab();
5218 ecore_x_pointer_root_xy_get(&x, &y);
5219 ecore_x_netwm_moveresize_request_send(sd->x.xwin, x, y, ri->x_dir, 1);
5224 INF("Window resize request not supported for this window!");
5227 // TIZEN_ONLY(20171114) Accessibility Highlight Frame added
5229 _elm_win_accessibility_highlight_init(Efl_Ui_Win_Data *sd, Evas_Object *atarget)
5231 sd->accessibility_highlight.cur.target = atarget;
5233 sd->accessibility_highlight.prev.target = NULL;
5234 sd->accessibility_highlight.fobj = edje_object_add(sd->evas);
5236 _elm_win_accessibility_highlight_callbacks_add(sd);
5241 _elm_win_frame_cb_move_start(void *data,
5242 Evas_Object *obj EINA_UNUSED,
5243 const char *sig EINA_UNUSED,
5244 const char *source EINA_UNUSED)
5246 ELM_WIN_DATA_GET_OR_RETURN(data, sd);
5248 _win_move_resize_start(sd, EFL_UI_WIN_MOVE_RESIZE_MODE_MOVE);
5252 _elm_win_frame_cb_resize_start(void *data, Evas_Object *obj EINA_UNUSED,
5253 const char *sig EINA_UNUSED, const char *source)
5255 ELM_WIN_DATA_GET_OR_RETURN(data, sd);
5256 Efl_Ui_Win_Move_Resize_Mode mode;
5258 mode = _move_resize_mode_get(sd->obj, source);
5259 if (mode == EFL_UI_WIN_MOVE_RESIZE_MODE_MOVE) return;
5261 _win_move_resize_start(sd, mode);
5264 //TIZEN_ONLY(20180131):Added resize,end signal for mouse up
5266 _elm_win_frame_cb_resize_end(void *data,
5267 Evas_Object *obj EINA_UNUSED,
5268 const char *sig EINA_UNUSED,
5269 const char *source EINA_UNUSED)
5271 #ifdef HAVE_ELEMENTARY_WL2
5272 ELM_WIN_DATA_GET(data, sd);
5275 if (sd->resizing) sd->resizing = EINA_FALSE;
5282 _elm_win_frame_cb_minimize(void *data,
5283 Evas_Object *obj EINA_UNUSED,
5284 const char *sig EINA_UNUSED,
5285 const char *source EINA_UNUSED)
5287 ELM_WIN_DATA_GET(data, sd);
5290 // sd->minimized = EINA_TRUE;
5291 TRAP(sd, iconified_set, EINA_TRUE);
5295 _elm_win_frame_cb_maximize(void *data,
5296 Evas_Object *obj EINA_UNUSED,
5297 const char *sig EINA_UNUSED,
5298 const char *source EINA_UNUSED)
5301 ELM_WIN_DATA_GET(data, sd);
5304 if (sd->maximized) value = EINA_FALSE;
5305 else value = EINA_TRUE;
5307 efl_ui_win_maximized_set(sd->obj, value);
5311 _elm_win_frame_cb_menu(void *data,
5312 Evas_Object *obj EINA_UNUSED,
5313 const char *sig EINA_UNUSED,
5314 const char *source EINA_UNUSED)
5316 ELM_WIN_DATA_GET(data, sd);
5317 #ifdef HAVE_ELEMENTARY_WL2
5318 Ecore_Wl2_Input *input;
5321 if (!sd->wl.win) return;
5322 evas_pointer_canvas_xy_get(sd->evas, &x, &y);
5323 ecore_wl2_window_geometry_get(sd->wl.win, &wx, &wy, NULL, NULL);
5329 Ecore_Wl2_Display *display = ecore_wl2_window_display_get(sd->wl.win);
5330 it = ecore_wl2_display_inputs_get(display);
5331 EINA_ITERATOR_FOREACH(it, input) break;
5332 eina_iterator_free(it);
5334 if (sd->wl.win->xdg_toplevel)
5336 xdg_toplevel_show_window_menu(sd->wl.win->xdg_toplevel,
5337 ecore_wl2_input_seat_get(input), 0, x, y);
5338 ecore_wl2_display_flush(input->display);
5340 else if (sd->wl.win->zxdg_toplevel)
5342 zxdg_toplevel_v6_show_window_menu(sd->wl.win->zxdg_toplevel,
5343 ecore_wl2_input_seat_get(input), 0, x, y);
5344 ecore_wl2_display_flush(input->display);
5351 _elm_win_frame_cb_close(void *data,
5352 Evas_Object *obj EINA_UNUSED,
5353 const char *sig EINA_UNUSED,
5354 const char *source EINA_UNUSED)
5356 ELM_WIN_DATA_GET(data, sd);
5359 /* FIXME: After the current freeze, this should be handled differently.
5361 * Ideally, we would want to mimic the X11 backend and use something
5362 * like ECORE_WL_EVENT_WINDOW_DELETE and handle the delete_request
5363 * inside of ecore_evas. That would be the 'proper' way, but since we are
5364 * in a freeze right now, I cannot add a new event value, or a new
5365 * event structure to ecore_wayland.
5367 * So yes, this is a temporary 'stop-gap' solution which will be fixed
5368 * when the freeze is over, but it does fix a trac bug for now, and in a
5369 * way which does not break API or the freeze. - dh
5376 int autodel = sd->autodel;
5377 sd->autodel_clear = &autodel;
5378 evas_object_ref(win);
5379 efl_event_callback_legacy_call(win, EFL_UI_WIN_EVENT_DELETE_REQUEST, NULL);
5381 evas_object_hide(win);
5382 // FIXME: if above callback deletes - then the below will be invalid
5383 if (autodel) evas_object_del(win);
5384 else sd->autodel_clear = NULL;
5385 evas_object_unref(win);
5388 #ifdef HAVE_ELEMENTARY_WL2
5390 _elm_win_wl_configure(void *data, int t EINA_UNUSED, void *event)
5392 Ecore_Wl2_Event_Window_Configure *ev = event;
5393 ELM_WIN_DATA_GET(data, sd);
5394 if (ecore_wl2_window_id_get(sd->wl.win) != (int)ev->win) return ECORE_CALLBACK_RENEW;
5396 if (sd->resizing && (!ev->edges)) sd->resizing = EINA_FALSE;
5397 return ECORE_CALLBACK_RENEW;
5400 //TIZEN_ONLY(20171110): added signal for effect start and done
5402 _elm_win_wl_effect_start(void *data, int type EINA_UNUSED, void *event)
5404 ELM_WIN_DATA_GET(data, sd);
5405 Ecore_Wl2_Event_Effect_Start *e = event;
5407 if (!sd->wl.win) return ECORE_CALLBACK_PASS_ON;
5409 if (ecore_wl2_window_id_get(sd->wl.win) != (int)e->win)
5410 return ECORE_CALLBACK_PASS_ON;
5412 evas_object_smart_callback_call(data, SIG_EFFECT_STARTED, (void*)e->type);
5414 return ECORE_CALLBACK_PASS_ON;
5418 _elm_win_wl_effect_end(void *data, int type EINA_UNUSED, void *event)
5420 ELM_WIN_DATA_GET(data, sd);
5421 Ecore_Wl2_Event_Effect_Start *e = event;
5422 unsigned int eff_type;
5424 if (!sd->wl.win) return ECORE_CALLBACK_PASS_ON;
5426 if (ecore_wl2_window_id_get(sd->wl.win) != (int)e->win)
5427 return ECORE_CALLBACK_PASS_ON;
5429 /* TIZEN_ONLY(20160704): added signal for launch */
5432 evas_object_smart_callback_call(data, SIG_LAUNCH_DONE, (void*)e->type);
5434 /* end of TIZEN_ONLY(20160704): added signal for launch*/
5435 evas_object_smart_callback_call(data, SIG_EFFECT_DONE, (void*)e->type);
5437 return ECORE_CALLBACK_PASS_ON;
5439 // end of TIZEN_ONLY(20171110): added signal for effect start and done
5443 _elm_object_part_cursor_set(Evas_Object *obj, Evas_Object *edj,
5444 const char *part, const char *cursor)
5448 edje_object_freeze(edj);
5449 sub = (Evas_Object *)edje_object_part_object_get(edj, part);
5450 edje_object_thaw(edj);
5453 elm_object_sub_cursor_set(sub, obj, cursor);
5457 _efl_system_theme_path_get(void)
5459 // Find the default theme from EFL install. Quite ugly.
5462 char path[PATH_MAX];
5465 sysdir = elm_theme_system_dir_get();
5466 if (!sysdir) return NULL;
5468 eina_file_path_join(path, PATH_MAX, sysdir, "default.edj");
5469 version = edje_file_data_get(path, "version");
5470 v = version ? atoi(version) : 0;
5472 if (v < FRAME_OBJ_THEME_MIN_VERSION)
5474 ERR("Default system theme is too old, something is wrong with your installation of EFL.");
5477 return strdup(path);
5481 _elm_win_frame_add(Efl_Ui_Win_Data *sd, const char *element, const char *style)
5483 Evas_Object *obj = sd->obj;
5485 const char *version;
5487 if (sd->frame_obj) return;
5489 sd->frame_obj = edje_object_add(sd->evas);
5491 // Verify theme version. Border requires an exact theme API.
5492 version = elm_theme_data_get(elm_widget_theme_get(sd->obj), "version");
5493 v = version ? atoi(version) : 0;
5494 if (EINA_LIKELY(v >= FRAME_OBJ_THEME_MIN_VERSION))
5496 if (elm_widget_theme_object_set
5497 (sd->obj, sd->frame_obj, "border", element, style) == EFL_UI_THEME_APPLY_ERROR_GENERIC)
5499 ERR("Failed to set main border theme for the window.");
5500 ELM_SAFE_FREE(sd->frame_obj, evas_object_del);
5504 // Verify border.edc version as well
5505 version = edje_object_data_get(sd->frame_obj, "version");
5506 v = version ? atoi(version) : 0;
5509 if (v < FRAME_OBJ_THEME_MIN_VERSION)
5511 // Theme compatibility
5512 const char *key = "elm/border/base/default"; // FIXME?
5515 WRN("Selected theme does not support the required border theme API "
5516 "(version = %d, requires >= %d).",
5517 v, FRAME_OBJ_THEME_MIN_VERSION);
5518 sys_theme = _efl_system_theme_path_get();
5520 !edje_object_file_set(sd->frame_obj, sys_theme, key))
5522 ERR("Failed to set main border theme for the window.");
5523 ELM_SAFE_FREE(sd->frame_obj, evas_object_del);
5530 edje_object_freeze(sd->frame_obj);
5531 /* Small hack: The special value 2 means this is the top frame object.
5532 * We propagate to the children now (the edc group contents), but subsequent
5533 * calls to smart_member_add will not propagate the flag further. Note that
5534 * this little hack will fall apart if edje creates and destroys objects on
5536 efl_canvas_object_is_frame_object_set(sd->frame_obj, 2);
5538 if (elm_widget_is_legacy(sd->obj))
5539 edje_object_part_swallow(sd->frame_obj, "elm.swallow.client", sd->legacy.edje);
5541 edje_object_part_swallow(sd->frame_obj, "efl.client", sd->legacy.edje);
5543 /* TIZEN_ONLY(20180427): disable unnecessary parts.
5545 evas_object_show(sd->icon);
5548 Eina_Bool set = EINA_FALSE;
5549 Eina_Bool legacy = elm_widget_is_legacy(sd->obj);
5552 sd->icon = elm_icon_add(sd->obj);
5554 sd->icon = efl_add(EFL_UI_IMAGE_CLASS, sd->obj);
5559 set = elm_icon_standard_set(sd->icon, sd->icon_name);
5561 set = efl_ui_image_icon_set(sd->icon, sd->icon_name);
5563 if (((!sd->icon_name) || (!set)) && _elm_appname)
5566 d = efreet_util_desktop_exec_find(_elm_appname);
5570 elm_icon_standard_set(sd->icon, d->icon);
5572 efl_ui_image_icon_set(sd->icon, d->icon);
5573 efreet_desktop_free(d);
5578 if (elm_widget_is_legacy(sd->obj))
5579 edje_object_part_swallow(sd->frame_obj, "elm.swallow.icon", sd->icon);
5581 edje_object_part_swallow(sd->frame_obj, "efl.icon", sd->icon);
5583 efl_canvas_object_is_frame_object_set(sd->icon, EINA_TRUE);
5586 evas_object_event_callback_add
5587 (sd->frame_obj, EVAS_CALLBACK_MOVE, _elm_win_frame_obj_move, sd);
5588 evas_object_event_callback_add
5589 (sd->frame_obj, EVAS_CALLBACK_RESIZE, _elm_win_frame_obj_resize, sd);
5591 if (elm_widget_is_legacy(sd->obj))
5593 edje_object_signal_callback_add
5594 (sd->frame_obj, "elm,action,move,start", "elm",
5595 _elm_win_frame_cb_move_start, obj);
5596 edje_object_signal_callback_add
5597 (sd->frame_obj, "elm,action,resize,show", "*",
5598 _elm_win_frame_cb_resize_show, obj);
5599 edje_object_signal_callback_add
5600 (sd->frame_obj, "elm,action,resize,hide", "*",
5601 _elm_win_frame_cb_resize_hide, obj);
5602 edje_object_signal_callback_add
5603 (sd->frame_obj, "elm,action,resize,start", "*",
5604 _elm_win_frame_cb_resize_start, obj);
5605 //TIZEN_ONLY(20180131):Added resize,end signal for mouse up
5606 edje_object_signal_callback_add
5607 (sd->frame_obj, "elm,action,resize,end", "*",
5608 _elm_win_frame_cb_resize_end, obj);
5610 edje_object_signal_callback_add
5611 (sd->frame_obj, "elm,action,minimize", "elm",
5612 _elm_win_frame_cb_minimize, obj);
5613 edje_object_signal_callback_add
5614 (sd->frame_obj, "elm,action,maximize", "elm",
5615 _elm_win_frame_cb_maximize, obj);
5616 edje_object_signal_callback_add
5617 (sd->frame_obj, "elm,action,close", "elm",
5618 _elm_win_frame_cb_close, obj);
5619 edje_object_signal_callback_add
5620 (sd->frame_obj, "elm,action,menu", "elm",
5621 _elm_win_frame_cb_menu, obj);
5625 edje_object_signal_callback_add
5626 (sd->frame_obj, "efl,action,move,start", "efl",
5627 _elm_win_frame_cb_move_start, obj);
5628 edje_object_signal_callback_add
5629 (sd->frame_obj, "efl,action,resize,show", "*",
5630 _elm_win_frame_cb_resize_show, obj);
5631 edje_object_signal_callback_add
5632 (sd->frame_obj, "efl,action,resize,hide", "*",
5633 _elm_win_frame_cb_resize_hide, obj);
5634 edje_object_signal_callback_add
5635 (sd->frame_obj, "efl,action,resize,start", "*",
5636 _elm_win_frame_cb_resize_start, obj);
5637 //TIZEN_ONLY(20180131):Added resize,end signal for mouse up
5638 edje_object_signal_callback_add
5639 (sd->frame_obj, "efl,action,resize,end", "*",
5640 _elm_win_frame_cb_resize_end, obj);
5642 edje_object_signal_callback_add
5643 (sd->frame_obj, "efl,action,minimize", "efl",
5644 _elm_win_frame_cb_minimize, obj);
5645 edje_object_signal_callback_add
5646 (sd->frame_obj, "efl,action,maximize", "efl",
5647 _elm_win_frame_cb_maximize, obj);
5648 edje_object_signal_callback_add
5649 (sd->frame_obj, "efl,action,close", "efl",
5650 _elm_win_frame_cb_close, obj);
5651 edje_object_signal_callback_add
5652 (sd->frame_obj, "efl,action,menu", "efl",
5653 _elm_win_frame_cb_menu, obj);
5656 if (!sd->pointer.obj)
5658 if (elm_widget_is_legacy(obj))
5660 for (size_t k = 0; k < EINA_C_ARRAY_LENGTH(_resize_infos_legacy); k++)
5662 const resize_info *ri = &_resize_infos_legacy[k];
5663 _elm_object_part_cursor_set(obj, sd->frame_obj, ri->source, ri->cursor);
5668 for (size_t k = 0; k < EINA_C_ARRAY_LENGTH(_resize_infos); k++)
5670 const resize_info *ri = &_resize_infos[k];
5671 _elm_object_part_cursor_set(obj, sd->frame_obj, ri->source, ri->cursor);
5678 if (elm_widget_is_legacy(sd->obj))
5679 edje_object_part_text_escaped_set(sd->frame_obj, "elm.text.title", sd->title);
5681 edje_object_part_text_escaped_set(sd->frame_obj, "efl.text.title", sd->title);
5685 // HACK: Force render mode of bg rect to COPY. This avoids render garbage.
5687 if (elm_widget_is_legacy(sd->obj))
5688 bgrect = (Eo *) edje_object_part_object_get(sd->frame_obj, "elm.rect.background");
5690 bgrect = (Eo *) edje_object_part_object_get(sd->frame_obj, "efl.rect.background");
5692 efl_canvas_object_render_op_set(bgrect, EFL_GFX_RENDER_OP_COPY);
5696 edje_object_thaw(sd->frame_obj);
5697 if (!efl_finalized_get(obj)) return;
5698 _elm_win_frame_style_update(sd, 1, 1);
5699 _elm_win_frame_geometry_adjust(sd);
5700 ecore_evas_geometry_get(sd->ee, NULL, NULL, &w, &h);
5701 if ((w > 1) && (h > 1))
5703 ecore_evas_resize(sd->ee, w, h);
5708 _elm_win_frame_style_update(Efl_Ui_Win_Data *sd, Eina_Bool force_emit, Eina_Bool calc)
5710 Eina_Bool borderless, maximized, shadow, focus, bg_solid, menu, unresizable,
5711 alpha, bg_standard, indicator;
5712 Eina_Bool changed = EINA_FALSE;
5716 if (!efl_finalized_get(sd->obj)) return;
5717 if (EINA_LIKELY(sd->type == EFL_UI_WIN_TYPE_FAKE))
5719 if (!_elm_config->win_no_border)
5720 CRI("Window has no frame object!");
5724 if ((sd->type == ELM_WIN_INLINED_IMAGE) ||
5725 (sd->type == ELM_WIN_SOCKET_IMAGE) ||
5726 (sd->type == ELM_WIN_TOOLTIP) ||
5727 (sd->type == ELM_WIN_COMBO) ||
5728 (sd->type == ELM_WIN_MENU) ||
5729 (sd->type == ELM_WIN_POPUP_MENU))
5731 sd->csd.need_shadow = EINA_FALSE;
5732 sd->csd.need_borderless = EINA_TRUE;
5733 sd->csd.need_unresizable = EINA_TRUE;
5734 sd->csd.need_menu = EINA_FALSE;
5735 sd->csd.need_indicator = EINA_FALSE;
5737 else if (_elm_config->win_no_border)
5738 sd->csd.need_borderless = EINA_TRUE;
5741 sd->csd.need_shadow = sd->csd.need && (!sd->maximized);
5744 alpha = sd->application_alpha || sd->theme_alpha;
5745 borderless = sd->csd.need_borderless || (!sd->csd.need) || sd->fullscreen;
5746 maximized = sd->maximized;
5747 shadow = sd->csd.need_shadow && (!sd->fullscreen) && (!sd->maximized) && (!borderless);
5748 if (alpha && borderless) shadow = 0;
5749 #ifdef HAVE_ELEMENTARY_WL2
5751 focus = ecore_wl2_window_activated_get(sd->wl.win);
5754 focus = ecore_evas_focus_get(sd->ee);
5755 bg_standard = sd->csd.need_bg_standard;
5756 unresizable = sd->csd.need_unresizable;
5757 menu = sd->csd.need_menu;
5758 indicator = sd->csd.need_indicator;
5759 bg_solid = sd->csd.need_bg_solid;
5760 /* Set background transparent if window supports alpha.
5761 * If alpha window does not emit signal to show background rectangle, then
5762 * the background color set by _efl_ui_win_part_color_set cannot be applied
5763 * because the background rectangle remains hidden.
5765 if (alpha && bg_solid && !(sd->csd.cur_bg_solid))
5766 edje_object_color_class_set(sd->frame_obj, "elm/win/background", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
5768 /* FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME
5769 * At the moment, E Wayland uses SSD for its internal windows. Which means
5770 * we must hide the shadow if the borderless flag is set. "trap" here means
5771 * we are likely to be running inside E compositor.
5772 * FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME */
5773 if (trap && sd->csd.wayland && sd->csd.need_borderless)
5776 #define STATE_SET(state, s1, s2, s3) do { \
5777 if (force_emit || (state != sd->csd.cur_##state)) \
5779 const char *sig = state ? s1 : s2; \
5780 edje_object_signal_emit(sd->frame_obj, sig, s3); \
5781 DBG("frame style emit: %p %s", sd->obj, sig); \
5782 sd->csd.cur_##state = state; \
5783 changed = EINA_TRUE; \
5786 if (elm_widget_is_legacy(sd->obj))
5788 STATE_SET(borderless, "elm,state,borderless,on", "elm,state,borderless,off", "elm");
5789 STATE_SET(shadow, "elm,state,shadow,on", "elm,state,shadow,off", "elm");
5790 STATE_SET(maximized, "elm,state,maximized", "elm,state,unmaximized", "elm");
5791 STATE_SET(focus, "elm,action,focus", "elm,action,unfocus", "elm");
5792 STATE_SET(bg_solid, "elm,state,background,solid,on", "elm,state,background,solid,off", "elm");
5793 STATE_SET(bg_standard, "elm,state,background,standard,on", "elm,state,background,standard,off", "elm");
5794 STATE_SET(unresizable, "elm,state,unresizable,on", "elm,state,unresizable,off", "elm");
5795 STATE_SET(menu, "elm,action,show_menu", "elm,action,hide_menu", "elm");
5796 STATE_SET(indicator, "elm,action,show_indicator", "elm,action,hide_indicator", "elm");
5800 STATE_SET(borderless, "efl,state,borderless,on", "efl,state,borderless,off", "efl");
5801 STATE_SET(shadow, "efl,state,shadow,on", "efl,state,shadow,off", "efl");
5802 STATE_SET(maximized, "efl,state,maximized", "efl,state,unmaximized", "efl");
5803 STATE_SET(focus, "efl,action,focus", "efl,action,unfocus", "efl");
5804 STATE_SET(bg_solid, "efl,state,background,solid,on", "efl,state,background,solid,off", "efl");
5805 STATE_SET(bg_standard, "efl,state,background,standard,on", "efl,state,background,standard,off", "efl");
5806 STATE_SET(unresizable, "efl,state,unresizable,on", "efl,state,unresizable,off", "efl");
5807 STATE_SET(menu, "efl,action,show_menu", "efl,action,hide_menu", "efl");
5808 STATE_SET(indicator, "efl,action,show_indicator", "efl,action,hide_indicator", "efl");
5815 if (calc || force_emit)
5816 edje_object_message_signal_process(sd->frame_obj);
5818 evas_object_smart_calculate(sd->frame_obj);
5819 _elm_win_frame_obj_update(sd, 0);
5825 _debug_key_down(void *data EINA_UNUSED,
5826 Evas *e EINA_UNUSED,
5830 Evas_Event_Key_Down *ev = event_info;
5832 if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD)
5835 if ((strcmp(ev->key, "F12")) ||
5836 (!evas_key_modifier_is_set(ev->modifiers, "Control")))
5839 INF("Tree graph generated.");
5840 elm_object_tree_dot_dump(obj, "./dump.dot");
5846 _win_inlined_image_set(Efl_Ui_Win_Data *sd)
5848 evas_object_image_alpha_set(sd->img_obj, EINA_FALSE);
5849 evas_object_image_filled_set(sd->img_obj, EINA_TRUE);
5851 evas_object_event_callback_add
5852 (sd->img_obj, EVAS_CALLBACK_DEL, _elm_win_on_img_obj_del, sd->obj);
5853 evas_object_event_callback_add
5854 (sd->img_obj, EVAS_CALLBACK_HIDE, _win_img_hide, sd->obj);
5855 evas_object_event_callback_add
5856 (sd->img_obj, EVAS_CALLBACK_MOUSE_UP, _win_img_mouse_up, sd->obj);
5857 evas_object_event_callback_add
5858 (sd->img_obj, EVAS_CALLBACK_FOCUS_IN, _win_img_focus_in, sd->obj);
5859 evas_object_event_callback_add
5860 (sd->img_obj, EVAS_CALLBACK_FOCUS_OUT, _win_img_focus_out, sd->obj);
5864 _elm_win_on_icon_del(void *data, const Efl_Event *ev)
5866 ELM_WIN_DATA_GET(data, sd);
5868 if (sd->icon == ev->object) sd->icon = NULL;
5872 _efl_ui_win_efl_canvas_group_group_add(Eo *obj, Efl_Ui_Win_Data *_pd EINA_UNUSED)
5874 efl_canvas_group_add(efl_super(obj, MY_CLASS));
5876 elm_widget_theme_klass_set(obj, "win");
5877 elm_widget_can_focus_set(obj, EINA_TRUE);
5879 elm_widget_highlight_ignore_set(obj, EINA_TRUE);
5882 #ifdef HAVE_ELEMENTARY_X
5884 _elm_x_io_err(void *data EINA_UNUSED)
5889 EINA_LIST_FOREACH(_elm_win_list, l, obj)
5890 evas_object_smart_callback_call(obj, "ioerr", NULL);
5891 fprintf(stderr, "X I/O Error - fatal. Exiting\n");
5896 // TIZEN_ONLY(20160218): Improve launching performance.
5898 elm_win_precreated_object_set(Evas_Object *obj)
5900 INF("Set precreated obj(%p).", obj);
5901 _precreated_win_obj = obj;
5905 elm_win_precreated_object_get(void)
5907 INF("Get precreated obj(%p).", _precreated_win_obj);
5908 return _precreated_win_obj;
5912 // TIZEN_ONLY(20160728): Indicator Implementation
5913 #ifdef HAVE_ELEMENTARY_WL2
5915 _elm_win_wl_indicator_flick(void *data, int type EINA_UNUSED, void *event EINA_UNUSED)
5917 ELM_WIN_DATA_GET(data, sd);
5918 evas_object_smart_callback_call(sd->obj, SIG_INDICATOR_FLICK_DONE, NULL);
5919 return ECORE_CALLBACK_PASS_ON;
5925 _elm_win_cb_hide(void *data EINA_UNUSED,
5926 Evas *e EINA_UNUSED,
5927 Evas_Object *obj EINA_UNUSED,
5928 void *event_info EINA_UNUSED)
5930 _elm_win_state_eval_queue();
5934 _elm_win_cb_show(void *data EINA_UNUSED,
5935 Evas *e EINA_UNUSED,
5936 Evas_Object *obj EINA_UNUSED,
5937 void *event_info EINA_UNUSED)
5939 _elm_win_state_eval_queue();
5942 static inline Eina_Bool
5943 _efl_ui_win_accel(Efl_Ui_Win_Data *sd, Eina_Stringshare **accel, int *gl_depth, int *gl_stencil, int *gl_msaa)
5945 const char *str = sd->accel_pref;
5947 const char *cfg = NULL;
5948 Eina_Bool is_accel = EINA_FALSE;
5950 /* current elm config OR global override */
5951 if ((!str) || ((_elm_config->accel_override) && (_elm_config->accel)))
5953 if (_elm_config->accel) cfg = _elm_config->accel;
5954 if (_elm_config->accel_override && _elm_accel_preference) cfg = _elm_accel_preference;
5958 env = getenv("ELM_ACCEL");
5961 is_accel = _elm_config_accel_preference_parse(env, accel, gl_depth, gl_stencil, gl_msaa);
5965 *accel = eina_stringshare_ref(cfg);
5966 *gl_depth = _elm_config->gl_depth;
5967 *gl_stencil = _elm_config->gl_stencil;
5968 *gl_msaa = _elm_config->gl_msaa;
5971 is_accel = _elm_config_accel_preference_parse(str, accel, gl_depth, gl_stencil, gl_msaa);
5977 _elm_win_need_frame_adjust(Efl_Ui_Win_Data *sd, const char *engine)
5981 /* this is for debug only - don't keep forever, it's not an api! */
5982 s = getenv("EFL_WIN_FRAME_MODE");
5983 sd->csd.wayland = (eina_streq(engine, ELM_WAYLAND_SHM) ||
5984 eina_streq(engine, ELM_WAYLAND_EGL));
5986 if (sd->type == EFL_UI_WIN_TYPE_FAKE)
5987 sd->csd.need = EINA_FALSE;
5988 else if (eina_streq(s, "on"))
5989 sd->csd.need = EINA_TRUE;
5990 else if (eina_streq(s, "off"))
5991 sd->csd.need = EINA_FALSE;
5993 sd->csd.need = sd->csd.wayland;
5997 _indicator_resized(void *data, const Efl_Event *event)
5999 ELM_WIN_DATA_GET_OR_RETURN(data, sd);
6000 Evas_Object *indicator = event->object;
6001 Evas_Coord_Size *size = (Evas_Coord_Size *)event->info;
6002 efl_gfx_hint_size_min_set(indicator, EINA_SIZE2D(size->w, size->h));
6003 _elm_win_frame_obj_update(sd, 0);
6007 _create_indicator(Evas_Object *obj)
6009 Evas_Object *indicator = NULL;
6010 const char *indicator_serv_name;
6012 indicator_serv_name = "elm_indicator_portrait";
6014 indicator = elm_plug_add(obj);
6017 ERR("Conformant cannot create plug to server[%s]", indicator_serv_name);
6021 if (!elm_plug_connect(indicator, indicator_serv_name, 0, EINA_FALSE))
6023 ERR("Conformant cannot connect to server[%s]", indicator_serv_name);
6031 _indicator_add(Efl_Ui_Win_Data *sd)
6035 sd->indicator = _create_indicator(obj);
6040 if (elm_widget_is_legacy(obj))
6042 if (!edje_object_part_swallow(sd->frame_obj, "elm.swallow.indicator", sd->indicator))
6047 if (!edje_object_part_swallow(sd->frame_obj, "efl.indicator", sd->indicator))
6051 efl_event_callback_add
6052 (sd->indicator, ELM_PLUG_EVENT_IMAGE_RESIZED, _indicator_resized, obj);
6054 efl_canvas_object_is_frame_object_set(sd->indicator, EINA_TRUE);
6055 sd->csd.need_indicator = EINA_TRUE;
6057 _elm_win_frame_style_update(sd, 0, 1);
6061 _indicator_del(Efl_Ui_Win_Data *sd)
6065 efl_event_callback_del
6066 (sd->indicator, ELM_PLUG_EVENT_IMAGE_RESIZED, _indicator_resized, obj);
6068 efl_del(sd->indicator);
6069 sd->indicator = NULL;
6071 sd->csd.need_indicator = EINA_FALSE;
6072 _elm_win_frame_style_update(sd, 0, 1);
6076 _win_finalize_job_cb(void *data, const Eina_Value value)
6078 Efl_Ui_Win_Data *sd = data;
6079 sd->finalize_future = NULL;
6080 if (!efl_invalidated_get(sd->obj))
6081 evas_render_pending_objects_flush(sd->evas);
6086 _gesture_manager_config_load(Eo *obj)
6089 Eo *gm = efl_provider_find(obj, EFL_CONFIG_INTERFACE);
6091 eina_value_setup(&val, EINA_VALUE_TYPE_DOUBLE);
6092 eina_value_set(&val, _elm_config->glayer_long_tap_start_timeout);
6093 efl_config_set(gm, "glayer_long_tap_start_timeout", &val);
6095 eina_value_set(&val, _elm_config->glayer_double_tap_timeout);
6096 efl_config_set(gm, "glayer_double_tap_timeout", &val);
6098 elm_config_scroll_thumbscroll_friction_set(_elm_config->thumbscroll_friction);
6099 elm_config_scroll_thumbscroll_momentum_threshold_set(_elm_config->thumbscroll_momentum_threshold);
6101 eina_value_set(&val, _elm_config->glayer_line_min_length);
6102 efl_config_set(gm, "glayer_line_min_length", &val);
6104 eina_value_set(&val, _elm_config->glayer_line_distance_tolerance);
6105 efl_config_set(gm, "glayer_line_distance_tolerance", &val);
6107 eina_value_set(&val, _elm_config->glayer_line_angular_tolerance);
6108 efl_config_set(gm, "glayer_line_angular_tolerance", &val);
6110 eina_value_set(&val, _elm_config->glayer_zoom_finger_factor);
6111 efl_config_set(gm, "glayer_zoom_finger_factor", &val);
6113 eina_value_set(&val, _elm_config->glayer_zoom_distance_tolerance);
6114 efl_config_set(gm, "glayer_zoom_distance_tolerance", &val);
6116 eina_value_setup(&val, EINA_VALUE_TYPE_UINT);
6117 eina_value_set(&val, _elm_config->glayer_flick_time_limit_ms);
6118 efl_config_set(gm, "glayer_flick_time_limit_ms", &val);
6120 eina_value_setup(&val, EINA_VALUE_TYPE_UCHAR);
6121 eina_value_set(&val, _elm_config->glayer_continues_enable);
6122 efl_config_set(gm, "glayer_continues_enable", &val);
6124 eina_value_set(&val, _elm_config->glayer_zoom_finger_enable);
6125 efl_config_set(gm, "glayer_zoom_finger_enable", &val);
6129 _elm_win_finalize_internal(Eo *obj, Efl_Ui_Win_Data *sd, const char *name, Efl_Ui_Win_Type type)
6131 Evas_Object *parent = NULL;
6134 const char *fontpath, *engine = NULL, *enginelist[32], *disp;
6135 int gl_depth = _elm_config->gl_depth;
6136 int gl_stencil = _elm_config->gl_stencil;
6137 int gl_msaa = _elm_config->gl_msaa;
6138 Eina_Stringshare *accel = NULL;
6139 Eina_Bool is_gl_accel;
6141 Ecore_Window parent_id = 0;
6143 Efl_Ui_Win_Data tmp_sd;
6145 if ((sd->type == ELM_WIN_INLINED_IMAGE) &&
6146 !efl_isa(obj, EFL_UI_WIN_INLINED_CLASS))
6148 ERR("Failed to create an inlined window!");
6152 parent = efl_parent_get(obj);
6153 //TIZEN_ONLY(20190321): support legacy window behavior compatibility
6154 if (!elm_widget_is_legacy(obj))
6157 if (!(efl_isa(parent, EFL_UI_WIN_CLASS) ||
6158 efl_isa(parent, EFL_UI_WIN_LEGACY_CLASS) ||
6159 efl_isa(parent, EFL_UI_WIN_INLINED_CLASS))) parent = NULL;
6160 //TIZEN_ONLY(20190321): support legacy window behavior compatibility
6164 /* just to store some data while trying out to create a canvas */
6165 memset(&tmp_sd, 0, sizeof(Efl_Ui_Win_Data));
6167 is_gl_accel = _efl_ui_win_accel(sd, &accel, &gl_depth, &gl_stencil, &gl_msaa);
6171 case EFL_UI_WIN_TYPE_FAKE:
6174 case ELM_WIN_INLINED_IMAGE:
6179 e = evas_object_evas_get(parent);
6182 ee = ecore_evas_ecore_evas_get(e);
6185 tmp_sd.img_obj = ecore_evas_object_image_new(ee);
6186 if (!tmp_sd.img_obj) break;
6188 tmp_sd.ee = ecore_evas_object_ecore_evas_get(tmp_sd.img_obj);
6191 ELM_SAFE_FREE(tmp_sd.img_obj, evas_object_del);
6196 case ELM_WIN_SOCKET_IMAGE:
6197 tmp_sd.ee = ecore_evas_extn_socket_new(1, 1);
6201 disp = getenv("ELM_DISPLAY");
6202 if ((disp) && (!strcmp(disp, "ews")))
6204 enginelist[p++] = ELM_EWS;
6206 else if ((disp) && (!strcmp(disp, "buffer")))
6208 enginelist[p++] = ELM_BUFFER;
6210 else if ((disp) && (!strcmp(disp, "shot")))
6212 enginelist[p++] = ENGINE_GET();
6214 // welcome to ifdef hell! :)
6216 #ifdef HAVE_ELEMENTARY_X
6217 else if ((disp) && (!strcmp(disp, "x11")))
6221 enginelist[p++] = ELM_OPENGL_X11;
6222 enginelist[p++] = ELM_SOFTWARE_X11;
6226 enginelist[p++] = ELM_SOFTWARE_X11;
6227 enginelist[p++] = ELM_OPENGL_X11;
6232 #ifdef HAVE_ELEMENTARY_WL2
6233 else if ((disp) && (!strcmp(disp, "wl")))
6237 enginelist[p++] = ELM_WAYLAND_EGL;
6238 enginelist[p++] = ELM_WAYLAND_SHM;
6242 enginelist[p++] = ELM_WAYLAND_SHM;
6243 enginelist[p++] = ELM_WAYLAND_EGL;
6248 #ifdef HAVE_ELEMENTARY_WIN32
6249 else if ((disp) && (!strcmp(disp, "win")))
6251 enginelist[p++] = ELM_SOFTWARE_WIN32;
6252 enginelist[p++] = ELM_SOFTWARE_DDRAW;
6256 #ifdef HAVE_ELEMENTARY_SDL
6257 else if ((disp) && (!strcmp(disp, "sdl")))
6261 enginelist[p++] = ELM_OPENGL_SDL;
6262 enginelist[p++] = ELM_SOFTWARE_SDL;
6266 enginelist[p++] = ELM_SOFTWARE_SDL;
6267 enginelist[p++] = ELM_OPENGL_SDL;
6272 #ifdef HAVE_ELEMENTARY_COCOA
6273 else if ((disp) && (!strcmp(disp, "mac")))
6275 enginelist[p++] = ELM_OPENGL_COCOA;
6279 #if defined(HAVE_ELEMENTARY_DRM) || defined(HAVE_ELEMENTARY_FB)
6280 else if ((disp) && (!strcmp(disp, "fb")))
6282 #ifdef HAVE_ELEMENTARY_DRM
6285 enginelist[p++] = ELM_GL_DRM;
6287 enginelist[p++] = ELM_DRM;
6289 #ifdef HAVE_ELEMENTARY_FB
6290 enginelist[p++] = ELM_SOFTWARE_FB;
6295 #ifdef HAVE_ELEMENTARY_X
6296 else if (!_elm_preferred_engine &&
6297 getenv("DISPLAY") && !getenv("ELM_ENGINE"))
6301 enginelist[p++] = ELM_OPENGL_X11;
6302 enginelist[p++] = ELM_SOFTWARE_X11;
6306 enginelist[p++] = ELM_SOFTWARE_X11;
6307 enginelist[p++] = ELM_OPENGL_X11;
6311 #ifdef HAVE_ELEMENTARY_WL2
6312 else if (!_elm_preferred_engine &&
6313 getenv("WAYLAND_DISPLAY") && !getenv("ELM_ENGINE"))
6317 enginelist[p++] = ELM_WAYLAND_EGL;
6318 enginelist[p++] = ELM_WAYLAND_SHM;
6322 enginelist[p++] = ELM_WAYLAND_SHM;
6323 enginelist[p++] = ELM_WAYLAND_EGL;
6331 // add all engines with selected engine first - if any
6333 enginelist[p++] = ENGINE_GET();
6335 // add all engines with gl/accelerated ones first - only engines compiled
6336 #ifdef HAVE_ELEMENTARY_X
6337 enginelist[p++] = ELM_OPENGL_X11;
6339 #ifdef HAVE_ELEMENTARY_WL2
6340 enginelist[p++] = ELM_WAYLAND_EGL;
6342 #ifdef HAVE_ELEMENTARY_DRM
6343 enginelist[p++] = ELM_GL_DRM;
6344 enginelist[p++] = ELM_DRM;
6346 #ifdef HAVE_ELEMENTARY_FB
6347 enginelist[p++] = ELM_SOFTWARE_FB;
6349 #ifdef HAVE_ELEMENTARY_COCOA
6350 enginelist[p++] = ELM_OPENGL_COCOA;
6352 #ifdef HAVE_ELEMENTARY_SDL
6353 enginelist[p++] = ELM_OPENGL_SDL;
6355 #ifdef HAVE_ELEMENTARY_X
6356 enginelist[p++] = ELM_SOFTWARE_X11;
6358 #ifdef HAVE_ELEMENTARY_WL2
6359 enginelist[p++] = ELM_WAYLAND_SHM;
6361 #ifdef HAVE_ELEMENTARY_WIN32
6362 enginelist[p++] = ELM_SOFTWARE_WIN32;
6363 enginelist[p++] = ELM_SOFTWARE_DDRAW;
6365 #ifdef HAVE_ELEMENTARY_SDL
6366 enginelist[p++] = ELM_SOFTWARE_SDL;
6371 // add all engines with selected engine first - if any
6372 if (elm_config_preferred_engine_get())
6373 enginelist[p++] = elm_config_preferred_engine_get();
6374 // add check _elm_gl_preference whether "none" or not
6375 else if (_elm_config->engine &&
6376 ((elm_config_accel_preference_get() &&
6377 !strcmp(elm_config_accel_preference_get(), "none"))
6378 || (accel && !strcmp(accel, "none"))))
6379 enginelist[p++] = _elm_config->engine;
6380 // add all engines with gl/accelerated ones first - only engines compiled
6381 #ifdef HAVE_ELEMENTARY_X
6382 enginelist[p++] = ELM_SOFTWARE_X11;
6384 #ifdef HAVE_ELEMENTARY_WL2
6385 enginelist[p++] = ELM_WAYLAND_SHM;
6387 #ifdef HAVE_ELEMENTARY_DRM
6388 enginelist[p++] = ELM_DRM;
6390 #ifdef HAVE_ELEMENTARY_FB
6391 enginelist[p++] = ELM_SOFTWARE_FB;
6393 #ifdef HAVE_ELEMENTARY_COCOA
6394 enginelist[p++] = ELM_OPENGL_COCOA;
6396 #ifdef HAVE_ELEMENTARY_WIN32
6397 enginelist[p++] = ELM_SOFTWARE_WIN32;
6398 enginelist[p++] = ELM_SOFTWARE_DDRAW;
6400 #ifdef HAVE_ELEMENTARY_SDL
6401 enginelist[p++] = ELM_SOFTWARE_SDL;
6403 #ifdef HAVE_ELEMENTARY_X
6404 enginelist[p++] = ELM_OPENGL_X11;
6406 #ifdef HAVE_ELEMENTARY_WL2
6407 enginelist[p++] = ELM_WAYLAND_EGL;
6409 #ifdef HAVE_ELEMENTARY_DRM
6410 enginelist[p++] = ELM_GL_DRM;
6411 enginelist[p++] = ELM_DRM;
6413 #ifdef HAVE_ELEMENTARY_SDL
6414 enginelist[p++] = ELM_OPENGL_SDL;
6418 if (parent) parent_id = elm_win_window_id_get(parent);
6419 for (i = 0; i < p; i++)
6421 int opt[20], opt_i = 0;
6423 if (_elm_config->vsync)
6425 opt[opt_i++] = ECORE_EVAS_OPT_VSYNC;
6430 opt[opt_i++] = ECORE_EVAS_OPT_GL_DEPTH;
6431 opt[opt_i++] = gl_depth;
6435 opt[opt_i++] = ECORE_EVAS_OPT_GL_STENCIL;
6436 opt[opt_i++] = gl_stencil;
6440 opt[opt_i++] = ECORE_EVAS_OPT_GL_MSAA;
6441 opt[opt_i++] = gl_msaa;
6443 //TIZEN_ONLY(20230302): Added frontbuffer API
6444 if (sd->use_frontbuffer)
6446 opt[opt_i++] = ECORE_EVAS_OPT_FRONTBUFFER;
6452 if (!strcmp(enginelist[i], ELM_SOFTWARE_X11))
6453 tmp_sd.ee = ecore_evas_software_x11_new(NULL, 0, 0, 0, 0, 0);
6454 else if (!strcmp(enginelist[i], ELM_OPENGL_X11))
6457 tmp_sd.ee = ecore_evas_gl_x11_options_new(NULL, 0, 0, 0, 0, 0, opt);
6459 tmp_sd.ee = ecore_evas_gl_x11_new(NULL, 0, 0, 0, 0, 0);
6461 else if (!strcmp(enginelist[i], ELM_WAYLAND_SHM))
6462 tmp_sd.ee = _wayland_shm_new(NULL, parent_id, 0, 0, 0, 0, 0);
6463 else if (!strcmp(enginelist[i], ELM_WAYLAND_EGL))
6464 tmp_sd.ee = _wayland_egl_new(NULL, parent_id, 0, 0, 0, 0, 0, (opt_i > 0) ? opt : NULL);
6465 else if (!strcmp(enginelist[i], ELM_SOFTWARE_WIN32))
6466 tmp_sd.ee = ecore_evas_software_gdi_new(NULL, 0, 0, 1, 1);
6467 else if (!strcmp(enginelist[i], ELM_SOFTWARE_DDRAW))
6468 tmp_sd.ee = ecore_evas_software_ddraw_new(NULL, 0, 0, 1, 1);
6469 else if (!strcmp(enginelist[i], ELM_SOFTWARE_SDL))
6470 tmp_sd.ee = ecore_evas_sdl_new(NULL, 0, 0, 0, 0, 0, 1);
6471 else if (!strcmp(enginelist[i], ELM_OPENGL_SDL))
6472 tmp_sd.ee = ecore_evas_gl_sdl_new(NULL, 1, 1, 0, 0);
6473 else if (!strcmp(enginelist[i], ELM_OPENGL_COCOA))
6474 tmp_sd.ee = ecore_evas_cocoa_new(NULL, 1, 1, 0, 0);
6475 else if (!strcmp(enginelist[i], ELM_EWS))
6476 tmp_sd.ee = ecore_evas_ews_new(0, 0, 1, 1);
6477 else if (!strcmp(enginelist[i], ELM_SOFTWARE_FB))
6478 tmp_sd.ee = ecore_evas_fb_new(NULL, 0, 1, 1);
6479 else if (!strcmp(enginelist[i], ELM_BUFFER))
6480 tmp_sd.ee = ecore_evas_buffer_new(1, 1);
6481 else if (!strcmp(enginelist[i], ELM_DRM))
6482 tmp_sd.ee = ecore_evas_drm_new(NULL, 0, 0, 0, 1, 1);
6483 else if (!strcmp(enginelist[i], ELM_GL_DRM))
6484 tmp_sd.ee = ecore_evas_gl_drm_new(NULL, 0, 0, 0, 1, 1);
6485 else if (!strncmp(enginelist[i], "shot:", 5))
6487 tmp_sd.ee = ecore_evas_buffer_new(1, 1);
6488 ecore_evas_manual_render_set(tmp_sd.ee, EINA_TRUE);
6489 tmp_sd.shot.info = eina_stringshare_add(ENGINE_GET() + 5);
6491 engine = enginelist[i];
6492 if (tmp_sd.ee) break;
6497 eina_stringshare_del(accel);
6500 ERR("Cannot create window.");
6504 if (!sd->accel_pref)
6505 eina_stringshare_replace(&sd->accel_pref, elm_config_accel_preference_get());
6507 efl_parent_set(obj, ecore_evas_get(tmp_sd.ee));
6509 /* FIXME: Major hack: calling the constructor in the middle of finalize. */
6510 efl_constructor(efl_super(obj, MY_CLASS));
6511 evas_object_smart_callbacks_descriptions_set(obj, _smart_callbacks);
6513 if (getenv("ELM_FIRST_FRAME"))
6514 evas_event_callback_add(ecore_evas_get(tmp_sd.ee), EVAS_CALLBACK_RENDER_POST,
6515 _elm_win_first_frame_do, getenv("ELM_FIRST_FRAME"));
6517 /* copying possibly altered fields back */
6518 #define SD_CPY(_field) \
6521 sd->_field = tmp_sd._field; \
6529 if ((type != EFL_UI_WIN_TYPE_FAKE) && (trap) && (trap->add))
6530 sd->trap_data = trap->add(obj);
6532 /* complementary actions, which depend on final smart data
6534 if (type == EFL_UI_WIN_TYPE_INLINED_IMAGE)
6535 _win_inlined_image_set(sd);
6536 #ifdef HAVE_ELEMENTARY_X
6537 else if ((engine) &&
6538 ((!strcmp(engine, ELM_SOFTWARE_X11)) ||
6539 (!strcmp(engine, ELM_OPENGL_X11))))
6541 sd->x.client_message_handler = ecore_event_handler_add
6542 (ECORE_X_EVENT_CLIENT_MESSAGE, _elm_win_client_message, obj);
6543 sd->x.property_handler = ecore_event_handler_add
6544 (ECORE_X_EVENT_WINDOW_PROPERTY, _elm_win_property_change, obj);
6547 #ifdef HAVE_ELEMENTARY_WL2
6548 else if ((engine) &&
6549 ((!strcmp(engine, ELM_WAYLAND_SHM)) ||
6550 (!strcmp(engine, ELM_WAYLAND_EGL))))
6552 //TIZEN_ONLY(20171110): added signal for effect start and done
6553 sd->wl.effect_start_handler = ecore_event_handler_add
6554 (ECORE_WL2_EVENT_EFFECT_START, _elm_win_wl_effect_start, obj);
6555 sd->wl.effect_end_handler = ecore_event_handler_add
6556 (ECORE_WL2_EVENT_EFFECT_END, _elm_win_wl_effect_end, obj);
6557 // TIZEN_ONLY(20160801): indicator implementation
6558 sd->wl.indicator_flick_handler = ecore_event_handler_add
6559 (ECORE_WL2_EVENT_INDICATOR_FLICK, _elm_win_wl_indicator_flick, obj);
6561 // TIZEN_ONLY(20150722): added signal for aux_hint(auxiliary hint)
6562 sd->wl.aux_msg_handler = ecore_event_handler_add
6563 (ECORE_WL2_EVENT_AUX_MESSAGE, _elm_win_wl_aux_message, obj);
6568 else if ((engine) && (!strncmp(engine, "shot:", 5)))
6571 sd->kbdmode = EFL_UI_WIN_KEYBOARD_MODE_UNKNOWN;
6572 sd->legacy.indmode = ELM_WIN_INDICATOR_UNKNOWN;
6573 sd->indimode = EFL_UI_WIN_INDICATOR_MODE_OFF;
6575 #ifdef HAVE_ELEMENTARY_X
6576 _internal_elm_win_xwindow_get(sd);
6577 if (sd->x.xwin) ecore_x_io_error_handler_set(_elm_x_io_err, NULL);
6580 #ifdef HAVE_ELEMENTARY_WL2
6581 _elm_win_wlwindow_get(sd);
6584 //TIZEN_ONLY(20160720): Allowed changing type after initializing
6586 Ecore_Wl2_Window_Type wtype;
6588 sd->wl.configure_handler =
6589 ecore_event_handler_add(ECORE_WL2_EVENT_WINDOW_CONFIGURE, _elm_win_wl_configure, obj);
6590 //TIZEN_ONLY(20160720): Allowed changing type after initializing
6595 case ELM_WIN_DIALOG_BASIC:
6596 case ELM_WIN_NAVIFRAME_BASIC:
6597 case ELM_WIN_SPLASH:
6598 case ELM_WIN_TOOLBAR:
6599 case ELM_WIN_UTILITY:
6601 case ELM_WIN_DESKTOP:
6602 wtype = ECORE_WL2_WINDOW_TYPE_TOPLEVEL;
6604 case ELM_WIN_TOOLTIP:
6607 case ELM_WIN_POPUP_MENU:
6608 wtype = ECORE_WL2_WINDOW_TYPE_MENU;
6611 wtype = ECORE_WL2_WINDOW_TYPE_DND;
6614 wtype = ECORE_WL2_WINDOW_TYPE_NONE;
6616 ecore_wl2_window_type_set(sd->wl.win, wtype);
6618 _elm_win_wlwin_type_update(sd);
6621 else if (sd->type == EFL_UI_WIN_TYPE_FAKE)
6623 const char *env = getenv("WAYLAND_DISPLAY");
6626 Ecore_Wl2_Display *d = ecore_wl2_display_connect(env);
6627 sd->wl.win = ecore_wl2_window_new(d, NULL, 0, 0, 1, 1);
6628 ecore_wl2_display_disconnect(d);
6629 //TIZEN_ONLY(20180518): call ecore_wl2_window_free only fake make it
6630 evas_object_data_set(sd->obj, "__fake_make_wl2", sd->obj);
6636 #ifdef HAVE_ELEMENTARY_COCOA
6637 _elm_win_cocoawindow_get(sd);
6639 #ifdef HAVE_ELEMENTARY_WIN32
6640 sd->win32.key_down_handler = ecore_event_handler_add(ECORE_EVENT_KEY_DOWN,
6641 _elm_win_key_down, obj);
6642 _internal_elm_win_win32window_get(sd);
6645 if ((_elm_config->bgpixmap)
6646 #ifdef HAVE_ELEMENTARY_X
6647 && (((sd->x.xwin) && (!ecore_x_screen_is_composited(0))) ||
6651 TRAP(sd, avoid_damage_set, ECORE_EVAS_AVOID_DAMAGE_EXPOSE);
6652 // bg pixmap done by x - has other issues like can be redrawn by x before it
6653 // is filled/ready by app
6654 // TRAP(sd, avoid_damage_set, ECORE_EVAS_AVOID_DAMAGE_BUILT_IN);
6657 sd->parent = parent;
6658 sd->modal_count = 0;
6659 sd->withdrawn = ecore_evas_withdrawn_get(sd->ee);
6663 // TIZEN_ONLY(20160315) set wayland parent window
6664 #ifdef HAVE_ELEMENTARY_WL2
6665 if ((sd->type >= ELM_WIN_BASIC) && (sd->type <= ELM_WIN_DND))
6666 //TIZEN_ONLY(20171208): fix build break by opensource temporarily until migration finish
6667 ecore_wl2_window_parent_set(sd->wl.win, (Ecore_Wl2_Window *)elm_win_wl_window_get(sd->parent));
6668 //TIZEN_ONLY(20171208)
6671 evas_object_event_callback_add
6672 (sd->parent, EVAS_CALLBACK_DEL, _elm_win_on_parent_del, obj);
6675 // TIZEN_ONLY(20161114): Sync the state of indicator with window manager
6676 #ifdef HAVE_ELEMENTARY_WL2
6678 ecore_wl2_indicator_visible_type_set(sd->wl.win, ECORE_WL2_INDICATOR_VISIBLE_TYPE_SHOWN);
6682 sd->evas = ecore_evas_get(sd->ee);
6684 evas_object_color_set(obj, 0, 0, 0, 0);
6685 //TIZEN_ONLY(20180530): keep default geometry compatibility
6686 evas_object_move(obj, 0, 0);
6687 evas_object_resize(obj, 1, 1);
6689 evas_object_pass_events_set(obj, EINA_TRUE);
6691 if (type == EFL_UI_WIN_TYPE_INLINED_IMAGE)
6692 efl_ui_win_inlined_parent_set(obj, parent);
6694 /* use own version of ecore_evas_object_associate() that does TRAP() */
6695 ecore_evas_data_set(sd->ee, "elm_win", obj);
6697 if (type != EFL_UI_WIN_TYPE_FAKE)
6699 evas_object_event_callback_add(obj, EVAS_CALLBACK_CHANGED_SIZE_HINTS,
6700 _elm_win_obj_callback_changed_size_hints, NULL);
6701 evas_object_intercept_raise_callback_add
6702 (obj, _elm_win_obj_intercept_raise, obj);
6703 evas_object_intercept_lower_callback_add
6704 (obj, _elm_win_obj_intercept_lower, obj);
6705 evas_object_intercept_stack_above_callback_add
6706 (obj, _elm_win_obj_intercept_stack_above, obj);
6707 evas_object_intercept_stack_below_callback_add
6708 (obj, _elm_win_obj_intercept_stack_below, obj);
6709 evas_object_intercept_layer_set_callback_add
6710 (obj, _elm_win_obj_intercept_layer_set, obj);
6713 TRAP(sd, name_class_set, name, _elm_appname);
6714 TRAP(sd, title_set, sd->title);
6715 ecore_evas_callback_delete_request_set(sd->ee, _elm_win_delete_request);
6716 ecore_evas_callback_state_change_set(sd->ee, _elm_win_state_change);
6717 ecore_evas_callback_focus_in_set(sd->ee, _elm_win_focus_in);
6718 ecore_evas_callback_focus_out_set(sd->ee, _elm_win_focus_out);
6719 ecore_evas_callback_resize_set(sd->ee, _elm_win_resize);
6720 ecore_evas_callback_move_set(sd->ee, _elm_win_move);
6721 ecore_evas_callback_pre_render_set(sd->ee, _elm_win_pre_render);
6722 if (type != EFL_UI_WIN_TYPE_FAKE)
6724 ecore_evas_callback_mouse_in_set(sd->ee, _elm_win_mouse_in);
6725 ecore_evas_callback_mouse_out_set(sd->ee, _elm_win_mouse_out);
6728 evas_object_event_callback_add(obj, EVAS_CALLBACK_HIDE, _elm_win_cb_hide, NULL);
6729 evas_object_event_callback_add(obj, EVAS_CALLBACK_SHOW, _elm_win_cb_show, NULL);
6731 evas_image_cache_set(sd->evas, (_elm_config->image_cache * 1024));
6732 evas_font_cache_set(sd->evas, (_elm_config->font_cache * 1024));
6734 EINA_LIST_FOREACH(_elm_config->font_dirs, l, fontpath)
6735 evas_font_path_append(sd->evas, fontpath);
6737 if (!_elm_config->font_hinting)
6738 evas_font_hinting_set(sd->evas, EVAS_FONT_HINTING_NONE);
6739 else if (_elm_config->font_hinting == 1)
6740 evas_font_hinting_set(sd->evas, EVAS_FONT_HINTING_AUTO);
6741 else if (_elm_config->font_hinting == 2)
6742 evas_font_hinting_set(sd->evas, EVAS_FONT_HINTING_BYTECODE);
6744 sd->wm_rot.wm_supported = ecore_evas_wm_rotation_supported_get(sd->ee);
6745 sd->wm_rot.preferred_rot = -1; // it means that elm_win doesn't use preferred rotation.
6747 #ifdef HAVE_ELEMENTARY_X
6748 _elm_win_xwin_update(sd);
6751 if (type != EFL_UI_WIN_TYPE_FAKE)
6753 //Prohibiting auto-rendering, until elm_win is shown.
6754 if (_elm_win_auto_norender_withdrawn(obj))
6756 if (elm_win_withdrawn_get(obj))
6758 if (!evas_object_data_get(obj, "__win_auto_norender"))
6760 elm_win_norender_push(obj);
6761 evas_object_data_set(obj, "__win_auto_norender", obj);
6768 Evas_Modifier_Mask mask = evas_key_modifier_mask_get(sd->evas, "Control");
6769 evas_object_event_callback_add
6770 (obj, EVAS_CALLBACK_KEY_DOWN, _debug_key_down, NULL);
6772 if (evas_object_key_grab(obj, "F12", mask, 0, EINA_TRUE))
6773 INF("Ctrl+F12 key combination exclusive for dot tree generation\n");
6775 ERR("failed to grab F12 key to elm widgets (dot) tree generation");
6778 if (type != EFL_UI_WIN_TYPE_FAKE)
6780 if ((_elm_config->softcursor_mode == ELM_SOFTCURSOR_MODE_ON) ||
6781 ((_elm_config->softcursor_mode == ELM_SOFTCURSOR_MODE_AUTO) &&
6783 ((!strcmp(engine, ELM_SOFTWARE_FB)) || (!strcmp(engine, ELM_DRM))
6784 || (!strcmp(engine, ELM_GL_DRM))))))
6787 Evas_Coord mw = 1, mh = 1, hx = 0, hy = 0;
6789 sd->pointer.obj = o = edje_object_add(ecore_evas_get(tmp_sd.ee));
6790 elm_widget_theme_object_set(obj, o, "pointer", "base", "default");
6791 edje_object_size_min_calc(o, &mw, &mh);
6792 evas_object_resize(o, mw, mh);
6793 if (elm_widget_is_legacy(obj))
6794 edje_object_part_geometry_get(o, "elm.swallow.hotspot",
6795 &hx, &hy, NULL, NULL);
6797 edje_object_part_geometry_get(o, "efl.hotspot",
6798 &hx, &hy, NULL, NULL);
6800 sd->pointer.hot_x = hx;
6801 sd->pointer.hot_y = hy;
6802 evas_object_show(o);
6803 ecore_evas_object_cursor_set(tmp_sd.ee, o, EVAS_LAYER_MAX, hx, hy);
6805 else if (_elm_config->softcursor_mode == ELM_SOFTCURSOR_MODE_OFF)
6811 _elm_win_legacy_init(sd);
6812 _elm_win_need_frame_adjust(sd, engine);
6813 _elm_win_apply_alpha(obj, sd);
6815 #ifdef HAVE_ELEMENTARY_WL2
6816 //TIZEN_ONLY(20180106): disable pointer window
6818 if ((type != EFL_UI_WIN_TYPE_FAKE) && (type != EFL_UI_WIN_TYPE_INLINED_IMAGE))
6821 ((!strcmp(engine, ELM_WAYLAND_SHM) ||
6822 (!strcmp(engine, ELM_WAYLAND_EGL)))))
6826 if (!strcmp(engine, ELM_WAYLAND_SHM))
6827 sd->pointer.ee = ecore_evas_wayland_shm_new(NULL, 0, 0, 0, 0, 0, 0);
6828 else if (!strcmp(engine, ELM_WAYLAND_EGL))
6829 sd->pointer.ee = ecore_evas_wayland_egl_new(NULL, 0, 0, 0, 0, 0, 0);
6830 ecore_evas_alpha_set(sd->pointer.ee, EINA_TRUE);
6832 pevas = ecore_evas_get(sd->pointer.ee);
6834 sd->pointer.obj = edje_object_add(pevas);
6836 sd->pointer.win = ecore_evas_wayland2_window_get(sd->pointer.ee);
6837 ecore_wl2_window_type_set(sd->pointer.win,
6838 ECORE_WL2_WINDOW_TYPE_NONE);
6839 _elm_win_wl_cursor_set(sd->obj, NULL);
6840 ecore_evas_show(sd->pointer.ee);
6847 /* do not append to list; all windows render as black rects */
6848 if (type != EFL_UI_WIN_TYPE_FAKE)
6850 const char *element = "base";
6853 _elm_win_list = eina_list_append(_elm_win_list, obj);
6857 ((!strcmp(engine, ELM_SOFTWARE_FB)) || (!strcmp(engine, ELM_DRM))
6858 || (!strcmp(engine, ELM_GL_DRM))))
6860 TRAP(sd, fullscreen_set, 1);
6862 style = elm_widget_style_get(obj);
6863 if (!style) style = "default";
6866 case EFL_UI_WIN_TYPE_DIALOG_BASIC: element = "dialog"; break;
6867 case EFL_UI_WIN_TYPE_NAVIFRAME_BASIC: element = "naviframe"; break;
6871 if (!_elm_config->win_no_border)
6872 _elm_win_frame_add(sd, element, style);
6874 if (sd->indimode != EFL_UI_WIN_INDICATOR_MODE_OFF)
6877 if (_elm_config->focus_highlight_enable)
6878 elm_win_focus_highlight_enabled_set(obj, EINA_TRUE);
6879 if (_elm_config->focus_highlight_animate)
6880 elm_win_focus_highlight_animate_set(obj, EINA_TRUE);
6883 efl_access_object_role_set(obj, EFL_ACCESS_ROLE_WINDOW);
6884 if (_elm_atspi_enabled())
6885 efl_access_window_created_signal_emit(obj);
6887 // attach config API
6888 efl_composite_attach(obj, efl_provider_find(efl_main_loop_get(), EFL_CONFIG_GLOBAL_CLASS));
6890 efl_event_callback_array_add(sd->evas, _elm_evas_tracking(), sd);
6891 efl_event_callback_array_add(obj, _elm_win_evas_feed_fake_callbacks(), sd->evas);
6892 efl_event_callback_array_add(obj, _elm_win_tracking(), sd);
6893 evas_object_show(sd->legacy.edje);
6895 if (type == EFL_UI_WIN_TYPE_FAKE)
6897 _elm_win_resize_job(obj);
6898 _elm_win_move(sd->ee);
6902 sd->finalize_future = eina_future_then_easy(efl_loop_job(efl_loop_get(obj)),
6903 .success = _win_finalize_job_cb, .data = sd);
6906 // All normal windows are "standard" windows with EO API
6907 if (!sd->legacy.ctor)
6911 case EFL_UI_WIN_TYPE_UNKNOWN:
6912 case EFL_UI_WIN_TYPE_BASIC:
6913 case EFL_UI_WIN_TYPE_DIALOG_BASIC:
6914 _elm_win_standard_init(obj);
6920 //TIZEN_ONLY(20171201): Use win_no_border config.
6921 if(_elm_config->win_no_border)
6923 elm_win_borderless_set(obj, EINA_TRUE);
6927 /* TIZEN_ONLY(20180117): Apply paragraph direction according to locale */
6928 if (!strcmp(E_("default:LTR"), "default:RTL"))
6929 evas_object_paragraph_direction_set(obj, EVAS_BIDI_DIRECTION_ANY_RTL);
6931 evas_object_paragraph_direction_set(obj, EVAS_BIDI_DIRECTION_LTR);
6933 // Load the config values into gesutre manager.
6934 _gesture_manager_config_load(obj);
6940 _efl_ui_win_efl_object_finalize(Eo *obj, Efl_Ui_Win_Data *sd)
6942 Eina_Bool resume = !_elm_win_count;
6944 obj = _elm_win_finalize_internal(obj, sd, sd->name, sd->type);
6945 if (!obj) return NULL;
6946 obj = efl_finalize(efl_super(obj, MY_CLASS));
6947 if (obj && resume) efl_event_callback_call(efl_loop_get(obj), EFL_APP_EVENT_RESUME, NULL);
6948 if (obj && (!elm_widget_is_legacy(obj)))
6950 /* FIXME: if parts other than background are supported then this should change */
6951 if (efl_file_get(efl_super(efl_part(obj, "background"), EFL_UI_WIN_PART_CLASS)) ||
6952 efl_file_mmap_get(efl_super(efl_part(obj, "background"), EFL_UI_WIN_PART_CLASS)))
6953 efl_file_load(efl_part(obj, "background"));
6955 _ee_backbone_init(obj, sd);
6960 _efl_ui_win_efl_canvas_object_legacy_ctor(Eo *obj, Efl_Ui_Win_Data *sd)
6962 efl_canvas_object_legacy_ctor(efl_super(obj, MY_CLASS));
6963 sd->legacy.ctor = EINA_TRUE;
6966 EOLIAN EINA_UNUSED static Efl_Ui_Focus_Manager*
6967 _efl_ui_win_efl_ui_widget_focus_manager_focus_manager_create(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *pd EINA_UNUSED, Efl_Ui_Focus_Object *root)
6969 Efl_Ui_Focus_Manager *manager;
6971 manager = efl_add(EFL_UI_FOCUS_MANAGER_CALC_CLASS, obj,
6972 efl_ui_focus_manager_root_set(efl_added, root)
6979 _efl_ui_win_efl_object_destructor(Eo *obj, Efl_Ui_Win_Data *pd EINA_UNUSED)
6981 #ifdef HAVE_ELEMENTARY_WL2
6982 //TIZEN_ONLY(20180518): call ecore_wl2_window_free only fake make it
6983 // if (pd->type == EFL_UI_WIN_TYPE_FAKE)
6984 if (pd->type == EFL_UI_WIN_TYPE_FAKE && evas_object_data_get(pd->obj, "__fake_make_wl2"))
6986 evas_object_data_del(obj, "__fake_make_wl2");
6989 ecore_wl2_window_free(pd->wl.win);
6992 if (pd->finalize_future)
6993 eina_future_cancel(pd->finalize_future);
6995 _ee_backbone_shutdown(obj, pd);
6997 efl_destructor(efl_super(obj, MY_CLASS));
6999 efl_unref(pd->provider);
7003 _efl_ui_win_efl_object_constructor(Eo *obj, Efl_Ui_Win_Data *pd)
7005 /* UGLY HACK: Do (almost) nothing here:
7006 * We are calling the constructor chain from the finalizer. It's
7007 * really bad and hacky. Needs fixing. */
7010 pd->provider = efl_add_ref(EFL_UI_FOCUS_PARENT_PROVIDER_STANDARD_CLASS, NULL);
7011 pd->profile.available = eina_array_new(4);
7012 pd->max_w = pd->max_h = -1;
7013 pd->planned_changes = eina_array_new(10);
7015 // For bindings: if no parent, allow simple unref
7016 if (!efl_parent_get(obj))
7017 efl_allow_parent_unref_set(obj, EINA_TRUE);
7019 //TIZEN_ONLY(20181024): Fix parent-children incosistencies in atspi tree
7020 Eo *root = efl_access_object_access_root_get();
7021 efl_access_object_access_parent_set(obj, root);
7024 if (!elm_widget_is_legacy(obj))
7025 pd->type = EFL_UI_WIN_TYPE_BASIC;
7031 _efl_ui_win_efl_text_text_set(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, const char *title)
7034 eina_stringshare_replace(&(sd->title), title);
7036 TRAP(sd, title_set, sd->title);
7039 if (elm_widget_is_legacy(sd->obj))
7040 edje_object_part_text_escaped_set(sd->frame_obj, "elm.text.title", sd->title);
7042 edje_object_part_text_escaped_set(sd->frame_obj, "efl.text.title", sd->title);
7046 EOLIAN static const char*
7047 _efl_ui_win_efl_text_text_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd)
7053 _efl_ui_win_efl_ui_i18n_language_set(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, const char *locale)
7056 efl_ui_language_set(sd->frame_obj, locale);
7060 _efl_ui_win_efl_ui_i18n_language_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd)
7062 return sd->frame_obj ? efl_ui_language_get(sd->frame_obj) : NULL;
7066 _efl_ui_win_efl_ui_l10n_l10n_text_set(Eo *obj, Efl_Ui_Win_Data *sd, const char *label, const char *domain)
7069 efl_ui_l10n_text_set(efl_part(obj, "efl.text.title"), label, domain);
7072 EOLIAN static const char *
7073 _efl_ui_win_efl_ui_l10n_l10n_text_get(const Eo *obj, Efl_Ui_Win_Data *sd, const char **domain)
7075 return sd->frame_obj ?
7076 efl_ui_l10n_text_get(efl_part(obj, "efl.text.title"), domain) : NULL;
7080 _efl_ui_win_win_type_set(Eo *obj, Efl_Ui_Win_Data *sd, Efl_Ui_Win_Type type)
7082 if (efl_finalized_get(obj))
7084 // TIZEN_ONLY(20160720): Allowed changing type after initializing
7085 #ifdef HAVE_ELEMENTARY_WL2
7086 if (sd->type != EFL_UI_WIN_TYPE_FAKE) sd->type = type;
7087 _elm_win_wlwin_type_update(sd);
7088 //TIZEN_ONLY(20161208): supported floating window
7089 if (type != EFL_UI_WIN_TYPE_BASIC)
7090 edje_object_signal_emit(sd->legacy.edje, "elm,state,floating,on", "elm");
7092 edje_object_signal_emit(sd->legacy.edje, "elm,state,floating,off", "elm");
7093 //TIZEN_ONLY(20161208)
7096 ERR("This function is only allowed during construction.");
7102 EOLIAN static Efl_Ui_Win_Type
7103 _efl_ui_win_win_type_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd)
7109 _efl_ui_win_win_name_set(Eo *obj, Efl_Ui_Win_Data *sd, const char *name)
7111 if (efl_finalized_get(obj))
7113 ERR("This function is only allowed during construction.");
7116 sd->name = eina_stringshare_add(name);
7119 EOLIAN static const char *
7120 _efl_ui_win_win_name_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd)
7126 _efl_ui_win_accel_preference_set(Eo *obj, Efl_Ui_Win_Data *pd, const char *accel)
7128 if (efl_finalized_get(obj))
7130 ERR("This function is only allowed during construction.");
7133 eina_stringshare_replace(&pd->accel_pref, accel);
7136 EOLIAN static const char *
7137 _efl_ui_win_accel_preference_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *pd)
7139 return pd->accel_pref;
7142 //TIZEN_ONLY(20230302): Added frontbuffer API
7144 _efl_ui_win_use_frontbuffer_set(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *pd, Eina_Bool use_frontbuffer)
7146 if (efl_finalized_get(obj))
7148 ERR("This function is only allowed during construction.");
7151 pd->use_frontbuffer = use_frontbuffer;
7154 EOLIAN static Eina_Bool
7155 _efl_ui_win_use_frontbuffer_get(const Eo *obj, Efl_Ui_Win_Data *pd)
7157 return pd->use_frontbuffer;
7162 _efl_ui_win_win_role_set(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, const char *role)
7165 eina_stringshare_replace(&(sd->role), role);
7166 #ifdef HAVE_ELEMENTARY_X
7167 _elm_win_xwin_update(sd);
7169 //TIZEN_ONLY(20180619): set role for wayland window
7170 #ifdef HAVE_ELEMENTARY_WL2
7171 ecore_wl2_window_role_set(sd->wl.win, role);
7176 EOLIAN static const char*
7177 _efl_ui_win_win_role_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd)
7183 _efl_ui_win_icon_object_set(Eo *obj, Efl_Ui_Win_Data *sd, Evas_Object *icon)
7185 if (icon && (!efl_isa(icon, EFL_CANVAS_IMAGE_INTERNAL_CLASS) &&
7186 !efl_isa(icon, EFL_UI_IMAGE_CLASS)))
7188 ERR("Icon object type is not supported!");
7195 efl_event_callback_del(sd->icon, EFL_EVENT_DEL, _elm_win_on_icon_del, obj);
7201 efl_event_callback_add(sd->icon, EFL_EVENT_DEL, _elm_win_on_icon_del, obj);
7204 if (elm_widget_is_legacy(sd->obj))
7205 edje_object_part_swallow(sd->frame_obj, "elm.swallow.icon", sd->icon);
7207 edje_object_part_swallow(sd->frame_obj, "efl.icon", sd->icon);
7209 evas_object_is_frame_object_set(sd->icon, EINA_TRUE);
7212 #ifdef HAVE_ELEMENTARY_X
7213 _elm_win_xwin_update(sd);
7214 //TIZEN_ONLY(160628): To support an app window icon on SDK UI Tools.
7215 #elif HAVE_ELEMENTARY_WIN32
7217 elm_image_file_get(icon, &path, NULL);
7218 ecore_win32_window_icon_set(sd->win32.win, path);
7222 EOLIAN static const Evas_Object*
7223 _efl_ui_win_icon_object_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd)
7228 EOLIAN static const Eina_Value *
7229 _efl_ui_win_exit_on_close_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd)
7231 return &sd->exit_on_close;
7235 _efl_ui_win_exit_on_close_set(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, const Eina_Value *exit_code)
7237 const Eina_Value_Type *type = eina_value_type_get(exit_code);
7240 eina_value_copy(exit_code, &sd->exit_on_close);
7242 eina_value_flush(&sd->exit_on_close);
7245 /* Only for C API */
7247 elm_win_autodel_set(Eo *obj, Eina_Bool autodel)
7249 ELM_WIN_DATA_GET_OR_RETURN(obj, sd);
7250 sd->autodel = autodel;
7254 elm_win_autodel_get(const Eo *obj)
7256 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
7257 if (!sd) return EINA_FALSE;
7262 _efl_ui_win_autohide_set(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, Eina_Bool autohide)
7264 sd->autohide = autohide;
7267 EOLIAN static Eina_Bool
7268 _efl_ui_win_autohide_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd)
7270 return sd->autohide;
7274 _efl_ui_win_activate(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd)
7280 _efl_ui_win_efl_gfx_stack_raise_to_top(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *pd)
7286 elm_win_raise(Eo *obj)
7288 efl_gfx_stack_raise_to_top(obj);
7292 _efl_ui_win_efl_gfx_stack_lower_to_bottom(Eo *obj, Efl_Ui_Win_Data *pd EINA_UNUSED)
7294 // Do nothing: in X we could request to stack lower but that has been abused
7295 // and transformed into a kind of "iconify". As a consequence, lower is
7296 // not allowed in EO land.
7297 if (!elm_widget_is_legacy(obj)) return;
7299 // Legacy support...
7304 _efl_ui_win_center(Eo *obj, Efl_Ui_Win_Data *sd, Eina_Bool h, Eina_Bool v)
7306 int win_w, win_h, screen_x, screen_y, screen_w, screen_h, nx, ny;
7308 if (sd->deferred_resize_job) _elm_win_resize_job(sd->obj);
7309 if (sd->frame_obj) edje_object_message_signal_process(sd->frame_obj);
7310 evas_smart_objects_calculate(evas_object_evas_get(obj));
7311 _elm_win_resize_objects_eval(obj, EINA_FALSE);
7312 if ((trap) && (trap->center) && (!trap->center(sd->trap_data, obj, h, v)))
7315 if (!efl_gfx_entity_visible_get(obj))
7317 // Chose to use env var so this will also translate more easily
7318 // to wayland. yes - we can get x atoms to figure out if wm is
7319 // enlightenment, but this works just as well. for wl we'd need
7320 // an alternate wl specific way... this below works better IMHO
7321 const char *s = getenv("DESKTOP");
7323 if ((s) && (!strcasecmp(s, "Enlightenment")))
7325 #ifdef HAVE_ELEMENTARY_X
7328 static Ecore_X_Atom state = 0;
7329 static Ecore_X_Atom centered = 0;
7331 _internal_elm_win_xwindow_get(sd);
7332 if (!centered) centered = ecore_x_atom_get
7333 ("__E_ATOM_WINDOW_STATE_CENTERED");
7334 if (!state) state = ecore_x_atom_get
7335 ("__E_ATOM_WINDOW_STATE");
7336 ecore_x_window_prop_card32_set(sd->x.xwin, state, ¢ered, 1);
7339 // XXX: what to do with wayland?
7340 // XXX: what to do with win32?
7341 // XXX: what to do with osx/coca?
7345 // not e - fall back to manually placing on what we think the screen
7346 // is/will be... to do this move window to where pointer is first
7347 #ifdef HAVE_ELEMENTARY_X
7357 else evas_object_geometry_get(obj, NULL, NULL, &win_w, &win_h);
7358 ecore_x_pointer_root_xy_get(&x, &y);
7359 ecore_evas_move(sd->ee, x - (win_w / 2), y - (win_h / 2));
7362 // XXX: what to do with wayland?
7363 // XXX: what to do with win32?
7364 // XXX: what to do with osx/coca?
7368 ecore_evas_screen_geometry_get(sd->ee,
7369 &screen_x, &screen_y,
7370 &screen_w, &screen_h);
7371 if ((!screen_w) || (!screen_h)) return;
7378 else evas_object_geometry_get(obj, NULL, NULL, &win_w, &win_h);
7384 else evas_object_geometry_get(obj, &nx, &ny, NULL, NULL);
7386 if ((!win_w) || (!win_h)) return;
7388 if (h) nx = win_w >= screen_w ? 0 : (screen_w / 2) - (win_w / 2);
7389 if (v) ny = win_h >= screen_h ? 0 : (screen_h / 2) - (win_h / 2);
7391 sd->req_xy = EINA_TRUE;
7392 sd->req_x = screen_x + nx;
7393 sd->req_y = screen_y + ny;
7394 evas_object_move(obj, screen_x + nx, screen_y + ny);
7398 _efl_ui_win_borderless_set(Eo *obj, Efl_Ui_Win_Data *sd, Eina_Bool borderless)
7400 sd->csd.need_borderless = borderless ? 1 : 0;
7401 _elm_win_frame_style_update(sd, 0, 1);
7403 #ifdef HAVE_ELEMENTARY_X
7404 if (!sd->x.xwin || !sd->csd.need)
7406 TRAP(sd, borderless_set, borderless);
7408 _elm_win_resize_objects_eval(obj, EINA_FALSE);
7409 #ifdef HAVE_ELEMENTARY_X
7410 _elm_win_xwin_update(sd);
7414 EOLIAN static Eina_Bool
7415 _efl_ui_win_borderless_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd)
7418 return ecore_evas_borderless_get(sd->ee);
7419 return sd->csd.need_borderless;
7423 _efl_ui_win_alpha_set(Eo *obj, Efl_Ui_Win_Data *sd, Eina_Bool enabled)
7425 sd->application_alpha = enabled;
7426 _elm_win_apply_alpha(obj, sd);
7427 _elm_win_frame_style_update(sd, 0, 1);
7430 EOLIAN static Eina_Bool
7431 _efl_ui_win_alpha_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd)
7435 return evas_object_image_alpha_get(sd->img_obj);
7439 return ecore_evas_alpha_get(sd->ee);
7446 _efl_ui_win_fullscreen_set(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, Eina_Bool fullscreen)
7448 const char *engine_name = ecore_evas_engine_name_get(sd->ee);
7449 // YYY: handle if sd->img_obj
7451 ((!strcmp(engine_name, ELM_SOFTWARE_FB)) ||
7452 (!strcmp(engine_name, ELM_DRM)) ||
7453 (!strcmp(engine_name, ELM_GL_DRM))))
7455 // these engines... can ONLY be fullscreen
7458 else if (sd->type == EFL_UI_WIN_TYPE_FAKE)
7459 sd->fullscreen = !!fullscreen;
7462 // sd->fullscreen = fullscreen;
7463 TRAP(sd, fullscreen_set, fullscreen);
7465 #ifdef HAVE_ELEMENTARY_X
7466 _elm_win_xwin_update(sd);
7471 EOLIAN static Eina_Bool
7472 _efl_ui_win_fullscreen_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd)
7474 const char *engine_name = ecore_evas_engine_name_get(sd->ee);
7477 ((!strcmp(engine_name, ELM_SOFTWARE_FB)) ||
7478 (!strcmp(engine_name, ELM_DRM)) ||
7479 (!strcmp(engine_name, ELM_GL_DRM))))
7481 // these engines... can ONLY be fullscreen
7484 return sd->fullscreen;
7488 _main_menu_swallow_get(Efl_Ui_Win_Data *sd)
7490 Eina_Bool legacy_menu_swallow = EINA_TRUE;
7494 data = edje_object_data_get(sd->legacy.edje, "version");
7495 version = data ? atoi(data) : 0;
7496 if (version >= 119) legacy_menu_swallow = EINA_FALSE;
7498 #ifdef HAVE_ELEMENTARY_COCOA
7499 if (sd->cocoa.win) legacy_menu_swallow = EINA_TRUE;
7502 if (legacy_menu_swallow)
7504 DBG("Detected legacy theme, using legacy swallows.");
7505 return sd->legacy.edje;
7507 return sd->frame_obj;
7511 _main_menu_resize_cb(void *data EINA_UNUSED, const Efl_Event *ev)
7513 // After resize, the framespace size has changed, so update the win geometry
7514 _elm_win_resize_objects_eval(ev->object, EINA_FALSE);
7515 efl_event_callback_del(ev->object, EFL_GFX_ENTITY_EVENT_SIZE_CHANGED, _main_menu_resize_cb, NULL);
7519 _dbus_menu_set(Eina_Bool dbus_connect, void *data)
7521 ELM_WIN_DATA_GET_OR_RETURN(data, sd);
7522 Eo *swallow = _main_menu_swallow_get(sd);
7526 DBG("Setting menu to D-Bus");
7527 edje_object_part_unswallow(swallow, sd->main_menu);
7528 sd->csd.need_menu = EINA_FALSE;
7529 _elm_menu_menu_bar_hide(sd->main_menu);
7530 _elm_win_resize_objects_eval(sd->obj, EINA_FALSE);
7531 if (swallow != sd->frame_obj)
7533 // Note: Based on EFL 1.18 the signal was "elm,action,hide"
7534 // and not "elm,action,hide_menu" as expected.
7535 if (elm_widget_is_legacy(data))
7536 edje_object_signal_emit(swallow, "elm,action,hide", "elm");
7538 edje_object_signal_emit(swallow, "efl,action,hide", "efl");
7539 edje_object_message_signal_recursive_process(swallow);
7544 DBG("Setting menu to local mode");
7545 efl_event_callback_add(sd->obj, EFL_GFX_ENTITY_EVENT_SIZE_CHANGED, _main_menu_resize_cb, NULL);
7547 if (elm_widget_is_legacy(sd->obj))
7548 edje_object_part_swallow(swallow, "elm.swallow.menu", sd->main_menu);
7550 edje_object_part_swallow(swallow, "efl.menu", sd->main_menu);
7552 evas_object_show(sd->main_menu);
7553 if (swallow == sd->frame_obj)
7555 efl_canvas_object_is_frame_object_set(sd->main_menu, EINA_TRUE);
7556 sd->csd.need_menu = EINA_TRUE;
7560 if (elm_widget_is_legacy(data))
7561 edje_object_signal_emit(swallow, "elm,action,show_menu", "elm");
7563 edje_object_signal_emit(swallow, "efl,action,show_menu", "efl");
7564 edje_object_message_signal_recursive_process(swallow);
7567 _elm_win_frame_style_update(sd, 0, 1);
7568 //sd->deferred_resize_job = EINA_TRUE;
7571 EOLIAN static const Eina_Value *
7572 _efl_ui_win_exit_on_all_windows_closed_get(void)
7574 return &exit_on_all_windows_closed;
7578 _efl_ui_win_exit_on_all_windows_closed_set(const Eina_Value *exit_code)
7580 const Eina_Value_Type *type = eina_value_type_get(exit_code);
7583 eina_value_copy(exit_code, &exit_on_all_windows_closed);
7585 eina_value_flush(&exit_on_all_windows_closed);
7589 _efl_ui_win_maximized_set(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, Eina_Bool maximized)
7591 _elm_win_frame_style_update(sd, 0, 1);
7592 // YYY: handle if sd->img_obj
7593 TRAP(sd, maximized_set, maximized);
7594 #ifdef HAVE_ELEMENTARY_X
7595 _elm_win_xwin_update(sd);
7599 EOLIAN static Eina_Bool
7600 _efl_ui_win_maximized_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd)
7602 return sd->maximized;
7606 _efl_ui_win_minimized_set(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, Eina_Bool minimized)
7608 // sd->minimized = minimized;
7609 TRAP(sd, iconified_set, minimized);
7610 #ifdef HAVE_ELEMENTARY_X
7611 _elm_win_xwin_update(sd);
7615 EOLIAN static Eina_Bool
7616 _efl_ui_win_minimized_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd)
7618 return sd->minimized;
7622 _efl_ui_win_wm_available_profiles_set(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, const Eina_Array *profiles)
7624 Eina_Bool found = EINA_FALSE;
7626 _elm_win_available_profiles_del(sd);
7627 if (profiles && eina_array_count(profiles))
7632 it = eina_array_iterator_new(profiles);
7633 EINA_ITERATOR_FOREACH(it, prof)
7635 Eina_Stringshare *str = eina_stringshare_add(prof);
7638 eina_array_push(sd->profile.available, str);
7639 /* check to see if a given array has a current profile of elm_win */
7640 if (str == sd->profile.name)
7643 eina_iterator_free(it);
7646 if (ecore_evas_window_profile_supported_get(sd->ee))
7648 ecore_evas_window_available_profiles_set(sd->ee,
7649 (const char **) sd->profile.available->data,
7650 eina_array_count(sd->profile.available));
7652 /* current profile of elm_win is wrong, change profile */
7653 if (!found && eina_array_count(sd->profile.available))
7655 eina_stringshare_replace(&(sd->profile.name),
7656 eina_array_data_get(sd->profile.available, 0));
7657 ecore_evas_window_profile_set(sd->ee, sd->profile.name);
7663 if (eina_array_count(sd->profile.available))
7664 _elm_win_profile_update(sd);
7668 EOLIAN static const Eina_Array *
7669 _efl_ui_win_wm_available_profiles_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd)
7671 if (ecore_evas_window_profile_supported_get(sd->ee))
7673 char **profiles = NULL; // all const
7674 unsigned int count, i;
7677 ok = ecore_evas_window_available_profiles_get(sd->ee, &profiles, &count);
7678 if (!ok) return NULL;
7680 if (count == eina_array_count(sd->profile.available))
7682 for (i = 0; ok && (i < count); i++)
7684 if (!eina_streq(profiles[i], eina_array_data_get(sd->profile.available, i)))
7687 if (ok) return sd->profile.available;
7690 // Oops! What is going on here? Can this happen?
7691 INF("Available profile list has changed in ecore evas!");
7692 _elm_win_available_profiles_del(sd);
7693 for (i = 0; i < count; i++)
7695 Eina_Stringshare *str = eina_stringshare_add(profiles[i]);
7696 if (str) eina_array_push(sd->profile.available, str);
7700 return sd->profile.available;
7704 _efl_ui_win_urgent_set(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, Efl_Ui_Win_Urgent_Mode urgent)
7706 Eina_Bool urgent_tmp = !!urgent;
7708 if (sd->urgent == urgent_tmp) return;
7710 sd->urgent = urgent_tmp;
7711 TRAP(sd, urgent_set, urgent_tmp);
7712 #ifdef HAVE_ELEMENTARY_X
7713 _elm_win_xwin_update(sd);
7717 EOLIAN static Efl_Ui_Win_Urgent_Mode
7718 _efl_ui_win_urgent_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd)
7720 if (sd->urgent) return EFL_UI_WIN_URGENT_MODE_URGENT;
7721 return EFL_UI_WIN_URGENT_MODE_NONE;
7725 _efl_ui_win_modal_set(Eo *obj, Efl_Ui_Win_Data *sd, Efl_Ui_Win_Modal_Mode modal)
7727 Eina_Bool modal_tmp = !!modal;
7729 if (sd->modal_count) return;
7731 if ((modal_tmp) && (!sd->modal) && (evas_object_visible_get(obj)))
7732 _elm_win_modality_increment(sd);
7733 else if ((!modal_tmp) && (sd->modal) && (evas_object_visible_get(obj)))
7734 _elm_win_modality_decrement(sd);
7736 sd->modal = modal_tmp;
7737 TRAP(sd, modal_set, modal_tmp);
7738 #ifdef HAVE_ELEMENTARY_X
7739 _elm_win_xwin_update(sd);
7743 EOLIAN static Efl_Ui_Win_Modal_Mode
7744 _efl_ui_win_modal_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd)
7746 if (sd->modal) return EFL_UI_WIN_MODAL_MODE_MODAL;
7747 return EFL_UI_WIN_MODAL_MODE_NONE;
7751 _win_aspect_set(Efl_Ui_Win_Data *sd, double aspect)
7753 sd->aspect = aspect;
7754 TRAP(sd, aspect_set, aspect);
7755 #ifdef HAVE_ELEMENTARY_X
7756 _elm_win_xwin_update(sd);
7761 _win_aspect_get(Efl_Ui_Win_Data *sd)
7767 _efl_ui_win_efl_gfx_hint_hint_aspect_set(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *pd,
7768 Efl_Gfx_Hint_Aspect mode, Eina_Size2D sz)
7770 if (sz.h) _win_aspect_set(pd, (double) sz.w / (double) sz.h);
7771 else _win_aspect_set(pd, 0.0);
7772 efl_gfx_hint_aspect_set(efl_super(obj, MY_CLASS), mode, sz);
7773 #ifdef HAVE_ELEMENTARY_WL2
7775 ecore_wl2_window_aspect_set(pd->wl.win, sz.w, sz.h, mode);
7780 _efl_ui_win_efl_gfx_hint_hint_weight_set(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *pd EINA_UNUSED,
7783 efl_gfx_hint_weight_set(efl_super(obj, MY_CLASS), w, h);
7784 #ifdef HAVE_ELEMENTARY_WL2
7786 ecore_wl2_window_weight_set(pd->wl.win, w, h);
7791 _efl_ui_win_hint_base_set(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, Eina_Size2D sz)
7793 sd->size_base_w = sz.w;
7794 sd->size_base_h = sz.h;
7795 TRAP(sd, size_base_set, sz.w, sz.h);
7796 #ifdef HAVE_ELEMENTARY_X
7797 _elm_win_xwin_update(sd);
7801 EOLIAN static Eina_Size2D
7802 _efl_ui_win_hint_base_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd)
7804 return EINA_SIZE2D(sd->size_base_w, sd->size_base_h);
7808 _efl_ui_win_hint_step_set(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, Eina_Size2D sz)
7810 sd->size_step_w = sz.w;
7811 sd->size_step_h = sz.h;
7812 TRAP(sd, size_step_set, sz.w, sz.h);
7813 #ifdef HAVE_ELEMENTARY_X
7814 _elm_win_xwin_update(sd);
7819 _efl_ui_win_efl_gfx_hint_hint_size_max_set(Eo *obj, Efl_Ui_Win_Data *sd, Eina_Size2D sz)
7821 if (sd->tmp_updating_hints)
7823 efl_gfx_hint_size_max_set(efl_super(obj, MY_CLASS), sz);
7827 if (sz.w < 1) sz.w = -1;
7828 if (sz.h < 1) sz.h = -1;
7831 _elm_win_resize_objects_eval(obj, EINA_FALSE);
7835 EOLIAN static Eina_Size2D
7836 _efl_ui_win_hint_step_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd)
7838 return EINA_SIZE2D(sd->size_step_w, sd->size_step_h);
7842 elm_win_norender_push(Evas_Object *obj)
7844 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
7848 if (sd->norender == 1) ecore_evas_manual_render_set(sd->ee, EINA_TRUE);
7852 elm_win_norender_pop(Evas_Object *obj)
7854 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
7857 if (sd->norender <= 0) return;
7859 if (sd->norender == 0) ecore_evas_manual_render_set(sd->ee, EINA_FALSE);
7863 elm_win_norender_get(const Evas_Object *obj)
7865 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
7868 return sd->norender;
7872 elm_win_render(Evas_Object *obj)
7874 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
7877 ecore_evas_manual_render(sd->ee);
7880 // TIZEN_ONLY(20170212): pend rotation until app set rotation
7882 * This API rotates the window by app side.
7886 _win_pending_rotate(Evas_Object *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, int rotation, Eina_Bool resize)
7888 rotation = _win_rotation_degree_check(rotation);
7889 DBG("PendingRotation: elm_win pending rotation set rot=%d", rotation);
7890 if (sd->rot == rotation) return;
7892 //TODO: We need time to set up the role of pending rotation between the server and client.
7893 //and also need time to discuss this concept with opensource.
7894 //so until that time, we add ecore evas data instead of opening the new ecore_evas_XXX api.
7895 ecore_evas_data_set(sd->ee, "pending_rotation", (void *)1);
7897 // Currently only support rotation_with_resize
7898 if (resize) TRAP(sd, rotation_with_resize_set, rotation);
7904 * This API resizes the internal window(ex: X window) and evas_output.
7905 * But this does not resize the elm window object and its contents.
7909 _efl_ui_win_wm_available_rotations_set(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd,
7910 Eina_Bool allow_0, Eina_Bool allow_90,
7911 Eina_Bool allow_180, Eina_Bool allow_270)
7916 if (allow_0) rots[cnt++] = 0;
7917 if (allow_90) rots[cnt++] = 90;
7918 if (allow_180) rots[cnt++] = 180;
7919 if (allow_270) rots[cnt++] = 270;
7920 sd->wm_rot.use = EINA_TRUE;
7922 ELM_SAFE_FREE(sd->wm_rot.rots, free);
7923 sd->wm_rot.count = 0;
7927 sd->wm_rot.rots = malloc(sizeof(int) * cnt);
7928 if (!sd->wm_rot.rots) return;
7929 memcpy(sd->wm_rot.rots, rots, cnt * sizeof(int));
7930 sd->wm_rot.count = cnt;
7933 ecore_evas_wm_rotation_available_rotations_set(sd->ee,
7938 EOLIAN static Eina_Bool
7939 _efl_ui_win_wm_available_rotations_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd,
7940 Eina_Bool *allow_0, Eina_Bool *allow_90,
7941 Eina_Bool *allow_180, Eina_Bool *allow_270)
7943 if (!sd->wm_rot.use) goto end;
7945 if (allow_0) *allow_0 = EINA_FALSE;
7946 if (allow_90) *allow_90 = EINA_FALSE;
7947 if (allow_180) *allow_180 = EINA_FALSE;
7948 if (allow_270) *allow_270 = EINA_FALSE;
7950 for (unsigned k = 0; k < sd->wm_rot.count; k++)
7952 switch (sd->wm_rot.rots[k])
7954 case 0: if (allow_0) *allow_0 = EINA_TRUE; break;
7955 case 90: if (allow_90) *allow_90 = EINA_TRUE; break;
7956 case 180: if (allow_180) *allow_180 = EINA_TRUE; break;
7957 case 270: if (allow_270) *allow_270 = EINA_TRUE; break;
7958 default: ERR("Unsupported rotation %d", sd->wm_rot.rots[k]); break;
7963 return !!sd->wm_rot.use;
7967 elm_win_wm_rotation_available_rotations_set(Elm_Win *obj, const int *rotations, unsigned int count)
7969 Eina_Bool allow[4] = { 0, };
7972 if (!rotations || !count) goto end;
7973 for (unsigned k = 0; (k < count) && (found < 4); k++)
7975 int rot = (((rotations[k] % 360) + 360) % 360) / 90;
7978 allow[rot] = EINA_TRUE;
7984 efl_ui_win_wm_available_rotations_set(obj, allow[0], allow[1], allow[2], allow[3]);
7988 elm_win_wm_rotation_available_rotations_get(const Elm_Win *obj, int **rotations, unsigned int *count)
7990 int rots[4] = { 0, };
7991 Eina_Bool allow[4] = { 0, };
7994 if (!efl_ui_win_wm_available_rotations_get(obj, &allow[0], &allow[1], &allow[2], &allow[3]))
7997 for (int k = 0; k < 4; k++)
7999 rots[cnt++] = k * 90;
8001 if (!cnt) goto none;
8005 *rotations = malloc(sizeof(int) * cnt);
8006 if (!*rotations) goto none;
8007 memcpy(*rotations, rots, cnt * sizeof(int));
8009 if (count) *count = cnt;
8013 if (rotations) *rotations = NULL;
8014 if (count) *count = 0;
8019 _efl_ui_win_sticky_set(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, Eina_Bool sticky)
8021 // sd->sticky = sticky;
8022 TRAP(sd, sticky_set, sticky);
8023 #ifdef HAVE_ELEMENTARY_X
8024 _elm_win_xwin_update(sd);
8028 EOLIAN static Eina_Bool
8029 _efl_ui_win_sticky_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd)
8035 _efl_ui_win_keyboard_mode_set(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, Efl_Ui_Win_Keyboard_Mode mode)
8037 if (mode == sd->kbdmode) return;
8038 #ifdef HAVE_ELEMENTARY_X
8039 _internal_elm_win_xwindow_get(sd);
8042 #ifdef HAVE_ELEMENTARY_X
8045 _internal_elm_win_xwindow_get(sd);
8046 ecore_x_e_virtual_keyboard_state_set
8047 (sd->x.xwin, (Ecore_X_Virtual_Keyboard_State)sd->kbdmode);
8052 EOLIAN static Efl_Ui_Win_Keyboard_Mode
8053 _efl_ui_win_keyboard_mode_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd)
8059 _efl_ui_win_indicator_mode_set(Eo *obj, Efl_Ui_Win_Data *sd, Efl_Ui_Win_Indicator_Mode mode)
8061 sd->legacy.forbidden = EINA_TRUE;
8062 if (sd->indimode == mode) return;
8063 sd->indimode = mode;
8065 if (sd->indimode == EFL_UI_WIN_INDICATOR_MODE_OFF)
8071 if (!sd->indicator) _indicator_add(sd);
8073 if (elm_widget_is_legacy(obj))
8075 if (sd->indimode == EFL_UI_WIN_INDICATOR_MODE_BG_OPAQUE)
8076 edje_object_signal_emit(sd->frame_obj, "elm,action,indicator,bg_opaque", "elm");
8077 else if (sd->indimode == EFL_UI_WIN_INDICATOR_MODE_BG_TRANSPARENT)
8078 edje_object_signal_emit(sd->frame_obj, "elm,action,indicator,bg_transparent", "elm");
8079 else if (sd->indimode == EFL_UI_WIN_INDICATOR_MODE_HIDDEN)
8080 edje_object_signal_emit(sd->frame_obj, "elm,action,indicator,hidden", "elm");
8084 if (sd->indimode == EFL_UI_WIN_INDICATOR_MODE_BG_OPAQUE)
8085 edje_object_signal_emit(sd->frame_obj, "efl,action,indicator,bg_opaque", "efl");
8086 else if (sd->indimode == EFL_UI_WIN_INDICATOR_MODE_BG_TRANSPARENT)
8087 edje_object_signal_emit(sd->frame_obj, "efl,action,indicator,bg_transparent", "efl");
8088 else if (sd->indimode == EFL_UI_WIN_INDICATOR_MODE_HIDDEN)
8089 edje_object_signal_emit(sd->frame_obj, "efl,action,indicator,hidden", "efl");
8092 edje_object_message_signal_process(sd->frame_obj);
8093 evas_object_smart_calculate(sd->frame_obj);
8094 _elm_win_frame_obj_update(sd, 0);
8097 EOLIAN static Efl_Ui_Win_Indicator_Mode
8098 _efl_ui_win_indicator_mode_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd EINA_UNUSED)
8100 sd->legacy.forbidden = EINA_TRUE;
8101 return sd->indimode;
8104 EOLIAN EINA_UNUSED static Eina_Bool
8105 _efl_ui_win_efl_ui_focus_object_focus_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd)
8107 // Bypass widget implementation here.
8108 return ecore_evas_focus_get(sd->ee);
8112 _efl_ui_win_screen_constrain_set(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, Eina_Bool constrain)
8114 sd->constrain = !!constrain;
8117 EOLIAN static Eina_Bool
8118 _efl_ui_win_screen_constrain_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd)
8120 return sd->constrain;
8123 EOLIAN static Eina_Size2D
8124 _efl_ui_win_efl_screen_screen_size_in_pixels_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd)
8127 ecore_evas_screen_geometry_get(sd->ee, NULL, NULL, &sz.w, &sz.h);
8132 _efl_ui_win_efl_screen_screen_dpi_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, int *xdpi, int *ydpi)
8134 ecore_evas_screen_dpi_get(sd->ee, xdpi, ydpi);
8138 _efl_ui_win_efl_screen_screen_rotation_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd)
8140 //TODO: query to wm about device's rotation
8142 WRN("Not yet implemented");
8147 _efl_ui_win_efl_screen_screen_scale_factor_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd EINA_UNUSED)
8149 WRN("Not yet implemented");
8154 _efl_ui_win_prop_focus_skip_set(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, Eina_Bool skip)
8156 // TIZEN_ONLY(20160404) skip_focus in case invoking elm_win_quickpanel_set
8157 _elm_win_focus_skip_set(sd, skip);
8162 _efl_ui_win_focus_highlight_enabled_set(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, Eina_Bool enabled)
8164 enabled = !!enabled;
8165 if (sd->focus_highlight.enabled == enabled)
8168 sd->focus_highlight.enabled = enabled;
8170 if ((sd->focus_highlight.enabled) || (sd->focus_highlight.auto_enabled))
8171 _elm_win_focus_highlight_init(sd);
8173 _elm_win_focus_highlight_shutdown(sd);
8176 EOLIAN static Eina_Bool
8177 _efl_ui_win_focus_highlight_enabled_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd)
8179 return sd->focus_highlight.enabled;
8183 _elm_win_theme_internal(Eo *obj, Efl_Ui_Win_Data *sd)
8185 Eina_Error int_ret = EFL_UI_THEME_APPLY_ERROR_GENERIC;
8186 Eina_Bool prev_alpha;
8189 int_ret = elm_widget_theme_object_set(obj, sd->legacy.edje, "win", "base",
8190 elm_widget_style_get(obj));
8191 if (int_ret == EFL_UI_THEME_APPLY_ERROR_GENERIC) return int_ret;
8193 edje_object_mirrored_set(sd->legacy.edje, efl_ui_mirrored_get(obj));
8194 edje_object_scale_set(sd->legacy.edje,
8195 efl_gfx_entity_scale_get(obj) * elm_config_scale_get());
8197 efl_event_callback_legacy_call(obj, EFL_UI_WIN_EVENT_THEME_CHANGED, NULL);
8199 prev_alpha = sd->theme_alpha;
8200 s = edje_object_data_get(sd->legacy.edje, "alpha");
8201 sd->theme_alpha = (eina_streq(s, "1") || eina_streq(s, "true"));
8202 if (sd->theme_alpha != prev_alpha)
8203 _elm_win_apply_alpha(obj, sd);
8208 EOLIAN static Eina_Error
8209 _efl_ui_win_efl_ui_widget_theme_apply(Eo *obj, Efl_Ui_Win_Data *sd)
8211 Eina_Error int_ret = EFL_UI_THEME_APPLY_ERROR_GENERIC;
8212 int_ret = efl_ui_widget_theme_apply(efl_super(obj, MY_CLASS));
8213 if (int_ret == EFL_UI_THEME_APPLY_ERROR_GENERIC) return int_ret;
8215 sd->focus_highlight.theme_changed = EINA_TRUE;
8217 int_ret = _elm_win_theme_internal(obj, sd) & int_ret;
8218 if (int_ret == EFL_UI_THEME_APPLY_ERROR_GENERIC) return int_ret;
8219 _elm_win_focus_highlight_reconfigure_job_start(sd);
8224 EOLIAN static Eina_Bool
8225 _efl_ui_win_focus_highlight_style_set(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, const char *style)
8227 if (!eina_stringshare_replace(&sd->focus_highlight.style, style))
8230 sd->focus_highlight.theme_changed = EINA_TRUE;
8231 _elm_win_focus_highlight_reconfigure_job_start(sd);
8235 EOLIAN static const char*
8236 _efl_ui_win_focus_highlight_style_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd)
8238 return sd->focus_highlight.style;
8242 _efl_ui_win_focus_highlight_animate_set(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, Eina_Bool animate)
8244 animate = !!animate;
8245 if (sd->focus_highlight.animate == animate)
8248 sd->focus_highlight.animate = animate;
8249 sd->focus_highlight.theme_changed = EINA_TRUE;
8250 _elm_win_focus_highlight_reconfigure_job_start(sd);
8253 EOLIAN static Eina_Bool
8254 _efl_ui_win_focus_highlight_animate_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd)
8256 return sd->focus_highlight.animate;
8259 EOLIAN static const char *
8260 _efl_ui_win_stack_id_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd)
8262 return sd->stack_id;
8266 _efl_ui_win_stack_master_id_set(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, const char *id)
8268 if (sd->shown) return;
8269 eina_stringshare_replace(&(sd->stack_master_id), id);
8270 #ifdef HAVE_ELEMENTARY_X
8272 _elm_win_xwin_update(sd);
8276 int num = ecore_evas_aux_hint_id_get(sd->ee, "stack_master_id");
8278 ecore_evas_aux_hint_val_set(sd->ee, num, id);
8280 ecore_evas_aux_hint_add(sd->ee, "stack_master_id", id);
8284 EOLIAN static const char *
8285 _efl_ui_win_stack_master_id_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd)
8287 return sd->stack_master_id;
8291 _efl_ui_win_stack_base_set(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, Eina_Bool base)
8294 if (sd->shown) return;
8295 sd->stack_base = !!base;
8296 num = ecore_evas_aux_hint_id_get(sd->ee, "stack_base");
8298 ecore_evas_aux_hint_val_set(sd->ee, num, sd->stack_base ? "1" : "0");
8300 ecore_evas_aux_hint_add(sd->ee, "stack_base", sd->stack_base ? "1" : "0");
8303 EOLIAN static Eina_Bool
8304 _efl_ui_win_stack_base_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd)
8306 return sd->stack_base;
8309 #ifdef HAVE_ELEMENTARY_X
8310 // list transient from bottom to top by recursive walking
8312 _x_transients_for_list(Ecore_X_Window base, Ecore_X_Window transient,
8313 Ecore_X_Window **wins, int *num)
8315 Ecore_X_Window t, *children, *w;
8318 children = ecore_x_window_children_get(base, &n);
8321 for (i = 0; i < n; i++)
8323 if (children[i] != transient)
8325 t = ecore_x_icccm_transient_for_get(children[i]);
8329 w = realloc(*wins, *num * sizeof(Ecore_X_Window));
8333 (*wins)[*num - 1] = children[i];
8336 _x_transients_for_list(children[i], transient, wins, num);
8345 _efl_ui_win_stack_pop_to(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd)
8347 if (!sd->stack_master_id) return;
8348 #ifdef HAVE_ELEMENTARY_X
8351 Ecore_X_Window *wins = NULL;
8353 Eina_Bool del = EINA_FALSE;
8355 _internal_elm_win_xwindow_get(sd);
8357 _x_transients_for_list
8358 (ecore_x_window_root_get(sd->x.xwin),
8359 ecore_x_icccm_transient_for_get(sd->x.xwin),
8363 for (i = 0; i < num; i++)
8365 if (del) ecore_x_window_delete_request_send(wins[i]);
8366 if (wins[i] == sd->x.xwin) del = EINA_TRUE;
8375 int num = ecore_evas_aux_hint_id_get(sd->ee, "stack_pop_to");
8376 if (num >= 0) ecore_evas_aux_hint_val_set(sd->ee, num, "1");
8377 else ecore_evas_aux_hint_add(sd->ee, "stack_pop_to", "1");
8383 elm_win_trap_set(const Elm_Win_Trap *t)
8385 DBG("old %p, new %p", trap, t);
8387 if ((t) && (t->version != ELM_WIN_TRAP_VERSION))
8389 CRI("trying to set a trap version %lu while %lu was expected!",
8390 t->version, ELM_WIN_TRAP_VERSION);
8399 elm_win_floating_mode_set(Evas_Object *obj, Eina_Bool floating)
8401 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
8404 floating = !!floating;
8405 if (floating == sd->floating) return;
8406 sd->floating = floating;
8407 //TIZEN_ONLY(20171114): implement elm_win_floating_mode_set on wayland
8408 #if HAVE_ELEMENTARY_WL2
8409 _elm_win_wlwindow_get(sd);
8412 //TIZEN_ONLY(20161208): supported floating window
8414 edje_object_signal_emit(sd->legacy.edje, "elm,state,floating,on", "elm");
8416 edje_object_signal_emit(sd->legacy.edje, "elm,state,floating,off", "elm");
8419 // TODO: frame style(csd) shall be applied refer to Eina_Bool floating
8420 ecore_wl2_window_floating_mode_set(sd->wl.win, floating);
8424 #ifdef HAVE_ELEMENTARY_X
8425 _internal_elm_win_xwindow_get(sd);
8428 _internal_elm_win_xwindow_get(sd);
8430 ecore_x_e_illume_window_state_set
8431 (sd->x.xwin, ECORE_X_ILLUME_WINDOW_STATE_FLOATING);
8433 ecore_x_e_illume_window_state_set
8434 (sd->x.xwin, ECORE_X_ILLUME_WINDOW_STATE_NORMAL);
8440 elm_win_floating_mode_get(const Evas_Object *obj)
8442 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
8443 if (!sd) return EINA_FALSE;
8445 return sd->floating;
8449 _elm_win_focus_highlight_in_theme_update(Evas_Object *obj, Eina_Bool in_theme)
8451 ELM_WIN_DATA_GET(obj, sd);
8452 sd->focus_highlight.cur.in_theme = !!in_theme;
8456 _elm_win_focus_highlight_start(Evas_Object *obj)
8458 ELM_WIN_DATA_GET(obj, sd);
8460 if (!(sd->focus_highlight.enabled) && !(sd->focus_highlight.auto_enabled)) return;
8461 sd->focus_highlight.cur.visible = EINA_TRUE;
8462 sd->focus_highlight.geometry_changed = EINA_TRUE;
8463 _elm_win_focus_highlight_reconfigure_job(obj);
8467 _elm_win_focus_auto_show(Evas_Object *obj)
8469 ELM_WIN_DATA_GET(obj, sd);
8470 Eina_Bool pfocus = (sd->focus_highlight.enabled) || (sd->focus_highlight.auto_enabled);
8471 sd->focus_highlight.auto_enabled = _elm_config->win_auto_focus_enable;
8472 sd->focus_highlight.auto_animate = _elm_config->win_auto_focus_animate;
8473 if (pfocus != ((sd->focus_highlight.enabled) || (sd->focus_highlight.auto_enabled)))
8475 if ((sd->focus_highlight.enabled) || (sd->focus_highlight.auto_enabled))
8476 _elm_win_focus_highlight_init(sd);
8481 _elm_win_focus_auto_hide(Evas_Object *obj)
8483 ELM_WIN_DATA_GET(obj, sd);
8484 Eina_Bool pfocus = (sd->focus_highlight.enabled) || (sd->focus_highlight.auto_enabled);
8485 sd->focus_highlight.auto_enabled = EINA_FALSE;
8486 sd->focus_highlight.auto_animate = EINA_FALSE;
8487 if (pfocus != ((sd->focus_highlight.enabled) || (sd->focus_highlight.auto_enabled)))
8489 if (!((sd->focus_highlight.enabled) || (sd->focus_highlight.auto_enabled)))
8490 _elm_win_focus_highlight_shutdown(sd);
8495 _efl_ui_win_class_constructor(Efl_Class *klass EINA_UNUSED)
8500 _efl_ui_win_efl_object_debug_name_override(Eo *obj, Efl_Ui_Win_Data *pd, Eina_Strbuf *sb)
8502 efl_debug_name_override(efl_super(obj, MY_CLASS), sb);
8503 eina_strbuf_append_printf(sb, ":'%s':'%s'", pd->name, pd->title);
8506 EOLIAN static const Efl_Access_Action_Data*
8507 _efl_ui_win_efl_access_widget_action_elm_actions_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd EINA_UNUSED)
8509 static Efl_Access_Action_Data atspi_actions[] = {
8510 { "move,previous", "move", "previous", _key_action_move},
8511 { "move,next", "move", "next", _key_action_move},
8512 { "move,left", "move", "left", _key_action_move},
8513 { "move,right", "move", "right", _key_action_move},
8514 { "move,up", "move", "up", _key_action_move},
8515 { "move,down", "move", "down", _key_action_move},
8516 { NULL, NULL, NULL, NULL }
8518 return &atspi_actions[0];
8521 EOLIAN static Efl_Access_State_Set
8522 _efl_ui_win_efl_access_object_state_set_get(const Eo *obj, Efl_Ui_Win_Data *sd EINA_UNUSED)
8524 Efl_Access_State_Set ret;
8525 ret = efl_access_object_state_set_get(efl_super(obj, MY_CLASS));
8527 if (elm_win_focus_get(obj))
8528 STATE_TYPE_SET(ret, EFL_ACCESS_STATE_TYPE_ACTIVE);
8533 EOLIAN static const char*
8534 _efl_ui_win_efl_access_object_i18n_name_get(const Eo *obj, Efl_Ui_Win_Data *sd EINA_UNUSED)
8537 ret = efl_access_object_i18n_name_get(efl_super(obj, EFL_UI_WIN_CLASS));
8538 if (ret) return ret;
8539 const char *name = elm_win_title_get(obj);
8540 return _elm_widget_accessible_plain_name_get(obj, name);
8543 //TIZEN_ONLY(20220322): add resource id to window attribute
8544 EOLIAN static Eina_List*
8545 _efl_ui_win_efl_access_object_attributes_get(const Eo *obj, Efl_Ui_Win_Data *sd)
8547 Eina_List *attr_list = NULL;
8548 attr_list = efl_access_object_attributes_get(efl_super(obj, EFL_UI_WIN_CLASS));
8550 #ifdef HAVE_ELEMENTARY_WL2
8552 Eina_Strbuf *str_buf;
8553 unsigned int resource_id;
8555 Efl_Access_Attribute *attr = NULL;
8557 str_buf = eina_strbuf_new();
8558 resource_id = ecore_wl2_window_resource_id_get(sd->wl.win);
8560 eina_strbuf_append_printf(str_buf, "%u", resource_id);
8561 resID = eina_strbuf_string_get(str_buf);
8563 attr = calloc(1, sizeof(Efl_Access_Attribute));
8566 attr->key = eina_stringshare_add("resID");
8567 attr->value = eina_stringshare_add(resID);
8568 attr_list = eina_list_append(attr_list, attr);
8571 eina_strbuf_free(str_buf);
8578 EOLIAN static Eina_Rect
8579 _efl_ui_win_efl_access_component_extents_get(const Eo *obj, Efl_Ui_Win_Data *_pd EINA_UNUSED, Eina_Bool screen_coords)
8583 r = efl_gfx_entity_geometry_get(obj);
8587 r = _efl_access_component_screen_coords_extents_get(obj, r);
8592 EOLIAN static Eina_Bool
8593 _efl_ui_win_efl_input_state_modifier_enabled_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *pd,
8594 Efl_Input_Modifier mod, const Efl_Input_Device *seat)
8596 const Evas_Modifier *m = evas_key_modifier_get(pd->evas);
8597 const char *name = _efl_input_modifier_to_string(mod);
8598 return evas_seat_key_modifier_is_set(m, name, seat);
8601 EOLIAN static Eina_Bool
8602 _efl_ui_win_efl_input_state_lock_enabled_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *pd,
8603 Efl_Input_Lock lock, const Efl_Input_Device *seat)
8605 const Evas_Lock *m = evas_key_lock_get(pd->evas);
8606 const char *name = _efl_input_lock_to_string(lock);
8607 return evas_seat_key_lock_is_set(m, name, seat);
8610 EOLIAN static Efl_Object *
8611 _efl_ui_win_efl_object_provider_find(const Eo *obj,
8612 Efl_Ui_Win_Data *pd EINA_UNUSED,
8613 const Efl_Object *klass)
8615 if (klass == EFL_UI_WIN_CLASS)
8618 // attach all kinds of windows directly to ATSPI application root object
8619 if (klass == EFL_ACCESS_OBJECT_MIXIN) return efl_access_object_access_root_get();
8621 if (klass == EFL_UI_FOCUS_PARENT_PROVIDER_INTERFACE)
8622 return pd->provider;
8624 return efl_provider_find(efl_super(obj, MY_CLASS), klass);
8627 // See evas_inline.x
8628 #define _EVAS_COLOR_CLAMP(x, y) do { \
8629 if (x > y) { x = y; bad = 1; } \
8630 if (x < 0) { x = 0; bad = 1; } } while (0)
8632 #define EVAS_COLOR_SANITIZE(r, g, b, a) \
8634 _EVAS_COLOR_CLAMP(a, 255); \
8635 _EVAS_COLOR_CLAMP(r, a); \
8636 _EVAS_COLOR_CLAMP(g, a); \
8637 _EVAS_COLOR_CLAMP(b, a); \
8642 #define WIN_PART_ERR(part) ERR("No such part in window: '%s'. Supported parts are: 'content' and 'background'.", part);
8645 _elm_win_bg_set(Efl_Ui_Win_Data *sd, Eo *bg)
8647 ELM_SAFE_DEL(sd->bg);
8648 if (!bg) return EINA_TRUE;
8650 if (!elm_widget_sub_object_add(sd->obj, bg))
8652 if (elm_widget_is_legacy(sd->obj))
8654 if (!_elm_config->win_no_border)
8656 if (!edje_object_part_swallow(sd->frame_obj, "elm.swallow.background", bg))
8661 if (!edje_object_part_swallow(sd->legacy.edje, "elm.swallow.background", bg))
8667 if (!_elm_config->win_no_border)
8669 if (!edje_object_part_swallow(sd->frame_obj, "efl.background", bg))
8674 if (!edje_object_part_swallow(sd->legacy.edje, "efl.background", bg))
8678 efl_gfx_entity_visible_set(bg, 1);
8679 efl_gfx_hint_fill_set(bg, EINA_TRUE, EINA_TRUE);
8680 efl_gfx_hint_weight_set(bg, 1, 1);
8681 efl_wref_add(bg, &sd->bg);
8685 /* Legacy theme compatibility */
8687 _elm_win_bg_must_swallow(Efl_Ui_Win_Data *sd, Eo **bg)
8689 if (EINA_UNLIKELY(!sd->legacy.bg_must_swallow_init))
8691 /* Overkill: check which theme version the standard elm_bg uses */
8692 Elm_Widget_Smart_Data *wd;
8693 const char *version;
8696 sd->legacy.bg_must_swallow = 1;
8697 sd->legacy.bg_must_swallow_init = 1;
8699 if (sd->legacy.ctor)
8700 *bg = elm_bg_add(sd->obj);
8703 // Note: This code path is probably not necessary (custom legacy
8704 // theme but efl_add'ed window -- all efl_add'ed widgets would
8705 // use default theme)
8706 *bg = efl_add(EFL_UI_BG_CLASS, sd->obj);
8708 wd = efl_data_scope_get(*bg, EFL_UI_WIDGET_CLASS);
8711 version = edje_object_data_get(wd->resize_obj, "version");
8712 v = version ? atoi(version) : 0;
8713 if (v >= FRAME_OBJ_THEME_MIN_VERSION)
8714 sd->legacy.bg_must_swallow = 0;
8718 return sd->legacy.bg_must_swallow;
8722 _elm_win_standard_init(Eo *obj)
8724 traceTaskStart("win_standard_init");
8726 /* Support for elm_util_win_standard_add() and Efl.Ui.Win.Standard */
8727 Efl_Ui_Win_Data *sd = efl_data_scope_get(obj, MY_CLASS);
8730 ELM_SAFE_DEL(sd->bg);
8732 sd->csd.need_bg_standard = 1;
8733 if (!_elm_win_bg_must_swallow(sd, &bg))
8735 sd->csd.need_bg_solid = EINA_TRUE;
8736 evas_object_del(bg);
8740 /* Legacy theme compatibility */
8741 DBG("Detected legacy theme used for elm_bg. Swallowing object.");
8742 sd->csd.need_bg_solid = EINA_FALSE;
8746 if (sd->legacy.ctor)
8747 bg = elm_bg_add(obj);
8750 // Note: This code path is probably not necessary (custom legacy
8751 // theme but efl_add'ed window -- all efl_add'ed widgets would
8752 // use default theme)
8753 bg = efl_add(EFL_UI_BG_CLASS, obj);
8756 _elm_win_bg_set(sd, bg);
8759 _elm_win_frame_style_update(sd, 0, 1);
8765 _efl_ui_win_content_set(Eo *obj, Efl_Ui_Win_Data *sd, const char *part, Eo *content)
8767 sd->legacy.forbidden = EINA_TRUE;
8768 if (eina_streq(part, "content"))
8770 if (sd->content == content) return EINA_TRUE;
8771 if (content && !elm_widget_sub_object_add(obj, content))
8773 /* FIXME: Switch to swallow inside the frame
8774 if (!edje_object_part_swallow(sd->frame_obj, "elm.swallow.client", content))
8777 evas_object_box_append(sd->legacy.box, content);
8778 evas_object_show(content);
8779 efl_wref_add(content, &sd->content);
8782 else if (eina_streq(part, "background"))
8784 sd->csd.need_bg_standard = 0;
8785 if (sd->bg == content) return EINA_TRUE;
8786 if (!_elm_win_bg_set(sd, content))
8790 //TIZEN_ONLY(20190425): add circle content part for circle object
8791 else if (eina_streq(part, "efl.content.circle"))
8794 ret = edje_object_part_swallow(sd->legacy.edje, "efl.content.circle", content);
8795 evas_object_show(content);
8804 ERR("Failed to set object %p as %s for window %p", content, part, obj);
8808 static Efl_Canvas_Object *
8809 _efl_ui_win_content_get(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, const char *part)
8811 sd->legacy.forbidden = EINA_TRUE;
8812 if (eina_streq(part, "content"))
8814 else if (eina_streq(part, "background"))
8821 static Efl_Canvas_Object *
8822 _efl_ui_win_content_unset(Eo *obj, Efl_Ui_Win_Data *sd, const char *part)
8826 sd->legacy.forbidden = EINA_TRUE;
8827 content = _efl_ui_win_content_get(obj, sd, part);
8828 if (!content) return NULL;
8831 _efl_ui_win_content_set(obj, sd, part, NULL);
8836 _efl_ui_win_part_color_set(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, const char *part, int r, int g, int b, int a)
8838 sd->legacy.forbidden = EINA_TRUE;
8839 if (eina_streq(part, "background"))
8841 sd->csd.need_bg_solid = EINA_TRUE;
8842 edje_object_color_class_set(sd->frame_obj, "elm/win/background", r, g, b, a, 0, 0, 0, 0, 0, 0, 0, 0);
8843 _elm_win_frame_style_update(sd, 0, 1);
8852 _efl_ui_win_part_color_get(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, const char *part, int *r, int *g, int *b, int *a)
8854 sd->legacy.forbidden = EINA_TRUE;
8855 if (eina_streq(part, "background"))
8857 edje_object_color_class_get(sd->frame_obj, "elm/win/background", r, g, b, a, 0, 0, 0, 0, 0, 0, 0, 0);
8866 _efl_ui_win_part_file_unload(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, Eo *part_obj EINA_UNUSED, const char *part)
8868 sd->legacy.forbidden = EINA_TRUE;
8869 if (eina_streq(part, "background"))
8871 _elm_win_bg_set(sd, NULL);
8879 _efl_ui_win_part_file_load(Eo *obj, Efl_Ui_Win_Data *sd, Eo *part_obj, const char *part)
8881 const char *file, *key;
8883 sd->legacy.forbidden = EINA_TRUE;
8884 if (efl_file_loaded_get(part_obj)) return 0;
8885 file = efl_file_get(part_obj);
8886 key = efl_file_key_get(part_obj);
8887 if (eina_streq(part, "background"))
8889 Eina_Bool ok = EINA_TRUE;
8894 bg = efl_add(EFL_UI_IMAGE_CLASS, obj);
8895 efl_gfx_image_scale_method_set(bg, EFL_GFX_IMAGE_SCALE_METHOD_EXPAND);
8896 ok = efl_file_simple_load(bg, file, key);
8897 if (!ok) ELM_SAFE_DEL(bg);
8898 _elm_win_bg_set(sd, bg);
8902 _elm_win_standard_init(obj);
8913 _efl_ui_win_part_file_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, const Eo *part_obj, const char *part EINA_UNUSED)
8915 sd->legacy.forbidden = EINA_TRUE;
8916 return efl_file_get(efl_super(part_obj, EFL_UI_WIN_PART_CLASS));
8919 if (eina_streq(part, "background"))
8921 const Eo *bg = _efl_ui_win_content_get(obj, sd, "background");
8922 return efl_file_get(bg);
8931 _efl_ui_win_part_file_key_get(const Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, const Eo *part_obj, const char *part EINA_UNUSED)
8933 sd->legacy.forbidden = EINA_TRUE;
8934 return efl_file_key_get(efl_super(part_obj, EFL_UI_WIN_PART_CLASS));
8935 /* NOTE; if more than one part is ever supported here then this section is needed */
8938 if (eina_streq(part, "background"))
8940 const Eo *bg = _efl_ui_win_content_get(obj, sd, "background");
8941 return efl_file_get(bg);
8949 /* Efl.Part begin */
8952 _efl_ui_win_part_efl_gfx_color_color_set(Eo *obj, void *_pd EINA_UNUSED, int r, int g, int b, int a)
8954 Elm_Part_Data *pd = efl_data_scope_get(obj, EFL_UI_WIDGET_PART_CLASS);
8955 Efl_Ui_Win_Data *sd = efl_data_scope_get(pd->obj, MY_CLASS);
8957 if (EVAS_COLOR_SANITIZE(r, g, b, a))
8958 ERR("Evas only handles premultiplied colors (0 <= R,G,B <= A <= 255)");
8960 _efl_ui_win_part_color_set(pd->obj, sd, pd->part, r, g, b, a);
8964 _efl_ui_win_part_efl_gfx_color_color_get(const Eo *obj, void *_pd EINA_UNUSED, int *r, int *g, int *b, int *a)
8966 Elm_Part_Data *pd = efl_data_scope_get(obj, EFL_UI_WIDGET_PART_CLASS);
8967 Efl_Ui_Win_Data *sd = efl_data_scope_get(pd->obj, MY_CLASS);
8968 _efl_ui_win_part_color_get(pd->obj, sd, pd->part, r, g, b, a);
8971 EOLIAN static const char *
8972 _efl_ui_win_part_efl_file_file_get(const Eo *obj, void *_pd EINA_UNUSED)
8974 Elm_Part_Data *pd = efl_data_scope_get(obj, EFL_UI_WIDGET_PART_CLASS);
8975 Efl_Ui_Win_Data *sd = efl_data_scope_get(pd->obj, MY_CLASS);
8976 return _efl_ui_win_part_file_get(pd->obj, sd, obj, pd->part);
8979 EOLIAN static const char *
8980 _efl_ui_win_part_efl_file_key_get(const Eo *obj, void *_pd EINA_UNUSED)
8982 Elm_Part_Data *pd = efl_data_scope_get(obj, EFL_UI_WIDGET_PART_CLASS);
8983 Efl_Ui_Win_Data *sd = efl_data_scope_get(pd->obj, MY_CLASS);
8984 return _efl_ui_win_part_file_key_get(pd->obj, sd, obj, pd->part);
8988 _efl_ui_win_part_efl_file_unload(Eo *obj, void *_pd EINA_UNUSED)
8990 Elm_Part_Data *pd = efl_data_scope_get(obj, EFL_UI_WIDGET_PART_CLASS);
8991 Efl_Ui_Win_Data *sd = efl_data_scope_get(pd->obj, MY_CLASS);
8992 return _efl_ui_win_part_file_unload(pd->obj, sd, obj, pd->part);
8995 EOLIAN static Eina_Error
8996 _efl_ui_win_part_efl_file_load(Eo *obj, void *_pd EINA_UNUSED)
8998 Elm_Part_Data *pd = efl_data_scope_get(obj, EFL_UI_WIDGET_PART_CLASS);
8999 Efl_Ui_Win_Data *sd = efl_data_scope_get(pd->obj, MY_CLASS);
9000 return _efl_ui_win_part_file_load(pd->obj, sd, obj, pd->part);
9004 ELM_PART_OVERRIDE(efl_ui_win, EFL_UI_WIN, Efl_Ui_Win_Data)
9005 ELM_PART_OVERRIDE_CONTENT_SET(efl_ui_win, EFL_UI_WIN, Efl_Ui_Win_Data)
9006 ELM_PART_OVERRIDE_CONTENT_GET(efl_ui_win, EFL_UI_WIN, Efl_Ui_Win_Data)
9007 ELM_PART_OVERRIDE_CONTENT_UNSET(efl_ui_win, EFL_UI_WIN, Efl_Ui_Win_Data)
9008 ELM_PART_CONTENT_DEFAULT_GET(efl_ui_win, "content")
9009 ELM_PART_CONTENT_DEFAULT_IMPLEMENT(efl_ui_win, Efl_Ui_Win_Data)
9010 #include "efl_ui_win_part.eo.c"
9014 EOLIAN static Eina_Bool
9015 _efl_ui_win_move_resize_start(Eo *obj EINA_UNUSED, Efl_Ui_Win_Data *sd, Efl_Ui_Win_Move_Resize_Mode mode)
9017 // 1. move_resize can only be started after mouse down event
9018 if (evas_event_down_count_get(sd->evas) <= 0)
9020 ERR("move_resize_start can only be called when a pointer is pressed.");
9023 return _win_move_resize_start(sd, mode);
9027 elm_win_get(Evas_Object *obj)
9029 EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
9030 return ecore_evas_data_get(ecore_evas_ecore_evas_get(evas_object_evas_get(obj)), "elm_win");
9033 /* windowing specific calls - shall we do this differently? */
9036 elm_win_xwindow_get(const Evas_Object *obj)
9038 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9041 #ifdef HAVE_ELEMENTARY_X
9042 _internal_elm_win_xwindow_get(sd);
9043 if (sd->x.xwin) return sd->x.xwin;
9044 if (sd->parent) return elm_win_xwindow_get(sd->parent);
9051 //TIZEN_ONLY(20171208): fix build break by opensource temporarily until migration finish
9052 EAPI Ecore_Wl_Window *
9053 elm_win_wl_window_get(const Evas_Object *obj)
9055 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9057 if (!sd) return NULL;
9059 if (!evas_object_smart_type_check_ptr(obj, MY_CLASS_NAME_LEGACY))
9061 Ecore_Evas *ee = ecore_evas_ecore_evas_get(evas_object_evas_get(obj));
9062 return (Ecore_Wl_Window *)_elm_ee_wlwin_get(ee);
9065 #if HAVE_ELEMENTARY_WL2
9066 if (sd->wl.win) return (Ecore_Wl_Window *)sd->wl.win;
9067 if (sd->parent) return (Ecore_Wl_Window *)elm_win_wl_window_get(sd->parent);
9072 //TIZEN_ONLY(20171208)
9075 EAPI Ecore_Cocoa_Window *
9076 elm_win_cocoa_window_get(const Evas_Object *obj)
9078 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9079 if (!sd) return NULL;
9081 #if HAVE_ELEMENTARY_COCOA
9082 if (sd->cocoa.win) return sd->cocoa.win;
9083 if (sd->ee) return _elm_ee_cocoa_win_get(sd->ee);
9084 if (sd->parent) return elm_win_cocoa_window_get(sd->parent);
9087 Ecore_Evas *ee = ecore_evas_ecore_evas_get(evas_object_evas_get(obj));
9088 return _elm_ee_cocoa_win_get(ee);
9093 EAPI Ecore_Win32_Window *
9094 elm_win_win32_window_get(const Evas_Object *obj)
9096 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9097 const char *engine_name;
9099 if (!sd) return NULL;
9100 engine_name = ecore_evas_engine_name_get(sd->ee);
9101 if (!(engine_name &&
9102 ((!strcmp(engine_name, ELM_SOFTWARE_WIN32)) ||
9103 (!strcmp(engine_name, ELM_SOFTWARE_DDRAW)))))
9106 if (!evas_object_smart_type_check_ptr(obj, MY_CLASS_NAME_LEGACY))
9108 Ecore_Evas *ee = ecore_evas_ecore_evas_get(evas_object_evas_get(obj));
9109 return _elm_ee_win32win_get(ee);
9112 Ecore_Win32_Window *ret = NULL;
9114 #if HAVE_ELEMENTARY_WIN32
9115 if (sd->win32.win) ret = sd->win32.win;
9116 if (sd->parent) ret = elm_win_win32_window_get(sd->parent);
9123 elm_win_trap_data_get(const Evas_Object *obj)
9125 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9126 if (!sd) return NULL;
9128 return sd->trap_data;
9132 elm_win_override_set(Evas_Object *obj, Eina_Bool override)
9134 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9137 TRAP(sd, override_set, override);
9138 #ifdef HAVE_ELEMENTARY_X
9139 _elm_win_xwin_update(sd);
9144 elm_win_override_get(const Evas_Object *obj)
9146 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9147 if (!sd) return EINA_FALSE;
9149 return ecore_evas_override_get(sd->ee);
9153 elm_win_lower(Evas_Object *obj)
9155 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9162 elm_win_quickpanel_set(Evas_Object *obj, Eina_Bool quickpanel)
9164 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9167 #ifdef HAVE_ELEMENTARY_X
9168 _internal_elm_win_xwindow_get(sd);
9171 _internal_elm_win_xwindow_get(sd);
9172 ecore_x_e_illume_quickpanel_set(sd->x.xwin, quickpanel);
9175 Ecore_X_Window_State states[2];
9177 states[0] = ECORE_X_WINDOW_STATE_SKIP_TASKBAR;
9178 states[1] = ECORE_X_WINDOW_STATE_SKIP_PAGER;
9179 ecore_x_netwm_window_state_set(sd->x.xwin, states, 2);
9180 ecore_x_icccm_hints_set(sd->x.xwin, 0, 0, 0, 0, 0, 0, 0);
9187 #ifdef HAVE_ELEMENTARY_WL2
9188 // TIZEN_ONLY(20160404) skip_focus in case invoking elm_win_quickpanel_set
9189 _elm_win_focus_skip_set(sd, EINA_TRUE);
9195 elm_win_quickpanel_get(const Evas_Object *obj)
9197 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9198 if (!sd) return EINA_FALSE;
9200 #ifdef HAVE_ELEMENTARY_X
9201 _internal_elm_win_xwindow_get(sd);
9204 _internal_elm_win_xwindow_get(sd);
9205 return ecore_x_e_illume_quickpanel_get(sd->x.xwin);
9215 elm_win_quickpanel_priority_major_set(Evas_Object *obj, int priority)
9217 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9220 #ifdef HAVE_ELEMENTARY_X
9221 _internal_elm_win_xwindow_get(sd);
9224 _internal_elm_win_xwindow_get(sd);
9225 ecore_x_e_illume_quickpanel_priority_major_set(sd->x.xwin, priority);
9234 elm_win_quickpanel_priority_major_get(const Evas_Object *obj)
9236 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9239 #ifdef HAVE_ELEMENTARY_X
9240 _internal_elm_win_xwindow_get(sd);
9243 _internal_elm_win_xwindow_get(sd);
9244 return ecore_x_e_illume_quickpanel_priority_major_get(sd->x.xwin);
9254 elm_win_quickpanel_priority_minor_set(Evas_Object *obj, int priority)
9256 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9259 #ifdef HAVE_ELEMENTARY_X
9260 _internal_elm_win_xwindow_get(sd);
9263 _internal_elm_win_xwindow_get(sd);
9264 ecore_x_e_illume_quickpanel_priority_minor_set(sd->x.xwin, priority);
9273 elm_win_quickpanel_priority_minor_get(const Evas_Object *obj)
9275 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9278 #ifdef HAVE_ELEMENTARY_X
9279 _internal_elm_win_xwindow_get(sd);
9282 _internal_elm_win_xwindow_get(sd);
9283 return ecore_x_e_illume_quickpanel_priority_minor_get(sd->x.xwin);
9293 elm_win_quickpanel_zone_set(Evas_Object *obj, int zone)
9295 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9298 #ifdef HAVE_ELEMENTARY_X
9299 _internal_elm_win_xwindow_get(sd);
9302 _internal_elm_win_xwindow_get(sd);
9303 ecore_x_e_illume_quickpanel_zone_set(sd->x.xwin, zone);
9312 elm_win_quickpanel_zone_get(const Evas_Object *obj)
9314 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9317 #ifdef HAVE_ELEMENTARY_X
9318 _internal_elm_win_xwindow_get(sd);
9321 _internal_elm_win_xwindow_get(sd);
9322 return ecore_x_e_illume_quickpanel_zone_get(sd->x.xwin);
9332 elm_win_indicator_mode_set(Evas_Object *obj, Elm_Win_Indicator_Mode mode)
9334 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9336 if (sd->legacy.forbidden)
9338 CRI("Use of this API is forbidden after calling an EO API on this "
9339 "window. Fix your code!");
9343 if (mode == sd->legacy.indmode) return;
9344 #ifdef HAVE_ELEMENTARY_X
9345 _internal_elm_win_xwindow_get(sd);
9347 sd->legacy.indmode = mode;
9348 #ifdef HAVE_ELEMENTARY_X
9351 _internal_elm_win_xwindow_get(sd);
9352 if (sd->legacy.indmode == ELM_WIN_INDICATOR_SHOW)
9353 ecore_x_e_illume_indicator_state_set
9354 (sd->x.xwin, ECORE_X_ILLUME_INDICATOR_STATE_ON);
9355 else if (sd->legacy.indmode == ELM_WIN_INDICATOR_HIDE)
9356 ecore_x_e_illume_indicator_state_set
9357 (sd->x.xwin, ECORE_X_ILLUME_INDICATOR_STATE_OFF);
9360 #ifdef HAVE_ELEMENTARY_WL2
9361 _elm_win_wlwindow_get(sd);
9364 if (sd->legacy.indmode == ELM_WIN_INDICATOR_SHOW)
9365 ecore_wl2_window_indicator_state_set
9366 (sd->wl.win, ECORE_WL2_INDICATOR_STATE_ON);
9367 else if (sd->legacy.indmode == ELM_WIN_INDICATOR_HIDE)
9368 ecore_wl2_window_indicator_state_set
9369 (sd->wl.win, ECORE_WL2_INDICATOR_STATE_OFF);
9372 efl_event_callback_legacy_call
9373 (obj, EFL_UI_WIN_EVENT_INDICATOR_PROP_CHANGED, NULL);
9376 EAPI Elm_Win_Indicator_Mode
9377 elm_win_indicator_mode_get(const Evas_Object *obj)
9379 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9380 if (!sd) return ELM_WIN_INDICATOR_UNKNOWN;
9381 if (sd->legacy.forbidden)
9383 CRI("Use of this API is forbidden after calling an EO API on this "
9384 "window. Fix your code!");
9385 return ELM_WIN_INDICATOR_UNKNOWN;
9388 return sd->legacy.indmode;
9392 elm_win_indicator_opacity_set(Evas_Object *obj, Elm_Win_Indicator_Opacity_Mode mode)
9394 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9396 if (sd->legacy.forbidden)
9398 CRI("Use of this API is forbidden after calling an EO API on this "
9399 "window. Fix your code!");
9403 if (mode == sd->legacy.ind_o_mode) return;
9404 sd->legacy.ind_o_mode = mode;
9405 #ifdef HAVE_ELEMENTARY_X
9406 _internal_elm_win_xwindow_get(sd);
9409 _internal_elm_win_xwindow_get(sd);
9410 if (sd->legacy.ind_o_mode == ELM_WIN_INDICATOR_OPAQUE)
9411 ecore_x_e_illume_indicator_opacity_set
9412 (sd->x.xwin, ECORE_X_ILLUME_INDICATOR_OPAQUE);
9413 else if (sd->legacy.ind_o_mode == ELM_WIN_INDICATOR_TRANSLUCENT)
9414 ecore_x_e_illume_indicator_opacity_set
9415 (sd->x.xwin, ECORE_X_ILLUME_INDICATOR_TRANSLUCENT);
9416 else if (sd->legacy.ind_o_mode == ELM_WIN_INDICATOR_TRANSPARENT)
9417 ecore_x_e_illume_indicator_opacity_set
9418 (sd->x.xwin, ECORE_X_ILLUME_INDICATOR_TRANSPARENT);
9421 #ifdef HAVE_ELEMENTARY_WL2
9422 _elm_win_wlwindow_get(sd);
9425 if (sd->legacy.ind_o_mode == ELM_WIN_INDICATOR_OPAQUE)
9426 ecore_wl2_window_indicator_opacity_set
9427 (sd->wl.win, ECORE_WL2_INDICATOR_OPAQUE);
9428 else if (sd->legacy.ind_o_mode == ELM_WIN_INDICATOR_TRANSLUCENT)
9429 ecore_wl2_window_indicator_opacity_set
9430 (sd->wl.win, ECORE_WL2_INDICATOR_TRANSLUCENT);
9431 else if (sd->legacy.ind_o_mode == ELM_WIN_INDICATOR_TRANSPARENT)
9432 ecore_wl2_window_indicator_opacity_set
9433 (sd->wl.win, ECORE_WL2_INDICATOR_TRANSPARENT);
9434 else if (sd->legacy.ind_o_mode == ELM_WIN_INDICATOR_BG_TRANSPARENT)
9435 ecore_wl2_window_indicator_opacity_set
9436 (sd->wl.win, ECORE_WL2_INDICATOR_BG_TRANSPARENT);
9439 efl_event_callback_legacy_call
9440 (obj, EFL_UI_WIN_EVENT_INDICATOR_PROP_CHANGED, NULL);
9443 EAPI Elm_Win_Indicator_Opacity_Mode
9444 elm_win_indicator_opacity_get(const Evas_Object *obj)
9446 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9447 if (!sd) return ELM_WIN_INDICATOR_OPACITY_UNKNOWN;
9448 if (sd->legacy.forbidden)
9450 CRI("Use of this API is forbidden after calling an EO API on this "
9451 "window. Fix your code!");
9452 return ELM_WIN_INDICATOR_OPACITY_UNKNOWN;
9455 return sd->legacy.ind_o_mode;
9459 elm_win_keyboard_win_set(Evas_Object *obj, Eina_Bool is_keyboard)
9461 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9464 #ifdef HAVE_ELEMENTARY_X
9465 _internal_elm_win_xwindow_get(sd);
9468 _internal_elm_win_xwindow_get(sd);
9469 ecore_x_e_virtual_keyboard_set(sd->x.xwin, is_keyboard);
9478 elm_win_keyboard_win_get(const Evas_Object *obj)
9480 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9481 if (!sd) return EINA_FALSE;
9483 #ifdef HAVE_ELEMENTARY_X
9484 _internal_elm_win_xwindow_get(sd);
9487 _internal_elm_win_xwindow_get(sd);
9488 return ecore_x_e_virtual_keyboard_get(sd->x.xwin);
9497 elm_win_conformant_set(Evas_Object *obj, Eina_Bool conformant)
9499 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9502 #ifdef HAVE_ELEMENTARY_X
9503 _internal_elm_win_xwindow_get(sd);
9506 _internal_elm_win_xwindow_get(sd);
9507 ecore_x_e_illume_conformant_set(sd->x.xwin, conformant);
9509 #elif HAVE_ELEMENTARY_WL2
9510 // TIZEN_ONLY(20150707): elm_conform for wayland, and signal if parts are changed
9511 _elm_win_wlwindow_get(sd);
9513 ecore_wl2_window_conformant_set(sd->wl.win, conformant);
9522 elm_win_conformant_get(const Evas_Object *obj)
9524 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9525 if (!sd) return EINA_FALSE;
9527 #ifdef HAVE_ELEMENTARY_X
9528 _internal_elm_win_xwindow_get(sd);
9531 _internal_elm_win_xwindow_get(sd);
9532 return ecore_x_e_illume_conformant_get(sd->x.xwin);
9534 #elif HAVE_ELEMENTARY_WL2
9535 // TIZEN_ONLY(20150707): elm_conform for wayland, and signal if parts are changed
9536 _elm_win_wlwindow_get(sd);
9538 return ecore_wl2_window_conformant_get(sd->wl.win);
9548 elm_win_wm_rotation_manual_rotation_done_set(Evas_Object *obj, Eina_Bool set)
9550 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9553 if (!sd->wm_rot.use) return;
9554 ecore_evas_wm_rotation_manual_rotation_done_set(sd->ee, set);
9558 elm_win_wm_rotation_manual_rotation_done_get(const Evas_Object *obj)
9560 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9561 if (!sd) return EINA_FALSE;
9563 if (!sd->wm_rot.use) return EINA_FALSE;
9564 return ecore_evas_wm_rotation_manual_rotation_done_get(sd->ee);
9568 elm_win_wm_rotation_manual_rotation_done(Evas_Object *obj)
9570 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9573 if (!sd->wm_rot.use) return;
9574 ecore_evas_wm_rotation_manual_rotation_done(sd->ee);
9578 * This API does not resize the internal window (ex: X window).
9579 * But this resizes evas_output, elm window, and its contents.
9582 elm_win_rotation_with_resize_set(Evas_Object *obj, int rotation)
9584 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9586 // TIZEN_ONLY(20170212): pend rotation until app set rotation
9587 if (sd->wm_rot.rotation_pending)
9589 _win_pending_rotate(obj, sd, rotation, EINA_TRUE);
9593 _win_rotate(obj, sd, rotation, EINA_TRUE);
9597 elm_win_wm_rotation_preferred_rotation_get(const Evas_Object *obj)
9599 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9602 return sd->wm_rot.preferred_rot;
9606 elm_win_wm_rotation_supported_get(const Evas_Object *obj)
9608 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9609 if (!sd) return EINA_FALSE;
9611 return sd->wm_rot.wm_supported;
9615 elm_win_wm_rotation_preferred_rotation_set(Evas_Object *obj, int rotation)
9617 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9621 if (!sd->wm_rot.use)
9622 sd->wm_rot.use = EINA_TRUE;
9624 // '-1' means that elm_win doesn't use preferred rotation.
9628 rot = _win_rotation_degree_check(rotation);
9630 if (sd->wm_rot.preferred_rot == rot) return;
9631 sd->wm_rot.preferred_rot = rot;
9633 ecore_evas_wm_rotation_preferred_rotation_set(sd->ee, rot);
9637 elm_win_screen_size_get(const Evas_Object *obj, int *x, int *y, int *w, int *h)
9639 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9642 ecore_evas_screen_geometry_get(sd->ee, x, y, w, h);
9646 elm_win_screen_position_get(const Evas_Object *obj, int *x, int *y)
9648 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9651 if (x) *x = sd->screen.x;
9652 if (y) *y = sd->screen.y;
9656 elm_win_screen_dpi_get(const Evas_Object *obj, int *xdpi, int *ydpi)
9658 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9661 ecore_evas_screen_dpi_get(sd->ee, xdpi, ydpi);
9665 elm_win_icon_name_set(Evas_Object *obj, const char *icon_name)
9667 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9670 if (!icon_name) return;
9671 eina_stringshare_replace(&(sd->icon_name), icon_name);
9672 #ifdef HAVE_ELEMENTARY_X
9673 _elm_win_xwin_update(sd);
9678 elm_win_icon_name_get(const Evas_Object *obj)
9680 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9681 if (!sd) return NULL;
9683 return sd->icon_name;
9687 elm_win_withdrawn_set(Evas_Object *obj, Eina_Bool withdrawn)
9689 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9692 // sd->withdrawn = withdrawn;
9693 TRAP(sd, withdrawn_set, withdrawn);
9694 #ifdef HAVE_ELEMENTARY_X
9695 _elm_win_xwin_update(sd);
9700 elm_win_withdrawn_get(const Evas_Object *obj)
9702 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9703 if (!sd) return EINA_FALSE;
9705 return sd->withdrawn;
9709 elm_win_urgent_set(Evas_Object *obj, Eina_Bool urgent)
9711 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9714 if (sd->urgent == urgent)
9716 sd->urgent = urgent;
9717 TRAP(sd, urgent_set, urgent);
9718 #ifdef HAVE_ELEMENTARY_X
9719 _elm_win_xwin_update(sd);
9724 elm_win_urgent_get(const Evas_Object *obj)
9726 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9727 if (!sd) return EINA_FALSE;
9733 elm_win_demand_attention_set(Evas_Object *obj, Eina_Bool demand_attention)
9735 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9738 sd->demand_attention = demand_attention;
9739 TRAP(sd, demand_attention_set, demand_attention);
9740 #ifdef HAVE_ELEMENTARY_X
9741 _elm_win_xwin_update(sd);
9746 elm_win_demand_attention_get(const Evas_Object *obj)
9748 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9749 if (!sd) return EINA_FALSE;
9751 return sd->demand_attention;
9755 elm_win_modal_set(Evas_Object *obj, Eina_Bool modal)
9757 Efl_Ui_Win_Modal_Mode modality;
9759 modality = modal ? EFL_UI_WIN_MODAL_MODE_MODAL : EFL_UI_WIN_MODAL_MODE_NONE;
9760 efl_ui_win_modal_set(obj, modality);
9764 elm_win_modal_get(const Evas_Object *obj)
9766 Efl_Ui_Win_Modal_Mode modality;
9768 modality = efl_ui_win_modal_get(obj);
9769 return (modality != EFL_UI_WIN_MODAL_MODE_NONE);
9773 elm_win_shaped_set(Evas_Object *obj, Eina_Bool shaped)
9775 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9780 #ifdef HAVE_ELEMENTARY_X
9781 if (sd->x.shaped == shaped) return;
9782 sd->x.shaped = shaped;
9783 TRAP(sd, shaped_set, shaped);
9788 elm_win_shaped_get(const Evas_Object *obj)
9790 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9791 if (!sd) return EINA_FALSE;
9793 return ecore_evas_shaped_get(sd->ee);
9797 elm_win_title_set(Evas_Object *obj, const char *title)
9799 efl_text_set(obj, title);
9803 elm_win_title_get(const Evas_Object *obj)
9805 return efl_text_get(obj);
9809 elm_win_size_base_set(Evas_Object *obj, int w, int h)
9811 efl_ui_win_hint_base_set(obj, EINA_SIZE2D(w, h));
9815 elm_win_size_base_get(const Evas_Object *obj, int *w, int *h)
9818 sz = efl_ui_win_hint_base_get(obj);
9824 elm_win_size_step_set(Evas_Object *obj, int w, int h)
9826 efl_ui_win_hint_step_set(obj, EINA_SIZE2D(w, h));
9830 elm_win_size_step_get(const Evas_Object *obj, int *w, int *h)
9833 sz = efl_ui_win_hint_step_get(obj);
9839 elm_win_illume_command_send(Evas_Object *obj, Elm_Illume_Command command, void *params EINA_UNUSED)
9841 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9844 #ifdef HAVE_ELEMENTARY_X
9845 _internal_elm_win_xwindow_get(sd);
9848 _internal_elm_win_xwindow_get(sd);
9851 case ELM_ILLUME_COMMAND_FOCUS_BACK:
9852 ecore_x_e_illume_focus_back_send(sd->x.xwin);
9855 case ELM_ILLUME_COMMAND_FOCUS_FORWARD:
9856 ecore_x_e_illume_focus_forward_send(sd->x.xwin);
9859 case ELM_ILLUME_COMMAND_FOCUS_HOME:
9860 ecore_x_e_illume_focus_home_send(sd->x.xwin);
9863 case ELM_ILLUME_COMMAND_CLOSE:
9864 ecore_x_e_illume_close_send(sd->x.xwin);
9878 elm_win_profile_set(Evas_Object *obj, const char *profile)
9880 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9883 /* check to see if a given profile is present in an available profiles */
9884 if (profile && eina_array_count(sd->profile.available))
9886 if (!_profile_exists(sd, profile))
9890 if (ecore_evas_window_profile_supported_get(sd->ee))
9892 if (!profile) _elm_win_profile_del(sd);
9893 ecore_evas_window_profile_set(sd->ee, profile);
9897 if (_internal_elm_win_profile_set(sd, profile))
9898 _elm_win_profile_update(sd);
9903 elm_win_profile_get(const Evas_Object *obj)
9905 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9906 if (!sd) return NULL;
9908 return sd->profile.name;
9912 elm_win_layer_set(Evas_Object *obj, int layer)
9914 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9917 TRAP(sd, layer_set, layer);
9918 #ifdef HAVE_ELEMENTARY_X
9919 _elm_win_xwin_update(sd);
9924 elm_win_layer_get(const Evas_Object *obj)
9926 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9929 return ecore_evas_layer_get(sd->ee);
9933 elm_win_inlined_image_object_get(const Evas_Object *obj)
9935 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
9936 if (!sd) return NULL;
9941 // TIZEN_ONLY(20170212): pend rotation until app set rotation
9943 /* Efl don't have any plan to open new API to support the client rotation.(ex: elm_win_rotation_set)
9944 * But it is need that apps deal with rotation
9945 * For example, if the app want to do the object rotation effect during the rotation,
9946 * canvas should not be rotated until app's rotation effect ends.
9947 * so until to decide app's rotaion policy,
9948 * just use the "wm.policy.win.rot.render.nopending" aux_hint.
9949 * Using this hint, elm- ecore_evas - engine -tizen display server will manage the pending rotation.
9953 _elm_win_wm_pending_rotation_set(Evas_Object *obj EINA_UNUSED, const char *hint EINA_UNUSED, const char *val)
9955 ELM_WIN_DATA_GET_OR_RETURN(obj, sd, -1);
9959 //TODO: aux_hint_del, aux_hint_val_set.
9960 //Currently only 1 is available.
9962 if (!val || (strncmp(val, "1", 1))) return -1;
9963 id = ecore_evas_aux_hint_add(sd->ee, "wm.policy.win.rot.render.nopending", val);
9967 ERR("PendingRotation: elm_win pending_rotation_set aux id failed");
9970 sd->wm_rot.rotation_pending = EINA_TRUE;
9971 DBG("PendingRotation: elm_win rotation_pending_set sucess");
9976 // TIZEN_ONLY(20171114) Accessibility Highlight Frame added
9977 static void _elm_win_accessibility_highlight_callbacks_del(Efl_Ui_Win_Data *sd)
9979 Evas_Object *obj = sd->accessibility_highlight.cur.target;
9982 evas_object_event_callback_del_full(obj, EVAS_CALLBACK_DEL, _elm_win_accessibility_highlight_obj_del, sd->obj);
9984 if (efl_isa(obj, EFL_UI_WIDGET_CLASS) && elm_widget_access_highlight_in_theme_get(obj))
9987 evas_object_event_callback_del_full(obj, EVAS_CALLBACK_MOVE, _elm_win_accessibility_highlight_obj_move, sd->obj);
9988 evas_object_event_callback_del_full(obj, EVAS_CALLBACK_RESIZE, _elm_win_accessibility_highlight_obj_resize, sd->obj);
9992 _elm_win_object_set_accessibility_highlight(Evas_Object *win, Evas_Object *obj, Eina_Bool visible)
9995 ELM_WIN_DATA_GET(win, sd);
9996 if (visible || sd->accessibility_highlight.cur.target == obj)
9999 _elm_win_accessibility_highlight_hide(sd->obj);
10000 // TIZEN_ONLY(20171117) Accessibility frame follows parent item on scroll event
10001 _elm_win_accessibility_highlight_callbacks_del(sd);
10006 _elm_win_accessibility_highlight_init(sd, obj);
10007 _elm_win_accessibility_highlight_show(win);
10008 //TIZEN_ONLY(20160623): atspi: moved highlight when object is out of screen
10009 sd->accessibility_highlight.cur.need_moved = EINA_TRUE;
10015 //TIZEN_ONLY(20170919): Handle default label object
10017 _default_label_obj_del_cb (void *data,
10018 Evas *e EINA_UNUSED,
10020 void *event_info EINA_UNUSED)
10022 ELM_WIN_DATA_GET(data, sd);
10025 sd->default_label_objs = eina_list_remove(sd->default_label_objs, obj);
10028 static int _sort_parent_child_order(const void *data1, const void *data2)
10033 parent = efl_provider_find(efl_parent_get(data1), EFL_ACCESS_OBJECT_MIXIN);
10036 if (parent == data2) return 1;
10037 parent = efl_provider_find(efl_parent_get(parent), EFL_ACCESS_OBJECT_MIXIN);
10044 _elm_win_default_label_obj_append(Evas_Object *default_label_obj)
10046 if (!default_label_obj) return;
10048 Evas_Object *win = elm_widget_top_get(default_label_obj);
10049 if (!win || !efl_isa(win, EFL_UI_WIN_CLASS))
10051 WRN("The top object of %s is not a window.",
10052 efl_class_name_get(efl_class_get(default_label_obj)));
10056 ELM_WIN_DATA_GET(win, sd);
10059 if (eina_list_data_find(sd->default_label_objs, default_label_obj))
10061 sd->default_label_objs =
10062 eina_list_remove(sd->default_label_objs, default_label_obj);
10063 evas_object_event_callback_del_full(default_label_obj, EVAS_CALLBACK_DEL,
10064 _default_label_obj_del_cb, win);
10067 evas_object_event_callback_add(default_label_obj, EVAS_CALLBACK_DEL,
10068 _default_label_obj_del_cb, win);
10069 sd->default_label_objs =
10070 eina_list_append(sd->default_label_objs, default_label_obj);
10072 sd->default_label_objs =
10073 eina_list_sort(sd->default_label_objs, -1, _sort_parent_child_order);
10077 _elm_win_default_label_obj_remove(Evas_Object *default_label_obj)
10079 if (!default_label_obj) return;
10081 Evas_Object *win = elm_widget_top_get(default_label_obj);
10082 if (!win || !efl_isa(win, EFL_UI_WIN_CLASS))
10084 WRN("The top object of %s is not a window.",
10085 efl_class_name_get(efl_class_get(default_label_obj)));
10089 ELM_WIN_DATA_GET(win, sd);
10092 if (eina_list_data_find(sd->default_label_objs, default_label_obj))
10094 sd->default_label_objs =
10095 eina_list_remove(sd->default_label_objs, default_label_obj);
10096 evas_object_event_callback_del_full(default_label_obj, EVAS_CALLBACK_DEL,
10097 _default_label_obj_del_cb, win);
10102 _elm_win_default_label_obj_get(Evas_Object *obj)
10104 if (!obj) return NULL;
10105 ELM_WIN_DATA_GET(obj, sd);
10106 if (!sd) return NULL;
10108 return eina_list_last_data_get(sd->default_label_objs);
10112 static Ecore_Window
10113 _elm_win_window_id_get(Efl_Ui_Win_Data *sd)
10115 #if HAVE_ELEMENTARY_WL2
10117 return (Ecore_Window)ecore_wl2_window_id_get(sd->wl.win);
10120 Ecore_Wl2_Window *parent;
10121 //TIZEN_ONLY(20171208): fix build break by opensource temporarily until migration finish
10122 parent = (Ecore_Wl2_Window *)elm_win_wl_window_get(sd->parent);
10123 //TIZEN_ONLY(20171208)
10125 return (Ecore_Window)ecore_wl2_window_id_get(parent);
10128 #ifdef HAVE_ELEMENTARY_X
10129 _internal_elm_win_xwindow_get(sd);
10132 _internal_elm_win_xwindow_get(sd);
10133 return (Ecore_Window)sd->x.xwin;
10137 Ecore_Window xwin = elm_win_xwindow_get(sd->parent);
10138 if (xwin) return xwin;
10141 #ifdef HAVE_ELEMENTARY_COCOA
10142 if (sd->cocoa.win) return (Ecore_Window)(sd->cocoa.win);
10145 Ecore_Cocoa_Window *pwin;
10146 pwin = elm_win_cocoa_window_get(sd->parent);
10147 if (pwin) return (Ecore_Window)pwin;
10150 #ifdef HAVE_ELEMENTARY_WIN32
10151 _internal_elm_win_win32window_get(sd);
10152 if (sd->win32.win) return (Ecore_Window)sd->win32.win;
10155 Ecore_Window wwin = (Ecore_Window)elm_win_win32_window_get(sd->parent);
10156 if (wwin) return wwin;
10164 elm_win_window_id_get(const Evas_Object *obj)
10166 Efl_Ui_Win_Data *sd;
10167 if (!obj) return 0;
10169 if (!evas_object_smart_type_check_ptr(obj, MY_CLASS_NAME_LEGACY))
10171 Ecore_Evas *ee = ecore_evas_ecore_evas_get(evas_object_evas_get(obj));
10173 return ecore_evas_window_get(ee);
10176 sd = efl_data_scope_safe_get(obj, MY_CLASS);
10178 return _elm_win_window_id_get(sd);
10182 elm_win_main_menu_get(Evas_Object *obj)
10184 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
10185 if (!sd) return NULL;
10187 #ifdef HAVE_ELEMENTARY_X
10188 Eina_Bool use_dbus = EINA_FALSE;
10191 if (sd->main_menu) goto end;
10193 sd->main_menu = elm_menu_add(obj);
10194 _elm_menu_menu_bar_set(sd->main_menu, EINA_TRUE);
10196 #ifdef HAVE_ELEMENTARY_X
10197 if (!_elm_config->disable_external_menu && sd->x.xwin) use_dbus = EINA_TRUE;
10199 if (use_dbus && _elm_dbus_menu_register(sd->main_menu))
10201 _internal_elm_win_xwindow_get(sd);
10202 _elm_dbus_menu_app_menu_register(sd->x.xwin, sd->main_menu,
10203 _dbus_menu_set, obj);
10207 _dbus_menu_set(EINA_FALSE, obj);
10210 return sd->main_menu;
10214 elm_win_aspect_set(Eo *obj, double aspect)
10216 Eina_Size2D sz = { 0, 0 };
10218 if (aspect > DBL_EPSILON)
10219 sz = EINA_SIZE2D(1000 * aspect, 1000);
10221 efl_gfx_hint_aspect_set(obj, EFL_GFX_HINT_ASPECT_NONE, sz);
10225 elm_win_aspect_get(const Eo *obj)
10227 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
10228 if (!sd) return 0.0;
10229 return _win_aspect_get(sd);
10235 _fake_canvas_set(Evas_Object *obj, Ecore_Evas *oee)
10237 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
10241 _elm_win_need_frame_adjust(sd, ecore_evas_engine_name_get(oee));
10247 * Recalculate the size of window considering its resize objects' weight and
10248 * min size. If any of its resize objects' weight equals to 0.0, window
10249 * layout's weight will be set to 0.0.
10251 * @param o box object
10252 * @param p box's private data
10253 * @param data window object
10256 _window_layout_stack(Evas_Object *o, Evas_Object_Box_Data *p, void *data)
10258 const Eina_List *l;
10259 Evas_Object *child;
10260 Evas_Object_Box_Option *opt;
10261 Evas_Coord x, y, w, h, menuw = 0;
10263 Evas_Coord minw = -1, minh = -1;
10264 double weight_x = EVAS_HINT_EXPAND;
10265 double weight_y = EVAS_HINT_EXPAND;
10267 ELM_WIN_DATA_GET(data, sd);
10268 if (sd->main_menu && efl_gfx_entity_visible_get(sd->main_menu))
10269 evas_object_size_hint_combined_min_get(sd->main_menu, &menuw, NULL);
10271 EINA_LIST_FOREACH(p->children, l, opt)
10274 efl_gfx_hint_weight_get(child, &wx, &wy);
10275 if (EINA_DBL_EQ(wx, 0.0)) weight_x = 0;
10276 if (EINA_DBL_EQ(wy, 0.0)) weight_y = 0;
10278 evas_object_size_hint_combined_min_get(child, &w, &h);
10279 if (w > minw) minw = w;
10280 if (h > minh) minh = h;
10283 if (minw < menuw) minw = menuw;
10284 efl_gfx_hint_size_restricted_min_set(o, EINA_SIZE2D(minw, minh));
10285 evas_object_geometry_get(o, &x, &y, &w, &h);
10286 if (w < minw) w = minw;
10287 if (h < minh) h = minh;
10288 evas_object_resize(o, w, h);
10290 EINA_LIST_FOREACH(p->children, l, opt)
10293 evas_object_geometry_set(child, x, y, w, h);
10296 efl_gfx_hint_weight_set(sd->legacy.edje, weight_x, weight_y);
10297 //evas_object_smart_changed(sd->legacy.edje);
10301 _elm_win_legacy_init(Efl_Ui_Win_Data *sd)
10303 sd->legacy.edje = edje_object_add(sd->evas);
10304 _elm_win_theme_internal(sd->obj, sd);
10306 //TIZEN_ONLY(20161208): supported floating window
10307 if (sd->type != ELM_WIN_BASIC)
10308 edje_object_signal_emit(sd->legacy.edje, "elm,state,floating,on", "elm");
10311 sd->legacy.box = evas_object_box_add(sd->evas);
10312 evas_object_box_layout_set(sd->legacy.box, _window_layout_stack, sd->obj, NULL);
10314 if (elm_widget_is_legacy(sd->obj))
10315 edje_object_part_swallow(sd->legacy.edje, "elm.swallow.contents", sd->legacy.box);
10317 edje_object_part_swallow(sd->legacy.edje, "efl.contents", sd->legacy.box);
10319 if (sd->type != EFL_UI_WIN_TYPE_FAKE)
10321 edje_object_update_hints_set(sd->legacy.edje, EINA_TRUE);
10322 evas_object_event_callback_add(sd->legacy.edje, EVAS_CALLBACK_CHANGED_SIZE_HINTS,
10323 _elm_win_on_resize_obj_changed_size_hints, sd->obj);
10328 elm_win_resize_object_add(Eo *obj, Evas_Object *subobj)
10330 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
10334 if (sd->legacy.forbidden)
10336 CRI("Use of this API is forbidden after calling an EO API on this "
10337 "window. Fix your code!");
10341 // Little hack for E
10342 if (evas_obj_box_count(sd->legacy.box) > 0)
10343 sd->single_edje_content = 0;
10344 else if (efl_isa(subobj, EFL_CANVAS_LAYOUT_CLASS))
10345 sd->single_edje_content = 1;
10347 ret = elm_widget_sub_object_add(obj, subobj);
10348 ret &= (evas_object_box_append(sd->legacy.box, subobj) != NULL);
10351 ERR("could not add sub object %p to window %p", subobj, obj);
10355 elm_win_resize_object_del(Eo *obj, Evas_Object *subobj)
10357 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
10361 if (sd->legacy.forbidden)
10363 CRI("Use of this API is forbidden after calling an EO API on this "
10364 "window. Fix your code!");
10368 ret = elm_widget_sub_object_del(obj, subobj);
10369 ret &= evas_object_box_remove(sd->legacy.box, subobj);
10372 ERR("could not remove sub object %p from window %p", subobj, obj);
10376 elm_win_keygrab_set(Elm_Win *obj, const char *key,
10377 Evas_Modifier_Mask modifiers EINA_UNUSED,
10378 Evas_Modifier_Mask not_modifiers EINA_UNUSED,
10379 int priority EINA_UNUSED, Elm_Win_Keygrab_Mode grab_mode)
10381 // Note: Not converting modifiers as they are not used in the implementation
10382 Eina_Bool ret = EINA_FALSE;
10383 #ifdef HAVE_ELEMENTARY_X
10384 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
10385 EINA_SAFETY_ON_NULL_RETURN_VAL(sd, EINA_FALSE);
10386 _internal_elm_win_xwindow_get(sd);
10389 _internal_elm_win_xwindow_get(sd);
10390 Ecore_X_Win_Keygrab_Mode x_grab_mode;
10393 case ELM_WIN_KEYGRAB_SHARED:
10394 x_grab_mode = ECORE_X_WIN_KEYGRAB_SHARED;
10396 case ELM_WIN_KEYGRAB_TOPMOST:
10397 x_grab_mode = ECORE_X_WIN_KEYGRAB_TOPMOST;
10399 case ELM_WIN_KEYGRAB_EXCLUSIVE:
10400 x_grab_mode = ECORE_X_WIN_KEYGRAB_EXCLUSIVE;
10402 case ELM_WIN_KEYGRAB_OVERRIDE_EXCLUSIVE:
10403 x_grab_mode = ECORE_X_WIN_KEYGRAB_OVERRIDE_EXCLUSIVE;
10408 ret = ecore_x_window_keygrab_set(sd->x.xwin, key, 0, 0, 0, x_grab_mode);
10412 // TIZEN_ONLY(20150722): Add ecore_wl2_window_keygrab_* APIs
10413 #ifdef HAVE_ELEMENTARY_WL2
10414 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
10415 EINA_SAFETY_ON_FALSE_RETURN_VAL(sd, EINA_FALSE);
10416 _elm_win_wlwindow_get(sd);
10419 Ecore_Wl2_Window_Keygrab_Mode wl_grab_mode;
10422 case ELM_WIN_KEYGRAB_SHARED:
10423 wl_grab_mode = ECORE_WL2_WINDOW_KEYGRAB_SHARED;
10425 case ELM_WIN_KEYGRAB_TOPMOST:
10426 wl_grab_mode = ECORE_WL2_WINDOW_KEYGRAB_TOPMOST;
10428 case ELM_WIN_KEYGRAB_EXCLUSIVE:
10429 wl_grab_mode = ECORE_WL2_WINDOW_KEYGRAB_EXCLUSIVE;
10431 case ELM_WIN_KEYGRAB_OVERRIDE_EXCLUSIVE:
10432 wl_grab_mode = ECORE_WL2_WINDOW_KEYGRAB_OVERRIDE_EXCLUSIVE;
10437 ret = ecore_wl2_window_keygrab_set(sd->wl.win, key, 0, 0, 0, wl_grab_mode);
10450 elm_win_keygrab_unset(Elm_Win *obj, const char *key,
10451 Evas_Modifier_Mask modifiers EINA_UNUSED,
10452 Evas_Modifier_Mask not_modifiers EINA_UNUSED)
10454 // Note: Not converting modifiers as they are not used in the implementation
10455 Eina_Bool ret = EINA_FALSE;
10456 #ifdef HAVE_ELEMENTARY_X
10457 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
10458 EINA_SAFETY_ON_NULL_RETURN_VAL(sd, EINA_FALSE);
10459 _internal_elm_win_xwindow_get(sd);
10462 _internal_elm_win_xwindow_get(sd);
10463 ret = ecore_x_window_keygrab_unset(sd->x.xwin, key, 0, 0);
10467 // TIZEN_ONLY(20150722): Add ecore_wl2_window_keygrab_* APIs
10468 #ifdef HAVE_ELEMENTARY_WL2
10469 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
10470 EINA_SAFETY_ON_FALSE_RETURN_VAL(sd, EINA_FALSE);
10471 _elm_win_wlwindow_get(sd);
10473 ret = ecore_wl2_window_keygrab_unset(sd->wl.win, key, 0, 0);
10484 elm_win_socket_listen(Efl_Ui_Win *obj, const char *svcname, int svcnum, Eina_Bool svcsys)
10486 return efl_ui_win_socket_listen(obj, svcname, svcnum, svcsys);
10490 elm_win_focus_get(const Efl_Ui_Win *obj)
10492 EINA_SAFETY_ON_FALSE_RETURN_VAL(efl_isa(obj, MY_CLASS), EINA_FALSE);
10493 /* TIZEN_ONLY(20180607): Restore legacy focus
10494 return efl_ui_focus_object_focus_get(obj);
10496 ELM_WIN_DATA_GET_OR_RETURN(obj, sd, EINA_FALSE);
10497 return ecore_evas_focus_get(sd->ee);
10502 elm_win_available_profiles_get(const Elm_Win *obj, char ***profiles, unsigned int *count)
10504 const Eina_Array *ar;
10506 if (!efl_isa(obj, MY_CLASS)) return EINA_FALSE;
10507 ar = efl_ui_win_wm_available_profiles_get(obj);
10510 if (profiles) *profiles = NULL;
10511 if (count) *count = 0;
10515 if (profiles) *profiles = (char **) ar->data;
10516 if (count) *count = ar->count;
10521 elm_win_available_profiles_set(Elm_Win *obj, const char **profiles, unsigned int count)
10523 if (!efl_isa(obj, MY_CLASS)) return;
10524 if ((count > 0) && (profiles))
10529 ar = eina_array_new(count);
10532 for (i = 0; i < count; i++)
10533 eina_array_push(ar, profiles[i]);
10534 efl_ui_win_wm_available_profiles_set(obj, ar);
10535 eina_array_free(ar);
10538 else efl_ui_win_wm_available_profiles_set(obj, NULL);
10541 // TIZEN_ONLY(20171114) Accessibility Highlight Frame added
10542 // //TIZEN_ONLY(20171108): bring HIGHLIGHT related changes
10544 // _elm_win_accessibility_highlight_obj_del(void *data,
10545 // Evas *e EINA_UNUSED,
10546 // Evas_Object *obj EINA_UNUSED,
10547 // void *event_info EINA_UNUSED)
10549 // ELM_WIN_DATA_GET(data, sd);
10550 // _elm_win_accessibility_highlight_shutdown(sd);
10554 // _elm_win_accessibility_highlight_obj_move(void *data,
10555 // Evas *e EINA_UNUSED,
10556 // Evas_Object *obj EINA_UNUSED,
10557 // void *event_info EINA_UNUSED)
10559 // ELM_WIN_DATA_GET(data, sd);
10560 // _elm_win_accessibility_highlight_update(sd);
10564 // _elm_win_accessibility_highlight_obj_resize(void *data,
10565 // Evas *e EINA_UNUSED,
10566 // Evas_Object *obj EINA_UNUSED,
10567 // void *event_info EINA_UNUSED)
10569 // ELM_WIN_DATA_GET(data, sd);
10570 // _elm_win_accessibility_highlight_update(sd);
10573 // static void _elm_win_accessibility_highlight_callbacks_add(Efl_Ui_Win_Data *sd)
10575 // Evas_Object *obj = sd->accessibility_highlight.target;
10576 // if (!obj) return;
10578 // evas_object_event_callback_add(obj, EVAS_CALLBACK_DEL, _elm_win_accessibility_highlight_obj_del, sd->obj);
10580 // if (efl_isa(obj, ELM_WIDGET_CLASS) && elm_widget_access_highlight_in_theme_get(obj))
10583 // evas_object_event_callback_add(obj, EVAS_CALLBACK_MOVE, _elm_win_accessibility_highlight_obj_move, sd->obj);
10584 // evas_object_event_callback_add(obj, EVAS_CALLBACK_RESIZE, _elm_win_accessibility_highlight_obj_resize, sd->obj);
10587 // static void _elm_win_accessibility_highlight_init(Efl_Ui_Win_Data *sd)
10589 // if (sd->accessibility_highlight.enabled) return;
10590 // sd->accessibility_highlight.enabled = EINA_TRUE;
10592 // sd->accessibility_highlight.fobj = edje_object_add(sd->evas);
10593 // elm_widget_theme_object_set(sd->obj, sd->accessibility_highlight.fobj, "access", "base", "default");
10597 // _elm_win_accessibility_highlight_visible_set(Efl_Ui_Win_Data *sd,
10598 // Eina_Bool visible)
10600 // Evas_Object *fobj = sd->accessibility_highlight.fobj;
10601 // Evas_Object *target = sd->accessibility_highlight.target;
10603 // if (!target) return;
10605 // if (efl_isa(target, ELM_WIDGET_CLASS) && elm_widget_access_highlight_in_theme_get(target))
10608 // elm_widget_signal_emit(target, "elm,action,access_highlight,show", "elm");
10610 // elm_widget_signal_emit(target, "elm,action,access_highlight,hide", "elm");
10615 // evas_object_show(fobj);
10617 // evas_object_hide(fobj);
10622 // _elm_win_accessibility_highlight_update(Efl_Ui_Win_Data *sd)
10624 // Evas_Coord x, y, w, h;
10625 // Evas_Object *target = sd->accessibility_highlight.target;
10626 // Evas_Object *fobj = sd->accessibility_highlight.fobj;
10628 // if (!target) return;
10629 // if (efl_isa(target, ELM_WIDGET_CLASS) && elm_widget_access_highlight_in_theme_get(target))
10632 // evas_object_geometry_get(target, &x, &y, &w, &h);
10633 // evas_object_move(fobj, x, y);
10634 // evas_object_resize(fobj, w, h);
10635 // evas_object_raise(fobj);
10639 // _elm_win_accessibility_highlight_target_set(Efl_Ui_Win_Data *sd, Evas_Object *target)
10641 // Evas_Object *clip, *fobj = sd->accessibility_highlight.fobj;
10643 // if (sd->accessibility_highlight.target == target)
10646 // _elm_win_accessibility_highlight_visible_set(sd, EINA_FALSE);
10647 // _elm_win_accessibility_highlight_callbacks_del(sd);
10649 // sd->accessibility_highlight.target = target;
10650 // if (!target) return;
10652 // clip = evas_object_clip_get(target);
10653 // if (clip) evas_object_clip_set(fobj, clip);
10655 // _elm_win_accessibility_highlight_callbacks_add(sd);
10656 // _elm_win_accessibility_highlight_update(sd);
10657 // _elm_win_accessibility_highlight_visible_set(sd, EINA_TRUE);
10660 // static void _elm_win_accessibility_highlight_shutdown(Efl_Ui_Win_Data *sd)
10662 // if (!sd->accessibility_highlight.enabled) return;
10664 // _elm_win_accessibility_highlight_target_set(sd, NULL);
10665 // evas_object_del(sd->accessibility_highlight.fobj);
10666 // sd->accessibility_highlight.fobj = NULL;
10667 // sd->accessibility_highlight.enabled = EINA_FALSE;
10671 // _elm_win_accessibility_highlight_set(Evas_Object *win, Evas_Object *obj)
10673 // ELM_WIN_DATA_GET_OR_RETURN(win, sd);
10677 // _elm_win_accessibility_highlight_init(sd);
10678 // _elm_win_accessibility_highlight_target_set(sd, obj);
10681 // _elm_win_accessibility_highlight_shutdown(sd);
10685 // _elm_win_accessibility_highlight_get(Evas_Object *win)
10687 // ELM_WIN_DATA_GET_OR_RETURN(win, sd, NULL);
10688 // return sd->accessibility_highlight.target;
10696 elm_win_fake_canvas_set(Evas_Object *obj EINA_UNUSED, Ecore_Evas *oee EINA_UNUSED)
10698 ERR("Calling deprecrated function '%s'", __func__);
10702 elm_win_name_set(Evas_Object *obj, const char *name)
10704 ERR("Calling deprecrated function '%s'", __func__);
10705 efl_ui_win_name_set(obj, name);
10709 elm_win_type_set(Evas_Object *obj, Elm_Win_Type type)
10711 ERR("Calling deprecrated function '%s'", __func__);
10712 efl_ui_win_type_set(obj, _elm_win_type_to_efl_ui_win_type(type));
10716 elm_win_teamwork_uri_preload(Efl_Ui_Win *obj EINA_UNUSED, const char *uri EINA_UNUSED)
10718 ERR("Calling deprecrated function '%s'", __func__);
10722 elm_win_teamwork_uri_show(Efl_Ui_Win *obj EINA_UNUSED, const char *uri EINA_UNUSED)
10724 ERR("Calling deprecrated function '%s'", __func__);
10728 elm_win_teamwork_uri_hide(Efl_Ui_Win *obj EINA_UNUSED)
10730 ERR("Calling deprecrated function '%s'", __func__);
10734 elm_win_teamwork_uri_open(Efl_Ui_Win *obj EINA_UNUSED, const char *uri EINA_UNUSED)
10736 ERR("Calling deprecrated function '%s'", __func__);
10739 // TIZEN_ONLY(20160216) : elm_win_input_rect_set/add/subtract added
10741 elm_win_input_rect_set(Evas_Object *obj, Eina_Rectangle *input_rect)
10743 ELM_WIN_DATA_GET_OR_RETURN(obj, sd);
10744 TRAP(sd, input_rect_set, input_rect);
10748 elm_win_input_rect_add(Evas_Object *obj, Eina_Rectangle *input_rect)
10750 ELM_WIN_DATA_GET_OR_RETURN(obj, sd);
10751 TRAP(sd, input_rect_add, input_rect);
10755 elm_win_input_rect_subtract(Evas_Object *obj, Eina_Rectangle *input_rect)
10757 ELM_WIN_DATA_GET_OR_RETURN(obj, sd);
10758 TRAP(sd, input_rect_subtract, input_rect);
10762 // TIZEN_ONLY(20160617) : add elm_win_active_win_orientation_get
10764 elm_win_active_win_orientation_get(Evas_Object *obj)
10767 #ifdef HAVE_ELEMENTARY_WL2
10768 Ecore_Wl2_Window *win = NULL;
10771 ELM_WIN_DATA_GET_OR_RETURN(obj, sd, angle);
10775 if (win) angle = ecore_wl2_window_active_angle_get(win);
10781 //////////////////////////////////////////////////////////////////
10782 // TIZEN_ONLY(20150722): added signal for aux_hint(auxiliary hint)
10783 EAPI const Eina_List *
10784 elm_win_aux_hints_supported_get(const Evas_Object *obj)
10786 ELM_WIN_DATA_GET_OR_RETURN(obj, sd, NULL);
10787 return ecore_evas_aux_hints_supported_get(sd->ee);
10791 elm_win_aux_hint_add(Evas_Object *obj, const char *hint, const char *val)
10793 ELM_WIN_DATA_GET_OR_RETURN(obj, sd, -1);
10794 // TIZEN_ONLY(20170212): pend rotation until app set rotation
10795 if ((hint) && (!strncmp(hint, "wm.policy.win.rot.render.nopending", strlen(hint))))
10797 return _elm_win_wm_pending_rotation_set(obj, hint, val);
10800 return ecore_evas_aux_hint_add(sd->ee, hint, val);
10804 elm_win_aux_hint_del(Evas_Object *obj,
10807 ELM_WIN_DATA_GET_OR_RETURN(obj, sd, EINA_FALSE);
10808 return ecore_evas_aux_hint_del(sd->ee, id);
10812 elm_win_aux_hint_val_set(Evas_Object *obj, const int id, const char *val)
10814 ELM_WIN_DATA_GET_OR_RETURN(obj, sd, EINA_FALSE);
10815 return ecore_evas_aux_hint_val_set(sd->ee, id, val);
10819 elm_win_aux_hint_val_get(Evas_Object *obj, int id)
10821 ELM_WIN_DATA_GET_OR_RETURN(obj, sd, NULL);
10822 return ecore_evas_aux_hint_val_get(sd->ee, id);
10826 elm_win_aux_hint_id_get(Evas_Object *obj, const char *hint)
10828 ELM_WIN_DATA_GET_OR_RETURN(obj, sd, -1);
10829 return ecore_evas_aux_hint_id_get(sd->ee, hint);
10833 elm_win_aux_msg_key_get(Evas_Object *obj,
10834 Elm_Win_Aux_Message *msg)
10836 ELM_WIN_DATA_GET_OR_RETURN(obj, sd, NULL);
10838 if (!msg) return NULL;
10843 elm_win_aux_msg_val_get(Evas_Object *obj,
10844 Elm_Win_Aux_Message *msg)
10846 ELM_WIN_DATA_GET_OR_RETURN(obj, sd, NULL);
10848 if (!msg) return NULL;
10852 EAPI const Eina_List *
10853 elm_win_aux_msg_options_get(Evas_Object *obj,
10854 Elm_Win_Aux_Message *msg)
10856 ELM_WIN_DATA_GET_OR_RETURN(obj, sd, NULL);
10858 if (!msg) return NULL;
10859 return msg->options;
10861 // END of TIZEN_ONLY(20150722): added signal for aux_hint(auxiliary hint)
10862 //////////////////////////////////////////////////////////////////
10864 /***********************************************************
10865 * TIZEN_ONLY(20180117): Override Paragraph Direction APIs *
10866 ***********************************************************/
10868 _efl_ui_win_efl_canvas_object_paragraph_direction_set(Eo *obj, Efl_Ui_Win_Data *sd, Efl_Text_Bidirectional_Type dir)
10870 efl_canvas_object_paragraph_direction_set(sd->legacy.edje, dir);
10872 efl_canvas_object_paragraph_direction_set(efl_super(obj, MY_CLASS), dir);
10878 /* What here follows is code that implements the glue between ecore evas and efl_ui* side */
10881 Eina_Bool currently_inside;
10884 static inline Efl_Ui_Cnp_Buffer
10885 _ui_buffer_get(Ecore_Evas_Selection_Buffer buffer)
10887 if (buffer == ECORE_EVAS_SELECTION_BUFFER_SELECTION_BUFFER)
10888 return EFL_UI_CNP_BUFFER_SELECTION;
10889 else if (buffer == ECORE_EVAS_SELECTION_BUFFER_COPY_AND_PASTE_BUFFER)
10890 return EFL_UI_CNP_BUFFER_COPY_AND_PASTE;
10896 _register_selection_changed(Efl_Ui_Selection *selection)
10898 ELM_WIN_DATA_GET(efl_provider_find(selection, EFL_UI_WIN_CLASS), pd);
10900 eina_array_push(pd->planned_changes, selection);
10904 _remove_object(void *data, void *gdata)
10912 _selection_changed_cb(Ecore_Evas *ee, unsigned int seat, Ecore_Evas_Selection_Buffer selection)
10914 Efl_Ui_Win_Data *pd = _elm_win_associate_get(ee);
10915 Efl_Ui_Wm_Selection_Changed changed = {
10917 .buffer = _ui_buffer_get(selection),
10918 .caused_by = eina_array_count(pd->planned_changes) > 0 ? eina_array_data_get(pd->planned_changes, 0) : NULL,
10921 for (unsigned int i = 0; i < eina_array_count(pd->selection_changed); ++i)
10923 Eo *obj = eina_array_data_get(pd->selection_changed, i);
10925 efl_event_callback_call(obj, EFL_UI_SELECTION_EVENT_WM_SELECTION_CHANGED, &changed);
10928 if (changed.caused_by)
10929 eina_array_remove(pd->planned_changes, _remove_object, changed.caused_by);
10933 _motion_cb(Ecore_Evas *ee, unsigned int seat, Eina_Position2D p)
10935 Efl_Ui_Win_Data *pd = _elm_win_associate_get(ee);
10936 // TIZEN_ONLY(20211208): keep the order of enter and leave event
10938 for (unsigned int i = 0; i < eina_inarray_count(pd->drop_target); ++i)
10940 Ui_Dnd_Target *target = eina_inarray_nth(pd->drop_target, i);
10941 Eina_Rect rect = efl_gfx_entity_geometry_get(target->obj);
10942 Eina_Bool inside = eina_rectangle_coords_inside(&rect.rect, p.x, p.y);
10943 Efl_Ui_Drop_Event ev = {p, seat, ecore_evas_drop_available_types_get(ee, seat)};
10945 if (target->currently_inside && !inside)
10947 target->currently_inside = EINA_FALSE;
10948 efl_event_callback_call(target->obj, EFL_UI_DND_EVENT_DROP_LEFT, &ev);
10949 ecore_evas_dnd_mark_motion_used(ee, seat);
10951 else if (!target->currently_inside && inside)
10953 target->currently_inside = EINA_TRUE;
10954 efl_event_callback_call(target->obj, EFL_UI_DND_EVENT_DROP_ENTERED, &ev);
10955 ecore_evas_dnd_mark_motion_used(ee, seat);
10957 else if (target->currently_inside && inside)
10959 efl_event_callback_call(target->obj, EFL_UI_DND_EVENT_DROP_POSITION_CHANGED, &ev);
10960 ecore_evas_dnd_mark_motion_used(ee, seat);
10962 eina_accessor_free(ev.available_types);
10965 for (unsigned int i = 0; i < eina_inarray_count(pd->drop_target); ++i)
10967 Ui_Dnd_Target *target = eina_inarray_nth(pd->drop_target, i);
10968 Eina_Rect rect = efl_gfx_entity_geometry_get(target->obj);
10969 Eina_Bool inside = eina_rectangle_coords_inside(&rect.rect, p.x, p.y);
10970 Efl_Ui_Drop_Event ev = {p, seat, ecore_evas_drop_available_types_get(ee, seat)};
10972 if (target->currently_inside && !inside)
10974 target->currently_inside = EINA_FALSE;
10975 efl_event_callback_call(target->obj, EFL_UI_DND_EVENT_DROP_LEFT, &ev);
10976 ecore_evas_dnd_mark_motion_used(ee, seat);
10980 for (unsigned int i = 0; i < eina_inarray_count(pd->drop_target); ++i)
10982 Ui_Dnd_Target *target = eina_inarray_nth(pd->drop_target, i);
10983 Eina_Rect rect = efl_gfx_entity_geometry_get(target->obj);
10984 Eina_Bool inside = eina_rectangle_coords_inside(&rect.rect, p.x, p.y);
10985 Efl_Ui_Drop_Event ev = {p, seat, ecore_evas_drop_available_types_get(ee, seat)};
10987 if (!target->currently_inside && inside)
10989 target->currently_inside = EINA_TRUE;
10990 efl_event_callback_call(target->obj, EFL_UI_DND_EVENT_DROP_ENTERED, &ev);
10991 ecore_evas_dnd_mark_motion_used(ee, seat);
10993 else if (target->currently_inside && inside)
10995 efl_event_callback_call(target->obj, EFL_UI_DND_EVENT_DROP_POSITION_CHANGED, &ev);
10996 ecore_evas_dnd_mark_motion_used(ee, seat);
10998 eina_accessor_free(ev.available_types);
11004 _enter_state_change_cb(Ecore_Evas *ee, unsigned int seat EINA_UNUSED, Eina_Position2D p, Eina_Bool move_inside)
11006 Efl_Ui_Win_Data *pd = _elm_win_associate_get(ee);
11007 for (unsigned int i = 0; i < eina_inarray_count(pd->drop_target); ++i)
11009 Ui_Dnd_Target *target = eina_inarray_nth(pd->drop_target, i);
11010 Eina_Rect rect = efl_gfx_entity_geometry_get(target->obj);
11011 Eina_Bool inside = eina_rectangle_coords_inside(&rect.rect, p.x, p.y);
11012 Efl_Ui_Drop_Event ev = {p, seat, ecore_evas_drop_available_types_get(ee, seat)};
11014 if (inside && move_inside)
11016 target->currently_inside = EINA_TRUE;
11017 // TIZEN_ONLY(20211208): keep the order of enter and leave event
11018 //efl_event_callback_call(target->obj, EFL_UI_DND_EVENT_DROP_ENTERED, &ev);
11021 else if (!move_inside && !target->currently_inside)
11023 target->currently_inside = EINA_FALSE;
11024 // TIZEN_ONLY(20211208): keep the order of enter and leave event
11025 //efl_event_callback_call(target->obj, EFL_UI_DND_EVENT_DROP_LEFT, &ev);
11032 _drop_cb(Ecore_Evas *ee, unsigned int seat EINA_UNUSED, Eina_Position2D p, const char *action)
11034 Eina_List *itr, *top_objects_list = NULL;
11035 Efl_Ui_Win_Data *pd = _elm_win_associate_get(ee);
11036 Eina_Array *tmp = eina_array_new(10);
11039 for (unsigned int i = 0; i < eina_inarray_count(pd->drop_target); ++i)
11041 Ui_Dnd_Target *target = eina_inarray_nth(pd->drop_target, i);
11042 Eina_Rect rect = efl_gfx_entity_geometry_get(target->obj);
11043 Eina_Bool inside = eina_rectangle_coords_inside(&rect.rect, p.x, p.y);
11047 EINA_SAFETY_ON_FALSE_GOTO(target->currently_inside, end);
11048 eina_array_push(tmp, target->obj);
11049 // TIZEN_ONLY(20211208): keep the order of enter and leave event
11050 target->currently_inside = EINA_FALSE;
11055 /* We retrieve the (non-smart) objects pointed by (px, py) */
11056 top_objects_list = evas_tree_objects_at_xy_get(ecore_evas_get(ee), NULL, p.x, p.y);
11057 /* We walk on this list from the last because if the list contains more than one
11058 * element, all but the last will repeat events. The last one can repeat events
11059 * or not. Anyway, this last one is the first that has to be taken into account
11060 * for the determination of the drop target.
11062 EINA_LIST_REVERSE_FOREACH(top_objects_list, itr, top_obj)
11064 Evas_Object *object = top_obj;
11065 /* We search for the dropable data into the object. If not found, we search into its parent.
11066 * For example, if a button is a drop target, the first object will be an (internal) image.
11067 * The drop target is attached to the button, i.e to image's parent. That's why we need to
11068 * walk on the parents until NULL.
11069 * If we find this dropable data, we found our drop target.
11073 unsigned int out_idx;
11074 if (!eina_array_find(tmp, object, &out_idx))
11076 object = evas_object_smart_parent_get(object);
11080 Efl_Ui_Drop_Dropped_Event ev = {{p, seat, ecore_evas_drop_available_types_get(ee, seat)}, action};
11081 efl_event_callback_call(object, EFL_UI_DND_EVENT_DROP_DROPPED, &ev);
11087 eina_list_free(top_objects_list);
11088 eina_array_free(tmp);
11092 _ee_backbone_init(Efl_Ui_Win *obj EINA_UNUSED, Efl_Ui_Win_Data *pd)
11094 pd->selection_changed = eina_array_new(1);
11095 pd->drop_target = eina_inarray_new(sizeof(Ui_Dnd_Target), 1);
11097 ecore_evas_callback_selection_changed_set(pd->ee, _selection_changed_cb);
11098 ecore_evas_callback_drop_drop_set(pd->ee, _drop_cb);
11099 ecore_evas_callback_drop_motion_set(pd->ee, _motion_cb);
11100 ecore_evas_callback_drop_state_changed_set(pd->ee, _enter_state_change_cb);
11104 _ee_backbone_shutdown(Efl_Ui_Win *obj EINA_UNUSED, Efl_Ui_Win_Data *pd)
11106 ecore_evas_callback_selection_changed_set(pd->ee, NULL);
11107 ecore_evas_callback_drop_drop_set(pd->ee, NULL);
11108 ecore_evas_callback_drop_motion_set(pd->ee, NULL);
11109 ecore_evas_callback_drop_state_changed_set(pd->ee, NULL);
11111 eina_array_free(pd->selection_changed);
11112 pd->selection_changed = NULL;
11113 eina_inarray_free(pd->drop_target);
11114 pd->drop_target = NULL;
11119 _remove(void *data, void *gdata)
11127 efl_ui_win_get(Evas_Object *obj)
11129 Efl_Ui_Win *win = efl_provider_find(obj, MY_CLASS);
11132 Evas *e = evas_object_evas_get(obj);
11133 Ecore_Evas *ee = ecore_evas_ecore_evas_get(e);
11135 win = ecore_evas_data_get(ee, "elm_win");
11137 EINA_SAFETY_ON_NULL_RETURN_VAL(win, NULL);
11141 static Efl_Ui_Win_Data*
11142 _fetch_win_data_from_arbitary_obj(Efl_Canvas_Object *obj)
11144 Efl_Ui_Win *win = efl_ui_win_get(obj);
11145 EINA_SAFETY_ON_NULL_RETURN_VAL(win, NULL);
11146 Efl_Ui_Win_Data *pd = efl_data_scope_safe_get(win, MY_CLASS);
11147 EINA_SAFETY_ON_NULL_RETURN_VAL(pd, NULL);
11152 _drop_event_register(Eo *obj)
11154 Ui_Dnd_Target target = {obj, EINA_FALSE};
11155 Efl_Ui_Win_Data *pd = _fetch_win_data_from_arbitary_obj(obj);
11158 eina_inarray_push(pd->drop_target, &target);
11162 _drop_event_unregister(Eo *obj)
11166 Efl_Ui_Win_Data *pd = _fetch_win_data_from_arbitary_obj(obj);
11169 for (unsigned int i = 0; i < eina_inarray_count(pd->drop_target); ++i)
11171 Ui_Dnd_Target *target = eina_inarray_nth(pd->drop_target, i);
11172 if (target->obj == obj)
11175 target->currently_inside = EINA_FALSE;
11180 eina_inarray_remove_at(pd->drop_target, idx);
11184 _selection_changed_event_register(Eo *obj)
11186 Efl_Ui_Win_Data *pd = _fetch_win_data_from_arbitary_obj(obj);
11189 eina_array_push(pd->selection_changed, obj);
11192 _selection_changed_event_unregister(Eo *obj)
11194 Efl_Ui_Win_Data *pd = _fetch_win_data_from_arbitary_obj(obj);
11197 eina_array_remove(pd->selection_changed, _remove, obj);
11199 /* Internal EO APIs and hidden overrides */
11201 ELM_WIDGET_KEY_DOWN_DEFAULT_IMPLEMENT(efl_ui_win, Efl_Ui_Win_Data)
11203 /* Internal EO APIs and hidden overrides */
11205 #define EFL_UI_WIN_EXTRA_OPS \
11206 EFL_CANVAS_GROUP_ADD_DEL_OPS(efl_ui_win), \
11207 ELM_PART_CONTENT_DEFAULT_OPS(efl_ui_win), \
11208 EFL_OBJECT_OP_FUNC(efl_canvas_object_legacy_ctor, _efl_ui_win_efl_canvas_object_legacy_ctor)
11210 #include "efl_ui_win.eo.c"
11213 _efl_ui_win_legacy_class_constructor(Efl_Class *klass)
11215 evas_smart_legacy_type_register(MY_CLASS_NAME_LEGACY, klass);
11219 _efl_ui_win_legacy_efl_object_finalize(Eo *obj, void *pd EINA_UNUSED)
11221 obj = efl_finalize(efl_super(obj, EFL_UI_WIN_LEGACY_CLASS));
11222 efl_canvas_object_type_set(obj, MY_CLASS_NAME_LEGACY);
11227 Efl_Object *_efl_ui_win_legacy_efl_object_finalize(Eo *obj, void *pd);
11231 _efl_ui_win_legacy_class_initializer(Efl_Class *klass)
11233 const Efl_Object_Ops *opsp = NULL;
11235 const Efl_Object_Property_Reflection_Ops *ropsp = NULL;
11237 #ifndef EFL_UI_WIN_LEGACY_EXTRA_OPS
11238 #define EFL_UI_WIN_LEGACY_EXTRA_OPS
11241 EFL_OPS_DEFINE(ops,
11242 EFL_OBJECT_OP_FUNC(efl_finalize, _efl_ui_win_legacy_efl_object_finalize),
11243 EFL_UI_WIN_LEGACY_EXTRA_OPS
11247 return efl_class_functions_set(klass, opsp, ropsp);
11250 static const Efl_Class_Description _efl_ui_win_legacy_class_desc = {
11252 "Efl.Ui.Win_Legacy",
11253 EFL_CLASS_TYPE_REGULAR,
11255 _efl_ui_win_legacy_class_initializer,
11256 _efl_ui_win_legacy_class_constructor,
11260 EFL_DEFINE_CLASS(efl_ui_win_legacy_class_get, &_efl_ui_win_legacy_class_desc, EFL_UI_WIN_CLASS, EFL_UI_LEGACY_INTERFACE, NULL);
11264 elm_win_add(Evas_Object *parent, const char *name, Elm_Win_Type type)
11266 //TIZEN_ONLY(20160628): Add Performance log for cold booting
11267 traceTaskStart("elm_win_add");
11269 const Efl_Class *klass = EFL_UI_WIN_LEGACY_CLASS;
11271 //TIZEN_ONLY(20161202): Temporary code - Apply mirroring in elm_win_add()
11272 if (_elm_config && _elm_config->language_auto_mirrored)
11274 if (!strcmp(E_("default:LTR"), "default:RTL"))
11275 elm_config_mirrored_set(EINA_TRUE);
11277 elm_config_mirrored_set(EINA_FALSE);
11281 switch ((int) type)
11283 case ELM_WIN_INLINED_IMAGE:
11284 klass = EFL_UI_WIN_INLINED_LEGACY_CLASS;
11286 case ELM_WIN_SOCKET_IMAGE:
11287 klass = EFL_UI_WIN_SOCKET_LEGACY_CLASS;
11292 // TIZEN_ONLY(20160218): Improve launching performance.
11293 if (_precreated_win_obj)
11295 ELM_WIN_DATA_GET(_precreated_win_obj, sd);
11299 if ((!parent) || (sd->parent == parent))
11301 Evas_Object *tmp = _precreated_win_obj;
11302 TRAP(sd, name_class_set, name, _elm_appname);
11303 //TIZEN_ONLY(20180131):Added code to set the window title
11304 TRAP(sd, title_set, sd->title ? sd->title : name);
11305 _precreated_win_obj = NULL;
11306 if (sd->type != type)
11307 efl_ui_win_type_set(tmp, type);
11308 INF("Return precreated obj(%p).", tmp);
11310 /* TIZEN_ONLY(20180117): Apply paragraph direction according to locale */
11311 if (!strcmp(E_("default:LTR"), "default:RTL"))
11312 efl_canvas_object_paragraph_direction_set(tmp, EVAS_BIDI_DIRECTION_ANY_RTL);
11314 efl_canvas_object_paragraph_direction_set(tmp, EVAS_BIDI_DIRECTION_LTR);
11323 Evas_Object *obj = elm_legacy_add(klass, parent,
11324 efl_ui_win_name_set(efl_added, name),
11325 efl_ui_win_type_set(efl_added, (Efl_Ui_Win_Type)type));
11327 //TIZEN_ONLY(20160628): Add Performance log for cold booting
11335 elm_win_fake_add(Ecore_Evas *ee)
11337 return elm_legacy_add(EFL_UI_WIN_LEGACY_CLASS, NULL,
11338 _fake_canvas_set(efl_added, ee),
11339 efl_ui_win_name_set(efl_added, NULL),
11340 efl_ui_win_type_set(efl_added, EFL_UI_WIN_TYPE_FAKE));
11344 elm_win_util_standard_add(const char *name, const char *title)
11348 traceTaskStart("win_standard_add");
11350 // TIZEN_ONLY(20180518): apply precreated window
11351 win = elm_win_add(NULL, name, ELM_WIN_BASIC);
11352 if (!win) return NULL;
11354 efl_text_set(win, title);
11356 win = elm_legacy_add(EFL_UI_WIN_LEGACY_CLASS, NULL,
11357 efl_text_set(efl_added, title),
11358 efl_ui_win_name_set(efl_added, name),
11359 efl_ui_win_type_set(efl_added, EFL_UI_WIN_TYPE_BASIC));
11360 if (!win) return NULL;
11363 _elm_win_standard_init(win);
11371 elm_win_util_dialog_add(Evas_Object *parent, const char *name, const char *title)
11375 win = elm_legacy_add(EFL_UI_WIN_LEGACY_CLASS, parent,
11376 efl_text_set(efl_added, title),
11377 efl_ui_win_name_set(efl_added, name),
11378 efl_ui_win_type_set(efl_added, EFL_UI_WIN_TYPE_DIALOG_BASIC));
11379 if (!win) return NULL;
11381 _elm_win_standard_init(win);
11386 elm_win_frontbuffer_add(Evas_Object *parent, const char *name, const char *title, Elm_Win_Type type)
11388 Evas_Object *win = NULL;
11390 win = elm_legacy_add(EFL_UI_WIN_LEGACY_CLASS, parent,
11391 efl_text_set(efl_added, title),
11392 efl_ui_win_name_set(efl_added, name),
11393 efl_ui_win_type_set(efl_added, (Elm_Win_Type)type),
11394 efl_ui_win_use_frontbuffer_set(efl_added, EINA_TRUE));
11396 _elm_win_standard_init(win);
11401 elm_win_keyboard_mode_set(Evas_Object *obj, Elm_Win_Keyboard_Mode mode)
11403 efl_ui_win_keyboard_mode_set(obj, (Efl_Ui_Win_Keyboard_Mode)mode);
11406 EAPI Elm_Win_Keyboard_Mode
11407 elm_win_keyboard_mode_get(const Evas_Object *obj)
11409 return (Elm_Win_Keyboard_Mode)efl_ui_win_keyboard_mode_get(obj);
11413 elm_win_screen_constrain_set(Evas_Object *obj, Eina_Bool constrain)
11415 efl_ui_win_screen_constrain_set(obj, constrain);
11419 elm_win_screen_constrain_get(const Evas_Object *obj)
11421 return efl_ui_win_screen_constrain_get(obj);
11425 elm_win_prop_focus_skip_set(Evas_Object *obj, Eina_Bool skip)
11427 efl_ui_win_prop_focus_skip_set(obj, skip);
11431 elm_win_autohide_set(Evas_Object *obj, Eina_Bool autohide)
11433 efl_ui_win_autohide_set(obj, autohide);
11437 elm_win_autohide_get(const Evas_Object *obj)
11439 return efl_ui_win_autohide_get(obj);
11443 elm_win_exit_on_close_set(Evas_Object *obj, const Eina_Value *exit_code)
11445 efl_ui_win_exit_on_close_set(obj, exit_code);
11448 EAPI const Eina_Value *
11449 elm_win_exit_on_close_get(const Evas_Object *obj)
11451 return efl_ui_win_exit_on_close_get(obj);
11455 elm_win_icon_object_set(Evas_Object *obj, Evas_Object *icon)
11457 efl_ui_win_icon_object_set(obj, icon);
11460 EAPI const Evas_Object *
11461 elm_win_icon_object_get(const Evas_Object *obj)
11463 return efl_ui_win_icon_object_get(obj);
11467 elm_win_iconified_set(Evas_Object *obj, Eina_Bool iconified)
11469 efl_ui_win_minimized_set(obj, iconified);
11473 elm_win_iconified_get(const Evas_Object *obj)
11475 return efl_ui_win_minimized_get(obj);
11479 elm_win_maximized_set(Evas_Object *obj, Eina_Bool maximized)
11481 efl_ui_win_maximized_set(obj, maximized);
11485 elm_win_maximized_get(const Evas_Object *obj)
11487 return efl_ui_win_maximized_get(obj);
11491 elm_win_fullscreen_set(Evas_Object *obj, Eina_Bool fullscreen)
11493 efl_ui_win_fullscreen_set(obj, fullscreen);
11497 elm_win_fullscreen_get(const Evas_Object *obj)
11499 return efl_ui_win_fullscreen_get(obj);
11503 elm_win_sticky_set(Evas_Object *obj, Eina_Bool sticky)
11505 efl_ui_win_sticky_set(obj, sticky);
11509 elm_win_sticky_get(const Evas_Object *obj)
11511 return efl_ui_win_sticky_get(obj);
11515 elm_win_noblank_set(Evas_Object *obj, Eina_Bool noblank)
11517 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
11518 EINA_SAFETY_ON_NULL_RETURN(sd);
11519 noblank = !!noblank;
11520 if (sd->noblank == noblank) return;
11521 sd->noblank = noblank;
11522 _win_noblank_eval();
11526 elm_win_noblank_get(const Evas_Object *obj)
11528 Efl_Ui_Win_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
11529 EINA_SAFETY_ON_NULL_RETURN_VAL(sd, EINA_FALSE);
11530 return sd->noblank;
11534 elm_win_borderless_set(Evas_Object *obj, Eina_Bool borderless)
11536 efl_ui_win_borderless_set(obj, borderless);
11540 elm_win_borderless_get(const Evas_Object *obj)
11542 return efl_ui_win_borderless_get(obj);
11546 elm_win_role_set(Evas_Object *obj, const char *role)
11548 efl_ui_win_role_set(obj, role);
11552 elm_win_role_get(const Evas_Object *obj)
11554 return efl_ui_win_role_get(obj);
11558 elm_win_name_get(const Evas_Object *obj)
11560 return efl_ui_win_name_get(obj);
11564 elm_win_type_get(const Evas_Object *obj)
11566 if (!(efl_isa(obj, EFL_UI_WIN_CLASS) ||
11567 efl_isa(obj, EFL_UI_WIN_LEGACY_CLASS) ||
11568 efl_isa(obj, EFL_UI_WIN_INLINED_CLASS))) return ELM_WIN_UNKNOWN;
11570 return _efl_ui_win_type_to_elm_win_type(efl_ui_win_type_get(obj));
11574 elm_win_accel_preference_get(const Evas_Object *obj)
11576 return efl_ui_win_accel_preference_get(obj);
11579 //TIZEN_ONLY(20230302): Added frontbuffer API
11581 elm_win_use_frontbuffer_set(Evas_Object *obj, Eina_Bool use_frontbuffer)
11583 return efl_ui_win_use_frontbuffer_set(obj, use_frontbuffer);
11586 EAPI const Eina_Bool
11587 elm_win_use_frontbuffer_get(const Evas_Object *obj)
11589 return efl_ui_win_use_frontbuffer_get(obj);
11594 elm_win_alpha_set(Evas_Object *obj, Eina_Bool alpha)
11596 efl_ui_win_alpha_set(obj, alpha);
11600 elm_win_alpha_get(const Evas_Object *obj)
11602 return efl_ui_win_alpha_get(obj);
11606 elm_win_activate(Evas_Object *obj)
11608 efl_ui_win_activate(obj);
11612 elm_win_center(Evas_Object *obj, Eina_Bool h, Eina_Bool v)
11614 efl_ui_win_center(obj, h, v);
11618 elm_win_move_resize_start(Evas_Object *obj, Elm_Win_Move_Resize_Mode mode)
11620 return efl_ui_win_move_resize_start(obj, (Efl_Ui_Win_Move_Resize_Mode)mode);
11624 elm_win_focus_highlight_animate_set(Efl_Ui_Win *obj, Eina_Bool animate)
11626 efl_ui_win_focus_highlight_animate_set(obj, animate);
11630 elm_win_focus_highlight_animate_get(const Efl_Ui_Win *obj)
11632 return efl_ui_win_focus_highlight_animate_get(obj);
11636 elm_win_focus_highlight_enabled_set(Efl_Ui_Win *obj, Eina_Bool enabled)
11638 efl_ui_win_focus_highlight_enabled_set(obj, enabled);
11642 elm_win_focus_highlight_enabled_get(const Efl_Ui_Win *obj)
11644 return efl_ui_win_focus_highlight_enabled_get(obj);
11648 elm_win_focus_highlight_style_set(Efl_Ui_Win *obj, const char *style)
11650 return efl_ui_win_focus_highlight_style_set(obj, style);
11654 elm_win_focus_highlight_style_get(const Efl_Ui_Win *obj)
11656 return efl_ui_win_focus_highlight_style_get(obj);
11659 EAPI Efl_Ui_Shared_Win_Data*
11660 efl_ui_win_shared_data_get(Efl_Ui_Win *obj)
11662 Efl_Ui_Win_Data *pd = efl_data_scope_safe_get(obj, MY_CLASS);
11663 EINA_SAFETY_ON_NULL_RETURN_VAL(pd, NULL);
11669 efl_ui_win_autodel_set(Efl_Ui_Win *obj, Eina_Bool autodel)
11671 elm_win_autodel_set(obj, autodel);
11675 efl_ui_win_autodel_get(const Efl_Ui_Win *obj)
11677 return elm_win_autodel_get(obj);
11680 // TIZEN_ONLY(20230125): add minimum/maximum sizes set API.
11682 elm_win_minimum_size_set(Elm_Win *obj, int w, int h)
11684 ELM_WIN_DATA_GET_OR_RETURN(obj, sd);
11685 if (sd->wl.win) ecore_wl2_window_minimum_size_set(sd->wl.win, w, h);
11689 elm_win_maximum_size_set(Elm_Win *obj, int w, int h)
11691 ELM_WIN_DATA_GET_OR_RETURN(obj, sd);
11692 if (sd->wl.win) ecore_wl2_window_maximum_size_set(sd->wl.win, w, h);