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