src/lib/elm_win.c

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