src/lib/elm_win.c

   1 #ifdef HAVE_CONFIG_H
   2 # include "elementary_config.h"
   3 #endif
   4
   5 #include <Elementary.h>
   6 #include <Elementary_Cursor.h>
   7
   8 #include "elm_priv.h"
   9 #include "elm_widget_menu.h"
  10
  11 EAPI Eo_Op ELM_OBJ_WIN_BASE_ID = EO_NOOP;
  12
  13 #define MY_CLASS ELM_OBJ_WIN_CLASS
  14
  15 #define MY_CLASS_NAME "Elm_Win"
  16 #define MY_CLASS_NAME_LEGACY "elm_win"
  17
  18 static const Elm_Win_Trap *trap = NULL;
  19
  20 #define TRAP(sd, name, ...)                                             \
  21   do                                                                    \
  22     {                                                                   \
  23        if ((!trap) || (!trap->name) ||                                  \
  24            ((trap->name) &&                                             \
  25             (trap->name(sd->trap_data, sd->obj, ## __VA_ARGS__)))) \
  26          ecore_evas_##name(sd->ee, ##__VA_ARGS__);                      \
  27     }                                                                   \
  28   while (0)
  29
  30 #define ELM_WIN_DATA_GET(o, sd) \
  31   Elm_Win_Smart_Data * sd = eo_data_scope_get(o, MY_CLASS)
  32
  33 #define ELM_WIN_DATA_GET_OR_RETURN(o, ptr)           \
  34   ELM_WIN_DATA_GET(o, ptr);                          \
  35   if (!ptr)                                          \
  36     {                                                \
  37        CRI("No widget data for object %p (%s)", \
  38                 o, evas_object_type_get(o));         \
  39        return;                                       \
  40     }
  41
  42 #define ELM_WIN_DATA_GET_OR_RETURN_VAL(o, ptr, val)  \
  43   ELM_WIN_DATA_GET(o, ptr);                          \
  44   if (!ptr)                                          \
  45     {                                                \
  46        CRI("No widget data for object %p (%s)", \
  47                 o, evas_object_type_get(o));         \
  48        return val;                                   \
  49     }
  50
  51 #define ELM_WIN_CHECK(obj)                                             \
  52   if (!obj || !eo_isa(obj, MY_CLASS)) \
  53     return
  54
  55 #define ENGINE_GET() (_elm_preferred_engine ? _elm_preferred_engine : (_elm_config->engine ? _elm_config->engine : ""))
  56 #define ENGINE_COMPARE(name) (!strcmp(ENGINE_GET(), name))
  57
  58 typedef struct _Elm_Win_Smart_Data Elm_Win_Smart_Data;
  59
  60 struct _Elm_Win_Smart_Data
  61 {
  62    Ecore_Evas           *ee;
  63    Evas                 *evas;
  64    Evas_Object          *parent; /* parent *window* object*/
  65    Evas_Object          *img_obj, *frame_obj;
  66    Evas_Object          *client_obj; /* rect representing the client */
  67    Evas_Object          *spacer_obj;
  68    Eo                   *layout;
  69    Eo                   *box;
  70    Evas_Object          *obj; /* The object itself */
  71 #ifdef HAVE_ELEMENTARY_X
  72    struct
  73    {
  74       Ecore_X_Window       xwin;
  75       Ecore_Event_Handler *client_message_handler;
  76       Ecore_Event_Handler *property_handler;
  77    } x;
  78 #endif
  79 #ifdef HAVE_ELEMENTARY_WAYLAND
  80    struct
  81    {
  82       Ecore_Wl_Window *win;
  83    } wl;
  84 #endif
  85
  86    Ecore_Job                     *deferred_resize_job;
  87    Ecore_Job                     *deferred_child_eval_job;
  88
  89    Elm_Win_Type                   type;
  90    Elm_Win_Keyboard_Mode          kbdmode;
  91    Elm_Win_Indicator_Mode         indmode;
  92    Elm_Win_Indicator_Opacity_Mode ind_o_mode;
  93    struct
  94    {
  95       const char  *info;
  96       Ecore_Timer *timer;
  97       int          repeat_count;
  98       int          shot_counter;
  99    } shot;
 100    int                            resize_location;
 101    int                           *autodel_clear, rot;
 102    struct
 103    {
 104       int x, y;
 105    } screen;
 106    struct
 107    {
 108       Ecore_Evas  *ee;
 109       Evas        *evas;
 110       Evas_Object *obj, *hot_obj;
 111       int          hot_x, hot_y;
 112    } pointer;
 113    struct
 114    {
 115       Evas_Object *fobj; /* focus highlight edje object */
 116
 117       struct
 118       {
 119          Evas_Object *target;
 120          Eina_Bool    visible : 1;
 121          Eina_Bool    in_theme: 1; /**< focus highlight is handled by theme.
 122                                      this is set true if edc data item "focus_highlight" is set to "on" during focus in callback. */
 123       } cur, prev;
 124
 125       const char  *style;
 126       Ecore_Job   *reconf_job;
 127
 128       Eina_Bool    enabled : 1;
 129       Eina_Bool    theme_changed : 1; /* set true when the focus theme is changed */
 130       Eina_Bool    animate : 1; /* set true when the focus highlight animate is enabled */
 131       Eina_Bool    animate_supported : 1; /* set true when the focus highlight animate is supported by theme */
 132       Eina_Bool    geometry_changed : 1;
 133    } focus_highlight;
 134
 135    Evas_Object *icon;
 136    const char  *title;
 137    const char  *icon_name;
 138    const char  *role;
 139
 140    Evas_Object *main_menu;
 141
 142    struct
 143    {
 144       const char  *name;
 145       const char **available_list;
 146       unsigned int count;
 147    } profile;
 148    struct
 149    {
 150       int          preferred_rot; /* indicates preferred rotation value, -1 means invalid. */
 151       int         *rots; /* indicates available rotations */
 152       unsigned int count; /* number of elements in available rotations */
 153       Eina_Bool    wm_supported : 1; /* set true when the window manager support window rotation */
 154       Eina_Bool    use : 1; /* set ture when application use window manager rotation. */
 155    } wm_rot;
 156
 157    void *trap_data;
 158
 159    double       aspect;
 160    int          size_base_w, size_base_h;
 161    int          size_step_w, size_step_h;
 162    int          norender;
 163    Eina_Bool    urgent : 1;
 164    Eina_Bool    modal : 1;
 165    Eina_Bool    demand_attention : 1;
 166    Eina_Bool    autodel : 1;
 167    Eina_Bool    constrain : 1;
 168    Eina_Bool    resizing : 1;
 169    Eina_Bool    iconified : 1;
 170    Eina_Bool    withdrawn : 1;
 171    Eina_Bool    sticky : 1;
 172    Eina_Bool    fullscreen : 1;
 173    Eina_Bool    maximized : 1;
 174    Eina_Bool    skip_focus : 1;
 175    Eina_Bool    floating : 1;
 176 };
 177
 178 static const char SIG_DELETE_REQUEST[] = "delete,request";
 179 static const char SIG_FOCUS_OUT[] = "focus,out"; // deprecated. use "focused" instead.
 180 static const char SIG_FOCUS_IN[] = "focus,in"; // deprecated. use "unfocused" instead.
 181 static const char SIG_MOVED[] = "moved";
 182 static const char SIG_WITHDRAWN[] = "withdrawn";
 183 static const char SIG_ICONIFIED[] = "iconified";
 184 static const char SIG_NORMAL[] = "normal";
 185 static const char SIG_STICK[] = "stick";
 186 static const char SIG_UNSTICK[] = "unstick";
 187 static const char SIG_FULLSCREEN[] = "fullscreen";
 188 static const char SIG_UNFULLSCREEN[] = "unfullscreen";
 189 static const char SIG_MAXIMIZED[] = "maximized";
 190 static const char SIG_UNMAXIMIZED[] = "unmaximized";
 191 static const char SIG_IOERR[] = "ioerr";
 192 static const char SIG_INDICATOR_PROP_CHANGED[] = "indicator,prop,changed";
 193 static const char SIG_ROTATION_CHANGED[] = "rotation,changed";
 194 static const char SIG_PROFILE_CHANGED[] = "profile,changed";
 195 static const char SIG_FOCUSED[] = "focused";
 196 static const char SIG_UNFOCUSED[] = "unfocused";
 197 static const char SIG_WM_ROTATION_CHANGED[] = "wm,rotation,changed";
 198
 199 static const Evas_Smart_Cb_Description _smart_callbacks[] = {
 200    {SIG_DELETE_REQUEST, ""},
 201    {SIG_FOCUS_OUT, ""},
 202    {SIG_FOCUS_IN, ""},
 203    {SIG_MOVED, ""},
 204    {SIG_WITHDRAWN, ""},
 205    {SIG_ICONIFIED, ""},
 206    {SIG_NORMAL, ""},
 207    {SIG_STICK, ""},
 208    {SIG_UNSTICK, ""},
 209    {SIG_FULLSCREEN, ""},
 210    {SIG_UNFULLSCREEN, ""},
 211    {SIG_MAXIMIZED, ""},
 212    {SIG_UNMAXIMIZED, ""},
 213    {SIG_IOERR, ""},
 214    {SIG_INDICATOR_PROP_CHANGED, ""},
 215    {SIG_ROTATION_CHANGED, ""},
 216    {SIG_PROFILE_CHANGED, ""},
 217    {SIG_FOCUSED, ""},
 218    {SIG_UNFOCUSED, ""},
 219    {SIG_WM_ROTATION_CHANGED, ""},
 220    {NULL, NULL}
 221 };
 222
 223 Eina_List *_elm_win_list = NULL;
 224 int _elm_win_deferred_free = 0;
 225
 226 static int _elm_win_count = 0;
 227
 228 static Eina_Bool _elm_win_auto_throttled = EINA_FALSE;
 229
 230 static Ecore_Job *_elm_win_state_eval_job = NULL;
 231
 232 static void
 233 _elm_win_on_resize_obj_changed_size_hints(void *data,
 234                                           Evas *e,
 235                                           Evas_Object *obj,
 236                                           void *event_info);
 237 static void
 238 _elm_win_img_callbacks_del(Evas_Object *obj, Evas_Object *imgobj);
 239
 240 #ifdef HAVE_ELEMENTARY_X
 241 static void _elm_win_xwin_update(Elm_Win_Smart_Data *sd);
 242 #endif
 243
 244 EAPI double _elm_startup_time = 0;
 245
 246 static void
 247 _elm_win_first_frame_do(void *data, Evas *e EINA_UNUSED, void *event_info EINA_UNUSED)
 248 {
 249    double end = ecore_time_unix_get();
 250    char *first = data;
 251
 252    switch (*first)
 253      {
 254       case 'A': abort();
 255       case 'E':
 256       case 'D': exit(-1);
 257       case 'T': fprintf(stderr, "Startup time: '%f' - '%f' = '%f' sec\n", end, _elm_startup_time, end - _elm_startup_time);
 258                 break;
 259      }
 260
 261    evas_event_callback_del_full(e, EVAS_CALLBACK_RENDER_POST, _elm_win_first_frame_do, data);
 262 }
 263
 264 static void
 265 _elm_win_state_eval(void *data EINA_UNUSED)
 266 {
 267    Eina_List *l;
 268    Evas_Object *obj;
 269    int _elm_win_count_shown = 0;
 270    int _elm_win_count_iconified = 0;
 271    int _elm_win_count_withdrawn = 0;
 272
 273    _elm_win_state_eval_job = NULL;
 274
 275    if (_elm_config->auto_norender_withdrawn)
 276      {
 277         EINA_LIST_FOREACH(_elm_win_list, l, obj)
 278           {
 279              if ((elm_win_withdrawn_get(obj)) ||
 280                  ((elm_win_iconified_get(obj) &&
 281                    (_elm_config->auto_norender_iconified_same_as_withdrawn))))
 282                {
 283                   if (!evas_object_data_get(obj, "__win_auto_norender"))
 284                     {
 285                        Evas *evas = evas_object_evas_get(obj);
 286
 287                        elm_win_norender_push(obj);
 288                        evas_object_data_set(obj, "__win_auto_norender", obj);
 289
 290                        if (_elm_config->auto_flush_withdrawn)
 291                          {
 292                             edje_file_cache_flush();
 293                             edje_collection_cache_flush();
 294                             evas_image_cache_flush(evas);
 295                             evas_font_cache_flush(evas);
 296                          }
 297                        if (_elm_config->auto_dump_withdrawn)
 298                          {
 299                             evas_render_dump(evas);
 300                          }
 301                     }
 302                }
 303              else
 304                {
 305                   if (evas_object_data_get(obj, "__win_auto_norender"))
 306                     {
 307                        elm_win_norender_pop(obj);
 308                        evas_object_data_del(obj, "__win_auto_norender");
 309                     }
 310                }
 311           }
 312      }
 313    if (((_elm_config->auto_throttle) &&
 314         (elm_policy_get(ELM_POLICY_THROTTLE) != ELM_POLICY_THROTTLE_NEVER)) ||
 315         (elm_policy_get(ELM_POLICY_THROTTLE) == ELM_POLICY_THROTTLE_HIDDEN_ALWAYS))
 316      {
 317         if (_elm_win_count == 0)
 318           {
 319              if (_elm_win_auto_throttled)
 320                {
 321                   ecore_throttle_adjust(-_elm_config->auto_throttle_amount);
 322                   _elm_win_auto_throttled = EINA_FALSE;
 323                }
 324           }
 325         else
 326           {
 327              EINA_LIST_FOREACH(_elm_win_list, l, obj)
 328                {
 329                   if (elm_win_withdrawn_get(obj))
 330                     _elm_win_count_withdrawn++;
 331                   else if (elm_win_iconified_get(obj))
 332                     _elm_win_count_iconified++;
 333                   else if (evas_object_visible_get(obj))
 334                     _elm_win_count_shown++;
 335                }
 336              if (_elm_win_count_shown <= 0)
 337                {
 338                   if (!_elm_win_auto_throttled)
 339                     {
 340                        ecore_throttle_adjust(_elm_config->auto_throttle_amount);
 341                        _elm_win_auto_throttled = EINA_TRUE;
 342                     }
 343                }
 344              else
 345                {
 346                   if (_elm_win_auto_throttled)
 347                     {
 348                        ecore_throttle_adjust(-_elm_config->auto_throttle_amount);
 349                        _elm_win_auto_throttled = EINA_FALSE;
 350                     }
 351                }
 352           }
 353      }
 354 }
 355
 356 static void
 357 _elm_win_state_eval_queue(void)
 358 {
 359    ecore_job_del(_elm_win_state_eval_job);
 360    _elm_win_state_eval_job = ecore_job_add(_elm_win_state_eval, NULL);
 361 }
 362
 363 // example shot spec (wait 0.1 sec then save as my-window.png):
 364 // ELM_ENGINE="shot:delay=0.1:file=my-window.png"
 365
 366 static double
 367 _shot_delay_get(Elm_Win_Smart_Data *sd)
 368 {
 369    char *p, *pd;
 370    char *d = strdup(sd->shot.info);
 371
 372    if (!d) return 0.5;
 373    for (p = (char *)sd->shot.info; *p; p++)
 374      {
 375         if (!strncmp(p, "delay=", 6))
 376           {
 377              double v;
 378
 379              for (pd = d, p += 6; (*p) && (*p != ':'); p++, pd++)
 380                {
 381                   *pd = *p;
 382                }
 383              *pd = 0;
 384              v = _elm_atof(d);
 385              free(d);
 386              return v;
 387           }
 388      }
 389    free(d);
 390
 391    return 0.5;
 392 }
 393
 394 static char *
 395 _shot_file_get(Elm_Win_Smart_Data *sd)
 396 {
 397    char *p;
 398    char *tmp = strdup(sd->shot.info);
 399    char *repname = NULL;
 400
 401    if (!tmp) return NULL;
 402
 403    for (p = (char *)sd->shot.info; *p; p++)
 404      {
 405         if (!strncmp(p, "file=", 5))
 406           {
 407              strcpy(tmp, p + 5);
 408              if (!sd->shot.repeat_count) return tmp;
 409              else
 410                {
 411                   char *dotptr = strrchr(tmp, '.');
 412                   if (dotptr)
 413                     {
 414                        size_t size = sizeof(char) * (strlen(tmp) + 16);
 415                        repname = malloc(size);
 416                        strncpy(repname, tmp, dotptr - tmp);
 417                        snprintf(repname + (dotptr - tmp), size -
 418                                 (dotptr - tmp), "%03i",
 419                                 sd->shot.shot_counter + 1);
 420                        strcat(repname, dotptr);
 421                        free(tmp);
 422                        return repname;
 423                     }
 424                }
 425           }
 426      }
 427    free(tmp);
 428    if (!sd->shot.repeat_count) return strdup("out.png");
 429
 430    repname = malloc(sizeof(char) * 24);
 431    snprintf(repname, sizeof(char) * 24, "out%03i.png",
 432             sd->shot.shot_counter + 1);
 433
 434    return repname;
 435 }
 436
 437 static int
 438 _shot_repeat_count_get(Elm_Win_Smart_Data *sd)
 439 {
 440    char *p, *pd;
 441    char *d = strdup(sd->shot.info);
 442
 443    if (!d) return 0;
 444    for (p = (char *)sd->shot.info; *p; p++)
 445      {
 446         if (!strncmp(p, "repeat=", 7))
 447           {
 448              int v;
 449
 450              for (pd = d, p += 7; (*p) && (*p != ':'); p++, pd++)
 451                {
 452                   *pd = *p;
 453                }
 454              *pd = 0;
 455              v = atoi(d);
 456              if (v < 0) v = 0;
 457              if (v > 1000) v = 999;
 458              free(d);
 459              return v;
 460           }
 461      }
 462    free(d);
 463
 464    return 0;
 465 }
 466
 467 static char *
 468 _shot_key_get(Elm_Win_Smart_Data *sd EINA_UNUSED)
 469 {
 470    return NULL;
 471 }
 472
 473 static char *
 474 _shot_flags_get(Elm_Win_Smart_Data *sd EINA_UNUSED)
 475 {
 476    return NULL;
 477 }
 478
 479 static void
 480 _shot_do(Elm_Win_Smart_Data *sd)
 481 {
 482    Ecore_Evas *ee;
 483    Evas_Object *o;
 484    unsigned int *pixels;
 485    int w, h;
 486    char *file, *key, *flags;
 487
 488    ecore_evas_manual_render(sd->ee);
 489    pixels = (void *)ecore_evas_buffer_pixels_get(sd->ee);
 490    if (!pixels) return;
 491
 492    ecore_evas_geometry_get(sd->ee, NULL, NULL, &w, &h);
 493    if ((w < 1) || (h < 1)) return;
 494
 495    file = _shot_file_get(sd);
 496    if (!file) return;
 497
 498    key = _shot_key_get(sd);
 499    flags = _shot_flags_get(sd);
 500    ee = ecore_evas_buffer_new(1, 1);
 501    o = evas_object_image_add(ecore_evas_get(ee));
 502    evas_object_image_alpha_set(o, ecore_evas_alpha_get(sd->ee));
 503    evas_object_image_size_set(o, w, h);
 504    evas_object_image_data_set(o, pixels);
 505    if (!evas_object_image_save(o, file, key, flags))
 506      {
 507         ERR("Cannot save window to '%s' (key '%s', flags '%s')",
 508             file, key, flags);
 509      }
 510    free(file);
 511    free(key);
 512    free(flags);
 513    ecore_evas_free(ee);
 514    if (sd->shot.repeat_count) sd->shot.shot_counter++;
 515 }
 516
 517 static Eina_Bool
 518 _shot_delay(void *data)
 519 {
 520    ELM_WIN_DATA_GET(data, sd);
 521
 522    _shot_do(sd);
 523    if (sd->shot.repeat_count)
 524      {
 525         int remainshot = (sd->shot.repeat_count - sd->shot.shot_counter);
 526         if (remainshot > 0) return EINA_TRUE;
 527      }
 528    sd->shot.timer = NULL;
 529    elm_exit();
 530
 531    return EINA_FALSE;
 532 }
 533
 534 static void
 535 _shot_init(Elm_Win_Smart_Data *sd)
 536 {
 537    if (!sd->shot.info) return;
 538
 539    sd->shot.repeat_count = _shot_repeat_count_get(sd);
 540    sd->shot.shot_counter = 0;
 541 }
 542
 543 static void
 544 _shot_handle(Elm_Win_Smart_Data *sd)
 545 {
 546    if (!sd->shot.info) return;
 547
 548    if (!sd->shot.timer)
 549      sd->shot.timer = ecore_timer_add(_shot_delay_get(sd), _shot_delay,
 550                                       sd->obj);
 551 }
 552
 553 /* elm-win specific associate, does the trap while ecore_evas_object_associate()
 554  * does not.
 555  */
 556 static Elm_Win_Smart_Data *
 557 _elm_win_associate_get(const Ecore_Evas *ee)
 558 {
 559    Evas_Object *obj = ecore_evas_data_get(ee, "elm_win");
 560    if (!obj) return NULL;
 561    ELM_WIN_DATA_GET(obj, sd);
 562    return sd;
 563 }
 564
 565 /* Interceptors Callbacks */
 566 static void
 567 _elm_win_obj_intercept_raise(void *data, Evas_Object *obj EINA_UNUSED)
 568 {
 569    ELM_WIN_DATA_GET(data, sd);
 570    TRAP(sd, raise);
 571 }
 572
 573 static void
 574 _elm_win_obj_intercept_lower(void *data, Evas_Object *obj EINA_UNUSED)
 575 {
 576    ELM_WIN_DATA_GET(data, sd);
 577    TRAP(sd, lower);
 578 }
 579
 580 static void
 581 _elm_win_obj_intercept_stack_above(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, Evas_Object *above EINA_UNUSED)
 582 {
 583    INF("TODO: %s", __FUNCTION__);
 584 }
 585
 586 static void
 587 _elm_win_obj_intercept_stack_below(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, Evas_Object *below EINA_UNUSED)
 588 {
 589    INF("TODO: %s", __FUNCTION__);
 590 }
 591
 592 static void
 593 _elm_win_obj_intercept_layer_set(void *data, Evas_Object *obj EINA_UNUSED, int l)
 594 {
 595    ELM_WIN_DATA_GET(data, sd);
 596    TRAP(sd, layer_set, l);
 597 }
 598
 599 /* Event Callbacks */
 600
 601 static void
 602 _elm_win_obj_callback_changed_size_hints(void *data, Evas *e EINA_UNUSED, Evas_Object *obj, void *event_info EINA_UNUSED)
 603 {
 604    ELM_WIN_DATA_GET(data, sd);
 605    Evas_Coord w, h;
 606
 607    evas_object_size_hint_min_get(obj, &w, &h);
 608    TRAP(sd, size_min_set, w, h);
 609
 610    evas_object_size_hint_max_get(obj, &w, &h);
 611    if (w < 1) w = -1;
 612    if (h < 1) h = -1;
 613    TRAP(sd, size_max_set, w, h);
 614 }
 615 /* end of elm-win specific associate */
 616
 617 static void
 618 _elm_win_move(Ecore_Evas *ee)
 619 {
 620    Elm_Win_Smart_Data *sd = _elm_win_associate_get(ee);
 621    int x, y;
 622
 623    if (!sd) return;
 624
 625    ecore_evas_geometry_get(ee, &x, &y, NULL, NULL);
 626    sd->screen.x = x;
 627    sd->screen.y = y;
 628    evas_object_smart_callback_call(sd->obj, SIG_MOVED, NULL);
 629 }
 630
 631 static void
 632 _elm_win_resize_job(void *data)
 633 {
 634    ELM_WIN_DATA_GET(data, sd);
 635    int w, h;
 636
 637    sd->deferred_resize_job = NULL;
 638    ecore_evas_request_geometry_get(sd->ee, NULL, NULL, &w, &h);
 639    if (sd->constrain)
 640      {
 641         int sw, sh;
 642         ecore_evas_screen_geometry_get(sd->ee, NULL, NULL, &sw, &sh);
 643         w = MIN(w, sw);
 644         h = MIN(h, sh);
 645      }
 646
 647    if (sd->frame_obj)
 648      {
 649         int fx, fy, fw, fh;
 650
 651         evas_output_framespace_get(sd->evas, &fx, &fy, &fw, &fh);
 652         evas_object_move(sd->frame_obj, -fx, -fy);
 653         evas_object_resize(sd->frame_obj, w + fw, h + fh);
 654      }
 655
 656    evas_object_resize(sd->obj, w, h);
 657    evas_object_resize(sd->layout, w, h);
 658 }
 659
 660 static void
 661 _elm_win_resize(Ecore_Evas *ee)
 662 {
 663    Elm_Win_Smart_Data *sd = _elm_win_associate_get(ee);
 664    if (!sd) return;
 665
 666    ecore_job_del(sd->deferred_resize_job);
 667    sd->deferred_resize_job = ecore_job_add(_elm_win_resize_job, sd->obj);
 668 }
 669
 670 static void
 671 _elm_win_mouse_in(Ecore_Evas *ee)
 672 {
 673    Elm_Win_Smart_Data *sd = _elm_win_associate_get(ee);
 674    if (!sd) return;
 675
 676    if (sd->resizing) sd->resizing = EINA_FALSE;
 677 }
 678
 679 static void
 680 _elm_win_focus_highlight_reconfigure_job_stop(Elm_Win_Smart_Data *sd)
 681 {
 682    ELM_SAFE_FREE(sd->focus_highlight.reconf_job, ecore_job_del);
 683 }
 684
 685 static void
 686 _elm_win_focus_highlight_visible_set(Elm_Win_Smart_Data *sd,
 687                                      Eina_Bool visible)
 688 {
 689    Evas_Object *fobj = sd->focus_highlight.fobj;
 690    if (!fobj) return;
 691
 692    if (visible)
 693      {
 694         evas_object_show(fobj);
 695         edje_object_signal_emit(fobj, "elm,action,focus,show", "elm");
 696      }
 697    else
 698      {
 699         edje_object_signal_emit(fobj, "elm,action,focus,hide", "elm");
 700      }
 701 }
 702
 703 static void
 704 _elm_win_focus_highlight_anim_setup(Elm_Win_Smart_Data *sd,
 705                                     Evas_Object *obj)
 706 {
 707    Evas_Coord tx, ty, tw, th;
 708    Evas_Coord w, h, px, py, pw, ph;
 709    Edje_Message_Int_Set *m;
 710    Evas_Object *previous = sd->focus_highlight.prev.target;
 711    Evas_Object *target = sd->focus_highlight.cur.target;
 712
 713    evas_object_geometry_get(sd->obj, NULL, NULL, &w, &h);
 714    elm_widget_focus_highlight_geometry_get(target, &tx, &ty, &tw, &th, EINA_TRUE);
 715    elm_widget_focus_highlight_geometry_get(previous, &px, &py, &pw, &ph, EINA_FALSE);
 716    evas_object_move(obj, tx, ty);
 717    evas_object_resize(obj, tw, th);
 718    evas_object_clip_unset(obj);
 719
 720    m = alloca(sizeof(*m) + (sizeof(int) * 8));
 721    m->count = 8;
 722    m->val[0] = px - tx;
 723    m->val[1] = py - ty;
 724    m->val[2] = pw;
 725    m->val[3] = ph;
 726    m->val[4] = 0;
 727    m->val[5] = 0;
 728    m->val[6] = tw;
 729    m->val[7] = th;
 730    edje_object_message_send(obj, EDJE_MESSAGE_INT_SET, 1, m);
 731 }
 732
 733 static void
 734 _elm_win_focus_highlight_simple_setup(Elm_Win_Smart_Data *sd,
 735                                       Evas_Object *obj)
 736 {
 737    Evas_Object *clip, *target = sd->focus_highlight.cur.target;
 738    Evas_Coord x, y, w, h;
 739
 740    clip = evas_object_clip_get(target);
 741    elm_widget_focus_highlight_geometry_get(target, &x, &y, &w, &h, EINA_TRUE);
 742
 743    evas_object_move(obj, x, y);
 744    evas_object_resize(obj, w, h);
 745    if (clip) evas_object_clip_set(obj, clip);
 746 }
 747
 748 static void
 749 _elm_win_focus_highlight_reconfigure(Elm_Win_Smart_Data *sd)
 750 {
 751    Evas_Object *target = sd->focus_highlight.cur.target;
 752    Evas_Object *previous = sd->focus_highlight.prev.target;
 753    Evas_Object *fobj = sd->focus_highlight.fobj;
 754    Eina_Bool visible_changed;
 755    Eina_Bool common_visible;
 756    const char *sig = NULL;
 757    const char *focus_style_target = NULL;
 758    const char *focus_style_previous = NULL;
 759
 760    _elm_win_focus_highlight_reconfigure_job_stop(sd);
 761
 762    visible_changed = (sd->focus_highlight.cur.visible !=
 763                       sd->focus_highlight.prev.visible);
 764
 765    if ((target == previous) && (!visible_changed) &&
 766        (!sd->focus_highlight.geometry_changed) &&
 767        (!sd->focus_highlight.theme_changed))
 768      return;
 769
 770    if ((previous) && (sd->focus_highlight.prev.in_theme))
 771      elm_widget_signal_emit
 772        (previous, "elm,action,focus_highlight,hide", "elm");
 773
 774    if (!target)
 775      common_visible = EINA_FALSE;
 776    else if (sd->focus_highlight.cur.in_theme)
 777      {
 778         common_visible = EINA_FALSE;
 779         if (sd->focus_highlight.cur.visible)
 780           sig = "elm,action,focus_highlight,show";
 781         else
 782           sig = "elm,action,focus_highlight,hide";
 783      }
 784    else
 785      common_visible = sd->focus_highlight.cur.visible;
 786
 787    if (sig)
 788      elm_widget_signal_emit(target, sig, "elm");
 789
 790    if ((!target) || (!common_visible) || (sd->focus_highlight.cur.in_theme))
 791      goto the_end;
 792
 793    if (previous)
 794      focus_style_previous = elm_widget_focus_highlight_style_get(previous);
 795    focus_style_target = elm_widget_focus_highlight_style_get(target);
 796
 797    if (sd->focus_highlight.theme_changed ||
 798        (focus_style_target != focus_style_previous))
 799      {
 800         const char *str;
 801
 802         if (focus_style_target)
 803           str = focus_style_target;
 804         else if (sd->focus_highlight.style)
 805           str = sd->focus_highlight.style;
 806         else
 807           str = "default";
 808
 809         elm_widget_theme_object_set
 810           (sd->obj, fobj, "focus_highlight", "top", str);
 811         sd->focus_highlight.theme_changed = EINA_FALSE;
 812
 813         if (sd->focus_highlight.animate)
 814           {
 815              str = edje_object_data_get(sd->focus_highlight.fobj, "animate");
 816              sd->focus_highlight.animate_supported = ((str) && (!strcmp(str, "on")));
 817           }
 818         else
 819           sd->focus_highlight.animate_supported = EINA_FALSE;
 820      }
 821
 822    if ((sd->focus_highlight.animate_supported) && (previous) &&
 823        (!sd->focus_highlight.prev.in_theme))
 824      _elm_win_focus_highlight_anim_setup(sd, fobj);
 825    else
 826      _elm_win_focus_highlight_simple_setup(sd, fobj);
 827    evas_object_raise(fobj);
 828
 829 the_end:
 830    _elm_win_focus_highlight_visible_set(sd, common_visible);
 831    sd->focus_highlight.geometry_changed = EINA_FALSE;
 832    sd->focus_highlight.prev = sd->focus_highlight.cur;
 833 }
 834
 835 static void
 836 _elm_win_focus_highlight_reconfigure_job(void *data)
 837 {
 838    ELM_WIN_DATA_GET(data, sd);
 839    _elm_win_focus_highlight_reconfigure(sd);
 840 }
 841
 842 static void
 843 _elm_win_focus_highlight_reconfigure_job_start(Elm_Win_Smart_Data *sd)
 844 {
 845    ecore_job_del(sd->focus_highlight.reconf_job);
 846
 847    sd->focus_highlight.reconf_job = ecore_job_add(
 848        _elm_win_focus_highlight_reconfigure_job, sd->obj);
 849 }
 850
 851 static void
 852 _elm_win_focus_in(Ecore_Evas *ee)
 853 {
 854    Elm_Win_Smart_Data *sd = _elm_win_associate_get(ee);
 855    Evas_Object *obj;
 856    unsigned int order = 0;
 857
 858    if (!sd) return;
 859
 860    obj = sd->obj;
 861
 862    _elm_widget_top_win_focused_set(obj, EINA_TRUE);
 863    if (!elm_widget_focus_order_get(obj)
 864        || (obj == elm_widget_newest_focus_order_get(obj, &order, EINA_TRUE)))
 865      {
 866         elm_widget_focus_steal(obj);
 867      }
 868    else
 869      elm_widget_focus_restore(obj);
 870    evas_object_smart_callback_call(obj, SIG_FOCUS_IN, NULL);
 871    evas_object_smart_callback_call(obj, SIG_FOCUSED, NULL);
 872    sd->focus_highlight.cur.visible = EINA_TRUE;
 873    _elm_win_focus_highlight_reconfigure_job_start(sd);
 874    if (sd->frame_obj)
 875      {
 876         edje_object_signal_emit(sd->frame_obj, "elm,action,focus", "elm");
 877      }
 878
 879    /* do nothing */
 880    /* else if (sd->img_obj) */
 881    /*   { */
 882    /*   } */
 883 }
 884
 885 static void
 886 _elm_win_focus_out(Ecore_Evas *ee)
 887 {
 888    Elm_Win_Smart_Data *sd = _elm_win_associate_get(ee);
 889    Evas_Object *obj;
 890
 891    if (!sd) return;
 892
 893    obj = sd->obj;
 894
 895    elm_object_focus_set(obj, EINA_FALSE);
 896    _elm_widget_top_win_focused_set(obj, EINA_FALSE);
 897    evas_object_smart_callback_call(obj, SIG_FOCUS_OUT, NULL);
 898    evas_object_smart_callback_call(obj, SIG_UNFOCUSED, NULL);
 899    sd->focus_highlight.cur.visible = EINA_FALSE;
 900    _elm_win_focus_highlight_reconfigure_job_start(sd);
 901    if (sd->frame_obj)
 902      {
 903         edje_object_signal_emit(sd->frame_obj, "elm,action,unfocus", "elm");
 904      }
 905
 906    /* access */
 907    _elm_access_object_highlight_disable(evas_object_evas_get(obj));
 908
 909    /* do nothing */
 910    /* if (sd->img_obj) */
 911    /*   { */
 912    /*   } */
 913 }
 914
 915 static void
 916 _elm_win_available_profiles_del(Elm_Win_Smart_Data *sd)
 917 {
 918    if (!sd->profile.available_list) return;
 919
 920    unsigned int i;
 921    for (i = 0; i < sd->profile.count; i++)
 922      ELM_SAFE_FREE(sd->profile.available_list[i], eina_stringshare_del);
 923    sd->profile.count = 0;
 924    ELM_SAFE_FREE(sd->profile.available_list, free);
 925 }
 926
 927 static void
 928 _elm_win_profile_del(Elm_Win_Smart_Data *sd)
 929 {
 930    ELM_SAFE_FREE(sd->profile.name, eina_stringshare_del);
 931 }
 932
 933 static Eina_Bool
 934 _elm_win_profile_set(Elm_Win_Smart_Data *sd, const char *profile)
 935 {
 936    Eina_Bool changed = EINA_FALSE;
 937    if (profile)
 938      {
 939         if (sd->profile.name)
 940           {
 941              if (strcmp(sd->profile.name, profile) != 0)
 942                {
 943                   eina_stringshare_replace(&(sd->profile.name), profile);
 944                   changed = EINA_TRUE;
 945                }
 946           }
 947         else
 948           {
 949              sd->profile.name = eina_stringshare_add(profile);
 950              changed = EINA_TRUE;
 951           }
 952      }
 953    else
 954      _elm_win_profile_del(sd);
 955
 956    return changed;
 957 }
 958
 959 static void
 960 _elm_win_profile_update(Elm_Win_Smart_Data *sd)
 961 {
 962    if (sd->profile.available_list)
 963      {
 964         Eina_Bool found = EINA_FALSE;
 965         if (sd->profile.name)
 966           {
 967              unsigned int i;
 968              for (i = 0; i < sd->profile.count; i++)
 969                {
 970                   if (!strcmp(sd->profile.name,
 971                               sd->profile.available_list[i]))
 972                     {
 973                        found = EINA_TRUE;
 974                        break;
 975                     }
 976                }
 977           }
 978
 979         /* If current profile is not present in an available profiles,
 980          * change current profile to the 1st element of an array.
 981          */
 982         if (!found)
 983           _elm_win_profile_set(sd, sd->profile.available_list[0]);
 984      }
 985
 986    _elm_config_profile_set(sd->profile.name);
 987
 988    /* update sub ee */
 989    Ecore_Evas *ee2;
 990    Eina_List *sub, *l = NULL;
 991
 992    sub = ecore_evas_sub_ecore_evas_list_get(sd->ee);
 993    EINA_LIST_FOREACH(sub, l, ee2)
 994      ecore_evas_window_profile_set(ee2, sd->profile.name);
 995
 996    evas_object_smart_callback_call(sd->obj, SIG_PROFILE_CHANGED, NULL);
 997 }
 998
 999 static void
1000 _elm_win_state_change(Ecore_Evas *ee)
1001 {
1002    Elm_Win_Smart_Data *sd = _elm_win_associate_get(ee);
1003    Evas_Object *obj;
1004    Eina_Bool ch_withdrawn = EINA_FALSE;
1005    Eina_Bool ch_sticky = EINA_FALSE;
1006    Eina_Bool ch_iconified = EINA_FALSE;
1007    Eina_Bool ch_fullscreen = EINA_FALSE;
1008    Eina_Bool ch_maximized = EINA_FALSE;
1009    Eina_Bool ch_profile = EINA_FALSE;
1010    Eina_Bool ch_wm_rotation = EINA_FALSE;
1011    const char *profile;
1012
1013    if (!sd) return;
1014
1015    obj = sd->obj;
1016
1017    if (sd->withdrawn != ecore_evas_withdrawn_get(sd->ee))
1018      {
1019         sd->withdrawn = ecore_evas_withdrawn_get(sd->ee);
1020         ch_withdrawn = EINA_TRUE;
1021      }
1022    if (sd->sticky != ecore_evas_sticky_get(sd->ee))
1023      {
1024         sd->sticky = ecore_evas_sticky_get(sd->ee);
1025         ch_sticky = EINA_TRUE;
1026      }
1027    if (sd->iconified != ecore_evas_iconified_get(sd->ee))
1028      {
1029         sd->iconified = ecore_evas_iconified_get(sd->ee);
1030         ch_iconified = EINA_TRUE;
1031      }
1032    if (sd->fullscreen != ecore_evas_fullscreen_get(sd->ee))
1033      {
1034         sd->fullscreen = ecore_evas_fullscreen_get(sd->ee);
1035         ch_fullscreen = EINA_TRUE;
1036      }
1037    if (sd->maximized != ecore_evas_maximized_get(sd->ee))
1038      {
1039         sd->maximized = ecore_evas_maximized_get(sd->ee);
1040         ch_maximized = EINA_TRUE;
1041      }
1042
1043    profile = ecore_evas_window_profile_get(sd->ee);
1044    ch_profile = _elm_win_profile_set(sd, profile);
1045
1046    if (sd->wm_rot.use)
1047      {
1048         if (sd->rot != ecore_evas_rotation_get(sd->ee))
1049           {
1050              sd->rot = ecore_evas_rotation_get(sd->ee);
1051              ch_wm_rotation = EINA_TRUE;
1052           }
1053      }
1054
1055    _elm_win_state_eval_queue();
1056
1057    if ((ch_withdrawn) || (ch_iconified))
1058      {
1059         if (sd->withdrawn)
1060           evas_object_smart_callback_call(obj, SIG_WITHDRAWN, NULL);
1061         else if (sd->iconified)
1062           evas_object_smart_callback_call(obj, SIG_ICONIFIED, NULL);
1063         else
1064           evas_object_smart_callback_call(obj, SIG_NORMAL, NULL);
1065      }
1066    if (ch_sticky)
1067      {
1068         if (sd->sticky)
1069           evas_object_smart_callback_call(obj, SIG_STICK, NULL);
1070         else
1071           evas_object_smart_callback_call(obj, SIG_UNSTICK, NULL);
1072      }
1073    if (ch_fullscreen)
1074      {
1075         if (sd->fullscreen)
1076           evas_object_smart_callback_call(obj, SIG_FULLSCREEN, NULL);
1077         else
1078           evas_object_smart_callback_call(obj, SIG_UNFULLSCREEN, NULL);
1079      }
1080    if (ch_maximized)
1081      {
1082         if (sd->maximized)
1083           evas_object_smart_callback_call(obj, SIG_MAXIMIZED, NULL);
1084         else
1085           evas_object_smart_callback_call(obj, SIG_UNMAXIMIZED, NULL);
1086      }
1087    if (ch_profile)
1088      {
1089         _elm_win_profile_update(sd);
1090      }
1091    if (ch_wm_rotation)
1092      {
1093         evas_object_size_hint_min_set(obj, -1, -1);
1094         evas_object_size_hint_max_set(obj, -1, -1);
1095 #ifdef HAVE_ELEMENTARY_X
1096         _elm_win_xwin_update(sd);
1097 #endif
1098         elm_widget_orientation_set(obj, sd->rot);
1099         evas_object_smart_callback_call(obj, SIG_ROTATION_CHANGED, NULL);
1100         evas_object_smart_callback_call(obj, SIG_WM_ROTATION_CHANGED, NULL);
1101      }
1102 }
1103
1104 static void
1105 _elm_win_smart_focus_next_manager_is(Eo *obj EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list)
1106 {
1107    Eina_Bool *ret = va_arg(*list, Eina_Bool *);
1108    *ret = EINA_TRUE;
1109 }
1110
1111 static void
1112 _elm_win_smart_focus_next(Eo *obj, void *_pd EINA_UNUSED, va_list *list)
1113 {
1114    Elm_Focus_Direction dir = va_arg(*list, Elm_Focus_Direction);
1115    Evas_Object **next = va_arg(*list, Evas_Object **);
1116    Eina_Bool *ret = va_arg(*list, Eina_Bool *);
1117    if (ret) *ret = EINA_FALSE;
1118
1119    ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
1120
1121    const Eina_List *items;
1122    void *(*list_data_get)(const Eina_List *list);
1123
1124    /* Focus chain */
1125    if (wd->subobjs)
1126      {
1127         if (!(items = elm_widget_focus_custom_chain_get(obj)))
1128           {
1129              items = wd->subobjs;
1130              if (!items)
1131                return;
1132           }
1133         list_data_get = eina_list_data_get;
1134
1135         elm_widget_focus_list_next_get(obj, items, list_data_get, dir, next);
1136
1137         if (*next)
1138           {
1139              if (ret) *ret = EINA_TRUE;
1140              return;
1141           }
1142      }
1143    *next = (Evas_Object *)obj;
1144    return;
1145 }
1146
1147 static void
1148 _elm_win_smart_focus_direction_manager_is(Eo *obj EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list)
1149 {
1150    Eina_Bool *ret = va_arg(*list, Eina_Bool *);
1151    *ret = EINA_TRUE;
1152 }
1153
1154 static void
1155 _elm_win_smart_focus_direction(Eo *obj, void *_pd EINA_UNUSED, va_list *list)
1156 {
1157    const Evas_Object *base = va_arg(*list, Evas_Object *);
1158    double degree = va_arg(*list, double);
1159    Evas_Object **direction = va_arg(*list, Evas_Object **);
1160    double *weight = va_arg(*list, double *);
1161    Eina_Bool *ret = va_arg(*list, Eina_Bool *);
1162    if (ret) *ret = EINA_FALSE;
1163    Eina_Bool int_ret = EINA_FALSE;
1164
1165    const Eina_List *items;
1166    void *(*list_data_get)(const Eina_List *list);
1167
1168    ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
1169
1170    /* Focus chain */
1171    if (wd->subobjs)
1172      {
1173         if (!(items = elm_widget_focus_custom_chain_get(obj)))
1174           items = wd->subobjs;
1175
1176         list_data_get = eina_list_data_get;
1177
1178         int_ret = elm_widget_focus_list_direction_get
1179                  (obj, base, items, list_data_get, degree, direction, weight);
1180         if (ret) *ret = int_ret;
1181      }
1182 }
1183
1184 static void
1185 _elm_win_smart_on_focus(Eo *obj, void *_pd, va_list *list)
1186 {
1187    Eina_Bool *ret = va_arg(*list, Eina_Bool *);
1188    if (ret) *ret = EINA_TRUE;
1189    Elm_Win_Smart_Data *sd = _pd;
1190    Eina_Bool int_ret = EINA_FALSE;
1191
1192    eo_do_super(obj, MY_CLASS, elm_wdg_on_focus(&int_ret));
1193    if (!int_ret) return;
1194
1195    if (sd->img_obj)
1196      evas_object_focus_set(sd->img_obj, elm_widget_focus_get(obj));
1197    else
1198      evas_object_focus_set(obj, elm_widget_focus_get(obj));
1199 }
1200
1201 static void
1202 _elm_win_smart_event(Eo *obj, void *_pd EINA_UNUSED, va_list *list)
1203 {
1204    Evas_Object *src = va_arg(*list, Evas_Object *);
1205    Evas_Callback_Type type = va_arg(*list, Evas_Callback_Type);
1206    Evas_Event_Key_Down *ev = va_arg(*list, void *);
1207    Eina_Bool *ret = va_arg(*list, Eina_Bool *);
1208
1209    if (ret) *ret = EINA_FALSE;
1210    (void) src;
1211
1212    if (elm_widget_disabled_get(obj)) return;
1213    if (type != EVAS_CALLBACK_KEY_DOWN) return;
1214
1215    if ((!strcmp(ev->key, "Tab")) ||
1216        (!strcmp(ev->key, "ISO_Left_Tab")))
1217      {
1218         if (evas_key_modifier_is_set(ev->modifiers, "Control") ||
1219             evas_key_modifier_is_set(ev->modifiers, "Alt"))
1220           return;
1221         if (evas_key_modifier_is_set(ev->modifiers, "Shift"))
1222           elm_widget_focus_cycle(obj, ELM_FOCUS_PREVIOUS);
1223         else
1224           elm_widget_focus_cycle(obj, ELM_FOCUS_NEXT);
1225
1226         goto success;
1227      }
1228    else if ((!strcmp(ev->key, "Left")) ||
1229             ((!strcmp(ev->key, "KP_Left")) && (!ev->string)))
1230      {
1231         elm_widget_focus_cycle(obj, ELM_FOCUS_LEFT);
1232
1233         goto success;
1234      }
1235    else if ((!strcmp(ev->key, "Right")) ||
1236             ((!strcmp(ev->key, "KP_Right")) && (!ev->string)))
1237      {
1238         elm_widget_focus_cycle(obj, ELM_FOCUS_RIGHT);
1239
1240         goto success;
1241      }
1242    else if ((!strcmp(ev->key, "Up")) ||
1243             ((!strcmp(ev->key, "KP_Up")) && (!ev->string)))
1244      {
1245         elm_widget_focus_cycle(obj, ELM_FOCUS_UP);
1246
1247         goto success;
1248      }
1249    else if ((!strcmp(ev->key, "Down")) ||
1250             ((!strcmp(ev->key, "KP_Down")) && (!ev->string)))
1251      {
1252         elm_widget_focus_cycle(obj, ELM_FOCUS_DOWN);
1253
1254         goto success;
1255      }
1256
1257    return;
1258
1259 success:
1260    ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
1261    if (ret) *ret = EINA_TRUE;
1262 }
1263
1264 static void
1265 _deferred_ecore_evas_free(void *data)
1266 {
1267    ecore_evas_free(data);
1268    _elm_win_deferred_free--;
1269 }
1270
1271 static void
1272 _elm_win_smart_show(Eo *obj, void *_pd, va_list *list EINA_UNUSED)
1273 {
1274    Elm_Win_Smart_Data *sd = _pd;
1275
1276    if (!evas_object_visible_get(obj))
1277      _elm_win_state_eval_queue();
1278    eo_do_super(obj, MY_CLASS, evas_obj_smart_show());
1279
1280    TRAP(sd, show);
1281
1282    if (sd->shot.info) _shot_handle(sd);
1283 }
1284
1285 static void
1286 _elm_win_smart_hide(Eo *obj, void *_pd, va_list *list EINA_UNUSED)
1287 {
1288    Elm_Win_Smart_Data *sd = _pd;
1289
1290    if (evas_object_visible_get(obj))
1291      _elm_win_state_eval_queue();
1292    eo_do_super(obj, MY_CLASS, evas_obj_smart_hide());
1293
1294    TRAP(sd, hide);
1295
1296    if (sd->frame_obj)
1297      {
1298         evas_object_hide(sd->frame_obj);
1299      }
1300    if (sd->img_obj)
1301      {
1302         evas_object_hide(sd->img_obj);
1303      }
1304    if (sd->pointer.obj)
1305      {
1306         evas_object_hide(sd->pointer.obj);
1307         ecore_evas_hide(sd->pointer.ee);
1308      }
1309 }
1310
1311 static void
1312 _elm_win_on_parent_del(void *data,
1313                        Evas *e EINA_UNUSED,
1314                        Evas_Object *obj,
1315                        void *event_info EINA_UNUSED)
1316 {
1317    ELM_WIN_DATA_GET(data, sd);
1318
1319    if (obj == sd->parent) sd->parent = NULL;
1320 }
1321
1322 static void
1323 _elm_win_focus_target_move(void *data,
1324                            Evas *e EINA_UNUSED,
1325                            Evas_Object *obj EINA_UNUSED,
1326                            void *event_info EINA_UNUSED)
1327 {
1328    ELM_WIN_DATA_GET(data, sd);
1329
1330    sd->focus_highlight.geometry_changed = EINA_TRUE;
1331    _elm_win_focus_highlight_reconfigure_job_start(sd);
1332 }
1333
1334 static void
1335 _elm_win_focus_target_resize(void *data,
1336                              Evas *e EINA_UNUSED,
1337                              Evas_Object *obj EINA_UNUSED,
1338                              void *event_info EINA_UNUSED)
1339 {
1340    ELM_WIN_DATA_GET(data, sd);
1341
1342    sd->focus_highlight.geometry_changed = EINA_TRUE;
1343    _elm_win_focus_highlight_reconfigure_job_start(sd);
1344 }
1345
1346 static void
1347 _elm_win_focus_target_del(void *data,
1348                           Evas *e EINA_UNUSED,
1349                           Evas_Object *obj EINA_UNUSED,
1350                           void *event_info EINA_UNUSED)
1351 {
1352    ELM_WIN_DATA_GET(data, sd);
1353
1354    sd->focus_highlight.cur.target = NULL;
1355
1356    _elm_win_focus_highlight_reconfigure_job_start(sd);
1357 }
1358
1359 static Evas_Object *
1360 _elm_win_focus_target_get(Evas_Object *obj)
1361 {
1362    Evas_Object *o = obj;
1363
1364    do
1365      {
1366         if (elm_widget_is(o))
1367           {
1368              if (!elm_widget_highlight_ignore_get(o))
1369                break;
1370              o = elm_widget_parent_get(o);
1371              if (!o)
1372                o = evas_object_smart_parent_get(o);
1373           }
1374         else
1375           {
1376              o = elm_widget_parent_widget_get(o);
1377              if (!o)
1378                o = evas_object_smart_parent_get(o);
1379           }
1380      }
1381    while (o);
1382
1383    return o;
1384 }
1385
1386 static void
1387 _elm_win_focus_target_callbacks_add(Elm_Win_Smart_Data *sd)
1388 {
1389    Evas_Object *obj = sd->focus_highlight.cur.target;
1390    if (!obj) return;
1391
1392    evas_object_event_callback_add
1393      (obj, EVAS_CALLBACK_MOVE, _elm_win_focus_target_move, sd->obj);
1394    evas_object_event_callback_add
1395      (obj, EVAS_CALLBACK_RESIZE, _elm_win_focus_target_resize, sd->obj);
1396    evas_object_event_callback_add
1397      (obj, EVAS_CALLBACK_DEL, _elm_win_focus_target_del, sd->obj);
1398 }
1399
1400 static void
1401 _elm_win_focus_target_callbacks_del(Elm_Win_Smart_Data *sd)
1402 {
1403    Evas_Object *obj = sd->focus_highlight.cur.target;
1404
1405    evas_object_event_callback_del_full
1406      (obj, EVAS_CALLBACK_MOVE, _elm_win_focus_target_move, sd->obj);
1407    evas_object_event_callback_del_full
1408      (obj, EVAS_CALLBACK_RESIZE, _elm_win_focus_target_resize, sd->obj);
1409    evas_object_event_callback_del_full
1410      (obj, EVAS_CALLBACK_DEL, _elm_win_focus_target_del, sd->obj);
1411 }
1412
1413 static void
1414 _elm_win_object_focus_in(void *data,
1415                          Evas *e EINA_UNUSED,
1416                          void *event_info)
1417 {
1418    Evas_Object *obj = event_info, *target;
1419    ELM_WIN_DATA_GET(data, sd);
1420
1421    if (sd->focus_highlight.cur.target == obj)
1422      return;
1423
1424    target = _elm_win_focus_target_get(obj);
1425    sd->focus_highlight.cur.target = target;
1426    if (target && elm_widget_highlight_in_theme_get(target))
1427      sd->focus_highlight.cur.in_theme = EINA_TRUE;
1428    else
1429      _elm_win_focus_target_callbacks_add(sd);
1430
1431    _elm_win_focus_highlight_reconfigure_job_start(sd);
1432 }
1433
1434 static void
1435 _elm_win_object_focus_out(void *data,
1436                           Evas *e EINA_UNUSED,
1437                           void *event_info EINA_UNUSED)
1438 {
1439    ELM_WIN_DATA_GET(data, sd);
1440
1441    if (!sd->focus_highlight.cur.target)
1442      return;
1443
1444    if (!sd->focus_highlight.cur.in_theme)
1445      _elm_win_focus_target_callbacks_del(sd);
1446
1447    sd->focus_highlight.cur.target = NULL;
1448    sd->focus_highlight.cur.in_theme = EINA_FALSE;
1449
1450    _elm_win_focus_highlight_reconfigure_job_start(sd);
1451 }
1452
1453 static void
1454 _elm_win_focus_highlight_shutdown(Elm_Win_Smart_Data *sd)
1455 {
1456    _elm_win_focus_highlight_reconfigure_job_stop(sd);
1457    if (sd->focus_highlight.cur.target)
1458      {
1459         elm_widget_signal_emit(sd->focus_highlight.cur.target,
1460                                "elm,action,focus_highlight,hide", "elm");
1461         _elm_win_focus_target_callbacks_del(sd);
1462         sd->focus_highlight.cur.target = NULL;
1463      }
1464    ELM_SAFE_FREE(sd->focus_highlight.fobj, evas_object_del);
1465
1466    evas_event_callback_del_full
1467      (sd->evas, EVAS_CALLBACK_CANVAS_OBJECT_FOCUS_IN,
1468      _elm_win_object_focus_in, sd->obj);
1469    evas_event_callback_del_full
1470      (sd->evas, EVAS_CALLBACK_CANVAS_OBJECT_FOCUS_OUT,
1471      _elm_win_object_focus_out, sd->obj);
1472 }
1473
1474 static void
1475 _win_img_hide(void *data,
1476               Evas *e EINA_UNUSED,
1477               Evas_Object *obj EINA_UNUSED,
1478               void *event_info EINA_UNUSED)
1479 {
1480    elm_widget_focus_hide_handle(data);
1481 }
1482
1483 static void
1484 _win_img_mouse_up(void *data,
1485                   Evas *e EINA_UNUSED,
1486                   Evas_Object *obj EINA_UNUSED,
1487                   void *event_info)
1488 {
1489    Evas_Event_Mouse_Up *ev = event_info;
1490    if (!(ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD))
1491      elm_widget_focus_mouse_up_handle(data);
1492 }
1493
1494 static void
1495 _win_img_focus_in(void *data,
1496                   Evas *e EINA_UNUSED,
1497                   Evas_Object *obj EINA_UNUSED,
1498                   void *event_info EINA_UNUSED)
1499 {
1500    elm_widget_focus_steal(data);
1501 }
1502
1503 static void
1504 _win_img_focus_out(void *data,
1505                    Evas *e EINA_UNUSED,
1506                    Evas_Object *obj EINA_UNUSED,
1507                    void *event_info EINA_UNUSED)
1508 {
1509    elm_widget_focused_object_clear(data);
1510 }
1511
1512 static void
1513 _elm_win_on_img_obj_del(void *data,
1514                         Evas *e EINA_UNUSED,
1515                         Evas_Object *obj EINA_UNUSED,
1516                         void *event_info EINA_UNUSED)
1517 {
1518    ELM_WIN_DATA_GET(data, sd);
1519    _elm_win_img_callbacks_del(sd->obj, sd->img_obj);
1520    sd->img_obj = NULL;
1521 }
1522
1523 static void
1524 _elm_win_img_callbacks_del(Evas_Object *obj, Evas_Object *imgobj)
1525 {
1526    evas_object_event_callback_del_full
1527      (imgobj, EVAS_CALLBACK_DEL, _elm_win_on_img_obj_del, obj);
1528    evas_object_event_callback_del_full
1529      (imgobj, EVAS_CALLBACK_HIDE, _win_img_hide, obj);
1530    evas_object_event_callback_del_full
1531      (imgobj, EVAS_CALLBACK_MOUSE_UP, _win_img_mouse_up, obj);
1532    evas_object_event_callback_del_full
1533      (imgobj, EVAS_CALLBACK_FOCUS_IN, _win_img_focus_in, obj);
1534    evas_object_event_callback_del_full
1535      (imgobj, EVAS_CALLBACK_FOCUS_OUT, _win_img_focus_out, obj);
1536 }
1537
1538 static void
1539 _elm_win_smart_del(Eo *obj, void *_pd, va_list *list EINA_UNUSED)
1540 {
1541    Elm_Win_Smart_Data *sd = _pd;
1542
1543    evas_object_event_callback_del_full(sd->layout,
1544                                        EVAS_CALLBACK_CHANGED_SIZE_HINTS,
1545                                        _elm_win_on_resize_obj_changed_size_hints,
1546                                        obj);
1547    evas_object_del(sd->box);
1548    evas_object_del(sd->layout);
1549
1550    /* NB: child deletion handled by parent's smart del */
1551
1552    if ((trap) && (trap->del))
1553      trap->del(sd->trap_data, obj);
1554
1555    if (sd->parent)
1556      {
1557         evas_object_event_callback_del_full
1558           (sd->parent, EVAS_CALLBACK_DEL, _elm_win_on_parent_del, obj);
1559         sd->parent = NULL;
1560      }
1561
1562    if (sd->autodel_clear) *(sd->autodel_clear) = -1;
1563
1564    _elm_win_list = eina_list_remove(_elm_win_list, obj);
1565    _elm_win_count--;
1566    _elm_win_state_eval_queue();
1567
1568    if (sd->ee)
1569      {
1570         ecore_evas_callback_delete_request_set(sd->ee, NULL);
1571         ecore_evas_callback_resize_set(sd->ee, NULL);
1572      }
1573
1574    ecore_job_del(sd->deferred_resize_job);
1575    ecore_job_del(sd->deferred_child_eval_job);
1576    eina_stringshare_del(sd->shot.info);
1577    ecore_timer_del(sd->shot.timer);
1578
1579 #ifdef HAVE_ELEMENTARY_X
1580    ecore_event_handler_del(sd->x.client_message_handler);
1581    ecore_event_handler_del(sd->x.property_handler);
1582 #endif
1583
1584    if (sd->img_obj)
1585      {
1586         _elm_win_img_callbacks_del(obj, sd->img_obj);
1587         sd->img_obj = NULL;
1588      }
1589    else
1590      {
1591         if (sd->ee)
1592           {
1593              ecore_job_add(_deferred_ecore_evas_free, sd->ee);
1594              _elm_win_deferred_free++;
1595           }
1596      }
1597
1598    _elm_win_focus_highlight_shutdown(sd);
1599    eina_stringshare_del(sd->focus_highlight.style);
1600
1601    eina_stringshare_del(sd->title);
1602    eina_stringshare_del(sd->icon_name);
1603    eina_stringshare_del(sd->role);
1604    evas_object_del(sd->icon);
1605    evas_object_del(sd->main_menu);
1606
1607    _elm_win_profile_del(sd);
1608    _elm_win_available_profiles_del(sd);
1609
1610    /* Don't let callback in the air that point to sd */
1611    ecore_evas_callback_delete_request_set(sd->ee, NULL);
1612    ecore_evas_callback_resize_set(sd->ee, NULL);
1613    ecore_evas_callback_mouse_in_set(sd->ee, NULL);
1614    ecore_evas_callback_focus_in_set(sd->ee, NULL);
1615    ecore_evas_callback_focus_out_set(sd->ee, NULL);
1616    ecore_evas_callback_move_set(sd->ee, NULL);
1617    ecore_evas_callback_state_change_set(sd->ee, NULL);
1618
1619    eo_do_super(obj, MY_CLASS, evas_obj_smart_del());
1620
1621    if ((!_elm_win_list) &&
1622        (elm_policy_get(ELM_POLICY_QUIT) == ELM_POLICY_QUIT_LAST_WINDOW_CLOSED))
1623      {
1624         edje_file_cache_flush();
1625         edje_collection_cache_flush();
1626         evas_image_cache_flush(evas_object_evas_get(obj));
1627         evas_font_cache_flush(evas_object_evas_get(obj));
1628         elm_exit();
1629      }
1630 }
1631
1632 static void
1633 _elm_win_obj_intercept_show(void *data,
1634                             Evas_Object *obj)
1635 {
1636    ELM_WIN_DATA_GET(data, sd);
1637
1638    // this is called to make sure all smart containers have calculated their
1639    // sizes BEFORE we show the window to make sure it initially appears at
1640    // our desired size (ie min size is known first)
1641    evas_smart_objects_calculate(evas_object_evas_get(obj));
1642    if (sd->frame_obj)
1643      {
1644         evas_object_show(sd->frame_obj);
1645      }
1646    if (sd->img_obj)
1647      {
1648         evas_object_show(sd->img_obj);
1649      }
1650    if (sd->pointer.obj)
1651      {
1652         ecore_evas_show(sd->pointer.ee);
1653         evas_object_show(sd->pointer.obj);
1654      }
1655    evas_object_show(obj);
1656 }
1657
1658 static void
1659 _elm_win_smart_move(Eo *obj, void *_pd EINA_UNUSED, va_list *list)
1660 {
1661    Evas_Coord x = va_arg(*list, Evas_Coord);
1662    Evas_Coord y = va_arg(*list, Evas_Coord);
1663    Elm_Win_Smart_Data *sd = _pd;
1664
1665    if (sd->img_obj)
1666      {
1667         if ((x != sd->screen.x) || (y != sd->screen.y))
1668           {
1669              sd->screen.x = x;
1670              sd->screen.y = y;
1671              evas_object_smart_callback_call(obj, SIG_MOVED, NULL);
1672           }
1673         return;
1674      }
1675    else
1676      {
1677         TRAP(sd, move, x, y);
1678         if (!ecore_evas_override_get(sd->ee))  return;
1679      }
1680
1681    eo_do_super(obj, MY_CLASS, evas_obj_smart_move(x, y));
1682
1683    if (ecore_evas_override_get(sd->ee))
1684      {
1685         sd->screen.x = x;
1686         sd->screen.y = y;
1687         evas_object_smart_callback_call(obj, SIG_MOVED, NULL);
1688      }
1689    if (sd->frame_obj)
1690      {
1691         /* FIXME: We should update ecore_wl_window_location here !! */
1692         sd->screen.x = x;
1693         sd->screen.y = y;
1694      }
1695    if (sd->img_obj)
1696      {
1697         sd->screen.x = x;
1698         sd->screen.y = y;
1699      }
1700 }
1701
1702 static void
1703 _elm_win_smart_resize(Eo *obj, void *_pd, va_list *list)
1704 {
1705    Evas_Coord w = va_arg(*list, Evas_Coord);
1706    Evas_Coord h = va_arg(*list, Evas_Coord);
1707
1708    Elm_Win_Smart_Data *sd = _pd;
1709
1710    eo_do_super(obj, MY_CLASS, evas_obj_smart_resize(w, h));
1711
1712    if (sd->img_obj)
1713      {
1714         if (sd->constrain)
1715           {
1716              int sw, sh;
1717
1718              ecore_evas_screen_geometry_get(sd->ee, NULL, NULL, &sw, &sh);
1719              w = MIN(w, sw);
1720              h = MIN(h, sh);
1721           }
1722         if (w < 1) w = 1;
1723         if (h < 1) h = 1;
1724
1725         evas_object_image_size_set(sd->img_obj, w, h);
1726      }
1727
1728    TRAP(sd, resize, w, h);
1729 }
1730
1731 static void
1732 _elm_win_delete_request(Ecore_Evas *ee)
1733 {
1734    Elm_Win_Smart_Data *sd = _elm_win_associate_get(ee);
1735    Evas_Object *obj;
1736
1737    if (!sd) return;
1738
1739    obj = sd->obj;
1740
1741    int autodel = sd->autodel;
1742    sd->autodel_clear = &autodel;
1743    evas_object_ref(obj);
1744    evas_object_smart_callback_call(obj, SIG_DELETE_REQUEST, NULL);
1745    // FIXME: if above callback deletes - then the below will be invalid
1746    if (autodel) evas_object_del(obj);
1747    else sd->autodel_clear = NULL;
1748    evas_object_unref(obj);
1749 }
1750
1751 Ecore_X_Window
1752 _elm_ee_xwin_get(const Ecore_Evas *ee)
1753 {
1754 #ifdef HAVE_ELEMENTARY_X
1755    const char *engine_name;
1756    if (!ee) return 0;
1757
1758    engine_name = ecore_evas_engine_name_get(ee);
1759    if (EINA_UNLIKELY(!engine_name)) return 0;
1760
1761    if (!strcmp(engine_name, ELM_SOFTWARE_X11))
1762      {
1763         return ecore_evas_software_x11_window_get(ee);
1764      }
1765    else if (!strcmp(engine_name, ELM_OPENGL_X11))
1766      {
1767         return ecore_evas_gl_x11_window_get(ee);
1768      }
1769    else if (!strcmp(engine_name, ELM_SOFTWARE_WIN32))
1770      {
1771         return (long)ecore_evas_win32_window_get(ee);
1772      }
1773 #endif
1774    return 0;
1775 }
1776
1777 #ifdef HAVE_ELEMENTARY_X
1778 static void
1779 _elm_win_xwindow_get(Elm_Win_Smart_Data *sd)
1780 {
1781    sd->x.xwin = _elm_ee_xwin_get(sd->ee);
1782 }
1783 #endif
1784
1785 Ecore_Wl_Window *
1786 _elm_ee_wlwin_get(const Ecore_Evas *ee)
1787 {
1788 #ifdef HAVE_ELEMENTARY_WAYLAND
1789    const char *engine_name;
1790
1791    if (!ee) return NULL;
1792
1793    engine_name = ecore_evas_engine_name_get(ee);
1794    if (EINA_UNLIKELY(!engine_name)) return NULL;
1795
1796    if ((!strcmp(engine_name, ELM_WAYLAND_SHM)) ||
1797        (!strcmp(engine_name, ELM_WAYLAND_EGL)))
1798      {
1799         return ecore_evas_wayland_window_get(ee);
1800      }
1801 #else
1802    (void)ee;
1803 #endif
1804    return NULL;
1805 }
1806
1807 #ifdef HAVE_ELEMENTARY_WAYLAND
1808 static void
1809 _elm_win_wlwindow_get(Elm_Win_Smart_Data *sd)
1810 {
1811    sd->wl.win = _elm_ee_wlwin_get(sd->ee);
1812 }
1813 #endif
1814
1815 #ifdef HAVE_ELEMENTARY_X
1816 static void
1817 _elm_win_xwin_update(Elm_Win_Smart_Data *sd)
1818 {
1819    const char *s;
1820
1821    _elm_win_xwindow_get(sd);
1822    if (sd->parent)
1823      {
1824         ELM_WIN_DATA_GET(sd->parent, sdp);
1825         if (sdp)
1826           {
1827              if (sd->x.xwin)
1828                ecore_x_icccm_transient_for_set(sd->x.xwin, sdp->x.xwin);
1829           }
1830      }
1831
1832    if (!sd->x.xwin) return;  /* nothing more to do */
1833
1834    s = sd->title;
1835    if (!s) s = _elm_appname;
1836    if (!s) s = "";
1837    if (sd->icon_name) s = sd->icon_name;
1838    ecore_x_icccm_icon_name_set(sd->x.xwin, s);
1839    ecore_x_netwm_icon_name_set(sd->x.xwin, s);
1840
1841    s = sd->role;
1842    if (s) ecore_x_icccm_window_role_set(sd->x.xwin, s);
1843
1844    // set window icon
1845    if (sd->icon)
1846      {
1847         void *data;
1848
1849         data = evas_object_image_data_get(sd->icon, EINA_FALSE);
1850         if (data)
1851           {
1852              Ecore_X_Icon ic;
1853              int w = 0, h = 0, stride, x, y;
1854              unsigned char *p;
1855              unsigned int *p2;
1856
1857              evas_object_image_size_get(sd->icon, &w, &h);
1858              stride = evas_object_image_stride_get(sd->icon);
1859              if ((w > 0) && (h > 0) &&
1860                  (stride >= (int)(w * sizeof(unsigned int))))
1861                {
1862                   ic.width = w;
1863                   ic.height = h;
1864                   ic.data = malloc(w * h * sizeof(unsigned int));
1865
1866                   if (ic.data)
1867                     {
1868                        p = (unsigned char *)data;
1869                        p2 = (unsigned int *)ic.data;
1870                        for (y = 0; y < h; y++)
1871                          {
1872                             for (x = 0; x < w; x++)
1873                               {
1874                                  *p2 = *((unsigned int *)p);
1875                                  p += sizeof(unsigned int);
1876                                  p2++;
1877                               }
1878                             p += (stride - (w * sizeof(unsigned int)));
1879                          }
1880                        ecore_x_netwm_icons_set(sd->x.xwin, &ic, 1);
1881                        free(ic.data);
1882                     }
1883                }
1884              evas_object_image_data_set(sd->icon, data);
1885           }
1886      }
1887
1888    switch (sd->type)
1889      {
1890       case ELM_WIN_BASIC:
1891         ecore_x_netwm_window_type_set(sd->x.xwin, ECORE_X_WINDOW_TYPE_NORMAL);
1892         break;
1893
1894       case ELM_WIN_DIALOG_BASIC:
1895         ecore_x_netwm_window_type_set(sd->x.xwin, ECORE_X_WINDOW_TYPE_DIALOG);
1896         break;
1897
1898       case ELM_WIN_DESKTOP:
1899         ecore_x_netwm_window_type_set(sd->x.xwin, ECORE_X_WINDOW_TYPE_DESKTOP);
1900         break;
1901
1902       case ELM_WIN_DOCK:
1903         ecore_x_netwm_window_type_set(sd->x.xwin, ECORE_X_WINDOW_TYPE_DOCK);
1904         break;
1905
1906       case ELM_WIN_TOOLBAR:
1907         ecore_x_netwm_window_type_set(sd->x.xwin, ECORE_X_WINDOW_TYPE_TOOLBAR);
1908         break;
1909
1910       case ELM_WIN_MENU:
1911         ecore_x_netwm_window_type_set(sd->x.xwin, ECORE_X_WINDOW_TYPE_MENU);
1912         break;
1913
1914       case ELM_WIN_UTILITY:
1915         ecore_x_netwm_window_type_set(sd->x.xwin, ECORE_X_WINDOW_TYPE_UTILITY);
1916         break;
1917
1918       case ELM_WIN_SPLASH:
1919         ecore_x_netwm_window_type_set(sd->x.xwin, ECORE_X_WINDOW_TYPE_SPLASH);
1920         break;
1921
1922       case ELM_WIN_DROPDOWN_MENU:
1923         ecore_x_netwm_window_type_set
1924           (sd->x.xwin, ECORE_X_WINDOW_TYPE_DROPDOWN_MENU);
1925         break;
1926
1927       case ELM_WIN_POPUP_MENU:
1928         ecore_x_netwm_window_type_set
1929           (sd->x.xwin, ECORE_X_WINDOW_TYPE_POPUP_MENU);
1930         break;
1931
1932       case ELM_WIN_TOOLTIP:
1933         ecore_x_netwm_window_type_set(sd->x.xwin, ECORE_X_WINDOW_TYPE_TOOLTIP);
1934         break;
1935
1936       case ELM_WIN_NOTIFICATION:
1937         ecore_x_netwm_window_type_set
1938           (sd->x.xwin, ECORE_X_WINDOW_TYPE_NOTIFICATION);
1939         break;
1940
1941       case ELM_WIN_COMBO:
1942         ecore_x_netwm_window_type_set(sd->x.xwin, ECORE_X_WINDOW_TYPE_COMBO);
1943         break;
1944
1945       case ELM_WIN_DND:
1946         ecore_x_netwm_window_type_set(sd->x.xwin, ECORE_X_WINDOW_TYPE_DND);
1947         break;
1948
1949       default:
1950         break;
1951      }
1952    ecore_x_e_virtual_keyboard_state_set
1953      (sd->x.xwin, (Ecore_X_Virtual_Keyboard_State)sd->kbdmode);
1954    if (sd->indmode == ELM_WIN_INDICATOR_SHOW)
1955      ecore_x_e_illume_indicator_state_set
1956        (sd->x.xwin, ECORE_X_ILLUME_INDICATOR_STATE_ON);
1957    else if (sd->indmode == ELM_WIN_INDICATOR_HIDE)
1958      ecore_x_e_illume_indicator_state_set
1959        (sd->x.xwin, ECORE_X_ILLUME_INDICATOR_STATE_OFF);
1960 }
1961
1962 #endif
1963
1964 /**
1965   * @internal
1966   *
1967   * Resize the window according to window layout's min and weight.
1968   * If the window layout's weight is 0.0, the window max is limited to layout's
1969   * min size.
1970   *
1971   * This is called when the window layout's weight hint is changed or when the
1972   * window is rotated.
1973   *
1974   * @param obj window object
1975   */
1976 static void
1977 _elm_win_resize_objects_eval(Evas_Object *obj)
1978 {
1979    ELM_WIN_DATA_GET(obj, sd);
1980    Evas_Coord w, h, minw, minh, maxw, maxh;
1981    double wx, wy;
1982
1983    evas_object_size_hint_min_get(sd->layout, &minw, &minh);
1984    if (minw < 1) minw = 1;
1985    if (minh < 1) minh = 1;
1986
1987    evas_object_size_hint_weight_get(sd->layout, &wx, &wy);
1988    if (!wx) maxw = minw;
1989    else maxw = 32767;
1990    if (!wy) maxh = minh;
1991    else maxh = 32767;
1992
1993    evas_object_size_hint_min_set(obj, minw, minh);
1994    evas_object_size_hint_max_set(obj, maxw, maxh);
1995    evas_object_geometry_get(obj, NULL, NULL, &w, &h);
1996    if (w < minw) w = minw;
1997    if (h < minh) h = minh;
1998    if (w > maxw) w = maxw;
1999    if (h > maxh) h = maxh;
2000    evas_object_move(obj, 0, 0);
2001    evas_object_resize(obj, w, h);
2002 }
2003
2004 static void
2005 _elm_win_on_resize_obj_changed_size_hints(void *data,
2006                                           Evas *e EINA_UNUSED,
2007                                           Evas_Object *obj EINA_UNUSED,
2008                                           void *event_info EINA_UNUSED)
2009 {
2010    _elm_win_resize_objects_eval(data);
2011 }
2012
2013 void
2014 _elm_win_shutdown(void)
2015 {
2016    while (_elm_win_list) evas_object_del(_elm_win_list->data);
2017    ELM_SAFE_FREE(_elm_win_state_eval_job, ecore_job_del);
2018 }
2019
2020 void
2021 _elm_win_rescale(Elm_Theme *th,
2022                  Eina_Bool use_theme)
2023 {
2024    const Eina_List *l;
2025    Evas_Object *obj;
2026
2027    if (!use_theme)
2028      {
2029         EINA_LIST_FOREACH(_elm_win_list, l, obj)
2030           elm_widget_theme(obj);
2031      }
2032    else
2033      {
2034         EINA_LIST_FOREACH(_elm_win_list, l, obj)
2035           elm_widget_theme_specific(obj, th, EINA_FALSE);
2036      }
2037 }
2038
2039 void
2040 _elm_win_access(Eina_Bool is_access)
2041 {
2042    Evas *evas;
2043    const Eina_List *l;
2044    Evas_Object *obj;
2045    Evas_Object *fobj;
2046
2047    EINA_LIST_FOREACH(_elm_win_list, l, obj)
2048      {
2049         elm_widget_access(obj, is_access);
2050
2051          /* floating orphan object. if there are A, B, C objects and user does
2052             as below, then there would be floating orphan objects.
2053
2054               1. elm_object_content_set(layout, A);
2055               2. elm_object_content_set(layout, B);
2056               3. elm_object_content_set(layout, C);
2057
2058             now, the object A and B are floating orphan objects */
2059
2060         fobj = obj;
2061         for (;;)
2062           {
2063              fobj = evas_object_below_get(fobj);
2064              if (!fobj) break;
2065
2066              if (elm_widget_is(fobj) && !elm_widget_parent_get(fobj))
2067                {
2068                   elm_widget_access(fobj, is_access);
2069                }
2070           }
2071
2072         if (!is_access)
2073           {
2074              evas = evas_object_evas_get(obj);
2075             if (evas) _elm_access_object_highlight_disable(evas);
2076           }
2077      }
2078 }
2079
2080 void
2081 _elm_win_translate(void)
2082 {
2083    const Eina_List *l;
2084    Evas_Object *obj;
2085
2086    EINA_LIST_FOREACH(_elm_win_list, l, obj)
2087      elm_widget_translate(obj);
2088 }
2089
2090 #ifdef HAVE_ELEMENTARY_X
2091 static Eina_Bool
2092 _elm_win_client_message(void *data,
2093                         int type EINA_UNUSED,
2094                         void *event)
2095 {
2096    ELM_WIN_DATA_GET(data, sd);
2097    Ecore_X_Event_Client_Message *e = event;
2098
2099    if (e->format != 32) return ECORE_CALLBACK_PASS_ON;
2100    if (e->message_type == ECORE_X_ATOM_E_COMP_FLUSH)
2101      {
2102         if ((unsigned int)e->data.l[0] == sd->x.xwin)
2103           {
2104              Evas *evas = evas_object_evas_get(sd->obj);
2105              if (evas)
2106                {
2107                   edje_file_cache_flush();
2108                   edje_collection_cache_flush();
2109                   evas_image_cache_flush(evas);
2110                   evas_font_cache_flush(evas);
2111                }
2112           }
2113      }
2114    else if (e->message_type == ECORE_X_ATOM_E_COMP_DUMP)
2115      {
2116         if ((unsigned int)e->data.l[0] == sd->x.xwin)
2117           {
2118              Evas *evas = evas_object_evas_get(sd->obj);
2119              if (evas)
2120                {
2121                   edje_file_cache_flush();
2122                   edje_collection_cache_flush();
2123                   evas_image_cache_flush(evas);
2124                   evas_font_cache_flush(evas);
2125                   evas_render_dump(evas);
2126                }
2127           }
2128      }
2129    else if (e->message_type == ECORE_X_ATOM_E_ILLUME_ACCESS_CONTROL)
2130      {
2131         if ((unsigned int)e->data.l[0] == sd->x.xwin)
2132           {
2133              if ((unsigned int)e->data.l[1] ==
2134                  ECORE_X_ATOM_E_ILLUME_ACCESS_ACTION_NEXT)
2135                {
2136                   // XXX: call right access func
2137                }
2138              else if ((unsigned int)e->data.l[1] ==
2139                       ECORE_X_ATOM_E_ILLUME_ACCESS_ACTION_PREV)
2140                {
2141                   // XXX: call right access func
2142                }
2143              else if ((unsigned int)e->data.l[1] ==
2144                       ECORE_X_ATOM_E_ILLUME_ACCESS_ACTION_ACTIVATE)
2145                {
2146                   _elm_access_highlight_object_activate
2147                     (sd->obj, ELM_ACTIVATE_DEFAULT);
2148                }
2149              else if ((unsigned int)e->data.l[1] ==
2150                       ECORE_X_ATOM_E_ILLUME_ACCESS_ACTION_READ)
2151                {
2152                   /* there would be better way to read highlight object */
2153                   Evas *evas;
2154                   evas = evas_object_evas_get(sd->obj);
2155                   if (!evas) return ECORE_CALLBACK_PASS_ON;
2156
2157                   _elm_access_mouse_event_enabled_set(EINA_TRUE);
2158
2159                   evas_event_feed_mouse_in(evas, 0, NULL);
2160                   evas_event_feed_mouse_move
2161                     (evas, e->data.l[2], e->data.l[3], 0, NULL);
2162
2163                   _elm_access_mouse_event_enabled_set(EINA_FALSE);
2164                }
2165              else if ((unsigned int)e->data.l[1] ==
2166                       ECORE_X_ATOM_E_ILLUME_ACCESS_ACTION_READ_NEXT)
2167                {
2168                   _elm_access_highlight_cycle(sd->obj, ELM_FOCUS_NEXT);
2169                }
2170              else if ((unsigned int)e->data.l[1] ==
2171                       ECORE_X_ATOM_E_ILLUME_ACCESS_ACTION_READ_PREV)
2172                {
2173                   _elm_access_highlight_cycle(sd->obj, ELM_FOCUS_PREVIOUS);
2174                }
2175              else if ((unsigned int)e->data.l[1] ==
2176                       ECORE_X_ATOM_E_ILLUME_ACCESS_ACTION_UP)
2177                {
2178                   _elm_access_highlight_object_activate
2179                     (sd->obj, ELM_ACTIVATE_UP);
2180                }
2181              else if ((unsigned int)e->data.l[1] ==
2182                       ECORE_X_ATOM_E_ILLUME_ACCESS_ACTION_DOWN)
2183                {
2184                   _elm_access_highlight_object_activate
2185                     (sd->obj, ELM_ACTIVATE_DOWN);
2186                }
2187           }
2188      }
2189    return ECORE_CALLBACK_PASS_ON;
2190 }
2191
2192 static Eina_Bool
2193 _elm_win_property_change(void *data,
2194                          int type EINA_UNUSED,
2195                          void *event)
2196 {
2197    ELM_WIN_DATA_GET(data, sd);
2198    Ecore_X_Event_Window_Property *e = event;
2199
2200    if (e->atom == ECORE_X_ATOM_E_ILLUME_INDICATOR_STATE)
2201      {
2202         if (e->win == sd->x.xwin)
2203           {
2204              sd->indmode = (Elm_Win_Indicator_Mode)ecore_x_e_illume_indicator_state_get(e->win);
2205              evas_object_smart_callback_call(sd->obj, SIG_INDICATOR_PROP_CHANGED, NULL);
2206           }
2207      }
2208    return ECORE_CALLBACK_PASS_ON;
2209 }
2210 #endif
2211
2212 static void
2213 _elm_win_focus_highlight_hide(void *data EINA_UNUSED,
2214                               Evas_Object *obj,
2215                               const char *emission EINA_UNUSED,
2216                               const char *source EINA_UNUSED)
2217 {
2218    evas_object_hide(obj);
2219 }
2220
2221 static void
2222 _elm_win_focus_highlight_anim_end(void *data,
2223                                   Evas_Object *obj,
2224                                   const char *emission EINA_UNUSED,
2225                                   const char *source EINA_UNUSED)
2226 {
2227    ELM_WIN_DATA_GET(data, sd);
2228
2229    _elm_win_focus_highlight_simple_setup(sd, obj);
2230 }
2231
2232 static void
2233 _elm_win_focus_highlight_init(Elm_Win_Smart_Data *sd)
2234 {
2235    evas_event_callback_add(sd->evas, EVAS_CALLBACK_CANVAS_OBJECT_FOCUS_IN,
2236                            _elm_win_object_focus_in, sd->obj);
2237    evas_event_callback_add(sd->evas,
2238                            EVAS_CALLBACK_CANVAS_OBJECT_FOCUS_OUT,
2239                            _elm_win_object_focus_out, sd->obj);
2240
2241    sd->focus_highlight.cur.target = evas_focus_get(sd->evas);
2242    sd->focus_highlight.fobj = edje_object_add(sd->evas);
2243    sd->focus_highlight.theme_changed = EINA_TRUE;
2244
2245    edje_object_signal_callback_add(sd->focus_highlight.fobj,
2246                                    "elm,action,focus,hide,end", "*",
2247                                    _elm_win_focus_highlight_hide, NULL);
2248    edje_object_signal_callback_add(sd->focus_highlight.fobj,
2249                                    "elm,action,focus,anim,end", "*",
2250                                    _elm_win_focus_highlight_anim_end, sd->obj);
2251    _elm_win_focus_highlight_reconfigure_job_start(sd);
2252 }
2253
2254 static void
2255 _elm_win_frame_cb_move_start(void *data,
2256                              Evas_Object *obj EINA_UNUSED,
2257                              const char *sig EINA_UNUSED,
2258                              const char *source)
2259 {
2260    ELM_WIN_DATA_GET(data, sd);
2261
2262    if (!sd) return;
2263
2264 #ifdef HAVE_ELEMENTARY_WAYLAND
2265    if (!strcmp(source, "elm"))
2266      ecore_wl_window_cursor_from_name_set(sd->wl.win, ELM_CURSOR_HAND1);
2267    else
2268      ecore_wl_window_cursor_default_restore(sd->wl.win);
2269 #else
2270    (void)source;
2271 #endif
2272
2273    /* FIXME: Change mouse pointer */
2274
2275    /* NB: Wayland handles moving surfaces by itself so we cannot
2276     * specify a specific x/y we want. Instead, we will pass in the
2277     * existing x/y values so they can be recorded as 'previous'
2278     * position. The new position will get updated automatically when
2279     * the move is finished */
2280
2281    ecore_evas_wayland_move(sd->ee, sd->screen.x, sd->screen.y);
2282 }
2283
2284 static void
2285 _elm_win_frame_cb_move_stop(void *data,
2286                             Evas_Object *obj EINA_UNUSED,
2287                             const char *sig EINA_UNUSED,
2288                             const char *source EINA_UNUSED)
2289 {
2290    ELM_WIN_DATA_GET(data, sd);
2291
2292    if (!sd) return;
2293
2294 #ifdef HAVE_ELEMENTARY_WAYLAND
2295    ecore_wl_window_cursor_default_restore(sd->wl.win);
2296 #endif
2297 }
2298
2299 #ifdef HAVE_ELEMENTARY_WAYLAND
2300 struct _resize_info
2301 {
2302    const char *name;
2303    int location;
2304 };
2305
2306 static struct _resize_info _border_side[4] =
2307 {
2308      { ELM_CURSOR_TOP_SIDE, 1 },
2309      { ELM_CURSOR_LEFT_SIDE, 4 },
2310      { ELM_CURSOR_BOTTOM_SIDE, 2 },
2311      { ELM_CURSOR_RIGHT_SIDE, 8 },
2312 };
2313
2314 static struct _resize_info _border_corner[4] =
2315 {
2316      { ELM_CURSOR_TOP_LEFT_CORNER, 5 },
2317      { ELM_CURSOR_BOTTOM_LEFT_CORNER, 6 },
2318      { ELM_CURSOR_BOTTOM_RIGHT_CORNER, 10 },
2319      { ELM_CURSOR_TOP_RIGHT_CORNER, 9 },
2320 };
2321 #endif
2322
2323 static void
2324 _elm_win_frame_obj_update(Elm_Win_Smart_Data *sd)
2325 {
2326    int fx, fy, fw, fh;
2327    int ox, oy, ow, oh;
2328    int sx, sy, sw, sh;
2329    int x, y, w, h;
2330    evas_object_geometry_get(sd->frame_obj, &fx, &fy, &fw, &fh);
2331    evas_object_geometry_get(sd->client_obj, &ox, &oy, &ow, &oh);
2332    evas_object_geometry_get(sd->spacer_obj, &sx, &sy, &sw, &sh);
2333
2334    evas_output_framespace_get(sd->evas, &x, &y, &w, &h);
2335
2336    if ((x != (ox - fx)) || (y != (oy - fy)) ||
2337        (w != (fw - ow)) || (h != (fh - oh)))
2338      {
2339         evas_output_framespace_set(sd->evas, (ox - fx), (oy - fy),
2340                                    (fw - ow), (fh - oh));
2341      }
2342
2343 #ifdef HAVE_ELEMENTARY_WAYLAND
2344    ecore_wl_window_opaque_region_set(sd->wl.win, -fx, -(fy - sy), sw, sh);
2345 #endif
2346 }
2347
2348 static void
2349 _elm_win_frame_obj_move(void *data,
2350                         Evas *e EINA_UNUSED,
2351                         Evas_Object *obj EINA_UNUSED,
2352                         void *event_info EINA_UNUSED)
2353 {
2354    Elm_Win_Smart_Data *sd;
2355
2356    if (!(sd = data)) return;
2357    if (!sd->client_obj) return;
2358
2359    _elm_win_frame_obj_update(sd);
2360 }
2361
2362 static void
2363 _elm_win_frame_obj_resize(void *data,
2364                           Evas *e EINA_UNUSED,
2365                           Evas_Object *obj EINA_UNUSED,
2366                           void *event_info EINA_UNUSED)
2367 {
2368    Elm_Win_Smart_Data *sd;
2369
2370    if (!(sd = data)) return;
2371    if (!sd->client_obj) return;
2372
2373    _elm_win_frame_obj_update(sd);
2374 }
2375
2376 static void
2377 _elm_win_frame_cb_resize_show(void *data,
2378                               Evas_Object *obj EINA_UNUSED,
2379                               const char *sig EINA_UNUSED,
2380                               const char *source)
2381 {
2382    ELM_WIN_DATA_GET(data, sd);
2383
2384    if (!sd) return;
2385    if (sd->resizing) return;
2386
2387 #ifdef HAVE_ELEMENTARY_WAYLAND
2388    int i;
2389    i = sd->rot / 90;
2390    if (!strcmp(source, "elm.event.resize.t"))
2391      ecore_wl_window_cursor_from_name_set(sd->wl.win,
2392                                           _border_side[(0 + i) % 4].name);
2393    else if (!strcmp(source, "elm.event.resize.b"))
2394      ecore_wl_window_cursor_from_name_set(sd->wl.win,
2395                                           _border_side[(2 + i) % 4].name);
2396    else if (!strcmp(source, "elm.event.resize.l"))
2397      ecore_wl_window_cursor_from_name_set(sd->wl.win,
2398                                           _border_side[(1 + i) % 4].name);
2399    else if (!strcmp(source, "elm.event.resize.r"))
2400      ecore_wl_window_cursor_from_name_set(sd->wl.win,
2401                                           _border_side[(3 + i) % 4].name);
2402    else if (!strcmp(source, "elm.event.resize.tl"))
2403      ecore_wl_window_cursor_from_name_set(sd->wl.win,
2404                                           _border_corner[(0 + i) % 4].name);
2405    else if (!strcmp(source, "elm.event.resize.tr"))
2406      ecore_wl_window_cursor_from_name_set(sd->wl.win,
2407                                           _border_corner[(3 + i) % 4].name);
2408    else if (!strcmp(source, "elm.event.resize.bl"))
2409      ecore_wl_window_cursor_from_name_set(sd->wl.win,
2410                                           _border_corner[(1 + i) % 4].name);
2411    else if (!strcmp(source, "elm.event.resize.br"))
2412      ecore_wl_window_cursor_from_name_set(sd->wl.win,
2413                                           _border_corner[(2 + i) % 4].name);
2414    else
2415      ecore_wl_window_cursor_default_restore(sd->wl.win);
2416 #else
2417    (void)source;
2418 #endif
2419 }
2420
2421 static void
2422 _elm_win_frame_cb_resize_hide(void *data,
2423                               Evas_Object *obj EINA_UNUSED,
2424                               const char *sig EINA_UNUSED,
2425                               const char *source EINA_UNUSED)
2426 {
2427    ELM_WIN_DATA_GET(data, sd);
2428
2429    if (!sd) return;
2430    if (sd->resizing) return;
2431
2432 #ifdef HAVE_ELEMENTARY_WAYLAND
2433    ecore_wl_window_cursor_default_restore(sd->wl.win);
2434 #endif
2435 }
2436
2437 static void
2438 _elm_win_frame_cb_resize_start(void *data,
2439                                Evas_Object *obj EINA_UNUSED,
2440                                const char *sig EINA_UNUSED,
2441                                const char *source)
2442 {
2443 #ifdef HAVE_ELEMENTARY_WAYLAND
2444    ELM_WIN_DATA_GET(data, sd);
2445    int i;
2446
2447    if (!sd) return;
2448    if (sd->resizing) return;
2449
2450    sd->resizing = EINA_TRUE;
2451    i = sd->rot / 90;
2452    if (!strcmp(source, "elm.event.resize.t"))
2453      sd->resize_location = _border_side[(0 + i) % 4].location;
2454    else if (!strcmp(source, "elm.event.resize.b"))
2455      sd->resize_location = _border_side[(2 + i) % 4].location;
2456    else if (!strcmp(source, "elm.event.resize.l"))
2457      sd->resize_location = _border_side[(1 + i) % 4].location;
2458    else if (!strcmp(source, "elm.event.resize.r"))
2459      sd->resize_location = _border_side[(3 + i) % 4].location;
2460    else if (!strcmp(source, "elm.event.resize.tl"))
2461      sd->resize_location = _border_corner[(0 + i) % 4].location;
2462    else if (!strcmp(source, "elm.event.resize.tr"))
2463      sd->resize_location = _border_corner[(3 + i) % 4].location;
2464    else if (!strcmp(source, "elm.event.resize.bl"))
2465      sd->resize_location = _border_corner[(1 + i) % 4].location;
2466    else if (!strcmp(source, "elm.event.resize.br"))
2467      sd->resize_location = _border_corner[(2 + i) % 4].location;
2468    else
2469      sd->resize_location = 0;
2470
2471    if (sd->resize_location > 0)
2472      ecore_evas_wayland_resize(sd->ee, sd->resize_location);
2473 #else
2474    (void)data;
2475    (void)source;
2476 #endif
2477 }
2478
2479 static void
2480 _elm_win_frame_cb_minimize(void *data,
2481                            Evas_Object *obj EINA_UNUSED,
2482                            const char *sig EINA_UNUSED,
2483                            const char *source EINA_UNUSED)
2484 {
2485    ELM_WIN_DATA_GET(data, sd);
2486
2487    if (!sd) return;
2488 //   sd->iconified = EINA_TRUE;
2489    TRAP(sd, iconified_set, EINA_TRUE);
2490 }
2491
2492 static void
2493 _elm_win_frame_maximized_state_update(Elm_Win_Smart_Data *sd, Eina_Bool maximized)
2494 {
2495    const char *emission;
2496
2497    if (maximized)
2498      emission = "elm,state,maximized";
2499    else
2500      emission = "elm,state,unmaximized";
2501
2502    edje_object_signal_emit(sd->frame_obj, emission, "elm");
2503    edje_object_message_signal_process(sd->frame_obj);
2504    evas_object_smart_calculate(sd->frame_obj);
2505
2506    _elm_win_frame_obj_update(sd);
2507 }
2508
2509 static void
2510 _elm_win_frame_cb_maximize(void *data,
2511                            Evas_Object *obj EINA_UNUSED,
2512                            const char *sig EINA_UNUSED,
2513                            const char *source EINA_UNUSED)
2514 {
2515    Eina_Bool value;
2516    ELM_WIN_DATA_GET(data, sd);
2517
2518    if (!sd) return;
2519    if (sd->maximized) value = EINA_FALSE;
2520    else value = EINA_TRUE;
2521
2522    _elm_win_frame_maximized_state_update(sd, value);
2523
2524    TRAP(sd, maximized_set, value);
2525 }
2526
2527 static void
2528 _elm_win_frame_cb_close(void *data,
2529                         Evas_Object *obj EINA_UNUSED,
2530                         const char *sig EINA_UNUSED,
2531                         const char *source EINA_UNUSED)
2532 {
2533    ELM_WIN_DATA_GET(data, sd);
2534    Evas_Object *win;
2535
2536    /* FIXME: After the current freeze, this should be handled differently.
2537     *
2538     * Ideally, we would want to mimic the X11 backend and use something
2539     * like ECORE_WL_EVENT_WINDOW_DELETE and handle the delete_request
2540     * inside of ecore_evas. That would be the 'proper' way, but since we are
2541     * in a freeze right now, I cannot add a new event value, or a new
2542     * event structure to ecore_wayland.
2543     *
2544     * So yes, this is a temporary 'stop-gap' solution which will be fixed
2545     * when the freeze is over, but it does fix a trac bug for now, and in a
2546     * way which does not break API or the freeze. - dh
2547     */
2548
2549    if (!sd) return;
2550
2551    win = sd->obj;
2552
2553    int autodel = sd->autodel;
2554    sd->autodel_clear = &autodel;
2555    evas_object_ref(win);
2556    evas_object_smart_callback_call(win, SIG_DELETE_REQUEST, NULL);
2557    // FIXME: if above callback deletes - then the below will be invalid
2558    if (autodel) evas_object_del(win);
2559    else sd->autodel_clear = NULL;
2560    evas_object_unref(win);
2561 }
2562
2563 static void
2564 _elm_win_frame_add(Elm_Win_Smart_Data *sd,
2565                    const char *style)
2566 {
2567    Evas_Object *obj = sd->obj;
2568    int w, h, mw, mh;
2569    short layer;
2570
2571    sd->frame_obj = edje_object_add(sd->evas);
2572    layer = evas_object_layer_get(obj);
2573    evas_object_layer_set(sd->frame_obj, layer + 1);
2574    if (!elm_widget_theme_object_set
2575        (sd->obj, sd->frame_obj, "border", "base", style))
2576      {
2577         ELM_SAFE_FREE(sd->frame_obj, evas_object_del);
2578         return;
2579      }
2580
2581    sd->spacer_obj = evas_object_rectangle_add(sd->evas);
2582    evas_object_color_set(sd->spacer_obj, 0, 0, 0, 0);
2583    evas_object_repeat_events_set(sd->spacer_obj, EINA_TRUE);
2584    edje_object_part_swallow(sd->frame_obj, "elm.swallow.frame_spacer",
2585                             sd->spacer_obj);
2586
2587    sd->client_obj = evas_object_rectangle_add(sd->evas);
2588    evas_object_color_set(sd->client_obj, 0, 0, 0, 0);
2589    /* NB: Tried pass_events here, but that fails to send events */
2590    evas_object_repeat_events_set(sd->client_obj, EINA_TRUE);
2591    edje_object_part_swallow(sd->frame_obj, "elm.swallow.client",
2592                             sd->client_obj);
2593
2594    evas_object_is_frame_object_set(sd->frame_obj, EINA_TRUE);
2595
2596    evas_object_event_callback_add
2597      (sd->frame_obj, EVAS_CALLBACK_MOVE, _elm_win_frame_obj_move, sd);
2598    evas_object_event_callback_add
2599      (sd->frame_obj, EVAS_CALLBACK_RESIZE, _elm_win_frame_obj_resize, sd);
2600
2601    /* NB: Do NOT remove these calls !! Needed to calculate proper
2602     * framespace on inital show of the window */
2603    edje_object_size_min_calc(sd->frame_obj, &mw, &mh);
2604    evas_object_move(sd->frame_obj, 0, 0);
2605    evas_object_resize(sd->frame_obj, mw, mh);
2606    evas_object_smart_calculate(sd->frame_obj);
2607
2608    edje_object_signal_callback_add
2609      (sd->frame_obj, "elm,action,move,start", "elm",
2610      _elm_win_frame_cb_move_start, obj);
2611    edje_object_signal_callback_add
2612      (sd->frame_obj, "elm,action,move,stop", "elm",
2613      _elm_win_frame_cb_move_stop, obj);
2614    edje_object_signal_callback_add
2615      (sd->frame_obj, "elm,action,resize,show", "*",
2616      _elm_win_frame_cb_resize_show, obj);
2617    edje_object_signal_callback_add
2618      (sd->frame_obj, "elm,action,resize,hide", "*",
2619      _elm_win_frame_cb_resize_hide, obj);
2620    edje_object_signal_callback_add
2621      (sd->frame_obj, "elm,action,resize,start", "*",
2622      _elm_win_frame_cb_resize_start, obj);
2623    edje_object_signal_callback_add
2624      (sd->frame_obj, "elm,action,minimize", "elm",
2625      _elm_win_frame_cb_minimize, obj);
2626    edje_object_signal_callback_add
2627      (sd->frame_obj, "elm,action,maximize", "elm",
2628      _elm_win_frame_cb_maximize, obj);
2629    edje_object_signal_callback_add
2630      (sd->frame_obj, "elm,action,close", "elm", _elm_win_frame_cb_close, obj);
2631
2632    if (sd->title)
2633      {
2634         edje_object_part_text_escaped_set
2635           (sd->frame_obj, "elm.text.title", sd->title);
2636      }
2637
2638    ecore_evas_geometry_get(sd->ee, NULL, NULL, &w, &h);
2639    ecore_evas_resize(sd->ee, w, h);
2640 }
2641
2642 static void
2643 _elm_win_frame_del(Elm_Win_Smart_Data *sd)
2644 {
2645    int w, h;
2646
2647    ELM_SAFE_FREE(sd->client_obj, evas_object_del);
2648
2649    if (sd->frame_obj)
2650      {
2651         evas_object_event_callback_del_full
2652           (sd->frame_obj, EVAS_CALLBACK_MOVE, _elm_win_frame_obj_move, sd);
2653         evas_object_event_callback_del_full
2654           (sd->frame_obj, EVAS_CALLBACK_RESIZE, _elm_win_frame_obj_resize, sd);
2655
2656         edje_object_signal_callback_del
2657           (sd->frame_obj, "elm,action,move,start", "elm",
2658               _elm_win_frame_cb_move_start);
2659         edje_object_signal_callback_del
2660           (sd->frame_obj, "elm,action,move,stop", "elm",
2661               _elm_win_frame_cb_move_stop);
2662         edje_object_signal_callback_del
2663           (sd->frame_obj, "elm,action,resize,show", "*",
2664               _elm_win_frame_cb_resize_show);
2665         edje_object_signal_callback_del
2666           (sd->frame_obj, "elm,action,resize,hide", "*",
2667               _elm_win_frame_cb_resize_hide);
2668         edje_object_signal_callback_del
2669           (sd->frame_obj, "elm,action,resize,start", "*",
2670               _elm_win_frame_cb_resize_start);
2671         edje_object_signal_callback_del
2672           (sd->frame_obj, "elm,action,minimize", "elm",
2673               _elm_win_frame_cb_minimize);
2674         edje_object_signal_callback_del
2675           (sd->frame_obj, "elm,action,maximize", "elm",
2676               _elm_win_frame_cb_maximize);
2677         edje_object_signal_callback_del
2678           (sd->frame_obj, "elm,action,close", "elm",
2679               _elm_win_frame_cb_close);
2680
2681         ELM_SAFE_FREE(sd->frame_obj, evas_object_del);
2682      }
2683
2684    evas_output_framespace_set(sd->evas, 0, 0, 0, 0);
2685    ecore_evas_geometry_get(sd->ee, NULL, NULL, &w, &h);
2686    ecore_evas_resize(sd->ee, w, h);
2687 }
2688
2689 #ifdef ELM_DEBUG
2690 static void
2691 _debug_key_down(void *data EINA_UNUSED,
2692                 Evas *e EINA_UNUSED,
2693                 Evas_Object *obj,
2694                 void *event_info)
2695 {
2696    Evas_Event_Key_Down *ev = event_info;
2697
2698    if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD)
2699      return;
2700
2701    if ((strcmp(ev->key, "F12")) ||
2702        (!evas_key_modifier_is_set(ev->modifiers, "Control")))
2703      return;
2704
2705    INF("Tree graph generated.");
2706    elm_object_tree_dot_dump(obj, "./dump.dot");
2707 }
2708
2709 #endif
2710
2711 static void
2712 _win_inlined_image_set(Elm_Win_Smart_Data *sd)
2713 {
2714    evas_object_image_alpha_set(sd->img_obj, EINA_FALSE);
2715    evas_object_image_filled_set(sd->img_obj, EINA_TRUE);
2716
2717    evas_object_event_callback_add
2718      (sd->img_obj, EVAS_CALLBACK_DEL, _elm_win_on_img_obj_del, sd->obj);
2719    evas_object_event_callback_add
2720      (sd->img_obj, EVAS_CALLBACK_HIDE, _win_img_hide, sd->obj);
2721    evas_object_event_callback_add
2722      (sd->img_obj, EVAS_CALLBACK_MOUSE_UP, _win_img_mouse_up, sd->obj);
2723    evas_object_event_callback_add
2724      (sd->img_obj, EVAS_CALLBACK_FOCUS_IN, _win_img_focus_in, sd->obj);
2725    evas_object_event_callback_add
2726      (sd->img_obj, EVAS_CALLBACK_FOCUS_OUT, _win_img_focus_out, sd->obj);
2727 }
2728
2729 static void
2730 _elm_win_on_icon_del(void *data,
2731                      Evas *e EINA_UNUSED,
2732                      Evas_Object *obj,
2733                      void *event_info EINA_UNUSED)
2734 {
2735    ELM_WIN_DATA_GET(data, sd);
2736
2737    if (sd->icon == obj) sd->icon = NULL;
2738 }
2739
2740 static void
2741 _elm_win_smart_add(Eo *obj, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED)
2742 {
2743    eo_do_super(obj, MY_CLASS, evas_obj_smart_add());
2744
2745    elm_widget_can_focus_set(obj, EINA_TRUE);
2746
2747    elm_widget_highlight_ignore_set(obj, EINA_TRUE);
2748 }
2749
2750 #ifdef HAVE_ELEMENTARY_X
2751 static void
2752 _elm_x_io_err(void *data EINA_UNUSED)
2753 {
2754    Eina_List *l;
2755    Evas_Object *obj;
2756
2757    EINA_LIST_FOREACH(_elm_win_list, l, obj)
2758      evas_object_smart_callback_call(obj, SIG_IOERR, NULL);
2759    elm_exit();
2760 }
2761 #endif
2762
2763 EAPI Evas_Object *
2764 elm_win_add(Evas_Object *parent,
2765             const char *name,
2766             Elm_Win_Type type)
2767 {
2768    Evas_Object *obj = eo_add_custom(MY_CLASS, parent, elm_obj_win_constructor(name, type));
2769    eo_unref(obj);
2770    return obj;
2771 }
2772
2773 static void
2774 _elm_win_cb_hide(void *data EINA_UNUSED,
2775                  Evas *e EINA_UNUSED,
2776                  Evas_Object *obj EINA_UNUSED,
2777                  void *event_info EINA_UNUSED)
2778 {
2779    _elm_win_state_eval_queue();
2780 }
2781
2782 static void
2783 _elm_win_cb_show(void *data EINA_UNUSED,
2784                  Evas *e EINA_UNUSED,
2785                  Evas_Object *obj EINA_UNUSED,
2786                  void *event_info EINA_UNUSED)
2787 {
2788    _elm_win_state_eval_queue();
2789 }
2790
2791 /**
2792   * @internal
2793   *
2794   * Recalculate the size of window considering its resize objects' weight and
2795   * min size. If any of its resize objects' weight equals to 0.0, window
2796   * layout's weight will be set to 0.0.
2797   *
2798   * @param o box object
2799   * @param p box's private data
2800   * @param data window object
2801   */
2802 static void
2803 _window_layout_stack(Evas_Object *o, Evas_Object_Box_Data *p, void *data)
2804 {
2805    const Eina_List *l;
2806    Evas_Object *child;
2807    Evas_Object_Box_Option *opt;
2808    Evas_Coord x, y, w, h;
2809    double wx, wy;
2810    Evas_Coord minw = -1, minh = -1;
2811    double weight_x = EVAS_HINT_EXPAND;
2812    double weight_y = EVAS_HINT_EXPAND;
2813
2814    EINA_LIST_FOREACH(p->children, l, opt)
2815      {
2816         child = opt->obj;
2817         evas_object_size_hint_weight_get(child, &wx, &wy);
2818         if (wx == 0.0) weight_x = 0;
2819         if (wy == 0.0) weight_y = 0;
2820
2821         evas_object_size_hint_min_get(child, &w, &h);
2822         if (w > minw) minw = w;
2823         if (h > minh) minh = h;
2824      }
2825
2826    evas_object_size_hint_min_set(o, minw, minh);
2827    evas_object_geometry_get(o, &x, &y, &w, &h);
2828    if (w < minw) w = minw;
2829    if (h < minh) h = minh;
2830    evas_object_resize(o, w, h);
2831
2832    EINA_LIST_FOREACH(p->children, l, opt)
2833      {
2834         child = opt->obj;
2835         evas_object_move(child, x, y);
2836         evas_object_resize(child, w, h);
2837      }
2838
2839    ELM_WIN_DATA_GET(data, sd);
2840    evas_object_size_hint_weight_set(sd->layout, weight_x, weight_y);
2841    evas_object_smart_changed(sd->layout);
2842 }
2843
2844 static void
2845 _win_constructor(Eo *obj, void *_pd, va_list *list)
2846 {
2847    Elm_Win_Smart_Data *sd = _pd;
2848    sd->obj = obj; // in ctor
2849
2850    const char *name = va_arg(*list, const char *);
2851    Elm_Win_Type type = va_arg(*list, Elm_Win_Type);
2852    Evas_Object *parent;
2853    Evas *e;
2854    const Eina_List *l;
2855    const char *fontpath, *fallback = NULL;
2856
2857    Elm_Win_Smart_Data tmp_sd;
2858
2859    eo_do(obj, eo_parent_get(&parent));
2860
2861    /* just to store some data while trying out to create a canvas */
2862    memset(&tmp_sd, 0, sizeof(Elm_Win_Smart_Data));
2863
2864 #define FALLBACK_TRY(engine)                                      \
2865   if (!tmp_sd.ee) {                                               \
2866      CRI(engine " engine creation failed. Trying default."); \
2867   } while (0)
2868 #define FALLBACK_STORE(engine)                               \
2869    if (tmp_sd.ee)                                            \
2870    {                                                         \
2871       CRI(engine "Fallback to %s successful.", engine); \
2872       fallback = engine;                                     \
2873    }
2874
2875    switch (type)
2876      {
2877       case ELM_WIN_INLINED_IMAGE:
2878         if (!parent) break;
2879           {
2880              e = evas_object_evas_get(parent);
2881              Ecore_Evas *ee;
2882
2883              if (!e) break;
2884
2885              ee = ecore_evas_ecore_evas_get(e);
2886              if (!ee) break;
2887
2888              tmp_sd.img_obj = ecore_evas_object_image_new(ee);
2889              if (!tmp_sd.img_obj) break;
2890
2891              tmp_sd.ee = ecore_evas_object_ecore_evas_get(tmp_sd.img_obj);
2892              if (!tmp_sd.ee)
2893                {
2894                   ELM_SAFE_FREE(tmp_sd.img_obj, evas_object_del);
2895                }
2896           }
2897         break;
2898
2899       case ELM_WIN_SOCKET_IMAGE:
2900         tmp_sd.ee = ecore_evas_extn_socket_new(1, 1);
2901         break;
2902
2903       default:
2904         if (ENGINE_COMPARE(ELM_SOFTWARE_X11))
2905           {
2906              tmp_sd.ee = ecore_evas_software_x11_new(NULL, 0, 0, 0, 1, 1);
2907              FALLBACK_TRY("Software X11");
2908              if (!tmp_sd.ee)
2909                {
2910                   tmp_sd.ee = ecore_evas_fb_new(NULL, 0, 1, 1);
2911                   FALLBACK_STORE("Software FB");
2912                }
2913           }
2914         else if (ENGINE_COMPARE(ELM_SOFTWARE_FB))
2915           {
2916              tmp_sd.ee = ecore_evas_fb_new(NULL, 0, 1, 1);
2917              FALLBACK_TRY("Software FB");
2918              if (!tmp_sd.ee)
2919                {
2920                   tmp_sd.ee = ecore_evas_software_x11_new(NULL, 0, 0, 0, 1, 1);
2921                   FALLBACK_STORE("Software X11");
2922                }
2923           }
2924         else if (ENGINE_COMPARE(ELM_OPENGL_X11))
2925           {
2926              int opt[10];
2927              int opt_i = 0;
2928
2929              if (_elm_config->vsync)
2930                {
2931                   opt[opt_i] = ECORE_EVAS_GL_X11_OPT_VSYNC;
2932                   opt_i++;
2933                   opt[opt_i] = 1;
2934                   opt_i++;
2935                   opt[opt_i] = 0;
2936                }
2937              if (opt_i > 0)
2938                tmp_sd.ee = ecore_evas_gl_x11_options_new
2939                    (NULL, 0, 0, 0, 1, 1, opt);
2940              else
2941                tmp_sd.ee = ecore_evas_gl_x11_new(NULL, 0, 0, 0, 1, 1);
2942              FALLBACK_TRY("OpenGL");
2943              if (!tmp_sd.ee)
2944                {
2945                   tmp_sd.ee = ecore_evas_software_x11_new(NULL, 0, 0, 0, 1, 1);
2946                   FALLBACK_STORE("Software X11");
2947                   if (!tmp_sd.ee)
2948                     {
2949                        tmp_sd.ee = ecore_evas_fb_new(NULL, 0, 1, 1);
2950                        FALLBACK_STORE("Software FB");
2951                     }
2952                }
2953           }
2954         else if (ENGINE_COMPARE(ELM_SOFTWARE_WIN32))
2955           {
2956              tmp_sd.ee = ecore_evas_software_gdi_new(NULL, 0, 0, 1, 1);
2957              FALLBACK_TRY("Software Win32");
2958           }
2959         else if (ENGINE_COMPARE(ELM_SOFTWARE_PSL1GHT))
2960           {
2961              tmp_sd.ee = ecore_evas_psl1ght_new(NULL, 1, 1);
2962              FALLBACK_TRY("PSL1GHT");
2963           }
2964         else if (ENGINE_COMPARE(ELM_SOFTWARE_SDL))
2965           {
2966              tmp_sd.ee = ecore_evas_sdl_new(NULL, 0, 0, 0, 0, 0, 1);
2967              FALLBACK_TRY("Software SDL");
2968              if (!tmp_sd.ee)
2969                {
2970                   tmp_sd.ee = ecore_evas_software_x11_new(NULL, 0, 0, 0, 1, 1);
2971                   FALLBACK_STORE("Software X11");
2972                   if (!tmp_sd.ee)
2973                     {
2974                        tmp_sd.ee = ecore_evas_fb_new(NULL, 0, 1, 1);
2975                        FALLBACK_STORE("Software FB");
2976                     }
2977                }
2978           }
2979         else if (ENGINE_COMPARE(ELM_SOFTWARE_16_SDL))
2980           {
2981              tmp_sd.ee = ecore_evas_sdl16_new(NULL, 0, 0, 0, 0, 0, 1);
2982              FALLBACK_TRY("Software-16-SDL");
2983              if (!tmp_sd.ee)
2984                {
2985                   tmp_sd.ee = ecore_evas_software_x11_new(NULL, 0, 0, 0, 1, 1);
2986                   FALLBACK_STORE("Software X11");
2987                   if (!tmp_sd.ee)
2988                     {
2989                        tmp_sd.ee = ecore_evas_fb_new(NULL, 0, 1, 1);
2990                        FALLBACK_STORE("Software FB");
2991                     }
2992                }
2993           }
2994         else if (ENGINE_COMPARE(ELM_OPENGL_SDL))
2995           {
2996              tmp_sd.ee = ecore_evas_gl_sdl_new(NULL, 1, 1, 0, 0);
2997              FALLBACK_TRY("OpenGL SDL");
2998              if (!tmp_sd.ee)
2999                {
3000                   tmp_sd.ee = ecore_evas_software_x11_new(NULL, 0, 0, 0, 1, 1);
3001                   FALLBACK_STORE("Software X11");
3002                   if (!tmp_sd.ee)
3003                     {
3004                        tmp_sd.ee = ecore_evas_fb_new(NULL, 0, 1, 1);
3005                        FALLBACK_STORE("Software FB");
3006                     }
3007                }
3008           }
3009         else if (ENGINE_COMPARE(ELM_OPENGL_COCOA))
3010           {
3011              tmp_sd.ee = ecore_evas_cocoa_new(NULL, 1, 1, 0, 0);
3012              FALLBACK_TRY("OpenGL Cocoa");
3013           }
3014         else if (ENGINE_COMPARE(ELM_BUFFER))
3015           {
3016              tmp_sd.ee = ecore_evas_buffer_new(1, 1);
3017           }
3018         else if (ENGINE_COMPARE(ELM_EWS))
3019           {
3020              tmp_sd.ee = ecore_evas_ews_new(0, 0, 1, 1);
3021           }
3022         else if (ENGINE_COMPARE(ELM_WAYLAND_SHM))
3023           {
3024              tmp_sd.ee = ecore_evas_wayland_shm_new(NULL, 0, 0, 0, 1, 1, 0);
3025           }
3026         else if (ENGINE_COMPARE(ELM_WAYLAND_EGL))
3027           {
3028              tmp_sd.ee = ecore_evas_wayland_egl_new(NULL, 0, 0, 0, 1, 1, 0);
3029           }
3030         else if (!strncmp(ENGINE_GET(), "shot:", 5))
3031           {
3032              tmp_sd.ee = ecore_evas_buffer_new(1, 1);
3033              ecore_evas_manual_render_set(tmp_sd.ee, EINA_TRUE);
3034              tmp_sd.shot.info = eina_stringshare_add
3035                  (ENGINE_GET() + 5);
3036           }
3037 #undef FALLBACK_TRY
3038         break;
3039      }
3040
3041    if (!tmp_sd.ee)
3042      {
3043         ERR("Cannot create window.");
3044         eo_error_set(obj);
3045         return;
3046      }
3047
3048    eo_do(obj, eo_parent_set(ecore_evas_get(tmp_sd.ee)));
3049    eo_do_super(obj, MY_CLASS, eo_constructor());
3050    eo_do(obj,
3051          evas_obj_type_set(MY_CLASS_NAME_LEGACY),
3052          evas_obj_smart_callbacks_descriptions_set(_smart_callbacks, NULL));
3053
3054    if (getenv("ELM_FIRST_FRAME"))
3055      evas_event_callback_add(ecore_evas_get(tmp_sd.ee), EVAS_CALLBACK_RENDER_POST,
3056                              _elm_win_first_frame_do, getenv("ELM_FIRST_FRAME"));
3057
3058    /* copying possibly altered fields back */
3059 #define SD_CPY(_field)             \
3060   do                               \
3061     {                              \
3062        sd->_field = tmp_sd._field; \
3063     } while (0)
3064
3065    SD_CPY(ee);
3066    SD_CPY(img_obj);
3067    SD_CPY(shot.info);
3068 #undef SD_CPY
3069
3070    if ((trap) && (trap->add))
3071      sd->trap_data = trap->add(obj);
3072
3073    /* complementary actions, which depend on final smart data
3074     * pointer */
3075    if (type == ELM_WIN_INLINED_IMAGE)
3076      _win_inlined_image_set(sd);
3077
3078 #ifdef HAVE_ELEMENTARY_X
3079    else if (ENGINE_COMPARE(ELM_SOFTWARE_X11) ||
3080             ENGINE_COMPARE(ELM_SOFTWARE_16_X11) ||
3081             ENGINE_COMPARE(ELM_SOFTWARE_8_X11) ||
3082             ENGINE_COMPARE(ELM_OPENGL_X11))
3083      {
3084         sd->x.client_message_handler = ecore_event_handler_add
3085             (ECORE_X_EVENT_CLIENT_MESSAGE, _elm_win_client_message, obj);
3086         sd->x.property_handler = ecore_event_handler_add
3087             (ECORE_X_EVENT_WINDOW_PROPERTY, _elm_win_property_change, obj);
3088      }
3089 #endif
3090
3091    else if (!strncmp(ENGINE_GET(), "shot:", 5))
3092      _shot_init(sd);
3093
3094    sd->kbdmode = ELM_WIN_KEYBOARD_UNKNOWN;
3095    sd->indmode = ELM_WIN_INDICATOR_UNKNOWN;
3096
3097 #ifdef HAVE_ELEMENTARY_X
3098    _elm_win_xwindow_get(sd);
3099    if (sd->x.xwin)
3100      {
3101         ecore_x_io_error_handler_set(_elm_x_io_err, NULL);
3102      }
3103 #endif
3104
3105 #ifdef HAVE_ELEMENTARY_WAYLAND
3106    if ((ENGINE_COMPARE(ELM_WAYLAND_SHM)) || (ENGINE_COMPARE(ELM_WAYLAND_EGL)))
3107      _elm_win_wlwindow_get(sd);
3108 #endif
3109
3110    if ((_elm_config->bgpixmap)
3111 #ifdef HAVE_ELEMENTARY_X
3112        &&
3113        (((sd->x.xwin) && (!ecore_x_screen_is_composited(0))) ||
3114            (!sd->x.xwin)))
3115 #else
3116       )
3117 #endif
3118      TRAP(sd, avoid_damage_set, ECORE_EVAS_AVOID_DAMAGE_EXPOSE);
3119    // bg pixmap done by x - has other issues like can be redrawn by x before it
3120    // is filled/ready by app
3121    //     TRAP(sd, avoid_damage_set, ECORE_EVAS_AVOID_DAMAGE_BUILT_IN);
3122
3123    sd->type = type;
3124    sd->parent = parent;
3125
3126    if (sd->parent)
3127      evas_object_event_callback_add
3128        (sd->parent, EVAS_CALLBACK_DEL, _elm_win_on_parent_del, obj);
3129
3130    sd->evas = ecore_evas_get(sd->ee);
3131
3132    evas_object_color_set(obj, 0, 0, 0, 0);
3133    evas_object_move(obj, 0, 0);
3134    evas_object_resize(obj, 1, 1);
3135    evas_object_layer_set(obj, 50);
3136    evas_object_pass_events_set(obj, EINA_TRUE);
3137
3138    if (type == ELM_WIN_INLINED_IMAGE)
3139      elm_widget_parent2_set(obj, parent);
3140
3141    /* use own version of ecore_evas_object_associate() that does TRAP() */
3142    ecore_evas_data_set(sd->ee, "elm_win", obj);
3143
3144    evas_object_event_callback_add
3145      (obj, EVAS_CALLBACK_CHANGED_SIZE_HINTS,
3146       _elm_win_obj_callback_changed_size_hints, obj);
3147
3148    evas_object_intercept_raise_callback_add
3149      (obj, _elm_win_obj_intercept_raise, obj);
3150    evas_object_intercept_lower_callback_add
3151      (obj, _elm_win_obj_intercept_lower, obj);
3152    evas_object_intercept_stack_above_callback_add
3153      (obj, _elm_win_obj_intercept_stack_above, obj);
3154    evas_object_intercept_stack_below_callback_add
3155      (obj, _elm_win_obj_intercept_stack_below, obj);
3156    evas_object_intercept_layer_set_callback_add
3157      (obj, _elm_win_obj_intercept_layer_set, obj);
3158    evas_object_intercept_show_callback_add
3159      (obj, _elm_win_obj_intercept_show, obj);
3160
3161    TRAP(sd, name_class_set, name, _elm_appname);
3162    ecore_evas_callback_delete_request_set(sd->ee, _elm_win_delete_request);
3163    ecore_evas_callback_resize_set(sd->ee, _elm_win_resize);
3164    ecore_evas_callback_mouse_in_set(sd->ee, _elm_win_mouse_in);
3165    ecore_evas_callback_focus_in_set(sd->ee, _elm_win_focus_in);
3166    ecore_evas_callback_focus_out_set(sd->ee, _elm_win_focus_out);
3167    ecore_evas_callback_move_set(sd->ee, _elm_win_move);
3168    ecore_evas_callback_state_change_set(sd->ee, _elm_win_state_change);
3169    evas_object_event_callback_add(obj, EVAS_CALLBACK_HIDE, _elm_win_cb_hide, NULL);
3170    evas_object_event_callback_add(obj, EVAS_CALLBACK_SHOW, _elm_win_cb_show, NULL);
3171
3172    evas_image_cache_set(sd->evas, (_elm_config->image_cache * 1024));
3173    evas_font_cache_set(sd->evas, (_elm_config->font_cache * 1024));
3174
3175    EINA_LIST_FOREACH(_elm_config->font_dirs, l, fontpath)
3176      evas_font_path_append(sd->evas, fontpath);
3177
3178    if (!_elm_config->font_hinting)
3179      evas_font_hinting_set(sd->evas, EVAS_FONT_HINTING_NONE);
3180    else if (_elm_config->font_hinting == 1)
3181      evas_font_hinting_set(sd->evas, EVAS_FONT_HINTING_AUTO);
3182    else if (_elm_config->font_hinting == 2)
3183      evas_font_hinting_set(sd->evas, EVAS_FONT_HINTING_BYTECODE);
3184
3185 #ifdef HAVE_ELEMENTARY_X
3186    _elm_win_xwin_update(sd);
3187 #endif
3188
3189    _elm_win_list = eina_list_append(_elm_win_list, obj);
3190    _elm_win_count++;
3191
3192    if (((fallback) && (!strcmp(fallback, "Software FB"))) ||
3193        ((!fallback) && (ENGINE_COMPARE(ELM_SOFTWARE_FB))))
3194      {
3195         TRAP(sd, fullscreen_set, 1);
3196      }
3197    else if ((type != ELM_WIN_INLINED_IMAGE) &&
3198             (ENGINE_COMPARE(ELM_WAYLAND_SHM) ||
3199              ENGINE_COMPARE(ELM_WAYLAND_EGL)))
3200      _elm_win_frame_add(sd, "default");
3201
3202    if (_elm_config->focus_highlight_enable)
3203      elm_win_focus_highlight_enabled_set(obj, EINA_TRUE);
3204    if (_elm_config->focus_highlight_animate)
3205      elm_win_focus_highlight_animate_set(obj, EINA_TRUE);
3206
3207 #ifdef ELM_DEBUG
3208    Evas_Modifier_Mask mask = evas_key_modifier_mask_get(sd->evas, "Control");
3209    evas_object_event_callback_add
3210      (obj, EVAS_CALLBACK_KEY_DOWN, _debug_key_down, NULL);
3211
3212    if (evas_object_key_grab(obj, "F12", mask, 0, EINA_TRUE))
3213      INF("Ctrl+F12 key combination exclusive for dot tree generation\n");
3214    else
3215      ERR("failed to grab F12 key to elm widgets (dot) tree generation");
3216 #endif
3217
3218    if ((_elm_config->softcursor_mode == ELM_SOFTCURSOR_MODE_ON) ||
3219        ((_elm_config->softcursor_mode == ELM_SOFTCURSOR_MODE_AUTO) &&
3220            (((fallback) && (!strcmp(fallback, "Software FB"))) ||
3221                ((!fallback) && (ENGINE_COMPARE(ELM_SOFTWARE_FB))))))
3222      {
3223         Evas_Object *o;
3224         Evas_Coord mw = 1, mh = 1, hx = 0, hy = 0;
3225
3226         sd->pointer.obj = o = edje_object_add(ecore_evas_get(tmp_sd.ee));
3227         _elm_theme_object_set(obj, o, "pointer", "base", "default");
3228         edje_object_size_min_calc(o, &mw, &mh);
3229         evas_object_resize(o, mw, mh);
3230         edje_object_part_geometry_get(o, "elm.swallow.hotspot",
3231                                       &hx, &hy, NULL, NULL);
3232         sd->pointer.hot_x = hx;
3233         sd->pointer.hot_y = hy;
3234         evas_object_show(o);
3235         ecore_evas_object_cursor_set(tmp_sd.ee, o, EVAS_LAYER_MAX, hx, hy);
3236      }
3237    else if (_elm_config->softcursor_mode == ELM_SOFTCURSOR_MODE_OFF)
3238      {
3239         // do nothing
3240      }
3241
3242    sd->wm_rot.wm_supported = ecore_evas_wm_rotation_supported_get(sd->ee);
3243    sd->wm_rot.preferred_rot = -1; // it means that elm_win doesn't use preferred rotation.
3244
3245    sd->layout = edje_object_add(sd->evas);
3246    _elm_theme_object_set(obj, sd->layout, "win", "base", "default");
3247    sd->box = evas_object_box_add(sd->evas);
3248    evas_object_box_layout_set(sd->box, _window_layout_stack, obj, NULL);
3249    edje_object_part_swallow(sd->layout, "elm.swallow.contents", sd->box);
3250    evas_object_move(sd->layout, 0, 0);
3251    evas_object_resize(sd->layout, 1, 1);
3252    edje_object_update_hints_set(sd->layout, EINA_TRUE);
3253    evas_object_event_callback_add(sd->layout, EVAS_CALLBACK_CHANGED_SIZE_HINTS,
3254                                   _elm_win_on_resize_obj_changed_size_hints, obj);
3255    evas_object_show(sd->layout);
3256 }
3257
3258 static void
3259 _constructor(Eo *obj, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED)
3260 {
3261    eo_error_set(obj);
3262    ERR("only custom constructor can be used with '%s' class", MY_CLASS_NAME);
3263 }
3264
3265 EAPI Elm_Win_Type
3266 elm_win_type_get(const Evas_Object *obj)
3267 {
3268    ELM_WIN_CHECK(obj) ELM_WIN_UNKNOWN;
3269    Elm_Win_Type ret = ELM_WIN_UNKNOWN;
3270    eo_do((Eo *) obj, elm_obj_win_type_get(&ret));
3271    return ret;
3272 }
3273
3274 static void
3275 _type_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
3276 {
3277    Elm_Win_Type *ret = va_arg(*list, Elm_Win_Type *);
3278    Elm_Win_Smart_Data *sd = _pd;
3279    *ret = sd->type;
3280 }
3281
3282 EAPI Evas_Object *
3283 elm_win_util_standard_add(const char *name,
3284                           const char *title)
3285 {
3286    Evas_Object *win, *bg;
3287
3288    win = elm_win_add(NULL, name, ELM_WIN_BASIC);
3289    if (!win) return NULL;
3290
3291    elm_win_title_set(win, title);
3292    bg = elm_bg_add(win);
3293    if (!bg)
3294      {
3295         evas_object_del(win);
3296         return NULL;
3297      }
3298    evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
3299    elm_win_resize_object_add(win, bg);
3300    evas_object_show(bg);
3301
3302    return win;
3303 }
3304
3305 EAPI void
3306 elm_win_resize_object_add(Evas_Object *obj,
3307                           Evas_Object *subobj)
3308 {
3309    ELM_WIN_CHECK(obj);
3310    eo_do(obj, elm_obj_win_resize_object_add(subobj));
3311 }
3312
3313 static void
3314 _resize_object_add(Eo *obj, void *_pd, va_list *list)
3315 {
3316    Evas_Object *subobj = va_arg(*list, Evas_Object *);
3317
3318    Elm_Win_Smart_Data *sd = _pd;
3319
3320    elm_widget_sub_object_add(obj, subobj);
3321
3322    if (!evas_object_box_append(sd->box, subobj))
3323      ERR("could not append %p to box", subobj);
3324 }
3325
3326 EAPI void
3327 elm_win_resize_object_del(Evas_Object *obj,
3328                           Evas_Object *subobj)
3329 {
3330    ELM_WIN_CHECK(obj);
3331    eo_do(obj, elm_obj_win_resize_object_del(subobj));
3332 }
3333
3334 static void
3335 _resize_object_del(Eo *obj, void *_pd, va_list *list)
3336 {
3337    Evas_Object *subobj = va_arg(*list, Evas_Object *);
3338    Elm_Win_Smart_Data *sd = _pd;
3339
3340    if (!elm_widget_sub_object_del(obj, subobj))
3341      ERR("could not remove sub object %p from %p", subobj, obj);
3342
3343    evas_object_box_remove(sd->box, subobj);
3344 }
3345
3346 EAPI void
3347 elm_win_title_set(Evas_Object *obj,
3348                   const char *title)
3349 {
3350    ELM_WIN_CHECK(obj);
3351    eo_do(obj, elm_obj_win_title_set(title));
3352 }
3353
3354 static void
3355 _title_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
3356 {
3357    const char *title = va_arg(*list, const char *);
3358    Elm_Win_Smart_Data *sd = _pd;
3359
3360    if (!title) return;
3361    eina_stringshare_replace(&(sd->title), title);
3362    TRAP(sd, title_set, sd->title);
3363    if (sd->frame_obj)
3364      edje_object_part_text_escaped_set
3365        (sd->frame_obj, "elm.text.title", sd->title);
3366 }
3367
3368 EAPI const char *
3369 elm_win_title_get(const Evas_Object *obj)
3370 {
3371    ELM_WIN_CHECK(obj) NULL;
3372    const char *ret = NULL;
3373    eo_do((Eo *) obj, elm_obj_win_title_get(&ret));
3374    return ret;
3375 }
3376
3377 static void
3378 _title_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
3379 {
3380    const char **ret = va_arg(*list, const char **);
3381    Elm_Win_Smart_Data *sd = _pd;
3382    *ret = sd->title;
3383 }
3384
3385 EAPI void
3386 elm_win_icon_name_set(Evas_Object *obj,
3387                       const char *icon_name)
3388 {
3389    ELM_WIN_CHECK(obj);
3390    eo_do(obj, elm_obj_win_icon_name_set(icon_name));
3391 }
3392
3393 static void
3394 _icon_name_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
3395 {
3396    const char *icon_name = va_arg(*list, const char *);
3397    Elm_Win_Smart_Data *sd = _pd;
3398
3399    if (!icon_name) return;
3400    eina_stringshare_replace(&(sd->icon_name), icon_name);
3401 #ifdef HAVE_ELEMENTARY_X
3402    _elm_win_xwin_update(sd);
3403 #endif
3404 }
3405
3406 EAPI const char *
3407 elm_win_icon_name_get(const Evas_Object *obj)
3408 {
3409    ELM_WIN_CHECK(obj) NULL;
3410    const char *ret = NULL;
3411    eo_do((Eo *) obj, elm_obj_win_icon_name_get(&ret));
3412    return ret;
3413 }
3414
3415 static void
3416 _icon_name_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
3417 {
3418    const char **ret = va_arg(*list, const char **);
3419    Elm_Win_Smart_Data *sd = _pd;
3420    *ret = sd->icon_name;
3421 }
3422
3423 EAPI void
3424 elm_win_role_set(Evas_Object *obj, const char *role)
3425 {
3426    ELM_WIN_CHECK(obj);
3427    eo_do(obj, elm_obj_win_role_set(role));
3428 }
3429
3430 static void
3431 _role_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
3432 {
3433    const char *role = va_arg(*list, const char *);
3434    Elm_Win_Smart_Data *sd = _pd;
3435
3436    if (!role) return;
3437    eina_stringshare_replace(&(sd->role), role);
3438 #ifdef HAVE_ELEMENTARY_X
3439    _elm_win_xwin_update(sd);
3440 #endif
3441 }
3442
3443 EAPI const char *
3444 elm_win_role_get(const Evas_Object *obj)
3445 {
3446    ELM_WIN_CHECK(obj) NULL;
3447    const char *ret = NULL;
3448    eo_do((Eo *) obj, elm_obj_win_role_get(&ret));
3449    return ret;
3450 }
3451
3452 static void
3453 _role_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
3454 {
3455    const char **ret = va_arg(*list, const char **);
3456    Elm_Win_Smart_Data *sd = _pd;
3457    *ret = sd->role;
3458 }
3459
3460 EAPI void
3461 elm_win_icon_object_set(Evas_Object *obj,
3462                         Evas_Object *icon)
3463 {
3464    ELM_WIN_CHECK(obj);
3465    eo_do(obj, elm_obj_win_icon_object_set(icon));
3466 }
3467
3468 static void
3469 _icon_object_set(Eo *obj, void *_pd, va_list *list)
3470 {
3471    Evas_Object *icon = va_arg(*list, Evas_Object *);
3472    Elm_Win_Smart_Data *sd = _pd;
3473
3474    if (sd->icon)
3475      evas_object_event_callback_del_full
3476        (sd->icon, EVAS_CALLBACK_DEL, _elm_win_on_icon_del, obj);
3477    sd->icon = icon;
3478    if (sd->icon)
3479      evas_object_event_callback_add
3480        (sd->icon, EVAS_CALLBACK_DEL, _elm_win_on_icon_del, obj);
3481 #ifdef HAVE_ELEMENTARY_X
3482    _elm_win_xwin_update(sd);
3483 #endif
3484 }
3485
3486 EAPI const Evas_Object *
3487 elm_win_icon_object_get(const Evas_Object *obj)
3488 {
3489    ELM_WIN_CHECK(obj) NULL;
3490    const Evas_Object *ret = NULL;
3491    eo_do((Eo *) obj, elm_obj_win_icon_object_get(&ret));
3492    return ret;
3493 }
3494
3495 static void
3496 _icon_object_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
3497 {
3498    const Evas_Object **ret = va_arg(*list, const Evas_Object **);
3499    Elm_Win_Smart_Data *sd = _pd;
3500    *ret = sd->icon;
3501 }
3502
3503 EAPI void
3504 elm_win_autodel_set(Evas_Object *obj,
3505                     Eina_Bool autodel)
3506 {
3507    ELM_WIN_CHECK(obj);
3508    eo_do(obj, elm_obj_win_autodel_set(autodel));
3509 }
3510
3511 static void
3512 _autodel_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
3513 {
3514    Eina_Bool autodel = va_arg(*list, int);
3515    Elm_Win_Smart_Data *sd = _pd;
3516    sd->autodel = autodel;
3517 }
3518
3519 EAPI Eina_Bool
3520 elm_win_autodel_get(const Evas_Object *obj)
3521 {
3522    ELM_WIN_CHECK(obj) EINA_FALSE;
3523    Eina_Bool ret = EINA_FALSE;
3524    eo_do((Eo *) obj, elm_obj_win_autodel_get(&ret));
3525    return ret;
3526 }
3527
3528 static void
3529 _autodel_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
3530 {
3531    Eina_Bool *ret = va_arg(*list, Eina_Bool *);
3532    Elm_Win_Smart_Data *sd = _pd;
3533    *ret = sd->autodel;
3534 }
3535
3536 EAPI void
3537 elm_win_activate(Evas_Object *obj)
3538 {
3539    ELM_WIN_CHECK(obj);
3540    eo_do(obj, elm_obj_win_activate());
3541 }
3542
3543 static void
3544 _activate(Eo *obj EINA_UNUSED, void *_pd, va_list *list EINA_UNUSED)
3545 {
3546    Elm_Win_Smart_Data *sd = _pd;
3547    TRAP(sd, activate);
3548 }
3549
3550 EAPI void
3551 elm_win_lower(Evas_Object *obj)
3552 {
3553    ELM_WIN_CHECK(obj);
3554    eo_do(obj, elm_obj_win_lower());
3555 }
3556
3557 static void
3558 _lower(Eo *obj EINA_UNUSED, void *_pd, va_list *list EINA_UNUSED)
3559 {
3560    Elm_Win_Smart_Data *sd = _pd;
3561    TRAP(sd, lower);
3562 }
3563
3564 EAPI void
3565 elm_win_raise(Evas_Object *obj)
3566 {
3567    ELM_WIN_CHECK(obj);
3568    eo_do(obj, elm_obj_win_raise());
3569 }
3570
3571 static void
3572 _raise(Eo *obj EINA_UNUSED, void *_pd, va_list *list EINA_UNUSED)
3573 {
3574    Elm_Win_Smart_Data *sd = _pd;
3575    TRAP(sd, raise);
3576 }
3577
3578 EAPI void
3579 elm_win_center(Evas_Object *obj,
3580                Eina_Bool h,
3581                Eina_Bool v)
3582 {
3583    ELM_WIN_CHECK(obj);
3584    eo_do(obj, elm_obj_win_center(h, v));
3585 }
3586
3587 static void
3588 _center(Eo *obj, void *_pd, va_list *list)
3589 {
3590    Eina_Bool h = va_arg(*list, int);
3591    Eina_Bool v = va_arg(*list, int);
3592    int win_w, win_h, screen_w, screen_h, nx, ny;
3593
3594    Elm_Win_Smart_Data *sd = _pd;
3595
3596    if ((trap) && (trap->center) && (!trap->center(sd->trap_data, obj)))
3597      return;
3598
3599    ecore_evas_screen_geometry_get(sd->ee, NULL, NULL, &screen_w, &screen_h);
3600    if ((!screen_w) || (!screen_h)) return;
3601
3602    evas_object_geometry_get(obj, NULL, NULL, &win_w, &win_h);
3603    if ((!win_w) || (!win_h)) return;
3604
3605    if (h) nx = win_w >= screen_w ? 0 : (screen_w / 2) - (win_w / 2);
3606    else nx = sd->screen.x;
3607    if (v) ny = win_h >= screen_h ? 0 : (screen_h / 2) - (win_h / 2);
3608    else ny = sd->screen.y;
3609    if (nx < 0) nx = 0;
3610    if (ny < 0) ny = 0;
3611
3612    evas_object_move(obj, nx, ny);
3613 }
3614
3615 EAPI void
3616 elm_win_borderless_set(Evas_Object *obj,
3617                        Eina_Bool borderless)
3618 {
3619    ELM_WIN_CHECK(obj);
3620    eo_do(obj, elm_obj_win_borderless_set(borderless));
3621 }
3622
3623 static void
3624 _borderless_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
3625 {
3626    Eina_Bool borderless = va_arg(*list, int);
3627    Elm_Win_Smart_Data *sd = _pd;
3628
3629    Eina_Bool need_frame = EINA_FALSE;
3630
3631    const char *engine_name = ecore_evas_engine_name_get(sd->ee);
3632    need_frame = engine_name &&
3633                 ((!strcmp(engine_name, ELM_WAYLAND_SHM)) ||
3634                  (!strcmp(engine_name, ELM_WAYLAND_EGL)));
3635
3636    if (borderless)
3637      {
3638         if (need_frame)
3639           _elm_win_frame_del(sd);
3640      }
3641    else
3642      {
3643         if (need_frame)
3644           _elm_win_frame_add(sd, "default");
3645
3646         if (sd->frame_obj)
3647           evas_object_show(sd->frame_obj);
3648      }
3649
3650    TRAP(sd, borderless_set, borderless);
3651 #ifdef HAVE_ELEMENTARY_X
3652    _elm_win_xwin_update(sd);
3653 #endif
3654 }
3655
3656 EAPI Eina_Bool
3657 elm_win_borderless_get(const Evas_Object *obj)
3658 {
3659    ELM_WIN_CHECK(obj) EINA_FALSE;
3660    Eina_Bool ret = EINA_FALSE;
3661    eo_do((Eo *) obj, elm_obj_win_borderless_get(&ret));
3662    return ret;
3663 }
3664
3665 static void
3666 _borderless_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
3667 {
3668    Eina_Bool *ret = va_arg(*list, Eina_Bool *);
3669    Elm_Win_Smart_Data *sd = _pd;
3670    *ret = ecore_evas_borderless_get(sd->ee);
3671 }
3672
3673 EAPI void
3674 elm_win_shaped_set(Evas_Object *obj,
3675                    Eina_Bool shaped)
3676 {
3677    ELM_WIN_CHECK(obj);
3678    eo_do(obj, elm_obj_win_shaped_set(shaped));
3679 }
3680
3681 static void
3682 _shaped_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
3683 {
3684    Eina_Bool shaped = va_arg(*list, int);
3685    Elm_Win_Smart_Data *sd = _pd;
3686
3687    TRAP(sd, shaped_set, shaped);
3688 #ifdef HAVE_ELEMENTARY_X
3689    _elm_win_xwin_update(sd);
3690 #endif
3691 }
3692
3693 EAPI Eina_Bool
3694 elm_win_shaped_get(const Evas_Object *obj)
3695 {
3696    ELM_WIN_CHECK(obj) EINA_FALSE;
3697    Eina_Bool ret = EINA_FALSE;
3698    eo_do((Eo *) obj, elm_obj_win_shaped_get(&ret));
3699    return ret;
3700 }
3701
3702 static void
3703 _shaped_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
3704 {
3705    Eina_Bool *ret = va_arg(*list, Eina_Bool *);
3706    Elm_Win_Smart_Data *sd = _pd;
3707    *ret = ecore_evas_shaped_get(sd->ee);
3708 }
3709
3710 EAPI void
3711 elm_win_alpha_set(Evas_Object *obj,
3712                   Eina_Bool enabled)
3713 {
3714    ELM_WIN_CHECK(obj);
3715    eo_do(obj, elm_obj_win_alpha_set(enabled));
3716 }
3717
3718 static void
3719 _alpha_set(Eo *obj, void *_pd, va_list *list)
3720 {
3721    Eina_Bool enabled = va_arg(*list, int);
3722    Elm_Win_Smart_Data *sd = _pd;
3723
3724    if (sd->img_obj)
3725      {
3726         evas_object_image_alpha_set(sd->img_obj, enabled);
3727         ecore_evas_alpha_set(sd->ee, enabled);
3728      }
3729    else
3730      {
3731 #ifdef HAVE_ELEMENTARY_X
3732         if (sd->x.xwin)
3733           {
3734              if (enabled)
3735                {
3736                   if (!ecore_x_screen_is_composited(0))
3737                     elm_win_shaped_set(obj, enabled);
3738                   else
3739                     TRAP(sd, alpha_set, enabled);
3740                }
3741              else
3742                TRAP(sd, alpha_set, enabled);
3743              _elm_win_xwin_update(sd);
3744           }
3745         else
3746 #endif
3747           TRAP(sd, alpha_set, enabled);
3748      }
3749 }
3750
3751 EAPI Eina_Bool
3752 elm_win_alpha_get(const Evas_Object *obj)
3753 {
3754    ELM_WIN_CHECK(obj) EINA_FALSE;
3755    Eina_Bool ret = EINA_FALSE;
3756    eo_do((Eo *) obj, elm_obj_win_alpha_get(&ret));
3757    return ret;
3758 }
3759
3760 static void
3761 _alpha_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
3762 {
3763    Eina_Bool *ret = va_arg(*list, Eina_Bool *);
3764    Elm_Win_Smart_Data *sd = _pd;
3765
3766    if (sd->img_obj)
3767      {
3768         *ret = evas_object_image_alpha_get(sd->img_obj);
3769      }
3770    else
3771      {
3772         *ret = ecore_evas_alpha_get(sd->ee);
3773      }
3774 }
3775
3776 EAPI void
3777 elm_win_override_set(Evas_Object *obj,
3778                      Eina_Bool override)
3779 {
3780    ELM_WIN_CHECK(obj);
3781    eo_do(obj, elm_obj_win_override_set(override));
3782 }
3783
3784 static void
3785 _override_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
3786 {
3787    Eina_Bool override = va_arg(*list, int);
3788    Elm_Win_Smart_Data *sd = _pd;
3789
3790    TRAP(sd, override_set, override);
3791 #ifdef HAVE_ELEMENTARY_X
3792    _elm_win_xwin_update(sd);
3793 #endif
3794 }
3795
3796 EAPI Eina_Bool
3797 elm_win_override_get(const Evas_Object *obj)
3798 {
3799    ELM_WIN_CHECK(obj) EINA_FALSE;
3800    Eina_Bool ret = EINA_FALSE;
3801    eo_do((Eo *) obj, elm_obj_win_override_get(&ret));
3802    return ret;
3803 }
3804
3805 static void
3806 _override_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
3807 {
3808    Eina_Bool *ret = va_arg(*list, Eina_Bool *);
3809    Elm_Win_Smart_Data *sd = _pd;
3810    *ret = ecore_evas_override_get(sd->ee);
3811 }
3812
3813 EAPI void
3814 elm_win_fullscreen_set(Evas_Object *obj,
3815                        Eina_Bool fullscreen)
3816 {
3817    ELM_WIN_CHECK(obj);
3818    eo_do(obj, elm_obj_win_fullscreen_set(fullscreen));
3819 }
3820
3821 static void
3822 _fullscreen_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
3823 {
3824    Eina_Bool fullscreen = va_arg(*list, int);
3825    Elm_Win_Smart_Data *sd = _pd;
3826    // YYY: handle if sd->img_obj
3827    if (ENGINE_COMPARE(ELM_SOFTWARE_FB) ||
3828        ENGINE_COMPARE(ELM_SOFTWARE_16_WINCE))
3829      {
3830         // these engines... can ONLY be fullscreen
3831         return;
3832      }
3833    else
3834      {
3835 //        sd->fullscreen = fullscreen;
3836
3837         Eina_Bool need_frame = EINA_FALSE;
3838
3839         const char *engine_name = ecore_evas_engine_name_get(sd->ee);
3840         need_frame = engine_name &&
3841                      ((!strcmp(engine_name, ELM_WAYLAND_SHM)) ||
3842                       (!strcmp(engine_name, ELM_WAYLAND_EGL)));
3843
3844         TRAP(sd, fullscreen_set, fullscreen);
3845
3846         if (fullscreen)
3847           {
3848              if (need_frame)
3849                _elm_win_frame_del(sd);
3850           }
3851         else
3852           {
3853              if (need_frame)
3854                _elm_win_frame_add(sd, "default");
3855
3856              if (sd->frame_obj)
3857                evas_object_show(sd->frame_obj);
3858           }
3859 #ifdef HAVE_ELEMENTARY_X
3860         _elm_win_xwin_update(sd);
3861 #endif
3862      }
3863 }
3864
3865 EAPI Eina_Bool
3866 elm_win_fullscreen_get(const Evas_Object *obj)
3867 {
3868    ELM_WIN_CHECK(obj) EINA_FALSE;
3869    Eina_Bool ret = EINA_FALSE;
3870    eo_do((Eo *) obj, elm_obj_win_fullscreen_get(&ret));
3871    return ret;
3872 }
3873
3874 static void
3875 _fullscreen_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
3876 {
3877    Eina_Bool *ret = va_arg(*list, Eina_Bool *);
3878    Elm_Win_Smart_Data *sd = _pd;
3879
3880    if (!ret) return;
3881
3882    const char* engine_name = ecore_evas_engine_name_get(sd->ee);
3883
3884    if (engine_name &&
3885        ((!strcmp(engine_name, ELM_SOFTWARE_FB)) ||
3886         (!strcmp(engine_name, ELM_SOFTWARE_16_WINCE))))
3887      {
3888         // these engines... can ONLY be fullscreen
3889         *ret = EINA_TRUE;
3890      }
3891    else
3892      {
3893         *ret = sd->fullscreen;
3894      }
3895 }
3896
3897 EAPI Evas_Object *
3898 elm_win_main_menu_get(const Evas_Object *obj)
3899 {
3900    ELM_WIN_CHECK(obj) NULL;
3901    Evas_Object *ret;
3902    eo_do((Eo *) obj, elm_obj_win_main_menu_get(&ret));
3903    return ret;
3904 }
3905
3906 static void
3907 _dbus_menu_set(Eina_Bool dbus_connect, void *data)
3908 {
3909    ELM_WIN_DATA_GET_OR_RETURN(data, sd);
3910
3911    if (dbus_connect)
3912      {
3913         DBG("Setting menu to D-Bus");
3914         edje_object_part_unswallow(sd->layout, sd->main_menu);
3915         edje_object_signal_emit(sd->layout, "elm,action,hide_menu", "elm");
3916         _elm_menu_menu_bar_hide(sd->main_menu);
3917      }
3918    else
3919      {
3920         DBG("Setting menu to local mode");
3921         edje_object_part_swallow(sd->layout, "elm.swallow.menu", sd->main_menu);
3922         edje_object_signal_emit(sd->layout, "elm,action,show_menu", "elm");
3923         evas_object_show(sd->main_menu);
3924      }
3925 }
3926
3927 static void
3928 _main_menu_get(Eo *obj, void *_pd, va_list *list)
3929 {
3930    Eo **ret = va_arg(*list, Eo **);
3931    Elm_Win_Smart_Data *sd = _pd;
3932    Eina_Bool use_dbus = EINA_FALSE;
3933
3934    if (sd->main_menu) goto end;
3935
3936    sd->main_menu = elm_menu_add(obj);
3937    _elm_menu_menu_bar_set(sd->main_menu, EINA_TRUE);
3938
3939 #ifdef HAVE_ELEMENTARY_X
3940    if (!_elm_config->disable_external_menu && sd->x.xwin) use_dbus = EINA_TRUE;
3941 #endif
3942
3943 #ifdef HAVE_ELEMENTARY_X
3944    if (use_dbus && _elm_dbus_menu_register(sd->main_menu))
3945      {
3946         _elm_dbus_menu_app_menu_register(sd->x.xwin, sd->main_menu,
3947                                          _dbus_menu_set, obj);
3948      }
3949    else
3950 #endif
3951      _dbus_menu_set(EINA_FALSE, obj);
3952
3953 end:
3954    *ret = sd->main_menu;
3955 }
3956
3957 EAPI void
3958 elm_win_maximized_set(Evas_Object *obj,
3959                       Eina_Bool maximized)
3960 {
3961    ELM_WIN_CHECK(obj);
3962    eo_do(obj, elm_obj_win_maximized_set(maximized));
3963 }
3964
3965 static void
3966 _maximized_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
3967 {
3968    Eina_Bool maximized = va_arg(*list, int);
3969    Elm_Win_Smart_Data *sd = _pd;
3970
3971    _elm_win_frame_maximized_state_update(sd, maximized);
3972    // YYY: handle if sd->img_obj
3973    TRAP(sd, maximized_set, maximized);
3974 #ifdef HAVE_ELEMENTARY_X
3975    _elm_win_xwin_update(sd);
3976 #endif
3977 }
3978
3979 EAPI Eina_Bool
3980 elm_win_maximized_get(const Evas_Object *obj)
3981 {
3982    ELM_WIN_CHECK(obj) EINA_FALSE;
3983    Eina_Bool ret = EINA_FALSE;
3984    eo_do((Eo *) obj, elm_obj_win_maximized_get(&ret));
3985    return ret;
3986 }
3987
3988 static void
3989 _maximized_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
3990 {
3991    Eina_Bool *ret = va_arg(*list, Eina_Bool *);
3992    Elm_Win_Smart_Data *sd = _pd;
3993    *ret = sd->maximized;
3994 }
3995
3996 EAPI void
3997 elm_win_iconified_set(Evas_Object *obj,
3998                       Eina_Bool iconified)
3999 {
4000    ELM_WIN_CHECK(obj);
4001    eo_do(obj, elm_obj_win_iconified_set(iconified));
4002 }
4003
4004 static void
4005 _iconified_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
4006 {
4007    Eina_Bool iconified = va_arg(*list, int);
4008    Elm_Win_Smart_Data *sd = _pd;
4009
4010 //   sd->iconified = iconified;
4011    TRAP(sd, iconified_set, iconified);
4012 #ifdef HAVE_ELEMENTARY_X
4013    _elm_win_xwin_update(sd);
4014 #endif
4015 }
4016
4017 EAPI Eina_Bool
4018 elm_win_iconified_get(const Evas_Object *obj)
4019 {
4020    ELM_WIN_CHECK(obj) EINA_FALSE;
4021    Eina_Bool ret = EINA_FALSE;
4022    eo_do((Eo *) obj, elm_obj_win_iconified_get(&ret));
4023    return ret;
4024 }
4025
4026 static void
4027 _iconified_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
4028 {
4029    Eina_Bool *ret = va_arg(*list, Eina_Bool *);
4030    Elm_Win_Smart_Data *sd = _pd;
4031    *ret = sd->iconified;
4032 }
4033
4034 EAPI void
4035 elm_win_withdrawn_set(Evas_Object *obj,
4036                       Eina_Bool withdrawn)
4037 {
4038    ELM_WIN_CHECK(obj);
4039    eo_do(obj, elm_obj_win_withdrawn_set(withdrawn));
4040 }
4041
4042 static void
4043 _withdrawn_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
4044 {
4045    Eina_Bool withdrawn = va_arg(*list, int);
4046    Elm_Win_Smart_Data *sd = _pd;
4047
4048 //   sd->withdrawn = withdrawn;
4049    TRAP(sd, withdrawn_set, withdrawn);
4050 #ifdef HAVE_ELEMENTARY_X
4051    _elm_win_xwin_update(sd);
4052 #endif
4053 }
4054
4055 EAPI Eina_Bool
4056 elm_win_withdrawn_get(const Evas_Object *obj)
4057 {
4058    ELM_WIN_CHECK(obj) EINA_FALSE;
4059    Eina_Bool ret = EINA_FALSE;
4060    eo_do((Eo *) obj, elm_obj_win_withdrawn_get(&ret));
4061    return ret;
4062 }
4063
4064 static void
4065 _withdrawn_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
4066 {
4067    Eina_Bool *ret = va_arg(*list, Eina_Bool *);
4068    Elm_Win_Smart_Data *sd = _pd;
4069    *ret = sd->withdrawn;
4070 }
4071
4072 EAPI void
4073 elm_win_available_profiles_set(Evas_Object  *obj,
4074                                const char  **profiles,
4075                                unsigned int  count)
4076 {
4077    ELM_WIN_CHECK(obj);
4078    eo_do((Eo *) obj, elm_obj_win_available_profiles_set(profiles, count));
4079 }
4080
4081 static void
4082 _available_profiles_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
4083 {
4084    const char **profiles = va_arg(*list, const char **);
4085    unsigned int count = va_arg(*list, unsigned int);
4086    Elm_Win_Smart_Data *sd = _pd;
4087    Eina_Bool found = EINA_FALSE;
4088
4089    _elm_win_available_profiles_del(sd);
4090    if ((profiles) && (count >= 1))
4091      {
4092         sd->profile.available_list = calloc(count, sizeof(char *));
4093         if (sd->profile.available_list)
4094           {
4095              if (!sd->profile.name) found = EINA_TRUE;
4096
4097              unsigned int i;
4098              for (i = 0; i < count; i++)
4099                {
4100                   sd->profile.available_list[i] = eina_stringshare_add(profiles[i]);
4101
4102                   /* check to see if a given array has a current profile of elm_win */
4103                   if ((sd->profile.name) &&
4104                       (!strcmp(sd->profile.name, profiles[i])))
4105                     {
4106                        found = EINA_TRUE;
4107                     }
4108                }
4109              sd->profile.count = count;
4110           }
4111      }
4112
4113    if (ecore_evas_window_profile_supported_get(sd->ee))
4114      {
4115         ecore_evas_window_available_profiles_set(sd->ee,
4116                                                  sd->profile.available_list,
4117                                                  sd->profile.count);
4118
4119         /* current profile of elm_win is wrong, change profile */
4120         if ((sd->profile.available_list) && (!found))
4121           {
4122              eina_stringshare_replace(&(sd->profile.name),
4123                                       sd->profile.available_list[0]);
4124              ecore_evas_window_profile_set(sd->ee, sd->profile.name);
4125           }
4126
4127      }
4128    else
4129      {
4130         if (sd->profile.available_list)
4131           _elm_win_profile_update(sd);
4132      }
4133 }
4134
4135 EAPI Eina_Bool
4136 elm_win_available_profiles_get(Evas_Object   *obj,
4137                                char        ***profiles,
4138                                unsigned int  *count)
4139 {
4140    ELM_WIN_CHECK(obj) EINA_FALSE;
4141    Eina_Bool ret = EINA_FALSE;
4142    eo_do((Eo *) obj, elm_obj_win_available_profiles_get(profiles, count, &ret));
4143    return ret;
4144 }
4145
4146 static void
4147 _available_profiles_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
4148 {
4149    char ***profiles = va_arg(*list, char ***);
4150    unsigned int *count = va_arg(*list, unsigned int *);
4151    Eina_Bool *ret = va_arg(*list, Eina_Bool *);
4152    Elm_Win_Smart_Data *sd = _pd;
4153    Eina_Bool res;
4154
4155    if (ecore_evas_window_profile_supported_get(sd->ee))
4156      {
4157         res = ecore_evas_window_available_profiles_get(sd->ee,
4158                                                        profiles,
4159                                                        count);
4160      }
4161    else
4162      {
4163         if (profiles) *profiles = (char **)sd->profile.available_list;
4164         if (count) *count = sd->profile.count;
4165         res = EINA_TRUE;
4166      }
4167    if (ret) *ret = res;
4168 }
4169
4170 EAPI void
4171 elm_win_profile_set(Evas_Object *obj,
4172                     const char *profile)
4173 {
4174    ELM_WIN_CHECK(obj);
4175    eo_do((Eo *) obj, elm_obj_win_profile_set(profile));
4176 }
4177
4178 static void
4179 _profile_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
4180 {
4181    const char *profile = va_arg(*list, const char *);
4182    Elm_Win_Smart_Data *sd = _pd;
4183
4184    /* check to see if a given profile is present in an available profiles */
4185    if ((profile) && (sd->profile.available_list))
4186      {
4187         Eina_Bool found = EINA_FALSE;
4188         unsigned int i;
4189         for (i = 0; i < sd->profile.count; i++)
4190           {
4191              if (!strcmp(profile,
4192                          sd->profile.available_list[i]))
4193                {
4194                   found = EINA_TRUE;
4195                   break;
4196                }
4197           }
4198         if (!found) return;
4199      }
4200
4201    if (ecore_evas_window_profile_supported_get(sd->ee))
4202      {
4203         if (!profile) _elm_win_profile_del(sd);
4204         ecore_evas_window_profile_set(sd->ee, profile);
4205      }
4206    else
4207      {
4208         if (_elm_win_profile_set(sd, profile))
4209           _elm_win_profile_update(sd);
4210      }
4211 }
4212
4213 EAPI const char *
4214 elm_win_profile_get(const Evas_Object *obj)
4215 {
4216    ELM_WIN_CHECK(obj) NULL;
4217    const char *ret = NULL;
4218    eo_do((Eo *) obj, elm_obj_win_profile_get(&ret));
4219    return ret;
4220 }
4221
4222 static void
4223 _profile_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
4224 {
4225    const char **ret = va_arg(*list, const char **);
4226    Elm_Win_Smart_Data *sd = _pd;
4227    *ret = sd->profile.name;
4228 }
4229
4230 EAPI void
4231 elm_win_urgent_set(Evas_Object *obj,
4232                    Eina_Bool urgent)
4233 {
4234    ELM_WIN_CHECK(obj);
4235    eo_do(obj, elm_obj_win_urgent_set(urgent));
4236 }
4237
4238 static void
4239 _urgent_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
4240 {
4241    Eina_Bool urgent = va_arg(*list, int);
4242    Elm_Win_Smart_Data *sd = _pd;
4243
4244    sd->urgent = urgent;
4245    TRAP(sd, urgent_set, urgent);
4246 #ifdef HAVE_ELEMENTARY_X
4247    _elm_win_xwin_update(sd);
4248 #endif
4249 }
4250
4251 EAPI Eina_Bool
4252 elm_win_urgent_get(const Evas_Object *obj)
4253 {
4254    ELM_WIN_CHECK(obj) EINA_FALSE;
4255    Eina_Bool ret = EINA_FALSE;
4256    eo_do((Eo *) obj, elm_obj_win_urgent_get(&ret));
4257    return ret;
4258 }
4259
4260 static void
4261 _urgent_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
4262 {
4263    Eina_Bool *ret = va_arg(*list, Eina_Bool *);
4264    Elm_Win_Smart_Data *sd = _pd;
4265    *ret = sd->urgent;
4266 }
4267
4268 EAPI void
4269 elm_win_demand_attention_set(Evas_Object *obj,
4270                              Eina_Bool demand_attention)
4271 {
4272    ELM_WIN_CHECK(obj);
4273    eo_do(obj, elm_obj_win_demand_attention_set(demand_attention));
4274 }
4275
4276 static void
4277 _demand_attention_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
4278 {
4279    Eina_Bool demand_attention = va_arg(*list, int);
4280    Elm_Win_Smart_Data *sd = _pd;
4281
4282    sd->demand_attention = demand_attention;
4283    TRAP(sd, demand_attention_set, demand_attention);
4284 #ifdef HAVE_ELEMENTARY_X
4285    _elm_win_xwin_update(sd);
4286 #endif
4287 }
4288
4289 EAPI Eina_Bool
4290 elm_win_demand_attention_get(const Evas_Object *obj)
4291 {
4292    ELM_WIN_CHECK(obj) EINA_FALSE;
4293    Eina_Bool ret = EINA_FALSE;
4294    eo_do((Eo *) obj, elm_obj_win_demand_attention_get(&ret));
4295    return ret;
4296 }
4297
4298 static void
4299 _demand_attention_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
4300 {
4301    Eina_Bool *ret = va_arg(*list, Eina_Bool *);
4302    Elm_Win_Smart_Data *sd = _pd;
4303    *ret = sd->demand_attention;
4304 }
4305
4306 EAPI void
4307 elm_win_modal_set(Evas_Object *obj,
4308                   Eina_Bool modal)
4309 {
4310    ELM_WIN_CHECK(obj);
4311    eo_do(obj, elm_obj_win_modal_set(modal));
4312 }
4313
4314 static void
4315 _modal_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
4316 {
4317    Eina_Bool modal = va_arg(*list, int);
4318    Elm_Win_Smart_Data *sd = _pd;
4319
4320    sd->modal = modal;
4321    TRAP(sd, modal_set, modal);
4322 #ifdef HAVE_ELEMENTARY_X
4323    _elm_win_xwin_update(sd);
4324 #endif
4325 }
4326
4327 EAPI Eina_Bool
4328 elm_win_modal_get(const Evas_Object *obj)
4329 {
4330    ELM_WIN_CHECK(obj) EINA_FALSE;
4331    Eina_Bool ret = EINA_FALSE;
4332    eo_do((Eo *) obj, elm_obj_win_modal_get(&ret));
4333    return ret;
4334 }
4335
4336 static void
4337 _modal_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
4338 {
4339    Eina_Bool *ret = va_arg(*list, Eina_Bool *);
4340    Elm_Win_Smart_Data *sd = _pd;
4341    *ret = sd->modal;
4342 }
4343
4344 EAPI void
4345 elm_win_aspect_set(Evas_Object *obj,
4346                    double aspect)
4347 {
4348    ELM_WIN_CHECK(obj);
4349    eo_do(obj, elm_obj_win_aspect_set(aspect));
4350 }
4351
4352 static void
4353 _aspect_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
4354 {
4355    double aspect = va_arg(*list, double);
4356    Elm_Win_Smart_Data *sd = _pd;
4357
4358    sd->aspect = aspect;
4359    TRAP(sd, aspect_set, aspect);
4360 #ifdef HAVE_ELEMENTARY_X
4361    _elm_win_xwin_update(sd);
4362 #endif
4363 }
4364
4365 EAPI double
4366 elm_win_aspect_get(const Evas_Object *obj)
4367 {
4368    ELM_WIN_CHECK(obj) 0.0;
4369    double ret = 0.0;
4370    eo_do((Eo *) obj, elm_obj_win_aspect_get(&ret));
4371    return ret;
4372 }
4373
4374 static void
4375 _aspect_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
4376 {
4377    double *ret = va_arg(*list, double *);
4378    Elm_Win_Smart_Data *sd = _pd;
4379    *ret = sd->aspect;
4380 }
4381
4382 EAPI void
4383 elm_win_size_base_set(Evas_Object *obj, int w, int h)
4384 {
4385    ELM_WIN_CHECK(obj);
4386    eo_do(obj, elm_obj_win_size_base_set(w, h));
4387 }
4388
4389 static void
4390 _size_base_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
4391 {
4392    int w = va_arg(*list, int);
4393    int h = va_arg(*list, int);
4394    Elm_Win_Smart_Data *sd = _pd;
4395    sd->size_base_w = w;
4396    sd->size_base_h = h;
4397    TRAP(sd, size_base_set, w, h);
4398 #ifdef HAVE_ELEMENTARY_X
4399    _elm_win_xwin_update(sd);
4400 #endif
4401 }
4402
4403 EAPI void
4404 elm_win_size_base_get(Evas_Object *obj, int *w, int *h)
4405 {
4406    ELM_WIN_CHECK(obj);
4407    eo_do(obj, elm_obj_win_size_base_get(w, h));
4408 }
4409
4410 static void
4411 _size_base_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
4412 {
4413    int *w = va_arg(*list, int *);
4414    int *h = va_arg(*list, int *);
4415
4416    Elm_Win_Smart_Data *sd = _pd;
4417    if (w) *w = sd->size_base_w;
4418    if (w) *h = sd->size_base_h;
4419 }
4420
4421 EAPI void
4422 elm_win_size_step_set(Evas_Object *obj, int w, int h)
4423 {
4424    ELM_WIN_CHECK(obj);
4425    eo_do(obj, elm_obj_win_size_step_set(w, h));
4426 }
4427
4428 static void
4429 _size_step_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
4430 {
4431    int w = va_arg(*list, int);
4432    int h = va_arg(*list, int);
4433    Elm_Win_Smart_Data *sd = _pd;
4434    sd->size_step_w = w;
4435    sd->size_step_h = h;
4436    TRAP(sd, size_step_set, w, h);
4437 #ifdef HAVE_ELEMENTARY_X
4438    _elm_win_xwin_update(sd);
4439 #endif
4440 }
4441
4442 EAPI void
4443 elm_win_size_step_get(Evas_Object *obj, int *w, int *h)
4444 {
4445    ELM_WIN_CHECK(obj);
4446    eo_do(obj, elm_obj_win_size_step_get(w, h));
4447 }
4448
4449 static void
4450 _size_step_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
4451 {
4452    int *w = va_arg(*list, int *);
4453    int *h = va_arg(*list, int *);
4454    Elm_Win_Smart_Data *sd = _pd;
4455    if (w) *w = sd->size_step_w;
4456    if (w) *h = sd->size_step_h;
4457 }
4458
4459 EAPI void
4460 elm_win_layer_set(Evas_Object *obj,
4461                   int layer)
4462 {
4463    ELM_WIN_CHECK(obj);
4464    eo_do(obj, elm_obj_win_layer_set(layer));
4465 }
4466
4467 static void
4468 _layer_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
4469 {
4470    int layer = va_arg(*list, int);
4471    Elm_Win_Smart_Data *sd = _pd;
4472
4473    TRAP(sd, layer_set, layer);
4474 #ifdef HAVE_ELEMENTARY_X
4475    _elm_win_xwin_update(sd);
4476 #endif
4477 }
4478
4479 EAPI int
4480 elm_win_layer_get(const Evas_Object *obj)
4481 {
4482    ELM_WIN_CHECK(obj) - 1;
4483    int ret = - 1;
4484    eo_do((Eo *) obj, elm_obj_win_layer_get(&ret));
4485    return ret;
4486 }
4487
4488 static void
4489 _layer_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
4490 {
4491    int *ret = va_arg(*list, int *);
4492    Elm_Win_Smart_Data *sd = _pd;
4493    *ret = ecore_evas_layer_get(sd->ee);
4494 }
4495
4496 EAPI void
4497 elm_win_norender_push(Evas_Object *obj)
4498 {
4499    ELM_WIN_CHECK(obj);
4500    ELM_WIN_DATA_GET_OR_RETURN(obj, sd);
4501
4502    sd->norender++;
4503    if (sd->norender == 1) ecore_evas_manual_render_set(sd->ee, EINA_TRUE);
4504 }
4505
4506 EAPI void
4507 elm_win_norender_pop(Evas_Object *obj)
4508 {
4509    ELM_WIN_CHECK(obj);
4510    ELM_WIN_DATA_GET_OR_RETURN(obj, sd);
4511
4512    if (sd->norender <= 0) return;
4513    sd->norender--;
4514    if (sd->norender == 0) ecore_evas_manual_render_set(sd->ee, EINA_FALSE);
4515 }
4516
4517 EAPI int
4518 elm_win_norender_get(Evas_Object *obj)
4519 {
4520    ELM_WIN_CHECK(obj) - 1;
4521    ELM_WIN_DATA_GET_OR_RETURN_VAL(obj, sd, -1);
4522    return sd->norender;
4523 }
4524
4525 EAPI void
4526 elm_win_render(Evas_Object *obj)
4527 {
4528    ELM_WIN_CHECK(obj);
4529    ELM_WIN_DATA_GET_OR_RETURN(obj, sd);
4530    ecore_evas_manual_render(sd->ee);
4531 }
4532
4533 static int
4534 _win_rotation_degree_check(int rotation)
4535 {
4536    if ((rotation > 360) || (rotation < 0))
4537      {
4538         WRN("Rotation degree should be 0 ~ 360 (passed degree: %d)", rotation);
4539         rotation %= 360;
4540         if (rotation < 0) rotation += 360;
4541      }
4542    return rotation;
4543 }
4544
4545 /*
4546  * This API resizes the internal window(ex: X window) and evas_output.
4547  * But this does not resize the elm window object and its contents.
4548  */
4549 EAPI void
4550 elm_win_rotation_set(Evas_Object *obj,
4551                      int rotation)
4552 {
4553    ELM_WIN_CHECK(obj);
4554    eo_do(obj, elm_obj_win_rotation_set(rotation));
4555 }
4556
4557 static void
4558 _win_rotate(Evas_Object *obj, Elm_Win_Smart_Data *sd, int rotation, Eina_Bool resize)
4559 {
4560    rotation = _win_rotation_degree_check(rotation);
4561    if (sd->rot == rotation) return;
4562    sd->rot = rotation;
4563    if (resize) TRAP(sd, rotation_with_resize_set, rotation);
4564    else TRAP(sd, rotation_set, rotation);
4565    evas_object_size_hint_min_set(obj, -1, -1);
4566    evas_object_size_hint_max_set(obj, -1, -1);
4567    _elm_win_resize_objects_eval(obj);
4568 #ifdef HAVE_ELEMENTARY_X
4569    _elm_win_xwin_update(sd);
4570 #endif
4571    _elm_win_frame_obj_update(sd);
4572    elm_widget_orientation_set(obj, rotation);
4573    evas_object_smart_callback_call(obj, SIG_ROTATION_CHANGED, NULL);
4574 }
4575
4576 static void
4577 _rotation_set(Eo *obj, void *_pd, va_list *list)
4578 {
4579    int rotation = va_arg(*list, int);
4580    Elm_Win_Smart_Data *sd = _pd;
4581    _win_rotate(obj, sd, rotation, EINA_FALSE);
4582 }
4583
4584 /*
4585  * This API does not resize the internal window (ex: X window).
4586  * But this resizes evas_output, elm window, and its contents.
4587  */
4588 EAPI void
4589 elm_win_rotation_with_resize_set(Evas_Object *obj,
4590                                  int rotation)
4591 {
4592    ELM_WIN_CHECK(obj);
4593    eo_do(obj, elm_obj_win_rotation_with_resize_set(rotation));
4594 }
4595
4596 static void
4597 _rotation_with_resize_set(Eo *obj, void *_pd, va_list *list)
4598 {
4599    int rotation = va_arg(*list, int);
4600    Elm_Win_Smart_Data *sd = _pd;
4601    _win_rotate(obj, sd, rotation, EINA_TRUE);
4602 }
4603
4604 EAPI int
4605 elm_win_rotation_get(const Evas_Object *obj)
4606 {
4607    ELM_WIN_CHECK(obj) - 1;
4608    int ret = - 1;
4609    eo_do((Eo *) obj, elm_obj_win_rotation_get(&ret));
4610    return ret;
4611 }
4612
4613 static void
4614 _rotation_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
4615 {
4616    int *ret = va_arg(*list, int *);
4617    Elm_Win_Smart_Data *sd = _pd;
4618    *ret = sd->rot;
4619 }
4620
4621 EAPI Eina_Bool
4622 elm_win_wm_rotation_supported_get(const Evas_Object *obj)
4623 {
4624    ELM_WIN_CHECK(obj) EINA_FALSE;
4625    Eina_Bool ret = EINA_FALSE;
4626    eo_do((Eo *) obj, elm_obj_win_wm_rotation_supported_get(&ret));
4627    return ret;
4628 }
4629
4630 static void
4631 _wm_rotation_supported_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
4632 {
4633    Eina_Bool *ret = va_arg(*list, Eina_Bool *);
4634    Elm_Win_Smart_Data *sd = _pd;
4635    *ret = sd->wm_rot.wm_supported;
4636 }
4637
4638 /* This will unset a preferred rotation, if given preferred rotation is '-1'.
4639  */
4640 EAPI void
4641 elm_win_wm_rotation_preferred_rotation_set(const Evas_Object *obj,
4642                                            int rotation)
4643 {
4644    ELM_WIN_CHECK(obj);
4645    eo_do((Eo *) obj, elm_obj_win_wm_preferred_rotation_set(rotation));
4646 }
4647
4648 static void
4649 _wm_preferred_rotation_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
4650 {
4651    int rotation = va_arg(*list, int);
4652    int rot;
4653    Elm_Win_Smart_Data *sd = _pd;
4654
4655    if (!sd->wm_rot.use)
4656      sd->wm_rot.use = EINA_TRUE;
4657
4658    // '-1' means that elm_win doesn't use preferred rotation.
4659    if (rotation == -1)
4660      rot = -1;
4661    else
4662      rot = _win_rotation_degree_check(rotation);
4663
4664    if (sd->wm_rot.preferred_rot == rot) return;
4665    sd->wm_rot.preferred_rot = rot;
4666
4667    ecore_evas_wm_rotation_preferred_rotation_set(sd->ee, rot);
4668 }
4669
4670 EAPI int
4671 elm_win_wm_rotation_preferred_rotation_get(const Evas_Object *obj)
4672 {
4673    ELM_WIN_CHECK(obj) -1;
4674    int ret = -1;
4675    eo_do((Eo *) obj, elm_obj_win_wm_preferred_rotation_get(&ret));
4676    return ret;
4677 }
4678
4679 static void
4680 _wm_preferred_rotation_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
4681 {
4682    int *ret = va_arg(*list, int *);
4683    Elm_Win_Smart_Data *sd = _pd;
4684    *ret = sd->wm_rot.preferred_rot;
4685 }
4686
4687 EAPI void
4688 elm_win_wm_rotation_available_rotations_set(Evas_Object *obj,
4689                                             const int   *rotations,
4690                                             unsigned int count)
4691 {
4692    ELM_WIN_CHECK(obj);
4693    eo_do((Eo *) obj, elm_obj_win_wm_available_rotations_set(rotations, count));
4694 }
4695
4696 static void
4697 _wm_available_rotations_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
4698 {
4699    const int *rotations = va_arg(*list, const int *);
4700    unsigned int count = va_arg(*list, unsigned int);
4701    Elm_Win_Smart_Data *sd = _pd;
4702    unsigned int i;
4703    int r;
4704
4705    if (!sd->wm_rot.use)
4706      sd->wm_rot.use = EINA_TRUE;
4707
4708    ELM_SAFE_FREE(sd->wm_rot.rots, free);
4709    sd->wm_rot.count = 0;
4710
4711    if (count > 0)
4712      {
4713         sd->wm_rot.rots = calloc(count, sizeof(int));
4714         if (!sd->wm_rot.rots) return;
4715         for (i = 0; i < count; i++)
4716           {
4717              r = _win_rotation_degree_check(rotations[i]);
4718              sd->wm_rot.rots[i] = r;
4719           }
4720      }
4721
4722    sd->wm_rot.count = count;
4723
4724    ecore_evas_wm_rotation_available_rotations_set(sd->ee,
4725                                                   sd->wm_rot.rots,
4726                                                   sd->wm_rot.count);
4727 }
4728
4729 EAPI Eina_Bool
4730 elm_win_wm_rotation_available_rotations_get(const Evas_Object *obj,
4731                                             int              **rotations,
4732                                             unsigned int      *count)
4733 {
4734    ELM_WIN_CHECK(obj) EINA_FALSE;
4735    Eina_Bool ret = EINA_FALSE;
4736    eo_do((Eo *) obj, elm_obj_win_wm_available_rotations_get(rotations, count, &ret));
4737    return ret;
4738 }
4739
4740 static void
4741 _wm_available_rotations_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
4742 {
4743    int **rotations = va_arg(*list, int **);
4744    unsigned int *count = va_arg(*list, unsigned int *);
4745    Eina_Bool *ret = va_arg(*list, Eina_Bool *);
4746    Elm_Win_Smart_Data *sd = _pd;
4747    *ret = EINA_FALSE;
4748    if (!sd->wm_rot.use) return;
4749
4750    if (sd->wm_rot.count > 0)
4751      {
4752         if (rotations)
4753           {
4754              *rotations = calloc(sd->wm_rot.count, sizeof(int));
4755              if (*rotations)
4756                {
4757                   memcpy(*rotations,
4758                          sd->wm_rot.rots,
4759                          sizeof(int) * sd->wm_rot.count);
4760                }
4761           }
4762      }
4763
4764    if (count) *count = sd->wm_rot.count;
4765    *ret = EINA_TRUE;
4766 }
4767
4768 EAPI void
4769 elm_win_wm_rotation_manual_rotation_done_set(Evas_Object *obj,
4770                                              Eina_Bool    set)
4771 {
4772    ELM_WIN_CHECK(obj);
4773    eo_do((Eo *) obj, elm_obj_win_wm_manual_rotation_done_set(set));
4774 }
4775
4776 static void
4777 _wm_manual_rotation_done_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
4778 {
4779    int set = va_arg(*list, int);
4780    Elm_Win_Smart_Data *sd = _pd;
4781    if (!sd->wm_rot.use) return;
4782    ecore_evas_wm_rotation_manual_rotation_done_set(sd->ee, set);
4783 }
4784
4785 EAPI Eina_Bool
4786 elm_win_wm_rotation_manual_rotation_done_get(const Evas_Object *obj)
4787 {
4788    ELM_WIN_CHECK(obj) EINA_FALSE;
4789    Eina_Bool ret = EINA_FALSE;
4790    eo_do((Eo *) obj, elm_obj_win_wm_manual_rotation_done_get(&ret));
4791    return ret;
4792 }
4793
4794 static void
4795 _wm_manual_rotation_done_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
4796 {
4797    Eina_Bool *ret = va_arg(*list, Eina_Bool *);
4798    Elm_Win_Smart_Data *sd = _pd;
4799    if (!sd->wm_rot.use) return;
4800    *ret = ecore_evas_wm_rotation_manual_rotation_done_get(sd->ee);
4801 }
4802
4803 EAPI void
4804 elm_win_wm_rotation_manual_rotation_done(Evas_Object *obj)
4805 {
4806    ELM_WIN_CHECK(obj);
4807    eo_do((Eo *) obj, elm_obj_win_wm_manual_rotation_done());
4808 }
4809
4810 static void
4811 _wm_manual_rotation_done(Eo *obj EINA_UNUSED, void *_pd, va_list *list EINA_UNUSED)
4812 {
4813    Elm_Win_Smart_Data *sd = _pd;
4814    if (!sd->wm_rot.use) return;
4815    ecore_evas_wm_rotation_manual_rotation_done(sd->ee);
4816 }
4817
4818 EAPI void
4819 elm_win_sticky_set(Evas_Object *obj,
4820                    Eina_Bool sticky)
4821 {
4822    ELM_WIN_CHECK(obj);
4823    eo_do(obj, elm_obj_win_sticky_set(sticky));
4824 }
4825
4826 static void
4827 _sticky_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
4828 {
4829    Eina_Bool sticky = va_arg(*list, int);
4830    Elm_Win_Smart_Data *sd = _pd;
4831
4832 //   sd->sticky = sticky;
4833    TRAP(sd, sticky_set, sticky);
4834 #ifdef HAVE_ELEMENTARY_X
4835    _elm_win_xwin_update(sd);
4836 #endif
4837 }
4838
4839 EAPI Eina_Bool
4840 elm_win_sticky_get(const Evas_Object *obj)
4841 {
4842    ELM_WIN_CHECK(obj) EINA_FALSE;
4843    Eina_Bool ret = EINA_FALSE;
4844    eo_do((Eo *) obj, elm_obj_win_sticky_get(&ret));
4845    return ret;
4846 }
4847
4848 static void
4849 _sticky_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
4850 {
4851    Eina_Bool *ret = va_arg(*list, Eina_Bool *);
4852    Elm_Win_Smart_Data *sd = _pd;
4853    *ret = sd->sticky;
4854 }
4855
4856 EAPI void
4857 elm_win_keyboard_mode_set(Evas_Object *obj,
4858                           Elm_Win_Keyboard_Mode mode)
4859 {
4860    ELM_WIN_CHECK(obj);
4861    eo_do(obj, elm_obj_win_keyboard_mode_set(mode));
4862 }
4863
4864 static void
4865 _keyboard_mode_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
4866 {
4867    Elm_Win_Keyboard_Mode mode = va_arg(*list, Elm_Win_Keyboard_Mode);
4868    Elm_Win_Smart_Data *sd = _pd;
4869
4870    if (mode == sd->kbdmode) return;
4871 #ifdef HAVE_ELEMENTARY_X
4872    _elm_win_xwindow_get(sd);
4873 #endif
4874    sd->kbdmode = mode;
4875 #ifdef HAVE_ELEMENTARY_X
4876    if (sd->x.xwin)
4877      ecore_x_e_virtual_keyboard_state_set
4878        (sd->x.xwin, (Ecore_X_Virtual_Keyboard_State)sd->kbdmode);
4879 #endif
4880 }
4881
4882 EAPI Elm_Win_Keyboard_Mode
4883 elm_win_keyboard_mode_get(const Evas_Object *obj)
4884 {
4885    ELM_WIN_CHECK(obj) ELM_WIN_KEYBOARD_UNKNOWN;
4886    Elm_Win_Keyboard_Mode ret = ELM_WIN_KEYBOARD_UNKNOWN;
4887    eo_do((Eo *) obj, elm_obj_win_keyboard_mode_get(&ret));
4888    return ret;
4889 }
4890
4891 static void
4892 _keyboard_mode_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
4893 {
4894    Elm_Win_Keyboard_Mode *ret = va_arg(*list, Elm_Win_Keyboard_Mode *);
4895    Elm_Win_Smart_Data *sd = _pd;
4896    *ret = sd->kbdmode;
4897 }
4898
4899 EAPI void
4900 elm_win_keyboard_win_set(Evas_Object *obj,
4901                          Eina_Bool is_keyboard)
4902 {
4903    ELM_WIN_CHECK(obj);
4904    eo_do(obj, elm_obj_win_keyboard_win_set(is_keyboard));
4905 }
4906
4907 static void
4908 _keyboard_win_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
4909 {
4910    Eina_Bool is_keyboard = va_arg(*list, int);
4911    Elm_Win_Smart_Data *sd = _pd;
4912
4913 #ifdef HAVE_ELEMENTARY_X
4914    _elm_win_xwindow_get(sd);
4915    if (sd->x.xwin)
4916      ecore_x_e_virtual_keyboard_set(sd->x.xwin, is_keyboard);
4917 #else
4918    (void)is_keyboard;
4919 #endif
4920 }
4921
4922 EAPI Eina_Bool
4923 elm_win_keyboard_win_get(const Evas_Object *obj)
4924 {
4925    ELM_WIN_CHECK(obj) EINA_FALSE;
4926    Eina_Bool ret = EINA_FALSE;
4927    eo_do((Eo *) obj, elm_obj_win_keyboard_win_get(&ret));
4928    return ret;
4929 }
4930
4931 static void
4932 _keyboard_win_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
4933 {
4934    Eina_Bool *ret = va_arg(*list, Eina_Bool *);
4935    Elm_Win_Smart_Data *sd = _pd;
4936
4937 #ifdef HAVE_ELEMENTARY_X
4938    _elm_win_xwindow_get(sd);
4939    if (sd->x.xwin)
4940      {
4941         *ret = ecore_x_e_virtual_keyboard_get(sd->x.xwin);
4942         return;
4943      }
4944 #endif
4945    *ret = EINA_FALSE;
4946 }
4947
4948 EAPI void
4949 elm_win_indicator_mode_set(Evas_Object *obj,
4950       Elm_Win_Indicator_Mode mode)
4951 {
4952    ELM_WIN_CHECK(obj);
4953    eo_do(obj, elm_obj_win_indicator_mode_set(mode));
4954 }
4955
4956 static void
4957 _indicator_mode_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
4958 {
4959    Elm_Win_Indicator_Mode mode = va_arg(*list, Elm_Win_Indicator_Mode);
4960    Elm_Win_Smart_Data *sd = _pd;
4961
4962    if (mode == sd->indmode) return;
4963 #ifdef HAVE_ELEMENTARY_X
4964    _elm_win_xwindow_get(sd);
4965 #endif
4966    sd->indmode = mode;
4967 #ifdef HAVE_ELEMENTARY_X
4968    if (sd->x.xwin)
4969      {
4970         if (sd->indmode == ELM_WIN_INDICATOR_SHOW)
4971           ecore_x_e_illume_indicator_state_set
4972             (sd->x.xwin, ECORE_X_ILLUME_INDICATOR_STATE_ON);
4973         else if (sd->indmode == ELM_WIN_INDICATOR_HIDE)
4974           ecore_x_e_illume_indicator_state_set
4975             (sd->x.xwin, ECORE_X_ILLUME_INDICATOR_STATE_OFF);
4976      }
4977 #endif
4978    evas_object_smart_callback_call(obj, SIG_INDICATOR_PROP_CHANGED, NULL);
4979 }
4980
4981 EAPI Elm_Win_Indicator_Mode
4982 elm_win_indicator_mode_get(const Evas_Object *obj)
4983 {
4984    ELM_WIN_CHECK(obj) ELM_WIN_INDICATOR_UNKNOWN;
4985    Elm_Win_Indicator_Mode ret = ELM_WIN_INDICATOR_UNKNOWN;
4986    eo_do((Eo *) obj, elm_obj_win_indicator_mode_get(&ret));
4987    return ret;
4988 }
4989
4990 static void
4991 _indicator_mode_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
4992 {
4993    Elm_Win_Indicator_Mode *ret = va_arg(*list, Elm_Win_Indicator_Mode *);
4994    Elm_Win_Smart_Data *sd = _pd;
4995    *ret = sd->indmode;
4996 }
4997
4998 EAPI void
4999 elm_win_indicator_opacity_set(Evas_Object *obj,
5000                               Elm_Win_Indicator_Opacity_Mode mode)
5001 {
5002    ELM_WIN_CHECK(obj);
5003    eo_do(obj, elm_obj_win_indicator_opacity_set(mode));
5004 }
5005
5006 static void
5007 _indicator_opacity_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
5008 {
5009    Elm_Win_Indicator_Opacity_Mode mode = va_arg(*list, Elm_Win_Indicator_Opacity_Mode);
5010    Elm_Win_Smart_Data *sd = _pd;
5011
5012    if (mode == sd->ind_o_mode) return;
5013    sd->ind_o_mode = mode;
5014 #ifdef HAVE_ELEMENTARY_X
5015    _elm_win_xwindow_get(sd);
5016    if (sd->x.xwin)
5017      {
5018         if (sd->ind_o_mode == ELM_WIN_INDICATOR_OPAQUE)
5019           ecore_x_e_illume_indicator_opacity_set
5020             (sd->x.xwin, ECORE_X_ILLUME_INDICATOR_OPAQUE);
5021         else if (sd->ind_o_mode == ELM_WIN_INDICATOR_TRANSLUCENT)
5022           ecore_x_e_illume_indicator_opacity_set
5023             (sd->x.xwin, ECORE_X_ILLUME_INDICATOR_TRANSLUCENT);
5024         else if (sd->ind_o_mode == ELM_WIN_INDICATOR_TRANSPARENT)
5025           ecore_x_e_illume_indicator_opacity_set
5026             (sd->x.xwin, ECORE_X_ILLUME_INDICATOR_TRANSPARENT);
5027      }
5028 #endif
5029    evas_object_smart_callback_call(obj, SIG_INDICATOR_PROP_CHANGED, NULL);
5030 }
5031
5032 EAPI Elm_Win_Indicator_Opacity_Mode
5033 elm_win_indicator_opacity_get(const Evas_Object *obj)
5034 {
5035    ELM_WIN_CHECK(obj) ELM_WIN_INDICATOR_OPACITY_UNKNOWN;
5036    Elm_Win_Indicator_Opacity_Mode ret = ELM_WIN_INDICATOR_OPACITY_UNKNOWN;
5037    eo_do((Eo *) obj, elm_obj_win_indicator_opacity_get(&ret));
5038    return ret;
5039 }
5040
5041 static void
5042 _indicator_opacity_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
5043 {
5044    Elm_Win_Indicator_Opacity_Mode *ret = va_arg(*list, Elm_Win_Indicator_Opacity_Mode *);
5045    Elm_Win_Smart_Data *sd = _pd;
5046    *ret = sd->ind_o_mode;
5047 }
5048
5049 EAPI void
5050 elm_win_screen_position_get(const Evas_Object *obj,
5051                             int *x,
5052                             int *y)
5053 {
5054    ELM_WIN_CHECK(obj);
5055    eo_do((Eo *) obj, elm_obj_win_screen_position_get(x, y));
5056 }
5057
5058 static void
5059 _screen_position_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
5060 {
5061    int *x = va_arg(*list, int *);
5062    int *y = va_arg(*list, int *);
5063    Elm_Win_Smart_Data *sd = _pd;
5064
5065    if (x) *x = sd->screen.x;
5066    if (y) *y = sd->screen.y;
5067 }
5068
5069 EAPI Eina_Bool
5070 elm_win_focus_get(const Evas_Object *obj)
5071 {
5072    ELM_WIN_CHECK(obj) EINA_FALSE;
5073    Eina_Bool ret = EINA_FALSE;
5074    eo_do((Eo *) obj, elm_obj_win_focus_get(&ret));
5075    return ret;
5076 }
5077
5078 static void
5079 _focus_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
5080 {
5081    Eina_Bool *ret = va_arg(*list, Eina_Bool *);
5082    Elm_Win_Smart_Data *sd = _pd;
5083    *ret = ecore_evas_focus_get(sd->ee);
5084 }
5085
5086 EAPI void
5087 elm_win_screen_constrain_set(Evas_Object *obj,
5088                              Eina_Bool constrain)
5089 {
5090    ELM_WIN_CHECK(obj);
5091    eo_do(obj, elm_obj_win_screen_constrain_set(constrain));
5092 }
5093
5094 static void
5095 _screen_constrain_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
5096 {
5097    Eina_Bool constrain = va_arg(*list, int);
5098    Elm_Win_Smart_Data *sd = _pd;
5099    sd->constrain = !!constrain;
5100 }
5101
5102 EAPI Eina_Bool
5103 elm_win_screen_constrain_get(Evas_Object *obj)
5104 {
5105    ELM_WIN_CHECK(obj) EINA_FALSE;
5106    Eina_Bool ret = EINA_FALSE;
5107    eo_do(obj, elm_obj_win_screen_constrain_get(&ret));
5108    return ret;
5109 }
5110
5111 static void
5112 _screen_constrain_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
5113 {
5114    Eina_Bool *ret = va_arg(*list, Eina_Bool *);
5115    Elm_Win_Smart_Data *sd = _pd;
5116    *ret = sd->constrain;
5117 }
5118
5119 EAPI void
5120 elm_win_screen_size_get(const Evas_Object *obj,
5121                         int *x,
5122                         int *y,
5123                         int *w,
5124                         int *h)
5125 {
5126    ELM_WIN_CHECK(obj);
5127    eo_do((Eo *) obj, elm_obj_win_screen_size_get(x, y, w, h));
5128 }
5129
5130 static void
5131 _screen_size_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
5132 {
5133    int *x = va_arg(*list, int *);
5134    int *y = va_arg(*list, int *);
5135    int *w = va_arg(*list, int *);
5136    int *h = va_arg(*list, int *);
5137    Elm_Win_Smart_Data *sd = _pd;
5138
5139    ecore_evas_screen_geometry_get(sd->ee, x, y, w, h);
5140 }
5141
5142 EAPI void
5143 elm_win_screen_dpi_get(const Evas_Object *obj,
5144                        int *xdpi,
5145                        int *ydpi)
5146 {
5147    ELM_WIN_CHECK(obj);
5148    eo_do((Eo *) obj, elm_obj_win_screen_dpi_get(xdpi, ydpi));
5149 }
5150
5151 static void
5152 _screen_dpi_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
5153 {
5154    int *xdpi = va_arg(*list, int *);
5155    int *ydpi = va_arg(*list, int *);
5156    Elm_Win_Smart_Data *sd = _pd;
5157
5158    ecore_evas_screen_dpi_get(sd->ee, xdpi, ydpi);
5159 }
5160
5161 EAPI void
5162 elm_win_conformant_set(Evas_Object *obj,
5163                        Eina_Bool conformant)
5164 {
5165    ELM_WIN_CHECK(obj);
5166    eo_do(obj, elm_obj_win_conformant_set(conformant));
5167 }
5168
5169 static void
5170 _conformant_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
5171 {
5172    Eina_Bool conformant = va_arg(*list, int);
5173    Elm_Win_Smart_Data *sd = _pd;
5174
5175 #ifdef HAVE_ELEMENTARY_X
5176    _elm_win_xwindow_get(sd);
5177    if (sd->x.xwin)
5178      ecore_x_e_illume_conformant_set(sd->x.xwin, conformant);
5179 #else
5180    (void)conformant;
5181 #endif
5182 }
5183
5184 EAPI Eina_Bool
5185 elm_win_conformant_get(const Evas_Object *obj)
5186 {
5187    ELM_WIN_CHECK(obj) EINA_FALSE;
5188    Eina_Bool ret = EINA_FALSE;
5189    eo_do((Eo *) obj, elm_obj_win_conformant_get(&ret));
5190    return ret;
5191 }
5192
5193 static void
5194 _conformant_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
5195 {
5196    Eina_Bool *ret = va_arg(*list, Eina_Bool *);
5197    Elm_Win_Smart_Data *sd = _pd;
5198    *ret = EINA_FALSE;
5199
5200 #ifdef HAVE_ELEMENTARY_X
5201    _elm_win_xwindow_get(sd);
5202    if (sd->x.xwin)
5203      *ret = ecore_x_e_illume_conformant_get(sd->x.xwin);
5204 #endif
5205 }
5206
5207 EAPI void
5208 elm_win_quickpanel_set(Evas_Object *obj,
5209                        Eina_Bool quickpanel)
5210 {
5211    ELM_WIN_CHECK(obj);
5212    eo_do(obj, elm_obj_win_quickpanel_set(quickpanel));
5213 }
5214
5215 static void
5216 _quickpanel_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
5217 {
5218    Eina_Bool quickpanel = va_arg(*list, int);
5219    Elm_Win_Smart_Data *sd = _pd;
5220 #ifdef HAVE_ELEMENTARY_X
5221    _elm_win_xwindow_get(sd);
5222    if (sd->x.xwin)
5223      {
5224         ecore_x_e_illume_quickpanel_set(sd->x.xwin, quickpanel);
5225         if (quickpanel)
5226           {
5227              Ecore_X_Window_State states[2];
5228
5229              states[0] = ECORE_X_WINDOW_STATE_SKIP_TASKBAR;
5230              states[1] = ECORE_X_WINDOW_STATE_SKIP_PAGER;
5231              ecore_x_netwm_window_state_set(sd->x.xwin, states, 2);
5232              ecore_x_icccm_hints_set(sd->x.xwin, 0, 0, 0, 0, 0, 0, 0);
5233           }
5234      }
5235 #else
5236    (void)quickpanel;
5237 #endif
5238 }
5239
5240 EAPI Eina_Bool
5241 elm_win_quickpanel_get(const Evas_Object *obj)
5242 {
5243    ELM_WIN_CHECK(obj) EINA_FALSE;
5244    Eina_Bool ret = EINA_FALSE;
5245    eo_do((Eo *) obj, elm_obj_win_quickpanel_get(&ret));
5246    return ret;
5247 }
5248
5249 static void
5250 _quickpanel_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
5251 {
5252    Eina_Bool *ret = va_arg(*list, Eina_Bool *);
5253    Elm_Win_Smart_Data *sd = _pd;
5254    *ret = EINA_FALSE;
5255
5256 #ifdef HAVE_ELEMENTARY_X
5257    _elm_win_xwindow_get(sd);
5258    if (sd->x.xwin)
5259      *ret = ecore_x_e_illume_quickpanel_get(sd->x.xwin);
5260 #endif
5261 }
5262
5263 EAPI void
5264 elm_win_quickpanel_priority_major_set(Evas_Object *obj,
5265                                       int priority)
5266 {
5267    ELM_WIN_CHECK(obj);
5268    eo_do(obj, elm_obj_win_quickpanel_priority_major_set(priority));
5269 }
5270
5271 static void
5272 _quickpanel_priority_major_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
5273 {
5274    int priority = va_arg(*list, int);
5275    Elm_Win_Smart_Data *sd = _pd;
5276
5277 #ifdef HAVE_ELEMENTARY_X
5278    _elm_win_xwindow_get(sd);
5279    if (sd->x.xwin)
5280      ecore_x_e_illume_quickpanel_priority_major_set(sd->x.xwin, priority);
5281 #else
5282    (void)priority;
5283 #endif
5284 }
5285
5286 EAPI int
5287 elm_win_quickpanel_priority_major_get(const Evas_Object *obj)
5288 {
5289    ELM_WIN_CHECK(obj) - 1;
5290    int ret = - 1;
5291    eo_do((Eo *) obj, elm_obj_win_quickpanel_priority_major_get(&ret));
5292    return ret;
5293 }
5294
5295 static void
5296 _quickpanel_priority_major_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
5297 {
5298    int *ret = va_arg(*list, int *);
5299    Elm_Win_Smart_Data *sd = _pd;
5300    *ret = -1;
5301
5302 #ifdef HAVE_ELEMENTARY_X
5303    _elm_win_xwindow_get(sd);
5304    if (sd->x.xwin)
5305      *ret = ecore_x_e_illume_quickpanel_priority_major_get(sd->x.xwin);
5306 #endif
5307 }
5308
5309 EAPI void
5310 elm_win_quickpanel_priority_minor_set(Evas_Object *obj,
5311                                       int priority)
5312 {
5313    ELM_WIN_CHECK(obj);
5314    eo_do(obj, elm_obj_win_quickpanel_priority_minor_set(priority));
5315 }
5316
5317 static void
5318 _quickpanel_priority_minor_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
5319 {
5320    int priority = va_arg(*list, int);
5321    Elm_Win_Smart_Data *sd = _pd;
5322
5323 #ifdef HAVE_ELEMENTARY_X
5324    _elm_win_xwindow_get(sd);
5325    if (sd->x.xwin)
5326      ecore_x_e_illume_quickpanel_priority_minor_set(sd->x.xwin, priority);
5327 #else
5328    (void)priority;
5329 #endif
5330 }
5331
5332 EAPI int
5333 elm_win_quickpanel_priority_minor_get(const Evas_Object *obj)
5334 {
5335    ELM_WIN_CHECK(obj) - 1;
5336    int ret = - 1;
5337    eo_do((Eo *) obj, elm_obj_win_quickpanel_priority_minor_get(&ret));
5338    return ret;
5339 }
5340
5341 static void
5342 _quickpanel_priority_minor_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
5343 {
5344    int *ret = va_arg(*list, int *);
5345    Elm_Win_Smart_Data *sd = _pd;
5346    *ret = -1;
5347
5348 #ifdef HAVE_ELEMENTARY_X
5349    _elm_win_xwindow_get(sd);
5350    if (sd->x.xwin)
5351      *ret = ecore_x_e_illume_quickpanel_priority_minor_get(sd->x.xwin);
5352 #endif
5353 }
5354
5355 EAPI void
5356 elm_win_quickpanel_zone_set(Evas_Object *obj,
5357                             int zone)
5358 {
5359    ELM_WIN_CHECK(obj);
5360    eo_do(obj, elm_obj_win_quickpanel_zone_set(zone));
5361 }
5362
5363 static void
5364 _quickpanel_zone_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
5365 {
5366    int zone = va_arg(*list, int);
5367    Elm_Win_Smart_Data *sd = _pd;
5368
5369 #ifdef HAVE_ELEMENTARY_X
5370    _elm_win_xwindow_get(sd);
5371    if (sd->x.xwin)
5372      ecore_x_e_illume_quickpanel_zone_set(sd->x.xwin, zone);
5373 #else
5374    (void)zone;
5375 #endif
5376 }
5377
5378 EAPI int
5379 elm_win_quickpanel_zone_get(const Evas_Object *obj)
5380 {
5381    ELM_WIN_CHECK(obj) 0;
5382    int ret = 0;
5383    eo_do((Eo *) obj, elm_obj_win_quickpanel_zone_get(&ret));
5384    return ret;
5385 }
5386
5387 static void
5388 _quickpanel_zone_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
5389 {
5390    int *ret = va_arg(*list, int *);
5391    Elm_Win_Smart_Data *sd = _pd;
5392    *ret = 0;
5393
5394 #ifdef HAVE_ELEMENTARY_X
5395    _elm_win_xwindow_get(sd);
5396    if (sd->x.xwin)
5397      *ret = ecore_x_e_illume_quickpanel_zone_get(sd->x.xwin);
5398 #endif
5399 }
5400
5401 EAPI void
5402 elm_win_prop_focus_skip_set(Evas_Object *obj,
5403                             Eina_Bool skip)
5404 {
5405    ELM_WIN_CHECK(obj);
5406    eo_do(obj, elm_obj_win_prop_focus_skip_set(skip));
5407 }
5408
5409 static void
5410 _prop_focus_skip_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
5411 {
5412    Eina_Bool skip = va_arg(*list, int);
5413    Elm_Win_Smart_Data *sd = _pd;
5414
5415    sd->skip_focus = skip;
5416    TRAP(sd, focus_skip_set, skip);
5417 }
5418
5419 EAPI void
5420 elm_win_illume_command_send(Evas_Object *obj,
5421                             Elm_Illume_Command command,
5422                             void *params)
5423 {
5424    ELM_WIN_CHECK(obj);
5425    eo_do(obj, elm_obj_win_illume_command_send(command, params));
5426 }
5427
5428 static void
5429 _illume_command_send(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
5430 {
5431    Elm_Illume_Command command = va_arg(*list, Elm_Illume_Command);
5432    void *params = va_arg(*list, void *);
5433    (void) params;
5434    Elm_Win_Smart_Data *sd = _pd;
5435
5436 #ifdef HAVE_ELEMENTARY_X
5437    _elm_win_xwindow_get(sd);
5438    if (sd->x.xwin)
5439      {
5440         switch (command)
5441           {
5442            case ELM_ILLUME_COMMAND_FOCUS_BACK:
5443              ecore_x_e_illume_focus_back_send(sd->x.xwin);
5444              break;
5445
5446            case ELM_ILLUME_COMMAND_FOCUS_FORWARD:
5447              ecore_x_e_illume_focus_forward_send(sd->x.xwin);
5448              break;
5449
5450            case ELM_ILLUME_COMMAND_FOCUS_HOME:
5451              ecore_x_e_illume_focus_home_send(sd->x.xwin);
5452              break;
5453
5454            case ELM_ILLUME_COMMAND_CLOSE:
5455              ecore_x_e_illume_close_send(sd->x.xwin);
5456              break;
5457
5458            default:
5459              break;
5460           }
5461      }
5462 #else
5463    (void)command;
5464 #endif
5465 }
5466
5467 EAPI Evas_Object *
5468 elm_win_inlined_image_object_get(Evas_Object *obj)
5469 {
5470    ELM_WIN_CHECK(obj) NULL;
5471    Evas_Object *ret = NULL;
5472    eo_do(obj, elm_obj_win_inlined_image_object_get(&ret));
5473    return ret;
5474 }
5475
5476 static void
5477 _inlined_image_object_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
5478 {
5479    Evas_Object **ret = va_arg(*list, Evas_Object **);
5480    Elm_Win_Smart_Data *sd = _pd;
5481    *ret = sd->img_obj;
5482 }
5483
5484 EAPI void
5485 elm_win_focus_highlight_enabled_set(Evas_Object *obj,
5486                                     Eina_Bool enabled)
5487 {
5488    ELM_WIN_CHECK(obj);
5489    eo_do(obj, elm_obj_win_focus_highlight_enabled_set(enabled));
5490 }
5491
5492 static void
5493 _focus_highlight_enabled_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
5494 {
5495    Eina_Bool enabled = va_arg(*list, int);
5496    Elm_Win_Smart_Data *sd = _pd;
5497
5498    enabled = !!enabled;
5499    if (sd->focus_highlight.enabled == enabled)
5500      return;
5501
5502    sd->focus_highlight.enabled = enabled;
5503
5504    if (sd->focus_highlight.enabled)
5505      _elm_win_focus_highlight_init(sd);
5506    else
5507      _elm_win_focus_highlight_shutdown(sd);
5508 }
5509
5510 EAPI Eina_Bool
5511 elm_win_focus_highlight_enabled_get(const Evas_Object *obj)
5512 {
5513    ELM_WIN_CHECK(obj) EINA_FALSE;
5514    Eina_Bool ret = EINA_FALSE;
5515    eo_do((Eo *) obj, elm_obj_win_focus_highlight_enabled_get(&ret));
5516    return ret;
5517 }
5518
5519 static void
5520 _focus_highlight_enabled_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
5521 {
5522    Eina_Bool *ret = va_arg(*list, Eina_Bool *);
5523    Elm_Win_Smart_Data *sd = _pd;
5524    *ret = sd->focus_highlight.enabled;
5525 }
5526
5527 EAPI void
5528 elm_win_focus_highlight_style_set(Evas_Object *obj,
5529                                   const char *style)
5530 {
5531    ELM_WIN_CHECK(obj);
5532    eo_do(obj, elm_obj_win_focus_highlight_style_set(style));
5533 }
5534
5535 static void
5536 _elm_win_smart_theme(Eo *obj EINA_UNUSED, void *_pd, va_list *list EINA_UNUSED)
5537 {
5538    Elm_Win_Smart_Data *sd = _pd;
5539    Eina_Bool *ret = va_arg(*list, Eina_Bool *);
5540    Eina_Bool int_ret = EINA_FALSE;
5541
5542    if (ret) *ret = EINA_TRUE;
5543
5544    eo_do_super(obj, MY_CLASS, elm_wdg_theme_apply(&int_ret));
5545    if (!int_ret) return;
5546
5547    sd->focus_highlight.theme_changed = EINA_TRUE;
5548    _elm_win_focus_highlight_reconfigure_job_start(sd);
5549
5550    if (ret) *ret = EINA_TRUE;
5551 }
5552
5553 static void
5554 _focus_highlight_style_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
5555 {
5556    const char *style = va_arg(*list, const char *);
5557    Elm_Win_Smart_Data *sd = _pd;
5558
5559    eina_stringshare_replace(&sd->focus_highlight.style, style);
5560    sd->focus_highlight.theme_changed = EINA_TRUE;
5561    _elm_win_focus_highlight_reconfigure_job_start(sd);
5562 }
5563
5564 EAPI const char *
5565 elm_win_focus_highlight_style_get(const Evas_Object *obj)
5566 {
5567    ELM_WIN_CHECK(obj) NULL;
5568    const char *ret = NULL;
5569    eo_do((Eo *) obj, elm_obj_win_focus_highlight_style_get(&ret));
5570    return ret;
5571 }
5572
5573 static void
5574 _focus_highlight_style_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
5575 {
5576    const char **ret = va_arg(*list, const char **);
5577    Elm_Win_Smart_Data *sd = _pd;
5578    *ret = sd->focus_highlight.style;
5579 }
5580
5581 EAPI void
5582 elm_win_focus_highlight_animate_set(Evas_Object *obj,
5583                                     Eina_Bool animate)
5584 {
5585    ELM_WIN_CHECK(obj);
5586    eo_do(obj, elm_obj_win_focus_highlight_animate_set(animate));
5587 }
5588
5589 static void
5590 _focus_highlight_animate_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
5591 {
5592    Eina_Bool animate = va_arg(*list, int);
5593    Elm_Win_Smart_Data *sd = _pd;
5594
5595    animate = !!animate;
5596    if (sd->focus_highlight.animate == animate)
5597      return;
5598
5599    sd->focus_highlight.animate = animate;
5600    sd->focus_highlight.theme_changed = EINA_TRUE;
5601    _elm_win_focus_highlight_reconfigure_job_start(sd);
5602 }
5603
5604 EAPI Eina_Bool
5605 elm_win_focus_highlight_animate_get(const Evas_Object *obj)
5606 {
5607    ELM_WIN_CHECK(obj) EINA_FALSE;
5608    Eina_Bool ret = EINA_FALSE;
5609    eo_do((Eo *) obj, elm_obj_win_focus_highlight_animate_get(&ret));
5610    return ret;
5611 }
5612
5613 static void
5614 _focus_highlight_animate_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
5615 {
5616    Eina_Bool *ret = va_arg(*list, Eina_Bool *);
5617    Elm_Win_Smart_Data *sd = _pd;
5618    *ret = sd->focus_highlight.animate;
5619 }
5620
5621 EAPI Eina_Bool
5622 elm_win_socket_listen(Evas_Object *obj,
5623                       const char *svcname,
5624                       int svcnum,
5625                       Eina_Bool svcsys)
5626 {
5627    ELM_WIN_CHECK(obj) EINA_FALSE;
5628    Eina_Bool ret = EINA_FALSE;
5629    eo_do(obj, elm_obj_win_socket_listen(svcname, svcnum, svcsys, &ret));
5630    return ret;
5631 }
5632
5633 static void
5634 _socket_listen(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
5635 {
5636    const char *svcname = va_arg(*list, const char *);
5637    int svcnum = va_arg(*list, int);
5638    Eina_Bool svcsys = va_arg(*list, int);
5639    Eina_Bool *ret = va_arg(*list, Eina_Bool *);
5640    Elm_Win_Smart_Data *sd = _pd;
5641    *ret = EINA_FALSE;
5642
5643    if (!sd->ee) return;
5644
5645    if (!ecore_evas_extn_socket_listen(sd->ee, svcname, svcnum, svcsys))
5646      return;
5647
5648    *ret = EINA_TRUE;
5649 }
5650
5651 /* windowing specific calls - shall we do this differently? */
5652
5653 EAPI Ecore_X_Window
5654 elm_win_xwindow_get(const Evas_Object *obj)
5655 {
5656    if (!obj) return 0;
5657
5658    if (!evas_object_smart_type_check_ptr(obj, MY_CLASS_NAME_LEGACY))
5659      {
5660         Ecore_Evas *ee = ecore_evas_ecore_evas_get(evas_object_evas_get(obj));
5661         return _elm_ee_xwin_get(ee);
5662      }
5663
5664    ELM_WIN_CHECK(obj) 0;
5665    Ecore_X_Window ret = 0;
5666    eo_do((Eo *) obj, elm_obj_win_xwindow_get(&ret));
5667    return ret;
5668 }
5669
5670 static void
5671 _xwindow_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
5672 {
5673    Ecore_X_Window *ret = va_arg(*list, Ecore_X_Window *);
5674    Elm_Win_Smart_Data *sd = _pd;
5675
5676 #ifdef HAVE_ELEMENTARY_X
5677    if (sd->x.xwin)
5678      {
5679         *ret = sd->x.xwin;
5680         return;
5681      }
5682    if (sd->parent)
5683      {
5684         *ret = elm_win_xwindow_get(sd->parent);
5685         return;
5686      }
5687 #endif
5688    *ret = 0;
5689 }
5690
5691 EAPI Ecore_Wl_Window *
5692 elm_win_wl_window_get(const Evas_Object *obj)
5693 {
5694    if (!obj) return NULL;
5695
5696    if ((!ENGINE_COMPARE(ELM_WAYLAND_SHM)) &&
5697        (!ENGINE_COMPARE(ELM_WAYLAND_EGL)))
5698      return NULL;
5699
5700    if (!evas_object_smart_type_check_ptr(obj, MY_CLASS_NAME_LEGACY))
5701      {
5702         Ecore_Evas *ee = ecore_evas_ecore_evas_get(evas_object_evas_get(obj));
5703         return _elm_ee_wlwin_get(ee);
5704      }
5705
5706    ELM_WIN_CHECK(obj) NULL;
5707    Ecore_Wl_Window *ret = NULL;
5708    eo_do((Eo *) obj, elm_obj_win_wl_window_get(&ret));
5709    return ret;
5710 }
5711
5712 static void
5713 _wl_window_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
5714 {
5715    Ecore_Wl_Window **ret = va_arg(*list, Ecore_Wl_Window **);
5716 #if HAVE_ELEMENTARY_WAYLAND
5717    Elm_Win_Smart_Data *sd = _pd;
5718    if (sd->wl.win)
5719      {
5720         *ret = sd->wl.win;
5721         return;
5722      }
5723    if (sd->parent)
5724      {
5725         *ret = elm_win_wl_window_get(sd->parent);
5726         return;
5727      }
5728 #else
5729    (void)_pd;
5730 #endif
5731    *ret = NULL;
5732 }
5733
5734 EAPI Eina_Bool
5735 elm_win_trap_set(const Elm_Win_Trap *t)
5736 {
5737    DBG("old %p, new %p", trap, t);
5738
5739    if ((t) && (t->version != ELM_WIN_TRAP_VERSION))
5740      {
5741         CRI("trying to set a trap version %lu while %lu was expected!",
5742                  t->version, ELM_WIN_TRAP_VERSION);
5743         return EINA_FALSE;
5744      }
5745
5746    trap = t;
5747    return EINA_TRUE;
5748 }
5749
5750 EAPI void
5751 elm_win_floating_mode_set(Evas_Object *obj, Eina_Bool floating)
5752 {
5753    ELM_WIN_CHECK(obj);
5754    ELM_WIN_DATA_GET_OR_RETURN(obj, sd);
5755
5756    floating = !!floating;
5757    if (floating == sd->floating) return;
5758    sd->floating = floating;
5759 #ifdef HAVE_ELEMENTARY_X
5760    _elm_win_xwindow_get(sd);
5761    if (sd->x.xwin)
5762      {
5763         if (sd->floating)
5764           ecore_x_e_illume_window_state_set
5765              (sd->x.xwin, ECORE_X_ILLUME_WINDOW_STATE_FLOATING);
5766         else
5767           ecore_x_e_illume_window_state_set
5768              (sd->x.xwin, ECORE_X_ILLUME_WINDOW_STATE_NORMAL);
5769      }
5770 #endif
5771 }
5772
5773 EAPI Eina_Bool
5774 elm_win_floating_mode_get(const Evas_Object *obj)
5775 {
5776    ELM_WIN_CHECK(obj) EINA_FALSE;
5777    ELM_WIN_DATA_GET_OR_RETURN_VAL(obj, sd, EINA_FALSE);
5778
5779    return sd->floating;
5780 }
5781
5782 static void
5783 _window_id_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
5784 {
5785    Ecore_Window *ret = va_arg(*list, Ecore_Window *);
5786    Elm_Win_Smart_Data *sd = _pd;
5787
5788    if ((ENGINE_COMPARE(ELM_WAYLAND_SHM)) || (ENGINE_COMPARE(ELM_WAYLAND_EGL)))
5789      {
5790 #if HAVE_ELEMENTARY_WAYLAND
5791         if (sd->wl.win)
5792           {
5793              *ret = (Ecore_Window)ecore_wl_window_surface_id_get(sd->wl.win);
5794              return;
5795           }
5796         if (sd->parent)
5797           {
5798              Ecore_Wl_Window *parent;
5799
5800              parent = elm_win_wl_window_get(sd->parent);
5801              if (parent) *ret = (Ecore_Window)ecore_wl_window_surface_id_get(parent);
5802              return;
5803           }
5804 #endif
5805      }
5806    else
5807      {
5808 #ifdef HAVE_ELEMENTARY_X
5809         _elm_win_xwindow_get(sd);
5810         if (sd->x.xwin)
5811           {
5812              *ret = (Ecore_Window)sd->x.xwin;
5813              return;
5814           }
5815         if (sd->parent)
5816           {
5817              *ret = (Ecore_Window)elm_win_xwindow_get(sd->parent);
5818              return;
5819           }
5820 #endif
5821      }
5822
5823    *ret = 0;
5824 }
5825
5826 void
5827 _elm_win_focus_highlight_start(Evas_Object *obj)
5828 {
5829    ELM_WIN_DATA_GET(obj, sd);
5830
5831    if (!elm_win_focus_highlight_enabled_get(obj)) return;
5832    sd->focus_highlight.cur.visible = EINA_TRUE;
5833    sd->focus_highlight.geometry_changed = EINA_TRUE;
5834    _elm_win_focus_highlight_reconfigure(sd);
5835 }
5836
5837 EAPI Ecore_Window
5838 elm_win_window_id_get(const Evas_Object *obj)
5839 {
5840    if (!obj) return 0;
5841
5842    if (!evas_object_smart_type_check_ptr(obj, MY_CLASS_NAME_LEGACY))
5843      {
5844         Ecore_Evas *ee = ecore_evas_ecore_evas_get(evas_object_evas_get(obj));
5845         return ecore_evas_window_get(ee);
5846      }
5847
5848    ELM_WIN_CHECK(obj) 0;
5849    Ecore_Window ret = 0;
5850    eo_do((Eo *) obj, elm_obj_win_window_id_get(&ret));
5851    return ret;
5852 }
5853
5854 static void
5855 _class_constructor(Eo_Class *klass)
5856 {
5857    const Eo_Op_Func_Description func_desc[] = {
5858         EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_CONSTRUCTOR), _constructor),
5859         EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_ADD), _elm_win_smart_add),
5860         EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_DEL), _elm_win_smart_del),
5861         EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_RESIZE), _elm_win_smart_resize),
5862         EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_MOVE), _elm_win_smart_move),
5863         EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_SHOW), _elm_win_smart_show),
5864         EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_HIDE), _elm_win_smart_hide),
5865
5866         EO_OP_FUNC(ELM_WIDGET_ID(ELM_WIDGET_SUB_ID_ON_FOCUS), _elm_win_smart_on_focus),
5867         EO_OP_FUNC(ELM_WIDGET_ID(ELM_WIDGET_SUB_ID_EVENT), _elm_win_smart_event),
5868         EO_OP_FUNC(ELM_WIDGET_ID(ELM_WIDGET_SUB_ID_FOCUS_NEXT_MANAGER_IS), _elm_win_smart_focus_next_manager_is),
5869         EO_OP_FUNC(ELM_WIDGET_ID(ELM_WIDGET_SUB_ID_FOCUS_NEXT), _elm_win_smart_focus_next),
5870         EO_OP_FUNC(ELM_WIDGET_ID(ELM_WIDGET_SUB_ID_FOCUS_DIRECTION_MANAGER_IS), _elm_win_smart_focus_direction_manager_is),
5871         EO_OP_FUNC(ELM_WIDGET_ID(ELM_WIDGET_SUB_ID_FOCUS_DIRECTION), _elm_win_smart_focus_direction),
5872         EO_OP_FUNC(ELM_WIDGET_ID(ELM_WIDGET_SUB_ID_THEME_APPLY), _elm_win_smart_theme),
5873
5874         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_WIN_CONSTRUCTOR), _win_constructor),
5875         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_RESIZE_OBJECT_ADD), _resize_object_add),
5876         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_RESIZE_OBJECT_DEL), _resize_object_del),
5877         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_TYPE_GET), _type_get),
5878         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_TITLE_SET), _title_set),
5879         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_TITLE_GET), _title_get),
5880         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_ICON_NAME_SET), _icon_name_set),
5881         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_ICON_NAME_GET), _icon_name_get),
5882         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_ROLE_SET), _role_set),
5883         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_ROLE_GET), _role_get),
5884         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_ICON_OBJECT_SET), _icon_object_set),
5885         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_ICON_OBJECT_GET), _icon_object_get),
5886         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_AUTODEL_SET), _autodel_set),
5887         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_AUTODEL_GET), _autodel_get),
5888         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_ACTIVATE), _activate),
5889         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_LOWER), _lower),
5890         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_RAISE), _raise),
5891         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_CENTER), _center),
5892         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_BORDERLESS_SET), _borderless_set),
5893         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_BORDERLESS_GET), _borderless_get),
5894         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_SHAPED_SET), _shaped_set),
5895         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_SHAPED_GET), _shaped_get),
5896         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_ALPHA_SET), _alpha_set),
5897         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_ALPHA_GET), _alpha_get),
5898         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_OVERRIDE_SET), _override_set),
5899         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_OVERRIDE_GET), _override_get),
5900         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_FULLSCREEN_SET), _fullscreen_set),
5901         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_FULLSCREEN_GET), _fullscreen_get),
5902         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_MAIN_MENU_GET), _main_menu_get),
5903         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_MAXIMIZED_SET), _maximized_set),
5904         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_MAXIMIZED_GET), _maximized_get),
5905         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_ICONIFIED_SET), _iconified_set),
5906         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_ICONIFIED_GET), _iconified_get),
5907         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_WITHDRAWN_SET), _withdrawn_set),
5908         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_WITHDRAWN_GET), _withdrawn_get),
5909         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_AVAILABLE_PROFILES_SET), _available_profiles_set),
5910         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_AVAILABLE_PROFILES_GET), _available_profiles_get),
5911         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_PROFILE_SET), _profile_set),
5912         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_PROFILE_GET), _profile_get),
5913         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_URGENT_SET), _urgent_set),
5914         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_URGENT_GET), _urgent_get),
5915         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_DEMAND_ATTENTION_SET), _demand_attention_set),
5916         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_DEMAND_ATTENTION_GET), _demand_attention_get),
5917         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_MODAL_SET), _modal_set),
5918         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_MODAL_GET), _modal_get),
5919         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_ASPECT_SET), _aspect_set),
5920         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_ASPECT_GET), _aspect_get),
5921         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_SIZE_BASE_SET), _size_base_set),
5922         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_SIZE_BASE_GET), _size_base_get),
5923         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_SIZE_STEP_SET), _size_step_set),
5924         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_SIZE_STEP_GET), _size_step_get),
5925         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_LAYER_SET), _layer_set),
5926         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_LAYER_GET), _layer_get),
5927         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_ROTATION_SET), _rotation_set),
5928         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_ROTATION_WITH_RESIZE_SET), _rotation_with_resize_set),
5929         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_ROTATION_GET), _rotation_get),
5930         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_STICKY_SET), _sticky_set),
5931         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_STICKY_GET), _sticky_get),
5932         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_KEYBOARD_MODE_SET), _keyboard_mode_set),
5933         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_KEYBOARD_MODE_GET), _keyboard_mode_get),
5934         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_KEYBOARD_WIN_SET), _keyboard_win_set),
5935         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_KEYBOARD_WIN_GET), _keyboard_win_get),
5936         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_INDICATOR_MODE_SET), _indicator_mode_set),
5937         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_INDICATOR_MODE_GET), _indicator_mode_get),
5938         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_INDICATOR_OPACITY_SET), _indicator_opacity_set),
5939         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_INDICATOR_OPACITY_GET), _indicator_opacity_get),
5940         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_SCREEN_POSITION_GET), _screen_position_get),
5941         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_FOCUS_GET), _focus_get),
5942         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_SCREEN_CONSTRAIN_SET), _screen_constrain_set),
5943         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_SCREEN_CONSTRAIN_GET), _screen_constrain_get),
5944         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_SCREEN_SIZE_GET), _screen_size_get),
5945         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_SCREEN_DPI_GET), _screen_dpi_get),
5946         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_CONFORMANT_SET), _conformant_set),
5947         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_CONFORMANT_GET), _conformant_get),
5948         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_QUICKPANEL_SET), _quickpanel_set),
5949         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_QUICKPANEL_GET), _quickpanel_get),
5950         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_QUICKPANEL_PRIORITY_MAJOR_SET), _quickpanel_priority_major_set),
5951         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_QUICKPANEL_PRIORITY_MAJOR_GET), _quickpanel_priority_major_get),
5952         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_QUICKPANEL_PRIORITY_MINOR_SET), _quickpanel_priority_minor_set),
5953         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_QUICKPANEL_PRIORITY_MINOR_GET), _quickpanel_priority_minor_get),
5954         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_QUICKPANEL_ZONE_SET), _quickpanel_zone_set),
5955         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_QUICKPANEL_ZONE_GET), _quickpanel_zone_get),
5956         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_PROP_FOCUS_SKIP_SET), _prop_focus_skip_set),
5957         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_ILLUME_COMMAND_SEND), _illume_command_send),
5958         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_INLINED_IMAGE_OBJECT_GET), _inlined_image_object_get),
5959         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_FOCUS_HIGHLIGHT_ENABLED_SET), _focus_highlight_enabled_set),
5960         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_FOCUS_HIGHLIGHT_ENABLED_GET), _focus_highlight_enabled_get),
5961         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_FOCUS_HIGHLIGHT_STYLE_SET), _focus_highlight_style_set),
5962         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_FOCUS_HIGHLIGHT_STYLE_GET), _focus_highlight_style_get),
5963         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_FOCUS_HIGHLIGHT_ANIMATE_SET), _focus_highlight_animate_set),
5964         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_FOCUS_HIGHLIGHT_ANIMATE_GET), _focus_highlight_animate_get),
5965         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_SOCKET_LISTEN), _socket_listen),
5966         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_XWINDOW_GET), _xwindow_get),
5967         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_WL_WINDOW_GET), _wl_window_get),
5968         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_WINDOW_ID_GET), _window_id_get),
5969         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_WM_ROTATION_SUPPORTED_GET), _wm_rotation_supported_get),
5970         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_WM_PREFERRED_ROTATION_SET), _wm_preferred_rotation_set),
5971         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_WM_PREFERRED_ROTATION_GET), _wm_preferred_rotation_get),
5972         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_WM_AVAILABLE_ROTATIONS_SET), _wm_available_rotations_set),
5973         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_WM_AVAILABLE_ROTATIONS_GET), _wm_available_rotations_get),
5974         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_WM_MANUAL_ROTATION_DONE_SET), _wm_manual_rotation_done_set),
5975         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_WM_MANUAL_ROTATION_DONE_GET), _wm_manual_rotation_done_get),
5976         EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_WM_MANUAL_ROTATION_DONE), _wm_manual_rotation_done),
5977         EO_OP_FUNC_SENTINEL
5978    };
5979
5980    eo_class_funcs_set(klass, func_desc);
5981
5982    evas_smart_legacy_type_register(MY_CLASS_NAME_LEGACY, klass);
5983 }
5984
5985 static const Eo_Op_Description op_desc[] = {
5986      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_WIN_CONSTRUCTOR, "Adds a window object."),
5987      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_RESIZE_OBJECT_ADD, "Add subobj as a resize object of window obj."),
5988      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_RESIZE_OBJECT_DEL, "Delete subobj as a resize object of window obj."),
5989      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_TYPE_GET, "Get the type of the window."),
5990      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_TITLE_SET, "Set the title of the window."),
5991      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_TITLE_GET, "Get the title of the window."),
5992      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_ICON_NAME_SET, "Set the icon name of the window."),
5993      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_ICON_NAME_GET, "Get the icon name of the window."),
5994      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_ROLE_SET, "Set the role of the window."),
5995      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_ROLE_GET, "Get the role of the window."),
5996      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_ICON_OBJECT_SET, "Set a window object's icon."),
5997      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_ICON_OBJECT_GET, "Get the icon object used for the window."),
5998      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_AUTODEL_SET, "Set the window's autodel state."),
5999      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_AUTODEL_GET, "Get the window's autodel state."),
6000      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_ACTIVATE, "Activate a window object."),
6001      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_LOWER, "Lower a window object."),
6002      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_RAISE, "Raise a window object."),
6003      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_CENTER, "Center a window on its screen."),
6004      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_BORDERLESS_SET, "Set the borderless state of a window."),
6005      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_BORDERLESS_GET, "Get the borderless state of a window."),
6006      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_SHAPED_SET, "Set the shaped state of a window."),
6007      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_SHAPED_GET, "Get the shaped state of a window."),
6008      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_ALPHA_SET, "Set the alpha channel state of a window."),
6009      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_ALPHA_GET, "Get the alpha channel state of a window."),
6010      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_OVERRIDE_SET, "Set the override state of a window."),
6011      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_OVERRIDE_GET, "Get the override state of a window."),
6012      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_FULLSCREEN_SET, "Set the fullscreen state of a window."),
6013      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_FULLSCREEN_GET, "Get the fullscreen state of a window."),
6014      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_MAIN_MENU_GET, "Get the Main Menu of a window."),
6015      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_MAXIMIZED_SET, "Set the maximized state of a window."),
6016      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_MAXIMIZED_GET, "Get the maximized state of a window."),
6017      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_ICONIFIED_SET, "Set the iconified state of a window."),
6018      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_ICONIFIED_GET, "Get the iconified state of a window."),
6019      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_WITHDRAWN_SET, "Set the withdrawn state of a window."),
6020      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_WITHDRAWN_GET, "Get the withdrawn state of a window."),
6021      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_AVAILABLE_PROFILES_SET, "Set the array of available profiles to a window."),
6022      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_AVAILABLE_PROFILES_GET, "Get the array of available profiles of a window."),
6023      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_PROFILE_SET, "Set the profile of a window."),
6024      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_PROFILE_GET, "Get the profile of a window."),
6025      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_URGENT_SET, "Set the urgent state of a window."),
6026      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_URGENT_GET, "Get the urgent state of a window."),
6027      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_DEMAND_ATTENTION_SET, "Set the demand_attention state of a window."),
6028      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_DEMAND_ATTENTION_GET, "Get the demand_attention state of a window."),
6029      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_MODAL_SET, "Set the modal state of a window."),
6030      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_MODAL_GET, "Get the modal state of a window."),
6031      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_ASPECT_SET, "Set the aspect ratio of a window."),
6032      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_ASPECT_GET, "Get the aspect ratio of a window."),
6033      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_SIZE_BASE_SET, "Set the base window size used with stepping calculation."),
6034      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_SIZE_BASE_GET, "Get the base size of a window."),
6035      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_SIZE_STEP_SET, "Set the window stepping used with sizing calculation."),
6036      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_SIZE_STEP_GET, "Get the stepping of a window."),
6037      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_LAYER_SET, "Set the layer of the window."),
6038      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_LAYER_GET, "Get the layer of the window."),
6039      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_ROTATION_SET, "Set the rotation of the window."),
6040      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_ROTATION_WITH_RESIZE_SET, "Rotates the window and resizes it."),
6041      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_ROTATION_GET, "Get the rotation of the window."),
6042      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_STICKY_SET, "Set the sticky state of the window."),
6043      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_STICKY_GET, "Get the sticky state of the window."),
6044      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_KEYBOARD_MODE_SET, "Sets the keyboard mode of the window."),
6045      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_KEYBOARD_MODE_GET, "Get the keyboard mode of the window."),
6046      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_KEYBOARD_WIN_SET, "Sets whether the window is a keyboard."),
6047      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_KEYBOARD_WIN_GET, "Get whether the window is a keyboard."),
6048      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_INDICATOR_MODE_SET, "Sets the indicator mode of the window."),
6049      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_INDICATOR_MODE_GET, "Get the indicator mode of the window."),
6050      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_INDICATOR_OPACITY_SET, "Sets the indicator opacity mode of the window."),
6051      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_INDICATOR_OPACITY_GET, "Get the indicator opacity mode of the window."),
6052      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_SCREEN_POSITION_GET, "Get the screen position of a window."),
6053      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_FOCUS_GET, "Determine whether a window has focus."),
6054      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_SCREEN_CONSTRAIN_SET, "Constrain the maximum width and height of a window to the width and height of its screen."),
6055      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_SCREEN_CONSTRAIN_GET, "Retrieve the constraints on the maximum width and height of a window relative to the width and height of its screen."),
6056      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_SCREEN_SIZE_GET, "Get screen geometry details for the screen that a window is on."),
6057      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_SCREEN_DPI_GET, "Get screen dpi for the screen that a window is on."),
6058      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_CONFORMANT_SET, "Set if this window is an illume conformant window."),
6059      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_CONFORMANT_GET, "Get if this window is an illume conformant window."),
6060      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_QUICKPANEL_SET, "Set a window to be an illume quickpanel window."),
6061      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_QUICKPANEL_GET, "Get if this window is a quickpanel or not."),
6062      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_QUICKPANEL_PRIORITY_MAJOR_SET, "Set the major priority of a quickpanel window."),
6063      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_QUICKPANEL_PRIORITY_MAJOR_GET, "Get the major priority of a quickpanel window."),
6064      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_QUICKPANEL_PRIORITY_MINOR_SET, "Set the minor priority of a quickpanel window."),
6065      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_QUICKPANEL_PRIORITY_MINOR_GET, "Get the minor priority of a quickpanel window."),
6066      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_QUICKPANEL_ZONE_SET, "Set which zone this quickpanel should appear in."),
6067      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_QUICKPANEL_ZONE_GET, "Get which zone this quickpanel should appear in."),
6068      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_PROP_FOCUS_SKIP_SET, "Set the window to be skipped by keyboard focus."),
6069      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_ILLUME_COMMAND_SEND, "Send a command to the windowing environment."),
6070      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_INLINED_IMAGE_OBJECT_GET, "Get the inlined image object handle."),
6071      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_FOCUS_HIGHLIGHT_ENABLED_SET, "Set the enabled status for the focus highlight in a window."),
6072      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_FOCUS_HIGHLIGHT_ENABLED_GET, "Get the enabled value of the focus highlight for this window."),
6073      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_FOCUS_HIGHLIGHT_STYLE_SET, "Set the style for the focus highlight on this window."),
6074      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_FOCUS_HIGHLIGHT_STYLE_GET, "Get the style set for the focus highlight object."),
6075      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_FOCUS_HIGHLIGHT_ANIMATE_SET, "Set the animate status for the focus highlight for this window."),
6076      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_FOCUS_HIGHLIGHT_ANIMATE_GET, "Get the animate status for the focus highlight for this window."),
6077      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_SOCKET_LISTEN, "Create a socket to provide the service for Plug widget."),
6078      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_XWINDOW_GET, "Get the Ecore_X_Window of an Evas_Object."),
6079      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_WL_WINDOW_GET, "Get the Ecore_Wl_Window of an Evas_Object."),
6080      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_WINDOW_ID_GET, "Get the Ecore_Window of an Evas_Object."),
6081      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_WM_ROTATION_SUPPORTED_GET, "Query if the underlying windowing system supports the window manager rotation.."),
6082      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_WM_PREFERRED_ROTATION_SET, "Set the preferred rotation hint."),
6083      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_WM_PREFERRED_ROTATION_GET, "Get the preferred rotation hint."),
6084      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_WM_AVAILABLE_ROTATIONS_SET, "Set the array of available window rotations."),
6085      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_WM_AVAILABLE_ROTATIONS_GET, "Get the array of available window rotations."),
6086      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_WM_MANUAL_ROTATION_DONE_SET, "Set manual rotation done mode of obj window."),
6087      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_WM_MANUAL_ROTATION_DONE_GET, "Get manual rotation done mode of obj window."),
6088      EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_WM_MANUAL_ROTATION_DONE, "Set rotation finish manually"),
6089      EO_OP_DESCRIPTION_SENTINEL
6090 };
6091
6092 static const Eo_Class_Description class_desc = {
6093      EO_VERSION,
6094      MY_CLASS_NAME,
6095      EO_CLASS_TYPE_REGULAR,
6096      EO_CLASS_DESCRIPTION_OPS(&ELM_OBJ_WIN_BASE_ID, op_desc, ELM_OBJ_WIN_SUB_ID_LAST),
6097      NULL,
6098      sizeof(Elm_Win_Smart_Data),
6099      _class_constructor,
6100      NULL
6101 };
6102
6103 EO_DEFINE_CLASS(elm_obj_win_class_get, &class_desc, ELM_OBJ_WIDGET_CLASS, NULL);