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