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